Index: code/branches/core3/src/orxonox/Orxonox.cc
===================================================================
--- code/branches/core3/src/orxonox/Orxonox.cc	(revision 1777)
+++ code/branches/core3/src/orxonox/Orxonox.cc	(revision 1778)
@@ -86,16 +86,16 @@
     assert(res == var##nr##2)
 
-template <>
-struct ConverterExplicit<orxonox::Radian, const char*>
-{
-    static bool convert(orxonox::Radian* output, const char* input)
-    {
-        //std::string asdf("asfd");
-        //std::cout << asdf;
-        float temp;
-        convertValue(&temp, input);
-        *output = temp;
-    }
-};
+//template <>
+//struct ConverterExplicit<orxonox::Radian, const char*>
+//{
+//    static bool convert(orxonox::Radian* output, const char* input)
+//    {
+//        //std::string asdf("asfd");
+//        //std::cout << asdf;
+//        float temp;
+//        convertValue(&temp, input);
+//        *output = temp;
+//    }
+//};
 
 class FooBar { };
Index: code/branches/core3/src/util/ArgReader.cc
===================================================================
--- code/branches/core3/src/util/ArgReader.cc	(revision 1777)
+++ code/branches/core3/src/util/ArgReader.cc	(revision 1778)
@@ -65,12 +65,12 @@
 #include "Convert.h"
 
-template<>
-struct ConverterExplicit<const char*, FooBar>
-{
-    static bool convert(const char** output, const FooBar input)
-    {
-        return true;
-    }
-};
+//template<>
+//struct ConverterExplicit<const char*, FooBar>
+//{
+//    static bool convert(const char** output, const FooBar input)
+//    {
+//        return true;
+//    }
+//};
 
 #include "MultiType.h"
@@ -90,5 +90,5 @@
   //val2 = val1;
   //convertValue(&val2, val1);
-  //explicitConversion(&FooBar(), val1);
+  //convertValue(&FooBar(), val1);
 
   //using namespace1::fooBar1;
@@ -96,5 +96,5 @@
   //int val1;
   //char val2;
-  //explicitConversion(&val1, val2);
+  //convertValue(&val1, val2);
 
   //std::istringstream asdf;
Index: code/branches/core3/src/util/Convert.h
===================================================================
--- code/branches/core3/src/util/Convert.h	(revision 1777)
+++ code/branches/core3/src/util/Convert.h	(revision 1778)
@@ -58,34 +58,4 @@
    is described in 'Moder C++ design' by Alexandrescu (2001). */
 
-namespace conversionTests
-{
-    // A struct that is guaranteed to be larger than any return type of our conversion functions.
-    // So we simply add all the sizes of the return types plus a little bit more.
-    struct VeryBigStruct
-    {
-        char intSize[sizeof(int)];
-        char issSize[sizeof(std::istringstream)];
-        char ossSize[sizeof(std::ostringstream)];
-        char boolSize[sizeof(bool)];
-        char addingMore[4096]; // just to be sure ;)
-    };
-}
-
-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.
-    // 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
-{
 // disable warnings about possible loss of data
 #if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
@@ -93,4 +63,14 @@
 #  pragma warning(disable:4244)
 #endif
+
+namespace conversionTests
+{
+    // A struct that is guaranteed to be larger than any return type of our conversion functions.
+    // So we simply add all the sizes of the return types plus a little bit more.
+    struct VeryBigStruct
+    {
+        char intSize[sizeof(int)];
+        char addingMore[4096]; // just to be sure ;)
+    };
 
     template <class FromType, class ToType>
@@ -110,47 +90,9 @@
         enum { exists = !(sizeof(test(object)) == sizeof(VeryBigStruct)) };
     };
+}
 
 #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;
-}
 
 
@@ -162,5 +104,5 @@
     Overwrites:
     1. (Partial) template specialisation of ConverterExplicit::convert
-    2. Global functions explicitConversion(ToType* output, const FromType input)
+    2. Global functions convertValue(ToType* output, const FromType input)
     Fallbacks:
     3. Any possible implicit conversion. This includes FooBar --> int if FooBar defines operator float().
@@ -171,5 +113,5 @@
 
     There are obviously a lot of ways to specifiy a user defined conversion. What should I use?
-    When using any non-template function based conversion (implicit conversion, explicitConversion, << or >>)
+    When using any non-template function based conversion (implicit conversion, convertValue, << or >>)
     then you should consider that this function has to be defined prior to including this file.
     If you do not whish do do that, you will have to spcecialsize the ConverterExplicit template.
@@ -193,18 +135,38 @@
 ///////////////////
 
-namespace conversion
-{
-    // Default template for stringtream, no Conversion possible
-    template <class ToType, class FromType>
-    struct ConverterSS
-    {
-        static bool convert(ToType* output, FromType input)
-        {
-            COUT(2) << "Could not convert value of type " << typeid(FromType).name()
-                    << " to type " << typeid(ToType).name() << std::endl;
-            return false;
-        }
-    };
-}
+// Default template for fallbackConvert, no conversion possible
+template <class ToType, class FromType>
+inline bool fallbackConversion(ToType* output, FromType input)
+{
+    COUT(2) << "Could not convert value of type " << typeid(FromType).name()
+            << " to type " << typeid(ToType).name() << std::endl;
+    return false;
+}
+
+
+/////////////////////
+// fallbackConvert //
+/////////////////////
+
+// Class template used when << or >> was not available with string conversions
+// It is required to call not yet declared fallbackConvert functions.
+template <class ToType, class FromType>
+struct ConverterFallbackTemplate
+{
+    static bool convert(ToType* output, const FromType& input)
+    {
+        return fallbackConversion(output, input);
+    }
+};
+
+// Default template for stringstream
+template <class ToType, class FromType>
+struct ConverterStringStream
+{
+    static bool convert(ToType* output, const FromType& input)
+    {
+        return fallbackConversion(output, input);
+    }
+};
 
 
@@ -215,35 +177,35 @@
 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>
-    struct ConverterSS<std::string, FromType>
-    {
-        // probe for '<<' ostream operator
-        static bool convert(std::string* output, const FromType& input)
+    inline bool operator <<(std::ostream& outstream,  const FromType& input)
+    {
+        std::string temp;
+        if (ConverterFallbackTemplate<std::string, FromType>::convert(&temp, input))
         {
-            std::ostringstream oss;
-            if (oss << input)
-            {
-                (*output) = oss.str();
-                return true;
-            }
-            else
-                return false;
+            std::operator <<(outstream, temp);
+            return true;
         }
-    };
-
-}
+        else
+            return false;
+    }
+}
+
+// template that evaluates whether OStringStream is possible for conversions to std::string
+template <class FromType>
+struct ConverterStringStream<std::string, FromType>
+{
+    static bool convert(std::string* output, const FromType& input)
+    {
+        using namespace fallbackTemplates;
+        std::ostringstream oss;
+        if (oss << input)
+        {
+            (*output) = oss.str();
+            return true;
+        }
+        else
+            return false;
+    }
+};
 
 
@@ -254,32 +216,28 @@
 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>
-    struct ConverterSS<ToType, std::string>
-    {
-        static bool convert(ToType* output, const std::string& input)
+    inline bool operator >>(std::istream& instream, ToType& output)
+    {
+        return ConverterFallbackTemplate<ToType, std::string>
+            ::convert(&output, static_cast<std::istringstream&>(instream).str());
+    }
+}
+
+// template that evaluates whether IStringStream is possible for conversions from std::string
+template <class ToType>
+struct ConverterStringStream<ToType, std::string>
+{
+    static bool convert(ToType* output, const std::string& input)
+    {
+        using namespace fallbackTemplates;
+        std::istringstream iss(input);
+        if (iss >> (*output))
         {
-            std::istringstream iss(input);
-            if (iss >> (*output))
-            {
-                return true;
-            }
-            else
-                return false;
+            return true;
         }
-    };
-
-    using namespace fallbackTemplates;
-}
+        else
+            return false;
+    }
+};
 
 
@@ -295,46 +253,32 @@
     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>
-    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>());
-    }
-}
-
-
-/////////////////////
-// Local Overwrite //
-/////////////////////
-
-// Template that is used when no explicit template specialisation is available.
-// Try explicitConversion() function next.
-template <class ToType, class FromType>
-struct ConverterExplicit
+    return ConverterStringStream<ToType, FromType>::convert(output, input);
+}
+
+
+///////////////////////
+// Explicit Fallback //
+///////////////////////
+
+template <class ToType, class FromType>
+inline 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;
+    return convertImplicitely(output, input, ::Int2Type<probe>());
+}
+
+
+// Indirect calls over a class template so we can call functions not yet declared.
+template <class ToType, class FromType>
+struct ConverterExplicitTemplate
 {
     static bool convert(ToType* output, const FromType& input)
     {
-        using namespace fallbackTemplates;
         return explicitConversion(output, input);
     }
@@ -348,14 +292,15 @@
 /**
 @brief
-    Converts any value to any other as long as there exits a conversion.
+    Converts any value to any other as long as there exists a conversion.
     Otherwise, the conversion will generate a runtime warning.
     For information about the different conversion methods (user defined too), see the section
     'Actual conversion sequence' in this file above.
+@note
+    This function is only a fallback if there is no appropriate 'convertValue' function.
 */
 template <class ToType, class FromType>
 inline bool convertValue(ToType* output, const FromType& input)
 {
-    // check whether we can convert one type to the other explicitely via explicit template specialisations
-    return ConverterExplicit<ToType, FromType>::convert(output, input);
+    return ConverterExplicitTemplate<ToType, FromType>::convert(output, input);
 }
 
@@ -425,5 +370,5 @@
 inline bool explicitConversion(ToType* output, const char* input)
 {
-    return ConverterExplicit<ToType, std::string>::convert(output, input);
+    return convertValue<ToType, std::string>(output, input);
 }
 
Index: code/branches/core3/src/util/Math.cc
===================================================================
--- code/branches/core3/src/util/Math.cc	(revision 1777)
+++ code/branches/core3/src/util/Math.cc	(revision 1778)
@@ -125,6 +125,10 @@
 }
 
+//////////////////////////
+// Conversion functions //
+//////////////////////////
+
 // std::string to Vector2
-bool explicitConversion(orxonox::Vector2* output, const std::string& input)
+bool fallbackConversion(orxonox::Vector2* output, const std::string& input)
 {
     unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
@@ -145,5 +149,5 @@
 
 // std::string to Vector3
-bool explicitConversion(orxonox::Vector3* output, const std::string& input)
+bool fallbackConversion(orxonox::Vector3* output, const std::string& input)
 {
     unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
@@ -166,5 +170,5 @@
 
 // std::string to Vector4
-bool explicitConversion(orxonox::Vector4* output, const std::string& input)
+bool fallbackConversion(orxonox::Vector4* output, const std::string& input)
 {
     unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
@@ -189,5 +193,5 @@
 
 // std::string to Quaternion
-bool explicitConversion(orxonox::Quaternion* output, const std::string& input)
+bool fallbackConversion(orxonox::Quaternion* output, const std::string& input)
 {
     unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
@@ -212,5 +216,5 @@
 
 // std::string to ColourValue
-bool explicitConversion(orxonox::ColourValue* output, const std::string& input)
+bool fallbackConversion(orxonox::ColourValue* output, const std::string& input)
 {
     unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
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 1778)
@@ -27,7 +27,8 @@
  */
 
-/*!
+/**
     @file
-    @brief Actual conversion functions.
+    @brief
+        Math conversion functions. Definitions are in Math.cc
 */
 
@@ -38,7 +39,4 @@
 #include "Convert.h"
 #include "Math.h"
-
-// Note: explicitConversion function is used whenever possible prior to
-//       template specialisations to allow for manual calls and overwrites.
 
 
@@ -113,13 +111,13 @@
 
 // std::string to Vector2
-_UtilExport bool explicitConversion(orxonox::Vector2* output, const std::string& input);
+_UtilExport bool fallbackConversion(orxonox::Vector2* output, const std::string& input);
 // std::string to Vector3
-_UtilExport bool explicitConversion(orxonox::Vector3* output, const std::string& input);
+_UtilExport bool fallbackConversion(orxonox::Vector3* output, const std::string& input);
 // std::string to Vector4
-_UtilExport bool explicitConversion(orxonox::Vector4* output, const std::string& input);
+_UtilExport bool fallbackConversion(orxonox::Vector4* output, const std::string& input);
 // std::string to Quaternion
-_UtilExport bool explicitConversion(orxonox::Quaternion* output, const std::string& input);
+_UtilExport bool fallbackConversion(orxonox::Quaternion* output, const std::string& input);
 // std::string to ColourValue
-_UtilExport bool explicitConversion(orxonox::ColourValue* output, const std::string& input);
+_UtilExport bool fallbackConversion(orxonox::ColourValue* output, const std::string& input);
 
 
@@ -130,5 +128,5 @@
 // From Radian
 template <class ToType>
-inline bool explicitConversion(ToType* output, const orxonox::Radian input)
+inline bool fallbackConversion(ToType* output, const orxonox::Radian input)
 {
     return convertValue<ToType, Ogre::Real>(output, input.valueRadians()); 
@@ -137,5 +135,5 @@
 // From Degree
 template <class ToType>
-inline bool explicitConversion(ToType* output, const orxonox::Degree input)
+inline bool fallbackConversion(ToType* output, const orxonox::Degree input)
 {
     return convertValue<ToType, Ogre::Real>(output, input.valueDegrees()); 
@@ -144,5 +142,5 @@
 // To Radian
 template <class FromType>
-inline bool explicitConversion(orxonox::Radian* output, const FromType input)
+inline bool fallbackConversion(orxonox::Radian* output, const FromType input)
 {
     float temp;
@@ -158,5 +156,5 @@
 // To Degree
 template <class FromType>
-inline bool explicitConversion(orxonox::Degree* output, const FromType input)
+inline bool fallbackConversion(orxonox::Degree* output, const FromType input)
 {
     float temp;
@@ -169,77 +167,4 @@
         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__ */
