Index: code/branches/core2/src/orxonox/core/Functor.h
===================================================================
--- code/branches/core2/src/orxonox/core/Functor.h	(revision 1002)
+++ code/branches/core2/src/orxonox/core/Functor.h	(revision 1003)
@@ -325,9 +325,5 @@
             void operator()(const MultiTypeMath& param1 = MT_null, const MultiTypeMath& param2 = MT_null, const MultiTypeMath& param3 = MT_null, const MultiTypeMath& param4 = MT_null, const MultiTypeMath& param5 = MT_null) \
             { \
-                std::cout << "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" << std::endl; \
-                std::cout << param1 << std::endl; \
-                std::cout << this->getTypenameParam(0) << std::endl; \
                 FUNCTOR_STORE_RETURNVALUE(returnvalue, (*this->functionPointer_)(FUNCTOR_FUNCTION_CALL(numparams))); \
-                std::cout << "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" << std::endl; \
             } \
     \
Index: code/branches/core2/src/util/Convert.h
===================================================================
--- code/branches/core2/src/util/Convert.h	(revision 1002)
+++ code/branches/core2/src/util/Convert.h	(revision 1003)
@@ -21,6 +21,7 @@
  *   Author:
  *      Benjamin Grauer
+ *      Fabian 'x3n' Landau
  *   Co-authors:
- *      Fabian 'x3n' Landau
+ *      ...
  */
 
@@ -45,270 +46,162 @@
 // Main //
 //////////
-/*
+
+// Enum to declare the wanted conversion preference in case of equal type-levels
 enum ConversionPreference
 {
-    CP_ToType,
-    CP_FromType
+    CP_PreferToType,
+    CP_PreferFromType,
 };
 
 // Helper classes to determine the preferred partial template specialization
-class _AnyType_  {};
-class _ToType_   {} static __to__;
-class _FromType_ {} static __from__;
-class _Explicit_ {} static __explicit__;
+class _ToType_   {};
+class _FromType_ {};
+class _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; }
+template <class FromType, class ToType, class Type>
+struct ConverterSpecialized
+{
+    enum { specialized = false };
+    static bool convert(ToType* output, const FromType& input)
+    { 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__))
+struct ConverterSpecialized<BothTypes, BothTypes, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(BothTypes* output, const BothTypes& input)
+    { (*output) = input; return true; }
+};
+
+
+// The possible levels
+#define __low__  0 // Everything that is or behaves like a primitive type (an can be converted with a typecast to every other low-level type)
+#define __mid__  1 // Everything that has overloaded << and >> operators to operate on a std::stream
+#define __high__ 2 // Everything that doesn't fullfill the lowerlevel-requirements and therefore needs specialized conversions
+
+// Defines the levels of all types: Default is __high__ so you don't have to define every high-level type
+template <class T> struct ConverterLevel           { enum { level = __high__ }; };
+template <> struct ConverterLevel<std::string>     { enum { level = __mid__ }; };
+template <> struct ConverterLevel<orxonox::Radian> { enum { level = __mid__ }; };
+template <> struct ConverterLevel<orxonox::Degree> { 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
+    {
+        // The maximum of both levels: element of {0, 1, 2}
+        // max 0: Both types are primitives or have a similar behaviour
+        // max 1: At least one type is not a primitive, but both can be put on a std::stream
+        // max 2: There is at least one generic type that needs specialized conversions
+        max = (from > to) ? from : to,
+
+        // The difference between both levels limited to +-1: element of {-1, 0, 1}
+        // diff -1: The FromType has higher level than the ToType
+        // diff  0: Both types have the same level
+        // diff  1: The ToType has higher level than the FromType
+        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>
+struct ConverterDefault
+{
+    static bool convert(ToType* output, const FromType& input)
+    {
+        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>
+struct ConverterDefault<0, FromType, ToType>
+{
+    static bool convert(ToType* output, const FromType& input)
+    {
+        (*output) = (ToType)input;
         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__);
+    }
+};
+
+
+// Converter: Converts input of FromType into output of ToType
+template <int diff, int max, class FromType, class ToType, ConversionPreference pref>
+struct Converter
+{
+    static bool convert(ToType* output, const FromType& input)
+    {
+        return false;
+    }
+};
+// Converter: level{FromType} > level{ToType}
+template <int max, class FromType, class ToType, ConversionPreference pref>
+struct Converter<-1, max, FromType, ToType, pref>
+{   static bool convert(ToType* output, const FromType& input)
+    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
+// Converter: level{FromType} < level{ToType}
+template <int max, class FromType, class ToType, ConversionPreference pref>
+struct Converter<1, max, FromType, ToType, pref>
+{   static bool convert(ToType* output, const FromType& input)
+    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
+// Converter: level{FromType} = level{ToType}
+// CP_PreferToType
+template <int max, class FromType, class ToType>
+struct Converter<0, max, FromType, ToType, CP_PreferToType>
+{   static bool convert(ToType* output, const FromType& input)
+    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
+// CP_PreferFromType
+template <int max, class FromType, class ToType>
+struct Converter<0, max, FromType, ToType, CP_PreferFromType>
+{   static bool convert(ToType* output, const FromType& input)
+    { return (ConverterSpecialized<FromType, ToType, _Explicit_>::specialized) ? (ConverterSpecialized<FromType, ToType, _Explicit_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _FromType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _FromType_>::convert(output, input)) : (ConverterSpecialized<FromType, ToType, _ToType_>::specialized) ? (ConverterSpecialized<FromType, ToType, _ToType_>::convert(output, input)) : (ConverterDefault<max, FromType, ToType>::convert(output, input)); } };
+
+
+// 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_PreferToType)
+{
+    return (preference == CP_PreferToType) ?
+           Converter<ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::diff,
+                     ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::max,
+                     FromType,
+                     ToType,
+                     CP_PreferToType>::convert(output, input)
+         : Converter<ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::diff,
+                     ConverterPreference<ConverterLevel<FromType>::level, ConverterLevel<ToType>::level>::max,
+                     FromType,
+                     ToType,
+                     CP_PreferFromType>::convert(output, input);
 }
-*/
-
-    // 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)
+static bool ConvertValue(ToType* output, const FromType& input, ConversionPreference preference = CP_PreferToType)
 {
     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)
+static bool ConvertValue(ToType* output, const FromType& input, const ToType& fallback, ConversionPreference preference = CP_PreferToType)
 {
     if (convertValue(output, input, preference))
@@ -321,5 +214,5 @@
 // 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)
+static ToType getConvertedValue(const FromType& input, ConversionPreference preference = CP_PreferToType)
 {
     ToType output = ToType();
@@ -328,5 +221,5 @@
 }
 template<class FromType, class ToType>
-static ToType getConvertedValue(const FromType& input, const ToType& fallback, ConversionPreference preference = CP_ToType)
+static ToType getConvertedValue(const FromType& input, const ToType& fallback, ConversionPreference preference = CP_PreferToType)
 {
     ToType output = fallback;
@@ -339,23 +232,34 @@
 /////////////////////
 
+/////////////
+// Samples //
+/////////////
 /*
+// convert everything to xyz
 template <class FromType>
-static bool convertDefault(primitive* output, const FromType& input, _ToType_* type)
-{
-
-}
-
+struct ConverterSpecialized<FromType, xyz, _ToType_>
+{
+    enum { specialized = true };
+    static bool convert(xyz* output, const FromType& input)
+    { return ...; }
+};
+
+// convert xyz to everything
 template <class ToType>
-static bool convertDefault(ToType* output, const primitive& input, _FromType_* type)
-{
-
-}
-
-
-template <>
-static bool convertDefault(ToType* output, const FromType& input, _Explicit_* type)
-{
-
-}
+struct ConverterSpecialized<xyz, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const xyz& input)
+    { return ...; }
+};
+
+// convert abc to xyz
+template <>
+struct ConverterSpecialized<abc, xyz, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(xyz* output, const abc& input)
+    { return ...; }
+};
 */
 
@@ -366,26 +270,34 @@
 // 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
-        return false;
-}
+struct ConverterSpecialized<FromType, std::string, _ToType_>
+{
+    enum { specialized = true };
+    static bool convert(std::string* output, const FromType& input)
+    {
+        std::ostringstream oss;
+        if (oss << input)
+        {
+            (*output) = oss.str();
+            return true;
+        }
+        else
+            return false;
+    }
+};
 
 // 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;
-}
+struct ConverterSpecialized<std::string, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const std::string& input)
+    {
+        std::istringstream iss(input);
+        if (iss >> (*output))
+            return true;
+        else
+            return false;
+    }
+};
 
 
@@ -396,67 +308,79 @@
 // 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)
-        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;
-}
+struct ConverterSpecialized<MultiTypePrimitive, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const MultiTypePrimitive& input)
+    {
+        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;
+    }
+};
 
 // 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)
-        return ConvertValue(output, input.getString());
-    else
-        return ConvertValue(output, (MultiTypePrimitive)input);
-}
+struct ConverterSpecialized<MultiTypeString, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const MultiTypeString& input)
+    {
+        if (input.getType() == MT_constchar)
+            return ConvertValue(output, input.getConstChar());
+        else if (input.getType() == MT_string)
+            return ConvertValue(output, input.getString());
+        else
+            return ConvertValue(output, (MultiTypePrimitive)input);
+    }
+};
 
 // 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)
-        return ConvertValue(output, input.getDegree());
-    else
-        return ConvertValue(output, (MultiTypeString)input);
-}
+struct ConverterSpecialized<MultiTypeMath, ToType, _FromType_>
+{
+    enum { specialized = true };
+    static bool convert(ToType* output, const MultiTypeMath& input)
+    {
+        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);
+    }
+};
 
 
@@ -467,159 +391,86 @@
 // 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>
-{
-  public:
-    bool operator()(std::string* output, const orxonox::Vector2& input) const
-    {
-      std::ostringstream ostream;
-      if (ostream << input.x << "," << input.y)
-      {
-        (*output) = ostream.str();
-        return true;
-      }
-
-      return false;
-    }
-};
-*/
+struct ConverterSpecialized<orxonox::Vector2, std::string, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(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
 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 <>
-class Converter<orxonox::Vector3, std::string>
-{
-  public:
-    bool operator()(std::string* output, const orxonox::Vector3& input) const
-    {
-      std::ostringstream ostream;
-      if (ostream << input.x << "," << input.y << "," << input.z)
-      {
-        (*output) = ostream.str();
-        return true;
-      }
-
-      return false;
-    }
-};
-*/
+struct ConverterSpecialized<orxonox::Vector3, std::string, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(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
 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 <>
-class Converter<orxonox::Vector4, std::string>
-{
-  public:
-    bool operator()(std::string* output, const orxonox::Vector4& input) const
-    {
-      std::ostringstream ostream;
-      if (ostream << input.x << "," << input.y << "," << input.z << "," << input.w)
-      {
-        (*output) = ostream.str();
-        return true;
-      }
-
-      return false;
-    }
-};
-*/
+struct ConverterSpecialized<orxonox::Vector4, std::string, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(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
 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 <>
-class Converter<orxonox::Quaternion, std::string>
-{
-  public:
-    bool operator()(std::string* output, const orxonox::Quaternion& input) const
-    {
-      std::ostringstream ostream;
-      if (ostream << input.w << "," << input.x << "," << input.y << "," << input.z)
-      {
-        (*output) = ostream.str();
-        return true;
-      }
-
-      return false;
-    }
-};
-*/
+struct ConverterSpecialized<orxonox::Quaternion, std::string, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(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
 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 <>
-class Converter<orxonox::ColourValue, std::string>
-{
-  public:
-    bool operator()(std::string* output, const orxonox::ColourValue& input) const
-    {
-      std::ostringstream ostream;
-      if (ostream << input.r << "," << input.g << "," << input.b << "," << input.a)
-      {
-        (*output) = ostream.str();
-        return true;
-      }
-
-      return false;
-    }
-};
-*/
+struct ConverterSpecialized<orxonox::ColourValue, std::string, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(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;
+    }
+};
 
 
@@ -630,261 +481,135 @@
 // 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>
-{
-  public:
-    bool operator()(orxonox::Vector2* output, const std::string& input) const
-    {
-      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;
-    }
-};
-*/
+struct ConverterSpecialized<std::string, orxonox::Vector2, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(orxonox::Vector2* output, const std::string& input)
+    {
+        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 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 <>
-class Converter<std::string, orxonox::Vector3>
-{
-  public:
-    bool operator()(orxonox::Vector3* output, const std::string& input) const
-    {
-      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;
-    }
-};
-*/
+struct ConverterSpecialized<std::string, orxonox::Vector3, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(orxonox::Vector3* output, const std::string& input)
+    {
+        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 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 <>
-class Converter<std::string, orxonox::Vector4>
-{
-  public:
-    bool operator()(orxonox::Vector4* output, const std::string& input) const
-    {
-      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;
-    }
-};
-*/
+struct ConverterSpecialized<std::string, orxonox::Vector4, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(orxonox::Vector4* output, const std::string& input)
+    {
+        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 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 <>
-class Converter<std::string, orxonox::Quaternion>
-{
-  public:
-    bool operator()(orxonox::Quaternion* output, const std::string& input) const
-    {
-      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;
-    }
-};
-*/
+struct ConverterSpecialized<std::string, orxonox::Quaternion, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(orxonox::Quaternion* output, const std::string& input)
+    {
+        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 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 <>
-class Converter<std::string, orxonox::ColourValue>
-{
-  public:
-    bool operator()(orxonox::ColourValue* output, const std::string& input) const
-    {
-      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;
-    }
-};
-*/
-
+struct ConverterSpecialized<std::string, orxonox::ColourValue, _Explicit_>
+{
+    enum { specialized = true };
+    static bool convert(orxonox::ColourValue* output, const std::string& input)
+    {
+        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;
+    }
+};
 
 #endif /* _Convert_H__ */
Index: code/branches/core2/src/util/MultiTypeMath.cc
===================================================================
--- code/branches/core2/src/util/MultiTypeMath.cc	(revision 1002)
+++ code/branches/core2/src/util/MultiTypeMath.cc	(revision 1003)
@@ -165,12 +165,12 @@
 
     if (this->type_ == MT_vector2)
-        ConvertValue(&output, this->vector2_, CP_FromType);
+        ConvertValue(&output, this->vector2_);
     else if (this->type_ == MT_vector3)
-        ConvertValue(&output, this->vector3_, CP_FromType);
+        ConvertValue(&output, this->vector3_);
     else if (this->type_ == MT_colourvalue)
     { std::cout << "3_1\n";
-        ConvertValue(&output, this->colourvalue_, CP_FromType);}
+        ConvertValue(&output, this->colourvalue_);}
     else if (this->type_ == MT_quaternion)
-        ConvertValue(&output, this->quaternion_, CP_FromType);
+        ConvertValue(&output, this->quaternion_);
     else if (this->type_ == MT_radian)
         ConvertValue(&output, this->radian_);
@@ -186,12 +186,12 @@
 {
     if (this->type_ == MT_vector2)
-        return ConvertValue(&this->vector2_, value, orxonox::Vector2(0, 0), CP_FromType);
+        return ConvertValue(&this->vector2_, value, orxonox::Vector2(0, 0));
     else if (this->type_ == MT_vector3)
-        return ConvertValue(&this->vector3_, value, orxonox::Vector3(0, 0, 0), CP_FromType);
+        return ConvertValue(&this->vector3_, value, orxonox::Vector3(0, 0, 0));
     else if (this->type_ == MT_colourvalue)
     { std::cout << "4_1\n";
-        return ConvertValue(&this->colourvalue_, value, orxonox::ColourValue(0, 0, 0, 0), CP_FromType); }
+        return ConvertValue(&this->colourvalue_, value, orxonox::ColourValue(0, 0, 0, 0)); }
     else if (this->type_ == MT_quaternion)
-        return ConvertValue(&this->quaternion_, value, orxonox::Quaternion(1, 0, 0, 0), CP_FromType);
+        return ConvertValue(&this->quaternion_, value, orxonox::Quaternion(1, 0, 0, 0));
     else if (this->type_ == MT_radian)
         return ConvertValue(&this->radian_, value, orxonox::Radian(0));
