Index: code/branches/doc/src/libraries/util/Clock.cc
===================================================================
--- code/branches/doc/src/libraries/util/Clock.cc	(revision 7366)
+++ code/branches/doc/src/libraries/util/Clock.cc	(revision 7367)
@@ -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. <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 Clock::capture()
     {
Index: code/branches/doc/src/libraries/util/Clock.h
===================================================================
--- code/branches/doc/src/libraries/util/Clock.h	(revision 7366)
+++ code/branches/doc/src/libraries/util/Clock.h	(revision 7367)
@@ -41,40 +41,49 @@
         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. 
-    @remarks
+    @par Remarks for Usage on Windows
         For proper functionality this class MUST be used in the same thread! <br>
-        Further more it might be possible that the Ogre::Timer has a performance
-        caveat on Windows 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 command line argument 'limitToCPU'.
+        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
+        /// Starts the time at 0
         Clock();
         ~Clock();
 
-        //! Internally captures the time and stays at that particular time
+        /** 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();
 
-        //! Returns the last captured absolute time in microseconds
+        /// Returns the last captured absolute time in microseconds
         unsigned long long getMicroseconds() const
             { return tickTime_; }
-        //! Returns the last captured absolute time in milliseconds
+        /// Returns the last captured absolute time in milliseconds
         unsigned long long getMilliseconds() const
             { return tickTime_ / 1000; }
-        //! Returns the last captured absolute time in seconds
+        /// 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
+        /// Returns the last captured absolute time in seconds as float
         float getSecondsPrecise() const
             { return static_cast<float>(tickTime_ / 1000000.0f); }
 
-        //! Returns the timespan in seconds between the last two calls to capture()
+        /// 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()
+        /// Returns the timespan in microseconds between the last two calls to capture()
         long getDeltaTimeMicroseconds() const
             { return tickDt_; }
@@ -88,11 +97,11 @@
 
     private:
-        //! Undefined
+        /// Undefined
         Clock(const Clock& instance);
 
-        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)
+        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/branches/doc/src/libraries/util/Exception.cc
===================================================================
--- code/branches/doc/src/libraries/util/Exception.cc	(revision 7366)
+++ code/branches/doc/src/libraries/util/Exception.cc	(revision 7367)
@@ -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/branches/doc/src/libraries/util/Exception.h
===================================================================
--- code/branches/doc/src/libraries/util/Exception.h	(revision 7366)
+++ code/branches/doc/src/libraries/util/Exception.h	(revision 7367)
@@ -31,4 +31,20 @@
 @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 +61,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
@@ -74,7 +89,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
@@ -107,5 +128,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                               \
@@ -129,5 +150,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);
@@ -142,9 +162,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.
@@ -158,11 +175,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/branches/doc/src/libraries/util/ExprParser.h
===================================================================
--- code/branches/doc/src/libraries/util/ExprParser.h	(revision 7366)
+++ code/branches/doc/src/libraries/util/ExprParser.h	(revision 7367)
@@ -28,6 +28,6 @@
 
 /**
-  @file
-  @brief Declaration of FloatParser
+@file
+@brief Declaration of FloatParser
 */
 
@@ -42,4 +42,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/branches/doc/src/libraries/util/MathConvert.h
===================================================================
--- code/branches/doc/src/libraries/util/MathConvert.h	(revision 7366)
+++ code/branches/doc/src/libraries/util/MathConvert.h	(revision 7367)
@@ -28,7 +28,7 @@
 
 /**
-    @file
-    @brief
-        Math conversion functions. Definitions are in Math.cc
+@file
+@brief
+    Conversion functions for Math types like Ogre::Vector3 (definitions are in Math.cc)
 */
 
@@ -46,5 +46,5 @@
     ////////////////////
 
-    // Vector2 to std::string
+    /// Ogre::Vector2 to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Vector2, std::string>
@@ -62,5 +62,5 @@
     };
 
-    // Vector3 to std::string
+    /// Ogre::Vector3 to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Vector3, std::string>
@@ -78,5 +78,5 @@
     };
 
-    // Vector4 to std::string
+    /// Ogre::Vector4 to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Vector4, std::string>
@@ -94,5 +94,5 @@
     };
 
-    // Quaternion to std::string
+    /// Ogre::Quaternion to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::Quaternion, std::string>
@@ -110,5 +110,5 @@
     };
 
-    // ColourValue to std::string
+    /// Ogre::ColourValue to std::string conversion
     template <>
     struct ConverterExplicit<orxonox::ColourValue, std::string>
@@ -131,17 +131,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 +152,5 @@
     ///////////////////////////////
 
-    // From Radian
+    /// Delegates conversions from Radian to conversions from float
     template <class ToType>
     struct ConverterFallback<orxonox::Radian, ToType>
@@ -162,5 +162,5 @@
     };
 
-    // From Degree
+    /// Delegates conversions from Degree to conversions from float
     template <class ToType>
     struct ConverterFallback<orxonox::Degree, ToType>
@@ -172,5 +172,5 @@
     };
 
-    // To Radian
+    /// Delegates conversions to Radian to conversions to float
     template <class FromType>
     struct ConverterFallback<FromType, orxonox::Radian>
@@ -189,5 +189,5 @@
     };
 
-    // To Degree
+    /// Delegates conversions to Degree to conversions to float
     template <class FromType>
     struct ConverterFallback<FromType, orxonox::Degree>
Index: code/branches/doc/src/libraries/util/OrxAssert.h
===================================================================
--- code/branches/doc/src/libraries/util/OrxAssert.h	(revision 7366)
+++ code/branches/doc/src/libraries/util/OrxAssert.h	(revision 7367)
@@ -41,6 +41,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/branches/doc/src/libraries/util/OrxEnum.h
===================================================================
--- code/branches/doc/src/libraries/util/OrxEnum.h	(revision 7366)
+++ code/branches/doc/src/libraries/util/OrxEnum.h	(revision 7367)
@@ -27,10 +27,4 @@
  */
 
-/**
-@file
-@brief
-    Declaration of the OrxEnum class.
-*/
-
 #ifndef _OrxEnum_H__
 #define _OrxEnum_H__
@@ -40,4 +34,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 +57,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 +71,5 @@
 }
 
+/// See orxonox::OrxEnum for more info
 #define OrxEnumConstructors(enumName)                        \
 enumName() { }                                               \
Index: code/branches/doc/src/libraries/util/TriBool.h
===================================================================
--- code/branches/doc/src/libraries/util/TriBool.h	(revision 7366)
+++ code/branches/doc/src/libraries/util/TriBool.h	(revision 7367)
@@ -35,4 +35,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
     {
