diff --git a/Source/Editor/Utilities/VariantUtils.cs b/Source/Editor/Utilities/VariantUtils.cs
index 6bebfdb5f..6ed8ce4a5 100644
--- a/Source/Editor/Utilities/VariantUtils.cs
+++ b/Source/Editor/Utilities/VariantUtils.cs
@@ -60,6 +60,10 @@ namespace FlaxEditor.Utilities
 
             Int16,
             Uint16,
+
+            Double2,
+            Double3,
+            Double4,
         }
 
         internal static VariantType ToVariantType(this Type type)
diff --git a/Source/Engine/Core/Types/Variant.cpp b/Source/Engine/Core/Types/Variant.cpp
index 46abe6cac..dac148a99 100644
--- a/Source/Engine/Core/Types/Variant.cpp
+++ b/Source/Engine/Core/Types/Variant.cpp
@@ -12,6 +12,9 @@
 #include "Engine/Core/Math/Vector2.h"
 #include "Engine/Core/Math/Vector3.h"
 #include "Engine/Core/Math/Vector4.h"
+#include "Engine/Core/Math/Double2.h"
+#include "Engine/Core/Math/Double3.h"
+#include "Engine/Core/Math/Double4.h"
 #include "Engine/Core/Math/Int2.h"
 #include "Engine/Core/Math/Int3.h"
 #include "Engine/Core/Math/Int4.h"
@@ -34,7 +37,7 @@
 
 namespace
 {
-    const char* InBuiltTypesTypeNames[37] =
+    const char* InBuiltTypesTypeNames[40] =
     {
         // @formatter:off
         "",// Null
@@ -69,11 +72,14 @@ namespace
         "System.Collections.Generic.Dictionary`2[System.Object,System.Object]",// Dictionary
         "System.Object",// ManagedObject
         "System.Type",// Typename
-        "FlaxEngine.Int2"// Int2
-        "FlaxEngine.Int3"// Int3
-        "FlaxEngine.Int4"// Int4
+        "FlaxEngine.Int2",// Int2
+        "FlaxEngine.Int3",// Int3
+        "FlaxEngine.Int4",// Int4
         "System.Int16",// Int16
         "System.UInt16",// Uint16
+        "FlaxEngine.Double2",// Double2
+        "FlaxEngine.Double3",// Double3
+        "FlaxEngine.Double4",// Double4
         // @formatter:on
     };
 }
@@ -398,7 +404,23 @@ VariantType VariantType::GetElementType() const
     case Typename:
         result = TEXT("Type");
         break;
-    case MAX:
+    case Int2:
+        result = TEXT("Int2");
+        break;
+    case Int3:
+        result = TEXT("Int3");
+        break;
+    case Int4:
+        result = TEXT("Int4");
+        break;
+    case Double2:
+        result = TEXT("Double2");
+        break;
+    case Double3:
+        result = TEXT("Double3");
+        break;
+    case Double4:
+        result = TEXT("Double4");
         break;
     default: ;
     }
@@ -417,15 +439,22 @@ FLAXENGINE_API uint32 GetHash(const VariantType& key)
     return hash;
 }
 
-static_assert(sizeof(Variant) <= 32, "Invalid Variant size!");
+static_assert(sizeof(Variant) <= 40, "Invalid Variant size!");
 static_assert(sizeof(Variant::AsData) >= sizeof(Vector2), "Invalid Variant data size!");
 static_assert(sizeof(Variant::AsData) >= sizeof(Vector3), "Invalid Variant data size!");
 static_assert(sizeof(Variant::AsData) >= sizeof(Vector4), "Invalid Variant data size!");
+static_assert(sizeof(Variant::AsData) >= sizeof(Double2), "Invalid Variant data size!");
+static_assert(sizeof(Variant::AsData) >= sizeof(Double3), "Invalid Variant data size!");
+static_assert(sizeof(Variant::AsData) >= sizeof(Int2), "Invalid Variant data size!");
+static_assert(sizeof(Variant::AsData) >= sizeof(Int3), "Invalid Variant data size!");
+static_assert(sizeof(Variant::AsData) >= sizeof(Int4), "Invalid Variant data size!");
 static_assert(sizeof(Variant::AsData) >= sizeof(Color), "Invalid Variant data size!");
 static_assert(sizeof(Variant::AsData) >= sizeof(Quaternion), "Invalid Variant data size!");
 static_assert(sizeof(Variant::AsData) >= sizeof(Rectangle), "Invalid Variant data size!");
 static_assert(sizeof(Variant::AsData) >= sizeof(Guid), "Invalid Variant data size!");
 static_assert(sizeof(Variant::AsData) >= sizeof(BoundingSphere), "Invalid Variant data size!");
+static_assert(sizeof(Variant::AsData) >= sizeof(BoundingBox), "Invalid Variant data size!");
+static_assert(sizeof(Variant::AsData) >= sizeof(Ray), "Invalid Variant data size!");
 static_assert(sizeof(Variant::AsData) >= sizeof(Array<Variant, HeapAllocation>), "Invalid Variant data size!");
 
 const Variant Variant::Zero(0.0f);
@@ -482,9 +511,7 @@ Variant::Variant(Variant&& other) noexcept
     case VariantType::Structure:
     case VariantType::Blob:
     case VariantType::String:
-    case VariantType::BoundingBox:
     case VariantType::Transform:
-    case VariantType::Ray:
     case VariantType::Matrix:
         AsBlob.Data = other.AsBlob.Data;
         AsBlob.Length = other.AsBlob.Length;
@@ -679,6 +706,26 @@ Variant::Variant(const Vector4& v)
     *(Vector4*)AsData = v;
 }
 
+Variant::Variant(const Double2& v)
+    : Type(VariantType::Double2)
+{
+    *(Double2*)AsData = v;
+}
+
+Variant::Variant(const Double3& v)
+    : Type(VariantType::Double3)
+{
+    *(Double3*)AsData = v;
+}
+
+Variant::Variant(const Double4& v)
+    : Type(VariantType::Double4)
+{
+    AsBlob.Length = sizeof(Double4);
+    AsBlob.Data = Allocator::Allocate(AsBlob.Length);
+    *(Double4*)AsBlob.Data = v;
+}
+
 Variant::Variant(const Int2& v)
     : Type(VariantType::Int2)
 {
@@ -724,9 +771,7 @@ Variant::Variant(const Rectangle& v)
 Variant::Variant(const BoundingBox& v)
     : Type(VariantType::BoundingBox)
 {
-    AsBlob.Length = sizeof(BoundingBox);
-    AsBlob.Data = Allocator::Allocate(AsBlob.Length);
-    *(BoundingBox*)AsBlob.Data = v;
+    *(BoundingBox*)AsData = v;
 }
 
 Variant::Variant(const Transform& v)
@@ -740,9 +785,7 @@ Variant::Variant(const Transform& v)
 Variant::Variant(const Ray& v)
     : Type(VariantType::Ray)
 {
-    AsBlob.Length = sizeof(Ray);
-    AsBlob.Data = Allocator::Allocate(AsBlob.Length);
-    *(Ray*)AsBlob.Data = v;
+    *(Ray*)AsData = v;
 }
 
 Variant::Variant(const Matrix& v)
@@ -882,11 +925,10 @@ Variant::~Variant()
         break;
     case VariantType::String:
     case VariantType::Blob:
-    case VariantType::BoundingBox:
     case VariantType::Transform:
-    case VariantType::Ray:
     case VariantType::Matrix:
     case VariantType::Typename:
+    case VariantType::Double4:
         Allocator::Free(AsBlob.Data);
         break;
     case VariantType::Array:
@@ -915,11 +957,10 @@ Variant& Variant::operator=(Variant&& other)
     case VariantType::String:
     case VariantType::Structure:
     case VariantType::Blob:
-    case VariantType::BoundingBox:
     case VariantType::Transform:
-    case VariantType::Ray:
     case VariantType::Matrix:
     case VariantType::Typename:
+    case VariantType::Double4:
         AsBlob.Data = other.AsBlob.Data;
         AsBlob.Length = other.AsBlob.Length;
         break;
@@ -973,11 +1014,10 @@ Variant& Variant::operator=(const Variant& other)
         break;
     case VariantType::String:
     case VariantType::Blob:
-    case VariantType::BoundingBox:
     case VariantType::Transform:
-    case VariantType::Ray:
     case VariantType::Matrix:
     case VariantType::Typename:
+    case VariantType::Double4:
         if (other.AsBlob.Data)
         {
             if (!AsBlob.Data || AsBlob.Length != other.AsBlob.Length)
@@ -1075,10 +1115,9 @@ bool Variant::operator==(const Variant& other) const
             return AsObject == other.AsObject;
         case VariantType::Structure:
         case VariantType::Blob:
-        case VariantType::BoundingBox:
         case VariantType::Transform:
-        case VariantType::Ray:
         case VariantType::Matrix:
+        case VariantType::Double4:
             return AsBlob.Length == other.AsBlob.Length && Platform::MemoryCompare(AsBlob.Data, other.AsBlob.Data, AsBlob.Length) == 0;
         case VariantType::Asset:
             return AsAsset == other.AsAsset;
@@ -1088,6 +1127,16 @@ bool Variant::operator==(const Variant& other) const
             return *(Vector3*)AsData == *(Vector3*)other.AsData;
         case VariantType::Vector4:
             return *(Vector4*)AsData == *(Vector4*)other.AsData;
+        case VariantType::Int2:
+            return *(Int2*)AsData == *(Int2*)other.AsData;
+        case VariantType::Int3:
+            return *(Int3*)AsData == *(Int3*)other.AsData;
+        case VariantType::Int4:
+            return *(Int4*)AsData == *(Int4*)other.AsData;
+        case VariantType::Double2:
+            return *(Double2*)AsData == *(Double2*)other.AsData;
+        case VariantType::Double3:
+            return *(Double3*)AsData == *(Double3*)other.AsData;
         case VariantType::Color:
             return *(Color*)AsData == *(Color*)other.AsData;
         case VariantType::Quaternion:
@@ -1096,6 +1145,10 @@ bool Variant::operator==(const Variant& other) const
             return *(Rectangle*)AsData == *(Rectangle*)other.AsData;
         case VariantType::BoundingSphere:
             return *(BoundingSphere*)AsData == *(BoundingSphere*)other.AsData;
+        case VariantType::BoundingBox:
+            return *(BoundingBox*)AsData == *(BoundingBox*)other.AsData;
+        case VariantType::Ray:
+            return *(Ray*)AsData == *(Ray*)other.AsData;
         case VariantType::Guid:
             return *(Guid*)AsData == *(Guid*)other.AsData;
         case VariantType::Array:
@@ -1266,110 +1319,17 @@ Variant::operator Char() const
 
 Variant::operator int8() const
 {
-    switch (Type.Type)
-    {
-    case VariantType::Bool:
-        return AsBool ? 1 : 0;
-    case VariantType::Int16:
-        return (int8)AsInt16;
-    case VariantType::Uint16:
-        return (int8)AsUint16;
-    case VariantType::Int:
-        return (int8)AsInt;
-    case VariantType::Uint:
-        return (int8)AsUint;
-    case VariantType::Int64:
-        return (int8)AsInt64;
-    case VariantType::Uint64:
-    case VariantType::Enum:
-        return (int8)AsUint64;
-    case VariantType::Float:
-        return (int8)AsFloat;
-    case VariantType::Double:
-        return (int8)AsDouble;
-    case VariantType::Pointer:
-        return (int8)(intptr)AsPointer;
-    case VariantType::Vector2:
-        return (int8)AsVector2().X;
-    case VariantType::Vector3:
-        return (int8)AsVector3().X;
-    case VariantType::Vector4:
-        return (int8)AsVector4().X;
-    default:
-        return 0;
-    }
+    return (int8)operator int64();
 }
 
 Variant::operator int16() const
 {
-    switch (Type.Type)
-    {
-    case VariantType::Bool:
-        return AsBool ? 1 : 0;
-    case VariantType::Int16:
-        return AsInt16;
-    case VariantType::Uint16:
-        return (int16)AsUint16;
-    case VariantType::Int:
-        return (int16)AsInt;
-    case VariantType::Uint:
-        return (int16)AsUint;
-    case VariantType::Int64:
-        return (int16)AsInt64;
-    case VariantType::Uint64:
-    case VariantType::Enum:
-        return (int16)AsUint64;
-    case VariantType::Float:
-        return (int16)AsFloat;
-    case VariantType::Double:
-        return (int16)AsDouble;
-    case VariantType::Pointer:
-        return (int16)(intptr)AsPointer;
-    case VariantType::Vector2:
-        return (int16)AsVector2().X;
-    case VariantType::Vector3:
-        return (int16)AsVector3().X;
-    case VariantType::Vector4:
-        return (int16)AsVector4().X;
-    default:
-        return 0;
-    }
+    return (int16)operator int64();
 }
 
 Variant::operator int32() const
 {
-    switch (Type.Type)
-    {
-    case VariantType::Bool:
-        return AsBool ? 1 : 0;
-    case VariantType::Int16:
-        return (int32)AsInt16;
-    case VariantType::Uint16:
-        return (int32)AsUint16;
-    case VariantType::Int:
-        return AsInt;
-    case VariantType::Uint:
-        return (int32)AsUint;
-    case VariantType::Int64:
-        return (int32)AsInt64;
-    case VariantType::Uint64:
-    case VariantType::Enum:
-        return (int32)AsUint64;
-    case VariantType::Float:
-        return (int32)AsFloat;
-    case VariantType::Double:
-        return (int32)AsDouble;
-    case VariantType::Pointer:
-        return (int32)(intptr)AsPointer;
-    case VariantType::Vector2:
-        return (int32)AsVector2().X;
-    case VariantType::Vector3:
-        return (int32)AsVector3().X;
-    case VariantType::Vector4:
-        return (int32)AsVector4().X;
-    default:
-        return 0;
-    }
+    return (int32)operator int64();
 }
 
 Variant::operator int64() const
@@ -1403,6 +1363,18 @@ Variant::operator int64() const
         return (int64)AsVector3().X;
     case VariantType::Vector4:
         return (int64)AsVector4().X;
+    case VariantType::Double2:
+        return (int64)AsDouble2().X;
+    case VariantType::Double3:
+        return (int64)AsDouble3().X;
+    case VariantType::Double4:
+        return (int64)AsDouble4().X;
+    case VariantType::Int2:
+        return (int64)AsInt2().X;
+    case VariantType::Int3:
+        return (int64)AsInt3().X;
+    case VariantType::Int4:
+        return (int64)AsInt4().X;
     default:
         return 0;
     }
@@ -1410,110 +1382,17 @@ Variant::operator int64() const
 
 Variant::operator uint8() const
 {
-    switch (Type.Type)
-    {
-    case VariantType::Bool:
-        return AsBool ? 1 : 0;
-    case VariantType::Int16:
-        return (uint8)AsInt16;
-    case VariantType::Uint16:
-        return (uint8)AsUint16;
-    case VariantType::Int:
-        return (uint8)AsInt;
-    case VariantType::Uint:
-        return (uint8)AsUint;
-    case VariantType::Int64:
-        return (uint8)AsInt64;
-    case VariantType::Uint64:
-    case VariantType::Enum:
-        return (uint8)AsUint64;
-    case VariantType::Float:
-        return (uint8)AsFloat;
-    case VariantType::Double:
-        return (uint8)AsDouble;
-    case VariantType::Pointer:
-        return (uint8)(uintptr)AsPointer;
-    case VariantType::Vector2:
-        return (uint8)AsVector2().X;
-    case VariantType::Vector3:
-        return (uint8)AsVector3().X;
-    case VariantType::Vector4:
-        return (uint8)AsVector4().X;
-    default:
-        return 0;
-    }
+    return (uint8)operator uint64();
 }
 
 Variant::operator uint16() const
 {
-    switch (Type.Type)
-    {
-    case VariantType::Bool:
-        return AsBool ? 1 : 0;
-    case VariantType::Int16:
-        return (uint16)AsInt16;
-    case VariantType::Uint16:
-        return AsUint16;
-    case VariantType::Int:
-        return (uint16)AsInt;
-    case VariantType::Uint:
-        return (uint16)AsUint;
-    case VariantType::Int64:
-        return (uint16)AsInt64;
-    case VariantType::Uint64:
-    case VariantType::Enum:
-        return (uint16)AsUint64;
-    case VariantType::Float:
-        return (uint16)AsFloat;
-    case VariantType::Double:
-        return (uint16)AsDouble;
-    case VariantType::Pointer:
-        return (uint16)(uintptr)AsPointer;
-    case VariantType::Vector2:
-        return (uint16)AsVector2().X;
-    case VariantType::Vector3:
-        return (uint16)AsVector3().X;
-    case VariantType::Vector4:
-        return (uint16)AsVector4().X;
-    default:
-        return 0;
-    }
+    return (uint16)operator uint64();
 }
 
 Variant::operator uint32() const
 {
-    switch (Type.Type)
-    {
-    case VariantType::Bool:
-        return AsBool ? 1 : 0;
-    case VariantType::Int16:
-        return (uint32)AsInt16;
-    case VariantType::Uint16:
-        return (uint32)AsUint16;
-    case VariantType::Int:
-        return (uint32)AsInt;
-    case VariantType::Uint:
-        return AsUint;
-    case VariantType::Int64:
-        return (uint32)AsInt64;
-    case VariantType::Uint64:
-    case VariantType::Enum:
-        return (uint32)AsUint64;
-    case VariantType::Float:
-        return (uint32)AsFloat;
-    case VariantType::Double:
-        return (uint32)AsDouble;
-    case VariantType::Pointer:
-        return (uint32)(uintptr)AsPointer;
-    case VariantType::Vector2:
-        return (uint32)AsVector2().X;
-    case VariantType::Vector3:
-        return (uint32)AsVector3().X;
-    case VariantType::Vector4:
-        return (uint32)AsVector4().X;
-    default:
-        return 0;
-    }
+    return (uint32)operator uint64();
 }
 
 Variant::operator uint64() const
@@ -1547,6 +1426,18 @@ Variant::operator uint64() const
         return (uint64)AsVector3().X;
     case VariantType::Vector4:
         return (uint64)AsVector4().X;
+    case VariantType::Double2:
+        return (uint64)AsDouble2().X;
+    case VariantType::Double3:
+        return (uint64)AsDouble3().X;
+    case VariantType::Double4:
+        return (uint64)AsDouble4().X;
+    case VariantType::Int2:
+        return (uint64)AsInt2().X;
+    case VariantType::Int3:
+        return (uint64)AsInt3().X;
+    case VariantType::Int4:
+        return (uint64)AsInt4().X;
     default:
         return 0;
     }
@@ -1581,6 +1472,18 @@ Variant::operator float() const
         return AsVector3().X;
     case VariantType::Vector4:
         return AsVector4().X;
+    case VariantType::Double2:
+        return (float)AsDouble2().X;
+    case VariantType::Double3:
+        return (float)AsDouble3().X;
+    case VariantType::Double4:
+        return (float)AsDouble4().X;
+    case VariantType::Int2:
+        return (float)AsInt2().X;
+    case VariantType::Int3:
+        return (float)AsInt3().X;
+    case VariantType::Int4:
+        return (float)AsInt4().X;
     default:
         return 0;
     }
@@ -1615,6 +1518,18 @@ Variant::operator double() const
         return (double)AsVector3().X;
     case VariantType::Vector4:
         return (double)AsVector4().X;
+    case VariantType::Double2:
+        return (double)AsDouble2().X;
+    case VariantType::Double3:
+        return (double)AsDouble3().X;
+    case VariantType::Double4:
+        return (double)AsDouble4().X;
+    case VariantType::Int2:
+        return (double)AsInt2().X;
+    case VariantType::Int3:
+        return (double)AsInt3().X;
+    case VariantType::Int4:
+        return (double)AsInt4().X;
     default:
         return 0;
     }
@@ -1729,6 +1644,18 @@ Variant::operator Vector2() const
     case VariantType::Vector4:
     case VariantType::Color:
         return Vector2(*(Vector4*)AsData);
+    case VariantType::Double2:
+        return Vector2(AsDouble2());
+    case VariantType::Double3:
+        return Vector2(AsDouble3());
+    case VariantType::Double4:
+        return Vector2(AsDouble4());
+    case VariantType::Int2:
+        return Vector2(AsInt2());
+    case VariantType::Int3:
+        return Vector2(AsInt3());
+    case VariantType::Int4:
+        return Vector2(AsInt4());
     case VariantType::Structure:
         if (StringUtils::Compare(Type.TypeName, Vector2::TypeInitializer.GetType().Fullname.Get()) == 0)
             return *(Vector2*)AsBlob.Data;
@@ -1769,6 +1696,18 @@ Variant::operator Vector3() const
     case VariantType::Vector4:
     case VariantType::Color:
         return Vector3(*(Vector4*)AsData);
+    case VariantType::Double2:
+        return Vector3(AsDouble2());
+    case VariantType::Double3:
+        return Vector3(AsDouble3());
+    case VariantType::Double4:
+        return Vector3(AsDouble4());
+    case VariantType::Int2:
+        return Vector3(AsInt2(), 0.0f);
+    case VariantType::Int3:
+        return Vector3(AsInt3());
+    case VariantType::Int4:
+        return Vector3(AsInt4());
     case VariantType::Structure:
         if (StringUtils::Compare(Type.TypeName, Vector3::TypeInitializer.GetType().Fullname.Get()) == 0)
             return *(Vector3*)AsBlob.Data;
@@ -1809,6 +1748,18 @@ Variant::operator Vector4() const
     case VariantType::Vector4:
     case VariantType::Color:
         return *(Vector4*)AsData;
+    case VariantType::Double2:
+        return Vector4(AsDouble2(), 0.0f, 0.0f);
+    case VariantType::Double3:
+        return Vector4(AsDouble3(), 0.0f);
+    case VariantType::Double4:
+        return Vector4(AsDouble4());
+    case VariantType::Int2:
+        return Vector4(AsInt2(), 0.0f, 0.0f);
+    case VariantType::Int3:
+        return Vector4(AsInt3(), 0.0f);
+    case VariantType::Int4:
+        return Vector4(AsInt4());
     case VariantType::Structure:
         if (StringUtils::Compare(Type.TypeName, Vector4::TypeInitializer.GetType().Fullname.Get()) == 0)
             return *(Vector4*)AsBlob.Data;
@@ -1817,96 +1768,123 @@ Variant::operator Vector4() const
     }
 }
 
-Variant::operator Int2() const
+Variant::operator Double2() const
+{
+    return Double2(operator Double3());
+}
+
+Variant::operator Double3() const
 {
     switch (Type.Type)
     {
     case VariantType::Bool:
-        return Int2((int32)(AsBool ? 1.0f : 0.0f));
+        return Double3(AsBool ? 1.0 : 0.0);
     case VariantType::Int16:
-        return Int2((int32)AsInt16);
+        return Double3((double)AsInt16);
     case VariantType::Uint16:
-        return Int2((int32)AsUint16);
+        return Double3((double)AsUint16);
     case VariantType::Int:
-        return Int2((int32)AsInt);
+        return Double3((double)AsInt);
     case VariantType::Uint:
-        return Int2((int32)AsUint);
+        return Double3((double)AsUint);
     case VariantType::Int64:
-        return Int2((int32)AsInt64);
+        return Double3((double)AsInt64);
     case VariantType::Uint64:
     case VariantType::Enum:
-        return Int2((int32)AsUint64);
+        return Double3((double)AsUint64);
     case VariantType::Float:
-        return Int2((int32)AsFloat);
+        return Double3(AsFloat);
     case VariantType::Double:
-        return Int2((int32)AsDouble);
+        return Double3(AsDouble);
     case VariantType::Pointer:
-        return Int2((int32)(intptr)AsPointer);
+        return Double3((double)(intptr)AsPointer);
     case VariantType::Vector2:
-        return Int2(*(Vector2*)AsData);
+        return Double3(*(Vector2*)AsData, 0.0);
     case VariantType::Vector3:
-        return Int2(*(Vector3*)AsData);
+        return Double3(*(Vector3*)AsData);
     case VariantType::Vector4:
-        return Int2(*(Vector4*)AsData);
-    case VariantType::Int2:
-        return Int2(*(Int2*)AsData);
-    case VariantType::Int3:
-        return Int2(*(Int3*)AsData);
-    case VariantType::Int4:
     case VariantType::Color:
-        return Int2(*(Int4*)AsData);
+        return Double3(*(Vector4*)AsData);
+    case VariantType::Double2:
+        return Double3(AsDouble2());
+    case VariantType::Double3:
+        return AsDouble3();
+    case VariantType::Double4:
+        return Double3(AsDouble4());
+    case VariantType::Int2:
+        return Double3(AsInt2(), 0.0);
+    case VariantType::Int3:
+        return Double3(AsInt3());
+    case VariantType::Int4:
+        return Double3(AsInt4());
     case VariantType::Structure:
-        if (StringUtils::Compare(Type.TypeName, Int2::TypeInitializer.GetType().Fullname.Get()) == 0)
-            return *(Int2*)AsBlob.Data;
+        if (StringUtils::Compare(Type.TypeName, Double3::TypeInitializer.GetType().Fullname.Get()) == 0)
+            return *(Double3*)AsBlob.Data;
     default:
-        return Int3::Zero;
+        return Double3::Zero;
     }
 }
 
+Variant::operator Double4() const
+{
+    switch (Type.Type)
+    {
+    case VariantType::Bool:
+        return Double4(AsBool ? 1.0 : 0.0);
+    case VariantType::Int16:
+        return Double4((double)AsInt16);
+    case VariantType::Uint16:
+        return Double4((double)AsUint16);
+    case VariantType::Int:
+        return Double4((double)AsInt);
+    case VariantType::Uint:
+        return Double4((double)AsUint);
+    case VariantType::Int64:
+        return Double4((double)AsInt64);
+    case VariantType::Uint64:
+    case VariantType::Enum:
+        return Double4((double)AsUint64);
+    case VariantType::Float:
+        return Double4(AsFloat);
+    case VariantType::Double:
+        return Double4(AsDouble);
+    case VariantType::Pointer:
+        return Double4((double)(intptr)AsPointer);
+    case VariantType::Vector2:
+        return Double4(*(Vector2*)AsData, 0.0, 0.0);
+    case VariantType::Vector3:
+        return Double4(*(Vector3*)AsData, 0.0);
+    case VariantType::Vector4:
+    case VariantType::Color:
+        return Double4(AsVector4());
+    case VariantType::Double2:
+        return Double4(AsDouble2(), 0.0, 0.0);
+    case VariantType::Double3:
+        return Double4(AsDouble3(), 0.0);
+    case VariantType::Double4:
+        return AsDouble4();
+    case VariantType::Int2:
+        return Double4(AsInt2(), 0.0, 0.0);
+    case VariantType::Int3:
+        return Double4(AsInt3(), 0.0);
+    case VariantType::Int4:
+        return Double4(AsInt4());
+    case VariantType::Structure:
+        if (StringUtils::Compare(Type.TypeName, Double4::TypeInitializer.GetType().Fullname.Get()) == 0)
+            return *(Double4*)AsBlob.Data;
+    default:
+        return Double4::Zero;
+    }
+}
+
+Variant::operator Int2() const
+{
+    return Int2(operator Int4());
+}
+
 Variant::operator Int3() const
 {
-    switch (Type.Type)
-    {
-    case VariantType::Bool:
-        return Int3((int32)(AsBool ? 1 : 0));
-    case VariantType::Int16:
-        return Int3((int32)AsInt16);
-    case VariantType::Uint16:
-        return Int3((int32)AsUint16);
-    case VariantType::Int:
-        return Int3((int32)AsInt);
-    case VariantType::Uint:
-        return Int3((int32)AsUint);
-    case VariantType::Int64:
-        return Int3((int32)AsInt64);
-    case VariantType::Uint64:
-    case VariantType::Enum:
-        return Int3((int32)AsUint64);
-    case VariantType::Float:
-        return Int3((int32)AsFloat);
-    case VariantType::Double:
-        return Int3((int32)AsDouble);
-    case VariantType::Pointer:
-        return Int3((int32)(intptr)AsPointer);
-    case VariantType::Vector2:
-        return Int3(*(Vector2*)AsData, 0);
-    case VariantType::Vector3:
-        return Int3(*(Vector3*)AsData);
-    case VariantType::Vector4:
-        return Int3(*(Vector4*)AsData);
-    case VariantType::Int2:
-        return Int3(*(Int2*)AsData, 0);
-    case VariantType::Int3:
-        return Int3(*(Int3*)AsData);
-    case VariantType::Int4:
-    case VariantType::Color:
-        return Int3(*(Int4*)AsData);
-    case VariantType::Structure:
-        if (StringUtils::Compare(Type.TypeName, Int3::TypeInitializer.GetType().Fullname.Get()) == 0)
-            return *(Int3*)AsBlob.Data;
-    default:
-        return Int3::Zero;
-    }
+    return Int3(operator Int4());
 }
 
 Variant::operator Int4() const
@@ -1939,14 +1917,20 @@ Variant::operator Int4() const
     case VariantType::Vector3:
         return Int4(*(Vector3*)AsData, 0);
     case VariantType::Vector4:
+    case VariantType::Color:
         return Int4(*(Vector4*)AsData);
     case VariantType::Int2:
         return Int4(*(Int2*)AsData, 0, 0);
     case VariantType::Int3:
         return Int4(*(Int3*)AsData, 0);
     case VariantType::Int4:
-    case VariantType::Color:
         return *(Int4*)AsData;
+    case VariantType::Double2:
+        return Int4(Vector2(AsDouble2()), 0, 0);
+    case VariantType::Double3:
+        return Int4(Vector3(AsDouble3()), 0);
+    case VariantType::Double4:
+        return Int4(Vector4(AsDouble4()));
     case VariantType::Structure:
         if (StringUtils::Compare(Type.TypeName, Int4::TypeInitializer.GetType().Fullname.Get()) == 0)
             return *(Int4*)AsBlob.Data;
@@ -2045,7 +2029,7 @@ Variant::operator BoundingBox() const
     switch (Type.Type)
     {
     case VariantType::BoundingBox:
-        return *(BoundingBox*)AsBlob.Data;
+        return *(BoundingBox*)AsData;
     case VariantType::Structure:
         if (StringUtils::Compare(Type.TypeName, BoundingBox::TypeInitializer.GetType().Fullname.Get()) == 0)
             return *(BoundingBox*)AsBlob.Data;
@@ -2087,7 +2071,7 @@ Variant::operator Ray() const
     switch (Type.Type)
     {
     case VariantType::Ray:
-        return *(Ray*)AsBlob.Data;
+        return *(Ray*)AsData;
     case VariantType::Structure:
         if (StringUtils::Compare(Type.TypeName, Ray::TypeInitializer.GetType().Fullname.Get()) == 0)
             return *(Ray*)AsBlob.Data;
@@ -2130,6 +2114,21 @@ const Vector4& Variant::AsVector4() const
     return *(const Vector4*)AsData;
 }
 
+const Double2& Variant::AsDouble2() const
+{
+    return *(const Double2*)AsData;
+}
+
+const Double3& Variant::AsDouble3() const
+{
+    return *(const Double3*)AsData;
+}
+
+const Double4& Variant::AsDouble4() const
+{
+    return *(const Double4*)AsBlob.Data;
+}
+
 const Int2& Variant::AsInt2() const
 {
     return *(const Int2*)AsData;
@@ -2155,6 +2154,41 @@ const Quaternion& Variant::AsQuaternion() const
     return *(const Quaternion*)AsData;
 }
 
+const Rectangle& Variant::AsRectangle() const
+{
+    return *(const Rectangle*)AsData;
+}
+
+const Guid& Variant::AsGuid() const
+{
+    return *(const Guid*)AsData;
+}
+
+const BoundingSphere& Variant::AsBoundingSphere() const
+{
+    return *(const BoundingSphere*)AsData;
+}
+
+const BoundingBox& Variant::AsBoundingBox() const
+{
+    return *(const BoundingBox*)AsData;
+}
+
+const Ray& Variant::AsRay() const
+{
+    return *(const Ray*)AsData;
+}
+
+const Transform& Variant::AsTransform() const
+{
+    return *(const Transform*)AsBlob.Data;
+}
+
+const Matrix& Variant::AsMatrix() const
+{
+    return *(const Matrix*)AsBlob.Data;
+}
+
 Array<Variant>& Variant::AsArray()
 {
     return *reinterpret_cast<Array<Variant, HeapAllocation>*>(AsData);
@@ -2190,11 +2224,10 @@ void Variant::SetType(const VariantType& type)
         break;
     case VariantType::String:
     case VariantType::Blob:
-    case VariantType::BoundingBox:
     case VariantType::Transform:
-    case VariantType::Ray:
     case VariantType::Matrix:
     case VariantType::Typename:
+    case VariantType::Double4:
         Allocator::Free(AsBlob.Data);
         break;
     case VariantType::Array:
@@ -2229,18 +2262,14 @@ void Variant::SetType(const VariantType& type)
     case VariantType::Asset:
         AsAsset = nullptr;
         break;
-    case VariantType::BoundingBox:
-        AsBlob.Data = Allocator::Allocate(sizeof(BoundingBox));
-        AsBlob.Length = sizeof(BoundingBox);
+    case VariantType::Double4:
+        AsBlob.Data = Allocator::Allocate(sizeof(Double4));
+        AsBlob.Length = sizeof(Double4);
         break;
     case VariantType::Transform:
         AsBlob.Data = Allocator::Allocate(sizeof(Transform));
         AsBlob.Length = sizeof(Transform);
         break;
-    case VariantType::Ray:
-        AsBlob.Data = Allocator::Allocate(sizeof(Ray));
-        AsBlob.Length = sizeof(Ray);
-        break;
     case VariantType::Matrix:
         AsBlob.Data = Allocator::Allocate(sizeof(Matrix));
         AsBlob.Length = sizeof(Matrix);
@@ -2286,11 +2315,10 @@ void Variant::SetType(VariantType&& type)
         break;
     case VariantType::String:
     case VariantType::Blob:
-    case VariantType::BoundingBox:
     case VariantType::Transform:
-    case VariantType::Ray:
     case VariantType::Matrix:
     case VariantType::Typename:
+    case VariantType::Double4:
         Allocator::Free(AsBlob.Data);
         break;
     case VariantType::Array:
@@ -2325,18 +2353,14 @@ void Variant::SetType(VariantType&& type)
     case VariantType::Asset:
         AsAsset = nullptr;
         break;
-    case VariantType::BoundingBox:
-        AsBlob.Data = Allocator::Allocate(sizeof(BoundingBox));
-        AsBlob.Length = sizeof(BoundingBox);
+    case VariantType::Double4:
+        AsBlob.Data = Allocator::Allocate(sizeof(Double4));
+        AsBlob.Length = sizeof(Double4);
         break;
     case VariantType::Transform:
         AsBlob.Data = Allocator::Allocate(sizeof(Transform));
         AsBlob.Length = sizeof(Transform);
         break;
-    case VariantType::Ray:
-        AsBlob.Data = Allocator::Allocate(sizeof(Ray));
-        AsBlob.Length = sizeof(Ray);
-        break;
     case VariantType::Matrix:
         AsBlob.Data = Allocator::Allocate(sizeof(Matrix));
         AsBlob.Length = sizeof(Matrix);
@@ -2562,6 +2586,18 @@ String Variant::ToString() const
         return (*(Vector3*)AsData).ToString();
     case VariantType::Vector4:
         return (*(Vector4*)AsData).ToString();
+    case VariantType::Double2:
+        return AsDouble2().ToString();
+    case VariantType::Double3:
+        return AsDouble3().ToString();
+    case VariantType::Double4:
+        return AsDouble4().ToString();
+    case VariantType::Int2:
+        return AsInt2().ToString();
+    case VariantType::Int3:
+        return AsInt3().ToString();
+    case VariantType::Int4:
+        return AsInt4().ToString();
     case VariantType::Color:
         return (*(Color*)AsData).ToString();
     case VariantType::Guid:
@@ -2573,11 +2609,11 @@ String Variant::ToString() const
     case VariantType::Rectangle:
         return (*(Rectangle*)AsData).ToString();
     case VariantType::BoundingBox:
-        return (*(BoundingBox*)AsBlob.Data).ToString();
+        return (*(BoundingBox*)AsData).ToString();
     case VariantType::Transform:
         return (*(Transform*)AsBlob.Data).ToString();
     case VariantType::Ray:
-        return (*(Ray*)AsBlob.Data).ToString();
+        return (*(Ray*)AsData).ToString();
     case VariantType::Matrix:
         return (*(Matrix*)AsBlob.Data).ToString();
     case VariantType::Typename:
@@ -2612,6 +2648,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Vector3:
         case VariantType::Vector4:
         case VariantType::Color:
+        case VariantType::Double2:
+        case VariantType::Double3:
+        case VariantType::Double4:
             return true;
         default:
             return false;
@@ -2631,6 +2670,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Vector3:
         case VariantType::Vector4:
         case VariantType::Color:
+        case VariantType::Double2:
+        case VariantType::Double3:
+        case VariantType::Double4:
             return true;
         default:
             return false;
@@ -2650,6 +2692,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Vector3:
         case VariantType::Vector4:
         case VariantType::Color:
+        case VariantType::Double2:
+        case VariantType::Double3:
+        case VariantType::Double4:
             return true;
         default:
             return false;
@@ -2669,6 +2714,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Vector3:
         case VariantType::Vector4:
         case VariantType::Color:
+        case VariantType::Double2:
+        case VariantType::Double3:
+        case VariantType::Double4:
             return true;
         default:
             return false;
@@ -2688,6 +2736,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Vector3:
         case VariantType::Vector4:
         case VariantType::Color:
+        case VariantType::Double2:
+        case VariantType::Double3:
+        case VariantType::Double4:
             return true;
         default:
             return false;
@@ -2707,6 +2758,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Vector3:
         case VariantType::Vector4:
         case VariantType::Color:
+        case VariantType::Double2:
+        case VariantType::Double3:
+        case VariantType::Double4:
             return true;
         default:
             return false;
@@ -2726,6 +2780,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Vector3:
         case VariantType::Vector4:
         case VariantType::Color:
+        case VariantType::Double2:
+        case VariantType::Double3:
+        case VariantType::Double4:
             return true;
         default:
             return false;
@@ -2745,6 +2802,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Vector3:
         case VariantType::Vector4:
         case VariantType::Color:
+        case VariantType::Double2:
+        case VariantType::Double3:
+        case VariantType::Double4:
             return true;
         default:
             return false;
@@ -2764,6 +2824,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Vector3:
         case VariantType::Vector4:
         case VariantType::Color:
+        case VariantType::Double2:
+        case VariantType::Double3:
+        case VariantType::Double4:
             return true;
         default:
             return false;
@@ -2782,6 +2845,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Vector3:
         case VariantType::Vector4:
         case VariantType::Color:
+        case VariantType::Double2:
+        case VariantType::Double3:
+        case VariantType::Double4:
             return true;
         default:
             return false;
@@ -2800,6 +2866,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Vector2:
         case VariantType::Vector4:
         case VariantType::Color:
+        case VariantType::Double2:
+        case VariantType::Double3:
+        case VariantType::Double4:
             return true;
         default:
             return false;
@@ -2818,6 +2887,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Vector2:
         case VariantType::Vector3:
         case VariantType::Color:
+        case VariantType::Double2:
+        case VariantType::Double3:
+        case VariantType::Double4:
             return true;
         default:
             return false;
@@ -2836,6 +2908,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Vector2:
         case VariantType::Vector3:
         case VariantType::Vector4:
+        case VariantType::Double2:
+        case VariantType::Double3:
+        case VariantType::Double4:
             return true;
         default:
             return false;
@@ -2878,6 +2953,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Vector4(v.AsBool ? 1.0f : 0.0f));
         case VariantType::Color:
             return Variant(Color(v.AsBool ? 1.0f : 0.0f));
+        case VariantType::Double2:
+            return Variant(Double2(v.AsBool ? 1.0 : 0.0));
+        case VariantType::Double3:
+            return Variant(Double3(v.AsBool ? 1.0 : 0.0));
+        case VariantType::Double4:
+            return Variant(Double4(v.AsBool ? 1.0 : 0.0));
         default: ;
         }
         break;
@@ -2908,6 +2989,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Vector4((float)v.AsInt16));
         case VariantType::Color:
             return Variant(Color((float)v.AsInt16));
+        case VariantType::Double2:
+            return Variant(Double2((double)v.AsInt16));
+        case VariantType::Double3:
+            return Variant(Double3((double)v.AsInt16));
+        case VariantType::Double4:
+            return Variant(Double4((double)v.AsInt16));
         default: ;
         }
         break;
@@ -2968,6 +3055,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Vector4((float)v.AsUint16));
         case VariantType::Color:
             return Variant(Color((float)v.AsUint16));
+        case VariantType::Double2:
+            return Variant(Double2((double)v.AsUint16));
+        case VariantType::Double3:
+            return Variant(Double3((double)v.AsUint16));
+        case VariantType::Double4:
+            return Variant(Double4((double)v.AsUint16));
         default: ;
         }
         break;
@@ -2998,6 +3091,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Vector4((float)v.AsUint));
         case VariantType::Color:
             return Variant(Color((float)v.AsUint));
+        case VariantType::Double2:
+            return Variant(Double2((double)v.AsUint));
+        case VariantType::Double3:
+            return Variant(Double3((double)v.AsUint));
+        case VariantType::Double4:
+            return Variant(Double4((double)v.AsUint));
         default: ;
         }
         break;
@@ -3028,6 +3127,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Vector4((float)v.AsInt64));
         case VariantType::Color:
             return Variant(Color((float)v.AsInt64));
+        case VariantType::Double2:
+            return Variant(Double2((double)v.AsInt64));
+        case VariantType::Double3:
+            return Variant(Double3((double)v.AsInt64));
+        case VariantType::Double4:
+            return Variant(Double4((double)v.AsInt64));
         default: ;
         }
         break;
@@ -3058,6 +3163,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Vector4((float)v.AsInt));
         case VariantType::Color:
             return Variant(Color((float)v.AsInt));
+        case VariantType::Double2:
+            return Variant(Double2((double)v.AsInt));
+        case VariantType::Double3:
+            return Variant(Double3((double)v.AsInt));
+        case VariantType::Double4:
+            return Variant(Double4((double)v.AsInt));
         default: ;
         }
         break;
@@ -3088,6 +3199,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Vector4(v.AsFloat));
         case VariantType::Color:
             return Variant(Color(v.AsFloat));
+        case VariantType::Double2:
+            return Variant(Double2(v.AsFloat));
+        case VariantType::Double3:
+            return Variant(Double3(v.AsFloat));
+        case VariantType::Double4:
+            return Variant(Double4(v.AsFloat));
         default: ;
         }
         break;
@@ -3118,6 +3235,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Vector4((float)v.AsDouble));
         case VariantType::Color:
             return Variant(Color((float)v.AsDouble));
+        case VariantType::Double2:
+            return Variant(Double2(v.AsDouble));
+        case VariantType::Double3:
+            return Variant(Double3(v.AsDouble));
+        case VariantType::Double4:
+            return Variant(Double4(v.AsDouble));
         default: ;
         }
         break;
@@ -3148,6 +3271,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Vector4(*(Vector2*)v.AsData, 0.0f, 0.0f));
         case VariantType::Color:
             return Variant(Color(((Vector2*)v.AsData)->X, ((Vector2*)v.AsData)->Y, 0.0f, 0.0f));
+        case VariantType::Double2:
+            return Variant(Double2(*(Vector2*)v.AsData));
+        case VariantType::Double3:
+            return Variant(Double3(*(Vector2*)v.AsData, 0.0));
+        case VariantType::Double4:
+            return Variant(Double4(*(Vector2*)v.AsData, 0.0, 0.0));
         default: ;
         }
         break;
@@ -3178,6 +3307,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Vector4(*(Vector3*)v.AsData, 0.0f));
         case VariantType::Color:
             return Variant(Color(((Vector3*)v.AsData)->X, ((Vector3*)v.AsData)->Y, ((Vector3*)v.AsData)->Z, 0.0f));
+        case VariantType::Double2:
+            return Variant(Double2(*(Vector3*)v.AsData));
+        case VariantType::Double3:
+            return Variant(Double3(*(Vector3*)v.AsData));
+        case VariantType::Double4:
+            return Variant(Double4(*(Vector3*)v.AsData, 0.0));
         default: ;
         }
         break;
@@ -3208,6 +3343,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Vector3(*(Vector4*)v.AsData));
         case VariantType::Color:
             return Variant(*(Vector4*)v.AsData);
+        case VariantType::Double2:
+            return Variant(Double2(*(Vector4*)v.AsData));
+        case VariantType::Double3:
+            return Variant(Double3(*(Vector4*)v.AsData));
+        case VariantType::Double4:
+            return Variant(Double4(*(Vector4*)v.AsData));
         default: ;
         }
         break;
@@ -3238,6 +3379,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Vector3(*(Color*)v.AsData));
         case VariantType::Vector4:
             return Variant(*(Color*)v.AsData);
+        case VariantType::Double2:
+            return Variant(Double2(*(Color*)v.AsData));
+        case VariantType::Double3:
+            return Variant(Double3(*(Color*)v.AsData));
+        case VariantType::Double4:
+            return Variant(Double4(*(Color*)v.AsData));
         default: ;
         }
         break;
@@ -3269,6 +3416,12 @@ bool Variant::NearEqual(const Variant& a, const Variant& b, float epsilon)
         return Vector3::NearEqual(*(Vector3*)a.AsData, *(Vector3*)b.AsData, epsilon);
     case VariantType::Vector4:
         return Vector4::NearEqual(*(Vector4*)a.AsData, *(Vector4*)b.AsData, epsilon);
+    case VariantType::Double2:
+        return Double2::NearEqual(*(Double2*)a.AsData, *(Double2*)b.AsData, epsilon);
+    case VariantType::Double3:
+        return Double3::NearEqual(*(Double3*)a.AsData, *(Double3*)b.AsData, epsilon);
+    case VariantType::Double4:
+        return Double4::NearEqual(*(Double4*)a.AsBlob.Data, *(Double4*)b.AsBlob.Data, epsilon);
     case VariantType::Color:
         return Color::NearEqual(*(Color*)a.AsData, *(Color*)b.AsData, epsilon);
     case VariantType::BoundingSphere:
@@ -3278,11 +3431,11 @@ bool Variant::NearEqual(const Variant& a, const Variant& b, float epsilon)
     case VariantType::Rectangle:
         return Rectangle::NearEqual(*(Rectangle*)a.AsData, *(Rectangle*)b.AsData, epsilon);
     case VariantType::BoundingBox:
-        return BoundingBox::NearEqual(*(BoundingBox*)a.AsBlob.Data, *(BoundingBox*)b.AsBlob.Data, epsilon);
+        return BoundingBox::NearEqual(*(BoundingBox*)a.AsData, *(BoundingBox*)b.AsData, epsilon);
     case VariantType::Transform:
         return Transform::NearEqual(*(Transform*)a.AsBlob.Data, *(Transform*)b.AsBlob.Data, epsilon);
     case VariantType::Ray:
-        return Ray::NearEqual(*(Ray*)a.AsBlob.Data, *(Ray*)b.AsBlob.Data, epsilon);
+        return Ray::NearEqual(*(Ray*)a.AsData, *(Ray*)b.AsData, epsilon);
     default:
         return a == b;
     }
@@ -3316,6 +3469,12 @@ Variant Variant::Lerp(const Variant& a, const Variant& b, float alpha)
         return Vector3::Lerp(*(Vector3*)a.AsData, *(Vector3*)b.AsData, alpha);
     case VariantType::Vector4:
         return Vector4::Lerp(*(Vector4*)a.AsData, *(Vector4*)b.AsData, alpha);
+    case VariantType::Double2:
+        return Double2::Lerp(*(Double2*)a.AsData, *(Double2*)b.AsData, alpha);
+    case VariantType::Double3:
+        return Double3::Lerp(*(Double3*)a.AsData, *(Double3*)b.AsData, alpha);
+    case VariantType::Double4:
+        return Double4::Lerp(*(Double4*)a.AsBlob.Data, *(Double4*)b.AsBlob.Data, alpha);
     case VariantType::Color:
         return Color::Lerp(*(Color*)a.AsData, *(Color*)b.AsData, alpha);
     case VariantType::Quaternion:
@@ -3327,9 +3486,9 @@ Variant Variant::Lerp(const Variant& a, const Variant& b, float alpha)
     case VariantType::Transform:
         return Variant(Transform::Lerp(*(Transform*)a.AsBlob.Data, *(Transform*)b.AsBlob.Data, alpha));
     case VariantType::BoundingBox:
-        return Variant(BoundingBox(Vector3::Lerp((*(BoundingBox*)a.AsBlob.Data).Minimum, (*(BoundingBox*)b.AsBlob.Data).Minimum, alpha), Vector3::Lerp((*(BoundingBox*)a.AsBlob.Data).Maximum, (*(BoundingBox*)b.AsBlob.Data).Maximum, alpha)));
+        return Variant(BoundingBox(Vector3::Lerp((*(BoundingBox*)a.AsData).Minimum, (*(BoundingBox*)b.AsData).Minimum, alpha), Vector3::Lerp((*(BoundingBox*)a.AsData).Maximum, (*(BoundingBox*)b.AsData).Maximum, alpha)));
     case VariantType::Ray:
-        return Variant(Ray(Vector3::Lerp((*(Ray*)a.AsBlob.Data).Position, (*(Ray*)b.AsBlob.Data).Position, alpha), Vector3::Normalize(Vector3::Lerp((*(Ray*)a.AsBlob.Data).Direction, (*(Ray*)b.AsBlob.Data).Direction, alpha))));
+        return Variant(Ray(Vector3::Lerp((*(Ray*)a.AsData).Position, (*(Ray*)b.AsData).Position, alpha), Vector3::Normalize(Vector3::Lerp((*(Ray*)a.AsData).Direction, (*(Ray*)b.AsData).Direction, alpha))));
     default:
         return a;
     }
diff --git a/Source/Engine/Core/Types/Variant.h b/Source/Engine/Core/Types/Variant.h
index 95722b026..4697d04bb 100644
--- a/Source/Engine/Core/Types/Variant.h
+++ b/Source/Engine/Core/Types/Variant.h
@@ -61,6 +61,10 @@ API_STRUCT(InBuild) struct FLAXENGINE_API VariantType
         Int16,
         Uint16,
 
+        Double2,
+        Double3,
+        Double4,
+
         MAX
     };
 
@@ -162,7 +166,7 @@ API_STRUCT(InBuild) struct FLAXENGINE_API Variant
 
         Dictionary<Variant, Variant, HeapAllocation>* AsDictionary;
 
-        byte AsData[16];
+        byte AsData[24];
     };
 
 public:
@@ -215,6 +219,9 @@ public:
     Variant(const Vector2& v);
     Variant(const Vector3& v);
     Variant(const Vector4& v);
+    Variant(const Double2& v);
+    Variant(const Double3& v);
+    Variant(const Double4& v);
     Variant(const Int2& v);
     Variant(const Int3& v);
     Variant(const Int4& v);
@@ -285,6 +292,9 @@ public:
     explicit operator Vector2() const;
     explicit operator Vector3() const;
     explicit operator Vector4() const;
+    explicit operator Double2() const;
+    explicit operator Double3() const;
+    explicit operator Double4() const;
     explicit operator Int2() const;
     explicit operator Int3() const;
     explicit operator Int4() const;
@@ -302,11 +312,21 @@ public:
     Vector3& AsVector3();
     const Vector3& AsVector3() const;
     const Vector4& AsVector4() const;
+    const Double2& AsDouble2() const;
+    const Double3& AsDouble3() const;
+    const Double4& AsDouble4() const;
     const Int2& AsInt2() const;
     const Int3& AsInt3() const;
     const Int4& AsInt4() const;
     const Color& AsColor() const;
     const Quaternion& AsQuaternion() const;
+    const Rectangle& AsRectangle() const;
+    const Guid& AsGuid() const;
+    const BoundingSphere& AsBoundingSphere() const;
+    const BoundingBox& AsBoundingBox() const;
+    const Ray& AsRay() const;
+    const Transform& AsTransform() const;
+    const Matrix& AsMatrix() const;
     Array<Variant, HeapAllocation>& AsArray();
     const Array<Variant, HeapAllocation>& AsArray() const;
 
diff --git a/Source/Engine/Scripting/BinaryModule.cpp b/Source/Engine/Scripting/BinaryModule.cpp
index 206019902..4499374ce 100644
--- a/Source/Engine/Scripting/BinaryModule.cpp
+++ b/Source/Engine/Scripting/BinaryModule.cpp
@@ -53,6 +53,16 @@ const ScriptingType& ScriptingTypeHandle::GetType() const
     return Module->Types[TypeIndex];
 }
 
+#if USE_MONO
+
+MonoClass* ScriptingTypeHandle::GetMonoClass() const
+{
+    ASSERT_LOW_LAYER(Module && Module->Types[TypeIndex].ManagedClass);
+    return Module->Types[TypeIndex].ManagedClass->GetNative();
+}
+
+#endif
+
 bool ScriptingTypeHandle::IsSubclassOf(ScriptingTypeHandle c) const
 {
     auto type = *this;
diff --git a/Source/Engine/Scripting/ManagedCLR/MUtils.cpp b/Source/Engine/Scripting/ManagedCLR/MUtils.cpp
index a09d45836..31e4f0d5a 100644
--- a/Source/Engine/Scripting/ManagedCLR/MUtils.cpp
+++ b/Source/Engine/Scripting/ManagedCLR/MUtils.cpp
@@ -12,6 +12,12 @@
 #include "Engine/Core/Math/Vector2.h"
 #include "Engine/Core/Math/Vector3.h"
 #include "Engine/Core/Math/Vector4.h"
+#include "Engine/Core/Math/Double2.h"
+#include "Engine/Core/Math/Double3.h"
+#include "Engine/Core/Math/Double4.h"
+#include "Engine/Core/Math/Int2.h"
+#include "Engine/Core/Math/Int3.h"
+#include "Engine/Core/Math/Int4.h"
 #include "Engine/Core/Math/Quaternion.h"
 #include "Engine/Core/Math/Matrix.h"
 #include "Engine/Core/Math/Transform.h"
@@ -236,6 +242,18 @@ VariantType MUtils::UnboxVariantType(MonoType* monoType)
             return VariantType(VariantType::Vector3);
         if (klass == stdTypes.Vector4Class->GetNative())
             return VariantType(VariantType::Vector4);
+        if (klass == Int2::TypeInitializer.GetMonoClass())
+            return VariantType(VariantType::Int2);
+        if (klass == Int3::TypeInitializer.GetMonoClass())
+            return VariantType(VariantType::Int3);
+        if (klass == Int4::TypeInitializer.GetMonoClass())
+            return VariantType(VariantType::Int4);
+        if (klass == Double2::TypeInitializer.GetMonoClass())
+            return VariantType(VariantType::Double2);
+        if (klass == Double3::TypeInitializer.GetMonoClass())
+            return VariantType(VariantType::Double3);
+        if (klass == Double4::TypeInitializer.GetMonoClass())
+            return VariantType(VariantType::Double4);
         if (klass == stdTypes.ColorClass->GetNative())
             return VariantType(VariantType::Color);
         if (klass == stdTypes.BoundingBoxClass->GetNative())
@@ -359,6 +377,18 @@ Variant MUtils::UnboxVariant(MonoObject* value)
             return *static_cast<Vector3*>(unboxed);
         if (klass == stdTypes.Vector4Class->GetNative())
             return *static_cast<Vector4*>(unboxed);
+        if (klass == Int2::TypeInitializer.GetType().ManagedClass->GetNative())
+            return *static_cast<Int2*>(unboxed);
+        if (klass == Int3::TypeInitializer.GetType().ManagedClass->GetNative())
+            return *static_cast<Int3*>(unboxed);
+        if (klass == Int4::TypeInitializer.GetType().ManagedClass->GetNative())
+            return *static_cast<Int4*>(unboxed);
+        if (klass == Double2::TypeInitializer.GetType().ManagedClass->GetNative())
+            return *static_cast<Double2*>(unboxed);
+        if (klass == Double3::TypeInitializer.GetType().ManagedClass->GetNative())
+            return *static_cast<Double3*>(unboxed);
+        if (klass == Double4::TypeInitializer.GetType().ManagedClass->GetNative())
+            return *static_cast<Double4*>(unboxed);
         if (klass == stdTypes.ColorClass->GetNative())
             return *static_cast<Color*>(unboxed);
         if (klass == stdTypes.BoundingBoxClass->GetNative())
@@ -421,6 +451,8 @@ Variant MUtils::UnboxVariant(MonoObject* value)
             case VariantType::Color:
             case VariantType::Guid:
             case VariantType::BoundingSphere:
+            case VariantType::BoundingBox:
+            case VariantType::Ray:
             case VariantType::Quaternion:
             case VariantType::Rectangle:
             case VariantType::Int2:
@@ -428,6 +460,8 @@ Variant MUtils::UnboxVariant(MonoObject* value)
             case VariantType::Int4:
             case VariantType::Int16:
             case VariantType::Uint16:
+            case VariantType::Double2:
+            case VariantType::Double3:
                 // Optimized unboxing of raw data type
                 for (int32 i = 0; i < array.Count(); i++)
                 {
@@ -436,10 +470,9 @@ Variant MUtils::UnboxVariant(MonoObject* value)
                     Platform::MemoryCopy(&a.AsData, mono_array_addr_with_size((MonoArray*)value, elementSize, i), elementSize);
                 }
                 break;
-            case VariantType::BoundingBox:
             case VariantType::Transform:
-            case VariantType::Ray:
             case VariantType::Matrix:
+            case VariantType::Double4:
                 // Optimized unboxing of raw data type
                 for (int32 i = 0; i < array.Count(); i++)
                 {
@@ -579,6 +612,12 @@ MonoObject* MUtils::BoxVariant(const Variant& value)
         return mono_value_box(mono_domain_get(), stdTypes.Vector3Class->GetNative(), (void*)&value.AsData);
     case VariantType::Vector4:
         return mono_value_box(mono_domain_get(), stdTypes.Vector4Class->GetNative(), (void*)&value.AsData);
+    case VariantType::Double2:
+        return mono_value_box(mono_domain_get(), Double2::TypeInitializer.GetMonoClass(), (void*)&value.AsData);
+    case VariantType::Double3:
+        return mono_value_box(mono_domain_get(), Double3::TypeInitializer.GetMonoClass(), (void*)&value.AsData);
+    case VariantType::Double4:
+        return mono_value_box(mono_domain_get(), Double4::TypeInitializer.GetMonoClass(), value.AsBlob.Data);
     case VariantType::Color:
         return mono_value_box(mono_domain_get(), stdTypes.ColorClass->GetNative(), (void*)&value.AsData);
     case VariantType::Guid:
@@ -594,9 +633,9 @@ MonoObject* MUtils::BoxVariant(const Variant& value)
     case VariantType::Pointer:
         return mono_value_box(mono_domain_get(), mono_get_intptr_class(), (void*)&value.AsPointer);
     case VariantType::Ray:
-        return mono_value_box(mono_domain_get(), stdTypes.RayClass->GetNative(), value.AsBlob.Data);
+        return mono_value_box(mono_domain_get(), stdTypes.RayClass->GetNative(), (void*)&value.AsData);
     case VariantType::BoundingBox:
-        return mono_value_box(mono_domain_get(), stdTypes.BoundingBoxClass->GetNative(), value.AsBlob.Data);
+        return mono_value_box(mono_domain_get(), stdTypes.BoundingBoxClass->GetNative(), (void*)&value.AsData);
     case VariantType::Transform:
         return mono_value_box(mono_domain_get(), stdTypes.TransformClass->GetNative(), value.AsBlob.Data);
     case VariantType::Matrix:
@@ -656,21 +695,24 @@ MonoObject* MUtils::BoxVariant(const Variant& value)
                 case VariantType::Color:
                 case VariantType::Guid:
                 case VariantType::BoundingSphere:
+                case VariantType::BoundingBox:
                 case VariantType::Quaternion:
+                case VariantType::Ray:
                 case VariantType::Rectangle:
                 case VariantType::Int2:
                 case VariantType::Int3:
                 case VariantType::Int4:
                 case VariantType::Int16:
                 case VariantType::Uint16:
+                case VariantType::Double2:
+                case VariantType::Double3:
                     // Optimized boxing of raw data type
                     for (int32 i = 0; i < array.Count(); i++)
                         Platform::MemoryCopy(mono_array_addr_with_size(managed, elementSize, i), &array[i].AsData, elementSize);
                     break;
-                case VariantType::BoundingBox:
                 case VariantType::Transform:
-                case VariantType::Ray:
                 case VariantType::Matrix:
+                case VariantType::Double4:
                     // Optimized boxing of raw data type
                     for (int32 i = 0; i < array.Count(); i++)
                         Platform::MemoryCopy(mono_array_addr_with_size(managed, elementSize, i), array[i].AsBlob.Data, elementSize);
@@ -888,6 +930,12 @@ MonoClass* MUtils::GetClass(const VariantType& value)
         return stdTypes.Vector3Class->GetNative();
     case VariantType::Vector4:
         return stdTypes.Vector4Class->GetNative();
+    case VariantType::Double2:
+        return Double2::TypeInitializer.GetMonoClass();
+    case VariantType::Double3:
+        return Double3::TypeInitializer.GetMonoClass();
+    case VariantType::Double4:
+        return Double4::TypeInitializer.GetMonoClass();
     case VariantType::Color:
         return stdTypes.ColorClass->GetNative();
     case VariantType::Guid:
@@ -972,6 +1020,12 @@ MonoClass* MUtils::GetClass(const Variant& value)
         return stdTypes.Vector3Class->GetNative();
     case VariantType::Vector4:
         return stdTypes.Vector4Class->GetNative();
+    case VariantType::Double2:
+        return Double2::TypeInitializer.GetMonoClass();
+    case VariantType::Double3:
+        return Double3::TypeInitializer.GetMonoClass();
+    case VariantType::Double4:
+        return Double4::TypeInitializer.GetMonoClass();
     case VariantType::Color:
         return stdTypes.ColorClass->GetNative();
     case VariantType::Guid:
@@ -1096,33 +1150,36 @@ void* MUtils::VariantToManagedArgPtr(Variant& value, const MType& type, bool& fa
             return &value.AsUint64;
         }
         const auto stdTypes = StdTypesContainer::Instance();
-#define CASE_IN_BUILD_TYPE(type) \
-    if (klass == stdTypes->type##Class->GetNative()) \
-    { \
-        if (value.Type.Type != VariantType::type) \
-            value = (type)value; \
-        return value.AsData; \
-    }
-        CASE_IN_BUILD_TYPE(Vector2);
-        CASE_IN_BUILD_TYPE(Vector3);
-        CASE_IN_BUILD_TYPE(Vector4);
-        CASE_IN_BUILD_TYPE(Color);
-        CASE_IN_BUILD_TYPE(Quaternion);
-        CASE_IN_BUILD_TYPE(Guid);
-        CASE_IN_BUILD_TYPE(Rectangle);
-        CASE_IN_BUILD_TYPE(BoundingSphere);
-#undef CASE_IN_BUILD_TYPE
-#define CASE_IN_BUILD_TYPE(type) \
+#define CASE_IN_BUILD_TYPE(type, access) \
     if (klass == stdTypes->type##Class->GetNative()) \
     { \
         if (value.Type.Type != VariantType::type) \
             value = Variant((type)value); \
-        return value.AsBlob.Data; \
+        return value.access; \
     }
-        CASE_IN_BUILD_TYPE(Matrix);
-        CASE_IN_BUILD_TYPE(BoundingBox);
-        CASE_IN_BUILD_TYPE(Transform);
-        CASE_IN_BUILD_TYPE(Ray);
+        CASE_IN_BUILD_TYPE(Vector2, AsData);
+        CASE_IN_BUILD_TYPE(Vector3, AsData);
+        CASE_IN_BUILD_TYPE(Vector4, AsData);
+        CASE_IN_BUILD_TYPE(Color, AsData);
+        CASE_IN_BUILD_TYPE(Quaternion, AsData);
+        CASE_IN_BUILD_TYPE(Guid, AsData);
+        CASE_IN_BUILD_TYPE(Ray, AsData);
+        CASE_IN_BUILD_TYPE(Rectangle, AsData);
+        CASE_IN_BUILD_TYPE(BoundingSphere, AsData);
+        CASE_IN_BUILD_TYPE(BoundingBox, AsData);
+        CASE_IN_BUILD_TYPE(Matrix, AsBlob.Data);
+        CASE_IN_BUILD_TYPE(Transform, AsBlob.Data);
+#undef CASE_IN_BUILD_TYPE
+#define CASE_IN_BUILD_TYPE(type, access) \
+    if (klass == type::TypeInitializer.GetMonoClass()) \
+    { \
+        if (value.Type.Type != VariantType::type) \
+            value = Variant((type)value); \
+        return value.access; \
+    }
+        CASE_IN_BUILD_TYPE(Double2, AsData);
+        CASE_IN_BUILD_TYPE(Double3, AsData);
+        CASE_IN_BUILD_TYPE(Double4, AsBlob.Data);
 #undef CASE_IN_BUILD_TYPE
         if (mono_class_is_valuetype(klass))
         {
diff --git a/Source/Engine/Scripting/ScriptingType.h b/Source/Engine/Scripting/ScriptingType.h
index 9d10849d6..1e674cbf2 100644
--- a/Source/Engine/Scripting/ScriptingType.h
+++ b/Source/Engine/Scripting/ScriptingType.h
@@ -65,6 +65,9 @@ struct FLAXENGINE_API ScriptingTypeHandle
     String ToString(bool withAssembly = false) const;
 
     const ScriptingType& GetType() const;
+#if USE_MONO
+    MonoClass* GetMonoClass() const;
+#endif
     bool IsSubclassOf(ScriptingTypeHandle c) const;
     bool IsAssignableFrom(ScriptingTypeHandle c) const;
 
diff --git a/Source/Engine/Serialization/Serialization.cpp b/Source/Engine/Serialization/Serialization.cpp
index b8070b14a..426760350 100644
--- a/Source/Engine/Serialization/Serialization.cpp
+++ b/Source/Engine/Serialization/Serialization.cpp
@@ -162,44 +162,53 @@ void Serialization::Serialize(ISerializable::SerializeStream& stream, const Vari
     case VariantType::Vector4:
         stream.Vector4(*(Vector4*)v.AsData);
         break;
+    case VariantType::Double2:
+        stream.Double2(v.AsDouble2());
+        break;
+    case VariantType::Double3:
+        stream.Double3(v.AsDouble3());
+        break;
+    case VariantType::Double4:
+        stream.Double4(v.AsDouble4());
+        break;
     case VariantType::Int2:
-        stream.Int2(*(Int2*)v.AsData);
+        stream.Int2(v.AsInt2());
         break;
     case VariantType::Int3:
-        stream.Int3(*(Int3*)v.AsData);
+        stream.Int3(v.AsInt3());
         break;
     case VariantType::Int4:
-        stream.Int4(*(Int4*)v.AsData);
+        stream.Int4(v.AsInt4());
         break;
     case VariantType::Color:
-        stream.Color(*(Color*)v.AsData);
+        stream.Color(v.AsColor());
         break;
     case VariantType::Guid:
-        stream.Guid(*(Guid*)v.AsData);
+        stream.Guid(v.AsGuid());
         break;
     case VariantType::BoundingSphere:
-        stream.BoundingSphere(*(BoundingSphere*)v.AsData);
+        stream.BoundingSphere(v.AsBoundingSphere());
         break;
     case VariantType::Quaternion:
-        stream.Quaternion(*(Quaternion*)v.AsData);
+        stream.Quaternion(v.AsQuaternion());
         break;
     case VariantType::Rectangle:
-        stream.Rectangle(*(Rectangle*)v.AsData);
+        stream.Rectangle(v.AsRectangle());
         break;
     case VariantType::BoundingBox:
-        stream.BoundingBox(*(BoundingBox*)v.AsBlob.Data);
+        stream.BoundingBox(v.AsBoundingBox());
         break;
     case VariantType::Transform:
-        stream.Transform(*(Transform*)v.AsBlob.Data);
+        stream.Transform(v.AsTransform());
         break;
     case VariantType::Ray:
-        stream.Ray(*(Ray*)v.AsBlob.Data);
+        stream.Ray(v.AsRay());
         break;
     case VariantType::Matrix:
-        stream.Matrix(*(Matrix*)v.AsBlob.Data);
+        stream.Matrix(v.AsMatrix());
         break;
     case VariantType::Array:
-        Serialize(stream, *(Array<Variant, HeapAllocation>*)v.AsData, nullptr);
+        Serialize(stream, v.AsArray(), nullptr);
         break;
     case VariantType::Dictionary:
         Serialize(stream, *v.AsDictionary, nullptr);
@@ -304,6 +313,15 @@ void Serialization::Deserialize(ISerializable::DeserializeStream& stream, Varian
     case VariantType::Vector4:
         Deserialize(value, *(Vector4*)v.AsData, modifier);
         break;
+    case VariantType::Double2:
+        Deserialize(value, *(Double2*)v.AsData, modifier);
+        break;
+    case VariantType::Double3:
+        Deserialize(value, *(Double3*)v.AsData, modifier);
+        break;
+    case VariantType::Double4:
+        Deserialize(value, *(Double4*)v.AsBlob.Data, modifier);
+        break;
     case VariantType::Int2:
         Deserialize(value, *(Int2*)v.AsData, modifier);
         break;
@@ -329,13 +347,13 @@ void Serialization::Deserialize(ISerializable::DeserializeStream& stream, Varian
         Deserialize(value, *(Rectangle*)v.AsData, modifier);
         break;
     case VariantType::BoundingBox:
-        Deserialize(value, *(BoundingBox*)v.AsBlob.Data, modifier);
+        Deserialize(value, *(BoundingBox*)v.AsData, modifier);
         break;
     case VariantType::Transform:
         Deserialize(value, *(Transform*)v.AsBlob.Data, modifier);
         break;
     case VariantType::Ray:
-        Deserialize(value, *(Ray*)v.AsBlob.Data, modifier);
+        Deserialize(value, *(Ray*)v.AsData, modifier);
         break;
     case VariantType::Matrix:
         Deserialize(value, *(Matrix*)v.AsBlob.Data, modifier);
diff --git a/Source/Engine/Serialization/Stream.cpp b/Source/Engine/Serialization/Stream.cpp
index 1b63f2c20..e8f80b5dd 100644
--- a/Source/Engine/Serialization/Stream.cpp
+++ b/Source/Engine/Serialization/Stream.cpp
@@ -7,6 +7,9 @@
 #include "MemoryReadStream.h"
 #include "Engine/Core/Types/CommonValue.h"
 #include "Engine/Core/Types/Variant.h"
+#include "Engine/Core/Math/Double2.h"
+#include "Engine/Core/Math/Double3.h"
+#include "Engine/Core/Math/Double4.h"
 #include "Engine/Core/Collections/Dictionary.h"
 #include "Engine/Content/Asset.h"
 #include "Engine/Core/Cache.h"
@@ -413,6 +416,15 @@ void ReadStream::ReadVariant(Variant* data)
     case VariantType::Vector4:
         ReadBytes(&data->AsData, sizeof(Vector4));
         break;
+    case VariantType::Double2:
+        ReadBytes(&data->AsData, sizeof(Double2));
+        break;
+    case VariantType::Double3:
+        ReadBytes(&data->AsData, sizeof(Double3));
+        break;
+    case VariantType::Double4:
+        ReadBytes(data->AsBlob.Data, sizeof(Double4));
+        break;
     case VariantType::Color:
         ReadBytes(&data->AsData, sizeof(Color));
         break;
@@ -420,7 +432,7 @@ void ReadStream::ReadVariant(Variant* data)
         ReadBytes(&data->AsData, sizeof(Guid));
         break;
     case VariantType::BoundingBox:
-        ReadBytes(data->AsBlob.Data, sizeof(BoundingBox));
+        ReadBytes(&data->AsData, sizeof(BoundingBox));
         break;
     case VariantType::BoundingSphere:
         ReadBytes(&data->AsData, sizeof(BoundingSphere));
@@ -435,7 +447,7 @@ void ReadStream::ReadVariant(Variant* data)
         ReadBytes(&data->AsData, sizeof(Rectangle));
         break;
     case VariantType::Ray:
-        ReadBytes(data->AsBlob.Data, sizeof(Ray));
+        ReadBytes(&data->AsData, sizeof(Ray));
         break;
     case VariantType::Matrix:
         ReadBytes(data->AsBlob.Data, sizeof(Matrix));
@@ -679,13 +691,13 @@ void WriteStream::WriteVariant(const Variant& data)
         WriteBytes(data.AsBlob.Data, data.AsBlob.Length);
         break;
     case VariantType::BoundingBox:
-        WriteBytes(data.AsBlob.Data, sizeof(BoundingBox));
+        WriteBytes(data.AsData, sizeof(BoundingBox));
         break;
     case VariantType::Transform:
         WriteBytes(data.AsBlob.Data, sizeof(Transform));
         break;
     case VariantType::Ray:
-        WriteBytes(data.AsBlob.Data, sizeof(Ray));
+        WriteBytes(data.AsData, sizeof(Ray));
         break;
     case VariantType::Matrix:
         WriteBytes(data.AsBlob.Data, sizeof(Matrix));
@@ -695,28 +707,37 @@ void WriteStream::WriteVariant(const Variant& data)
         Write(&id);
         break;
     case VariantType::Vector2:
-        Write(data.AsData, sizeof(Vector2));
+        WriteBytes(data.AsData, sizeof(Vector2));
         break;
     case VariantType::Vector3:
-        Write(data.AsData, sizeof(Vector3));
+        WriteBytes(data.AsData, sizeof(Vector3));
         break;
     case VariantType::Vector4:
-        Write(data.AsData, sizeof(Vector4));
+        WriteBytes(data.AsData, sizeof(Vector4));
+        break;
+    case VariantType::Double2:
+        WriteBytes(data.AsData, sizeof(Double2));
+        break;
+    case VariantType::Double3:
+        WriteBytes(data.AsData, sizeof(Double3));
+        break;
+    case VariantType::Double4:
+        WriteBytes(data.AsBlob.Data, sizeof(Double4));
         break;
     case VariantType::Color:
-        Write(data.AsData, sizeof(Color));
+        WriteBytes(data.AsData, sizeof(Color));
         break;
     case VariantType::Guid:
-        Write(data.AsData, sizeof(Guid));
+        WriteBytes(data.AsData, sizeof(Guid));
         break;
     case VariantType::Quaternion:
-        Write(data.AsData, sizeof(Quaternion));
+        WriteBytes(data.AsData, sizeof(Quaternion));
         break;
     case VariantType::Rectangle:
-        Write(data.AsData, sizeof(Rectangle));
+        WriteBytes(data.AsData, sizeof(Rectangle));
         break;
     case VariantType::BoundingSphere:
-        Write(data.AsData, sizeof(BoundingSphere));
+        WriteBytes(data.AsData, sizeof(BoundingSphere));
         break;
     case VariantType::Array:
         id.A = ((Array<Variant>*)data.AsData)->Count();
diff --git a/Source/Engine/Visject/GraphUtilities.cpp b/Source/Engine/Visject/GraphUtilities.cpp
index 9c5dba3ad..9d309cf99 100644
--- a/Source/Engine/Visject/GraphUtilities.cpp
+++ b/Source/Engine/Visject/GraphUtilities.cpp
@@ -1,6 +1,9 @@
 // Copyright (c) 2012-2022 Wojciech Figat. All rights reserved.
 
 #include "GraphUtilities.h"
+#include "Engine/Core/Math/Double2.h"
+#include "Engine/Core/Math/Double3.h"
+#include "Engine/Core/Math/Double4.h"
 
 // [Deprecated on 31.07.2020, expires on 31.07.2022]
 enum class GraphParamType_Deprecated
@@ -164,7 +167,7 @@ FLAXENGINE_API void ReadOldGraphParamValue_Deprecated(byte graphParamType, ReadS
         param->Value.AsUint64 = (uint64)value.AsInteger;
         break;
     default:
-    CRASH;
+        CRASH;
     }
 }
 
@@ -309,41 +312,84 @@ void GraphUtilities::ApplySomeMathHere(Variant& v, Variant& a, MathOp1 op)
         v.AsFloat = op(a.AsFloat);
         break;
     case VariantType::Vector2:
-        (*(Vector2*)v.AsData).X = op((*(Vector2*)a.AsData).X);
-        (*(Vector2*)v.AsData).Y = op((*(Vector2*)a.AsData).Y);
+    {
+        Vector2& vv = *(Vector2*)v.AsData;
+        const Vector2& aa = *(const Vector2*)a.AsData;
+        vv.X = op(aa.X);
+        vv.Y = op(aa.Y);
         break;
+    }
     case VariantType::Vector3:
-        (*(Vector3*)v.AsData).X = op((*(Vector3*)a.AsData).X);
-        (*(Vector3*)v.AsData).Y = op((*(Vector3*)a.AsData).Y);
-        (*(Vector3*)v.AsData).Z = op((*(Vector3*)a.AsData).Z);
+    {
+        Vector3& vv = *(Vector3*)v.AsData;
+        const Vector3& aa = *(const Vector3*)a.AsData;
+        vv.X = op(aa.X);
+        vv.Y = op(aa.Y);
+        vv.Z = op(aa.Z);
         break;
+    }
     case VariantType::Vector4:
     case VariantType::Color:
-        (*(Vector4*)v.AsData).X = op((*(Vector4*)a.AsData).X);
-        (*(Vector4*)v.AsData).Y = op((*(Vector4*)a.AsData).Y);
-        (*(Vector4*)v.AsData).Z = op((*(Vector4*)a.AsData).Z);
-        (*(Vector4*)v.AsData).W = op((*(Vector4*)a.AsData).W);
+    {
+        Vector4& vv = *(Vector4*)v.AsData;
+        const Vector4& aa = *(const Vector4*)a.AsData;
+        vv.X = op(aa.X);
+        vv.Y = op(aa.Y);
+        vv.Z = op(aa.Z);
+        vv.W = op(aa.W);
         break;
+    }
+    case VariantType::Double2:
+    {
+        Double2& vv = *(Double2*)v.AsData;
+        const Double2& aa = *(const Double2*)a.AsData;
+        vv.X = (double)op((float)aa.X);
+        vv.Y = (double)op((float)aa.Y);
+        break;
+    }
+    case VariantType::Double3:
+    {
+        Double3& vv = *(Double3*)v.AsData;
+        const Double3& aa = *(const Double3*)a.AsData;
+        vv.X = (double)op((float)aa.X);
+        vv.Y = (double)op((float)aa.Y);
+        vv.Z = (double)op((float)aa.Z);
+        break;
+    }
+    case VariantType::Double4:
+    {
+        Double4& vv = *(Double4*)v.AsBlob.Data;
+        const Double4& aa = *(const Double4*)a.AsBlob.Data;
+        vv.X = (double)op((float)aa.X);
+        vv.Y = (double)op((float)aa.Y);
+        vv.Z = (double)op((float)aa.Z);
+        vv.W = (double)op((float)aa.W);
+        break;
+    }
     case VariantType::Quaternion:
-        (*(Quaternion*)v.AsData).X = op((*(Quaternion*)a.AsData).X);
-        (*(Quaternion*)v.AsData).Y = op((*(Quaternion*)a.AsData).Y);
-        (*(Quaternion*)v.AsData).Z = op((*(Quaternion*)a.AsData).Z);
-        (*(Quaternion*)v.AsData).W = op((*(Quaternion*)a.AsData).W);
+    {
+        Quaternion& vv = *(Quaternion*)v.AsData;
+        const Quaternion& aa = *(const Quaternion*)a.AsData;
+        vv.X = op(aa.X);
+        vv.Y = op(aa.Y);
+        vv.Z = op(aa.Z);
+        vv.W = op(aa.W);
         break;
+    }
     case VariantType::Transform:
     {
-        Transform& vTransform = *(Transform*)v.AsBlob.Data;
-        const Transform& aTransform = *(const Transform*)a.AsBlob.Data;
-        vTransform.Translation.X = op(aTransform.Translation.X);
-        vTransform.Translation.Y = op(aTransform.Translation.Y);
-        vTransform.Translation.Z = op(aTransform.Translation.Z);
-        vTransform.Orientation.X = op(aTransform.Orientation.X);
-        vTransform.Orientation.Y = op(aTransform.Orientation.Y);
-        vTransform.Orientation.Z = op(aTransform.Orientation.Z);
-        vTransform.Orientation.W = op(aTransform.Orientation.W);
-        vTransform.Scale.X = op(aTransform.Scale.X);
-        vTransform.Scale.Y = op(aTransform.Scale.Y);
-        vTransform.Scale.Z = op(aTransform.Scale.Z);
+        Transform& vv = *(Transform*)v.AsBlob.Data;
+        const Transform& aa = *(const Transform*)a.AsBlob.Data;
+        vv.Translation.X = op(aa.Translation.X);
+        vv.Translation.Y = op(aa.Translation.Y);
+        vv.Translation.Z = op(aa.Translation.Z);
+        vv.Orientation.X = op(aa.Orientation.X);
+        vv.Orientation.Y = op(aa.Orientation.Y);
+        vv.Orientation.Z = op(aa.Orientation.Z);
+        vv.Orientation.W = op(aa.Orientation.W);
+        vv.Scale.X = op(aa.Scale.X);
+        vv.Scale.Y = op(aa.Scale.Y);
+        vv.Scale.Z = op(aa.Scale.Z);
         break;
     }
     default:
@@ -370,41 +416,92 @@ void GraphUtilities::ApplySomeMathHere(Variant& v, Variant& a, Variant& b, MathO
         v.AsFloat = op(a.AsFloat, b.AsFloat);
         break;
     case VariantType::Vector2:
-        (*(Vector2*)v.AsData).X = op((*(Vector2*)a.AsData).X, (*(Vector2*)b.AsData).X);
-        (*(Vector2*)v.AsData).Y = op((*(Vector2*)a.AsData).Y, (*(Vector2*)b.AsData).Y);
+    {
+        Vector2& vv = *(Vector2*)v.AsData;
+        const Vector2& aa = *(const Vector2*)a.AsData;
+        const Vector2& bb = *(const Vector2*)b.AsData;
+        vv.X = op(aa.X, bb.X);
+        vv.Y = op(aa.Y, bb.Y);
         break;
+    }
     case VariantType::Vector3:
-        (*(Vector3*)v.AsData).X = op((*(Vector3*)a.AsData).X, (*(Vector3*)b.AsData).X);
-        (*(Vector3*)v.AsData).Y = op((*(Vector3*)a.AsData).Y, (*(Vector3*)b.AsData).Y);
-        (*(Vector3*)v.AsData).Z = op((*(Vector3*)a.AsData).Z, (*(Vector3*)b.AsData).Z);
+    {
+        Vector3& vv = *(Vector3*)v.AsData;
+        const Vector3& aa = *(const Vector3*)a.AsData;
+        const Vector3& bb = *(const Vector3*)b.AsData;
+        vv.X = op(aa.X, bb.X);
+        vv.Y = op(aa.Y, bb.Y);
+        vv.Z = op(aa.Z, bb.Z);
         break;
+    }
     case VariantType::Vector4:
     case VariantType::Color:
-        (*(Vector4*)v.AsData).X = op((*(Vector4*)a.AsData).X, (*(Vector4*)b.AsData).X);
-        (*(Vector4*)v.AsData).Y = op((*(Vector4*)a.AsData).Y, (*(Vector4*)b.AsData).Y);
-        (*(Vector4*)v.AsData).Z = op((*(Vector4*)a.AsData).Z, (*(Vector4*)b.AsData).Z);
-        (*(Vector4*)v.AsData).W = op((*(Vector4*)a.AsData).W, (*(Vector4*)b.AsData).W);
-    case VariantType::Quaternion:
-        (*(Quaternion*)v.AsData).X = op((*(Quaternion*)a.AsData).X, (*(Quaternion*)b.AsData).X);
-        (*(Quaternion*)v.AsData).Y = op((*(Quaternion*)a.AsData).Y, (*(Quaternion*)b.AsData).Y);
-        (*(Quaternion*)v.AsData).Z = op((*(Quaternion*)a.AsData).Z, (*(Quaternion*)b.AsData).Z);
-        (*(Quaternion*)v.AsData).W = op((*(Quaternion*)a.AsData).W, (*(Quaternion*)b.AsData).W);
+    {
+        Vector4& vv = *(Vector4*)v.AsData;
+        const Vector4& aa = *(const Vector4*)a.AsData;
+        const Vector4& bb = *(const Vector4*)b.AsData;
+        vv.X = op(aa.X, bb.X);
+        vv.Y = op(aa.Y, bb.Y);
+        vv.W = op(aa.Z, bb.Z);
+        vv.W = op(aa.W, bb.W);
         break;
+    }
+    case VariantType::Double2:
+    {
+        Double2& vv = *(Double2*)v.AsData;
+        const Double2& aa = *(const Double2*)a.AsData;
+        const Double2& bb = *(const Double2*)b.AsData;
+        vv.X = (double)op((float)aa.X, (float)bb.X);
+        vv.Y = (double)op((float)aa.Y, (float)bb.Y);
+        break;
+    }
+    case VariantType::Double3:
+    {
+        Double3& vv = *(Double3*)v.AsData;
+        const Double3& aa = *(const Double3*)a.AsData;
+        const Double3& bb = *(const Double3*)b.AsData;
+        vv.X = (double)op((float)aa.X, (float)bb.X);
+        vv.Y = (double)op((float)aa.Y, (float)bb.Y);
+        vv.Z = (double)op((float)aa.Z, (float)bb.Z);
+        break;
+    }
+    case VariantType::Double4:
+    {
+        Double4& vv = *(Double4*)v.AsBlob.Data;
+        const Double4& aa = *(const Double4*)a.AsBlob.Data;
+        const Double4& bb = *(const Double4*)b.AsBlob.Data;
+        vv.X = (double)op((float)aa.X, (float)bb.X);
+        vv.Y = (double)op((float)aa.Y, (float)bb.Y);
+        vv.W = (double)op((float)aa.Z, (float)bb.Z);
+        vv.W = (double)op((float)aa.W, (float)bb.W);
+        break;
+    }
+    case VariantType::Quaternion:
+    {
+        Quaternion& vv = *(Quaternion*)v.AsData;
+        const Quaternion& aa = *(const Quaternion*)a.AsData;
+        const Quaternion& bb = *(const Quaternion*)b.AsData;
+        vv.X = op(aa.X, bb.X);
+        vv.Y = op(aa.Y, bb.Y);
+        vv.W = op(aa.Z, bb.Z);
+        vv.W = op(aa.W, bb.W);
+        break;
+    }
     case VariantType::Transform:
     {
-        Transform& vTransform = *(Transform*)v.AsBlob.Data;
-        const Transform& aTransform = *(const Transform*)a.AsBlob.Data;
-        const Transform& bTransform = *(const Transform*)b.AsBlob.Data;
-        vTransform.Translation.X = op(aTransform.Translation.X, bTransform.Translation.X);
-        vTransform.Translation.Y = op(aTransform.Translation.Y, bTransform.Translation.Y);
-        vTransform.Translation.Z = op(aTransform.Translation.Z, bTransform.Translation.Z);
-        vTransform.Orientation.X = op(aTransform.Orientation.X, bTransform.Orientation.X);
-        vTransform.Orientation.Y = op(aTransform.Orientation.Y, bTransform.Orientation.Y);
-        vTransform.Orientation.Z = op(aTransform.Orientation.Z, bTransform.Orientation.Z);
-        vTransform.Orientation.W = op(aTransform.Orientation.W, bTransform.Orientation.W);
-        vTransform.Scale.X = op(aTransform.Scale.X, bTransform.Scale.X);
-        vTransform.Scale.Y = op(aTransform.Scale.Y, bTransform.Scale.Y);
-        vTransform.Scale.Z = op(aTransform.Scale.Z, bTransform.Scale.Z);
+        Transform& vv = *(Transform*)v.AsBlob.Data;
+        const Transform& aa = *(const Transform*)a.AsBlob.Data;
+        const Transform& bb = *(const Transform*)b.AsBlob.Data;
+        vv.Translation.X = op(aa.Translation.X, bb.Translation.X);
+        vv.Translation.Y = op(aa.Translation.Y, bb.Translation.Y);
+        vv.Translation.Z = op(aa.Translation.Z, bb.Translation.Z);
+        vv.Orientation.X = op(aa.Orientation.X, bb.Orientation.X);
+        vv.Orientation.Y = op(aa.Orientation.Y, bb.Orientation.Y);
+        vv.Orientation.Z = op(aa.Orientation.Z, bb.Orientation.Z);
+        vv.Orientation.W = op(aa.Orientation.W, bb.Orientation.W);
+        vv.Scale.X = op(aa.Scale.X, bb.Scale.X);
+        vv.Scale.Y = op(aa.Scale.Y, bb.Scale.Y);
+        vv.Scale.Z = op(aa.Scale.Z, bb.Scale.Z);
         break;
     }
     default:
@@ -431,43 +528,100 @@ void GraphUtilities::ApplySomeMathHere(Variant& v, Variant& a, Variant& b, Varia
         v.AsFloat = op(a.AsFloat, b.AsFloat, c.AsFloat);
         break;
     case VariantType::Vector2:
-        (*(Vector2*)v.AsData).X = op((*(Vector2*)a.AsData).X, (*(Vector2*)b.AsData).X, (*(Vector2*)c.AsData).X);
-        (*(Vector2*)v.AsData).Y = op((*(Vector2*)a.AsData).Y, (*(Vector2*)b.AsData).Y, (*(Vector2*)c.AsData).Y);
+    {
+        Vector2& vv = *(Vector2*)v.AsData;
+        const Vector2& aa = *(const Vector2*)a.AsData;
+        const Vector2& bb = *(const Vector2*)b.AsData;
+        const Vector2& cc = *(const Vector2*)b.AsData;
+        vv.X = op(aa.X, bb.X, cc.X);
+        vv.Y = op(aa.Y, bb.Y, cc.Y);
         break;
+    }
     case VariantType::Vector3:
-        (*(Vector3*)v.AsData).X = op((*(Vector3*)a.AsData).X, (*(Vector3*)b.AsData).X, (*(Vector3*)c.AsData).X);
-        (*(Vector3*)v.AsData).Y = op((*(Vector3*)a.AsData).Y, (*(Vector3*)b.AsData).Y, (*(Vector3*)c.AsData).Y);
-        (*(Vector3*)v.AsData).Z = op((*(Vector3*)a.AsData).Z, (*(Vector3*)b.AsData).Z, (*(Vector3*)c.AsData).Z);
+    {
+        Vector3& vv = *(Vector3*)v.AsData;
+        const Vector3& aa = *(const Vector3*)a.AsData;
+        const Vector3& bb = *(const Vector3*)b.AsData;
+        const Vector3& cc = *(const Vector3*)b.AsData;
+        vv.X = op(aa.X, bb.X, cc.X);
+        vv.Y = op(aa.Y, bb.Y, cc.Y);
+        vv.Z = op(aa.Z, bb.Z, cc.Z);
         break;
+    }
     case VariantType::Vector4:
     case VariantType::Color:
-        (*(Vector4*)v.AsData).X = op((*(Vector4*)a.AsData).X, (*(Vector4*)b.AsData).X, (*(Vector4*)c.AsData).X);
-        (*(Vector4*)v.AsData).Y = op((*(Vector4*)a.AsData).Y, (*(Vector4*)b.AsData).Y, (*(Vector4*)c.AsData).Y);
-        (*(Vector4*)v.AsData).Z = op((*(Vector4*)a.AsData).Z, (*(Vector4*)b.AsData).Z, (*(Vector4*)c.AsData).Z);
-        (*(Vector4*)v.AsData).W = op((*(Vector4*)a.AsData).W, (*(Vector4*)b.AsData).W, (*(Vector4*)c.AsData).W);
+    {
+        Vector4& vv = *(Vector4*)v.AsData;
+        const Vector4& aa = *(const Vector4*)a.AsData;
+        const Vector4& bb = *(const Vector4*)b.AsData;
+        const Vector4& cc = *(const Vector4*)b.AsData;
+        vv.X = op(aa.X, bb.X, cc.X);
+        vv.Y = op(aa.Y, bb.Y, cc.Y);
+        vv.Z = op(aa.Z, bb.Z, cc.Z);
+        vv.W = op(aa.W, bb.W, cc.W);
         break;
+    }
+    case VariantType::Double2:
+    {
+        Double2& vv = *(Double2*)v.AsData;
+        const Double2& aa = *(const Double2*)a.AsData;
+        const Double2& bb = *(const Double2*)b.AsData;
+        const Double2& cc = *(const Double2*)b.AsData;
+        vv.X = (double)op((float)aa.X, (float)bb.X, (float)cc.X);
+        vv.Y = (double)op((float)aa.Y, (float)bb.Y, (float)cc.Y);
+        break;
+    }
+    case VariantType::Double3:
+    {
+        Double3& vv = *(Double3*)v.AsData;
+        const Double3& aa = *(const Double3*)a.AsData;
+        const Double3& bb = *(const Double3*)b.AsData;
+        const Double3& cc = *(const Double3*)b.AsData;
+        vv.X = (double)op((float)aa.X, (float)bb.X, (float)cc.X);
+        vv.Y = (double)op((float)aa.Y, (float)bb.Y, (float)cc.Y);
+        vv.Z = (double)op((float)aa.Z, (float)bb.Z, (float)cc.Z);
+        break;
+    }
+    case VariantType::Double4:
+    {
+        Double4& vv = *(Double4*)v.AsBlob.Data;
+        const Double4& aa = *(const Double4*)a.AsBlob.Data;
+        const Double4& bb = *(const Double4*)b.AsBlob.Data;
+        const Double4& cc = *(const Double4*)b.AsBlob.Data;
+        vv.X = (double)op((float)aa.X, (float)bb.X, (float)cc.X);
+        vv.Y = (double)op((float)aa.Y, (float)bb.Y, (float)cc.Y);
+        vv.Z = (double)op((float)aa.Z, (float)bb.Z, (float)cc.Z);
+        vv.W = (double)op((float)aa.W, (float)bb.W, (float)cc.W);
+        break;
+    }
     case VariantType::Quaternion:
-        (*(Quaternion*)v.AsData).X = op((*(Quaternion*)a.AsData).X, (*(Quaternion*)b.AsData).X, (*(Quaternion*)c.AsData).X);
-        (*(Quaternion*)v.AsData).Y = op((*(Quaternion*)a.AsData).Y, (*(Quaternion*)b.AsData).Y, (*(Quaternion*)c.AsData).Y);
-        (*(Quaternion*)v.AsData).Z = op((*(Quaternion*)a.AsData).Z, (*(Quaternion*)b.AsData).Z, (*(Quaternion*)c.AsData).Z);
-        (*(Quaternion*)v.AsData).W = op((*(Quaternion*)a.AsData).W, (*(Quaternion*)b.AsData).W, (*(Quaternion*)c.AsData).W);
+    {
+        Quaternion& vv = *(Quaternion*)v.AsData;
+        const Quaternion& aa = *(const Quaternion*)a.AsData;
+        const Quaternion& bb = *(const Quaternion*)b.AsData;
+        const Quaternion& cc = *(const Quaternion*)b.AsData;
+        vv.X = op(aa.X, bb.X, cc.X);
+        vv.Y = op(aa.Y, bb.Y, cc.Y);
+        vv.Z = op(aa.Z, bb.Z, cc.Z);
+        vv.W = op(aa.W, bb.W, cc.W);
         break;
+    }
     case VariantType::Transform:
     {
-        Transform& vTransform = *(Transform*)v.AsBlob.Data;
-        const Transform& aTransform = *(const Transform*)a.AsBlob.Data;
-        const Transform& bTransform = *(const Transform*)b.AsBlob.Data;
-        const Transform& cTransform = *(const Transform*)c.AsBlob.Data;
-        vTransform.Translation.X = op(aTransform.Translation.X, bTransform.Translation.X, cTransform.Translation.X);
-        vTransform.Translation.Y = op(aTransform.Translation.Y, bTransform.Translation.Y, cTransform.Translation.Y);
-        vTransform.Translation.Z = op(aTransform.Translation.Z, bTransform.Translation.Z, cTransform.Translation.Z);
-        vTransform.Orientation.X = op(aTransform.Orientation.X, bTransform.Orientation.X, cTransform.Orientation.X);
-        vTransform.Orientation.Y = op(aTransform.Orientation.Y, bTransform.Orientation.Y, cTransform.Orientation.Y);
-        vTransform.Orientation.Z = op(aTransform.Orientation.Z, bTransform.Orientation.Z, cTransform.Orientation.Z);
-        vTransform.Orientation.W = op(aTransform.Orientation.W, bTransform.Orientation.W, cTransform.Orientation.W);
-        vTransform.Scale.X = op(aTransform.Scale.X, bTransform.Scale.X, cTransform.Scale.X);
-        vTransform.Scale.Y = op(aTransform.Scale.Y, bTransform.Scale.Y, cTransform.Scale.Y);
-        vTransform.Scale.Z = op(aTransform.Scale.Z, bTransform.Scale.Z, cTransform.Scale.Z);
+        Transform& vv = *(Transform*)v.AsBlob.Data;
+        const Transform& aa = *(const Transform*)a.AsBlob.Data;
+        const Transform& bb = *(const Transform*)b.AsBlob.Data;
+        const Transform& cc = *(const Transform*)c.AsBlob.Data;
+        vv.Translation.X = op(aa.Translation.X, bb.Translation.X, cc.Translation.X);
+        vv.Translation.Y = op(aa.Translation.Y, bb.Translation.Y, cc.Translation.Y);
+        vv.Translation.Z = op(aa.Translation.Z, bb.Translation.Z, cc.Translation.Z);
+        vv.Orientation.X = op(aa.Orientation.X, bb.Orientation.X, cc.Orientation.X);
+        vv.Orientation.Y = op(aa.Orientation.Y, bb.Orientation.Y, cc.Orientation.Y);
+        vv.Orientation.Z = op(aa.Orientation.Z, bb.Orientation.Z, cc.Orientation.Z);
+        vv.Orientation.W = op(aa.Orientation.W, bb.Orientation.W, cc.Orientation.W);
+        vv.Scale.X = op(aa.Scale.X, bb.Scale.X, cc.Scale.X);
+        vv.Scale.Y = op(aa.Scale.Y, bb.Scale.Y, cc.Scale.Y);
+        vv.Scale.Z = op(aa.Scale.Z, bb.Scale.Z, cc.Scale.Z);
         break;
     }
     default:
@@ -692,10 +846,16 @@ int32 GraphUtilities::CountComponents(VariantType::Types type)
     case VariantType::Pointer:
         return 1;
     case VariantType::Vector2:
+    case VariantType::Double2:
+    case VariantType::Int2:
         return 2;
     case VariantType::Vector3:
+    case VariantType::Double3:
+    case VariantType::Int3:
         return 3;
     case VariantType::Vector4:
+    case VariantType::Double4:
+    case VariantType::Int4:
     case VariantType::Color:
         return 4;
     default: