Refactored Variant.

Source/Urho3D/Core/Variant.cpp

@@ -70,6 +70,8 @@ static const char* typeNames[] =
     0
 };
 
+static_assert(sizeof(typeNames) / sizeof(const char*) == MAX_VAR_TYPES + 1, "Variant type name array is out-of-date");
+
 Variant& Variant::operator =(const Variant& rhs)
 {
     SetType(rhs.GetType());
@@ -77,51 +79,51 @@ Variant& Variant::operator =(const Variant& rhs)
     switch (type_)
     {
     case VAR_STRING:
-        *(reinterpret_cast<String*>(&value_)) = *(reinterpret_cast<const String*>(&rhs.value_));
+        value_.string_ = rhs.value_.string_;
         break;
 
     case VAR_BUFFER:
-        *(reinterpret_cast<PODVector<unsigned char>*>(&value_)) = *(reinterpret_cast<const PODVector<unsigned char>*>(&rhs.value_));
+        value_.buffer_ = rhs.value_.buffer_;
         break;
 
     case VAR_RESOURCEREF:
-        *(reinterpret_cast<ResourceRef*>(&value_)) = *(reinterpret_cast<const ResourceRef*>(&rhs.value_));
+        value_.resourceRef_ = rhs.value_.resourceRef_;
         break;
 
     case VAR_RESOURCEREFLIST:
-        *(reinterpret_cast<ResourceRefList*>(&value_)) = *(reinterpret_cast<const ResourceRefList*>(&rhs.value_));
+        value_.resourceRefList_ = rhs.value_.resourceRefList_;
         break;
 
     case VAR_VARIANTVECTOR:
-        *(reinterpret_cast<VariantVector*>(&value_)) = *(reinterpret_cast<const VariantVector*>(&rhs.value_));
+        value_.variantVector_ = rhs.value_.variantVector_;
         break;
 
     case VAR_STRINGVECTOR:
-        *(reinterpret_cast<StringVector*>(&value_)) = *(reinterpret_cast<const StringVector*>(&rhs.value_));
+        value_.stringVector_ = rhs.value_.stringVector_;
         break;
 
     case VAR_VARIANTMAP:
-        *(reinterpret_cast<VariantMap*>(&value_)) = *(reinterpret_cast<const VariantMap*>(&rhs.value_));
+        value_.variantMap_ = rhs.value_.variantMap_;
         break;
 
     case VAR_PTR:
-        *(reinterpret_cast<WeakPtr<RefCounted>*>(&value_)) = *(reinterpret_cast<const WeakPtr<RefCounted>*>(&rhs.value_));
+        value_.weakPtr_ = rhs.value_.weakPtr_;
         break;
 
     case VAR_MATRIX3:
-        *(reinterpret_cast<Matrix3*>(value_.ptr_)) = *(reinterpret_cast<const Matrix3*>(rhs.value_.ptr_));
+        *value_.matrix3_ = *rhs.value_.matrix3_;
         break;
 
     case VAR_MATRIX3X4:
-        *(reinterpret_cast<Matrix3x4*>(value_.ptr_)) = *(reinterpret_cast<const Matrix3x4*>(rhs.value_.ptr_));
+        *value_.matrix3x4_ = *rhs.value_.matrix3x4_;
         break;
 
     case VAR_MATRIX4:
-        *(reinterpret_cast<Matrix4*>(value_.ptr_)) = *(reinterpret_cast<const Matrix4*>(rhs.value_.ptr_));
+        *value_.matrix4_ = *rhs.value_.matrix4_;
         break;
 
     default:
-        value_ = rhs.value_;
+        memcpy(&value_, &rhs.value_, sizeof(VariantValue));
         break;
     }
 
@@ -131,7 +133,7 @@ Variant& Variant::operator =(const Variant& rhs)
 Variant& Variant::operator =(const VectorBuffer& rhs)
 {
     SetType(VAR_BUFFER);
-    *(reinterpret_cast<PODVector<unsigned char>*>(&value_)) = rhs.GetBuffer();
+    value_.buffer_ = rhs.GetBuffer();
     return *this;
 }
 
@@ -148,7 +150,7 @@ bool Variant::operator ==(const Variant& rhs) const
         return value_.int_ == rhs.value_.int_;
 
     case VAR_INT64:
-        return *reinterpret_cast<const long long*>(&value_.int_) == *reinterpret_cast<const long long*>(&rhs.value_.int_);
+        return value_.int64_ == rhs.value_.int64_;
 
     case VAR_BOOL:
         return value_.bool_ == rhs.value_.bool_;
@@ -157,62 +159,64 @@ bool Variant::operator ==(const Variant& rhs) const
         return value_.float_ == rhs.value_.float_;
 
     case VAR_VECTOR2:
-        return *(reinterpret_cast<const Vector2*>(&value_)) == *(reinterpret_cast<const Vector2*>(&rhs.value_));
+        return value_.vector2_ == rhs.value_.vector2_;
 
     case VAR_VECTOR3:
-        return *(reinterpret_cast<const Vector3*>(&value_)) == *(reinterpret_cast<const Vector3*>(&rhs.value_));
+        return value_.vector3_ == rhs.value_.vector3_;
 
     case VAR_VECTOR4:
+        return value_.vector4_ == rhs.value_.vector4_;
+
     case VAR_QUATERNION:
+        return value_.quaterion_ == rhs.value_.quaterion_;
+
     case VAR_COLOR:
-        // Hack: use the Vector4 compare for all these classes, as they have the same memory structure
-        return *(reinterpret_cast<const Vector4*>(&value_)) == *(reinterpret_cast<const Vector4*>(&rhs.value_));
+        return value_.color_ == rhs.value_.color_;
 
     case VAR_STRING:
-        return *(reinterpret_cast<const String*>(&value_)) == *(reinterpret_cast<const String*>(&rhs.value_));
+        return value_.string_ == rhs.value_.string_;
 
     case VAR_BUFFER:
-        return *(reinterpret_cast<const PODVector<unsigned char>*>(&value_)) ==
-               *(reinterpret_cast<const PODVector<unsigned char>*>(&rhs.value_));
+        return value_.buffer_ == rhs.value_.buffer_;
 
     case VAR_RESOURCEREF:
-        return *(reinterpret_cast<const ResourceRef*>(&value_)) == *(reinterpret_cast<const ResourceRef*>(&rhs.value_));
+        return value_.resourceRef_ == rhs.value_.resourceRef_;
 
     case VAR_RESOURCEREFLIST:
-        return *(reinterpret_cast<const ResourceRefList*>(&value_)) == *(reinterpret_cast<const ResourceRefList*>(&rhs.value_));
+        return value_.resourceRefList_ == rhs.value_.resourceRefList_;
 
     case VAR_VARIANTVECTOR:
-        return *(reinterpret_cast<const VariantVector*>(&value_)) == *(reinterpret_cast<const VariantVector*>(&rhs.value_));
+        return value_.variantVector_ == rhs.value_.variantVector_;
 
     case VAR_STRINGVECTOR:
-        return *(reinterpret_cast<const StringVector*>(&value_)) == *(reinterpret_cast<const StringVector*>(&rhs.value_));
+        return value_.stringVector_ == rhs.value_.stringVector_;
 
     case VAR_VARIANTMAP:
-        return *(reinterpret_cast<const VariantMap*>(&value_)) == *(reinterpret_cast<const VariantMap*>(&rhs.value_));
+        return value_.variantMap_ == rhs.value_.variantMap_;
 
     case VAR_INTRECT:
-        return *(reinterpret_cast<const IntRect*>(&value_)) == *(reinterpret_cast<const IntRect*>(&rhs.value_));
+        return value_.intRect_ == rhs.value_.intRect_;
 
     case VAR_INTVECTOR2:
-        return *(reinterpret_cast<const IntVector2*>(&value_)) == *(reinterpret_cast<const IntVector2*>(&rhs.value_));
+        return value_.intVector2_ == rhs.value_.intVector2_;
 
     case VAR_INTVECTOR3:
-        return *(reinterpret_cast<const IntVector3*>(&value_)) == *(reinterpret_cast<const IntVector3*>(&rhs.value_));
+        return value_.intVector3_ == rhs.value_.intVector3_;
 
     case VAR_MATRIX3:
-        return *(reinterpret_cast<const Matrix3*>(value_.ptr_)) == *(reinterpret_cast<const Matrix3*>(rhs.value_.ptr_));
+        return *value_.matrix3_ == *rhs.value_.matrix3_;
 
     case VAR_MATRIX3X4:
-        return *(reinterpret_cast<const Matrix3x4*>(value_.ptr_)) == *(reinterpret_cast<const Matrix3x4*>(rhs.value_.ptr_));
+        return *value_.matrix3x4_ == *rhs.value_.matrix3x4_;
 
     case VAR_MATRIX4:
-        return *(reinterpret_cast<const Matrix4*>(value_.ptr_)) == *(reinterpret_cast<const Matrix4*>(rhs.value_.ptr_));
+        return *value_.matrix4_ == *rhs.value_.matrix4_;
 
     case VAR_DOUBLE:
-        return *(reinterpret_cast<const double*>(&value_)) == *(reinterpret_cast<const double*>(&rhs.value_));
+        return value_.double_ == rhs.value_.double_;
 
     case VAR_RECT:
-        return *(reinterpret_cast<const Rect*>(&value_)) == *(reinterpret_cast<const Rect*>(&rhs.value_));
+        return value_.rect_ == rhs.value_.rect_;
 
     default:
         return true;
@@ -222,7 +226,7 @@ bool Variant::operator ==(const Variant& rhs) const
 bool Variant::operator ==(const PODVector<unsigned char>& rhs) const
 {
     // Use strncmp() instead of PODVector<unsigned char>::operator ==()
-    const PODVector<unsigned char>& buffer = *(reinterpret_cast<const PODVector<unsigned char>*>(&value_));
+    const PODVector<unsigned char>& buffer = value_.buffer_;
     return type_ == VAR_BUFFER && buffer.Size() == rhs.Size() ?
         strncmp(reinterpret_cast<const char*>(&buffer[0]), reinterpret_cast<const char*>(&rhs[0]), buffer.Size()) == 0 :
         false;
@@ -230,7 +234,7 @@ bool Variant::operator ==(const PODVector<unsigned char>& rhs) const
 
 bool Variant::operator ==(const VectorBuffer& rhs) const
 {
-    const PODVector<unsigned char>& buffer = *(reinterpret_cast<const PODVector<unsigned char>*>(&value_));
+    const PODVector<unsigned char>& buffer = value_.buffer_;
     return type_ == VAR_BUFFER && buffer.Size() == rhs.GetSize() ?
         strncmp(reinterpret_cast<const char*>(&buffer[0]), reinterpret_cast<const char*>(rhs.GetData()), buffer.Size()) == 0 :
         false;
@@ -296,11 +300,8 @@ void Variant::FromString(VariantType type, const char* value)
         break;
 
     case VAR_BUFFER:
-    {
         SetType(VAR_BUFFER);
-        PODVector<unsigned char>& buffer = *(reinterpret_cast<PODVector<unsigned char>*>(&value_));
-        StringToBuffer(buffer, value);
-    }
+        StringToBuffer(value_.buffer_, value);
         break;
 
     case VAR_VOIDPTR:
@@ -314,12 +315,11 @@ void Variant::FromString(VariantType type, const char* value)
         if (values.Size() == 2)
         {
             SetType(VAR_RESOURCEREF);
-            ResourceRef& ref = *(reinterpret_cast<ResourceRef*>(&value_));
-            ref.type_ = values[0];
-            ref.name_ = values[1];
+            value_.resourceRef_.type_ = values[0];
+            value_.resourceRef_.name_ = values[1];
         }
-    }
         break;
+    }
 
     case VAR_RESOURCEREFLIST:
     {
@@ -327,14 +327,13 @@ void Variant::FromString(VariantType type, const char* value)
         if (values.Size() >= 1)
         {
             SetType(VAR_RESOURCEREFLIST);
-            ResourceRefList& refList = *(reinterpret_cast<ResourceRefList*>(&value_));
-            refList.type_ = values[0];
-            refList.names_.Resize(values.Size() - 1);
+            value_.resourceRefList_.type_ = values[0];
+            value_.resourceRefList_.names_.Resize(values.Size() - 1);
             for (unsigned i = 1; i < values.Size(); ++i)
-                refList.names_[i - 1] = values[i];
+                value_.resourceRefList_.names_[i - 1] = values[i];
         }
-    }
         break;
+    }
 
     case VAR_INTRECT:
         *this = ToIntRect(value);
@@ -384,7 +383,7 @@ void Variant::SetBuffer(const void* data, unsigned size)
         size = 0;
 
     SetType(VAR_BUFFER);
-    PODVector<unsigned char>& buffer = *(reinterpret_cast<PODVector<unsigned char>*>(&value_));
+    PODVector<unsigned char>& buffer = value_.buffer_;
     buffer.Resize(size);
     if (size)
         memcpy(&buffer[0], data, size);
@@ -392,7 +391,7 @@ void Variant::SetBuffer(const void* data, unsigned size)
 
 VectorBuffer Variant::GetVectorBuffer() const
 {
-    return VectorBuffer(type_ == VAR_BUFFER ? *reinterpret_cast<const PODVector<unsigned char>*>(&value_) : emptyBuffer);
+    return VectorBuffer(type_ == VAR_BUFFER ? value_.buffer_ : emptyBuffer);
 }
 
 String Variant::GetTypeName() const
@@ -408,7 +407,7 @@ String Variant::ToString() const
         return String(value_.int_);
 
     case VAR_INT64:
-        return String(*reinterpret_cast<const long long*>(&value_.int_));
+        return String(value_.int64_);
 
     case VAR_BOOL:
         return String(value_.bool_);
@@ -417,26 +416,26 @@ String Variant::ToString() const
         return String(value_.float_);
 
     case VAR_VECTOR2:
-        return (reinterpret_cast<const Vector2*>(&value_))->ToString();
+        return value_.vector2_.ToString();
 
     case VAR_VECTOR3:
-        return (reinterpret_cast<const Vector3*>(&value_))->ToString();
+        return value_.vector3_.ToString();
 
     case VAR_VECTOR4:
-        return (reinterpret_cast<const Vector4*>(&value_))->ToString();
+        return value_.vector4_.ToString();
 
     case VAR_QUATERNION:
-        return (reinterpret_cast<const Quaternion*>(&value_))->ToString();
+        return value_.quaterion_.ToString();
 
     case VAR_COLOR:
-        return (reinterpret_cast<const Color*>(&value_))->ToString();
+        return value_.color_.ToString();
 
     case VAR_STRING:
-        return *(reinterpret_cast<const String*>(&value_));
+        return value_.string_;
 
     case VAR_BUFFER:
         {
-            const PODVector<unsigned char>& buffer = *(reinterpret_cast<const PODVector<unsigned char>*>(&value_));
+            const PODVector<unsigned char>& buffer = value_.buffer_;
             String ret;
             BufferToString(ret, buffer.Begin().ptr_, buffer.Size());
             return ret;
@@ -448,28 +447,28 @@ String Variant::ToString() const
         return String(0);
 
     case VAR_INTRECT:
-        return (reinterpret_cast<const IntRect*>(&value_))->ToString();
+        return value_.intRect_.ToString();
 
     case VAR_INTVECTOR2:
-        return (reinterpret_cast<const IntVector2*>(&value_))->ToString();
+        return value_.intVector2_.ToString();
 
     case VAR_INTVECTOR3:
-        return (reinterpret_cast<const IntVector3*>(&value_))->ToString();
+        return value_.intVector3_.ToString();
 
     case VAR_MATRIX3:
-        return (reinterpret_cast<const Matrix3*>(value_.ptr_))->ToString();
+        return value_.matrix3_->ToString();
 
     case VAR_MATRIX3X4:
-        return (reinterpret_cast<const Matrix3x4*>(value_.ptr_))->ToString();
+        return value_.matrix3x4_->ToString();
 
     case VAR_MATRIX4:
-        return (reinterpret_cast<const Matrix4*>(value_.ptr_))->ToString();
+        return value_.matrix4_->ToString();
 
     case VAR_DOUBLE:
-        return String(*reinterpret_cast<const double*>(&value_));
+        return String(value_.double_);
 
     case VAR_RECT:
-        return (reinterpret_cast<const Rect*>(&value_))->ToString();
+        return value_.rect_.ToString();
 
     default:
         // VAR_RESOURCEREF, VAR_RESOURCEREFLIST, VAR_VARIANTVECTOR, VAR_STRINGVECTOR, VAR_VARIANTMAP
@@ -487,7 +486,7 @@ bool Variant::IsZero() const
         return value_.int_ == 0;
 
     case VAR_INT64:
-        return *reinterpret_cast<const long long*>(&value_.int_) == 0;
+        return value_.int64_ == 0;
 
     case VAR_BOOL:
         return value_.bool_ == false;
@@ -496,36 +495,36 @@ bool Variant::IsZero() const
         return value_.float_ == 0.0f;
 
     case VAR_VECTOR2:
-        return *reinterpret_cast<const Vector2*>(&value_) == Vector2::ZERO;
+        return value_.vector2_ == Vector2::ZERO;
 
     case VAR_VECTOR3:
-        return *reinterpret_cast<const Vector3*>(&value_) == Vector3::ZERO;
+        return value_.vector3_ == Vector3::ZERO;
 
     case VAR_VECTOR4:
-        return *reinterpret_cast<const Vector4*>(&value_) == Vector4::ZERO;
+        return value_.vector4_ == Vector4::ZERO;
 
     case VAR_QUATERNION:
-        return *reinterpret_cast<const Quaternion*>(&value_) == Quaternion::IDENTITY;
+        return value_.quaterion_ == Quaternion::IDENTITY;
 
     case VAR_COLOR:
         // WHITE is considered empty (i.e. default) color in the Color class definition
-        return *reinterpret_cast<const Color*>(&value_) == Color::WHITE;
+        return value_.color_ == Color::WHITE;
 
     case VAR_STRING:
-        return reinterpret_cast<const String*>(&value_)->Empty();
+        return value_.string_.Empty();
 
     case VAR_BUFFER:
-        return reinterpret_cast<const PODVector<unsigned char>*>(&value_)->Empty();
+        return value_.buffer_.Empty();
 
     case VAR_VOIDPTR:
-        return value_.ptr_ == 0;
+        return value_.voidPtr_ == 0;
 
     case VAR_RESOURCEREF:
-        return reinterpret_cast<const ResourceRef*>(&value_)->name_.Empty();
+        return value_.resourceRef_.name_.Empty();
 
     case VAR_RESOURCEREFLIST:
     {
-        const StringVector& names = reinterpret_cast<const ResourceRefList*>(&value_)->names_;
+        const StringVector& names = value_.resourceRefList_.names_;
         for (StringVector::ConstIterator i = names.Begin(); i != names.End(); ++i)
         {
             if (!i->Empty())
@@ -535,40 +534,40 @@ bool Variant::IsZero() const
     }
 
     case VAR_VARIANTVECTOR:
-        return reinterpret_cast<const VariantVector*>(&value_)->Empty();
+        return value_.variantVector_.Empty();
 
     case VAR_STRINGVECTOR:
-        return reinterpret_cast<const StringVector*>(&value_)->Empty();
+        return value_.stringVector_.Empty();
 
     case VAR_VARIANTMAP:
-        return reinterpret_cast<const VariantMap*>(&value_)->Empty();
+        return value_.variantMap_.Empty();
 
     case VAR_INTRECT:
-        return *reinterpret_cast<const IntRect*>(&value_) == IntRect::ZERO;
+        return value_.intRect_ == IntRect::ZERO;
 
     case VAR_INTVECTOR2:
-        return *reinterpret_cast<const IntVector2*>(&value_) == IntVector2::ZERO;
+        return value_.intVector2_ == IntVector2::ZERO;
 
     case VAR_INTVECTOR3:
-        return *reinterpret_cast<const IntVector3*>(&value_) == IntVector3::ZERO;
+        return value_.intVector3_ == IntVector3::ZERO;
 
     case VAR_PTR:
-        return *reinterpret_cast<const WeakPtr<RefCounted>*>(&value_) == (RefCounted*)0;
+        return value_.weakPtr_ == (RefCounted*)0;
 
     case VAR_MATRIX3:
-        return *reinterpret_cast<const Matrix3*>(value_.ptr_) == Matrix3::IDENTITY;
+        return *value_.matrix3_ == Matrix3::IDENTITY;
 
     case VAR_MATRIX3X4:
-        return *reinterpret_cast<const Matrix3x4*>(value_.ptr_) == Matrix3x4::IDENTITY;
+        return *value_.matrix3x4_ == Matrix3x4::IDENTITY;
 
     case VAR_MATRIX4:
-        return *reinterpret_cast<const Matrix4*>(value_.ptr_) == Matrix4::IDENTITY;
+        return *value_.matrix4_ == Matrix4::IDENTITY;
 
     case VAR_DOUBLE:
-        return *reinterpret_cast<const double*>(&value_) == 0.0;
+        return value_.double_ == 0.0;
 
     case VAR_RECT:
-        return *reinterpret_cast<const Rect*>(&value_) == Rect::ZERO;
+        return value_.rect_ == Rect::ZERO;
 
     default:
         return true;
@@ -583,47 +582,47 @@ void Variant::SetType(VariantType newType)
     switch (type_)
     {
     case VAR_STRING:
-        (reinterpret_cast<String*>(&value_))->~String();
+        value_.string_.~String();
         break;
 
     case VAR_BUFFER:
-        (reinterpret_cast<PODVector<unsigned char>*>(&value_))->~PODVector<unsigned char>();
+        value_.buffer_.~PODVector<unsigned char>();
         break;
 
     case VAR_RESOURCEREF:
-        (reinterpret_cast<ResourceRef*>(&value_))->~ResourceRef();
+        value_.resourceRef_.~ResourceRef();
         break;
 
     case VAR_RESOURCEREFLIST:
-        (reinterpret_cast<ResourceRefList*>(&value_))->~ResourceRefList();
+        value_.resourceRefList_.~ResourceRefList();
         break;
 
     case VAR_VARIANTVECTOR:
-        (reinterpret_cast<VariantVector*>(&value_))->~VariantVector();
+        value_.variantVector_.~VariantVector();
         break;
 
     case VAR_STRINGVECTOR:
-        (reinterpret_cast<StringVector*>(&value_))->~StringVector();
+        value_.stringVector_.~StringVector();
         break;
 
     case VAR_VARIANTMAP:
-        (reinterpret_cast<VariantMap*>(&value_))->~VariantMap();
+        value_.variantMap_.~VariantMap();
         break;
 
     case VAR_PTR:
-        (reinterpret_cast<WeakPtr<RefCounted>*>(&value_))->~WeakPtr<RefCounted>();
+        value_.weakPtr_.~WeakPtr<RefCounted>();
         break;
 
     case VAR_MATRIX3:
-        delete reinterpret_cast<Matrix3*>(value_.ptr_);
+        delete value_.matrix3_;
         break;
 
     case VAR_MATRIX3X4:
-        delete reinterpret_cast<Matrix3x4*>(value_.ptr_);
+        delete value_.matrix3x4_;
         break;
 
     case VAR_MATRIX4:
-        delete reinterpret_cast<Matrix4*>(value_.ptr_);
+        delete value_.matrix4_;
         break;
 
     default:
@@ -635,47 +634,47 @@ void Variant::SetType(VariantType newType)
     switch (type_)
     {
     case VAR_STRING:
-        new(reinterpret_cast<String*>(&value_)) String();
+        new(&value_.string_) String();
         break;
 
     case VAR_BUFFER:
-        new(reinterpret_cast<PODVector<unsigned char>*>(&value_)) PODVector<unsigned char>();
+        new(&value_.buffer_) PODVector<unsigned char>();
         break;
 
     case VAR_RESOURCEREF:
-        new(reinterpret_cast<ResourceRef*>(&value_)) ResourceRef();
+        new(&value_.resourceRef_) ResourceRef();
         break;
 
     case VAR_RESOURCEREFLIST:
-        new(reinterpret_cast<ResourceRefList*>(&value_)) ResourceRefList();
+        new(&value_.resourceRefList_) ResourceRefList();
         break;
 
     case VAR_VARIANTVECTOR:
-        new(reinterpret_cast<VariantVector*>(&value_)) VariantVector();
+        new(&value_.variantVector_) VariantVector();
         break;
 
     case VAR_STRINGVECTOR:
-        new(reinterpret_cast<StringVector*>(&value_)) StringVector();
+        new(&value_.stringVector_) StringVector();
         break;
 
     case VAR_VARIANTMAP:
-        new(reinterpret_cast<VariantMap*>(&value_)) VariantMap();
+        new(&value_.variantMap_) VariantMap();
         break;
 
     case VAR_PTR:
-        new(reinterpret_cast<WeakPtr<RefCounted>*>(&value_)) WeakPtr<RefCounted>();
+        new(&value_.weakPtr_) WeakPtr<RefCounted>();
         break;
 
     case VAR_MATRIX3:
-        value_.ptr_ = new Matrix3();
+        value_.matrix3_ = new Matrix3();
         break;
 
     case VAR_MATRIX3X4:
-        value_.ptr_ = new Matrix3x4();
+        value_.matrix3x4_ = new Matrix3x4();
         break;
 
     case VAR_MATRIX4:
-        value_.ptr_ = new Matrix4();
+        value_.matrix4_ = new Matrix4();
         break;
 
     default:

Source/Urho3D/LuaScript/ToluaUtils.cpp

@@ -407,9 +407,15 @@ void ToluaPushVariant(lua_State* L, const Variant* variant, const char* type)
         break;
 
     case VAR_MATRIX3:
+        tolua_pushusertype(L, variant->Get<const VariantValue*>()->matrix3_, "Matrix3");
+        break;
+
     case VAR_MATRIX3X4:
+        tolua_pushusertype(L, variant->Get<const VariantValue*>()->matrix3x4_, "Matrix3x4");
+        break;
+
     case VAR_MATRIX4:
-        tolua_pushusertype(L, variant->Get<const VariantValue*>()->ptr_, variant->GetTypeName().CString());
+        tolua_pushusertype(L, variant->Get<const VariantValue*>()->matrix4_, "Matrix4");
         break;
 
     default: