Index: code/branches/core3/src/orxonox/Orxonox.cc
===================================================================
--- code/branches/core3/src/orxonox/Orxonox.cc	(revision 1775)
+++ code/branches/core3/src/orxonox/Orxonox.cc	(revision 1777)
@@ -34,4 +34,5 @@
 // Precompiled Headers
 #include "OrxonoxStableHeaders.h"
+#include "util/MathConvert.h"
 #include "Orxonox.h"
 
@@ -77,4 +78,5 @@
 #include "Settings.h"
 
+
 #define TestConv(nr, Type1, var1, Type2, res) \
     Type1 var##nr##1##var1; \
@@ -98,4 +100,21 @@
 
 class FooBar { };
+
+inline bool explicitConversion(FooBar* output, std::string input)
+{
+    return true;
+}
+
+//inline bool explicitConversion(std::string* output, const orxonox::Vector3& input)
+//{
+//    std::ostringstream ostream;
+//    if (ostream << input.x << "," << input.y << "," << input.z)
+//    {
+//        (*output) = ostream.str();
+//        return true;
+//    }
+//    return false;
+//}
+
 
 
@@ -212,9 +231,9 @@
     Factory::createClassHierarchy();
 
-    Radian nmbr;
-    float res;
+    std::string nmbr;
+    char res('a');
     //const char* nmbr;
     //const char* str;
-    convertValue(&res, nmbr);
+    convertValue(&nmbr, res);
     //const unsigned int blah = 4;
     //convertValue(nmbr, blah);
@@ -226,6 +245,11 @@
     FooBar asdf;
     std::string asdf2;
+    std::ostringstream oss;
+    char blah(' ');
+    oss << blah;
     std::cout << asdf2;
     ConvertValue(&asdf2, asdf);
+    //if (conversionTests::OStreamOperator<FooBar>::exists)
+    //    int asdfasdfasdf = 7;
     //COUT(3) << asdf;
 
Index: code/branches/core3/src/orxonox/Orxonox.h
===================================================================
--- code/branches/core3/src/orxonox/Orxonox.h	(revision 1775)
+++ code/branches/core3/src/orxonox/Orxonox.h	(revision 1777)
@@ -35,9 +35,4 @@
 #ifndef _Orxonox_H__
 #define _Orxonox_H__
-inline bool explicitConversion(float* output, const double input)
-{
-    *output = 2*input;
-    return true;
-}
 
 #include "OrxonoxPrereqs.h"
Index: code/branches/core3/src/util/ArgReader.cc
===================================================================
--- code/branches/core3/src/util/ArgReader.cc	(revision 1775)
+++ code/branches/core3/src/util/ArgReader.cc	(revision 1777)
@@ -84,7 +84,8 @@
   //std::cout << errorString_;
 
-  int a = conversionTests::ImplicitConversion<FooBar, const char*>::exists;
-  int val1;
-  long long val2 = conversion_cast<long long>(val1);
+  //const int a = conversionTests::ExplicitConversion<FooBar, const char*>::exists;
+  //BOOST_STATIC_ASSERT(a == 0);
+  //int val1;
+  //long long val2 = 4LL;//conversion_cast<long long>(val1);
   //val2 = val1;
   //convertValue(&val2, val1);
@@ -97,5 +98,5 @@
   //explicitConversion(&val1, val2);
 
-  std::istringstream asdf;
+  //std::istringstream asdf;
   //asdf >> val2;
 
Index: code/branches/core3/src/util/Convert.h
===================================================================
--- code/branches/core3/src/util/Convert.h	(revision 1775)
+++ code/branches/core3/src/util/Convert.h	(revision 1777)
@@ -23,4 +23,5 @@
  *      Benjamin Grauer
  *      Fabian 'x3n' Landau
+ *      Reto Grieder (direct conversion tests)
  *   Co-authors:
  *      ...
@@ -28,10 +29,10 @@
 
 /*!
-    @file Convert.h
+    @file
     @brief Definition and Implementation of the Convert class.
 */
 
-#ifndef _Convert_H__
-#define _Convert_H__
+#ifndef _Converter_H__
+#define _Converter_H__
 
 #include "UtilPrereqs.h"
@@ -39,6 +40,7 @@
 #include <string>
 #include <sstream>
-
-#include "Math.h"
+#include <istream>
+#include <ostream>
+
 #include "Debug.h"
 
@@ -46,5 +48,5 @@
 // This is however exactly what convertValue does, so we need to suppress the warnings.
 // They only occur in when using the ImplicitConversion template.
-#if ORXONOX_COMPILER == ORXONOX_COMPILER_GCC
+#if ORXONOX_COMPILER == ORXONOX_COMPILER_GNUC
 #  pragma GCC system_header
 #endif
@@ -53,5 +55,4 @@
 // Static detection for conversion functions //
 ///////////////////////////////////////////////
-
 /* The idea to use the sizeof() operator on return functions to determine function existance
    is described in 'Moder C++ design' by Alexandrescu (2001). */
@@ -71,39 +72,25 @@
 }
 
-namespace separate_namespace
+namespace conversion_another_namespace
 {
     // We want to keep the templates for the convert functions out of global namespace so that there
     // are no ambiguities. These templates are never used anyway, they only serve to detect whether
     // there is a global funciton for a specific conversion or not.
-    // Now why not putting this in namespace 'conversionTests'?
-    // I can not tell for sure, but I think there is a bug in msvc 8. It chooses this general template
-    // (if it was in 'conversionTests') over a better fitting function in global namespace.
-    // The solution is to use another namespace and then apply the 'using' directive in 'conversionTests'.
-    // Unfortunately there is a (somewhat documented) bug in msvc 8 that exposes namespace members
-    // globally when applying the 'using' directive in a namespace. And it so happens that the bug is
-    // triggered in this file. This unwanted global exposure hopefully doesn't cause ambiguities.
-    template <class AnyToType, class AnyFromType>
-    conversionTests::VeryBigStruct explicitConversion(AnyToType* output, const AnyFromType input)
-    {
-        // We have to make sure noboy uses it , so a good compiler error would be nice.
-        *output = (AnyToType)input; // Do not use this function!
-        // gcc does some syntax checking anyway. So return a correct value that is not a temporary.
-	    return *(new conversionTests::VeryBigStruct());
-    }
-
-    // These operators simply accept anything but have lower priority than specialisations
-    // or exact-match non-template functions.
-    // They can be identified by the larger return value.
-    // We put these in a seperate namespace to avoid conflicts with ambiguities.
-    template <class Any>
-    conversionTests::VeryBigStruct operator<<(std::ostream& outstream, const Any anything);
-    template <class Any>
-    conversionTests::VeryBigStruct operator>>(std::istream& instream,  const Any anything);
+    // Why the seperate namespace? --> see 'using' statement at the end of conversionTests::
+    //template <class AnyToType, class AnyFromType>
+    //conversionTests::VeryBigStruct explicitConversion(AnyToType* output, const AnyFromType input);
+    //template <class Any, int Dummy>
+    //conversionTests::VeryBigStruct operator<<(std::ostream& outstream, const Any& anything);
+    //template <class Any, int Dummy>
+    //conversionTests::VeryBigStruct operator>>(std::istream& instream,  const Any& anything);
 }
 
 namespace conversionTests
 {
-    // Part of the msvc hack. See above in the namespace for more explanations.
-    using namespace separate_namespace;
+// disable warnings about possible loss of data
+#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
+#  pragma warning(push)
+#  pragma warning(disable:4244)
+#endif
 
     template <class FromType, class ToType>
@@ -120,82 +107,50 @@
         static FromType object; // helper object to handle private c'tor and d'tor
     public:
-        // test(object) has only 'VerySmallStruct' return type iff the compiler doesn't choose test(...)
+        // test(object) only has 'VerySmallStruct' return type iff the compiler doesn't choose test(...)
         enum { exists = !(sizeof(test(object)) == sizeof(VeryBigStruct)) };
     };
 
-    template <class FromType, class ToType>
-    class ExplicitConversion
-    {
-    private:
-        ExplicitConversion(); ExplicitConversion(const ExplicitConversion&); ~ExplicitConversion();
-        static FromType objectFromType; // helper object to handle private c'tor and d'tor
-        static ToType   objectToType;   // helper object to handle private c'tor and d'tor
-    public:
-        enum { exists = !(sizeof(explicitConversion(&objectToType, objectFromType)) == sizeof(VeryBigStruct)) };
-    };
-
-    template <class Type>
-    class IStringStreamOperator
-    {
-        IStringStreamOperator(); IStringStreamOperator(const IStringStreamOperator&); ~IStringStreamOperator();
-        static std::istream istream_; // helper object to perform the '>>' operation
-        static Type object;                 // helper object to handle private c'tor and d'tor
-    public:
-        enum { exists = !(sizeof(istream_ >> object) == sizeof(VeryBigStruct)) };
-    };
-
-    template <class Type>
-    class OStringStreamOperator
-    {
-        OStringStreamOperator(); OStringStreamOperator(const OStringStreamOperator&); ~OStringStreamOperator();
-        static std::ostream ostream_; // helper object to perform the '<<' operation
-        static Type object;                 // helper object to handle private c'tor and d'tor
-    public:
-        enum { exists = !(sizeof(ostream_ << object) == sizeof(VeryBigStruct)) };
-    };
-}
-
-/* Shortcuts because we usually don't have a namespace in util/ but need one here for the conversion tests*/
-
-/**
-@brief
-    Checks for an implicit conversion FromType --> TyType.
-    This also works for user defined conversion operators.
-    Usage: ImplicitConversion<FromType, ToType>::exists
-*/
-//template <class FromType, class ToType>
-//struct ImplicitConversion
-//{ enum { exists = conversionTests::asdf::ImplicitConversion<FromType, ToType>::exists }; };
-
-/**
-@brief
-    Checks for an explicit conversion FromType --> TyType via 'explicConversion()' function.
-    There has to e an exact type match for a success!
-    Usage: ExplicitConversion<FromType, ToType>::exists
-*/
-//template <class FromType, class ToType>
-//struct ExplicitConversion
-//{ enum { exists = conversionTests::asdf::ExplicitConversion<FromType, ToType>::exists }; };
-
-/**
-@brief
-    Checks for an explicit conversion std::string --> TyType via >> operator.
-    There has to e an exact type match for a success!
-    Usage: IStringStreamConversion<FromType, ToType>::exists
-*/
-//template <class Type>
-//struct IStringStreamOperator
-//{ enum { exists = conversionTests::asdf::IStringStreamOperator<Type>::exists }; };
-
-/**
-@brief
-    Checks for an explicit conversion std::string --> TyType via << operator.
-    There has to e an exact type match for a success!
-    Usage: OStringStreamConversion<FromType, ToType>::exists
-*/
-//template <class Type>
-//struct OStringStreamOperator
-//{ enum { exists = conversionTests::asdf::OStringStreamOperator<Type>::exists }; };
-
+#if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
+#  pragma warning(pop)
+#endif
+
+    //template <class FromType, class ToType>
+    //class ExplicitConversion
+    //{
+    //private:
+    //    ExplicitConversion(); ExplicitConversion(const ExplicitConversion&); ~ExplicitConversion();
+    //    static FromType objectFromType; // helper object to handle private c'tor and d'tor
+    //    static ToType   objectToType;   // helper object to handle private c'tor and d'tor
+    //public:
+    //    enum { exists = !(sizeof(explicitConversion(&objectToType, objectFromType)) == sizeof(VeryBigStruct)) };
+    //};
+
+    //template <class Type>
+    //class IStreamOperator
+    //{
+    //    IStreamOperator(); IStreamOperator(const IStreamOperator&); ~IStreamOperator();
+    //    static std::istream istream_; // helper object to perform the '>>' operation
+    //    static Type object;           // helper object to handle private c'tor and d'tor
+    //public:
+    //    enum { exists = !(sizeof(istream_ >> object) == sizeof(VeryBigStruct)) };
+    //};
+
+    //template <class Type>
+    //class OStreamOperator
+    //{
+    //    OStreamOperator(); OStreamOperator(const OStreamOperator&); ~OStreamOperator();
+    //    static std::ostream ostream_; // helper object to perform the '<<' operation
+    //    static Type object;           // helper object to handle private c'tor and d'tor
+    //public:
+    //    enum { exists = !(sizeof(ostream_ << object) == sizeof(VeryBigStruct)) };
+    //};
+
+    // Somehow msvc and gcc don't like it when using function arguments that have a type
+    // in a third namespace. The global namespace functions then get overridden by the
+    // templates above. So we simply put the generic ones in a another namespace.
+    // Note: DON'T place this statement before a class template. That would trigger
+    //       a heavy bug (namespace leakage) in msvc 2005.
+    //using namespace conversion_another_namespace;
+}
 
 
@@ -226,23 +181,20 @@
 */
 
-// Put everything in a namespace to avoid unnecessary exposure
-// Note that the textual order of the functions is in reverse.
+namespace
+{
+    // little template that maps to ints to entire types (Alexandrescu 2001)
+    template <int I>
+    struct Int2Type { };
+}
+
+
+///////////////////
+// No Conversion //
+///////////////////
+
 namespace conversion
 {
-    // Maps bools to types in order to use function overloading instead of template specialisation (Alexandrescu 2001)
-    template <bool WhetherOrNot>
-    struct ImplicitPossible { };
-    template <bool WhetherOrNot>
-    struct ExplicitPossible { };
-    template <bool WhetherOrNot>
-    struct StringStreamPossible { };
-
-
-    ///////////////////
-    // No Conversion //
-    ///////////////////
-
-    // Default template, no Conversion possible
-    template <class ToType, class FromType, int Dummy>
+    // Default template for stringtream, no Conversion possible
+    template <class ToType, class FromType>
     struct ConverterSS
     {
@@ -254,137 +206,129 @@
         }
     };
-
-
-    ///////////////////
-    // OStringStream //
-    ///////////////////
-
-    // Conversion via ostringstream
+}
+
+
+/////////////
+// OStream //
+/////////////
+
+namespace fallbackTemplates
+{
+    template <class Any>
+    bool operator <<(std::ostream& outstream,  const Any& anything)
+    {
+        COUT(2) << "Could not convert value of type " << typeid(Any).name()
+                << " to std::string" << std::endl;
+        return false;
+    }
+}
+
+namespace conversion
+{
+    //using namespace fallbackTemplates;
+    // template that evaluates whether OStringStream is possible for conversions to std::string
     template <class FromType>
-    inline bool convertOStringStream(std::string* output, const FromType& input)
-    {
-        std::ostringstream oss;
-        if (oss << input)
-        {
-            (*output) = oss.str();
-            return true;
-        }
-        else
-            return false;
-    }
-
-    // template that evaluates whether OStringStream is possible for conversions to std::string
-    template <class FromType, int Dummy>
-    struct ConverterSS<std::string, FromType, Dummy>
-    {
-        // probe for '<<' stringstream operator
+    struct ConverterSS<std::string, FromType>
+    {
+        // probe for '<<' ostream operator
         static bool convert(std::string* output, const FromType& input)
         {
-            const bool probe = conversionTests::OStringStreamOperator<FromType>::exists;
-            return convert(output, input, StringStreamPossible<probe>());
-        }
-        // Conversion with ostringstream possible
-        static bool convert(std::string* output, const FromType& input, StringStreamPossible<true>)
-        {
-            return convertOStringStream(output, input);
-        }
-        // Conversion with ostringstream not possible
-        static bool convert(std::string* output, const FromType& input, StringStreamPossible<false>)
-        {
-            COUT(2) << "Could not convert value of type " << typeid(FromType).name()
-                    << " to std::string" << std::endl;
-            return false;
+            std::ostringstream oss;
+            if (oss << input)
+            {
+                (*output) = oss.str();
+                return true;
+            }
+            else
+                return false;
         }
     };
 
-
-    ///////////////////
-    // IStringStream //
-    ///////////////////
-
-    // conversion from std::string via istringstream
+}
+
+
+/////////////
+// IStream //
+/////////////
+
+namespace fallbackTemplates
+{
+    template <class Any>
+    bool operator >>(std::istream& instream,  const Any& anything)
+    {
+        COUT(2) << "Could not convert std::string value to type " << typeid(ToType).name() << std::endl;
+        return false;
+    }
+}
+
+namespace conversion
+{
+    // template that evaluates whether IStringStream is possible for conversions from std::string
     template <class ToType>
-    inline bool convertIStringStream(ToType* output, const std::string& input)
-    {
-        std::istringstream iss(input);
-        if (iss >> (*output))
-        {
-            return true;
-        }
-        else
-            return false;
-    }
-
-    // template that evaluates whether IStringStream is possible for conversions from std::string
-    template <class ToType, int Dummy>
-    struct ConverterSS<ToType, std::string, Dummy>
-    {
-        // probe for '>>' stringstream operator
+    struct ConverterSS<ToType, std::string>
+    {
         static bool convert(ToType* output, const std::string& input)
         {
-            const bool probe = conversionTests::IStringStreamOperator<ToType>::exists;
-            return convert(output, input, StringStreamPossible<probe>());
-        }
-        // Conversion with istringstream possible
-        static bool convert(ToType* output, const std::string& input, StringStreamPossible<true>)
-        {
-            return convertIStringStream(output, input);
-        }
-        // Conversion with istringstream not possible
-        static bool convert(ToType* output, const std::string& input, StringStreamPossible<false>)
-        {
-            COUT(2) << "Could not convert std::string value to type " << typeid(ToType).name() << std::endl;
-            return false;
+            std::istringstream iss(input);
+            if (iss >> (*output))
+            {
+                return true;
+            }
+            else
+                return false;
         }
     };
 
-
-    ///////////////////
-    // Implicit Cast //
-    ///////////////////
-
-    // We can cast implicitely
+    using namespace fallbackTemplates;
+}
+
+
+///////////////////
+// Implicit Cast //
+///////////////////
+
+// We can cast implicitely
+template <class ToType, class FromType>
+inline bool convertImplicitely(ToType* output, const FromType& input, ::Int2Type<true>)
+{
+    (*output) = static_cast<ToType>(input);
+    return true;
+}
+// static cast no possible, try stringstream conversion next
+template <class ToType, class FromType>
+inline bool convertImplicitely(ToType* output, const FromType& input, ::Int2Type<false>)
+{
+    return conversion::ConverterSS<ToType, FromType>::convert(output, input);
+}
+
+
+/////////////////////////
+// Explicit conversion //
+/////////////////////////
+
+namespace fallbackTemplates
+{
+    // We want to keep the templates for the convert functions out of global namespace so that there
+    // are no ambiguities. These templates are never used anyway, they only serve to detect whether
+    // there is a global funciton for a specific conversion or not.
+    // Note: Don't put these functions in a separate namespace and add a 'using' directive here.
+    // For MS sake, just don't!
     template <class ToType, class FromType>
-    inline bool convert(ToType* output, const FromType& input, ImplicitPossible<true>)
-    {
-        (*output) = static_cast<ToType>(input);
-        return true;
+    bool explicitConversion(ToType* output, const FromType input)
+    {
+        // try implict conversion by probing first because we use '...' instead of a template
+        const bool probe = conversionTests::ImplicitConversion<FromType, ToType>::exists;
+        //using namespace conversion;
+        return convertImplicitely(output, input, ::Int2Type<probe>());
     }
-
-    // No implicit cast, leave it up to << and >> via template spcialisation
-    template <class ToType, class FromType>
-    inline bool convert(ToType* output, const FromType& input, ImplicitPossible<false>)
-    {
-        return ConverterSS<ToType, FromType, 0>::convert(output, input);
-    }
-
-
-    /////////////////////////
-    // Explicit Conversion //
-    /////////////////////////
-
-    // We can convert explicitely via function overloading
-    template <class ToType, class FromType>
-    inline bool convert(ToType* output, const FromType& input, ExplicitPossible<true>)
-    {
-        // This function can by anywhere globally!
-        return explicitConversion(output, input);
-    }
-
-    // No explict conversion via explicitConversion(), try implicit cast
-    template <class ToType, class FromType>
-    inline bool convert(ToType* output, const FromType& input, ExplicitPossible<false>)
-    {
-        const bool probe = conversionTests::ImplicitConversion<FromType, ToType>::exists;
-        return convert(output, input, ImplicitPossible<probe>());
-    }
-}
-
-// We usually don't have a namespace in util/ but it would still be desirable to lock
-// everything internal away in namespace conversion.
-// However this template can be specialised everywhere.
-
-// Template that is used when no explicit template specialisation is available
-// try explicitConversion() function next.
+}
+
+
+/////////////////////
+// Local Overwrite //
+/////////////////////
+
+// Template that is used when no explicit template specialisation is available.
+// Try explicitConversion() function next.
 template <class ToType, class FromType>
 struct ConverterExplicit
@@ -392,7 +336,6 @@
     static bool convert(ToType* output, const FromType& input)
     {
-        // check for explicit conversion via function overloading
-        const bool probe = conversionTests::ExplicitConversion<FromType, ToType>::exists;
-        return conversion::convert(output, input, conversion::ExplicitPossible<probe>());
+        using namespace fallbackTemplates;
+        return explicitConversion(output, input);
     }
 };
@@ -474,57 +417,42 @@
 
 
-///////////////////////////////////////
-// Explicit Template Specialisations //
-///////////////////////////////////////
+////////////////////////////////
+// Special string conversions //
+////////////////////////////////
 
 // delegate conversion from const char* to std::string
 template <class ToType>
-struct ConverterExplicit<ToType, const char*>
-{
-    static bool convert(ToType* output, const char* input)
-    {
-        return ConverterExplicit<ToType, std::string>::convert(output, input);
-    }
-};
+inline bool explicitConversion(ToType* output, const char* input)
+{
+    return ConverterExplicit<ToType, std::string>::convert(output, input);
+}
 
 // These conversions would exhibit ambiguous << or >> operators when using stringstream
-template <> struct ConverterExplicit<std::string, char>
-{
-    static bool convert(std::string* output, const char input)
-    {
-        *output = std::string(1, input);
-        return true;
-    }
-};
-template <> struct ConverterExplicit<std::string, unsigned char>
-{
-    static bool convert(std::string* output, const unsigned char input)
-    {
-        *output = std::string(1, input);
-        return true;
-    }
-};
-template <> struct ConverterExplicit<char, std::string>
-{
-    static bool convert(char* output, const std::string input)
-    {
-        if (input != "")
-            *output = input[0];
-        else
-            *output = '\0';
-        return true;
-    }
-};
-template <> struct ConverterExplicit<unsigned char, std::string>
-{
-    static bool convert(unsigned char* output, const std::string input)
-    {
-        if (input != "")
-            *output = input[0];
-        else
-            *output = '\0';
-        return true;
-    }
-};
+inline bool explicitConversion(std::string* output, const char input)
+{
+    *output = std::string(1, input);
+    return true;
+}
+inline bool explicitConversion(std::string* output, const unsigned char input)
+{
+    *output = std::string(1, input);
+    return true;
+}
+inline bool explicitConversion(char* output, const std::string input)
+{
+    if (input != "")
+        *output = input[0];
+    else
+        *output = '\0';
+    return true;
+}
+inline bool explicitConversion(unsigned char* output, const std::string input)
+{
+    if (input != "")
+        *output = input[0];
+    else
+        *output = '\0';
+    return true;
+}
 
 #endif /* _Convert_H__ */
Index: code/branches/core3/src/util/Math.cc
===================================================================
--- code/branches/core3/src/util/Math.cc	(revision 1775)
+++ code/branches/core3/src/util/Math.cc	(revision 1777)
@@ -30,5 +30,5 @@
 
 #include <OgrePlane.h>
-#include "Convert.h"
+#include "MathConvert.h"
 
 /**
Index: code/branches/core3/src/util/Math.h
===================================================================
--- code/branches/core3/src/util/Math.h	(revision 1775)
+++ code/branches/core3/src/util/Math.h	(revision 1777)
@@ -64,91 +64,4 @@
 _UtilExport orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
 _UtilExport orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity);
-
-/////////////////////////////////////
-// Conversion Functions of our own //
-/////////////////////////////////////
-
-// Vector2 to std::string
-//inline bool explicitConversion(std::string* output, const orxonox::Vector2& input)
-//{
-//    std::ostringstream ostream;
-//    if (ostream << input.x << "," << input.y)
-//    {
-//        (*output) = ostream.str();
-//        return true;
-//    }
-//    return false;
-//}
-
-// Vector3 to std::string
-inline bool explicitConversion(std::string* output, const orxonox::Vector3& input)
-{
-    std::ostringstream ostream;
-    if (ostream << input.x << "," << input.y << "," << input.z)
-    {
-        (*output) = ostream.str();
-        return true;
-    }
-    return false;
-}
-
-// Vector4 to std::string
-inline bool explicitConversion(std::string* output, const orxonox::Vector4& input)
-{
-    std::ostringstream ostream;
-    if (ostream << input.x << "," << input.y << "," << input.z << "," << input.w)
-    {
-        (*output) = ostream.str();
-        return true;
-    }
-    return false;
-}
-
-// Quaternion to std::string
-inline bool explicitConversion(std::string* output, const orxonox::Quaternion& input)
-{
-    std::ostringstream ostream;
-    if (ostream << input.w << "," << input.x << "," << input.y << "," << input.z)
-    {
-        (*output) = ostream.str();
-        return true;
-    }
-    return false;
-}
-
-// ColourValue to std::string
-inline bool explicitConversion(std::string* output, const orxonox::ColourValue& input)
-{
-    std::ostringstream ostream;
-    if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
-    {
-        (*output) = ostream.str();
-        return true;
-    }
-    return false;
-}
-
-//// ColourValue to std::string
-//inline bool explicitConversion(std::string* output, const orxonox::ColourValue& input)
-//{
-//    std::ostringstream ostream;
-//    if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
-//    {
-//        (*output) = ostream.str();
-//        return true;
-//    }
-//    return false;
-//}
-
-// std::string to Vector2
-_UtilExport bool explicitConversion(orxonox::Vector2* output, const std::string& input);
-// std::string to Vector3
-_UtilExport bool explicitConversion(orxonox::Vector3* output, const std::string& input);
-// std::string to Vector4
-_UtilExport bool explicitConversion(orxonox::Vector4* output, const std::string& input);
-// std::string to Quaternion
-_UtilExport bool explicitConversion(orxonox::Quaternion* output, const std::string& input);
-// std::string to ColourValue
-_UtilExport bool explicitConversion(orxonox::ColourValue* output, const std::string& input);
 
 template <typename T>
Index: code/branches/core3/src/util/MathConvert.h
===================================================================
--- code/branches/core3/src/util/MathConvert.h	(revision 1777)
+++ code/branches/core3/src/util/MathConvert.h	(revision 1777)
@@ -0,0 +1,245 @@
+/*
+ *   ORXONOX - the hottest 3D action shooter ever to exist
+ *                    > www.orxonox.net <
+ *
+ *
+ *   License notice:
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation; either version 2
+ *   of the License, or (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ *
+ *   Author:
+ *      Fabian 'x3n' Landau
+ *      Reto Grieder
+ *   Co-authors:
+ *      ...
+ */
+
+/*!
+    @file
+    @brief Actual conversion functions.
+*/
+
+#ifndef _MathConvert_H__
+#define _MathConvert_H__
+
+#include "UtilPrereqs.h"
+#include "Convert.h"
+#include "Math.h"
+
+// Note: explicitConversion function is used whenever possible prior to
+//       template specialisations to allow for manual calls and overwrites.
+
+
+////////////////////
+// Math to string //
+////////////////////
+
+// Vector2 to std::string
+inline bool explicitConversion(std::string* output, const orxonox::Vector2& input)
+{
+    std::ostringstream ostream;
+    if (ostream << input.x << "," << input.y)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+
+// Vector3 to std::string
+inline bool explicitConversion(std::string* output, const orxonox::Vector3& input)
+{
+    std::ostringstream ostream;
+    if (ostream << input.x << "," << input.y << "," << input.z)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+
+// Vector4 to std::string
+inline bool explicitConversion(std::string* output, const orxonox::Vector4& input)
+{
+    std::ostringstream ostream;
+    if (ostream << input.x << "," << input.y << "," << input.z << "," << input.w)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+
+// Quaternion to std::string
+inline bool explicitConversion(std::string* output, const orxonox::Quaternion& input)
+{
+    std::ostringstream ostream;
+    if (ostream << input.w << "," << input.x << "," << input.y << "," << input.z)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+
+// ColourValue to std::string
+inline bool explicitConversion(std::string* output, const orxonox::ColourValue& input)
+{
+    std::ostringstream ostream;
+    if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+
+
+////////////////////
+// string to Math //
+////////////////////
+
+// std::string to Vector2
+_UtilExport bool explicitConversion(orxonox::Vector2* output, const std::string& input);
+// std::string to Vector3
+_UtilExport bool explicitConversion(orxonox::Vector3* output, const std::string& input);
+// std::string to Vector4
+_UtilExport bool explicitConversion(orxonox::Vector4* output, const std::string& input);
+// std::string to Quaternion
+_UtilExport bool explicitConversion(orxonox::Quaternion* output, const std::string& input);
+// std::string to ColourValue
+_UtilExport bool explicitConversion(orxonox::ColourValue* output, const std::string& input);
+
+
+///////////////////////////////
+// From and to Radian/Degree //
+///////////////////////////////
+
+// From Radian
+template <class ToType>
+inline bool explicitConversion(ToType* output, const orxonox::Radian input)
+{
+    return convertValue<ToType, Ogre::Real>(output, input.valueRadians()); 
+}
+
+// From Degree
+template <class ToType>
+inline bool explicitConversion(ToType* output, const orxonox::Degree input)
+{
+    return convertValue<ToType, Ogre::Real>(output, input.valueDegrees()); 
+}
+
+// To Radian
+template <class FromType>
+inline bool explicitConversion(orxonox::Radian* output, const FromType input)
+{
+    float temp;
+    if (convertValue(&temp, input))
+    {
+        *output = temp;
+        return true;
+    }
+    else
+        return false;
+}
+
+// To Degree
+template <class FromType>
+inline bool explicitConversion(orxonox::Degree* output, const FromType input)
+{
+    float temp;
+    if (convertValue(&temp, input))
+    {
+        *output = temp;
+        return true;
+    }
+    else
+        return false;
+}
+// Radian to Radian
+inline bool explicitConversion(orxonox::Radian* output, const orxonox::Radian input)
+{ *output = input; return true; }
+// Degree to Degree
+inline bool explicitConversion(orxonox::Degree* output, const orxonox::Degree input)
+{ *output = input; return true; }
+// Radian to Degree
+inline bool explicitConversion(orxonox::Degree* output, const orxonox::Radian input)
+{ *output = input; return true; }
+// Degree to Radian
+inline bool explicitConversion(orxonox::Radian* output, const orxonox::Degree input)
+{ *output = input; return true; }
+
+//template <class ToType>
+//struct ConverterExplicit<ToType, Ogre::Radian>
+//{
+//    static bool convert(ToType* output, const Ogre::Radian input)
+//    {
+//        return ConverterExplicit<ToType, Ogre::Real>::convert(output, input.valueRadians());
+//    }
+//};
+
+//// Conversion from Ogre::Radian
+//template <class ToType>
+//struct ConverterExplicit<ToType, const Ogre::Radian>
+//{
+//    static bool convert(ToType* output, const Ogre::Radian input)
+//    {
+//        return ConverterExplicit<ToType, Ogre::Real>::convert(output, input.getValueRadian());
+//    }
+//};
+
+//template <class ToType>
+//inline bool explicitConversion(ToType* output, const Ogre::Radian& input)
+//{
+//    return ConvertValue(output, ;
+//}
+
+//// Conversion from Ogre::Degrees
+//inline bool explicitConversion(std::string* output, const orxonox::ColourValue& input)
+//{
+//    std::ostringstream ostream;
+//    if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
+//    {
+//        (*output) = ostream.str();
+//        return true;
+//    }
+//    return false;
+//}
+//
+//// Conversion to Ogre::Radian
+//inline bool explicitConversion(std::string* output, const orxonox::ColourValue& input)
+//{
+//    std::ostringstream ostream;
+//    if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
+//    {
+//        (*output) = ostream.str();
+//        return true;
+//    }
+//    return false;
+//}
+//
+//// Conversion to Ogre::Degrees
+//inline bool explicitConversion(std::string* output, const orxonox::ColourValue& input)
+//{
+//    std::ostringstream ostream;
+//    if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
+//    {
+//        (*output) = ostream.str();
+//        return true;
+//    }
+//    return false;
+//}
+
+#endif /* _MathConvert_H__ */
Index: code/branches/core3/src/util/MultiTypeValue.h
===================================================================
--- code/branches/core3/src/util/MultiTypeValue.h	(revision 1775)
+++ code/branches/core3/src/util/MultiTypeValue.h	(revision 1777)
@@ -31,5 +31,5 @@
 
 #include "UtilPrereqs.h"
-#include "Convert.h"
+#include "MathConvert.h"
 #include "MultiType.h"
 
Index: code/branches/core3/visual_studio/vc8/util.vcproj
===================================================================
--- code/branches/core3/visual_studio/vc8/util.vcproj	(revision 1775)
+++ code/branches/core3/visual_studio/vc8/util.vcproj	(revision 1777)
@@ -223,4 +223,8 @@
 			</File>
 			<File
+				RelativePath="..\..\src\util\MathConvert.h"
+				>
+			</File>
+			<File
 				RelativePath="..\..\src\util\MultiType.h"
 				>
