Index: code/trunk/src/libraries/util/Clipboard.cc
===================================================================
--- code/trunk/src/libraries/util/Clipboard.cc	(revision 7305)
+++ code/trunk/src/libraries/util/Clipboard.cc	(revision 7401)
@@ -54,6 +54,5 @@
 
     /**
-        @brief Puts text into the windows-clipboard
-        @param text The text
+        @brief Puts text into the Windows-clipboard
         @return True if the action was successful
     */
@@ -119,10 +118,9 @@
 namespace orxonox
 {
-    static std::string clipboard; //!< Keeps the text of our internal clipboard
+    static std::string clipboard; ///< Keeps the text of our internal clipboard
 
     /**
         @brief Default implementation if there is no OS-specific implementation or no clipboard. Copies the text into an internal clipboard.
-        @param text The text
-        @return True
+        @see fromClipboard()
     */
     bool toClipboard(const std::string& text)
@@ -134,5 +132,5 @@
     /**
         @brief Default implementation if there is no OS-specific implementation or no clipboard. Gets the text from the internal clipboard.
-        @return The text
+        @see toClipboard()
     */
     std::string fromClipboard()
Index: code/trunk/src/libraries/util/Clipboard.h
===================================================================
--- code/trunk/src/libraries/util/Clipboard.h	(revision 7305)
+++ code/trunk/src/libraries/util/Clipboard.h	(revision 7401)
@@ -29,12 +29,13 @@
 /**
     @file
-    @brief Some functions to exchange text between the OS clipboard and Orxonox.
+    @ingroup Util Command
+    @brief Some functions to exchange text between the OS clipboard and the Shell in Orxonox.
 
     Use fromClipboard() to get text from the clipboard (if there is any text) and
-    toClipboard(text) to put text into the clipboard.
+    toClipboard() to put text into the clipboard.
 
-    Those functions can only work properly if there's an OS-specific implementation.
-    If an OS isn't supported, the clipboard only works within Orxonox, but exchange
-    with other programs isn't possible.
+    These functions can only work properly if there's an OS-specific implementation
+    in Clipboard.cc. If a specific OS is not supported, the clipboard only works
+    within Orxonox, but the exchange with other programs is not possible.
 */
 
Index: code/trunk/src/libraries/util/Clock.cc
===================================================================
--- code/trunk/src/libraries/util/Clock.cc	(revision 7305)
+++ code/trunk/src/libraries/util/Clock.cc	(revision 7401)
@@ -45,13 +45,4 @@
     }
 
-    /**
-    @remarks
-        Mind the types! Ogre::Timer::getMicroseconds() will return an unsigned
-        long, which will eventually overflow. But if you use the subtraction of
-        the current time minus the last time the timer gave us and sum these up to
-        a 64 bit integer, we get the desired result.
-        Also mind that we don't have to store the last timer's time as unsigned long
-        as well because (unsigned long)tickTime_ will do exactly that.
-    */
     void Clock::capture()
     {
Index: code/trunk/src/libraries/util/Clock.h
===================================================================
--- code/trunk/src/libraries/util/Clock.h	(revision 7305)
+++ code/trunk/src/libraries/util/Clock.h	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @ingroup Util
+*/
+
 #ifndef _Clock_H__
 #define _Clock_H__
@@ -35,29 +40,73 @@
 namespace orxonox
 {
+    /** Simple real time clock based on Ogre::Timer
+    @details
+        The class can be used to both capture the current real time or to
+        incrementally capture the time and then distribute that time information
+        via Clock& references (for instance for the game tick). <br>
+        Precision: <br>
+    @par Precision
+        The maximum precision is given by the Ogre::Timer and that is somewhere
+        in the microsecond range for both Windows and UNIX.
+    @par Remarks for Usage on Windows
+        For proper functionality this class MUST be used in the same thread! <br>
+        Furthermore it might be possible that the Ogre::Timer has a performance
+        caveat because it will only capture the time on the same CPU core.
+        Confining the main thread to one process could speed up the game.
+        See \ref cmdargspage "Ccommandline Argument" 'limitToCPU' (only on Windows)
+    */
     class _UtilExport Clock
     {
     public:
+        /// Starts the time at 0
         Clock();
         ~Clock();
 
+        /** Internally captures the time and stays at that particular time
+        @remarks
+            Mind the types! Ogre::Timer::getMicroseconds() will return an unsigned
+            long, which will eventually overflow. But if you use the subtraction of
+            the current time minus the last time the timer gave us and sum these up to
+            a 64 bit integer, we get the desired result. <br>
+            Also mind that we don't have to store the last timer's time as unsigned long
+            as well because (unsigned long)tickTime_ will do exactly that.
+        */
         void capture();
 
-        unsigned long long getMicroseconds()   const { return tickTime_; }
-        unsigned long long getMilliseconds()   const { return tickTime_ / 1000; }
-        unsigned long      getSeconds()        const { return static_cast<long> (tickTime_ / 1000000); }
-        float              getSecondsPrecise() const { return static_cast<float>(tickTime_ / 1000000.0f); }
+        /// Returns the last captured absolute time in microseconds
+        unsigned long long getMicroseconds() const
+            { return tickTime_; }
+        /// Returns the last captured absolute time in milliseconds
+        unsigned long long getMilliseconds() const
+            { return tickTime_ / 1000; }
+        /// Returns the last captured absolute time in seconds
+        unsigned long getSeconds() const
+            { return static_cast<long> (tickTime_ / 1000000); }
+        /// Returns the last captured absolute time in seconds as float
+        float getSecondsPrecise() const
+            { return static_cast<float>(tickTime_ / 1000000.0f); }
 
-        float              getDeltaTime()      const { return tickDtFloat_; }
-        long               getDeltaTimeMicroseconds() const { return tickDt_; }
+        /// Returns the timespan in seconds between the last two calls to capture()
+        float getDeltaTime() const
+            { return tickDtFloat_; }
+        /// Returns the timespan in microseconds between the last two calls to capture()
+        long getDeltaTimeMicroseconds() const
+            { return tickDt_; }
 
+        /** Returns the current real time in microseconds
+        @note
+            This is especially useful to measure execution times because of the
+            high precision.
+        */
         unsigned long long getRealMicroseconds() const;
 
     private:
+        /// Undefined
         Clock(const Clock& instance);
 
-        Ogre::Timer*       timer_;
-        unsigned long long tickTime_;
-        long               tickDt_;
-        float              tickDtFloat_;
+        Ogre::Timer*       timer_;       ///< Ogre timer object
+        unsigned long long tickTime_;    ///< Currently captured time
+        long               tickDt_;      ///< Delta time in microseconds (cache value)
+        float              tickDtFloat_; ///< Delta time in seconds (cache value)
     };
 }
Index: code/trunk/src/libraries/util/Convert.cc
===================================================================
--- code/trunk/src/libraries/util/Convert.cc	(revision 7305)
+++ code/trunk/src/libraries/util/Convert.cc	(revision 7401)
@@ -32,5 +32,4 @@
 namespace orxonox
 {
-    //template <class FromType, class ToType>
     bool ConverterExplicit<std::string, bool>::convert(bool* output, const std::string& input)
     {
Index: code/trunk/src/libraries/util/Convert.h
===================================================================
--- code/trunk/src/libraries/util/Convert.h	(revision 7305)
+++ code/trunk/src/libraries/util/Convert.h	(revision 7401)
@@ -28,7 +28,94 @@
  */
 
-/*!
-    @file
-    @brief Definition and Implementation of the Convert class.
+/**
+    @defgroup Convert Conversion functions
+    @ingroup Util
+*/
+
+/** Functions that convert values between different types.
+@file
+@ingroup Convert
+@par Usage
+    There are three ways to use the conversions depending on what you need. <br>
+    - For simply converting values without having to know whether the conversion
+      was successful (for instance float --> string), use orxonox::multi_cast
+      which effectively works exactly like static_cast, etc.
+      @code
+        float input = 42.0;
+        std::string output = multi_cast<std::string>(input);
+      @endcode
+    - If you care about whether the conversion was successful,
+      use orxonox::convertValue.
+      @code
+        std::string input("3.4");
+        float output;
+        bool success = convertValue(&output, input);
+      @endcode
+    - If you care about success and if you can also feed a fallback value,
+      use orxonox::convertValue.
+      @code
+        std::string input("3.4");
+        float output;
+        bool success = convertValue(&output, input, 0.0);
+      @endcode
+    - If success doesn't matter but you can feed a fallback value,
+      use orxonox::getConvertedValue.
+      @code
+        std::string input("3.4");
+        float output = getConvertedValue(input, 0.0);
+      @endcode
+@details
+    The back end of these functions are the actual implementations for the
+    specific conversions, for instance from Ogre::Vector3 to std::string and
+    vice versa. Some of them also use the iostream operators. <br>
+    The real deal is evaluating which function is needed for a conversion based
+    on the input and output type. But there are lots of catches in conjunction
+    with templates which explains why there are so many functions in this file.
+    <br> <br>
+@par Search Order
+    Finding the right function is governed by priority rules: <br>
+    -# (Partial) template specialisation of orxonox::ConverterExplicit::convert()
+    -# An implicit conversion. This includes 'FooBar' to 'int' if FooBar
+       defines operator int() or float().
+    -# Global or member operators for iostream when converting from or
+       to std::string (and FROM const char*)
+    -# (Partial) template specialisation of orxonox::ConverterFallback::convert()
+    -# Fallback function that displays "Could not convert value" with type
+       information obtained from typeid().
+@par Implementing conversion functions
+    To do that you probably need to know a thing or two about the types
+    involved. So, get ready with that. <br>
+    Usually the best way to do it is specialising of the orxonox::ConverterFallback
+    template, like this:
+    @code
+    template <>
+    struct _UtilExport ConverterFallback<std::string, MyType>
+    {
+        static bool convert(MyType* output, const std::string& input)
+        {
+           ...
+           return success;
+        }
+    };
+    @endcode
+    This piece of code converts an std::string to MyType and returns whether the
+    conversion was successful. You can also use partial specialisation.<br>
+    The advantage with orxonox::ConverterFallback is that it has a low priority
+    meaning that when there is an implicit conversion or an iostream method, that
+    comes first and you don't have to deal with it (and the accompanying
+    function call ambiguity). <br>
+    However sometimes you would like to explicitely replace such a conversion.
+    That's where orxonox::ConverterExplicit comes in handy (for instance we
+    replaced the operator << conversions for Ogre::VectorX with our own functions).
+@note
+    There has to be an exact type match when using template specialisations. <br>
+    Template specialisations can be defined after including this file.
+    But any implicit cast function or iostream operator has to be included
+    in this file!
+@par Understanding the Code
+    In order to understand how the templates work, it is probably best to study
+    the functions in order of calling. There are lots of comments explaining
+    what happens, but you'll need to understand a deal about partial template
+    specialisation and function headers are matched in C++.
 */
 
@@ -46,33 +133,4 @@
 #include "ImplicitConversion.h"
 
-////////////////////////////////////
-//// ACTUAL CONVERSION SEQUENCE ////
-////////////////////////////////////
-/*
-    There is a distinct priority when choosing the right conversion function:
-    Overwrite:
-    1. (Partial) template specialisation of ConverterExplicit::convert()
-    Fallbacks:
-    2. Any possible implicit conversion. This includes 'FooBar' --> 'int' if FooBar defines operator float().
-    3. Global or member operators for stringstream when converting from or to std::string (or FROM const char*)
-    4. (Partial) template specialisation of ConverterFallback::convert()
-    5. Function that simply displays "Could not convert value" with type information obtained from typeid().
-
-    Notes:
-    There has to be an exact type match when using template specialisations.
-    Template specialisations can be defined after including this file. Any implicit cast function or iostream
-    operator has to be declared BEFORE this file gets parsed.
-
-    Defining your own functions:
-    There are obviously 4 ways to specify a user defined conversion. What should you use?
-
-    Usually, ConverterFallback fits quite well. You won't have to deal with the conversion from
-    'MyClass' to 'MyClass' by using another explicit template specialisation to avoid ambiguities.
-
-    However if you want to overwrite an implicit conversion or an iostream operator, you really need to
-    make use of ConverterExplicit. We have to do this for the Ogre classes for instance because they
-    define stream operators we don't particulary like.
-*/
-
 namespace orxonox
 {
@@ -81,5 +139,5 @@
     ///////////////////
 
-    // Default template. No conversion available at all.
+    /// Default template. No conversion available at all.
     template <class FromType, class ToType>
     struct ConverterFallback
@@ -93,5 +151,5 @@
     };
 
-    // If all else fails, try a dynamic_cast for pointer types.
+    /// If all else fails, try a dynamic_cast for pointer types.
     template <class FromType, class ToType>
     struct ConverterFallback<FromType*, ToType*>
@@ -109,32 +167,4 @@
         }
     };
-
-    ////////////
-    // upcast //
-    ////////////
-    namespace detail
-    {
-        // perform a static cast if ToType is a base of FromType
-        template<class ToType, class FromType>
-        FORCEINLINE ToType upcast(FromType input, Loki::Int2Type<true>)
-        {
-            return static_cast<ToType>(input);
-        }
-
-        // return zero if ToType is not a base of FromType
-        template<class ToType, class FromType>
-        FORCEINLINE ToType upcast(FromType input, Loki::Int2Type<false>)
-        {
-            return 0;
-        }
-    }
-
-    // performs an upcast if ToType is a base of FromType, returns zero otherwise
-    template <class ToType, class FromType>
-    FORCEINLINE ToType upcast(FromType input)
-    {
-        enum { probe = ImplicitConversion<FromType, ToType>::exists };
-        return detail::upcast<ToType, FromType>(input, Loki::Int2Type<probe>());
-    }
 }
 
@@ -144,5 +174,9 @@
 ///////////////////////
 
-// Default template for stringstream
+/** Fallback template for stringstream
+@details
+    Neither FromType nor ToType was std::string, therefore
+    delegate to orxonox::ConverterFallback
+*/
 template <class FromType, class ToType>
 struct ConverterStringStream
@@ -159,6 +193,8 @@
 /////////////
 
+/// Extra namespace to avoid exposing the iostream operators in it
 namespace fallbackTemplates
 {
+    /// Fallback operator <<() (delegates to orxonox::ConverterFallback)
     template <class FromType>
     FORCEINLINE bool operator <<(std::ostream& outstream,  const FromType& input)
@@ -175,5 +211,5 @@
 }
 
-// template that evaluates whether we can convert to std::string via ostringstream
+/// Template that evaluates whether we can convert to std::string via ostringstream
 template <class FromType>
 struct ConverterStringStream<FromType, std::string>
@@ -182,6 +218,8 @@
     {
         using namespace fallbackTemplates;
-        // this operator call only chooses fallbackTemplates::operator<< if there's no other fitting function
+        // this operator call only chooses fallbackTemplates::operator<<()
+        // if there's no other fitting function
         std::ostringstream oss;
+        // Note: std::ostream has operator!() to tell whether any error flag was set
         if (oss << input)
         {
@@ -201,13 +239,14 @@
 namespace fallbackTemplates
 {
+    /// Fallback operator >>() (delegates to orxonox::ConverterFallback)
     template <class ToType>
     FORCEINLINE bool operator >>(std::istream& instream, ToType& output)
     {
-        return orxonox::ConverterFallback<std::string, ToType>
-            ::convert(&output, static_cast<std::istringstream&>(instream).str());
+        std::string input(static_cast<std::istringstream&>(instream).str());
+        return orxonox::ConverterFallback<std::string, ToType>::convert(&output, input);
     }
 }
 
-// template that evaluates whether we can convert from std::string via ostringstream
+/// Template that evaluates whether we can convert from std::string via istringstream
 template <class ToType>
 struct ConverterStringStream<std::string, ToType>
@@ -216,6 +255,8 @@
     {
         using namespace fallbackTemplates;
+        // this operator call chooses fallbackTemplates::operator>>()
+        // only if there's no other fitting function
         std::istringstream iss(input);
-        // this operator call only chooses fallbackTemplates::operator>> if there's no other fitting function
+        // Note: std::istream has operator!() to tell whether any error flag was set
         if (iss >> (*output))
         {
@@ -229,10 +270,9 @@
 namespace orxonox
 {
-
     ///////////////////
     // Implicit Cast //
     ///////////////////
 
-    // implicit cast not possible, try stringstream conversion next
+    /// %Template delegates to ::ConverterStringStream
     template <class FromType, class ToType>
     FORCEINLINE bool convertImplicitely(ToType* output, const FromType& input, Loki::Int2Type<false>)
@@ -241,5 +281,5 @@
     }
 
-    // We can cast implicitely
+    /// Makes an implicit cast from \a FromType to \a ToType
     template <class FromType, class ToType>
     FORCEINLINE bool convertImplicitely(ToType* output, const FromType& input, Loki::Int2Type<true>)
@@ -254,5 +294,9 @@
     ////////////////////////////////
 
-    // Default template if no specialisation is available
+    /** Default template if no orxonox::ConverterExplicit is available
+    @details
+        Evaluates whether \a FromType can be implicitly converted to \a ToType
+        by the use the ImplicitConversion magic.
+    */
     template <class FromType, class ToType>
     struct ConverterExplicit
@@ -261,6 +305,5 @@
         FORCEINLINE static bool convert(ToType* output, const FromType& input)
         {
-            // Try implict cast and probe first. If a simple cast is not possible, it will not compile
-            // We therefore have to out source it into another template function
+            // Use the probe's value to delegate to the right function
             return convertImplicitely(output, input, Loki::Int2Type<probe>());
         }
@@ -275,7 +318,11 @@
     @brief
         Converts any value to any other as long as there exists a conversion.
+    @details
         Otherwise, the conversion will generate a runtime warning and return false.
-        For information about the different conversion methods (user defined too), see the section
-        'Actual conversion sequence' in this file above.
+    @see Convert.h
+    @param output
+        A pointer to the variable where the converted value will be stored
+    @param input
+        The original value
     */
     template <class FromType, class ToType>
@@ -291,7 +338,10 @@
         Converts any value to any other as long as there exists a conversion.
         Otherwise, the conversion will generate a runtime warning and return false.
-        For information about the different conversion methods (user defined too), see the section
-        'Actual conversion sequence' in this file above.
-        If the conversion doesn't succeed, 'fallback' is written to '*output'.
+        If the conversion doesn't succeed, \a fallback is written to \a output.
+    @see Convert.h
+    @param output
+        A pointer to the variable where the converted value will be stored
+    @param input
+        The original value
     @param fallback
         A default value that gets written to '*output' if there is no conversion.
@@ -309,7 +359,26 @@
     }
 
-    // Directly returns the converted value, even if the conversion was not successful.
+    /// Directly returns the converted value, but uses the fallback on failure. @see convertValue
     template<class FromType, class ToType>
-    FORCEINLINE ToType getConvertedValue(const FromType& input)
+    FORCEINLINE ToType getConvertedValue(const FromType& input, const ToType& fallback)
+    {
+        ToType output;
+        convertValue(&output, input, fallback);
+        return output;
+    }
+
+    /**
+    @brief
+        Converts any value to any other as long as there exists a conversion.
+    @details
+        Use exactly the way you use static_cast, etc. <br>
+        A failed conversion will return a default instance of \a ToType
+        (possibly uninitialised)
+    @see Convert.h
+    @param input
+        The original value
+    */
+    template<class ToType, class FromType>
+    FORCEINLINE ToType multi_cast(const FromType& input)
     {
         ToType output;
@@ -318,28 +387,9 @@
     }
 
-    // Directly returns the converted value, but uses the fallback on failure.
-    template<class FromType, class ToType>
-    FORCEINLINE ToType getConvertedValue(const FromType& input, const ToType& fallback)
-    {
-        ToType output;
-        convertValue(&output, input, fallback);
-        return output;
-    }
-
-    // Like getConvertedValue, but the template argument order is in reverse.
-    // That means you can call it exactly like static_cast<ToType>(fromTypeValue).
-    template<class ToType, class FromType>
-    FORCEINLINE ToType multi_cast(const FromType& input)
-    {
-        ToType output;
-        convertValue(&output, input);
-        return output;
-    }
-
     ////////////////////////////////
     // Special string conversions //
     ////////////////////////////////
 
-    // Delegate conversion from const char* to std::string
+    /// Delegates conversion from const char* to std::string
     template <class ToType>
     struct ConverterExplicit<const char*, ToType>
@@ -351,5 +401,5 @@
     };
 
-    // These conversions would exhibit ambiguous << or >> operators when using stringstream
+    /// Conversion would exhibit ambiguous << or >> operators when using iostream
     template <>
     struct ConverterExplicit<char, std::string>
@@ -361,4 +411,5 @@
         }
     };
+    /// Conversion would exhibit ambiguous << or >> operators when using iostream
     template <>
     struct ConverterExplicit<unsigned char, std::string>
@@ -370,4 +421,5 @@
         }
     };
+    /// Conversion would exhibit ambiguous << or >> operators when using iostream
     template <>
     struct ConverterExplicit<std::string, char>
@@ -382,4 +434,5 @@
         }
     };
+    /// Conversion would exhibit ambiguous << or >> operators when using iostream
     template <>
     struct ConverterExplicit<std::string, unsigned char>
@@ -396,5 +449,5 @@
 
 
-    // bool to std::string
+    /// Conversion from bool to std::string
     template <>
     struct ConverterExplicit<bool, std::string>
@@ -410,5 +463,5 @@
     };
 
-    // std::string to bool
+    /// Conversion from std::string to bool
     template <>
     struct _UtilExport ConverterExplicit<std::string, bool>
Index: code/trunk/src/libraries/util/Debug.h
===================================================================
--- code/trunk/src/libraries/util/Debug.h	(revision 7305)
+++ code/trunk/src/libraries/util/Debug.h	(revision 7401)
@@ -29,9 +29,15 @@
 
 /**
+    @defgroup COUT COUT(x) output macro
+    @ingroup Util
+*/
+
+/**
 @file
+@ingroup COUT
 @brief
-    Handles different output-levels of errors, warnings, infos and debug information.
+    Handles different output-levels of errors, warnings, infos, and debug information.
 
-    The COUT(level) macro acts like std::cout, but the output is only performed if the given
+    The COUT(level) macro acts like @c std::cout, but the output is only performed if the given
     level is <= the soft debug level.
 
@@ -39,18 +45,20 @@
      - The hard debug level is used during compile time. It describes the highest allowed output level.
      - The soft debug level is used during runtime and is the maximum of the three configurable
-       output-levels for console, log file and in game shell.
+       output-levels for console, log file, and in game shell.
 
     The separation between the three devices is done by the OutputHandler.
 
+    @anchor COUTlevels
     Possible levels are:
-     0: Very important output
-     1: Errors
-     2: Warnings
-     3: Information
-     4: Debug information
-     5: More debug information
-     6: Crazy debug information
+     - 0: Very important output
+     - 1: Errors
+     - 2: Warnings
+     - 3: Information
+     - 4: Debug information
+     - 5: More debug information
+     - 6: Crazy debug information
 
-@example
+    Example:
+    @code
     COUT(0) << "Very important output" << std::endl;
     COUT(1) << "Error: Something went wrong!" << std::endl;
@@ -58,4 +66,5 @@
     COUT(3) << "Info: It's Monday" << std::endl;
     COUT(4) << "Debug: x is 1.23456" << std::endl;
+    @endcode
 */
 
@@ -90,16 +99,20 @@
 /**
 @brief
-    Logs text output: use exactly like std::cout, but specify an output
-    level as argument.
-@details
-    (a > b ? 0 : c << "text") is equivalent to (a > b ? 0 : (c << "text"))
-    where (a > b ? 0 : ) stands for COUT(x). This should explain how
+    Logs text output: You can use COUT(level) exactly like @c std::cout, but you have to specify an output level as argument.
+@param level
+    The level of the following output (passed with <tt><< "text"</tt>). Lower levels are more important. See @ref COUTlevels "the description above" for a list of possible output levels.
+
+    Example:
+    @code
+    COUT(3) << "Some info" << std::endl; // Output with level 3
+    @endcode
+@note
+    <tt>(a > b ? 0 : c << "text")</tt> is equivalent to <tt>(a > b ? 0 : (c << "text")</tt>
+    where <tt>(a > b ? 0 : )</tt> stands for COUT(x). This should explain how
     this macro magic can possibly even work ;)
-@example
-    COUT(3) << "Some info" << std::endl;
-@note
-    The ? : operator requires both possible results to have the type of
+@remarks
+    The <tt>? :</tt> operator requires both possible results to have the type of
     the first. This is achieved by the int conversion operator dummy
-    in the OutputHandler.
+    in the @ref orxonox::OutputHandler.
 */
 #define COUT(level)                                                    \
Index: code/trunk/src/libraries/util/Exception.cc
===================================================================
--- code/trunk/src/libraries/util/Exception.cc	(revision 7305)
+++ code/trunk/src/libraries/util/Exception.cc	(revision 7401)
@@ -53,10 +53,4 @@
     { }
 
-    /**
-    @remarks
-        The composed full description gets stored to fullDescription_. But for compliance
-        with std::exception, this method has to be const. Hence fullDescription_ is declared
-        as mutable.
-    */
     const std::string& Exception::getFullDescription() const
     {
@@ -89,5 +83,4 @@
     }
 
-    //! Returns the error description
     const char* Exception::what() const throw()
     {
Index: code/trunk/src/libraries/util/Exception.h
===================================================================
--- code/trunk/src/libraries/util/Exception.h	(revision 7305)
+++ code/trunk/src/libraries/util/Exception.h	(revision 7401)
@@ -28,7 +28,29 @@
 
 /**
+    @defgroup ExceptionAssertion Exceptions and assertions
+    @ingroup Util
+*/
+
+/**
 @file
+@ingroup ExceptionAssertion
 @brief
     Declaration of facilities to handle exceptions.
+@details
+    Any exception thrown should inherit from orxonox::Exception. There is a macro
+    \ref CREATE_ORXONOX_EXCEPTION to create a new exception (you can find a list of
+    available exceptions in the docs of this file). <br>
+    Throwing exception is also very simple:
+    @code
+        ThrowException(General, "Something went wrong");
+    @endcode
+    (\c General is a type of exception, see docs of this file) <br>
+    The exception will automatically contain information about file, line number
+    and function name it occurred in. <br><br>
+    There is also some magic you can do for numbers, etc.:
+    @code
+        ThrowException(General, "Error code: " << myInt << ". more info...");
+    @endcode
+    It works with an std::ostringstream, so you can feed it all sorts of values.
 */
 
@@ -45,10 +67,9 @@
 namespace orxonox
 {
-    /**
-    @brief
-        Base class for all exceptions (derived from std::exception).
+    /** Base class for all exceptions (derived from std::exception).
     @details
         This class provides support for information about the file, the line
-        and the function the error occured.
+        and the function the error occurred.
+    @see Exception.h
     */
     class _UtilExport Exception : public std::exception
@@ -60,4 +81,10 @@
         @param description
             Exception description as string. This message is supposed to help developers!
+        @param lineNumber
+            The number of the code-line in which the exception occurred
+        @param filename
+            The file in which the exception occurred
+        @param functionName
+            The function in which the exception occurred
         */
         Exception(const std::string& description, unsigned int lineNumber,
@@ -68,7 +95,13 @@
         //! Needed for compatibility with std::exception
         virtual ~Exception() throw() { }
+        //! Returns the error description
         const char* what() const throw();
 
-        //! Returns a full description with type, line, file and function
+        /** Returns a full description with type, line, file and function
+        @remarks
+            The composed full description gets stored to fullDescription_. But for compliance
+            with std::exception, this method has to be const. Hence fullDescription_ is declared
+            as mutable.
+        */
         virtual const std::string& getFullDescription() const;
         //! Returns the string name of the exception type
@@ -101,5 +134,5 @@
     };
 
-//! Creates a new type of exception that inherits from tracker::Exception
+//! Creates a new type of exception that inherits from orxonox::Exception
 #define CREATE_ORXONOX_EXCEPTION(ExceptionName)                                     \
     class ExceptionName##Exception : public Exception                               \
@@ -123,5 +156,4 @@
     // Creates all possible exception types.
     // If you want to add a new type, simply copy and adjust a new line here.
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
     CREATE_ORXONOX_EXCEPTION(General);
     CREATE_ORXONOX_EXCEPTION(FileNotFound);
@@ -136,9 +168,6 @@
     CREATE_ORXONOX_EXCEPTION(NoGraphics);
     CREATE_ORXONOX_EXCEPTION(AbortLoading);
-#endif
 
-    /**
-    @brief
-        Helper function that forwards an exception and displays the message.
+    /** Helper function that forwards an exception and displays the message.
     @details
         This is necessary because only when using 'throw' the objects storage is managed.
@@ -152,11 +181,10 @@
     }
 
-/**
-@brief
-    Throws an exception and logs a message beforehand.
+/** Throws an exception and logs a message beforehand.
 @param type
     Type of the exception as literal (General, Initialisation, etc.)
 @param description
     Exception description as string
+@see Exception.h
 */
 #define ThrowException(type, description) \
Index: code/trunk/src/libraries/util/ExprParser.h
===================================================================
--- code/trunk/src/libraries/util/ExprParser.h	(revision 7305)
+++ code/trunk/src/libraries/util/ExprParser.h	(revision 7401)
@@ -28,6 +28,7 @@
 
 /**
-  @file
-  @brief Declaration of FloatParser
+@file
+@ingroup Util
+@brief Declaration of FloatParser
 */
 
@@ -42,4 +43,52 @@
 namespace orxonox
 {
+    /** Parser for expressions like \c "3 * cos(5 + 4) / a" where \a a is a predeclared
+        variable.
+    @par Usage
+        Using it is rather simple:
+        @code
+        std::string str("3 + 4");
+        ExprParser expr;
+        expr.parse(str);
+        if (expr.getSuccess())
+        {
+            if (!expr.getRemains().empty())
+            {
+                COUT(2) << "Warning: Expression could not be parsed to the end! Remains: '" << expr.getRemains() << '\'' << std::endl;
+            }
+            double result = expr.getResult();
+        }
+        else
+            COUT(1) << "Error: Cannot calculate expression: Parse error." << std::endl;
+        @endcode
+        getRemains() returns the expression after what could be parsed. For instance
+        \c "2*3 text" will return \c "text" as remains.
+    @details
+        The implementation of this class is really old and sort of a trial for
+        a first C++ class by Reto. That explains why it looks more like C than
+        C++... Also some of the variable names are in German. <br>
+        Explaining how it works exactly is probably not possible anymore, but it
+        is based on recursively parsing the expression character by character.
+        That much I can remember.
+    @par Functions, operators and variables supported
+        - Variables:
+            - e
+            - pi
+        - Functions:
+            - sin, asin, sinh, asinh
+            - cos, acos, cosh, acosh
+            - tan, atan, tanh, atanh
+            - int, floor, ceil, abs, sign
+            - pow, sqrt, exp, ln, log
+            - mod, div
+            - min, max
+            - radians, degrees
+        - Operators:
+            - +, -, ! (unary)
+            - +, -, *, /, %, ^, |, &, !, <, >, !=, <=, >=, =
+    @note
+        Operators may not be very consistent with C++ rules, but using the class
+        for plus and minus should be perfectly ok.
+    */
     class _UtilExport ExprParser
     {
Index: code/trunk/src/libraries/util/ImplicitConversion.h
===================================================================
--- code/trunk/src/libraries/util/ImplicitConversion.h	(revision 7305)
+++ code/trunk/src/libraries/util/ImplicitConversion.h	(revision 7401)
@@ -29,4 +29,5 @@
 /**
     @file
+    @ingroup Util
     @brief Declaration of various helper templates.
 */
Index: code/trunk/src/libraries/util/Math.cc
===================================================================
--- code/trunk/src/libraries/util/Math.cc	(revision 7305)
+++ code/trunk/src/libraries/util/Math.cc	(revision 7401)
@@ -91,10 +91,10 @@
         @param mydirection My viewing direction
         @param otherposition The position of the other object
-        @return The angle
-
-        @example
-        If the other object is exactly in front of me, the function returns 0.
-        If the other object is exactly behind me, the function returns pi.
-        If the other object is exactly right/left to me (or above/below), the function returns pi/2.
+        @return The angle in radian
+
+        Examples:
+         - If the other object is exactly in front of me, the function returns 0.
+         - If the other object is exactly behind me, the function returns pi.
+         - If the other object is exactly right/left to me (or above/below), the function returns pi/2.
     */
     float getAngle(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& otherposition)
@@ -116,10 +116,10 @@
         @return The viewing direction
 
-        @example
-        If the other object is exactly in front of me, the function returns Vector2(0, 0).
-        If the other object is exactly at my left, the function returns Vector2(-1, 0).
-        If the other object is exactly at my right, the function returns Vector2(1, 0).
-        If the other object is only a bit at my right, the function still returns Vector2(1, 0).
-        If the other object is exactly above me, the function returns Vector2(0, 1).
+        Examples:
+         - If the other object is exactly in front of me, the function returns <tt>Vector2(0, 0)</tt>.
+         - If the other object is exactly at my left, the function returns <tt>Vector2(-1, 0)</tt>.
+         - If the other object is exactly at my right, the function returns <tt>Vector2(1, 0)</tt>.
+         - If the other object is only a bit at my right, the function still returns <tt>Vector2(1, 0)</tt>.
+         - If the other object is exactly above me, the function returns <tt>Vector2(0, 1)</tt>.
     */
     orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
@@ -156,10 +156,10 @@
         @return The viewing direction
 
-        @example
-        If the other object is exactly in front of me, the function returns Vector2(0, 0).
-        If the other object is exactly at my left, the function returns Vector2(-0.5, 0).
-        If the other object is exactly at my right, the function returns Vector2(0.5, 0).
-        If the other object is only a bit at my right, the function still returns Vector2(0.01, 0).
-        If the other object is exactly above me, the function returns Vector2(0, 0.5).
+        Examples:
+         - If the other object is exactly in front of me, the function returns <tt>Vector2(0, 0)</tt>.
+         - If the other object is exactly at my left, the function returns <tt>Vector2(-0.5, 0)</tt>.
+         - If the other object is exactly at my right, the function returns <tt>Vector2(0.5, 0)</tt>.
+         - If the other object is only a bit at my right, the function still returns <tt>Vector2(0.01, 0)</tt>.
+         - If the other object is exactly above me, the function returns <tt>Vector2(0, 0.5)</tt>.
     */
     orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition)
@@ -220,4 +220,7 @@
     }
 
+    /**
+        @brief Returns a unique number. This function will never return the same value twice.
+    */
     unsigned long getUniqueNumber()
     {
Index: code/trunk/src/libraries/util/Math.h
===================================================================
--- code/trunk/src/libraries/util/Math.h	(revision 7305)
+++ code/trunk/src/libraries/util/Math.h	(revision 7401)
@@ -28,5 +28,11 @@
 
 /**
+    @defgroup Math Mathematical functions
+    @ingroup Util
+*/
+
+/**
     @file
+    @ingroup Math
     @brief Declaration and implementation of several math-functions, typedefs of some Ogre::Math classes to the orxonox namespace.
 */
@@ -62,17 +68,17 @@
     namespace math
     {
-        const float pi      = 3.14159265f;
-        const float pi_2    = 1.57079633f;
-        const float pi_4    = 7.85398163e-1f;
-        const float e       = 2.71828183f;
-        const float sqrt2   = 1.41421356f;
-        const float sqrt2_2 = 7.07106781e-1f;
-
-        const double pi_d      = 3.14159265358979324;
-        const double pi_2_d    = 1.57079632679489662;
-        const double pi_4_d    = 7.85398163397448310e-1;
-        const double e_d       = 2.71828182845904524;
-        const double sqrt2_d   = 1.41421356237309505;
-        const double sqrt2_2_d = 7.07106781186547524e-1;
+        const float pi      = 3.14159265f;      ///< PI
+        const float pi_2    = 1.57079633f;      ///< PI / 2
+        const float pi_4    = 7.85398163e-1f;   ///< PI / 4
+        const float e       = 2.71828183f;      ///< e
+        const float sqrt2   = 1.41421356f;      ///< sqrt(2)
+        const float sqrt2_2 = 7.07106781e-1f;   ///< sqrt(2) / 2
+
+        const double pi_d      = 3.14159265358979324;       ///< PI (double)
+        const double pi_2_d    = 1.57079632679489662;       ///< PI / 2 (double)
+        const double pi_4_d    = 7.85398163397448310e-1;    ///< PI / 4 (double)
+        const double e_d       = 2.71828182845904524;       ///< e (double)
+        const double sqrt2_d   = 1.41421356237309505;       ///< sqrt(2) (double)
+        const double sqrt2_2_d = 7.07106781186547524e-1;    ///< sqrt(2) / 2 (double)
     }
 
@@ -101,5 +107,5 @@
 
     /**
-        @brief Keeps a value between a lower and an upper limit.
+        @brief Keeps a value between a lower and an upper limit. Values beyond these limits are limited to either @a min or @a max.
         @param x The value
         @param min The lower limit
@@ -119,5 +125,5 @@
 
     /**
-        @brief Returns the square value (x^2).
+        @brief Returns the squared value (x^2).
     */
     template <typename T>
@@ -128,5 +134,5 @@
 
     /**
-        @brief Returns the cube value (x^3).
+        @brief Returns the cubed value (x^3).
     */
     template <typename T>
@@ -137,5 +143,5 @@
 
     /**
-        @brief Rounds the value.
+        @brief Rounds the value to the nearest integer.
     */
     template <typename T>
@@ -149,4 +155,17 @@
         @param x The value
         @param max The operand
+
+        The built in modulo operator % yields a strange behavior with negative values.
+        This function corrects this - the result is guaranteed to lie always between
+        zero and (max-1).
+
+        Example:
+        @code
+        int var = 11 % 10;      //  1
+        int var = -1 % 10;      // -1
+
+        int var = mod(11, 10);  //  1
+        int var = mod(-1, 10);  //  9
+        @endcode
     */
     template <typename T>
@@ -159,4 +178,12 @@
     }
 
+    /**
+        @brief Returns a "zero" value for the given type.
+        @note This is the default template of the zeroise() function. The template is spezialized for each supported type.
+
+        The exact return value of the function depends on the type. For @c int this is 0,
+        for @c float it's 0.0f. For a @c std::string the function returns "" and for
+        @c Vector3 you get <tt>Vector3(0, 0, 0)</tt>.
+    */
     template <typename T>
     inline T zeroise()
@@ -192,5 +219,8 @@
     template <> inline orxonox::Quaternion  zeroise<orxonox::Quaternion>()  { return orxonox::Quaternion (0, 0, 0, 0); }
 
-    //! Provides zero value symbols that can be returned as reference
+    /**
+        @brief Provides zero value symbols that can be returned as reference
+        @see zeroise()
+    */
     template <typename T>
     struct NilValue
@@ -207,8 +237,8 @@
     /**
         @brief Interpolates between two values for a time between 0 and 1.
-        @param time The time is a value between 0 and 1 - the function returns start if time is 0 and end if time is 1 and interpolates if time is between 0 and 1.
-        @param start The value at time = 0
-        @param end The value at time = 1
-        @return The interpolation at a given time
+        @param time The time is a value between 0 and 1 - the function returns @a start if @a time is 0, @a end if @a time is 1, and interpolates if @a time is between 0 and 1.
+        @param start The value at @a time = 0
+        @param end The value at @a time = 1
+        @return The interpolated value at a given time
     */
     template <typename T>
@@ -220,8 +250,8 @@
     /**
         @brief Interpolates smoothly between two values for a time between 0 and 1. The function starts slowly, increases faster and stops slowly again.
-        @param time The time is a value between 0 and 1 - the function returns start if time is 0 and end if time is 1 and interpolates if time is between 0 and 1.
-        @param start The value at time = 0
-        @param end The value at time = 1
-        @return The smoothed interpolation at a given time
+        @param time The time is a value between 0 and 1 - the function returns @a start if @a time is 0, @a end if @a time is 1, and interpolates if @a time is between 0 and 1.
+        @param start The value at @a time = 0
+        @param end The value at @a time = 1
+        @return The interpolated value at a given time
     */
     template <typename T>
@@ -232,5 +262,5 @@
 
     /**
-        @brief Returns a random number between 0 and almost 1: 0 <= rnd < 1.
+        @brief Returns a random number between 0 and almost 1: <tt>0 <= rnd < 1</tt>.
     */
     inline float rnd()
@@ -240,5 +270,5 @@
 
     /**
-        @brief Returns a random number between 0 and almost max: 0 <= rnd < max.
+        @brief Returns a random number between 0 and almost @a max: <tt>0 <= rnd < max</tt>.
         @param max The maximum
     */
@@ -249,5 +279,5 @@
 
     /**
-        @brief Returns a random number between min and almost max: min <= rnd < max.
+        @brief Returns a random number between @a min and almost @a max: <tt>min <= rnd < max</tt>.
         @param min The minimum
         @param max The maximum
@@ -268,4 +298,7 @@
     _UtilExport unsigned long getUniqueNumber();
 
+    /**
+        @brief A Vector class containing two integers @a x and @a y.
+    */
     class IntVector2
     {
@@ -277,4 +310,7 @@
     };
 
+    /**
+        @brief A Vector class containing three integers @a x, @a y, and @a z.
+    */
     class IntVector3
     {
Index: code/trunk/src/libraries/util/MathConvert.h
===================================================================
--- code/trunk/src/libraries/util/MathConvert.h	(revision 7305)
+++ code/trunk/src/libraries/util/MathConvert.h	(revision 7401)
@@ -28,7 +28,8 @@
 
 /**
-    @file
-    @brief
-        Math conversion functions. Definitions are in Math.cc
+@file
+@ingroup Convert
+@brief
+    Conversion functions for Math types like Ogre::Vector3 (definitions are in Math.cc)
 */
 
@@ -46,5 +47,5 @@
     ////////////////////
 
-    // Vector2 to std::string
+    /// Ogre::Vector2 to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Vector2, std::string>
@@ -62,5 +63,5 @@
     };
 
-    // Vector3 to std::string
+    /// Ogre::Vector3 to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Vector3, std::string>
@@ -78,5 +79,5 @@
     };
 
-    // Vector4 to std::string
+    /// Ogre::Vector4 to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Vector4, std::string>
@@ -94,5 +95,5 @@
     };
 
-    // Quaternion to std::string
+    /// Ogre::Quaternion to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Quaternion, std::string>
@@ -110,5 +111,5 @@
     };
 
-    // ColourValue to std::string
+    /// Ogre::ColourValue to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::ColourValue, std::string>
@@ -131,17 +132,17 @@
     ////////////////////
 
-    // std::string to Vector2
+    /// std::string to Ogre::Vector2 conversion
     template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector2>
     { static bool convert(orxonox::Vector2*     output, const std::string& input); };
-    // std::string to Vector3
+    /// std::string to Ogre::Vector3 conversion
     template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector3>
     { static bool convert(orxonox::Vector3*     output, const std::string& input); };
-    // std::string to Vector4
+    /// std::string to Ogre::Vector4 conversion
     template <> struct _UtilExport ConverterFallback<std::string, orxonox::Vector4>
     { static bool convert(orxonox::Vector4*     output, const std::string& input); };
-    // std::string to Quaternion
+    /// std::string to Ogre::Quaternion conversion
     template <> struct _UtilExport ConverterFallback<std::string, orxonox::Quaternion>
     { static bool convert(orxonox::Quaternion*  output, const std::string& input); };
-    // std::string to ColourValue
+    /// std::string to Ogre::ColourValue conversion
     template <> struct _UtilExport ConverterFallback<std::string, orxonox::ColourValue>
     { static bool convert(orxonox::ColourValue* output, const std::string& input); };
@@ -152,5 +153,5 @@
     ///////////////////////////////
 
-    // From Radian
+    /// Delegates conversions from Radian to conversions from float
     template <class ToType>
     struct ConverterFallback<orxonox::Radian, ToType>
@@ -162,5 +163,5 @@
     };
 
-    // From Degree
+    /// Delegates conversions from Degree to conversions from float
     template <class ToType>
     struct ConverterFallback<orxonox::Degree, ToType>
@@ -172,5 +173,5 @@
     };
 
-    // To Radian
+    /// Delegates conversions to Radian to conversions to float
     template <class FromType>
     struct ConverterFallback<FromType, orxonox::Radian>
@@ -189,5 +190,5 @@
     };
 
-    // To Degree
+    /// Delegates conversions to Degree to conversions to float
     template <class FromType>
     struct ConverterFallback<FromType, orxonox::Degree>
Index: code/trunk/src/libraries/util/MultiType.cc
===================================================================
--- code/trunk/src/libraries/util/MultiType.cc	(revision 7305)
+++ code/trunk/src/libraries/util/MultiType.cc	(revision 7401)
@@ -159,50 +159,50 @@
     }
 
-    MultiType::operator char()                 const { return (this->value_) ? ((this->value_->type_ == MT_Type::Char            ) ? (static_cast<MT_Value<char>                *>(this->value_))->value_ : (*this->value_)) : 0;                      } /** @brief 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;                      } /** @brief 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;                      } /** @brief 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;                      } /** @brief 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;                      } /** @brief 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;                      } /** @brief 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;                      } /** @brief 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;                      } /** @brief 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;                      } /** @brief 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;                      } /** @brief 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;                      } /** @brief 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;                      } /** @brief 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;                      } /** @brief 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;                      } /** @brief 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;                      } /** @brief 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>();          } /** @brief 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>();     } /** @brief 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>();     } /** @brief 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>();     } /** @brief 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>(); } /** @brief 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>();  } /** @brief 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>();      } /** @brief 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>();      } /** @brief 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            ); } /** @brief 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    ); } /** @brief 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           ); } /** @brief 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   ); } /** @brief 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             ); } /** @brief 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     ); } /** @brief 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            ); } /** @brief 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    ); } /** @brief 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        ); } /** @brief 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); } /** @brief 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           ); } /** @brief 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          ); } /** @brief 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      ); } /** @brief 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            ); } /** @brief 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     ); } /** @brief 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          ); } /** @brief 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         ); } /** @brief 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         ); } /** @brief 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         ); } /** @brief 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     ); } /** @brief 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      ); } /** @brief 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          ); } /** @brief 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          ); } /** @brief Creates a new value container for the given type. */
+    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.
 }
Index: code/trunk/src/libraries/util/MultiType.h
===================================================================
--- code/trunk/src/libraries/util/MultiType.h	(revision 7305)
+++ code/trunk/src/libraries/util/MultiType.h	(revision 7401)
@@ -28,11 +28,19 @@
 
 /**
+    @defgroup MultiType MultiType
+    @ingroup Util
+*/
+
+/**
     @file
+    @ingroup MultiType
     @brief Declaration of the MultiType and some helper constructs.
 
+    @anchor MultiTypeExamples
+
     The MultiType can hold a value of one of the following types:
-     - all primitives
-     - all pointers
-     - string
+     - all primitives (int, float, bool, etc.)
+     - all pointers (void* and T*)
+     - std::string
      - Vector2, Vector3, Vector4
      - Quaternion
@@ -40,22 +48,43 @@
      - Radian, Degree
 
-    The MultiType has a "type" determined by the first assigned value, either through
-     - the constructor,
-     - the assignment operator= or
-     - setValue(value).
-    If you assign another value of another type, the MultiType keeps "it's" type and
-    converts the new value to this type.
+    The MultiType has an internal "type" determined by the first assigned value, using one of these ways:
+     - @ref orxonox::MultiType::MultiType "The constructor"
+     - The assignment operator= (orxonox::MultiType::operator=())
+     - @ref orxonox::MultiType::setValue() "setValue(value)"
+
+    If you assign another value of another type, the MultiType keeps "its" type and
+    converts the new value to the old type.
 
     If you want to change the type, there are three possibilities:
-     - convert<T>() set's the type to T and converts the currently assigned value
-     - setType<T>() set's the type to T and resets the value
+     - @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.
 
-    @example
-    MultiType a = 10;;         // a has now the type int and the value 10
+    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.14
-    a.convert<bool>();         // converts 3.14 to bool, which is true
+    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)
+    @endcode
+
+    You can pass a MultiType to a function as an argument, even if the argument is
+    not of type MultiType. This works, because the MultiType is automatically converted
+    to the right type.
+
+    Example:
+    @code
+    void myfunction(int value)
+    {
+        COUT(0) << "doubled value is " << (2 * value) << std::endl;
+    }
+
+    MultiType a = "50";        // Note: We assigned a string
+    myfunction(a);             // a is converted to int and passed to the function, which prints "value is 100"
+    @endcode
+
+    Note however that it is of course quite expensive to convert values, especially std::string <-> value.
+    So if you can, always assign a value with the right type to avoid conversion.
 
     @note
@@ -127,8 +156,7 @@
          - Radian, Degree
 
-        The internal type of a MultiType is determined by the first assigned value, but can be
-        changed by using setType<T>(), convert<T>() or setValue<T>(value). If a value gets assigned
-        the normal way (operator=, setValue(value)), the value gets converted to the current internal
-        type of the MultiType.
+        For more information and some examples see the description @ref MultiTypeExamples "here".
+
+        @see MultiType.h
     */
     class _UtilExport MultiType
@@ -153,8 +181,8 @@
             virtual bool assimilate(const MultiType& other) = 0;
 
-            /** @brief Returns the type of the current value. */
+            /// Returns the type of the current value.
             const MT_Type::Value& getType() const { return this->type_; }
 
-            /** @brief Checks whether the value is a default one. */
+            /// Checks whether the value is a default one.
             bool hasDefaultValue()   const { return this->bHasDefaultValue_; }
 
@@ -237,45 +265,45 @@
             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
+            MT_Type::Value type_;   ///< The type of the current value
+            bool bHasDefaultValue_; ///< True if the last conversion wasn't successful
         };
 
         public:
-            inline MultiType()                                  : value_(0) {}                                      /** @brief 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); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const unsigned char& value)        : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const short& value)                : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const unsigned short& value)       : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const int& value)                  : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const unsigned int& value)         : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const long& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const unsigned long& value)        : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const long long& value)            : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const unsigned long long& value)   : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const float& value)                : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const double& value)               : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const long double& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const bool& value)                 : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(      void* const& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const std::string& value)          : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::Vector2& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::Vector3& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::Vector4& value)     : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::ColourValue& value) : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::Quaternion& value)  : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::Radian& value)      : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::Degree& value)      : value_(0) { this->assignValue(value); }           /** @brief Constructor: Assigns the given value and sets the type. */
-            inline MultiType(const orxonox::mbool& value)       : value_(0) { this->assignValue((bool)value); }     /** @brief Constructor: Assigns the given mbool and converts it to bool. */
-            inline MultiType(const char* value)                 : value_(0) { this->setValue(std::string(value)); } /** @brief 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); }              /** @brief Copyconstructor: Assigns value and type of the other MultiType. */
-            inline MultiType(MT_Type::Value type)               : value_(0) { this->setType(type); }                /** @brief Constructor: Sets the type, the next assignment will determine the value. */
-
-            /** @brief Destructor: Deletes the MT_Value. */
+            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.
+
+            /// 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); } /** @brief 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); } /** @brief Assigns a pointer. */
-            inline                       MultiType& operator=(const MultiType& other) { this->setValue(other); return (*this); } /** @brief 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); } /** @brief Resets the value and changes the type. */
+            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);
@@ -303,5 +331,5 @@
             inline bool                                   setValue(const orxonox::Degree& value);
             inline bool                                   setValue(const char* value);
-            /** @brief Assigns a pointer. */
+            /// Assigns a pointer.
             template <typename V> inline bool setValue(V* value)
             {
@@ -311,48 +339,53 @@
                     return this->assignValue     (static_cast<void*>(const_cast<typename Loki::TypeTraits<V>::UnqualifiedType*>(value)));
             }
-            /** @brief Assigns the value of the other MultiType and converts it to the current type. */
+            /// 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; } }
-            /** @brief Changes the type to T and assigns the new value (which might be of another type than T - it gets converted). */
+            /// 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); }
 
 
-            /** @brief Copies the other MultiType by assigning value and type. */
+            /// 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; }
 
-            template <typename T> inline bool convert()                       { return this->setValue<T>((typename Loki::TypeTraits<T>::UnqualifiedReferredType)(*this));  } /** @brief Converts the current value to type T. */
-            inline bool                       convert(const MultiType& other) { return this->convert(other.getType()); } /** @brief Converts the current value to the type of the other MultiType. */
+            /// 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);
 
-            /** @brief Current content gets deleted. New type is MT_Type::Null */
+            /// Current content gets deleted. New type is MT_Type::Null
             inline void                       reset()                         { if (this->value_) delete this->value_; this->value_ = 0; }
-            /** @brief Current content gets overridden with default zero value */
+            /// Current content gets overridden with default zero value
             inline void                       resetValue()                    { if (this->value_) this->value_->reset(); }
 
-            template <typename T> inline void setType()                       { this->assignValue(typename Loki::TypeTraits<T>::UnqualifiedReferredType()); } /** @brief Resets the value and changes the internal type to T. */
-            inline void                       setType(const MultiType& other) { this->setType(other.getType());                                             } /** @brief Resets the value and changes the internal type to the type of the other MultiType. */
-            inline void                       setType(MT_Type::Value type)    { this->reset(); this->convert(type); this->resetValue();                     } /** @brief Resets the value and changes the internal type to the given type. */
-
-            /** @brief Returns the current type. */
+            /// 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; }
-            /** @brief Returns true if the current type equals the given type. */
+            /// 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); }
-            /** @brief Returns true if the current type is T. */
+            /// 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;
 
-            /** @brief Saves the value of the MT to a bytestream (pointed at by mem) and increases mem pointer by size of MT */
+            /// 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); }
-            /** @brief Loads the value of the MT from a bytestream (pointed at by mem) and increases mem pointer by size of MT */
+            /// 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); }
-            /** @brief Saves the value of the MT to a bytestream and increases pointer to bytestream by size of MT */
+            /// 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; }
-            /** @brief Loads the value of the MT to a bytestream and increases pointer to bytestream by size of MT */
+            /// 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); }
 
-            /** @brief Checks whether the value is a default one. */
+            /// Checks whether the value is a default one (assigned after a failed conversion)
             bool                              hasDefaultValue() const { return this->value_->hasDefaultValue(); }
 
-            /** @brief Checks if the MT contains no value. */
+            /// Checks if the MT contains no value.
             bool                              null() const { return (!this->value_); }
 
@@ -380,84 +413,84 @@
             operator orxonox::Radian()       const;
             operator orxonox::Degree()       const;
-            /** @brief Returns the current value, converted to a T* pointer. */
+            /// 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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; } /** @brief 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();                 } /** @brief Returns the current value, converted to the requested type. */
-            inline unsigned char            getUnsignedChar()     const { return this->operator unsigned char();        } /** @brief Returns the current value, converted to the requested type. */
-            inline short                    getShort()            const { return this->operator short();                } /** @brief Returns the current value, converted to the requested type. */
-            inline unsigned short           getUnsignedShort()    const { return this->operator unsigned short();       } /** @brief Returns the current value, converted to the requested type. */
-            inline int                      getInt()              const { return this->operator int();                  } /** @brief Returns the current value, converted to the requested type. */
-            inline unsigned int             getUnsignedInt()      const { return this->operator unsigned int();         } /** @brief Returns the current value, converted to the requested type. */
-            inline long                     getLong()             const { return this->operator long();                 } /** @brief Returns the current value, converted to the requested type. */
-            inline unsigned long            getUnsignedLong()     const { return this->operator unsigned long();        } /** @brief Returns the current value, converted to the requested type. */
-            inline long long                getLongLong()         const { return this->operator long long();            } /** @brief Returns the current value, converted to the requested type. */
-            inline unsigned long long       getUnsignedLongLong() const { return this->operator unsigned long long();   } /** @brief Returns the current value, converted to the requested type. */
-            inline float                    getFloat()            const { return this->operator float();                } /** @brief Returns the current value, converted to the requested type. */
-            inline double                   getDouble()           const { return this->operator double();               } /** @brief Returns the current value, converted to the requested type. */
-            inline long double              getLongDouble()       const { return this->operator long double();          } /** @brief Returns the current value, converted to the requested type. */
-            inline bool                     getBool()             const { return this->operator bool();                 } /** @brief Returns the current value, converted to the requested type. */
-            inline void*                    getVoid()             const { return this->operator void*();                } /** @brief Returns the current value, converted to the requested type. */
-            inline std::string              getString()           const { return this->operator std::string();          } /** @brief Returns the current value, converted to the requested type. */
-            inline orxonox::Vector2         getVector2()          const { return this->operator orxonox::Vector2();     } /** @brief Returns the current value, converted to the requested type. */
-            inline orxonox::Vector3         getVector3()          const { return this->operator orxonox::Vector3();     } /** @brief Returns the current value, converted to the requested type. */
-            inline orxonox::Vector4         getVector4()          const { return this->operator orxonox::Vector4();     } /** @brief Returns the current value, converted to the requested type. */
-            inline orxonox::ColourValue     getColourValue()      const { return this->operator orxonox::ColourValue(); } /** @brief Returns the current value, converted to the requested type. */
-            inline orxonox::Quaternion      getQuaternion()       const { return this->operator orxonox::Quaternion();  } /** @brief Returns the current value, converted to the requested type. */
-            inline orxonox::Radian          getRadian()           const { return this->operator orxonox::Radian();      } /** @brief Returns the current value, converted to the requested type. */
-            inline orxonox::Degree          getDegree()           const { return this->operator orxonox::Degree();      } /** @brief Returns the current value, converted to the requested type. */
-            template <typename T> inline T* getPointer()          const { return static_cast<T*>(this->getVoid());      } /** @brief Returns the current value, converted to a T* pointer. */
+            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.
 
         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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief 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; } } /** @brief Assigns a new value by changing type and creating a new container. */
-
-            /** @brief Changes the value container. */
+            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.
+
+            /// Changes the value container.
             template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
-            /** @brief Creates a new value container (works only with specialized types). */
+            /// Creates a new value container (works only with specialized types).
             template <typename T>        void createNewValueContainer(const T& value) { /* STATIC ASSERT */ *****value; return false; }
 
@@ -465,52 +498,53 @@
     };
 
-    /** @brief Puts the MultiType on a stream by using the native << operator of the current type. */
+    /// 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);             } /** @brief 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);     } /** @brief 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);            } /** @brief 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);    } /** @brief 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);              } /** @brief 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);      } /** @brief 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);             } /** @brief 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);     } /** @brief 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);         } /** @brief 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); } /** @brief 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);            } /** @brief 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);           } /** @brief 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);       } /** @brief 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);             } /** @brief 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);      } /** @brief 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);           } /** @brief 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);          } /** @brief 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);          } /** @brief 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);          } /** @brief 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);      } /** @brief 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);       } /** @brief 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);           } /** @brief 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);           } /** @brief Returns true if the current type equals the given type. */
-
-    template <> inline bool MultiType::convert<void>()                 { this->reset(); return true; } /** @brief Deletes the content, type becomes MT_Type::Null. */
+    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());          } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<orxonox::Vector2>()     { return this->setValue<orxonox::Vector2>    (this->operator orxonox::Vector2());     } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<orxonox::Vector3>()     { return this->setValue<orxonox::Vector3>    (this->operator orxonox::Vector3());     } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<orxonox::Vector4>()     { return this->setValue<orxonox::Vector4>    (this->operator orxonox::Vector4());     } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<orxonox::ColourValue>() { return this->setValue<orxonox::ColourValue>(this->operator orxonox::ColourValue()); } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<orxonox::Quaternion>()  { return this->setValue<orxonox::Quaternion> (this->operator orxonox::Quaternion());  } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<orxonox::Radian>()      { return this->setValue<orxonox::Radian>     (this->operator orxonox::Radian());      } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<orxonox::Degree>()      { return this->setValue<orxonox::Degree>     (this->operator orxonox::Degree());      } /** @brief Converts the current value to the given type. */
+    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>();          } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<const orxonox::Vector2&>()     { return this->convert<orxonox::Vector2>();     } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<const orxonox::Vector3&>()     { return this->convert<orxonox::Vector3>();     } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<const orxonox::Vector4&>()     { return this->convert<orxonox::Vector4>();     } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<const orxonox::ColourValue&>() { return this->convert<orxonox::ColourValue>(); } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<const orxonox::Quaternion&>()  { return this->convert<orxonox::Quaternion>();  } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<const orxonox::Radian&>()      { return this->convert<orxonox::Radian>();      } /** @brief Converts the current value to the given type. */
-    template <> inline bool MultiType::convert<const orxonox::Degree&>()      { return this->convert<orxonox::Degree>();      } /** @brief Converts the current value to the given type. */
+    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.
 
     template <> _UtilExport void MultiType::createNewValueContainer(const char& value);
@@ -538,29 +572,30 @@
     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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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); } } /** @brief 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)); } }  /** @brief 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(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 7305)
+++ code/trunk/src/libraries/util/MultiTypeValue.h	(revision 7401)
@@ -29,4 +29,5 @@
 /**
     @file
+    @ingroup MultiType
     @brief Declaration and Implementation of the MT_Value<T> class.
 
@@ -53,14 +54,17 @@
     {
     public:
-        /** @brief Constructor: Assigns the value and the type identifier. */
+        /// Constructor: Assigns the value and the type identifier.
         MT_Value(const T& value, MT_Type::Value type) : MT_ValueBase(type), value_(value) {}
 
-        /** @brief Creates a copy of itself. */
+        /// Creates a copy of itself.
         inline MT_ValueBase* clone() const { return new MT_Value<T>(this->value_, this->type_); }
 
-        /** @brief Resets the current value to the default. */
+        /// 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 */
+        /**
+            @brief Assigns the value of the other MultiType, converted to T.
+            @param other The other MultiType
+        */
         inline bool assimilate(const MultiType& other)
         {
@@ -76,87 +80,87 @@
         }
 
-        inline bool getValue(char*                 value) const { return convertValue<T, char                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(unsigned char*        value) const { return convertValue<T, unsigned char       >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(short*                value) const { return convertValue<T, short               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(unsigned short*       value) const { return convertValue<T, unsigned short      >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(int*                  value) const { return convertValue<T, int                 >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(unsigned int*         value) const { return convertValue<T, unsigned int        >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(long*                 value) const { return convertValue<T, long                >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(unsigned long*        value) const { return convertValue<T, unsigned long       >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(long long*            value) const { return convertValue<T, long long           >(value, value_, 0); } /** @brief 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 { return convertValue<T, unsigned long long  >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(float*                value) const { return convertValue<T, float               >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(double*               value) const { return convertValue<T, double              >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(long double*          value) const { return convertValue<T, long double         >(value, value_, 0); } /** @brief Assigns the value to the given pointer. The value gets converted if the types don't match. */
-        inline bool getValue(bool*                 value) const { return convertValue<T, bool                >(value, value_, 0); } /** @brief 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); } /** @brief 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>         ()); } /** @brief 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>    ()); } /** @brief 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>    ()); } /** @brief 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>    ()); } /** @brief 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>()); } /** @brief 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> ()); } /** @brief 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>     ()); } /** @brief 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>     ()); } /** @brief 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>())); } /** @brief 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>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const short& value)                { return !(bHasDefaultValue_ = !convertValue<short               , T>(&value_, value, zeroise<T>())); } /** @brief 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>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const int& value)                  { return !(bHasDefaultValue_ = !convertValue<int                 , T>(&value_, value, zeroise<T>())); } /** @brief 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>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const long& value)                 { return !(bHasDefaultValue_ = !convertValue<long                , T>(&value_, value, zeroise<T>())); } /** @brief 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>())); } /** @brief 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>())); } /** @brief 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>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const float& value)                { return !(bHasDefaultValue_ = !convertValue<float               , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const double& value)               { return !(bHasDefaultValue_ = !convertValue<double              , T>(&value_, value, zeroise<T>())); } /** @brief 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>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(const bool& value)                 { return !(bHasDefaultValue_ = !convertValue<bool                , T>(&value_, value, zeroise<T>())); } /** @brief Assigns the value by converting it to T. */
-        inline bool setValue(      void* const& value)          { return !(bHasDefaultValue_ = !convertValue<void*               , T>(&value_, value, zeroise<T>())); } /** @brief 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>())); } /** @brief 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>())); } /** @brief 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>())); } /** @brief 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>())); } /** @brief 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>())); } /** @brief 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>())); } /** @brief 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>())); } /** @brief 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>())); } /** @brief Assigns the value by converting it to T. */
-
-        inline operator char()                 const { return getConvertedValue<T, char>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator unsigned char()        const { return getConvertedValue<T, unsigned char>       (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator short()                const { return getConvertedValue<T, short>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator unsigned short()       const { return getConvertedValue<T, unsigned short>      (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator int()                  const { return getConvertedValue<T, int>                 (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator unsigned int()         const { return getConvertedValue<T, unsigned int>        (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator long()                 const { return getConvertedValue<T, long>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator unsigned long()        const { return getConvertedValue<T, unsigned long>       (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator long long()            const { return getConvertedValue<T, long long>           (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator unsigned long long()   const { return getConvertedValue<T, unsigned long long>  (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator float()                const { return getConvertedValue<T, float>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator double()               const { return getConvertedValue<T, double>              (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator long double()          const { return getConvertedValue<T, long double>         (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator bool()                 const { return getConvertedValue<T, bool>                (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator void*()                const { return getConvertedValue<T, void*>               (this->value_, 0); }     /** @brief Returns the current value, converted to the requested type. */
-        inline operator std::string()          const { return getConvertedValue<T, std::string>         (this->value_, NilValue<std::string         >()); } /** @brief Returns the current value, converted to the requested type. */
-        inline operator orxonox::Vector2()     const { return getConvertedValue<T, orxonox::Vector2>    (this->value_, NilValue<orxonox::Vector2    >()); } /** @brief Returns the current value, converted to the requested type. */
-        inline operator orxonox::Vector3()     const { return getConvertedValue<T, orxonox::Vector3>    (this->value_, NilValue<orxonox::Vector3    >()); } /** @brief Returns the current value, converted to the requested type. */
-        inline operator orxonox::Vector4()     const { return getConvertedValue<T, orxonox::Vector4>    (this->value_, NilValue<orxonox::Vector4    >()); } /** @brief Returns the current value, converted to the requested type. */
-        inline operator orxonox::ColourValue() const { return getConvertedValue<T, orxonox::ColourValue>(this->value_, NilValue<orxonox::ColourValue>()); } /** @brief Returns the current value, converted to the requested type. */
-        inline operator orxonox::Quaternion()  const { return getConvertedValue<T, orxonox::Quaternion> (this->value_, NilValue<orxonox::Quaternion >()); } /** @brief Returns the current value, converted to the requested type. */
-        inline operator orxonox::Radian()      const { return getConvertedValue<T, orxonox::Radian>     (this->value_, NilValue<orxonox::Radian     >()); } /** @brief Returns the current value, converted to the requested type. */
-        inline operator orxonox::Degree()      const { return getConvertedValue<T, orxonox::Degree>     (this->value_, NilValue<orxonox::Degree     >()); } /** @brief Returns the current value, converted to the requested type. */
-
-        /** @brief Puts the current value on the stream */
+        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.
+        inline bool getValue(unsigned char*        value) const { return convertValue<T, unsigned char       >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(short*                value) const { return convertValue<T, short               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(unsigned short*       value) const { return convertValue<T, unsigned short      >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(int*                  value) const { return convertValue<T, int                 >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(unsigned int*         value) const { return convertValue<T, unsigned int        >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(long*                 value) const { return convertValue<T, long                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(unsigned long*        value) const { return convertValue<T, unsigned long       >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(long long*            value) const { return convertValue<T, long long           >(value, value_, 0); } ///< 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 { return convertValue<T, unsigned long long  >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(float*                value) const { return convertValue<T, float               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(double*               value) const { return convertValue<T, double              >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        inline bool getValue(long double*          value) const { return convertValue<T, long double         >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
+        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.
+
+        /// Puts the current value on the stream
         inline void toString(std::ostream& outstream) const { outstream << this->value_; }
 
-        /** @brief loads data from the bytestream (mem) into the MT and increases the bytestream pointer by the size of the data */
+        /// loads data from the bytestream (mem) into the MT and increases the bytestream pointer by the size of the data
         inline void importData( uint8_t*& mem )         { loadAndIncrease( /*(const T&)*/this->value_, mem ); }
-        /** @brief saves data from the MT into the bytestream (mem) and increases the bytestream pointer by the size of the data */
+        /// saves data from the MT into the bytestream (mem) and increases the bytestream pointer by the size of the data
         inline void exportData( uint8_t*& mem ) const   { saveAndIncrease( /*(const T&)*/this->value_, mem ); }
-        /** @brief returns the size of the data that would be saved by exportData */
+        /// returns the size of the data that would be saved by exportData
         inline uint8_t getSize() const { return returnSize( this->value_ ); }
 
-        T value_; //!< The stored value
+        T value_; ///< The stored value
     };
 
Index: code/trunk/src/libraries/util/OrxAssert.h
===================================================================
--- code/trunk/src/libraries/util/OrxAssert.h	(revision 7305)
+++ code/trunk/src/libraries/util/OrxAssert.h	(revision 7401)
@@ -29,4 +29,5 @@
 /**
 @file
+@ingroup ExceptionAssertion
 @brief
     Declaration of custom assertion facilities
@@ -41,6 +42,13 @@
 #include "OutputHandler.h"
 
-// define an assert macro that can display a message
 #ifndef NDEBUG
+/** Run time assertion like assert(), but with an embedded message.
+@details
+    The message will be printed as error with COUT(1). <br>
+    You can use the same magic here as you can with \ref ThrowException
+    @code
+        OrxAssert(condition, "Text: " << number << " more text");
+    @endcode
+*/
 #define OrxAssert(Assertion, ErrorMessage) \
     Assertion ? ((void)0) : (void)(orxonox::OutputHandler::getOutStream(1) << ErrorMessage << std::endl); \
Index: code/trunk/src/libraries/util/OrxEnum.h
===================================================================
--- code/trunk/src/libraries/util/OrxEnum.h	(revision 7305)
+++ code/trunk/src/libraries/util/OrxEnum.h	(revision 7401)
@@ -28,7 +28,6 @@
 
 /**
-@file
-@brief
-    Declaration of the OrxEnum class.
+    @file
+    @ingroup Util
 */
 
@@ -40,4 +39,22 @@
 namespace orxonox
 {
+    /** Lightweight enumeration class that can be extended at run time.
+    @details
+        The class accepts type int and also defines operator int(). Therefore
+        int and OrxEnum can be used interchangeably so you can extend the content
+        of the enumeration at run time by adding ints.
+    @par Declaring an OrxEnum
+        Write a struct that inherits OrxEnum and use some macros:
+        @code
+        struct MyEnum : OrxEnum<MyEnum>
+        {
+            OrxEnumConstructors(MyEnum);
+
+            static const int Value1 = -1;
+            static const int Value2 = 0;
+            static const int Value3 = Value2 + 10;
+        };
+        @endcode
+    */
     template <class T>
     struct OrxEnum
@@ -45,8 +62,8 @@
         public:
             OrxEnum() { }
-            OrxEnum(int type)                  { type_ = type; }
+            OrxEnum(int type)            { type_ = type; }
             OrxEnum(const T& instance)   { type_ = instance.type_; }
 
-            operator int()                     { return type_; }
+            operator int()               { return type_; }
             T& operator =(int type)      { type_ = type; return *this; }
             bool operator <(const T& right) const { return (type_ < right.type_); }
@@ -59,4 +76,5 @@
 }
 
+/// See orxonox::OrxEnum for more info
 #define OrxEnumConstructors(enumName)                        \
 enumName() { }                                               \
Index: code/trunk/src/libraries/util/OutputHandler.cc
===================================================================
--- code/trunk/src/libraries/util/OutputHandler.cc	(revision 7305)
+++ code/trunk/src/libraries/util/OutputHandler.cc	(revision 7401)
@@ -67,7 +67,4 @@
         @brief
             Gets temporary log path and starts the log file
-        @param outputHandler
-            This is only required to avoid another call to getInstance (this c'tor was
-            called from getInstance!)
         */
         LogFileWriter()
@@ -117,6 +114,6 @@
 
     private:
-        std::ofstream logFile_;     //! File handle for the log file
-        std::string   logFilename_; //! Filename of the log file
+        std::ofstream logFile_;     //!< File handle for the log file
+        std::string   logFilename_; //!< Filename of the log file
     };
 
@@ -162,7 +159,4 @@
         @brief
             Sets the right soft debug level and registers itself
-        @param outputHandler
-            This is only required to avoid another call to getInstance (this c'tor was
-            called from getInstance!)
         */
         MemoryLogWriter()
@@ -186,6 +180,6 @@
 
     private:
-        std::ostringstream                        buffer_; //! Stream object used to process the output
-        std::vector<std::pair<int, std::string> > output_; //! Vector containing ALL output
+        std::ostringstream                        buffer_; //!< Stream object used to process the output
+        std::vector<std::pair<int, std::string> > output_; //!< Vector containing ALL output
     };
 
Index: code/trunk/src/libraries/util/OutputHandler.h
===================================================================
--- code/trunk/src/libraries/util/OutputHandler.h	(revision 7305)
+++ code/trunk/src/libraries/util/OutputHandler.h	(revision 7401)
@@ -29,6 +29,7 @@
 /**
 @file
+@ingroup Util Output
 @brief
-    Declaration of classes related to output (logging).
+    Declaration of classes related to output (logging), most notably OutputHandler and OutputListener.
 */
 
@@ -50,11 +51,11 @@
         Denotes different levels of text output (log output)
 
-        0, None   : Very important output
-        1, Error  : Errors
-        2, Warning: Warnings
-        3, Info   : Information
-        4, Debug  : Debug information
-        5, Verbose: More debug information
-        6, Ultra  : Crazy debug information
+         - 0, None   : Very important output
+         - 1, Error  : Errors
+         - 2, Warning: Warnings
+         - 3, Info   : Information
+         - 4, Debug  : Debug information
+         - 5, Verbose: More debug information
+         - 6, Ultra  : Crazy debug information
     */
     namespace OutputLevel
@@ -79,11 +80,16 @@
     /**
     @brief
-        The OutputHandler acts like std::cout, but output isn't only shown in the console.
-
-        You can register your own listener for output by inheriting from OutputListner.
+        The OutputHandler acts like @c std::cout, but output isn't only shown in the console.
+
+        Output passed to the OutputHandler is distributed to all registered listeners,
+        for example the console, the logfile, or the ingame shell.
+
+        You can register your own listener for output by inheriting from OutputListener.
         And if you need the output previously processed, iterate over it with
-        OutputHandler::getOutputVector[Begin/End].
+        OutputHandler::getOutputVectorBegin and OutputHandler::getOutputVectorEnd.
+
         The way to output text is to first set the desired output level with
-        OutputHandler::getOutStream(level) and then use the "<<" operator like with std::cout.
+        @ref getOutStream "OutputHandler::getOutStream(level)" and then use
+        the "<<" operator like with @c std::cout. Alternatively you can use the COUT() macro.
     */
     class _UtilExport OutputHandler
@@ -213,5 +219,5 @@
             OutputHandler();
             ~OutputHandler();
-            OutputHandler(const OutputHandler& rhs); //! Unused and undefined
+            OutputHandler(const OutputHandler& rhs);      //!< Copy-constructor: Unused and undefined
 
             std::list<OutputListener*> listeners_;        //!< Array with all registered output listeners
Index: code/trunk/src/libraries/util/Scope.cc
===================================================================
--- code/trunk/src/libraries/util/Scope.cc	(revision 7305)
+++ code/trunk/src/libraries/util/Scope.cc	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @brief Static linkage of the two maps in orxonox::ScopeManager.
+*/
+
 #include "Scope.h"
 
Index: code/trunk/src/libraries/util/Scope.h
===================================================================
--- code/trunk/src/libraries/util/Scope.h	(revision 7305)
+++ code/trunk/src/libraries/util/Scope.h	(revision 7401)
@@ -27,4 +27,27 @@
  */
 
+/**
+@file
+@ingroup SingletonScope
+@brief Declaration of the classes that are needed to use Scopes:
+orxonox::Scope, orxonox::ScopeListener, and orxonox::ScopeManager.
+
+@anchor Scope
+
+A virtual scope can be represented by an instance of class orxonox::Scope. orxonox::Scope<@a scope> is a template
+an its template argument defines the name of the virtual scope. See orxonox::ScopeID for an enumeration of the
+available values for @a scope. The orxonox::Scope object for a given @a scope can be activated or deactivated.
+Instances of orxonox::ScopeListener can register for a given @a scope and will get a notification if the
+corresponding orxonox::Scope object changes its state.
+
+To avoid multiple instances of orxonox::Scope<@a scope> in different libraries, each instance of orxonox::Scope
+registers in orxonox::ScopeManager, where they are linked statically in the util library.
+
+Scopes are usually used to control the creation and destruction of Singletons.
+
+@see orxonox::ScopedSingletonManager
+@see orxonox::Singleton
+*/
+
 #ifndef __Util_Scope_H__
 #define __Util_Scope_H__
@@ -42,5 +65,11 @@
 {
     /**
-        @brief The ScopeManager stores the variables of the scope templates in a statically linked context.
+        @brief The ScopeManager stores the variables of the Scope templates in a statically linked context.
+
+        If all Scope objects are managed by this class, they are statically linked in the util library.
+        Without this, a new instance of Scope<T> for each T would be created in every library of Orxonox,
+        which is of course not the desired behavior.
+
+        @see See @ref Scope "this description" for details about the interrelationship of Scope, ScopeListener, and ScopeManager.
     */
     class _UtilExport ScopeManager
@@ -56,5 +85,8 @@
 
     /**
-        @brief ScopeListeners register themselves in the corresponding scope and wait for notifications.
+        @brief ScopeListeners register themselves in the corresponding Scope and wait for notifications.
+        Notifications are sent if a Scope is activated or deactivated.
+
+        @see See @ref Scope "this description" for details about the interrelationship of Scope, ScopeListener, and ScopeManager.
     */
     class _UtilExport ScopeListener
@@ -86,4 +118,6 @@
         Objects inheriting from a ScopeListener are registered in a list (different for each scope).
         If the scope gets activated or deactivated, all objects in this list are notified.
+
+        @see See @ref Scope "this description" for details about the interrelationship of Scope, ScopeListener, and ScopeManager.
     */
     template <ScopeID::Value scope>
@@ -130,4 +164,5 @@
             }
 
+            //! Deactivates the listeners of this scope in case the scope is destroyed or the construction fails.
             void deactivateListeners()
             {
Index: code/trunk/src/libraries/util/ScopedSingletonManager.cc
===================================================================
--- code/trunk/src/libraries/util/ScopedSingletonManager.cc	(revision 7305)
+++ code/trunk/src/libraries/util/ScopedSingletonManager.cc	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @brief Static linkage of the ScopedSingletonManager maps.
+*/
+
 #include "ScopedSingletonManager.h"
 
Index: code/trunk/src/libraries/util/ScopedSingletonManager.h
===================================================================
--- code/trunk/src/libraries/util/ScopedSingletonManager.h	(revision 7305)
+++ code/trunk/src/libraries/util/ScopedSingletonManager.h	(revision 7401)
@@ -26,4 +26,19 @@
  *
  */
+
+/**
+    @file
+    @ingroup SingletonScope
+    @brief Definition of orxonox::ScopedSingletonManager, orxonox::ClassScopedSingletonManager, and the ManageScopedSingleton macro.
+
+    ScopedSingletonManager is used to create and destroy Singletons that belong to
+    a given Scope. For each one of these singletons, the macro ManageScopedSingleton()
+    has to be called to register the singleton with orxonox::ScopedSingletonManager.
+
+    See @ref SingletonExample "this code" for an example.
+
+    @see orxonox::Singleton
+    @see orxonox::Scope
+*/
 
 #ifndef __ScopedSingletonManager_H__
@@ -38,4 +53,13 @@
 #include "util/Singleton.h"
 
+/**
+    @brief Registers an orxonox::Singleton with orxonox::ScopedSingletonManager.
+    @param className The name of the singleton class
+    @param scope The scope in which the singleton should exist
+    @param allowedToFail If true, the singleton is allowed to fail and thus a try-catch block is used when creating the singleton.
+
+    If this macro is called for a singleton, it is registered with ScopedSingletonManager
+    and will thus be created if its scope becomes active and destroyed if is deactivated.
+*/
 #define ManageScopedSingleton(className, scope, allowedToFail) \
     className* className::singletonPtr_s = NULL; \
@@ -46,7 +70,14 @@
     class OrxonoxClass;
 
+    /**
+        @brief Base class of ClassScopedSingletonManager, implements some static functions
+        used to dispatch calls to preUpdate and postUpdate to all instances of this class.
+        It also keeps track of all existing ScopedSingletonManagers and stores them in a
+        map, sorted by the scope they belong to.
+    */
     class _UtilExport ScopedSingletonManager
     {
         public:
+            /// Constructor: Initializes all the values
             ScopedSingletonManager(const std::string& className, ScopeID::Value scope)
                 : className_(className)
@@ -54,6 +85,9 @@
             { }
             virtual ~ScopedSingletonManager() { }
+
+            /// Adds a new instance of ScopedSingletonManager to the map.
             static void addManager(ScopedSingletonManager* manager);
 
+            /// Calls preUpdate in all instances of ScopedSingletonManager that are registered in the map.
             template<ScopeID::Value scope>
             static void preUpdate(const Clock& time)
@@ -64,4 +98,6 @@
             }
             virtual void preUpdate(const Clock& time) = 0;
+
+            /// Calls postUpdate in all instances of ScopedSingletonManager that are registered in the map.
             template<ScopeID::Value scope>
             static void postUpdate(const Clock& time)
@@ -78,12 +114,29 @@
 
         protected:
-            const std::string className_;
-            const ScopeID::Value scope_;
+            const std::string className_;   ///< The name of the scoped singleton class that is managed by this object
+            const ScopeID::Value scope_;    ///< The scope of the singleton that is managed by this object
     };
 
+    /**
+        @anchor ClassScopedSingletonManager
+
+        @brief Manages a scoped singleton for a given scope.
+        @param T The managed singleton class
+        @param scope The scope in which the singleton @a T should be active
+        @param allowedToFail If true, a specialization of this template is used, that uses try-catch blocks to handle possible failures.
+
+        This class inherits from ScopeListener for the given scope and thus its functions
+        activated() and deactivated() are called whenever the Scope changes its state.
+
+        If the Scope is activated, a new instance of @a T (which must be a singleton) is created.
+        If the Scope is deactivated, the singleton is destroyed.
+
+        @see Singleton
+    */
     template <class T, ScopeID::Value scope, bool allowedToFail>
     class ClassScopedSingletonManager : public ScopedSingletonManager, public ScopeListener
     {
     public:
+        //! Constructor: Initializes the singleton pointer and passes the scope to ScopedSingletonManager and ScopeListener
         ClassScopedSingletonManager(const std::string& className)
             : ScopedSingletonManager(className, scope)
@@ -113,8 +166,10 @@
         }
 
+        //! Destroys the singleton instance - overloaded for OrxonoxClass, calls OrxonoxClass::destroy()
         void destroy(OrxonoxClass*)
         {
             singletonPtr_->destroy();
         }
+        //! Destroys the singleton instance - overloaded for all other pointers, calls delete
         void destroy(void*)
         {
@@ -139,11 +194,22 @@
 
     private:
-        T* singletonPtr_;
+        T* singletonPtr_;   ///< Unique instance of the singleton class @a T
     };
 
+    /**
+        @brief This class partially spezializes ClassScopedSingletonManager for classes @a T that are allowed to fail.
+        @param T The managed singleton class
+        @param scope The scope in which the singleton @a T should be active
+
+        Because @a T could fail when being created, this partial spezialization of ClassScopedSingletonManager
+        uses a try-catch block to handle exceptions.
+
+        See @ref ClassScopedSingletonManager for a full documentation of the basis template.
+    */
     template <class T, ScopeID::Value scope>
     class ClassScopedSingletonManager<T, scope, true> : public ScopedSingletonManager, public ScopeListener
     {
     public:
+        //! Constructor: Initializes the singleton pointer and passes the scope to ScopedSingletonManager and ScopeListener
         ClassScopedSingletonManager(const std::string& className)
             : ScopedSingletonManager(className, scope)
@@ -180,8 +246,10 @@
         }
 
+        //! Destroys the singleton instance - overloaded for OrxonoxClass, calls OrxonoxClass::destroy()
         void destroy(OrxonoxClass* ptr)
         {
             singletonPtr_->destroy();
         }
+        //! Destroys the singleton instance - overloaded for void*, calls delete
         void destroy(void* ptr)
         {
@@ -208,5 +276,5 @@
 
     private:
-        T* singletonPtr_;
+        T* singletonPtr_;   ///< Unique instance of the singleton class @a T
     };
 }
Index: code/trunk/src/libraries/util/Serialise.h
===================================================================
--- code/trunk/src/libraries/util/Serialise.h	(revision 7305)
+++ code/trunk/src/libraries/util/Serialise.h	(revision 7401)
@@ -29,4 +29,5 @@
 /**
     @file
+    @ingroup Util
     @brief Functions to serialise most of the types/classed used in Orxonox
 */
@@ -53,12 +54,12 @@
     template <class T> inline bool checkEquality( const T& variable, uint8_t* mem );
 
-  
+
   // =========== char*
-    
+
   inline uint32_t returnSize( char*& variable )
   {
     return strlen(variable)+1;
   }
-      
+
   inline void saveAndIncrease( char*& variable, uint8_t*& mem )
   {
@@ -66,5 +67,5 @@
     mem += returnSize(variable);
   }
-        
+
   inline void loadAndIncrease( char*& variable, uint8_t*& mem )
   {
@@ -76,10 +77,10 @@
     mem += len;
   }
-          
+
   inline bool checkEquality( char*& variable, uint8_t* mem )
   {
     return strcmp(variable, (char*)mem)==0;
   }
-    
+
 // =================== Template specialisation stuff =============
 
@@ -423,5 +424,5 @@
         return memcmp(&temp, mem, sizeof(uint64_t))==0;
     }
-        
+
 // =========== string
 
Index: code/trunk/src/libraries/util/SharedPtr.cc
===================================================================
--- code/trunk/src/libraries/util/SharedPtr.cc	(revision 7305)
+++ code/trunk/src/libraries/util/SharedPtr.cc	(revision 7401)
@@ -27,12 +27,20 @@
  */
 
+/**
+    @file
+    @brief Static linkage of the SmallObjectAllocator used by SharedPtr.
+*/
+
 #include "SharedPtr.h"
 
 namespace orxonox
 {
-    SmallObjectAllocator& createSharedCounterPool()
+    namespace detail
     {
-        static SmallObjectAllocator instance(sizeof(SharedCounterImpl<void>));
-        return instance;
+        SmallObjectAllocator& createSharedCounterPool()
+        {
+            static SmallObjectAllocator instance(sizeof(SharedCounterImpl<void>));
+            return instance;
+        }
     }
 }
Index: code/trunk/src/libraries/util/SharedPtr.h
===================================================================
--- code/trunk/src/libraries/util/SharedPtr.h	(revision 7305)
+++ code/trunk/src/libraries/util/SharedPtr.h	(revision 7401)
@@ -27,4 +27,121 @@
  */
 
+/**
+    @defgroup SharedPtr SharedPtr<T>
+    @ingroup Util
+*/
+
+/**
+    @file
+    @ingroup SharedPtr
+    @brief Definition of the SharedPtr template that is used to manage pointers.
+
+    @anchor SharedPtrExample
+
+    The orxonox::SharedPtr template can be used to manage a pointer to an object
+    that was created with new. The SharedPtr acts like the pointer itself, but it
+    keeps track of the number of references to it. If all references are removed,
+    SharedPtr deletes the managed object automatically.
+
+    Example:
+
+    Classic implementation using new and delete:
+    @code
+    void someFunction()
+    {
+        MyClass* object = new MyClass();            // Create a new instance of MyClass
+
+        object->myFunction();                       // Calls MyClass::myFunction()
+
+        delete object;                              // Delete the object at the end of the scope
+    }
+    @endcode
+
+    The same function using SharedPtr:
+    @code
+    void someFunction()
+    {
+        SharedPtr<MyClass> object = new MyClass();  // Create a new instance of MyClass and store its pointer in a SharedPtr
+
+        object->myFunction();                       // Calls MyClass::myFunction()
+
+    }                                               // At the end of the scope, the SharedPtr is destroyed. Because no other SharedPtrs
+                                                    // point at the object, the object itself is also destroyed automatically
+    @endcode
+
+    This is especially handy if you do not know what will happen with an object that was
+    created with new, for example if you pass it to another object. If multiple instances
+    share a pointer to the same object, none of these instances can delete the object
+    without interfering with the other instances. But if none of the instances destroy the
+    object, it will never be destroyed and results in a memory leak. With a SharedPtr
+    however you don't have to think about destroying the object, because the SharedPtr
+    itself keeps track of the references.
+
+    Example:
+
+    Classic implementation using new and delete:
+    @code
+    class OtherClass                                    // Declaration of some class
+    {
+        public:
+            OtherClass(MyClass* object)                 // Constructor
+            {
+                this->object_ = object;                 // Assigns the pointer to the member variable object_
+            }
+
+            ~OtherClass()                               // Destructor
+            {
+                ???                                     // What to do with object_?
+            }
+
+        private:
+            MyClass* object_;                           // A pointer to the object
+    };
+
+    void someFunction()
+    {
+        MyClass* object = new MyClass();                // Create a new instance of MyClass
+
+        OtherClass* other1 = new OtherClass(object);    // Create an instance of OtherClass and pass the object pointer
+        OtherClass* other2 = new OtherClass(object);    // "
+        OtherClass* other3 = new OtherClass(object);    // "
+
+        ???                                             // What happens with object now?
+    }
+    @endcode
+
+    If you use SharedPtr<MyClass> instead of a classic MyClass* pointer, the instance of
+    MyClass would be automatically destroyed if all instances of OtherClass are destroyed.
+    You don't need any code in the destructor and you can completely forget about the
+    object, because its managed by the SharedPtr.
+
+    The same code using SharedPtr:
+    @code
+    class OtherClass                                        // Declaration of some class
+    {
+        public:
+            OtherClass(const SharedPtr<MyClass>& object)    // Constructor
+            {
+                this->object_ = object;                     // Assigns the pointer to the member variable object_
+            }
+
+        private:
+            SharedPtr<MyClass> object_;                     // A SharedPtr to the object
+    };
+
+    void someFunction()
+    {
+        SharedPtr<MyClass> object = new MyClass();          // Create a new instance of MyClass
+
+        OtherClass* other1 = new OtherClass(object);        // Create an instance of OtherClass and pass the object pointer
+        OtherClass* other2 = new OtherClass(object);        // "
+        OtherClass* other3 = new OtherClass(object);        // "
+
+    }                                                       // The SmartPtr "object" is destroyed at the end of the scope,
+                                                            // but the three instances of OtherClass keep the object alive
+                                                            // until they are all destroyed.
+    @endcode
+*/
+
 #ifndef _SharedPtr_H__
 #define _SharedPtr_H__
@@ -39,36 +156,55 @@
 namespace orxonox
 {
-    class SharedCounter
-    {
-        public:
-            SharedCounter() : count_(1) {}
-            virtual void destroy() = 0;
-
-            int count_;
-    };
-
-    template <class T>
-    class SharedCounterImpl : public SharedCounter
-    {
-        public:
-            SharedCounterImpl(T* pointer) : pointer_(pointer) {}
-
-            void destroy()
-            {
-                delete this->pointer_;
-            }
-
-        private:
-            T* pointer_;
-    };
-
-    _UtilExport SmallObjectAllocator& createSharedCounterPool();
-
-    FORCEINLINE SmallObjectAllocator& getSharedCounterPool()
-    {
-        static SmallObjectAllocator& instance = createSharedCounterPool();
-        return instance;
+    namespace detail
+    {
+        /// BaseClass of SharedCounterImpl, has a counter that is initialized with 1
+        class SharedCounter
+        {
+            public:
+                SharedCounter() : count_(1) {}
+                virtual void destroy() = 0;
+
+                int count_;
+        };
+
+        /// Child class of SharedCounter, keeps a pointer to an object of type T that can be destroyed with destroy()
+        template <class T>
+        class SharedCounterImpl : public SharedCounter
+        {
+            public:
+                SharedCounterImpl(T* pointer) : pointer_(pointer) {}
+
+                void destroy()
+                {
+                    delete this->pointer_;
+                }
+
+            private:
+                T* pointer_;
+        };
+
+        _UtilExport SmallObjectAllocator& createSharedCounterPool();
+
+        FORCEINLINE SmallObjectAllocator& getSharedCounterPool()
+        {
+            static SmallObjectAllocator& instance = createSharedCounterPool();
+            return instance;
+        }
     }
 
+    /**
+        @brief The SharedPtr template is a utility to manage pointers to an object.
+        @param T The type of the managed object
+
+        SharedPtr acts like a real pointer, except that it keeps track of the number of
+        references to the object. If the the number of references drops to zero, the
+        object is destroyed automatically.
+
+        @see See @ref SharedPtrExample "this description" for some examples and more information.
+
+        @note The number of references is stored in a separate object that is shared
+        among all instances of SharedPtr that point to the same pointer. This object is
+        also responsible for destroying the pointer if the reference counter becomes zero.
+    */
     template <class T>
     class SharedPtr
@@ -78,17 +214,20 @@
 
         public:
+            /// Default constructor, the pointer is set to NULL.
             inline SharedPtr() : pointer_(0), counter_(0)
             {
             }
 
+            /// Constructor, creates a SharedPtr that points to @a pointer, increments the counter.
             inline SharedPtr(T* pointer) : pointer_(pointer), counter_(0)
             {
                 if (this->pointer_)
                 {
-                    void* chunk = getSharedCounterPool().alloc();
-                    this->counter_ = new (chunk) SharedCounterImpl<T>(this->pointer_);
+                    void* chunk = detail::getSharedCounterPool().alloc();
+                    this->counter_ = new (chunk) detail::SharedCounterImpl<T>(this->pointer_);
                 }
             }
 
+            /// Copy-constructor, this SharedPtr now points to the same object like the other SharedPtr, increments the counter.
             inline SharedPtr(const SharedPtr& other) : pointer_(other.pointer_), counter_(other.counter_)
             {
@@ -97,4 +236,5 @@
             }
 
+            /// Copy-constructor for SharedPtr with another template agument, increments the counter.
             template <class O>
             inline SharedPtr(const SharedPtr<O>& other) : pointer_(other.pointer_), counter_(other.counter_)
@@ -104,4 +244,5 @@
             }
 
+            /// Destructor, decrements the counter and deletes the object if the counter becomes zero.
             inline ~SharedPtr()
             {
@@ -113,9 +254,10 @@
                     {
                         this->counter_->destroy();
-                        getSharedCounterPool().free(this->counter_);
+                        detail::getSharedCounterPool().free(this->counter_);
                     }
                 }
             }
 
+            /// Assigns a new object, decrements the counter of the old object, increments the counter of the new object.
             inline SharedPtr& operator=(const SharedPtr& other)
             {
@@ -124,4 +266,5 @@
             }
 
+            /// Assigns a new object with another template argument, decrements the counter of the old object, increments the counter of the new object.
             template <class O>
             inline SharedPtr& operator=(const SharedPtr<O>& other)
@@ -131,4 +274,5 @@
             }
 
+            /// Casts the pointer to another type
             template <class O>
             inline SharedPtr<O> cast() const
@@ -138,4 +282,5 @@
             }
 
+            /// Overloaded -> operator, returns the pointer to the managed object.
             inline T* operator->() const
             {
@@ -144,4 +289,5 @@
             }
 
+            /// Overloaded * operator, returns a reference ot the managed object.
             inline T& operator*() const
             {
@@ -150,4 +296,5 @@
             }
 
+            /// Returns the pointer to the managed object.
             inline T* get() const
             {
@@ -155,4 +302,5 @@
             }
 
+            /// Returns true if the pointer is not NULL.
             inline operator bool() const
             {
@@ -160,4 +308,5 @@
             }
 
+            /// Swaps the pointer and the counter of two instances of SharedPtr with the same template argument.
             inline void swap(SharedPtr& other)
             {
@@ -167,5 +316,6 @@
 
         private:
-            inline SharedPtr(T* pointer, SharedCounter* counter) : pointer_(pointer), counter_(counter)
+            /// Private constructor, used by the cast() function.
+            inline SharedPtr(T* pointer, detail::SharedCounter* counter) : pointer_(pointer), counter_(counter)
             {
                 if (this->pointer_)
@@ -173,8 +323,39 @@
             }
 
-            T* pointer_;
-            SharedCounter* counter_;
+            T* pointer_;                        ///< A pointer to the managed object of type @a T
+            detail::SharedCounter* counter_;    ///< A pointer to the shared reference counter
     };
 
+    /**
+        @brief A child class of SharedPtr, used to reflect the hierarchy of the underlying class @a T.
+        @param T The type of the managed object
+        @param Parent The type of the SharedPtr that manages the parent class of @a T
+
+        This class is used to reflect the hierarchy of the underlying class @a T.
+        For example the @c Functor classes: While a @c Functor* pointer would be managed by
+        @c SharedPtr<Functor>, the child class @c FunctorStatic is managed by the class
+        <tt>SharedChildPtr<FunctorStatic, SharedPtr<Functor> ></tt>.
+
+        The second template argument @a Parent is used as the parent class of
+        SharedChildPtr. This means that each instance of <tt>SharedChildPtr<T, Parent></tt>
+        can be upcasted to @c Parent.
+
+        So for example this works:
+        @code
+        SharedChildPtr<FunctorStatic, SharedPtr<Functor> > functorStatic = createFunctor(&MyClass::myStaticFunction);
+        SharedPtr<Functor> functor = functorStatic;
+        @endcode
+
+        @note There are some typedefs and more to make the usage of SharedChildPtr easier
+        for the classes Functor and Executor. See FunctorPtr.h and ExecutorPtr.h. The above
+        example could thus be simplified the following way:
+        @code
+        FunctorStaticPtr functorStatic = createFunctor(&MyClass::myStaticFunction);
+        FunctorPtr functor = functorStatic;
+        @endcode
+
+        @see See SharedPtr for more information about the base class SharedPtr.
+        @see See @ref SharedPtrExample "this description" for some examples about how to use SharedPtr.
+    */
     template <class T, class Parent>
     class SharedChildPtr : public Parent
Index: code/trunk/src/libraries/util/SignalHandler.h
===================================================================
--- code/trunk/src/libraries/util/SignalHandler.h	(revision 7305)
+++ code/trunk/src/libraries/util/SignalHandler.h	(revision 7401)
@@ -29,4 +29,5 @@
 /**
     @file
+    @ingroup Util
     @brief Declaration of the SignalHandler class.
 */
@@ -68,4 +69,5 @@
     typedef std::list<SignalCallbackRec> SignalCallbackList;
 
+    /// The SignalHandler is used to catch signals like SIGSEGV and write a backtrace to the logfile.
     class SignalHandler : public Singleton<SignalHandler>
     {
@@ -99,4 +101,5 @@
 namespace orxonox
 {
+    /// The SignalHandler is used to catch signals like SIGSEGV and write a backtrace to the logfile. Not implemented on Windows.
     class _UtilExport SignalHandler : public Singleton<SignalHandler>
     {
Index: code/trunk/src/libraries/util/Singleton.h
===================================================================
--- code/trunk/src/libraries/util/Singleton.h	(revision 7305)
+++ code/trunk/src/libraries/util/Singleton.h	(revision 7401)
@@ -27,4 +27,84 @@
  */
 
+/**
+    @defgroup SingletonScope Singletons and Scope
+    @ingroup Util
+*/
+
+/**
+    @file
+    @ingroup SingletonScope
+    @brief Definition of the Singleton template that is used as base class for classes that allow only one instance.
+
+    @anchor SingletonExample
+
+    Classes that inherit from orxonox::Singleton follow the singleton pattern and thus
+    allow only one instance of the class to exist. This istance is stored in a static
+    variable called @c singletonPtr_s. orxonox::Singleton will access this variable, but
+    it must be implemented in the deriving class.
+
+    Example:
+    @code
+    class TestSingleton : public Singleton<TestSingleton>   // inherit from Singleton, pass the own class as template argument
+    {
+        friend class Singleton<TestSingleton>;              // friend declaration so Singleton can access singletonPtr_s
+
+        public:
+            TestSingleton();                                // public constructor because we may want to manage this singleton
+                                                            //     with an orxonox::ScopedSingletonManager (see below)
+            virtual ~TestSingleton();                       // public destructor
+
+            void testFunction();                            // put your functions here
+
+        private:
+            int testValue_;                                 // put your variables here
+
+            static TestSingleton* singletonPtr_s;           // static singleton instance pointer, used by the Singleton template
+    };
+    @endcode
+
+    And don't forget to initialize the static singleton pointer in the source (*.cc) %file:
+    @code
+    TestSingleton* TestSingleton::singletonPtr_s = NULL;
+    @endcode
+
+    Usually a singleton gets created automatically when it is first used, but it will never
+    be destroyed (unless the singleton explicitly deletes itself). To allow controlled
+    construction and destruction, the singleton can be put within a virtual scope. This is
+    done by registering the singleton class with orxonox::ScopedSingletonManager. To
+    do so, the ManageScopedSingleton() macro has to be called:
+
+    @code
+    ManageScopedSingleton(TestSingleton, ScopeID::Graphics, false); // muste be called in a source (*.cc) file
+    @endcode
+
+    @b Important: If you call ManageScopedSingleton(), you don't have to initialize singletonPtr_s anymore,
+    because that's already done by the macro.
+
+    Now the singleton TestSingleton gets automatically created if the scope Graphics becomes
+    active and also gets destroyed if the scope is deactivated.
+
+    Note that not all singletons must register with a scope, but it's recommended.
+
+    If a class inherits from orxonox::Singleton, it also inherits its functions. The most important
+    function is orxonox::Singleton::getInstance() which returns a reference to the only instance
+    of the singleton.
+
+    Example:
+    @code
+    TestSingleton::TestSingleton()                          // implement the constructor
+    {
+        this->testValue_ = 15;
+    }
+
+    void TestSingleton::testFunction()                      // implement testFunction
+    {
+        COUT(0) << "My value is " << this->testValue_ << std::endl;
+    }
+
+    TestSingleton::getInstance().testFunction();            // prints "My value is 15"
+    @endcode
+*/
+
 #ifndef __Util_Singleton_H__
 #define __Util_Singleton_H__
@@ -42,7 +122,8 @@
 
         Usage:
-        Inherit publicly from Singleton<MyClass> and provide access to
-        MyClass::singletonPtr_s.
+        Inherit publicly from Singleton<MyClass> and provide access to MyClass::singletonPtr_s.
         This can easily be done with a friend declaration.
+
+        See @ref SingletonExample "this example" for an exemplary implementation.
     */
     template <class T>
@@ -80,5 +161,5 @@
         }
 
-        //! Constructor resets the singleton instance pointer
+        //! Destructor resets the singleton instance pointer
         ~Singleton()
         {
Index: code/trunk/src/libraries/util/SmallObjectAllocator.cc
===================================================================
--- code/trunk/src/libraries/util/SmallObjectAllocator.cc	(revision 7305)
+++ code/trunk/src/libraries/util/SmallObjectAllocator.cc	(revision 7401)
@@ -27,15 +27,28 @@
  */
 
+/**
+    @file
+    @brief Implementation of SmallObjectAllocator
+*/
+
 #include "SmallObjectAllocator.h"
 
 namespace orxonox
 {
+    /**
+        @brief Constructor: initializes the allocator and its values.
+        @param objectSize The size in bytes (returned by sizeof()) of the allocated objects
+        @param numObjects The number of objects that are allocated in one block of memory
+    */
     SmallObjectAllocator::SmallObjectAllocator(size_t objectSize, size_t numObjects)
     {
-        this->objectSize_ = std::max(objectSize, sizeof(Chunk));
-        this->numObjects_ = numObjects;
+        this->chunkSize_ = std::max(objectSize, sizeof(Chunk)); // the chunk's size will be the maximum of the object's size and the size of a Chunk object itself
+        this->numChunksPerBlock_ = numObjects;
         this->first_ = 0;
     }
 
+    /**
+        @brief Destructor: deletes the allocated memory blocks.
+    */
     SmallObjectAllocator::~SmallObjectAllocator()
     {
@@ -44,4 +57,7 @@
     }
 
+    /**
+        @brief Helper function, used to set the next_ pointer of a Chunk.
+    */
     /* static */ void SmallObjectAllocator::setNext(void* chunk, void* next)
     {
@@ -49,4 +65,7 @@
     }
 
+    /**
+        @brief Helper function, returns the next_ pointer of a Chunk
+    */
     /* static */ void* SmallObjectAllocator::getNext(void* chunk)
     {
@@ -54,32 +73,48 @@
     }
 
+    /**
+        @brief Returns the first free memory chunk or allocates a new block of memory.
+    */
     void* SmallObjectAllocator::alloc()
     {
+        // get the first free chunk
         void* chunk = this->first_;
 
+        // check if the chunk exists
         if (chunk)
         {
+            // yes it does - the first_ pointer now points to the second element in the list
             this->first_ = getNext(chunk);
         }
         else
         {
-            char* block = new char[this->objectSize_ * this->numObjects_];
+            // no it doesnt - allocate a new block of memory
+            char* block = new char[this->chunkSize_ * this->numChunksPerBlock_];
             this->blocks_.push_back(block);
 
-            for (size_t i = 1; i < this->numObjects_ - 1; ++i)
-                setNext(block + i * this->objectSize_, block + (i + 1) * this->objectSize_);
+            // iterate through the chunks in the new memory block and link them together to a single linked list
+            for (size_t i = 1; i < this->numChunksPerBlock_ - 1; ++i)
+                setNext(block + i * this->chunkSize_, block + (i + 1) * this->chunkSize_);
 
-            setNext(block + (this->numObjects_ - 1) * this->objectSize_, 0);
+            // the next_ pointer of the last chunk must point to NULL
+            setNext(block + (this->numChunksPerBlock_ - 1) * this->chunkSize_, 0);
 
-            this->first_ = block + this->objectSize_;
+            // The second chunk in the block is assigned to the first_ pointer
+            this->first_ = block + this->chunkSize_;
 
+            // The first chunk in the block is returned
             chunk = block;
         }
 
+        // return the pointer to the chunk
         return chunk;
     }
 
+    /**
+        @brief Puts the memory chunk back on the list of free memory.
+    */
     void SmallObjectAllocator::free(void* chunk)
     {
+        // The first_ pointer points to the freed chunk, its next_ pointer points to the rest of the list
         setNext(chunk, this->first_);
         this->first_ = chunk;
Index: code/trunk/src/libraries/util/SmallObjectAllocator.h
===================================================================
--- code/trunk/src/libraries/util/SmallObjectAllocator.h	(revision 7305)
+++ code/trunk/src/libraries/util/SmallObjectAllocator.h	(revision 7401)
@@ -27,4 +27,49 @@
  */
 
+/**
+    @defgroup SmallObjectAllocator SmallObjectAllocator
+    @ingroup Util
+*/
+
+/**
+    @file
+    @ingroup SmallObjectAllocator
+    @brief Declaration of SmallObjectAllocator
+
+    @anchor SmallObjectAllocatorExample
+
+    The default implementations of new and delete are designed to work with objects of
+    arbitrary size. They are thus not optimal for small objects.
+    @ref orxonox::SmallObjectAllocator "SmallObjectAllocator" allocates a large memory
+    block and divides it into small chunks. These chunks are returned by the function
+    @ref orxonox::SmallObjectAllocator::alloc() "alloc()" and can be used to create a
+    new object using the placement new operator. Instead of delete, the function
+    @ref orxonox::SmallObjectAllocator::free() "free()" is used to give the memory
+    back to SmallObjectAllocator.
+
+    Example:
+    @code
+    SmallObjectAllocator allocator(sizeof(MySmallObject));  // Create an allocator. The size of the memory chunks must equal the size of the desired class
+
+    void* chunk = allocator.alloc();                        // Allocate a memory chunk
+    MySmallObject* object = new (chunk) MySmallObject();    // Call the placement new operator
+
+    object->someFunction();                                 // Do something with the object
+
+    object->~MySmallObject();                               // Call the destructor
+    allocator.free(object);                                 // Free the allocated memory
+    @endcode
+
+    @b Important: You have to call the destructor of the object manually, because this
+    is not automatically done by the allocator nor free().
+
+    @note The destructor can be ignored if it is empty or not implemented. This saves
+    another amount of time.
+
+    @remarks For a distributed usage of SmallObjectAllocator it may be a good idea to
+    create a static function that returns an instance to it. The allocator then works
+    like a singleton and can be accesses from everywhere.
+*/
+
 #ifndef _SmallObjectAllocator_H__
 #define _SmallObjectAllocator_H__
@@ -35,9 +80,17 @@
 namespace orxonox
 {
+    /**
+        @brief This class is used to allocate and free small objects (usually not polymorphic).
+
+        SmallObjectAllocator provides a fast alternative to new and delete for small objects.
+
+        @see See @ref SmallObjectAllocatorExample "this description" for more information and an example.
+    */
     class _UtilExport SmallObjectAllocator
     {
+        /// The memory chunk is at the same time an element of a single linked list.
         struct Chunk
         {
-            Chunk* next_;
+            Chunk* next_;   ///< A pointer to the next chunk in the list
         };
 
@@ -53,9 +106,9 @@
             static void* getNext(void* chunk);
 
-            void* first_;
-            size_t objectSize_;
-            size_t numObjects_;
+            void* first_;                   ///< A pointer to the first free memory chunk
+            size_t chunkSize_;              ///< The size of each chunk (and usually also the size of the created objects)
+            size_t numChunksPerBlock_;      ///< The number of chunks per memory block
 
-            std::vector<char*> blocks_;
+            std::vector<char*> blocks_;     ///< A list of all allocated memory blocks (used to destroy them again)
     };
 }
Index: code/trunk/src/libraries/util/StringUtils.cc
===================================================================
--- code/trunk/src/libraries/util/StringUtils.cc	(revision 7305)
+++ code/trunk/src/libraries/util/StringUtils.cc	(revision 7401)
@@ -41,6 +41,8 @@
 namespace orxonox
 {
+    /// A blank string (""). Used to return a blank string by reference.
     std::string BLANKSTRING;
 
+    /// Returns a string of a unique number. This function is guaranteed to never return the same string twice.
     std::string getUniqueNumberString()
     {
@@ -48,8 +50,5 @@
     }
 
-    /**
-        @brief Removes all whitespaces from a string.
-        @param str The string to strip
-    */
+    /// Removes all whitespaces from a string.
     void strip(std::string* str)
     {
@@ -63,9 +62,5 @@
     }
 
-    /**
-        @brief Returns a copy of a string without whitespaces.
-        @param str The string to strip
-        @return The stripped line
-    */
+    /// Returns a copy of a string without whitespaces.
     std::string getStripped(const std::string& str)
     {
@@ -75,9 +70,5 @@
     }
 
-    /**
-        @brief Returns a copy of a string without trailing whitespaces.
-        @param str The string
-        @return The modified copy
-    */
+    /// Returns a copy of a string without trailing whitespaces.
     std::string removeTrailingWhitespaces(const std::string& str)
     {
@@ -90,8 +81,8 @@
 
     /**
-        @brief Returns the position of the next quote in the string, starting with start.
+        @brief Returns the position of the next quotation mark in the string, starting with start.
         @param str The string
-        @param start The startposition
-        @return The position of the next quote (std::string::npos if there is no next quote)
+        @param start The first position to look at
+        @return The position of the next quotation mark (@c std::string::npos if there is none)
     */
     size_t getNextQuote(const std::string& str, size_t start)
@@ -115,8 +106,8 @@
 
     /**
-        @brief Returns true if pos is between two quotes.
+        @brief Returns true if pos is between two quotation marks.
         @param str The string
         @param pos The position to check
-        @return True if pos is between two quotes
+        @return True if pos is between two quotation marks
     */
     bool isBetweenQuotes(const std::string& str, size_t pos)
@@ -140,9 +131,5 @@
     }
 
-    /**
-        @brief Returns true if the string contains something like '..."between quotes"...'.
-        @param The string
-        @return True if there is something between quotes
-    */
+    /// Returns true if the string contains something like '..."between quotaton marks"...'.
     bool hasStringBetweenQuotes(const std::string& str)
     {
@@ -152,9 +139,5 @@
     }
 
-    /**
-        @brief If the string contains something like '..."between quotes"...' then 'between quotes' gets returned (without quotes).
-        @param The string
-        @param The string between the quotes
-    */
+    /// If the string contains something like '..."between quotaton marks"...' then 'between quotaton marks' gets returned, otherwise "".
     std::string getStringBetweenQuotes(const std::string& str)
     {
@@ -168,7 +151,6 @@
 
     /**
-        @brief Removes enclosing quotes if available (including whitespaces at the outside of the quotes).
-        @brief str The string to strip
-        @return The string with removed quotes
+        @brief Removes enclosing quotation marks if available (including whitespaces at the outside of the quotation marks).
+        @return The striped string without quotation marks
     */
     std::string stripEnclosingQuotes(const std::string& str)
@@ -208,7 +190,6 @@
 
     /**
-        @brief Removes enclosing {braces} (braces must be exactly on the beginning and the end of the string).
-        @param str The string to strip
-        @return The striped string
+        @brief Removes enclosing braces '{' and '}' (the braces must be exactly on the beginning and the end of the string).
+        @return The striped string without braces
     */
     std::string stripEnclosingBraces(const std::string& str)
@@ -224,6 +205,4 @@
     /**
         @brief Determines if a string is a comment (starts with a comment-symbol).
-        @param str The string to check
-        @return True = it's a comment
 
         A comment is defined by a leading '#', '%', ';' or '//'.
@@ -253,9 +232,5 @@
     }
 
-    /**
-        @brief Determines if a string is empty (contains only whitespaces).
-        @param str The string to check
-        @return True = it's empty
-    */
+    /// Determines if a string is empty (contains only whitespaces).
     bool isEmpty(const std::string& str)
     {
@@ -263,9 +238,5 @@
     }
 
-    /**
-        @brief Determines if a string contains only numbers and maximal one '.'.
-        @param str The string to check
-        @return True = it's a number
-    */
+    /// Determines if a string contains only numbers and maximal one '.'.
     bool isNumeric(const std::string& str)
     {
@@ -288,6 +259,12 @@
     /**
         @brief Adds backslashes to the given string which makes special chars visible. Existing slashes will be doubled.
-        @param str The string to manipulate
-        @return The string with added slashes
+
+        This function converts all special chars like line breaks, tabs, quotation marks etc. into
+        a human readable format by adding a backslash. So for example "\n" will be converted to
+        "\\" + "n".
+
+        This is usually used when a string is written to a file.
+
+        @see removeSlashes
     */
     std::string addSlashes(const std::string& str)
@@ -320,6 +297,11 @@
     /**
         @brief Removes backslashes from the given string. Double backslashes are interpreted as one backslash.
-        @param str The string to manipulate
-        @return The string with removed slashes
+
+        This function removes all backslashes and converts the human readable equivalents of
+        special chars like "\\" + "n" into their real meaning (in this case a line break or "\n").
+
+        This is usually used when reading a string from a file.
+
+        @see addSlashes
     */
     std::string removeSlashes(const std::string& str)
@@ -361,8 +343,5 @@
     }
 
-    /**
-        @brief Replaces each char between A and Z with its lowercase equivalent.
-        @param str The string to convert
-    */
+    /// Replaces each char between A and Z with its lowercase equivalent.
     void lowercase(std::string* str)
     {
@@ -373,9 +352,5 @@
     }
 
-    /**
-        @brief Returns a copy of the given string without uppercase chars.
-        @param str The string
-        @return The copy
-    */
+    /// Returns a copy of the given string where all chars are converted to lowercase.
     std::string getLowercase(const std::string& str)
     {
@@ -385,8 +360,5 @@
     }
 
-    /**
-        @brief Replaces each char between a and z with its uppercase equivalent.
-        @param str The string to convert
-    */
+    /// Replaces each char between a and z with its uppercase equivalent.
     void uppercase(std::string* str)
     {
@@ -397,9 +369,5 @@
     }
 
-    /**
-        @brief Returns a copy of the given string without lowercase chars.
-        @param str The string
-        @return The copy
-    */
+    /// Returns a copy of the given string where all chars are converted to uppercase.
     std::string getUppercase(const std::string& str)
     {
@@ -411,6 +379,5 @@
     /**
         @brief Compares two strings ignoring different casing.
-        @param s1 First string
-        @param s2 Second string
+        @return s1 == s1 -> returns 0 / s1 < s2 -> returns -1 / s1 >= s2 -> returns 1
     */
     int nocaseCmp(const std::string& s1, const std::string& s2)
@@ -438,5 +405,5 @@
 
     /**
-        @brief Compares the first 'len' chars of two strings ignoring different casing.
+        @brief Compares the first @a len chars of two strings ignoring different casing.
         @param s1 First string
         @param s2 Second string
@@ -463,39 +430,26 @@
     }
 
-    /**
-        @brief Returns true if the string contains a comment, introduced by #, %, ; or //.
+    /// Returns true if the string contains a comment, introduced by #, %, ; or //.
+    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.
+    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.
         @param str The string
-        @return True if the string contains a comment
-    */
-    bool hasComment(const std::string& str)
-    {
-        return (getCommentPosition(str) != std::string::npos);
-    }
-
-    /**
-        @brief If the string contains a comment, the comment gets returned (including the comment symbol), an empty string otherwise.
-        @param str The string
-        @return The comment
-    */
-    std::string getComment(const std::string& str)
-    {
-        return str.substr(getCommentPosition(str));
-    }
-
-    /**
-        @brief If the string contains a comment, the position of the comment-symbol gets returned, std::string::npos otherwise.
-        @param str The string
-        @return The position
-    */
-    size_t getCommentPosition(const std::string& str)
-    {
-        return getNextCommentPosition(str, 0);
-    }
-
-    /**
-        @brief Returns the position of the next comment-symbol, starting with start.
-        @param str The string
-        @param start The startposition
-        @return The position
+        @param start The first position to look at
     */
     size_t getNextCommentPosition(const std::string& str, size_t start)
Index: code/trunk/src/libraries/util/StringUtils.h
===================================================================
--- code/trunk/src/libraries/util/StringUtils.h	(revision 7305)
+++ code/trunk/src/libraries/util/StringUtils.h	(revision 7401)
@@ -28,5 +28,11 @@
 
 /**
+    @defgroup String String functions
+    @ingroup Util
+*/
+
+/**
     @file
+    @ingroup String
     @brief Declaration of several string manipulation functions, used in many parts of the game.
 */
Index: code/trunk/src/libraries/util/SubString.cc
===================================================================
--- code/trunk/src/libraries/util/SubString.cc	(revision 7305)
+++ code/trunk/src/libraries/util/SubString.cc	(revision 7401)
@@ -38,233 +38,196 @@
  */
 
+/**
+    @file
+    @brief Implementation of the SubString class.
+*/
+
 #include "SubString.h"
 #include <cstdio>
+#include "Debug.h"
 
 namespace orxonox
 {
-    /**
-     * @brief default constructor
-     */
+    const std::string SubString::WhiteSpaces          = " \n\t";
+    const std::string SubString::WhiteSpacesWithComma = " \n\t,";
+    const SubString SubString::NullSubString          = SubString();
+
+    /**
+        @brief Default constructor.
+    */
     SubString::SubString()
-    {}
-
-
-    /**
-     * @brief create a SubString from
-     * @param string the String to Split
-     * @param delimiter the Character at which to split string (delimiter)
-     */
-    SubString::SubString(const std::string& string, char delimiter)
-    {
-        this->split(string, delimiter);
-    }
-
-
-    /**
-     * @brief Splits a String into multiple splitters.
-     * @param string the String to split
-     * @param delimiters multiple set of characters at what to split. (delimiters)
-     * @param delimiterNeighbours neighbours of the delimiters, that will be erased only when near a delimiter.
-     * @param emptyEntries If empty entries should be allewed or removed.
-     * @param escapeChar The Escape Character that overrides splitters commends and so on...
-     * @param safemode_char within these characters splitting won't happen
-     * @param comment_char the Comment character.
-     */
-    SubString::SubString(const std::string& string,
-                         const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
-                         char escapeChar, bool removeEscapeChar, char safemode_char, bool removeSafemodeChar,
-                         char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
-    {
-        SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeEscapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
-    }
-
-    /**
-     * @brief creates a SubSet of a SubString.
-     * @param subString the SubString to take a set from.
-     * @param subSetBegin the beginning to the end
-     */
-    SubString::SubString(const SubString& subString, unsigned int subSetBegin)
-    {
-        for (unsigned int i = subSetBegin; i < subString.size(); i++)
-        {
-            this->strings.push_back(subString[i]);
-            this->bInSafemode.push_back(subString.isInSafemode(i));
-        }
-    }
-
-
-    /**
-     * @brief creates a SubSet of a SubString.
-     * @param subString the SubString to take a Set from
-     * @param subSetBegin the beginning to the end
-     * @param subSetEnd the end of the SubSet (max subString.size() will be checked internaly)
-     */
-    SubString::SubString(const SubString& subString, unsigned int subSetBegin, unsigned int subSetEnd)
-    {
-        for (unsigned int i = subSetBegin; i < subString.size() && i < subSetEnd; i++)
-        {
-            this->strings.push_back(subString[i]);
-            this->bInSafemode.push_back(subString.isInSafemode(i));
-        }
-    }
-
-    /**
-     * @brief creates a Substring from a count and values set.
-     * @param argc: the Arguments Count.
-     * @param argv: Argument Values.
-     */
+    {
+    }
+
+    /**
+        @brief Splits a string into multiple tokens.
+        @param line The line to split
+        @param delimiters Multiple characters at which to split the line
+        @param delimiterNeighbours Neighbours of the delimiters that will be erased as well (for example white-spaces)
+        @param bAllowEmptyEntries If true, empty tokens are also added to the SubString (if there are two delimiters without a char in between)
+        @param escapeChar The escape character that is used to escape safemode chars (for example if you want to use a quotation mark between two other quotation marks).
+        @param bRemoveEscapeChar If true, the escape char is removed from the tokens
+        @param safemodeChar Within these characters splitting won't happen (usually the quotation marks)
+        @param bRemoveSafemodeChar Removes the safemodeChar from the beginning and the ending of a token
+        @param openparenthesisChar The beginning of a safemode is marked with this (usually an opening brace)
+        @param closeparenthesisChar The ending of a safemode is marked with this (usually a closing brace)
+        @param bRemoveParenthesisChars Removes the parenthesis chars from the beginning and the ending of a token
+        @param commentChar The comment character (used to ignore the part of the line after the comment char).
+    */
+    SubString::SubString(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)
+    {
+        SubString::splitLine(this->tokens_, this->bTokenInSafemode_, line, delimiters, delimiterNeighbours, bAllowEmptyEntries, escapeChar, bRemoveEscapeChar, safemodeChar, bRemoveSafemodeChar, openparenthesisChar, closeparenthesisChar, bRemoveParenthesisChars, commentChar);
+    }
+
+    /**
+        @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
+
+        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));
+        }
+    }
+
+    /**
+        @brief Creates a SubString from a count and values set.
+        @param argc The number of arguments
+        @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)
         {
-            this->strings.push_back(std::string(argv[i]));
-            this->bInSafemode.push_back(false);
-        }
-    }
-
-    /**
-     * @brief removes the object from memory
-     */
+            this->tokens_.push_back(std::string(argv[i]));
+            this->bTokenInSafemode_.push_back(false);
+        }
+    }
+
+    /**
+        @brief Destructor
+    */
     SubString::~SubString()
     { }
 
-    /** @brief An empty String */
-    // const std::string SubString::emptyString = "";
-    /** @brief Helper that gets you a String consisting of all White Spaces */
-    const std::string SubString::WhiteSpaces = " \n\t";
-    /** @brief Helper that gets you a String consisting of all WhiteSpaces and the Comma */
-    const std::string SubString::WhiteSpacesWithComma = " \n\t,";
-    /** An Empty SubString */
-    const SubString SubString::NullSubString = SubString();
-
-    /**
-     * @brief stores the Value of subString in this SubString
-     * @param subString will be copied into this String.
-     * @returns this SubString.
-     */
-    SubString& SubString::operator=(const SubString& subString)
-    {
-        this->strings = subString.strings;
-        this->bInSafemode = subString.bInSafemode;
+    /**
+        @brief Stores the tokens of @a other in this SubString
+        @return This SubString.
+    */
+    SubString& SubString::operator=(const SubString& other)
+    {
+        this->tokens_ = other.tokens_;
+        this->bTokenInSafemode_ = other.bTokenInSafemode_;
         return *this;
     }
 
-
-    /**
-     * @brief comparator.
-     * @param subString the SubString to compare against this one.
-     * @returns true if the Stored Strings match
-     */
-    bool SubString::operator==(const SubString& subString) const
-    {
-        return ((this->strings == subString.strings) && (this->bInSafemode == subString.bInSafemode));
-    }
-
-    /**
-     * @brief comparator.
-     * @param subString the SubString to compare against this one.
-     * @returns true if the Stored Strings match
-     */
-    bool SubString::compare(const SubString& subString) const
-    {
-        return (*this == subString);
-    }
-
-    /**
-     * @brief comparator.
-     * @param subString the SubString to compare against this one.
-     * @param length how many entries to compare. (from 0 to length)
-     * @returns true if the Stored Strings match
-     */
-    bool SubString::compare(const SubString& subString, unsigned int length) const
-    {
-        if (length > this->size() || length > subString.size())
+    /**
+        @brief Compares this SubString to another SubString and returns true if they contain the same values.
+    */
+    bool SubString::operator==(const SubString& other) const
+    {
+        return ((this->tokens_ == other.tokens_) && (this->bTokenInSafemode_ == other.bTokenInSafemode_));
+    }
+
+    /**
+        @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())
             return false;
 
-        for (unsigned int i = 0; i < length; i++)
-            if ((this->strings[i] != subString.strings[i]) || (this->bInSafemode[i] != subString.bInSafemode[i]))
+        for (unsigned int i = 0; i < length; ++i)
+            if ((this->tokens_[i] != other.tokens_[i]) || (this->bTokenInSafemode_[i] != other.bTokenInSafemode_[i]))
                 return false;
         return true;
     }
 
-
-    /**
-     * @brief append operator
-     * @param subString the String to append.
-     * @returns a SubString where this and subString are appended.
-     */
-    SubString SubString::operator+(const SubString& subString) const
-    {
-        return SubString(*this) += subString;
-    }
-
-
-    /**
-     * @brief append operator.
-     * @param subString append subString to this SubString.
-     * @returns this substring appended with subString
-     */
-    SubString& SubString::operator+=(const SubString& subString)
-    {
-        for (unsigned int i = 0; i < subString.size(); i++)
-        {
-            this->strings.push_back(subString[i]);
-            this->bInSafemode.push_back(subString.isInSafemode(i));
+    /**
+        @brief Concatenates the tokens of two SubStrings and returns the resulting new SubString
+        @return A new SubString that contains the tokens of this and the other SubString
+    */
+    SubString SubString::operator+(const SubString& other) const
+    {
+        return SubString(*this) += other;
+    }
+
+    /**
+        @brief Appends the tokens of @a other to this SubString
+        @return This SubString
+    */
+    SubString& SubString::operator+=(const SubString& other)
+    {
+        for (unsigned int i = 0; i < other.size(); ++i)
+        {
+            this->tokens_.push_back(other[i]);
+            this->bTokenInSafemode_.push_back(other.isInSafemode(i));
         }
         return *this;
     }
 
-
-    /**
-     * @brief Split the String at
-     * @param string where to split
-     * @param splitter delimiter.
-     */
-    unsigned int SubString::split(const std::string& string, char splitter)
-    {
-        this->strings.clear();
-        this->bInSafemode.clear();
-        char split[2];
-        split[0] = splitter;
-        split[1] = '\0';
-        SubString::splitLine(this->strings, this->bInSafemode, string, split);
-        return strings.size();
-    }
-
-
-    /**
-     * @brief Splits a String into multiple splitters.
-     * @param string the String to split
-     * @param delimiters multiple set of characters at what to split. (delimiters)
-     * @param delimiterNeighbours: Neighbours to the Delimiters that will be erased too.
-     * @param emptyEntries: If empty entries are added to the List of SubStrings
-     * @param escapeChar The Escape Character that overrides splitters commends and so on...
-     * @param safemode_char within these characters splitting won't happen
-     * @param comment_char the Comment character.
-     */
-    unsigned int SubString::split(const std::string& string,
-                                  const std::string& delimiters, const std::string& delimiterNeighbours, bool emptyEntries,
-                                  char escapeChar, bool removeExcapeChar, char safemode_char, bool removeSafemodeChar,
-                                  char openparenthesis_char, char closeparenthesis_char, bool removeParenthesisChars, char comment_char)
-    {
-        this->strings.clear();
-        this->bInSafemode.clear();
-        SubString::splitLine(this->strings, this->bInSafemode, string, delimiters, delimiterNeighbours, emptyEntries, escapeChar, removeExcapeChar, safemode_char, removeSafemodeChar, openparenthesis_char, closeparenthesis_char, removeParenthesisChars, comment_char);
-        return this->strings.size();
-    }
-
-
-    /**
-     * @brief joins together all Strings of this Substring.
-     * @param delimiter the String between the subStrings.
-     * @returns the joined String.
-     */
+    /**
+        @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)
+    {
+        this->tokens_.clear();
+        this->bTokenInSafemode_.clear();
+        SubString::splitLine(this->tokens_, this->bTokenInSafemode_, line, delimiters, delimiterNeighbours, bAllowEmptyEntries, escapeChar, bRemoveEscapeChar, safemodeChar, bRemoveSafemodeChar, openparenthesisChar, closeparenthesisChar, bRemoveParenthesisChars, commentChar);
+        return this->tokens_.size();
+    }
+
+    /**
+        @brief Joins the tokens of this SubString using the given delimiter and returns a string.
+        @param delimiter This delimiter will be placed between each two tokens
+        @return The joined string.
+    */
     std::string SubString::join(const std::string& delimiter) const
     {
-        if (!this->strings.empty())
-        {
-            std::string retVal = this->strings[0];
-            for (unsigned int i = 1; i < this->strings.size(); i++)
-                retVal += delimiter + this->strings[i];
+        if (!this->tokens_.empty())
+        {
+            std::string retVal = this->tokens_[0];
+            for (unsigned int i = 1; i < this->tokens_.size(); ++i)
+                retVal += delimiter + this->tokens_[i];
             return retVal;
         }
@@ -273,71 +236,63 @@
     }
 
-
-    /**
-     * @brief creates a SubSet of a SubString.
-     * @param subSetBegin the beginning to the end
-     * @returns the SubSet
-     *
-     * This function is added for your convenience, and does the same as
-     * SubString::SubString(const SubString& subString, unsigned int subSetBegin)
-     */
-    SubString SubString::subSet(unsigned int subSetBegin) const
-    {
-        return SubString(*this, subSetBegin);
-    }
-
-
-    /**
-     * @brief creates a SubSet of a SubString.
-     * @param subSetBegin the beginning to
-     * @param subSetEnd the end of the SubSet to select (if bigger than subString.size() it will be downset.)
-     * @returns the SubSet
-     *
-     * This function is added for your convenience, and does the same as
-     * SubString::SubString(const SubString& subString, unsigned int subSetBegin)
-     */
-    SubString SubString::subSet(unsigned int subSetBegin, unsigned int subSetEnd) const
-    {
-        return SubString(*this, subSetBegin, subSetEnd);
-    }
-
-
-    /**
-     * @brief splits line into tokens and stores them in ret.
-     * @param ret the Array, where the Splitted strings will be stored in
-     * to the beginning of the current token is stored
-     * @param line the inputLine to split
-     * @param delimiters a String of Delimiters (here the input will be splitted)
-     * @param delimiterNeighbours Neighbours to the Delimiter, that will be removed if they are to the left or the right of a Delimiter.
-     * @param emptyEntries: if empty Strings are added to the List of Strings.
-     * @param escape_char: Escape carater (escapes splitters)
-     * @param safemode_char: the beginning of the safemode is marked with this
-     * @param removeSafemodeChar removes the safemode_char from the beginning and the ending of a token
-     * @param openparenthesis_char the beginning of a safemode is marked with this
-     * @param closeparenthesis_char the ending of a safemode is marked with this
-     * @param removeParenthesisChars removes the parenthesis from the beginning and the ending of a token
-     * @param comment_char: the beginning of a comment is marked with this: (until the end of a Line)
-     * @param start_state: the Initial state on how to parse the String.
-     * @return SPLIT_LINE_STATE the parser was in when returning
-     *
-     * This is the Actual Splitting Algorithm from Clemens Wacha
-     * Supports delimiters, escape characters,
-     * ignores special  characters between safemode_char and between comment_char and linend '\n'.
-     */
+    /**
+        @brief Creates a subset of this SubString.
+        @param begin The beginning 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.
+
+        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);
+    }
+
+    /**
+        @copydoc SubString(const std::string&,const std::string&,const std::string&,bool,char,bool,char,bool,char,char,bool,char)
+        @param tokens The array, where the splitted strings will be stored in
+        @param bTokenInSafemode A vector wich stores for each character of the string if it is in safemode or not
+        @param start_state The internal state of the parser
+
+        This is the actual splitting algorithm from Clemens Wacha.
+        Supports delimiters, escape characters, ignores special characters between safemodeChar and between commentChar and line end "\n".
+
+        Extended by Orxonox to support parenthesis as additional safe-mode.
+    */
     SubString::SPLIT_LINE_STATE
-    SubString::splitLine(std::vector<std::string>& ret,
-                         std::vector<bool>& bInSafemode,
+    SubString::splitLine(std::vector<std::string>& tokens,
+                         std::vector<bool>& bTokenInSafemode,
                          const std::string& line,
                          const std::string& delimiters,
                          const std::string& delimiterNeighbours,
-                         bool emptyEntries,
-                         char escape_char,
-                         bool removeExcapeChar,
-                         char safemode_char,
-                         bool removeSafemodeChar,
-                         char openparenthesis_char,
-                         char closeparenthesis_char,
-                         bool removeParenthesisChars,
-                         char comment_char,
+                         bool bAllowEmptyEntries,
+                         char escapeChar,
+                         bool bRemoveEscapeChar,
+                         char safemodeChar,
+                         bool bRemoveSafemodeChar,
+                         char openparenthesisChar,
+                         char closeparenthesisChar,
+                         bool bRemoveParenthesisChars,
+                         char commentChar,
                          SPLIT_LINE_STATE start_state)
     {
@@ -349,13 +304,13 @@
         bool inSafemode = false;
 
-        if(start_state != SL_NORMAL && ret.size() > 0)
-        {
-            token = ret[ret.size()-1];
-            ret.pop_back();
-        }
-        if(start_state != SL_NORMAL && bInSafemode.size() > 0)
-        {
-            inSafemode = bInSafemode[bInSafemode.size()-1];
-            bInSafemode.pop_back();
+        if(start_state != SL_NORMAL && tokens.size() > 0)
+        {
+            token = tokens[tokens.size()-1];
+            tokens.pop_back();
+        }
+        if(start_state != SL_NORMAL && bTokenInSafemode.size() > 0)
+        {
+            inSafemode = bTokenInSafemode[bTokenInSafemode.size()-1];
+            bTokenInSafemode.pop_back();
         }
 
@@ -365,34 +320,38 @@
             {
             case SL_NORMAL:
-                if(line[i] == escape_char)
+                if(line[i] == escapeChar)
                 {
                     state = SL_ESCAPE;
-                    if (!removeExcapeChar)
+                    if (!bRemoveEscapeChar)
                         token += line[i];
-                }
-                else if(line[i] == safemode_char)
+                    fallBackNeighbours = 0;
+                }
+                else if(line[i] == safemodeChar)
                 {
                     state = SL_SAFEMODE;
                     inSafemode = true;
-                    if (!removeSafemodeChar)
+                    if (!bRemoveSafemodeChar)
                         token += line[i];
-                }
-                else if(line[i] == openparenthesis_char)
+                    fallBackNeighbours = 0;
+                }
+                else if(line[i] == openparenthesisChar)
                 {
                     state = SL_PARENTHESES;
                     inSafemode = true;
-                    if (!removeParenthesisChars)
+                    if (!bRemoveParenthesisChars)
                         token += line[i];
-                }
-                else if(line[i] == comment_char)
+                    fallBackNeighbours = 0;
+                }
+                else if(line[i] == commentChar)
                 {
                     if (fallBackNeighbours > 0)
                         token = token.substr(0, token.size() - fallBackNeighbours);
-                    /// FINISH
-                    if(emptyEntries || token.size() > 0)
+                    fallBackNeighbours = 0;
+                    // FINISH
+                    if(bAllowEmptyEntries || token.size() > 0)
                     {
-                        ret.push_back(token);
+                        tokens.push_back(token);
                         token.clear();
-                        bInSafemode.push_back(inSafemode);
+                        bTokenInSafemode.push_back(inSafemode);
                         inSafemode = false;
                     }
@@ -405,10 +364,11 @@
                     if (fallBackNeighbours > 0)
                         token = token.substr(0, token.size() - fallBackNeighbours);
-                    /// FINISH
-                    if(emptyEntries || token.size() > 0)
+                    fallBackNeighbours = 0;
+                    // FINISH
+                    if(bAllowEmptyEntries || token.size() > 0)
                     {
-                        ret.push_back(token);
+                        tokens.push_back(token);
                         token.clear();
-                        bInSafemode.push_back(inSafemode);
+                        bTokenInSafemode.push_back(inSafemode);
                         inSafemode = false;
                     }
@@ -423,5 +383,5 @@
                         else
                         {
-                            i++;
+                            ++i;
                             continue;
                         }
@@ -433,5 +393,5 @@
                 break;
             case SL_ESCAPE:
-                if (!removeSafemodeChar)
+                if (!bRemoveSafemodeChar)
                     token += line[i];
                 else
@@ -450,11 +410,11 @@
                 break;
             case SL_SAFEMODE:
-                if(line[i] == safemode_char)
+                if(line[i] == safemodeChar)
                 {
                     state = SL_NORMAL;
-                    if (!removeSafemodeChar)
+                    if (!bRemoveSafemodeChar)
                         token += line[i];
                 }
-                else if(line[i] == escape_char)
+                else if(line[i] == escapeChar)
                 {
                     state = SL_SAFEESCAPE;
@@ -480,11 +440,11 @@
 
             case SL_PARENTHESES:
-                if(line[i] == closeparenthesis_char)
+                if(line[i] == closeparenthesisChar)
                 {
                     state = SL_NORMAL;
-                    if (!removeParenthesisChars)
+                    if (!bRemoveParenthesisChars)
                         token += line[i];
                 }
-                else if(line[i] == escape_char)
+                else if(line[i] == escapeChar)
                 {
                     state = SL_PARENTHESESESCAPE;
@@ -512,10 +472,10 @@
                 if(line[i] == '\n')
                 {
-                    /// FINISH
+                    // FINISH
                     if(token.size() > 0)
                     {
-                        ret.push_back(token);
+                        tokens.push_back(token);
                         token.clear();
-                        bInSafemode.push_back(inSafemode);
+                        bTokenInSafemode.push_back(inSafemode);
                         inSafemode = false;
                     }
@@ -532,15 +492,15 @@
                 break;
             }
-            i++;
-        }
-
-        /// FINISH
+            ++i;
+        }
+
+        // FINISH
         if (fallBackNeighbours > 0)
             token = token.substr(0, token.size() - fallBackNeighbours);
-        if(emptyEntries || token.size() > 0)
-        {
-            ret.push_back(token);
+        if(bAllowEmptyEntries || token.size() > 0)
+        {
+            tokens.push_back(token);
             token.clear();
-            bInSafemode.push_back(inSafemode);
+            bTokenInSafemode.push_back(inSafemode);
             inSafemode = false;
         }
@@ -548,14 +508,13 @@
     }
 
-
-    /**
-     * @brief Some nice debug information about this SubString
-     */
+    /**
+        @brief Some nice debug information about this SubString.
+    */
     void SubString::debug() const
     {
-        printf("Substring-information::count=%d ::", this->strings.size());
-        for (unsigned int i = 0; i < this->strings.size(); i++)
-            printf("s%d='%s'::", i, this->strings[i].c_str());
-        printf("\n");
+        COUT(0) << "Substring-information::count=" << this->tokens_.size() << " ::";
+        for (unsigned int i = 0; i < this->tokens_.size(); ++i)
+            COUT(0) << "s" << i << "='" << this->tokens_[i].c_str() << "'::";
+        COUT(0) << std::endl;
     }
 }
Index: code/trunk/src/libraries/util/SubString.h
===================================================================
--- code/trunk/src/libraries/util/SubString.h	(revision 7305)
+++ code/trunk/src/libraries/util/SubString.h	(revision 7401)
@@ -37,22 +37,47 @@
  */
 
- /*!
- * @file
- * @brief a small class to get the parts of a string separated by commas
- *
- * This class is also identified as a Tokenizer. It splits up one long
- * String into multiple small ones by a designated Delimiter.
- *
- * Substring is Advanced, and it is possible, to split a string by ','
- * but also removing leading and trailing spaces around the comma.
- *
- * @example
- * Split the String std::string st = "1345, The new empire   , is , orxonox"
- * is splitted with:
- * SubString(st, ',', " \n\t")
- * into
- * "1345", "The new empire", "is", "orxonox"
- * As you can see, the useless spaces around ',' were removed.
- */
+ /**
+    @file
+    @ingroup String
+    @brief A helper class to split a string into several tokens.
+
+    @anchor SubStringExample
+
+    The class SubString can be used to split an std::string into multiple tokens, using
+    a delimiter. SubString allows different options, for example to remove whitespaces
+    around the delimiters or different safe-mode chars, like quotation marks and braces.
+
+    You can access the tokens of the SubString using the [] operator like an array.
+    SubString also supports to join the tokens (or a subset of the tokens) again using
+    @ref orxonox::SubString::join() "join()". It's even possible to get a subset of the
+    SubString as another SubString using @ref orxonox::SubString::subSet() "subSet()".
+
+    Example:
+    @code
+    std::string text = "This is a test, \"Hello \\\" World\" and vector {1, 2, 3}";
+    SubString tokens(text, SubString::WhiteSpaces, "", false, '\\', true, '"', true, '{', '}', true, '\0');
+
+    for (unsigned int i = 0; i < tokens.size(); ++i)
+        COUT(0) << i << ": " << tokens[i] << std::endl;
+    @endcode
+
+    The output of this code is:
+     - 0: This
+     - 1: is
+     - 2: a
+     - 3: test,
+     - 4: Hello " World
+     - 5: and
+     - 6: vector
+     - 7: 1, 2, 3
+
+    The string was split using the delimiter " ". A string between quotation mark is not
+    split, the same holds for strings between '{' and '}'. Note how the quotation marks and
+    the braces were removed from the tokens, because the corresponding argument is 'true'.
+
+    Also note that the comma after "test" in token 3 is still there - it is neither part of the
+    delimiters SubString::WhiteSpaces nor part of the delimiterNeighbours parameter, so it
+    remains a part of the token.
+*/
 
 #ifndef __SubString_H__
@@ -66,109 +91,124 @@
 namespace orxonox
 {
-    //! A class that can load one string and split it in multipe ones
     /**
-     * SubString is a very Powerfull way to create a SubSet from a String
-     * It can be used, to Split strings append them and join them again.
-     */
+        @brief A class that splits a string into multiple tokens using different options.
+
+        The string is split into multiple tokens using a delimiter. Different options like
+        escape character, quotation marks, and more can be used to satisfy your needs.
+
+        See @ref SubStringExample "this description" for an example.
+    */
     class _UtilExport SubString
     {
-    public:
-        //! An enumerator for the State the Parser is in
-        typedef enum {
+        /// An enumerator for the internal state of the parser
+        enum SPLIT_LINE_STATE
+        {
             SL_NORMAL,            //!< Normal state
             SL_ESCAPE,            //!< After an escape character
-            SL_SAFEMODE,          //!< In safe mode (between "" mostly).
+            SL_SAFEMODE,          //!< In safe mode (usually between quotation marks).
             SL_SAFEESCAPE,        //!< In safe mode with the internal escape character, that escapes even the savemode character.
             SL_COMMENT,           //!< In Comment mode.
             SL_PARENTHESES,       //!< Between parentheses (usually '{' and '}')
             SL_PARENTHESESESCAPE, //!< Between parentheses with the internal escape character, that escapes even the closing paranthesis character.
-        } SPLIT_LINE_STATE;
-
+        };
 
     public:
         SubString();
-        SubString(const std::string& string, char delimiter = ',');
-        SubString(const std::string& string,
-                  const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries=false,
-                  char escapeChar ='\\', bool removeEscapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
-                  char openparenthesis_char = '{', char closeparenthesis_char = '}',  bool removeParenthesisChars = true, char comment_char = '\0');
+        SubString(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');
         SubString(unsigned int argc, const char** argv);
-        /** @brief create a Substring as a copy of another one. @param subString the SubString to copy. */
-        SubString(const SubString& subString) { *this = subString; };
-        SubString(const SubString& subString, unsigned int subSetBegin);
-        SubString(const SubString& subString, unsigned int subSetBegin, unsigned int subSetEnd);
+        SubString(const SubString& other, unsigned int begin);
+        SubString(const SubString& other, unsigned int begin, unsigned int end);
         ~SubString();
 
         // operate on the SubString
-        SubString& operator=(const SubString& subString);
-        bool operator==(const SubString& subString) const;
-        bool compare(const SubString& subString) const;
-        bool compare(const SubString& subString, unsigned int length) const;
-        SubString operator+(const SubString& subString) const;
-        SubString& operator+=(const SubString& subString);
-        /** @param subString the String to append @returns appended String. @brief added for convenience */
-        SubString& append(const SubString subString) { return (*this += subString); };
+        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;
+        SubString operator+(const SubString& other) const;
+        SubString& operator+=(const SubString& other);
+        /// Appends the tokens of another SubString to this. @return This SubString.
+        inline SubString& append(const SubString& other) { return (*this += other); }
 
         /////////////////////////////////////////
         // Split and Join the any String. ///////
-        unsigned int split(const std::string& string = "", char delimiter = ',');
-        unsigned int split(const std::string& string,
-                           const std::string& delimiters, const std::string& delimiterNeighbours = "", bool emptyEntries = false,
-                           char escapeChar ='\\', bool removeExcapeChar = true, char safemode_char = '"', bool removeSafemodeChar = true,
-                           char openparenthesis_char = '{', char closeparenthesis_char = '}',  bool removeParenthesisChars = true, char comment_char = '\0');
+        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');
+
         std::string join(const std::string& delimiter = " ") const;
         ////////////////////////////////////////
 
         // retrieve a SubSet from the String
-        SubString subSet(unsigned int subSetBegin) const;
-        SubString subSet(unsigned int subSetBegin, unsigned int subSetEnd) const;
+        SubString subSet(unsigned int begin) const;
+        SubString subSet(unsigned int begin, unsigned int end) const;
 
         // retrieve Information from within
-        /** @brief Returns true if the SubString is empty */
-        inline bool empty() const { return this->strings.empty(); };
-        /** @brief Returns the count of Strings stored in this substring */
-        inline unsigned int size() const { return this->strings.size(); };
-        /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
-        inline const std::string& operator[](unsigned int i) const { return this->strings[i]; };
-        /** @brief Returns the i'th string from the subset of Strings @param i the i'th String */
-        inline const std::string& getString(unsigned int i) const { return (*this)[i]; };
-        /** @brief Returns all Strings as std::vector */
-        inline const std::vector<std::string>& getAllStrings() const { return this->strings; }
-        /** @brief Returns true if the token is in safemode. @param i the i'th token */
-        inline bool isInSafemode(unsigned int i) const { return this->bInSafemode[i]; }
-        /** @brief Returns the front of the StringList. */
-        inline const std::string& front() const { return this->strings.front(); };
-        /** @brief Returns the back of the StringList. */
-        inline const std::string& back() const { return this->strings.back(); };
-        /** @brief removes the back of the strings list. */
-        inline void pop_back() { this->strings.pop_back(); this->bInSafemode.pop_back(); };
-
+        /// Returns true if the SubString is empty
+        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(); }
+        /// Returns the i'th token from the subset of strings @param index The index of the requested doken
+        inline const std::string& operator[](unsigned int 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]; }
+        /// 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]; }
+        /// Returns the front of the list of tokens.
+        inline const std::string& front() const { return this->tokens_.front(); }
+        /// Returns the back of the list of tokens.
+        inline const std::string& back() const { return this->tokens_.back(); }
+        /// Removes the back of the list of tokens.
+        inline void pop_back() { this->tokens_.pop_back(); this->bTokenInSafemode_.pop_back(); }
+
+        void debug() const;
+
+    public:
+        static const std::string WhiteSpaces;           ///< All whitespaces (usually used as delimiters or delimiterNeighbours
+        static const std::string WhiteSpacesWithComma;  ///< All whitespaces and the comma (usually used as delimiters)
+        static const SubString   NullSubString;         ///< An empty SubString
+
+    private:
         // the almighty algorithm.
-        static SPLIT_LINE_STATE splitLine(std::vector<std::string>& ret,
-                                          std::vector<bool>& bInSafemode,
+        static SPLIT_LINE_STATE splitLine(std::vector<std::string>& tokens,
+                                          std::vector<bool>& bTokenInSafemode,
                                           const std::string& line,
                                           const std::string& delimiters = SubString::WhiteSpaces,
                                           const std::string& delimiterNeighbours = "",
-                                          bool emptyEntries = false,
-                                          char escape_char = '\\',
-                                          bool removeExcapeChar = true,
-                                          char safemode_char = '"',
-                                          bool removeSafemodeChar = true,
-                                          char openparenthesis_char = '{',
-                                          char closeparenthesis_char = '}',
-                                          bool removeParenthesisChars = true,
-                                          char comment_char = '\0',
+                                          bool bAllowEmptyEntries = false,
+                                          char escapeChar = '\\',
+                                          bool bRemoveEscapeChar = true,
+                                          char safemodeChar = '"',
+                                          bool bRemoveSafemodeChar = true,
+                                          char openparenthesisChar = '{',
+                                          char closeparenthesisChar = '}',
+                                          bool bRemoveParenthesisChars = true,
+                                          char commentChar = '\0',
                                           SPLIT_LINE_STATE start_state = SL_NORMAL);
-        // debugging.
-        void debug() const;
-
-    public:
-        static const std::string WhiteSpaces;
-        static const std::string WhiteSpacesWithComma;
-        static const SubString   NullSubString;
-
-    private:
-        std::vector<std::string>  strings;                      //!< strings produced from a single string splitted in multiple strings
-        std::vector<bool>         bInSafemode;
+
+        std::vector<std::string>  tokens_;              ///< The tokens after spliting the input line
+        std::vector<bool>         bTokenInSafemode_;    ///< Saves for each token if it was in safe mode (between quotation marks or parenthesis)
     };
 }
Index: code/trunk/src/libraries/util/TriBool.h
===================================================================
--- code/trunk/src/libraries/util/TriBool.h	(revision 7305)
+++ code/trunk/src/libraries/util/TriBool.h	(revision 7401)
@@ -27,4 +27,9 @@
  */
 
+/**
+    @file
+    @ingroup Util
+*/
+
 #ifndef _TriBool_H__
 #define _TriBool_H__
@@ -35,4 +40,9 @@
 namespace orxonox
 {
+    /** Sort of a boolean value that also has state \c Dontcare
+    @remarks
+        Even though \c False has the value 0, both \c True and \c Dontcare have
+        a value other than 0. Keep that in mind when using TriBools in if statements.
+    */
     namespace TriBool
     {
Index: code/trunk/src/libraries/util/VA_NARGS.h
===================================================================
--- code/trunk/src/libraries/util/VA_NARGS.h	(revision 7305)
+++ code/trunk/src/libraries/util/VA_NARGS.h	(revision 7401)
@@ -29,5 +29,37 @@
 /**
     @file
+    @ingroup Util
     @brief Declaration of the ORXONOX_VA_NARGS macro which returns the number of arguments passed to a variadic macro.
+
+    With this utility you can overload a macro for different numbers of arguments
+    (of course overloading is not possible for different types, as macros are not
+    type aware, but for different numbers of arguments is still very powerful).
+
+    Example: A macro to call functions
+    @code
+    myfunction();                                           // A static function
+    MyClass::myStaticFunction();                            // A static class function
+    MyClass::myFunction();                                  // A member function
+
+    #define CallFunction(...) \                             // Define a variadic macro that passes the arguments to the overloaded implementations
+        BOOST_PP_EXPAND(BOOST_PP_CAT(CallFunction, ORXONOX_VA_NARGS(__VA_ARGS__))(__VA_ARGS__))
+
+    #define CallFunction1(function) \                       // Overloaded macro for 1 argument
+        function()                                          // Calls the static function
+
+    #define CallFunction2(class, function) \                // Overloaded macro for 2 arguments
+        class::function()                                   // Calls the static class function
+
+    #define CallFunction3(class, function, object) \        // Overloaded macro for 3 arguments
+        object->class::function()                           // Calls the function on the object
+
+
+    CallFunction(myFunction);                               // Call the macro with 1 argument
+    CallFunction(MyClass, myStaticFunction);                // Call the macro with 2 arguments
+    CallFunction(MyClass, myFunction, new MyClass());       // Call the macro with 3 arguments
+    @endcode
+
+    Note that the first (variadic) macro concatenates the name "CallFunction" with
+    the number of arguments ("1" - "N"). Then all arguments are passed to the right macro.
 */
 
Index: code/trunk/src/libraries/util/mbool.h
===================================================================
--- code/trunk/src/libraries/util/mbool.h	(revision 7305)
+++ code/trunk/src/libraries/util/mbool.h	(revision 7401)
@@ -27,4 +27,10 @@
  */
 
+/**
+    @file
+    @ingroup Util
+    @brief Declaration and implementation of the @ref orxonox::mbool class.
+*/
+
 #ifndef _mbool_H__
 #define _mbool_H__
@@ -34,38 +40,67 @@
 namespace orxonox
 {
+    /**
+        @brief mbool is a small helper class that acts like a bool, but keeps track of the number of its state changes.
+
+        The mbool class acts like a bool, but it has an internal counter that counts
+        the number state changes (i.e. when the bool changes from true to false or
+        back). This is used in the network if a boolean value is synchronized, because
+        if a value changes quickly from false to true and back in the same tick, the
+        clients will never be notified of this action. By using mbool however this
+        behaviour is fixed, which is important for triggers and other objects.
+
+        @note This is efficiently solved by using a union that combines a counter and a
+        boolean bitfield of size 1. The boolean value corresponds always to the first
+        bit of the counter - this means, if the counter is incremented, the boolean state
+        changes. On the other hand, if you want to change the state, you can simply increase
+        the counter.
+    */
     struct _UtilExport mbool
     {
         public:
+            /// Constructor: Creates the mbool and initializes the boolean value (default to false).
             inline mbool(bool value = false)
                 { this->value_.memory_ = 0; this->value_.bool_ = value; }
+            /// Copy-constructor, copies state and memory.
             inline mbool(const mbool& value)
                 { this->value_.memory_ = value.value_.memory_; }
 
+            /// Assigns a boolean value (and increases the memory value if the value is different to the old value).
             inline mbool& operator=(bool value)
                 { if (value != this->value_.bool_) { ++this->value_.memory_; } return (*this); }
+            /// Assigns another mbool, copies state and memory.
             inline mbool& operator=(const mbool& value)
                 { this->value_.memory_ = value.value_.memory_; return (*this); }
 
+            /// Increases the memory which also inverts it's state (++mbool).
             inline mbool& operator++()
                 { ++this->value_.memory_; return (*this); }
-            inline mbool operator++(int i)
+            /// Increases the memory which also inverts it's state (mbool++).
+            inline mbool operator++(int)
                 { mbool temp = (*this); ++this->value_.memory_; return temp; }
 
+            /// Implicitly converts the mbool to a bool.
             inline operator bool() const
                 { return this->value_.bool_; }
 
+            /// Compares the mbool to a bool, returns true if the bool has the same value as the state of the mbool.
             inline bool operator==(bool other) const
                 { return this->value_.bool_ == other; }
+            /// Compares the mbool to a bool, returns true if the bool has a different value than the state of the mbool.
             inline bool operator!=(bool other) const
                 { return this->value_.bool_ != other; }
 
+            /// Compares two mbools, returns true if their memory matches.
             inline bool operator==(const mbool& other) const
                 { return this->value_.memory_ == other.value_.memory_; }
+            /// Compares two mbools, returns true if they have a different memory value.
             inline bool operator!=(const mbool& other) const
                 { return this->value_.memory_ != other.value_.memory_; }
 
+            /// Returns the inverted state of the bool (doesn't change the internal state).
             inline bool operator!() const
                 { return (!this->value_.bool_); }
 
+            /// Returns the memory value.
             inline unsigned char& getMemory(){ return value_.memory_; }
 
@@ -73,7 +108,7 @@
             union
             {
-                bool bool_ : 1;
-                unsigned char memory_;
-            } value_;
+                bool bool_ : 1;         ///< The boolean state of the mbool, is located on the first bit of the memory variable
+                unsigned char memory_;  ///< The memory of the mbool, counts the state-changes (and the first bit represents also the boolean value)
+            } value_;                   ///< A union containing the state and the memory of the mbool
     };
 }
