Index: code/branches/core3/src/core/ConfigValueContainer.cc
===================================================================
--- code/branches/core3/src/core/ConfigValueContainer.cc	(revision 1719)
+++ code/branches/core3/src/core/ConfigValueContainer.cc	(revision 1720)
@@ -153,19 +153,15 @@
         {
             return this->callFunctionWithIndex(&ConfigValueContainer::tset, input);
-        }
-        else
-        {
-//            MultiType temp = this->value_;
-//            if (temp.assimilate(input))
-//            {
-//                this->value_ = temp;
-                this->value_ = input;
-                if (this->identifier_)
-                    this->identifier_->updateConfigValues();
-
-                return true;
-//            }
-        }
-        return false;
+            return false;
+        }
+        else
+        {
+            this->value_ = input;
+
+            if (this->identifier_)
+                this->identifier_->updateConfigValues();
+
+            return true;
+        }
     }
 
@@ -194,21 +190,16 @@
             }
 
-//            MultiType temp = this->value_;
-//            if (temp.assimilate(input))
-//            {
-//                this->valueVector_[index] = temp;
-                this->valueVector_[index] = input;
-
-                if (this->identifier_)
-                    this->identifier_->updateConfigValues();
-
-                return true;
-//            }
+            this->valueVector_[index] = input;
+
+            if (this->identifier_)
+                this->identifier_->updateConfigValues();
+
+            return true;
         }
         else
         {
             COUT(1) << "Error: Config-value '" << this->varname_ << "' in " << this->sectionname_ << " is not a vector." << std::endl;
-        }
-        return false;
+            return false;
+        }
     }
 
Index: code/branches/core3/src/core/Functor.h
===================================================================
--- code/branches/core3/src/core/Functor.h	(revision 1719)
+++ code/branches/core3/src/core/Functor.h	(revision 1720)
@@ -280,28 +280,5 @@
 
 
-/*
-#define FUNCTOR_EVALUATE_PARAM(numparams) FUNCTOR_EVALUATE_PARAM##numparams
-#define FUNCTOR_EVALUATE_PARAM0
-#define FUNCTOR_EVALUATE_PARAM1 \
-    if (index == 0) { P1 temp = param; param = temp; }
-#define FUNCTOR_EVALUATE_PARAM2 \
-    if (index == 0) { P1 temp = param; param = temp; } \
-    else if (index == 1) { P2 temp = param; param = temp; }
-#define FUNCTOR_EVALUATE_PARAM3 \
-    if (index == 0) { P1 temp = param; param = temp; } \
-    else if (index == 1) { P2 temp = param; param = temp; } \
-    else if (index == 2) { P3 temp = param; param = temp; }
-#define FUNCTOR_EVALUATE_PARAM4 \
-    if (index == 0) { P1 temp = param; param = temp; } \
-    else if (index == 1) { P2 temp = param; param = temp; } \
-    else if (index == 2) { P3 temp = param; param = temp; } \
-    else if (index == 3) { P4 temp = param; param = temp; }
-#define FUNCTOR_EVALUATE_PARAM5 \
-    if (index == 0) { P1 temp = param; param = temp; } \
-    else if (index == 1) { P2 temp = param; param = temp; } \
-    else if (index == 2) { P3 temp = param; param = temp; } \
-    else if (index == 3) { P4 temp = param; param = temp; } \
-    else if (index == 4) { P5 temp = param; param = temp; }
-*/
+
 #define FUNCTOR_EVALUATE_PARAM(numparams) FUNCTOR_EVALUATE_PARAM##numparams
 #define FUNCTOR_EVALUATE_PARAM0
@@ -330,4 +307,5 @@
 
 
+
 #define CREATE_STATIC_FUNCTOR(returnvalue, numparams) \
     FUNCTOR_TEMPLATE(0, returnvalue, numparams) \
Index: code/branches/core3/src/util/Convert.h
===================================================================
--- code/branches/core3/src/util/Convert.h	(revision 1719)
+++ code/branches/core3/src/util/Convert.h	(revision 1720)
@@ -43,5 +43,4 @@
 #include "Debug.h"
 #include "SubString.h"
-//#include "MultiTypeMath.h"
 
 // disable annoying warning about forcing value to boolean
@@ -320,88 +319,4 @@
 
 
-////////////////
-// MULTITYPES //
-////////////////
-/*
-// convert from MultiTypePrimitive
-template <class ToType>
-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>
-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>
-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_vector4)
-            return ConvertValue(output, input.getVector4());
-        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);
-    }
-};
-*/
 
 ////////////////////
Index: code/branches/core3/src/util/MultiType.cc
===================================================================
--- code/branches/core3/src/util/MultiType.cc	(revision 1719)
+++ code/branches/core3/src/util/MultiType.cc	(revision 1720)
@@ -29,21 +29,5 @@
 #include "MultiType.h"
 #include "MultiTypeValue.h"
