Changeset 5695 for code/trunk/src

code/trunk

Property svn:mergeinfo changed
/code/branches/resource2 (added) merged: 3373-3374,5594,5597,5610-5611,5614,5624,5641,5644-5646,5650-5664,5667-5672,5682-5684,5688-5691,5694

code/trunk/src/CMakeLists.txt

-                      r3368
+                      r5695
  #     Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ #
+ #
+ #  Author:
+ #    Reto Grieder
+ #  Description:
+ #    Configures the compilers and sets build options.
+ #
+################ Various Options ################
+# various macro includes
+# Required macros and functions
 INCLUDE(FlagUtilities)
 INCLUDE(TargetUtilities)
+# Configure the two headers and set some options
+INCLUDE(OrxonoxConfig.cmake)
+################ Library Defines ################
+# Disable Boost auto linking completely
+ADD_COMPILER_FLAGS("-DBOOST_ALL_NO_LIB")
+# If no defines are specified, these libs get linked statically
+ADD_COMPILER_FLAGS("-DBOOST_ALL_DYN_LINK" WIN32 LINK_BOOST_DYNAMIC)
+ADD_COMPILER_FLAGS("-DENET_DLL"           WIN32 LINK_ENET_DYNAMIC)
+ADD_COMPILER_FLAGS("-DLUA_BUILD_AS_DLL"   WIN32 LINK_LUA_DYNAMIC)
+ADD_COMPILER_FLAGS("-DOIS_DYNAMIC_LIB")
+ADD_COMPILER_FLAGS("-DZLIB_DLL"           WIN32 LINK_ZLIB_DYNAMIC)
+# If no defines are specified, these libs get linked dynamically
+ADD_COMPILER_FLAGS("-DCEGUI_STATIC"       WIN32 NOT LINK_CEGUI_DYNAMIC)
+ADD_COMPILER_FLAGS("-DOGRE_STATIC_LIB"    WIN32 NOT LINK_OGRE_DYNAMIC)
+ADD_COMPILER_FLAGS("-DSTATIC_BUILD"       WIN32 NOT LINK_TCL_DYNAMIC)
 # Use TinyXML++
 ADD_COMPILER_FLAGS("-DTIXML_USE_TICPP")
-# OIS dynamic linking requires macro definition, at least for Windows
-ADD_COMPILER_FLAGS("-DOIS_DYNAMIC_LIB")
-################ OrxonoxConfig.h ################
-# Check endianness
-INCLUDE(TestBigEndian)
-TEST_BIG_ENDIAN(ORXONOX_BIG_ENDIAN)
-IF(NOT ORXONOX_BIG_ENDIAN)
-  SET(ORXONOX_LITTLE_ENDIAN TRUE)
-ENDIF()
-# 32/64 bit system check
-IF(CMAKE_SIZEOF_VOID_P EQUAL 8)
-  SET(ORXONOX_ARCH_64 TRUE)
-ELSE()
-  SET(ORXONOX_ARCH_32 TRUE)
-ENDIF()
-# Platforms
-SET(ORXONOX_PLATFORM_WINDOWS ${WIN32})
-SET(ORXONOX_PLATFORM_APPLE ${APPLE})
-SET(ORXONOX_PLATFORM_UNIX ${UNIX})
-IF(UNIX AND NOT APPLE)
-  SET(ORXONOX_PLATFORM_LINUX TRUE)
-ENDIF()
-# Check __forceinline
-IF(MSVC)
-  INCLUDE(CheckCXXSourceCompiles)
-  SET(_source "int main() { return 0; } __forceinline void test() { return; }")
-  CHECK_CXX_SOURCE_COMPILES("${_source}" HAVE_FORCEINLINE)
-ENDIF(MSVC)
-# Check ciso646 include (literal operators)
-INCLUDE(CheckIncludeFileCXX)
-CHECK_INCLUDE_FILE_CXX(iso646.h HAVE_ISO646_H)
-# XCode and Visual Studio support multiple configurations. In order to tell the
-# which one we have to define the macros separately for each configuration
-ADD_COMPILER_FLAGS("-DCMAKE_BUILD_TYPE=Debug"          Debug)
-ADD_COMPILER_FLAGS("-DCMAKE_BUILD_TYPE=Release"        Release)
-ADD_COMPILER_FLAGS("-DCMAKE_BUILD_TYPE=RelWithDebInfo" RelWithDebInfo)
-ADD_COMPILER_FLAGS("-DCMAKE_BUILD_TYPE=MinSizeRel"     MinSizeRel)
-SET(GENERATED_FILE_COMMENT
-   "DO NOT EDIT THIS FILE! <br>
-    It has been automatically generated by CMake from OrxonoxConfig.h.in")
-# Copy and configure OrxonoxConfig which gets included in every file
-CONFIGURE_FILE(OrxonoxConfig.h.in ${CMAKE_CURRENT_BINARY_DIR}/OrxonoxConfig.h)
-# This file only gets included by very few classes to avoid a large recompilation
-CONFIGURE_FILE(SpecialConfig.h.in ${CMAKE_CURRENT_BINARY_DIR}/SpecialConfig.h)
-SET(ORXONOX_CONFIG_FILES
-  ${CMAKE_CURRENT_BINARY_DIR}/OrxonoxConfig.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/OrxonoxConfig.h.in
-  ${CMAKE_CURRENT_BINARY_DIR}/SpecialConfig.h
-  ${CMAKE_CURRENT_SOURCE_DIR}/SpecialConfig.h.in
+)
 ############## Include Directories ##############

code/trunk/src/OrxonoxConfig.h.in

-                      r3196
+                      r5695
+}
+// Import general purpose smart pointers
+namespace boost
+{
+    template<class T> class scoped_ptr;
+    template<class T> class shared_ptr;
+    template<class T> class weak_ptr;
+    template<class T> class intrusive_ptr;
+    template<class T> class shared_array;
+    template<class T> class scoped_array;
+}
+namespace orxonox
+{
+    using boost::scoped_ptr;
+    using boost::shared_ptr;
+    using boost::weak_ptr;
+    using boost::intrusive_ptr;
+    using boost::shared_array;
+    using boost::scoped_array;
+}
 #endif /* _OrxonoxConfig_H__ */

code/trunk/src/SpecialConfig.h.in

-                      r5693
+                      r5695
 // Handle default ConfigValues
 namespace orxonox
+namespace orxonox { namespace specialConfig
+{
+    // DEFAULT RELATIVE PATHS (might not be used at all)
+    const char defaultRuntimePath[] = "@DEFAULT_RUNTIME_PATH@";
+    const char defaultLibraryPath[] = "@DEFAULT_LIBRARY_PATH@";
+    const char defaultArchivePath[] = "@DEFAULT_ARCHIVE_PATH@";
+    const char defaultModulePath[]  = "@DEFAULT_MODULE_PATH@";
+    const char defaultDocPath[]     = "@DEFAULT_DOC_PATH@";
+    const char defaultDataPath[]    = "@DEFAULT_DATA_PATH@";
+    const char defaultConfigPath[]  = "@DEFAULT_CONFIG_PATH@";
+    const char defaultLogPath[]     = "@DEFAULT_LOG_PATH@";
+#ifndef INSTALL_COPYABLE
     // INSTALLATION PATHS
+    const char ORXONOX_RUNTIME_INSTALL_PATH[] = "@ORXONOX_RUNTIME_INSTALL_PATH@";
+    const char ORXONOX_MODULE_INSTALL_PATH[]  = "@ORXONOX_MODULE_INSTALL_PATH@";
+    const char ORXONOX_MEDIA_INSTALL_PATH[]   = "@ORXONOX_MEDIA_INSTALL_PATH@";
+    /* Config and Log path might be relative because they could be user and therefore runtime dependent */
+    const char ORXONOX_CONFIG_INSTALL_PATH[]  = "@ORXONOX_CONFIG_INSTALL_PATH@";
+    const char ORXONOX_LOG_INSTALL_PATH[]     = "@ORXONOX_LOG_INSTALL_PATH@";
+    const char dataInstallDirectory[]       = "@DATA_INSTALL_DIRECTORY@";
+    const char moduleInstallDirectory[]     = "@MODULE_INSTALL_DIRECTORY@";
+#endif
     // DEVELOPMENT RUN PATHS
+    const char ORXONOX_MEDIA_DEV_PATH[]       = "@CMAKE_MEDIA_OUTPUT_DIRECTORY@";
+    const char dataDevDirectory[]           = "@DATA_DIRECTORY@";
+    const char externalDataDevDirectory[]   = "@EXTERNAL_DATA_DIRECTORY@";
 #ifdef CMAKE_CONFIGURATION_TYPES
     const char ORXONOX_MODULE_DEV_PATH[]      = "@CMAKE_MODULE_OUTPUT_DIRECTORY@/" BOOST_PP_STRINGIZE(CMAKE_BUILD_TYPE);
     const char ORXONOX_CONFIG_DEV_PATH[]      = "@CMAKE_CONFIG_OUTPUT_DIRECTORY@/" BOOST_PP_STRINGIZE(CMAKE_BUILD_TYPE);
     const char ORXONOX_LOG_DEV_PATH[]         = "@CMAKE_LOG_OUTPUT_DIRECTORY@/"    BOOST_PP_STRINGIZE(CMAKE_BUILD_TYPE);
+    const char moduleDevDirectory[]         = "@CMAKE_MODULE_OUTPUT_DIRECTORY@/" BOOST_PP_STRINGIZE(CMAKE_BUILD_TYPE);
+    const char configDevDirectory[]         = "@CMAKE_CONFIG_OUTPUT_DIRECTORY@/" BOOST_PP_STRINGIZE(CMAKE_BUILD_TYPE);
+    const char logDevDirectory[]            = "@CMAKE_LOG_OUTPUT_DIRECTORY@/"    BOOST_PP_STRINGIZE(CMAKE_BUILD_TYPE);
 #else
     const char ORXONOX_MODULE_DEV_PATH[]      = "@CMAKE_MODULE_OUTPUT_DIRECTORY@";
     const char ORXONOX_CONFIG_DEV_PATH[]      = "@CMAKE_CONFIG_OUTPUT_DIRECTORY@";
     const char ORXONOX_LOG_DEV_PATH[]         = "@CMAKE_LOG_OUTPUT_DIRECTORY@";
+    const char moduleDevDirectory[]         = "@CMAKE_MODULE_OUTPUT_DIRECTORY@";
+    const char configDevDirectory[]         = "@CMAKE_CONFIG_OUTPUT_DIRECTORY@";
+    const char logDevDirectory[]            = "@CMAKE_LOG_OUTPUT_DIRECTORY@";
 #endif
 #ifdef DEPENDENCY_PACKAGE_ENABLE
     const char ORXONOX_DEP_LIB_PATH[]         = "@DEP_LIBRARY_DIR@";
+    const char dependencyLibraryDirectory[] = "@DEP_LIBRARY_DIR@";
 #endif
     // Module extension
     const char ORXONOX_MODULE_EXTENSION[]     = "@ORXONOX_MODULE_EXTENSION@";
+    const char moduleExtension[] = "@ORXONOX_MODULE_EXTENSION@";
     // OGRE PLUGINS
 #ifdef NDEBUG
     const char ORXONOX_OGRE_PLUGINS[] = "@OGRE_PLUGINS_RELEASE@";
+    const char ogrePlugins[] = "@OGRE_PLUGINS_RELEASE@";
 #  ifdef DEPENDENCY_PACKAGE_ENABLE
     const char ORXONOX_OGRE_PLUGINS_FOLDER[] = ".";
+    const char ogrePluginsDirectory[] = ".";
 #  else
     const char ORXONOX_OGRE_PLUGINS_FOLDER[] = "@OGRE_PLUGINS_FOLDER_RELEASE@";
+    const char ogrePluginsDirectory[] = "@OGRE_PLUGINS_FOLDER_RELEASE@";
 #  endif
 #else
     const char ORXONOX_OGRE_PLUGINS[] = "@OGRE_PLUGINS_DEBUG@";
+    const char ogrePlugins[] = "@OGRE_PLUGINS_DEBUG@";
 #  ifdef DEPENDENCY_PACKAGE_ENABLE
     const char ORXONOX_OGRE_PLUGINS_FOLDER[] = ".";
+    const char ogrePluginsDirectory[] = ".";
 #  else
     const char ORXONOX_OGRE_PLUGINS_FOLDER[] = "@OGRE_PLUGINS_FOLDER_DEBUG@";
+    const char ogrePluginsDirectory[] = "@OGRE_PLUGINS_FOLDER_DEBUG@";
 #  endif
 #endif
+}
+} }
 /**

code/trunk/src/ceguilua/CMakeLists.txt

r3196	r5695
63	63	CEGUI.pkg
64	64	DEPENDS ${TOLUA_PARSER_DEPENDENCIES}
65		WORKING_DIRECTORY ${~~ORXONOX_~~RUNTIME_LIBRARY_DIRECTORY}
	65	WORKING_DIRECTORY ${RUNTIME_LIBRARY_DIRECTORY}
66	66	COMMENT "Generating tolua bind files for package CEGUILua"
67	67	)

code/trunk/src/core/CMakeLists.txt

-                      r5693
+                      r5695
   GUIManager.cc
   Language.cc
+  LuaBind.cc
+  LuaState.cc
+  MemoryArchive.cc
   ObjectListBase.cc
   OrxonoxClass.cc
+  Resource.cc
   WindowEventListener.cc
 …
   TOLUA_FILES
     CommandExecutor.h
+    LuaBind.h
+    Loader.h
+    LuaState.h
   DEFINE_SYMBOL
     "CORE_SHARED_BUILD"

code/trunk/src/core/Clock.h

-                      r3370
+                      r5695
+ *
  *   Author:
  *      Fabian 'x3n' Landau
+ *      Reto Grieder
  *   Co-authors:
  *      Reto Grieder
+ *      ...
+ *
  */

code/trunk/src/core/ConfigFileManager.cc

-                      r3370
+                      r5695
 namespace orxonox
+{
-    const char* const DEFAULT_CONFIG_FILE = "default.ini";
-    ConfigFileManager* ConfigFileManager::singletonPtr_s = 0;
     SetConsoleCommandShortcutExtern(config).argumentCompleter(0, autocompletion::configvalueclasses()).argumentCompleter(1, autocompletion::configvalues()).argumentCompleter(2, autocompletion::configvalue());
     SetConsoleCommandShortcutExtern(tconfig).argumentCompleter(0, autocompletion::configvalueclasses()).argumentCompleter(1, autocompletion::configvalues()).argumentCompleter(2, autocompletion::configvalue());
 …
         if (!boost::filesystem::exists(filepath))
+        {
             // Try to get default one from the media folder
             boost::filesystem::path defaultFilepath(Core::getMediaPath() / "defaultConfig" / this->filename_);
+            // Try to get default one from the data folder
+            boost::filesystem::path defaultFilepath(Core::getDataPath() / "defaultConfig" / this->filename_);
             if (boost::filesystem::exists(defaultFilepath))
+            {
 …
     void ConfigFile::save() const
+    {
-        boost::filesystem::path filepath(Core::getConfigPath() / this->filename_);
         std::ofstream file;
         file.open(filepath.string().c_str(), std::fstream::out);
+        file.open((Core::getConfigPathString() + filename_).c_str(), std::fstream::out);
         file.setf(std::ios::fixed, std::ios::floatfield);
         file.precision(6);
 …
     ///////////////////////
+    ConfigFileManager* ConfigFileManager::singletonPtr_s = 0;
+    std::string ConfigFileManager::DEFAULT_CONFIG_FILE = "default.ini";
     ConfigFileManager::ConfigFileManager()
          : mininmalFreeType_(ConfigFileType::numberOfReservedTypes)

code/trunk/src/core/ConfigFileManager.h

r3370	r5695
307	307	void updateConfigValues(ConfigFileType type);
308	308
	309	static std::string DEFAULT_CONFIG_FILE;
	310
309	311	private:
310	312	ConfigFileManager(const ConfigFileManager&);

code/trunk/src/core/ConfigValueContainer.h

-                      r3301
+                      r5695
     @brief Definition of the ConfigValueContainer class.
     The ConfigValueContainer class contains all needed informations about a configurable variable:
+    The ConfigValueContainer class contains all needed information about a configurable variable:
      - the name of the variable
      - the name of the class the variable belongs to
 …
     //! The ConfigValuecontainer contains all needed informations about a configurable variable.
+    //! The ConfigValuecontainer contains all needed information about a configurable variable.
     /**
         The ConfigValueContainer class contains all needed informations about a configurable variable:
+        The ConfigValueContainer class contains all needed information about a configurable variable:
          - the name of the variable
          - the name of the class the variable belongs to

code/trunk/src/core/Core.cc

-                      r5693
+                      r5695
 #include <boost/version.hpp>
 #include <boost/filesystem.hpp>
-#include <OgreRenderWindow.h>
 #ifdef ORXONOX_PLATFORM_WINDOWS
 …
 #include "Identifier.h"
 #include "Language.h"
 #include "LuaBind.h"
+#include "LuaState.h"
 #include "Shell.h"
 #include "TclBind.h"
 …
     Core* Core::singletonPtr_s  = 0;
     SetCommandLineArgument(mediaPath, "").information("Path to the media/data files");
+    SetCommandLineArgument(externalDataPath, "").information("Path to the external data files");
     SetCommandLineOnlyArgument(writingPathSuffix, "").information("Additional subfolder for config and log files");
     SetCommandLineArgument(settingsFile, "orxonox.ini").information("THE configuration file");
 …
             this->setConfigValues();
+            // Possible media path override by the command line
+            if (!CommandLine::getArgument("mediaPath")->hasDefaultValue())
+                tsetMediaPath(CommandLine::getValue("mediaPath"));
+            // External data directory only exists for dev runs
+            if (Core::isDevelopmentRun())
+            {
+                // Possible data path override by the command line
+                if (!CommandLine::getArgument("externalDataPath")->hasDefaultValue())
+                    tsetExternalDataPath(CommandLine::getValue("externalDataPath"));
+            }
+        }
 …
                 .description("If true, all random actions are different each time you start the game")
                 .callback(this, &CoreConfiguration::initializeRandomNumberGenerator);
-            // Only show this config value for development builds
-            if (Core::isDevelopmentRun())
+            {
-                SetConfigValue(mediaPathString_, mediaPath_.string())
-                    .description("Relative path to the game data.")
-                    .callback(this, &CoreConfiguration::mediaPathChanged);
+            }
+        }
 …
         /**
-        @brief
-            Callback function if the media path has changed.
-        */
-        void mediaPathChanged()
+        {
-            mediaPath_ = boost::filesystem::path(this->mediaPathString_);
+        }
-        /**
             @brief Sets the language in the config-file back to the default.
         */
 …
         /**
         @brief
             Temporary sets the media path
+            Temporary sets the data path
         @param path
             The new media path
+            The new data path
         */
+        void tsetMediaPath(const std::string& path)
+        {
+            if (Core::isDevelopmentRun())
+            {
+                ModifyConfigValue(mediaPathString_, tset, path);
+            }
+            else
+            {
+                // Manual 'config' value without the file entry
+                mediaPathString_ = path;
+                this->mediaPathChanged();
+            }
+        void tsetExternalDataPath(const std::string& path)
+        {
+            dataPath_ = boost::filesystem::path(path);
+        }
 …
         std::string language_;                          //!< The language
         bool bInitializeRandomNumberGenerator_;         //!< If true, srand(time(0)) is called
-        std::string mediaPathString_;                   //!< Path to the data/media file folder as string
         //! Path to the parent directory of the ones above if program was installed with relativ pahts
 …
         boost::filesystem::path executablePath_;        //!< Path to the executable
         boost::filesystem::path modulePath_;            //!< Path to the modules
+        boost::filesystem::path mediaPath_;             //!< Path to the media file folder
+        boost::filesystem::path dataPath_;              //!< Path to the data file folder
+        boost::filesystem::path externalDataPath_;      //!< Path to the external data file folder
         boost::filesystem::path configPath_;            //!< Path to the config file folder
         boost::filesystem::path logPath_;               //!< Path to the log file folder
 …
+        {
             // We search for helper files with the following extension
             std::string moduleextension = ORXONOX_MODULE_EXTENSION;
+            std::string moduleextension = specialConfig::moduleExtension;
             size_t moduleextensionlength = moduleextension.size();
 …
         this->languageInstance_.reset(new Language());
+        // creates the class hierarchy for all classes with factories
+        Factory::createClassHierarchy();
         // Do this soon after the ConfigFileManager has been created to open up the
         // possibility to configure everything below here
         this->configuration_->initialise();
         // Create the lua interface
         this->luaBind_.reset(new LuaBind());
+        // Load OGRE excluding the renderer and the render window
+        this->graphicsManager_.reset(new GraphicsManager(false));
         // initialise Tcl
         this->tclBind_.reset(new TclBind(Core::getMediaPathString()));
+        this->tclBind_.reset(new TclBind(Core::getDataPathString()));
         this->tclThreadManager_.reset(new TclThreadManager(tclBind_->getTclInterpreter()));
         // create a shell
         this->shell_.reset(new Shell());
-        // creates the class hierarchy for all classes with factories
-        Factory::createClassHierarchy();
+    }
     /**
     @brief
         All destruction code is handled by scoped_ptrs and SimpleScopeGuards.
+        All destruction code is handled by scoped_ptrs and ScopeGuards.
     */
     Core::~Core()
 …
     void Core::loadGraphics()
+    {
+        if (bGraphicsLoaded_)
+            return;
+        // Load OGRE including the render window
+        scoped_ptr<GraphicsManager> graphicsManager(new GraphicsManager());
+        // The render window width and height are used to set up the mouse movement.
+        size_t windowHnd = 0;
+        graphicsManager->getRenderWindow()->getCustomAttribute("WINDOW", &windowHnd);
+        // Any exception should trigger this, even in upgradeToGraphics (see its remarks)
+        Loki::ScopeGuard unloader = Loki::MakeObjGuard(*this, &Core::unloadGraphics);
+        // Upgrade OGRE to receive a render window
+        graphicsManager_->upgradeToGraphics();
         // Calls the InputManager which sets up the input devices.
         scoped_ptr<InputManager> inputManager(new InputManager(windowHnd));
+        inputManager_.reset(new InputManager());
         // load the CEGUI interface
+        guiManager_.reset(new GUIManager(graphicsManager->getRenderWindow()));
+        // Dismiss scoped pointers
+        graphicsManager_.swap(graphicsManager);
+        inputManager_.swap(inputManager);
+        guiManager_.reset(new GUIManager(graphicsManager_->getRenderWindow(),
+            inputManager_->getMousePosition(), graphicsManager_->isFullScreen()));
+        unloader.Dismiss();
         bGraphicsLoaded_ = true;
 …
     void Core::unloadGraphics()
+    {
-        if (!bGraphicsLoaded_)
-            return;
         this->guiManager_.reset();;
         this->inputManager_.reset();;
         this->graphicsManager_.reset();
+        // Load Ogre::Root again, but without the render system
+        try
+            { this->graphicsManager_.reset(new GraphicsManager(false)); }
+        catch (...)
+        {
+            COUT(0) << "An exception occurred during 'new GraphicsManager' while "
+                    << "another exception was being handled. This will lead to undefined behaviour!" << std::endl
+                    << "Terminating the program." << std::endl;
+            abort();
+        }
         bGraphicsLoaded_ = false;
 …
+    }
+    /*static*/ void Core::tsetMediaPath(const std::string& path)
+    {
+        getInstance().configuration_->tsetMediaPath(path);
+    }
+    /*static*/ const boost::filesystem::path& Core::getMediaPath()
+    {
+        return getInstance().configuration_->mediaPath_;
+    }
+    /*static*/ std::string Core::getMediaPathString()
+    {
+        return getInstance().configuration_->mediaPath_.string() + '/';
+    /*static*/ void Core::tsetExternalDataPath(const std::string& path)
+    {
+        getInstance().configuration_->tsetExternalDataPath(path);
+    }
+    /*static*/ const boost::filesystem::path& Core::getDataPath()
+    {
+        return getInstance().configuration_->dataPath_;
+    }
+    /*static*/ std::string Core::getDataPathString()
+    {
+        return getInstance().configuration_->dataPath_.string() + '/';
+    }
+    /*static*/ const boost::filesystem::path& Core::getExternalDataPath()
+    {
+        return getInstance().configuration_->externalDataPath_;
+    }
+    /*static*/ std::string Core::getExternalDataPathString()
+    {
+        return getInstance().configuration_->externalDataPath_.string() + '/';
+    }
 …
             COUT(1) << "Running from the build tree." << std::endl;
             Core::bDevRun_ = true;
             configuration_->modulePath_ = ORXONOX_MODULE_DEV_PATH;
+            configuration_->modulePath_ = specialConfig::moduleDevDirectory;
+        }
         else
 …
             // Also set the root path
             boost::filesystem::path relativeExecutablePath(ORXONOX_RUNTIME_INSTALL_PATH);
+            boost::filesystem::path relativeExecutablePath(specialConfig::defaultRuntimePath);
             configuration_->rootPath_ = configuration_->executablePath_;
             while (!boost::filesystem::equivalent(configuration_->rootPath_ / relativeExecutablePath, configuration_->executablePath_)
 …
             // Module path is fixed as well
             configuration_->modulePath_ = configuration_->rootPath_ / ORXONOX_MODULE_INSTALL_PATH;
+            configuration_->modulePath_ = configuration_->rootPath_ / specialConfig::defaultModulePath;
 #else
 …
             // There is no root path, so don't set it at all
             // Module path is fixed as well
             configuration_->modulePath_ = ORXONOX_MODULE_INSTALL_PATH;
+            configuration_->modulePath_ = specialConfig::moduleInstallDirectory;
 #endif
 …
         if (Core::isDevelopmentRun())
+        {
+            configuration_->mediaPath_  = ORXONOX_MEDIA_DEV_PATH;
+            configuration_->configPath_ = ORXONOX_CONFIG_DEV_PATH;
+            configuration_->logPath_    = ORXONOX_LOG_DEV_PATH;
+            configuration_->dataPath_  = specialConfig::dataDevDirectory;
+            configuration_->externalDataPath_ = specialConfig::externalDataDevDirectory;
+            configuration_->configPath_ = specialConfig::configDevDirectory;
+            configuration_->logPath_    = specialConfig::logDevDirectory;
+        }
         else
 …
             // Using paths relative to the install prefix, complete them
             configuration_->mediaPath_  = configuration_->rootPath_ / ORXONOX_MEDIA_INSTALL_PATH;
             configuration_->configPath_ = configuration_->rootPath_ / ORXONOX_CONFIG_INSTALL_PATH;
             configuration_->logPath_    = configuration_->rootPath_ / ORXONOX_LOG_INSTALL_PATH;
+            configuration_->dataPath_   = configuration_->rootPath_ / specialConfig::defaultDataPath;
+            configuration_->configPath_ = configuration_->rootPath_ / specialConfig::defaultConfigPath;
+            configuration_->logPath_    = configuration_->rootPath_ / specialConfig::defaultLogPath;
 #else
             configuration_->mediaPath_  = ORXONOX_MEDIA_INSTALL_PATH;
+            configuration_->dataPath_  = specialConfig::dataInstallDirectory;
             // Get user directory
 …
             userDataPath /= ".orxonox";
             configuration_->configPath_ = userDataPath / ORXONOX_CONFIG_INSTALL_PATH;
             configuration_->logPath_    = userDataPath / ORXONOX_LOG_INSTALL_PATH;
+            configuration_->configPath_ = userDataPath / specialConfig::defaultConfigPath;
+            configuration_->logPath_    = userDataPath / specialConfig::defaultLogPath;
 #endif
 …
+    }
+    bool Core::preUpdate(const Clock& time) throw()
+    {
+        std::string exceptionMessage;
+        try
+        {
+            if (this->bGraphicsLoaded_)
+            {
+                // process input events
+                this->inputManager_->update(time);
+                // process gui events
+                this->guiManager_->update(time);
+            }
+            // process thread commands
+            this->tclThreadManager_->update(time);
+        }
+        catch (const std::exception& ex)
+        { exceptionMessage = ex.what(); }
+        catch (...)
+        { exceptionMessage = "Unknown exception"; }
+        if (!exceptionMessage.empty())
+        {
+            COUT(0) << "An exception occurred in the Core preUpdate: " << exceptionMessage << std::endl;
+            COUT(0) << "This should really never happen! Closing the program." << std::endl;
+            return false;
+        }
+        return true;
+    }
+    bool Core::postUpdate(const Clock& time) throw()
+    {
+        std::string exceptionMessage;
+        try
+        {
+            if (this->bGraphicsLoaded_)
+            {
+                // Render (doesn't throw)
+                this->graphicsManager_->update(time);
+            }
+        }
+        catch (const std::exception& ex)
+        { exceptionMessage = ex.what(); }
+        catch (...)
+        { exceptionMessage = "Unknown exception"; }
+        if (!exceptionMessage.empty())
+        {
+            COUT(0) << "An exception occurred in the Core postUpdate: " << exceptionMessage << std::endl;
+            COUT(0) << "This should really never happen! Closing the program." << std::endl;
+            return false;
+        }
+        return true;
+    void Core::preUpdate(const Clock& time)
+    {
+        if (this->bGraphicsLoaded_)
+        {
+            // process input events
+            this->inputManager_->update(time);
+            // process gui events
+            this->guiManager_->update(time);
+        }
+        // process thread commands
+        this->tclThreadManager_->update(time);
+    }
+    void Core::postUpdate(const Clock& time)
+    {
+        if (this->bGraphicsLoaded_)
+        {
+            // Render (doesn't throw)
+            this->graphicsManager_->update(time);
+        }
+    }
+}

code/trunk/src/core/Core.h

-                      r5693
+                      r5695
+{
     class CoreConfiguration;
-    using boost::scoped_ptr;
     /**
 …
         The Core class is a singleton used to configure the program basics.
     @details
         The class provides information about the media, config and log path.
+        The class provides information about the data, config and log path.
         It determines those by the use of platform specific functions.
     @remark
 …
         typedef Loki::ScopeGuardImpl0<void (*)()> SimpleScopeGuard;
         friend class Singleton<Core>;
+        friend class Game;
         public:
 …
             void setConfigValues();
-            bool preUpdate(const Clock& time) throw();
-            bool postUpdate(const Clock& time) throw();
-            void loadGraphics();
-            void unloadGraphics();
             static int   getSoftDebugLevel(OutputHandler::OutputDevice device = OutputHandler::LD_All);
             static void  setSoftDebugLevel(OutputHandler::OutputDevice device, int level);
 …
             static void  resetLanguage();
+            static void tsetMediaPath(const std::string& path);
+            //! Returns the path to the config files as boost::filesystem::path
+            static const boost::filesystem::path& getMediaPath();
+            static void tsetExternalDataPath(const std::string& path);
+            //! Returns the path to the data files as boost::filesystem::path
+            static const boost::filesystem::path& getDataPath();
+            //! Returns the path to the external data files as boost::filesystem::path
+            static const boost::filesystem::path& getExternalDataPath();
             //! Returns the path to the config files as boost::filesystem::path
             static const boost::filesystem::path& getConfigPath();
 …
             static const boost::filesystem::path& getRootPath();
             //! Returns the path to the data files as std::string
+            static std::string getMediaPathString();
+            static std::string getDataPathString();
+            //! Returns the path to the external data files as std::string
+            static std::string getExternalDataPathString();
             //! Returns the path to the config files as std::string
             static std::string getConfigPathString();
 …
         private:
             Core(const Core&); //!< Don't use (undefined symbol)
+            void preUpdate(const Clock& time);
+            void postUpdate(const Clock& time);
+            void loadGraphics();
+            void unloadGraphics();
             void setFixedPaths();
 …
             scoped_ptr<Language>          languageInstance_;
             scoped_ptr<CoreConfiguration> configuration_;
-            scoped_ptr<LuaBind>           luaBind_;
             scoped_ptr<TclBind>           tclBind_;
             scoped_ptr<TclThreadManager>  tclThreadManager_;

code/trunk/src/core/CorePrereqs.h

-                      r5693
+                      r5695
     class LanguageEntry;
     class Loader;
+    class LuaBind;
+    class LuaState;
+    class MemoryArchive;
+    class MemoryArchiveFactory;
     class MetaObjectList;
     class MetaObjectListElement;
 …
     class OgreWindowEventListener;
     class OrxonoxClass;
+    struct ResourceInfo;
     class Shell;
     class ShellListener;
 …
+}
+// Ogre
+namespace Ogre
+{
+    class DataStream;
+    template <class T> class SharedPtr;
+    typedef SharedPtr<DataStream> DataStreamPtr;
+}
+namespace orxonox
+{
+    // Import the Ogre::DataStream
+    using Ogre::DataStream;
+    using Ogre::DataStreamPtr;
+}
 // CEGUI
 namespace CEGUI

code/trunk/src/core/DynLibManager.h

-                      r5693
+                      r5695
 #include "CorePrereqs.h"
+#include <map>
+#include <string>
 #include "util/Singleton.h"

code/trunk/src/core/GUIManager.cc

-                      r3370
+                      r5695
+ *
  */
-/**
-@file
-@brief
-    Implementation of the GUIManager class.
-*/
 #include "GUIManager.h"
 …
 #include <CEGUIExceptions.h>
 #include <CEGUIInputEvent.h>
+#include <CEGUIMouseCursor.h>
 #include <CEGUIResourceProvider.h>
 #include <CEGUISystem.h>
 …
 #include "Core.h"
 #include "Clock.h"
+#include "LuaBind.h"
+#include "LuaState.h"
+#include "Resource.h"
 namespace orxonox
 …
     @return true if success, otherwise false
     */
     GUIManager::GUIManager(Ogre::RenderWindow* renderWindow)
+    GUIManager::GUIManager(Ogre::RenderWindow* renderWindow, const std::pair<int, int>& mousePosition, bool bFullScreen)
         : renderWindow_(renderWindow)
         , resourceProvider_(0)
 …
         COUT(3) << "Initialising CEGUI." << std::endl;
+        try
+        {
+            // Note: No SceneManager specified yet
+            guiRenderer_.reset(new OgreCEGUIRenderer(renderWindow_, Ogre::RENDER_QUEUE_OVERLAY, false, 3000));
+            resourceProvider_ = guiRenderer_->createResourceProvider();
+            resourceProvider_->setDefaultResourceGroup("GUI");
+            // setup scripting
+            scriptModule_.reset(new LuaScriptModule());
+            luaState_ = scriptModule_->getLuaState();
+            // Create our own logger to specify the filepath
+            std::auto_ptr<CEGUILogger> ceguiLogger(new CEGUILogger());
+            ceguiLogger->setLogFilename(Core::getLogPathString() + "cegui.log");
+            // set the log level according to ours (translate by subtracting 1)
+            ceguiLogger->setLoggingLevel(
+                static_cast<LoggingLevel>(Core::getSoftDebugLevel(OutputHandler::LD_Logfile) - 1));
+            this->ceguiLogger_ = ceguiLogger.release();
+            // create the CEGUI system singleton
+            guiSystem_.reset(new System(guiRenderer_.get(), resourceProvider_, 0, scriptModule_.get()));
+            // do this after 'new CEGUI::Sytem' because that creates the lua state in the first place
+            LuaBind::getInstance().openToluaInterfaces(this->luaState_);
+            // initialise the basic lua code
+            this->loadLuaCode();
+        }
+        catch (CEGUI::Exception& ex)
+        {
+#if CEGUI_VERSION_MAJOR == 0 && CEGUI_VERSION_MINOR < 6
+            throw GeneralException(ex.getMessage().c_str());
+#else
+            throw GeneralException(ex.getMessage().c_str(), ex.getLine(),
+                ex.getFileName().c_str(), ex.getName().c_str());
+#endif
+        }
+    }
+    /**
+    @brief
+        Destructor of the GUIManager
+        // Note: No SceneManager specified yet
+        guiRenderer_.reset(new OgreCEGUIRenderer(renderWindow_, Ogre::RENDER_QUEUE_OVERLAY, false, 3000));
+        resourceProvider_ = guiRenderer_->createResourceProvider();
+        resourceProvider_->setDefaultResourceGroup("GUI");
+        // setup scripting
+        luaState_.reset(new LuaState());
+        scriptModule_.reset(new LuaScriptModule(luaState_->getInternalLuaState()));
+        // Create our own logger to specify the filepath
+        std::auto_ptr<CEGUILogger> ceguiLogger(new CEGUILogger());
+        ceguiLogger->setLogFilename(Core::getLogPathString() + "cegui.log");
+        // set the log level according to ours (translate by subtracting 1)
+        ceguiLogger->setLoggingLevel(
+            static_cast<LoggingLevel>(Core::getSoftDebugLevel(OutputHandler::LD_Logfile) - 1));
+        this->ceguiLogger_ = ceguiLogger.release();
+        // create the CEGUI system singleton
+        guiSystem_.reset(new System(guiRenderer_.get(), resourceProvider_, 0, scriptModule_.get()));
+        // Initialise the basic lua code
+        rootFileInfo_ = Resource::getInfo("InitialiseGUI.lua", "GUI");
+        this->luaState_->doFile("InitialiseGUI.lua", "GUI", false);
+        // Align CEGUI mouse with OIS mouse
+        guiSystem_->injectMousePosition(mousePosition.first, mousePosition.second);
+        // Hide the mouse cursor unless playing in fullscreen mode
+        if (!bFullScreen)
+            CEGUI::MouseCursor::getSingleton().hide();
+    }
+    /**
+    @brief
         Basically shuts down CEGUI (member smart pointers) but first unloads our Tolua modules.
     */
     GUIManager::~GUIManager()
+    {
-        // destroy our own tolua interfaces
-        LuaBind::getInstance().closeToluaInterfaces(this->luaState_);
+    }
-    /**
-    @brief
-        Calls main Lua script
-    @todo
-        This function calls the main Lua script for our GUI.
-        Additionally we set the datapath variable in Lua. This is needed so Lua can access the data used for the GUI.
-    */
-    void GUIManager::loadLuaCode()
+    {
-        // set datapath for GUI data
-        lua_pushfstring(this->scriptModule_->getLuaState(), Core::getMediaPathString().c_str());
-        lua_setglobal(this->scriptModule_->getLuaState(), "datapath");
-        // call main Lua script
-        this->scriptModule_->executeScriptFile("loadGUI_3.lua", "GUI");
+    }
 …
     void GUIManager::executeCode(const std::string& str)
+    {
+        try
+        {
+            this->scriptModule_->executeString(str);
+        }
+        catch (const CEGUI::Exception& ex)
+        {
+            COUT(2) << "CEGUI Error: \"" << ex.getMessage() << "\" while executing code \"" << str << "\"" << std::endl;
+        }
+        catch (...)
+        {
+            COUT(2) << "Couldn't execute GUI related Lua code due to unknown reasons." << std::endl;
+        }
+        this->luaState_->doString(str, rootFileInfo_);
+    }
 …
     void GUIManager::showGUI(const std::string& name)
+    {
         this->executeCode(std::string("showGUI(\"") + name + "\")");
+        this->luaState_->doString("showGUI(\"" + name + "\")", rootFileInfo_);
+    }
 …
     void GUIManager::mouseMoved(IntVector2 abs, IntVector2 rel, IntVector2 clippingSize)
+    {
         guiSystem_->injectMouseMove(static_cast<float>(rel.x), static_cast<float>(rel.y));
+        guiSystem_->injectMousePosition(static_cast<float>(abs.x), static_cast<float>(abs.y));
+    }
     void GUIManager::mouseScrolled(int abs, int rel)

code/trunk/src/core/GUIManager.h

-                      r5693
+                      r5695
  */
-/**
-@file
-@brief
-    Declaration of the GUIManager class.
-*/
 #ifndef _GUIManager_H__
 #define _GUIManager_H__
 …
 #include <CEGUIForwardRefs.h>
 #include <boost/scoped_ptr.hpp>
+#include <boost/shared_ptr.hpp>
 #include "util/OgreForwardRefs.h"
 …
         friend class Singleton<GUIManager>;
     public:
         GUIManager(Ogre::RenderWindow* renderWindow);
+        GUIManager(Ogre::RenderWindow* renderWindow, const std::pair<int, int>& mousePosition, bool bFullScreen);
         ~GUIManager();
 …
         GUIManager(const GUIManager& instance); //!< private and undefined copy c'tor (this is a singleton class)
-        void loadLuaCode();
         // keyHandler functions
         void keyPressed (const KeyEvent& evt);
 …
         void mouseScrolled (int abs, int rel);
+        boost::scoped_ptr<CEGUI::OgreCEGUIRenderer> guiRenderer_;       //!< CEGUI's interface to the Ogre Engine
+        boost::scoped_ptr<CEGUI::LuaScriptModule>   scriptModule_;      //!< CEGUI's script module to use Lua
+        boost::scoped_ptr<CEGUI::System>            guiSystem_;         //!< CEGUI's main system
+        Ogre::RenderWindow*                         renderWindow_;      //!< Ogre's render window to give CEGUI access to it
+        CEGUI::ResourceProvider*                    resourceProvider_;  //!< CEGUI's resource provider
+        CEGUI::Logger*                              ceguiLogger_;       //!< CEGUI's logger to be able to log CEGUI errors in our log
+        lua_State*                                  luaState_;          //!< Lua state, access point to the Lua engine
+        std::map<std::string, PlayerInfo*>          players_;           //!< Stores the player (owner) for each gui
+        scoped_ptr<CEGUI::OgreCEGUIRenderer> guiRenderer_;      //!< CEGUI's interface to the Ogre Engine
+        scoped_ptr<LuaState>                 luaState_;         //!< LuaState, access point to the Lua engine
+        scoped_ptr<CEGUI::LuaScriptModule>   scriptModule_;     //!< CEGUI's script module to use Lua
+        scoped_ptr<CEGUI::System>            guiSystem_;        //!< CEGUI's main system
+        shared_ptr<ResourceInfo>             rootFileInfo_;     //!< Resource information about the root script
+        Ogre::RenderWindow*                  renderWindow_;     //!< Ogre's render window to give CEGUI access to it
+        CEGUI::ResourceProvider*             resourceProvider_; //!< CEGUI's resource provider
+        CEGUI::Logger*                       ceguiLogger_;      //!< CEGUI's logger to be able to log CEGUI errors in our log
+        std::map<std::string, PlayerInfo*>   players_;          //!< Stores the player (owner) for each gui
         static GUIManager*                          singletonPtr_s;     //!< Singleton reference to GUIManager
+        static GUIManager*                   singletonPtr_s;    //!< Singleton reference to GUIManager
     };

code/trunk/src/core/Game.cc

-                      r5693
+                      r5695
 #include <exception>
 #include <boost/weak_ptr.hpp>
+#include <CEGUIExceptions.h>
 #include "util/Debug.h"
 …
 namespace orxonox
+{
-    using boost::shared_ptr;
-    using boost::weak_ptr;
     static void stop_game()
         { Game::getInstance().stop(); }
 …
             // Core preUpdate (doesn't throw)
+            if (!this->core_->preUpdate(*this->gameClock_))
+            {
+            try
+                { this->core_->preUpdate(*this->gameClock_); }
+            catch (...)
+            {
+                COUT(0) << "An exception occurred in the Core preUpdate: " << Game::getExceptionMessage() << std::endl;
+                COUT(0) << "This should really never happen! Closing the program." << std::endl;
                 this->stop();
                 break;
 …
             // Core postUpdate (doesn't throw)
+            if (!this->core_->postUpdate(*this->gameClock_))
+            {
+            try
+                { this->core_->postUpdate(*this->gameClock_); }
+            catch (...)
+            {
+            COUT(0) << "An exception occurred in the Core postUpdate: " << Game::getExceptionMessage() << std::endl;
+            COUT(0) << "This should really never happen! Closing the program." << std::endl;
                 this->stop();
                 break;
 …
                     this->loadState(requestedStateNode->name_);
+                }
                 catch (const std::exception& ex)
+                catch (...)
+                {
                     COUT(1) << "Error: Loading GameState '" << requestedStateNode->name_ << "' failed: " << ex.what() << std::endl;
+                    COUT(1) << "Error: Loading GameState '" << requestedStateNode->name_ << "' failed: " << Game::getExceptionMessage() << std::endl;
                     // All scheduled operations have now been rendered inert --> flush them and issue a warning
                     if (this->requestedStateNodes_.size() > 1)
                         COUT(1) << "All " << this->requestedStateNodes_.size() - 1 << " scheduled transitions have been ignored." << std::endl;
+                        COUT(4) << "All " << this->requestedStateNodes_.size() - 1 << " scheduled transitions have been ignored." << std::endl;
                     this->requestedStateNodes_.clear();
                     break;
 …
             it != this->loadedStates_.end(); ++it)
+        {
-            std::string exceptionMessage;
             try
+            {
                 // Add tick time for most of the states
                 uint64_t timeBeforeTick;
+                uint64_t timeBeforeTick = 0;
                 if ((*it)->getInfo().bIgnoreTickTime)
                     timeBeforeTick = this->gameClock_->getRealMicroseconds();
 …
                     this->subtractTickTime(static_cast<int32_t>(this->gameClock_->getRealMicroseconds() - timeBeforeTick));
+            }
-            catch (const std::exception& ex)
-            { exceptionMessage = ex.what(); }
             catch (...)
+            { exceptionMessage = "Unknown exception"; }
+            if (!exceptionMessage.empty())
+            {
+                COUT(1) << "An exception occurred while updating '" << (*it)->getName() << "': " << exceptionMessage << std::endl;
+            {
+                COUT(1) << "An exception occurred while updating '" << (*it)->getName() << "': " << Game::getExceptionMessage() << std::endl;
                 COUT(1) << "This should really never happen!" << std::endl;
                 COUT(1) << "Unloading all GameStates depending on the one that crashed." << std::endl;
 …
             state->deactivate();
+        }
+        catch (...)
+        {
+            COUT(2) << "Warning: Unloading GameState '" << name << "' threw an exception: " << Game::getExceptionMessage() << std::endl;
+            COUT(2) << "         There might be potential resource leaks involved! To avoid this, improve exception-safety." << std::endl;
+        }
+        // Check if graphics is still required
+        if (!bAbort_)
+        {
+            bool graphicsRequired = false;
+            for (unsigned i = 0; i < loadedStates_.size(); ++i)
+                graphicsRequired |= loadedStates_[i]->getInfo().bGraphicsMode;
+            if (!graphicsRequired)
+                this->unloadGraphics();
+        }
+        this->bChangingState_ = false;
+    }
+    /*static*/ std::string Game::getExceptionMessage()
+    {
+        std::string exceptionMessage;
+        try
+        {
+            // rethrow
+            throw;
+        }
         catch (const std::exception& ex)
+        {
+            COUT(2) << "Warning: Unloading GameState '" << name << "' threw an exception: " << ex.what() << std::endl;
+            COUT(2) << "         There might be potential resource leaks involved! To avoid this, improve exception-safety." << std::endl;
+        }
+        // Check if graphics is still required
+        bool graphicsRequired = false;
+        for (unsigned i = 0; i < loadedStates_.size(); ++i)
+            graphicsRequired |= loadedStates_[i]->getInfo().bGraphicsMode;
+        if (!graphicsRequired)
+            this->unloadGraphics();
+        this->bChangingState_ = false;
+            return ex.what();
+        }
+        catch (const CEGUI::Exception& ex)
+        {
+#if CEGUI_VERSION_MAJOR == 0 && CEGUI_VERSION_MINOR < 6
+            return GeneralException(ex.getMessage().c_str()).getDescription();
+#else
+            return GeneralException(ex.getMessage().c_str(), ex.getLine(),
+                ex.getFileName().c_str(), ex.getName().c_str()).getDescription();
+#endif
+        }
+        catch (...)
+        {
+            return "Unknown exception";
+        }
+    }

code/trunk/src/core/Game.h

-                      r5693
+                      r5695
+{
     class GameConfiguration;
-    using boost::scoped_ptr;
-    using boost::shared_ptr;
     //! Helper object required before GameStates are being constructed
 …
         typedef std::vector<shared_ptr<GameState> > GameStateVector;
         typedef std::map<std::string, shared_ptr<GameState> > GameStateMap;
         typedef boost::shared_ptr<GameStateTreeNode> GameStateTreeNodePtr;
+        typedef shared_ptr<GameStateTreeNode> GameStateTreeNodePtr;
     public:
 …
         // ScopeGuard helper function
         void resetChangingState() { this->bChangingState_ = false; }
+        /**
+        @brief
+            Retrieves information from an exception caught with "..."
+        @remarks
+            Never ever call this function without an exception in the stack!
+        */
+        static std::string getExceptionMessage();
         scoped_ptr<Clock>                  gameClock_;

code/trunk/src/core/GraphicsManager.cc

-                      r3370
+                      r5695
  */
-/**
-@file
-@brief
-    Implementation of an partial interface to Ogre.
-*/
 #include "GraphicsManager.h"
 #include <fstream>
 #include <memory>
+#include <sstream>
 #include <boost/filesystem.hpp>
 #include <boost/shared_ptr.hpp>
 #include <OgreCompositorManager.h>
 #include <OgreConfigFile.h>
+#include <boost/shared_array.hpp>
+#include <OgreArchiveFactory.h>
+#include <OgreArchiveManager.h>
 #include <OgreFrameListener.h>
 #include <OgreRoot.h>
 #include <OgreLogManager.h>
-#include <OgreException.h>
 #include <OgreRenderWindow.h>
 #include <OgreRenderSystem.h>
+#include <OgreResourceGroupManager.h>
 #include <OgreTextureManager.h>
 #include <OgreViewport.h>
 …
 #include "Game.h"
 #include "GameMode.h"
+#include "Loader.h"
+#include "MemoryArchive.h"
 #include "WindowEventListener.h"
+#include "XMLFile.h"
 namespace orxonox
+{
-    using boost::shared_ptr;
     class OgreWindowEventListener : public Ogre::WindowEventListener
+    {
 …
         Non-initialising constructor.
     */
+    GraphicsManager::GraphicsManager()
+        : ogreRoot_(0)
+        , ogreLogger_(0)
+    GraphicsManager::GraphicsManager(bool bLoadRenderer)
+        : ogreWindowEventListener_(new OgreWindowEventListener())
+#if OGRE_VERSION < 0x010600
+        , memoryArchiveFactory_(new MemoryArchiveFactory())
+#endif
         , renderWindow_(0)
         , viewport_(0)
-        , ogreWindowEventListener_(new OgreWindowEventListener())
+    {
         RegisterObject(GraphicsManager);
 …
         this->setConfigValues();
+        // Ogre setup procedure
+        setupOgre();
+        try
+        {
+            // load all the required plugins for Ogre
+            loadOgrePlugins();
+            // read resource declaration file
+            this->declareResources();
+            // Reads ogre config and creates the render window
+            this->loadRenderer();
+            // TODO: Spread this
+            this->initialiseResources();
+            // add console commands
+            FunctorMember<GraphicsManager>* functor1 = createFunctor(&GraphicsManager::printScreen);
+            functor1->setObject(this);
+            ccPrintScreen_ = createConsoleCommand(functor1, "printScreen");
+            CommandExecutor::addConsoleCommandShortcut(ccPrintScreen_);
+        }
+        catch (...)
+        {
+            // clean up
+            delete this->ogreRoot_;
+            delete this->ogreLogger_;
+            delete this->ogreWindowEventListener_;
+            throw;
+        // Ogre setup procedure (creating Ogre::Root)
+        this->loadOgreRoot();
+        // load all the required plugins for Ogre
+        this->loadOgrePlugins();
+        // At first, add the root paths of the data directories as resource locations
+        Ogre::ResourceGroupManager::getSingleton().addResourceLocation(Core::getDataPathString(), "FileSystem", "dataRoot", false);
+        // Load resources
+        resources_.reset(new XMLFile("resources.oxr", "dataRoot"));
+        resources_->setLuaSupport(false);
+        Loader::open(resources_.get());
+        // Only for development runs
+        if (Core::isDevelopmentRun())
+        {
+            Ogre::ResourceGroupManager::getSingleton().addResourceLocation(Core::getExternalDataPathString(), "FileSystem", "externalDataRoot", false);
+            extResources_.reset(new XMLFile("resources.oxr", "externalDataRoot"));
+            extResources_->setLuaSupport(false);
+            Loader::open(extResources_.get());
+        }
+        if (bLoadRenderer)
+        {
+            // Reads the ogre config and creates the render window
+            this->upgradeToGraphics();
+        }
+    }
 …
     /**
     @brief
         Destroys all the Ogre related objects
+        Destruction is done by the member scoped_ptrs.
     */
     GraphicsManager::~GraphicsManager()
+    {
+/*
+        delete this->ccPrintScreen_;
+*/
+        // unload all compositors (this is only necessary because we don't yet destroy all resources!)
+        Ogre::CompositorManager::getSingleton().removeAll();
+        // Delete OGRE main control organ
+        delete this->ogreRoot_;
+        // delete the logManager (since we have created it in the first place).
+        delete this->ogreLogger_;
+        delete this->ogreWindowEventListener_;
+        Ogre::WindowEventUtilities::removeWindowEventListener(renderWindow_, ogreWindowEventListener_.get());
+        // TODO: Destroy the console command
+    }
     void GraphicsManager::setConfigValues()
+    {
-        SetConfigValue(resourceFile_,    "resources.cfg")
-            .description("Location of the resources file in the data path.");
         SetConfigValue(ogreConfigFile_,  "ogre.cfg")
             .description("Location of the Ogre config file");
         SetConfigValue(ogrePluginsFolder_, ORXONOX_OGRE_PLUGINS_FOLDER)
+        SetConfigValue(ogrePluginsDirectory_, specialConfig::ogrePluginsDirectory)
             .description("Folder where the Ogre plugins are located.");
         SetConfigValue(ogrePlugins_, ORXONOX_OGRE_PLUGINS)
+        SetConfigValue(ogrePlugins_, specialConfig::ogrePlugins)
             .description("Comma separated list of all plugins to load.");
         SetConfigValue(ogreLogFile_,     "ogre.log")
 …
+    }
+    /**
+    @brief
+        Loads the renderer and creates the render window if not yet done so.
+    @remarks
+        This operation is irreversible without recreating the GraphicsManager!
+        So if it throws you HAVE to recreate the GraphicsManager!!!
+        It therefore offers almost no exception safety.
+    */
+    void GraphicsManager::upgradeToGraphics()
+    {
+        if (renderWindow_ != NULL)
+            return;
+        this->loadRenderer();
+#if OGRE_VERSION < 0x010600
+        // WORKAROUND: There is an incompatibility for particle scripts when trying
+        // to support both Ogre 1.4 and 1.6. The hacky solution is to create
+        // scripts for the 1.6 version and then remove the inserted "particle_system"
+        // keyword. But we need to supply these new scripts as well, which is why
+        // there is an extra Ogre::Archive dealing with in the memory.
+        using namespace Ogre;
+        ArchiveManager::getSingleton().addArchiveFactory(memoryArchiveFactory_.get());
+        const StringVector& groups = ResourceGroupManager::getSingleton().getResourceGroups();
+        // Travers all groups
+        for (StringVector::const_iterator itGroup = groups.begin(); itGroup != groups.end(); ++itGroup)
+        {
+            FileInfoListPtr files = ResourceGroupManager::getSingleton().findResourceFileInfo(*itGroup, "*.particle");
+            for (FileInfoList::const_iterator itFile = files->begin(); itFile != files->end(); ++itFile)
+            {
+                // open file
+                Ogre::DataStreamPtr input = ResourceGroupManager::getSingleton().openResource(itFile->filename, *itGroup, false);
+                std::stringstream output;
+                // Parse file and replace "particle_system" with nothing
+                while (!input->eof())
+                {
+                    std::string line = input->getLine();
+                    size_t pos = line.find("particle_system");
+                    if (pos != std::string::npos)
+                    {
+                        // 15 is the length of "particle_system"
+                        line.replace(pos, 15, "");
+                    }
+                    output << line << std::endl;
+                }
+                // Add file to the memory archive
+                shared_array<char> data(new char[output.str().size()]);
+                // Debug optimisations
+                const std::string outputStr = output.str();
+                char* rawData = data.get();
+                for (unsigned i = 0; i < outputStr.size(); ++i)
+                    rawData[i] = outputStr[i];
+                MemoryArchive::addFile("particle_scripts_ogre_1.4_" + *itGroup, itFile->filename, data, output.str().size());
+            }
+            if (!files->empty())
+            {
+                // Declare the files, but using a new group
+                ResourceGroupManager::getSingleton().addResourceLocation("particle_scripts_ogre_1.4_" + *itGroup,
+                    "Memory", "particle_scripts_ogre_1.4_" + *itGroup);
+            }
+        }
+#endif
+        // Initialise all resources (do this AFTER the renderer has been loaded!)
+        // Note: You can only do this once! Ogre will check whether a resource group has
+        // already been initialised. If you need to load resources later, you will have to
+        // choose another resource group.
+        Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
+    }
+    /**
+    @brief
+        Creates the Ogre Root object and sets up the ogre log.
+    */
+    void GraphicsManager::loadOgreRoot()
+    {
+        COUT(3) << "Setting up Ogre..." << std::endl;
+        if (ogreConfigFile_ == "")
+        {
+            COUT(2) << "Warning: Ogre config file set to \"\". Defaulting to config.cfg" << std::endl;
+            ModifyConfigValue(ogreConfigFile_, tset, "config.cfg");
+        }
+        if (ogreLogFile_ == "")
+        {
+            COUT(2) << "Warning: Ogre log file set to \"\". Defaulting to ogre.log" << std::endl;
+            ModifyConfigValue(ogreLogFile_, tset, "ogre.log");
+        }
+        boost::filesystem::path ogreConfigFilepath(Core::getConfigPath() / this->ogreConfigFile_);
+        boost::filesystem::path ogreLogFilepath(Core::getLogPath() / this->ogreLogFile_);
+        // create a new logManager
+        // Ogre::Root will detect that we've already created a Log
+        ogreLogger_.reset(new Ogre::LogManager());
+        COUT(4) << "Ogre LogManager created" << std::endl;
+        // create our own log that we can listen to
+        Ogre::Log *myLog;
+        myLog = ogreLogger_->createLog(ogreLogFilepath.string(), true, false, false);
+        COUT(4) << "Ogre Log created" << std::endl;
+        myLog->setLogDetail(Ogre::LL_BOREME);
+        myLog->addListener(this);
+        COUT(4) << "Creating Ogre Root..." << std::endl;
+        // check for config file existence because Ogre displays (caught) exceptions if not
+        if (!boost::filesystem::exists(ogreConfigFilepath))
+        {
+            // create a zero sized file
+            std::ofstream creator;
+            creator.open(ogreConfigFilepath.string().c_str());
+            creator.close();
+        }
+        // Leave plugins file empty. We're going to do that part manually later
+        ogreRoot_.reset(new Ogre::Root("", ogreConfigFilepath.string(), ogreLogFilepath.string()));
+        COUT(3) << "Ogre set up done." << std::endl;
+    }
+    void GraphicsManager::loadOgrePlugins()
+    {
+        // just to make sure the next statement doesn't segfault
+        if (ogrePluginsDirectory_ == "")
+            ogrePluginsDirectory_ = ".";
+        boost::filesystem::path folder(ogrePluginsDirectory_);
+        // Do some SubString magic to get the comma separated list of plugins
+        SubString plugins(ogrePlugins_, ",", " ", false, '\\', false, '"', false, '(', ')', false, '\0');
+        // Use backslash paths on Windows! file_string() already does that though.
+        for (unsigned int i = 0; i < plugins.size(); ++i)
+            ogreRoot_->loadPlugin((folder / plugins[i]).file_string());
+    }
+    void GraphicsManager::loadRenderer()
+    {
+        CCOUT(4) << "Configuring Renderer" << std::endl;
+        if (!ogreRoot_->restoreConfig())
+            if (!ogreRoot_->showConfigDialog())
+                ThrowException(InitialisationFailed, "OGRE graphics configuration dialogue failed.");
+        CCOUT(4) << "Creating render window" << std::endl;
+        this->renderWindow_ = ogreRoot_->initialise(true, "Orxonox");
+        // Propagate the size of the new winodw
+        this->ogreWindowEventListener_->windowResized(renderWindow_);
+        Ogre::WindowEventUtilities::addWindowEventListener(this->renderWindow_, ogreWindowEventListener_.get());
+        // create a full screen default viewport
+        // Note: This may throw when adding a viewport with an existing z-order!
+        //       But in our case we only have one viewport for now anyway, therefore
+        //       no ScopeGuards or anything to handle exceptions.
+        this->viewport_ = this->renderWindow_->addViewport(0, 0);
+        Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(0);
+        // add console commands
+        FunctorMember<GraphicsManager>* functor1 = createFunctor(&GraphicsManager::printScreen);
+        ccPrintScreen_ = createConsoleCommand(functor1->setObject(this), "printScreen");
+        CommandExecutor::addConsoleCommandShortcut(ccPrintScreen_);
+    }
     void GraphicsManager::update(const Clock& time)
+    {
 …
+    {
         this->viewport_->setCamera(camera);
+    }
-    /**
-    @brief
-        Creates the Ogre Root object and sets up the ogre log.
-    */
-    void GraphicsManager::setupOgre()
+    {
-        COUT(3) << "Setting up Ogre..." << std::endl;
-        if (ogreConfigFile_ == "")
+        {
-            COUT(2) << "Warning: Ogre config file set to \"\". Defaulting to config.cfg" << std::endl;
-            ModifyConfigValue(ogreConfigFile_, tset, "config.cfg");
+        }
-        if (ogreLogFile_ == "")
+        {
-            COUT(2) << "Warning: Ogre log file set to \"\". Defaulting to ogre.log" << std::endl;
-            ModifyConfigValue(ogreLogFile_, tset, "ogre.log");
+        }
-        boost::filesystem::path ogreConfigFilepath(Core::getConfigPath() / this->ogreConfigFile_);
-        boost::filesystem::path ogreLogFilepath(Core::getLogPath() / this->ogreLogFile_);
-        // create a new logManager
-        // Ogre::Root will detect that we've already created a Log
-        std::auto_ptr<Ogre::LogManager> logger(new Ogre::LogManager());
-        COUT(4) << "Ogre LogManager created" << std::endl;
-        // create our own log that we can listen to
-        Ogre::Log *myLog;
-        myLog = logger->createLog(ogreLogFilepath.string(), true, false, false);
-        COUT(4) << "Ogre Log created" << std::endl;
-        myLog->setLogDetail(Ogre::LL_BOREME);
-        myLog->addListener(this);
-        COUT(4) << "Creating Ogre Root..." << std::endl;
-        // check for config file existence because Ogre displays (caught) exceptions if not
-        if (!boost::filesystem::exists(ogreConfigFilepath))
+        {
-            // create a zero sized file
-            std::ofstream creator;
-            creator.open(ogreConfigFilepath.string().c_str());
-            creator.close();
+        }
-        // Leave plugins file empty. We're going to do that part manually later
-        ogreRoot_ = new Ogre::Root("", ogreConfigFilepath.string(), ogreLogFilepath.string());
-        // In case that new Root failed the logger gets destroyed because of the std::auto_ptr
-        ogreLogger_ = logger.release();
-        COUT(3) << "Ogre set up done." << std::endl;
+    }
-    void GraphicsManager::loadOgrePlugins()
+    {
-        // just to make sure the next statement doesn't segfault
-        if (ogrePluginsFolder_ == "")
-            ogrePluginsFolder_ = ".";
-        boost::filesystem::path folder(ogrePluginsFolder_);
-        // Do some SubString magic to get the comma separated list of plugins
-        SubString plugins(ogrePlugins_, ",", " ", false, '\\', false, '"', false, '(', ')', false, '\0');
-        // Use backslash paths on Windows! file_string() already does that though.
-        for (unsigned int i = 0; i < plugins.size(); ++i)
-            ogreRoot_->loadPlugin((folder / plugins[i]).file_string());
+    }
-    void GraphicsManager::declareResources()
+    {
-        CCOUT(4) << "Declaring Resources" << std::endl;
-        //TODO: Specify layout of data file and maybe use xml-loader
-        //TODO: Work with ressource groups (should be generated by a special loader)
-        if (resourceFile_ == "")
+        {
-            COUT(2) << "Warning: Ogre resource file set to \"\". Defaulting to resources.cfg" << std::endl;
-            ModifyConfigValue(resourceFile_, tset, "resources.cfg");
+        }
-        // Load resource paths from data file using configfile ressource type
-        Ogre::ConfigFile cf;
-        try
+        {
-            cf.load((Core::getMediaPath() / resourceFile_).string());
+        }
-        catch (...)
+        {
-            //COUT(1) << ex.getFullDescription() << std::endl;
-            COUT(0) << "Have you forgotten to set the data path in orxnox.ini?" << std::endl;
-            throw;
+        }
-        // Go through all sections & settings in the file
-        Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
-        std::string secName, typeName, archName;
-        while (seci.hasMoreElements())
+        {
-            try
+            {
-                secName = seci.peekNextKey();
-                Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
-                Ogre::ConfigFile::SettingsMultiMap::iterator i;
-                for (i = settings->begin(); i != settings->end(); ++i)
+                {
-                    typeName = i->first; // for instance "FileSystem" or "Zip"
-                    archName = i->second; // name (and location) of archive
-                    Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
-                        (Core::getMediaPath() / archName).string(), typeName, secName);
+                }
+            }
-            catch (Ogre::Exception& ex)
+            {
-                COUT(1) << ex.getFullDescription() << std::endl;
+            }
+        }
+    }
-    void GraphicsManager::loadRenderer()
+    {
-        CCOUT(4) << "Configuring Renderer" << std::endl;
-        if (!ogreRoot_->restoreConfig())
-            if (!ogreRoot_->showConfigDialog())
-                ThrowException(InitialisationFailed, "OGRE graphics configuration dialogue failed.");
-        CCOUT(4) << "Creating render window" << std::endl;
-        this->renderWindow_ = ogreRoot_->initialise(true, "Orxonox");
-        this->ogreWindowEventListener_->windowResized(renderWindow_);
-        Ogre::WindowEventUtilities::addWindowEventListener(this->renderWindow_, ogreWindowEventListener_);
-        Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(0);
-        // create a full screen default viewport
-        this->viewport_ = this->renderWindow_->addViewport(0, 0);
+    }
-    void GraphicsManager::initialiseResources()
+    {
-        CCOUT(4) << "Initialising resources" << std::endl;
-        //TODO: Do NOT load all the groups, why are we doing that? And do we really do that? initialise != load...
-        //try
-        //{
-            Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
-            /*Ogre::StringVector str = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
-            for (unsigned int i = 0; i < str.size(); i++)
+            {
-            Ogre::ResourceGroupManager::getSingleton().loadResourceGroup(str[i]);
-            }*/
-        //}
-        //catch (...)
-        //{
-        //    CCOUT(2) << "Error: There was a serious error when initialising the resources." << std::endl;
-        //    throw;
-        //}
+    }
 …
+    }
+    size_t GraphicsManager::getRenderWindowHandle()
+    {
+        size_t windowHnd = 0;
+        renderWindow_->getCustomAttribute("WINDOW", &windowHnd);
+        return windowHnd;
+    }
+    bool GraphicsManager::isFullScreen() const
+    {
+        Ogre::ConfigOptionMap& options = ogreRoot_->getRenderSystem()->getConfigOptions();
+        if (options.find("Full Screen") != options.end())
+        {
+            if (options["Full Screen"].currentValue == "Yes")
+                return true;
+            else
+                return false;
+        }
+        else
+        {
+            COUT(0) << "Could not find 'Full Screen' render system option. Fix This!!!" << std::endl;
+            return false;
+        }
+    }
     void GraphicsManager::printScreen()
+    {

code/trunk/src/core/GraphicsManager.h

-                      r3370
+                      r5695
 #include <string>
 #include <OgreLog.h>
+#include <boost/scoped_ptr.hpp>
+#include <boost/shared_ptr.hpp>
 #include "util/Singleton.h"
 #include "OrxonoxClass.h"
 …
         friend class Singleton<GraphicsManager>;
     public:
         GraphicsManager();
+        GraphicsManager(bool bLoadRenderer = true);
         ~GraphicsManager();
 …
         void update(const Clock& time);
+        inline Ogre::Viewport* getViewport()
+            { return this->viewport_; }
+        inline Ogre::RenderWindow* getRenderWindow()
+            { return this->renderWindow_; }
+        Ogre::Viewport* getViewport()         { return this->viewport_; }
+        Ogre::RenderWindow* getRenderWindow() { return this->renderWindow_; }
+        size_t getRenderWindowHandle();
+        bool isFullScreen() const;
+        void upgradeToGraphics();
+        bool rendererLoaded() const { return renderWindow_ != NULL; }
         void setCamera(Ogre::Camera* camera);
 …
         // OGRE initialisation
         void setupOgre();
+        void loadOgreRoot();
         void loadOgrePlugins();
-        void declareResources();
         void loadRenderer();
-        void initialiseResources();
         // event from Ogre::LogListener
 …
         void printScreen();
+    private:
+        Ogre::Root*         ogreRoot_;                 //!< Ogre's root
+        Ogre::LogManager*   ogreLogger_;
+        scoped_ptr<OgreWindowEventListener> ogreWindowEventListener_; //!< Pimpl to hide OgreWindowUtilities.h
+#if OGRE_VERSION < 0x010600
+        scoped_ptr<MemoryArchiveFactory>    memoryArchiveFactory_;    //!< Stores the modified particle scripts
+#endif
+        scoped_ptr<Ogre::LogManager>        ogreLogger_;
+        scoped_ptr<Ogre::Root>              ogreRoot_;                //!< Ogre's root
         Ogre::RenderWindow* renderWindow_;             //!< the one and only render window
         Ogre::Viewport*     viewport_;                 //!< default full size viewport
+        OgreWindowEventListener* ogreWindowEventListener_; //!< Pimpl to hide OgreWindowUtilities.h
+        // XML files for the resources
+        shared_ptr<XMLFile> resources_;                //!< XML with resource locations
+        shared_ptr<XMLFile> extResources_;             //!< XML with resource locations in the external path (only for dev runs)
         // config values
-        std::string         resourceFile_;             //!< resources file name
         std::string         ogreConfigFile_;           //!< ogre config file name
         std::string         ogrePluginsFolder_;        //!< Folder where the Ogre plugins are located
+        std::string         ogrePluginsDirectory_;     //!< Directory where the Ogre plugins are located
         std::string         ogrePlugins_;              //!< Comma separated list of all plugins to load
         std::string         ogreLogFile_;              //!< log file name for Ogre log messages

code/trunk/src/core/Identifier.cc

r3325	r5695
138	138	if (!this->bCreatedOneObject_ && Identifier::isCreatingHierarchy())
139	139	{
140		// If no: We have to store the informations and initialize the Identifier
	140	// If no: We have to store the information and initialize the Identifier
141	141	COUT(4) << "*** ClassIdentifier: Register Class in " << this->getName() << "-Singleton -> Initialize Singleton." << std::endl;
142	142	if (bRootClass)

code/trunk/src/core/Identifier.h

-                      r3370
+                      r5695
     @brief Definition of the Identifier, ClassIdentifier and SubclassIdentifier classes, implementation of the ClassIdentifier and SubclassIdentifier classes.
     The Identifier contains all needed informations about the class it belongs to:
+    The Identifier contains all needed information about the class it belongs to:
      - the name
      - a list with all objects
 …
     // ###       Identifier        ###
     // ###############################
     //! The Identifier is used to identify the class of an object and to store informations about the class.
     /**
         The Identifier contains all needed informations about the class it belongs to:
+    //! The Identifier is used to identify the class of an object and to store information about the class.
+    /**
+        The Identifier contains all needed information about the class it belongs to:
          - the name
          - a list with all objects
 …
     /**
         ClassIdentifier is a Singleton, which means that only one object of a given type T exists.
         This makes it possible to store informations about a class, sharing them with all
+        This makes it possible to store information about a class, sharing them with all
         objects of that class without defining static variables in every class.

code/trunk/src/core/Loader.cc

-                      r3370
+                      r5695
 #include "Loader.h"
+#include <sstream>
 #include <tinyxml/ticpp.h>
+#include <boost/scoped_ptr.hpp>
 #include "util/Debug.h"
 #include "util/Exception.h"
+#include "util/StringUtils.h"
 #include "BaseObject.h"
 #include "Iterator.h"
 #include "ObjectList.h"
 #include "LuaBind.h"
+#include "LuaState.h"
 #include "Namespace.h"
+#include "Resource.h"
 #include "XMLFile.h"
 …
         Loader::currentMask_s = file->getMask() * mask;
+        // let Lua work this out:
+        LuaBind& lua = LuaBind::getInstance();
+        lua.clearLuaOutput();
+        lua.loadFile(file->getFilename(), true);
+        lua.run();
+        std::string xmlInput;
+        if (file->getLuaSupport())
+        {
+            // Use the LuaState to replace the XML tags (calls our function)
+            scoped_ptr<LuaState> luaState(new LuaState());
+            luaState->setIncludeParser(&Loader::replaceLuaTags);
+            luaState->includeFile(file->getFilename(), file->getResourceGroup(), false);
+            xmlInput = luaState->getOutput().str();
+        }
+        else
+        {
+            shared_ptr<ResourceInfo> info = Resource::getInfo(file->getFilename(), file->getResourceGroup());
+            if (info == NULL)
+            {
+                COUT(1) << "Error: Could not find XML file '" << file->getFilename() << "'." << std::endl;
+                return false;
+            }
+            xmlInput = Resource::open(file->getFilename(), file->getResourceGroup())->getAsString();
+        }
         try
 …
             COUT(3) << "Mask: " << Loader::currentMask_s << std::endl;
+            //ticpp::Document xmlfile(file->getFilename());
+            //xmlfile.LoadFile();
+            //ticpp::Element myelement(*Script::getFileString());
+            ticpp::Document xmlfile;
+            //xmlfile.ToDocument();
+            xmlfile.Parse(lua.getLuaOutput(), true);
+            ticpp::Document xmlfile(file->getFilename());
+            xmlfile.Parse(xmlInput, true);
             ticpp::Element rootElement;
 …
         return Loader::load(file, mask);
+    }
+    std::string Loader::replaceLuaTags(const std::string& text)
+    {
+        // chreate map with all Lua tags
+        std::map<size_t, bool> luaTags;
+        {
+            size_t pos = 0;
+            while ((pos = text.find("<?lua", pos)) != std::string::npos)
+                luaTags[pos++] = true;
+        }
+        {
+            size_t pos = 0;
+            while ((pos = text.find("?>", pos)) != std::string::npos)
+                luaTags[pos++] = false;
+        }
+        // erase all tags from the map that are between two quotes
+        {
+            std::map<size_t, bool>::iterator it = luaTags.begin();
+            std::map<size_t, bool>::iterator it2 = it;
+            bool bBetweenQuotes = false;
+            size_t pos = 0;
+            while ((pos = getNextQuote(text, pos)) != std::string::npos)
+            {
+                while ((it != luaTags.end()) && (it->first < pos))
+                {
+                    if (bBetweenQuotes)
+                    {
+                        it2++;
+                        if(it->second && !(it2->second) && it2->first < pos)
+                            it = ++it2;
+                        else
+                            luaTags.erase(it++);
+                    }
+                    else
+                        ++it;
+                }
+                bBetweenQuotes = !bBetweenQuotes;
+                pos++;
+            }
+        }
+        // check whether on every opening <?lua tag a closing ?> tag follows
+        {
+            bool expectedValue = true;
+            for (std::map<size_t, bool>::iterator it = luaTags.begin(); it != luaTags.end(); ++it)
+            {
+                if (it->second == expectedValue)
+                    expectedValue = !expectedValue;
+                else
+                {
+                    expectedValue = false;
+                    break;
+                }
+            }
+            if (!expectedValue)
+            {
+                COUT(2) << "Warning: Error in level file" << std::endl;
+                // todo: errorhandling
+                return "";
+            }
+        }
+        // Use a stringstream object to speed up the parsing
+        std::ostringstream output;
+        // cut the original string into pieces and put them together with print() instead of lua tags
+        {
+            std::map<size_t, bool>::iterator it = luaTags.begin();
+            bool bInPrintFunction = true;
+            size_t start = 0;
+            size_t end = 0;
+            do
+            {
+                if (it != luaTags.end())
+                    end = (*(it++)).first;
+                else
+                    end = std::string::npos;
+                unsigned int equalSignCounter = 0;
+                if (bInPrintFunction)
+                {
+                    // count ['='[ and ]'='] and replace tags with print([[ and ]])
+                    std::string temp = text.substr(start, end - start);
+                    {
+                    size_t pos = 0;
+                    while ((pos = temp.find('[', pos)) != std::string::npos)
+                    {
+                        unsigned int tempCounter = 1;
+                        size_t tempPos = pos++;
+                        while(temp[++tempPos] == '=')
+                        {
+                            tempCounter++;
+                        }
+                        if(temp[tempPos] != '[')
+                        {
+                            tempCounter = 0;
+                        }
+                        else if(tempCounter == 0)
+                        {
+                            tempCounter = 1;
+                        }
+                        if (tempCounter > equalSignCounter)
+                            equalSignCounter = tempCounter;
+                        }
+                    }
+                    {
+                        size_t pos = 0;
+                        while ((pos = temp.find(']', pos)) != std::string::npos)
+                        {
+                            unsigned int tempCounter = 1;
+                            size_t tempPos = pos++;
+                            while(temp[++tempPos] == '=')
+                            {
+                                tempCounter++;
+                            }
+                            if(temp[tempPos] != ']')
+                            {
+                                tempCounter = 0;
+                            }
+                            else if(tempCounter == 0)
+                            {
+                                tempCounter = 1;
+                            }
+                            if (tempCounter > equalSignCounter)
+                                equalSignCounter = tempCounter;
+                        }
+                    }
+                    std::string equalSigns = "";
+                    for(unsigned int i = 0; i < equalSignCounter; i++)
+                    {
+                        equalSigns += "=";
+                    }
+                    output << "print([" + equalSigns + "[" + temp + "]" + equalSigns +"])";
+                    start = end + 5;
+                }
+                else
+                {
+                    output << text.substr(start, end - start);
+                    start = end + 2;
+                }
+                bInPrintFunction = !bInPrintFunction;
+            }
+            while (end != std::string::npos);
+        }
+        return output.str();
+    }
+}

code/trunk/src/core/Loader.h

r3370	r5695
55	55	static bool reload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
56	56
	57	static std::string replaceLuaTags(const std::string& text);
	58
57	59	static ClassTreeMask currentMask_s;
58	60

code/trunk/src/core/TclBind.cc

r3370	r5695
127	127	#ifdef DEPENDENCY_PACKAGE_ENABLE
128	128	if (Core::isDevelopmentRun())
129		return (std::string(~~ORXONOX_DEP_LIB_PATH~~) + "/tcl");
	129	return (std::string(specialConfig::dependencyLibraryDirectory) + "/tcl");
130	130	else
131	131	return (Core::getRootPathString() + "lib/tcl");

code/trunk/src/core/TclThreadManager.cc

r3370	r5695
57	57
58	58	/**
59		@brief A struct containing all informations about a Tcl-interpreter
	59	@brief A struct containing all information about a Tcl-interpreter
60	60	*/
61	61	struct TclInterpreterBundle

code/trunk/src/core/XMLFile.h

-                      r3196
+                      r5695
+    {
         public:
+            XMLFile(const std::string& filename) : filename_(filename) {}
+            XMLFile(const std::string& filename, const ClassTreeMask& mask) : filename_(filename), mask_(mask) {};
+            XMLFile(const std::string& filename, const std::string& resourceGroup = "General")
+                : filename_(filename)
+                , group_(resourceGroup)
+                , bLuaSupport_(true)
+            { }
+            XMLFile(const ClassTreeMask& mask, const std::string& filename, const std::string& resourceGroup = "General")
+                : filename_(filename)
+                , group_(resourceGroup)
+                , mask_(mask)
+                , bLuaSupport_(true)
+            { }
+            void setLuaSupport(bool val) { bLuaSupport_ = val; }
             const std::string& getFilename() const { return this->filename_; }
+            const std::string& getResourceGroup() const { return this->group_; }
             const ClassTreeMask& getMask() const { return this->mask_; }
+            bool getLuaSupport() const { return this->bLuaSupport_; }
         private:
             std::string filename_;
+            std::string group_;
             ClassTreeMask mask_;
+            bool bLuaSupport_; // Default is true
     };
+}

code/trunk/src/core/input/Button.cc

r3327	r5695
59	59	nCommands_[1]=0;
60	60	nCommands_[2]=0;
61		~~this->configContainer_ = 0;~~
62	61	}
63	62

code/trunk/src/core/input/InputManager.cc

-                      r3370
+                      r5695
 #include <boost/foreach.hpp>
+#include "util/Convert.h"
 #include "util/Exception.h"
 #include "util/ScopeGuard.h"
 …
 #include "core/CommandLine.h"
 #include "core/Functor.h"
+#include "core/GraphicsManager.h"
 #include "InputBuffer.h"
 …
     // ##########                                        ##########
     // ############################################################
     InputManager::InputManager(size_t windowHnd)
+    InputManager::InputManager()
         : internalState_(Bad)
         , oisInputManager_(0)
         , devices_(2)
         , windowHnd_(0)
+        , bExclusiveMouse_(false)
         , emptyState_(0)
         , keyDetector_(0)
 …
         this->setConfigValues();
         this->loadDevices(windowHnd);
+        this->loadDevices();
         // Lowest priority empty InputState
 …
         Creates the OIS::InputMananger, the keyboard, the mouse and
         the joys ticks. If either of the first two fail, this method throws an exception.
-    @param windowHnd
-        The window handle of the render window
     @param windowWidth
         The width of the render window
 …
         The height of the render window
     */
     void InputManager::loadDevices(size_t windowHnd)
+    {
         CCOUT(3) << "Loading input devices..." << std::endl;
+    void InputManager::loadDevices()
+    {
+        CCOUT(4) << "Loading input devices..." << std::endl;
         // When loading the devices they should not already be loaded
 …
         assert(devices_.size() == InputDeviceEnumerator::FirstJoyStick);
+        // store handle internally so we can reload OIS
+        windowHnd_ = windowHnd;
+        // Fill parameter list
         OIS::ParamList paramList;
+        std::ostringstream windowHndStr;
+        // Fill parameter list
+        windowHndStr << static_cast<unsigned int>(windowHnd);
+        paramList.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
+        size_t windowHnd = GraphicsManager::getInstance().getRenderWindowHandle();
+        paramList.insert(std::make_pair("WINDOW", multi_cast<std::string>(windowHnd)));
 #if defined(ORXONOX_PLATFORM_WINDOWS)
+        //paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_NONEXCLUSIVE")));
+        //paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND")));
+        //paramList.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_NONEXCLUSIVE")));
+        //paramList.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_FOREGROUND")));
+        paramList.insert(std::make_pair("w32_keyboard", "DISCL_NONEXCLUSIVE"));
+        paramList.insert(std::make_pair("w32_keyboard", "DISCL_FOREGROUND"));
+        paramList.insert(std::make_pair("w32_mouse", "DISCL_FOREGROUND"));
+        if (bExclusiveMouse_ || GraphicsManager::getInstance().isFullScreen())
+        {
+            // Disable Windows key plus special keys (like play, stop, next, etc.)
+            paramList.insert(std::make_pair("w32_keyboard", "DISCL_NOWINKEY"));
+            paramList.insert(std::make_pair("w32_mouse", "DISCL_EXCLUSIVE"));
+        }
+        else
+            paramList.insert(std::make_pair("w32_mouse", "DISCL_NONEXCLUSIVE"));
 #elif defined(ORXONOX_PLATFORM_LINUX)
+        paramList.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
+        paramList.insert(std::make_pair(std::string("x11_mouse_grab"), "true"));
+        paramList.insert(std::make_pair(std::string("x11_mouse_hide"), "true"));
+        bool kbNoGrab;
+        CommandLine::getValue("keyboard_no_grab", &kbNoGrab);
+        if (kbNoGrab)
+            paramList.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("false")));
+        // Enabling this is probably a bad idea, but whenever orxonox crashes, the setting stays on
+        // Trouble might be that the Pressed event occurs a bit too often...
+        paramList.insert(std::make_pair("XAutoRepeatOn", "true"));
+        if (bExclusiveMouse_ || GraphicsManager::getInstance().isFullScreen())
+        {
+            if (CommandLine::getValue("keyboard_no_grab").getBool())
+                paramList.insert(std::make_pair("x11_keyboard_grab", "false"));
+            else
+                paramList.insert(std::make_pair("x11_keyboard_grab", "true"));
+            paramList.insert(std::make_pair("x11_mouse_grab",  "true"));
+            paramList.insert(std::make_pair("x11_mouse_hide", "true"));
+        }
         else
+            paramList.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("true")));
+        {
+            paramList.insert(std::make_pair("x11_keyboard_grab", "false"));
+            paramList.insert(std::make_pair("x11_mouse_grab",  "false"));
+            paramList.insert(std::make_pair("x11_mouse_hide", "false"));
+        }
 #endif
 …
+        }
-        // TODO: Remove the two parameters
         this->loadMouse();
         this->loadJoySticks();
 …
         this->updateActiveStates();
         CCOUT(3) << "Input devices loaded." << std::endl;
+        CCOUT(4) << "Input devices loaded." << std::endl;
+    }
 …
     InputManager::~InputManager()
+    {
         CCOUT(4) << "Destroying..." << std::endl;
+        CCOUT(3) << "Destroying..." << std::endl;
         // Destroy calibrator helper handler and state
 …
             this->destroyDevices();
         CCOUT(4) << "Destruction complete." << std::endl;
+        CCOUT(3) << "Destruction complete." << std::endl;
+    }
 …
     void InputManager::destroyDevices()
+    {
         CCOUT(3) << "Destroying devices..." << std::endl;
+        CCOUT(4) << "Destroying devices..." << std::endl;
         BOOST_FOREACH(InputDevice*& device, devices_)
 …
         internalState_ |= Bad;
         CCOUT(3) << "Destroyed devices." << std::endl;
+        CCOUT(4) << "Destroyed devices." << std::endl;
+    }
 …
         this->destroyDevices();
         this->loadDevices(windowHnd_);
+        this->loadDevices();
         internalState_ &= ~Bad;
         internalState_ &= ~ReloadRequest;
         CCOUT(3) << "Reloading complete." << std::endl;
+        CCOUT(4) << "Reloading complete." << std::endl;
+    }
 …
     void InputManager::updateActiveStates()
+    {
+        assert((internalState_ & InputManager::Ticking) == 0);
         // temporary resize
         for (unsigned int i = 0; i < devices_.size(); ++i)
 …
         for (std::set<InputState*>::const_iterator it = tempSet.begin();it != tempSet.end(); ++it)
             activeStatesTicked_.push_back(*it);
+        // Check whether we have to change the mouse mode
+        std::vector<InputState*>& mouseStates = devices_[InputDeviceEnumerator::Mouse]->getStateListRef();
+        if (mouseStates.empty() && bExclusiveMouse_ ||
+            !mouseStates.empty() && mouseStates.front()->getIsExclusiveMouse() != bExclusiveMouse_)
+        {
+            bExclusiveMouse_ = !bExclusiveMouse_;
+            if (!GraphicsManager::getInstance().isFullScreen())
+                this->reloadInternal();
+        }
+    }
 …
+    }
+    // ############################################################
+    // #####                    Iput States                   #####
+    std::pair<int, int> InputManager::getMousePosition() const
+    {
+        Mouse* mouse = static_cast<Mouse*>(devices_[InputDeviceEnumerator::Mouse]);
+        if (mouse != NULL)
+        {
+            const OIS::MouseState state = mouse->getOISDevice()->getMouseState();
+            return std::make_pair(state.X.abs, state.Y.abs);
+        }
+        else
+            return std::make_pair(0, 0);
+    }
+    // ############################################################
+    // #####                    Input States                  #####
     // ##########                                        ##########
     // ############################################################

code/trunk/src/core/input/InputManager.h

-                      r3370
+                      r5695
             the constructor fails with an std::exception.
         */
         InputManager(size_t windowHnd);
+        InputManager();
         //! Destroys all devices AND all input states!
         ~InputManager();
 …
             { return devices_.size() - InputDeviceEnumerator::FirstJoyStick; }
         //! Returns a pointer to the OIS InputManager. Only you if you know what you're doing!
         OIS::InputManager* getOISInputManager()
             { return this->oisInputManager_; }
+        OIS::InputManager* getOISInputManager() { return this->oisInputManager_; }
+        std::pair<int, int> getMousePosition() const;
     private: // functions
 …
         // Intenal methods
         void loadDevices(size_t windowHnd);
+        void loadDevices();
         void loadMouse();
         void loadJoySticks();
 …
         OIS::InputManager*                  oisInputManager_;      //!< OIS input manager
         std::vector<InputDevice*>           devices_;              //!< List of all input devices (keyboard, mouse, joy sticks)
+        // TODO: Get this from the GraphicsManager during reload
+        size_t                              windowHnd_;            //!< Render window handle (used to reload the InputManager)
+        bool                                bExclusiveMouse_;      //!< Currently applied mouse mode
         // some internally handled states and handlers

code/trunk/src/core/input/InputState.cc

r3327	r5695
37	37	, bAlwaysGetsInput_(bAlwaysGetsInput)
38	38	, bTransparent_(bTransparent)
	39	, bExclusiveMouse_(true)
39	40	, bExpired_(true)
40	41	, handlers_(2)

code/trunk/src/core/input/InputState.h

-                      r3327
+                      r5695
           not influence ony other InputState at all.
+        Priorities
+        **********
+    @par Priorities
         Every InputState has a priority when on the stack, but mostly this
         priority is dynamic (InputStatePriority::Dynamic) which means that a state
 …
         a high priority (InputStatePriority::HighPriority). These 'special' ones
         are used for features like the KeyDetector or the console. Use with care!
+    @par Exclusive/Non-Exclusive mouse Mode
+        You can select a specific mouse mode that tells whether the application
+        should have exclusive accessto it or not.
+        When in non-exclusive mode, you can move the mouse out of the window
+        like with any other normal window (only for windowed mode!).
+        The setting is dictated by the topmost InputState that gets mouse events.
     */
     class _CoreExport InputState : public JoyStickQuantityListener
 …
         void setHandler        (InputHandler* handler);
+        void setIsExclusiveMouse(bool value) { bExclusiveMouse_ = value; this->bExpired_ = true; }
+        bool getIsExclusiveMouse() const { return bExclusiveMouse_; }
         //! Returns the name of the state (which is unique!)
         const std::string& getName() const { return name_; }
 …
         const bool                  bAlwaysGetsInput_;      //!< See class declaration for explanation
         const bool                  bTransparent_;          //!< See class declaration for explanation
+        bool                        bExclusiveMouse_;       //!< See class declaration for explanation
         int                         priority_;              //!< Current priority (might change)
         bool                        bExpired_;              //!< See hasExpired()

code/trunk/src/core/input/KeyBinder.cc

r3327	r5695
55	55	mousePosition_[0] = 0;
56	56	mousePosition_[1] = 0;
57
58		~~joyStickButtons_.reserve(1000);~~
59		~~joyStickAxes_.reserve(1000);~~
60	57
61	58	RegisterRootObject(KeyBinder);
…	…
167	164	{
168	165	for (unsigned int i = 0; i < JoyStickButtonCode::numberOfButtons; ++i)
169		~~joyStickButtons_[iDev]~~[i].readConfigValue(this->configFile_);
	166	(*joyStickButtons_[iDev])[i].readConfigValue(this->configFile_);
170	167	for (unsigned int i = 0; i < JoyStickAxisCode::numberOfAxes * 2; ++i)
171		~~joyStickAxes_[iDev]~~[i].readConfigValue(this->configFile_);
	168	(*joyStickAxes_[iDev])[i].readConfigValue(this->configFile_);
172	169	}
173	170	}
…	…
179	176	void KeyBinder::initialiseJoyStickBindings()
180	177	{
	178	while (joyStickAxes_.size() < joySticks_.size())
	179	joyStickAxes_.push_back(shared_ptr<JoyStickAxisVector>(new JoyStickAxisVector()));
	180	while (joyStickButtons_.size() < joySticks_.size())
	181	joyStickButtons_.push_back(shared_ptr<JoyStickButtonVector>(new JoyStickButtonVector()));
	182	// For the case the new size is smaller
181	183	this->joyStickAxes_.resize(joySticks_.size());
182	184	this->joyStickButtons_.resize(joySticks_.size());
…	…
189	191	for (unsigned int i = 0; i < JoyStickButtonCode::numberOfButtons; i++)
190	192	{
191		~~joyStickButtons_[iDev]~~[i].name_ = JoyStickButtonCode::ByString[i];
192		~~joyStickButtons_[iDev]~~[i].paramCommandBuffer_ = &paramCommandBuffer_;
193		~~joyStickButtons_[iDev]~~[i].groupName_ = "JoyStickButtons_" + deviceName;
	193	(*joyStickButtons_[iDev])[i].name_ = JoyStickButtonCode::ByString[i];
	194	(*joyStickButtons_[iDev])[i].paramCommandBuffer_ = &paramCommandBuffer_;
	195	(*joyStickButtons_[iDev])[i].groupName_ = "JoyStickButtons_" + deviceName;
194	196	}
195	197	// joy stick axes
196	198	for (unsigned int i = 0; i < JoyStickAxisCode::numberOfAxes * 2; i++)
197	199	{
198		~~joyStickAxes_[iDev]~~[i].name_ = JoyStickAxisCode::ByString[i / 2];
	200	(*joyStickAxes_[iDev])[i].name_ = JoyStickAxisCode::ByString[i / 2];
199	201	if (i & 1)
200		~~joyStickAxes_[iDev]~~[i].name_ += "Pos";
	202	(*joyStickAxes_[iDev])[i].name_ += "Pos";
201	203	else
202		~~joyStickAxes_[iDev]~~[i].name_ += "Neg";
203		~~joyStickAxes_[iDev]~~[i].paramCommandBuffer_ = &paramCommandBuffer_;
204		~~joyStickAxes_[iDev]~~[i].groupName_ = "JoyStickAxes_" + deviceName;
	204	(*joyStickAxes_[iDev])[i].name_ += "Neg";
	205	(*joyStickAxes_[iDev])[i].paramCommandBuffer_ = &paramCommandBuffer_;
	206	(*joyStickAxes_[iDev])[i].groupName_ = "JoyStickAxes_" + deviceName;
205	207	}
206	208	}
…	…
226	228	{
227	229	for (unsigned int i = 0; i < JoyStickButtonCode::numberOfButtons; i++)
228		allButtons_[~~joyStickButtons_[iDev][i].groupName_ + "." + joyStickButtons_[iDev][i].name_] = &(joyStickButtons_[iDev]~~[i]);
	230	allButtons_[(joyStickButtons_[iDev])[i].groupName_ + "." + (joyStickButtons_[iDev])[i].name_] = &((*joyStickButtons_[iDev])[i]);
229	231	for (unsigned int i = 0; i < JoyStickAxisCode::numberOfAxes * 2; i++)
230	232	{
231		allButtons_[~~joyStickAxes_[iDev][i].groupName_ + "." + joyStickAxes_[iDev][i].name_] = &(joyStickAxes_[iDev]~~[i]);
232		allHalfAxes_.push_back(&(~~joyStickAxes_[iDev]~~[i]));
	233	allButtons_[(joyStickAxes_[iDev])[i].groupName_ + "." + (joyStickAxes_[iDev])[i].name_] = &((*joyStickAxes_[iDev])[i]);
	234	allHalfAxes_.push_back(&((*joyStickAxes_[iDev])[i]));
233	235	}
234	236	}
…	…
303	305	for (unsigned int i = 0; i < JoyStickAxisCode::numberOfAxes * 2; i++)
304	306	{
305		~~joyStickAxes_[iDev]~~[i].absVal_ = 0.0f;
306		~~joyStickAxes_[iDev]~~[i].relVal_ = 0.0f;
	307	(*joyStickAxes_[iDev])[i].absVal_ = 0.0f;
	308	(*joyStickAxes_[iDev])[i].relVal_ = 0.0f;
307	309	}
308	310	}
…	…
366	368	for (unsigned int i = 0; i < JoyStickAxisCode::numberOfAxes * 2; i++)
367	369	{
368		tickHalfAxis(~~joyStickAxes_[joyStick]~~[i]);
	370	tickHalfAxis((*joyStickAxes_[joyStick])[i]);
369	371	}
370	372	}
…	…
481	483	{
482	484	int i = axisID * 2;
483		JoyStickAxisVector& axis = joyStickAxes_[device];
	485	JoyStickAxisVector& axis = *joyStickAxes_[device];
484	486	if (value < 0)
485	487	{

code/trunk/src/core/input/KeyBinder.h

-                      r3327
+                      r5695
 #include <string>
 #include <vector>
+#include <boost/shared_ptr.hpp>
 #include "InputHandler.h"
 …
         };
         //! Actual key bindings for joy stick buttons
         std::vector<JoyStickButtonVector> joyStickButtons_;
+        std::vector<shared_ptr<JoyStickButtonVector> > joyStickButtons_;
         //! Helper class to use something like std:vector<HalfAxis[48]>
         struct JoyStickAxisVector
 …
         };
         //! Actual key bindings for joy stick axes (and sliders)
         std::vector<JoyStickAxisVector> joyStickAxes_;
+        std::vector<shared_ptr<JoyStickAxisVector> > joyStickAxes_;
         //! Pointer map with all Buttons, including half axes
 …
     inline void KeyBinder::buttonPressed (unsigned int device, JoyStickButtonCode::ByEnum button)
     { joyStickButtons_[device][button].execute(KeybindMode::OnPress); }
+    { (*joyStickButtons_[device])[button].execute(KeybindMode::OnPress); }
     inline void KeyBinder::buttonReleased(unsigned int device, JoyStickButtonCode::ByEnum button)
     { joyStickButtons_[device][button].execute(KeybindMode::OnRelease); }
+    { (*joyStickButtons_[device])[button].execute(KeybindMode::OnRelease); }
     inline void KeyBinder::buttonHeld    (unsigned int device, JoyStickButtonCode::ByEnum button)
     { joyStickButtons_[device][button].execute(KeybindMode::OnHold); }
+    { (*joyStickButtons_[device])[button].execute(KeybindMode::OnHold); }
     inline void KeyBinder::allDevicesUpdated(float dt)

code/trunk/src/core/input/KeyDetector.cc

r3327	r5695
70	70	{
71	71	KeyBinder::JoyStickQuantityChanged(joyStickList);
72		setCallbackCommand(callbackCommand_);
	72	if (!callbackCommand_.empty())
	73	setCallbackCommand(callbackCommand_);
73	74	}
74	75	}

code/trunk/src/network/CMakeLists.txt

-                      r3304
+                      r5695
   TrafficControl.cc
+)
+SET_SOURCE_FILES(NETWORK_HDR_FILES
+  ChatListener.h
+  Client.h
+  ClientConnection.h
+  ClientConnectionListener.h
+  ClientInformation.h
+  Connection.h
+  FunctionCallManager.h
+  GamestateClient.h
+  GamestateHandler.h
+  GamestateManager.h
+  Host.h
+  NetworkFunction.h
+  NetworkPrecompiledHeaders.h
+  NetworkPrereqs.h
+  Server.h
+  ServerConnection.h
+  TrafficControl.h
+)
 ADD_SUBDIRECTORY(packet)
 ADD_SUBDIRECTORY(synchronisable)
 ORXONOX_ADD_LIBRARY(network
-  FIND_HEADER_FILES
   DEFINE_SYMBOL
     "NETWORK_SHARED_BUILD"
 …
     core
   SOURCE_FILES
     ${NETWORK_SRC_FILES}
+    ${NETWORK_SRC_FILES} ${NETWORK_HDR_FILES}
+)

code/trunk/src/network/ClientInformation.h

r3304	r5695
49	49
50	50	/**
51		* This class implements a list for client informations
	51	* This class implements a list for client information
52	52	* @author Oliver Scheuss
53	53	*/

code/trunk/src/network/TODO

Property svn:mergeinfo deleted

code/trunk/src/network/packet/CMakeLists.txt

-                      r3084
+                      r5695
 ADD_SOURCE_FILES(NETWORK_SRC_FILES
-  Packet.cc
   Acknowledgement.cc
   Chat.cc
 …
   FunctionCalls.cc
   Gamestate.cc
+  Packet.cc
   Welcome.cc
+)
+ADD_SOURCE_FILES(NETWORK_HDR_FILES
+  Acknowledgement.h
+  Chat.cc
+  Chat.h
+  ClassID.h
+  DeleteObjects.h
+  FunctionCalls.h
+  FunctionIDs.h
+  Gamestate.h
+  Packet.h
+  Welcome.h
+)

code/trunk/src/network/synchronisable/CMakeLists.txt

-                      r2710
+                      r5695
   SynchronisableVariable.cc
+)
+ADD_SOURCE_FILES(NETWORK_HDR_FILES
+  NetworkCallback.h
+  NetworkCallbackManager.h
+  Synchronisable.h
+  SynchronisableVariable.h
+)

code/trunk/src/ois/OISEffect.cpp

-                      r1505
+                      r5695
 //Perhaps a case of a crazy extreme optimizer :/ (moved to header)
 //const unsigned int Effect::OIS_INFINITE = 0xFFFFFFFF;
+//------------------------------------------------------------------------------//
+static const char* pszEForceString[] =
+  { "UnknownForce",
+    "ConstantForce",
+    "RampForce",
+    "PeriodicForce",
+    "ConditionalForce",
+    "CustomForce" };
+const char* Effect::getForceTypeName(Effect::EForce eValue)
+{
+  return (eValue >= 0 && eValue < _ForcesNumber) ? pszEForceString[eValue] : "<Bad force type>";
+}
+static const char* pszETypeString[] =
+  { "Unknown",
+    "Constant",
+    "Ramp",
+    "Square", "Triangle", "Sine", "SawToothUp", "SawToothDown",
+    "Friction", "Damper", "Inertia", "Spring",
+    "Custom" };
+const char* Effect::getEffectTypeName(Effect::EType eValue)
+{
+  return (eValue >= 0 && eValue < _TypesNumber) ? pszETypeString[eValue] : "<Bad effect type>";
+}
+static const char* pszEDirectionString[] =
+  { "NorthWest", "North", "NorthEast", "East", "SouthEast", "South", "SouthWest", "West"};
+const char* Effect::getDirectionName(Effect::EDirection eValue)
+{
+  return (eValue >= 0 && eValue < _DirectionsNumber) ? pszEDirectionString[eValue] : "<Bad direction>";
+}
 //------------------------------------------------------------------------------//

code/trunk/src/ois/OISEffect.h

-                      r1505
+                      r5695
                         PeriodicForce,
                         ConditionalForce,
+                        CustomForce
+                        CustomForce,
+                        _ForcesNumber // Always keep in last position.
                 };
+                static const char* getForceTypeName(EForce eValue);
                 //! Type of effect
 …
                         Inertia,     //ConditionalForce
                         Spring,      //ConditionalForce
+                        Custom       //CustomForce
+                        Custom,      //CustomForce
+                        _TypesNumber // Always keep in last position.
                 };
+                static const char* getEffectTypeName(EType eValue);
                 //! Direction of the Force
 …
                         South,
                         SouthWest,
+                        West
+                        West,
+                        _DirectionsNumber // Always keep in last position.
                 };
+                static const char* getDirectionName(EDirection eValue);
                 /**
 …
                 An optional envelope to be applied to the start/end of an effect. If any of
                 these values are nonzero, then the envelope will be used in setting up the
                 effect. Not currently utilised.. But, will be soon.
+                effect.
         */
         class _OISExport Envelope : public ForceEffect
 …
   #pragma warning (disable : 4800)
 #endif
                 bool isUsed() { return attackLength | attackLevel | fadeLength | fadeLevel; }
+                bool isUsed() const { return attackLength | attackLevel | fadeLength | fadeLevel; }
 #if defined(OIS_MSVC_COMPILER)
   #pragma warning (pop)
 #endif
+                unsigned short attackLength;
+                // Duration of the attack (microseconds)
+                unsigned int attackLength;
+                // Absolute level at the beginning of the attack (0 to 10K)
+                // (automatically signed when necessary by FF core according to effect level sign)
                 unsigned short attackLevel;
+                unsigned short fadeLength;
+                // Duration of fade (microseconds)
+                unsigned int fadeLength;
+                // Absolute level at the end of fade (0 to 10K)
+                // (automatically signed when necessary by FF core according to effect level sign)
                 unsigned short fadeLevel;
         };
 …
                 RampEffect() : startLevel(0), endLevel(0) {}
         class Envelope envelope; //Optional envolope
+        class Envelope envelope; //Optional envelope
                 signed short startLevel;  //-10K to +10k
                 signed short endLevel;    //-10K to +10k

code/trunk/src/ois/OISForceFeedback.cpp

-                      r1505
+                      r5695
 //-------------------------------------------------------------//
 void ForceFeedback::_addEffectTypes( Effect::EForce force, Effect::EType type )
+ForceFeedback::ForceFeedback() : mSetGainSupport(false), mSetAutoCenterSupport(false)
+{
-        if( force == Effect::UnknownForce || type == Effect::Unknown )
-                OIS_EXCEPT( E_General, "Unknown Force||Type was added too effect list..." );
-        mSupportedEffects[force] = type;
+}
 //-------------------------------------------------------------//
+const ForceFeedback::SupportedEffectList&
+                                                ForceFeedback::getSupportedEffects() const
+void ForceFeedback::_addEffectTypes( Effect::EForce force, Effect::EType type )
+{
+        if( force <= Effect::UnknownForce || force >= Effect::_ForcesNumber
+                || type <= Effect::Unknown || type >= Effect::_TypesNumber )
+                OIS_EXCEPT( E_General, "Can't add unknown effect Force/Type to the supported list" );
+        mSupportedEffects.insert(std::pair<Effect::EForce, Effect::EType>(force, type));
+}
+//-------------------------------------------------------------//
+void ForceFeedback::_setGainSupport( bool on )
+{
+        mSetGainSupport = on;
+}
+//-------------------------------------------------------------//
+void ForceFeedback::_setAutoCenterSupport( bool on )
+{
+        mSetAutoCenterSupport = on;
+}
+//-------------------------------------------------------------//
+const ForceFeedback::SupportedEffectList& ForceFeedback::getSupportedEffects() const
+{
         return mSupportedEffects;
+}
+//-------------------------------------------------------------//
+bool ForceFeedback::supportsEffect(Effect::EForce force, Effect::EType type) const
+{
+    const std::pair<SupportedEffectList::const_iterator, SupportedEffectList::const_iterator>
+            iterRange = mSupportedEffects.equal_range(force);
+        SupportedEffectList::const_iterator iter;
+        for (iter = iterRange.first; iter != iterRange.second; iter++)
+        {
+          if ((*iter).second == type)
+                return true;
+        }
+        return false;
+}

code/trunk/src/ois/OISForceFeedback.h

-                      r1505
+                      r5695
+        {
         public:
                 ForceFeedback() {}
+                ForceFeedback();
                 virtual ~ForceFeedback() {}
 …
                         Individual effects have gain levels; however, this affects all
                         effects at once.
+                        Note: If the device does not support master gain setting, nothing is done
                 @param level
                         A value between 0.0 and 1.0 represent the percentage of gain. 1.0
 …
                         the joystick back to center. DirectInput only has an on/off setting,
                         whereas linux has levels.. Though, we go with DI's on/off mode only
+                        Note: If the device does not support auto-centering, nothing is done
                 @param auto_on
                         true to turn auto centering on, false to turn off.
 …
         virtual short getFFAxesNumber() = 0;
+                typedef std::map<Effect::EForce, Effect::EType> SupportedEffectList;
+                /**
+                @remarks
+                        Get the current load (%, in [0, 100] of the FF device memory
+                */
+                virtual unsigned short getFFMemoryLoad() = 0;
+                typedef std::multimap<Effect::EForce, Effect::EType> SupportedEffectList;
                 /**
                 @remarks
 …
                 const SupportedEffectList& getSupportedEffects() const;
+                /**
+                @remarks
+                        Tell if a given force / effect type pair is supported
+                */
+                bool supportsEffect(Effect::EForce force, Effect::EType type) const;
                 void _addEffectTypes( Effect::EForce force, Effect::EType type );
+                void _setGainSupport( bool on );
+                void _setAutoCenterSupport( bool on );
         protected:
                 SupportedEffectList mSupportedEffects;
+                bool mSetGainSupport;
+                bool mSetAutoCenterSupport;
         };
+}

code/trunk/src/ois/OISJoyStick.h

-                      r1505
+                      r5695
         //! POV / HAT Joystick component
         class _OISExport Pov : Component
+        class _OISExport Pov : public Component
+        {
         public:
 …
         //! A sliding axis - only used in Win32 Right Now
         class _OISExport Slider : Component
+        class _OISExport Slider : public Component
+        {
         public:

code/trunk/src/ois/OISPrereqs.h

-                      r1505
+                      r5695
+        {
         public:
                 Button() {}
                 Button(bool bPushed) : Component(OIS_Button), pushed(bPushed) {};
+                Button() : Component(OIS_Button), pushed(false) {}
+                Button(bool bPushed) : Component(OIS_Button), pushed(bPushed) {}
                 //! true if pushed, false otherwise
                 bool pushed;

code/trunk/src/ois/changes_orxonox.diff

-                      r2710
+                      r5695
+--- linux/EventHelpers.cpp      (revision 5668)
++++ linux/EventHelpers.cpp      (working copy)
+@@ -35,6 +35,20 @@
+ # include <iostream>
+ #endif
++// Fixes for missing macros in input.h
++#ifndef FF_EFFECT_MIN
++#define FF_EFFECT_MIN FF_RUMBLE
++#endif
++#ifndef FF_EFFECT_MAX
++#define FF_EFFECT_MAX FF_RAMP
++#endif
++#ifndef FF_WAVEFORM_MIN
++#define FF_WAVEFORM_MIN FF_SQUARE
++#endif
++#ifndef FF_WAVEFORM_MAX
++#define FF_WAVEFORM_MAX FF_CUSTOM
++#endif
++
+ using namespace std;
+ using namespace OIS;

code/trunk/src/ois/linux/EventHelpers.cpp

-                      r1505
+                      r5695
 #ifdef OIS_LINUX_JOY_DEBUG
 # include <iostream>
+  using namespace std;
+#endif
+#endif
+// Fixes for missing macros in input.h
+#ifndef FF_EFFECT_MIN
+#define FF_EFFECT_MIN FF_RUMBLE
+#endif
+#ifndef FF_EFFECT_MAX
+#define FF_EFFECT_MAX FF_RAMP
+#endif
+#ifndef FF_WAVEFORM_MIN
+#define FF_WAVEFORM_MIN FF_SQUARE
+#endif
+#ifndef FF_WAVEFORM_MAX
+#define FF_WAVEFORM_MAX FF_CUSTOM
+#endif
+using namespace std;
 using namespace OIS;
 …
+{
 public:
         std::vector<int> buttons, relAxes, absAxes, hats;
+        vector<int> buttons, relAxes, absAxes, hats;
 };
+bool inline isBitSet(unsigned long bits[], unsigned int bit)
+{
+        return (bits[bit/(sizeof(long)*8)] >> ((bit)%(sizeof(long)*8))) & 1;
+}
+bool inline isBitSet(unsigned char bits[], unsigned int bit)
+{
+  return (bits[(bit)/(sizeof(unsigned char)*8)] >> ((bit)%(sizeof(unsigned char)*8))) & 1;
+}
 //-----------------------------------------------------------------------------//
 DeviceComponentInfo getComponentInfo( int deviceID )
+{
+        unsigned long info[2][((KEY_MAX-1)/(sizeof(long)*8)) +1];
+        memset( info, 0, sizeof(info) );
+        unsigned char ev_bits[1 + EV_MAX/8/sizeof(unsigned char)];
+        memset( ev_bits, 0, sizeof(ev_bits) );
+        //Read "all" (hence 0) components of the device
+#ifdef OIS_LINUX_JOY_DEBUG
+        cout << "EventUtils::getComponentInfo(" << deviceID
+                 << ") : Reading device events features" << endl;
+#endif
+        if (ioctl(deviceID, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits) == -1)
+                OIS_EXCEPT( E_General, "Could not read device events features");
         DeviceComponentInfo components;
-        //Read "all" (hence 0) components of the device - read into first entry
-        ioctl(deviceID, EVIOCGBIT(0, EV_MAX), info[0]);
         for (int i = 0; i < EV_MAX; i++)
+        {
                 if( isBitSet(info[0], i) )
+                if( isBitSet(ev_bits, i) )
+                {
+                        memset( info[1], 0, sizeof(info) / 2 );
+                        ioctl(deviceID, EVIOCGBIT(i, KEY_MAX), info[1]);
+                        for (int j = 0; j < KEY_MAX; j++)
+                    // Absolute axis.
+                    if(i == EV_ABS)
+                        {
+                                if( isBitSet(info[1], j) )
+                            unsigned char abs_bits[1 + ABS_MAX/8/sizeof(unsigned char)];
+                            memset( abs_bits, 0, sizeof(abs_bits) );
+#ifdef OIS_LINUX_JOY_DEBUG
+                                cout << "EventUtils::getComponentInfo(" << deviceID
+                                         << ") : Reading device absolute axis features" << endl;
+#endif
+                                if (ioctl(deviceID, EVIOCGBIT(i, sizeof(abs_bits)), abs_bits) == -1)
+                                    OIS_EXCEPT( E_General, "Could not read device absolute axis features");
+                                for (int j = 0; j < ABS_MAX; j++)
+                                {
                                         if(i == EV_ABS)
+                                    if( isBitSet(abs_bits, j) )
+                                        {
                                                 //input_absinfo abInfo;
 …
+                                                }
+                                        }
+                                        else if(i == EV_REL)
+                                }
+                        }
+                        else if(i == EV_REL)
+                        {
+                            unsigned char rel_bits[1 + REL_MAX/8/sizeof(unsigned char)];
+                                memset( rel_bits, 0, sizeof(rel_bits) );
+#ifdef OIS_LINUX_JOY_DEBUG
+                                cout << "EventUtils::getComponentInfo(" << deviceID
+                                         << ") : Reading device relative axis features" << endl;
+#endif
+                                if (ioctl(deviceID, EVIOCGBIT(i, sizeof(rel_bits)), rel_bits) == -1)
+                                    OIS_EXCEPT( E_General, "Could not read device relative axis features");
+                                for (int j = 0; j < REL_MAX; j++)
+                                {
+                                    if( isBitSet(rel_bits, j) )
+                                        {
                                                 components.relAxes.push_back(j);
+                                            components.relAxes.push_back(j);
+                                        }
+                                        else if(i == EV_KEY)
+                                }
+                        }
+                        else if(i == EV_KEY)
+                        {
+                            unsigned char key_bits[1 + KEY_MAX/8/sizeof(unsigned char)];
+                                memset( key_bits, 0, sizeof(key_bits) );
+#ifdef OIS_LINUX_JOY_DEBUG
+                                cout << "EventUtils::getComponentInfo(" << deviceID
+                                         << ") : Reading device buttons features" << endl;
+#endif
+                                if (ioctl(deviceID, EVIOCGBIT(i, sizeof(key_bits)), key_bits) == -1)
+                                    OIS_EXCEPT( E_General, "Could not read device buttons features");
+                                for (int j = 0; j < KEY_MAX; j++)
+                                {
+                                    if( isBitSet(key_bits, j) )
+                                        {
                                                 components.buttons.push_back(j);
+                                            components.buttons.push_back(j);
+                                        }
+                                }
 …
 bool EventUtils::isJoyStick( int deviceID, JoyStickInfo &js )
+{
+        if( deviceID == -1 ) OIS_EXCEPT( E_General, "Error with File Descriptor" );
+        if( deviceID == -1 )
+                OIS_EXCEPT( E_General, "Error with File Descriptor" );
         DeviceComponentInfo info = getComponentInfo( deviceID );
 …
         #ifdef OIS_LINUX_JOY_DEBUG
           cout << "\n\nDisplaying ButtonMapping Status:";
+        cout << endl << "Displaying ButtonMapping Status:" << endl;
         #endif
         for(std::vector<int>::iterator i = info.buttons.begin(), e = info.buttons.end(); i != e; ++i )
+        for(vector<int>::iterator i = info.buttons.begin(), e = info.buttons.end(); i != e; ++i )
+        {
                 //Check to ensure we find at least one joy only button
+                if( (*i >= BTN_JOYSTICK && *i <= BTN_THUMBR) || (*i >= BTN_WHEEL && *i <= BTN_GEAR_UP ) )
+                if( (*i >= BTN_JOYSTICK && *i < BTN_GAMEPAD)
+                        || (*i >= BTN_GAMEPAD && *i < BTN_DIGI)
+                        || (*i >= BTN_WHEEL && *i < KEY_OK) )
                         joyButtonFound = true;
 …
                 #ifdef OIS_LINUX_JOY_DEBUG
+                  cout << "\nButton Mapping ID (hex): " << hex << *i << " OIS Button Num: " << dec << (buttons-1);
+                  cout << "Button Mapping ID (hex): " << hex << *i
+                           << " OIS Button Num: " << dec << buttons-1 << endl;
                 #endif
+        }
+        #ifdef OIS_LINUX_JOY_DEBUG
+        cout << endl;
+        #endif
         //Joy Buttons found, so it must be a joystick or pad
 …
                 js.axes = info.relAxes.size() + info.absAxes.size();
                 js.hats = info.hats.size();
+                #ifdef OIS_LINUX_JOY_DEBUG
+                  cout << endl << "Device name:" << js.vendor << endl;
+                  cout << "Device unique Id:" << getUniqueId(deviceID) << endl;
+                  cout << "Device physical location:" << getPhysicalLocation(deviceID) << endl;
+                #endif
                 //Map the Axes
                 #ifdef OIS_LINUX_JOY_DEBUG
                   cout << "\n\nDisplaying AxisMapping Status:";
+                  cout << endl << "Displaying AxisMapping Status:" << endl;
                 #endif
                 int axes = 0;
                 for(std::vector<int>::iterator i = info.absAxes.begin(), e = info.absAxes.end(); i != e; ++i )
+                for(vector<int>::iterator i = info.absAxes.begin(), e = info.absAxes.end(); i != e; ++i )
+                {
                         js.axis_map[*i] = axes;
+#ifdef OIS_LINUX_JOY_DEBUG
+                        cout << "EventUtils::isJoyStick(" << deviceID
+                                          << ") : Reading device absolute axis #" << *i << " features" << endl;
+#endif
                         input_absinfo absinfo;
+                        ioctl(deviceID, EVIOCGABS(*i), &absinfo);
+                        if (ioctl(deviceID, EVIOCGABS(*i), &absinfo) == -1)
+                                OIS_EXCEPT( E_General, "Could not read device absolute axis features");
                         js.axis_range[axes] = Range(absinfo.minimum, absinfo.maximum);
                         #ifdef OIS_LINUX_JOY_DEBUG
+                          cout << "\nAxis Mapping ID (hex): " << hex << *i << " OIS Axis Num: " << dec << axes;
+                          cout << "Axis Mapping ID (hex): " << hex << *i
+                                   << " OIS Axis Num: " << dec << axes << endl;
                         #endif
 …
 //-----------------------------------------------------------------------------//
+std::string EventUtils::getName( int deviceID )
+{
+string EventUtils::getName( int deviceID )
+{
+#ifdef OIS_LINUX_JOY_DEBUG
+        cout << "EventUtils::getName(" << deviceID
+                 << ") : Reading device name" << endl;
+#endif
         char name[OIS_DEVICE_NAME];
+        ioctl(deviceID, EVIOCGNAME(OIS_DEVICE_NAME), name);
+        return std::string(name);
+        if (ioctl(deviceID, EVIOCGNAME(OIS_DEVICE_NAME), name) == -1)
+                OIS_EXCEPT( E_General, "Could not read device name");
+        return string(name);
+}
+//-----------------------------------------------------------------------------//
+string EventUtils::getUniqueId( int deviceID )
+{
+#ifdef OIS_LINUX_JOY_DEBUG
+        cout << "EventUtils::getUniqueId(" << deviceID
+                 << ") : Reading device unique Id" << endl;
+#endif
+#define OIS_DEVICE_UNIQUE_ID 128
+        char uId[OIS_DEVICE_UNIQUE_ID];
+        if (ioctl(deviceID, EVIOCGUNIQ(OIS_DEVICE_UNIQUE_ID), uId) == -1)
+                OIS_EXCEPT( E_General, "Could not read device unique Id");
+        return string(uId);
+}
+//-----------------------------------------------------------------------------//
+string EventUtils::getPhysicalLocation( int deviceID )
+{
+#ifdef OIS_LINUX_JOY_DEBUG
+        cout << "EventUtils::getPhysicalLocation(" << deviceID
+                 << ") : Reading device physical location" << endl;
+#endif
+#define OIS_DEVICE_PHYSICAL_LOCATION 128
+        char physLoc[OIS_DEVICE_PHYSICAL_LOCATION];
+        if (ioctl(deviceID, EVIOCGPHYS(OIS_DEVICE_PHYSICAL_LOCATION), physLoc) == -1)
+                OIS_EXCEPT( E_General, "Could not read device physical location");
+        return string(physLoc);
+}
 …
+{
         //Linux Event to OIS Event Mappings
         std::map<int, Effect::EType> typeMap;
+        map<int, Effect::EType> typeMap;
         typeMap[FF_CONSTANT] = Effect::Constant;
         typeMap[FF_RAMP]     = Effect::Ramp;
 …
         typeMap[FF_CUSTOM]   = Effect::Custom;
         std::map<int, Effect::EForce> forceMap;
+        map<int, Effect::EForce> forceMap;
         forceMap[FF_CONSTANT] = Effect::ConstantForce;
+        forceMap[FF_RAMP] = Effect::RampForce;
+        forceMap[FF_PERIODIC] = Effect::PeriodicForce;
+        forceMap[FF_CUSTOM] = Effect::CustomForce;
+        forceMap[FF_RAMP]     = Effect::RampForce;
+        forceMap[FF_SPRING]   = Effect::ConditionalForce;
+        forceMap[FF_FRICTION] = Effect::ConditionalForce;
+        forceMap[FF_SQUARE]   = Effect::PeriodicForce;
+        forceMap[FF_TRIANGLE] = Effect::PeriodicForce;
+        forceMap[FF_SINE]     = Effect::PeriodicForce;
+        forceMap[FF_SAW_UP]   = Effect::PeriodicForce;
+        forceMap[FF_SAW_DOWN] = Effect::PeriodicForce;
+        forceMap[FF_DAMPER]   = Effect::ConditionalForce;
+        forceMap[FF_INERTIA]  = Effect::ConditionalForce;
+        forceMap[FF_CUSTOM]   = Effect::CustomForce;
         //Remove any previously existing memory and create fresh
         removeForceFeedback( ff );
+        *ff = new LinuxForceFeedback();
+        unsigned long info[4] = {0,0,0,0};
+        unsigned long subinfo[4]= {0,0,0,0};
+        //Read overall force feedback components of the device
+        ioctl(deviceID, EVIOCGBIT(EV_FF, sizeof(long)*4), info);
+        *ff = new LinuxForceFeedback(deviceID);
+        //Read overall force feedback features
+        unsigned char ff_bits[1 + FF_MAX/8/sizeof(unsigned char)];
+        memset(ff_bits, 0, sizeof(ff_bits));
+#ifdef OIS_LINUX_JOY_DEBUG
+        cout << "EventUtils::enumerateForceFeedback(" << deviceID
+                 << ") : Reading device force feedback features" << endl;
+#endif
+        if (ioctl(deviceID, EVIOCGBIT(EV_FF, sizeof(ff_bits)), ff_bits) == -1)
+                OIS_EXCEPT( E_General, "Could not read device force feedback features");
+    #ifdef OIS_LINUX_JOY_DEBUG
+        cout << "FF bits: " << hex;
+        for (int i = 0; i < sizeof(ff_bits); i++)
+                cout << (int)ff_bits[i];
+        cout << endl << dec;
+    #endif
         //FF Axes
         //if( isBitSet(info, ABS_X) ) //X Axis
         //if( isBitSet(info, ABS_Y) ) //Y Axis
         //if( isBitSet(info, ABS_WHEEL) ) //Wheel
+        //if( isBitSet(ff_bits, ABS_X) ) //X Axis
+        //if( isBitSet(ff_bits, ABS_Y) ) //Y Axis
+        //if( isBitSet(ff_bits, ABS_WHEEL) ) //Wheel
         //FF Effects
         for( int effect = ABS_WHEEL+1; effect < FF_MAX; effect++ )
+        for( int effect = FF_EFFECT_MIN; effect <= FF_WAVEFORM_MAX; effect++ )
+        {
+                if(isBitSet(info, effect))
+                // The RUMBLE force type is ignored, as periodic force one is more powerfull.
+                // The PERIODIC force type is processed later, for each associated periodic effect type.
+                if (effect == FF_RUMBLE || effect == FF_PERIODIC)
+                        continue;
+                if(isBitSet(ff_bits, effect))
+                {
+                        //std::cout << "\tEffect Type: " << effect << std::endl;
+                        memset(subinfo, 0, sizeof(subinfo));
+                        //Read any info about this supported effect
+                        ioctl(deviceID, EVIOCGBIT(effect, sizeof(long)*4), subinfo);
+                        for( int force = 0; force < FF_MAX; force++ )
+                        {
+                                if(isBitSet(subinfo, force))
+                                        (*ff)->_addEffectTypes( forceMap[force], typeMap[effect] );
+                        }
+                        #ifdef OIS_LINUX_JOY_DEBUG
+                    cout << "  Effect Type: " << Effect::getEffectTypeName(typeMap[effect]) << endl;
+                        #endif
+                        (*ff)->_addEffectTypes( forceMap[effect], typeMap[effect] );
+                }
+        }
+        //FF device properties
+        if (isBitSet(ff_bits, FF_GAIN))
+                (*ff)->_setGainSupport(true);
+        if (isBitSet(ff_bits, FF_AUTOCENTER))
+                (*ff)->_setAutoCenterSupport(true);
         //Check to see if any effects were added, else destroy the pointer

code/trunk/src/ois/linux/EventHelpers.h

r1505	r5695
43	43
44	44	static std::string getName( int deviceID );
	45	static std::string getUniqueId( int deviceID );
	46	static std::string getPhysicalLocation( int deviceID );
45	47	};
46	48	}

code/trunk/src/ois/linux/LinuxForceFeedback.cpp

-                      r1505
+                      r5695
 #include "OISException.h"
+#include <cstdlib>
+#include <errno.h>
+#include <memory.h>
 using namespace OIS;
+//--------------------------------------------------------------//
+LinuxForceFeedback::LinuxForceFeedback()
+{
+}
+// 0 = No trace; 1 = Important traces; 2 = Debug traces
+#define OIS_LINUX_JOYFF_DEBUG 1
+#ifdef OIS_LINUX_JOYFF_DEBUG
+# include <iostream>
+  using namespace std;
+#endif
+//--------------------------------------------------------------//
+LinuxForceFeedback::LinuxForceFeedback(int deviceID) :
+        ForceFeedback(), mJoyStick(deviceID)
+{
+}
 //--------------------------------------------------------------//
 LinuxForceFeedback::~LinuxForceFeedback()
+{
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::setMasterGain(float)
+{
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::setAutoCenterMode(bool)
+{
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::upload( const Effect* /*effect*/ )
+{
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::modify( const Effect* /*effect*/ )
+{
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::remove( const Effect* /*effect*/ )
+{
+}
+        // Unload all effects.
+        for(EffectList::iterator i = mEffectList.begin(); i != mEffectList.end(); ++i )
+        {
+                struct ff_effect *linEffect = i->second;
+                if( linEffect )
+                        _unload(linEffect->id);
+        }
+        mEffectList.clear();
+}
+//--------------------------------------------------------------//
+unsigned short LinuxForceFeedback::getFFMemoryLoad()
+{
+        int nEffects = -1;
+        if (ioctl(mJoyStick, EVIOCGEFFECTS, &nEffects) == -1)
+                OIS_EXCEPT(E_General, "Unknown error reading max number of uploaded effects.");
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+        cout << "LinuxForceFeedback("<< mJoyStick
+                 << ") : Read device max number of uploaded effects : " << nEffects << endl;
+#endif
+        return (unsigned short int)(nEffects > 0 ? 100.0*mEffectList.size()/nEffects : 100);
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::setMasterGain(float value)
+{
+        if (!mSetGainSupport)
+        {
+#if (OIS_LINUX_JOYFF_DEBUG > 0)
+                cout << "LinuxForceFeedback("<< mJoyStick << ") : Setting master gain "
+                         << "is not supported by the device" << endl;
+#endif
+                return;
+        }
+        struct input_event event;
+        memset(&event, 0, sizeof(event));
+        event.type = EV_FF;
+        event.code = FF_GAIN;
+        if (value < 0.0)
+                value = 0.0;
+        else if (value > 1.0)
+                value = 1.0;
+        event.value = (__s32)(value * 0xFFFFUL);
+#if (OIS_LINUX_JOYFF_DEBUG > 0)
+        cout << "LinuxForceFeedback("<< mJoyStick << ") : Setting master gain to "
+                 << value << " => " << event.value << endl;
+#endif
+        if (write(mJoyStick, &event, sizeof(event)) != sizeof(event)) {
+                OIS_EXCEPT(E_General, "Unknown error changing master gain.");
+        }
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::setAutoCenterMode(bool enabled)
+{
+        if (!mSetAutoCenterSupport)
+        {
+#if (OIS_LINUX_JOYFF_DEBUG > 0)
+                cout << "LinuxForceFeedback("<< mJoyStick << ") : Setting auto-center mode "
+                         << "is not supported by the device" << endl;
+#endif
+                return;
+        }
+        struct input_event event;
+        memset(&event, 0, sizeof(event));
+        event.type = EV_FF;
+        event.code = FF_AUTOCENTER;
+        event.value = (__s32)(enabled*0xFFFFFFFFUL);
+#if (OIS_LINUX_JOYFF_DEBUG > 0)
+        cout << "LinuxForceFeedback("<< mJoyStick << ") : Toggling auto-center to "
+                 << enabled << " => 0x" << hex << event.value << dec << endl;
+#endif
+        if (write(mJoyStick, &event, sizeof(event)) != sizeof(event)) {
+                OIS_EXCEPT(E_General, "Unknown error toggling auto-center.");
+        }
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::upload( const Effect* effect )
+{
+        switch( effect->force )
+        {
+                case OIS::Effect::ConstantForce:
+                        _updateConstantEffect(effect);
+                        break;
+                case OIS::Effect::ConditionalForce:
+                        _updateConditionalEffect(effect);
+                        break;
+                case OIS::Effect::PeriodicForce:
+                        _updatePeriodicEffect(effect);
+                        break;
+                case OIS::Effect::RampForce:
+                        _updateRampEffect(effect);
+                        break;
+                case OIS::Effect::CustomForce:
+                        //_updateCustomEffect(effect);
+                        //break;
+                default:
+                        OIS_EXCEPT(E_NotImplemented, "Requested force not implemented yet, sorry!");
+                        break;
+        }
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::modify( const Effect* effect )
+{
+        upload(effect);
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::remove( const Effect* effect )
+{
+        //Get the effect - if it exists
+        EffectList::iterator i = mEffectList.find(effect->_handle);
+        if( i != mEffectList.end() )
+        {
+                struct ff_effect *linEffect = i->second;
+                if( linEffect )
+                {
+                        _stop(effect->_handle);
+                        _unload(effect->_handle);
+                        free(linEffect);
+                        mEffectList.erase(i);
+                }
+                else
+                        mEffectList.erase(i);
+        }
+}
+//--------------------------------------------------------------//
+// To Signed16/Unsigned15 safe conversions
+#define MaxUnsigned15Value 0x7FFF
+#define toUnsigned15(value) \
+        (__u16)((value) < 0 ? 0 : ((value) > MaxUnsigned15Value ? MaxUnsigned15Value : (value)))
+#define MaxSigned16Value  0x7FFF
+#define MinSigned16Value -0x7FFF
+#define toSigned16(value) \
+  (__s16)((value) < MinSigned16Value ? MinSigned16Value : ((value) > MaxSigned16Value ? MaxSigned16Value : (value)))
+// OIS to Linux duration
+#define LinuxInfiniteDuration 0xFFFF
+#define OISDurationUnitMS 1000 // OIS duration unit (microseconds), expressed in milliseconds (theLinux duration unit)
+// linux/input.h : All duration values are expressed in ms. Values above 32767 ms (0x7fff)
+//                 should not be used and have unspecified results.
+#define LinuxDuration(oisDuration) ((oisDuration) == Effect::OIS_INFINITE ? LinuxInfiniteDuration \
+                                                                        : toUnsigned15((oisDuration)/OISDurationUnitMS))
+// OIS to Linux levels
+#define OISMaxLevel 10000
+#define LinuxMaxLevel 0x7FFF
+// linux/input.h : Valid range for the attack and fade levels is 0x0000 - 0x7fff
+#define LinuxPositiveLevel(oisLevel) toUnsigned15(LinuxMaxLevel*(long)(oisLevel)/OISMaxLevel)
+#define LinuxSignedLevel(oisLevel) toSigned16(LinuxMaxLevel*(long)(oisLevel)/OISMaxLevel)
+//--------------------------------------------------------------//
+void LinuxForceFeedback::_setCommonProperties(struct ff_effect *event,
+                                                                                          struct ff_envelope *ffenvelope,
+                                                                                          const Effect* effect, const Envelope *envelope )
+{
+        memset(event, 0, sizeof(struct ff_effect));
+        if (envelope && ffenvelope && envelope->isUsed()) {
+                ffenvelope->attack_length = LinuxDuration(envelope->attackLength);
+                ffenvelope->attack_level = LinuxPositiveLevel(envelope->attackLevel);
+                ffenvelope->fade_length = LinuxDuration(envelope->fadeLength);
+                ffenvelope->fade_level = LinuxPositiveLevel(envelope->fadeLevel);
+        }
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+        cout << endl;
+        if (envelope && ffenvelope)
+        {
+                cout << "  Enveloppe :" << endl
+                         << "    AttackLen : " << envelope->attackLength
+                         << " => " << ffenvelope->attack_length << endl
+                         << "    AttackLvl : " << envelope->attackLevel
+                         << " => " << ffenvelope->attack_level << endl
+                         << "    FadeLen   : " << envelope->fadeLength
+                         << " => " << ffenvelope->fade_length << endl
+                         << "    FadeLvl   : " << envelope->fadeLevel
+                         << " => " << ffenvelope->fade_level << endl;
+        }
+#endif
+        event->direction = (__u16)(1 + (effect->direction*45.0+135.0)*0xFFFFUL/360.0);
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+        cout << "  Direction : " << Effect::getDirectionName(effect->direction)
+                 << " => 0x" << hex << event->direction << dec << endl;
+#endif
+        // TODO trigger_button 0 vs. -1
+        event->trigger.button = effect->trigger_button; // < 0 ? 0 : effect->trigger_button;
+        event->trigger.interval = LinuxDuration(effect->trigger_interval);
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+        cout << "  Trigger :" << endl
+                 << "    Button   : " << effect->trigger_button
+                 << " => " << event->trigger.button << endl
+                 << "    Interval : " << effect->trigger_interval
+                 << " => " << event->trigger.interval << endl;
+#endif
+        event->replay.length = LinuxDuration(effect->replay_length);
+        event->replay.delay = LinuxDuration(effect->replay_delay);
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+        cout << "  Replay :" << endl
+                 << "    Length : " << effect->replay_length
+                 << " => " << event->replay.length << endl
+                 << "    Delay  : " << effect->replay_delay
+                 << " => " << event->replay.delay << endl;
+#endif
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::_updateConstantEffect( const Effect* eff )
+{
+        struct ff_effect event;
+        ConstantEffect *effect = static_cast<ConstantEffect*>(eff->getForceEffect());
+        _setCommonProperties(&event, &event.u.constant.envelope, eff, &effect->envelope);
+        event.type = FF_CONSTANT;
+        event.id = -1;
+        event.u.constant.level = LinuxSignedLevel(effect->level);
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+        cout << "  Level : " << effect->level
+                 << " => " << event.u.constant.level << endl;
+#endif
+        _upload(&event, eff);
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::_updateRampEffect( const Effect* eff )
+{
+        struct ff_effect event;
+        RampEffect *effect = static_cast<RampEffect*>(eff->getForceEffect());
+        _setCommonProperties(&event, &event.u.constant.envelope, eff, &effect->envelope);
+        event.type = FF_RAMP;
+        event.id = -1;
+        event.u.ramp.start_level = LinuxSignedLevel(effect->startLevel);
+        event.u.ramp.end_level = LinuxSignedLevel(effect->endLevel);
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+        cout << "  StartLevel : " << effect->startLevel
+                 << " => " << event.u.ramp.start_level << endl
+                 << "  EndLevel   : " << effect->endLevel
+                 << " => " << event.u.ramp.end_level << endl;
+#endif
+        _upload(&event, eff);
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::_updatePeriodicEffect( const Effect* eff )
+{
+        struct ff_effect event;
+        PeriodicEffect *effect = static_cast<PeriodicEffect*>(eff->getForceEffect());
+        _setCommonProperties(&event, &event.u.periodic.envelope, eff, &effect->envelope);
+        event.type = FF_PERIODIC;
+        event.id = -1;
+        switch( eff->type )
+        {
+                case OIS::Effect::Square:
+                        event.u.periodic.waveform = FF_SQUARE;
+                        break;
+                case OIS::Effect::Triangle:
+                        event.u.periodic.waveform = FF_TRIANGLE;
+                        break;
+                case OIS::Effect::Sine:
+                        event.u.periodic.waveform = FF_SINE;
+                        break;
+                case OIS::Effect::SawToothUp:
+                        event.u.periodic.waveform = FF_SAW_UP;
+                        break;
+                case OIS::Effect::SawToothDown:
+                        event.u.periodic.waveform = FF_SAW_DOWN;
+                        break;
+                // Note: No support for Custom periodic force effect for the moment
+                //case OIS::Effect::Custom:
+                        //event.u.periodic.waveform = FF_CUSTOM;
+                        //break;
+                default:
+                        OIS_EXCEPT(E_General, "No such available effect for Periodic force!");
+                        break;
+        }
+        event.u.periodic.period    = LinuxDuration(effect->period);
+        event.u.periodic.magnitude = LinuxPositiveLevel(effect->magnitude);
+        event.u.periodic.offset    = LinuxPositiveLevel(effect->offset);
+        event.u.periodic.phase     = (__u16)(effect->phase*event.u.periodic.period/36000.0); // ?????
+        // Note: No support for Custom periodic force effect for the moment
+        event.u.periodic.custom_len = 0;
+        event.u.periodic.custom_data = 0;
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+        cout << "  Magnitude : " << effect->magnitude
+                 << " => " << event.u.periodic.magnitude << endl
+                 << "  Period    : " << effect->period
+                 << " => " << event.u.periodic.period  << endl
+                 << "  Offset    : " << effect->offset
+                 << " => " << event.u.periodic.offset << endl
+                 << "  Phase     : " << effect->phase
+                 << " => " << event.u.periodic.phase << endl;
+#endif
+        _upload(&event, eff);
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::_updateConditionalEffect( const Effect* eff )
+{
+        struct ff_effect event;
+        ConditionalEffect *effect = static_cast<ConditionalEffect*>(eff->getForceEffect());
+        _setCommonProperties(&event, NULL, eff, NULL);
+        switch( eff->type )
+        {
+                case OIS::Effect::Friction:
+                        event.type = FF_FRICTION;
+                        break;
+                case OIS::Effect::Damper:
+                        event.type = FF_DAMPER;
+                        break;
+                case OIS::Effect::Inertia:
+                        event.type = FF_INERTIA;
+                        break;
+                case OIS::Effect::Spring:
+                        event.type = FF_SPRING;
+                        break;
+                default:
+                        OIS_EXCEPT(E_General, "No such available effect for Conditional force!");
+                        break;
+        }
+        event.id = -1;
+        event.u.condition[0].right_saturation = LinuxSignedLevel(effect->rightSaturation);
+        event.u.condition[0].left_saturation  = LinuxSignedLevel(effect->leftSaturation);
+        event.u.condition[0].right_coeff      = LinuxSignedLevel(effect->rightCoeff);
+        event.u.condition[0].left_coeff       = LinuxSignedLevel(effect->leftCoeff);
+        event.u.condition[0].deadband         = LinuxPositiveLevel(effect->deadband);// Unit ??
+        event.u.condition[0].center           = LinuxSignedLevel(effect->center); // Unit ?? TODO ?
+        // TODO support for second condition
+        event.u.condition[1] = event.u.condition[0];
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+        cout << "  Condition[0] : " << endl
+                 << "    RightSaturation  : " << effect->rightSaturation
+                 << " => " << event.u.condition[0].right_saturation << endl
+                 << "    LeftSaturation   : " << effect->leftSaturation
+                 << " => " << event.u.condition[0]. left_saturation << endl
+                 << "    RightCoefficient : " << effect->rightCoeff
+                 << " => " << event.u.condition[0].right_coeff << endl
+                 << "    LeftCoefficient : " << effect->leftCoeff
+                 << " => " << event.u.condition[0].left_coeff << endl
+                 << "    DeadBand        : " << effect->deadband
+                 << " => " << event.u.condition[0].deadband  << endl
+                 << "    Center          : " << effect->center
+                 << " => " << event.u.condition[0].center << endl;
+        cout << "  Condition[1] : Not implemented" << endl;
+#endif
+        _upload(&event, eff);
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::_upload( struct ff_effect* ffeffect, const Effect* effect)
+{
+        struct ff_effect *linEffect = 0;
+        //Get the effect - if it exists
+        EffectList::iterator i = mEffectList.find(effect->_handle);
+        //It has been created already
+        if( i != mEffectList.end() )
+                linEffect = i->second;
+        if( linEffect == 0 )
+        {
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+                cout << endl << "LinuxForceFeedback("<< mJoyStick << ") : Adding new effect : "
+                         << Effect::getEffectTypeName(effect->type) << endl;
+#endif
+                //This effect has not yet been created, so create it in the device
+                if (ioctl(mJoyStick, EVIOCSFF, ffeffect) == -1) {
+                        // TODO device full check
+                        // OIS_EXCEPT(E_DeviceFull, "Remove an effect before adding more!");
+                        OIS_EXCEPT(E_General, "Unknown error creating effect (may be the device is full)->..");
+                }
+                // Save returned effect handle
+                effect->_handle = ffeffect->id;
+                // Save a copy of the uploaded effect for later simple modifications
+                linEffect = (struct ff_effect *)calloc(1, sizeof(struct ff_effect));
+                memcpy(linEffect, ffeffect, sizeof(struct ff_effect));
+                mEffectList[effect->_handle] = linEffect;
+                // Start playing the effect.
+                _start(effect->_handle);
+        }
+        else
+        {
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+                cout << endl << "LinuxForceFeedback("<< mJoyStick << ") : Replacing effect : "
+                         << Effect::getEffectTypeName(effect->type) << endl;
+#endif
+                // Keep same id/handle, as this is just an update in the device.
+                ffeffect->id = effect->_handle;
+                // Update effect in the device.
+                if (ioctl(mJoyStick, EVIOCSFF, ffeffect) == -1) {
+                        OIS_EXCEPT(E_General, "Unknown error updating an effect->..");
+                }
+                // Update local linEffect for next time.
+                memcpy(linEffect, ffeffect, sizeof(struct ff_effect));
+        }
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+        cout << "LinuxForceFeedback("<< mJoyStick
+                 << ") : Effect handle : " << effect->_handle << endl;
+#endif
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::_stop( int handle) {
+        struct input_event stop;
+        stop.type = EV_FF;
+        stop.code = handle;
+        stop.value = 0;
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+        cout << endl << "LinuxForceFeedback("<< mJoyStick
+                 << ") : Stopping effect with handle " << handle << endl;
+#endif
+        if (write(mJoyStick, &stop, sizeof(stop)) != sizeof(stop)) {
+                OIS_EXCEPT(E_General, "Unknown error stopping effect->..");
+        }
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::_start( int handle) {
+        struct input_event play;
+        play.type = EV_FF;
+        play.code = handle;
+        play.value = 1; // Play once.
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+        cout << endl << "LinuxForceFeedback("<< mJoyStick
+                 << ") : Starting effect with handle " << handle << endl;
+#endif
+        if (write(mJoyStick, &play, sizeof(play)) != sizeof(play)) {
+                OIS_EXCEPT(E_General, "Unknown error playing effect->..");
+        }
+}
+//--------------------------------------------------------------//
+void LinuxForceFeedback::_unload( int handle)
+{
+#if (OIS_LINUX_JOYFF_DEBUG > 1)
+        cout << endl << "LinuxForceFeedback("<< mJoyStick
+                 << ") : Removing effect with handle " << handle << endl;
+#endif
+        if (ioctl(mJoyStick, EVIOCRMFF, handle) == -1) {
+                OIS_EXCEPT(E_General, "Unknown error removing effect->..");
+        }
+}

code/trunk/src/ois/linux/LinuxForceFeedback.h

-                      r1505
+                      r5695
 #include "linux/LinuxPrereqs.h"
 #include "OISForceFeedback.h"
+#include <linux/input.h>
 namespace OIS
 …
+        {
         public:
                 LinuxForceFeedback();
+                LinuxForceFeedback(int deviceID);
                 ~LinuxForceFeedback();
 …
                 void remove( const Effect* effect );
+                /** FF is not yet implemented fully on Linux.. just retun 0 for now. todo, xxx */
+                short int getFFAxesNumber() { return 0; }
+                /** FF is not yet implemented fully on Linux.. just return -1 for now. todo, xxx */
+                short int getFFAxesNumber() { return -1; }
+                /** @copydoc ForceFeedback::getFFMemoryLoad */
+                unsigned short getFFMemoryLoad();
+        protected:
+                //Sets the common properties to all effects
+                void _setCommonProperties(struct ff_effect *event, struct ff_envelope *ffenvelope,
+                                                                  const Effect* effect, const Envelope *envelope );
+                //Specific Effect Settings
+                void _updateConstantEffect( const Effect* effect );
+                void _updateRampEffect( const Effect* effect );
+                void _updatePeriodicEffect( const Effect* effect );
+                void _updateConditionalEffect( const Effect* effect );
+                //void _updateCustomEffect( const Effect* effect );
+                void _upload( struct ff_effect* ffeffect, const Effect* effect);
+                void _stop( int handle);
+                void _start( int handle);
+                void _unload( int handle);
+                // Map of currently uploaded effects (handle => effect)
+                typedef std::map<int, struct ff_effect *> EffectList;
+                EffectList mEffectList;
+                // Joystick device (file) descriptor.
+                int mJoyStick;
         };
+}

code/trunk/src/ois/linux/LinuxJoyStickEvents.cpp

-                      r1505
+                      r5695
 #include <sstream>
+# include <iostream>
+using namespace std;
 using namespace OIS;
 //#define OIS_LINUX_JOY_DEBUG
-#ifdef OIS_LINUX_JOY_DEBUG
-# include <iostream>
-  using namespace std;
-#endif
 //-------------------------------------------------------------------//
 …
                         #ifdef OIS_LINUX_JOY_DEBUG
                           std::cout << "\nButton Code: " << js[i].code << ", OIS Value: " << button << std::endl;
+                          cout << "\nButton Code: " << js[i].code << ", OIS Value: " << button << endl;
                         #endif
 …
                         break;
+                }
+                case EV_ABS:  //Absoulte Axis
+                case EV_ABS:  //Absolute Axis
+                {
                         //A Stick (BrakeDefine is the highest possible Axis)
 …
+                        {
                                 int axis = mAxisMap[js[i].code];
                                 assert( axis < 32 && "Too many axes, not supported. Report this to OIS forums!" );
+                                assert( axis < 32 && "Too many axes (Max supported is 32). Report this to OIS forums!" );
                                 axisMoved[axis] = true;
 …
                         break;
+                }
+                //Relative Axes (Do any joysticks actually have a relative axis?)
+                case EV_REL:
+                case EV_REL: //Relative Axes (Do any joystick actually have a relative axis?)
+#ifdef OIS_LINUX_JOY_DEBUG
+                    cout << "\nWarning: Relatives axes not supported yet" << endl;
+#endif
+                        break;
                 default: break;
+                }
 …
         for(int i = 0; i < 64; ++i )
+        {
                 std::stringstream s;
+                stringstream s;
                 s << "/dev/input/event" << i;
                 int fd = open( s.str().c_str(), O_RDONLY |O_NONBLOCK );
+                int fd = open( s.str().c_str(), O_RDWR |O_NONBLOCK );
                 if(fd == -1)
                         continue;
         #ifdef OIS_LINUX_JOY_DEBUG
           std::cout << "\nOpening " << s.str() << "...";
+                  cout << "Opening " << s.str() << "..." << endl;
         #endif
                 try
 …
                                 joys.push_back(js);
                 #ifdef OIS_LINUX_JOY_DEBUG
                   std::cout << "\n__Joystick added to list";
+                  cout << "=> Joystick added to list." << endl;
                 #endif
+                        }
 …
+                        {
                 #ifdef OIS_LINUX_JOY_DEBUG
                   std::cout << "\n__Not a joystick!!";
+                  cout << "=> Not a joystick." << endl;
                 #endif
                                 close(fd);
 …
+                {
             #ifdef OIS_LINUX_JOY_DEBUG
               std::cout << "\nException caught!!";
+              cout << "Exception caught!!" << endl;
             #endif
                         close(fd);

code/trunk/src/ois/win32/Win32ForceFeedback.cpp

-                      r1505
+                      r5695
 #include <Math.h>
+#if defined (_DEBUG)
+// 0 = No trace; 1 = Important traces; 2 = Debug traces
+#define OIS_WIN32_JOYFF_DEBUG 1
+#if (defined (_DEBUG) || defined(OIS_WIN32_JOYFF_DEBUG))
+  #include <iostream>
   #include <sstream>
+  using namespace std;
 #endif
 …
 //--------------------------------------------------------------//
+Win32ForceFeedback::Win32ForceFeedback(IDirectInputDevice8* joy) :
+        mHandles(0), mJoyStick(joy)
+{
+Win32ForceFeedback::Win32ForceFeedback(IDirectInputDevice8* pDIJoy, const DIDEVCAPS* pDIJoyCaps) :
+  mHandles(0), mJoyStick(pDIJoy), mFFAxes(0), mpDIJoyCaps(pDIJoyCaps)
+{
+#if (OIS_WIN32_JOYFF_DEBUG > 0)
+  cout << "FFSamplePeriod      : " << mpDIJoyCaps->dwFFSamplePeriod << " mu-s, "
+           << "FFMinTimeResolution : " << mpDIJoyCaps->dwFFMinTimeResolution << " mu-s,"
+           << "" << endl;
+#endif
+}
 …
                 LPDIRECTINPUTEFFECT dxEffect = i->second;
                 if( dxEffect )
+                {
                         dxEffect->Unload();
+                        dxEffect->Release();
+                }
+        }
         mEffectList.clear();
+}
+//--------------------------------------------------------------//
+short Win32ForceFeedback::getFFAxesNumber()
+{
+        return mFFAxes;
+}
+//--------------------------------------------------------------//
+unsigned short Win32ForceFeedback::getFFMemoryLoad()
+{
+    DIPROPDWORD dipdw;  // DIPROPDWORD contains a DIPROPHEADER structure.
+        dipdw.diph.dwSize       = sizeof(DIPROPDWORD);
+        dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
+        dipdw.diph.dwObj        = 0; // device property
+        dipdw.diph.dwHow        = DIPH_DEVICE;
+        dipdw.dwData            = 0; // In case of any error.
+        const HRESULT hr = mJoyStick->GetProperty(DIPROP_FFLOAD, &dipdw.diph);
+        if(FAILED(hr))
+        {
+            if (hr == DIERR_NOTEXCLUSIVEACQUIRED)
+                    OIS_EXCEPT(E_General, "Can't query FF memory load as device was not acquired in exclusive mode");
+                else
+                    OIS_EXCEPT(E_General, "Unknown error querying FF memory load ->..");
+        }
+        return (unsigned short)dipdw.dwData;
+}
 …
                         //have been unlaoded
                         if( SUCCEEDED(dxEffect->Unload()) )
+                        {
+                            dxEffect->Release();
                                 mEffectList.erase(i);
+                        }
+                }
                 else
 …
         DIPropGain.dwData            = gain_level;
+        mJoyStick->SetProperty(DIPROP_FFGAIN, &DIPropGain.diph);
+#if (OIS_WIN32_JOYFF_DEBUG > 0)
+        cout << "Win32ForceFeedback("<< mJoyStick << ") : Setting master gain to "
+                 << level << " => " << DIPropGain.dwData << endl;
+#endif
+        const HRESULT hr = mJoyStick->SetProperty(DIPROP_FFGAIN, &DIPropGain.diph);
+#if defined (_DEBUG)
+        if(FAILED(hr))
+            cout << "Failed to change master gain" << endl;
+#endif
+}
 …
 void Win32ForceFeedback::setAutoCenterMode( bool auto_on )
+{
-        //DI Property DIPROPAUTOCENTER_OFF = 0, 1 is on
         DIPROPDWORD DIPropAutoCenter;
         DIPropAutoCenter.diph.dwSize       = sizeof(DIPropAutoCenter);
 …
         DIPropAutoCenter.diph.dwObj        = 0;
         DIPropAutoCenter.diph.dwHow        = DIPH_DEVICE;
+        DIPropAutoCenter.dwData            = auto_on;
+        //hr =
+        mJoyStick->SetProperty(DIPROP_AUTOCENTER, &DIPropAutoCenter.diph);
+        DIPropAutoCenter.dwData            = (auto_on ? DIPROPAUTOCENTER_ON : DIPROPAUTOCENTER_OFF);
+#if (OIS_WIN32_JOYFF_DEBUG > 0)
+        cout << "Win32ForceFeedback("<< mJoyStick << ") : Setting auto-center mode to "
+                 << auto_on << " => " << DIPropAutoCenter.dwData << endl;
+#endif
+        const HRESULT hr = mJoyStick->SetProperty(DIPROP_AUTOCENTER, &DIPropAutoCenter.diph);
+#if defined (_DEBUG)
+        if(FAILED(hr))
+            cout << "Failed to change auto-center mode" << endl;
+#endif
+}
 …
 void Win32ForceFeedback::_updateConstantEffect( const Effect* effect )
+{
+        ConstantEffect *eff = static_cast<ConstantEffect*>(effect->getForceEffect());
         DWORD           rgdwAxes[2]     = { DIJOFS_X, DIJOFS_Y };
         LONG            rglDirection[2] = { 0, 0 };
+        DIENVELOPE      diEnvelope;
         DICONSTANTFORCE cf;
         DIEFFECT        diEffect;
 …
         //Currently only support 1 axis
         //if( effect->getNumAxes() == 1 )
+        cf.lMagnitude = static_cast<ConstantEffect*>(effect->getForceEffect())->level;
+        _setCommonProperties(&diEffect, rgdwAxes, rglDirection, sizeof(DICONSTANTFORCE), &cf, effect);
+        cf.lMagnitude = eff->level;
+#if (OIS_WIN32_JOYFF_DEBUG > 1)
+        cout << "  Level : " << eff->level
+                 << " => " << cf.lMagnitude << endl;
+#endif
+        _setCommonProperties(&diEffect, rgdwAxes, rglDirection, &diEnvelope, sizeof(DICONSTANTFORCE), &cf, effect, &eff->envelope);
         _upload(GUID_ConstantForce, &diEffect, effect);
+}
 …
 void Win32ForceFeedback::_updateRampEffect( const Effect* effect )
+{
+        RampEffect *eff = static_cast<RampEffect*>(effect->getForceEffect());
         DWORD           rgdwAxes[2]     = { DIJOFS_X, DIJOFS_Y };
         LONG            rglDirection[2] = { 0, 0 };
+        DIENVELOPE      diEnvelope;
         DIRAMPFORCE     rf;
         DIEFFECT        diEffect;
         //Currently only support 1 axis
         rf.lStart = static_cast<RampEffect*>(effect->getForceEffect())->startLevel;
         rf.lEnd = static_cast<RampEffect*>(effect->getForceEffect())->endLevel;
         _setCommonProperties(&diEffect, rgdwAxes, rglDirection, sizeof(DIRAMPFORCE), &rf, effect);
+        rf.lStart = eff->startLevel;
+        rf.lEnd = eff->endLevel;
+        _setCommonProperties(&diEffect, rgdwAxes, rglDirection, &diEnvelope, sizeof(DIRAMPFORCE), &rf, effect, &eff->envelope );
         _upload(GUID_RampForce, &diEffect, effect);
+}
 …
 void Win32ForceFeedback::_updatePeriodicEffect( const Effect* effect )
+{
+        PeriodicEffect *eff = static_cast<PeriodicEffect*>(effect->getForceEffect());
         DWORD           rgdwAxes[2]     = { DIJOFS_X, DIJOFS_Y };
         LONG            rglDirection[2] = { 0, 0 };
+        DIENVELOPE      diEnvelope;
         DIPERIODIC      pf;
         DIEFFECT        diEffect;
         //Currently only support 1 axis
         pf.dwMagnitude = static_cast<PeriodicEffect*>(effect->getForceEffect())->magnitude;
         pf.lOffset = static_cast<PeriodicEffect*>(effect->getForceEffect())->offset;
         pf.dwPhase = static_cast<PeriodicEffect*>(effect->getForceEffect())->phase;
         pf.dwPeriod = static_cast<PeriodicEffect*>(effect->getForceEffect())->period;
         _setCommonProperties(&diEffect, rgdwAxes, rglDirection, sizeof(DIPERIODIC), &pf, effect);
+        pf.dwMagnitude = eff->magnitude;
+        pf.lOffset = eff->offset;
+        pf.dwPhase = eff->phase;
+        pf.dwPeriod = eff->period;
+        _setCommonProperties(&diEffect, rgdwAxes, rglDirection, &diEnvelope, sizeof(DIPERIODIC), &pf, effect, &eff->envelope );
         switch( effect->type )
 …
 void Win32ForceFeedback::_updateConditionalEffect( const Effect* effect )
+{
+        ConditionalEffect *eff = static_cast<ConditionalEffect*>(effect->getForceEffect());
         DWORD           rgdwAxes[2]     = { DIJOFS_X, DIJOFS_Y };
         LONG            rglDirection[2] = { 0, 0 };
+        DIENVELOPE      diEnvelope;
         DICONDITION     cf;
         DIEFFECT        diEffect;
         cf.lOffset = static_cast<ConditionalEffect*>(effect->getForceEffect())->deadband;
         cf.lPositiveCoefficient = static_cast<ConditionalEffect*>(effect->getForceEffect())->rightCoeff;
         cf.lNegativeCoefficient = static_cast<ConditionalEffect*>(effect->getForceEffect())->leftCoeff;
         cf.dwPositiveSaturation = static_cast<ConditionalEffect*>(effect->getForceEffect())->rightSaturation;
         cf.dwNegativeSaturation = static_cast<ConditionalEffect*>(effect->getForceEffect())->leftSaturation;
         cf.lDeadBand = static_cast<ConditionalEffect*>(effect->getForceEffect())->deadband;
         _setCommonProperties(&diEffect, rgdwAxes, rglDirection, sizeof(DICONDITION), &cf, effect);
+        cf.lOffset = eff->deadband;
+        cf.lPositiveCoefficient = eff->rightCoeff;
+        cf.lNegativeCoefficient = eff->leftCoeff;
+        cf.dwPositiveSaturation = eff->rightSaturation;
+        cf.dwNegativeSaturation = eff->leftSaturation;
+        cf.lDeadBand = eff->deadband;
+        _setCommonProperties(&diEffect, rgdwAxes, rglDirection, &diEnvelope, sizeof(DICONDITION), &cf, effect, 0 );
         switch( effect->type )
 …
 void Win32ForceFeedback::_updateCustomEffect( const Effect* /*effect*/ )
+{
+    //CustomEffect *eff = static_cast<CustomEffect*>(effect->getForceEffect());
+    //
         //DWORD           rgdwAxes[2]     = { DIJOFS_X, DIJOFS_Y };
         //LONG            rglDirection[2] = { 0, 0 };
+        //DIENVELOPE      diEnvelope;
         //DICUSTOMFORCE cf;
         //DIEFFECT        diEffect;
 …
         //cf.cSamples = 0;
         //cf.rglForceData = 0;
         //_setCommonProperties(&diEffect, rgdwAxes, rglDirection, sizeof(DICUSTOMFORCE), &cf, effect);
+        //_setCommonProperties(&diEffect, rgdwAxes, rglDirection, &diEnvelope, sizeof(DICUSTOMFORCE), &cf, effect, &eff->envelope);
         //_upload(GUID_CustomForce, &diEffect, effect);
+}
 …
 void Win32ForceFeedback::_setCommonProperties(
                 DIEFFECT* diEffect, DWORD* rgdwAxes,
                 LONG* rglDirection, DWORD struct_size,
                 LPVOID struct_type, const Effect* effect )
+                LONG* rglDirection, DIENVELOPE* diEnvelope, DWORD struct_size,
+                LPVOID struct_type, const Effect* effect, const Envelope* envelope )
+{
         ZeroMemory(diEffect, sizeof(DIEFFECT));
 …
         diEffect->dwSize                  = sizeof(DIEFFECT);
         diEffect->dwFlags                 = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS;
+        diEffect->dwGain                  = DI_FFNOMINALMAX;
+        diEffect->dwTriggerButton         = DIEB_NOTRIGGER; // effect->trigger_button; // TODO: Conversion
+        diEffect->dwTriggerRepeatInterval = effect->trigger_interval;
+#if (OIS_WIN32_JOYFF_DEBUG > 1)
+        cout << "  Trigger :" << endl
+                 << "    Button   : " << effect->trigger_button
+                 << " => " << diEffect->dwTriggerButton << endl
+                 << "    Interval : " << effect->trigger_interval
+                 << " => " << diEffect->dwTriggerRepeatInterval << endl;
+#endif
+        diEffect->cAxes                   = 1; // effect->getNumAxes();
+        diEffect->rgdwAxes                = rgdwAxes;
+        diEffect->rglDirection            = rglDirection; // TODO: conversion from effect->direction
+#if (OIS_WIN32_JOYFF_DEBUG > 1)
+        cout << "  Direction : " << Effect::getDirectionName(effect->direction)
+                 << " => {";
+        for (int iDir=0; iDir < (int)diEffect->cAxes; iDir++)
+          cout << " " << diEffect->rglDirection[iDir];
+        cout << "}" << endl;
+#endif
+        if (diEnvelope && envelope && envelope->isUsed())
+        {
+            diEnvelope->dwSize = sizeof(DIENVELOPE);
+            diEnvelope->dwAttackLevel = envelope->attackLevel;
+            diEnvelope->dwAttackTime  = envelope->attackLength;
+            diEnvelope->dwFadeLevel   = envelope->fadeLevel;
+            diEnvelope->dwFadeTime    = envelope->fadeLength;
+            diEffect->lpEnvelope = diEnvelope;
+        }
+        else
+            diEffect->lpEnvelope = 0;
+#if (OIS_WIN32_JOYFF_DEBUG > 1)
+        if (diEnvelope && envelope && envelope->isUsed())
+        {
+                cout << "  Enveloppe :" << endl
+                         << "    AttackLen : " << envelope->attackLength
+                         << " => " << diEnvelope->dwAttackTime << endl
+                         << "    AttackLvl : " << envelope->attackLevel
+                         << " => " << diEnvelope->dwAttackLevel << endl
+                         << "    FadeLen   : " << envelope->fadeLength
+                         << " => " << diEnvelope->dwFadeTime << endl
+                         << "    FadeLvl   : " << envelope->fadeLevel
+                         << " => " << diEnvelope->dwFadeLevel << endl;
+        }
+#endif
+        diEffect->dwSamplePeriod          = 0;
         diEffect->dwDuration              = effect->replay_length;
+        diEffect->dwSamplePeriod          = 0;
+        diEffect->dwGain                  = DI_FFNOMINALMAX;
+        diEffect->dwTriggerButton         = DIEB_NOTRIGGER;
+        diEffect->dwTriggerRepeatInterval = 0;
+        diEffect->cAxes                   = effect->getNumAxes();
+        diEffect->rgdwAxes                = rgdwAxes;
+        diEffect->rglDirection            = rglDirection;
+        diEffect->lpEnvelope              = 0;
+        diEffect->dwStartDelay            = effect->replay_delay;
+#if (OIS_WIN32_JOYFF_DEBUG > 1)
+        cout << "  Replay :" << endl
+                 << "    Length : " << effect->replay_length
+                 << " => " << diEffect->dwDuration << endl
+                 << "    Delay  : " << effect->replay_delay
+                 << " => " << diEffect->dwStartDelay << endl;
+#endif
         diEffect->cbTypeSpecificParams    = struct_size;
         diEffect->lpvTypeSpecificParams   = struct_type;
-        diEffect->dwStartDelay            = effect->replay_delay;
+}
 …
 void Win32ForceFeedback::_addEffectSupport( LPCDIEFFECTINFO pdei )
+{
+        //Determine what the effect is and how it corresponds to our OIS's Enums
+        //We could save the GUIDs too, however, we will just use the predefined
+        //ones later
+#if (OIS_WIN32_JOYFF_DEBUG > 0)
+    // Dump some usefull information about the effect type.
+    cout << "Adding support for '" << pdei->tszName << "' effect type" << endl;
+        cout << "  Supported static params: ";
+        if (pdei->dwStaticParams & DIEP_AXES) cout << " Axes";
+        if (pdei->dwStaticParams & DIEP_DIRECTION) cout << " Direction";
+        if (pdei->dwStaticParams & DIEP_DURATION) cout << " Duration";
+        if (pdei->dwStaticParams & DIEP_ENVELOPE) cout << " Envelope";
+        if (pdei->dwStaticParams & DIEP_GAIN) cout << " Gain";
+        if (pdei->dwStaticParams & DIEP_SAMPLEPERIOD) cout << " SamplePeriod";
+        if (pdei->dwStaticParams & DIEP_STARTDELAY) cout << " StartDelay";
+        if (pdei->dwStaticParams & DIEP_TRIGGERBUTTON) cout << " TriggerButton";
+        if (pdei->dwStaticParams & DIEP_TRIGGERREPEATINTERVAL) cout << " TriggerRepeatInterval";
+        if (pdei->dwStaticParams & DIEP_TYPESPECIFICPARAMS) cout << " TypeSpecificParams";
+        cout << endl;
+        cout << "  Supported dynamic params: ";
+        if (pdei->dwDynamicParams & DIEP_AXES) cout << " Axes";
+        if (pdei->dwDynamicParams & DIEP_DIRECTION) cout << " Direction";
+        if (pdei->dwDynamicParams & DIEP_DURATION) cout << " Duration";
+        if (pdei->dwDynamicParams & DIEP_ENVELOPE) cout << " Envelope";
+        if (pdei->dwDynamicParams & DIEP_GAIN) cout << " Gain";
+        if (pdei->dwDynamicParams & DIEP_SAMPLEPERIOD) cout << " SamplePeriod";
+        if (pdei->dwDynamicParams & DIEP_STARTDELAY) cout << " StartDelay";
+        if (pdei->dwDynamicParams & DIEP_TRIGGERBUTTON) cout << " TriggerButton";
+        if (pdei->dwDynamicParams & DIEP_TRIGGERREPEATINTERVAL) cout << " TriggerRepeatInterval";
+        if (pdei->dwDynamicParams & DIEP_TYPESPECIFICPARAMS) cout << " TypeSpecificParams";
+        cout << endl;
+        cout << "  More details about supported parameters support: ";
+        if (pdei->dwEffType & DIEFT_STARTDELAY) cout << " StartDelay";
+        if (pdei->dwEffType & DIEFT_FFATTACK) cout << " Attack";
+        if (pdei->dwEffType & DIEFT_FFFADE) cout << " Fade";
+        if (pdei->dwEffType & DIEFT_DEADBAND) cout << " DeadBand";
+        if (pdei->dwEffType & DIEFT_SATURATION) cout << " Saturation";
+        if (pdei->dwEffType & DIEFT_POSNEGSATURATION) cout << " PosNegaturation";
+        if (pdei->dwEffType & DIEFT_POSNEGCOEFFICIENTS) cout << " PosNegCoefficients";
+        if (pdei->dwEffType & DIEFT_HARDWARE) cout << " HardwareSpecific";
+        cout << endl;
+#endif
+    Effect::EForce eForce;
+        switch (DIEFT_GETTYPE(pdei->dwEffType))
+        {
+            case DIEFT_CONSTANTFORCE:
+                    eForce = Effect::ConstantForce;
+                        break;
+            case DIEFT_RAMPFORCE:
+                    eForce = Effect::RampForce;
+                        break;
+            case DIEFT_PERIODIC:
+                    eForce = Effect::PeriodicForce;
+                        break;
+            case DIEFT_CONDITION:
+                    eForce = Effect::ConditionalForce;
+                        break;
+            case DIEFT_CUSTOMFORCE:
+                    eForce = Effect::CustomForce;
+                        break;
+            default:
+                    eForce = Effect::UnknownForce;
+#if defined (_DEBUG)
+                        cout << "Win32ForceFeedback: DirectInput8 Effect type support not implemented: "
+                                 << "DIEFT_GETTYPE="<< (int)DIEFT_GETTYPE(pdei->dwEffType) << endl;
+#endif
+                        return;
+        }
+        //Determine what the effect type is and how it corresponds to our OIS's Enums
+        //We could save the GUIDs too, however, we will just use the predefined ones later
         if( pdei->guid == GUID_ConstantForce )
                 _addEffectTypes((Effect::EForce)DIEFT_GETTYPE(pdei->dwEffType), Effect::Constant );
+                _addEffectTypes(eForce, Effect::Constant );
         else if( pdei->guid == GUID_Triangle )
                 _addEffectTypes((Effect::EForce)DIEFT_GETTYPE(pdei->dwEffType), Effect::Triangle );
+                _addEffectTypes(eForce, Effect::Triangle );
         else if( pdei->guid == GUID_Spring )
                 _addEffectTypes((Effect::EForce)DIEFT_GETTYPE(pdei->dwEffType), Effect::Spring );
+                _addEffectTypes(eForce, Effect::Spring );
         else if( pdei->guid == GUID_Friction )
                 _addEffectTypes((Effect::EForce)DIEFT_GETTYPE(pdei->dwEffType), Effect::Friction );
+                _addEffectTypes(eForce, Effect::Friction );
         else if( pdei->guid == GUID_Square )
                 _addEffectTypes((Effect::EForce)DIEFT_GETTYPE(pdei->dwEffType), Effect::Square );
+                _addEffectTypes(eForce, Effect::Square );
         else if( pdei->guid == GUID_Sine )
                 _addEffectTypes((Effect::EForce)DIEFT_GETTYPE(pdei->dwEffType), Effect::Sine );
+                _addEffectTypes(eForce, Effect::Sine );
         else if( pdei->guid == GUID_SawtoothUp )
                 _addEffectTypes((Effect::EForce)DIEFT_GETTYPE(pdei->dwEffType), Effect::SawToothUp );
+                _addEffectTypes(eForce, Effect::SawToothUp );
         else if( pdei->guid == GUID_SawtoothDown )
                 _addEffectTypes((Effect::EForce)DIEFT_GETTYPE(pdei->dwEffType), Effect::SawToothDown );
+                _addEffectTypes(eForce, Effect::SawToothDown );
         else if( pdei->guid == GUID_Damper )
                 _addEffectTypes((Effect::EForce)DIEFT_GETTYPE(pdei->dwEffType), Effect::Damper );
+                _addEffectTypes(eForce, Effect::Damper );
         else if( pdei->guid == GUID_Inertia )
                 _addEffectTypes((Effect::EForce)DIEFT_GETTYPE(pdei->dwEffType), Effect::Inertia );
+                _addEffectTypes(eForce, Effect::Inertia );
         else if( pdei->guid == GUID_CustomForce )
                 _addEffectTypes((Effect::EForce)DIEFT_GETTYPE(pdei->dwEffType), Effect::Custom );
+                _addEffectTypes(eForce, Effect::Custom );
         else if( pdei->guid == GUID_RampForce )
+                _addEffectTypes((Effect::EForce)DIEFT_GETTYPE(pdei->dwEffType), Effect::Ramp );
+                _addEffectTypes(eForce, Effect::Ramp );
 #if defined (_DEBUG)
         //Only care about this for Debugging Purposes
 …
 #endif
+}
+//--------------------------------------------------------------//
+void Win32ForceFeedback::_addFFAxis()
+{
+        mFFAxes++;
+}

code/trunk/src/ois/win32/Win32ForceFeedback.h

-                      r1505
+                      r5695
                 Win32ForceFeedback() {}
         public:
                 Win32ForceFeedback(IDirectInputDevice8* joy);
+                Win32ForceFeedback(IDirectInputDevice8* pDIJoy, const DIDEVCAPS* pDIJoyCaps);
                 ~Win32ForceFeedback();
 …
                 void setAutoCenterMode( bool auto_on );
+                /** @copydoc ForceFeedback::getFFAxesNumber
+                        xxx todo - Actually return correct number
+                */
+                short getFFAxesNumber() {return 1;}
+                /** @copydoc ForceFeedback::getFFAxesNumber */
+                short getFFAxesNumber();
+                /** @copydoc ForceFeedback::getFFMemoryLoad */
+                unsigned short getFFMemoryLoad();
                 /**
 …
                 void _addEffectSupport( LPCDIEFFECTINFO pdei );
+                /**
+                        @remarks
+                        Internal use.. Used during axis enumeration to get number of FF axes
+                        support effects.
+                */
+                void _addFFAxis();
         protected:
                 //Specific Effect Settings
                 void _updateConstantEffect( const Effect* effect );
 …
                 void _updateConditionalEffect( const Effect* effect );
                 void _updateCustomEffect( const Effect* effect );
                 //Sets the common properties to all effects
                 void _setCommonProperties( DIEFFECT* diEffect, DWORD* rgdwAxes,
                                                                         LONG* rglDirection, DWORD struct_size,
                                                                         LPVOID struct_type, const Effect* effect );
+                                                                        LONG* rglDirection, DIENVELOPE* diEnvelope, DWORD struct_size,
+                                                                        LPVOID struct_type, const Effect* effect, const Envelope* envelope );
                 //Actually do the upload
                 void _upload( GUID, DIEFFECT*, const Effect* );
+                // Map of currently uploaded effects (handle => effect)
                 typedef std::map<int,LPDIRECTINPUTEFFECT> EffectList;
                 EffectList mEffectList;
+                //Simple unique handle creation - allows for upto 2+ million effects
+                //Simple unique handle creation - allows for upto 2+ billion effects
                 //during the lifetime of application. Hopefully, that is enough.
                 int mHandles;
+                // Joystick device descriptor.
                 IDirectInputDevice8* mJoyStick;
+                // Joystick capabilities.
+                const DIDEVCAPS* mpDIJoyCaps;
+                // Number of axis supporting FF.
+                short mFFAxes;
         };
+}

code/trunk/src/ois/win32/Win32InputManager.cpp

-                      r1505
+                      r5695
         hInst = GetModuleHandle(0);
         //Create the device
+        //Create the input system
         hr = DirectInput8Create( hInst, DIRECTINPUT_VERSION, IID_IDirectInput8, (VOID**)&mDirectInput, NULL );
     if (FAILED(hr))
 …
         //Ok, now we have DirectInput, parse whatever extra settings were sent to us
         _parseConfigSettings( paramList );
+        // Enumerate devices ...
         _enumerateDevices();
+}
 …
+{
         //Enumerate all attached devices
         mDirectInput->EnumDevices(NULL, _DIEnumKbdCallback, this, DIEDFL_ATTACHEDONLY);
+}
 //--------------------------------------------------------------------------------//
 BOOL CALLBACK Win32InputManager::_DIEnumKbdCallback(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef)
+        mDirectInput->EnumDevices(NULL , _DIEnumDevCallback, this, DIEDFL_ATTACHEDONLY);
+}
+//--------------------------------------------------------------------------------//
+BOOL CALLBACK Win32InputManager::_DIEnumDevCallback(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef)
+{
         Win32InputManager *_this_ = static_cast<Win32InputManager*>(pvRef);
+        // Register only game devices (keyboard and mouse are managed differently).
         if( GET_DIDEVICE_TYPE(lpddi->dwDevType) == DI8DEVTYPE_JOYSTICK ||
                 GET_DIDEVICE_TYPE(lpddi->dwDevType) == DI8DEVTYPE_GAMEPAD ||

code/trunk/src/ois/win32/Win32InputManager.h

r1505	r5695
81	81
82	82	//! Used during device enumeration
83		static BOOL CALLBACK _DIEnum~~Kbd~~Callback(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef);
	83	static BOOL CALLBACK _DIEnumDevCallback(LPCDIDEVICEINSTANCE lpddi, LPVOID pvRef);
84	84
85	85	//! Keep a list of all joysticks enumerated, but not in use

code/trunk/src/ois/win32/Win32JoyStick.cpp

-                      r1505
+                      r5695
         mState.mAxes.clear();
+        delete ff_device;
+        ff_device = 0;
+        if (ff_device)
+        {
+                delete ff_device;
+                ff_device = 0;
+        }
+        // Create direct input joystick device.
+        if(FAILED(mDirectInput->CreateDevice(deviceGuid, &mJoyStick, NULL)))
+                OIS_EXCEPT( E_General, "Win32JoyStick::_initialize() >> Could not initialize joy device!");
+        // Set DIJoystick2 data format.
+        if(FAILED(mJoyStick->SetDataFormat(&c_dfDIJoystick2)))
+                OIS_EXCEPT( E_General, "Win32JoyStick::_initialize() >> data format error!");
+        // Set cooperative level as specified when creating input manager.
+        HWND hwin = ((Win32InputManager*)mCreator)->getWindowHandle();
+        if(FAILED(mJoyStick->SetCooperativeLevel( hwin, coopSetting)))
+                OIS_EXCEPT( E_General, "Win32JoyStick::_initialize() >> failed to set cooperation level!");
+        // Set buffer size.
         DIPROPDWORD dipdw;
         dipdw.diph.dwSize       = sizeof(DIPROPDWORD);
         dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
 …
         dipdw.dwData            = JOYSTICK_DX_BUFFERSIZE;
-        if(FAILED(mDirectInput->CreateDevice(deviceGuid, &mJoyStick, NULL)))
-                OIS_EXCEPT( E_General, "Win32JoyStick::_initialize() >> Could not initialize joy device!");
-        if(FAILED(mJoyStick->SetDataFormat(&c_dfDIJoystick2)))
-                OIS_EXCEPT( E_General, "Win32JoyStick::_initialize() >> data format error!");
-        HWND hwin = ((Win32InputManager*)mCreator)->getWindowHandle();
-        if(FAILED(mJoyStick->SetCooperativeLevel( hwin, coopSetting)))
-                OIS_EXCEPT( E_General, "Win32JoyStick::_initialize() >> failed to set cooperation level!");
         if( FAILED(mJoyStick->SetProperty(DIPROP_BUFFERSIZE, &dipdw.diph)) )
                 OIS_EXCEPT( E_General, "Win32Mouse::Win32Mouse >> Failed to set buffer size property" );
         //Enumerate all axes/buttons/sliders/etc before aquiring
+                OIS_EXCEPT( E_General, "Win32JoyStick::_initialize >> Failed to set buffer size property" );
+        // Enumerate all axes/buttons/sliders/force feedback/etc before aquiring
         _enumerate();
 …
 void Win32JoyStick::_enumerate()
+{
+        //We can check force feedback here too
+        DIDEVCAPS  DIJoyCaps;
+        DIJoyCaps.dwSize = sizeof(DIDEVCAPS);
+        mJoyStick->GetCapabilities(&DIJoyCaps);
+        mPOVs = (short)DIJoyCaps.dwPOVs;
+        mState.mButtons.resize(DIJoyCaps.dwButtons);
+        mState.mAxes.resize(DIJoyCaps.dwAxes);
+        // Get joystick capabilities.
+        mDIJoyCaps.dwSize = sizeof(DIDEVCAPS);
+        if( FAILED(mJoyStick->GetCapabilities(&mDIJoyCaps)) )
+                OIS_EXCEPT( E_General, "Win32JoyStick::_enumerate >> Failed to get capabilities" );
+        // => Number of POVs
+        mPOVs = (short)mDIJoyCaps.dwPOVs;
+        // => Number of buttons and axes.
+        mState.mButtons.resize(mDIJoyCaps.dwButtons);
+        mState.mAxes.resize(mDIJoyCaps.dwAxes);
+        // Enumerate all Force Feedback effects (if any)
+        mJoyStick->EnumEffects(DIEnumEffectsCallback, this, DIEFT_ALL);
         //Reset the axis mapping enumeration value
         _AxisNumber = 0;
+        //Enumerate Force Feedback (if any)
+        mJoyStick->EnumEffects(DIEnumEffectsCallback, this, DIEFT_ALL);
+        //Enumerate and set axis constraints (and check FF Axes)
+        // Enumerate and set axis constraints (and check FF Axes)
         mJoyStick->EnumObjects(DIEnumDeviceObjectsCallback, this, DIDFT_AXIS);
+}
 …
                 OIS_EXCEPT( E_General, "Win32JoyStick::_DIEnumDeviceObjectsCallback >> Failed to set min/max range property" );
         //Check if FF Axes
+        //Check if FF Axes, and if so, increment counter
         if((lpddoi->dwFlags & DIDOI_FFACTUATOR) != 0 )
+        {
                 if( _this->ff_device )
+                {
                         //todo - increment force feedback axis count
+                        _this->ff_device->_addFFAxis();
+                }
+        }
+        //Force the flags for gain and auto-center support to true,
+        //as DInput has no API to query the device for these capabilities
+        //(the only way to know is to try them ...)
+        if( _this->ff_device )
+        {
+            _this->ff_device->_setGainSupport(true);
+            _this->ff_device->_setAutoCenterSupport(true);
+        }
         return DIENUM_CONTINUE;
+}
 …
         Win32JoyStick* _this = (Win32JoyStick*)pvRef;
         //Create the FF class after we know there is at least one effect type
+        //Create the FF instance only after we know there is at least one effect type
         if( _this->ff_device == 0 )
                 _this->ff_device = new Win32ForceFeedback(_this->mJoyStick);
+          _this->ff_device = new Win32ForceFeedback(_this->mJoyStick, &_this->mDIJoyCaps);
         _this->ff_device->_addEffectSupport( pdei );

code/trunk/src/ois/win32/Win32JoyStick.h

r1505	r5695
60	60	IDirectInput8* mDirectInput;
61	61	IDirectInputDevice8* mJoyStick;
	62	DIDEVCAPS mDIJoyCaps;
	63
62	64	DWORD coopSetting;
63	65	GUID deviceGuid;

code/trunk/src/ois/win32/Win32KeyBoard.cpp

-                      r1505
+                      r5695
                 return 0;
+        unsigned char buff[3] = {0,0,0};
+        int ascii = ToAsciiEx(vk, kc, keyState, (LPWORD) buff, 0, layout);
+        //WCHAR wide[3];
+        //int ascii = ToUnicodeEx(vk, kc, keyState, wide, 3, 0, layout);
+        WCHAR buff[3] = {0};
+        int ascii = ToUnicodeEx(vk, kc, keyState, buff, 3, 0, layout);
         if(ascii == 1 && deadKey != '\0' )
+        {

code/trunk/src/orxonox/LevelManager.cc

-                      r3370
+                      r5695
 #include <map>
 #include <boost/filesystem.hpp>
+#include <OgreResourceGroupManager.h>
 #include "core/CommandLine.h"
 …
         availableLevels_.clear();
         boost::filesystem::directory_iterator file(Core::getMediaPathString() + "levels");
         boost::filesystem::directory_iterator end;
+        availableLevels_ = *Ogre::ResourceGroupManager::getSingleton().findResourceNames(
+            Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME, "*.oxw");
+        while (file != end)
+        {
+            if (!boost::filesystem::is_directory(*file) && file->string()[file->string().length()-1] != '~')
+        for (std::vector<std::string>::iterator it = availableLevels_.begin(); it != availableLevels_.end();)
+            if (it->find("old/") == 0)
+                it = availableLevels_.erase(it);
+            else
+            {
                 std::string filename = file->path().leaf();
                 if (filename.length() > 4)
                     availableLevels_.push_back(filename.substr(0,filename.length()-4));
+                size_t pos = it->find(".oxw");
+                *it = it->substr(0, pos);
+                ++it;
+            }
-            ++file;
+        }
+    }
+}

code/trunk/src/orxonox/Main.cc

-                      r5693
+                      r5695
 #include "core/CommandLine.h"
 #include "core/Game.h"
+#include "core/LuaState.h"
+#include "ToluaBindOrxonox.h"
 #include "Main.h"
 …
 SetCommandLineSwitch(dedicated).information("Start in dedicated server mode");
 SetCommandLineSwitch(standalone).information("Start in standalone mode");
+DeclareToluaInterface(Orxonox);
 namespace orxonox

code/trunk/src/orxonox/gamestates/GSDedicated.cc

-                      r3370
+                      r5695
 #include "GSDedicated.h"
+#include <iomanip>
+#include <iostream>
+#include <boost/bind.hpp>
 #include "util/Debug.h"
 …
 #include "core/GameMode.h"
 #include "network/Server.h"
-#include <iostream>
-#include <iomanip>
-#include <boost/bind.hpp>
 #ifdef ORXONOX_PLATFORM_UNIX

code/trunk/src/orxonox/gamestates/GSGraphics.cc

r5693	r5695
96	96	// load debug overlay
97	97	COUT(3) << "Loading Debug Overlay..." << std::endl;
98		this->debugOverlay_ = new XMLFile(~~Core::getMediaPathString() + "overlay/~~debug.oxo");
	98	this->debugOverlay_ = new XMLFile("debug.oxo");
99	99	Loader::open(debugOverlay_);
100	100

code/trunk/src/orxonox/gamestates/GSLevel.cc

-                      r5693
+                      r5695
 #include "GSLevel.h"
+#include <OgreCompositorManager.h>
 #include "core/input/InputManager.h"
 …
 */
+        if (GameMode::showsGraphics())
+        {
+            // unload all compositors (this is only necessary because we don't yet destroy all resources!)
+            Ogre::CompositorManager::getSingleton().removeAll();
+        }
         // this call will delete every BaseObject!
 …
         // call the loader
         COUT(0) << "Loading level..." << std::endl;
         startFile_s = new XMLFile(Core::getMediaPathString() + "levels" + '/' + LevelManager::getInstance().getDefaultLevel());
+        startFile_s = new XMLFile(LevelManager::getInstance().getDefaultLevel());
         Loader::open(startFile_s);
+    }

code/trunk/src/orxonox/gamestates/GSMainMenu.cc

-                      r3370
+                      r5695
         inputState_->setHandler(GUIManager::getInstancePtr());
         inputState_->setJoyStickHandler(&InputHandler::EMPTY);
+        inputState_->setIsExclusiveMouse(false);
         // create an empty Scene
 …
+    {
         // show main menu
         GUIManager::getInstance().showGUI("mainmenu_4");
+        GUIManager::getInstance().showGUI("MainMenu");
         GUIManager::getInstance().setCamera(this->camera_);
         GraphicsManager::getInstance().setCamera(this->camera_);

code/trunk/src/orxonox/gamestates/GSRoot.cc

-                      r5693
+                      r5695
 #include "core/Game.h"
 #include "core/GameMode.h"
-#include "core/LuaBind.h"
 #include "network/NetworkFunction.h"
-#include "ToluaBindCore.h"
-#include "ToluaBindOrxonox.h"
 #include "tools/Timer.h"
 #include "tools/interfaces/TimeFactorListener.h"
 …
         this->ccSetTimeFactor_ = 0;
         this->ccPause_ = 0;
-        // Tell LuaBind about all tolua interfaces
-        LuaBind::getInstance().addToluaInterface(&tolua_Core_open, "Core");
-        LuaBind::getInstance().addToluaInterface(&tolua_Orxonox_open, "Orxonox");
+    }
 …
+        }
         // create the global LevelManager
+        // create the LevelManager
         this->levelManager_ = new LevelManager();
+    }

code/trunk/src/orxonox/objects/Level.cc

-                      r3325
+                      r5695
         this->registerVariables();
         this->xmlfilename_ = this->getFilename();
-        if (this->xmlfilename_.length() >= Core::getMediaPathString().length())
-            this->xmlfilename_ = this->xmlfilename_.substr(Core::getMediaPathString().length());
+    }
 …
         mask.include(Class(OverlayGroup)); // HACK to include the ChatOverlay
         this->xmlfile_ = new XMLFile(Core::getMediaPathString() + this->xmlfilename_, mask);
+        this->xmlfile_ = new XMLFile(mask, this->xmlfilename_);
         Loader::open(this->xmlfile_);

code/trunk/src/orxonox/objects/Script.cc

-                      r3196
+                      r5695
 #include "Script.h"
-#include <tinyxml/ticpp.h>
 #include "core/CoreIncludes.h"
+#include "core/LuaBind.h"
+#include "core/LuaState.h"
+#include "core/XMLPort.h"
 namespace orxonox
+{
   CreateFactory(Script);
+    CreateFactory(Script);
   Script::Script(BaseObject* creator) : BaseObject(creator)
+  {
     RegisterObject(Script);
+    Script::Script(BaseObject* creator) : BaseObject(creator)
+    {
+        RegisterObject(Script);
+    code_ = "";
+  }
+        // Get a new LuaState
+        luaState_ = new LuaState();
+    }
+  Script::~Script()
+  {
+  }
+    Script::~Script()
+    {
+        if (this->isInitialized())
+            delete luaState_;
+    }
+  /**
+  @brief XML loading and saving.
+  @param xmlelement The XML-element
+  @param loading Loading (true) or saving (false)
+   */
+  void Script::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+  {
+    BaseObject::XMLPort(xmlelement, mode);
+    void Script::XMLPort(Element& xmlelement, XMLPort::Mode mode)
+    {
+        BaseObject::XMLPort(xmlelement, mode);
     code_ = xmlelement.GetText(false);
+  }
+        XMLPortParam(Script, "code", setCode, getCode, xmlelement, mode);
+    }
+  void Script::execute()
+  {
+    LuaBind& lua = LuaBind::getInstance();
+    lua.loadString(this->code_);
+    lua.run();
+  }
+    void Script::execute()
+    {
+        luaState_->doString(code_);
+    }
+}

code/trunk/src/orxonox/objects/Script.h

-                      r3196
+                      r5695
 namespace orxonox
+{
   class _OrxonoxExport Script : public BaseObject
+  {
+    class _OrxonoxExport Script : public BaseObject
+    {
     public:
+      Script(BaseObject* creator);
+      ~Script();
+      void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+      void execute();
+        Script(BaseObject* creator);
+        ~Script();
+        void XMLPort(Element& xmlelement, XMLPort::Mode mode);
+        void execute();
+        void setCode(const std::string& code) { code_ = code; }
+        const std::string& getCode() const { return code_; }
     private:
+      std::string code_;
+  };
+        std::string code_;
+        LuaState* luaState_;
+    };
+}

code/trunk/src/orxonox/orxonox-main.vcproj.user.in

-                      r5693
+                      r5695
                         <DebugSettings
                                 WorkingDirectory="${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$(OutDir)"
                                 Environment="Path=${ORXONOX_RUNTIME_LIBRARY_DIRECTORY}"
+                                Environment="Path=${RUNTIME_LIBRARY_DIRECTORY}"
                                 EnvironmentMerge="true"
                         />
 …
                         <DebugSettings
                                 WorkingDirectory="${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$(OutDir)"
                                 Environment="Path=${ORXONOX_RUNTIME_LIBRARY_DIRECTORY}"
+                                Environment="Path=${RUNTIME_LIBRARY_DIRECTORY}"
                                 EnvironmentMerge="true"
                         />
 …
                         <DebugSettings
                                 WorkingDirectory="${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$(OutDir)"
                                 Environment="Path=${ORXONOX_RUNTIME_LIBRARY_DIRECTORY}"
+                                Environment="Path=${RUNTIME_LIBRARY_DIRECTORY}"
                                 EnvironmentMerge="true"
                         />
 …
                         <DebugSettings
                                 WorkingDirectory="${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/$(OutDir)"
                                 Environment="Path=${ORXONOX_RUNTIME_LIBRARY_DIRECTORY}"
+                                Environment="Path=${RUNTIME_LIBRARY_DIRECTORY}"
                                 EnvironmentMerge="true"
                         />

code/trunk/src/orxonox/sound/SoundBase.cc

-                      r3370
+                      r5695
 #include "util/Math.h"
 #include "core/Core.h"
+#include "core/Resource.h"
 #include "orxonox/objects/worldentities/WorldEntity.h"
 #include "SoundManager.h"
 …
+    }
+    bool SoundBase::loadFile(std::string filename) {
+        filename = Core::getMediaPathString() + "/audio/" + filename;
+    bool SoundBase::loadFile(const std::string& filename) {
         if(!SoundManager::getInstance().isSoundAvailable())
+        {
 …
         COUT(3) << "Sound: OpenAL ALUT: loading file " << filename << std::endl;
+        this->buffer_ = alutCreateBufferFromFile(filename.c_str());
+        // Get DataStream from the resources
+        shared_ptr<ResourceInfo> fileInfo = Resource::getInfo(filename);
+        if (fileInfo == NULL) {
+            COUT(2) << "Warning: Sound file '" << filename << "' not found" << std::endl;
+            return false;
+        }
+        DataStreamPtr stream = Resource::open(filename);
+        // Read everything into a temporary buffer
+        char* buffer = new char[fileInfo->size];
+        stream->read(buffer, fileInfo->size);
+        this->buffer_ = alutCreateBufferFromFileImage(buffer, fileInfo->size);
+        delete[] buffer;
         if(this->buffer_ == AL_NONE) {
             COUT(2) << "Sound: OpenAL ALUT: " << alutGetErrorString(alutGetError()) << std::endl;

code/trunk/src/orxonox/sound/SoundBase.h

r5693	r5695
55	55	bool isStopped();
56	56
57		bool loadFile(~~std::string~~ filename);
	57	bool loadFile(const std::string& filename);
58	58
59	59	private:

code/trunk/src/orxonox/tools/CMakeLists.txt

r5693	r5695
5	5	Mesh.cc
6	6	ParticleInterface.cc
	7	ResourceCollection.cc
	8	ResourceLocation.cc
7	9	Shader.cc
8	10	TextureGenerator.cc

code/trunk/src/orxonox/tools/Mesh.cc

-                      r3280
+                      r5695
                 this->entity_->setCastShadows(this->bCastShadows_);
+#if OGRE_VERSION < 0x010600
                 this->entity_->setNormaliseNormals(true);
                 /*
 …
                     I don't know exactly what this means, but I put this here if there will be problems with shaders.
                 */
+#endif
+            }
             catch (...)

code/trunk/src/orxonox/tools/ResourceCollection.h

-                      r5694
+                      r5695
 #define _ResourceCollection_H__
 #include "OrxonoxPrereqs.h"
+#include "tools/ToolsPrereqs.h"
 #include <string>
 …
     class ResourceLocation;
     class _OrxonoxExport ResourceCollection : public BaseObject
+    class _ToolsExport ResourceCollection : public BaseObject
+    {
     public:

code/trunk/src/orxonox/tools/ResourceLocation.h

-                      r5694
+                      r5695
 #define _ResourceLocation_H__
 #include "OrxonoxPrereqs.h"
+#include "tools/ToolsPrereqs.h"
 #include <string>
 …
 namespace orxonox
+{
     class _OrxonoxExport ResourceLocation : public BaseObject
+    class _ToolsExport ResourceLocation : public BaseObject
+    {
         // for load/unload

code/trunk/src/util/CMakeLists.txt

-                      r5693
+                      r5695
+)
+SET_SOURCE_FILES(UTIL_HDR_FILES
+  CRC32.h
+  Clipboard.h
+  Convert.h
+  Debug.h
+  Exception.h
+  ExprParser.h
+  Math.h
+  MathConvert.h
+  mbool.h
+  MultiType.h
+  MultiTypeValue.h
+  OgreForwardRefs.h
+  OrxAssert.h
+  OrxEnum.h
+  OutputBuffer.h
+  OutputHandler.h
+  RefToValue.h
+  ScopeGuard.h
+  Serialise.h
+  SignalHandler.h
+  Singleton.h
+  Sleep.h
+  StringUtils.h
+  SubString.h
+  TemplateUtils.h
+  TypeTraits.h
+  UTFStringConversions.h
+  UtilPrereqs.h
+)
 IF(GCC_NO_SYSTEM_HEADER_SUPPORT)
   # Get around displaying a few hundred lines of warning code
 …
 ORXONOX_ADD_LIBRARY(util
-  FIND_HEADER_FILES
   DEFINE_SYMBOL
     "UTIL_SHARED_BUILD"
 …
     ${OGRE_LIBRARY}
   SOURCE_FILES
     ${UTIL_SRC_FILES}
+    ${UTIL_SRC_FILES} ${UTIL_HDR_FILES}
+)

code/trunk/src/util/Debug.h

-                      r3196
+                      r5695
 /**
     @file
     @brief Handles different output-levels of errors, warnings, infos and debug informations.
+    @brief Handles different output-levels of errors, warnings, infos and debug information.
     The COUT(level) macro acts like std::cout, but the output is only performed if the given
 …
 : Errors
 : Warnings
 : Informations
+: Information
 : Debug information
 : More debug information
 : Crazy debug informations
+: Crazy debug information
     @example

Context Navigation

Legend:

Download in other formats: