Index: code/branches/core2/src/util/Convert.h
===================================================================
--- code/branches/core2/src/util/Convert.h	(revision 994)
+++ code/branches/core2/src/util/Convert.h	(revision 1001)
@@ -41,101 +41,352 @@
 #include "MultiTypeMath.h"
 
-// DEFAULT CLASS
-template <typename FromType, typename ToType>
-class Converter
-{
-  public:
-    bool operator()(ToType* output, const FromType& input) const
-    {
-      return false;
-    }
-};
-
-// PARTIAL SPECIALIZATION TO CONVERT TO STRINGS
-template<typename FromType>
-class Converter<FromType, std::string>
-{
-  public:
-    bool operator()(std::string* output, const FromType& input) const
-    {
-      std::ostringstream oss;
-      if (oss << input)
-      {
+
+//////////
+// Main //
+//////////
+/*
+enum ConversionPreference
+{
+    CP_ToType,
+    CP_FromType
+};
+
+// Helper classes to determine the preferred partial template specialization
+class _AnyType_  {};
+class _ToType_   {} static __to__;
+class _FromType_ {} static __from__;
+class _Explicit_ {} static __explicit__;
+
+
+// The default convert functions
+template <class FromType, class ToType>
+static bool convert(ToType* output, const FromType& input, _ToType_* type)
+{ std::cout << "default to" << std::endl; return false; }
+template <class FromType, class ToType>
+static bool convert(ToType* output, const FromType& input, _FromType_* type)
+{ std::cout << "default from" << std::endl; return false; }
+template <class FromType, class ToType>
+static bool convert(ToType* output, const FromType& input, _Explicit_* type)
+{ std::cout << "default explicit" << std::endl; return false; }
+
+
+// The default convert function if both types are the same
+template <class BothTypes>
+static bool convert(BothTypes* output, const BothTypes& input, _Explicit_* type)
+{ (*output) = input; return true; }
+
+
+// The default conversion of primitives: A typecast (defined over two partial specialized templates to exclude all non-primitive types and classes)
+template <class FromType, class ToType, class Type>
+static bool convertDefault(ToType* output, const FromType& input, Type* type)
+{ return false; }
+#define CONVERT_PRIMITIVE_DEFAULT(primitive) \
+template <class FromType> static bool convertDefault(primitive* output, const FromType& input, _ToType_* type) { return convertDefault(output, input, &__from__); } \
+template <class ToType>   static bool convertDefault(ToType* output, const primitive& input, _FromType_* type) { (*output) = (ToType)input; return true; }
+CONVERT_PRIMITIVE_DEFAULT(int)
+CONVERT_PRIMITIVE_DEFAULT(unsigned int)
+CONVERT_PRIMITIVE_DEFAULT(char)
+CONVERT_PRIMITIVE_DEFAULT(unsigned char)
+CONVERT_PRIMITIVE_DEFAULT(short)
+CONVERT_PRIMITIVE_DEFAULT(unsigned short)
+CONVERT_PRIMITIVE_DEFAULT(long)
+CONVERT_PRIMITIVE_DEFAULT(unsigned long)
+CONVERT_PRIMITIVE_DEFAULT(float)
+CONVERT_PRIMITIVE_DEFAULT(double)
+CONVERT_PRIMITIVE_DEFAULT(long double)
+CONVERT_PRIMITIVE_DEFAULT(bool)
+
+// Calls all four possibilities of converting two values: (the order of 2 and 3 can be changed by setting bPreferToType to false)
+// 1) explicit specialization
+// 2) partial specialization for ToType
+// 3) partial specialization of the FromType
+// 4) default conversion if available
+template<class FromType, class ToType>
+static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_ToType)
+{
+std::cout << "1_1\n";
+    if (convert(output, input, &__explicit__))
+        return true;
+
+std::cout << "1_2\n";
+    if (preference == CP_ToType)
+    {
+std::cout << "1_3\n";
+        if (convert(output, input, &__to__))
+            return true;
+std::cout << "1_4\n";
+        if (convert(output, input, &__from__))
+            return true;
+std::cout << "1_5\n";
+    }
+    else
+    {
+std::cout << "1_6\n";
+        if (convert(output, input, &__from__))
+            return true;
+std::cout << "1_7\n";
+        if (convert(output, input, &__to__))
+            return true;
+std::cout << "1_8\n";
+    }
+std::cout << "1_9\n";
+    return convertDefault(output, input, &__to__);
+}
+*/
+
+    // Enum to declare the wanted conversion preference in case of equal type-levels
+    enum ConversionPreference
+    {
+        CP_ToType,
+        CP_FromType
+    };
+
+    // Helper classes to determine the preferred partial template specialization
+    class _AnyType_  {};
+    class _ToType_   {} static __to__;
+    class _FromType_ {} static __from__;
+    class _Explicit_ {} static __explicit__;
+
+
+    // The default convert functions
+    template <class FromType, class ToType>
+    static bool convert(ToType* output, const FromType& input, _ToType_* type)
+    { std::cout << "default to" << std::endl; return false; }
+    template <class FromType, class ToType>
+    static bool convert(ToType* output, const FromType& input, _FromType_* type)
+    { std::cout << "default from" << std::endl; return false; }
+    template <class FromType, class ToType>
+    static bool convert(ToType* output, const FromType& input, _Explicit_* type)
+    { std::cout << "default explicit" << std::endl; return false; }
+
+
+    // The default convert function if both types are the same
+    template <class BothTypes>
+    static bool convert(BothTypes* output, const BothTypes& input, _Explicit_* type)
+    { (*output) = input; return true; }
+
+
+    // The possible levels
+    #define __low__  0
+    #define __mid__  1
+    #define __high__ 2
+
+    // Defines the levels of all types
+    template <class T> struct ConverterLeveL          { enum { level = __high__ }; };
+    template <> struct ConverterLeveL<std::string>    { enum { level = __mid__ }; };
+    template <> struct ConverterLeveL<int>            { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<unsigned int>   { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<char>           { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<unsigned char>  { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<short>          { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<unsigned short> { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<long>           { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<unsigned long>  { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<float>          { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<double>         { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<long double>    { enum { level = __low__ }; };
+    template <> struct ConverterLeveL<bool>           { enum { level = __low__ }; };
+
+
+    // Calculates the preference based on the levels of FromType and ToType
+    template <int from, int to>
+    struct ConverterPreference
+    {
+        enum
+        {
+            max = (from > to) ? from : to,
+            diff = ((to - from) > 1) ? 1 : (((to - from) < -1) ? -1 : to - from)
+        };
+    };
+
+
+    // The default conversion: This usually does nothing
+    template <int max, class FromType, class ToType, class Type>
+    struct ConverterDefault
+    {
+        static bool convert(ToType* output, const FromType& input, Type* type)
+        {
+            return false;
+        }
+    };
+    // The default conversion for primitives: A typecast (defined over two partial specialized templates to exclude all non-primitive types and classes)    template <int max, class FromType, class ToType>
+    template <class FromType, class ToType, class Type>
+    struct ConverterDefault<0, FromType, ToType, Type>
+    {
+        static bool convert(ToType* output, const FromType& input, Type* type)
+        {
+            (*output) = (ToType)input;
+            return true;
+        }
+    };
+
+
+    // Converter: Converts input of FromType into output of ToType
+    template <int diff, int max, class FromType, class ToType>
+    struct Converter
+    {
+        static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_ToType)
+        {
+            return false;
+        }
+    };
+    // Converter: FromType-level > ToType-level
+    template <int max, class FromType, class ToType>
+    struct Converter<-1, max, FromType, ToType>
+    {
+        static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_ToType)
+        {
+            if (convert(output, input, &__explicit__))
+                return true;
+            if (convert(output, input, &__from__))
+                return true;
+            if (ConverterDefault<max, FromType, ToType, _ToType_>::convert(output, input, &__to__))
+                return true;
+
+            return false;
+        }
+    };
+    // Converter: ToType-level > FromType-level
+    template <int max, class FromType, class ToType>
+    struct Converter<1, max, FromType, ToType>
+    {
+        static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_ToType)
+        {
+            if (convert(output, input, &__explicit__))
+                return true;
+            if (convert(output, input, &__to__))
+                return true;
+            if (ConverterDefault<max, FromType, ToType, _ToType_>::convert(output, input, &__to__))
+                return true;
+
+            return false;
+        }
+    };
+    // Converter: ToType-level = ToType-level
+    template <int max, class FromType, class ToType>
+    struct Converter<0, max, FromType, ToType>
+    {
+        static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_ToType)
+        {
+            if (convert(output, input, &__explicit__))
+                return true;
+
+            if (preference == CP_ToType)
+            {
+                if (convert(output, input, &__to__))
+                    return true;
+                if (convert(output, input, &__from__))
+                    return true;
+            }
+            else
+            {
+                if (convert(output, input, &__from__))
+                    return true;
+                if (convert(output, input, &__to__))
+                    return true;
+            }
+
+            if (ConverterDefault<max, FromType, ToType, _ToType_>::convert(output, input, &__to__))
+                return true;
+
+            return false;
+        }
+    };
+
+
+    // Calls the Converter::convertValue function with the correct template type parameters calculated by ConverterPreference
+    template <class FromType, class ToType>
+    static bool convertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_ToType)
+    {
+        return Converter<ConverterPreference<ConverterLeveL<FromType>::level, ConverterLeveL<ToType>::level>::diff, ConverterPreference<ConverterLeveL<FromType>::level, ConverterLeveL<ToType>::level>::max, FromType, ToType>::convertValue(output, input, preference);
+    }
+
+
+// Helper function: Calls convertValue with and without default value and returns true if the conversion was successful
+template<class FromType, class ToType>
+static bool ConvertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_ToType)
+{
+    return convertValue(output, input, preference);
+}
+template<class FromType, class ToType>
+static bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback, ConversionPreference preference = CP_ToType)
+{
+    if (convertValue(output, input, preference))
+        return true;
+
+    (*output) = fallback;
+    return false;
+}
+
+// Helper function: Calls convertValue with and without default value and returns the converted value
+template<class FromType, class ToType>
+static ToType getConvertedValue(const FromType& input, ConversionPreference preference = CP_ToType)
+{
+    ToType output = ToType();
+    ConvertValue(&output, input, preference);
+    return output;
+}
+template<class FromType, class ToType>
+static ToType getConvertedValue(const FromType& input, const ToType& fallback, ConversionPreference preference = CP_ToType)
+{
+    ToType output = fallback;
+    ConvertValue(&output, input, fallback, preference);
+    return output;
+}
+
+/////////////////////
+// SPECIALISATIONS //
+/////////////////////
+
+/*
+template <class FromType>
+static bool convertDefault(primitive* output, const FromType& input, _ToType_* type)
+{
+
+}
+
+template <class ToType>
+static bool convertDefault(ToType* output, const primitive& input, _FromType_* type)
+{
+
+}
+
+
+template <>
+static bool convertDefault(ToType* output, const FromType& input, _Explicit_* type)
+{
+
+}
+*/
+
+////////////
+// String //
+////////////
+
+// convert to string
+template <class FromType>
+static bool convert(std::string* output, const FromType& input, _ToType_* type)
+{
+    std::ostringstream oss;
+    if (oss << input)
+    {
         (*output) = oss.str();
         return true;
-      }
-      else
+    }
+    else
         return false;
-    }
-};
-
-// PARTIAL SPECIALIZATION TO CONVERT FROM STRING
-template<typename ToType>
-class Converter<std::string, ToType>
-{
-  public:
-    bool operator()(ToType* output, const std::string& input) const
-    {
-      std::istringstream iss(input);
-      if (iss >> (*output))
-        return true;
-      else
+}
+
+// convert from string
+template <class ToType>
+static bool convert(ToType* output, const std::string& input, _FromType_* type)
+{
+    std::istringstream iss(input);
+    if (iss >> (*output))
+        return true;
+    else
         return false;
-    }
-};
-
-// FUNCTION SO WE DO NOT HAVE TO TELL THE COMPILER ABOUT THE TYPE
-template<typename FromType, typename ToType>
-static bool ConvertValue(ToType* output, const FromType& input)
-{
-  Converter<FromType, ToType> converter;
-  return converter(output, input);
-}
-
-// THE SAME, BUT WITH DEFAULT VALUE
-template<typename FromType, typename ToType>
-static bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback)
-{
-  Converter<FromType, ToType> converter;
-  if (converter(output, input))
-    return true;
-
-  (*output) = fallback;
-  return false;
-}
-
-// THE SAME LIKE BEFORE, BUT NEEDS NO POINTER TO THE OUTPUT
-template<typename FromType, typename ToType>
-static ToType ConvertValueAndReturn(const FromType& input)
-{
-  ToType output = ToType();
-  ConvertValue(&output, input);
-  return output;
-}
-
-// THE SAME, BUT WITH DEFAULT VALUE
-template<typename FromType, typename ToType>
-static ToType ConvertValueAndReturn(const FromType& input, const ToType& fallback)
-{
-  ToType output = fallback;
-  ConvertValue(&output, input, fallback);
-  return output;
-}
-
-//////////////////////////
-// MORE SPECIALISATIONS //
-//////////////////////////
-
-// STRING TO STRING
-template<>
-class Converter<std::string, std::string>
-{
-  public:
-    bool operator()(std::string* output, const std::string& input) const
-    {
-        (*output) = std::string(input);
-        return true;
-    }
-};
+}
+
 
 ////////////////
@@ -143,157 +394,69 @@
 ////////////////
 
-// PARTIAL SPECIALIZATION TO CONVERT FROM MULTITYPEPRIMITIVE
-template<typename ToType>
-class Converter<MultiTypePrimitive, ToType>
-{
-  public:
-    bool operator()(ToType* output, const MultiTypePrimitive& input) const
-    {
-      if (input.getType() == MT_void)
+// convert from MultiTypePrimitive
+template <class ToType>
+static bool convert(ToType* output, const MultiTypePrimitive& input, _FromType_* type)
+{
+    if (input.getType() == MT_void)
         return ConvertValue(output, input.getVoid());
-      else if (input.getType() == MT_int)
+    else if (input.getType() == MT_int)
         return ConvertValue(output, input.getInt());
-      else if (input.getType() == MT_uint)
+    else if (input.getType() == MT_uint)
         return ConvertValue(output, input.getUnsignedInt());
-      else if (input.getType() == MT_char)
+    else if (input.getType() == MT_char)
         return ConvertValue(output, input.getChar());
-      else if (input.getType() == MT_uchar)
+    else if (input.getType() == MT_uchar)
         return ConvertValue(output, input.getUnsignedChar());
-      else if (input.getType() == MT_short)
+    else if (input.getType() == MT_short)
         return ConvertValue(output, input.getShort());
-      else if (input.getType() == MT_ushort)
+    else if (input.getType() == MT_ushort)
         return ConvertValue(output, input.getUnsignedShort());
-      else if (input.getType() == MT_long)
+    else if (input.getType() == MT_long)
         return ConvertValue(output, input.getLong());
-      else if (input.getType() == MT_ulong)
+    else if (input.getType() == MT_ulong)
         return ConvertValue(output, input.getUnsignedLong());
-      else if (input.getType() == MT_float)
+    else if (input.getType() == MT_float)
         return ConvertValue(output, input.getFloat());
-      else if (input.getType() == MT_double)
+    else if (input.getType() == MT_double)
         return ConvertValue(output, input.getDouble());
-      else if (input.getType() == MT_longdouble)
+    else if (input.getType() == MT_longdouble)
         return ConvertValue(output, input.getLongDouble());
-      else if (input.getType() == MT_bool)
+    else if (input.getType() == MT_bool)
         return ConvertValue(output, input.getBool());
-      else
+    else
         return false;
-    }
-};
-template<>
-class Converter<MultiTypePrimitive, std::string>
-{
-  public:
-    bool operator()(std::string* output, const MultiTypePrimitive& input) const
-    {
-      if (input.getType() == MT_void)
-        return ConvertValue(output, input.getVoid());
-      else if (input.getType() == MT_int)
-        return ConvertValue(output, input.getInt());
-      else if (input.getType() == MT_uint)
-        return ConvertValue(output, input.getUnsignedInt());
-      else if (input.getType() == MT_char)
-        return ConvertValue(output, input.getChar());
-      else if (input.getType() == MT_uchar)
-        return ConvertValue(output, input.getUnsignedChar());
-      else if (input.getType() == MT_short)
-        return ConvertValue(output, input.getShort());
-      else if (input.getType() == MT_ushort)
-        return ConvertValue(output, input.getUnsignedShort());
-      else if (input.getType() == MT_long)
-        return ConvertValue(output, input.getLong());
-      else if (input.getType() == MT_ulong)
-        return ConvertValue(output, input.getUnsignedLong());
-      else if (input.getType() == MT_float)
-        return ConvertValue(output, input.getFloat());
-      else if (input.getType() == MT_double)
-        return ConvertValue(output, input.getDouble());
-      else if (input.getType() == MT_longdouble)
-        return ConvertValue(output, input.getLongDouble());
-      else if (input.getType() == MT_bool)
-        return ConvertValue(output, input.getBool());
-      else
-        return false;
-    }
-};
-
-// PARTIAL SPECIALIZATION TO CONVERT FROM MULTITYPESTRING
-template<typename ToType>
-class Converter<MultiTypeString, ToType>
-{
-  public:
-    bool operator()(ToType* output, const MultiTypeString& input) const
-    {
-      if (input.getType() == MT_constchar)
+}
+
+// convert from MultiTypeString
+template <class ToType>
+static bool convert(ToType* output, const MultiTypeString& input, _FromType_* type)
+{
+    if (input.getType() == MT_constchar)
         return ConvertValue(output, input.getConstChar());
-      else if (input.getType() == MT_string)
+    else if (input.getType() == MT_string)
         return ConvertValue(output, input.getString());
-      else if (input.getType() == MT_xmlelement)
-        return ConvertValue(output, input.getXMLElement());
-      else
+    else
         return ConvertValue(output, (MultiTypePrimitive)input);
-    }
-};
-template<>
-class Converter<MultiTypeString, std::string>
-{
-  public:
-    bool operator()(std::string* output, const MultiTypeString& input) const
-    {
-      if (input.getType() == MT_constchar)
-        return ConvertValue(output, input.getConstChar());
-      else if (input.getType() == MT_string)
-        return ConvertValue(output, input.getString());
-      else if (input.getType() == MT_xmlelement)
-        return ConvertValue(output, input.getXMLElement());
-      else
-        return ConvertValue(output, (MultiTypePrimitive)input);
-    }
-};
-
-// PARTIAL SPECIALIZATION TO CONVERT FROM MULTITYPEMATH
-template<typename ToType>
-class Converter<MultiTypeMath, ToType>
-{
-  public:
-    bool operator()(ToType* output, const MultiTypeMath& input) const
-    {
-      if (input.getType() == MT_vector2)
-        return ConvertValue(output, input.getVector2());
-      else if (input.getType() == MT_vector3)
-        return ConvertValue(output, input.getVector3());
-      else if (input.getType() == MT_quaternion)
-        return ConvertValue(output, input.getQuaternion());
-      else if (input.getType() == MT_colourvalue)
-        return ConvertValue(output, input.getColourValue());
-      else if (input.getType() == MT_radian)
+}
+
+// convert from MultiTypeMath
+template <class ToType>
+static bool convert(ToType* output, const MultiTypeMath& input, _FromType_* type)
+{
+    if (input.getType() == MT_vector2)
+        return ConvertValue(output, input.getVector2(), CP_FromType);
+    else if (input.getType() == MT_vector3)
+        return ConvertValue(output, input.getVector3(), CP_FromType);
+    else if (input.getType() == MT_quaternion)
+        return ConvertValue(output, input.getQuaternion(), CP_FromType);
+    else if (input.getType() == MT_colourvalue)
+        return ConvertValue(output, input.getColourValue(), CP_FromType);
+    else if (input.getType() == MT_radian)
         return ConvertValue(output, input.getRadian());
-      else if (input.getType() == MT_degree)
+    else if (input.getType() == MT_degree)
         return ConvertValue(output, input.getDegree());
-      else
+    else
         return ConvertValue(output, (MultiTypeString)input);
-    }
-};
-template<>
-class Converter<MultiTypeMath, std::string>
-{
-  public:
-    bool operator()(std::string* output, const MultiTypeMath& input) const
-    {
-      if (input.getType() == MT_vector2)
-        return ConvertValue(output, input.getVector2());
-      else if (input.getType() == MT_vector3)
-        return ConvertValue(output, input.getVector3());
-      else if (input.getType() == MT_quaternion)
-        return ConvertValue(output, input.getQuaternion());
-      else if (input.getType() == MT_colourvalue)
-        return ConvertValue(output, input.getColourValue());
-      else if (input.getType() == MT_radian)
-        return ConvertValue(output, input.getRadian());
-      else if (input.getType() == MT_degree)
-        return ConvertValue(output, input.getDegree());
-      else
-        return ConvertValue(output, (MultiTypeString)input);
-    }
-};
+}
 
 
@@ -304,4 +467,18 @@
 // Vector2 to std::string
 template <>
+static bool convert(std::string* output, const orxonox::Vector2& input, _Explicit_* type)
+{
+    std::ostringstream ostream;
+    if (ostream << input.x << "," << input.y)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+
+/*
+// Vector2 to std::string
+template <>
 class Converter<orxonox::Vector2, std::string>
 {
@@ -319,5 +496,19 @@
     }
 };
-
+*/
+// Vector3 to std::string
+template <>
+static bool convert(std::string* output, const orxonox::Vector3& input, _Explicit_* type)
+{
+    std::ostringstream ostream;
+    if (ostream << input.x << "," << input.y << "," << input.z)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+
+/*
 // Vector3 to std::string
 template <>
@@ -337,5 +528,18 @@
     }
 };
-
+*/
+// Vector4 to std::string
+template <>
+static bool convert(std::string* output, const orxonox::Vector4& input, _Explicit_* type)
+{
+    std::ostringstream ostream;
+    if (ostream << input.x << "," << input.y << "," << input.z << "," << input.w)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+/*
 // Vector4 to std::string
 template <>
@@ -355,5 +559,18 @@
     }
 };
-
+*/
+// Quaternion to std::string
+template <>
+static bool convert(std::string* output, const orxonox::Quaternion& input, _Explicit_* type)
+{
+    std::ostringstream ostream;
+    if (ostream << input.w << "," << input.x << "," << input.y << "," << input.z)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+/*
 // Quaternion to std::string
 template <>
@@ -373,5 +590,18 @@
     }
 };
-
+*/
+// ColourValue to std::string
+template <>
+static bool convert(std::string* output, const orxonox::ColourValue& input, _Explicit_* type)
+{
+    std::ostringstream ostream;
+    if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
+    {
+        (*output) = ostream.str();
+        return true;
+    }
+    return false;
+}
+/*
 // ColourValue to std::string
 template <>
@@ -391,4 +621,5 @@
     }
 };
+*/
 
 
@@ -399,4 +630,24 @@
 // std::string to Vector2
 template <>
+static bool convert(orxonox::Vector2* output, const std::string& input, _Explicit_* type)
+{
+    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 2)
+    {
+        if (!ConvertValue(&(output->x), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+            return false;
+
+        return true;
+    }
+    return false;
+}
+/*
+// std::string to Vector2
+template <>
 class Converter<std::string, orxonox::Vector2>
 {
@@ -422,5 +673,27 @@
     }
 };
-
+*/
+// std::string to Vector3
+template <>
+static bool convert(orxonox::Vector3* output, const std::string& input, _Explicit_* type)
+{
+    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 3)
+    {
+        if (!ConvertValue(&(output->x), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+            return false;
+        if (!ConvertValue(&(output->z), tokens[2]))
+            return false;
+
+        return true;
+    }
+    return false;
+}
+/*
 // std::string to Vector3
 template <>
@@ -450,5 +723,29 @@
     }
 };
-
+*/
+// std::string to Vector4
+template <>
+static bool convert(orxonox::Vector4* output, const std::string& input, _Explicit_* type)
+{
+    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 4)
+    {
+        if (!ConvertValue(&(output->x), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->y), tokens[1]))
+            return false;
+        if (!ConvertValue(&(output->z), tokens[2]))
+            return false;
+        if (!ConvertValue(&(output->w), tokens[3]))
+            return false;
+
+        return true;
+    }
+    return false;
+}
+/*
 // std::string to Vector4
 template <>
@@ -480,5 +777,29 @@
     }
 };
-
+*/
+// std::string to Quaternion
+template <>
+static bool convert(orxonox::Quaternion* output, const std::string& input, _Explicit_* type)
+{
+    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 4)
+    {
+        if (!ConvertValue(&(output->w), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->x), tokens[1]))
+            return false;
+        if (!ConvertValue(&(output->y), tokens[2]))
+            return false;
+        if (!ConvertValue(&(output->z), tokens[3]))
+            return false;
+
+        return true;
+    }
+    return false;
+}
+/*
 // std::string to Quaternion
 template <>
@@ -510,5 +831,29 @@
     }
 };
-
+*/
+// std::string to ColourValue
+template <>
+static bool convert(orxonox::ColourValue* output, const std::string& input, _Explicit_* type)
+{
+    unsigned int opening_parenthesis, closing_parenthesis = input.find(')');
+    if ((opening_parenthesis = input.find('(')) == std::string::npos) { opening_parenthesis = 0; } else { opening_parenthesis++; }
+
+    SubString tokens(input.substr(opening_parenthesis, closing_parenthesis - opening_parenthesis), ",", SubString::WhiteSpaces, false, '\\', true, '"', true, '\0', '\0', true, '\0');
+    if (tokens.size() >= 4)
+    {
+        if (!ConvertValue(&(output->r), tokens[0]))
+            return false;
+        if (!ConvertValue(&(output->g), tokens[1]))
+            return false;
+        if (!ConvertValue(&(output->b), tokens[2]))
+            return false;
+        if (!ConvertValue(&(output->a), tokens[3]))
+            return false;
+
+        return true;
+    }
+    return false;
+}
+/*
 // std::string to ColourValue
 template <>
@@ -540,4 +885,6 @@
     }
 };
+*/
+
 
 #endif /* _Convert_H__ */