-/*
-int test()
-{
-    MultiType test1(10);
 
-//    test1.setValue(true);
-//    test1.setValue(10);
-//    test1.setValue<float>(10);
-
-//    orxonox::Vector3 test2;
-//    test1 = test2;
-
-    return 0;
-}
-
-int temp = test();
-*/
 void MultiType::setType(MT_Type type)
 {
Index: code/branches/core3/src/util/MultiType.h
===================================================================
--- code/branches/core3/src/util/MultiType.h	(revision 1719)
+++ code/branches/core3/src/util/MultiType.h	(revision 1720)
@@ -73,6 +73,5 @@
 {
     _UtilExport friend std::ostream& operator<<(std::ostream& outstream, const MultiType& mt);
-    template <typename T>
-    friend struct MT_Value;
+    template <typename T> friend struct MT_Value;
 
     struct _UtilExport MT_ValueBase
@@ -135,5 +134,4 @@
     public:
         inline                       MultiType()                                  : value_(0), type_(MT_null) {}
-//        template <typename V> inline MultiType(const V& value)                  : value_(0), type_(MT_null) { this->assignValue(value); }
         inline                       MultiType(const char& value)                 : value_(0), type_(MT_null) { this->assignValue(value); }
         inline                       MultiType(const unsigned char& value)        : value_(0), type_(MT_null) { this->assignValue(value); }
@@ -150,4 +148,5 @@
         inline                       MultiType(const long double& value)          : value_(0), type_(MT_null) { this->assignValue(value); }
         inline                       MultiType(const bool& value)                 : value_(0), type_(MT_null) { this->assignValue(value); }
+        inline                       MultiType(      void* const& value)          : value_(0), type_(MT_null) { this->assignValue(value); }
         inline                       MultiType(const std::string& value)          : value_(0), type_(MT_null) { this->assignValue(value); }
         inline                       MultiType(const orxonox::Vector2& value)     : value_(0), type_(MT_null) { this->assignValue(value); }
@@ -180,4 +179,5 @@
         inline void                                   setValue(const long double& value);
         inline void                                   setValue(const bool& value);
+        inline void                                   setValue(      void* const& value);
         inline void                                   setValue(const std::string& value);
         inline void                                   setValue(const orxonox::Vector2& value);
@@ -281,4 +281,5 @@
         inline void assignValue(const orxonox::Radian& value)      { if (this->value_ && this->type_ == MT_radian)      { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Radian>(value);      this->type_ = MT_radian;      } }
         inline void assignValue(const orxonox::Degree& value)      { if (this->value_ && this->type_ == MT_degree)      { this->value_->setValue(value); } else { this->changeValueContainer<orxonox::Degree>(value);      this->type_ = MT_degree;      } }
+
         template <typename T> inline void changeValueContainer(const T& value) { if (this->value_) { delete this->value_; } this->createNewValueContainer<T>(value); }
         template <typename T>        void createNewValueContainer(const T& value) { BOOST_STATIC_ASSERT(sizeof(T) == 0); }
@@ -380,31 +381,4 @@
 inline void MultiType::setValue(const char* value) { if (this->value_) { this->value_->setValue(std::string(value)); } else { this->assignValue(std::string(value)); } }
 
-/*
-
-(*) = funktion 2x:
-function(...) : bezieht sich auf aktuellen type
-function<T>(...) : bezieht sich auf type T
-
-constructor(V value) : zuweisung
-(*) operator=(V value) : zuweisung
-(*) setValue(V value) : zuweisung
-
-(*) == != > < <= >= : template
-
-(*) reset() : zurück auf 0 (bzw "")
-setType<T>() : setzt type und macht reset
-convert<T>() : setzt type und konvertiert
-
-(T) : return konvertiert
-
-isType<T>() : return bool
-getType() : return MT_Type
-getTypename() : return string
-
-toString() : return string
-(*) fromString(string value) : konvertiert string
-operator<< : toString()
-
-*/
 
 #if ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
Index: code/branches/core3/src/util/MultiTypeValue.h
===================================================================
--- code/branches/core3/src/util/MultiTypeValue.h	(revision 1719)
+++ code/branches/core3/src/util/MultiTypeValue.h	(revision 1720)
@@ -37,79 +37,9 @@
 struct MT_Value : public MultiType::MT_ValueBase
 {
-/*
-    template <class A, class B, class Btest = B>
-    class StaticConversion
-    {
-        private:
-            template <class V, bool convertable> struct Convert
-            {   static inline A convert(const V& value) { return A(); }   };
-            template <class V>                   struct Convert<V, true>
-            {   static inline A convert(const V& value) { return ((A)value); }   };
-
-            template <typename V, bool convertable> struct Compare
-            {
-                static inline bool compare_equal       (const A& value, const V& other) { return false; }
-                static inline bool compare_notequal    (const A& value, const V& other) { return true;  }
-                static inline bool compare_smaller     (const A& value, const V& other) { return false; }
-                static inline bool compare_smallerequal(const A& value, const V& other) { return false; }
-                static inline bool compare_greater     (const A& value, const V& other) { return false; }
-                static inline bool compare_greaterequal(const A& value, const V& other) { return false; }
-            };
-            template <typename V>                   struct Compare<V, true>
-            {
-                static inline bool compare_equal       (const A& value, const V& other) { return (value == other); }
-                static inline bool compare_notequal    (const A& value, const V& other) { return (value != other); }
-                static inline bool compare_smaller     (const A& value, const V& other) { return (value <  other); }
-                static inline bool compare_smallerequal(const A& value, const V& other) { return (value <= other); }
-                static inline bool compare_greater     (const A& value, const V& other) { return (value >  other); }
-                static inline bool compare_greaterequal(const A& value, const V& other) { return (value >= other); }
-            };
-
-            class Small { char dummy[1]; };
-            class Big   { char dummy[1024]; };
-            static Small Test(A);
-            static Big   Test(...);
-            static Btest MakeB();
-            enum { exists = sizeof(Test(MakeB())) == sizeof(Small) };
-
-        public:
-            static inline A    convert(const B& value)                              { return Convert<B, exists>::convert(value); }
-            static inline bool compare_equal       (const B& value, const A& other) { return Compare<B, exists>::compare_equal       (value, other); }
-            static inline bool compare_notequal    (const B& value, const A& other) { return Compare<B, exists>::compare_notequal    (value, other); }
-            static inline bool compare_smaller     (const B& value, const A& other) { return Compare<B, exists>::compare_smaller     (value, other); }
-            static inline bool compare_smallerequal(const B& value, const A& other) { return Compare<B, exists>::compare_smallerequal(value, other); }
-            static inline bool compare_greater     (const B& value, const A& other) { return Compare<B, exists>::compare_greater     (value, other); }
-            static inline bool compare_greaterequal(const B& value, const A& other) { return Compare<B, exists>::compare_greaterequal(value, other); }
-    };
-*/
     MT_Value() {}
     MT_Value(const T& value) : value_(value) {}
 
     inline MT_ValueBase* clone() const { return new MT_Value<T>(this->value_); }
-/*
-    inline void setValue(const char& value)                 { this->value_ = StaticConversion<T, char>::convert(value);                 }
-    inline void setValue(const unsigned char& value)        { this->value_ = StaticConversion<T, unsigned char>::convert(value);        }
-    inline void setValue(const short& value)                { this->value_ = StaticConversion<T, short>::convert(value);                }
-    inline void setValue(const unsigned short& value)       { this->value_ = StaticConversion<T, unsigned short>::convert(value);       }
-    inline void setValue(const int& value)                  { this->value_ = StaticConversion<T, int>::convert(value);                  }
-    inline void setValue(const unsigned int& value)         { this->value_ = StaticConversion<T, unsigned int>::convert(value);         }
-    inline void setValue(const long& value)                 { this->value_ = StaticConversion<T, long>::convert(value);                 }
-    inline void setValue(const unsigned long& value)        { this->value_ = StaticConversion<T, unsigned long>::convert(value);        }
-    inline void setValue(const long long& value)            { this->value_ = StaticConversion<T, long long>::convert(value);            }
-    inline void setValue(const unsigned long long& value)   { this->value_ = StaticConversion<T, unsigned long long>::convert(value);   }
-    inline void setValue(const float& value)                { this->value_ = StaticConversion<T, float, int>::convert(value);           }
-    inline void setValue(const double& value)               { this->value_ = StaticConversion<T, double, int>::convert(value);          }
-    inline void setValue(const long double& value)          { this->value_ = StaticConversion<T, long double, int>::convert(value);     }
-    inline void setValue(const bool& value)                 { this->value_ = StaticConversion<T, bool>::convert(value);                 }
-    inline void setValue(      void* const& value)          { this->value_ = StaticConversion<T, void*>::convert(value);                }
-    inline void setValue(const std::string& value)          { this->value_ = StaticConversion<T, std::string>::convert(value);          }
-    inline void setValue(const orxonox::Vector2& value)     { this->value_ = StaticConversion<T, orxonox::Vector2>::convert(value);     }
-    inline void setValue(const orxonox::Vector3& value)     { this->value_ = StaticConversion<T, orxonox::Vector3>::convert(value);     }
-    inline void setValue(const orxonox::Vector4& value)     { this->value_ = StaticConversion<T, orxonox::Vector4>::convert(value);     }
-    inline void setValue(const orxonox::ColourValue& value) { this->value_ = StaticConversion<T, orxonox::ColourValue>::convert(value); }
-    inline void setValue(const orxonox::Quaternion& value)  { this->value_ = StaticConversion<T, orxonox::Quaternion>::convert(value);  }
-    inline void setValue(const orxonox::Radian& value)      { this->value_ = StaticConversion<T, orxonox::Radian>::convert(value);      }
-    inline void setValue(const orxonox::Degree& value)      { this->value_ = StaticConversion<T, orxonox::Degree>::convert(value);      }
-*/
+
     inline void setValue(const char& value)                 { this->value_ = getConvertedValue<char,                 T>(value); }
     inline void setValue(const unsigned char& value)        { this->value_ = getConvertedValue<unsigned char,        T>(value); }
