Changeset 1755 for code/trunk/src

code/trunk

Property svn:mergeinfo changed

/code/branches/gui (added)	merged: 1636,1638,1640-1647,1649-1654,1656,1659-1665,1670,1672-1674,1686,1688-1692,1694-1697,1704
/code/branches/input (added)	merged: 1629-1630

code/trunk/src/core/CMakeLists.txt

-                      r1747
+                      r1755
 SET(CORE_SRC_FILES
+  Clock.cc
   ConfigFileManager.cc
   ConfigValueContainer.cc
   Core.cc
+  Exception.cc
+  GameState.cc
   Language.cc
   ObjectListBase.cc
   OrxonoxClass.cc
+  RootGameState.cc
   Script.cc
 …
   CommandEvaluation.cc
   CommandExecutor.cc
+  CommandLine.cc
   ConsoleCommand.cc
   ConsoleCommandCompilation.cc
 …
   input/Button.cc
   input/CalibratorCallback.cc
+  input/ExtendedInputState.cc
   input/HalfAxis.cc
   input/InputBuffer.cc
 …
   input/KeyBinder.cc
   input/KeyDetector.cc
+  input/SimpleInputState.cc
   tolua/tolua_bind.cc
 …
 ADD_CUSTOM_COMMAND(
   OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/tolua/tolua_bind.cc
   COMMAND ${TOLUA_EXE} -n core -o ../../src/core/tolua/tolua_bind.cc -H ../../src/core/tolua/tolua_bind.h ../../src/core/tolua/tolua.pkg
+  COMMAND ${TOLUA_EXE} -n Core -o ../../src/core/tolua/tolua_bind.cc -H ../../src/core/tolua/tolua_bind.h ../../src/core/tolua/tolua.pkg
   DEPENDS tolua
   WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin/lib

code/trunk/src/core/ClassTreeMask.h

r1747	r1755
60	60	step back, and so on.
61	61
62		Example: A and B are child~~s of BaseObject, A1 and A2 are childs of A, B1 and B2 are childs~~ of B.
	62	Example: A and B are children of BaseObject, A1 and A2 are children of A, B1 and B2 are children of B.
63	63	The ClassTreeMaskIterator would move trough the tree in the following order:
64	64	BaseObject, A, A1, A2, B, B1, B2.

code/trunk/src/core/CommandExecutor.h

-                      r1505
+                      r1755
 #include "CommandEvaluation.h"
 namespace orxonox
+{
+namespace orxonox // tolua_export
+{ // tolua_export
     class _CoreExport CommandExecutor
+    /*
+    class CommandExecutor { // tolua_export
+    */
+    {
         public:
             static bool execute(const std::string& command, bool useTcl = true);
+            static bool execute(const std::string& command, bool useTcl = true); // tolua_export
             static std::string complete(const std::string& command);
             static std::string hint(const std::string& command);
 …
             std::map<std::string, ConsoleCommand*> consoleCommandShortcuts_;
             std::map<std::string, ConsoleCommand*> consoleCommandShortcuts_LC_;
     };
+}
+    }; // tolua_export
+} // tolua_export
 #endif /* _CommandExecutor_H__ */

code/trunk/src/core/CommandLine.h

r1724	r1755
33	33	#include <map>
34	34	#include "util/Convert.h"
35		#include "Debug.h"
	35	#include "util/Debug.h"
36	36	#include "Exception.h"
37	37

code/trunk/src/core/ConsoleCommand.cc

r1747	r1755
31	31	namespace orxonox
32	32	{
33		ConsoleCommand::ConsoleCommand(Functor~~Static* functor, const std::string& name) : ExecutorStatic~~(functor, name)
	33	ConsoleCommand::ConsoleCommand(Functor* functor, const std::string& name) : Executor(functor, name)
34	34	{
35	35	this->accessLevel_ = AccessLevel::None;

code/trunk/src/core/ConsoleCommand.h

-                      r1747
+                      r1755
+    }
     class _CoreExport ConsoleCommand : public ExecutorStatic
+    class _CoreExport ConsoleCommand : public Executor
+    {
         public:
             ConsoleCommand(FunctorStatic* functor, const std::string& name = "");
+            ConsoleCommand(Functor* functor, const std::string& name = "");
             inline ConsoleCommand& description(const std::string& description)
                 { this->ExecutorStatic::setDescription(description); return (*this); }
+                { this->Executor::setDescription(description); return (*this); }
             inline ConsoleCommand& descriptionParam(int param, const std::string& description)
                 { this->ExecutorStatic::setDescriptionParam(param, description); return (*this); }
+                { this->Executor::setDescriptionParam(param, description); return (*this); }
             inline ConsoleCommand& descriptionReturnvalue(const std::string& description)
                 { this->ExecutorStatic::setDescriptionReturnvalue(description); return (*this); }
+                { this->Executor::setDescriptionReturnvalue(description); return (*this); }
             inline ConsoleCommand& defaultValues(const MultiType& param1)
                 { this->ExecutorStatic::setDefaultValues(param1); return (*this); }
+                { this->Executor::setDefaultValues(param1); return (*this); }
             inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2)
                 { this->ExecutorStatic::setDefaultValues(param1, param2); return (*this); }
+                { this->Executor::setDefaultValues(param1, param2); return (*this); }
             inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3)
                 { this->ExecutorStatic::setDefaultValues(param1, param2, param3); return (*this); }
+                { this->Executor::setDefaultValues(param1, param2, param3); return (*this); }
             inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4)
                 { this->ExecutorStatic::setDefaultValues(param1, param2, param3, param4); return (*this); }
+                { this->Executor::setDefaultValues(param1, param2, param3, param4); return (*this); }
             inline ConsoleCommand& defaultValues(const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5)
                 { this->ExecutorStatic::setDefaultValues(param1, param2, param3, param4, param5); return (*this); }
+                { this->Executor::setDefaultValues(param1, param2, param3, param4, param5); return (*this); }
             inline ConsoleCommand& defaultValue(unsigned int index, const MultiType& param)
                 { this->ExecutorStatic::setDefaultValue(index, param); return (*this); }
+                { this->Executor::setDefaultValue(index, param); return (*this); }
             inline ConsoleCommand& accessLevel(AccessLevel::Level level)
 …
     };
     inline ConsoleCommand* createConsoleCommand(FunctorStatic* functor, const std::string& name = "")
+    inline ConsoleCommand* createConsoleCommand(Functor* functor, const std::string& name = "")
+    {
         return new ConsoleCommand(functor, name);

code/trunk/src/core/Core.cc

-                      r1747
+                      r1755
  *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
+ *      Reto Grieder
+ *
  */
 …
 #include "CoreIncludes.h"
 #include "ConfigValueIncludes.h"
 #include "input/InputManager.h"
 #include "TclThreadManager.h"
+//#include "input/InputManager.h"
+//#include "TclThreadManager.h"
 namespace orxonox
 …
+    }
     /**
         @brief Ticks every core class in a specified sequence. Has to be called
                every Orxonox tick!
         @param dt Delta Time
     */
     void Core::tick(float dt)
+    {
         TclThreadManager::getInstance().tick(dt);
         InputManager::tick(dt);
+    }
+    ///**
+    //    @brief Ticks every core class in a specified sequence. Has to be called
+    //           every Orxonox tick!
+    //    @param dt Delta Time
+    //*/
+    //void Core::tick(float dt)
+    //{
+    //    TclThreadManager::getInstance().tick(dt);
+    //    InputManager::getInstance().tick(dt);
+    //}
+}

code/trunk/src/core/Core.h

-                      r1747
+                      r1755
  *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
+ *      Reto Grieder
+ *
  */
 …
 /**
     @file Core.h
     @brief Definition of the Core class.
+    @brief Declaration of the Core class.
     The Core class is a singleton, only used to configure some variables
 …
             static void resetLanguage();
             static void tick(float dt);
+            //static void tick(float dt);
         private:

code/trunk/src/core/CoreIncludes.h

r1747	r1755
111	111	@param StringOrInt The name or the network ID of the class
112	112	*/
113		#define ID(StringOrInt) \
	113	#define GetIdentifier(StringOrInt) \
114	114	orxonox::Factory::getIdentifier(StringOrInt)
115	115

code/trunk/src/core/CorePrereqs.h

-                      r1747
+                      r1755
   class ClassTreeMaskIterator;
   class ClassTreeMaskNode;
+  class Clock;
   class CommandEvaluation;
   class CommandExecutor;
+  class CommandLine;
+  class BaseCommandLineArgument;
+  template <class T>
+  class CommandLineArgument;
   class ConfigFile;
   class ConfigFileEntry;
 …
   class XMLPortParamContainer;
+  // game states
+  class GameStateBase;
+  template <class ParentType>
+  class GameState;
+  class RootGameState;
   // input
-  //class GUIInputHandler;
   class BaseCommand;
   class BufferedParamCommand;
   class Button;
   class CalibratorCallback;
+  class ExtendedInputState;
   class HalfAxis;
   class InputBuffer;
   class InputManager;
+  class InputState;
   class JoyStickHandler;
   class MouseHandler;
 …
   class ParamCommand;
   class SimpleCommand;
+  class SimpleInputState;
+}

code/trunk/src/core/Exception.h

r1724	r1755
41	41	#include <exception>
42	42	#include <cassert>
43		#include "~~core~~/Debug.h"
	43	#include "util/Debug.h"
44	44
45	45	// Define some ugly macros to make things more clear

code/trunk/src/core/GameState.cc

r1724	r1755
34	34
35	35	#include "GameState.h"
36		#include "Debug.h"
	36	#include "util/Debug.h"
37	37	#include "Exception.h"
38	38

code/trunk/src/core/Identifier.h

r1747	r1755
78	78	- the name
79	79	- a list with all objects
80		- parents and childs
	80	- parents and children
81	81	- the factory (if available)
82	82	- the networkID that can be synchronised with the server

code/trunk/src/core/Loader.cc

r1747	r1755
65	65	void Loader::add(const Level* level, const ClassTreeMask& mask)
66	66	{
	67	if (!level)
	68	return;
67	69	Loader::levels_s.insert(Loader::levels_s.end(), std::pair<const Level*, ClassTreeMask>(level, mask));
68	70	}
…	…
70	72	void Loader::remove(const Level* level)
71	73	{
	74	if (!level)
	75	return;
72	76	for (std::vector<std::pair<const Level*, ClassTreeMask> >::iterator it = Loader::levels_s.begin(); it != Loader::levels_s.end(); ++it)
73	77	{
…	…
109	113	bool Loader::load(const Level* level, const ClassTreeMask& mask)
110	114	{
	115	if (!level)
	116	return false;
	117
111	118	Loader::currentMask_s = level->getMask() * mask;
112	119
…	…
166	173	void Loader::unload(const Level* level, const ClassTreeMask& mask)
167	174	{
	175	if (!level)
	176	return;
168	177	for (ObjectList<BaseObject>::iterator it = ObjectList<BaseObject>::begin(); it; )
169	178	{

code/trunk/src/core/OrxonoxClass.h

r1505	r1755
29	29	/**
30	30	@file OrxonoxClass.h
31		@brief De~~fini~~tion of the OrxonoxClass Class.
	31	@brief Declaration of the OrxonoxClass Class.
32	32
33	33	All objects and interfaces of the game-logic (not the engine) are derived from OrxonoxClass.

code/trunk/src/core/RootGameState.cc

-                      r1724
+                      r1755
 #include "util/String.h"
 #include "util/SubString.h"
+#include "util/Debug.h"
+#include "Core.h"
 #include "Clock.h"
-#include "Debug.h"
 #include "Exception.h"
 #include "CommandLine.h"

code/trunk/src/core/Script.cc

-                      r1555
+                      r1755
     luaopen_debug(luaState_);
 #endif
     tolua_core_open(luaState_);
+    tolua_Core_open(luaState_);
     output_ = "";
+  }
 …
       for (std::map<unsigned int, bool>::iterator it = luaTags.begin(); it != luaTags.end(); ++it)
+      {
         if ((*it).second == expectedValue)
+        if (it->second == expectedValue)
           expectedValue = !expectedValue;
         else

code/trunk/src/core/Script.h

-                      r1625
+                      r1755
 /**
  @file  script.h
+ @file
  @brief Representation of an interface to lua
  @author Benjamin Knecht <beni_at_orxonox.net>
 …
 namespace orxonox // tolua_export
 { // tolua_export
+  class _CoreExport Script // tolua_export
+  { // tolua_export
+  class _CoreExport Script
+  /*
+  class Script { // tolua_export
+  */
+  {
     struct LoadS {
       const char *s;

code/trunk/src/core/Shell.cc

-                      r1747
+                      r1755
 #include "Core.h"
 #include "ConsoleCommand.h"
-#include "input/InputInterfaces.h"
 #include "util/OutputHandler.h"
 …
         this->clearLines();
         this->inputBuffer_ = 0;
         this->setInputBuffer(new InputBuffer());
+        this->inputBuffer_ = new InputBuffer();
+        this->configureInputBuffer();
         this->outputBuffer_.registerListener(this);
 …
         this->setConfigValues();
+    }
+    Shell::~Shell()
+    {
+        if (this->inputBuffer_)
+            delete this->inputBuffer_;
+    }
 …
+    }
+    void Shell::setInputBuffer(InputBuffer* buffer)
+    {
+        if (this->inputBuffer_)
+        {
+            this->inputBuffer_->unregisterListener(this);
+            // TODO: may be very dangerous. InputManager already deletes InputBuffer instance!!!
+            delete this->inputBuffer_;
+        }
+        this->inputBuffer_ = buffer;
+    void Shell::configureInputBuffer()
+    {
         this->inputBuffer_->registerListener(this, &Shell::inputChanged, true);
         this->inputBuffer_->registerListener(this, &Shell::execute, '\r', false);

code/trunk/src/core/Shell.h

-                      r1747
+                      r1755
             void unregisterListener(ShellListener* listener);
+            void setInputBuffer(InputBuffer* buffer);
+            inline InputBuffer& getInputBuffer()
+                { return (*this->inputBuffer_); }
+            inline InputBuffer* getInputBuffer()
+                { return this->inputBuffer_; }
             inline OutputBuffer& getOutputBuffer()
                 { return this->outputBuffer_; }
 …
             Shell();
             Shell(const Shell& other);
+            virtual ~Shell() {}
+            virtual ~Shell();
+            void configureInputBuffer();
             void addToHistory(const std::string& command);

code/trunk/src/core/XMLPort.h

r1747	r1755
298	298	for (ticpp::Iterator<ticpp::Element> child = xmlsubelement->FirstChildElement(false); child != child.end(); child++)
299	299	{
300		Identifier* identifier = ID(child->Value());
	300	Identifier* identifier = GetIdentifier(child->Value());
301	301	if (identifier)
302	302	{

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

-                      r1747
+                      r1755
 /**
+ @file
+ @brief Implementation of the different input handlers.
+ */
+@file
+@brief
+    Implementation of the different input handlers.
+*/
 #include "Button.h"
 …
 namespace orxonox
+{
+  void Button::clear()
+  {
+    for (unsigned int j = 0; j < 3; j++)
+    {
+      if (nCommands_[j])
+      {
+        // delete all commands and the command pointer array
+        for (unsigned int i = 0; i < nCommands_[j]; i++)
+          delete commands_[j][i];
+        delete[] commands_[j];
+        commands_[j] = 0;
+        nCommands_[j] = 0;
+      }
+      else
+      {
+        commands_[j] = 0;
+      }
+    }
+  }
+  void Button::parse(std::vector<BufferedParamCommand*>& paramCommandBuffer)
+  {
+    if (isEmpty(bindingString_))
+    {
+      clear();
+      return;
+    }
+    // use std::vector for a temporary dynamic array
+    std::vector<BaseCommand*> commands[3];
+    // separate the commands
+    SubString commandStrings(bindingString_, "|", SubString::WhiteSpaces, false,
+        '\\', false, '"', false, '(', ')', false, '\0');
+    for (unsigned int iCommand = 0; iCommand < commandStrings.size(); iCommand++)
+    {
+      if (commandStrings[iCommand] != "")
+      {
+        SubString tokens(commandStrings[iCommand], " ", SubString::WhiteSpaces, false,
+    void Button::clear()
+    {
+        for (unsigned int j = 0; j < 3; j++)
+        {
+            if (nCommands_[j])
+            {
+                // delete all commands and the command pointer array
+                for (unsigned int i = 0; i < nCommands_[j]; i++)
+                    delete commands_[j][i];
+                delete[] commands_[j];
+                commands_[j] = 0;
+                nCommands_[j] = 0;
+            }
+            else
+            {
+                commands_[j] = 0;
+            }
+        }
+    }
+    void Button::parse(std::vector<BufferedParamCommand*>& paramCommandBuffer)
+    {
+        if (isEmpty(bindingString_))
+        {
+            clear();
+            return;
+        }
+        // use std::vector for a temporary dynamic array
+        std::vector<BaseCommand*> commands[3];
+        // separate the commands
+        SubString commandStrings(bindingString_, "|", SubString::WhiteSpaces, false,
             '\\', false, '"', false, '(', ')', false, '\0');
+        unsigned int iToken = 0;
+        // for real axes, we can feed a ButtonThreshold argument as entire command
+        if (getLowercase(tokens[0]) == "buttonthreshold")
+        {
+          if (tokens.size() == 1)
+            continue;
+          // may fail, but doesn't matter
+          convertValue(&buttonThreshold_, tokens[1]);
+          continue;
+        }
+        // first argument can be OnPress, OnHold OnRelease or nothing
+        KeybindMode::Enum mode = KeybindMode::None;
+        if (getLowercase(tokens[iToken]) == "onpress")
+          mode = KeybindMode::OnPress,   iToken++;
+        if (getLowercase(tokens[iToken]) == "onrelease")
+          mode = KeybindMode::OnRelease, iToken++;
+        if (getLowercase(tokens[iToken]) == "onhold")
+          mode = KeybindMode::OnHold,    iToken++;
+        if (iToken == tokens.size())
+          continue;
+        // second argument can be the amplitude for the case it as an axis command
+        // default amplitude is 1.0f
+        float paramModifier = 1.0f;
+        if (getLowercase(tokens[iToken]) == "scale")
+        {
+          iToken++;
+          if (iToken == tokens.size() || !convertValue(&paramModifier, tokens[iToken]))
+          {
+            COUT(2) << "Error while parsing key binding " << name_
+                << ". Numeric expression expected afer 'AxisAmp', switching to default value" << std::endl;
+            if (iToken == tokens.size())
+              continue;
+          }
+          iToken++;
+        }
+        // no more arguments expected except for the actual command
+        if (iToken == tokens.size())
+          continue;
+        std::string commandStr;
+        while (iToken != tokens.size())
+          commandStr += tokens[iToken++] + " ";
+        // evaluate the command
+        CommandEvaluation eval = CommandExecutor::evaluate(commandStr);
+        if (!eval.isValid())
+          continue;
+        // check for param command
+        int paramIndex = eval.getConsoleCommand()->getAxisParamIndex();
+        if (paramIndex >= 0)
+        {
+          // parameter supported command
+          ParamCommand* cmd = new ParamCommand();
+          cmd->paramModifier_ = paramModifier;
+          cmd->bRelative_ = eval.getConsoleCommand()->getIsAxisRelative();
+          // add command to the buffer if not yet existing
+          for (unsigned int iParamCmd = 0; iParamCmd < paramCommandBuffer.size(); iParamCmd++)
+          {
+            if (getLowercase(paramCommandBuffer[iParamCmd]->evaluation_.getOriginalCommand())
+                == getLowercase(commandStr))
+            {
+              // already in list
+              cmd->paramCommand_ = paramCommandBuffer[iParamCmd];
+              break;
+            }
+          }
+          if (cmd->paramCommand_ == 0)
+          {
+            cmd->paramCommand_ = new BufferedParamCommand();
+            paramCommandBuffer.push_back(cmd->paramCommand_);
+            cmd->paramCommand_->evaluation_ = eval;
+            cmd->paramCommand_->paramIndex_ = paramIndex;
+          }
+          // we don't know whether this is an actual axis or just a button
+          if (mode == KeybindMode::None)
+          {
+            if (!addParamCommand(cmd))
+            {
+              mode = eval.getConsoleCommand()->getKeybindMode();
+              commands[mode].push_back(cmd);
+            }
+          }
+        for (unsigned int iCommand = 0; iCommand < commandStrings.size(); iCommand++)
+        {
+            if (commandStrings[iCommand] != "")
+            {
+                SubString tokens(commandStrings[iCommand], " ", SubString::WhiteSpaces, false,
+                    '\\', false, '"', false, '(', ')', false, '\0');
+                KeybindMode::Enum mode = KeybindMode::None;
+                float paramModifier = 1.0f;
+                std::string commandStr = "";
+                for (unsigned int iToken = 0; iToken < tokens.size(); ++iToken)
+                {
+                    std::string token = getLowercase(tokens[iToken]);
+                    if (token == "onpress")
+                        mode = KeybindMode::OnPress;
+                    else if (token == "onrelease")
+                        mode = KeybindMode::OnRelease;
+                    else if (token == "onhold")
+                        mode = KeybindMode::OnHold;
+                    else if (token == "buttonthreshold")
+                    {
+                        // for real axes, we can feed a ButtonThreshold argument
+                        ++iToken;
+                        if (iToken == tokens.size())
+                            continue;
+                        // may fail, but doesn't matter (default value already set)
+                        if (!convertValue(&buttonThreshold_, tokens[iToken + 1]))
+                            parseError("Could not parse 'ButtonThreshold' argument. \
+                                Switching to default value.", true);
+                    }
+                    else if (token == "scale")
+                    {
+                        ++iToken;
+                        if (iToken == tokens.size() || !convertValue(&paramModifier, tokens[iToken]))
+                            parseError("Could not parse 'scale' argument. Switching to default value.", true);
+                    }
+                    else
+                    {
+                        // no input related argument
+                        // we interpret everything from here as a command string
+                        while (iToken != tokens.size())
+                            commandStr += tokens[iToken++] + " ";
+                    }
+                }
+                if (commandStr == "")
+                {
+                    parseError("No command string given.", false);
+                    continue;
+                }
+                // evaluate the command
+                CommandEvaluation eval = CommandExecutor::evaluate(commandStr);
+                if (!eval.isValid())
+                {
+                    parseError("Command evaluation failed.", true);
+                    continue;
+                }
+                // check for param command
+                int paramIndex = eval.getConsoleCommand()->getAxisParamIndex();
+                if (paramIndex >= 0)
+                {
+                    // parameter supported command
+                    ParamCommand* cmd = new ParamCommand();
+                    cmd->paramModifier_ = paramModifier;
+                    cmd->bRelative_ = eval.getConsoleCommand()->getIsAxisRelative();
+                    // add command to the buffer if not yet existing
+                    for (unsigned int iParamCmd = 0; iParamCmd < paramCommandBuffer.size(); iParamCmd++)
+                    {
+                        if (getLowercase(paramCommandBuffer[iParamCmd]->evaluation_.getOriginalCommand())
+                            == getLowercase(commandStr))
+                        {
+                            // already in list
+                            cmd->paramCommand_ = paramCommandBuffer[iParamCmd];
+                            break;
+                        }
+                    }
+                    if (cmd->paramCommand_ == 0)
+                    {
+                        cmd->paramCommand_ = new BufferedParamCommand();
+                        paramCommandBuffer.push_back(cmd->paramCommand_);
+                        cmd->paramCommand_->evaluation_ = eval;
+                        cmd->paramCommand_->paramIndex_ = paramIndex;
+                    }
+                    // we don't know whether this is an actual axis or just a button
+                    if (mode == KeybindMode::None)
+                    {
+                        if (!addParamCommand(cmd))
+                        {
+                            mode = eval.getConsoleCommand()->getKeybindMode();
+                            commands[mode].push_back(cmd);
+                        }
+                    }
+                }
+                else
+                {
+                    SimpleCommand* cmd = new SimpleCommand();
+                    cmd->evaluation_ = eval;
+                    if (mode == KeybindMode::None)
+                        mode = eval.getConsoleCommand()->getKeybindMode();
+                    commands[mode].push_back(cmd);
+                }
+            }
+        }
+        for (unsigned int j = 0; j < 3; j++)
+        {
+            nCommands_[j] = commands[j].size();
+            if (nCommands_[j])
+            {
+                commands_[j] = new BaseCommand*[nCommands_[j]];
+                for (unsigned int i = 0; i < commands[j].size(); i++)
+                    commands_[j][i] = commands[j][i];
+            }
+            else
+                commands_[j] = 0;
+        }
+    }
+    bool Button::execute(KeybindMode::Enum mode, float abs, float rel)
+    {
+        // execute all the parsed commands in the string
+        for (unsigned int iCommand = 0; iCommand < nCommands_[mode]; iCommand++)
+            commands_[mode][iCommand]->execute(abs, rel);
+        return true;
+    }
+    inline void Button::parseError(std::string message, bool serious)
+    {
+        if (serious)
+        {
+            COUT(2) << "Error while parsing binding for button/axis" << this->name_ << ". "
+                << message << std::endl;
+        }
         else
+        {
+          SimpleCommand* cmd = new SimpleCommand();
+          cmd->evaluation_ = eval;
+          if (mode == KeybindMode::None)
+            mode = eval.getConsoleCommand()->getKeybindMode();
+          commands[mode].push_back(cmd);
+        }
+      }
+    }
+    for (unsigned int j = 0; j < 3; j++)
+    {
+      nCommands_[j] = commands[j].size();
+      if (nCommands_[j])
+      {
+        commands_[j] = new BaseCommand*[nCommands_[j]];
+        for (unsigned int i = 0; i < commands[j].size(); i++)
+          commands_[j][i] = commands[j][i];
+      }
+      else
+        commands_[j] = 0;
+    }
+  }
+  bool Button::execute(KeybindMode::Enum mode, float abs, float rel)
+  {
+    // execute all the parsed commands in the string
+    for (unsigned int iCommand = 0; iCommand < nCommands_[mode]; iCommand++)
+      commands_[mode][iCommand]->execute(abs, rel);
+    return true;
+  }
+            COUT(3) << "Warning while parsing binding for button/axis" << this->name_ << ". "
+                << message << std::endl;
+        }
+    }
+}

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

-                      r1535
+                      r1755
 /**
+ @file
+ @brief Different definitions of input processing.
+ */
+@file
+@brief
+    Different definitions of input processing.
+*/
 #ifndef _Button_H__
 …
 namespace orxonox
+{
   class _CoreExport Button
+  {
   public:
     Button() { nCommands_[0]=0; nCommands_[1]=0; nCommands_[2]=0; clear(); }
     virtual ~Button() { clear(); }
     virtual void clear();
     virtual bool addParamCommand(ParamCommand* command) { return false; }
     void parse(std::vector<BufferedParamCommand*>& paramCommandBuffer);
     bool execute(KeybindMode::Enum mode, float abs = 1.0f, float rel = 1.0f);
+    class _CoreExport Button
+    {
+    public:
+        Button() { nCommands_[0]=0; nCommands_[1]=0; nCommands_[2]=0; clear(); }
+        virtual ~Button() { clear(); }
+        virtual void clear();
+        virtual bool addParamCommand(ParamCommand* command) { return false; }
+        void parse(std::vector<BufferedParamCommand*>& paramCommandBuffer);
+        bool execute(KeybindMode::Enum mode, float abs = 1.0f, float rel = 1.0f);
+    //! The configured string value
+    std::string bindingString_;
+    //! Name of the trigger as strings
+    std::string name_;
+    //! Basic commands for OnPress, OnHold and OnRelease
+    BaseCommand** commands_[3];
+    //! Number of basic commands
+    unsigned int nCommands_[3];
+    //! Says how much it takes for an analog axis to trigger a button
+    //! Note: This variable is here to have only one parse() function.
+    float buttonThreshold_;
+  };
+        //! The configured string value
+        std::string bindingString_;
+        //! Name of the trigger as strings
+        std::string name_;
+        //! Basic commands for OnPress, OnHold and OnRelease
+        BaseCommand** commands_[3];
+        //! Number of basic commands
+        unsigned int nCommands_[3];
+        //! Says how much it takes for an analog axis to trigger a button
+        //! Note: This variable is here to have only one parse() function.
+        float buttonThreshold_;
+    private:
+        void parseError(std::string message, bool serious);
+    };
+}

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

-                      r1535
+                      r1755
 /**
+ @file
+ @brief Implementation of the different input handlers.
+ */
+@file
+@brief
+    Implementation of the different input handlers.
+*/
 #include "CalibratorCallback.h"
 …
 namespace orxonox
+{
+  void CalibratorCallback::keyPressed(const orxonox::KeyEvent &evt)
+  {
+    if (evt.key == KeyCode::Return)
+    void CalibratorCallback::keyPressed(const orxonox::KeyEvent &evt)
+    {
+      InputManager::setInputState(InputManager::IS_NOCALIBRATE);
+        if (evt.key == KeyCode::Return)
+        {
+            //InputManager::setInputState(InputManager::IS_NOCALIBRATE);
+        }
+    }
+  }
+}

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

-                      r1535
+                      r1755
 /**
+ @file
+ @brief Different definitions of input processing.
+ */
+@file
+@brief
+    Different definitions of input processing.
+*/
 #ifndef _CalibratorCallback_H__
 …
 #include "core/CorePrereqs.h"
 #include "InputInterfaces.h"
 namespace orxonox
+{
   class _CoreExport CalibratorCallback : public KeyHandler
+  {
   public:
     CalibratorCallback() {}
     ~CalibratorCallback() {}
+    class _CoreExport CalibratorCallback : public KeyHandler
+    {
+    public:
+        CalibratorCallback()  { }
+        ~CalibratorCallback() { }
   private:
     void keyPressed (const KeyEvent& evt);
     void keyReleased(const KeyEvent& evt) {}
     void keyHeld    (const KeyEvent& evt) {}
+    private:
+        void keyPressed (const KeyEvent& evt);
+        void keyReleased(const KeyEvent& evt) { }
+        void keyHeld    (const KeyEvent& evt) { }
     void tickInput(float dt, const HandlerState &state) { }
   };
+        void tickInput(float dt) { }
+    };
+}

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

r1724	r1755
36	36
37	37	#include <assert.h>
38		#include "~~core~~/Debug.h"
	38	#include "util/Debug.h"
39	39
40	40	namespace orxonox

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

-                      r1535
+                      r1755
 /**
+ @file
+ @brief Implementation of the different input handlers.
+ */
+@file
+@brief
+    Implementation of the different input handlers.
+*/
 #include "HalfAxis.h"
 …
 namespace orxonox
+{
+  void HalfAxis::clear()
+  {
+    Button::clear();
+    if (nParamCommands_)
+    void HalfAxis::clear()
+    {
+      // delete all commands and the command pointer array
+      for (unsigned int i = 0; i < nParamCommands_; i++)
+        delete paramCommands_[i];
+      delete[] paramCommands_;
+      nParamCommands_ = 0;
+        Button::clear();
+        if (nParamCommands_)
+        {
+            // delete all commands and the command pointer array
+            for (unsigned int i = 0; i < nParamCommands_; i++)
+                delete paramCommands_[i];
+            delete[] paramCommands_;
+            nParamCommands_ = 0;
+        }
+        else
+        {
+            nParamCommands_ = 0; nParamCommands_ = 0;
+        }
+    }
+    else
+    bool HalfAxis::addParamCommand(ParamCommand* command)
+    {
+      nParamCommands_ = 0; nParamCommands_ = 0;
+        ParamCommand** cmds = paramCommands_;
+        paramCommands_ = new ParamCommand*[++nParamCommands_];
+        unsigned int i;
+        for (i = 0; i < nParamCommands_ - 1; i++)
+            paramCommands_[i] = cmds[i];
+        paramCommands_[i] = command;
+        if (nParamCommands_ > 1)
+            delete[] cmds;
+        return true;
+    }
+  }
+  bool HalfAxis::addParamCommand(ParamCommand* command)
+  {
+    ParamCommand** cmds = paramCommands_;
+    paramCommands_ = new ParamCommand*[++nParamCommands_];
+    unsigned int i;
+    for (i = 0; i < nParamCommands_ - 1; i++)
+      paramCommands_[i] = cmds[i];
+    paramCommands_[i] = command;
+    if (nParamCommands_ > 1)
+      delete[] cmds;
+    return true;
+  }
+  bool HalfAxis::execute()
+  {
+    bool success = true;
+    for (unsigned int i = 0; i < nParamCommands_; i++)
+      success = success && paramCommands_[i]->execute(absVal_, relVal_);
+    return success;
+  }
+    bool HalfAxis::execute()
+    {
+        bool success = true;
+        for (unsigned int i = 0; i < nParamCommands_; i++)
+            success = success && paramCommands_[i]->execute(absVal_, relVal_);
+        return success;
+    }
+}

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

-                      r1535
+                      r1755
 /**
+ @file
+ @brief Different definitions of input processing.
+ */
+@file
+@brief
+    Different definitions of input processing.
+*/
 #ifndef _HalfAxis_H__
 …
 namespace orxonox
+{
+  class _CoreExport HalfAxis : public Button
+  {
+  public:
+    HalfAxis() : relVal_(0.0f), absVal_(0.0f), paramCommands_(0), nParamCommands_(0),
+                 wasDown_(false), hasChanged_(false) { }
+    using Button::execute;
+    bool execute();
+    bool addParamCommand(ParamCommand* command);
+    void clear();
+    class _CoreExport HalfAxis : public Button
+    {
+    public:
+        HalfAxis()
+            : relVal_(0.0f)
+            , absVal_(0.0f)
+            , paramCommands_(0)
+            , nParamCommands_(0)
+            , wasDown_(false)
+            , hasChanged_(false)
+        { }
+        using Button::execute;
+        bool execute();
+        bool addParamCommand(ParamCommand* command);
+        void clear();
     // axis related
     float relVal_;
     float absVal_;
     ParamCommand** paramCommands_;
     unsigned int nParamCommands_;
+        // axis related
+        float relVal_;
+        float absVal_;
+        ParamCommand** paramCommands_;
+        unsigned int nParamCommands_;
     // button related
     bool wasDown_;
     bool hasChanged_;
   };
+        // button related
+        bool wasDown_;
+        bool hasChanged_;
+    };
+}

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

r1535	r1755
220	220	@param dt Delta time
221	221	*/
222		void InputBuffer::tickInput(float dt~~, const HandlerState& state~~)
	222	void InputBuffer::tickInput(float dt)
223	223	{
224	224	timeSinceKeyPressed_ += dt;

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

-                      r1535
+                      r1755
             void processKey (const KeyEvent &e);
+            void tickInput(float dt, const HandlerState& state);
+            void tickInput(float dt);
+            void tickKey(float dt) { }
             std::string buffer_;

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

-                      r1535
+                      r1755
 /**
+ @file
+ @brief Implementation of the different input handlers.
+ */
+@file
+@brief
+    Implementation of the different input handlers.
+*/
 #include "InputCommands.h"
 …
 namespace orxonox
+{
   // ###############################
   // ###  BufferedParamCommand   ###
   // ###############################
+    // ###############################
+    // ###  BufferedParamCommand   ###
+    // ###############################
   /**
   * Executes a buffered command. This is used for commands with additional
   * parameters.
   * @return True if command execution was successful or value was zero.
   */
   bool BufferedParamCommand::execute()
+  {
     if (nValuesAdded_)
+    /**
+    @brief
+        Executes a buffered command. This is used for commands with additional
+        parameters.
+    @return
+        True if command execution was successful or value was zero.
+    */
+    bool BufferedParamCommand::execute()
+    {
+      BufferedParamCommand& cmd = *this;
+      cmd.evaluation_.setEvaluatedParameter(cmd.paramIndex_, cmd.value_);
+      // reset
+      cmd.nValuesAdded_ = 0;
+      cmd.value_ = 0;
+      return cmd.evaluation_.execute();
+        if (nValuesAdded_)
+        {
+            BufferedParamCommand& cmd = *this;
+            cmd.evaluation_.setEvaluatedParameter(cmd.paramIndex_, cmd.value_);
+            // reset
+            cmd.nValuesAdded_ = 0;
+            cmd.value_ = 0;
+            return cmd.evaluation_.execute();
+        }
+        else
+            return true;
+    }
-    else
-      return true;
+  }
   // ###############################
   // #####    SimpleCommand    #####
   // ###############################
+    // ###############################
+    // #####    SimpleCommand    #####
+    // ###############################
+  /**
+  * Executes a simple command with no additional paramters.
+  * @return True if command execution was successful, false otherwise.
+  */
+  bool SimpleCommand::execute(float abs, float rel)
+  {
+    return evaluation_.execute();
+  }
+    /**
+    @brief
+        Executes a simple command with no additional paramters.
+    @return
+        True if command execution was successful, false otherwise.
+    */
+    bool SimpleCommand::execute(float abs, float rel)
+    {
+        return evaluation_.execute();
+    }
   // ###############################
   // #####    ParamCommand     #####
   // ###############################
+    // ###############################
+    // #####    ParamCommand     #####
+    // ###############################
+  /**
+  * Executes a parameter command. The commmand string is not directly executed,
+  * but instead stored in a buffer list so that values can be combined.
+  * @return Always true.
+  */
+  bool ParamCommand::execute(float abs, float rel)
+  {
+    BufferedParamCommand& cmd = *paramCommand_;
+    // command has an additional parameter
+    if (bRelative_)
+    /**
+    @brief
+        Executes a parameter command. The commmand string is not directly executed,
+        but instead stored in a buffer list so that values can be combined.
+    @return
+        Always true.
+    */
+    bool ParamCommand::execute(float abs, float rel)
+    {
+      if (rel != 0.0f)
+      {
+        // we have to calculate a relative movement.
+        // paramModifier_ says how much one keystroke is
+        cmd.value_ += paramModifier_ * rel;
+      }
+        BufferedParamCommand& cmd = *paramCommand_;
+        // command has an additional parameter
+        if (bRelative_)
+        {
+            if (rel != 0.0f)
+            {
+                // we have to calculate a relative movement.
+                // paramModifier_ says how much one keystroke is
+                cmd.value_ += paramModifier_ * rel;
+            }
+        }
+        else if (abs != 0.0f)
+        {
+            // Usually, joy sticks create 'noise' (they return values if they're in 0 position)
+            // and normally this is caught in tickInput(), but that threshold cannot be to high
+            // in order to preserve accuracy. Instead, we have to catch the problem here. An example:
+            // Someone only uses buttons with an active joystick. The joy stick value could then
+            // be 0.05 for instance and the the key value 1. Without handling the problem, the final
+            // value would be computed to (1+0.05)/2=0.5025 which is not what the user expects.
+            float absQ = abs * abs;
+            float valueQ = cmd.value_ * cmd.value_;
+            if (absQ > 50.0f * valueQ) // ease up comparison by using quadratics
+            {
+                cmd.value_ = abs * paramModifier_;
+                cmd.nValuesAdded_ = 1;
+            }
+            else if (absQ * 50.0f < valueQ)
+            {
+                // abs is too small, we just don't do anything
+            }
+            else
+            {
+                // we have to calculate the absolute position of the axis.
+                // Since there might be another axis that is affected, we have to wait and
+                // store the result in a temporary place
+                cmd.value_ = (cmd.value_ * cmd.nValuesAdded_ + paramModifier_ * abs) / ++cmd.nValuesAdded_;
+            }
+        }
+        return true;
+    }
-    else if (abs != 0.0f)
+    {
-      // Usually, joy sticks create 'noise' (they return values if they're in 0 position)
-      // and normally this is caught in tickInput(), but that threshold cannot be to high
-      // in order to preserve accuracy. Instead, we have to catch the problem here. An example:
-      // Someone only uses buttons with an active joystick. The joy stick value could then
-      // be 0.05 for instance and the the key value 1. Without handling the problem, the final
-      // value would be computed to (1+0.05)/2=0.5025 which is not what the user expects.
-      float absQ = abs * abs;
-      float valueQ = cmd.value_ * cmd.value_;
-      if (absQ > 50.0f * valueQ) // ease up comparison by using quadratics
+      {
-        cmd.value_ = abs * paramModifier_;
-        cmd.nValuesAdded_ = 1;
+      }
-      else if (absQ * 50.0f < valueQ)
+      {
-        // abs is too small, we just don't do anything
+      }
-      else
+      {
-        // we have to calculate the absolute position of the axis.
-        // Since there might be another axis that is affected, we have to wait and
-        // store the result in a temporary place
-        cmd.value_ = (cmd.value_ * cmd.nValuesAdded_ + paramModifier_ * abs) / ++cmd.nValuesAdded_;
+      }
+    }
-    return true;
+  }
+}

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

-                      r1535
+                      r1755
 /**
+ @file
+ @brief Different definitions of input processing.
+ */
+@file
+@brief
+    Different definitions of input processing.
+*/
 #ifndef _InputCommands_H__
 …
 namespace orxonox
+{
   class _CoreExport BufferedParamCommand
+  {
   public:
     BufferedParamCommand() : value_(0.0f), nValuesAdded_(0), paramIndex_(-1) { }
     bool execute();
+    class _CoreExport BufferedParamCommand
+    {
+    public:
+        BufferedParamCommand() : value_(0.0f), nValuesAdded_(0), paramIndex_(-1) { }
+        bool execute();
     float value_;
     unsigned int nValuesAdded_;
     int paramIndex_;
     CommandEvaluation evaluation_;
   };
+        float value_;
+        unsigned int nValuesAdded_;
+        int paramIndex_;
+        CommandEvaluation evaluation_;
+    };
   class _CoreExport BaseCommand
+  {
   public:
     virtual ~BaseCommand() { }
     virtual bool execute(float abs = 1.0f, float rel = 1.0f) = 0;
   };
+    class _CoreExport BaseCommand
+    {
+    public:
+        virtual ~BaseCommand() { }
+        virtual bool execute(float abs = 1.0f, float rel = 1.0f) = 0;
+    };
   class _CoreExport SimpleCommand : public BaseCommand
+  {
   public:
     bool execute(float abs = 1.0f, float rel = 1.0f);
+    class _CoreExport SimpleCommand : public BaseCommand
+    {
+    public:
+        bool execute(float abs = 1.0f, float rel = 1.0f);
     CommandEvaluation evaluation_;
   };
+        CommandEvaluation evaluation_;
+    };
   class _CoreExport ParamCommand : public BaseCommand
+  {
   public:
     ParamCommand() : bRelative_(false), paramModifier_(1.0f), paramCommand_(0) { }
     bool execute(float abs = 1.0f, float rel = 1.0f);
+    class _CoreExport ParamCommand : public BaseCommand
+    {
+    public:
+        ParamCommand() : bRelative_(false), paramModifier_(1.0f), paramCommand_(0) { }
+        bool execute(float abs = 1.0f, float rel = 1.0f);
     bool bRelative_;
     float paramModifier_;
     BufferedParamCommand* paramCommand_;
   };
+        bool bRelative_;
+        float paramModifier_;
+        BufferedParamCommand* paramCommand_;
+    };
+}

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

-                      r1556
+                      r1755
 /**
+ @file
+ @brief Declarations of various interface classes for the input management.
+@file
+@brief
+    Declarations of various interface classes for the input management.
 */
 …
 #include "core/CorePrereqs.h"
 #include "src/ois/OISKeyboard.h"
 #include "src/ois/OISMouse.h"
 #include "src/ois/OISJoyStick.h"
+#include "ois/OISKeyboard.h"
+#include "ois/OISMouse.h"
+#include "ois/OISJoyStick.h"
 #include "util/Math.h"
 namespace orxonox
+{
+  namespace KeyCode
+  {
+    // note: KeyCode comments were directly taken from OISKeyboard.h
+    enum Enum
+    {
+      Unassigned    = OIS::KC_UNASSIGNED,
+      Escape        = OIS::KC_ESCAPE,
+      NumRow1       = OIS::KC_1,
+      NumRow2       = OIS::KC_2,
+      NumRow3       = OIS::KC_3,
+      NumRow4       = OIS::KC_4,
+      NumRow5       = OIS::KC_5,
+      NumRow6       = OIS::KC_6,
+      NumRow7       = OIS::KC_7,
+      NumRow8       = OIS::KC_8,
+      NumRow9       = OIS::KC_9,
+      NumRow0       = OIS::KC_0,
+      Minus         = OIS::KC_MINUS,           // - on main keyboard
+      Equals        = OIS::KC_EQUALS,
+      Back          = OIS::KC_BACK,            // backspace
+      Tab           = OIS::KC_TAB,
+      Q             = OIS::KC_Q,
+      W             = OIS::KC_W,
+      E             = OIS::KC_E,
+      R             = OIS::KC_R,
+      T             = OIS::KC_T,
+      Y             = OIS::KC_Y,
+      U             = OIS::KC_U,
+      I             = OIS::KC_I,
+      O             = OIS::KC_O,
+      P             = OIS::KC_P,
+      LeftBracket   = OIS::KC_LBRACKET,
+      RightBracket  = OIS::KC_RBRACKET,
+      Return        = OIS::KC_RETURN,          // Enter on main keyboard
+      LeftControl   = OIS::KC_LCONTROL,
+      A             = OIS::KC_A,
+      S             = OIS::KC_S,
+      D             = OIS::KC_D,
+      F             = OIS::KC_F,
+      G             = OIS::KC_G,
+      H             = OIS::KC_H,
+      J             = OIS::KC_J,
+      K             = OIS::KC_K,
+      L             = OIS::KC_L,
+      Semicolon     = OIS::KC_SEMICOLON,
+      Apostrophe    = OIS::KC_APOSTROPHE,
+      Grave         = OIS::KC_GRAVE,           // accent
+      LeftShift     = OIS::KC_LSHIFT,
+      Backslash     = OIS::KC_BACKSLASH,
+      Z             = OIS::KC_Z,
+      X             = OIS::KC_X,
+      C             = OIS::KC_C,
+      V             = OIS::KC_V,
+      B             = OIS::KC_B,
+      N             = OIS::KC_N,
+      M             = OIS::KC_M,
+      Comma         = OIS::KC_COMMA,
+      Period        = OIS::KC_PERIOD,          // . on main keyboard
+      Slash         = OIS::KC_SLASH,           // / on main keyboard
+      RightShift    = OIS::KC_RSHIFT,
+      Multiply      = OIS::KC_MULTIPLY,        // * on numeric keypad
+      LeftAlt       = OIS::KC_LMENU,           // left Alt
+      Space         = OIS::KC_SPACE,
+      CapsLock      = OIS::KC_CAPITAL,
+      F1            = OIS::KC_F1,
+      F2            = OIS::KC_F2,
+      F3            = OIS::KC_F3,
+      F4            = OIS::KC_F4,
+      F5            = OIS::KC_F5,
+      F6            = OIS::KC_F6,
+      F7            = OIS::KC_F7,
+      F8            = OIS::KC_F8,
+      F9            = OIS::KC_F9,
+      F10           = OIS::KC_F10,
+      Numlock       = OIS::KC_NUMLOCK,
+      Scrolllock    = OIS::KC_SCROLL,          // Scroll Lock
+      Numpad7       = OIS::KC_NUMPAD7,
+      Numpad8       = OIS::KC_NUMPAD8,
+      Numpad9       = OIS::KC_NUMPAD9,
+      NumpadSubtract= OIS::KC_SUBTRACT,        // - on numeric keypad
+      Numpad4       = OIS::KC_NUMPAD4,
+      Numpad5       = OIS::KC_NUMPAD5,
+      Numpad6       = OIS::KC_NUMPAD6,
+      NumpadAdd     = OIS::KC_ADD,             // + on numeric keypad
+      Numpad1       = OIS::KC_NUMPAD1,
+      Numpad2       = OIS::KC_NUMPAD2,
+      Numpad3       = OIS::KC_NUMPAD3,
+      Numpad0       = OIS::KC_NUMPAD0,
+      NumpadPeriod  = OIS::KC_DECIMAL,         // . on numeric keypad
+      LessThan      = OIS::KC_OEM_102,         // < > | on UK/Germany keyboards
+      F11           = OIS::KC_F11,
+      F12           = OIS::KC_F12,
+      F13           = OIS::KC_F13,             //                     (NEC PC98)
+      F14           = OIS::KC_F14,             //                     (NEC PC98)
+      F15           = OIS::KC_F15,             //                     (NEC PC98)
+      Kana          = OIS::KC_KANA,            // (Japanese keyboard)
+      ABNT_C1       = OIS::KC_ABNT_C1,         // / ? on Portugese (Brazilian) keyboards
+      Convert       = OIS::KC_CONVERT,         // (Japanese keyboard)
+      NoConvert     = OIS::KC_NOCONVERT,       // (Japanese keyboard)
+      Yen           = OIS::KC_YEN,             // (Japanese keyboard)
+      ABNT_C2       = OIS::KC_ABNT_C2,         // Numpad . on Portugese (Brazilian) keyboards
+      NumpadEquals  = OIS::KC_NUMPADEQUALS,    // = on numeric keypad (NEC PC98)
+      PreviousTrack = OIS::KC_PREVTRACK,       // Previous Track (KC_CIRCUMFLEX on Japanese keyboard)
+      AT            = OIS::KC_AT,              //                     (NEC PC98)
+      Colon         = OIS::KC_COLON,           //                     (NEC PC98)
+      Underline     = OIS::KC_UNDERLINE,       //                     (NEC PC98)
+      Kanji         = OIS::KC_KANJI,           // (Japanese keyboard)
+      Stop          = OIS::KC_STOP,            //                     (NEC PC98)
+      AX            = OIS::KC_AX,              //                     (Japan AX)
+      Unlabeled     = OIS::KC_UNLABELED,       //                        (J3100)
+      NextTrack     = OIS::KC_NEXTTRACK,       // Next Track
+      NumpadEnter   = OIS::KC_NUMPADENTER,     // Enter on numeric keypad
+      RightControl  = OIS::KC_RCONTROL,
+      Mute          = OIS::KC_MUTE,            // Mute
+      Calculator    = OIS::KC_CALCULATOR,      // Calculator
+      PlayPause     = OIS::KC_PLAYPAUSE,       // Play / Pause
+      MediaStop     = OIS::KC_MEDIASTOP,       // Media Stop
+      VolumeDown    = OIS::KC_VOLUMEDOWN,      // Volume -
+      VolumeUp      = OIS::KC_VOLUMEUP,        // Volume +
+      WebHome       = OIS::KC_WEBHOME,         // Web home
+      NumpadComma   = OIS::KC_NUMPADCOMMA,     // , on numeric keypad (NEC PC98)
+      Divide        = OIS::KC_DIVIDE,          // / on numeric keypad
+      SYSRQ         = OIS::KC_SYSRQ,
+      RightAlt      = OIS::KC_RMENU,           // right Alt
+      Pause         = OIS::KC_PAUSE,           // Pause
+      Home          = OIS::KC_HOME,            // Home on arrow keypad
+      Up            = OIS::KC_UP,              // UpArrow on arrow keypad
+      PageUp        = OIS::KC_PGUP,            // PgUp on arrow keypad
+      Left          = OIS::KC_LEFT,            // LeftArrow on arrow keypad
+      Right         = OIS::KC_RIGHT,           // RightArrow on arrow keypad
+      End           = OIS::KC_END,             // End on arrow keypad
+      Down          = OIS::KC_DOWN,            // DownArrow on arrow keypad
+      PageDown      = OIS::KC_PGDOWN,          // PgDn on arrow keypad
+      Insert        = OIS::KC_INSERT,          // Insert on arrow keypad
+      Delete        = OIS::KC_DELETE,          // Delete on arrow keypad
+      LeftWindows   = OIS::KC_LWIN,            // Left Windows key
+      RightWindows  = OIS::KC_RWIN,            // Right Windows key
+      Apps          = OIS::KC_APPS,            // AppMenu key
+      Power         = OIS::KC_POWER,           // System Power
+      Sleep         = OIS::KC_SLEEP,           // System Sleep
+      Wake          = OIS::KC_WAKE,            // System Wake
+      WebSearch     = OIS::KC_WEBSEARCH,       // Web Search
+      WebFavorites  = OIS::KC_WEBFAVORITES,    // Web Favorites
+      WebRefresh    = OIS::KC_WEBREFRESH,      // Web Refresh
+      WebStop       = OIS::KC_WEBSTOP,         // Web Stop
+      WebForward    = OIS::KC_WEBFORWARD,      // Web Forward
+      WebBack       = OIS::KC_WEBBACK,         // Web Back
+      MyComputer    = OIS::KC_MYCOMPUTER,      // My Computer
+      Mail          = OIS::KC_MAIL,            // Mail
+      MediaSelect   = OIS::KC_MEDIASELECT      // Media Select
+    };
+  }
+  namespace MouseButton
+  {
+    enum Enum
+    {
+      Left    = OIS::MB_Left,
+      Right   = OIS::MB_Right,
+      Middle  = OIS::MB_Middle,
+      Button3 = OIS::MB_Button3,
+      Button4 = OIS::MB_Button4,
+      Button5 = OIS::MB_Button5,
+      Button6 = OIS::MB_Button6,
+      Button7 = OIS::MB_Button7
+    };
+  }
+  namespace KeyboardModifier
+  {
+    enum Enum
+    {
+      Shift = 0x0000001,
+      Ctrl  = 0x0000010,
+      Alt   = 0x0000100
+    };
+  }
+  struct _CoreExport Key
+  {
+    Key(const OIS::KeyEvent& evt) : key((KeyCode::Enum)evt.key), text(evt.text) { }
+    KeyCode::Enum key;
+    unsigned int text;
+  };
+  class _CoreExport KeyEvent
+  {
+  public:
+    KeyEvent(KeyCode::Enum key, unsigned int text) : key(key), text(text) { }
+    KeyEvent(const OIS::KeyEvent& evt, unsigned int mod) : key((KeyCode::Enum)evt.key), text(evt.text), modifiers(mod) { }
+    KeyEvent(const Key& key, unsigned int mod) : key(key.key), text(key.text), modifiers(mod) { }
+    bool isModifierDown(KeyboardModifier::Enum modifier) const { return (KeyboardModifier::Enum)modifier&modifiers; }
+    const KeyCode::Enum key;
+    unsigned int text;
+    unsigned int modifiers;
+  };
+  //typedef OIS::MouseState MouseState;
+  /*class _CoreExport JoyStickState
+  {
+  public:
+    JoyStickState(const OIS::JoyStickState& state, int ID) : OIS::JoyStickState(state), mJoyStickID(ID) { }
+    JoyStickState() { clear(); }
+    int mJoyStickID;
+                JoyStickState() { clear(); }
+                std::vector<bool> mButtons;
+                int axes[16];
+                std::vector<Vector3> mVectors;
+  };*/
+  /**
+  * Helper struct to determine which handlers of an object (can implement
+  * multiple handlers) are active.
+  */
+  struct HandlerState
+  {
+    HandlerState() : key(false), mouse(false), joyStick(false) { }
+    bool key;
+    bool mouse;
+    bool joyStick;
+  };
+  class _CoreExport InputTickable
+  {
+  public:
+    virtual ~InputTickable() { }
+    virtual void tickInput(float dt, const HandlerState& state) = 0;
+  };
+  /**
+    @brief Interface class used for key input listeners.
+  */
+  class _CoreExport KeyHandler : virtual public InputTickable
+  {
+  public:
+    virtual ~KeyHandler() { }
+    virtual void keyPressed (const KeyEvent& evt) = 0;
+    virtual void keyReleased(const KeyEvent& evt) = 0;
+    virtual void keyHeld    (const KeyEvent& evt) = 0;
+    //virtual void tickKey    (float dt) { }
+  };
+  /**
+    @brief Interface class used for mouse input listeners.
+  */
+  class _CoreExport MouseHandler : virtual public InputTickable
+  {
+  public:
+    virtual ~MouseHandler() { }
+    virtual void mouseButtonPressed (MouseButton::Enum id) = 0;
+    virtual void mouseButtonReleased(MouseButton::Enum id) = 0;
+    virtual void mouseButtonHeld    (MouseButton::Enum id) = 0;
+    virtual void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize) = 0;
+    virtual void mouseScrolled      (int abs, int rel)     = 0;
+    //virtual void tickMouse          (float dt) { }
+  };
+  /**
+    @brief Interface class used for joy stick input listeners.
+  */
+  class _CoreExport JoyStickHandler : virtual public InputTickable
+  {
+  public:
+    virtual ~JoyStickHandler() { }
+    virtual void joyStickButtonPressed (int joyStickID, int button) = 0;
+    virtual void joyStickButtonReleased(int joyStickID, int button) = 0;
+    virtual void joyStickButtonHeld    (int joyStickID, int button) = 0;
+    virtual void joyStickAxisMoved     (int joyStickID, int axis, float value) = 0;
+    //virtual bool joyStickVector3Moved  (int joyStickID, int index /*, fill list*/) {return true;}
+    //virtual void tickJoyStick          (float dt) { }
+  };
+    namespace KeyCode
+    {
+        // note: KeyCode comments were directly copied from OISKeyboard.h
+        enum Enum
+        {
+            Unassigned    = OIS::KC_UNASSIGNED,
+            Escape        = OIS::KC_ESCAPE,
+            NumRow1       = OIS::KC_1,
+            NumRow2       = OIS::KC_2,
+            NumRow3       = OIS::KC_3,
+            NumRow4       = OIS::KC_4,
+            NumRow5       = OIS::KC_5,
+            NumRow6       = OIS::KC_6,
+            NumRow7       = OIS::KC_7,
+            NumRow8       = OIS::KC_8,
+            NumRow9       = OIS::KC_9,
+            NumRow0       = OIS::KC_0,
+            Minus         = OIS::KC_MINUS,           // - on main keyboard
+            Equals        = OIS::KC_EQUALS,
+            Back          = OIS::KC_BACK,            // backspace
+            Tab           = OIS::KC_TAB,
+            Q             = OIS::KC_Q,
+            W             = OIS::KC_W,
+            E             = OIS::KC_E,
+            R             = OIS::KC_R,
+            T             = OIS::KC_T,
+            Y             = OIS::KC_Y,
+            U             = OIS::KC_U,
+            I             = OIS::KC_I,
+            O             = OIS::KC_O,
+            P             = OIS::KC_P,
+            LeftBracket   = OIS::KC_LBRACKET,
+            RightBracket  = OIS::KC_RBRACKET,
+            Return        = OIS::KC_RETURN,          // Enter on main keyboard
+            LeftControl   = OIS::KC_LCONTROL,
+            A             = OIS::KC_A,
+            S             = OIS::KC_S,
+            D             = OIS::KC_D,
+            F             = OIS::KC_F,
+            G             = OIS::KC_G,
+            H             = OIS::KC_H,
+            J             = OIS::KC_J,
+            K             = OIS::KC_K,
+            L             = OIS::KC_L,
+            Semicolon     = OIS::KC_SEMICOLON,
+            Apostrophe    = OIS::KC_APOSTROPHE,
+            Grave         = OIS::KC_GRAVE,           // accent
+            LeftShift     = OIS::KC_LSHIFT,
+            Backslash     = OIS::KC_BACKSLASH,
+            Z             = OIS::KC_Z,
+            X             = OIS::KC_X,
+            C             = OIS::KC_C,
+            V             = OIS::KC_V,
+            B             = OIS::KC_B,
+            N             = OIS::KC_N,
+            M             = OIS::KC_M,
+            Comma         = OIS::KC_COMMA,
+            Period        = OIS::KC_PERIOD,          // . on main keyboard
+            Slash         = OIS::KC_SLASH,           // / on main keyboard
+            RightShift    = OIS::KC_RSHIFT,
+            Multiply      = OIS::KC_MULTIPLY,        // * on numeric keypad
+            LeftAlt       = OIS::KC_LMENU,           // left Alt
+            Space         = OIS::KC_SPACE,
+            CapsLock      = OIS::KC_CAPITAL,
+            F1            = OIS::KC_F1,
+            F2            = OIS::KC_F2,
+            F3            = OIS::KC_F3,
+            F4            = OIS::KC_F4,
+            F5            = OIS::KC_F5,
+            F6            = OIS::KC_F6,
+            F7            = OIS::KC_F7,
+            F8            = OIS::KC_F8,
+            F9            = OIS::KC_F9,
+            F10           = OIS::KC_F10,
+            Numlock       = OIS::KC_NUMLOCK,
+            Scrolllock    = OIS::KC_SCROLL,          // Scroll Lock
+            Numpad7       = OIS::KC_NUMPAD7,
+            Numpad8       = OIS::KC_NUMPAD8,
+            Numpad9       = OIS::KC_NUMPAD9,
+            NumpadSubtract= OIS::KC_SUBTRACT,        // - on numeric keypad
+            Numpad4       = OIS::KC_NUMPAD4,
+            Numpad5       = OIS::KC_NUMPAD5,
+            Numpad6       = OIS::KC_NUMPAD6,
+            NumpadAdd     = OIS::KC_ADD,             // + on numeric keypad
+            Numpad1       = OIS::KC_NUMPAD1,
+            Numpad2       = OIS::KC_NUMPAD2,
+            Numpad3       = OIS::KC_NUMPAD3,
+            Numpad0       = OIS::KC_NUMPAD0,
+            NumpadPeriod  = OIS::KC_DECIMAL,         // . on numeric keypad
+            LessThan      = OIS::KC_OEM_102,         // < > | on UK/Germany keyboards
+            F11           = OIS::KC_F11,
+            F12           = OIS::KC_F12,
+            F13           = OIS::KC_F13,             //                     (NEC PC98)
+            F14           = OIS::KC_F14,             //                     (NEC PC98)
+            F15           = OIS::KC_F15,             //                     (NEC PC98)
+            Kana          = OIS::KC_KANA,            // (Japanese keyboard)
+            ABNT_C1       = OIS::KC_ABNT_C1,         // / ? on Portugese (Brazilian) keyboards
+            Convert       = OIS::KC_CONVERT,         // (Japanese keyboard)
+            NoConvert     = OIS::KC_NOCONVERT,       // (Japanese keyboard)
+            Yen           = OIS::KC_YEN,             // (Japanese keyboard)
+            ABNT_C2       = OIS::KC_ABNT_C2,         // Numpad . on Portugese (Brazilian) keyboards
+            NumpadEquals  = OIS::KC_NUMPADEQUALS,    // = on numeric keypad (NEC PC98)
+            PreviousTrack = OIS::KC_PREVTRACK,       // Previous Track (KC_CIRCUMFLEX on Japanese keyboard)
+            AT            = OIS::KC_AT,              //                     (NEC PC98)
+            Colon         = OIS::KC_COLON,           //                     (NEC PC98)
+            Underline     = OIS::KC_UNDERLINE,       //                     (NEC PC98)
+            Kanji         = OIS::KC_KANJI,           // (Japanese keyboard)
+            Stop          = OIS::KC_STOP,            //                     (NEC PC98)
+            AX            = OIS::KC_AX,              //                     (Japan AX)
+            Unlabeled     = OIS::KC_UNLABELED,       //                        (J3100)
+            NextTrack     = OIS::KC_NEXTTRACK,       // Next Track
+            NumpadEnter   = OIS::KC_NUMPADENTER,     // Enter on numeric keypad
+            RightControl  = OIS::KC_RCONTROL,
+            Mute          = OIS::KC_MUTE,            // Mute
+            Calculator    = OIS::KC_CALCULATOR,      // Calculator
+            PlayPause     = OIS::KC_PLAYPAUSE,       // Play / Pause
+            MediaStop     = OIS::KC_MEDIASTOP,       // Media Stop
+            VolumeDown    = OIS::KC_VOLUMEDOWN,      // Volume -
+            VolumeUp      = OIS::KC_VOLUMEUP,        // Volume +
+            WebHome       = OIS::KC_WEBHOME,         // Web home
+            NumpadComma   = OIS::KC_NUMPADCOMMA,     // , on numeric keypad (NEC PC98)
+            Divide        = OIS::KC_DIVIDE,          // / on numeric keypad
+            SYSRQ         = OIS::KC_SYSRQ,
+            RightAlt      = OIS::KC_RMENU,           // right Alt
+            Pause         = OIS::KC_PAUSE,           // Pause
+            Home          = OIS::KC_HOME,            // Home on arrow keypad
+            Up            = OIS::KC_UP,              // UpArrow on arrow keypad
+            PageUp        = OIS::KC_PGUP,            // PgUp on arrow keypad
+            Left          = OIS::KC_LEFT,            // LeftArrow on arrow keypad
+            Right         = OIS::KC_RIGHT,           // RightArrow on arrow keypad
+            End           = OIS::KC_END,             // End on arrow keypad
+            Down          = OIS::KC_DOWN,            // DownArrow on arrow keypad
+            PageDown      = OIS::KC_PGDOWN,          // PgDn on arrow keypad
+            Insert        = OIS::KC_INSERT,          // Insert on arrow keypad
+            Delete        = OIS::KC_DELETE,          // Delete on arrow keypad
+            LeftWindows   = OIS::KC_LWIN,            // Left Windows key
+            RightWindows  = OIS::KC_RWIN,            // Right Windows key
+            Apps          = OIS::KC_APPS,            // AppMenu key
+            Power         = OIS::KC_POWER,           // System Power
+            Sleep         = OIS::KC_SLEEP,           // System Sleep
+            Wake          = OIS::KC_WAKE,            // System Wake
+            WebSearch     = OIS::KC_WEBSEARCH,       // Web Search
+            WebFavorites  = OIS::KC_WEBFAVORITES,    // Web Favorites
+            WebRefresh    = OIS::KC_WEBREFRESH,      // Web Refresh
+            WebStop       = OIS::KC_WEBSTOP,         // Web Stop
+            WebForward    = OIS::KC_WEBFORWARD,      // Web Forward
+            WebBack       = OIS::KC_WEBBACK,         // Web Back
+            MyComputer    = OIS::KC_MYCOMPUTER,      // My Computer
+            Mail          = OIS::KC_MAIL,            // Mail
+            MediaSelect   = OIS::KC_MEDIASELECT      // Media Select
+        };
+    }
+    namespace MouseButton
+    {
+        enum Enum
+        {
+            Left    = OIS::MB_Left,
+            Right   = OIS::MB_Right,
+            Middle  = OIS::MB_Middle,
+            Button3 = OIS::MB_Button3,
+            Button4 = OIS::MB_Button4,
+            Button5 = OIS::MB_Button5,
+            Button6 = OIS::MB_Button6,
+            Button7 = OIS::MB_Button7
+        };
+    }
+    namespace JoyStickButton
+    {
+        enum Enum
+        {
+            Button0       =  0, Button1       =  1, Button2       =  2, Button3       =  3,
+            Button4       =  4, Button5       =  5, Button6       =  6, Button7       =  7,
+            Button8       =  8, Button9       =  9, Button10      = 10, Button11      = 11,
+            Button12      = 12, Button13      = 13, Button14      = 14, Button15      = 15,
+            Button16      = 16, Button17      = 17, Button18      = 18, Button19      = 19,
+            Button20      = 20, Button21      = 21, Button22      = 22, Button23      = 23,
+            Button24      = 24, Button25      = 25, Button26      = 26, Button27      = 27,
+            Button28      = 28, Button29      = 29, Button30      = 30, Button31      = 31,
+            POV0North     = 32, POV0South     = 33, POV0East      = 34, POV0West      = 35,
+            POV0NorthEast = 36, POV0SouthEast = 37, POV0NorthWest = 38, POV0SouthWest = 39,
+            POV1North     = 40, POV1South     = 41, POV1East      = 42, POV1West      = 43,
+            POV1NorthEast = 44, POV1SouthEast = 45, POV1NorthWest = 46, POV1SouthWest = 47,
+            POV2North     = 48, POV2South     = 49, POV2East      = 50, POV2West      = 51,
+            POV2NorthEast = 52, POV2SouthEast = 53, POV2NorthWest = 54, POV2SouthWest = 55,
+            POV3North     = 56, POV3South     = 57, POV3East      = 58, POV3West      = 59,
+            POV3NorthEast = 60, POV3SouthEast = 61, POV3NorthWest = 62, POV3SouthWest = 63,
+        };
+    }
+    namespace KeyboardModifier
+    {
+        enum Enum
+        {
+            Shift = 0x0000001,
+            Ctrl  = 0x0000010,
+            Alt   = 0x0000100
+        };
+    }
+    namespace InputDevice
+    {
+        enum Enum
+        {
+            Keyboard,
+            Mouse,
+            JoyStick0,
+            JoyStick1,
+            JoyStick2,
+            JoyStick3,
+            // note: No problem if there are more joy sticks. This enum is just for convenience.
+        };
+    }
+    struct _CoreExport Key
+    {
+        Key(const OIS::KeyEvent& evt) : key((KeyCode::Enum)evt.key), text(evt.text) { }
+        KeyCode::Enum key;
+        unsigned int text;
+    };
+    class _CoreExport KeyEvent
+    {
+    public:
+        KeyEvent(KeyCode::Enum key, unsigned int text) : key(key), text(text) { }
+        KeyEvent(const OIS::KeyEvent& evt, unsigned int mod)
+            : key((KeyCode::Enum)evt.key), text(evt.text), modifiers(mod) { }
+        KeyEvent(const Key& key, unsigned int mod) : key(key.key), text(key.text), modifiers(mod) { }
+        bool isModifierDown(KeyboardModifier::Enum modifier) const
+            { return (KeyboardModifier::Enum)modifier&modifiers; }
+        const KeyCode::Enum key;
+        unsigned int text;
+        unsigned int modifiers;
+    };
+    class _CoreExport InputTickable
+    {
+    public:
+        virtual ~InputTickable() { }
+        virtual void tickInput(float dt) = 0;
+    };
+    /**
+    @brief
+        Interface class used for key input listeners.
+    */
+    class _CoreExport KeyHandler : virtual public InputTickable
+    {
+    public:
+        virtual ~KeyHandler() { }
+        virtual void keyPressed (const KeyEvent& evt) = 0;
+        virtual void keyReleased(const KeyEvent& evt) = 0;
+        virtual void keyHeld    (const KeyEvent& evt) = 0;
+        virtual void tickKey    (float dt) = 0;
+    };
+    /**
+    @brief
+        Interface class used for mouse input listeners.
+    */
+    class _CoreExport MouseHandler : virtual public InputTickable
+    {
+    public:
+        virtual ~MouseHandler() { }
+        virtual void mouseButtonPressed (MouseButton::Enum id) = 0;
+        virtual void mouseButtonReleased(MouseButton::Enum id) = 0;
+        virtual void mouseButtonHeld    (MouseButton::Enum id) = 0;
+        virtual void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize) = 0;
+        virtual void mouseScrolled      (int abs, int rel)     = 0;
+        virtual void tickMouse          (float dt) = 0;
+    };
+    /**
+    @brief
+        Interface class used for joy stick input listeners.
+    */
+    class _CoreExport JoyStickHandler : virtual public InputTickable
+    {
+    public:
+        virtual ~JoyStickHandler() { }
+        virtual void joyStickButtonPressed (unsigned int joyStickID, JoyStickButton::Enum id) = 0;
+        virtual void joyStickButtonReleased(unsigned int joyStickID, JoyStickButton::Enum id) = 0;
+        virtual void joyStickButtonHeld    (unsigned int joyStickID, JoyStickButton::Enum id) = 0;
+        virtual void joyStickAxisMoved     (unsigned int joyStickID, unsigned int axis, float value) = 0;
+        virtual void tickJoyStick          (float dt, unsigned int joyStick) = 0;
+    };
+    class _CoreExport EmptyHandler : public KeyHandler, public MouseHandler, public JoyStickHandler
+    {
+    private:
+        void tickInput(float dt) { }
+        void tickJoyStick(float dt, unsigned int joyStick) { }
+        void tickMouse(float dt) { }
+        void tickKey(float dt) { }
+        void keyPressed (const KeyEvent& evt) { }
+        void keyReleased(const KeyEvent& evt) { }
+        void keyHeld    (const KeyEvent& evt) { }
+        void mouseButtonPressed (MouseButton::Enum id) { }
+        void mouseButtonReleased(MouseButton::Enum id) { }
+        void mouseButtonHeld    (MouseButton::Enum id) { }
+        void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize) { }
+        void mouseScrolled      (int abs, int rel) { }
+        void joyStickButtonPressed (unsigned int joyStickID, JoyStickButton::Enum id) { }
+        void joyStickButtonReleased(unsigned int joyStickID, JoyStickButton::Enum id) { }
+        void joyStickButtonHeld    (unsigned int joyStickID, JoyStickButton::Enum id) { }
+        void joyStickAxisMoved     (unsigned int joyStickID, unsigned int axis, float value) { }
+    };
+}

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

-                      r1747
+                      r1755
 /**
+  @file
+  @brief Implementation of the InputManager that captures all the input from OIS
+         and redirects it to handlers.
+@file
+@brief
+    Implementation of the InputManager that captures all the input from OIS
+    and redirects it to handlers.
  */
 #include "InputManager.h"
+#include <limits.h>
+#include <climits>
+#include <cassert>
+#include "ois/OISException.h"
+#include "ois/OISInputManager.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/Exception.h"
 #include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
-#include "core/Shell.h"               // hack!
 #include "util/Debug.h"
 …
 #include "KeyDetector.h"
 #include "CalibratorCallback.h"
 #include "src/ois/OISException.h"
 #include "src/ois/OISInputManager.h"
+#include "InputState.h"
+#include "SimpleInputState.h"
+#include "ExtendedInputState.h"
 namespace orxonox
+{
+  SetConsoleCommandShortcut(InputManager, keyBind);
+  SetConsoleCommandShortcut(InputManager, storeKeyStroke);
+  SetConsoleCommandShortcut(InputManager, calibrate);
+  // ###############################
+  // ###    Internal Methods     ###
+  // ###############################
+  // ###############################
+  /**
+    @brief Constructor only sets member fields to initial zero values
+           and registers the class in the class hierarchy.
+  */
+  InputManager::InputManager() :
+      inputSystem_(0), keyboard_(0), mouse_(0),
+      joySticksSize_(0),
+      keyBinder_(0), keyDetector_(0), buffer_(0), calibratorCallback_(0),
+      state_(IS_UNINIT), stateRequest_(IS_UNINIT), savedState_(IS_UNINIT),
+      keyboardModifiers_(0)
+  {
+    RegisterRootObject(InputManager);
+  }
+  /**
+    @brief The one instance of the InputManager is stored in this function.
+    @return A reference to the only instance of the InputManager
+  */
+  InputManager& InputManager::_getSingleton()
+  {
+    static InputManager theOnlyInstance;
+    return theOnlyInstance;
+  }
+  /**
+    @brief Destructor only called at the end of the program, after main.
+  */
+  InputManager::~InputManager()
+  {
+    _destroy();
+  }
+  /**
+    @brief Creates the OIS::InputMananger, the keyboard, the mouse and
+           the joysticks and assigns the key bindings.
+    @param windowHnd The window handle of the render window
+    @param windowWidth The width of the render window
+    @param windowHeight The height of the render window
+  */
+  bool InputManager::_initialise(const size_t windowHnd, int windowWidth, int windowHeight,
+        bool createKeyboard, bool createMouse, bool createJoySticks)
+  {
+    if (state_ == IS_UNINIT)
+    {
+      CCOUT(3) << "Initialising Input System..." << std::endl;
+      CCOUT(ORX_DEBUG) << "Initialising OIS components..." << std::endl;
+      OIS::ParamList paramList;
+      std::ostringstream windowHndStr;
+      // Fill parameter list
+      windowHndStr << (unsigned int)windowHnd;
+      paramList.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
+      //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")));
+    SetConsoleCommand(InputManager, keyBind, true);
+    SetConsoleCommand(InputManager, storeKeyStroke, true);
+    SetConsoleCommand(InputManager, calibrate, true);
+    SetConsoleCommand(InputManager, reload, false);
+    std::string InputManager::bindingCommmandString_s = "";
+    InputManager* InputManager::singletonRef_s = 0;
+    using namespace InputDevice;
+    /**
+    @brief
+        Defines the |= operator for easier use.
+    */
+    inline InputManager::InputManagerState operator|=(InputManager::InputManagerState& lval,
+                                                      InputManager::InputManagerState rval)
+    {
+        return (lval = (InputManager::InputManagerState)(lval | rval));
+    }
+    /**
+    @brief
+        Defines the &= operator for easier use.
+    */
+    inline InputManager::InputManagerState operator&=(InputManager::InputManagerState& lval, int rval)
+    {
+        return (lval = (InputManager::InputManagerState)(lval & rval));
+    }
+    // ############################################################
+    // #####                  Initialisation                  #####
+    // ##########                                        ##########
+    // ############################################################
+    /**
+    @brief
+        Constructor only sets member fields to initial zero values
+        and registers the class in the class hierarchy.
+    */
+    InputManager::InputManager()
+        : inputSystem_(0)
+        , keyboard_(0)
+        , mouse_(0)
+        , joySticksSize_(0)
+        , devicesNum_(0)
+        , windowHnd_(0)
+        , internalState_(Uninitialised)
+        , stateDetector_(0)
+        , stateCalibrator_(0)
+        , stateEmpty_(0)
+        , bCalibrating_(false)
+        , keyboardModifiers_(0)
+    {
+        RegisterRootObject(InputManager);
+        assert(singletonRef_s == 0);
+        singletonRef_s = this;
+    }
+    /**
+    @brief
+        Creates the OIS::InputMananger, the keyboard, the mouse and
+        the joysticks and assigns the key bindings.
+    @param windowHnd
+        The window handle of the render window
+    @param windowWidth
+        The width of the render window
+    @param windowHeight
+        The height of the render window
+    @param joyStickSupport
+        Whether or not to load the joy sticks as well
+    */
+    void InputManager::initialise(size_t windowHnd, int windowWidth, int windowHeight, bool joyStickSupport)
+    {
+        CCOUT(3) << "Initialising Input System..." << std::endl;
+        if (!(internalState_ & OISReady))
+        {
+            CCOUT(4) << "Initialising OIS components..." << std::endl;
+            // store handle internally so we can reload OIS
+            windowHnd_ = windowHnd;
+            OIS::ParamList paramList;
+            std::ostringstream windowHndStr;
+            // Fill parameter list
+            windowHndStr << (unsigned int)windowHnd_;
+            paramList.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
+            //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")));
 #if defined OIS_LINUX_PLATFORM
       paramList.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
+            paramList.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
 #endif
+      try
+      {
+        inputSystem_ = OIS::InputManager::createInputSystem(paramList);
+        CCOUT(ORX_DEBUG) << "Created OIS input system" << std::endl;
+      }
+      catch (OIS::Exception ex)
+      {
+        CCOUT(ORX_ERROR) << "Error: Failed creating an OIS input system."
+            << "OIS message: \"" << ex.eText << "\"" << std::endl;
+        inputSystem_ = 0;
+            inputSystem_ = OIS::InputManager::createInputSystem(paramList);
+            CCOUT(ORX_DEBUG) << "Created OIS input system" << std::endl;
+            _initialiseKeyboard();
+            _initialiseMouse();
+            if (joyStickSupport)
+                _initialiseJoySticks();
+            // Set mouse/joystick region
+            if (mouse_)
+                setWindowExtents(windowWidth, windowHeight);
+            // clear all buffers
+            _clearBuffers();
+            // load joy stick calibration
+            setConfigValues();
+            internalState_ |= OISReady;
+            CCOUT(ORX_DEBUG) << "Initialising OIS components done." << std::endl;
+        }
+        else
+        {
+            CCOUT(2) << "Warning: OIS compoments already initialised, skipping" << std::endl;
+        }
+        if (!(internalState_ & InternalsReady))
+        {
+            CCOUT(4) << "Initialising InputStates components..." << std::endl;
+            stateEmpty_ = createInputState<SimpleInputState>("empty", -1);
+            stateEmpty_->setHandler(new EmptyHandler());
+            activeStates_[stateEmpty_->getPriority()] = stateEmpty_;
+            stateDetector_ = createInputState<SimpleInputState>("detector", 101);
+            KeyDetector* temp = new KeyDetector();
+            temp->loadBindings("storeKeyStroke");
+            stateDetector_->setHandler(temp);
+            stateCalibrator_ = createInputState<SimpleInputState>("calibrator", 100);
+            stateCalibrator_->setHandler(new EmptyHandler());
+            InputBuffer* buffer = new InputBuffer();
+            buffer->registerListener(this, &InputManager::_completeCalibration, '\r', true);
+            stateCalibrator_->setKeyHandler(buffer);
+            internalState_ |= InternalsReady;
+            CCOUT(4) << "Initialising InputStates complete." << std::endl;
+        }
+        _updateActiveStates();
+        CCOUT(3) << "Initialising complete." << std::endl;
+    }
+    /**
+    @brief
+        Creates a keyboard and sets the event handler.
+    @return
+        False if keyboard stays uninitialised, true otherwise.
+    */
+    void InputManager::_initialiseKeyboard()
+    {
+        if (keyboard_ != 0)
+        {
+            CCOUT(2) << "Warning: Keyboard already initialised, skipping." << std::endl;
+            return;
+        }
+        if (inputSystem_->getNumberOfDevices(OIS::OISKeyboard) > 0)
+        {
+            keyboard_ = (OIS::Keyboard*)inputSystem_->createInputObject(OIS::OISKeyboard, true);
+            // register our listener in OIS.
+            keyboard_->setEventCallback(this);
+            // note: OIS will not detect keys that have already been down when the keyboard was created.
+            CCOUT(ORX_DEBUG) << "Created OIS keyboard" << std::endl;
+        }
+        else
+        {
+            ThrowException(InitialisationFailed, "No keyboard found!");
+        }
+    }
+    /**
+    @brief
+        Creates a mouse and sets the event handler.
+    @return
+        False if mouse stays uninitialised, true otherwise.
+    */
+    void InputManager::_initialiseMouse()
+    {
+        if (mouse_ != 0)
+        {
+            CCOUT(2) << "Warning: Mouse already initialised, skipping." << std::endl;
+            return;
+        }
+        try
+        {
+            if (inputSystem_->getNumberOfDevices(OIS::OISMouse) > 0)
+            {
+                mouse_ = static_cast<OIS::Mouse*>(inputSystem_->createInputObject(OIS::OISMouse, true));
+                // register our listener in OIS.
+                mouse_->setEventCallback(this);
+                CCOUT(ORX_DEBUG) << "Created OIS mouse" << std::endl;
+            }
+            else
+            {
+                CCOUT(ORX_WARNING) << "Warning: No mouse found!" << std::endl;
+            }
+        }
+        catch (OIS::Exception ex)
+        {
+            CCOUT(ORX_WARNING) << "Warning: Failed to create an OIS mouse\n"
+                << "OIS error message: \"" << ex.eText << "\"" << std::endl;
+            mouse_ = 0;
+        }
+    }
+    /**
+    @brief
+        Creates all joy sticks and sets the event handler.
+    @return
+        False joy stick stay uninitialised, true otherwise.
+    */
+    void InputManager::_initialiseJoySticks()
+    {
+        if (joySticksSize_ > 0)
+        {
+            CCOUT(2) << "Warning: Joy sticks already initialised, skipping." << std::endl;
+            return;
+        }
+        if (inputSystem_->getNumberOfDevices(OIS::OISJoyStick) > 0)
+        {
+            for (int i = 0; i < inputSystem_->getNumberOfDevices(OIS::OISJoyStick); i++)
+            {
+                try
+                {
+                    OIS::JoyStick* stig = static_cast<OIS::JoyStick*>
+                        (inputSystem_->createInputObject(OIS::OISJoyStick, true));
+                    CCOUT(ORX_DEBUG) << "Created OIS joy stick with ID " << stig->getID() << std::endl;
+                    joySticks_.push_back(stig);
+                    // register our listener in OIS.
+                    stig->setEventCallback(this);
+                }
+                catch (OIS::Exception ex)
+                {
+                    CCOUT(ORX_WARNING) << "Warning: Failed to create OIS joy number" << i << "\n"
+                        << "OIS error message: \"" << ex.eText << "\"" << std::endl;
+                }
+            }
+        }
+        else
+        {
+            //CCOUT(ORX_WARNING) << "Warning: Joy stick support requested, but no joy stick was found" << std::endl;
+        }
+        _redimensionLists();
+    }
+    /**
+    @brief
+        Sets the size of all the different lists that are dependent on the number
+        of joy stick devices created.
+    @remarks
+        No matter whether there are a mouse and/or keyboard, they will always
+        occupy 2 places in the device number dependent lists.
+    */
+    void InputManager::_redimensionLists()
+    {
+        joySticksSize_ = joySticks_.size();
+        devicesNum_ = 2 + joySticksSize_;
+        joyStickButtonsDown_ .resize(joySticksSize_);
+        povStates_           .resize(joySticksSize_);
+        sliderStates_        .resize(joySticksSize_);
+        joySticksCalibration_.resize(joySticksSize_);
+        for (unsigned int iJoyStick = 0; iJoyStick < joySticksSize_; iJoyStick++)
+        {
+            // reset the calibration with default values
+            for (unsigned int i = 0; i < 24; i++)
+            {
+                joySticksCalibration_[iJoyStick].negativeCoeff[i] = 1.0f/32767.0f;
+                joySticksCalibration_[iJoyStick].positiveCoeff[i] = 1.0f/32768.0f;
+                joySticksCalibration_[iJoyStick].zeroStates[i] = 0;
+            }
+        }
+        // state management
+        activeStatesTop_.resize(devicesNum_);
+        // inform all states
+        for (std::map<int, InputState*>::const_iterator it = inputStatesByPriority_.begin();
+            it != inputStatesByPriority_.end(); ++it)
+            it->second->setNumOfJoySticks(joySticksSize_);
+    }
+    /**
+    @brief
+        Sets the configurable values.
+        This mainly concerns joy stick calibrations.
+    */
+    void InputManager::setConfigValues()
+    {
+        if (joySticksSize_ > 0)
+        {
+            std::vector<double> coeffPos;
+            std::vector<double> coeffNeg;
+            std::vector<int> zero;
+            coeffPos.resize(24);
+            coeffNeg.resize(24);
+            zero.resize(24);
+            for (unsigned int i = 0; i < 24; i++)
+            {
+                coeffPos[i] =  1.0f/32767.0f;
+                coeffNeg[i] =  1.0f/32768.0f;
+                zero[i]     =  0;
+            }
+            ConfigValueContainer* cont = getIdentifier()->getConfigValueContainer("CoeffPos");
+            if (!cont)
+            {
+                cont = new ConfigValueContainer(CFT_Settings, getIdentifier(), "CoeffPos", coeffPos);
+                getIdentifier()->addConfigValueContainer("CoeffPos", cont);
+            }
+            cont->getValue(&coeffPos, this);
+            cont = getIdentifier()->getConfigValueContainer("CoeffNeg");
+            if (!cont)
+            {
+                cont = new ConfigValueContainer(CFT_Settings, getIdentifier(), "CoeffNeg", coeffNeg);
+                getIdentifier()->addConfigValueContainer("CoeffNeg", cont);
+            }
+            cont->getValue(&coeffNeg, this);
+            cont = getIdentifier()->getConfigValueContainer("Zero");
+            if (!cont)
+            {
+                cont = new ConfigValueContainer(CFT_Settings, getIdentifier(), "Zero", zero);
+                getIdentifier()->addConfigValueContainer("Zero", cont);
+            }
+            cont->getValue(&zero, this);
+            // copy values to our own variables
+            for (unsigned int i = 0; i < 24; i++)
+            {
+                joySticksCalibration_[0].positiveCoeff[i] = coeffPos[i];
+                joySticksCalibration_[0].negativeCoeff[i] = coeffNeg[i];
+                joySticksCalibration_[0].zeroStates[i]    = zero[i];
+            }
+        }
+    }
+    // ############################################################
+    // #####                    Destruction                   #####
+    // ##########                                        ##########
+    // ############################################################
+    /**
+    @brief
+        Destroys all the created input devices and states.
+    */
+    InputManager::~InputManager()
+    {
+        if (internalState_ != Uninitialised)
+        {
+            try
+            {
+                CCOUT(3) << "Destroying ..." << std::endl;
+                // clear our own states
+                stateEmpty_->removeAndDestroyAllHandlers();
+                stateCalibrator_->removeAndDestroyAllHandlers();
+                stateDetector_->removeAndDestroyAllHandlers();
+                // kick all active states 'nicely'
+                for (std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin();
+                    rit != activeStates_.rend(); ++rit)
+                {
+                    (*rit).second->onLeave();
+                }
+                // destroy all input states
+                while (inputStatesByPriority_.size() > 0)
+                    _destroyState((*inputStatesByPriority_.rbegin()).second);
+                // destroy the devices
+                _destroyKeyboard();
+                _destroyMouse();
+                _destroyJoySticks();
+                OIS::InputManager::destroyInputSystem(inputSystem_);
+                CCOUT(3) << "Destroying done." << std::endl;
+            }
+            catch (OIS::Exception& ex)
+            {
+                CCOUT(1) << "An exception has occured while destroying:\n" << ex.what()
+                         << "This could lead to a possible memory/resource leak!" << std::endl;
+            }
+        }
+    }
+    /**
+    @brief
+        Destroys the keyboard and sets it to 0.
+    */
+    void InputManager::_destroyKeyboard()
+    {
+        assert(inputSystem_);
+        if (keyboard_)
+            inputSystem_->destroyInputObject(keyboard_);
+        keyboard_ = 0;
+        CCOUT(4) << "Keyboard destroyed." << std::endl;
+    }
+    /**
+    @brief
+        Destroys the mouse and sets it to 0.
+    */
+    void InputManager::_destroyMouse()
+    {
+        assert(inputSystem_);
+        if (mouse_)
+            inputSystem_->destroyInputObject(mouse_);
+        mouse_ = 0;
+        CCOUT(4) << "Mouse destroyed." << std::endl;
+    }
+    /**
+    @brief
+        Destroys all the joy sticks and resizes the lists to 0.
+    */
+    void InputManager::_destroyJoySticks()
+    {
+        if (joySticksSize_ > 0)
+        {
+            assert(inputSystem_);
+            for (unsigned int i = 0; i < joySticksSize_; i++)
+                if (joySticks_[i] != 0)
+                    inputSystem_->destroyInputObject(joySticks_[i]);
+            joySticks_.clear();
+            // don't use _redimensionLists(), might mess with registered handler if
+            // downgrading from 2 to 1 joystick
+            //_redimensionLists();
+            joySticksSize_ = 0;
+        }
+        CCOUT(4) << "Joy sticks destroyed." << std::endl;
+    }
+    /**
+    @brief
+        Removes and destroys an InputState.
+    @return
+        True if state was removed immediately, false if postponed.
+    */
+    void InputManager::_destroyState(InputState* state)
+    {
+        assert(state && !(this->internalState_ & Ticking));
+        std::map<int, InputState*>::iterator it = this->activeStates_.find(state->getPriority());
+        if (it != this->activeStates_.end())
+        {
+            this->activeStates_.erase(it);
+            _updateActiveStates();
+        }
+        inputStatesByPriority_.erase(state->getPriority());
+        inputStatesByName_.erase(state->getName());
+        delete state;
+    }
+    void InputManager::_clearBuffers()
+    {
+        keysDown_.clear();
+        keyboardModifiers_ = 0;
+        mouseButtonsDown_.clear();
+        for (unsigned int i = 0; i < joySticksSize_; ++i)
+        {
+            joyStickButtonsDown_[i].clear();
+            for (int j = 0; j < 4; ++j)
+            {
+                sliderStates_[i].sliderStates[j].x = 0;
+                sliderStates_[i].sliderStates[j].y = 0;
+                povStates_[i][j] = 0;
+            }
+        }
+    }
+    // ############################################################
+    // #####                     Reloading                    #####
+    // ##########                                        ##########
+    // ############################################################
+    /**
+    @brief
+        Public interface. Only reloads immediately if the call stack doesn't
+        include the tick() method.
+    @param joyStickSupport
+        Whether or not to initialise joy sticks as well.
+    */
+    void InputManager::reloadInputSystem(bool joyStickSupport)
+    {
+        if (internalState_ & Ticking)
+        {
+            // We cannot destroy OIS right now, because reload was probably
+            // caused by a user clicking on a GUI item. The backtrace would then
+            // include an OIS method. So it would be a very bad thing to destroy it..
+            internalState_ |= ReloadRequest;
+            // Misuse of internalState_: We can easily store the joyStickSupport bool.
+            // use Uninitialised as 0 value in order to make use of the overloaded |= operator
+            internalState_ |= joyStickSupport ? JoyStickSupport : Uninitialised;
+        }
+        else if (internalState_ & OISReady)
+        {
+            _reload(joyStickSupport);
+        }
+        else
+        {
+            CCOUT(2) << "Warning: Cannot reload OIS. May not yet be initialised or"
+                     << "joy sticks are currently calibrating." << std::endl;
+        }
+    }
+    /**
+    @brief
+        Internal reload method. Destroys the OIS devices and loads them again.
+    */
+    void InputManager::_reload(bool joyStickSupport)
+    {
+        try
+        {
+            CCOUT(3) << "Reloading ..." << std::endl;
+            // Save mouse clipping size
+            int mouseWidth  = mouse_->getMouseState().width;
+            int mouseHeight = mouse_->getMouseState().height;
+            internalState_ &= ~OISReady;
+            // destroy the devices
+            _destroyKeyboard();
+            _destroyMouse();
+            _destroyJoySticks();
+            OIS::InputManager::destroyInputSystem(inputSystem_);
+            inputSystem_ = 0;
+            // clear all buffers containing input information
+            _clearBuffers();
+            initialise(windowHnd_, mouseWidth, mouseHeight, joyStickSupport);
+            CCOUT(3) << "Reloading done." << std::endl;
+        }
+        catch (OIS::Exception& ex)
+        {
+            CCOUT(1) << "An exception has occured while reloading:\n" << ex.what() << std::endl;
+        }
+    }
+    // ############################################################
+    // #####                  Runtime Methods                 #####
+    // ##########                                        ##########
+    // ############################################################
+    /**
+    @brief
+        Updates the InputManager. Tick is called by the Core class.
+    @param dt
+        Delta time
+    */
+    void InputManager::tick(float dt)
+    {
+        if (internalState_ == Uninitialised)
+            return;
+        else if (internalState_ & ReloadRequest)
+        {
+            _reload(internalState_ & JoyStickSupport);
+            internalState_ &= ~ReloadRequest;
+            internalState_ &= ~JoyStickSupport;
+        }
+        // check for states to leave
+        for (std::set<InputState*>::reverse_iterator rit = stateLeaveRequests_.rbegin();
+            rit != stateLeaveRequests_.rend(); ++rit)
+        {
+            (*rit)->onLeave();
+            // just to be sure that the state actually is registered
+            assert(inputStatesByName_.find((*rit)->getName()) != inputStatesByName_.end());
+            activeStates_.erase((*rit)->getPriority());
+            _updateActiveStates();
+        }
+        stateLeaveRequests_.clear();
+        // check for states to enter
+        for (std::set<InputState*>::reverse_iterator rit = stateEnterRequests_.rbegin();
+            rit != stateEnterRequests_.rend(); ++rit)
+        {
+            // just to be sure that the state actually is registered
+            assert(inputStatesByName_.find((*rit)->getName()) != inputStatesByName_.end());
+            activeStates_[(*rit)->getPriority()] = (*rit);
+            _updateActiveStates();
+            (*rit)->onEnter();
+        }
+        stateEnterRequests_.clear();
+        // check for states to destroy
+        for (std::set<InputState*>::reverse_iterator rit = stateDestroyRequests_.rbegin();
+            rit != stateDestroyRequests_.rend(); ++rit)
+        {
+            _destroyState((*rit));
+        }
+        stateDestroyRequests_.clear();
+        // mark that we capture and distribute input
+        internalState_ |= Ticking;
+        // Capture all the input. This calls the event handlers in InputManager.
+        if (keyboard_)
+            keyboard_->capture();
+        if (mouse_)
+            mouse_->capture();
+        for (unsigned  int i = 0; i < joySticksSize_; i++)
+            joySticks_[i]->capture();
+        if (!bCalibrating_)
+        {
+            // call all the handlers for the held key events
+            for (unsigned int iKey = 0; iKey < keysDown_.size(); iKey++)
+                activeStatesTop_[Keyboard]->keyHeld(KeyEvent(keysDown_[iKey], keyboardModifiers_));
+            // call all the handlers for the held mouse button events
+            for (unsigned int iButton = 0; iButton < mouseButtonsDown_.size(); iButton++)
+                activeStatesTop_[Mouse]->mouseButtonHeld(mouseButtonsDown_[iButton]);
+            // call all the handlers for the held joy stick button events
+            for (unsigned int iJoyStick  = 0; iJoyStick < joySticksSize_; iJoyStick++)
+                for (unsigned int iButton   = 0; iButton   < joyStickButtonsDown_[iJoyStick].size(); iButton++)
+                    activeStatesTop_[JoyStick0 + iJoyStick]
+                        ->joyStickButtonHeld(iJoyStick, joyStickButtonsDown_[iJoyStick][iButton]);
+            // tick the handlers for each active handler
+            for (unsigned int i = 0; i < devicesNum_; ++i)
+                activeStatesTop_[i]->tickInput(dt, i);
+            // tick the handler with a general tick afterwards
+            for (unsigned int i = 0; i < activeStatesTicked_.size(); ++i)
+                activeStatesTicked_[i]->tickInput(dt);
+        }
+        internalState_ &= ~Ticking;
+    }
+    /**
+    @brief
+        Updates the currently active states (according to activeStates_) for each device.
+        Also, a list of all active states (no duplicates!) is compiled for the general tick.
+    */
+    void InputManager::_updateActiveStates()
+    {
+        for (std::map<int, InputState*>::const_iterator it = activeStates_.begin(); it != activeStates_.end(); ++it)
+            for (unsigned int i = 0; i < devicesNum_; ++i)
+                if (it->second->isInputDeviceEnabled(i))
+                    activeStatesTop_[i] = it->second;
+        // update tickables (every state will only appear once)
+        // Using a std::set to avoid duplicates
+        std::set<InputState*> tempSet;
+        for (unsigned int i = 0; i < devicesNum_; ++i)
+            tempSet.insert(activeStatesTop_[i]);
+        // copy the content of the set back to the actual vector
+        activeStatesTicked_.clear();
+        for (std::set<InputState*>::const_iterator it = tempSet.begin();it != tempSet.end(); ++it)
+            activeStatesTicked_.push_back(*it);
+        this->mouseButtonsDown_.clear();
+    }
+    /**
+    @brief
+        Processes the accumultated data for the joy stick calibration.
+    */
+    void InputManager::_completeCalibration()
+    {
+        for (unsigned int i = 0; i < 24; i++)
+        {
+            // positive coefficient
+            if (marginalsMax_[i] == INT_MIN)
+                marginalsMax_[i] =  32767;
+            // coefficients
+            if (marginalsMax_[i] - joySticksCalibration_[0].zeroStates[i])
+            {
+                joySticksCalibration_[0].positiveCoeff[i]
+                    = 1.0f/(marginalsMax_[i] - joySticksCalibration_[0].zeroStates[i]);
+            }
+            else
+                joySticksCalibration_[0].positiveCoeff[i] =  1.0f;
+            // config value
+            ConfigValueContainer* cont = getIdentifier()->getConfigValueContainer("CoeffPos");
+            assert(cont);
+            cont->set(i, joySticksCalibration_[0].positiveCoeff[i]);
+            // negative coefficient
+            if (marginalsMin_[i] == INT_MAX)
+                marginalsMin_[i] = -32768;
+            // coefficients
+            if (marginalsMin_[i] - joySticksCalibration_[0].zeroStates[i])
+            {
+                joySticksCalibration_[0].negativeCoeff[i] = -1.0f
+                    / (marginalsMin_[i] - joySticksCalibration_[0].zeroStates[i]);
+            }
+            else
+                joySticksCalibration_[0].negativeCoeff[i] =  1.0f;
+            // config value
+            cont = getIdentifier()->getConfigValueContainer("CoeffNeg");
+            assert(cont);
+            cont->set(i, joySticksCalibration_[0].negativeCoeff[i]);
+            // zero states
+            if (i < 8)
+            {
+                if (!(i & 1))
+                    joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mSliders[i/2].abX;
+                else
+                    joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mSliders[i/2].abY;
+            }
+            else
+            {
+                if (i - 8 < joySticks_[0]->getJoyStickState().mAxes.size())
+                    joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mAxes[i - 8].abs;
+                else
+                    joySticksCalibration_[0].zeroStates[i] = 0;
+            }
+            // config value
+            cont = getIdentifier()->getConfigValueContainer("Zero");
+            assert(cont);
+            cont->set(i, joySticksCalibration_[0].zeroStates[i]);
+        }
+        // restore old input state
+        requestLeaveState("calibrator");
+        bCalibrating_ = false;
+    }
+    // ############################################################
+    // #####                    OIS events                    #####
+    // ##########                                        ##########
+    // ############################################################
+    // ###### Key Events ######
+    /**
+    @brief
+        Event handler for the keyPressed Event.
+    @param e
+        Event information
+    */
+    bool InputManager::keyPressed(const OIS::KeyEvent &e)
+    {
+        // check whether the key already is in the list (can happen when focus was lost)
+        unsigned int iKey = 0;
+        while (iKey < keysDown_.size() && keysDown_[iKey].key != (KeyCode::Enum)e.key)
+            iKey++;
+        if (iKey == keysDown_.size())
+            keysDown_.push_back(Key(e));
+        else
+            return true;
+        // update modifiers
+        if(e.key == OIS::KC_RMENU    || e.key == OIS::KC_LMENU)
+            keyboardModifiers_ |= KeyboardModifier::Alt;   // alt key
+        if(e.key == OIS::KC_RCONTROL || e.key == OIS::KC_LCONTROL)
+            keyboardModifiers_ |= KeyboardModifier::Ctrl;  // ctrl key
+        if(e.key == OIS::KC_RSHIFT   || e.key == OIS::KC_LSHIFT)
+            keyboardModifiers_ |= KeyboardModifier::Shift; // shift key
+        activeStatesTop_[Keyboard]->keyPressed(KeyEvent(e, keyboardModifiers_));
+        return true;
+    }
+    /**
+    @brief
+        Event handler for the keyReleased Event.
+    @param e
+        Event information
+    */
+    bool InputManager::keyReleased(const OIS::KeyEvent &e)
+    {
+        // remove the key from the keysDown_ list
+        for (unsigned int iKey = 0; iKey < keysDown_.size(); iKey++)
+        {
+            if (keysDown_[iKey].key == (KeyCode::Enum)e.key)
+            {
+                keysDown_.erase(keysDown_.begin() + iKey);
+                break;
+            }
+        }
+        // update modifiers
+        if(e.key == OIS::KC_RMENU    || e.key == OIS::KC_LMENU)
+            keyboardModifiers_ &= ~KeyboardModifier::Alt;   // alt key
+        if(e.key == OIS::KC_RCONTROL || e.key == OIS::KC_LCONTROL)
+            keyboardModifiers_ &= ~KeyboardModifier::Ctrl;  // ctrl key
+        if(e.key == OIS::KC_RSHIFT   || e.key == OIS::KC_LSHIFT)
+            keyboardModifiers_ &= ~KeyboardModifier::Shift; // shift key
+        activeStatesTop_[Keyboard]->keyReleased(KeyEvent(e, keyboardModifiers_));
+        return true;
+    }
+    // ###### Mouse Events ######
+    /**
+    @brief
+        Event handler for the mouseMoved Event.
+    @param e
+        Event information
+    */
+    bool InputManager::mouseMoved(const OIS::MouseEvent &e)
+    {
+        // check for actual moved event
+        if (e.state.X.rel != 0 || e.state.Y.rel != 0)
+        {
+            activeStatesTop_[Mouse]->mouseMoved(IntVector2(e.state.X.abs, e.state.Y.abs),
+                    IntVector2(e.state.X.rel, e.state.Y.rel), IntVector2(e.state.width, e.state.height));
+        }
+        // check for mouse scrolled event
+        if (e.state.Z.rel != 0)
+        {
+            activeStatesTop_[Mouse]->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
+        }
+        return true;
+    }
+    /**
+    @brief
+        Event handler for the mousePressed Event.
+    @param e
+        Event information
+    @param id
+        The ID of the mouse button
+    */
+    bool InputManager::mousePressed(const OIS::MouseEvent &e, OIS::MouseButtonID id)
+    {
+        // check whether the button already is in the list (can happen when focus was lost)
+        unsigned int iButton = 0;
+        while (iButton < mouseButtonsDown_.size() && mouseButtonsDown_[iButton] != (MouseButton::Enum)id)
+            iButton++;
+        if (iButton == mouseButtonsDown_.size())
+            mouseButtonsDown_.push_back((MouseButton::Enum)id);
+        activeStatesTop_[Mouse]->mouseButtonPressed((MouseButton::Enum)id);
+        return true;
+    }
+    /**
+    @brief
+        Event handler for the mouseReleased Event.
+    @param e
+        Event information
+    @param id
+        The ID of the mouse button
+    */
+    bool InputManager::mouseReleased(const OIS::MouseEvent &e, OIS::MouseButtonID id)
+    {
+        // remove the button from the keysDown_ list
+        for (unsigned int iButton = 0; iButton < mouseButtonsDown_.size(); iButton++)
+        {
+            if (mouseButtonsDown_[iButton] == (MouseButton::Enum)id)
+            {
+                mouseButtonsDown_.erase(mouseButtonsDown_.begin() + iButton);
+                break;
+            }
+        }
+        activeStatesTop_[Mouse]->mouseButtonReleased((MouseButton::Enum)id);
+        return true;
+    }
+    // ###### Joy Stick Events ######
+    /**
+    @brief
+        Returns the joy stick ID (orxonox) according to a OIS::JoyStickEvent
+    */
+    inline unsigned int InputManager::_getJoystick(const OIS::JoyStickEvent& arg)
+    {
+        // use the device to identify which one called the method
+        OIS::JoyStick* joyStick = (OIS::JoyStick*)arg.device;
+        unsigned int iJoyStick = 0;
+        while (joySticks_[iJoyStick] != joyStick)
+            iJoyStick++;
+        // assert: Unknown joystick fired an event.
+        assert(iJoyStick != joySticksSize_);
+        return iJoyStick;
+    }
+    bool InputManager::buttonPressed(const OIS::JoyStickEvent &arg, int button)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        // check whether the button already is in the list (can happen when focus was lost)
+        std::vector<JoyStickButton::Enum>& buttonsDown = joyStickButtonsDown_[iJoyStick];
+        unsigned int iButton = 0;
+        while (iButton < buttonsDown.size() && buttonsDown[iButton] != button)
+            iButton++;
+        if (iButton == buttonsDown.size())
+            buttonsDown.push_back((JoyStickButton::Enum)button);
+        activeStatesTop_[2 + iJoyStick]->joyStickButtonPressed(iJoyStick, (JoyStickButton::Enum)button);
+        return true;
+    }
+    bool InputManager::buttonReleased(const OIS::JoyStickEvent &arg, int button)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        // remove the button from the joyStickButtonsDown_ list
+        std::vector<JoyStickButton::Enum>& buttonsDown = joyStickButtonsDown_[iJoyStick];
+        for (unsigned int iButton = 0; iButton < buttonsDown.size(); iButton++)
+        {
+            if (buttonsDown[iButton] == button)
+            {
+                buttonsDown.erase(buttonsDown.begin() + iButton);
+                break;
+            }
+        }
+        activeStatesTop_[2 + iJoyStick]->joyStickButtonReleased(iJoyStick, (JoyStickButton::Enum)button);
+        return true;
+    }
+    /**
+    @brief
+        Calls the states for a particular axis with our enumeration.
+        Used by OIS sliders and OIS axes.
+    */
+    void InputManager::_fireAxis(unsigned int iJoyStick, int axis, int value)
+    {
+        if (bCalibrating_)
+        {
+            if (value > marginalsMax_[axis])
+                marginalsMax_[axis] = value;
+            if (value < marginalsMin_[axis])
+                marginalsMin_[axis] = value;
+        }
+        else
+        {
+            float fValue = value - joySticksCalibration_[iJoyStick].zeroStates[axis];
+            if (fValue > 0.0f)
+                fValue *= joySticksCalibration_[iJoyStick].positiveCoeff[axis];
+            else
+                fValue *= joySticksCalibration_[iJoyStick].negativeCoeff[axis];
+            activeStatesTop_[2 + iJoyStick]->joyStickAxisMoved(iJoyStick, axis, fValue);
+        }
+    }
+    bool InputManager::axisMoved(const OIS::JoyStickEvent &arg, int axis)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        // keep in mind that the first 8 axes are reserved for the sliders
+        _fireAxis(iJoyStick, axis + 8, arg.state.mAxes[axis].abs);
+        return true;
+    }
+    bool InputManager::sliderMoved(const OIS::JoyStickEvent &arg, int id)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        if (sliderStates_[iJoyStick].sliderStates[id].x != arg.state.mSliders[id].abX)
+            _fireAxis(iJoyStick, id * 2, arg.state.mSliders[id].abX);
+        else if (sliderStates_[iJoyStick].sliderStates[id].y != arg.state.mSliders[id].abY)
+            _fireAxis(iJoyStick, id * 2 + 1, arg.state.mSliders[id].abY);
+        return true;
+    }
+    bool InputManager::povMoved(const OIS::JoyStickEvent &arg, int id)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        // translate the POV into 8 simple buttons
+        int lastState = povStates_[iJoyStick][id];
+        if (lastState & OIS::Pov::North)
+            buttonReleased(arg, 32 + id * 4 + 0);
+        if (lastState & OIS::Pov::South)
+            buttonReleased(arg, 32 + id * 4 + 1);
+        if (lastState & OIS::Pov::East)
+            buttonReleased(arg, 32 + id * 4 + 2);
+        if (lastState & OIS::Pov::West)
+            buttonReleased(arg, 32 + id * 4 + 3);
+        povStates_[iJoyStick].povStates[id] = arg.state.mPOV[id].direction;
+        int currentState = povStates_[iJoyStick][id];
+        if (currentState & OIS::Pov::North)
+            buttonPressed(arg, 32 + id * 4 + 0);
+        if (currentState & OIS::Pov::South)
+            buttonPressed(arg, 32 + id * 4 + 1);
+        if (currentState & OIS::Pov::East)
+            buttonPressed(arg, 32 + id * 4 + 2);
+        if (currentState & OIS::Pov::West)
+            buttonPressed(arg, 32 + id * 4 + 3);
+        return true;
+    }
+    // ############################################################
+    // #####         Other Public Interface Methods           #####
+    // ##########                                        ##########
+    // ############################################################
+    /**
+    @brief
+        Adjusts the mouse window metrics.
+        This method has to be called every time the size of the window changes.
+    @param width
+        The new width of the render window
+    @param^height
+        The new height of the render window
+    */
+    void InputManager::setWindowExtents(const int width, const int height)
+    {
+        if (mouse_)
+        {
+            // Set mouse region (if window resizes, we should alter this to reflect as well)
+            mouse_->getMouseState().width  = width;
+            mouse_->getMouseState().height = height;
+        }
+    }
+    // ###### InputStates ######
+    /**
+    @brief
+        Adds a new key handler.
+    @param handler
+        Pointer to the handler object.
+    @param name
+        Unique name of the handler.
+    @param priority
+        Unique integer number. Higher means more prioritised.
+    @return
+        True if added, false if name or priority already existed.
+    */
+    bool InputManager::_configureInputState(InputState* state, const std::string& name, int priority)
+    {
+        if (name == "")
+            return false;
+        if (!state)
+            return false;
+        if (inputStatesByName_.find(name) == inputStatesByName_.end())
+        {
+            if (inputStatesByPriority_.find(priority)
+                == inputStatesByPriority_.end())
+            {
+                inputStatesByName_[name] = state;
+                inputStatesByPriority_[priority] = state;
+                state->setNumOfJoySticks(numberOfJoySticks());
+                state->setName(name);
+                state->setPriority(priority);
+                return true;
+            }
+            else
+            {
+                COUT(2) << "Warning: Could not add an InputState with the same priority '"
+                    << priority << "'." << std::endl;
+                return false;
+            }
+        }
+        else
+        {
+            COUT(2) << "Warning: Could not add an InputState with the same name '" << name << "'." << std::endl;
+            return false;
+        }
+    }
+    /**
+    @brief
+        Removes and destroys an input state internally.
+    @param name
+        Name of the handler.
+    @return
+        True if removal was successful, false if name was not found.
+    @remarks
+        You can't remove the internal states "empty", "calibrator" and "detector".
+        The removal process is being postponed if InputManager::tick() is currently running.
+    */
+    bool InputManager::requestDestroyState(const std::string& name)
+    {
+        if (name == "empty" || name == "calibrator" || name == "detector")
+        {
+            COUT(2) << "InputManager: Removing the '" << name << "' state is not allowed!" << std::endl;
+            return false;
+        }
+        std::map<std::string, InputState*>::iterator it = inputStatesByName_.find(name);
+        if (it != inputStatesByName_.end())
+        {
+            if (activeStates_.find(it->second->getPriority()) != activeStates_.end())
+            {
+                // The state is still active. We have to postpone
+                stateLeaveRequests_.insert(it->second);
+                stateDestroyRequests_.insert(it->second);
+            }
+            else if (this->internalState_ & Ticking)
+            {
+                // cannot remove state while ticking
+                stateDestroyRequests_.insert(it->second);
+            }
+            else
+                _destroyState(it->second);
+            return true;
+        }
         return false;
+      }
+      if (createKeyboard)
+        _initialiseKeyboard();
+      if (createMouse)
+        _initialiseMouse();
+      if (createJoySticks)
+        _initialiseJoySticks();
+      // Set mouse/joystick region
+      if (mouse_)
+      {
+        setWindowExtents(windowWidth, windowHeight);
+      }
+      state_ = IS_NONE;
+      CCOUT(ORX_DEBUG) << "Initialising OIS components done." << std::endl;
+      // InputManager holds the input buffer --> create one and add it.
+      buffer_ = new InputBuffer();
+      addKeyHandler(buffer_, "buffer");
+      Shell::getInstance().setInputBuffer(buffer_);
+      keyBinder_ = new KeyBinder();
+      keyBinder_->loadBindings();
+      addKeyHandler(keyBinder_, "keybinder");
+      addMouseHandler(keyBinder_, "keybinder");
+      addJoyStickHandler(keyBinder_, "keybinder");
+      keyDetector_ = new KeyDetector();
+      keyDetector_->loadBindings();
+      addKeyHandler(keyDetector_, "keydetector");
+      addMouseHandler(keyDetector_, "keydetector");
+      addJoyStickHandler(keyDetector_, "keydetector");
+      calibratorCallback_ = new CalibratorCallback();
+      addKeyHandler(calibratorCallback_, "calibratorcallback");
+      setConfigValues();
+      CCOUT(ORX_DEBUG) << "Initialising complete." << std::endl;
+    }
+    else
+    {
+      CCOUT(ORX_WARNING) << "Warning: OIS compoments already initialised, skipping" << std::endl;
+    }
+    return true;
+  }
+  /**
+    @brief Creates a keyboard and sets the event handler.
+    @return False if keyboard stays uninitialised, true otherwise.
+  */
+  bool InputManager::_initialiseKeyboard()
+  {
+    if (keyboard_ != 0)
+    {
+      CCOUT(2) << "Warning: Keyboard already initialised, skipping." << std::endl;
+      return true;
+    }
+    try
+    {
+      if (inputSystem_->getNumberOfDevices(OIS::OISKeyboard) > 0)
+      {
+        keyboard_ = (OIS::Keyboard*)inputSystem_->createInputObject(OIS::OISKeyboard, true);
+        // register our listener in OIS.
+        keyboard_->setEventCallback(this);
+        // note: OIS will not detect keys that have already been down when the keyboard was created.
+        CCOUT(ORX_DEBUG) << "Created OIS keyboard" << std::endl;
+        return true;
+      }
+      else
+      {
+        CCOUT(ORX_WARNING) << "Warning: No keyboard found!" << std::endl;
+    }
+    /**
+    @brief
+        Returns the pointer to the requested InputState.
+    @param name
+        Unique name of the state.
+    @return
+        Pointer to the instance, 0 if name was not found.
+    */
+    InputState* InputManager::getState(const std::string& name)
+    {
+        std::map<std::string, InputState*>::iterator it = inputStatesByName_.find(name);
+        if (it != inputStatesByName_.end())
+            return it->second;
+        else
+            return 0;
+    }
+    /**
+    @brief
+        Returns the current input state (there might be others active too!)
+    @return
+        The current highest prioritised active input state.
+    */
+    InputState* InputManager::getCurrentState()
+    {
+        return (*activeStates_.rbegin()).second;
+    }
+    /**
+    @brief
+        Activates a specific input state.
+        It might not be really activated if the priority is too low!
+    @param name
+        Unique name of the state.
+    @return
+        False if name was not found, true otherwise.
+    */
+    bool InputManager::requestEnterState(const std::string& name)
+    {
+        // get pointer from the map with all stored handlers
+        std::map<std::string, InputState*>::const_iterator it = inputStatesByName_.find(name);
+        if (it != inputStatesByName_.end())
+        {
+            // exists
+            if (activeStates_.find(it->second->getPriority()) == activeStates_.end())
+            {
+                // not active
+                if (stateDestroyRequests_.find(it->second) == stateDestroyRequests_.end())
+                {
+                    // not scheduled for destruction
+                    // set prevents a state being added multiple times
+                    stateEnterRequests_.insert(it->second);
+                    return true;
+                }
+            }
+        }
         return false;
+      }
+    }
+    catch (OIS::Exception ex)
+    {
+      // TODO: Test this output regarding formatting
+      CCOUT(ORX_WARNING) << "Warning: Failed to create an OIS keyboard\n"
+          << "OIS error message: \"" << ex.eText << "\"" << std::endl;
+      keyboard_ = 0;
+      return false;
+    }
+  }
+  /**
+    @brief Creates a mouse and sets the event handler.
+    @return False if mouse stays uninitialised, true otherwise.
+  */
+  bool InputManager::_initialiseMouse()
+  {
+    if (mouse_ != 0)
+    {
+      CCOUT(2) << "Warning: Mouse already initialised, skipping." << std::endl;
+      return true;
+    }
+    try
+    {
+      if (inputSystem_->getNumberOfDevices(OIS::OISMouse) > 0)
+      {
+        mouse_ = static_cast<OIS::Mouse*>(inputSystem_->createInputObject(OIS::OISMouse, true));
+        // register our listener in OIS.
+        mouse_->setEventCallback(this);
+        CCOUT(ORX_DEBUG) << "Created OIS mouse" << std::endl;
+        return true;
+      }
+      else
+      {
+        CCOUT(ORX_WARNING) << "Warning: No mouse found!" << std::endl;
+    }
+    /**
+    @brief
+        Deactivates a specific input state.
+    @param name
+        Unique name of the state.
+    @return
+        False if name was not found, true otherwise.
+    */
+    bool InputManager::requestLeaveState(const std::string& name)
+    {
+        // get pointer from the map with all stored handlers
+        std::map<std::string, InputState*>::const_iterator it = inputStatesByName_.find(name);
+        if (it != inputStatesByName_.end())
+        {
+            // exists
+            if (activeStates_.find(it->second->getPriority()) != activeStates_.end())
+            {
+                // active
+                stateLeaveRequests_.insert(it->second);
+                return true;
+            }
+        }
         return false;
+      }
+    }
+    catch (OIS::Exception ex)
+    {
+      CCOUT(ORX_WARNING) << "Warning: Failed to create an OIS mouse\n"
+          << "OIS error message: \"" << ex.eText << "\"" << std::endl;
+      mouse_ = 0;
+      return false;
+    }
+  }
+  /**
+    @brief Creates all joy sticks and sets the event handler.
+    @return False joy stick stay uninitialised, true otherwise.
+  */
+  bool InputManager::_initialiseJoySticks()
+  {
+    if (joySticksSize_ > 0)
+    {
+      CCOUT(2) << "Warning: Joy sticks already initialised, skipping." << std::endl;
+      return true;
+    }
+    bool success = false;
+    if (inputSystem_->getNumberOfDevices(OIS::OISJoyStick) > 0)
+    {
+      for (int i = 0; i < inputSystem_->getNumberOfDevices(OIS::OISJoyStick); i++)
+      {
+        try
+        {
+          OIS::JoyStick* stig = static_cast<OIS::JoyStick*>(inputSystem_->createInputObject(OIS::OISJoyStick, true));
+          joySticks_.push_back(stig);
+          // register our listener in OIS.
+          stig->setEventCallback(this);
+          CCOUT(ORX_DEBUG) << "Created OIS joy stick with ID " << stig->getID() << std::endl;
+          success = true;
+        }
+        catch (OIS::Exception ex)
+        {
+          CCOUT(ORX_WARNING) << "Warning: Failed to create OIS joy number" << i << "\n"
+              << "OIS error message: \"" << ex.eText << "\"" << std::endl;
+        }
+      }
+    }
+    else
+    {
+      CCOUT(ORX_WARNING) << "Warning: Joy stick support requested, but no joy stick was found" << std::endl;
+      return false;
+    }
+    joySticksSize_ = joySticks_.size();
+    activeJoyStickHandlers_.resize(joySticksSize_);
+    joyStickButtonsDown_.resize(joySticksSize_);
+    povStates_.resize(joySticksSize_);
+    sliderStates_.resize(joySticksSize_);
+    joySticksCalibration_.resize(joySticksSize_);
+    for (unsigned int iJoyStick = 0; iJoyStick < joySticksSize_; iJoyStick++)
+    {
+      // reset the calibration with default values
+      for (unsigned int i = 0; i < 24; i++)
+      {
+        joySticksCalibration_[iJoyStick].negativeCoeff[i] = 1.0f/32767.0f;
+        joySticksCalibration_[iJoyStick].positiveCoeff[i] = 1.0f/32768.0f;
+        joySticksCalibration_[iJoyStick].zeroStates[i] = 0;
+      }
+    }
+    return success;
+  }
+  /**
+    @brief Sets the configurable values. Use keybindings.ini as file..
+  */
+  void InputManager::setConfigValues()
+  {
+    if (joySticksSize_)
+    {
+      std::vector<double> coeffPos;
+      std::vector<double> coeffNeg;
+      std::vector<int> zero;
+      coeffPos.resize(24);
+      coeffNeg.resize(24);
+      zero.resize(24);
+      for (unsigned int i = 0; i < 24; i++)
+      {
+        coeffPos[i] =  1.0f/32767.0f;
+        coeffNeg[i] =  1.0f/32768.0f;
+        zero[i]     =  0;
+      }
+      ConfigValueContainer* cont = getIdentifier()->getConfigValueContainer("CoeffPos");
+      if (!cont)
+      {
+          cont = new ConfigValueContainer(CFT_Keybindings, getIdentifier(), "CoeffPos", coeffPos);
+          getIdentifier()->addConfigValueContainer("CoeffPos", cont);
+      }
+      cont->getValue(&coeffPos, this);
+      cont = getIdentifier()->getConfigValueContainer("CoeffNeg");
+      if (!cont)
+      {
+          cont = new ConfigValueContainer(CFT_Keybindings, getIdentifier(), "CoeffNeg", coeffNeg);
+          getIdentifier()->addConfigValueContainer("CoeffNeg", cont);
+      }
+      cont->getValue(&coeffNeg, this);
+      cont = getIdentifier()->getConfigValueContainer("Zero");
+      if (!cont)
+      {
+          cont = new ConfigValueContainer(CFT_Keybindings, getIdentifier(), "Zero", zero);
+          getIdentifier()->addConfigValueContainer("Zero", cont);
+      }
+      cont->getValue(&zero, this);
+      // copy values to our own variables
+      for (unsigned int i = 0; i < 24; i++)
+      {
+        joySticksCalibration_[0].positiveCoeff[i] = coeffPos[i];
+        joySticksCalibration_[0].negativeCoeff[i] = coeffNeg[i];
+        joySticksCalibration_[0].zeroStates[i]    = zero[i];
+      }
+    }
+  }
+  /**
+    @brief Destroys all the created input devices and sets the InputManager to construction state.
+  */
+  void InputManager::_destroy()
+  {
+    if (state_ != IS_UNINIT)
+    {
+      CCOUT(ORX_DEBUG) << "Destroying ..." << std::endl;
+      if (buffer_)
+        delete buffer_;
+      if (keyBinder_)
+        delete keyBinder_;
+      if (keyDetector_)
+        delete keyDetector_;
+      if (calibratorCallback_)
+        delete calibratorCallback_;
+      keyHandlers_.clear();
+      mouseHandlers_.clear();
+      joyStickHandlers_.clear();
+      _destroyKeyboard();
+      _destroyMouse();
+      _destroyJoySticks();
+      activeHandlers_.clear();
+      // inputSystem_ can never be 0, or else the code is mistaken
+      OIS::InputManager::destroyInputSystem(inputSystem_);
+      inputSystem_ = 0;
+      state_ = IS_UNINIT;
+      CCOUT(ORX_DEBUG) << "Destroying done." << std::endl;
+    }
+  }
+  /**
+    @brief Destroys the keyboard and sets it to 0.
+  */
+  void InputManager::_destroyKeyboard()
+  {
+    if (keyboard_)
+      // inputSystem_ can never be 0, or else the code is mistaken
+      inputSystem_->destroyInputObject(keyboard_);
+    keyboard_ = 0;
+    activeKeyHandlers_.clear();
+    keysDown_.clear();
+    CCOUT(ORX_DEBUG) << "Keyboard destroyed." << std::endl;
+  }
+  /**
+    @brief Destroys the mouse and sets it to 0.
+  */
+  void InputManager::_destroyMouse()
+  {
+    if (mouse_)
+      // inputSystem_ can never be 0, or else the code is mistaken
+      inputSystem_->destroyInputObject(mouse_);
+    mouse_ = 0;
+    activeMouseHandlers_.clear();
+    mouseButtonsDown_.clear();
+    CCOUT(ORX_DEBUG) << "Mouse destroyed." << std::endl;
+  }
+  /**
+    @brief Destroys all the joy sticks and resizes the lists to 0.
+  */
+  void InputManager::_destroyJoySticks()
+  {
+    if (joySticksSize_ > 0)
+    {
+      // note: inputSystem_ can never be 0, or else the code is mistaken
+      for (unsigned int i = 0; i < joySticksSize_; i++)
+        if (joySticks_[i] != 0)
+          inputSystem_->destroyInputObject(joySticks_[i]);
+      joySticks_.clear();
+      joySticksSize_ = 0;
+      activeJoyStickHandlers_.clear();
+      joyStickButtonsDown_.clear();
+      povStates_.clear();
+      sliderStates_.clear();
+      joySticksCalibration_.clear();
+    }
+    CCOUT(ORX_DEBUG) << "Joy sticks destroyed." << std::endl;
+  }
+  void InputManager::_saveState()
+  {
+    savedHandlers_.activeHandlers_ = activeHandlers_;
+    savedHandlers_.activeJoyStickHandlers_ = activeJoyStickHandlers_;
+    savedHandlers_.activeKeyHandlers_ = activeKeyHandlers_;
+    savedHandlers_.activeMouseHandlers_ = activeMouseHandlers_;
+  }
+  void InputManager::_restoreState()
+  {
+    activeHandlers_ = savedHandlers_.activeHandlers_;
+    activeJoyStickHandlers_ = savedHandlers_.activeJoyStickHandlers_;
+    activeKeyHandlers_ = savedHandlers_.activeKeyHandlers_;
+    activeMouseHandlers_ = savedHandlers_.activeMouseHandlers_;
+  }
+  void InputManager::_updateTickables()
+  {
+    // we can use a map to have a list of unique pointers (an object can implement all 3 handlers)
+    std::map<InputTickable*, HandlerState> tempSet;
+    for (unsigned int iHandler = 0; iHandler < activeKeyHandlers_.size(); iHandler++)
+      tempSet[activeKeyHandlers_[iHandler]].joyStick = true;
+    for (unsigned int iHandler = 0; iHandler < activeMouseHandlers_.size(); iHandler++)
+      tempSet[activeMouseHandlers_[iHandler]].mouse = true;
+    for (unsigned int iJoyStick  = 0; iJoyStick < joySticksSize_; iJoyStick++)
+      for (unsigned int iHandler = 0; iHandler  < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
+        tempSet[activeJoyStickHandlers_[iJoyStick][iHandler]].joyStick = true;
+    // copy the content of the map back to the actual vector
+    activeHandlers_.clear();
+    for (std::map<InputTickable*, HandlerState>::const_iterator itHandler = tempSet.begin();
+        itHandler != tempSet.end(); itHandler++)
+      activeHandlers_.push_back(std::pair<InputTickable*, HandlerState>((*itHandler).first, (*itHandler).second));
+  }
+  // #################################
+  // ### Private Interface Methods ###
+  // #################################
+  // #################################
+  /**
+    @brief Updates the InputManager. Tick is called by Orxonox.
+    @param dt Delta time
+  */
+  void InputManager::_tick(float dt)
+  {
+    if (state_ == IS_UNINIT)
+      return;
+    if (state_ != stateRequest_)
+    {
+      InputState sr = stateRequest_;
+      switch (sr)
+      {
+      case IS_NORMAL:
+        activeKeyHandlers_.clear();
+        activeMouseHandlers_.clear();
+        for (unsigned int i = 0; i < joySticksSize_; i++)
+          activeJoyStickHandlers_[i].clear();
+        // normal play mode
+        // note: we assume that the handlers exist since otherwise, something's wrong anyway.
+        enableKeyHandler("keybinder");
+        enableMouseHandler("keybinder");
+        enableJoyStickHandler("keybinder", 0);
+        stateRequest_ = IS_NORMAL;
+        state_ = IS_NORMAL;
+        break;
+      case IS_GUI:
+        state_ = IS_GUI;
+        break;
+      case IS_CONSOLE:
+        activeKeyHandlers_.clear();
+        activeMouseHandlers_.clear();
+        for (unsigned int i = 0; i < joySticksSize_; i++)
+          activeJoyStickHandlers_[i].clear();
+        enableMouseHandler("keybinder");
+        enableJoyStickHandler("keybinder", 0);
+        enableKeyHandler("buffer");
+        stateRequest_ = IS_CONSOLE;
+        state_ = IS_CONSOLE;
+        break;
+      case IS_DETECT:
+        savedState_ = state_;
+        _saveState();
+        activeKeyHandlers_.clear();
+        activeMouseHandlers_.clear();
+        for (unsigned int i = 0; i < joySticksSize_; i++)
+          activeJoyStickHandlers_[i].clear();
+        enableKeyHandler("keydetector");
+        enableMouseHandler("keydetector");
+        enableJoyStickHandler("keydetector", 0);
+        stateRequest_ = IS_DETECT;
+        state_ = IS_DETECT;
+        break;
+      case IS_NODETECT:
+        _restoreState();
+        keysDown_.clear();
+        mouseButtonsDown_.clear();
+        for (unsigned int i = 0; i < joySticksSize_; i++)
+          joyStickButtonsDown_[i].clear();
+        state_ = IS_NODETECT;
+        stateRequest_ = savedState_;
+        break;
+      case IS_CALIBRATE:
+        if (joySticksSize_)
+        {
+          savedState_ = _getSingleton().state_;
+          for (unsigned int i = 0; i < 24; i++)
+          {
+            marginalsMax_[i] = INT_MIN;
+            marginalsMin_[i] = INT_MAX;
+          }
+          COUT(0) << "Move all joy stick axes in all directions a few times. "
+            << "Then put all axes in zero state and hit enter." << std::endl;
+          savedState_ = state_;
+          _saveState();
+          activeKeyHandlers_.clear();
+          activeMouseHandlers_.clear();
+          for (unsigned int i = 0; i < joySticksSize_; i++)
+            activeJoyStickHandlers_[i].clear();
+          enableKeyHandler("calibratorcallback");
+          stateRequest_ = IS_CALIBRATE;
+          state_ = IS_CALIBRATE;
+        }
+        else
+        {
+          COUT(3) << "Connot calibrate, no joy stick found!" << std::endl;
+          stateRequest_ = state_;
+        }
+        break;
+      case IS_NOCALIBRATE:
+        _completeCalibration();
+        _restoreState();
+        keyBinder_->resetJoyStickAxes();
+        state_ = IS_NOCALIBRATE;
+        stateRequest_ = savedState_;
+        break;
+      case IS_NONE:
+        activeKeyHandlers_.clear();
+        activeMouseHandlers_.clear();
+        for (unsigned int i = 0; i < joySticksSize_; i++)
+          activeJoyStickHandlers_[i].clear();
+        state_ = IS_NONE;
+      default:
+        break;
+      }
+    }
+    // Capture all the input. This calls the event handlers in InputManager.
+    if (mouse_)
+      mouse_->capture();
+    if (keyboard_)
+      keyboard_->capture();
+    for (unsigned  int i = 0; i < joySticksSize_; i++)
+      joySticks_[i]->capture();
+    if (state_ != IS_CALIBRATE)
+    {
+      // call all the handlers for the held key events
+      for (unsigned int iKey = 0; iKey < keysDown_.size(); iKey++)
+        for (unsigned int iHandler = 0; iHandler < activeKeyHandlers_.size(); iHandler++)
+          activeKeyHandlers_[iHandler]->keyHeld(KeyEvent(keysDown_[iKey], keyboardModifiers_));
+      // call all the handlers for the held mouse button events
+      for (unsigned int iButton = 0; iButton < mouseButtonsDown_.size(); iButton++)
+        for (unsigned int iHandler = 0; iHandler < activeMouseHandlers_.size(); iHandler++)
+          activeMouseHandlers_[iHandler]->mouseButtonHeld(mouseButtonsDown_[iButton]);
+      // call all the handlers for the held joy stick button events
+      for (unsigned int iJoyStick  = 0; iJoyStick < joySticksSize_; iJoyStick++)
+        for (unsigned int iButton   = 0; iButton   < joyStickButtonsDown_[iJoyStick].size(); iButton++)
+          for (unsigned int iHandler = 0; iHandler  < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
+            activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickButtonHeld(iJoyStick, joyStickButtonsDown_[iJoyStick][iButton]);
+    }
+    // call the ticks for the handlers (need to be treated specially)
+    for (unsigned int iHandler = 0; iHandler < activeHandlers_.size(); iHandler++)
+      activeHandlers_[iHandler].first->tickInput(dt, activeHandlers_[iHandler].second);
+  }
+  void InputManager::_completeCalibration()
+  {
+    for (unsigned int i = 0; i < 24; i++)
+    {
+      // positive coefficient
+      if (marginalsMax_[i] == INT_MIN)
+        marginalsMax_[i] =  32767;
+      // coefficients
+      if (marginalsMax_[i] - joySticksCalibration_[0].zeroStates[i])
+        joySticksCalibration_[0].positiveCoeff[i] =  1.0f/(marginalsMax_[i] - joySticksCalibration_[0].zeroStates[i]);
+      else
+        joySticksCalibration_[0].positiveCoeff[i] =  1.0f;
+      // config value
+      ConfigValueContainer* cont = getIdentifier()->getConfigValueContainer("CoeffPos");
+      assert(cont);
+      cont->set(i, joySticksCalibration_[0].positiveCoeff[i]);
+      // negative coefficient
+      if (marginalsMin_[i] == INT_MAX)
+        marginalsMin_[i] = -32768;
+      // coefficients
+      if (marginalsMin_[i] - joySticksCalibration_[0].zeroStates[i])
+        joySticksCalibration_[0].negativeCoeff[i] = -1.0f/(marginalsMin_[i] - joySticksCalibration_[0].zeroStates[i]);
+      else
+        joySticksCalibration_[0].negativeCoeff[i] =  1.0f;
+      // config value
+      cont = getIdentifier()->getConfigValueContainer("CoeffNeg");
+      assert(cont);
+      cont->set(i, joySticksCalibration_[0].negativeCoeff[i]);
+      // zero states
+      if (i < 8)
+      {
+        if (!(i & 1))
+          joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mSliders[i/2].abX;
+        else
+          joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mSliders[i/2].abY;
+      }
+      else
+      {
+        if (i - 8 < joySticks_[0]->getJoyStickState().mAxes.size())
+          joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mAxes[i - 8].abs;
+        else
+          joySticksCalibration_[0].zeroStates[i] = 0;
+      }
+      // config value
+      cont = getIdentifier()->getConfigValueContainer("Zero");
+      assert(cont);
+      cont->set(i, joySticksCalibration_[0].zeroStates[i]);
+    }
+  }
+  // ###### Key Events ######
+  /**
+    @brief Event handler for the keyPressed Event.
+    @param e Event information
+  */
+  bool InputManager::keyPressed(const OIS::KeyEvent &e)
+  {
+    // check whether the key already is in the list (can happen when focus was lost)
+    unsigned int iKey = 0;
+    while (iKey < keysDown_.size() && keysDown_[iKey].key != (KeyCode::Enum)e.key)
+      iKey++;
+    if (iKey == keysDown_.size())
+      keysDown_.push_back(Key(e));
+    else
+      return true;
+    // update modifiers
+    if(e.key == OIS::KC_RMENU    || e.key == OIS::KC_LMENU)
+      keyboardModifiers_ |= KeyboardModifier::Alt;   // alt key
+    if(e.key == OIS::KC_RCONTROL || e.key == OIS::KC_LCONTROL)
+      keyboardModifiers_ |= KeyboardModifier::Ctrl;  // ctrl key
+    if(e.key == OIS::KC_RSHIFT   || e.key == OIS::KC_LSHIFT)
+      keyboardModifiers_ |= KeyboardModifier::Shift; // shift key
+    for (unsigned int i = 0; i < activeKeyHandlers_.size(); i++)
+      activeKeyHandlers_[i]->keyPressed(KeyEvent(e, keyboardModifiers_));
+    return true;
+  }
+  /**
+    @brief Event handler for the keyReleased Event.
+    @param e Event information
+  */
+  bool InputManager::keyReleased(const OIS::KeyEvent &e)
+  {
+    // remove the key from the keysDown_ list
+    for (unsigned int iKey = 0; iKey < keysDown_.size(); iKey++)
+    {
+      if (keysDown_[iKey].key == (KeyCode::Enum)e.key)
+      {
+        keysDown_.erase(keysDown_.begin() + iKey);
+        break;
+      }
+    }
+    // update modifiers
+    if(e.key == OIS::KC_RMENU    || e.key == OIS::KC_LMENU)
+      keyboardModifiers_ &= ~KeyboardModifier::Alt;   // alt key
+    if(e.key == OIS::KC_RCONTROL || e.key == OIS::KC_LCONTROL)
+      keyboardModifiers_ &= ~KeyboardModifier::Ctrl;  // ctrl key
+    if(e.key == OIS::KC_RSHIFT   || e.key == OIS::KC_LSHIFT)
+      keyboardModifiers_ &= ~KeyboardModifier::Shift; // shift key
+    for (unsigned int i = 0; i < activeKeyHandlers_.size(); i++)
+      activeKeyHandlers_[i]->keyReleased(KeyEvent(e, keyboardModifiers_));
+    return true;
+  }
+  // ###### Mouse Events ######
+  /**
+    @brief Event handler for the mouseMoved Event.
+    @param e Event information
+  */
+  bool InputManager::mouseMoved(const OIS::MouseEvent &e)
+  {
+    // check for actual moved event
+    if (e.state.X.rel != 0 || e.state.Y.rel != 0)
+    {
+      for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
+        activeMouseHandlers_[i]->mouseMoved(IntVector2(e.state.X.abs, e.state.Y.abs),
+            IntVector2(e.state.X.rel, e.state.Y.rel), IntVector2(e.state.width, e.state.height));
+    }
+    // check for mouse scrolled event
+    if (e.state.Z.rel != 0)
+    {
+      for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
+        activeMouseHandlers_[i]->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
+    }
+    return true;
+  }
+  /**
+    @brief Event handler for the mousePressed Event.
+    @param e Event information
+    @param id The ID of the mouse button
+  */
+  bool InputManager::mousePressed(const OIS::MouseEvent &e, OIS::MouseButtonID id)
+  {
+    // check whether the button already is in the list (can happen when focus was lost)
+    unsigned int iButton = 0;
+    while (iButton < mouseButtonsDown_.size() && mouseButtonsDown_[iButton] != (MouseButton::Enum)id)
+      iButton++;
+    if (iButton == mouseButtonsDown_.size())
+      mouseButtonsDown_.push_back((MouseButton::Enum)id);
+    for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
+      activeMouseHandlers_[i]->mouseButtonPressed((MouseButton::Enum)id);
+    return true;
+  }
+  /**
+    @brief Event handler for the mouseReleased Event.
+    @param e Event information
+    @param id The ID of the mouse button
+  */
+  bool InputManager::mouseReleased(const OIS::MouseEvent &e, OIS::MouseButtonID id)
+  {
+    // remove the button from the keysDown_ list
+    for (unsigned int iButton = 0; iButton < mouseButtonsDown_.size(); iButton++)
+    {
+      if (mouseButtonsDown_[iButton] == (MouseButton::Enum)id)
+      {
+        mouseButtonsDown_.erase(mouseButtonsDown_.begin() + iButton);
+        break;
+      }
+    }
+    for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
+      activeMouseHandlers_[i]->mouseButtonReleased((MouseButton::Enum)id);
+    return true;
+  }
+  // ###### Joy Stick Events ######
+  inline unsigned int InputManager::_getJoystick(const OIS::JoyStickEvent& arg)
+  {
+    // use the device to identify which one called the method
+    OIS::JoyStick* joyStick = (OIS::JoyStick*)arg.device;
+    unsigned int iJoyStick = 0;
+    while (joySticks_[iJoyStick] != joyStick)
+    {
+      iJoyStick++;
+      if (iJoyStick == joySticksSize_)
+      {
+        CCOUT(3) << "Unknown joystick fired an event. This means there is a bug somewhere! Aborting." << std::endl;
+        abort();
+      }
+    }
+    return iJoyStick;
+  }
+  bool InputManager::buttonPressed(const OIS::JoyStickEvent &arg, int button)
+  {
+    unsigned int iJoyStick = _getJoystick(arg);
+    // check whether the button already is in the list (can happen when focus was lost)
+    std::vector<int>& buttonsDown = joyStickButtonsDown_[iJoyStick];
+    unsigned int iButton = 0;
+    while (iButton < buttonsDown.size() && buttonsDown[iButton] != button)
+      iButton++;
+    if (iButton == buttonsDown.size())
+      buttonsDown.push_back(button);
+    for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
+      activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickButtonPressed(iJoyStick, button);
+    return true;
+  }
+  bool InputManager::buttonReleased(const OIS::JoyStickEvent &arg, int button)
+  {
+    unsigned int iJoyStick = _getJoystick(arg);
+    // remove the button from the joyStickButtonsDown_ list
+    std::vector<int>& buttonsDown = joyStickButtonsDown_[iJoyStick];
+    for (unsigned int iButton = 0; iButton < buttonsDown.size(); iButton++)
+    {
+      if (buttonsDown[iButton] == button)
+      {
+        buttonsDown.erase(buttonsDown.begin() + iButton);
+        break;
+      }
+    }
+    for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
+      activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickButtonReleased(iJoyStick, button);
+    return true;
+  }
+  void InputManager::_fireAxis(unsigned int iJoyStick, int axis, int value)
+  {
+    if (state_ == IS_CALIBRATE)
+    {
+      if (value > marginalsMax_[axis])
+        marginalsMax_[axis] = value;
+      if (value < marginalsMin_[axis])
+        marginalsMin_[axis] = value;
+    }
+    else
+    {
+      float fValue = value - joySticksCalibration_[iJoyStick].zeroStates[axis];
+      if (fValue > 0.0f)
+        fValue *= joySticksCalibration_[iJoyStick].positiveCoeff[axis];
+      else
+        fValue *= joySticksCalibration_[iJoyStick].negativeCoeff[axis];
+      for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
+        activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickAxisMoved(iJoyStick, axis, fValue);
+    }
+  }
+  bool InputManager::axisMoved(const OIS::JoyStickEvent &arg, int axis)
+  {
+    //if (arg.state.mAxes[axis].abs > 10000 || arg.state.mAxes[axis].abs < -10000)
+    //{ CCOUT(3) << "axis " << axis << " moved" << arg.state.mAxes[axis].abs << std::endl;}
+    unsigned int iJoyStick = _getJoystick(arg);
+    // keep in mind that the first 8 axes are reserved for the sliders
+    _fireAxis(iJoyStick, axis + 8, arg.state.mAxes[axis].abs);
+    return true;
+  }
+  bool InputManager::sliderMoved(const OIS::JoyStickEvent &arg, int id)
+  {
+    //if (arg.state.mSliders[id].abX > 10000 || arg.state.mSliders[id].abX < -10000)
+    //{CCOUT(3) << "slider " << id << " moved" << arg.state.mSliders[id].abX << std::endl;}
+    //CCOUT(3) << arg.state.mSliders[id].abX << "\t |" << arg.state.mSliders[id].abY << std::endl;
+    unsigned int iJoyStick = _getJoystick(arg);
+    if (sliderStates_[iJoyStick].sliderStates[id].x != arg.state.mSliders[id].abX)
+      _fireAxis(iJoyStick, id * 2, arg.state.mSliders[id].abX);
+    else if (sliderStates_[iJoyStick].sliderStates[id].y != arg.state.mSliders[id].abY)
+      _fireAxis(iJoyStick, id * 2 + 1, arg.state.mSliders[id].abY);
+    return true;
+  }
+  bool InputManager::povMoved(const OIS::JoyStickEvent &arg, int id)
+  {
+    unsigned int iJoyStick = _getJoystick(arg);
+    // translate the POV into 8 simple buttons
+    int lastState = povStates_[iJoyStick][id];
+    if (lastState & OIS::Pov::North)
+      buttonReleased(arg, 32 + id * 4 + 0);
+    if (lastState & OIS::Pov::South)
+      buttonReleased(arg, 32 + id * 4 + 1);
+    if (lastState & OIS::Pov::East)
+      buttonReleased(arg, 32 + id * 4 + 2);
+    if (lastState & OIS::Pov::West)
+      buttonReleased(arg, 32 + id * 4 + 3);
+    povStates_[iJoyStick].povStates[id] = arg.state.mPOV[id].direction;
+    int currentState = povStates_[iJoyStick][id];
+    if (currentState & OIS::Pov::North)
+      buttonPressed(arg, 32 + id * 4 + 0);
+    if (currentState & OIS::Pov::South)
+      buttonPressed(arg, 32 + id * 4 + 1);
+    if (currentState & OIS::Pov::East)
+      buttonPressed(arg, 32 + id * 4 + 2);
+    if (currentState & OIS::Pov::West)
+      buttonPressed(arg, 32 + id * 4 + 3);
+    return true;
+  }
+  /*bool InputManager::vector3Moved(const OIS::JoyStickEvent &arg, int id)
+  {
+    unsigned int iJoyStick = _getJoystick(arg);
+    for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
+      activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickVector3Moved(JoyStickState(arg.state, iJoyStick), id);
+    return true;
+  }*/
+  // ################################
+  // ### Static Interface Methods ###
+  // ################################
+  // ################################
+  std::string InputManager::bindingCommmandString_s = "";
+  bool InputManager::initialise(const size_t windowHnd, int windowWidth, int windowHeight,
+    bool createKeyboard, bool createMouse, bool createJoySticks)
+  {
+    return _getSingleton()._initialise(windowHnd, windowWidth, windowHeight,
+          createKeyboard, createMouse, createJoySticks);
+  }
+  bool InputManager::initialiseKeyboard()
+  {
+    return _getSingleton()._initialiseKeyboard();
+  }
+  bool InputManager::initialiseMouse()
+  {
+    return _getSingleton()._initialiseMouse();
+  }
+  bool InputManager::initialiseJoySticks()
+  {
+    return _getSingleton()._initialiseJoySticks();
+  }
+  int InputManager::numberOfKeyboards()
+  {
+    if (_getSingleton().keyboard_ != 0)
+      return 1;
+    else
+      return 0;
+  }
+  int InputManager::numberOfMice()
+  {
+    if (_getSingleton().mouse_ != 0)
+      return 1;
+    else
+      return 0;
+  }
+  int InputManager::numberOfJoySticks()
+  {
+    return _getSingleton().joySticksSize_;
+  }
+  /*bool InputManager::isKeyDown(KeyCode::Enum key)
+  {
+    if (_getSingleton().keyboard_)
+      return _getSingleton().keyboard_->isKeyDown((OIS::KeyCode)key);
+    else
+      return false;
+  }*/
+  /*bool InputManager::isModifierDown(KeyboardModifier::Enum modifier)
+  {
+    if (_getSingleton().keyboard_)
+      return isModifierDown(modifier);
+    else
+      return false;
+  }*/
+  /*const MouseState InputManager::getMouseState()
+  {
+    if (_getSingleton().mouse_)
+      return _getSingleton().mouse_->getMouseState();
+    else
+      return MouseState();
+  }*/
+  /*const JoyStickState InputManager::getJoyStickState(unsigned int ID)
+  {
+    if (ID < _getSingleton().joySticksSize_)
+      return JoyStickState(_getSingleton().joySticks_[ID]->getJoyStickState(), ID);
+    else
+      return JoyStickState();
+  }*/
+  void InputManager::destroy()
+  {
+    _getSingleton()._destroy();
+  }
+  void InputManager::destroyKeyboard()
+  {
+    return _getSingleton()._destroyKeyboard();
+  }
+  void InputManager::destroyMouse()
+  {
+    return _getSingleton()._destroyMouse();
+  }
+  void InputManager::destroyJoySticks()
+  {
+    return _getSingleton()._destroyJoySticks();
+  }
+  /**
+    @brief Adjusts the mouse window metrics.
+    This method has to be called every time the size of the window changes.
+    @param width The new width of the render window
+    @param height the new height of the render window
+  */
+  void InputManager::setWindowExtents(const int width, const int height)
+  {
+    if (_getSingleton().mouse_)
+    {
+      // Set mouse region (if window resizes, we should alter this to reflect as well)
+      const OIS::MouseState &mouseState = _getSingleton().mouse_->getMouseState();
+      mouseState.width  = width;
+      mouseState.height = height;
+    }
+  }
+  /**
+    @brief Sets the input mode to either GUI, inGame or Buffer
+    @param mode The new input mode
+    @remark Only has an affect if the mode actually changes
+  */
+  void InputManager::setInputState(const InputState state)
+  {
+    _getSingleton().stateRequest_ = state;
+  }
+  /**
+    @brief Returns the current input handling method
+    @return The current input mode.
+  */
+  InputManager::InputState InputManager::getInputState()
+  {
+    return _getSingleton().state_;
+  }
+  void InputManager::storeKeyStroke(const std::string& name)
+  {
+    setInputState(IS_NODETECT);
+    COUT(0) << "Binding string \"" << bindingCommmandString_s << "\" on key '" << name << "'" << std::endl;
+    CommandExecutor::execute("config KeyBinder " + name + " " + bindingCommmandString_s, false);
+  }
+  void InputManager::keyBind(const std::string& command)
+  {
+    bindingCommmandString_s = command;
+    setInputState(IS_DETECT);
+    COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
+  }
+  void InputManager::calibrate()
+  {
+    _getSingleton().setInputState(IS_CALIBRATE);
+  }
+  void InputManager::tick(float dt)
+  {
+    _getSingleton()._tick(dt);
+  }
+  // ###### KeyHandler ######
+  /**
+    @brief Adds a new key handler.
+    @param handler Pointer to the handler object.
+    @param name Unique name of the handler.
+    @return True if added, false if name already existed.
+  */
+  bool InputManager::addKeyHandler(KeyHandler* handler, const std::string& name)
+  {
+    if (!handler)
+      return false;
+    if (_getSingleton().keyHandlers_.find(name) == _getSingleton().keyHandlers_.end())
+    {
+      _getSingleton().keyHandlers_[name] = handler;
+      return true;
+    }
+    else
+      return false;
+  }
+  /**
+    @brief Removes a Key handler from the list.
+    @param name Unique name of the handler.
+    @return True if removal was successful, false if name was not found.
+  */
+  bool InputManager::removeKeyHandler(const std::string &name)
+  {
+    disableKeyHandler(name);
+    std::map<std::string, KeyHandler*>::iterator it = _getSingleton().keyHandlers_.find(name);
+    if (it != _getSingleton().keyHandlers_.end())
+    {
+      _getSingleton().keyHandlers_.erase(it);
+      return true;
+    }
+    else
+      return false;
+  }
+  /**
+    @brief Returns the pointer to a handler.
+    @param name Unique name of the handler.
+    @return Pointer to the instance, 0 if name was not found.
+  */
+  KeyHandler* InputManager::getKeyHandler(const std::string& name)
+  {
+    std::map<std::string, KeyHandler*>::iterator it = _getSingleton().keyHandlers_.find(name);
+    if (it != _getSingleton().keyHandlers_.end())
+    {
+      return (*it).second;
+    }
+    else
+      return 0;
+  }
+  /**
+    @brief Enables a specific key handler that has already been added.
+    @param name Unique name of the handler.
+    @return False if name was not found, true otherwise.
+  */
+  bool InputManager::enableKeyHandler(const std::string& name)
+  {
+    // get pointer from the map with all stored handlers
+    std::map<std::string, KeyHandler*>::const_iterator mapIt = _getSingleton().keyHandlers_.find(name);
+    if (mapIt == _getSingleton().keyHandlers_.end())
+      return false;
+    // see whether the handler already is in the list
+    for (std::vector<KeyHandler*>::iterator it = _getSingleton().activeKeyHandlers_.begin();
+          it != _getSingleton().activeKeyHandlers_.end(); it++)
+    {
+      if ((*it) == (*mapIt).second)
+      {
+        return true;
+      }
+    }
+    _getSingleton().activeKeyHandlers_.push_back((*mapIt).second);
+    _getSingleton().stateRequest_ = IS_CUSTOM;
+    _getSingleton()._updateTickables();
+    return true;
+  }
+  /**
+    @brief Disables a specific key handler.
+    @param name Unique name of the handler.
+    @return False if name was not found, true otherwise.
+  */
+  bool InputManager::disableKeyHandler(const std::string &name)
+  {
+    // get pointer from the map with all stored handlers
+    std::map<std::string, KeyHandler*>::const_iterator mapIt = _getSingleton().keyHandlers_.find(name);
+    if (mapIt == _getSingleton().keyHandlers_.end())
+      return false;
+    // look for the handler in the list
+    for (std::vector<KeyHandler*>::iterator it = _getSingleton().activeKeyHandlers_.begin();
+          it != _getSingleton().activeKeyHandlers_.end(); it++)
+    {
+      if ((*it) == (*mapIt).second)
+      {
+        _getSingleton().activeKeyHandlers_.erase(it);
+        _getSingleton().stateRequest_ = IS_CUSTOM;
+        _getSingleton()._updateTickables();
+        return true;
+      }
+    }
+    return true;
+  }
+  /**
+    @brief Checks whether a key handler is active
+    @param name Unique name of the handler.
+    @return False if key handler is not active or doesn't exist, true otherwise.
+  */
+  bool InputManager::isKeyHandlerActive(const std::string& name)
+  {
+    // get pointer from the map with all stored handlers
+    std::map<std::string, KeyHandler*>::const_iterator mapIt = _getSingleton().keyHandlers_.find(name);
+    if (mapIt == _getSingleton().keyHandlers_.end())
+      return false;
+    // see whether the handler already is in the list
+    for (std::vector<KeyHandler*>::iterator it = _getSingleton().activeKeyHandlers_.begin();
+          it != _getSingleton().activeKeyHandlers_.end(); it++)
+    {
+      if ((*it) == (*mapIt).second)
+        return true;
+    }
+    return false;
+  }
+  // ###### MouseHandler ######
+  /**
+    @brief Adds a new mouse handler.
+    @param handler Pointer to the handler object.
+    @param name Unique name of the handler.
+    @return True if added, false if name already existed.
+  */
+  bool InputManager::addMouseHandler(MouseHandler* handler, const std::string& name)
+  {
+    if (!handler)
+      return false;
+    if (_getSingleton().mouseHandlers_.find(name) == _getSingleton().mouseHandlers_.end())
+    {
+      _getSingleton().mouseHandlers_[name] = handler;
+      return true;
+    }
+    else
+      return false;
+  }
+  /**
+    @brief Removes a Mouse handler from the list.
+    @param name Unique name of the handler.
+    @return True if removal was successful, false if name was not found.
+  */
+  bool InputManager::removeMouseHandler(const std::string &name)
+  {
+    disableMouseHandler(name);
+    std::map<std::string, MouseHandler*>::iterator it = _getSingleton().mouseHandlers_.find(name);
+    if (it != _getSingleton().mouseHandlers_.end())
+    {
+      _getSingleton().mouseHandlers_.erase(it);
+      return true;
+    }
+    else
+      return false;
+  }
+  /**
+    @brief Returns the pointer to a handler.
+    @param name Unique name of the handler.
+    @return Pointer to the instance, 0 if name was not found.
+  */
+  MouseHandler* InputManager::getMouseHandler(const std::string& name)
+  {
+    std::map<std::string, MouseHandler*>::iterator it = _getSingleton().mouseHandlers_.find(name);
+    if (it != _getSingleton().mouseHandlers_.end())
+    {
+      return (*it).second;
+    }
+    else
+      return 0;
+  }
+  /**
+    @brief Enables a specific mouse handler that has already been added.
+    @param name Unique name of the handler.
+    @return False if name was not found, true otherwise.
+  */
+  bool InputManager::enableMouseHandler(const std::string& name)
+  {
+    // get pointer from the map with all stored handlers
+    std::map<std::string, MouseHandler*>::const_iterator mapIt = _getSingleton().mouseHandlers_.find(name);
+    if (mapIt == _getSingleton().mouseHandlers_.end())
+      return false;
+    // see whether the handler already is in the list
+    for (std::vector<MouseHandler*>::iterator it = _getSingleton().activeMouseHandlers_.begin();
+          it != _getSingleton().activeMouseHandlers_.end(); it++)
+    {
+      if ((*it) == (*mapIt).second)
+      {
+        return true;
+      }
+    }
+    _getSingleton().activeMouseHandlers_.push_back((*mapIt).second);
+    _getSingleton().stateRequest_ = IS_CUSTOM;
+    _getSingleton()._updateTickables();
+    return true;
+  }
+  /**
+    @brief Disables a specific mouse handler.
+    @param name Unique name of the handler.
+    @return False if name was not found, true otherwise.
+  */
+  bool InputManager::disableMouseHandler(const std::string &name)
+  {
+    // get pointer from the map with all stored handlers
+    std::map<std::string, MouseHandler*>::const_iterator mapIt = _getSingleton().mouseHandlers_.find(name);
+    if (mapIt == _getSingleton().mouseHandlers_.end())
+      return false;
+    // look for the handler in the list
+    for (std::vector<MouseHandler*>::iterator it = _getSingleton().activeMouseHandlers_.begin();
+          it != _getSingleton().activeMouseHandlers_.end(); it++)
+    {
+      if ((*it) == (*mapIt).second)
+      {
+        _getSingleton().activeMouseHandlers_.erase(it);
+        _getSingleton().stateRequest_ = IS_CUSTOM;
+        _getSingleton()._updateTickables();
+        return true;
+      }
+    }
+    return true;
+  }
+  /**
+    @brief Checks whether a mouse handler is active
+    @param name Unique name of the handler.
+    @return False if key handler is not active or doesn't exist, true otherwise.
+  */
+  bool InputManager::isMouseHandlerActive(const std::string& name)
+  {
+    // get pointer from the map with all stored handlers
+    std::map<std::string, MouseHandler*>::const_iterator mapIt = _getSingleton().mouseHandlers_.find(name);
+    if (mapIt == _getSingleton().mouseHandlers_.end())
+      return false;
+    // see whether the handler already is in the list
+    for (std::vector<MouseHandler*>::iterator it = _getSingleton().activeMouseHandlers_.begin();
+          it != _getSingleton().activeMouseHandlers_.end(); it++)
+    {
+      if ((*it) == (*mapIt).second)
+        return true;
+    }
+    return false;
+  }
+  // ###### JoyStickHandler ######
+  /**
+    @brief Adds a new joy stick handler.
+    @param handler Pointer to the handler object.
+    @param name Unique name of the handler.
+    @return True if added, false if name already existed.
+  */
+  bool InputManager::addJoyStickHandler(JoyStickHandler* handler, const std::string& name)
+  {
+    if (!handler)
+      return false;
+    if (_getSingleton().joyStickHandlers_.find(name) == _getSingleton().joyStickHandlers_.end())
+    {
+      _getSingleton().joyStickHandlers_[name] = handler;
+      return true;
+    }
+    else
+      return false;
+  }
+  /**
+    @brief Removes a JoyStick handler from the list.
+    @param name Unique name of the handler.
+    @return True if removal was successful, false if name was not found.
+  */
+  bool InputManager::removeJoyStickHandler(const std::string &name)
+  {
+    for (std::vector<OIS::JoyStick*>::iterator itstick = _getSingleton().joySticks_.begin();
+          itstick != _getSingleton().joySticks_.end(); itstick++)
+      disableJoyStickHandler(name, itstick - _getSingleton().joySticks_.begin());
+    std::map<std::string, JoyStickHandler*>::iterator it = _getSingleton().joyStickHandlers_.find(name);
+    if (it != _getSingleton().joyStickHandlers_.end())
+    {
+      _getSingleton().joyStickHandlers_.erase(it);
+      return true;
+    }
+    else
+      return false;
+  }
+  /**
+    @brief Returns the pointer to a handler.
+    @param name Unique name of the handler.
+    @return Pointer to the instance, 0 if name was not found.
+  */
+  JoyStickHandler* InputManager::getJoyStickHandler(const std::string& name)
+  {
+    std::map<std::string, JoyStickHandler*>::iterator it = _getSingleton().joyStickHandlers_.find(name);
+    if (it != _getSingleton().joyStickHandlers_.end())
+    {
+      return (*it).second;
+    }
+    else
+      return 0;
+  }
+  /**
+    @brief Enables a specific joy stick handler that has already been added.
+    @param name Unique name of the handler.
+    @return False if name or id was not found, true otherwise.
+  */
+  bool InputManager::enableJoyStickHandler(const std::string& name, unsigned int ID)
+  {
+    // get handler pointer from the map with all stored handlers
+    std::map<std::string, JoyStickHandler*>::const_iterator handlerIt = _getSingleton().joyStickHandlers_.find(name);
+    if (handlerIt == _getSingleton().joyStickHandlers_.end())
+      return false;
+    // check for existence of the ID
+    if (ID >= _getSingleton().joySticksSize_)
+      return false;
+    // see whether the handler already is in the list
+    for (std::vector<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[ID].begin();
+          it != _getSingleton().activeJoyStickHandlers_[ID].end(); it++)
+    {
+      if ((*it) == (*handlerIt).second)
+      {
+        return true;
+      }
+    }
+    _getSingleton().activeJoyStickHandlers_[ID].push_back((*handlerIt).second);
+    _getSingleton().stateRequest_ = IS_CUSTOM;
+    _getSingleton()._updateTickables();
+    return true;
+  }
+  /**
+    @brief Disables a specific joy stick handler.
+    @param name Unique name of the handler.
+    @return False if name or id was not found, true otherwise.
+  */
+  bool InputManager::disableJoyStickHandler(const std::string &name, unsigned int ID)
+  {
+    // get handler pointer from the map with all stored handlers
+    std::map<std::string, JoyStickHandler*>::const_iterator handlerIt = _getSingleton().joyStickHandlers_.find(name);
+    if (handlerIt == _getSingleton().joyStickHandlers_.end())
+      return false;
+    // check for existence of the ID
+    if (ID >= _getSingleton().joySticksSize_)
+      return false;
+    // look for the handler in the list
+    for (std::vector<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[ID].begin();
+          it != _getSingleton().activeJoyStickHandlers_[ID].end(); it++)
+    {
+      if ((*it) == (*handlerIt).second)
+      {
+        _getSingleton().activeJoyStickHandlers_[ID].erase(it);
+        _getSingleton().stateRequest_ = IS_CUSTOM;
+        _getSingleton()._updateTickables();
+        return true;
+      }
+    }
+    return true;
+  }
+  /**
+    @brief Checks whether a joy stick handler is active
+    @param name Unique name of the handler.
+    @return False if key handler is not active or doesn't exist, true otherwise.
+  */
+  bool InputManager::isJoyStickHandlerActive(const std::string& name, unsigned int ID)
+  {
+    // get handler pointer from the map with all stored handlers
+    std::map<std::string, JoyStickHandler*>::const_iterator handlerIt = _getSingleton().joyStickHandlers_.find(name);
+    if (handlerIt == _getSingleton().joyStickHandlers_.end())
+      return false;
+    // check for existence of the ID
+    if (ID >= _getSingleton().joySticksSize_)
+      return false;
+    // see whether the handler already is in the list
+    for (std::vector<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[ID].begin();
+          it != _getSingleton().activeJoyStickHandlers_[ID].end(); it++)
+    {
+      if ((*it) == (*handlerIt).second)
+        return true;
+    }
+    return false;
+  }
+    }
+    // ############################################################
+    // #####                Console Commands                  #####
+    // ##########                                        ##########
+    // ############################################################
+    /**
+    @brief
+        Method for easily storing a string with the command executor. It is used by the
+        KeyDetector to get assign commands. The KeyDetector simply executes
+        the command 'storeKeyStroke myName' for each button/axis.
+    @remarks
+        This is only a temporary hack until we thourouhgly support multiple KeyBinders.
+    @param name
+        The name of the button/axis.
+    */
+    void InputManager::storeKeyStroke(const std::string& name)
+    {
+        getInstance().requestLeaveState("detector");
+        COUT(0) << "Binding string \"" << bindingCommmandString_s << "\" on key '" << name << "'" << std::endl;
+        CommandExecutor::execute("config KeyBinder " + name + " " + bindingCommmandString_s, false);
+    }
+    /**
+    @brief
+        Assigns a command string to a key/button/axis. The name is determined via KeyDetector
+        and InputManager::storeKeyStroke(.).
+    @param command
+        Command string that can be executed by the CommandExecutor
+    */
+    void InputManager::keyBind(const std::string& command)
+    {
+        bindingCommmandString_s = command;
+        getInstance().requestEnterState("detector");
+        COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
+    }
+    /**
+    @brief
+        Starts joy stick calibration.
+    */
+    void InputManager::calibrate()
+    {
+        getInstance().bCalibrating_ = true;
+        getInstance().requestEnterState("calibrator");
+    }
+    /**
+    @brief
+        Reloads the input system
+    */
+    void InputManager::reload(bool joyStickSupport)
+    {
+        getInstance().reloadInputSystem(joyStickSupport);
+    }
+}

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

-                      r1555
+                      r1755
 /**
+ @file
+ @brief Implementation of a little Input handler that distributes everything
+        coming from OIS.
+ */
+@file
+@brief
+    Implementation of a little Input handler that distributes everything
+    coming from OIS.
+*/
 #ifndef _InputManager_H__
 …
 #include <map>
 #include <vector>
+#include <stack>
 #include "util/Math.h"
 #include "core/OrxonoxClass.h"
 …
 namespace orxonox
+{
+  /**
+  * Helper class to realise a vector<int[4]>
+  */
+  class POVStates
+  {
+  public:
+    int operator[](unsigned int index) { return povStates[index]; }
+    int povStates[4];
+  };
+  /**
+  * Helper class to realise a vector< {int[4], int[4]} >
+  */
+  class SliderStates
+  {
+  public:
+    IntVector2 sliderStates[4];
+  };
+  /**
+  * Struct for storing a custom input state
+  */
+  struct StoredState
+  {
+    std::vector<KeyHandler*>                    activeKeyHandlers_;
+    std::vector<MouseHandler*>                  activeMouseHandlers_;
+    std::vector<std::vector<JoyStickHandler*> > activeJoyStickHandlers_;
+    std::vector<std::pair<InputTickable*, HandlerState> > activeHandlers_;
+  };
+  struct JoyStickCalibration
+  {
+    int zeroStates[24];
+    float positiveCoeff[24];
+    float negativeCoeff[24];
+  };
+  /**
+    @brief Captures and distributes mouse and keyboard input.
+  */
+  class _CoreExport InputManager
+    /**
+    @brief
+        Helper class to realise a vector<int[4]>
+    */
+    class POVStates
+    {
+    public:
+        int& operator[](unsigned int index) { return povStates[index]; }
+        int povStates[4];
+    };
+    /**
+    @brief
+        Helper class to realise a vector< {int[4], int[4]} >
+    */
+    class SliderStates
+    {
+    public:
+        IntVector2 sliderStates[4];
+    };
+    struct JoyStickCalibration
+    {
+        int zeroStates[24];
+        float positiveCoeff[24];
+        float negativeCoeff[24];
+    };
+    /**
+    @brief
+        Captures and distributes mouse and keyboard input.
+    */
+    class _CoreExport InputManager
         : public OrxonoxClass,
+          public OIS::KeyListener, public OIS::MouseListener, public OIS::JoyStickListener
+  {
+  public: // enumerations
+    /**
+      @brief Designates the way input is handled and redirected.
+    */
+    enum InputState
+    {
+      IS_UNINIT,    //!< InputManager has not yet been initialised.
+      IS_NONE,      //!< Input is discarded.
+      IS_NORMAL,    //!< Normal play state. Key and button bindings are active.
+      IS_GUI,       //!< All OIS input events are passed to CEGUI.
+      IS_CONSOLE,   //!< Keyboard input is redirected to the InputBuffer.
+      IS_DETECT,    //!< All the input additionally goes to the KeyDetector
+      IS_NODETECT,  //!< remove KeyDetector
+      IS_NOCALIBRATE,
+      IS_CALIBRATE,
+      IS_CUSTOM     //!< Any possible configuration.
+    };
+  public: // member functions
+    void setConfigValues();
+  public: // static functions
+    static bool initialise(const size_t windowHnd, int windowWidth, int windowHeight,
+          bool createKeyboard = true, bool createMouse = true, bool createJoySticks = false);
+    static bool initialiseKeyboard();
+    static bool initialiseMouse();
+    static bool initialiseJoySticks();
+    static int  numberOfKeyboards();
+    static int  numberOfMice();
+    static int  numberOfJoySticks();
+    static void destroy();
+    static void destroyKeyboard();
+    static void destroyMouse();
+    static void destroyJoySticks();
+    //static bool isModifierDown(KeyboardModifier::Enum modifier);
+    //static bool isKeyDown(KeyCode::Enum key);
+    //static const MouseState getMouseState();
+    //static const JoyStickState getJoyStickState(unsigned int ID);
+    static void setWindowExtents(const int width, const int height);
+    static void setInputState(const InputState state);
+    static InputState getInputState();
+    static void storeKeyStroke(const std::string& name);
+    static void keyBind(const std::string& command);
+    static void calibrate();
+    static void tick(float dt);
+    static bool addKeyHandler                 (KeyHandler* handler, const std::string& name);
+    static bool removeKeyHandler              (const std::string& name);
+    static KeyHandler* getKeyHandler          (const std::string& name);
+    static bool enableKeyHandler              (const std::string& name);
+    static bool disableKeyHandler             (const std::string& name);
+    static bool isKeyHandlerActive            (const std::string& name);
+    static bool addMouseHandler               (MouseHandler* handler, const std::string& name);
+    static bool removeMouseHandler            (const std::string& name);
+    static MouseHandler* getMouseHandler      (const std::string& name);
+    static bool enableMouseHandler            (const std::string& name);
+    static bool disableMouseHandler           (const std::string& name);
+    static bool isMouseHandlerActive          (const std::string& name);
+    static bool addJoyStickHandler            (JoyStickHandler* handler, const std::string& name);
+    static bool removeJoyStickHandler         (const std::string& name);
+    static JoyStickHandler* getJoyStickHandler(const std::string& name);
+    static bool enableJoyStickHandler         (const std::string& name, unsigned int id);
+    static bool disableJoyStickHandler        (const std::string& name, unsigned int id);
+    static bool isJoyStickHandlerActive       (const std::string& name, unsigned int id);
+  private: // functions
+    // don't mess with a Singleton
+    InputManager ();
+    InputManager (const InputManager&);
+    ~InputManager();
+    // Intenal methods
+    bool _initialise(const size_t, int, int, bool, bool, bool);
+    bool _initialiseKeyboard();
+    bool _initialiseMouse();
+    bool _initialiseJoySticks();
+    void _destroy();
+    void _destroyKeyboard();
+    void _destroyMouse();
+    void _destroyJoySticks();
+    void _updateTickables();
+    void _saveState();
+    void _restoreState();
+    void _completeCalibration();
+    void _fireAxis(unsigned int iJoyStick, int axis, int value);
+    unsigned int _getJoystick(const OIS::JoyStickEvent& arg);
+    void _tick(float dt);
+    // input events
+    bool mousePressed  (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
+    bool mouseReleased (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
+    bool mouseMoved    (const OIS::MouseEvent    &arg);
+    bool keyPressed    (const OIS::KeyEvent      &arg);
+    bool keyReleased   (const OIS::KeyEvent      &arg);
+    bool buttonPressed (const OIS::JoyStickEvent &arg, int button);
+    bool buttonReleased(const OIS::JoyStickEvent &arg, int button);
+    bool axisMoved     (const OIS::JoyStickEvent &arg, int axis);
+    bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
+    bool povMoved      (const OIS::JoyStickEvent &arg, int id);
+    //bool vector3Moved  (const OIS::JoyStickEvent &arg, int id);
+    static InputManager& _getSingleton();
+    static InputManager* _getSingletonPtr() { return &_getSingleton(); }
+  private: // variables
+    OIS::InputManager*                          inputSystem_;     //!< OIS input manager
+    OIS::Keyboard*                              keyboard_;        //!< OIS mouse
+    OIS::Mouse*                                 mouse_;           //!< OIS keyboard
+    std::vector<OIS::JoyStick*>                 joySticks_;       //!< OIS joy sticks
+    unsigned int                                joySticksSize_;
+    KeyBinder*                                  keyBinder_;       //!< KeyBinder instance
+    KeyDetector*                                keyDetector_;     //!< KeyDetector instance
+    InputBuffer*                                buffer_;          //!< InputBuffer instance
+    CalibratorCallback*                         calibratorCallback_;
+    InputState state_;
+    InputState stateRequest_;
+    InputState savedState_;
+    unsigned int keyboardModifiers_;
+    StoredState savedHandlers_;
+    // joystick calibration
+    //std::vector<int> marginalsMaxConfig_;
+    //std::vector<int> marginalsMinConfig_;
+    int marginalsMax_[24];
+    int marginalsMin_[24];
+    bool bCalibrated_;
+    //! Keeps track of the joy stick POV states
+    std::vector<POVStates>                      povStates_;
+    //! Keeps track of the possibly two slider axes
+    std::vector<SliderStates>                   sliderStates_;
+    std::vector<JoyStickCalibration>            joySticksCalibration_;
+    std::map<std::string, KeyHandler*>          keyHandlers_;
+    std::map<std::string, MouseHandler*>        mouseHandlers_;
+    std::map<std::string, JoyStickHandler*>     joyStickHandlers_;
+    std::vector<KeyHandler*>                    activeKeyHandlers_;
+    std::vector<MouseHandler*>                  activeMouseHandlers_;
+    std::vector<std::vector<JoyStickHandler*> > activeJoyStickHandlers_;
+    std::vector<std::pair<InputTickable*, HandlerState> > activeHandlers_;
+    std::vector<Key>                            keysDown_;
+    std::vector<MouseButton::Enum>              mouseButtonsDown_;
+    std::vector<std::vector<int> >              joyStickButtonsDown_;
+    static std::string                          bindingCommmandString_s;
+  };
+        public OIS::KeyListener, public OIS::MouseListener, public OIS::JoyStickListener
+    {
+        // --> setConfigValues is private
+        friend class ClassIdentifier<InputManager>;
+        // let Core class use tick(.)
+        friend class Core;
+    public:
+        enum InputManagerState
+        {
+            Uninitialised    = 0x00,
+            OISReady         = 0x01,
+            InternalsReady   = 0x02,
+            Ticking          = 0x04,
+            Calibrating      = 0x08,
+            ReloadRequest    = 0x10,
+            JoyStickSupport  = 0x20 // used with ReloadRequest to store a bool
+        };
+        InputManager ();
+        ~InputManager();
+        void initialise(size_t windowHnd, int windowWidth, int windowHeight, bool joyStickSupport = true);
+        void reloadInputSystem(bool joyStickSupport = true);
+        int  numberOfKeyboards() { return keyboard_ ? 1 : 0; }
+        int  numberOfMice()      { return mouse_    ? 1 : 0; }
+        int  numberOfJoySticks() { return joySticksSize_; }
+        void setWindowExtents(const int width, const int height);
+        template <class T>
+        T* createInputState(const std::string& name, int priority)
+        {
+            T* state = new T;
+            if (_configureInputState(state, name, priority))
+                return state;
+            else
+            {
+                delete state;
+                return 0;
+            }
+        }
+        InputState* getState       (const std::string& name);
+        InputState* getCurrentState();
+        bool requestDestroyState   (const std::string& name);
+        bool requestEnterState     (const std::string& name);
+        bool requestLeaveState     (const std::string& name);
+        void tick(float dt);
+        static InputManager& getInstance()    { assert(singletonRef_s); return *singletonRef_s; }
+        static InputManager* getInstancePtr() { return singletonRef_s; }
+    public: // console commands
+        static void storeKeyStroke(const std::string& name);
+        static void keyBind(const std::string& command);
+        static void calibrate();
+        static void reload(bool joyStickSupport = true);
+    private: // functions
+        // don't mess with a Singleton
+        InputManager (const InputManager&);
+        // Intenal methods
+        void _initialiseKeyboard();
+        void _initialiseMouse();
+        void _initialiseJoySticks();
+        void _redimensionLists();
+        void _destroyKeyboard();
+        void _destroyMouse();
+        void _destroyJoySticks();
+        void _destroyState(InputState* state);
+        void _clearBuffers();
+        void _reload(bool joyStickSupport);
+        void _completeCalibration();
+        void _fireAxis(unsigned int iJoyStick, int axis, int value);
+        unsigned int _getJoystick(const OIS::JoyStickEvent& arg);
+        void _updateActiveStates();
+        bool _configureInputState(InputState* state, const std::string& name, int priority);
+        // input events
+        bool mousePressed  (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
+        bool mouseReleased (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
+        bool mouseMoved    (const OIS::MouseEvent    &arg);
+        bool keyPressed    (const OIS::KeyEvent      &arg);
+        bool keyReleased   (const OIS::KeyEvent      &arg);
+        bool buttonPressed (const OIS::JoyStickEvent &arg, int button);
+        bool buttonReleased(const OIS::JoyStickEvent &arg, int button);
+        bool axisMoved     (const OIS::JoyStickEvent &arg, int axis);
+        bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
+        bool povMoved      (const OIS::JoyStickEvent &arg, int id);
+        // don't remove that! Or else add OIS as dependency library to orxonox.
+        bool vector3Moved  (const OIS::JoyStickEvent &arg, int id) { return true; }
+        void setConfigValues();
+    private: // variables
+        OIS::InputManager*                  inputSystem_;          //!< OIS input manager
+        OIS::Keyboard*                      keyboard_;             //!< OIS mouse
+        OIS::Mouse*                         mouse_;                //!< OIS keyboard
+        std::vector<OIS::JoyStick*>         joySticks_;            //!< OIS joy sticks
+        unsigned int                        joySticksSize_;
+        unsigned int                        devicesNum_;
+        size_t                              windowHnd_;            //!< Render window handle
+        InputManagerState                   internalState_;        //!< Current internal state
+        // some internally handled states
+        SimpleInputState*                   stateDetector_;        //!< KeyDetector instance
+        SimpleInputState*                   stateCalibrator_;
+        SimpleInputState*                   stateEmpty_;
+        std::map<std::string, InputState*>  inputStatesByName_;
+        std::map<int, InputState*>          inputStatesByPriority_;
+        std::set<InputState*>               stateEnterRequests_;   //!< Request to enter a new state
+        std::set<InputState*>               stateLeaveRequests_;   //!< Request to leave a running state
+        std::set<InputState*>               stateDestroyRequests_; //!< Request to destroy a state
+        std::map<int, InputState*>          activeStates_;
+        std::vector<InputState*>            activeStatesTop_;      //!< Current input states for joy stick events.
+        std::vector<InputState*>            activeStatesTicked_;   //!< Current input states for joy stick events.
+        // joystick calibration
+        //std::vector<int> marginalsMaxConfig_;
+        //std::vector<int> marginalsMinConfig_;
+        int                                 marginalsMax_[24];
+        int                                 marginalsMin_[24];
+        bool                                bCalibrated_;
+        bool                                bCalibrating_;
+        unsigned int                        keyboardModifiers_;    //!< Bit mask representing keyboard modifiers.
+        std::vector<POVStates>              povStates_;            //!< Keeps track of the joy stick POV states.
+        std::vector<SliderStates>           sliderStates_;         //!< Keeps track of the possibly two slider axes.
+        std::vector<JoyStickCalibration>    joySticksCalibration_;
+        std::vector<Key>                    keysDown_;
+        std::vector<MouseButton::Enum>      mouseButtonsDown_;
+        std::vector<std::vector<JoyStickButton::Enum> >  joyStickButtonsDown_;
+        static std::string                  bindingCommmandString_s;
+        static InputManager*                singletonRef_s;
+    };
+}

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

-                      r1747
+                      r1755
 namespace orxonox
+{
+  /**
+    @brief Constructor that does as little as necessary.
+  */
+  KeyBinder::KeyBinder() : deriveTime_(0.0f)
+  {
+    mouseRelative_[0] = 0;
+    mouseRelative_[1] = 0;
+    mousePosition_[0] = 0;
+    mousePosition_[1] = 0;
+    RegisterRootObject(KeyBinder);
+    // keys
+    std::string keyNames[] = {
+      "UNASSIGNED",
+      "ESCAPE",
+      "1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
+      "MINUS", "EQUALS", "BACK", "TAB",
+      "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P",
+      "LBRACKET", "RBRACKET",
+      "RETURN", "LCONTROL",
+      "A", "S", "D", "F", "G", "H", "J", "K", "L",
+      "SEMICOLON", "APOSTROPHE", "GRAVE",
+      "LSHIFT", "BACKSLASH",
+      "Z", "X", "C", "V", "B", "N", "M",
+      "COMMA", "PERIOD", "SLASH",
+      "RSHIFT",
+      "MULTIPLY",
+      "LMENU",
+      "SPACE",
+      "CAPITAL",
+      "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10",
+      "NUMLOCK", "SCROLL",
+      "NUMPAD7", "NUMPAD8", "NUMPAD9",
+      "SUBTRACT",
+      "NUMPAD4", "NUMPAD5", "NUMPAD6",
+      "ADD",
+      "NUMPAD1", "NUMPAD2", "NUMPAD3", "NUMPAD0",
+      "DECIMAL",
+      "","",
+      "OEM_102",
+      "F11", "F12",
+      "","","","","","","","","","","",
+      "F13", "F14", "F15",
+      "","","","","","","","","","",
+      "KANA",
+      "","",
+      "ABNT_C1",
+      "","","","","",
+      "CONVERT",
+      "",
+      "NOCONVERT",
+      "",
+      "YEN",
+      "ABNT_C2",
+      "","","","","","","","","","","","","","",
+      "NUMPADEQUALS",
+      "","",
+      "PREVTRACK",
+      "AT",
+      "COLON", "UNDERLINE",
+      "KANJI",
+      "STOP",
+      "AX",
+      "UNLABELED",
+      "NEXTTRACK",
+      "","",
+      "NUMPADENTER",
+      "RCONTROL",
+      "","",
+      "MUTE",
+      "CALCULATOR",
+      "PLAYPAUSE",
+      "",
+      "MEDIASTOP",
+      "","","","","","","","","",
+      "VOLUMEDOWN",
+      "",
+      "VOLUMEUP",
+      "",
+      "WEBHOME",
+      "NUMPADCOMMA",
+      "",
+      "DIVIDE",
+      "",
+      "SYSRQ",
+      "RMENU",
+      "","","","","","","","","","","","",
+      "PAUSE",
+      "",
+      "HOME",
+      "UP",
+      "PGUP",
+      "",
+      "LEFT",
+      "",
+      "RIGHT",
+      "",
+      "END", "DOWN", "PGDOWN", "INSERT", "DELETE",
+      "","","","","","","",
+      "LWIN", "RWIN", "APPS",
+      "POWER", "SLEEP",
+      "","","",
+      "WAKE",
+      "",
+      "WEBSEARCH", "WEBFAVORITES", "WEBREFRESH", "WEBSTOP", "WEBFORWARD", "WEBBACK",
+      "MYCOMPUTER", "MAIL", "MEDIASELECT"
+    };
+    for (unsigned int i = 0; i < nKeys_s; i++)
+      keys_[i].name_ = "Key" + keyNames[i];
+    // mouse buttons
+    std::string mouseButtonNames[] = {
+      "MouseLeft", "MouseRight", "MouseMiddle",
+      "MouseButton3", "MouseButton4", "MouseButton5",
+      "MouseButton6", "MouseButton7",
+      "MouseWheel1Up", "MouseWheel1Down",
+      "MouseWheel2Up", "MouseWheel2Down" };
+    for (unsigned int i = 0; i < nMouseButtons_s; i++)
+      mouseButtons_[i].name_ = mouseButtonNames[i];
+    // joy stick buttons
+    for (unsigned int i = 0; i < 32; i++)
+      joyStickButtons_[i].name_ = "JoyButton" + getConvertedValue<int, std::string>(i);
+    for (unsigned int i = 32; i < nJoyStickButtons_s; i += 4)
+    {
+                  joyStickButtons_[i + 0].name_ = "JoyPOV" + getConvertedValue<int, std::string>((i - 32)/4 + 1) + "North";
+                  joyStickButtons_[i + 1].name_ = "JoyPOV" + getConvertedValue<int, std::string>((i - 32)/4 + 1) + "South";
+                  joyStickButtons_[i + 2].name_ = "JoyPOV" + getConvertedValue<int, std::string>((i - 32)/4 + 1) + "East";
+                  joyStickButtons_[i + 3].name_ = "JoyPOV" + getConvertedValue<int, std::string>((i - 32)/4 + 1) + "West";
+    }
+    // half axes
+    std::string rawNames[nHalfAxes_s/2];
+    rawNames[0] = "MouseX";
+    rawNames[1] = "MouseY";
+    rawNames[2] = "Empty1";
+    rawNames[3] = "Empty2";
+    for (unsigned int i = 4; i < nHalfAxes_s/2; i++)
+      rawNames[i] = "JoyAxis" + getConvertedValue<int, std::string>(i - 3);
+    for (unsigned int i = 0; i < nHalfAxes_s/2; i++)
+    {
+      halfAxes_[i * 2 + 0].name_ = rawNames[i] + "Pos";
+      halfAxes_[i * 2 + 1].name_ = rawNames[i] + "Neg";
+    }
+    for (unsigned int i = 0; i < this->nHalfAxes_s; i++)
+      halfAxes_[i].buttonThreshold_ = buttonThreshold_;
+  }
+  /**
+    @brief Destructor
+  */
+  KeyBinder::~KeyBinder()
+  {
+    // almost no destructors required because most of the arrays are static.
+    clearBindings(); // does some destruction work
+  }
+  /**
+    @brief Loads the key and button bindings.
+    @return True if loading succeeded.
+  */
+  void KeyBinder::loadBindings()
+  {
+    COUT(3) << "KeyBinder: Loading key bindings..." << std::endl;
+    clearBindings();
+    std::ifstream infile;
+    infile.open("keybindings.ini");
+    if (!infile)
+    {
+      ConfigFileManager::getInstance()->setFile(CFT_Keybindings, "def_keybindings.ini");
+      ConfigFileManager::getInstance()->save(CFT_Keybindings, "keybindings.ini");
+    }
+    else
+      infile.close();
+    ConfigFileManager::getInstance()->setFile(CFT_Keybindings, "keybindings.ini");
+    // parse key bindings
+    setConfigValues();
+    COUT(3) << "KeyBinder: Loading key bindings done." << std::endl;
+  }
+  /**
+    @brief Loader for the key bindings, managed by config values.
+  */
+  void KeyBinder::setConfigValues()
+  {
+    SetConfigValue(analogThreshold_, 0.05f)  .description("Threshold for analog axes until which the state is 0.");
+    SetConfigValue(mouseSensitivity_, 1.0f)  .description("Mouse sensitivity.");
+    SetConfigValue(bDeriveMouseInput_, false).description("Whether or not to derive moues movement for the absolute value.");
+    SetConfigValue(derivePeriod_, 0.05f).description("Accuracy of the mouse input deriver. The higher the more precise, but laggier.");
+    SetConfigValue(mouseSensitivityDerived_, 1.0f).description("Mouse sensitivity if mouse input is derived.");
+    SetConfigValue(bClipMouse_, true).description("Whether or not to clip absolute value of mouse in non derive mode.");
+    float oldThresh = buttonThreshold_;
+    SetConfigValue(buttonThreshold_, 0.80f).description("Threshold for analog axes until which the button is not pressed.");
+    if (oldThresh != buttonThreshold_)
+      for (unsigned int i = 0; i < nHalfAxes_s; i++)
+        if (halfAxes_[i].buttonThreshold_ == oldThresh)
+          halfAxes_[i].buttonThreshold_ = buttonThreshold_;
+    // keys
+    for (unsigned int i = 0; i < nKeys_s; i++)
+      readTrigger(keys_[i]);
+    // mouse buttons
+    for (unsigned int i = 0; i < nMouseButtons_s; i++)
+      readTrigger(mouseButtons_[i]);
+    // joy stick buttons
+    for (unsigned int i = 0; i < nJoyStickButtons_s; i++)
+      readTrigger(joyStickButtons_[i]);
+    // half axes
+    for (unsigned int i = 0; i < nHalfAxes_s; i++)
+      readTrigger(halfAxes_[i]);
+  }
+  void KeyBinder::readTrigger(Button& button)
+  {
+    // config value stuff
+    ConfigValueContainer* cont = ClassIdentifier<KeyBinder>::getIdentifier()->getConfigValueContainer(button.name_);
+    if (!cont)
+    {
+      cont = new ConfigValueContainer(CFT_Keybindings, ClassIdentifier<KeyBinder>::getIdentifier(), button.name_, "", button.name_);
+      ClassIdentifier<KeyBinder>::getIdentifier()->addConfigValueContainer(button.name_, cont);
+    }
+    std::string old = button.bindingString_;
+    cont->getValue(&button.bindingString_, this);
+    // keybinder stuff
+    if (old != button.bindingString_)
+    {
+      // clear everything so we don't get old axis ParamCommands mixed up
+      button.clear();
+      // binding has changed
+      button.parse(paramCommandBuffer_);
+    }
+  }
+  /**
+    @brief Overwrites all bindings with ""
+  */
+  void KeyBinder::clearBindings()
+  {
+    for (unsigned int i = 0; i < nKeys_s; i++)
+      keys_[i].clear();
+    for (unsigned int i = 0; i < nMouseButtons_s; i++)
+      mouseButtons_[i].clear();
+    for (unsigned int i = 0; i < nJoyStickButtons_s; i++)
+      joyStickButtons_[i].clear();
+    for (unsigned int i = 0; i < nHalfAxes_s; i++)
+      halfAxes_[i].clear();
+    for (unsigned int i = 0; i < paramCommandBuffer_.size(); i++)
+      delete paramCommandBuffer_[i];
+    paramCommandBuffer_.clear();
+  }
+  void KeyBinder::resetJoyStickAxes()
+  {
+    for (unsigned int i = 8; i < nHalfAxes_s; i++)
+    {
+      halfAxes_[i].absVal_ = 0.0f;
+      halfAxes_[i].relVal_ = 0.0f;
+    }
+  }
+  void KeyBinder::tickInput(float dt, const HandlerState& state)
+  {
+    // we have to process all the analog input since there is e.g. no 'mouseDoesntMove' event.
+    unsigned int iBegin = 8;
+    unsigned int iEnd   = 8;
+    if (state.joyStick)
+      iEnd = nHalfAxes_s;
+    if (state.mouse)
+      iBegin = 0;
+    for (unsigned int i = iBegin; i < iEnd; i++)
+    {
+      if (halfAxes_[i].hasChanged_)
+      {
+        if (!halfAxes_[i].wasDown_ && halfAxes_[i].absVal_ > halfAxes_[i].buttonThreshold_)
+        {
+          halfAxes_[i].wasDown_ = true;
+          if (halfAxes_[i].nCommands_[KeybindMode::OnPress])
+            halfAxes_[i].execute(KeybindMode::OnPress);
+        }
+        else if (halfAxes_[i].wasDown_ && halfAxes_[i].absVal_ < halfAxes_[i].buttonThreshold_)
+        {
+          halfAxes_[i].wasDown_ = false;
+          if (halfAxes_[i].nCommands_[KeybindMode::OnRelease])
+            halfAxes_[i].execute(KeybindMode::OnRelease);
+        }
+        halfAxes_[i].hasChanged_ = false;
+      }
+      if (halfAxes_[i].wasDown_)
+      {
+        if (halfAxes_[i].nCommands_[KeybindMode::OnHold])
+          halfAxes_[i].execute(KeybindMode::OnHold);
+      }
+      // these are the actually useful axis bindings for analog input AND output
+      if (halfAxes_[i].relVal_ > analogThreshold_ || halfAxes_[i].absVal_ > analogThreshold_)
+      {
+        //COUT(3) << halfAxes_[i].name_ << "\t" << halfAxes_[i].absVal_ << std::endl;
+        halfAxes_[i].execute();
+      }
+    }
+    if (bDeriveMouseInput_ && state.mouse)
+    {
+      if (deriveTime_ > derivePeriod_)
+      {
+        //CCOUT(3) << "mouse abs: ";
+    /**
+    @brief
+        Constructor that does as little as necessary.
+    */
+    KeyBinder::KeyBinder()
+        : deriveTime_(0.0f)
+    {
+        mouseRelative_[0] = 0;
+        mouseRelative_[1] = 0;
+        mousePosition_[0] = 0;
+        mousePosition_[1] = 0;
+        RegisterRootObject(KeyBinder);
+        // keys
+        std::string keyNames[] = {
+        "UNASSIGNED",
+        "ESCAPE",
+        "1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
+        "MINUS", "EQUALS", "BACK", "TAB",
+        "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P",
+        "LBRACKET", "RBRACKET",
+        "RETURN", "LCONTROL",
+        "A", "S", "D", "F", "G", "H", "J", "K", "L",
+        "SEMICOLON", "APOSTROPHE", "GRAVE",
+        "LSHIFT", "BACKSLASH",
+        "Z", "X", "C", "V", "B", "N", "M",
+        "COMMA", "PERIOD", "SLASH",
+        "RSHIFT",
+        "MULTIPLY",
+        "LMENU",
+        "SPACE",
+        "CAPITAL",
+        "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10",
+        "NUMLOCK", "SCROLL",
+        "NUMPAD7", "NUMPAD8", "NUMPAD9",
+        "SUBTRACT",
+        "NUMPAD4", "NUMPAD5", "NUMPAD6",
+        "ADD",
+        "NUMPAD1", "NUMPAD2", "NUMPAD3", "NUMPAD0",
+        "DECIMAL",
+        "","",
+        "OEM_102",
+        "F11", "F12",
+        "","","","","","","","","","","",
+        "F13", "F14", "F15",
+        "","","","","","","","","","",
+        "KANA",
+        "","",
+        "ABNT_C1",
+        "","","","","",
+        "CONVERT",
+        "",
+        "NOCONVERT",
+        "",
+        "YEN",
+        "ABNT_C2",
+        "","","","","","","","","","","","","","",
+        "NUMPADEQUALS",
+        "","",
+        "PREVTRACK",
+        "AT",
+        "COLON", "UNDERLINE",
+        "KANJI",
+        "STOP",
+        "AX",
+        "UNLABELED",
+        "NEXTTRACK",
+        "","",
+        "NUMPADENTER",
+        "RCONTROL",
+        "","",
+        "MUTE",
+        "CALCULATOR",
+        "PLAYPAUSE",
+        "",
+        "MEDIASTOP",
+        "","","","","","","","","",
+        "VOLUMEDOWN",
+        "",
+        "VOLUMEUP",
+        "",
+        "WEBHOME",
+        "NUMPADCOMMA",
+        "",
+        "DIVIDE",
+        "",
+        "SYSRQ",
+        "RMENU",
+        "","","","","","","","","","","","",
+        "PAUSE",
+        "",
+        "HOME",
+        "UP",
+        "PGUP",
+        "",
+        "LEFT",
+        "",
+        "RIGHT",
+        "",
+        "END", "DOWN", "PGDOWN", "INSERT", "DELETE",
+        "","","","","","","",
+        "LWIN", "RWIN", "APPS",
+        "POWER", "SLEEP",
+        "","","",
+        "WAKE",
+        "",
+        "WEBSEARCH", "WEBFAVORITES", "WEBREFRESH", "WEBSTOP", "WEBFORWARD", "WEBBACK",
+        "MYCOMPUTER", "MAIL", "MEDIASELECT"
+        };
+        for (unsigned int i = 0; i < nKeys_s; i++)
+            keys_[i].name_ = "Key" + keyNames[i];
+        // mouse buttons
+        std::string mouseButtonNames[] = {
+            "MouseLeft",     "MouseRight",   "MouseMiddle",
+            "MouseButton3",  "MouseButton4", "MouseButton5",
+            "MouseButton6",  "MouseButton7",
+            "MouseWheel1Up", "MouseWheel1Down",
+            "MouseWheel2Up", "MouseWheel2Down"
+        };
+        for (unsigned int i = 0; i < nMouseButtons_s; i++)
+            mouseButtons_[i].name_ = mouseButtonNames[i];
+        // joy stick buttons
+        for (unsigned int i = 0; i < 32; i++)
+            joyStickButtons_[i].name_ = "JoyButton" + getConvertedValue<int, std::string>(i);
+        for (unsigned int i = 32; i < nJoyStickButtons_s; i += 4)
+        {
+            joyStickButtons_[i + 0].name_ = "JoyPOV" + convertToString((i - 32)/4 + 1) + "North";
+            joyStickButtons_[i + 1].name_ = "JoyPOV" + convertToString((i - 32)/4 + 1) + "South";
+            joyStickButtons_[i + 2].name_ = "JoyPOV" + convertToString((i - 32)/4 + 1) + "East";
+            joyStickButtons_[i + 3].name_ = "JoyPOV" + convertToString((i - 32)/4 + 1) + "West";
+        }
+        // half axes
+        std::string rawNames[nHalfAxes_s/2];
+        rawNames[0] = "MouseX";
+        rawNames[1] = "MouseY";
+        rawNames[2] = "Empty1";
+        rawNames[3] = "Empty2";
+        for (unsigned int i = 4; i < nHalfAxes_s/2; i++)
+            rawNames[i] = "JoyAxis" + convertToString(i - 3);
+        for (unsigned int i = 0; i < nHalfAxes_s/2; i++)
+        {
+            halfAxes_[i * 2 + 0].name_ = rawNames[i] + "Pos";
+            halfAxes_[i * 2 + 1].name_ = rawNames[i] + "Neg";
+        }
+        for (unsigned int i = 0; i < this->nHalfAxes_s; i++)
+            halfAxes_[i].buttonThreshold_ = buttonThreshold_;
+    }
+    /**
+    @brief
+        Destructor
+    */
+    KeyBinder::~KeyBinder()
+    {
+        // almost no destructors required because most of the arrays are static.
+        clearBindings(); // does some destruction work
+    }
+    /**
+    @brief
+        Loads the key and button bindings.
+    @return
+        True if loading succeeded.
+    */
+    void KeyBinder::loadBindings()
+    {
+        COUT(3) << "KeyBinder: Loading key bindings..." << std::endl;
+        clearBindings();
+        std::ifstream infile;
+        infile.open("keybindings.ini");
+        if (!infile)
+        {
+            ConfigFileManager::getInstance()->setFile(CFT_Keybindings, "def_keybindings.ini");
+            ConfigFileManager::getInstance()->save(CFT_Keybindings, "keybindings.ini");
+        }
+        else
+            infile.close();
+        ConfigFileManager::getInstance()->setFile(CFT_Keybindings, "keybindings.ini");
+        // parse key bindings
+        setConfigValues();
+        COUT(3) << "KeyBinder: Loading key bindings done." << std::endl;
+    }
+    /**
+    @brief
+        Loader for the key bindings, managed by config values.
+    */
+    void KeyBinder::setConfigValues()
+    {
+        SetConfigValue(analogThreshold_, 0.05f)
+            .description("Threshold for analog axes until which the state is 0.");
+        SetConfigValue(mouseSensitivity_, 1.0f)
+            .description("Mouse sensitivity.");
+        SetConfigValue(bDeriveMouseInput_, false)
+            .description("Whether or not to derive moues movement for the absolute value.");
+        SetConfigValue(derivePeriod_, 0.05f)
+            .description("Accuracy of the mouse input deriver. The higher the more precise, but laggier.");
+        SetConfigValue(mouseSensitivityDerived_, 1.0f)
+            .description("Mouse sensitivity if mouse input is derived.");
+        SetConfigValue(bClipMouse_, true)
+            .description("Whether or not to clip absolute value of mouse in non derive mode.");
+        float oldThresh = buttonThreshold_;
+        SetConfigValue(buttonThreshold_, 0.80f)
+            .description("Threshold for analog axes until which the button is not pressed.");
+        if (oldThresh != buttonThreshold_)
+            for (unsigned int i = 0; i < nHalfAxes_s; i++)
+                if (halfAxes_[i].buttonThreshold_ == oldThresh)
+                    halfAxes_[i].buttonThreshold_ = buttonThreshold_;
+        // keys
+        for (unsigned int i = 0; i < nKeys_s; i++)
+            readTrigger(keys_[i]);
+        // mouse buttons
+        for (unsigned int i = 0; i < nMouseButtons_s; i++)
+            readTrigger(mouseButtons_[i]);
+        // joy stick buttons
+        for (unsigned int i = 0; i < nJoyStickButtons_s; i++)
+            readTrigger(joyStickButtons_[i]);
+        // half axes
+        for (unsigned int i = 0; i < nHalfAxes_s; i++)
+            readTrigger(halfAxes_[i]);
+    }
+    void KeyBinder::readTrigger(Button& button)
+    {
+        // config value stuff
+        ConfigValueContainer* cont
+            = ClassIdentifier<KeyBinder>::getIdentifier()->getConfigValueContainer(button.name_);
+        if (!cont)
+        {
+            cont = new ConfigValueContainer
+                (CFT_Keybindings, ClassIdentifier<KeyBinder>::getIdentifier(), button.name_, "", button.name_);
+            ClassIdentifier<KeyBinder>::getIdentifier()->addConfigValueContainer(button.name_, cont);
+        }
+        std::string old = button.bindingString_;
+        cont->getValue(&button.bindingString_, this);
+        // keybinder stuff
+        if (old != button.bindingString_)
+        {
+            // clear everything so we don't get old axis ParamCommands mixed up
+            button.clear();
+            // binding has changed
+            button.parse(paramCommandBuffer_);
+        }
+    }
+    /**
+    @brief
+        Overwrites all bindings with ""
+    */
+    void KeyBinder::clearBindings()
+    {
+        for (unsigned int i = 0; i < nKeys_s; i++)
+            keys_[i].clear();
+        for (unsigned int i = 0; i < nMouseButtons_s; i++)
+            mouseButtons_[i].clear();
+        for (unsigned int i = 0; i < nJoyStickButtons_s; i++)
+            joyStickButtons_[i].clear();
+        for (unsigned int i = 0; i < nHalfAxes_s; i++)
+            halfAxes_[i].clear();
+        for (unsigned int i = 0; i < paramCommandBuffer_.size(); i++)
+            delete paramCommandBuffer_[i];
+        paramCommandBuffer_.clear();
+    }
+    void KeyBinder::resetJoyStickAxes()
+    {
+        for (unsigned int i = 8; i < nHalfAxes_s; i++)
+        {
+            halfAxes_[i].absVal_ = 0.0f;
+            halfAxes_[i].relVal_ = 0.0f;
+        }
+    }
+    void KeyBinder::tickMouse(float dt)
+    {
+        tickDevices(0, 8);
+        if (bDeriveMouseInput_)
+        {
+            if (deriveTime_ > derivePeriod_)
+            {
+                //CCOUT(3) << "mouse abs: ";
+                for (int i = 0; i < 2; i++)
+                {
+                    if (mouseRelative_[i] > 0)
+                    {
+                        halfAxes_[2*i + 0].absVal_
+                            =  mouseRelative_[i] / deriveTime_ * 0.0005 * mouseSensitivityDerived_;
+                        halfAxes_[2*i + 1].absVal_ = 0.0f;
+                    }
+                    else if (mouseRelative_[i] < 0)
+                    {
+                        halfAxes_[2*i + 0].absVal_ = 0.0f;
+                        halfAxes_[2*i + 1].absVal_
+                            = -mouseRelative_[i] / deriveTime_ * 0.0005 * mouseSensitivityDerived_;
+                    }
+                    else
+                    {
+                        halfAxes_[2*i + 0].absVal_ = 0.0f;
+                        halfAxes_[2*i + 1].absVal_ = 0.0f;
+                    }
+                    //COUT(3) << mouseRelative_[i] << " | ";
+                    mouseRelative_[i] = 0;
+                    halfAxes_[2*i + 0].hasChanged_ = true;
+                    halfAxes_[2*i + 1].hasChanged_ = true;
+                }
+                deriveTime_ = 0.0f;
+                //COUT(3) << std::endl;
+            }
+            else
+                deriveTime_ += dt;
+        }
+    }
+    void KeyBinder::tickJoyStick(float dt, unsigned int joyStick)
+    {
+        tickDevices(8, nHalfAxes_s);
+    }
+    void KeyBinder::tickInput(float dt)
+    {
+        // execute all buffered bindings (additional parameter)
+        for (unsigned int i = 0; i < paramCommandBuffer_.size(); i++)
+            paramCommandBuffer_[i]->execute();
+        // always reset the relative movement of the mouse
+        for (unsigned int i = 0; i < 8; i++)
+            halfAxes_[i].relVal_ = 0.0f;
+    }
+    void KeyBinder::tickDevices(unsigned int begin, unsigned int end)
+    {
+        for (unsigned int i = begin; i < end; i++)
+        {
+            // button mode
+            // TODO: optimize out all the half axes that don't act as a button at the moment
+            if (halfAxes_[i].hasChanged_)
+            {
+                if (!halfAxes_[i].wasDown_ && halfAxes_[i].absVal_ > halfAxes_[i].buttonThreshold_)
+                {
+                    halfAxes_[i].wasDown_ = true;
+                    if (halfAxes_[i].nCommands_[KeybindMode::OnPress])
+                        halfAxes_[i].execute(KeybindMode::OnPress);
+                }
+                else if (halfAxes_[i].wasDown_ && halfAxes_[i].absVal_ < halfAxes_[i].buttonThreshold_)
+                {
+                    halfAxes_[i].wasDown_ = false;
+                    if (halfAxes_[i].nCommands_[KeybindMode::OnRelease])
+                        halfAxes_[i].execute(KeybindMode::OnRelease);
+                }
+                halfAxes_[i].hasChanged_ = false;
+            }
+            if (halfAxes_[i].wasDown_)
+            {
+                if (halfAxes_[i].nCommands_[KeybindMode::OnHold])
+                    halfAxes_[i].execute(KeybindMode::OnHold);
+            }
+            // these are the actually useful axis bindings for analog input
+            if (halfAxes_[i].relVal_ > analogThreshold_ || halfAxes_[i].absVal_ > analogThreshold_)
+            {
+                //COUT(3) << halfAxes_[i].name_ << "\t" << halfAxes_[i].absVal_ << std::endl;
+                halfAxes_[i].execute();
+            }
+        }
+    }
+    void KeyBinder::keyPressed (const KeyEvent& evt)
+    { keys_[evt.key].execute(KeybindMode::OnPress); }
+    void KeyBinder::keyReleased(const KeyEvent& evt)
+    { keys_[evt.key].execute(KeybindMode::OnRelease); }
+    void KeyBinder::keyHeld    (const KeyEvent& evt)
+    { keys_[evt.key].execute(KeybindMode::OnHold); }
+    void KeyBinder::mouseButtonPressed (MouseButton::Enum id)
+    { mouseButtons_[id].execute(KeybindMode::OnPress); }
+    void KeyBinder::mouseButtonReleased(MouseButton::Enum id)
+    { mouseButtons_[id].execute(KeybindMode::OnRelease); }
+    void KeyBinder::mouseButtonHeld    (MouseButton::Enum id)
+    { mouseButtons_[id].execute(KeybindMode::OnHold); }
+    void KeyBinder::joyStickButtonPressed (unsigned int joyStickID, JoyStickButton::Enum id)
+    { joyStickButtons_[id].execute(KeybindMode::OnPress); }
+    void KeyBinder::joyStickButtonReleased(unsigned int joyStickID, JoyStickButton::Enum id)
+    { joyStickButtons_[id].execute(KeybindMode::OnRelease); }
+    void KeyBinder::joyStickButtonHeld    (unsigned int joyStickID, JoyStickButton::Enum id)
+    { joyStickButtons_[id].execute(KeybindMode::OnHold); }
+    /**
+    @brief
+        Event handler for the mouseMoved Event.
+    @param e
+        Mouse state information
+    */
+    void KeyBinder::mouseMoved(IntVector2 abs_, IntVector2 rel_, IntVector2 clippingSize)
+    {
+        // y axis of mouse input is inverted
+        int rel[] = { rel_.x, -rel_.y };
+        if (!bDeriveMouseInput_)
+        {
+            for (int i = 0; i < 2; i++)
+            {
+                if (rel[i])
+                {
+                    // absolute
+                    halfAxes_[2*i + 0].hasChanged_ = true;
+                    halfAxes_[2*i + 1].hasChanged_ = true;
+                    mousePosition_[i] += rel[i];
+                    if (bClipMouse_)
+                    {
+                        if (mousePosition_[i] > 1024)
+                            mousePosition_[i] =  1024;
+                        if (mousePosition_[i] < -1024)
+                            mousePosition_[i] = -1024;
+                    }
+                    if (mousePosition_[i] >= 0)
+                    {
+                        halfAxes_[2*i + 0].absVal_ =   mousePosition_[i]/1024.0f * mouseSensitivity_;
+                        halfAxes_[2*i + 1].absVal_ =  0.0f;
+                    }
+                    else
+                    {
+                        halfAxes_[2*i + 0].absVal_ =  0.0f;
+                        halfAxes_[2*i + 1].absVal_ =  -mousePosition_[i]/1024.0f * mouseSensitivity_;
+                    }
+                }
+            }
+        }
+        else
+        {
+            mouseRelative_[0] += rel[0];
+            mouseRelative_[1] += rel[1];
+        }
+        // relative
         for (int i = 0; i < 2; i++)
+        {
+          if (mouseRelative_[i] > 0)
+          {
+            halfAxes_[2*i + 0].absVal_ =  mouseRelative_[i] / deriveTime_ * 0.0005 * mouseSensitivityDerived_;
+            halfAxes_[2*i + 1].absVal_ = 0.0f;
+          }
+          else if (mouseRelative_[i] < 0)
+          {
+            halfAxes_[2*i + 0].absVal_ = 0.0f;
+            halfAxes_[2*i + 1].absVal_ = -mouseRelative_[i] / deriveTime_ * 0.0005 * mouseSensitivityDerived_;
+          }
+          else
+          {
+            halfAxes_[2*i + 0].absVal_ = 0.0f;
+            halfAxes_[2*i + 1].absVal_ = 0.0f;
+          }
+          //COUT(3) << mouseRelative_[i] << " | ";
+          mouseRelative_[i] = 0;
+          halfAxes_[2*i + 0].hasChanged_ = true;
+          halfAxes_[2*i + 1].hasChanged_ = true;
+        }
+        deriveTime_ = 0.0f;
+        //COUT(3) << std::endl;
+      }
+      else
+        deriveTime_ += dt;
+    }
+    // execute all buffered bindings (addional parameter)
+    for (unsigned int i = 0; i < paramCommandBuffer_.size(); i++)
+      paramCommandBuffer_[i]->execute();
+    // always reset the relative movement of the mouse
+    if (state.mouse)
+      for (unsigned int i = 0; i < 8; i++)
+        halfAxes_[i].relVal_ = 0.0f;
+  }
+  void KeyBinder::keyPressed (const KeyEvent& evt)
+  { keys_[evt.key].execute(KeybindMode::OnPress); }
+  void KeyBinder::keyReleased(const KeyEvent& evt)
+  { keys_[evt.key].execute(KeybindMode::OnRelease); }
+  void KeyBinder::keyHeld    (const KeyEvent& evt)
+  { keys_[evt.key].execute(KeybindMode::OnHold); }
+  void KeyBinder::mouseButtonPressed (MouseButton::Enum id)
+  { mouseButtons_[id].execute(KeybindMode::OnPress); }
+  void KeyBinder::mouseButtonReleased(MouseButton::Enum id)
+  { mouseButtons_[id].execute(KeybindMode::OnRelease); }
+  void KeyBinder::mouseButtonHeld    (MouseButton::Enum id)
+  { mouseButtons_[id].execute(KeybindMode::OnHold); }
+  void KeyBinder::joyStickButtonPressed (int joyStickID, int button)
+  { joyStickButtons_[button].execute(KeybindMode::OnPress); }
+  void KeyBinder::joyStickButtonReleased(int joyStickID, int button)
+  { joyStickButtons_[button].execute(KeybindMode::OnRelease); }
+  void KeyBinder::joyStickButtonHeld    (int joyStickID, int button)
+  { joyStickButtons_[button].execute(KeybindMode::OnHold); }
+  /**
+    @brief Event handler for the mouseMoved Event.
+    @param e Mouse state information
+  */
+  void KeyBinder::mouseMoved(IntVector2 abs_, IntVector2 rel_, IntVector2 clippingSize)
+  {
+    // y axis of mouse input is inverted
+    int rel[] = { rel_.x, -rel_.y };
+    if (!bDeriveMouseInput_)
+    {
+      for (int i = 0; i < 2; i++)
+      {
+        if (rel[i])
+        {
+          // absolute
+          halfAxes_[2*i + 0].hasChanged_ = true;
+          halfAxes_[2*i + 1].hasChanged_ = true;
+          mousePosition_[i] += rel[i];
+          if (bClipMouse_)
+          {
+            if (mousePosition_[i] > 1024)
+              mousePosition_[i] =  1024;
+            if (mousePosition_[i] < -1024)
+              mousePosition_[i] = -1024;
+          }
+          if (mousePosition_[i] >= 0)
+          {
+            halfAxes_[2*i + 0].absVal_ =   mousePosition_[i]/1024.0f * mouseSensitivity_;
+            halfAxes_[2*i + 1].absVal_ =  0.0f;
+          }
+          else
+          {
+            halfAxes_[2*i + 0].absVal_ =  0.0f;
+            halfAxes_[2*i + 1].absVal_ =  -mousePosition_[i]/1024.0f * mouseSensitivity_;
+          }
+        }
+      }
+    }
+    else
+    {
+      mouseRelative_[0] += rel[0];
+      mouseRelative_[1] += rel[1];
+    }
+    // relative
+    for (int i = 0; i < 2; i++)
+    {
+      if (rel[i] > 0)
+        halfAxes_[0 + 2*i].relVal_ =  ((float)rel[i])/1024 * mouseSensitivity_;
+      else
+        halfAxes_[1 + 2*i].relVal_ = -((float)rel[i])/1024 * mouseSensitivity_;
+    }
+  }
+  /**
+            if (rel[i] > 0)
+                halfAxes_[0 + 2*i].relVal_ =  ((float)rel[i])/1024 * mouseSensitivity_;
+            else
+                halfAxes_[1 + 2*i].relVal_ = -((float)rel[i])/1024 * mouseSensitivity_;
+        }
+    }
+    /**
     @brief Event handler for the mouseScrolled Event.
     @param e Mouse state information
+  */
+  void KeyBinder::mouseScrolled(int abs, int rel)
+  {
+    //COUT(3) << mouseButtons_[8].name_ << "   " << abs << " | " << rel << std::endl;
+    if (rel > 0)
+      for (int i = 0; i < rel/120; i++)
+        mouseButtons_[8].execute(KeybindMode::OnPress, ((float)abs)/120.0f);
+    else
+      for (int i = 0; i < -rel/120; i++)
+        mouseButtons_[9].execute(KeybindMode::OnPress, ((float)abs)/120.0f);
+  }
+  void KeyBinder::joyStickAxisMoved(int joyStickID, int axis, float value)
+  {
+    // TODO: Use proper calibration values instead of generally 16-bit integer
+    int i = 8 + axis * 2;
+    if (value >= 0)
+    {
+      //if (value > 10000)
+      //{ CCOUT(3) << halfAxes_[i].name_ << std::endl; }
+      halfAxes_[i].absVal_ = value;
+      halfAxes_[i].relVal_ = value;
+      halfAxes_[i].hasChanged_ = true;
+      if (halfAxes_[i + 1].absVal_ > 0.0f)
+      {
+        halfAxes_[i + 1].absVal_ = -0.0f;
+        halfAxes_[i + 1].relVal_ = -0.0f;
+        halfAxes_[i + 1].hasChanged_ = true;
+      }
+    }
+    else
+    {
+      //if (value < -10000)
+      //{ CCOUT(3) << halfAxes_[i + 1].name_ << std::endl; }
+      halfAxes_[i + 1].absVal_ = -value;
+      halfAxes_[i + 1].relVal_ = -value;
+      halfAxes_[i + 1].hasChanged_ = true;
+      if (halfAxes_[i].absVal_ > 0.0f)
+      {
+        halfAxes_[i].absVal_ = -0.0f;
+        halfAxes_[i].relVal_ = -0.0f;
+        halfAxes_[i].hasChanged_ = true;
+      }
+    }
+  }
+    */
+    void KeyBinder::mouseScrolled(int abs, int rel)
+    {
+        //COUT(3) << mouseButtons_[8].name_ << "   " << abs << " | " << rel << std::endl;
+        if (rel > 0)
+            for (int i = 0; i < rel/120; i++)
+                mouseButtons_[8].execute(KeybindMode::OnPress, ((float)abs)/120.0f);
+        else
+            for (int i = 0; i < -rel/120; i++)
+                mouseButtons_[9].execute(KeybindMode::OnPress, ((float)abs)/120.0f);
+    }
+    void KeyBinder::joyStickAxisMoved(unsigned int joyStickID, unsigned int axis, float value)
+    {
+        int i = 8 + axis * 2;
+        if (value >= 0)
+        {
+            //if (value > 10000)
+            //{ CCOUT(3) << halfAxes_[i].name_ << std::endl; }
+            halfAxes_[i].absVal_ = value;
+            halfAxes_[i].relVal_ = value;
+            halfAxes_[i].hasChanged_ = true;
+            if (halfAxes_[i + 1].absVal_ > 0.0f)
+            {
+                halfAxes_[i + 1].absVal_ = -0.0f;
+                halfAxes_[i + 1].relVal_ = -0.0f;
+                halfAxes_[i + 1].hasChanged_ = true;
+            }
+        }
+        else
+        {
+            //if (value < -10000)
+            //{ CCOUT(3) << halfAxes_[i + 1].name_ << std::endl; }
+            halfAxes_[i + 1].absVal_ = -value;
+            halfAxes_[i + 1].relVal_ = -value;
+            halfAxes_[i + 1].hasChanged_ = true;
+            if (halfAxes_[i].absVal_ > 0.0f)
+            {
+                halfAxes_[i].absVal_ = -0.0f;
+                halfAxes_[i].relVal_ = -0.0f;
+                halfAxes_[i].hasChanged_ = true;
+            }
+        }
+    }
+}

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

-                      r1535
+                      r1755
 /**
+ @file
+ @brief Different definitions of input processing.
+ */
+@file
+@brief
+    Different definitions of input processing.
+*/
 #ifndef _KeyBinder_H__
 …
 namespace orxonox
+{
+  /**
+    @brief Handles mouse, keyboard and joy stick input while in the actual game mode.
+           Manages the key bindings.
+  */
+  class _CoreExport KeyBinder : public KeyHandler, public MouseHandler, public JoyStickHandler, public OrxonoxClass
+  {
+  public:
+    KeyBinder ();
+    virtual ~KeyBinder();
+    /**
+    @brief
+        Handles mouse, keyboard and joy stick input while in the actual game mode.
+        Manages the key bindings.
+    */
+    class _CoreExport KeyBinder : public KeyHandler, public MouseHandler, public JoyStickHandler, public OrxonoxClass
+    {
+    public:
+        KeyBinder ();
+        virtual ~KeyBinder();
     void loadBindings();
     void clearBindings();
     void setConfigValues();
     void resetJoyStickAxes();
+        void loadBindings();
+        void clearBindings();
+        void setConfigValues();
+        void resetJoyStickAxes();
+  protected: // functions
+    void tickInput(float dt, const HandlerState& state);
+    protected: // functions
+        void tickInput(float dt);
+        //void tickInput(float dt, int device);
+        void tickKey(float dt) { }
+        void tickMouse(float dt);
+        void tickJoyStick(float dt, unsigned int joyStick);
+        void tickDevices(unsigned int begin, unsigned int end);
     virtual void readTrigger(Button& button);
+        virtual void readTrigger(Button& button);
     void keyPressed (const KeyEvent& evt);
     void keyReleased(const KeyEvent& evt);
     void keyHeld    (const KeyEvent& evt);
+        void keyPressed (const KeyEvent& evt);
+        void keyReleased(const KeyEvent& evt);
+        void keyHeld    (const KeyEvent& evt);
     void mouseButtonPressed (MouseButton::Enum id);
     void mouseButtonReleased(MouseButton::Enum id);
     void mouseButtonHeld    (MouseButton::Enum id);
     void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize);
     void mouseScrolled      (int abs, int rel);
+        void mouseButtonPressed (MouseButton::Enum id);
+        void mouseButtonReleased(MouseButton::Enum id);
+        void mouseButtonHeld    (MouseButton::Enum id);
+        void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize);
+        void mouseScrolled      (int abs, int rel);
     void joyStickButtonPressed (int joyStickID, int button);
     void joyStickButtonReleased(int joyStickID, int button);
     void joyStickButtonHeld    (int joyStickID, int button);
     void joyStickAxisMoved     (int joyStickID, int axis, float value);
+        void joyStickButtonPressed (unsigned int joyStickID, JoyStickButton::Enum id);
+        void joyStickButtonReleased(unsigned int joyStickID, JoyStickButton::Enum id);
+        void joyStickButtonHeld    (unsigned int joyStickID, JoyStickButton::Enum id);
+        void joyStickAxisMoved     (unsigned int joyStickID, unsigned int axis, float value);
   protected: // variables
     //! denotes the number of different keys there are in OIS.
     static const unsigned int nKeys_s = 0xEE;
     //! Actual key bindings as bundle for Press, Hold and Release
     Button keys_ [nKeys_s];
+    protected: // variables
+        //! denotes the number of different keys there are in OIS.
+        static const unsigned int nKeys_s = 0xEE;
+        //! Actual key bindings as bundle for Press, Hold and Release
+        Button keys_ [nKeys_s];
     //! denotes the number of different mouse buttons there are in OIS.
     static const unsigned int nMouseButtons_s = 8 + 2*2; // 8 buttons and 2 scroll wheels
     //! Actual key bindings as bundle for Press, Hold and Release
     Button mouseButtons_ [nMouseButtons_s];
+        //! denotes the number of different mouse buttons there are in OIS.
+        static const unsigned int nMouseButtons_s = 8 + 2*2; // 8 buttons and 2 scroll wheels
+        //! Actual key bindings as bundle for Press, Hold and Release
+        Button mouseButtons_ [nMouseButtons_s];
     //! denotes the number of different joy stick buttons there are in OIS.
     static const unsigned int nJoyStickButtons_s = 32 + 4 * 4; // 32 buttons and 4 POVs with 4 buttons
     //! Actual key bindings as bundle for Press, Hold and Release
     Button joyStickButtons_ [nJoyStickButtons_s];
+        //! denotes the number of different joy stick buttons there are in OIS.
+        static const unsigned int nJoyStickButtons_s = 32 + 4 * 4; // 32 buttons and 4 POVs with 4 buttons
+        //! Actual key bindings as bundle for Press, Hold and Release
+        Button joyStickButtons_ [nJoyStickButtons_s];
     //! denotes the number of half axes (every axis twice) there can be.
     static const unsigned int nHalfAxes_s = 56;
     /**
     * Array with all the half axes for mouse and joy sticks.
     * Keep in mind that the positions are fixed and that the first entry is the
     * positive one and the second is negative.
     * Sequence is as follows:
     *  0 -  3: Mouse x and y
     *  4 -  7: empty
     *  8 - 23: joy stick slider axes 1 to 8
     * 24 - 55: joy stick axes 1 - 16
     */
     HalfAxis halfAxes_[nHalfAxes_s];
+        //! denotes the number of half axes (every axis twice) there can be.
+        static const unsigned int nHalfAxes_s = 56;
+        /**
+        * Array with all the half axes for mouse and joy sticks.
+        * Keep in mind that the positions are fixed and that the first entry is the
+        * positive one and the second is negative.
+        * Sequence is as follows:
+        *  0 -  3: Mouse x and y
+        *  4 -  7: empty
+        *  8 - 23: joy stick slider axes 1 to 8
+        * 24 - 55: joy stick axes 1 - 16
+        */
+        HalfAxis halfAxes_[nHalfAxes_s];
+    /**
+    * Commands that have additional parameters (axes) are executed at the end of
+    * the tick() so that all values can be buffered for single execution.
+    */
+    std::vector<BufferedParamCommand*> paramCommandBuffer_;
+        /**
+        @brief
+            Commands that have additional parameters (axes) are executed at the end of
+            the tick() so that all values can be buffered for single execution.
+        */
+        std::vector<BufferedParamCommand*> paramCommandBuffer_;
     //! Keeps track of the absolute mouse value (incl. scroll wheel)
     int mousePosition_[2];
     //! Used to derive mouse input if requested
     int mouseRelative_[2];
     float deriveTime_;
+        //! Keeps track of the absolute mouse value (incl. scroll wheel)
+        int mousePosition_[2];
+        //! Used to derive mouse input if requested
+        int mouseRelative_[2];
+        float deriveTime_;
+    //##### ConfigValues #####
+    //! Threshold for analog triggers until which the state is 0.
+    float analogThreshold_;
+    //! Threshold for analog triggers until which the button is not pressed.
+    float buttonThreshold_;
+    //! Derive mouse input for absolute values?
+    bool bDeriveMouseInput_;
+    //! Accuracy of the mouse input deriver. The higher the more precise, but laggier.
+    float derivePeriod_;
+    //! mouse sensitivity
+    float mouseSensitivity_;
+    //! mouse sensitivity if mouse input is derived
+    float mouseSensitivityDerived_;
+    //! Whether or not to clip abslute mouse values to 1024
+    bool bClipMouse_;
+  };
+        //##### ConfigValues #####
+        //! Threshold for analog triggers until which the state is 0.
+        float analogThreshold_;
+        //! Threshold for analog triggers until which the button is not pressed.
+        float buttonThreshold_;
+        //! Derive mouse input for absolute values?
+        bool bDeriveMouseInput_;
+        //! Accuracy of the mouse input deriver. The higher the more precise, but laggier.
+        float derivePeriod_;
+        //! mouse sensitivity
+        float mouseSensitivity_;
+        //! mouse sensitivity if mouse input is derived
+        float mouseSensitivityDerived_;
+        //! Whether or not to clip abslute mouse values to 1024
+        bool bClipMouse_;
+    };
+}

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

-                      r1747
+                      r1755
 /**
+ @file
+ @brief Implementation of the different input handlers.
+ */
+@file
+@brief
+    Implementation of the different input handlers.
+*/
 #include "KeyDetector.h"
 …
 namespace orxonox
+{
+  /**
+    @brief Constructor
+  */
+  KeyDetector::KeyDetector()
+  {
+    RegisterObject(KeyDetector);
+  }
+    /**
+    @brief
+        Constructor
+    */
+    KeyDetector::KeyDetector()
+    {
+        RegisterObject(KeyDetector);
+    }
+  /**
+    @brief Destructor
+  */
+  KeyDetector::~KeyDetector()
+  {
+  }
+    /**
+    @brief
+        Destructor
+    */
+    KeyDetector::~KeyDetector()
+    {
+    }
+  /**
+    @brief Loads the key and button bindings.
+    @return True if loading succeeded.
+  */
+  void KeyDetector::loadBindings()
+  {
+    clearBindings();
+    setConfigValues();
+  }
+    /**
+    @brief
+        Loads the key and button bindings.
+    @return
+        True if loading succeeded.
+    */
+    void KeyDetector::loadBindings(const std::string& command)
+    {
+        this->command_ = command;
+        clearBindings();
+        setConfigValues();
+    }
   void KeyDetector::readTrigger(Button& button)
+  {
     SimpleCommand* cmd = new SimpleCommand();
     cmd->evaluation_ = CommandExecutor::evaluate("storeKeyStroke " + button.name_);
     button.commands_[KeybindMode::OnPress] = new BaseCommand*[1];
     button.commands_[KeybindMode::OnPress][0] = cmd;
     button.nCommands_[KeybindMode::OnPress] = 1;
+  }
+    void KeyDetector::readTrigger(Button& button)
+    {
+        SimpleCommand* cmd = new SimpleCommand();
+        cmd->evaluation_ = CommandExecutor::evaluate(this->command_ + " " + button.name_);
+        button.commands_[KeybindMode::OnPress] = new BaseCommand*[1];
+        button.commands_[KeybindMode::OnPress][0] = cmd;
+        button.nCommands_[KeybindMode::OnPress] = 1;
+    }
+}

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

-                      r1535
+                      r1755
 /**
+ @file
+ @brief Different definitions of input processing.
+ */
+@file
+@brief
+    Different definitions of input processing.
+*/
 #ifndef _KeyDetector_H__
 …
 namespace orxonox
+{
   class _CoreExport KeyDetector : public KeyBinder
+  {
   public:
     KeyDetector();
     ~KeyDetector();
     void loadBindings();
+    class _CoreExport KeyDetector : public KeyBinder
+    {
+    public:
+        KeyDetector();
+        ~KeyDetector();
+        void loadBindings(const std::string& command);
+  protected:
+    void readTrigger(Button& button);
+  };
+    protected:
+        void readTrigger(Button& button);
+    private:
+        std::string command_;
+    };
+}

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

r1724	r1755
36	36
37	37	#include <assert.h>
38		#include "~~core~~/Debug.h"
	38	#include "util/Debug.h"
39	39	#include "core/Executor.h"
40	40

code/trunk/src/core/tolua/tolua.pkg

r1505	r1755
1		$cfile "../../src/core/Script_clean.h"
	1	$cfile "../../src/core/Script.h"
	2	$cfile "../../src/core/CommandExecutor.h"

code/trunk/src/network/ClientConnection.cc

r1747	r1755
42	42	#include <iostream>
43	43	// boost.thread library for multithreading support
	44	#include <boost/thread/thread.hpp>
44	45	#include <boost/bind.hpp>
45	46

code/trunk/src/network/ClientConnection.h

-                      r1534
+                      r1755
 #include <string>
 #include <enet/enet.h>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/recursive_mutex.hpp>
+#include "PacketBuffer.h"
+#include "PacketBuffer.h"
+namespace boost { class thread; }
 namespace network

code/trunk/src/network/ConnectionManager.cc

r1747	r1755
41	41	#include <assert.h>
42	42	// boost.thread library for multithreading support
	43	#include <boost/thread/thread.hpp>
43	44	#include <boost/bind.hpp>
44	45

code/trunk/src/network/ConnectionManager.h

-                      r1735
+                      r1755
 // enet library for networking support
 #include <enet/enet.h>
-#include <boost/thread/thread.hpp>
 #include <boost/thread/recursive_mutex.hpp>
 #include "PacketBuffer.h"
 #include "packet/Packet.h"
+namespace boost { class thread; }
 namespace std

code/trunk/src/network/GamestateManager.cc

r1751	r1755
44	44	#include <iostream>
45	45	#include <zlib.h>
46		#include <~~assert.h~~>
	46	#include <cassert>
47	47
48	48	#include "core/CoreIncludes.h"

code/trunk/src/network/Server.cc

-                      r1752
+                      r1755
 #include <iostream>
+#include <cassert>
 …
     if(!client)
       return false;
     orxonox::Identifier* id = ID("SpaceShip");
+    orxonox::Identifier* id = GetIdentifier("SpaceShip");
     if(!id){
       COUT(4) << "We could not create the SpaceShip for client: " << client->getID() << std::endl;

code/trunk/src/network/Synchronisable.cc

r1751	r1755
101	101	return true;
102	102
103		orxonox::Identifier* id = ID(classID);
	103	orxonox::Identifier* id = GetIdentifier(classID);
104	104	if(!id){
105	105	COUT(3) << "We could not identify a new object; classid: " << classID << " uint: " << (unsigned int)classID << " objectID: " << objectID << " size: " << size << std::endl;

code/trunk/src/network/packet/ClassID.cc

r1735	r1755
73	73	bool ClassID::process(){
74	74	COUT(3) << "processing classid: " << getClassID() << " name: " << (const char*)(data_+_CLASSNAME) << std::endl;
75		orxonox::Identifier id=ID( std::string((const char)(data_+_CLASSNAME) ));
	75	orxonox::Identifier id=GetIdentifier( std::string((const char)(data_+_CLASSNAME) ));
76	76	if(id==NULL)
77	77	return false;

code/trunk/src/orxonox/CMakeLists.txt

-                      r1747
+                      r1755
   GraphicsEngine.cc
   Main.cc
-  Orxonox.cc
   Radar.cc
   RadarListener.cc
 …
   Settings.cc
   SignalHandler.cc
+  gamestates/GSClient.cc
+  gamestates/GSDedicated.cc
+  gamestates/GSGraphics.cc
+  gamestates/GSGUI.cc
+  gamestates/GSIOConsole.cc
+  gamestates/GSLevel.cc
+  gamestates/GSRoot.cc
+  gamestates/GSServer.cc
+  gamestates/GSStandalone.cc
+  gui/GUIManager.cc
+  gui/OgreCEGUIRenderer.cpp
+  gui/OgreCEGUIResourceProvider.cpp
+  gui/OgreCEGUITexture.cpp
   overlays/OrxonoxOverlay.cc
 …
 ADD_CUSTOM_COMMAND(
   OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/tolua/tolua_bind.cc
   COMMAND ${TOLUA_EXE} -n orxonox -o ../../src/orxonox/tolua/tolua_bind.cc -H ../../src/orxonox/tolua/tolua_bind.h ../../src/orxonox/tolua/tolua.pkg
   DEPENDS tolua
+  COMMAND ${TOLUA_EXE} -n Orxonox -o ../../src/orxonox/tolua/tolua_bind.cc -H ../../src/orxonox/tolua/tolua_bind.h ../../src/orxonox/tolua/tolua.pkg
+  DEPENDS tolua ${CMAKE_SOURCE_DIR}/src/orxonox/tolua/tolua.pkg
   WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin/lib
+)
 …
   ${OGRE_LIBRARIES}
   ${Lua_LIBRARIES}
+  ${CEGUI_LIBRARIES}
+  ${CEGUI_SCRIPT_LIBRARIES}
   tinyxml
   tolualib

code/trunk/src/orxonox/GraphicsEngine.cc

-                      r1747
+                      r1755
  *   Author:
  *      Reto Grieder
+ *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
  *   Co-authors:
  *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007, Felix Schulthess
+ *      Felix Schulthess
+ *
  */
+ /**
+    @file orxonox.cc
+    @brief Orxonox class
+  */
+/**
+@file
+@brief
+    Implementation of an partial interface to Ogre.
+*/
 #include "OrxonoxStableHeaders.h"
 #include "GraphicsEngine.h"
+#include <fstream>
+#include <OgreConfigFile.h>
+#include <OgreException.h>
+#include <OgreLogManager.h>
+#include <OgreRoot.h>
+#include <OgreSceneManager.h>
+#include <OgreTextureManager.h>
+#include <OgreViewport.h>
+#include <OgreRenderWindow.h>
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
-#include "core/Iterator.h"
-#include "core/CommandExecutor.h"
-#include "core/ConsoleCommand.h"
 #include "util/Debug.h"
-#include "overlays/console/InGameConsole.h"
-#include "overlays/OverlayGroup.h"
 #include "tools/ParticleInterface.h"
-#include "Settings.h"
-#include "tools/WindowEventListener.h"
 namespace orxonox
+{
+  /**
+    @brief Returns the singleton instance and creates it the first time.
+    @return The only instance of GraphicsEngine.
+  */
+  /*static*/ GraphicsEngine& GraphicsEngine::getSingleton()
+  {
+    static GraphicsEngine theOnlyInstance;
+    return theOnlyInstance;
+  }
+    //SetConsoleCommand(GraphicsEngine, printScreen, true).setKeybindMode(KeybindMode::OnPress);
+  /**
+    @brief Only use constructor to initialise variables and pointers!
+  */
+  GraphicsEngine::GraphicsEngine() :
+    root_(0),
+    scene_(0),
+    renderWindow_(0)
+  {
+    RegisterObject(GraphicsEngine);
+    GraphicsEngine* GraphicsEngine::singletonRef_s = 0;
+    this->detailLevelParticle_ = 0;
+    this->setConfigValues();
+    CCOUT(4) << "Constructed" << std::endl;
+  }
+  void GraphicsEngine::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(ogrePluginsFile_, "plugins.cfg").description("Location of the Ogre plugins file");
+    SetConfigValue(ogreLogFile_,     "ogre.log").description("Logfile for messages from Ogre. \
+                                                             Use \"\" to suppress log file creation.");
+    SetConfigValue(ogreLogLevelTrivial_ , 5).description("Corresponding orxonox debug level for ogre Trivial");
+    SetConfigValue(ogreLogLevelNormal_  , 4).description("Corresponding orxonox debug level for ogre Normal");
+    SetConfigValue(ogreLogLevelCritical_, 2).description("Corresponding orxonox debug level for ogre Critical");
+    SetConfigValue(detailLevelParticle_, 2).description("O: off, 1: low, 2: normal, 3: high").callback(this, &GraphicsEngine::detailLevelParticleChanged);
+  }
+  void GraphicsEngine::detailLevelParticleChanged()
+  {
+    for (ObjectList<ParticleInterface>::iterator it = ObjectList<ParticleInterface>::begin(); it; ++it)
+      it->detailLevelChanged(this->detailLevelParticle_);
+  }
+  /**
+    @brief Called after main() --> call destroyObjects()!
+  */
+  GraphicsEngine::~GraphicsEngine()
+  {
+    this->destroy();
+  }
+  /**
+    @brief Destroys all the internal objects. Call this method when you
+           normally would call the destructor.
+  */
+  void GraphicsEngine::destroy()
+  {
+    CCOUT(4) << "Destroying objects..." << std::endl;
+    Ogre::WindowEventUtilities::removeWindowEventListener(this->renderWindow_, this);
+    if (this->root_)
+      delete this->root_;
+    this->root_ = 0;
+    this->scene_ = 0;
+    this->renderWindow_ = 0;
+    // delete the ogre log and the logManager (since we have created it).
+    if (Ogre::LogManager::getSingletonPtr() != 0)
+    /**
+    @brief
+        Returns the singleton instance.
+    @return
+        The only instance of GraphicsEngine.
+    */
+    /*static*/ GraphicsEngine& GraphicsEngine::getInstance()
+    {
+      Ogre::LogManager::getSingleton().getDefaultLog()->removeListener(this);
+      Ogre::LogManager::getSingleton().destroyLog(Ogre::LogManager::getSingleton().getDefaultLog());
+      delete Ogre::LogManager::getSingletonPtr();
+    }
+    CCOUT(4) << "Destroying objects done" << std::endl;
+  }
+  /**
+    @brief Creates the Ogre Root object and sets up the ogre log.
+  */
+  bool GraphicsEngine::setup()
+  {
+    CCOUT(3) << "Setting up..." << std::endl;
+    // temporary overwrite of dataPath, change ini file for permanent change
+// TODO: LogManager doesn't work on specific systems. The why is unknown yet.
+#if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32
+    // create a logManager
+    // note: If there's already a logManager, Ogre will complain by a failed assertation.
+    // but that shouldn't happen, since this is the first time to create a logManager..
+    Ogre::LogManager* logger = new Ogre::LogManager();
+    CCOUT(4) << "Ogre LogManager created" << std::endl;
+    // create our own log that we can listen to
+    Ogre::Log *myLog;
+    if (this->ogreLogFile_ == "")
+      myLog = logger->createLog("ogre.log", true, false, true);
+    else
+      myLog = logger->createLog(this->ogreLogFile_, true, false, false);
+    CCOUT(4) << "Ogre Log created" << std::endl;
+    myLog->setLogDetail(Ogre::LL_BOREME);
+    myLog->addListener(this);
+#endif
+    // Root will detect that we've already created a Log
+    CCOUT(4) << "Creating Ogre Root..." << std::endl;
+    if (ogrePluginsFile_ == "")
+    {
+      COUT(1) << "Error: Ogre plugins file set to \"\". Cannot load." << std::endl;
+      return false;
+    }
+    if (ogreConfigFile_ == "")
+    {
+      COUT(1) << "Error: Ogre config file set to \"\". Cannot load." << std::endl;
+      return false;
+    }
+    if (ogreLogFile_ == "")
+    {
+      COUT(1) << "Error: Ogre log file set to \"\". Cannot load." << std::endl;
+      return false;
+        assert(singletonRef_s);
+        return *singletonRef_s;
+    }
+    try
+    /**
+    @brief
+        Non-initialising constructor.
+    */
+    GraphicsEngine::GraphicsEngine()
+        : root_(0)
+        , renderWindow_(0)
+        , levelSceneManager_(0)
+        , viewport_(0)
+    {
+      root_ = new Ogre::Root(ogrePluginsFile_, ogreConfigFile_, ogreLogFile_);
+    }
+    catch (Ogre::Exception ex)
+    {
+      COUT(2) << "Error: There was an exception when creating Ogre Root." << std::endl;
+      return false;
+        RegisterObject(GraphicsEngine);
+        assert(singletonRef_s == 0);
+        singletonRef_s = this;
+        this->detailLevelParticle_ = 0;
+        this->setConfigValues();
+        CCOUT(4) << "Constructed" << std::endl;
+    }
     if (!root_->getInstalledPlugins().size())
+    void GraphicsEngine::setConfigValues()
+    {
+      COUT(1) << "Error: No plugins declared. Cannot load Ogre." << std::endl;
+      COUT(0) << "Is the plugins file correctly declared?" << std::endl;
+      return false;
+        SetConfigValue(detailLevelParticle_, 2).description("O: off, 1: low, 2: normal, 3: high").callback(this, &GraphicsEngine::detailLevelParticleChanged);
+    }
+#if 0
+    // tame the ogre ouput so we don't get all the mess in the console
+    Ogre::Log* defaultLog = Ogre::LogManager::getSingleton().getDefaultLog();
+    defaultLog->setDebugOutputEnabled(false);
+    defaultLog->setLogDetail(Ogre::LL_BOREME);
+    defaultLog->addListener(this);
+#endif
+    CCOUT(4) << "Creating Ogre Root done" << std::endl;
+    // specify where Ogre has to look for resources. This call doesn't parse anything yet!
+    if (!declareRessourceLocations())
+      return false;
+    CCOUT(3) << "Set up done." << std::endl;
+    return true;
+  }
+  bool GraphicsEngine::declareRessourceLocations()
+  {
+    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_ == "")
+    void GraphicsEngine::detailLevelParticleChanged()
+    {
       COUT(1) << "Error: Resource file set to \"\". Cannot load." << std::endl;
       return false;
+        for (ObjectList<ParticleInterface>::iterator it = ObjectList<ParticleInterface>::begin(); it; ++it)
+            it->detailLevelChanged(this->detailLevelParticle_);
+    }
+    // Load resource paths from data file using configfile ressource type
+    Ogre::ConfigFile cf;
+    try
+    /**
+    @brief
+        Destroys all the Ogre related objects
+    */
+    GraphicsEngine::~GraphicsEngine()
+    {
+      cf.load(Settings::getDataPath() + resourceFile_);
+    }
+    catch (Ogre::Exception ex)
+    {
+      COUT(1) << "Error: Could not load resources.cfg in path " << Settings::getDataPath() << std::endl;
+      COUT(0) << "Have you forgotten to set the data path in orxnox.ini?" << std::endl;
+      return false;
+        singletonRef_s = 0;
+    }
+    // Go through all sections & settings in the file
+    Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
+    std::string secName, typeName, archName;
+    while (seci.hasMoreElements())
+    /**
+    @brief
+        Get the width of the render window
+    @return
+        The width of the render window
+    */
+    int GraphicsEngine::getWindowWidth() const
+    {
+      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(
+              std::string(Settings::getDataPath() + archName), typeName, secName);
+        }
+      }
+      catch (Ogre::Exception ex)
+      {
+        COUT(2) << "Exception while reading resources.cfg. Proceeding.." << ex.getDescription() << std::endl;
+      }
+    }
+    return true;
+  }
+  bool GraphicsEngine::loadRenderer()
+  {
+    CCOUT(4) << "Configuring Renderer" << std::endl;
+    // check for file existence because Ogre displays exceptions if not
+    std::ifstream probe;
+    probe.open(ogreConfigFile_.c_str());
+    if (!probe)
+    {
+      // create a zero sized file
+      std::ofstream creator;
+      creator.open(ogreConfigFile_.c_str());
+      creator.close();
+    }
+    else
+      probe.close();
+    if (!root_->restoreConfig())
+      if (!root_->showConfigDialog())
+        return false;
+    CCOUT(4) << "Creating render window" << std::endl;
+    try
+    {
+      this->renderWindow_ = root_->initialise(true, "OrxonoxV2");
+    }
+    catch (Ogre::Exception ex)
+    {
+      COUT(2) << "Error: There was an exception when initialising Ogre Root." << std::endl;
+      return false;
+        if (this->renderWindow_)
+            return this->renderWindow_->getWidth();
+        else
+            return 0;
+    }
+    if (!root_->isInitialised())
+    /**
+    @brief
+        Get the height of the render window
+    @return
+        The height of the render window
+    */
+    int GraphicsEngine::getWindowHeight() const
+    {
+      CCOUT(2) << "Error: Initialising Ogre root object failed." << std::endl;
+      return false;
+        if (this->renderWindow_)
+            return this->renderWindow_->getHeight();
+        else
+            return 0;
+    }
-    Ogre::WindowEventUtilities::addWindowEventListener(this->renderWindow_, this);
-    Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
-    return true;
+  }
+  bool GraphicsEngine::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
+    /**
+    @brief
+        Returns the window aspect ratio height/width.
+    @return
+        The window aspect ratio
+    */
+    float GraphicsEngine::getWindowAspectRatio() const
+    {
+      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]);
+      }*/
+        if (this->renderWindow_)
+            return (float)this->renderWindow_->getHeight() / (float)this->renderWindow_->getWidth();
+        else
+            return 1.0f;
+    }
-    catch (Ogre::Exception e)
+    {
-      CCOUT(2) << "Error: There was an Error when initialising the resources." << std::endl;
-      CCOUT(2) << "ErrorMessage: " << e.getFullDescription() << std::endl;
-      return false;
+    }
-    return true;
+  }
-  /**
-   * @brief Creates the SceneManager
-   */
-  bool GraphicsEngine::createNewScene()
+  {
-    CCOUT(4) << "Creating new SceneManager..." << std::endl;
-    if (scene_)
+    {
-      CCOUT(2) << "SceneManager already exists! Skipping." << std::endl;
-      return false;
+    }
-    scene_ = root_->createSceneManager(Ogre::ST_GENERIC, "Default SceneManager");
-    CCOUT(3) << "Created SceneManager: " << scene_ << std::endl;
-    return true;
+  }
-  /**
-    Returns the window handle of the render window.
-    At least the InputHandler uses this to create the OIS::InputManager
-    @return The window handle of the render window
-  */
-  size_t GraphicsEngine::getWindowHandle()
+  {
-    if (this->renderWindow_)
+    {
-      size_t windowHnd = 0;
-      this->renderWindow_->getCustomAttribute("WINDOW", &windowHnd);
-      return windowHnd;
+    }
-    else
-      return 0;
+  }
-  /**
-    Get the width of the current render window
-    @return The width of the current render window
-  */
-  int GraphicsEngine::getWindowWidth() const
+  {
-    if (this->renderWindow_)
-      return this->renderWindow_->getWidth();
-    else
-      return 0;
+  }
-  /**
-    Get the height of the current render window
-    @return The height of the current render window
-  */
-  int GraphicsEngine::getWindowHeight() const
+  {
-    if (this->renderWindow_)
-      return this->renderWindow_->getHeight();
-    else
-      return 0;
+  }
-  /**
-    @brief Returns the window aspect ratio height/width.
-    @return The ratio
-  */
-  float GraphicsEngine::getWindowAspectRatio() const
+  {
-    if (this->renderWindow_)
-        return (float)this->renderWindow_->getHeight() / (float)this->renderWindow_->getWidth();
-    else
-        return 1.0f;
+  }
-  /**
-    @brief Method called by the LogListener interface from Ogre.
-    We use it to capture Ogre log messages and handle it ourselves.
-    @param message The message to be logged
-    @param lml The message level the log is using
-    @param maskDebug If we are printing to the console or not
-    @param logName the name of this log (so you can have several listeners
-                   for different logs, and identify them)
-  */
-  void GraphicsEngine::messageLogged(const std::string& message,
-    Ogre::LogMessageLevel lml, bool maskDebug, const std::string &logName)
+  {
-    int orxonoxLevel;
-    switch (lml)
+    {
-      case Ogre::LML_TRIVIAL:
-        orxonoxLevel = this->ogreLogLevelTrivial_;
-        break;
-      case Ogre::LML_NORMAL:
-        orxonoxLevel = this->ogreLogLevelNormal_;
-        break;
-      case Ogre::LML_CRITICAL:
-        orxonoxLevel = this->ogreLogLevelCritical_;
-        break;
-      default:
-        orxonoxLevel = 0;
+    }
-    OutputHandler::getOutStream().setOutputLevel(orxonoxLevel)
-        << "Ogre: " << message << std::endl;
+  }
-  /**
-  * Window has moved.
-  * @param rw The render window it occured in
-  */
-  void GraphicsEngine::windowMoved(Ogre::RenderWindow *rw)
+  {
-    for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
-      it->windowMoved();
+  }
-  /**
-  * Window has resized.
-  * @param rw The render window it occured in
-  * @note GraphicsEngine has a render window stored itself. This is the same
-  *       as rw. But we have to be careful when using multiple render windows!
-  */
-  void GraphicsEngine::windowResized(Ogre::RenderWindow *rw)
+  {
-    for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
-      it->windowResized(this->renderWindow_->getWidth(), this->renderWindow_->getHeight());
+  }
-  /**
-  * Window has changed Focus.
-  * @param rw The render window it occured in
-  */
-  void GraphicsEngine::windowFocusChanged(Ogre::RenderWindow *rw)
+  {
-    for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
-      it->windowFocusChanged();
+  }
-  /**
-  * Window was closed.
-  * @param rw The render window it occured in
-  */
-  void GraphicsEngine::windowClosed(Ogre::RenderWindow *rw)
+  {
-    // using CommandExecutor in order to avoid depending on Orxonox.h.
-    CommandExecutor::execute("exit", false);
+  }
+}

code/trunk/src/orxonox/GraphicsEngine.h

-                      r1747
+                      r1755
  *   Author:
  *      Reto Grieder
+ *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
  *   Co-authors:
  *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007, Felix Schulthess
+ *      Felix Schulthess
+ *
  */
 …
 #include <OgrePrerequisites.h>
-#include <OgreLog.h>
-#include <OgreRenderWindow.h>
-#include <OgreWindowEventUtilities.h>
 #include "core/OrxonoxClass.h"
 namespace orxonox
 …
     @brief Graphics engine manager class
     */
     class _OrxonoxExport GraphicsEngine : public Ogre::WindowEventListener, public Ogre::LogListener, public OrxonoxClass
+    class _OrxonoxExport GraphicsEngine : public OrxonoxClass
+    {
+        public:
+            void setConfigValues();
+            void detailLevelParticleChanged();
+            bool setup();
+            bool declareRessourceLocations();
+            bool loadRenderer();
+            bool initialiseResources();
+            bool createNewScene();
+        // HACK: temporary means
+        friend class GSGraphics;
+            void destroy();
+    public:
+        GraphicsEngine();
+        ~GraphicsEngine();
+            Ogre::SceneManager* getSceneManager() { return scene_; }
+        void setConfigValues();
+        void detailLevelParticleChanged();
+            // several window properties
+            Ogre::RenderWindow* getRenderWindow() { return this->renderWindow_; }
+            size_t getWindowHandle();
+            int getWindowWidth() const;
+            int getWindowHeight() const;
+            float getWindowAspectRatio() const;
+            float getAverageFramesPerSecond() const { return this->avgFramesPerSecond_; }
+            float getAverageTickTime() const { return this->avgTickTime_; }
+            void setAverageTickTime(float tickTime) { this->avgTickTime_ = tickTime; }
+            void setAverageFramesPerSecond(float fps) { this->avgFramesPerSecond_ = fps; }
+        void setLevelSceneManager(Ogre::SceneManager* sceneMgr) { this->levelSceneManager_ = sceneMgr; }
+        Ogre::SceneManager* getLevelSceneManager() { return levelSceneManager_; }
             void setWindowActivity(bool activity)
             { if (this->renderWindow_) this->renderWindow_->setActive(activity); }
+        Ogre::Viewport* getViewport() { return this->viewport_; }
+        Ogre::Root*     getOgreRoot() { return this->root_; }
+            void windowMoved       (Ogre::RenderWindow* rw);
+            void windowResized     (Ogre::RenderWindow* rw);
+            void windowFocusChanged(Ogre::RenderWindow* rw);
+            void windowClosed      (Ogre::RenderWindow* rw);
+        // several window properties
+        int getWindowWidth() const;
+        int getWindowHeight() const;
+        float getWindowAspectRatio() const;
+        float getAverageFramesPerSecond() const   { return this->avgFramesPerSecond_; }
+        float getAverageTickTime() const          { return this->avgTickTime_; }
+        void setAverageTickTime(float tickTime)   { this->avgTickTime_ = tickTime; }
+        void setAverageFramesPerSecond(float fps) { this->avgFramesPerSecond_ = fps; }
             inline unsigned int getDetailLevelParticle() const
               { return this->detailLevelParticle_; }
+        inline unsigned int getDetailLevelParticle() const
+        { return this->detailLevelParticle_; }
             static GraphicsEngine& getSingleton();
             static GraphicsEngine* getSingletonPtr() { return &getSingleton(); }
+        static GraphicsEngine& getInstance();
+        static GraphicsEngine* getInstancePtr() { return singletonRef_s; }
+    private:
+        // don't mess with singletons
+        GraphicsEngine(GraphicsEngine&);
+        private:
+            // don't mess with singletons
+            GraphicsEngine();
+            ~GraphicsEngine();
+            GraphicsEngine(GraphicsEngine&) { }
+        Ogre::Root*         root_;                  //!< Ogre's root
+        Ogre::RenderWindow* renderWindow_;          //!< the current render window
+        Ogre::SceneManager* levelSceneManager_;     //!< scene manager of the game
+        Ogre::Viewport*     viewport_;              //!< default full size viewport
             //! Method called by the LogListener from Ogre
             void messageLogged(const std::string&, Ogre::LogMessageLevel,
                              bool, const std::string&);
+        // stats
+        float               avgTickTime_;           //!< time in ms to tick() one frame
+        float               avgFramesPerSecond_;    //!< number of frames processed in one second
+            Ogre::Root*         root_;                  //!< Ogre's root
+            Ogre::SceneManager* scene_;                 //!< scene manager of the game
+            Ogre::RenderWindow* renderWindow_;          //!< the current render window
+            std::string         resourceFile_;          //!< resources file name
+            std::string         ogreConfigFile_;        //!< ogre config file name
+            std::string         ogrePluginsFile_;       //!< ogre plugins file name
+            std::string         ogreLogFile_;           //!< log file name for Ogre log messages
+            int                 ogreLogLevelTrivial_;   //!< Corresponding Orxonx debug level for LL_TRIVIAL
+            int                 ogreLogLevelNormal_;    //!< Corresponding Orxonx debug level for LL_NORMAL
+            int                 ogreLogLevelCritical_;  //!< Corresponding Orxonx debug level for LL_CRITICAL
+            unsigned int        detailLevelParticle_;   //!< Detail level of particle effects (0: off, 1: low, 2: normal, 3: high)
+            float               avgTickTime_;           //!< time in ms to tick() one frame
+            float               avgFramesPerSecond_;    //!< number of frames processed in one second
+        // config values
+        unsigned int        detailLevelParticle_;   //!< Detail level of particle effects (0: off, 1: low, 2: normal, 3: high)
+        static GraphicsEngine* singletonRef_s;      //!< Pointer to the Singleton
     };
+}

code/trunk/src/orxonox/Main.cc

-                      r1747
+                      r1755
  *   Author:
  *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
+ *      Reto Grieder
  *   Co-authors:
  *      ...
 …
 #include <exception>
+#include <cassert>
 #include "util/OrxonoxPlatform.h"
 #include "SignalHandler.h"
+#include "Orxonox.h"
+#include "util/Debug.h"
+#include "gamestates/GSRoot.h"
+#include "gamestates/GSGraphics.h"
+#include "gamestates/GSStandalone.h"
+#include "gamestates/GSServer.h"
+#include "gamestates/GSClient.h"
+#include "gamestates/GSDedicated.h"
+#include "gamestates/GSGUI.h"
+#include "gamestates/GSIOConsole.h"
 using namespace orxonox;
 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE
 #include <CoreFoundation/CoreFoundation.h>
 …
              std::string macBundlePath()
+{
   char path[1024];
   CFBundleRef mainBundle = CFBundleGetMainBundle();
   assert(mainBundle);
+    char path[1024];
+    CFBundleRef mainBundle = CFBundleGetMainBundle();
+    assert(mainBundle);
   CFURLRef mainBundleURL = CFBundleCopyBundleURL(mainBundle);
   assert(mainBundleURL);
+    CFURLRef mainBundleURL = CFBundleCopyBundleURL(mainBundle);
+    assert(mainBundleURL);
   CFStringRef cfStringRef = CFURLCopyFileSystemPath( mainBundleURL, kCFURLPOSIXPathStyle);
   assert(cfStringRef);
+    CFStringRef cfStringRef = CFURLCopyFileSystemPath( mainBundleURL, kCFURLPOSIXPathStyle);
+    assert(cfStringRef);
   CFStringGetCString(cfStringRef, path, 1024, kCFStringEncodingASCII);
+    CFStringGetCString(cfStringRef, path, 1024, kCFStringEncodingASCII);
   CFRelease(mainBundleURL);
   CFRelease(cfStringRef);
+    CFRelease(mainBundleURL);
+    CFRelease(cfStringRef);
   return std::string(path);
+    return std::string(path);
+}
 #endif
-#ifdef __cplusplus
-extern "C" {
-#endif
+int main(int argc, char **argv)
+//#ifdef __cplusplus
+//extern "C" {
+//#endif
+int main(int argc, char** argv)
+{
   //try {
+    // create a signal handler (only works for linux)
     SignalHandler::getInstance()->doCatch(argv[0], "orxonox.log");
-    Orxonox* orx = Orxonox::getSingleton();
+    bool res = false;
+#if ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE
+    res = orx->init(argc, argv, macBundlePath());
+#else
+    res = orx->init(argc, argv);
+#endif
+    GSRoot root;
+    GSGraphics graphics;
+    GSStandalone standalone;
+    GSServer server;
+    GSClient client;
+    GSDedicated dedicated;
+    GSGUI gui;
+    GSIOConsole ioConsole;
+    if (res)
+      orx->start();
+    orx->destroySingleton();
+  /*}
+  catch (std::exception &ex)
+  {
+    std::cerr << "Exception:\n";
+    std::cerr << ex.what() << "\n";
+    return 1;
+  }*/
+    root.addChild(&graphics);
+    graphics.addChild(&standalone);
+    graphics.addChild(&server);
+    graphics.addChild(&client);
+    graphics.addChild(&gui);
+  return 0;
+    root.addChild(&ioConsole);
+    root.addChild(&dedicated);
+    root.start(argc, argv);
+    return 0;
+}
 #ifdef __cplusplus
+}
 #endif
+//#ifdef __cplusplus
+//}
+//#endif

code/trunk/src/orxonox/OrxonoxPrereqs.h

-                      r1625
+                      r1755
     class GraphicsEngine;
     class Orxonox;
+    class Settings;
     class RadarViewable;
 …
     class Backlight;
     class Camera;
-    class Fighter;
     class Model;
     class NPC;
 …
     class OverlayGroup;
     class OverlayText;
+    //gui
+    class GUIManager;
+    // game states
+    class GSRoot;
+    class GSGraphics;
+    class GSIO;
+    class GSIOConsole;
+    class GSLevel;
+    class GSStandalone;
+    class GSServer;
+    class GSClient;
+    class GSGUI;
+}
 …
+}
+namespace CEGUI
+{
+    class LuaScriptModule;
+    class OgreCEGUIRenderer;
+    class OgreCEGUIResourceProvider;
+    class OgreCEGUITexture;
+}
+struct lua_State;
 #endif /* _OrxonoxPrereqs_H__ */

code/trunk/src/orxonox/OrxonoxStableHeaders.h

-                      r1747
+                      r1755
 /**
  @file  OrxonoxStableHeaders.h
  @brief Contains the bigger (or smaller) header files in order to precompile them with MSVC
+ @file
+ @brief Contains the frequently used header files of our own writing
  */
 …
 #include "util/OrxonoxPlatform.h"
 #if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
+#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC && !defined(ORXONOX_DISABLE_PCH)
 // including std headers here is useless since they're already precompiled
 …
 #  define WIN32_LEAN_AND_MEAN
 #endif
+// not including the entire Ogre.h doesn't exceed the default heap size for pch
+//#include <Ogre.h>
+#include <OgreBillboardSet.h>
+#include <OgreCamera.h>
+#include <OgreColourValue.h>
+#include <OgreConfigFile.h>
+#include <OgreEntity.h>
+#include <OgreException.h>
+#include <OgreFrameListener.h>
+#include <OgreLight.h>
+#include <OgreLog.h>
+#include <OgreLogManager.h>
+#include <OgreMath.h>
+#include <OgreMatrix3.h>
+#include <OgreMatrix4.h>
+#include <OgreMesh.h>
+#include <OgreOverlay.h>
+#include <OgreOverlayElement.h>
+#include <OgreOverlayManager.h>
+#include <OgreParticleEmitter.h>
+#include <OgreParticleSystem.h>
+#include <OgreQuaternion.h>
+#include <OgreResourceGroupManager.h>
+#include <OgreRenderWindow.h>
+#include <OgreRoot.h>
+#include <OgreSceneManager.h>
+#include <OgreSceneNode.h>
+#include <OgreString.h>
+#include <OgreStringConverter.h>
+#include <OgreTextureManager.h>
+#include <OgreTimer.h>
+#include <OgreVector2.h>
+#include <OgreVector3.h>
+#include <OgreVector3.h>
+#include <OgreViewport.h>
+#include <OgreWindowEventUtilities.h>
+#include <Ogre.h>
+#include <CEGUI.h>
+#include <boost/thread/recursive_mutex.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/condition.hpp>
+#include <boost/thread/thread.hpp>
-//-----------------------------------------------------------------------
-// ORXONOX HEADERS
-//-----------------------------------------------------------------------
-#include "ois/OIS.h"
-#include "cpptcl/CppTcl.h"
 #include "tinyxml/ticpp.h"
 #include "tinyxml/tinyxml.h"
+//----------- Our files ----------
+//--------------------------------
+// only include when not debugging so that we may find issues with missing headers quicker
+#if defined(NDEBUG)
 #include "util/Convert.h"
 …
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/CommandExecutor.h"
 #include "core/Executor.h"
 #include "core/XMLPort.h"
 …
 //#include "objects/WorldEntity.h"
+#endif /* Compiler MSVC */
+#endif /* ifdef NDEBUG */
+#endif /* ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC && !defined(ORXONOX_DISABLE_PCH) */
 #endif /* _OrxonoxStableHeaders_H__ */

code/trunk/src/orxonox/Radar.cc

-                      r1747
+                      r1755
 #include "OrxonoxStableHeaders.h"
 #include "Radar.h"
+#include <float.h>
+#include <cfloat>
+#include <cassert>
 #include "objects/WorldEntity.h"
 #include "objects/SpaceShip.h"

code/trunk/src/orxonox/RadarViewable.h

r1747	r1755
32	32	#include "OrxonoxPrereqs.h"
33	33	#include <string>
	34	#include <cassert>
34	35	#include "util/Math.h"
35	36	#include "util/Debug.h"

code/trunk/src/orxonox/Settings.cc

-                      r1747
+                      r1755
 /**
+    @file
+    @brief Implementation of the Settings class.
+@file
+@brief
+    Implementation of the Settings class.
 */
 …
 #include "Settings.h"
+#include "util/String.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
 …
 namespace orxonox
+{
+  /**
+    @brief Constructor: Registers the object and sets the config-values.
+  */
+  Settings::Settings()
+  {
+    RegisterRootObject(Settings);
+    setConfigValues();
+  }
+    Settings* Settings::singletonRef_s = 0;
+  Settings::~Settings()
+  {
+  }
+  /**
+    @brief Returns a unique instance of Core.
+    @return The instance
+  */
+  Settings& Settings::getSingleton()
+  {
+    static Settings instance;
+    return instance;
+  }
+  /**
+    @brief Function to collect the SetConfigValue-macro calls.
+  */
+  void Settings::setConfigValues()
+  {
+    SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.").callback(this, &Settings::dataPathChanged);
+  }
+  /**
+    @brief Callback function if the datapath has changed.
+  */
+  void Settings::dataPathChanged()
+  {
+    if (dataPath_ != "" && dataPath_[dataPath_.size() - 1] != '/')
+    /**
+    @brief
+        Constructor: Registers the object and sets the config-values.
+    */
+    Settings::Settings()
+        : bShowsGraphics_(false)
+        , bHasServer_(false)
+    {
+      ModifyConfigValue(dataPath_, set, dataPath_ + "/");
+        RegisterRootObject(Settings);
+        assert(singletonRef_s == 0);
+        singletonRef_s = this;
+        setConfigValues();
+    }
+    if (dataPath_ == "")
+    /**
+    @brief
+        Function to collect the SetConfigValue-macro calls.
+    */
+    void Settings::setConfigValues()
+    {
+      ModifyConfigValue(dataPath_, set, "/");
+      COUT(2) << "Warning: Data path set to \"/\", is that really correct?" << std::endl;
+        SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.").callback(this, &Settings::dataPathChanged);
+    }
+  }
+  /**
+    @brief Temporary sets the data path
+    @param path The new data path
+  */
+  void Settings::_tsetDataPath(const std::string& path)
+  {
+    ModifyConfigValue(dataPath_, tset, path);
+  }
+    /**
+    @brief
+        Callback function if the datapath has changed.
+    */
+    void Settings::dataPathChanged()
+    {
+        if (dataPath_ != "" && dataPath_[dataPath_.size() - 1] != '/')
+        {
+            ModifyConfigValue(dataPath_, set, dataPath_ + "/");
+        }
+  /*static*/ void Settings::tsetDataPath(const std::string& path)
+  {
+    getSingleton()._tsetDataPath(path);
+  }
+        if (dataPath_ == "")
+        {
+            ModifyConfigValue(dataPath_, set, "/");
+            COUT(2) << "Warning: Data path set to \"/\", is that really correct?" << std::endl;
+        }
+    }
+  /**
+    @brief Returns the relative path to the game data.
+    @return The path to the game data
+  */
+  /*static*/ const std::string& Settings::getDataPath()
+  {
+    return getSingleton().dataPath_;
+  }
+    /**
+    @brief
+        Temporary sets the data path
+    @param path
+        The new data path
+    */
+    void Settings::_tsetDataPath(const std::string& path)
+    {
+        ModifyConfigValue(dataPath_, tset, path);
+    }
+}

code/trunk/src/orxonox/Settings.h

-                      r1747
+                      r1755
 /**
     @file Core.h
     @brief Definition of the Settings class.
+    @brief Declaration of the Settings class.
     The static Settings class is only used to configure some variables
 …
 #include <string>
 #include "core/OrxonoxClass.h"
+#include "util/Debug.h"
+#include "util/MultiType.h"
+#include "util/Convert.h"
 namespace orxonox
+{
+  class _OrxonoxExport Settings : public OrxonoxClass
+  {
+    class _OrxonoxExport Settings : public OrxonoxClass
+    {
+        friend class ClassIdentifier<Settings>;
+        friend class GSRoot;
+        friend class GSGraphics;
+        friend class GSServer;
+        friend class GSDedicated;
     public:
+      void setConfigValues();
+      void dataPathChanged();
+        static const std::string& getDataPath()
+        { assert(singletonRef_s); return singletonRef_s->dataPath_; }
+        static void tsetDataPath(const std::string& path)
+        { assert(singletonRef_s); singletonRef_s->_tsetDataPath(path); }
       static const std::string& getDataPath();
       static void tsetDataPath(const std::string& path);
+        // an alternative to a global game mode variable
+        static bool showsGraphics() { assert(singletonRef_s); return singletonRef_s->bShowsGraphics_; }
+        static bool hasServer()     { assert(singletonRef_s); return singletonRef_s->bHasServer_; }
     private:
+      Settings();
+      Settings(const Settings& instance);
+      ~Settings();
+      static Settings& getSingleton();
+        // GSRoot has access to these
+        static void setShowsGraphics(bool val) { assert(singletonRef_s); singletonRef_s->bShowsGraphics_ = val; }
+        static void setHasServer    (bool val) { assert(singletonRef_s); singletonRef_s->bHasServer_     = val; }
+      void _tsetDataPath(const std::string& path);
+        Settings();
+        Settings(const Settings& instance);
+        ~Settings() { singletonRef_s = 0; }
+      std::string dataPath_;               //!< Path to the game data
+  };
+        static Settings& _getInstance() { assert(singletonRef_s); return *singletonRef_s; }
+        void _tsetDataPath(const std::string& path);
+        void dataPathChanged();
+        void setConfigValues();
+        bool bShowsGraphics_;                                  //!< global variable that tells whether to show graphics
+        bool bHasServer_;                                      //!< global variable that tells whether this is a server
+        std::string dataPath_;                                 //!< Path to the game data
+        static Settings* singletonRef_s;                       //!< Static pointer to the only instance.
+    };
+}

code/trunk/src/orxonox/SignalHandler.h

r1747	r1755
29	29	/**
30	30	@file SignalHandler.h
31		@brief De~~fini~~tion of the SignalHandler class.
	31	@brief Declaration of the SignalHandler class.
32	32	*/
33	33

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

-                      r1724
+                      r1755
         int serverPort = CommandLine::getArgument<int>("port")->getValue();
         std::string serverIP = CommandLine::getArgument<std::string>("ip")->getValue();
         this->client_ = network::Client::createSingleton(serverIP, serverPort);
+        this->client_ = new network::Client(serverIP, serverPort);
         if(!client_->establishConnection())
 …
         client_->closeConnection();
+        // TODO: destroy client
+        // destroy client
+        delete this->client_;
         GSLevel::leave();

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

-                      r1724
+                      r1755
         int serverPort = CommandLine::getArgument<int>("port")->getValue();
         this->server_ = network::Server::createSingleton(serverPort);
+        this->server_ = new network::Server(serverPort);
         // call the loader
 …
         FunctorMember01<GSDedicated, float>* functor = createFunctor(&GSDedicated::setTimeFactor);
         functor->setObject(this);
         CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor"));
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor")).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);;
+    }
 …
         this->server_->close();
         // TODO: destroy server
+        delete this->server_;
         Ogre::Root::getSingleton().destroySceneManager(this->sceneManager_);
 …
+    {
         // Call those objects that need the real time
         for (Iterator<TickableReal> it = ObjectList<TickableReal>::start(); it; ++it)
+        for (ObjectList<TickableReal>::iterator it = ObjectList<TickableReal>::begin(); it; ++it)
             it->tick(time.getDeltaTime());
         // Call the scene objects
         for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
+        for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
             it->tick(time.getDeltaTime() * this->timeFactor_);

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

r1724	r1755
40	40	#include <OgreWindowEventUtilities.h>
41	41
42		#include "~~core~~/Debug.h"
	42	#include "util/Debug.h"
43	43	#include "core/ConsoleCommand.h"
44	44	#include "core/ConfigValueIncludes.h"
…	…
308	308	void GSGraphics::windowMoved(Ogre::RenderWindow *rw)
309	309	{
310		for (~~Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start~~(); it; ++it)
	310	for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
311	311	it->windowMoved();
312	312	}
…	…
323	323	void GSGraphics::windowResized(Ogre::RenderWindow *rw)
324	324	{
325		for (~~Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start~~(); it; ++it)
	325	for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
326	326	it->windowResized(this->renderWindow_->getWidth(), this->renderWindow_->getHeight());
327	327	}
…	…
335	335	void GSGraphics::windowFocusChanged(Ogre::RenderWindow *rw)
336	336	{
337		for (~~Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start~~(); it; ++it)
	337	for (ObjectList<orxonox::WindowEventListener>::iterator it = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
338	338	it->windowFocusChanged();
339	339	}

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

-                      r1724
+                      r1755
         // reset game speed to normal
         timeFactor_ = 1.0f;
+        // TODO: insert slomo console command with
+        // .accessLevel(AccessLevel::Offline).defaultValue(0, 1.0).axisParamIndex(0).isAxisRelative(false);
+    }
 …
+    {
         // Call those objects that need the real time
         for (Iterator<TickableReal> it = ObjectList<TickableReal>::start(); it; ++it)
+        for (ObjectList<TickableReal>::iterator it = ObjectList<TickableReal>::begin(); it; ++it)
             it->tick(time.getDeltaTime());
         // Call the scene objects
         for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
+        for (ObjectList<Tickable>::iterator it = ObjectList<Tickable>::begin(); it; ++it)
             it->tick(time.getDeltaTime() * this->timeFactor_);
         for (Iterator<TimerBase> it = ObjectList<TimerBase>::start(); it; ++it)
+        for (ObjectList<TimerBase>::iterator it = ObjectList<TimerBase>::begin(); it; ++it)
             it->tick(time);
+    }
 …
         float change = factor / this->timeFactor_;
         this->timeFactor_ = factor;
         for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
+        for (ObjectList<ParticleInterface>::iterator it = ObjectList<ParticleInterface>::begin(); it; ++it)
             it->setSpeedFactor(it->getSpeedFactor() * change);
         for (Iterator<Backlight> it = ObjectList<Backlight>::begin(); it; ++it)
+        for (ObjectList<Backlight>::iterator it = ObjectList<Backlight>::begin(); it; ++it)
             it->setTimeFactor(timeFactor_);
+    }

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

-                      r1724
+                      r1755
 #include "core/ConsoleCommand.h"
 #include "core/CommandLine.h"
 #include "core/Debug.h"
+#include "util/Debug.h"
 #include "core/Exception.h"
 #include "core/TclBind.h"
 …
+    {
 #if ORXONOX_DEBUG_MODE == 1
         ConfigFileManager::getSingleton()->setFile(CFT_Settings, "orxonox_d.ini");
+        ConfigFileManager::getInstance()->setFile(CFT_Settings, "orxonox_d.ini");
 #else
         ConfigFileManager::getSingleton()->setFile(CFT_Settings, "orxonox.ini");
+        ConfigFileManager::getInstance()->setFile(CFT_Settings, "orxonox.ini");
 #endif

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

-                      r1724
+                      r1755
         int serverPort = CommandLine::getArgument<int>("port")->getValue();
+        this->server_ = network::Server::createSingleton(serverPort);
+        this->server_ = new network::Server(serverPort);
+        COUT(0) << "Loading scene in server mode" << std::endl;
         this->loadLevel();
 …
         FunctorMember<GSLevel>* functor = createFunctor(&GSLevel::setTimeFactor);
         functor->setObject(this);
         CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor"));
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor")).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);;
         // level is loaded: we can start capturing the input
 …
         this->server_->close();
         // TODO: destroy server
+        delete this->server_;
         GSLevel::leave();

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

r1724	r1755
53	53	FunctorMember<GSLevel>* functor = createFunctor(&GSLevel::setTimeFactor);
54	54	functor->setObject(this);
55		CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor"));
	55	CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(functor, "setTimeFactor")).accessLevel(AccessLevel::Offline).defaultValue(0, 1.0);;
56	56
57	57	// level is loaded: we can start capturing the input

code/trunk/src/orxonox/gui/GUIManager.cc

r1724	r1755
57	57	namespace orxonox
58	58	{
59		SetConsoleCommandShortcut(GUIManager, showGUI_s).~~setK~~eybindMode(KeybindMode::OnPress);
	59	SetConsoleCommandShortcut(GUIManager, showGUI_s).keybindMode(KeybindMode::OnPress);
60	60
61	61	GUIManager* GUIManager::singletonRef_s = 0;

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

-                      r1747
+                      r1755
 #include "core/XMLPort.h"
 #include "core/ConsoleCommand.h"
+#include "Settings.h"
 #include "GraphicsEngine.h"
 …
     bool Ambient::create()
+    {
+        GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(ambientLight_);
+        if (Settings::showsGraphics())
+            GraphicsEngine::getInstance().getLevelSceneManager()->setAmbientLight(ambientLight_);
         return Synchronisable::create();
+    }
 …
     void Ambient::setAmbientLight(const ColourValue& colour)
+    {
+        GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(colour);
+        ambientLight_=colour;
+        if (Settings::showsGraphics())
+            GraphicsEngine::getInstance().getLevelSceneManager()->setAmbientLight(colour);
+        ambientLight_ = colour;
+    }
     /**
+        @brief XML loading and saving.
+        @param xmlelement The XML-element
+        @param loading Loading (true) or saving (false)
+        @return The XML-element
+    @brief
+        XML loading and saving.
+    @param
+        xmlelement The XML-element
+    @param
+        loading Loading (true) or saving (false)
+    @return
+        The XML-element
     */
     void Ambient::XMLPort(Element& xmlelement, XMLPort::Mode mode)

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

-                      r1747
+                      r1755
 #include <OgreBillboard.h>
 #include <OgreRibbonTrail.h>
+#include <OgreSceneManager.h>
 #include "core/CoreIncludes.h"
 …
 #include "util/Math.h"
 #include "GraphicsEngine.h"
-#include "Orxonox.h"
 namespace orxonox
 …
         this->attachObject(this->billboard_.getBillboardSet());
         this->ribbonTrail_ = GraphicsEngine::getSingleton().getSceneManager()->createRibbonTrail(this->getName() + "RibbonTrail");
         this->ribbonTrailNode_ = GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName() + "RibbonTrailNode");
+        this->ribbonTrail_ = GraphicsEngine::getInstance().getLevelSceneManager()->createRibbonTrail(this->getName() + "RibbonTrail");
+        this->ribbonTrailNode_ = GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName() + "RibbonTrailNode");
         this->ribbonTrailNode_->attachObject(this->ribbonTrail_);
         this->ribbonTrail_->addNode(this->getNode());
 …
         this->ribbonTrail_->setMaterialName("Trail/backlighttrail");
+        this->setTimeFactor(Orxonox::getSingleton()->getTimeFactor());
+        //this->setTimeFactor(Orxonox::getInstance().getTimeFactor());
+        this->setTimeFactor(1.0f);
+    }
 …
+        {
             this->detachObject(this->billboard_.getBillboardSet());
             GraphicsEngine::getSingleton().getSceneManager()->destroySceneNode(this->getName() + "RibbonTrailNode");
             GraphicsEngine::getSingleton().getSceneManager()->destroyRibbonTrail(this->ribbonTrail_);
+            GraphicsEngine::getInstance().getLevelSceneManager()->destroySceneNode(this->getName() + "RibbonTrailNode");
+            GraphicsEngine::getInstance().getLevelSceneManager()->destroyRibbonTrail(this->ribbonTrail_);
+        }
+    }

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

r1747	r1755
52	52	{
53	53	this->bHasFocus_ = false;
54		this->cameraNode_ = GraphicsEngine::get~~Singleton().get~~SceneManager()->getRootSceneNode()->createChildSceneNode(node->getName() + "Camera");
	54	this->cameraNode_ = GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(node->getName() + "Camera");
55	55	if( node != NULL )
56	56	this->setPositionNode(node);
…	…
60	60	{
61	61	CameraHandler::getInstance()->releaseFocus(this);
62		GraphicsEngine::get~~Singleton().get~~SceneManager()->getRootSceneNode()->removeAndDestroyChild(cameraNode_->getName());
	62	GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->removeAndDestroyChild(cameraNode_->getName());
63	63	}
64	64

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

-                      r1505
+                      r1755
   CameraHandler::CameraHandler()
+  {
+    this->cam_ = GraphicsEngine::getSingleton().getSceneManager()->createCamera("Cam");
+    GraphicsEngine::getSingleton().getRenderWindow()->addViewport(this->cam_);
+    this->cam_ = GraphicsEngine::getInstance().getLevelSceneManager()->createCamera("Cam");
+    GraphicsEngine::getInstance().getViewport()->setCamera(this->cam_);
+    //GraphicsEngine::getInstance().getRenderWindow()->addViewport(this->cam_, 2, 0.4, 0.4, 0.2, 0.2);
     /*this->activeCamera_ = *ObjectList<Camera>::begin();
     this->activeCamera_->cam_ = this->cam_;*/

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

-                      r1608
+                      r1755
 #include "ParticleSpawner.h"
+#include <OgreSceneManager.h>
 #include "core/CoreIncludes.h"
 #include "core/Executor.h"
 …
         this->setPosition(this->getNode()->getParent()->getPosition());
         this->getNode()->getParent()->removeChild(this->getNode());
         GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->addChild(this->getNode());
+        GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->addChild(this->getNode());
         if (this->particle_)
             this->particle_->setEnabled(false);

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

r1747	r1755
39	39	#include "core/XMLPort.h"
40	40	#include "util/Debug.h"
	41	#include "Settings.h"
41	42
42	43	namespace orxonox
…	…
56	57	void Skybox::setSkybox(const std::string& skyboxname)
57	58	{
58		GraphicsEngine::getSingleton().getSceneManager()->setSkyBox(true, skyboxname);
	59	if (Settings::showsGraphics())
	60	GraphicsEngine::getInstance().getLevelSceneManager()->setSkyBox(true, skyboxname);
59	61	}
60	62
…	…
87	89	{
88	90	SUPER(Skybox, changedVisibility);
89		GraphicsEngine::getSingleton().getSceneManager()->setSkyBox(this->isVisible(), this->skyboxSrc_);
	91	if (Settings::showsGraphics())
	92	GraphicsEngine::getInstance().getLevelSceneManager()->setSkyBox(this->isVisible(), this->skyboxSrc_);
90	93	}
91	94	}

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

-                      r1751
+                      r1755
 #include "CameraHandler.h"
 #include "ParticleSpawner.h"
+#include "Settings.h"
 #include "RotatingProjectile.h"
 #include "ParticleProjectile.h"
 …
+      }
       assert(0);
+      return 0;
+    }
 …
     void SpaceShip::init()
+    {
+        // START CREATING THRUSTERS
+        this->tt1_ = new ParticleInterface("Orxonox/thruster1", LODParticle::low);
+        this->tt1_->createNewEmitter();
+        this->tt1_->getAllEmitters()->setDirection(-this->getInitialDir());
+        this->tt1_->getEmitter(0)->setPosition(Vector3(-15, 20, -1));
+        this->tt1_->getEmitter(1)->setPosition(Vector3(-15, -20, -1));
+        this->tt1_->setSpeedFactor(3.0);
+        Ogre::SceneNode* node2a = this->getNode()->createChildSceneNode(this->getName() + "particle2a");
+        node2a->setInheritScale(false);
+        node2a->setScale(1, 1, 1);
+        tt1_->addToSceneNode(node2a);
+        this->tt2_ = new ParticleInterface("Orxonox/thruster2", LODParticle::normal);
+        this->tt2_->createNewEmitter();
+        this->tt2_->getAllEmitters()->setDirection(Vector3(-1, 0, 0));
+        this->tt2_->getEmitter(0)->setPosition(Vector3(-30, 40, -2));
+        this->tt2_->getEmitter(1)->setPosition(Vector3(-30, -40, -2));
+        Ogre::SceneNode* node2b = this->getNode()->createChildSceneNode(this->getName() + "particle2b");
+        node2b->setInheritScale(false);
+        node2b->setScale(0.5, 0.5, 0.5);
+        tt2_->addToSceneNode(node2b);
+        this->leftThrusterFlare_.setBillboardSet("Flares/ThrusterFlare1", Vector3(-7.5, -10, -0.5));
+        this->rightThrusterFlare_.setBillboardSet("Flares/ThrusterFlare1", Vector3(-7.5, 10, -0.5));
+        Ogre::SceneNode* node2c = this->getNode()->createChildSceneNode(this->getName() + "particle2c");
+        node2c->setInheritScale(false);
+        node2c->setScale(2, 2, 2);
+        node2c->attachObject(this->leftThrusterFlare_.getBillboardSet());
+        node2c->attachObject(this->rightThrusterFlare_.getBillboardSet());
+        // END CREATING THRUSTERS
+        // START CREATING BLINKING LIGHTS
+        this->redBillboard_.setBillboardSet("Examples/Flare", ColourValue(1.0, 0.0, 0.0), 1);
+        this->greenBillboard_.setBillboardSet("Examples/Flare", ColourValue(0.0, 1.0, 0.0), 1);
+        this->redNode_ = this->getNode()->createChildSceneNode(this->getName() + "red", Vector3(0.3, 4.0, -0.3));
+        this->redNode_->setInheritScale(false);
+        this->greenNode_ = this->getNode()->createChildSceneNode(this->getName() + "green", Vector3(0.3, -4.0, -0.3));
+        this->greenNode_->setInheritScale(false);
+        this->redNode_->attachObject(this->redBillboard_.getBillboardSet());
+        this->redNode_->setScale(0.3, 0.3, 0.3);
+        this->greenNode_->attachObject(this->greenBillboard_.getBillboardSet());
+        this->greenNode_->setScale(0.3, 0.3, 0.3);
+        // END CREATING BLINKING LIGHTS
+        // START CREATING ADDITIONAL EFFECTS
+        /*if(!network::Host::running() || network::Host::isServer()){
+          this->backlight_ = new Backlight(this->maxSpeed_, 0.8);
+          this->attachObject(this->backlight_);
+          this->backlight_->setPosition(-2.35, 0, 0.2);
+          this->backlight_->setColour(this->getProjectileColour());
+          this->smoke_ = new ParticleSpawner();
+          this->smoke_->setParticle("Orxonox/smoke5", LODParticle::normal, 0, 0, 3);
+          this->attachObject(this->smoke_);
+          this->fire_ = new ParticleSpawner();
+          this->fire_->setParticle("Orxonox/fire3", LODParticle::normal, 0, 0, 1);
+          this->attachObject(this->fire_);
+        }*/
+        // END CREATING ADDITIONAL EFFECTS
+        if (this->isExactlyA(Class(SpaceShip)))
+        {
+            // START of testing crosshair
+            this->crosshairNear_.setBillboardSet("Orxonox/Crosshair", ColourValue(1.0, 1.0, 0.0), 1);
+            this->crosshairFar_.setBillboardSet("Orxonox/Crosshair", ColourValue(1.0, 1.0, 0.0), 1);
+            this->chNearNode_ = this->getNode()->createChildSceneNode(this->getName() + "near", Vector3(50.0, 0.0, 0.0));
+            this->chNearNode_->setInheritScale(false);
+            this->chFarNode_ = this->getNode()->createChildSceneNode(this->getName() + "far", Vector3(200.0, 0.0, 0.0));
+            this->chFarNode_->setInheritScale(false);
+            this->chNearNode_->attachObject(this->crosshairNear_.getBillboardSet());
+            this->chNearNode_->setScale(0.2, 0.2, 0.2);
+            this->chFarNode_->attachObject(this->crosshairFar_.getBillboardSet());
+            this->chFarNode_->setScale(0.4, 0.4, 0.4);
+            // END of testing crosshair
+        if (Settings::showsGraphics())
+        {
+            // START CREATING THRUSTERS
+            this->tt1_ = new ParticleInterface("Orxonox/thruster1", LODParticle::low);
+            this->tt1_->createNewEmitter();
+            this->tt1_->getAllEmitters()->setDirection(-this->getInitialDir());
+            this->tt1_->getEmitter(0)->setPosition(Vector3(-15, 20, -1));
+            this->tt1_->getEmitter(1)->setPosition(Vector3(-15, -20, -1));
+            this->tt1_->setSpeedFactor(3.0);
+            Ogre::SceneNode* node2a = this->getNode()->createChildSceneNode(this->getName() + "particle2a");
+            node2a->setInheritScale(false);
+            node2a->setScale(1, 1, 1);
+            tt1_->addToSceneNode(node2a);
+            this->tt2_ = new ParticleInterface("Orxonox/thruster2", LODParticle::normal);
+            this->tt2_->createNewEmitter();
+            this->tt2_->getAllEmitters()->setDirection(Vector3(-1, 0, 0));
+            this->tt2_->getEmitter(0)->setPosition(Vector3(-30, 40, -2));
+            this->tt2_->getEmitter(1)->setPosition(Vector3(-30, -40, -2));
+            Ogre::SceneNode* node2b = this->getNode()->createChildSceneNode(this->getName() + "particle2b");
+            node2b->setInheritScale(false);
+            node2b->setScale(0.5, 0.5, 0.5);
+            tt2_->addToSceneNode(node2b);
+            this->leftThrusterFlare_.setBillboardSet("Flares/ThrusterFlare1", Vector3(-7.5, -10, -0.5));
+            this->rightThrusterFlare_.setBillboardSet("Flares/ThrusterFlare1", Vector3(-7.5, 10, -0.5));
+            Ogre::SceneNode* node2c = this->getNode()->createChildSceneNode(this->getName() + "particle2c");
+            node2c->setInheritScale(false);
+            node2c->setScale(2, 2, 2);
+            node2c->attachObject(this->leftThrusterFlare_.getBillboardSet());
+            node2c->attachObject(this->rightThrusterFlare_.getBillboardSet());
+            // END CREATING THRUSTERS
+            // START CREATING BLINKING LIGHTS
+            this->redBillboard_.setBillboardSet("Examples/Flare", ColourValue(1.0, 0.0, 0.0), 1);
+            this->greenBillboard_.setBillboardSet("Examples/Flare", ColourValue(0.0, 1.0, 0.0), 1);
+            this->redNode_ = this->getNode()->createChildSceneNode(this->getName() + "red", Vector3(0.3, 4.0, -0.3));
+            this->redNode_->setInheritScale(false);
+            this->greenNode_ = this->getNode()->createChildSceneNode(this->getName() + "green", Vector3(0.3, -4.0, -0.3));
+            this->greenNode_->setInheritScale(false);
+            this->redNode_->attachObject(this->redBillboard_.getBillboardSet());
+            this->redNode_->setScale(0.3, 0.3, 0.3);
+            this->greenNode_->attachObject(this->greenBillboard_.getBillboardSet());
+            this->greenNode_->setScale(0.3, 0.3, 0.3);
+            // END CREATING BLINKING LIGHTS
+            // START CREATING ADDITIONAL EFFECTS
+            /*this->backlight_ = new Backlight(this->maxSpeed_, 0.8);
+            this->attachObject(this->backlight_);
+            this->backlight_->setPosition(-2.35, 0, 0.2);
+            this->backlight_->setColour(this->getProjectileColour());
+            this->smoke_ = new ParticleSpawner();
+            this->smoke_->setParticle("Orxonox/smoke5", LODParticle::normal, 0, 0, 3);
+            this->attachObject(this->smoke_);
+            this->fire_ = new ParticleSpawner();
+            this->fire_->setParticle("Orxonox/fire3", LODParticle::normal, 0, 0, 1);
+            this->attachObject(this->fire_);
+            */
+            // END CREATING ADDITIONAL EFFECTS
+            if (this->isExactlyA(Class(SpaceShip)))
+            {
+                // START of testing crosshair
+                this->crosshairNear_.setBillboardSet("Orxonox/Crosshair", ColourValue(1.0, 1.0, 0.0), 1);
+                this->crosshairFar_.setBillboardSet("Orxonox/Crosshair", ColourValue(1.0, 1.0, 0.0), 1);
+                this->chNearNode_ = this->getNode()->createChildSceneNode(this->getName() + "near", Vector3(50.0, 0.0, 0.0));
+                this->chNearNode_->setInheritScale(false);
+                this->chFarNode_ = this->getNode()->createChildSceneNode(this->getName() + "far", Vector3(200.0, 0.0, 0.0));
+                this->chFarNode_->setInheritScale(false);
+                this->chNearNode_->attachObject(this->crosshairNear_.getBillboardSet());
+                this->chNearNode_->setScale(0.2, 0.2, 0.2);
+                this->chFarNode_->attachObject(this->crosshairFar_.getBillboardSet());
+                this->chFarNode_->setScale(0.4, 0.4, 0.4);
+                // END of testing crosshair
+            }
+        }
         // END of testing crosshair
 …
             this->cam_->tick(dt);
+        if (this->smoke_)
+            this->smoke_->setVisible(this->isVisible() && this->health_ < 40);
+        if (this->fire_)
+            this->fire_->setVisible(this->isVisible() && this->health_ < 20);
+        if (this->backlight_)
+        {   // (there's already fire ||                 we're to slow                 ||                  we're moving backwards                  )
+            if (this->health_ < 20   || this->getVelocity().squaredLength() < 150*150 || this->getVelocity().dotProduct(this->getInitialDir()) < 0)
+                this->backlight_->setActive(false);
+            else
+                this->backlight_->setActive(true);
+        }
+        if (this->redNode_ && this->greenNode_)
+        {
+            this->blinkTime_ += dt;
+            float redScale = 0.15 + 0.15 * sin(this->blinkTime_ * 10.0);
+            float greenScale = 0.15 - 0.15 * sin(this->blinkTime_ * 10.0);
+            this->redNode_->setScale(redScale, redScale, redScale);
+            this->greenNode_->setScale(greenScale, greenScale, greenScale);
+        if (Settings::showsGraphics())
+        {
+            if (this->smoke_)
+                this->smoke_->setVisible(this->isVisible() && this->health_ < 40);
+            if (this->fire_)
+                this->fire_->setVisible(this->isVisible() && this->health_ < 20);
+            if (this->backlight_)
+            {   // (there's already fire ||                 we're to slow                 ||                  we're moving backwards                  )
+                if (this->health_ < 20   || this->getVelocity().squaredLength() < 150*150 || this->getVelocity().dotProduct(this->getInitialDir()) < 0)
+                    this->backlight_->setActive(false);
+                else
+                    this->backlight_->setActive(true);
+            }
+            if (this->redNode_ && this->greenNode_)
+            {
+                this->blinkTime_ += dt;
+                float redScale = 0.15 + 0.15 * sin(this->blinkTime_ * 10.0);
+                float greenScale = 0.15 - 0.15 * sin(this->blinkTime_ * 10.0);
+                this->redNode_->setScale(redScale, redScale, redScale);
+                this->greenNode_->setScale(greenScale, greenScale, greenScale);
+            }
+        }

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

-                      r1747
+                      r1755
 #include "core/XMLPort.h"
 #include "tools/ParticleInterface.h"
+#include "Settings.h"
 #define ACTION_INTERVAL 1.0f
 …
             newenemy->XMLPort(xmlelement, XMLPort::LoadObject);
+            ParticleSpawner* spawneffect = new ParticleSpawner("Orxonox/fairytwirl", LODParticle::normal, 2.0, 0, 0, newenemy->getOrth());
+            spawneffect->setPosition(newenemy->getPosition() - newenemy->getOrth() * 50);
+            spawneffect->create();
+            if (Settings::showsGraphics())
+            {
+                ParticleSpawner* spawneffect = new ParticleSpawner("Orxonox/fairytwirl", LODParticle::normal, 2.0, 0, 0, newenemy->getOrth());
+                spawneffect->setPosition(newenemy->getPosition() - newenemy->getOrth() * 50);
+                spawneffect->create();
+            }
+        }
+    }
 …
     void SpaceShipAI::kill()
+    {
+        ParticleSpawner* explosion = new ParticleSpawner("Orxonox/BigExplosion1part1", LODParticle::low, 3.0);
+        explosion->setPosition(this->getPosition());
+        explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+        explosion->setScale(4);
+        explosion->create();
+        explosion = new ParticleSpawner("Orxonox/BigExplosion1part2", LODParticle::normal, 3.0);
+        explosion->setPosition(this->getPosition());
+        explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+        explosion->setScale(4);
+        explosion->create();
+        explosion = new ParticleSpawner("Orxonox/BigExplosion1part2", LODParticle::high, 3.0);
+        explosion->setPosition(this->getPosition());
+        explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+        explosion->setScale(4);
+        explosion->create();
+        Vector3 ringdirection = Vector3(rnd(), rnd(), rnd());
+        ringdirection.normalise();
+        explosion = new ParticleSpawner("Orxonox/BigExplosion1part3", LODParticle::normal, 3.0, 0.5, 0, ringdirection);
+        explosion->setPosition(this->getPosition());
+        explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+        explosion->setScale(4);
+        explosion->create();
+        explosion = new ParticleSpawner("Orxonox/BigExplosion1part3", LODParticle::high, 3.0, 0.5, 0, ringdirection);
+        explosion->setPosition(this->getPosition());
+        explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+        explosion->setScale(4);
+        explosion->create();
+        if (Settings::showsGraphics())
+        {
+            ParticleSpawner* explosion = new ParticleSpawner("Orxonox/BigExplosion1part1", LODParticle::low, 3.0);
+            explosion->setPosition(this->getPosition());
+            explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+            explosion->setScale(4);
+            explosion->create();
+            explosion = new ParticleSpawner("Orxonox/BigExplosion1part2", LODParticle::normal, 3.0);
+            explosion->setPosition(this->getPosition());
+            explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+            explosion->setScale(4);
+            explosion->create();
+            explosion = new ParticleSpawner("Orxonox/BigExplosion1part2", LODParticle::high, 3.0);
+            explosion->setPosition(this->getPosition());
+            explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+            explosion->setScale(4);
+            explosion->create();
+            Vector3 ringdirection = Vector3(rnd(), rnd(), rnd());
+            ringdirection.normalise();
+            explosion = new ParticleSpawner("Orxonox/BigExplosion1part3", LODParticle::normal, 3.0, 0.5, 0, ringdirection);
+            explosion->setPosition(this->getPosition());
+            explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+            explosion->setScale(4);
+            explosion->create();
+            explosion = new ParticleSpawner("Orxonox/BigExplosion1part3", LODParticle::high, 3.0, 0.5, 0, ringdirection);
+            explosion->setPosition(this->getPosition());
+            explosion->getParticleInterface()->setKeepParticlesInLocalSpace(true);
+            explosion->setScale(4);
+            explosion->create();
+        }
         delete this;

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

r1747	r1755
29	29	/*!
30	30	@file Tickable.h
31		@brief De~~fini~~tion of the Tickable interface.
	31	@brief Declaration of the Tickable interface.
32	32
33	33	The Tickable interface provides a tick(dt) function, that gets called every frame.

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

r1747	r1755
32	32	#include <string>
33	33	#include <sstream>
	34	#include <OgreSceneManager.h>
34	35
35	36	#include "tinyxml/tinyxml.h"
…	…
49	50	RegisterObject(WorldEntity);
50	51
51		if (GraphicsEngine::get~~Singleton().get~~SceneManager())
	52	if (GraphicsEngine::getInstance().getLevelSceneManager())
52	53	{
53	54	std::ostringstream name;
54	55	name << (WorldEntity::worldEntityCounter_s++);
55	56	this->setName("WorldEntity" + name.str());
56		this->node_ = GraphicsEngine::get~~Singleton().get~~SceneManager()->getRootSceneNode()->createChildSceneNode(this->getName());
	57	this->node_ = GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName());
57	58
58	59	registerAllVariables();
…	…
77	78	{
78	79	this->getNode()->removeAndDestroyAllChildren();
79		GraphicsEngine::get~~Singleton().get~~SceneManager()->destroySceneNode(this->getName());
	80	GraphicsEngine::getInstance().getLevelSceneManager()->destroySceneNode(this->getName());
80	81	}
81	82	}
…	…
177	178	void WorldEntity::attachObject(const WorldEntity& obj) const
178	179	{
179		GraphicsEngine::get~~Singleton().get~~SceneManager()->getRootSceneNode()->removeChild(obj.getNode());
	180	GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->removeChild(obj.getNode());
180	181	this->getNode()->addChild(obj.getNode());
181	182	}
…	…
183	184	void WorldEntity::attachObject(WorldEntity* obj) const
184	185	{
185		GraphicsEngine::get~~Singleton().get~~SceneManager()->getRootSceneNode()->removeChild(obj->getNode());
	186	GraphicsEngine::getInstance().getLevelSceneManager()->getRootSceneNode()->removeChild(obj->getNode());
186	187	this->getNode()->addChild(obj->getNode());
187	188	}

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

-                      r1747
+                      r1755
 #include "OrxonoxPrereqs.h"
+#include <OgrePrerequisites.h>
-#include <OgreSceneManager.h>
 #include <OgreSceneNode.h>
 #include "util/Math.h"
 #include "util/XMLIncludes.h"

code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc

-                      r1747
+                      r1755
             // We'll have to get the aspect ratio manually for the first time. Afterwards windowResized() gets
             // called automatically by the GraphicsEngine.
             this->windowResized(GraphicsEngine::getSingleton().getWindowWidth(),
                 GraphicsEngine::getSingleton().getWindowHeight());
+            this->windowResized(GraphicsEngine::getInstance().getWindowWidth(),
+                GraphicsEngine::getInstance().getWindowHeight());
             this->changedVisibility();

code/trunk/src/orxonox/overlays/console/InGameConsole.cc

-                      r1747
+                      r1755
 #include "core/ConsoleCommand.h"
 #include "core/input/InputManager.h"
+#include "core/input/SimpleInputState.h"
+#include "core/input/InputBuffer.h"
 #include "GraphicsEngine.h"
 …
     SetConsoleCommand(InGameConsole, closeConsole, true);
+    InGameConsole* InGameConsole::singletonRef_s = 0;
     /**
         @brief Constructor: Creates and initializes the InGameConsole.
     */
+    InGameConsole::InGameConsole() :
+        consoleOverlay_(0), consoleOverlayContainer_(0),
+        consoleOverlayNoise_(0), consoleOverlayCursor_(0), consoleOverlayBorder_(0),
+        consoleOverlayTextAreas_(0)
+    InGameConsole::InGameConsole()
+        : consoleOverlay_(0)
+        , consoleOverlayContainer_(0)
+        , consoleOverlayNoise_(0)
+        , consoleOverlayCursor_(0)
+        , consoleOverlayBorder_(0)
+        , consoleOverlayTextAreas_(0)
+    {
         RegisterObject(InGameConsole);
+        assert(singletonRef_s == 0);
+        singletonRef_s = this;
         this->bActive_ = false;
 …
     InGameConsole::~InGameConsole(void)
+    {
+        this->destroy();
+    }
+    /**
+        @brief Returns a reference to the only existing instance of InGameConsole.
+    */
+    InGameConsole& InGameConsole::getInstance()
+    {
+        static InGameConsole instance;
+        return instance;
+    }
+    /**
+        @brief Sets the config values, describing the size of the console.
+    */
+    void InGameConsole::setConfigValues()
+    {
+        SetConfigValue(relativeWidth, 0.8);
+        SetConfigValue(relativeHeight, 0.4);
+        SetConfigValue(blinkTime, 0.5);
+        SetConfigValue(scrollSpeed_, 3.0f);
+        SetConfigValue(noiseSize_, 1.0f);
+        SetConfigValue(cursorSymbol_, '|');
+    }
+    /**
+        @brief Initializes the InGameConsole.
+    */
+    void InGameConsole::initialise()
+    {
+        // create overlay and elements
+        Ogre::OverlayManager* ovMan = Ogre::OverlayManager::getSingletonPtr();
+        // create actual overlay
+        this->consoleOverlay_ = ovMan->create("InGameConsoleConsole");
+        // create a container
+        this->consoleOverlayContainer_ = static_cast<Ogre::OverlayContainer*>(ovMan->createOverlayElement("Panel", "InGameConsoleContainer"));
+        this->consoleOverlayContainer_->setMetricsMode(Ogre::GMM_RELATIVE);
+        this->consoleOverlayContainer_->setPosition((1 - this->relativeWidth) / 2, 0);
+        this->consoleOverlayContainer_->setDimensions(this->relativeWidth, this->relativeHeight);
+        this->consoleOverlay_->add2D(this->consoleOverlayContainer_);
+        // create BorderPanel
+        this->consoleOverlayBorder_ = static_cast<Ogre::BorderPanelOverlayElement*>(ovMan->createOverlayElement("BorderPanel", "InGameConsoleBorderPanel"));
+        this->consoleOverlayBorder_->setMetricsMode(Ogre::GMM_PIXELS);
+        this->consoleOverlayBorder_->setMaterialName("ConsoleCenter");
+        this->consoleOverlayBorder_->setBorderSize(16, 16, 0, 16);
+        this->consoleOverlayBorder_->setBorderMaterialName("ConsoleBorder");
+        this->consoleOverlayBorder_->setLeftBorderUV(0.0, 0.49, 0.5, 0.51);
+        this->consoleOverlayBorder_->setRightBorderUV(0.5, 0.49, 1.0, 0.5);
+        this->consoleOverlayBorder_->setBottomBorderUV(0.49, 0.5, 0.51, 1.0);
+        this->consoleOverlayBorder_->setBottomLeftBorderUV(0.0, 0.5, 0.5, 1.0);
+        this->consoleOverlayBorder_->setBottomRightBorderUV(0.5, 0.5, 1.0, 1.0);
+        this->consoleOverlayContainer_->addChild(this->consoleOverlayBorder_);
+        // create a new font to match the requested size exactly
+        Ogre::FontPtr font = static_cast<Ogre::FontPtr>
+            (Ogre::FontManager::getSingleton().create("MonofurConsole", "General"));
+        font->setType(Ogre::FT_TRUETYPE);
+        font->setSource("Monofur.ttf");
+        font->setTrueTypeSize(18);
+        // reto: I don't know why, but setting the resolution twice as high makes the font look a lot clearer
+        font->setTrueTypeResolution(192);
+        font->addCodePointRange(Ogre::Font::CodePointRange(33, 126));
+        font->addCodePointRange(Ogre::Font::CodePointRange(161, 255));
+        // create the text lines
+        this->consoleOverlayTextAreas_ = new Ogre::TextAreaOverlayElement*[LINES];
+        for (int i = 0; i < LINES; i++)
+        {
+            this->consoleOverlayTextAreas_[i] = static_cast<Ogre::TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "InGameConsoleTextArea" + convertToString(i)));
+            this->consoleOverlayTextAreas_[i]->setMetricsMode(Ogre::GMM_PIXELS);
+            this->consoleOverlayTextAreas_[i]->setFontName("MonofurConsole");
+            this->consoleOverlayTextAreas_[i]->setCharHeight(18);
+            this->consoleOverlayTextAreas_[i]->setParameter("colour_top", "0.21 0.69 0.21");
+            this->consoleOverlayTextAreas_[i]->setLeft(8);
+            this->consoleOverlayTextAreas_[i]->setCaption("");
+            this->consoleOverlayContainer_->addChild(this->consoleOverlayTextAreas_[i]);
+        }
+        // create cursor (also a text area overlay element)
+        this->consoleOverlayCursor_ = static_cast<Ogre::TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "InGameConsoleCursor"));
+        this->consoleOverlayCursor_->setMetricsMode(Ogre::GMM_PIXELS);
+        this->consoleOverlayCursor_->setFontName("MonofurConsole");
+        this->consoleOverlayCursor_->setCharHeight(18);
+        this->consoleOverlayCursor_->setParameter("colour_top", "0.21 0.69 0.21");
+        this->consoleOverlayCursor_->setLeft(7);
+        this->consoleOverlayCursor_->setCaption(std::string(this->cursorSymbol_, 1));
+        this->consoleOverlayContainer_->addChild(this->consoleOverlayCursor_);
+        // create noise
+        this->consoleOverlayNoise_ = static_cast<Ogre::PanelOverlayElement*>(ovMan->createOverlayElement("Panel", "InGameConsoleNoise"));
+        this->consoleOverlayNoise_->setMetricsMode(Ogre::GMM_PIXELS);
+        this->consoleOverlayNoise_->setPosition(5,0);
+        this->consoleOverlayNoise_->setMaterialName("ConsoleNoiseSmall");
+        // comment following line to disable noise
+        this->consoleOverlayContainer_->addChild(this->consoleOverlayNoise_);
+        this->windowResized(GraphicsEngine::getSingleton().getWindowWidth(), GraphicsEngine::getSingleton().getWindowHeight());
+        // move overlay "above" the top edge of the screen
+        // we take -1.2 because the border makes the panel bigger
+        this->consoleOverlayContainer_->setTop(-1.2 * this->relativeHeight);
+        Shell::getInstance().addOutputLevel(true);
+        COUT(4) << "Info: InGameConsole initialized" << std::endl;
+    }
+    /**
+        @brief Destroys all the elements if necessary.
+    */
+    void InGameConsole::destroy()
+    {
+        this->deactivate();
+        // destroy the input state previously created (InputBuffer gets destroyed by the Shell)
+        InputManager::getInstance().requestDestroyState("console");
         Ogre::OverlayManager* ovMan = Ogre::OverlayManager::getSingletonPtr();
         if (ovMan)
 …
             this->consoleOverlayTextAreas_ = 0;
+        }
+        singletonRef_s = 0;
+    }
+    /**
+        @brief Sets the config values, describing the size of the console.
+    */
+    void InGameConsole::setConfigValues()
+    {
+        SetConfigValue(relativeWidth, 0.8);
+        SetConfigValue(relativeHeight, 0.4);
+        SetConfigValue(blinkTime, 0.5);
+        SetConfigValue(scrollSpeed_, 3.0f);
+        SetConfigValue(noiseSize_, 1.0f);
+        SetConfigValue(cursorSymbol_, '|');
+    }
+    /**
+        @brief Initializes the InGameConsole.
+    */
+    void InGameConsole::initialise()
+    {
+        // create the corresponding input state
+        InputManager::getInstance().createInputState<SimpleInputState>("console", 40)
+            ->setKeyHandler(Shell::getInstance().getInputBuffer());
+        // create overlay and elements
+        Ogre::OverlayManager* ovMan = Ogre::OverlayManager::getSingletonPtr();
+        // create actual overlay
+        this->consoleOverlay_ = ovMan->create("InGameConsoleConsole");
+        // create a container
+        this->consoleOverlayContainer_ = static_cast<Ogre::OverlayContainer*>(ovMan->createOverlayElement("Panel", "InGameConsoleContainer"));
+        this->consoleOverlayContainer_->setMetricsMode(Ogre::GMM_RELATIVE);
+        this->consoleOverlayContainer_->setPosition((1 - this->relativeWidth) / 2, 0);
+        this->consoleOverlayContainer_->setDimensions(this->relativeWidth, this->relativeHeight);
+        this->consoleOverlay_->add2D(this->consoleOverlayContainer_);
+        // create BorderPanel
+        this->consoleOverlayBorder_ = static_cast<Ogre::BorderPanelOverlayElement*>(ovMan->createOverlayElement("BorderPanel", "InGameConsoleBorderPanel"));
+        this->consoleOverlayBorder_->setMetricsMode(Ogre::GMM_PIXELS);
+        this->consoleOverlayBorder_->setMaterialName("ConsoleCenter");
+        this->consoleOverlayBorder_->setBorderSize(16, 16, 0, 16);
+        this->consoleOverlayBorder_->setBorderMaterialName("ConsoleBorder");
+        this->consoleOverlayBorder_->setLeftBorderUV(0.0, 0.49, 0.5, 0.51);
+        this->consoleOverlayBorder_->setRightBorderUV(0.5, 0.49, 1.0, 0.5);
+        this->consoleOverlayBorder_->setBottomBorderUV(0.49, 0.5, 0.51, 1.0);
+        this->consoleOverlayBorder_->setBottomLeftBorderUV(0.0, 0.5, 0.5, 1.0);
+        this->consoleOverlayBorder_->setBottomRightBorderUV(0.5, 0.5, 1.0, 1.0);
+        this->consoleOverlayContainer_->addChild(this->consoleOverlayBorder_);
+        // create a new font to match the requested size exactly
+        Ogre::FontPtr font = static_cast<Ogre::FontPtr>
+            (Ogre::FontManager::getSingleton().create("MonofurConsole", "General"));
+        font->setType(Ogre::FT_TRUETYPE);
+        font->setSource("Monofur.ttf");
+        font->setTrueTypeSize(18);
+        // reto: I don't know why, but setting the resolution twice as high makes the font look a lot clearer
+        font->setTrueTypeResolution(192);
+        font->addCodePointRange(Ogre::Font::CodePointRange(33, 126));
+        font->addCodePointRange(Ogre::Font::CodePointRange(161, 255));
+        // create the text lines
+        this->consoleOverlayTextAreas_ = new Ogre::TextAreaOverlayElement*[LINES];
+        for (int i = 0; i < LINES; i++)
+        {
+            this->consoleOverlayTextAreas_[i] = static_cast<Ogre::TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "InGameConsoleTextArea" + convertToString(i)));
+            this->consoleOverlayTextAreas_[i]->setMetricsMode(Ogre::GMM_PIXELS);
+            this->consoleOverlayTextAreas_[i]->setFontName("MonofurConsole");
+            this->consoleOverlayTextAreas_[i]->setCharHeight(18);
+            this->consoleOverlayTextAreas_[i]->setParameter("colour_top", "0.21 0.69 0.21");
+            this->consoleOverlayTextAreas_[i]->setLeft(8);
+            this->consoleOverlayTextAreas_[i]->setCaption("");
+            this->consoleOverlayContainer_->addChild(this->consoleOverlayTextAreas_[i]);
+        }
+        // create cursor (also a text area overlay element)
+        this->consoleOverlayCursor_ = static_cast<Ogre::TextAreaOverlayElement*>(ovMan->createOverlayElement("TextArea", "InGameConsoleCursor"));
+        this->consoleOverlayCursor_->setMetricsMode(Ogre::GMM_PIXELS);
+        this->consoleOverlayCursor_->setFontName("MonofurConsole");
+        this->consoleOverlayCursor_->setCharHeight(18);
+        this->consoleOverlayCursor_->setParameter("colour_top", "0.21 0.69 0.21");
+        this->consoleOverlayCursor_->setLeft(7);
+        this->consoleOverlayCursor_->setCaption(std::string(this->cursorSymbol_, 1));
+        this->consoleOverlayContainer_->addChild(this->consoleOverlayCursor_);
+        // create noise
+        this->consoleOverlayNoise_ = static_cast<Ogre::PanelOverlayElement*>(ovMan->createOverlayElement("Panel", "InGameConsoleNoise"));
+        this->consoleOverlayNoise_->setMetricsMode(Ogre::GMM_PIXELS);
+        this->consoleOverlayNoise_->setPosition(5,0);
+        this->consoleOverlayNoise_->setMaterialName("ConsoleNoiseSmall");
+        // comment following line to disable noise
+        this->consoleOverlayContainer_->addChild(this->consoleOverlayNoise_);
+        this->windowResized(GraphicsEngine::getInstance().getWindowWidth(), GraphicsEngine::getInstance().getWindowHeight());
+        // move overlay "above" the top edge of the screen
+        // we take -1.2 because the border makes the panel bigger
+        this->consoleOverlayContainer_->setTop(-1.2 * this->relativeHeight);
+        Shell::getInstance().addOutputLevel(true);
+        COUT(4) << "Info: InGameConsole initialized" << std::endl;
+    }
 …
                 if (output.size() > this->maxCharsPerLine_)
+                {
                     if (Shell::getInstance().getInputBuffer().getCursorPosition() < this->inputWindowStart_)
                         this->inputWindowStart_ = Shell::getInstance().getInputBuffer().getCursorPosition();
                     else if (Shell::getInstance().getInputBuffer().getCursorPosition() >= (this->inputWindowStart_ + this->maxCharsPerLine_ - 1))
                         this->inputWindowStart_ = Shell::getInstance().getInputBuffer().getCursorPosition() - this->maxCharsPerLine_ + 1;
+                    if (Shell::getInstance().getInputBuffer()->getCursorPosition() < this->inputWindowStart_)
+                        this->inputWindowStart_ = Shell::getInstance().getInputBuffer()->getCursorPosition();
+                    else if (Shell::getInstance().getInputBuffer()->getCursorPosition() >= (this->inputWindowStart_ + this->maxCharsPerLine_ - 1))
+                        this->inputWindowStart_ = Shell::getInstance().getInputBuffer()->getCursorPosition() - this->maxCharsPerLine_ + 1;
                     output = output.substr(this->inputWindowStart_, this->maxCharsPerLine_);
 …
+        {
             this->bActive_ = true;
             InputManager::setInputState(InputManager::IS_CONSOLE);
+            InputManager::getInstance().requestEnterState("console");
             Shell::getInstance().registerListener(this);
 …
+        {
             this->bActive_ = false;
             InputManager::setInputState(InputManager::IS_NORMAL);
+            InputManager::getInstance().requestLeaveState("console");
             Shell::getInstance().unregisterListener(this);

code/trunk/src/orxonox/overlays/console/InGameConsole.h

-                      r1747
+                      r1755
 #include "core/Shell.h"
 #include "objects/Tickable.h"
+#include "core/OrxonoxClass.h"
 #include "tools/WindowEventListener.h"
 …
 namespace orxonox
+{
     class _OrxonoxExport InGameConsole : public TickableReal, public ShellListener, public WindowEventListener
+    class _OrxonoxExport InGameConsole : virtual public OrxonoxClass, public ShellListener, public WindowEventListener
+    {
+        public: // functions
+            void initialise();
+            void destroy();
+            void setConfigValues();
+    public: // functions
+        InGameConsole();
+        ~InGameConsole();
+            virtual void tick(float dt);
+        void initialise();
+        void destroy();
+        void setConfigValues();
             static InGameConsole& getInstance();
+        virtual void tick(float dt);
             static void openConsole();
             static void closeConsole();
+        static InGameConsole& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
+        static InGameConsole* getInstancePtr() { return singletonRef_s; }
+        private: // functions
+            InGameConsole();
+            InGameConsole(const InGameConsole& other) {}
+            ~InGameConsole();
+        static void openConsole();
+        static void closeConsole();
             void activate();
             void deactivate();
+    private: // functions
+        InGameConsole(const InGameConsole& other) {}
+            void linesChanged();
+            void onlyLastLineChanged();
+            void lineAdded();
+            void inputChanged();
+            void cursorChanged();
+            void exit();
+        void activate();
+        void deactivate();
+            void shiftLines();
+            void colourLine(int colourcode, int index);
+            void setCursorPosition(unsigned int pos);
+            void print(const std::string& text, int index, bool alwaysShift = false);
+        void linesChanged();
+        void onlyLastLineChanged();
+        void lineAdded();
+        void inputChanged();
+        void cursorChanged();
+        void exit();
+            void windowResized(int newWidth, int newHeight);
+        void shiftLines();
+        void colourLine(int colourcode, int index);
+        void setCursorPosition(unsigned int pos);
+        void print(const std::string& text, int index, bool alwaysShift = false);
             static Ogre::UTFString convert2UTF(std::string s);
+        void windowResized(int newWidth, int newHeight);
+        private: // variables
+            bool bActive_;
+            int windowW_;
+            int windowH_;
+            int desiredTextWidth_;
+            unsigned int maxCharsPerLine_;
+            unsigned int numLinesShifted_;
+            int scroll_;
+            float cursor_;
+            unsigned int inputWindowStart_;
+            bool bShowCursor_;
+            std::string displayedText_;
+            Ogre::Overlay* consoleOverlay_;
+            Ogre::OverlayContainer* consoleOverlayContainer_;
+            Ogre::PanelOverlayElement* consoleOverlayNoise_;
+            Ogre::TextAreaOverlayElement* consoleOverlayCursor_;
+            Ogre::BorderPanelOverlayElement* consoleOverlayBorder_;
+            Ogre::TextAreaOverlayElement** consoleOverlayTextAreas_;
+        static Ogre::UTFString convert2UTF(std::string s);
+            // config values
+            float relativeWidth;
+            float relativeHeight;
+            float blinkTime;
+            float scrollSpeed_;
+            float noiseSize_;
+            char cursorSymbol_;
+    private: // variables
+        bool bActive_;
+        int windowW_;
+        int windowH_;
+        int desiredTextWidth_;
+        unsigned int maxCharsPerLine_;
+        unsigned int numLinesShifted_;
+        int scroll_;
+        float cursor_;
+        unsigned int inputWindowStart_;
+        bool bShowCursor_;
+        std::string displayedText_;
+        Ogre::Overlay* consoleOverlay_;
+        Ogre::OverlayContainer* consoleOverlayContainer_;
+        Ogre::PanelOverlayElement* consoleOverlayNoise_;
+        Ogre::TextAreaOverlayElement* consoleOverlayCursor_;
+        Ogre::BorderPanelOverlayElement* consoleOverlayBorder_;
+        Ogre::TextAreaOverlayElement** consoleOverlayTextAreas_;
+        // config values
+        float relativeWidth;
+        float relativeHeight;
+        float blinkTime;
+        float scrollSpeed_;
+        float noiseSize_;
+        char cursorSymbol_;
+        static InGameConsole* singletonRef_s;
     };
+}

code/trunk/src/orxonox/overlays/debug/DebugFPSText.cc

r1625	r1755
49	49	void DebugFPSText::tick(float dt)
50	50	{
51		float fps = GraphicsEngine::get~~Singleton~~().getAverageFramesPerSecond();
	51	float fps = GraphicsEngine::getInstance().getAverageFramesPerSecond();
52	52	this->text_->setCaption(this->getCaption() + convertToString(fps));
53	53	}

code/trunk/src/orxonox/overlays/debug/DebugRTRText.cc

r1625	r1755
49	49	void DebugRTRText::tick(float dt)
50	50	{
51		float rtr = GraphicsEngine::get~~Singleton~~().getAverageTickTime();
	51	float rtr = GraphicsEngine::getInstance().getAverageTickTime();
52	52	this->text_->setCaption(this->getCaption() + convertToString(rtr));
53	53	}

code/trunk/src/orxonox/overlays/hud/HUDSpeedBar.cc

r1626	r1755
54	54	float v = ship->getVelocity().length();
55	55	float value = v / ship->getMaxSpeed();
56		if (value != this->getValue())
	56	if (value != this->getValue())
57	57	this->setValue(value);
58	58	}

code/trunk/src/orxonox/tolua/tolua.pkg

r1505	r1755
	1	$cfile "../../src/orxonox/gui/GUIManager.h"

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

-                      r1602
+                      r1755
         std::ostringstream name;
         name << (BillboardSet::billboardSetCounter_s++);
         this->billboardSet_ = GraphicsEngine::getSingleton().getSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_ = GraphicsEngine::getInstance().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
         this->billboardSet_->createBillboard(Vector3::ZERO);
         this->billboardSet_->setMaterialName(file);
 …
         std::ostringstream name;
         name << (BillboardSet::billboardSetCounter_s++);
         this->billboardSet_ = GraphicsEngine::getSingleton().getSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_ = GraphicsEngine::getInstance().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
         this->billboardSet_->createBillboard(Vector3::ZERO, colour);
         this->billboardSet_->setMaterialName(file);
 …
         std::ostringstream name;
         name << (BillboardSet::billboardSetCounter_s++);
         this->billboardSet_ = GraphicsEngine::getSingleton().getSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_ = GraphicsEngine::getInstance().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
         this->billboardSet_->createBillboard(position);
         this->billboardSet_->setMaterialName(file);
 …
         std::ostringstream name;
         name << (BillboardSet::billboardSetCounter_s++);
         this->billboardSet_ = GraphicsEngine::getSingleton().getSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_ = GraphicsEngine::getInstance().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
         this->billboardSet_->createBillboard(position, colour);
         this->billboardSet_->setMaterialName(file);
 …
+    {
         if (this->billboardSet_)
             GraphicsEngine::getSingleton().getSceneManager()->destroyBillboardSet(this->billboardSet_);
+            GraphicsEngine::getInstance().getLevelSceneManager()->destroyBillboardSet(this->billboardSet_);
+    }
+}

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

r1505	r1755
49	49	std::ostringstream name;
50	50	name << (Light::lightCounter_s++);
51		this->light_ = GraphicsEngine::get~~Singleton().get~~SceneManager()->createLight("Light" + name.str());
	51	this->light_ = GraphicsEngine::getInstance().getLevelSceneManager()->createLight("Light" + name.str());
52	52	this->light_->setType(type);
53	53	this->light_->setDiffuseColour(diffuse);
…	…
58	58	{
59	59	if (this->light_)
60		GraphicsEngine::get~~Singleton().get~~SceneManager()->destroyLight(this->light_);
	60	GraphicsEngine::getInstance().getLevelSceneManager()->destroyLight(this->light_);
61	61	}
62	62	}

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

-                      r1505
+                      r1755
 #include <sstream>
 #include <OgreSceneManager.h>
 #include "GraphicsEngine.h"
+#include "Settings.h"
 namespace orxonox
 …
         std::ostringstream name;
         name << (Mesh::meshCounter_s++);
+        this->entity_ = GraphicsEngine::getSingleton().getSceneManager()->createEntity("Mesh" + name.str(), file);
+        if (Settings::showsGraphics())
+            this->entity_ = GraphicsEngine::getInstance().getLevelSceneManager()->createEntity("Mesh" + name.str(), file);
+    }
     Mesh::~Mesh()
+    {
         if (this->entity_)
             GraphicsEngine::getSingleton().getSceneManager()->destroyEntity(this->entity_);
+        if (this->entity_ && Settings::showsGraphics())
+            GraphicsEngine::getInstance().getLevelSceneManager()->destroyEntity(this->entity_);
+    }
+}

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

-                      r1563
+                      r1755
 #include "GraphicsEngine.h"
-#include "Orxonox.h"
 #include "core/CoreIncludes.h"
 #include "util/Convert.h"
 …
     this->bEnabled_ = true;
     this->detaillevel_ = (unsigned int)detaillevel;
+    this->particleSystem_ = GraphicsEngine::getSingleton().getSceneManager()->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
+    this->particleSystem_->setSpeedFactor(Orxonox::getSingleton()->getTimeFactor());
+    this->particleSystem_ = GraphicsEngine::getInstance().getLevelSceneManager()->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
+    //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor());
+    this->particleSystem_->setSpeedFactor(1.0f);
     if (GraphicsEngine::getSingleton().getDetailLevelParticle() < (unsigned int)this->detaillevel_)
+    if (GraphicsEngine::getInstance().getDetailLevelParticle() < (unsigned int)this->detaillevel_)
+    {
       this->bVisible_ = false;
 …
+  {
     this->particleSystem_->removeAllEmitters();
     GraphicsEngine::getSingleton().getSceneManager()->destroyParticleSystem(particleSystem_);
+    GraphicsEngine::getInstance().getLevelSceneManager()->destroyParticleSystem(particleSystem_);
+  }
 …
   void ParticleInterface::setSpeedFactor(float factor)
+  {
+    this->particleSystem_->setSpeedFactor(Orxonox::getSingleton()->getTimeFactor() * factor);
+    //this->particleSystem_->setSpeedFactor(Orxonox::getInstance().getTimeFactor() * factor);
+    this->particleSystem_->setSpeedFactor(1.0f * factor);
+  }
   float ParticleInterface::getSpeedFactor() const
+  {
+    return (this->particleSystem_->getSpeedFactor() / Orxonox::getSingleton()->getTimeFactor());
+    //return (this->particleSystem_->getSpeedFactor() / Orxonox::getInstance().getTimeFactor());
+    return (this->particleSystem_->getSpeedFactor() / 1.0f);
+  }

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

-                      r1552
+                      r1755
 #include "core/ConsoleCommand.h"
 #include "core/CommandExecutor.h"
+#include "core/Clock.h"
 namespace orxonox
 …
         @brief Updates the timer before the frames are rendered.
     */
     void TimerBase::tick(float dt)
+    void TimerBase::tick(const Clock& time)
+    {
         if (this->bActive_)
+        {
             // If active: Decrease the timer by the duration of the last frame
             this->time_ -= dt;
+            this->time_ -= time.getDeltaTimeMicroseconds();
             if (this->time_ <= 0)

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

-                      r1608
+                      r1755
 #include "OrxonoxPrereqs.h"
 #include "objects/Tickable.h"
+#include "core/OrxonoxClass.h"
 namespace orxonox
 …
     //! TimerBase is the parent of the Timer class.
     class _OrxonoxExport TimerBase : public Tickable
+    class _OrxonoxExport TimerBase : public OrxonoxClass
+    {
         public:
 …
             /** @brief Returns the remaining time until the Timer calls the function. @return The remaining time */
             inline float getRemainingTime() const
                 { return this->time_; }
+                { return (float)this->time_ / 1000000.0f; }
             /** @brief Gives the Timer some extra time. @param time The amount of extra time in seconds */
             inline void addTime(float time)
                 { this->time_ += time; }
+                { if (time > 0.0f) this->time_ += (long long)(time * 1000000.0f); }
             /** @brief Decreases the remaining time of the Timer. @param time The amount of time to remove */
             inline void removeTime(float time)
                 { this->time_ -= time; }
+                { if (time > 0.0f) this->time_ -= (long long)(time * 1000000.0f); }
             /** @brief Sets the interval of the Timer. @param interval The interval */
             inline void setInterval(float interval)
                 { this->interval_ = interval; }
+                { this->interval_ = (long long)(interval * 1000000.0f); }
             /** @brief Sets bLoop to a given value. @param bLoop True = loop */
             inline void setLoop(bool bLoop)
                 { this->bLoop_ = bLoop; }
             void tick(float dt);
+            void tick(const Clock& time);
         protected:
 …
             Executor* executor_; //!< The executor of the function that should be called when the time expires
             float interval_;     //!< The time-interval in seconds
+            long long interval_; //!< The time-interval in micro seconds
             bool bLoop_;         //!< If true, the function gets called every 'interval' seconds
             bool bActive_;       //!< If true, the Timer ticks and calls the function if the time's up
             float time_;         //!< Internal variable, counting the time till the next function-call
+            long long time_;     //!< Internal variable, counting the time till the next function-call
     };
 …
                 this->deleteExecutor();
                 this->interval_ = interval;
+                this->setInterval(interval);
                 this->bLoop_ = bLoop;
                 executor->setObject(object);
 …
                 this->bActive_ = true;
                 this->time_ = interval;
+                this->time_ = this->interval_;
+            }
     };
 …
                 this->deleteExecutor();
                 this->interval_ = interval;
+                this->setInterval(interval);
                 this->bLoop_ = bLoop;
                 this->executor_ = (Executor*)executor;
                 this->bActive_ = true;
                 this->time_ = interval;
+                this->time_ = this->interval_;
+            }
     };

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

-                      r1625
+                      r1755
         virtual ~WindowEventListener() { }
                     /** Window has moved position */
                     virtual void windowMoved() { }
+            /** Window has moved position */
+            virtual void windowMoved() { }
                     /** Window has resized */
                     virtual void windowResized(int newWidth, int newHeight) { }
+            /** Window has resized */
+            virtual void windowResized(int newWidth, int newHeight) { }
                     /** Window has lost/gained focus */
                     virtual void windowFocusChanged() { }
+            /** Window has lost/gained focus */
+            virtual void windowFocusChanged() { }
     };
+}

code/trunk/src/tolua/CMakeLists.txt

-                      r1582
+                      r1755
+)
+SET (TOLUAGEN_SRC_FILES
+  tolua.c
+  toluabind.c
+)
+ADD_EXECUTABLE (toluagen ${TOLUAGEN_SRC_FILES})
+TARGET_LINK_LIBRARIES (toluagen
+  ${Lua_LIBRARIES}
+  tolualib
+  m
+)
+IF (Lua_VERSION EQUAL 5.0)
+  SET (TOLUA_PACKAGE "../../src/tolua/tolua-5.0.pkg")
+ELSE (Lua_VERSION EQUAL 5.0)
+  SET (TOLUA_PACKAGE "../../src/tolua/tolua-5.1.pkg")
+ENDIF (Lua_VERSION EQUAL 5.0)
+GET_TARGET_PROPERTY(TOLUAGEN_EXE toluagen LOCATION)
+ADD_CUSTOM_COMMAND(
+  OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/toluabind_orxonox.c
+  COMMAND ${TOLUAGEN_EXE} -n tolua -o ../../src/tolua/toluabind_orxonox.c -H ../../src/tolua/toluabind_orxonox.h ${TOLUA_PACKAGE}
+  DEPENDS toluagen
+  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/bin/lib
+)
 SET (TOLUAEXE_SRC_FILES
   tolua.c
   toluabind.c
+  toluabind_orxonox.c
+)

code/trunk/src/tolua/tolua++.h

-                      r1505
+                      r1755
 #define TOLUA_H
+/* original code */
+/*
 #ifndef TOLUA_API
 #define TOLUA_API extern
 #endif
+*/
+/********************************
+******* ORXONOX CHANGES *********
+********************************/
+#if (defined( __WIN32__ ) || defined( _WIN32 )) && !defined( TOLUA_STATIC_BUILD )
+#  ifdef TOLUA_SHARED_BUILD
+#    define TOLUA_API __declspec(dllexport)
+#  else
+#    if defined( __MINGW32__ )
+#      define TOLUA_API
+#    else
+#      define TOLUA_API __declspec(dllimport)
+#    endif
+#  endif
+#else
+#  define TOLUA_API extern
+#endif
+/********************************
+****** END ORXONOX CHANGES ******
+********************************/
 #define TOLUA_VERSION "tolua++-1.0.92"

code/trunk/src/tolua/toluabind.c

-                      r1505
+                      r1755
 /* Exported function */
 TOLUA_API int  tolua_tolua_open (lua_State* tolua_S);
+int  tolua_tolua_open (lua_State* tolua_S);
 …
 /* Open function */
 TOLUA_API int tolua_tolua_open (lua_State* tolua_S)
+int tolua_tolua_open (lua_State* tolua_S)
+{
  tolua_open(tolua_S);
 …
 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
  TOLUA_API int luaopen_tolua (lua_State* tolua_S) {
+ int luaopen_tolua (lua_State* tolua_S) {
  return tolua_tolua_open(tolua_S);
 };

code/trunk/src/tolua/toluabind_orxonox.c

r1724	r1755
1	1	/*
2	2	** Lua binding: tolua
3		** Generated automatically by tolua++-1.0.92 on 09/~~05/08 12:45:12~~.
	3	** Generated automatically by tolua++-1.0.92 on 09/10/08 00:32:19.
4	4	*/
5	5

code/trunk/src/tolua/toluabind_orxonox.h

r1724	r1755
1	1	/*
2	2	** Lua binding: tolua
3		** Generated automatically by tolua++-1.0.92 on 09/~~05/08 12:45:13~~.
	3	** Generated automatically by tolua++-1.0.92 on 09/10/08 00:32:21.
4	4	*/
5	5

code/trunk/src/util/CMakeLists.txt

r1751	r1755
1	1	SET(UTIL_SRC_FILES
2		~~ArgReader.cc~~
3	2	Clipboard.cc
4	3	Error.cc

code/trunk/src/util/CRC32.h

-                      r1751
+                      r1755
 #define _Util_CRC_H__
+#include "UtilPrereqs.h"
 #include <iostream>
+#include "Integers.h"
 #define UTIL_CRC32POLY 0x04C11DB7 /* CRC-32 Polynom */
 void calcCRCBit(uint32_t &crc32, int bit);
+_UtilExport void calcCRCBit(uint32_t &crc32, int bit);
 uint32_t calcCRC(unsigned char *data, unsigned int dataLength);
+_UtilExport uint32_t calcCRC(unsigned char *data, unsigned int dataLength);

code/trunk/src/util/Convert.h

-                      r1747
+                      r1755
 };
+///////////////////////////
+// Static type detection //
+///////////////////////////
+/**
+    Template class that determines whether type T converts implicitly to type U.
+@note
+    This allows to detect type conversion at compile time.
+    From 'Modern C++ Design' (Alexandrescu 2001).
+*/
+template <class T, class U>
+class StaticConversion
+{
+    class Small { char dummy[1]; };
+    class Big   { char dummy[1024]; };
+    static Small Test(U);
+    static Big   Test(...);
+    static T MakeT();
+public:
+    enum { exists = sizeof(Test(MakeT())) == sizeof(Small) };
+};
 #if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
 #pragma warning(pop)

code/trunk/src/util/OrxonoxPlatform.h

-                      r1505
+                      r1755
  *      Reto Grieder
+ *
+ *   Original code: OgrePlatform.h, licensed under the LGPL. The code
+ *   has changed quite a bit however.
+ *
  */
 /**
  @file
  @brief Various constants for compiler, architecture and platform. It's a mere
         copy of the file found in the Ogre source code (OgrePlatform.h).
+ @brief
+    Various constants for compiler, architecture and platform.
  */
 …
 #define _OrxonoxPlatform_H__
 /* Initial platform/compiler-related stuff to set.
+*/
+/* Initial platform/compiler-related stuff to set. */
 #define ORXONOX_PLATFORM_WIN32 1
 #define ORXONOX_PLATFORM_LINUX 2
 …
 #define ORXONOX_ARCHITECTURE_64 2
+/* Finds the compiler type and version.
+*/
+/* Finds the compiler type and version. */
 #if defined( _MSC_VER )
 #  define ORXONOX_COMPILER ORXONOX_COMPILER_MSVC
 …
 #endif
 /* See if we can use __forceinline or if we need to use __inline instead */
 #if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
 …
 /* Finds the current platform */
 #if defined( __WIN32__ ) || defined( _WIN32 )
 #  define ORXONOX_PLATFORM ORXONOX_PLATFORM_WIN32
 #elif defined( __APPLE_CC__)
 #  define ORXONOX_PLATFORM ORXONOX_PLATFORM_APPLE
 #else
 #  define ORXONOX_PLATFORM ORXONOX_PLATFORM_LINUX
 #endif
     /* Find the arch type */
+/* Find the arch type */
 #if defined(__x86_64__) || defined(_M_X64) || defined(__powerpc64__) || defined(__alpha__) || defined(__ia64__) || defined(__s390__) || defined(__s390x__)
 #  define ORXONOX_ARCH_TYPE ORXONOX_ARCHITECTURE_64
 …
 #endif
+// For generating compiler warnings - should work on any compiler
+// As a side note, if you start your message with 'Warning: ', the MSVC
+// IDE actually does catch a warning :)
+// FIXME: Try this on linux box. Doesn't work with msvc
+//#define ORXONOX_QUOTE_INPLACE(x) # x
+//#define ORXONOX_QUOTE(x) ORXONOX_QUOTE_INPLACE(x)
+//#define ORXONOX_WARN( x )  message( __FILE__ "(" QUOTE( __LINE__ ) ") : " x "\n" )
+//----------------------------------------------------------------------------
+// Windows Settings
+/* Try to define function information */
+#ifndef __FUNCTIONNAME__
+#  if ORXONOX_COMPILER == ORXONOX_COMPILER_BORL
+#    define __FUNCTIONNAME__ __FUNC__
+#  elif ORXONOX_COMPILER == ORXONOX_COMPILER_GNUC
+#    define __FUNCTIONNAME__ __PRETTY_FUNCTION__
+#  elif ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
+#    define __FUNCTIONNAME__ __FUNCTION__
+#  else
+#    define __FUNCTIONNAME__
+#  endif
+#endif
+/* Determine whether we're building in debug mode */
+#if defined(_DEBUG) || defined(DEBUG)
+#  define ORXONOX_DEBUG_MODE 1
+#else
+#  define ORXONOX_DEBUG_MODE 0
+#endif
+/* Define configurable floating point type */
+namespace orxonox
+{
+#ifdef ORXONOX_DOUBLE_PRECISION
+    typedef double Real;
+#else
+    typedef float  Real;
+#endif
+}
+/*---------------------------------
+ * Windows Settings
+ *-------------------------------*/
 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32
+// Win32 compilers use _DEBUG for specifying debug builds.
+#  ifdef _DEBUG
+#    define ORXONOX_DEBUG_MODE 1
+#  else
+#    define ORXONOX_DEBUG_MODE 0
+#  endif
+// Disable unicode support on MingW at the moment, poorly supported in stdlibc++
+// STLPORT fixes this though so allow if found
+// MinGW C++ Toolkit supports unicode and sets the define __MINGW32_TOOLKIT_UNICODE__ in _mingw.h
+/* Disable unicode support on MingW at the moment, poorly supported in stdlibc++
+ * STLPORT fixes this though so allow if found
+ * MinGW C++ Toolkit supports unicode and sets the define __MINGW32_TOOLKIT_UNICODE__ in _mingw.h */
 #  if defined( __MINGW32__ ) && !defined(_STLPORT_VERSION)
 #    include<_mingw.h>
 …
 #    define ORXONOX_UNICODE_SUPPORT 1
 #  endif
 #endif /* Platform Win32 */
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+// Linux/Apple Settings
+/*---------------------------------
+ * Linux/Apple Settings
+ *-------------------------------*/
 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_LINUX || ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE
+// A quick define to overcome different names for the same function
+/* A quick define to overcome different names for the same function */
 #  define stricmp strcasecmp
+// Unlike the Win32 compilers, Linux compilers seem to use DEBUG for when
+// specifying a debug build.
+// (??? this is wrong, on Linux debug builds aren't marked in any way unless
+// you mark it yourself any way you like it -- zap ???)
+#  ifdef DEBUG
+#    define ORXONOX_DEBUG_MODE 1
+#  else
+#    define ORXONOX_DEBUG_MODE 0
+#  endif
+/* FIXME: Check what this actually is and whether we need it or not
+/* TODO: Check what this actually is and whether we need it or not */
+#if 0
 #  if ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE
 #    define ORXONOX_PLATFORM_LIB "OrxonoxPlatform.bundle"
 #  else
 // ORXONOX_PLATFORM_LINUX
+/* ORXONOX_PLATFORM_LINUX */
 #    define ORXONOX_PLATFORM_LIB "libOrxonoxPlatform.so"
 #  endif
+*/
 // Always enable unicode support for the moment
+// Perhaps disable in old versions of gcc if necessary
+#endif
+/* Always enable unicode support for the moment
+ * Perhaps disable in old versions of gcc if necessary */
 #  define ORXONOX_UNICODE_SUPPORT 1
 #endif /* Patform Linux/Apple */
+//For apple, we always have a custom config.h file
+/*---------------------------------
+ * Apple Settings
+ *-------------------------------*/
+/* For apple, we always have a custom config.h file */
 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE
 #  include "config.h"
 #endif
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+// Endian Settings
+// check for BIG_ENDIAN config flag, set ORXONOX_ENDIAN correctly
+#ifdef ORXONOX_CONFIG_BIG_ENDIAN
+#  define ORXONOX_ENDIAN ORXONOX_ENDIAN_BIG
+#else
+#  define ORXONOX_ENDIAN ORXONOX_ENDIAN_LITTLE
+#endif
+//-----------------------------------------------------------------------
+// fixed width integers
+//-----------------------------------------------------------------------
+/*---------------------------------
+ * Visual Studio Settings
+ *-------------------------------*/
 #if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
+typedef __int8            int8_t;
+typedef __int16           int16_t;
+typedef __int32           int32_t;
+typedef __int64           int64_t;
+typedef unsigned __int8   uint8_t;
+typedef unsigned __int16  uint16_t;
+typedef unsigned __int32  uint32_t;
+typedef unsigned __int64  uint64_t;
+#else
+# include "inttypes.h"
+#endif
+namespace orxonox {
+#ifdef ORXONOX_DOUBLE_PRECISION
+typedef double Real;
+#else
+typedef float Real;
+#endif
+}
+#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
+// Turn off warnings generated by long std templates
+// This warns about truncation to 255 characters in debug/browse info
+//#   pragma warning (disable : 4786)
+// Turn off warnings generated by long std templates
+// This warns about truncation to 255 characters in debug/browse info
+//#   pragma warning (disable : 4503)
+// disable: conversion from 'double' to 'float', possible loss of data
+// disable: conversion from 'ogg_int64_t' to 'long', possible loss of data
+// This has been dealt with in base_properties of the solution since the
+// warning primarily occurs in library header files (which are mostly
+// included before OrxonoxPlatform.h is)
+//#   pragma warning (disable : 4244)
+// disable: "conversion from 'size_t' to 'unsigned int', possible loss of data
+//#   pragma warning (disable : 4267)
+// disable: "truncation from 'double' to 'float'
+//#   pragma warning (disable : 4305)
+// set to level 4: "<type> needs to have dll-interface to be used by clients'
+// Happens on STL member variables which are not public therefore is ok
+/* Turn off warnings generated by long std templates
+ * This warns about truncation to 255 characters in debug/browse info */
+/*#   pragma warning (disable : 4786)*/
+/* Turn off warnings generated by long std templates
+ * This warns about truncation to 255 characters in debug/browse info */
+/*#   pragma warning (disable : 4503)*/
+/* disable: conversion from 'double' to 'float', possible loss of data
+ * disable: conversion from 'ogg_int64_t' to 'long', possible loss of data
+ * This has been dealt with in base_properties of the solution since the
+ * warning primarily occurs in library header files (which are mostly
+ * included before OrxonoxPlatform.h is) */
+/*#   pragma warning (disable : 4244)*/
+/* disable: "conversion from 'size_t' to 'unsigned int', possible loss of data */
+/*#   pragma warning (disable : 4267)*/
+/* disable: "truncation from 'double' to 'float' */
+/*#   pragma warning (disable : 4305)*/
+/* set to level 4: "<type> needs to have dll-interface to be used by clients'
+ * Happens on STL member variables which are not public therefore is ok */
 #   pragma warning (disable : 4251)
 // disable: 'MultiTypeString' : multiple assignment operators specified
+// Used in MultiType and works fine so far
 //#   pragma warning (disable : 4522)
 // disable: "non dll-interface class used as base for dll-interface class"
 // Happens when deriving from Singleton because bug in compiler ignores
+// template export
 //#   pragma warning (disable : 4275)
 // disable: "C++ Exception Specification ignored"
 // This is because MSVC 6 did not implement all the C++ exception
+// specifications in the ANSI C++ draft.
 //#   pragma warning( disable : 4290 )
 // disable: "no suitable definition provided for explicit template
 // instantiation request" Occurs in VC7 for no justifiable reason on all
+// #includes of Singleton
 //#   pragma warning( disable: 4661)
 // disable: deprecation warnings when using CRT calls in VC8
 // These show up on all C runtime lib code in VC8, disable since they clutter
 // the warnings with things we may not be able to do anything about (e.g.
 // generated code from nvparse etc). I doubt very much that these calls
+// will ever be actually removed from VC anyway, it would break too much code.
 //#     pragma warning( disable: 4996)
 // disable: "conditional expression constant", always occurs on
+// ORXONOX_MUTEX_CONDITIONAL when no threading enabled
 //#   pragma warning (disable : 201)
 // Define the english written operators like and, or, xor
+/* disable: 'MultiTypeString' : multiple assignment operators specified
+ * Used in MultiType and works fine so far */
+/*#   pragma warning (disable : 4522)*/
+/* disable: "non dll-interface class used as base for dll-interface class"
+ * Happens when deriving from Singleton because bug in compiler ignores
+ * template export */
+/*#   pragma warning (disable : 4275)*/
+/* disable: "C++ Exception Specification ignored"
+ * This is because MSVC 6 did not implement all the C++ exception
+ * specifications in the ANSI C++ draft. */
+/*#   pragma warning( disable : 4290 )*/
+/* disable: "no suitable definition provided for explicit template
+ * instantiation request" Occurs in VC7 for no justifiable reason on all
+ * #includes of Singleton */
+/*#   pragma warning( disable: 4661)*/
+/* disable: deprecation warnings when using CRT calls in VC8
+ * These show up on all C runtime lib code in VC8, disable since they clutter
+ * the warnings with things we may not be able to do anything about (e.g.
+ * generated code from nvparse etc). I doubt very much that these calls
+ * will ever be actually removed from VC anyway, it would break too much code. */
+/*# pragma warning( disable: 4996)*/
+/* disable: "conditional expression constant", always occurs on
+ * ORXONOX_MUTEX_CONDITIONAL when no threading enabled */
+/*#   pragma warning (disable : 201)*/
+/* Define the english written operators like and, or, xor */
 #include <iso646.h>
+/* include visual leak detector to search for memory leaks */
+/* #include <vld.h> */
 #endif /* ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC */
-// include visual leak detector to search for memory leaks
-//#include <vld.h>
 #endif /* _OrxonoxPlatform_H__ */

code/trunk/src/util/Sleep.h

-                      r1505
+                      r1755
 /**
+ @file  Sleep.h
+ @brief Macros for using sleep() and usleep() under windows
+ @file
+ @brief
+    Functions for using sleep() and usleep() under windows.
  */
+#include "UtilPrereqs.h"
+#ifndef _Sleep_H__
+#define _Sleep_H__
+#include "OrxonoxPlatform.h"
 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32
+#  ifndef WIN32_LEAN_AND_MEAN
+#    define WIN32_LEAN_AND_MEAN
+#  endif
+#  include <windows.h>
+#ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
 inline void usleep(DWORD dwMicroseconds)
+{
   Sleep(dwMicroseconds / 1000);
+}
 inline void msleep(DWORD dwMilliseconds)
+{
   Sleep(dwMilliseconds);
+}
 inline void sleep(DWORD dwSeconds)
+{
   Sleep(dwSeconds * 1000);
+}
+#else
+#  include <unistd.h>
+#else /* Linux/Apple */
+#include <unistd.h>
 inline void msleep(unsigned long msec)
+{
   usleep(msec * 1000);
+}
 #endif
+#endif /* _Sleep_H__ */

code/trunk/src/util/SubString.h

r1505	r1755
131	131	/** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
132	132	inline const std::string& getString(unsigned int i) const { return (*this)[i]; };
	133	/** @brief Returns all Strings as std::vector */
	134	inline const std::vector<std::string>& getAllStrings() const { return this->strings; }
133	135	/** @brief Returns true if the token is in safemode. @param i the i'th token */
134	136	inline bool isInSafemode(unsigned int i) const { return this->bInSafemode[i]; }

Context Navigation

Legend:

Download in other formats: