Index: code/trunk/src/libraries/core/CommandLineParser.cc
===================================================================
--- code/trunk/src/libraries/core/CommandLineParser.cc	(revision 9348)
+++ code/trunk/src/libraries/core/CommandLineParser.cc	(revision 9550)
@@ -50,5 +50,5 @@
     void CommandLineArgument::parse(const std::string& value)
     {
-        if (value_.getType() == MT_Type::Bool)
+        if (value_.isType<bool>())
         {
             // simulate command line switch
@@ -69,7 +69,7 @@
         else
         {
-            if (!value_.setValue(value))
-            {
-                value_.setValue(defaultValue_);
+            if (!value_.set(value))
+            {
+                value_.set(defaultValue_);
                 ThrowException(Argument, "Could not read command line argument '" + getName() + "'.");
             }
@@ -298,8 +298,8 @@
                 infoStr << "      ";
             infoStr << "--" << it->second->getName() << ' ';
-            if (it->second->getValue().getType() != MT_Type::Bool)
+            if (it->second->getValue().isType<bool>())
+                infoStr << "    ";
+            else
                 infoStr << "ARG ";
-            else
-                infoStr << "    ";
             // fill with the necessary amount of blanks
             infoStr << std::string(maxNameSize - it->second->getName().size(), ' ');
Index: code/trunk/src/libraries/core/CommandLineParser.h
===================================================================
--- code/trunk/src/libraries/core/CommandLineParser.h	(revision 9348)
+++ code/trunk/src/libraries/core/CommandLineParser.h	(revision 9550)
@@ -200,5 +200,5 @@
     inline void CommandLineParser::getValue<std::string>(const std::string& name, std::string* value)
     {
-        *value = getArgument(name)->getValue().getString();
+        *value = getArgument(name)->getValue().get<std::string>();
     }
 
@@ -217,5 +217,5 @@
         OrxAssert(!_getInstance().existsArgument(name),
             "Cannot add a command line argument with name '" + name + "' twice.");
-        OrxAssert(MultiType(defaultValue).getType() != MT_Type::Bool || MultiType(defaultValue).getBool() != true,
+        OrxAssert(!MultiType(defaultValue).isType<bool>() || MultiType(defaultValue).get<bool>() != true,
                "Boolean command line arguments with positive default values are not supported." << endl
             << "Please use SetCommandLineSwitch and adjust your argument: " << name);
Index: code/trunk/src/libraries/core/ConfigValueContainer.cc
===================================================================
--- code/trunk/src/libraries/core/ConfigValueContainer.cc	(revision 9348)
+++ code/trunk/src/libraries/core/ConfigValueContainer.cc	(revision 9550)
@@ -70,5 +70,5 @@
         this->bIsVector_ = false;
 
-        this->defvalueString_ = this->value_.getString();
+        this->defvalueString_ = this->value_.get<std::string>();
         this->update();
     }
@@ -83,5 +83,5 @@
         for (unsigned int i = 0; i < this->valueVector_.size(); i++)
         {
-            ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType(MT_Type::String));
+            ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType<std::string>());
             this->defvalueStringVector_.push_back(this->valueVector_[i]);
         }
@@ -118,5 +118,5 @@
             if (this->tset(input))
             {
-                ConfigFileManager::getInstance().getConfigFile(this->type_)->setValue(this->sectionname_, this->varname_, input, this->value_.isType(MT_Type::String));
+                ConfigFileManager::getInstance().getConfigFile(this->type_)->setValue(this->sectionname_, this->varname_, input, this->value_.isType<std::string>());
                 return true;
             }
@@ -137,5 +137,5 @@
             if (this->tset(index, input))
             {
-                ConfigFileManager::getInstance().getConfigFile(this->type_)->setValue(this->sectionname_, this->varname_, index, input, this->value_.isType(MT_Type::String));
+                ConfigFileManager::getInstance().getConfigFile(this->type_)->setValue(this->sectionname_, this->varname_, index, input, this->value_.isType<std::string>());
                 return true;
             }
@@ -236,5 +236,5 @@
                 this->valueVector_.erase(this->valueVector_.begin() + index);
                 for (unsigned int i = index; i < this->valueVector_.size(); i++)
-                    ConfigFileManager::getInstance().getConfigFile(this->type_)->setValue(this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType(MT_Type::String));
+                    ConfigFileManager::getInstance().getConfigFile(this->type_)->setValue(this->sectionname_, this->varname_, i, this->valueVector_[i], this->value_.isType<std::string>());
                 ConfigFileManager::getInstance().getConfigFile(this->type_)->deleteVectorEntries(this->sectionname_, this->varname_, this->valueVector_.size());
 
@@ -272,5 +272,5 @@
     {
         if (!this->bIsVector_)
-            this->value_ = ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, this->defvalueString_, this->value_.isType(MT_Type::String));
+            this->value_ = ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, this->defvalueString_, this->value_.isType<std::string>());
         else
         {
@@ -281,9 +281,9 @@
                 if (i < this->defvalueStringVector_.size())
                 {
-                    this->value_ = ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, i, this->defvalueStringVector_[i], this->value_.isType(MT_Type::String));
+                    this->value_ = ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, i, this->defvalueStringVector_[i], this->value_.isType<std::string>());
                 }
                 else
                 {
-                    this->value_ = ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, i, MultiType(), this->value_.isType(MT_Type::String));
+                    this->value_ = ConfigFileManager::getInstance().getConfigFile(this->type_)->getOrCreateValue(this->sectionname_, this->varname_, i, MultiType(), this->value_.isType<std::string>());
                 }
 
Index: code/trunk/src/libraries/core/Core.cc
===================================================================
--- code/trunk/src/libraries/core/Core.cc	(revision 9348)
+++ code/trunk/src/libraries/core/Core.cc	(revision 9550)
@@ -55,4 +55,5 @@
 #include "util/Exception.h"
 #include "util/output/LogWriter.h"
+#include "util/output/OutputManager.h"
 #include "util/Scope.h"
 #include "util/ScopedSingletonManager.h"
@@ -167,5 +168,5 @@
         this->configFileManager_ = new ConfigFileManager();
         this->configFileManager_->setFilename(ConfigFileType::Settings,
-            CommandLineParser::getValue("settingsFile").getString());
+            CommandLineParser::getValue("settingsFile").get<std::string>());
 
         // Required as well for the config values
@@ -180,9 +181,9 @@
 
         // Set the correct log path and rewrite the log file with the correct log levels
-        LogWriter::getInstance().setLogPath(PathConfig::getLogPathString());
+        OutputManager::getInstance().getLogWriter()->setLogDirectory(PathConfig::getLogPathString());
 
 #if !defined(ORXONOX_PLATFORM_APPLE) && !defined(ORXONOX_USE_WINMAIN)
         // Create persistent IO console
-        if (CommandLineParser::getValue("noIOConsole").getBool())
+        if (CommandLineParser::getValue("noIOConsole").get<bool>())
         {
             ModifyConfigValue(bStartIOConsole_, tset, false);
@@ -258,22 +259,22 @@
     void Core::setConfigValues()
     {
-        SetConfigValueExternal(LogWriter::getInstance().configurableMaxLevel_,
-                               LogWriter::getInstance().getConfigurableSectionName(),
-                               LogWriter::getInstance().getConfigurableMaxLevelName(),
-                               LogWriter::getInstance().configurableMaxLevel_)
+        SetConfigValueExternal(OutputManager::getInstance().getLogWriter()->configurableMaxLevel_,
+                               OutputManager::getInstance().getLogWriter()->getConfigurableSectionName(),
+                               OutputManager::getInstance().getLogWriter()->getConfigurableMaxLevelName(),
+                               OutputManager::getInstance().getLogWriter()->configurableMaxLevel_)
             .description("The maximum level of output shown in the log file")
-            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableLevel);
-        SetConfigValueExternal(LogWriter::getInstance().configurableAdditionalContextsMaxLevel_,
-                               LogWriter::getInstance().getConfigurableSectionName(),
-                               LogWriter::getInstance().getConfigurableAdditionalContextsMaxLevelName(),
-                               LogWriter::getInstance().configurableAdditionalContextsMaxLevel_)
+            .callback(static_cast<BaseWriter*>(OutputManager::getInstance().getLogWriter()), &BaseWriter::changedConfigurableLevel);
+        SetConfigValueExternal(OutputManager::getInstance().getLogWriter()->configurableAdditionalContextsMaxLevel_,
+                               OutputManager::getInstance().getLogWriter()->getConfigurableSectionName(),
+                               OutputManager::getInstance().getLogWriter()->getConfigurableAdditionalContextsMaxLevelName(),
+                               OutputManager::getInstance().getLogWriter()->configurableAdditionalContextsMaxLevel_)
             .description("The maximum level of output shown in the log file for additional contexts")
-            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableAdditionalContextsLevel);
-        SetConfigValueExternal(LogWriter::getInstance().configurableAdditionalContexts_,
-                               LogWriter::getInstance().getConfigurableSectionName(),
-                               LogWriter::getInstance().getConfigurableAdditionalContextsName(),
-                               LogWriter::getInstance().configurableAdditionalContexts_)
+            .callback(static_cast<BaseWriter*>(OutputManager::getInstance().getLogWriter()), &BaseWriter::changedConfigurableAdditionalContextsLevel);
+        SetConfigValueExternal(OutputManager::getInstance().getLogWriter()->configurableAdditionalContexts_,
+                               OutputManager::getInstance().getLogWriter()->getConfigurableSectionName(),
+                               OutputManager::getInstance().getLogWriter()->getConfigurableAdditionalContextsName(),
+                               OutputManager::getInstance().getLogWriter()->configurableAdditionalContexts_)
             .description("Additional output contexts shown in the log file")
-            .callback(static_cast<BaseWriter*>(&LogWriter::getInstance()), &BaseWriter::changedConfigurableAdditionalContexts);
+            .callback(static_cast<BaseWriter*>(OutputManager::getInstance().getLogWriter()), &BaseWriter::changedConfigurableAdditionalContexts);
 
         SetConfigValue(bDevMode_, PathConfig::buildDirectoryRun())
@@ -337,5 +338,5 @@
     {
         orxout(internal_info) << "loading graphics in Core" << endl;
-        
+
         // Any exception should trigger this, even in upgradeToGraphics (see its remarks)
         Loki::ScopeGuard unloader = Loki::MakeObjGuard(*this, &Core::unloadGraphics);
Index: code/trunk/src/libraries/core/PathConfig.cc
===================================================================
--- code/trunk/src/libraries/core/PathConfig.cc	(revision 9348)
+++ code/trunk/src/libraries/core/PathConfig.cc	(revision 9550)
@@ -188,5 +188,5 @@
             // Check for data path override by the command line
             if (!CommandLineParser::getArgument("externalDataPath")->hasDefaultValue())
-                externalDataPath_ = CommandLineParser::getValue("externalDataPath").getString();
+                externalDataPath_ = CommandLineParser::getValue("externalDataPath").get<std::string>();
             else
                 externalDataPath_ = specialConfig::externalDataDevDirectory;
@@ -227,5 +227,5 @@
         if (!CommandLineParser::getArgument("writingPathSuffix")->hasDefaultValue())
         {
-            const std::string& directory(CommandLineParser::getValue("writingPathSuffix").getString());
+            const std::string& directory(CommandLineParser::getValue("writingPathSuffix").get<std::string>());
             configPath_ = configPath_ / directory;
             logPath_    = logPath_    / directory;
Index: code/trunk/src/libraries/core/command/CommandEvaluation.cc
===================================================================
--- code/trunk/src/libraries/core/command/CommandEvaluation.cc	(revision 9348)
+++ code/trunk/src/libraries/core/command/CommandEvaluation.cc	(revision 9550)
@@ -119,5 +119,5 @@
         @brief Executes the command which was evaluated by this object and returns its return-value.
         @param error A pointer to an integer (or NULL) which will be used to write error codes to (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
-        @return Returns the result of the command (or MT_Type::Null if there is no return value)
+        @return Returns the result of the command (or MultiType::Null if there is no return value)
     */
     MultiType CommandEvaluation::query(int* error)
@@ -138,5 +138,5 @@
 
             if (*error != CommandExecutor::Success)
-                return MT_Type::Null;
+                return MultiType::Null;
         }
 
@@ -170,5 +170,5 @@
 
         // return a null value in case of an error
-        return MT_Type::Null;
+        return MultiType::Null;
     }
 
@@ -225,5 +225,5 @@
             return this->arguments_[index];
 
-        return MT_Type::Null;
+        return MultiType::Null;
     }
 
@@ -600,5 +600,5 @@
             // print the default value if available
             if (command->getExecutor()->defaultValueSet(i))
-                output += '=' + command->getExecutor()->getDefaultValue(i).getString() + ']';
+                output += '=' + command->getExecutor()->getDefaultValue(i).get<std::string>() + ']';
             else
                 output += '}';
Index: code/trunk/src/libraries/core/command/CommandExecutor.cc
===================================================================
--- code/trunk/src/libraries/core/command/CommandExecutor.cc	(revision 9348)
+++ code/trunk/src/libraries/core/command/CommandExecutor.cc	(revision 9550)
@@ -83,5 +83,5 @@
         @param error A pointer to a value (or NULL) where the error-code should be written to (see @ref CommandExecutorErrorCodes "error codes")
         @param useTcl If true, the command is passed to tcl (see TclBind)
-        @return Returns the return-value of the command (if any - MT_Type::Null otherwise)
+        @return Returns the return-value of the command (if any - MultiType::Null otherwise)
     */
     /* static */ MultiType CommandExecutor::queryMT(const std::string& command, int* error, bool useTcl)
@@ -133,5 +133,5 @@
     /* static */ std::string CommandExecutor::query(const std::string& command, int* error, bool useTcl)
     {
-        return CommandExecutor::queryMT(command, error, useTcl).getString();
+        return CommandExecutor::queryMT(command, error, useTcl).get<std::string>();
     }
 
Index: code/trunk/src/libraries/core/command/ConsoleCommand.h
===================================================================
--- code/trunk/src/libraries/core/command/ConsoleCommand.h	(revision 9348)
+++ code/trunk/src/libraries/core/command/ConsoleCommand.h	(revision 9550)
@@ -222,6 +222,4 @@
 #include <stack>
 #include <vector>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/facilities/expand.hpp>
 
 #include "util/VA_NARGS.h"
Index: code/trunk/src/libraries/core/command/Executor.cc
===================================================================
--- code/trunk/src/libraries/core/command/Executor.cc	(revision 9348)
+++ code/trunk/src/libraries/core/command/Executor.cc	(revision 9550)
@@ -79,5 +79,5 @@
         @param delimiter The delimiter that is used to separate the arguments in the string @a arguments
         @param bPrintError If true, errors are printed to the console if the function couldn't be executed with the given arguments
-        @return Returns the return value of the function (or MT_Type::Null if there is no return value)
+        @return Returns the return value of the function (or MultiType::Null if there is no return value)
     */
     MultiType Executor::parse(const std::string& arguments, int* error, const std::string& delimiter, bool bPrintError) const
@@ -92,5 +92,5 @@
         @param delimiter The delimiter that was used to separate the arguments in the SubString @a arguments (used to join the surplus arguments)
         @param bPrintError If true, errors are printed to the console if the function couldn't be executed with the given arguments
-        @return Returns the return value of the function (or MT_Type::Null if there is no return value)
+        @return Returns the return value of the function (or MultiType::Null if there is no return value)
     */
     MultiType Executor::parse(const SubString& arguments, int* error, const std::string& delimiter, bool bPrintError) const
@@ -105,5 +105,5 @@
             if (bPrintError)
                 orxout(internal_warning) << "Can't call executor " << this->name_ << " through parser: Not enough arguments or default values given (input: " << arguments.join() << ")." << endl;
-            return MT_Type::Null;
+            return MultiType::Null;
         }
 
Index: code/trunk/src/libraries/core/command/Executor.h
===================================================================
--- code/trunk/src/libraries/core/command/Executor.h	(revision 9348)
+++ code/trunk/src/libraries/core/command/Executor.h	(revision 9550)
@@ -169,5 +169,5 @@
                     return this->defaultValue_[index];
 
-                return MT_Type::Null;
+                return MultiType::Null;
             }
 
Index: code/trunk/src/libraries/core/command/Functor.h
===================================================================
--- code/trunk/src/libraries/core/command/Functor.h	(revision 9348)
+++ code/trunk/src/libraries/core/command/Functor.h	(revision 9550)
@@ -189,6 +189,6 @@
             virtual ~Functor() {}
 
-            /// Calls the function-pointer with up to five arguments. In case of a member-function, the assigned object-pointer is used to call the function. @return Returns the return-value of the function (if any; MT_Type::Null otherwise)
-            virtual MultiType operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
+            /// Calls the function-pointer with up to five arguments. In case of a member-function, the assigned object-pointer is used to call the function. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
+            virtual MultiType operator()(const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null) = 0;
 
             /// Creates a new instance of Functor with the same values like this (used instead of a copy-constructor)
@@ -245,9 +245,9 @@
             virtual ~FunctorMember() { if (this->bSafeMode_) { this->unregisterObject(this->object_); } }
 
-            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be NULL. @return Returns the return-value of the function (if any; MT_Type::Null otherwise)
-            virtual MultiType operator()(O* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
+            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be NULL. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
+            virtual MultiType operator()(O* object, const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null) = 0;
 
             // see Functor::operator()()
-            MultiType operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null)
+            MultiType operator()(const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null)
             {
                 // call the function if an object was assigned
@@ -257,5 +257,5 @@
                 {
                     orxout(internal_error) << "Can't execute FunctorMember, no object set." << endl;
-                    return MT_Type::Null;
+                    return MultiType::Null;
                 }
             }
@@ -324,9 +324,9 @@
             FunctorMember(void* object = 0) {}
 
-            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be NULL. @return Returns the return-value of the function (if any; MT_Type::Null otherwise)
-            virtual MultiType operator()(void* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null) = 0;
+            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be NULL. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
+            virtual MultiType operator()(void* object, const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null) = 0;
 
             // see Functor::operator()()
-            MultiType operator()(const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null)
+            MultiType operator()(const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null)
             {
                 return (*this)((void*)0, param1, param2, param3, param4, param5);
@@ -416,10 +416,10 @@
         template <class R, class O, bool isconst, class P1>                                         struct FunctorCaller<R, O, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, P1, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (object->*functionPointer)(param1); } };
         template <class R, class O, bool isconst>                                                   struct FunctorCaller<R, O, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, O, isconst, void, void, void, void, void>::Type functionPointer, O* object, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (object->*functionPointer)(); } };
-        template <class O, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, P5>           { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1, param2, param3, param4, param5); return MT_Type::Null; } };
-        template <class O, bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { (object->*functionPointer)(param1, param2, param3, param4); return MT_Type::Null; } };
-        template <class O, bool isconst, class P1, class P2, class P3>                     struct FunctorCaller<void, O, isconst, P1, P2, P3, void, void>       { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { (object->*functionPointer)(param1, param2, param3); return MT_Type::Null; } };
-        template <class O, bool isconst, class P1, class P2>                               struct FunctorCaller<void, O, isconst, P1, P2, void, void, void>     { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(param1, param2); return MT_Type::Null; } };
-        template <class O, bool isconst, class P1>                                         struct FunctorCaller<void, O, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(param1); return MT_Type::Null; } };
-        template <class O, bool isconst>                                                   struct FunctorCaller<void, O, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, void, void, void, void, void>::Type functionPointer, O* object, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(); return MT_Type::Null; } };
+        template <class O, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, P5>           { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (object->*functionPointer)(param1, param2, param3, param4, param5); return MultiType::Null; } };
+        template <class O, bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<void, O, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, P4, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { (object->*functionPointer)(param1, param2, param3, param4); return MultiType::Null; } };
+        template <class O, bool isconst, class P1, class P2, class P3>                     struct FunctorCaller<void, O, isconst, P1, P2, P3, void, void>       { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, P3, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { (object->*functionPointer)(param1, param2, param3); return MultiType::Null; } };
+        template <class O, bool isconst, class P1, class P2>                               struct FunctorCaller<void, O, isconst, P1, P2, void, void, void>     { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, P2, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(param1, param2); return MultiType::Null; } };
+        template <class O, bool isconst, class P1>                                         struct FunctorCaller<void, O, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, P1, void, void, void, void>::Type functionPointer, O* object, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(param1); return MultiType::Null; } };
+        template <class O, bool isconst>                                                   struct FunctorCaller<void, O, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, O, isconst, void, void, void, void, void>::Type functionPointer, O* object, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (object->*functionPointer)(); return MultiType::Null; } };
         template <class R, bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<R, void, isconst, P1, P2, P3, P4, P5>           { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, P4, P5>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { return (*functionPointer)(param1, param2, param3, param4, param5); } };
         template <class R, bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<R, void, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, P2, P3, P4, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { return (*functionPointer)(param1, param2, param3, param4); } };
@@ -428,10 +428,10 @@
         template <class R, bool isconst, class P1>                                         struct FunctorCaller<R, void, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, P1, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (*functionPointer)(param1); } };
         template <class R, bool isconst>                                                   struct FunctorCaller<R, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<R, void, isconst, void, void, void, void, void>::Type functionPointer, void*, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { return (*functionPointer)(); } };
-        template <bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, P5>           { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, P5>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (*functionPointer)(param1, param2, param3, param4, param5); return MT_Type::Null; } };
-        template <bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { (*functionPointer)(param1, param2, param3, param4); return MT_Type::Null; } };
-        template <bool isconst, class P1, class P2, class P3>                     struct FunctorCaller<void, void, isconst, P1, P2, P3, void, void>       { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { (*functionPointer)(param1, param2, param3); return MT_Type::Null; } };
-        template <bool isconst, class P1, class P2>                               struct FunctorCaller<void, void, isconst, P1, P2, void, void, void>     { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(param1, param2); return MT_Type::Null; } };
-        template <bool isconst, class P1>                                         struct FunctorCaller<void, void, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(param1); return MT_Type::Null; } };
-        template <bool isconst>                                                   struct FunctorCaller<void, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, void, void, void, void, void>::Type functionPointer, void*, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(); return MT_Type::Null; } };
+        template <bool isconst, class P1, class P2, class P3, class P4, class P5> struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, P5>           { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, P5>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType& param5) { (*functionPointer)(param1, param2, param3, param4, param5); return MultiType::Null; } };
+        template <bool isconst, class P1, class P2, class P3, class P4>           struct FunctorCaller<void, void, isconst, P1, P2, P3, P4, void>         { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, P4, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType& param4, const MultiType&) { (*functionPointer)(param1, param2, param3, param4); return MultiType::Null; } };
+        template <bool isconst, class P1, class P2, class P3>                     struct FunctorCaller<void, void, isconst, P1, P2, P3, void, void>       { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, P3, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType& param3, const MultiType&, const MultiType&) { (*functionPointer)(param1, param2, param3); return MultiType::Null; } };
+        template <bool isconst, class P1, class P2>                               struct FunctorCaller<void, void, isconst, P1, P2, void, void, void>     { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, P2, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType& param2, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(param1, param2); return MultiType::Null; } };
+        template <bool isconst, class P1>                                         struct FunctorCaller<void, void, isconst, P1, void, void, void, void>   { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, P1, void, void, void, void>::Type functionPointer, void*, const MultiType& param1, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(param1); return MultiType::Null; } };
+        template <bool isconst>                                                   struct FunctorCaller<void, void, isconst, void, void, void, void, void> { static inline MultiType call(typename detail::FunctionPointer<void, void, isconst, void, void, void, void, void>::Type functionPointer, void*, const MultiType&, const MultiType&, const MultiType&, const MultiType&, const MultiType&) { (*functionPointer)(); return MultiType::Null; } };
 
         // Helper class, used to identify the header of a function-pointer (independent of its class)
@@ -497,5 +497,5 @@
 
             // see FunctorMember::operator()()
-            MultiType operator()(O* object, const MultiType& param1 = MT_Type::Null, const MultiType& param2 = MT_Type::Null, const MultiType& param3 = MT_Type::Null, const MultiType& param4 = MT_Type::Null, const MultiType& param5 = MT_Type::Null)
+            MultiType operator()(O* object, const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null)
             {
                 return detail::FunctorCaller<R, O, isconst, P1, P2, P3, P4, P5>::call(this->functionPointer_, object, param1, param2, param3, param4, param5);
Index: code/trunk/src/libraries/core/command/IOConsolePOSIX.cc
===================================================================
--- code/trunk/src/libraries/core/command/IOConsolePOSIX.cc	(revision 9348)
+++ code/trunk/src/libraries/core/command/IOConsolePOSIX.cc	(revision 9550)
@@ -38,4 +38,5 @@
 #include "util/Math.h"
 #include "util/output/ConsoleWriter.h"
+#include "util/output/OutputManager.h"
 #include "core/Game.h"
 #include "core/input/InputBuffer.h"
@@ -75,5 +76,5 @@
 
         // Disable standard std::cout logging
-        ConsoleWriter::getInstance().disable();
+        OutputManager::getInstance().getConsoleWriter()->disable();
         // Redirect std::cout to an ostringstream
         // (Other part is in the initialiser list)
@@ -103,5 +104,5 @@
         std::cout.rdbuf(this->cout_.rdbuf());
         // Enable standard std::cout logging again
-        ConsoleWriter::getInstance().enable();
+        OutputManager::getInstance().getConsoleWriter()->enable();
     }
 
Index: code/trunk/src/libraries/core/command/IOConsoleWindows.cc
===================================================================
--- code/trunk/src/libraries/core/command/IOConsoleWindows.cc	(revision 9348)
+++ code/trunk/src/libraries/core/command/IOConsoleWindows.cc	(revision 9550)
@@ -35,4 +35,5 @@
 #include "util/Math.h"
 #include "util/output/ConsoleWriter.h"
+#include "util/output/OutputManager.h"
 #include "core/Game.h"
 #include "core/input/InputBuffer.h"
@@ -53,5 +54,5 @@
     {
         // Disable standard this->cout_ logging
-        ConsoleWriter::getInstance().disable();
+        OutputManager::getInstance().getConsoleWriter()->disable();
         // Redirect std::cout to an ostringstream
         // (Other part is in the initialiser list)
@@ -109,5 +110,5 @@
         std::cout.rdbuf(this->cout_.rdbuf());
         // Enable standard this->cout_ logging again
-        ConsoleWriter::getInstance().enable();
+        OutputManager::getInstance().getConsoleWriter()->enable();
 
         resetTerminalMode();
Index: code/trunk/src/libraries/core/command/Shell.cc
===================================================================
--- code/trunk/src/libraries/core/command/Shell.cc	(revision 9348)
+++ code/trunk/src/libraries/core/command/Shell.cc	(revision 9550)
@@ -88,5 +88,5 @@
 
         // Get the previous output and add it to the Shell
-        MemoryWriter::getInstance().resendOutput(this);
+        OutputManager::getInstance().getMemoryWriter()->resendOutput(this);
     }
 
@@ -170,5 +170,5 @@
         {
             OutputLevel level = (value ? DefaultLogLevel::Dev : DefaultLogLevel::User);
-            ModifyConfigValueExternal(this->configurableMaxLevel_, this->getConfigurableMaxLevelName(), tset, level);
+            ModifyConfigValueExternal(this->configurableMaxLevel_, this->getConfigurableMaxLevelName(), tset, static_cast<int>(level));
         }
     }
Index: code/trunk/src/libraries/core/command/TclBind.cc
===================================================================
--- code/trunk/src/libraries/core/command/TclBind.cc	(revision 9348)
+++ code/trunk/src/libraries/core/command/TclBind.cc	(revision 9550)
@@ -183,5 +183,5 @@
 
         if (bQuery)
-            result = evaluation.query(&error).getString();
+            result = evaluation.query(&error).get<std::string>();
         else
             error = evaluation.execute();
Index: code/trunk/src/libraries/core/input/InputManager.cc
===================================================================
--- code/trunk/src/libraries/core/input/InputManager.cc	(revision 9348)
+++ code/trunk/src/libraries/core/input/InputManager.cc	(revision 9550)
@@ -176,5 +176,5 @@
         if (exclusiveMouse_ || GraphicsManager::getInstance().isFullScreen())
         {
-            if (CommandLineParser::getValue("keyboard_no_grab").getBool())
+            if (CommandLineParser::getValue("keyboard_no_grab").get<bool>())
                 paramList.insert(StringPair("x11_keyboard_grab", "false"));
             else
Index: code/trunk/src/libraries/network/Client.cc
===================================================================
--- code/trunk/src/libraries/network/Client.cc	(revision 9348)
+++ code/trunk/src/libraries/network/Client.cc	(revision 9550)
@@ -68,5 +68,5 @@
       timeSinceLastUpdate_(0)
   {
-    this->setDestination( CommandLineParser::getValue("dest").getString(), CommandLineParser::getValue("port") );
+    this->setDestination( CommandLineParser::getValue("dest").get<std::string>(), CommandLineParser::getValue("port") );
   }
 
Index: code/trunk/src/libraries/tools/Shader.cc
===================================================================
--- code/trunk/src/libraries/tools/Shader.cc	(revision 9348)
+++ code/trunk/src/libraries/tools/Shader.cc	(revision 9550)
@@ -161,5 +161,5 @@
     void Shader::setParameter(size_t technique, size_t pass, const std::string& parameter, int value)
     {
-        ParameterContainer container = {technique, pass, parameter, value, 0.0f, MT_Type::Int};
+        ParameterContainer container = {technique, pass, parameter, value};
         this->parameters_.push_back(container);
         this->addAsListener();
@@ -171,5 +171,5 @@
     void Shader::setParameter(size_t technique, size_t pass, const std::string& parameter, float value)
     {
-        ParameterContainer container = {technique, pass, parameter, 0, value, MT_Type::Float};
+        ParameterContainer container = {technique, pass, parameter, value};
         this->parameters_.push_back(container);
         this->addAsListener();
@@ -204,15 +204,8 @@
                 {
                     // change the value of the parameter depending on its type
-                    switch (it->valueType_)
-                    {
-                        case MT_Type::Int:
-                            passPtr->getFragmentProgramParameters()->setNamedConstant(it->parameter_, it->valueInt_);
-                            break;
-                        case MT_Type::Float:
-                            passPtr->getFragmentProgramParameters()->setNamedConstant(it->parameter_, it->valueFloat_);
-                            break;
-                        default:
-                            break;
-                    }
+                    if (it->value_.isType<int>())
+                        passPtr->getFragmentProgramParameters()->setNamedConstant(it->parameter_, it->value_.get<int>());
+                    else if (it->value_.isType<float>())
+                        passPtr->getFragmentProgramParameters()->setNamedConstant(it->parameter_, it->value_.get<float>());
                 }
                 else
Index: code/trunk/src/libraries/tools/Shader.h
===================================================================
--- code/trunk/src/libraries/tools/Shader.h	(revision 9348)
+++ code/trunk/src/libraries/tools/Shader.h	(revision 9550)
@@ -114,8 +114,5 @@
                 std::string parameter_;     ///< The name of the parameter
 
-                int valueInt_;              ///< The desired int value of the parameter
-                float valueFloat_;          ///< The desired float value of the parameter
-
-                MT_Type::Value valueType_;  ///< The type of the parameter (currently only int or float)
+                MultiType value_;           ///< The desired value of the parameter
             };
 
Index: code/trunk/src/libraries/util/Math.h
===================================================================
--- code/trunk/src/libraries/util/Math.h	(revision 9348)
+++ code/trunk/src/libraries/util/Math.h	(revision 9550)
@@ -139,13 +139,4 @@
     {
         return x*x*x;
-    }
-
-    /**
-        @brief Rounds the value to the nearest integer.
-    */
-    template <typename T>
-    inline int round(T x)
-    {
-        return static_cast<int>(x + 0.5);
     }
 
@@ -247,5 +238,5 @@
     inline T interpolate(float time, const T& start, const T& end)
     {
-        return time * (end - start) + start;
+        return static_cast<T>(time * (end - start) + start);
     }
 
@@ -260,5 +251,5 @@
     inline T interpolateSmooth(float time, const T& start, const T& end)
     {
-        return (-2 * (end - start) * cube(time)) + (3 * (end - start) * square(time)) + start;
+        return static_cast<T>((-2 * (end - start) * cube(time)) + (3 * (end - start) * square(time)) + start);
     }
 
Index: code/trunk/src/libraries/util/MultiType.cc
===================================================================
--- code/trunk/src/libraries/util/MultiType.cc	(revision 9348)
+++ code/trunk/src/libraries/util/MultiType.cc	(revision 9550)
@@ -37,59 +37,61 @@
 namespace orxonox
 {
+    const MultiType MultiType::Null;
+
     /**
         @brief Converts the current value of the MultiType to a new type.
         @param type The type
     */
-    bool MultiType::convert(MT_Type::Value type)
+    bool MultiType::convert(Type::Enum type)
     {
         switch (type)
         {
-            case MT_Type::Null:
+            case Type::Null:
                 this->reset(); return true;
-            case MT_Type::Char:
+            case Type::Char:
                 return this->convert<char>(); break;
-            case MT_Type::UnsignedChar:
+            case Type::UnsignedChar:
                 return this->convert<unsigned char>(); break;
-            case MT_Type::Short:
+            case Type::Short:
                 return this->convert<short>(); break;
-            case MT_Type::UnsignedShort:
+            case Type::UnsignedShort:
                 return this->convert<unsigned short>(); break;
-            case MT_Type::Int:
+            case Type::Int:
                 return this->convert<int>(); break;
-            case MT_Type::UnsignedInt:
+            case Type::UnsignedInt:
                 return this->convert<unsigned int>(); break;
-            case MT_Type::Long:
+            case Type::Long:
                 return this->convert<long>(); break;
-            case MT_Type::UnsignedLong:
+            case Type::UnsignedLong:
                 return this->convert<unsigned long>(); break;
-            case MT_Type::LongLong:
+            case Type::LongLong:
                 return this->convert<long long>(); break;
-            case MT_Type::UnsignedLongLong:
+            case Type::UnsignedLongLong:
                 return this->convert<unsigned long long>(); break;
-            case MT_Type::Float:
+            case Type::Float:
                 return this->convert<float>(); break;
-            case MT_Type::Double:
+            case Type::Double:
                 return this->convert<double>(); break;
-            case MT_Type::LongDouble:
+            case Type::LongDouble:
                 return this->convert<long double>(); break;
-            case MT_Type::Bool:
+            case Type::Bool:
                 return this->convert<bool>(); break;
-            case MT_Type::VoidPointer:
+            case Type::VoidPointer:
                 return this->convert<void*>(); break;
-            case MT_Type::String:
+            case Type::String:
                 return this->convert<std::string>(); break;
-            case MT_Type::Vector2:
+            case Type::Vector2:
                 return this->convert<orxonox::Vector2>(); break;
-            case MT_Type::Vector3:
+            case Type::Vector3:
                 return this->convert<orxonox::Vector3>(); break;
-            case MT_Type::Vector4:
+            case Type::Vector4:
                 return this->convert<orxonox::Vector4>(); break;
-            case MT_Type::ColourValue:
+            case Type::ColourValue:
                 return this->convert<orxonox::ColourValue>(); break;
-            case MT_Type::Quaternion:
+            case Type::Quaternion:
                 return this->convert<orxonox::Quaternion>(); break;
-            case MT_Type::Radian:
+            case Type::Radian:
                 return this->convert<orxonox::Radian>(); break;
-            case MT_Type::Degree:
+            case Type::Degree:
                 return this->convert<orxonox::Degree>(); break;
             default:
@@ -104,53 +106,53 @@
     std::string MultiType::getTypename() const
     {
-        MT_Type::Value type = (this->value_) ? this->value_->type_ : MT_Type::Null;
+        Type::Enum type = (this->value_) ? this->value_->type_ : Type::Null;
 
         switch (type)
         {
-            case MT_Type::Char:
+            case Type::Char:
                 return "char"; break;
-            case MT_Type::UnsignedChar:
+            case Type::UnsignedChar:
                 return "unsigned char"; break;
-            case MT_Type::Short:
+            case Type::Short:
                 return "short"; break;
-            case MT_Type::UnsignedShort:
+            case Type::UnsignedShort:
                 return "unsigned short"; break;
-            case MT_Type::Int:
+            case Type::Int:
                 return "int"; break;
-            case MT_Type::UnsignedInt:
+            case Type::UnsignedInt:
                 return "unsigned int"; break;
-            case MT_Type::Long:
+            case Type::Long:
                 return "long"; break;
-            case MT_Type::UnsignedLong:
+            case Type::UnsignedLong:
                 return "unsigned long"; break;
-            case MT_Type::LongLong:
+            case Type::LongLong:
                 return "long long"; break;
-            case MT_Type::UnsignedLongLong:
+            case Type::UnsignedLongLong:
                 return "unsigned long long"; break;
-            case MT_Type::Float:
+            case Type::Float:
                 return "float"; break;
-            case MT_Type::Double:
+            case Type::Double:
                 return "double"; break;
-            case MT_Type::LongDouble:
+            case Type::LongDouble:
                 return "long double"; break;
-            case MT_Type::Bool:
+            case Type::Bool:
                 return "bool"; break;
-            case MT_Type::VoidPointer:
+            case Type::VoidPointer:
                 return "void*"; break;
-            case MT_Type::String:
+            case Type::String:
                 return "std::string"; break;
-            case MT_Type::Vector2:
+            case Type::Vector2:
                 return "orxonox::Vector2"; break;
-            case MT_Type::Vector3:
+            case Type::Vector3:
                 return "orxonox::Vector3"; break;
-            case MT_Type::Vector4:
+            case Type::Vector4:
                 return "orxonox::Vector4"; break;
-            case MT_Type::ColourValue:
+            case Type::ColourValue:
                 return "orxonox::ColourValue"; break;
-            case MT_Type::Quaternion:
+            case Type::Quaternion:
                 return "orxonox::Quaternion"; break;
-            case MT_Type::Radian:
+            case Type::Radian:
                 return "orxonox::Radian"; break;
-            case MT_Type::Degree:
+            case Type::Degree:
                 return "orxonox::Degree"; break;
             default:
@@ -159,50 +161,26 @@
     }
 
-    MultiType::operator char()                 const { return (this->value_) ? ((this->value_->type_ == MT_Type::Char            ) ? (static_cast<MT_Value<char>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator unsigned char()        const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedChar    ) ? (static_cast<MT_Value<unsigned char>       *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator short()                const { return (this->value_) ? ((this->value_->type_ == MT_Type::Short           ) ? (static_cast<MT_Value<short>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator unsigned short()       const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedShort   ) ? (static_cast<MT_Value<unsigned short>      *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator int()                  const { return (this->value_) ? ((this->value_->type_ == MT_Type::Int             ) ? (static_cast<MT_Value<int>                 *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator unsigned int()         const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedInt     ) ? (static_cast<MT_Value<unsigned int>        *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator long()                 const { return (this->value_) ? ((this->value_->type_ == MT_Type::Long            ) ? (static_cast<MT_Value<long>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator unsigned long()        const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedLong    ) ? (static_cast<MT_Value<unsigned long>       *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator long long()            const { return (this->value_) ? ((this->value_->type_ == MT_Type::LongLong        ) ? (static_cast<MT_Value<long long>           *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator unsigned long long()   const { return (this->value_) ? ((this->value_->type_ == MT_Type::UnsignedLongLong) ? (static_cast<MT_Value<unsigned long long>  *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator float()                const { return (this->value_) ? ((this->value_->type_ == MT_Type::Float           ) ? (static_cast<MT_Value<float>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator double()               const { return (this->value_) ? ((this->value_->type_ == MT_Type::Double          ) ? (static_cast<MT_Value<double>              *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator long double()          const { return (this->value_) ? ((this->value_->type_ == MT_Type::LongDouble      ) ? (static_cast<MT_Value<long double>         *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator bool()                 const { return (this->value_) ? ((this->value_->type_ == MT_Type::Bool            ) ? (static_cast<MT_Value<bool>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator void*()                const { return (this->value_) ? ((this->value_->type_ == MT_Type::VoidPointer     ) ? (static_cast<MT_Value<void*>               *>(this->value_))->value_ : (*this->value_)) : 0;                      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator std::string()          const { return (this->value_) ? ((this->value_->type_ == MT_Type::String          ) ? (static_cast<MT_Value<std::string>         *>(this->value_))->value_ : (*this->value_)) : NilValue<std::string>();          } ///< Returns the current value, converted to the requested type.
-    MultiType::operator orxonox::Vector2()     const { return (this->value_) ? ((this->value_->type_ == MT_Type::Vector2         ) ? (static_cast<MT_Value<orxonox::Vector2>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector2>();     } ///< Returns the current value, converted to the requested type.
-    MultiType::operator orxonox::Vector3()     const { return (this->value_) ? ((this->value_->type_ == MT_Type::Vector3         ) ? (static_cast<MT_Value<orxonox::Vector3>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector3>();     } ///< Returns the current value, converted to the requested type.
-    MultiType::operator orxonox::Vector4()     const { return (this->value_) ? ((this->value_->type_ == MT_Type::Vector4         ) ? (static_cast<MT_Value<orxonox::Vector4>    *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Vector4>();     } ///< Returns the current value, converted to the requested type.
-    MultiType::operator orxonox::ColourValue() const { return (this->value_) ? ((this->value_->type_ == MT_Type::ColourValue     ) ? (static_cast<MT_Value<orxonox::ColourValue>*>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::ColourValue>(); } ///< Returns the current value, converted to the requested type.
-    MultiType::operator orxonox::Quaternion()  const { return (this->value_) ? ((this->value_->type_ == MT_Type::Quaternion      ) ? (static_cast<MT_Value<orxonox::Quaternion> *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Quaternion>();  } ///< Returns the current value, converted to the requested type.
-    MultiType::operator orxonox::Radian()      const { return (this->value_) ? ((this->value_->type_ == MT_Type::Radian          ) ? (static_cast<MT_Value<orxonox::Radian>     *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Radian>();      } ///< Returns the current value, converted to the requested type.
-    MultiType::operator orxonox::Degree()      const { return (this->value_) ? ((this->value_->type_ == MT_Type::Degree          ) ? (static_cast<MT_Value<orxonox::Degree>     *>(this->value_))->value_ : (*this->value_)) : NilValue<orxonox::Degree>();      } ///< Returns the current value, converted to the requested type.
-
-    template <> void MultiType::createNewValueContainer(const char& value)                 { this->value_ = new MT_Value<char>                (value, MT_Type::Char            ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const unsigned char& value)        { this->value_ = new MT_Value<unsigned char>       (value, MT_Type::UnsignedChar    ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const short& value)                { this->value_ = new MT_Value<short>               (value, MT_Type::Short           ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const unsigned short& value)       { this->value_ = new MT_Value<unsigned short>      (value, MT_Type::UnsignedShort   ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const int& value)                  { this->value_ = new MT_Value<int>                 (value, MT_Type::Int             ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const unsigned int& value)         { this->value_ = new MT_Value<unsigned int>        (value, MT_Type::UnsignedInt     ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const long& value)                 { this->value_ = new MT_Value<long>                (value, MT_Type::Long            ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const unsigned long& value)        { this->value_ = new MT_Value<unsigned long>       (value, MT_Type::UnsignedLong    ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const long long& value)            { this->value_ = new MT_Value<long long>           (value, MT_Type::LongLong        ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const unsigned long long& value)   { this->value_ = new MT_Value<unsigned long long>  (value, MT_Type::UnsignedLongLong); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const float& value)                { this->value_ = new MT_Value<float>               (value, MT_Type::Float           ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const double& value)               { this->value_ = new MT_Value<double>              (value, MT_Type::Double          ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const long double& value)          { this->value_ = new MT_Value<long double>         (value, MT_Type::LongDouble      ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const bool& value)                 { this->value_ = new MT_Value<bool>                (value, MT_Type::Bool            ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(      void* const& value)          { this->value_ = new MT_Value<void*>               (value, MT_Type::VoidPointer     ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const std::string& value)          { this->value_ = new MT_Value<std::string>         (value, MT_Type::String          ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value)     { this->value_ = new MT_Value<orxonox::Vector2>    (value, MT_Type::Vector2         ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value)     { this->value_ = new MT_Value<orxonox::Vector3>    (value, MT_Type::Vector3         ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value)     { this->value_ = new MT_Value<orxonox::Vector4>    (value, MT_Type::Vector4         ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value) { this->value_ = new MT_Value<orxonox::ColourValue>(value, MT_Type::ColourValue     ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value)  { this->value_ = new MT_Value<orxonox::Quaternion> (value, MT_Type::Quaternion      ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const orxonox::Radian& value)      { this->value_ = new MT_Value<orxonox::Radian>     (value, MT_Type::Radian          ); } ///< Creates a new value container for the given type.
-    template <> void MultiType::createNewValueContainer(const orxonox::Degree& value)      { this->value_ = new MT_Value<orxonox::Degree>     (value, MT_Type::Degree          ); } ///< Creates a new value container for the given type.
+    template <> void MultiType::createNewValueContainer(const char& value)                 { this->value_ = new MT_Value<char>                (value, Type::Char            ); }
+    template <> void MultiType::createNewValueContainer(const unsigned char& value)        { this->value_ = new MT_Value<unsigned char>       (value, Type::UnsignedChar    ); }
+    template <> void MultiType::createNewValueContainer(const short& value)                { this->value_ = new MT_Value<short>               (value, Type::Short           ); }
+    template <> void MultiType::createNewValueContainer(const unsigned short& value)       { this->value_ = new MT_Value<unsigned short>      (value, Type::UnsignedShort   ); }
+    template <> void MultiType::createNewValueContainer(const int& value)                  { this->value_ = new MT_Value<int>                 (value, Type::Int             ); }
+    template <> void MultiType::createNewValueContainer(const unsigned int& value)         { this->value_ = new MT_Value<unsigned int>        (value, Type::UnsignedInt     ); }
+    template <> void MultiType::createNewValueContainer(const long& value)                 { this->value_ = new MT_Value<long>                (value, Type::Long            ); }
+    template <> void MultiType::createNewValueContainer(const unsigned long& value)        { this->value_ = new MT_Value<unsigned long>       (value, Type::UnsignedLong    ); }
+    template <> void MultiType::createNewValueContainer(const long long& value)            { this->value_ = new MT_Value<long long>           (value, Type::LongLong        ); }
+    template <> void MultiType::createNewValueContainer(const unsigned long long& value)   { this->value_ = new MT_Value<unsigned long long>  (value, Type::UnsignedLongLong); }
+    template <> void MultiType::createNewValueContainer(const float& value)                { this->value_ = new MT_Value<float>               (value, Type::Float           ); }
+    template <> void MultiType::createNewValueContainer(const double& value)               { this->value_ = new MT_Value<double>              (value, Type::Double          ); }
+    template <> void MultiType::createNewValueContainer(const long double& value)          { this->value_ = new MT_Value<long double>         (value, Type::LongDouble      ); }
+    template <> void MultiType::createNewValueContainer(const bool& value)                 { this->value_ = new MT_Value<bool>                (value, Type::Bool            ); }
+    template <> void MultiType::createNewValueContainer(      void* const& value)          { this->value_ = new MT_Value<void*>               (value, Type::VoidPointer     ); }
+    template <> void MultiType::createNewValueContainer(const std::string& value)          { this->value_ = new MT_Value<std::string>         (value, Type::String          ); }
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector2& value)     { this->value_ = new MT_Value<orxonox::Vector2>    (value, Type::Vector2         ); }
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector3& value)     { this->value_ = new MT_Value<orxonox::Vector3>    (value, Type::Vector3         ); }
+    template <> void MultiType::createNewValueContainer(const orxonox::Vector4& value)     { this->value_ = new MT_Value<orxonox::Vector4>    (value, Type::Vector4         ); }
+    template <> void MultiType::createNewValueContainer(const orxonox::ColourValue& value) { this->value_ = new MT_Value<orxonox::ColourValue>(value, Type::ColourValue     ); }
+    template <> void MultiType::createNewValueContainer(const orxonox::Quaternion& value)  { this->value_ = new MT_Value<orxonox::Quaternion> (value, Type::Quaternion      ); }
+    template <> void MultiType::createNewValueContainer(const orxonox::Radian& value)      { this->value_ = new MT_Value<orxonox::Radian>     (value, Type::Radian          ); }
+    template <> void MultiType::createNewValueContainer(const orxonox::Degree& value)      { this->value_ = new MT_Value<orxonox::Degree>     (value, Type::Degree          ); }
 }
Index: code/trunk/src/libraries/util/MultiType.h
===================================================================
--- code/trunk/src/libraries/util/MultiType.h	(revision 9348)
+++ code/trunk/src/libraries/util/MultiType.h	(revision 9550)
@@ -51,5 +51,5 @@
      - @ref orxonox::MultiType::MultiType "The constructor"
      - The assignment operator= (orxonox::MultiType::operator=())
-     - @ref orxonox::MultiType::setValue() "setValue(value)"
+     - @ref orxonox::MultiType::set() "set(value)"
 
     If you assign another value of another type, the MultiType keeps "its" type and
@@ -58,14 +58,14 @@
     If you want to change the type, there are three possibilities:
      - @ref orxonox::MultiType::convert "convert<T>()" sets the type to T and converts the currently assigned value
-     - @ref orxonox::MultiType::setType "setType<T>()" sets the type to T and resets the value to zero using zeroise<T>()
-     - setValue<T>(value) assigns a new value and changes the type to T.
+     - @ref orxonox::MultiType::reset "reset<T>()" sets the type to T and resets the value to zero using zeroise<T>()
+     - force<T>(value) assigns a new value and changes the type to T.
 
     Examples:
     @code
-    MultiType a = 10;          // a has now the type int and the value 10
-    a.setValue("3.14");        // a has still the type int and "3.14" gets converted, therefore the value is now 3
-    a.setValue<float>("3.14"); // a has now the type float and "3.14" gets converted to 3.14f
-    a.convert<bool>();         // converts 3.14f to bool, which is true
-    a = false;                 // assigns false, this is equivalent to a.setValue(false)
+    MultiType a = 10;       // a has now the type int and the value 10
+    a.set("3.14");          // a has still the type int and "3.14" gets converted, therefore the value is now 3
+    a.force<float>("3.14"); // a has now the type float and "3.14" gets converted to 3.14f
+    a.convert<bool>();      // converts 3.14f to bool, which is true
+    a = false;              // assigns false, this is equivalent to a.setValue(false)
     @endcode
 
@@ -106,42 +106,9 @@
 #include <OgreColourValue.h>
 #include <loki/TypeTraits.h>
+#include "Math.h"
 #include "mbool.h"
 
 namespace orxonox
 {
-    /**
-        @brief Enum of all possible types of a MultiType.
-    */
-    namespace MT_Type
-    {
-        enum Value
-        {
-            Null,
-            Char,
-            UnsignedChar,
-            Short,
-            UnsignedShort,
-            Int,
-            UnsignedInt,
-            Long,
-            UnsignedLong,
-            LongLong,
-            UnsignedLongLong,
-            Float,
-            Double,
-            LongDouble,
-            Bool,
-            VoidPointer,
-            String,
-            Vector2,
-            Vector3,
-            Vector4,
-            ColourValue,
-            Quaternion,
-            Radian,
-            Degree
-        };
-    }
-
     /**
         @brief The MultiType can hold a value of many possible types and convert them to other types.
@@ -165,4 +132,38 @@
         template <typename T> friend class MT_Value;
 
+        struct Type
+        {
+            /**
+                @brief Enum of all possible types of a MultiType.
+            */
+            enum Enum
+            {
+                Null,
+                Char,
+                UnsignedChar,
+                Short,
+                UnsignedShort,
+                Int,
+                UnsignedInt,
+                Long,
+                UnsignedLong,
+                LongLong,
+                UnsignedLongLong,
+                Float,
+                Double,
+                LongDouble,
+                Bool,
+                VoidPointer,
+                String,
+                Vector2,
+                Vector3,
+                Vector4,
+                ColourValue,
+                Quaternion,
+                Radian,
+                Degree
+            };
+        };
+
     public:
         /**
@@ -173,17 +174,18 @@
         {
         public:
-            MT_ValueBase(MT_Type::Value type) : type_(type), bHasDefaultValue_(false) {}
-            virtual ~MT_ValueBase() {}
+            inline MT_ValueBase(void* data, Type::Enum type) : type_(type), bLastConversionSuccessful(true), data_(data) {}
+            inline virtual ~MT_ValueBase() {}
 
             virtual MT_ValueBase* clone() const = 0;
 
             virtual void reset() = 0;
-            virtual bool assimilate(const MultiType& other) = 0;
 
             /// Returns the type of the current value.
-            const MT_Type::Value& getType() const { return this->type_; }
+            inline const Type::Enum& getType() const { return this->type_; }
+            /// Returns true if the type of the stored value is T.
+            template <typename T> inline bool isType() const { return false; }
 
             /// Checks whether the value is a default one.
-            bool hasDefaultValue()   const { return this->bHasDefaultValue_; }
+            inline bool lastConversionSuccessful()   const { return this->bLastConversionSuccessful; }
 
             virtual bool setValue(const char& value)                 = 0;
@@ -211,4 +213,6 @@
             virtual bool setValue(const orxonox::Degree& value)      = 0;
 
+            virtual bool setValue(const MultiType& other)            = 0;
+
             virtual bool getValue(char*                 value) const = 0;
             virtual bool getValue(unsigned char*        value) const = 0;
@@ -235,263 +239,216 @@
             virtual bool getValue(orxonox::Degree*      value) const = 0;
 
-            virtual operator char()                 const = 0;
-            virtual operator unsigned char()        const = 0;
-            virtual operator short()                const = 0;
-            virtual operator unsigned short()       const = 0;
-            virtual operator int()                  const = 0;
-            virtual operator unsigned int()         const = 0;
-            virtual operator long()                 const = 0;
-            virtual operator unsigned long()        const = 0;
-            virtual operator long long()            const = 0;
-            virtual operator unsigned long long()   const = 0;
-            virtual operator float()                const = 0;
-            virtual operator double()               const = 0;
-            virtual operator long double()          const = 0;
-            virtual operator bool()                 const = 0;
-            virtual operator void*()                const = 0;
-            virtual operator std::string()          const = 0;
-            virtual operator orxonox::Vector2()     const = 0;
-            virtual operator orxonox::Vector3()     const = 0;
-            virtual operator orxonox::Vector4()     const = 0;
-            virtual operator orxonox::ColourValue() const = 0;
-            virtual operator orxonox::Quaternion()  const = 0;
-            virtual operator orxonox::Radian()      const = 0;
-            virtual operator orxonox::Degree()      const = 0;
+            template <typename T> T get() const
+            {
+                if (this->isType<T>())
+                    return *reinterpret_cast<const T*>(this->data_);
+                else
+                {
+                    T value;
+                    this->getValue(&value);
+                    return value;
+                }
+            }
 
             virtual void toString(std::ostream& outstream) const = 0;
 
-            virtual void importData( uint8_t*& mem )=0;
-            virtual void exportData( uint8_t*& mem ) const=0;
-            virtual uint8_t getSize() const=0;
-
-            MT_Type::Value type_;   ///< The type of the current value
-            bool bHasDefaultValue_; ///< True if the last conversion wasn't successful
+            virtual void importData(uint8_t*& mem) = 0;
+            virtual void exportData(uint8_t*& mem) const = 0;
+            virtual uint8_t getSize() const = 0;
+
+            Type::Enum type_;               ///< The type of the current value
+            bool bLastConversionSuccessful; ///< True if the last conversion was successful
+            void* data_;                    ///< For direct access to the value if the type is known
         };
 
         public:
-            inline MultiType()                                  : value_(0) {}                                      ///< Default constructor: Assigns no value and no type. The type will be determined by the first assignment of a value.
-            inline MultiType(const char& value)                 : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const unsigned char& value)        : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const short& value)                : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const unsigned short& value)       : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const int& value)                  : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const unsigned int& value)         : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const long& value)                 : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const unsigned long& value)        : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const long long& value)            : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const unsigned long long& value)   : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const float& value)                : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const double& value)               : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const long double& value)          : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const bool& value)                 : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(      void* const& value)          : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const std::string& value)          : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const orxonox::Vector2& value)     : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const orxonox::Vector3& value)     : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const orxonox::Vector4& value)     : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const orxonox::ColourValue& value) : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const orxonox::Quaternion& value)  : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const orxonox::Radian& value)      : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const orxonox::Degree& value)      : value_(0) { this->assignValue(value); }           ///< Constructor: Assigns the given value and sets the type.
-            inline MultiType(const orxonox::mbool& value)       : value_(0) { this->assignValue((bool)value); }     ///< Constructor: Assigns the given mbool and converts it to bool.
-            inline MultiType(const char* value)                 : value_(0) { this->setValue(std::string(value)); } ///< Constructor: Converts the char array to a std::string, assigns the value and sets the type.
-            inline MultiType(const MultiType& other)            : value_(0) { this->setValue(other); }              ///< Copyconstructor: Assigns value and type of the other MultiType.
-            inline MultiType(MT_Type::Value type)               : value_(0) { this->setType(type); }                ///< Constructor: Sets the type, the next assignment will determine the value.
+            static const MultiType Null;
+
+            /// Default constructor: Assigns no value and no type. The type will be determined by the first assignment of a value.
+            inline MultiType()                       : value_(0) { }
+            /// Constructor: Assigns the given value and sets the type.
+            template <typename V>
+            inline MultiType(const V& value)         : value_(0) { this->set(value); }
+            /// Copyconstructor: Assigns value and type of the other MultiType.
+            inline MultiType(const MultiType& other) : value_(0) { this->set(other); }
 
             /// Destructor: Deletes the MT_Value.
             inline ~MultiType() { if (this->value_) { delete this->value_; } }
 
-            template <typename V> inline MultiType& operator=(const V& value)         { this->setValue(value); return (*this); } ///< Assigns a new value. The value will be converted to the current type of the MultiType.
-            template <typename V> inline MultiType& operator=(V* value)               { this->setValue(value); return (*this); } ///< Assigns a pointer.
-            inline                       MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); } ///< Assigns the value of the other MultiType and converts it to the current type of the MultiType.
-            inline                       MultiType& operator=(MT_Type::Value type)    { this->setType(type);   return (*this); } ///< Resets the value and changes the type.
-
-            inline bool                                   setValue(const char& value);
-            inline bool                                   setValue(const unsigned char& value);
-            inline bool                                   setValue(const short& value);
-            inline bool                                   setValue(const unsigned short& value);
-            inline bool                                   setValue(const int& value);
-            inline bool                                   setValue(const unsigned int& value);
-            inline bool                                   setValue(const long& value);
-            inline bool                                   setValue(const unsigned long& value);
-            inline bool                                   setValue(const long long& value);
-            inline bool                                   setValue(const unsigned long long& value);
-            inline bool                                   setValue(const float& value);
-            inline bool                                   setValue(const double& value);
-            inline bool                                   setValue(const long double& value);
-            inline bool                                   setValue(const bool& value);
-            inline bool                                   setValue(      void* const& value);
-            inline bool                                   setValue(const std::string& value);
-            inline bool                                   setValue(const orxonox::Vector2& value);
-            inline bool                                   setValue(const orxonox::Vector3& value);
-            inline bool                                   setValue(const orxonox::Vector4& value);
-            inline bool                                   setValue(const orxonox::ColourValue& value);
-            inline bool                                   setValue(const orxonox::Quaternion& value);
-            inline bool                                   setValue(const orxonox::Radian& value);
-            inline bool                                   setValue(const orxonox::Degree& value);
-            inline bool                                   setValue(const char* value);
+            /// Assigns a new value. The value will be converted to the current type of the MultiType.
+            template <typename V> inline MultiType& operator=(const V& value)         { this->set(value); return (*this); }
             /// Assigns a pointer.
-            template <typename V> inline bool setValue(V* value)
+            template <typename V> inline MultiType& operator=(V* value)               { this->set(value); return (*this); }
+            /// Assigns the value of the other MultiType and converts it to the current type of the MultiType.
+            inline                       MultiType& operator=(const MultiType& other) { this->set(other); return (*this); }
+
+            /// Assigns the given value and converts it to the current type.
+            template <typename V> inline bool set(const V& value)
+            {
+                if (this->value_)
+                    return this->value_->setValue(value);
+
+                this->assignValue(value);
+                return true;
+            }
+            /// Assigns a pointer.
+            template <typename V> inline bool set(V* value)
             {
                 if (this->value_)
                     return this->value_->setValue(static_cast<void*>(const_cast<typename Loki::TypeTraits<V>::UnqualifiedType*>(value)));
-                else
-                    return this->assignValue     (static_cast<void*>(const_cast<typename Loki::TypeTraits<V>::UnqualifiedType*>(value)));
+
+                this->assignValue(static_cast<void*>(const_cast<typename Loki::TypeTraits<V>::UnqualifiedType*>(value)));
+                return true;
             }
             /// Assigns the value of the other MultiType and converts it to the current type.
-            bool                                          setValue(const MultiType& other) { if (this->value_) { return this->value_->assimilate(other); } else { if (other.value_) { this->value_ = other.value_->clone(); } return true; } }
+            inline bool set(const MultiType& other)
+            {
+                if (this->value_)
+                    return this->value_->setValue(other);
+                else if (other.value_)
+                    this->value_ = other.value_->clone();
+                return true;
+            }
+
             /// Changes the type to T and assigns the new value (which might be of another type than T - it gets converted).
-            template <typename T, typename V> inline bool setValue(const V& value) { this->setType<T>(); return this->setValue(value); }
-
+            template <typename T, typename V> inline bool force(const V& value)
+            {
+                this->reset<T>();
+                return this->set(value);
+            }
 
             /// Copies the other MultiType by assigning value and type.
-            inline void                       copy(const MultiType& other)    { if (this == &other) { return; } if (this->value_) { delete this->value_; } this->value_ = (other.value_) ? other.value_->clone() : 0; }
+            inline void copy(const MultiType& other)
+            {
+                if (this == &other)
+                    return;
+                if (this->value_)
+                    delete this->value_;
+                this->value_ = (other.value_) ? other.value_->clone() : 0;
+            }
 
             /// Converts the current value to type T.
-            template <typename T> inline bool convert()                       { return this->setValue<T>((typename Loki::TypeTraits<T>::UnqualifiedReferredType)(*this));  }
-            /// Converts the current value to the type of the other MultiType.
-            inline bool                       convert(const MultiType& other) { return this->convert(other.getType()); }
-            bool                              convert(MT_Type::Value type);
-
-            /// Current content gets deleted. New type is MT_Type::Null
-            inline void                       reset()                         { if (this->value_) delete this->value_; this->value_ = 0; }
-            /// Current content gets overridden with default zero value
-            inline void                       resetValue()                    { if (this->value_) this->value_->reset(); }
-
+            template <typename T> inline bool convert() { return this->force<T>(MultiType(*this)); }
+
+            /// Resets value and type. Type will be void afterwards and null() returns true.
+            inline void reset() { if (this->value_) delete this->value_; this->value_ = 0; }
             /// Resets the value and changes the internal type to T.
-            template <typename T> inline void setType()                       { this->assignValue(typename Loki::TypeTraits<T>::UnqualifiedReferredType()); }
-            /// Resets the value and changes the internal type to the type of the other MultiType.
-            inline void                       setType(const MultiType& other) { this->setType(other.getType());                                             }
-            /// Resets the value and changes the internal type to the given type.
-            inline void                       setType(MT_Type::Value type)    { this->reset(); this->convert(type); this->resetValue();                     }
-
-            /// Returns the current type.
-            inline MT_Type::Value             getType()                   const { return (this->value_) ? this->value_->type_ : MT_Type::Null; }
-            /// Returns true if the current type equals the given type.
-            inline bool                       isType(MT_Type::Value type) const { return (this->value_) ? (this->value_->type_ == type) : (type == MT_Type::Null); }
-            /// Returns true if the current type is T.
-            template <typename T> inline bool isType()                    const { return false; } // Only works for specialized values - see below
-            std::string                       getTypename()               const;
-
-            /// Saves the value of the MT to a bytestream (pointed at by mem) and increases mem pointer by size of MT
-            inline void                       exportData(uint8_t*& mem) const { assert(sizeof(MT_Type::Value)<=8); *static_cast<uint8_t*>(mem) = this->getType(); mem+=sizeof(uint8_t); this->value_->exportData(mem); }
-            /// Loads the value of the MT from a bytestream (pointed at by mem) and increases mem pointer by size of MT
-            inline void                       importData(uint8_t*& mem) { assert(sizeof(MT_Type::Value)<=8); this->setType(static_cast<MT_Type::Value>(*static_cast<uint8_t*>(mem))); mem+=sizeof(uint8_t); this->value_->importData(mem); }
-            /// Saves the value of the MT to a bytestream and increases pointer to bytestream by size of MT
-            inline uint8_t*&                  operator << (uint8_t*& mem) { importData(mem); return mem; }
-            /// Loads the value of the MT to a bytestream and increases pointer to bytestream by size of MT
-            inline void                       operator >> (uint8_t*& mem) const { exportData(mem); }
-            inline uint32_t                   getNetworkSize() const { assert(this->value_); return this->value_->getSize() + sizeof(uint8_t); }
-
-            /// Checks whether the value is a default one (assigned after a failed conversion)
-            bool                              hasDefaultValue() const { return this->value_->hasDefaultValue(); }
+            template <typename T> inline void reset() { this->assignValue(typename Loki::TypeTraits<T>::UnqualifiedReferredType()); }
+            /// Current value gets overridden with default zero value
+            inline void resetValue() { if (this->value_) this->value_->reset(); }
+
+            /// Returns true if the type of the current value is T.
+            template <typename T> inline bool isType() const { return (this->value_ ? this->value_->isType<T>() : false); }
+            std::string getTypename() const;
+
+            /// Checks whether the last conversion was successful
+            inline bool lastConversionSuccessful() const { return !this->value_ || this->value_->lastConversionSuccessful(); }
 
             /// Checks if the MT contains no value.
-            bool                              null() const { return (!this->value_); }
-
-            operator char()                  const;
-            operator unsigned char()         const;
-            operator short()                 const;
-            operator unsigned short()        const;
-            operator int()                   const;
-            operator unsigned int()          const;
-            operator long()                  const;
-            operator unsigned long()         const;
-            operator long long()             const;
-            operator unsigned long long()    const;
-            operator float()                 const;
-            operator double()                const;
-            operator long double()           const;
-            operator bool()                  const;
-            operator void*()                 const;
-            operator std::string()           const;
-            operator orxonox::Vector2()      const;
-            operator orxonox::Vector3()      const;
-            operator orxonox::Vector4()      const;
-            operator orxonox::ColourValue()  const;
-            operator orxonox::Quaternion()   const;
-            operator orxonox::Radian()       const;
-            operator orxonox::Degree()       const;
+            inline bool null() const { return !this->value_; }
+
+            inline operator char()                 const { return (this->value_ ? this->value_->get<char>()                 : 0); }
+            inline operator unsigned char()        const { return (this->value_ ? this->value_->get<unsigned char>()        : 0); }
+            inline operator short()                const { return (this->value_ ? this->value_->get<short>()                : 0); }
+            inline operator unsigned short()       const { return (this->value_ ? this->value_->get<unsigned short>()       : 0); }
+            inline operator int()                  const { return (this->value_ ? this->value_->get<int>()                  : 0); }
+            inline operator unsigned int()         const { return (this->value_ ? this->value_->get<unsigned int>()         : 0); }
+            inline operator long()                 const { return (this->value_ ? this->value_->get<long>()                 : 0); }
+            inline operator unsigned long()        const { return (this->value_ ? this->value_->get<unsigned long>()        : 0); }
+            inline operator long long()            const { return (this->value_ ? this->value_->get<long long>()            : 0); }
+            inline operator unsigned long long()   const { return (this->value_ ? this->value_->get<unsigned long long>()   : 0); }
+            inline operator float()                const { return (this->value_ ? this->value_->get<float>()                : 0); }
+            inline operator double()               const { return (this->value_ ? this->value_->get<double>()               : 0); }
+            inline operator long double()          const { return (this->value_ ? this->value_->get<long double>()          : 0); }
+            inline operator bool()                 const { return (this->value_ ? this->value_->get<bool>()                 : 0); }
+            inline operator void*()                const { return (this->value_ ? this->value_->get<void*>()                : 0); }
+            inline operator std::string()          const { return (this->value_ ? this->value_->get<std::string>()          : NilValue<std::string>()); }
+            inline operator orxonox::Vector2()     const { return (this->value_ ? this->value_->get<orxonox::Vector2>()     : NilValue<orxonox::Vector2>()); }
+            inline operator orxonox::Vector3()     const { return (this->value_ ? this->value_->get<orxonox::Vector3>()     : NilValue<orxonox::Vector3>()); }
+            inline operator orxonox::Vector4()     const { return (this->value_ ? this->value_->get<orxonox::Vector4>()     : NilValue<orxonox::Vector4>()); }
+            inline operator orxonox::ColourValue() const { return (this->value_ ? this->value_->get<orxonox::ColourValue>() : NilValue<orxonox::ColourValue>()); }
+            inline operator orxonox::Quaternion()  const { return (this->value_ ? this->value_->get<orxonox::Quaternion>()  : NilValue<orxonox::Quaternion>()); }
+            inline operator orxonox::Radian()      const { return (this->value_ ? this->value_->get<orxonox::Radian>()      : NilValue<orxonox::Radian>()); }
+            inline operator orxonox::Degree()      const { return (this->value_ ? this->value_->get<orxonox::Degree>()      : NilValue<orxonox::Degree>()); }
             /// Returns the current value, converted to a T* pointer.
             template <class T> operator T*() const { return (static_cast<T*>(this->operator void*())); }
 
-            inline bool getValue(char*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(unsigned char*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(short*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(unsigned short*       value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(int*                  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(unsigned int*         value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(long*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(unsigned long*        value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(long long*            value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(unsigned long long*   value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(float*                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(double*               value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(long double*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(bool*                 value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(void**                value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(std::string*          value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(orxonox::Vector2*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(orxonox::Vector3*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(orxonox::Vector4*     value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(orxonox::ColourValue* value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(orxonox::Quaternion*  value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(orxonox::Radian*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-            inline bool getValue(orxonox::Degree*      value) const { if (this->value_) { return this->value_->getValue(value); } return false; } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-
-            inline char                     getChar()             const { return this->operator char();                 } ///< Returns the current value, converted to the requested type.
-            inline unsigned char            getUnsignedChar()     const { return this->operator unsigned char();        } ///< Returns the current value, converted to the requested type.
-            inline short                    getShort()            const { return this->operator short();                } ///< Returns the current value, converted to the requested type.
-            inline unsigned short           getUnsignedShort()    const { return this->operator unsigned short();       } ///< Returns the current value, converted to the requested type.
-            inline int                      getInt()              const { return this->operator int();                  } ///< Returns the current value, converted to the requested type.
-            inline unsigned int             getUnsignedInt()      const { return this->operator unsigned int();         } ///< Returns the current value, converted to the requested type.
-            inline long                     getLong()             const { return this->operator long();                 } ///< Returns the current value, converted to the requested type.
-            inline unsigned long            getUnsignedLong()     const { return this->operator unsigned long();        } ///< Returns the current value, converted to the requested type.
-            inline long long                getLongLong()         const { return this->operator long long();            } ///< Returns the current value, converted to the requested type.
-            inline unsigned long long       getUnsignedLongLong() const { return this->operator unsigned long long();   } ///< Returns the current value, converted to the requested type.
-            inline float                    getFloat()            const { return this->operator float();                } ///< Returns the current value, converted to the requested type.
-            inline double                   getDouble()           const { return this->operator double();               } ///< Returns the current value, converted to the requested type.
-            inline long double              getLongDouble()       const { return this->operator long double();          } ///< Returns the current value, converted to the requested type.
-            inline bool                     getBool()             const { return this->operator bool();                 } ///< Returns the current value, converted to the requested type.
-            inline void*                    getVoid()             const { return this->operator void*();                } ///< Returns the current value, converted to the requested type.
-            inline std::string              getString()           const { return this->operator std::string();          } ///< Returns the current value, converted to the requested type.
-            inline orxonox::Vector2         getVector2()          const { return this->operator orxonox::Vector2();     } ///< Returns the current value, converted to the requested type.
-            inline orxonox::Vector3         getVector3()          const { return this->operator orxonox::Vector3();     } ///< Returns the current value, converted to the requested type.
-            inline orxonox::Vector4         getVector4()          const { return this->operator orxonox::Vector4();     } ///< Returns the current value, converted to the requested type.
-            inline orxonox::ColourValue     getColourValue()      const { return this->operator orxonox::ColourValue(); } ///< Returns the current value, converted to the requested type.
-            inline orxonox::Quaternion      getQuaternion()       const { return this->operator orxonox::Quaternion();  } ///< Returns the current value, converted to the requested type.
-            inline orxonox::Radian          getRadian()           const { return this->operator orxonox::Radian();      } ///< Returns the current value, converted to the requested type.
-            inline orxonox::Degree          getDegree()           const { return this->operator orxonox::Degree();      } ///< Returns the current value, converted to the requested type.
-            template <typename T> inline T* getPointer()          const { return static_cast<T*>(this->getVoid());      } ///< Returns the current value, converted to a T* pointer.
+            /// Assigns the value to the given pointer. The value gets converted if the types don't match.
+            template <typename T> inline bool getValue(T* value) const { if (this->value_) { return this->value_->getValue(value); } return false; }
+
+            /// Returns the current value, converted to the requested type.
+            template <typename T> inline T get() const { return *this; }
+
+
+            ///////////////////////////////
+            // network-related functions //
+            ///////////////////////////////
+            /// Saves the value of the MT to a bytestream (pointed at by mem) and increases mem pointer by size of MT
+            inline void exportData(uint8_t*& mem) const
+            {
+                assert(sizeof(Type::Enum) <= 8);
+                *static_cast<uint8_t*>(mem) = this->getType();
+                mem += sizeof(uint8_t);
+                this->value_->exportData(mem);
+            }
+            /// Loads the value of the MT from a bytestream (pointed at by mem) and increases mem pointer by size of MT
+            inline void importData(uint8_t*& mem)
+            {
+                assert(sizeof(Type::Enum) <= 8);
+                this->setType(static_cast<Type::Enum>(*static_cast<uint8_t*>(mem)));
+                mem += sizeof(uint8_t);
+                this->value_->importData(mem);
+            }
+            /// Saves the value of the MT to a bytestream and increases pointer to bytestream by size of MT
+            inline uint8_t*& operator<<(uint8_t*& mem)
+            {
+                importData(mem);
+                return mem;
+            }
+            /// Loads the value of the MT to a bytestream and increases pointer to bytestream by size of MT
+            inline void operator>>(uint8_t*& mem) const
+            {
+                exportData(mem);
+            }
+            inline uint32_t getNetworkSize() const
+            {
+                assert(this->value_);
+                return this->value_->getSize() + sizeof(uint8_t);
+            }
 
         private:
-            inline bool assignValue(const char& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Char)             { return this->value_->setValue(value); } else { this->changeValueContainer<char>(value);                 return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const unsigned char& value)        { if (this->value_ && this->value_->type_ == MT_Type::UnsignedChar)     { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned char>(value);        return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const short& value)                { if (this->value_ && this->value_->type_ == MT_Type::Short)            { return this->value_->setValue(value); } else { this->changeValueContainer<short>(value);                return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const unsigned short& value)       { if (this->value_ && this->value_->type_ == MT_Type::UnsignedShort)    { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned short>(value);       return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const int& value)                  { if (this->value_ && this->value_->type_ == MT_Type::Int)              { return this->value_->setValue(value); } else { this->changeValueContainer<int>(value);                  return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const unsigned int& value)         { if (this->value_ && this->value_->type_ == MT_Type::UnsignedInt)      { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned int>(value);         return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const long& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Long)             { return this->value_->setValue(value); } else { this->changeValueContainer<long>(value);                 return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const unsigned long& value)        { if (this->value_ && this->value_->type_ == MT_Type::UnsignedLong)     { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long>(value);        return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const long long& value)            { if (this->value_ && this->value_->type_ == MT_Type::LongLong)         { return this->value_->setValue(value); } else { this->changeValueContainer<long long>(value);            return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const unsigned long long& value)   { if (this->value_ && this->value_->type_ == MT_Type::UnsignedLongLong) { return this->value_->setValue(value); } else { this->changeValueContainer<unsigned long long>(value);   return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const float& value)                { if (this->value_ && this->value_->type_ == MT_Type::Float)            { return this->value_->setValue(value); } else { this->changeValueContainer<float>(value);                return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const double& value)               { if (this->value_ && this->value_->type_ == MT_Type::Double)           { return this->value_->setValue(value); } else { this->changeValueContainer<double>(value);               return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const long double& value)          { if (this->value_ && this->value_->type_ == MT_Type::LongDouble)       { return this->value_->setValue(value); } else { this->changeValueContainer<long double>(value);          return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const bool& value)                 { if (this->value_ && this->value_->type_ == MT_Type::Bool)             { return this->value_->setValue(value); } else { this->changeValueContainer<bool>(value);                 return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(      void* const& value)          { if (this->value_ && this->value_->type_ == MT_Type::VoidPointer)      { return this->value_->setValue(value); } else { this->changeValueContainer<void*>(value);                return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const std::string& value)          { if (this->value_ && this->value_->type_ == MT_Type::String)           { return this->value_->setValue(value); } else { this->changeValueContainer<std::string>(value);          return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const orxonox::Vector2& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector2)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector2>(value);     return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const orxonox::Vector3& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector3)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector3>(value);     return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const orxonox::Vector4& value)     { if (this->value_ && this->value_->type_ == MT_Type::Vector4)          { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Vector4>(value);     return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const orxonox::ColourValue& value) { if (this->value_ && this->value_->type_ == MT_Type::ColourValue)      { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::ColourValue>(value); return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const orxonox::Quaternion& value)  { if (this->value_ && this->value_->type_ == MT_Type::Quaternion)       { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Quaternion>(value);  return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const orxonox::Radian& value)      { if (this->value_ && this->value_->type_ == MT_Type::Radian)           { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      return true; } } ///< Assigns a new value by changing type and creating a new container.
-            inline bool assignValue(const orxonox::Degree& value)      { if (this->value_ && this->value_->type_ == MT_Type::Degree)           { return this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      return true; } } ///< Assigns a new value by changing type and creating a new container.
+            /// Assigns a new value by changing type and creating a new container.
+            template <typename T> inline void assignValue(const T& value)
+            {
+                if (this->isType<T>())
+                    this->value_->setValue(value);
+                else
+                    this->changeValueContainer(value);
+            }
+            /// Assigns a new value by changing type and creating a new container (overload for pointers).
+            template <typename T> inline void assignValue(T* const& value)
+            {
+                if (this->isType<void*>())
+                    this->value_->setValue(static_cast<void*>(value));
+                else
+                    this->changeValueContainer<void*>(value);
+            }
+
+            /// Resets the value and changes the internal type to the given type.
+            inline void setType(Type::Enum type) { this->reset(); this->convert(type); this->resetValue(); }
+            /// Returns the current type.
+            inline Type::Enum getType() const { return (this->value_) ? this->value_->type_ : Type::Null; }
+            /// Converts the current value to the given type.
+            bool convert(Type::Enum type);
 
             /// Changes the value container.
-            template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
+            template <typename T> inline void changeValueContainer(const T& value)
+            {
+                if (this->value_)
+                    delete this->value_;
+                this->createNewValueContainer(value);
+            }
             /// Creates a new value container (works only with specialized types).
-            template <typename T>        void createNewValueContainer(const T& value) { /* STATIC ASSERT */ *****value; return false; }
+            template <typename T> inline void createNewValueContainer(const T& value) { /* STATIC ASSERT */ *****value; return false; }
 
             MT_ValueBase* value_; //!< A pointer to the value container
@@ -499,52 +456,41 @@
 
     /// Puts the MultiType on a stream by using the native << operator of the current type.
-    _UtilExport inline std::ostream& operator<<(std::ostream& outstream, const MultiType& mt) { if (mt.value_) { mt.value_->toString(outstream); } return outstream; }
-
-    template <> inline bool MultiType::isType<char>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Char);             } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<unsigned char>()        const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedChar);     } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<short>()                const { return (this->value_ && this->value_->type_ == MT_Type::Short);            } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<unsigned short>()       const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedShort);    } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<int>()                  const { return (this->value_ && this->value_->type_ == MT_Type::Int);              } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<unsigned int>()         const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedInt);      } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<long>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Long);             } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<unsigned long>()        const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedLong);     } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<long long>()            const { return (this->value_ && this->value_->type_ == MT_Type::LongLong);         } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<unsigned long long>()   const { return (this->value_ && this->value_->type_ == MT_Type::UnsignedLongLong); } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<float>()                const { return (this->value_ && this->value_->type_ == MT_Type::Float);            } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<double>()               const { return (this->value_ && this->value_->type_ == MT_Type::Double);           } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<long double>()          const { return (this->value_ && this->value_->type_ == MT_Type::LongDouble);       } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<bool>()                 const { return (this->value_ && this->value_->type_ == MT_Type::Bool);             } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<void*>()                const { return (this->value_ && this->value_->type_ == MT_Type::VoidPointer);      } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<std::string>()          const { return (this->value_ && this->value_->type_ == MT_Type::String);           } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<orxonox::Vector2>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector2);          } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<orxonox::Vector3>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector3);          } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<orxonox::Vector4>()     const { return (this->value_ && this->value_->type_ == MT_Type::Vector4);          } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<orxonox::ColourValue>() const { return (this->value_ && this->value_->type_ == MT_Type::ColourValue);      } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<orxonox::Quaternion>()  const { return (this->value_ && this->value_->type_ == MT_Type::Quaternion);       } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<orxonox::Radian>()      const { return (this->value_ && this->value_->type_ == MT_Type::Radian);           } ///< Returns true if the current type equals the given type.
-    template <> inline bool MultiType::isType<orxonox::Degree>()      const { return (this->value_ && this->value_->type_ == MT_Type::Degree);           } ///< Returns true if the current type equals the given type.
-
-    /// Deletes the content, type becomes MT_Type::Null.
-    template <> inline bool MultiType::convert<void>()                 { this->reset(); return true; }
-
-    // Specialization to avoid ambiguities with the conversion operator
-    template <> inline bool MultiType::convert<std::string>()          { return this->setValue<std::string>         (this->operator std::string());          } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<orxonox::Vector2>()     { return this->setValue<orxonox::Vector2>    (this->operator orxonox::Vector2());     } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<orxonox::Vector3>()     { return this->setValue<orxonox::Vector3>    (this->operator orxonox::Vector3());     } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<orxonox::Vector4>()     { return this->setValue<orxonox::Vector4>    (this->operator orxonox::Vector4());     } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<orxonox::ColourValue>() { return this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<orxonox::Quaternion>()  { return this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion());  } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<orxonox::Radian>()      { return this->setValue<orxonox::Radian>     (this->operator orxonox::Radian());      } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<orxonox::Degree>()      { return this->setValue<orxonox::Degree>     (this->operator orxonox::Degree());      } ///< Converts the current value to the given type.
-
-    // Specialization to avoid ambiguities with the conversion operator
-    template <> inline bool MultiType::convert<const std::string&>()          { return this->convert<std::string>();          } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<const orxonox::Vector2&>()     { return this->convert<orxonox::Vector2>();     } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<const orxonox::Vector3&>()     { return this->convert<orxonox::Vector3>();     } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<const orxonox::Vector4&>()     { return this->convert<orxonox::Vector4>();     } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<const orxonox::ColourValue&>() { return this->convert<orxonox::ColourValue>(); } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<const orxonox::Quaternion&>()  { return this->convert<orxonox::Quaternion>();  } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<const orxonox::Radian&>()      { return this->convert<orxonox::Radian>();      } ///< Converts the current value to the given type.
-    template <> inline bool MultiType::convert<const orxonox::Degree&>()      { return this->convert<orxonox::Degree>();      } ///< Converts the current value to the given type.
+    _UtilExport inline std::ostream& operator<<(std::ostream& outstream, const MultiType& mt)
+    {
+        if (mt.value_)
+            mt.value_->toString(outstream);
+        return outstream;
+    }
+
+    template <> inline bool MultiType::MT_ValueBase::isType<char>()                 const { return this->type_ == Type::Char;             }
+    template <> inline bool MultiType::MT_ValueBase::isType<unsigned char>()        const { return this->type_ == Type::UnsignedChar;     }
+    template <> inline bool MultiType::MT_ValueBase::isType<short>()                const { return this->type_ == Type::Short;            }
+    template <> inline bool MultiType::MT_ValueBase::isType<unsigned short>()       const { return this->type_ == Type::UnsignedShort;    }
+    template <> inline bool MultiType::MT_ValueBase::isType<int>()                  const { return this->type_ == Type::Int;              }
+    template <> inline bool MultiType::MT_ValueBase::isType<unsigned int>()         const { return this->type_ == Type::UnsignedInt;      }
+    template <> inline bool MultiType::MT_ValueBase::isType<long>()                 const { return this->type_ == Type::Long;             }
+    template <> inline bool MultiType::MT_ValueBase::isType<unsigned long>()        const { return this->type_ == Type::UnsignedLong;     }
+    template <> inline bool MultiType::MT_ValueBase::isType<long long>()            const { return this->type_ == Type::LongLong;         }
+    template <> inline bool MultiType::MT_ValueBase::isType<unsigned long long>()   const { return this->type_ == Type::UnsignedLongLong; }
+    template <> inline bool MultiType::MT_ValueBase::isType<float>()                const { return this->type_ == Type::Float;            }
+    template <> inline bool MultiType::MT_ValueBase::isType<double>()               const { return this->type_ == Type::Double;           }
+    template <> inline bool MultiType::MT_ValueBase::isType<long double>()          const { return this->type_ == Type::LongDouble;       }
+    template <> inline bool MultiType::MT_ValueBase::isType<bool>()                 const { return this->type_ == Type::Bool;             }
+    template <> inline bool MultiType::MT_ValueBase::isType<void*>()                const { return this->type_ == Type::VoidPointer;      }
+    template <> inline bool MultiType::MT_ValueBase::isType<std::string>()          const { return this->type_ == Type::String;           }
+    template <> inline bool MultiType::MT_ValueBase::isType<orxonox::Vector2>()     const { return this->type_ == Type::Vector2;          }
+    template <> inline bool MultiType::MT_ValueBase::isType<orxonox::Vector3>()     const { return this->type_ == Type::Vector3;          }
+    template <> inline bool MultiType::MT_ValueBase::isType<orxonox::Vector4>()     const { return this->type_ == Type::Vector4;          }
+    template <> inline bool MultiType::MT_ValueBase::isType<orxonox::ColourValue>() const { return this->type_ == Type::ColourValue;      }
+    template <> inline bool MultiType::MT_ValueBase::isType<orxonox::Quaternion>()  const { return this->type_ == Type::Quaternion;       }
+    template <> inline bool MultiType::MT_ValueBase::isType<orxonox::Radian>()      const { return this->type_ == Type::Radian;           }
+    template <> inline bool MultiType::MT_ValueBase::isType<orxonox::Degree>()      const { return this->type_ == Type::Degree;           }
+
+    template <> inline bool MultiType::set(const char* value)  { return this->set(std::string(value)); }
+    template <> inline bool MultiType::set(const mbool& value) { return this->set((bool)value); }
+
+    // Spezializations for void
+    template <> inline bool MultiType::isType<void>() const { return this->null(); }
+    template <> inline bool MultiType::convert<void>() { this->reset(); return true; }
 
     template <> _UtilExport void MultiType::createNewValueContainer(const char& value);
@@ -571,31 +517,4 @@
     template <> _UtilExport void MultiType::createNewValueContainer(const orxonox::Radian& value);
     template <> _UtilExport void MultiType::createNewValueContainer(const orxonox::Degree& value);
-
-    inline bool MultiType::setValue(const char& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const unsigned char& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const short& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const unsigned short& value)        { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const int& value)                   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const unsigned int& value)          { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const long& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const unsigned long& value)         { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const long long& value)             { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const unsigned long long& value)    { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const float& value)                 { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const double& value)                { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const long double& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const bool& value)                  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(      void* const& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const std::string& value)           { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const orxonox::Vector2& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const orxonox::Vector3& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const orxonox::Vector4& value)      { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const orxonox::ColourValue& value)  { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const orxonox::Quaternion& value)   { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const orxonox::Radian& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const orxonox::Degree& value)       { if (this->value_) { return this->value_->setValue(value); } else { return this->assignValue(value); } } ///< Assigns the given value and converts it to the current type.
-
-    /// Assigns the given value and converts it to the current type.
-    inline bool MultiType::setValue(const char* value)                  { if (this->value_) { return this->value_->setValue(std::string(value)); } else { return this->assignValue(std::string(value)); } }
 }
 
Index: code/trunk/src/libraries/util/MultiTypeValue.h
===================================================================
--- code/trunk/src/libraries/util/MultiTypeValue.h	(revision 9348)
+++ code/trunk/src/libraries/util/MultiTypeValue.h	(revision 9550)
@@ -55,5 +55,5 @@
     public:
         /// Constructor: Assigns the value and the type identifier.
-        MT_Value(const T& value, MT_Type::Value type) : MT_ValueBase(type), value_(value) {}
+        MT_Value(const T& value, MultiType::Type::Enum type) : MT_ValueBase(&this->value_, type), value_(value) {}
 
         /// Creates a copy of itself.
@@ -61,22 +61,5 @@
 
         /// Resets the current value to the default.
-        inline void reset() { this->value_ = zeroise<T>(); bHasDefaultValue_ = true; }
-
-        /**
-            @brief Assigns the value of the other MultiType, converted to T.
-            @param other The other MultiType
-        */
-        inline bool assimilate(const MultiType& other)
-        {
-            if (other.value_)
-            {
-                return !(bHasDefaultValue_ = !other.value_->getValue(&value_));
-            }
-            else
-            {
-                this->value_ = zeroise<T>();
-                return !(bHasDefaultValue_ = true);
-            }
-        }
+        inline void reset() { this->value_ = zeroise<T>(); bLastConversionSuccessful = true; }
 
         inline bool getValue(char*                 value) const { return convertValue<T, char                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
@@ -95,60 +78,53 @@
         inline bool getValue(bool*                 value) const { return convertValue<T, bool                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
         inline bool getValue(void**                value) const { return convertValue<T, void*               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(std::string*          value) const { return convertValue<T, std::string         >(value, value_, zeroise<std::string>         ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Vector2*     value) const { return convertValue<T, orxonox::Vector2    >(value, value_, zeroise<orxonox::Vector2>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Vector3*     value) const { return convertValue<T, orxonox::Vector3    >(value, value_, zeroise<orxonox::Vector3>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Vector4*     value) const { return convertValue<T, orxonox::Vector4    >(value, value_, zeroise<orxonox::Vector4>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::ColourValue* value) const { return convertValue<T, orxonox::ColourValue>(value, value_, zeroise<orxonox::ColourValue>()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Quaternion*  value) const { return convertValue<T, orxonox::Quaternion >(value, value_, zeroise<orxonox::Quaternion> ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Radian*      value) const { return convertValue<T, orxonox::Radian     >(value, value_, zeroise<orxonox::Radian>     ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-        inline bool getValue(orxonox::Degree*      value) const { return convertValue<T, orxonox::Degree     >(value, value_, zeroise<orxonox::Degree>     ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
-
-        inline bool setValue(const char& value)                 { return !(bHasDefaultValue_ = !convertValue<char                , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned char& value)        { return !(bHasDefaultValue_ = !convertValue<unsigned char       , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const short& value)                { return !(bHasDefaultValue_ = !convertValue<short               , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned short& value)       { return !(bHasDefaultValue_ = !convertValue<unsigned short      , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const int& value)                  { return !(bHasDefaultValue_ = !convertValue<int                 , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned int& value)         { return !(bHasDefaultValue_ = !convertValue<unsigned int        , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const long& value)                 { return !(bHasDefaultValue_ = !convertValue<long                , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned long& value)        { return !(bHasDefaultValue_ = !convertValue<unsigned long       , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const long long& value)            { return !(bHasDefaultValue_ = !convertValue<long long           , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const unsigned long long& value)   { return !(bHasDefaultValue_ = !convertValue<unsigned long long  , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const float& value)                { return !(bHasDefaultValue_ = !convertValue<float               , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const double& value)               { return !(bHasDefaultValue_ = !convertValue<double              , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const long double& value)          { return !(bHasDefaultValue_ = !convertValue<long double         , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const bool& value)                 { return !(bHasDefaultValue_ = !convertValue<bool                , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(      void* const& value)          { return !(bHasDefaultValue_ = !convertValue<void*               , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const std::string& value)          { return !(bHasDefaultValue_ = !convertValue<std::string         , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Vector2& value)     { return !(bHasDefaultValue_ = !convertValue<orxonox::Vector2    , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Vector3& value)     { return !(bHasDefaultValue_ = !convertValue<orxonox::Vector3    , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Vector4& value)     { return !(bHasDefaultValue_ = !convertValue<orxonox::Vector4    , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::ColourValue& value) { return !(bHasDefaultValue_ = !convertValue<orxonox::ColourValue, T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Quaternion& value)  { return !(bHasDefaultValue_ = !convertValue<orxonox::Quaternion , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Radian& value)      { return !(bHasDefaultValue_ = !convertValue<orxonox::Radian     , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-        inline bool setValue(const orxonox::Degree& value)      { return !(bHasDefaultValue_ = !convertValue<orxonox::Degree     , T>(&value_, value, zeroise<T>())); } ///< Assigns the value by converting it to T.
-
-        inline operator char()                 const { return getConvertedValue<T, char>                (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator unsigned char()        const { return getConvertedValue<T, unsigned char>       (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator short()                const { return getConvertedValue<T, short>               (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator unsigned short()       const { return getConvertedValue<T, unsigned short>      (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator int()                  const { return getConvertedValue<T, int>                 (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator unsigned int()         const { return getConvertedValue<T, unsigned int>        (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator long()                 const { return getConvertedValue<T, long>                (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator unsigned long()        const { return getConvertedValue<T, unsigned long>       (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator long long()            const { return getConvertedValue<T, long long>           (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator unsigned long long()   const { return getConvertedValue<T, unsigned long long>  (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator float()                const { return getConvertedValue<T, float>               (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator double()               const { return getConvertedValue<T, double>              (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator long double()          const { return getConvertedValue<T, long double>         (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator bool()                 const { return getConvertedValue<T, bool>                (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator void*()                const { return getConvertedValue<T, void*>               (this->value_, 0); }     ///< Returns the current value, converted to the requested type.
-        inline operator std::string()          const { return getConvertedValue<T, std::string>         (this->value_, NilValue<std::string         >()); } ///< Returns the current value, converted to the requested type.
-        inline operator orxonox::Vector2()     const { return getConvertedValue<T, orxonox::Vector2>    (this->value_, NilValue<orxonox::Vector2    >()); } ///< Returns the current value, converted to the requested type.
-        inline operator orxonox::Vector3()     const { return getConvertedValue<T, orxonox::Vector3>    (this->value_, NilValue<orxonox::Vector3    >()); } ///< Returns the current value, converted to the requested type.
-        inline operator orxonox::Vector4()     const { return getConvertedValue<T, orxonox::Vector4>    (this->value_, NilValue<orxonox::Vector4    >()); } ///< Returns the current value, converted to the requested type.
-        inline operator orxonox::ColourValue() const { return getConvertedValue<T, orxonox::ColourValue>(this->value_, NilValue<orxonox::ColourValue>()); } ///< Returns the current value, converted to the requested type.
-        inline operator orxonox::Quaternion()  const { return getConvertedValue<T, orxonox::Quaternion> (this->value_, NilValue<orxonox::Quaternion >()); } ///< Returns the current value, converted to the requested type.
-        inline operator orxonox::Radian()      const { return getConvertedValue<T, orxonox::Radian>     (this->value_, NilValue<orxonox::Radian     >()); } ///< Returns the current value, converted to the requested type.
-        inline operator orxonox::Degree()      const { return getConvertedValue<T, orxonox::Degree>     (this->value_, NilValue<orxonox::Degree     >()); } ///< Returns the current value, converted to the requested type.
+        inline bool getValue(std::string*          value) const { return convertValue<T, std::string         >(value, value_, NilValue<std::string>         ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(orxonox::Vector2*     value) const { return convertValue<T, orxonox::Vector2    >(value, value_, NilValue<orxonox::Vector2>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(orxonox::Vector3*     value) const { return convertValue<T, orxonox::Vector3    >(value, value_, NilValue<orxonox::Vector3>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(orxonox::Vector4*     value) const { return convertValue<T, orxonox::Vector4    >(value, value_, NilValue<orxonox::Vector4>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(orxonox::ColourValue* value) const { return convertValue<T, orxonox::ColourValue>(value, value_, NilValue<orxonox::ColourValue>()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(orxonox::Quaternion*  value) const { return convertValue<T, orxonox::Quaternion >(value, value_, NilValue<orxonox::Quaternion> ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(orxonox::Radian*      value) const { return convertValue<T, orxonox::Radian     >(value, value_, NilValue<orxonox::Radian>     ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(orxonox::Degree*      value) const { return convertValue<T, orxonox::Degree     >(value, value_, NilValue<orxonox::Degree>     ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+
+        /**
+            @brief Assigns the value of the other MultiType, converted to T.
+            @param other The other MultiType
+        */
+        inline bool setValue(const MultiType& other)
+        {
+            if (other.value_)
+            {
+                return (this->bLastConversionSuccessful = other.value_->getValue(&value_));
+            }
+            else
+            {
+                this->value_ = zeroise<T>();
+                return (bLastConversionSuccessful = false);
+            }
+        }
+
+        inline bool setValue(const char& value)                 { return (bLastConversionSuccessful = convertValue<char                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const unsigned char& value)        { return (bLastConversionSuccessful = convertValue<unsigned char       , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const short& value)                { return (bLastConversionSuccessful = convertValue<short               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const unsigned short& value)       { return (bLastConversionSuccessful = convertValue<unsigned short      , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const int& value)                  { return (bLastConversionSuccessful = convertValue<int                 , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const unsigned int& value)         { return (bLastConversionSuccessful = convertValue<unsigned int        , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const long& value)                 { return (bLastConversionSuccessful = convertValue<long                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const unsigned long& value)        { return (bLastConversionSuccessful = convertValue<unsigned long       , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const long long& value)            { return (bLastConversionSuccessful = convertValue<long long           , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const unsigned long long& value)   { return (bLastConversionSuccessful = convertValue<unsigned long long  , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const float& value)                { return (bLastConversionSuccessful = convertValue<float               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const double& value)               { return (bLastConversionSuccessful = convertValue<double              , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const long double& value)          { return (bLastConversionSuccessful = convertValue<long double         , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const bool& value)                 { return (bLastConversionSuccessful = convertValue<bool                , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(      void* const& value)          { return (bLastConversionSuccessful = convertValue<void*               , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const std::string& value)          { return (bLastConversionSuccessful = convertValue<std::string         , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const orxonox::Vector2& value)     { return (bLastConversionSuccessful = convertValue<orxonox::Vector2    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const orxonox::Vector3& value)     { return (bLastConversionSuccessful = convertValue<orxonox::Vector3    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const orxonox::Vector4& value)     { return (bLastConversionSuccessful = convertValue<orxonox::Vector4    , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const orxonox::ColourValue& value) { return (bLastConversionSuccessful = convertValue<orxonox::ColourValue, T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const orxonox::Quaternion& value)  { return (bLastConversionSuccessful = convertValue<orxonox::Quaternion , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const orxonox::Radian& value)      { return (bLastConversionSuccessful = convertValue<orxonox::Radian     , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
+        inline bool setValue(const orxonox::Degree& value)      { return (bLastConversionSuccessful = convertValue<orxonox::Degree     , T>(&value_, value, NilValue<T>())); } ///< Assigns the value by converting it to T.
 
         /// Puts the current value on the stream
Index: code/trunk/src/libraries/util/SignalHandler.cc
===================================================================
--- code/trunk/src/libraries/util/SignalHandler.cc	(revision 9348)
+++ code/trunk/src/libraries/util/SignalHandler.cc	(revision 9550)
@@ -21,5 +21,6 @@
  *
  *   Author:
- *      Christoph Renner
+ *      Christoph Renner (Linux implementation)
+ *      Fabian 'x3n' Landau (Windows implementation)
  *   Co-authors:
  *      ...
@@ -139,11 +140,11 @@
       orxout(user_error) << "Received signal " << sigName.c_str() << endl << "Try to write backtrace to file orxonox_crash.log" << endl;
 
-      
+
       // First start GDB which will be attached to this process later on
-      
+
       int gdbIn[2];
       int gdbOut[2];
       int gdbErr[2];
-      
+
       if ( pipe(gdbIn) == -1 || pipe(gdbOut) == -1 || pipe(gdbErr) == -1 )
       {
@@ -151,8 +152,8 @@
         exit(EXIT_FAILURE);
       }
-      
+
       int gdbPid = fork();
       // this process will run gdb
-      
+
       if ( gdbPid == -1 )
       {
@@ -160,23 +161,23 @@
         exit(EXIT_FAILURE);
       }
-      
+
       if ( gdbPid == 0 )
       {
         // start gdb
-        
+
         close(gdbIn[1]);
         close(gdbOut[0]);
         close(gdbErr[0]);
-        
+
         dup2( gdbIn[0], STDIN_FILENO );
         dup2( gdbOut[1], STDOUT_FILENO );
         dup2( gdbErr[1], STDERR_FILENO );
-        
+
         execlp( "sh", "sh", "-c", "gdb", static_cast<void*>(NULL));
       }
-      
-      
+
+
       // Now start a fork of this process on which GDB will be attached on
-      
+
       int sigPipe[2];
       if ( pipe(sigPipe) == -1 )
@@ -202,5 +203,5 @@
       {
         getInstance().dontCatch();
-        
+
         // make sure gdb is allowed to attach to our PID even if there are some system restrictions
 #ifdef PR_SET_PTRACER
@@ -208,5 +209,5 @@
           orxout(user_error) << "could not set proper permissions for GDB to attach to process..." << endl;
 #endif
-        
+
         // wait for message from parent when it has attached gdb
         int someData;
Index: code/trunk/src/libraries/util/SignalHandler.h
===================================================================
--- code/trunk/src/libraries/util/SignalHandler.h	(revision 9348)
+++ code/trunk/src/libraries/util/SignalHandler.h	(revision 9550)
@@ -21,5 +21,6 @@
  *
  *   Author:
- *      Christoph Renner
+ *      Christoph Renner (Linux implementation)
+ *      Fabian 'x3n' Landau (Windows implementation)
  *   Co-authors:
  *      ...
Index: code/trunk/src/libraries/util/StringUtils.cc
===================================================================
--- code/trunk/src/libraries/util/StringUtils.cc	(revision 9348)
+++ code/trunk/src/libraries/util/StringUtils.cc	(revision 9550)
@@ -81,7 +81,8 @@
     }
 
-    /// Splits a given string by a delimiter and stores it in an output vector
+    /// Splits a given string by a delimiter and stores it in an output vector. See @ref SubString for a more sophisticated implementation.
     void vectorize(const std::string& str, char delimiter, std::vector<std::string>* output)
     {
+        output->clear();
         for (size_t start = 0, end = 0; end != std::string::npos; start = end + 1)
         {
@@ -92,5 +93,5 @@
 
     /**
-        @brief Returns the position of the next quotation mark in the string, starting with start.
+        @brief Returns the position of the next quotation mark in the string, starting with start. Escaped quotation marks (with \ in front) are not considered.
         @param str The string
         @param start The first position to look at
@@ -130,10 +131,8 @@
         size_t quote = static_cast<size_t>(-1);
         while ((quote = getNextQuote(str, quote + 1)) < pos)
-        {
-            if (quote == pos)
-                return false;
             quotecount++;
-        }
-
+
+        if (quote == pos)
+            return false;
         if (quote == std::string::npos)
             return false;
@@ -156,5 +155,5 @@
         size_t pos2 = getNextQuote(str, pos1 + 1);
         if (pos1 != std::string::npos && pos2 != std::string::npos)
-            return str.substr(pos1, pos2 - pos1 + 1);
+            return str.substr(pos1 + 1, pos2 - pos1 - 1);
         else
             return "";
@@ -247,23 +246,4 @@
     {
         return getStripped(str).empty();
-    }
-
-    /// Determines if a string contains only numbers and maximal one '.'.
-    bool isNumeric(const std::string& str)
-    {
-        bool foundPoint = false;
-
-        for (std::string::const_iterator it = str.begin(); it != str.end(); ++it)
-        {
-            if (((*it) < '0' || (*it) > '9'))
-            {
-                if ((*it) != '.' && !foundPoint)
-                    foundPoint = true;
-                else
-                    return false;
-            }
-        }
-
-        return true;
     }
 
@@ -444,21 +424,19 @@
     bool hasComment(const std::string& str)
     {
-        return (getCommentPosition(str) != std::string::npos);
-    }
-
-    /// If the string contains a comment, the comment gets returned (including the comment symbol), an empty string otherwise.
+        return (getNextCommentPosition(str) != std::string::npos);
+    }
+
+    /// If the string contains a comment, the comment gets returned (including the comment symbol and white spaces in front of it), an empty string otherwise.
     std::string getComment(const std::string& str)
     {
-        return str.substr(getCommentPosition(str));
-    }
-
-    /// If the string contains a comment, the position of the comment-symbol gets returned, @c std::string::npos otherwise.
-    size_t getCommentPosition(const std::string& str)
-    {
-        return getNextCommentPosition(str, 0);
-    }
-
-    /**
-        @brief Returns the position of the next comment-symbol, starting with @a start.
+        size_t pos = getNextCommentPosition(str);
+        if (pos == std::string::npos)
+            return "";
+        else
+            return str.substr(pos);
+    }
+
+    /**
+        @brief Returns the beginning of the next comment including whitespaces in front of the comment symbol.
         @param str The string
         @param start The first position to look at
Index: code/trunk/src/libraries/util/StringUtils.h
===================================================================
--- code/trunk/src/libraries/util/StringUtils.h	(revision 9348)
+++ code/trunk/src/libraries/util/StringUtils.h	(revision 9550)
@@ -58,5 +58,5 @@
     _UtilExport void         vectorize(const std::string& str, char delimiter, std::vector<std::string>* output);
 
-    _UtilExport size_t       getNextQuote(const std::string& str, size_t start);
+    _UtilExport size_t       getNextQuote(const std::string& str, size_t start = 0);
     _UtilExport bool         isBetweenQuotes(const std::string& str, size_t pos);
 
@@ -69,5 +69,4 @@
     _UtilExport bool         isEmpty(const std::string& str);
     _UtilExport bool         isComment(const std::string& str);
-    _UtilExport bool         isNumeric(const std::string& str);
 
     _UtilExport std::string  addSlashes(const std::string& str);
@@ -85,5 +84,4 @@
     _UtilExport bool         hasComment(const std::string& str);
     _UtilExport std::string  getComment(const std::string& str);
-    _UtilExport size_t       getCommentPosition(const std::string& str);
     _UtilExport size_t       getNextCommentPosition(const std::string& str, size_t start = 0);
 
Index: code/trunk/src/libraries/util/SubString.cc
===================================================================
--- code/trunk/src/libraries/util/SubString.cc	(revision 9348)
+++ code/trunk/src/libraries/util/SubString.cc	(revision 9550)
@@ -87,32 +87,17 @@
         @param other The other SubString
         @param begin The beginning of the subset
-
-        The subset ranges from the token with index @a begin to the end of the tokens.
-        If @a begin is greater than the greatest index, the new SubString will be empty.
-    */
-    SubString::SubString(const SubString& other, unsigned int begin)
-    {
-        for (unsigned int i = begin; i < other.size(); ++i)
-        {
-            this->tokens_.push_back(other[i]);
-            this->bTokenInSafemode_.push_back(other.isInSafemode(i));
-        }
-    }
-
-    /**
-        @brief creates a new SubString based on a subset of an other SubString.
-        @param other The other SubString
-        @param begin The beginning of the subset
-        @param end The end of the subset
-
-        The subset ranges from the token with index @a begin until (but not including) the token with index @a end.
-        If @a begin or @a end are beyond the allowed index, the resulting SubString will be empty.
-    */
-    SubString::SubString(const SubString& other, unsigned int begin, unsigned int end)
-    {
-        for (unsigned int i = begin; i < std::min(other.size(), end); ++i)
-        {
-            this->tokens_.push_back(other[i]);
-            this->bTokenInSafemode_.push_back(other.isInSafemode(i));
+        @param length The length of the subset
+
+        The subset ranges from the token with index @a begin and contains @a length elements.
+    */
+    SubString::SubString(const SubString& other, size_t begin, size_t length)
+    {
+        for (size_t i = 0; i < length; ++i)
+        {
+            if (begin + i >= other.size())
+                break;
+
+            this->tokens_.push_back(other[begin + i]);
+            this->bTokenInSafemode_.push_back(other.isInSafemode(begin + i));
         }
     }
@@ -123,7 +108,7 @@
         @param argv An array of pointers to the arguments
     */
-    SubString::SubString(unsigned int argc, const char** argv)
-    {
-        for(unsigned int i = 0; i < argc; ++i)
+    SubString::SubString(size_t argc, const char** argv)
+    {
+        for (size_t i = 0; i < argc; ++i)
         {
             this->tokens_.push_back(std::string(argv[i]));
@@ -158,24 +143,17 @@
 
     /**
-        @copydoc operator==
-    */
-    bool SubString::compare(const SubString& other) const
-    {
-        return (*this == other);
-    }
-
-    /**
         @brief Compares this SubString to another SubString and returns true if the first @a length values match.
         @param other The other SubString
         @param length How many tokens to compare
     */
-    bool SubString::compare(const SubString& other, unsigned int length) const
-    {
-        if (length > this->size() || length > other.size())
+    bool SubString::compare(const SubString& other, size_t length) const
+    {
+        if (std::min(length, this->size()) != std::min(length, other.size()))
             return false;
 
-        for (unsigned int i = 0; i < length; ++i)
+        for (size_t i = 0; i < std::min(length, this->size()); ++i)
             if ((this->tokens_[i] != other.tokens_[i]) || (this->bTokenInSafemode_[i] != other.bTokenInSafemode_[i]))
                 return false;
+
         return true;
     }
@@ -196,5 +174,5 @@
     SubString& SubString::operator+=(const SubString& other)
     {
-        for (unsigned int i = 0; i < other.size(); ++i)
+        for (size_t i = 0; i < other.size(); ++i)
         {
             this->tokens_.push_back(other[i]);
@@ -207,8 +185,8 @@
         @copydoc SubString(const std::string&,const std::string&,const std::string&,bool,char,bool,char,bool,char,char,bool,char)
     */
-    unsigned int SubString::split(const std::string& line,
-                                  const std::string& delimiters, const std::string& delimiterNeighbours, bool bAllowEmptyEntries,
-                                  char escapeChar, bool bRemoveEscapeChar, char safemodeChar, bool bRemoveSafemodeChar,
-                                  char openparenthesisChar, char closeparenthesisChar, bool bRemoveParenthesisChars, char commentChar)
+    size_t SubString::split(const std::string& line,
+                            const std::string& delimiters, const std::string& delimiterNeighbours, bool bAllowEmptyEntries,
+                            char escapeChar, bool bRemoveEscapeChar, char safemodeChar, bool bRemoveSafemodeChar,
+                            char openparenthesisChar, char closeparenthesisChar, bool bRemoveParenthesisChars, char commentChar)
     {
         this->tokens_.clear();
@@ -228,5 +206,5 @@
         {
             std::string retVal = this->tokens_[0];
-            for (unsigned int i = 1; i < this->tokens_.size(); ++i)
+            for (size_t i = 1; i < this->tokens_.size(); ++i)
                 retVal += delimiter + this->tokens_[i];
             return retVal;
@@ -239,32 +217,15 @@
         @brief Creates a subset of this SubString.
         @param begin The beginning of the subset
+        @param length The length of the subset
         @return A new SubString containing the defined subset.
 
-        The subset ranges from the token with index @a begin to the end of the tokens.
-        If @a begin is greater than the greatest index, the new SubString will be empty.
+        The subset ranges from the token with index @a begin and contains @a length elements.
 
         This function is added for your convenience, and does the same as
-        SubString::SubString(const SubString& other, unsigned int begin)
-    */
-    SubString SubString::subSet(unsigned int begin) const
-    {
-        return SubString(*this, begin);
-    }
-
-    /**
-        @brief Creates a subset of this SubString.
-        @param begin The beginning of the subset
-        @param end The ending of the subset
-        @return A new SubString containing the defined subset.
-
-        The subset ranges from the token with index @a begin until (but not including) the token with index @a end.
-        If @a begin or @a end are beyond the allowed index, the resulting SubString will be empty.
-
-        This function is added for your convenience, and does the same as
-        SubString::SubString(const SubString& other, unsigned int begin, unsigned int end)
-    */
-    SubString SubString::subSet(unsigned int begin, unsigned int end) const
-    {
-        return SubString(*this, begin, end);
+        SubString::SubString(const SubString& other, size_t begin, size_t length)
+    */
+    SubString SubString::subSet(size_t begin, size_t length) const
+    {
+        return SubString(*this, begin, length);
     }
 
@@ -298,6 +259,6 @@
     {
         SPLIT_LINE_STATE state = start_state;
-        unsigned int i = 0;
-        unsigned int fallBackNeighbours = 0;
+        size_t i = 0;
+        size_t fallBackNeighbours = 0;
 
         std::string token;
@@ -514,5 +475,5 @@
     {
         orxout(debug_output) << "Substring-information::count=" << this->tokens_.size() << " ::";
-        for (unsigned int i = 0; i < this->tokens_.size(); ++i)
+        for (size_t i = 0; i < this->tokens_.size(); ++i)
             orxout(debug_output) << "s" << i << "='" << this->tokens_[i].c_str() << "'::";
         orxout(debug_output) << endl;
Index: code/trunk/src/libraries/util/SubString.h
===================================================================
--- code/trunk/src/libraries/util/SubString.h	(revision 9348)
+++ code/trunk/src/libraries/util/SubString.h	(revision 9550)
@@ -58,5 +58,5 @@
     SubString tokens(text, SubString::WhiteSpaces, "", false, '\\', true, '"', true, '{', '}', true, '\0');
 
-    for (unsigned int i = 0; i < tokens.size(); ++i)
+    for (size_t i = 0; i < tokens.size(); ++i)
         orxout() << i << ": " << tokens[i] << endl;
     @endcode
@@ -127,7 +127,6 @@
                   bool bRemoveParenthesisChars = true,
                   char commentChar = '\0');
-        SubString(unsigned int argc, const char** argv);
-        SubString(const SubString& other, unsigned int begin);
-        SubString(const SubString& other, unsigned int begin, unsigned int end);
+        SubString(size_t argc, const char** argv);
+        SubString(const SubString& other, size_t begin, size_t length = std::string::npos);
         ~SubString();
 
@@ -135,6 +134,5 @@
         SubString& operator=(const SubString& other);
         bool operator==(const SubString& other) const;
-        bool compare(const SubString& other) const;
-        bool compare(const SubString& other, unsigned int length) const;
+        bool compare(const SubString& other, size_t length = std::string::npos) const;
         SubString operator+(const SubString& other) const;
         SubString& operator+=(const SubString& other);
@@ -144,16 +142,16 @@
         /////////////////////////////////////////
         // Split and Join the any String. ///////
-        unsigned int split(const std::string& line,
-                           const std::string& delimiters = SubString::WhiteSpaces,
-                           const std::string& delimiterNeighbours = "",
-                           bool bAllowEmptyEntries = false,
-                           char escapeChar ='\\',
-                           bool bRemoveEscapeChar = true,
-                           char safemodeChar = '"',
-                           bool bRemoveSafemodeChar = true,
-                           char openparenthesisChar = '{',
-                           char closeparenthesisChar = '}',
-                           bool bRemoveParenthesisChars = true,
-                           char commentChar = '\0');
+        size_t split(const std::string& line,
+                     const std::string& delimiters = SubString::WhiteSpaces,
+                     const std::string& delimiterNeighbours = "",
+                     bool bAllowEmptyEntries = false,
+                     char escapeChar ='\\',
+                     bool bRemoveEscapeChar = true,
+                     char safemodeChar = '"',
+                     bool bRemoveSafemodeChar = true,
+                     char openparenthesisChar = '{',
+                     char closeparenthesisChar = '}',
+                     bool bRemoveParenthesisChars = true,
+                     char commentChar = '\0');
 
         std::string join(const std::string& delimiter = " ") const;
@@ -161,6 +159,5 @@
 
         // retrieve a SubSet from the String
-        SubString subSet(unsigned int begin) const;
-        SubString subSet(unsigned int begin, unsigned int end) const;
+        SubString subSet(size_t begin, size_t length = std::string::npos) const;
 
         // retrieve Information from within
@@ -168,13 +165,13 @@
         inline bool empty() const { return this->tokens_.empty(); }
         /// Returns the number of tokens stored in this SubString
-        inline unsigned int size() const { return this->tokens_.size(); }
+        inline size_t size() const { return this->tokens_.size(); }
         /// Returns the i'th token from the subset of strings @param index The index of the requested token
-        inline const std::string& operator[](unsigned int index) const { return this->tokens_[index]; }
+        inline const std::string& operator[](size_t index) const { return this->tokens_[index]; }
         /// Returns the i'th token from the subset of strings @param index The index of the requested token
-        inline const std::string& getString(unsigned int index) const { return (*this)[index]; }
+        inline const std::string& getString(size_t index) const { return (*this)[index]; }
         /// Returns all tokens as std::vector
         inline const std::vector<std::string>& getAllStrings() const { return this->tokens_; }
         /// Returns true if the token is in safemode. @param index The index of the token
-        inline bool isInSafemode(unsigned int index) const { return this->bTokenInSafemode_[index]; }
+        inline bool isInSafemode(size_t index) const { return this->bTokenInSafemode_[index]; }
         /// Returns the front of the list of tokens.
         inline const std::string& front() const { return this->tokens_.front(); }
Index: code/trunk/src/libraries/util/UtilPrereqs.h
===================================================================
--- code/trunk/src/libraries/util/UtilPrereqs.h	(revision 9348)
+++ code/trunk/src/libraries/util/UtilPrereqs.h	(revision 9550)
@@ -84,7 +84,12 @@
 namespace orxonox
 {
+    class AdditionalContextListener;
+    class BaseWriter;
     class Clock;
+    class ConsoleWriter;
     class Exception;
     class ExprParser;
+    class LogWriter;
+    class MemoryWriter;
     class MultiType;
     class OutputListener;
@@ -96,7 +101,10 @@
     class ScopedSingleton;
     class ScopeListener;
+    template <class T>
+    class SharedPtr;
     class SignalHandler;
     template <class T>
     class Singleton;
+    class SubcontextOutputListener;
     class SubString;
 }
Index: code/trunk/src/libraries/util/VA_NARGS.h
===================================================================
--- code/trunk/src/libraries/util/VA_NARGS.h	(revision 9348)
+++ code/trunk/src/libraries/util/VA_NARGS.h	(revision 9550)
@@ -36,4 +36,6 @@
     type aware, but for different numbers of arguments is still very powerful).
 
+    Important: The macro can not be overloaded for 0 arguments: ORXONOX_VA_NARGS() returns 1!
+
     Example: A macro to call functions
     @code
@@ -64,4 +66,5 @@
 */
 
+#include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/facilities/expand.hpp>
 
Index: code/trunk/src/libraries/util/output/AdditionalContextListener.h
===================================================================
--- code/trunk/src/libraries/util/output/AdditionalContextListener.h	(revision 9550)
+++ code/trunk/src/libraries/util/output/AdditionalContextListener.h	(revision 9550)
@@ -0,0 +1,60 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *   Co-authors:
+ *      ...
+ *
+ */
+
+/**
+    @file
+    @ingroup Output
+    @brief Declaration of the AdditionalContextListener interface
+*/
+
+#ifndef _AdditionalContextListener_H__
+#define _AdditionalContextListener_H__
+
+#include "util/UtilPrereqs.h"
+
+#include <vector>
+
+#include "OutputDefinitions.h"
+
+namespace orxonox
+{
+    /**
+        @brief AdditionalContextListener is an interface which is used to notify OutputManager about additional contexts in OutputListeners
+    */
+    class _UtilExport AdditionalContextListener
+    {
+        public:
+            virtual ~AdditionalContextListener() {}
+
+            virtual void updatedLevelMask(const OutputListener* listener) = 0;
+            virtual void updatedAdditionalContextsLevelMask(const OutputListener* listener) = 0;
+            virtual void updatedAdditionalContextsMask(const OutputListener* listener) = 0;
+    };
+}
+
+#endif /* _AdditionalContextListener_H__ */
Index: code/trunk/src/libraries/util/output/ConsoleWriter.cc
===================================================================
--- code/trunk/src/libraries/util/output/ConsoleWriter.cc	(revision 9348)
+++ code/trunk/src/libraries/util/output/ConsoleWriter.cc	(revision 9550)
@@ -34,5 +34,4 @@
 #include "ConsoleWriter.h"
 
-#include <iostream>
 
 #include "OutputManager.h"
@@ -48,5 +47,5 @@
         After creation, the instance is enabled.
     */
-    ConsoleWriter::ConsoleWriter() : BaseWriter("Console")
+    ConsoleWriter::ConsoleWriter(std::ostream& outputStream) : BaseWriter("Console"), outputStream_(outputStream)
     {
 #ifdef ORXONOX_RELEASE
@@ -66,18 +65,9 @@
 
     /**
-        @brief Returns the only existing instance of this class.
-    */
-    /*static*/ ConsoleWriter& ConsoleWriter::getInstance()
-    {
-        static ConsoleWriter instance;
-        return instance;
-    }
-
-    /**
         @brief Inherited function from BaseWriter, writes output to the console using std::cout.
     */
     void ConsoleWriter::printLine(const std::string& line, OutputLevel)
     {
-        std::cout << line << std::endl;
+        this->outputStream_ << line << std::endl;
     }
 
Index: code/trunk/src/libraries/util/output/ConsoleWriter.h
===================================================================
--- code/trunk/src/libraries/util/output/ConsoleWriter.h	(revision 9348)
+++ code/trunk/src/libraries/util/output/ConsoleWriter.h	(revision 9550)
@@ -37,4 +37,7 @@
 
 #include "util/UtilPrereqs.h"
+
+#include <ostream>
+
 #include "BaseWriter.h"
 
@@ -44,14 +47,18 @@
         @brief ConsoleWriter inherits from BaseWriter and writes output to the console.
 
-        This class can be seen as an equivalent to std::cout within the output
-        system. It is implemented as a singleton for static acces.
+        This class can be seen as an equivalent to std::cout within the output system.
     */
     class _UtilExport ConsoleWriter : public BaseWriter
     {
         public:
-            static ConsoleWriter& getInstance();
+            ConsoleWriter(std::ostream& outputStream);
+            ConsoleWriter(const ConsoleWriter&);
+            virtual ~ConsoleWriter();
 
             void enable();
             void disable();
+
+            inline const std::ostream& getOutputStream() const
+                { return this->outputStream_; }
 
         protected:
@@ -59,9 +66,6 @@
 
         private:
-            ConsoleWriter();
-            ConsoleWriter(const ConsoleWriter&);
-            virtual ~ConsoleWriter();
-
-            bool bEnabled_; ///< If false, the instance will not write output to the console.
+            std::ostream& outputStream_; ///< The ostream to which the console writer writes its output
+            bool bEnabled_;              ///< If false, the instance will not write output to the console.
     };
 }
Index: code/trunk/src/libraries/util/output/LogWriter.cc
===================================================================
--- code/trunk/src/libraries/util/output/LogWriter.cc	(revision 9348)
+++ code/trunk/src/libraries/util/output/LogWriter.cc	(revision 9550)
@@ -39,7 +39,10 @@
 #include "OutputManager.h"
 #include "MemoryWriter.h"
+#include "util/Convert.h"
 
 namespace orxonox
 {
+    static const int MAX_ARCHIVED_FILES = 9;
+
     /**
         @brief Constructor, initializes the desired output levels and the name and path of the log-file, and opens the log-file.
@@ -58,9 +61,11 @@
         // get the path for a temporary file, depending on the system
 #ifdef ORXONOX_PLATFORM_WINDOWS
-        this->path_ = getenv("TEMP");
+        this->directory_ = getenv("TEMP");
 #else
-        this->path_ = "/tmp";
+        this->directory_ = "/tmp";
 #endif
-        this->bDefaultPath_ = true;
+
+        // send a message to the user so that he can find the file in the case of a crash.
+        OutputManager::getInstance().pushMessage(level::user_info, context::undefined(), "Opening log file " + this->getPath());
 
         this->openFile();
@@ -76,26 +81,13 @@
 
     /**
-        @brief Returns the only existing instance of this class.
-    */
-    /*static*/ LogWriter& LogWriter::getInstance()
-    {
-        static LogWriter instance;
-        return instance;
-    }
-
-    /**
         @brief Opens the log-file in order to write output to it.
     */
     void LogWriter::openFile()
     {
-        // get the full file-name
-        std::string name = this->path_ + '/' + this->filename_;
-
-        // if we open the log file in the default directory, send a message to the user so that he can find the file in the case of a crash.
-        if (this->bDefaultPath_)
-            OutputManager::getInstance().pushMessage(level::user_info, context::undefined(), "Opening log file " + name);
+        // archive the old log file
+        this->archive();
 
         // open the file
-        this->file_.open(name.c_str(), std::fstream::out);
+        this->file_.open(this->getPath().c_str(), std::fstream::out);
 
         // check if it worked and print some output
@@ -119,19 +111,63 @@
 
     /**
+     * @brief Archives old copies of the log file by adding increasing numbers to the filename.
+     */
+    void LogWriter::archive(int index)
+    {
+        std::string oldPath = this->getArchivedPath(index);
+
+        // see if the file already exists, otherwise return
+        std::ifstream stream(oldPath.c_str());
+        bool exists = stream.is_open();
+        stream.close();
+
+        if (!exists)
+            return;
+
+        if (index < MAX_ARCHIVED_FILES)
+        {
+            // increment the index and archive the file with the next higher index
+            this->archive(++index);
+
+            // create the new path based on the incremented index
+            std::string newPath = this->getArchivedPath(index);
+
+            // move the file
+            std::rename(oldPath.c_str(), newPath.c_str());
+        }
+        else
+        {
+            // delete the file
+            std::remove(oldPath.c_str());
+        }
+    }
+    
+    /**
+     * @brief Returns the path for archived copies of the logfile (based on the archive index)
+     */
+    std::string LogWriter::getArchivedPath(int index) const
+    {
+        std::string path = this->getPath();
+        if (index > 0)
+            path += '.' + multi_cast<std::string>(index);
+        return path;
+    }
+
+    /**
         @brief Changes the path of the log-file. Re-writes the log-file by using MemoryWriter.
     */
-    void LogWriter::setLogPath(const std::string& path)
+    void LogWriter::setLogDirectory(const std::string& directory)
     {
         // notify about the change of the log-file (because the old file will no longer be updated)
-        OutputManager::getInstance().pushMessage(level::internal_info, context::undefined(), "Migrating log file from " + this->path_ + "\nto " + path);
+        OutputManager::getInstance().pushMessage(level::internal_info, context::undefined(), "Migrating log file from " + this->directory_ + "\nto " + directory);
 
         // close the old file, update the path and open the new file
         this->closeFile();
-        this->path_ = path;
-        this->bDefaultPath_ = false;
+        this->directory_ = directory;
         this->openFile();
 
         // request old output from MemoryWriter
-        MemoryWriter::getInstance().resendOutput(this);
+        if (OutputManager::getInstance().getMemoryWriter())
+            OutputManager::getInstance().getMemoryWriter()->resendOutput(this);
     }
 
Index: code/trunk/src/libraries/util/output/LogWriter.h
===================================================================
--- code/trunk/src/libraries/util/output/LogWriter.h	(revision 9348)
+++ code/trunk/src/libraries/util/output/LogWriter.h	(revision 9550)
@@ -47,6 +47,5 @@
         @brief The LogWriter class inherits from BaseWriter and writes output to a log-file.
 
-        It is implemented as singleton because we (currently) use only one
-        log-file. The path of the file can be changed, in which case the file
+        The path of the file can be changed, in which case the file
         is rewritten by using the output stored by MemoryWriter. This adds the
         possibility to change the desired output levels before changing the
@@ -57,7 +56,16 @@
     {
         public:
-            static LogWriter& getInstance();
+            LogWriter();
+            LogWriter(const LogWriter&);
+            virtual ~LogWriter();
 
-            void setLogPath(const std::string& path);
+            void setLogDirectory(const std::string& directory);
+
+            /** @brief Returns the path to the logfile. */
+            inline std::string getPath() const
+                { return this->directory_ + '/' + this->filename_; }
+            /** @brief Returns the open file stream. */
+            inline const std::ofstream& getFile() const
+                { return this->file_; }
 
         protected:
@@ -65,15 +73,12 @@
 
         private:
-            LogWriter();
-            LogWriter(const LogWriter&);
-            virtual ~LogWriter();
-
             void openFile();
             void closeFile();
 
-            std::string filename_;  ///< The name of the log-file (without directories)
-            std::string path_;      ///< The path of the log-file (without file-name)
-            bool bDefaultPath_;     ///< If true, the log-file resides at the default path (which is usually a temporary directory)
+            void archive(int index = 0);
+            std::string getArchivedPath(int index) const;
 
+            std::string filename_;  ///< The name of the log-file (without directory)
+            std::string directory_; ///< The directory where the log-file resided (without file-name)
             std::ofstream file_;    ///< The output file stream.
     };
Index: code/trunk/src/libraries/util/output/MemoryWriter.cc
===================================================================
--- code/trunk/src/libraries/util/output/MemoryWriter.cc	(revision 9348)
+++ code/trunk/src/libraries/util/output/MemoryWriter.cc	(revision 9550)
@@ -53,13 +53,4 @@
 
     /**
-        @brief Returns the only existing instance of this singleton class.
-    */
-    /*static*/ MemoryWriter& MemoryWriter::getInstance()
-    {
-        static MemoryWriter instance;
-        return instance;
-    }
-
-    /**
         @brief Implementation of the output() function inherited from OutputListener, stores the received output in memory.
     */
Index: code/trunk/src/libraries/util/output/MemoryWriter.h
===================================================================
--- code/trunk/src/libraries/util/output/MemoryWriter.h	(revision 9348)
+++ code/trunk/src/libraries/util/output/MemoryWriter.h	(revision 9550)
@@ -67,5 +67,7 @@
 
         public:
-            static MemoryWriter& getInstance();
+            MemoryWriter();
+            MemoryWriter(const MemoryWriter&);
+            virtual ~MemoryWriter();
 
             void resendOutput(OutputListener* listener) const;
@@ -76,8 +78,4 @@
 
         private:
-            MemoryWriter();
-            MemoryWriter(const MemoryWriter&);
-            virtual ~MemoryWriter();
-
             std::vector<Message> messages_; ///< Stores all output messages from the creation of this instance until disable() is called.
     };
Index: code/trunk/src/libraries/util/output/OutputDefinitions.h
===================================================================
--- code/trunk/src/libraries/util/output/OutputDefinitions.h	(revision 9348)
+++ code/trunk/src/libraries/util/output/OutputDefinitions.h	(revision 9550)
@@ -47,6 +47,11 @@
     context argument.
 */
-#define REGISTER_OUTPUT_CONTEXT(name) \
-    const OutputContextContainer& name() { static const OutputContextContainer& context = registerContext(#name); return context; }
+#ifndef DISABLE_OUTPUT_CONTEXT_STATIC_CACHE
+    #define REGISTER_OUTPUT_CONTEXT(name) \
+        const OutputContextContainer& name() { static OutputContextContainer context = registerContext(#name); return context; }
+#else
+    #define REGISTER_OUTPUT_CONTEXT(name) \
+        const OutputContextContainer& name() { return registerContext(#name); }
+#endif
 
 /**
@@ -60,6 +65,11 @@
     individually by derivatives of orxonox::SubcontextOutputListener.
 */
-#define REGISTER_OUTPUT_SUBCONTEXT(name, subname) \
-    const OutputContextContainer& subname() { static const OutputContextContainer& context = registerContext(#name, #subname); return context; }
+#ifndef DISABLE_OUTPUT_CONTEXT_STATIC_CACHE
+    #define REGISTER_OUTPUT_SUBCONTEXT(name, subname) \
+        const OutputContextContainer& subname() { static const OutputContextContainer context = registerContext(#name, #subname); return context; }
+#else
+    #define REGISTER_OUTPUT_SUBCONTEXT(name, subname) \
+        const OutputContextContainer& subname() { return registerContext(#name, #subname); }
+#endif
 
 // tolua_begin
@@ -105,4 +115,9 @@
         OutputContextSubID sub_id;  ///< The id of the sub-context (or context::no_subcontext if this container doesn't define a sub-context)
         std::string name;           ///< The name of this context
+
+        inline bool operator==(const OutputContextContainer& other) const
+        {
+            return this->mask == other.mask && this->sub_id == other.sub_id && this->name == other.name;
+        }
     };
 
Index: code/trunk/src/libraries/util/output/OutputListener.cc
===================================================================
--- code/trunk/src/libraries/util/output/OutputListener.cc	(revision 9348)
+++ code/trunk/src/libraries/util/output/OutputListener.cc	(revision 9550)
@@ -62,4 +62,27 @@
 
     /**
+        @brief Adds a listener to the list.
+    */
+    void OutputListener::registerListener(AdditionalContextListener* listener)
+    {
+        this->listeners_.push_back(listener);
+    }
+
+    /**
+        @brief Removes a listener from the list.
+    */
+    void OutputListener::unregisterListener(AdditionalContextListener* listener)
+    {
+        for (std::vector<AdditionalContextListener*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
+        {
+            if (*it == listener)
+            {
+                this->listeners_.erase(it);
+                break;
+            }
+        }
+    }
+
+    /**
         @brief Defines the level mask in a way which accepts all output up to the level \c max.
     */
@@ -88,5 +111,6 @@
         this->levelMask_ = mask;
 
-        OutputManager::getInstance().updateCombinedLevelMask();
+        for (size_t i = 0; i < this->listeners_.size(); ++i)
+            this->listeners_[i]->updatedLevelMask(this);
     }
 
@@ -118,5 +142,6 @@
         this->additionalContextsLevelMask_ = mask;
 
-        OutputManager::getInstance().updateCombinedAdditionalContextsLevelMask();
+        for (size_t i = 0; i < this->listeners_.size(); ++i)
+            this->listeners_[i]->updatedAdditionalContextsLevelMask(this);
     }
 
@@ -128,5 +153,6 @@
         this->additionalContextsMask_ = mask;
 
-        OutputManager::getInstance().updateCombinedAdditionalContextsMask();
+        for (size_t i = 0; i < this->listeners_.size(); ++i)
+            this->listeners_[i]->updatedAdditionalContextsMask(this);
     }
 
Index: code/trunk/src/libraries/util/output/OutputListener.h
===================================================================
--- code/trunk/src/libraries/util/output/OutputListener.h	(revision 9348)
+++ code/trunk/src/libraries/util/output/OutputListener.h	(revision 9550)
@@ -55,4 +55,7 @@
             virtual ~OutputListener();
 
+            void registerListener(AdditionalContextListener* listener);
+            void unregisterListener(AdditionalContextListener* listener);
+
             void setLevelMax(OutputLevel max);
             void setLevelRange(OutputLevel min, OutputLevel max);
@@ -63,5 +66,5 @@
             void setAdditionalContextsLevelMask(OutputLevel mask);
 
-            void setAdditionalContextsMask(OutputContextMask mask);
+            virtual void setAdditionalContextsMask(OutputContextMask mask);
 
             /// @brief Returns the level mask.
@@ -78,5 +81,5 @@
 
             /// @brief Called by OutputManager for each line of output, checks if this listener actually accepts this output before it calls the output() function.
-            inline void unfilteredOutput(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines)
+            virtual void unfilteredOutput(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines)
                 { if (this->acceptsOutput(level, context)) this->output(level, context, lines); }
 
@@ -85,8 +88,13 @@
             virtual void output(OutputLevel level, const OutputContextContainer& context, const std::vector<std::string>& lines) = 0;
 
+            inline const std::vector<AdditionalContextListener*>& getListeners() const
+                { return this->listeners_; }
+
         private:
-            OutputLevel       levelMask_;                   ///< Mask of accepted output levels, independent of contexts
-            OutputContextMask additionalContextsMask_;      ///< Mask of accepted additional contexts
-            OutputLevel       additionalContextsLevelMask_; ///< Mask of accepted output levels of the additional contexts
+            std::vector<AdditionalContextListener*> listeners_; ///< List of all registered additional context listeners
+
+            OutputLevel       levelMask_;                       ///< Mask of accepted output levels, independent of contexts
+            OutputContextMask additionalContextsMask_;          ///< Mask of accepted additional contexts
+            OutputLevel       additionalContextsLevelMask_;     ///< Mask of accepted output levels of the additional contexts
     };
 
Index: code/trunk/src/libraries/util/output/OutputManager.cc
===================================================================
--- code/trunk/src/libraries/util/output/OutputManager.cc	(revision 9348)
+++ code/trunk/src/libraries/util/output/OutputManager.cc	(revision 9550)
@@ -33,4 +33,6 @@
 
 #include "OutputManager.h"
+
+#include <iostream>
 
 #include "MemoryWriter.h"
@@ -39,4 +41,5 @@
 #include "util/Output.h"
 #include "util/StringUtils.h"
+#include "util/SharedPtr.h"
 
 namespace orxonox
@@ -52,4 +55,12 @@
 
         this->subcontextCounter_ = 0;
+
+        this->isInitialized_ = false;
+        this->memoryWriterInstance_ = 0;
+        this->consoleWriterInstance_ = 0;
+        this->logWriterInstance_ = 0;
+
+        // register 'undefined' context in order to give it always the first context-ID
+        this->registerContext("undefined");
     }
 
@@ -59,4 +70,19 @@
     OutputManager::~OutputManager()
     {
+        while (!this->listeners_.empty())
+            this->unregisterListener(this->listeners_[0]);
+
+        if (this->memoryWriterInstance_)
+            delete this->memoryWriterInstance_;
+        if (this->consoleWriterInstance_)
+            delete this->consoleWriterInstance_;
+        if (this->logWriterInstance_)
+            delete this->logWriterInstance_;
+    }
+
+    /*static*/ SharedPtr<OutputManager>& OutputManager::Testing::getInstancePointer()
+    {
+        static SharedPtr<OutputManager> instance(new OutputManager());
+        return instance;
     }
 
@@ -66,6 +92,5 @@
     /*static*/ OutputManager& OutputManager::getInstance()
     {
-        static OutputManager instance;
-        return instance;
+        return *OutputManager::Testing::getInstancePointer();
     }
 
@@ -80,9 +105,12 @@
     /*static*/ OutputManager& OutputManager::getInstanceAndCreateListeners()
     {
-        static OutputManager& instance = OutputManager::getInstance();
-
-        static MemoryWriter& memoryWriterInstance = MemoryWriter::getInstance(); (void)memoryWriterInstance;
-        static ConsoleWriter& consoleWriterInstance = ConsoleWriter::getInstance(); (void)consoleWriterInstance;
-        static LogWriter& logWriterInstance = LogWriter::getInstance(); (void)logWriterInstance;
+        OutputManager& instance = *OutputManager::Testing::getInstancePointer();
+
+        if (!instance.isInitialized_) {
+            instance.isInitialized_ = true;
+            instance.memoryWriterInstance_ = new MemoryWriter();
+            instance.consoleWriterInstance_ = new ConsoleWriter(std::cout);
+            instance.logWriterInstance_ = new LogWriter();
+        }
 
         return instance;
@@ -113,4 +141,5 @@
     void OutputManager::registerListener(OutputListener* listener)
     {
+        listener->registerListener(this);
         this->listeners_.push_back(listener);
         this->updateMasks();
@@ -122,4 +151,5 @@
     void OutputManager::unregisterListener(OutputListener* listener)
     {
+        listener->unregisterListener(this);
         for (std::vector<OutputListener*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
         {
@@ -267,5 +297,5 @@
     {
         // "undefined" context is ignored because it's used implicitly if no explicit context is defined
-        static OutputContextMask undefined_mask = context::undefined().mask;
+        OutputContextMask undefined_mask = context::undefined().mask;
 
         std::string prefix = this->getLevelName(level) + ": ";
Index: code/trunk/src/libraries/util/output/OutputManager.h
===================================================================
--- code/trunk/src/libraries/util/output/OutputManager.h	(revision 9348)
+++ code/trunk/src/libraries/util/output/OutputManager.h	(revision 9550)
@@ -43,4 +43,5 @@
 
 #include "OutputDefinitions.h"
+#include "AdditionalContextListener.h"
 
 namespace orxonox
@@ -61,19 +62,29 @@
         Additionally OutputManager is used to register output contexts.
     */
-    class _UtilExport OutputManager
+    class _UtilExport OutputManager : public AdditionalContextListener
     {
         public:
+            OutputManager();
+            OutputManager(const OutputManager&);
+            virtual ~OutputManager();
+
             static OutputManager& getInstance();
             static OutputManager& getInstanceAndCreateListeners();
 
-            void pushMessage(OutputLevel level, const OutputContextContainer& context, const std::string& message);
+            inline MemoryWriter* getMemoryWriter()   { return this->memoryWriterInstance_; }
+            inline ConsoleWriter* getConsoleWriter() { return this->consoleWriterInstance_; }
+            inline LogWriter* getLogWriter()         { return this->logWriterInstance_; }
 
-            void registerListener(OutputListener* listener);
-            void unregisterListener(OutputListener* listener);
+            virtual void pushMessage(OutputLevel level, const OutputContextContainer& context, const std::string& message);
 
-            void updateMasks();
-            void updateCombinedLevelMask();
-            void updateCombinedAdditionalContextsLevelMask();
-            void updateCombinedAdditionalContextsMask();
+            virtual void registerListener(OutputListener* listener);
+            virtual void unregisterListener(OutputListener* listener);
+
+            virtual void updatedLevelMask(const OutputListener* listener)
+                { this->updateCombinedLevelMask(); }
+            virtual void updatedAdditionalContextsLevelMask(const OutputListener* listener)
+                { this->updateCombinedAdditionalContextsLevelMask(); }
+            virtual void updatedAdditionalContextsMask(const OutputListener* listener)
+                { this->updateCombinedAdditionalContextsMask(); }
 
             /**
@@ -95,8 +106,16 @@
             std::string getDefaultPrefix(OutputLevel level, const OutputContextContainer& context) const;
 
+            inline const std::vector<OutputListener*>& getListeners() const
+                { return this->listeners_; }
+
+            inline OutputLevel getCombinedLevelMask() const { return this->combinedLevelMask_; }
+            inline OutputLevel getCombinedAdditionalContextsLevelMask() const { return this->combinedAdditionalContextsLevelMask_; }
+            inline OutputContextMask getCombinedAdditionalContextsMask() const { return this->combinedAdditionalContextsMask_; }
+
         private:
-            OutputManager();
-            OutputManager(const OutputManager&);
-            ~OutputManager();
+            void updateMasks();
+            void updateCombinedLevelMask();
+            void updateCombinedAdditionalContextsLevelMask();
+            void updateCombinedAdditionalContextsMask();
 
             std::vector<OutputListener*> listeners_;                            ///< List of all registered output listeners
@@ -109,4 +128,15 @@
             std::map<std::string, OutputContextContainer> contextContainers_;   ///< Contains all contexts including sub-contexts and their containers
             OutputContextSubID subcontextCounter_;                              ///< Counts the number of sub-contexts (and generates their IDs)
+
+            bool isInitialized_;                                                ///< Becomes true once the following instances were created
+            MemoryWriter*  memoryWriterInstance_;                               ///< The main instance of MemoryWriter, managed by OutputManager
+            ConsoleWriter* consoleWriterInstance_;                              ///< The main instance of ConsoleWriter, managed by OutputManager
+            LogWriter*     logWriterInstance_;                                  ///< The main instance of LogWriter, managed by OutputManager
+
+        public:
+            struct _UtilExport Testing
+            {
+                static SharedPtr<OutputManager>& getInstancePointer();
+            };
     };
 }
Index: code/trunk/src/libraries/util/output/OutputStream.h
===================================================================
--- code/trunk/src/libraries/util/output/OutputStream.h	(revision 9348)
+++ code/trunk/src/libraries/util/output/OutputStream.h	(revision 9550)
@@ -102,4 +102,8 @@
             }
 
+            inline const OutputLevel getOutputLevel() const { return this->level_; }
+            inline const OutputContextContainer* getOutputContext() const { return this->context_; }
+            inline bool acceptsOutput() const { return this->bAcceptsOutput_; }
+
         private:
             /// @brief Generic function to add values to the output stream, using the inherited << operator from std::ostringstream.
Index: code/trunk/src/libraries/util/output/SubcontextOutputListener.h
===================================================================
--- code/trunk/src/libraries/util/output/SubcontextOutputListener.h	(revision 9348)
+++ code/trunk/src/libraries/util/output/SubcontextOutputListener.h	(revision 9550)
@@ -73,8 +73,11 @@
             virtual ~SubcontextOutputListener();
 
-            void setAdditionalContextsMask(OutputContextMask mask);
+            virtual void setAdditionalContextsMask(OutputContextMask mask);
             void setAdditionalSubcontexts(const std::set<const OutputContextContainer*>& subcontexts);
 
             virtual bool acceptsOutput(OutputLevel level, const OutputContextContainer& context) const;
+
+            inline const std::set<OutputContextSubID>& getSubcontexts() const
+                { return this->subcontexts_; }
 
         private:
