diff --git a/Source/Engine/Animations/Graph/AnimGroup.Animation.cpp b/Source/Engine/Animations/Graph/AnimGroup.Animation.cpp
index b07b5a132..afebe60aa 100644
--- a/Source/Engine/Animations/Graph/AnimGroup.Animation.cpp
+++ b/Source/Engine/Animations/Graph/AnimGroup.Animation.cpp
@@ -873,65 +873,41 @@ void AnimGraphExecutor::ProcessGroupParameters(Box* box, Node* node, Value& valu
             switch (param->Type.Type)
             {
             case VariantType::Float2:
-                switch (box->ID)
-                {
-                case 1:
-                case 2:
+                if (box->ID >= 1 && box->ID <= 2)
                     value = value.AsFloat2().Raw[box->ID - 1];
-                    break;
-                }
                 break;
             case VariantType::Float3:
-                switch (box->ID)
-                {
-                case 1:
-                case 2:
-                case 3:
+                if (box->ID >= 1 && box->ID <= 3)
                     value = value.AsFloat3().Raw[box->ID - 1];
-                    break;
-                }
                 break;
             case VariantType::Float4:
             case VariantType::Color:
-                switch (box->ID)
-                {
-                case 1:
-                case 2:
-                case 3:
-                case 4:
+                if (box->ID >= 1 && box->ID <= 4)
                     value = value.AsFloat4().Raw[box->ID - 1];
-                    break;
-                }
                 break;
             case VariantType::Double2:
-                switch (box->ID)
-                {
-                case 1:
-                case 2:
+                if (box->ID >= 1 && box->ID <= 2)
                     value = value.AsDouble2().Raw[box->ID - 1];
-                    break;
-                }
                 break;
             case VariantType::Double3:
-                switch (box->ID)
-                {
-                case 1:
-                case 2:
-                case 3:
+                if (box->ID >= 1 && box->ID <= 3)
                     value = value.AsDouble3().Raw[box->ID - 1];
-                    break;
-                }
                 break;
             case VariantType::Double4:
-                switch (box->ID)
-                {
-                case 1:
-                case 2:
-                case 3:
-                case 4:
+                if (box->ID >= 1 && box->ID <= 4)
                     value = value.AsDouble4().Raw[box->ID - 1];
-                    break;
-                }
+                break;
+            case VariantType::Int2:
+                if (box->ID >= 1 && box->ID <= 2)
+                    value = value.AsInt2().Raw[box->ID - 1];
+                break;
+            case VariantType::Int3:
+                if (box->ID >= 1 && box->ID <= 3)
+                    value = value.AsInt3().Raw[box->ID - 1];
+                break;
+            case VariantType::Int4:
+                if (box->ID >= 1 && box->ID <= 4)
+                    value = value.AsInt4().Raw[box->ID - 1];
                 break;
             case VariantType::Matrix:
             {
diff --git a/Source/Engine/Core/Math/Vector2.cpp b/Source/Engine/Core/Math/Vector2.cpp
index c6abd7589..790a27bcc 100644
--- a/Source/Engine/Core/Math/Vector2.cpp
+++ b/Source/Engine/Core/Math/Vector2.cpp
@@ -9,6 +9,8 @@
 // Float
 
 static_assert(sizeof(Float2) == 8, "Invalid Float2 type size.");
+static_assert(sizeof(Int2) == 8, "Invalid Int2 type size.");
+static_assert(sizeof(Double2) == 16, "Invalid Double2 type size.");
 
 template<>
 const Float2 Float2::Zero(0.0f);
diff --git a/Source/Engine/Core/Math/Vector3.cpp b/Source/Engine/Core/Math/Vector3.cpp
index 6c0c3f1f8..f96954d97 100644
--- a/Source/Engine/Core/Math/Vector3.cpp
+++ b/Source/Engine/Core/Math/Vector3.cpp
@@ -13,6 +13,8 @@
 // Float
 
 static_assert(sizeof(Float3) == 12, "Invalid Float3 type size.");
+static_assert(sizeof(Int3) == 12, "Invalid Int3 type size.");
+static_assert(sizeof(Double3) == 24, "Invalid Double3 type size.");
 
 template<>
 const Float3 Float3::Zero(0.0f);
diff --git a/Source/Engine/Core/Math/Vector4.cpp b/Source/Engine/Core/Math/Vector4.cpp
index 699d2d550..afae743c6 100644
--- a/Source/Engine/Core/Math/Vector4.cpp
+++ b/Source/Engine/Core/Math/Vector4.cpp
@@ -11,6 +11,8 @@
 // Float
 
 static_assert(sizeof(Float4) == 16, "Invalid Float4 type size.");
+static_assert(sizeof(Int4) == 16, "Invalid Int4 type size.");
+static_assert(sizeof(Double4) == 32, "Invalid Double4 type size.");
 
 template<>
 const Float4 Float4::Zero(0.0f);
diff --git a/Source/Engine/Core/Types/Variant.cpp b/Source/Engine/Core/Types/Variant.cpp
index aecc292dc..7f805f9e3 100644
--- a/Source/Engine/Core/Types/Variant.cpp
+++ b/Source/Engine/Core/Types/Variant.cpp
@@ -4,6 +4,7 @@
 #include "Engine/Core/Collections/HashFunctions.h"
 #include "Engine/Core/Collections/Dictionary.h"
 #include "Engine/Content/Asset.h"
+#include "Engine/Content/Deprecated.h"
 #include "Engine/Core/Log.h"
 #include "Engine/Core/Math/Mathd.h"
 #include "Engine/Core/Math/BoundingBox.h"
@@ -3193,6 +3194,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Double2:
         case VariantType::Double3:
         case VariantType::Double4:
+        case VariantType::Int2:
+        case VariantType::Int3:
+        case VariantType::Int4:
         case VariantType::Enum:
             return true;
         default:
@@ -3216,6 +3220,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Double2:
         case VariantType::Double3:
         case VariantType::Double4:
+        case VariantType::Int2:
+        case VariantType::Int3:
+        case VariantType::Int4:
         case VariantType::Enum:
             return true;
         default:
@@ -3239,6 +3246,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Double2:
         case VariantType::Double3:
         case VariantType::Double4:
+        case VariantType::Int2:
+        case VariantType::Int3:
+        case VariantType::Int4:
         case VariantType::Enum:
             return true;
         default:
@@ -3262,6 +3272,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Double2:
         case VariantType::Double3:
         case VariantType::Double4:
+        case VariantType::Int2:
+        case VariantType::Int3:
+        case VariantType::Int4:
         case VariantType::Enum:
             return true;
         default:
@@ -3285,6 +3298,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Double2:
         case VariantType::Double3:
         case VariantType::Double4:
+        case VariantType::Int2:
+        case VariantType::Int3:
+        case VariantType::Int4:
         case VariantType::Enum:
             return true;
         default:
@@ -3308,6 +3324,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Double2:
         case VariantType::Double3:
         case VariantType::Double4:
+        case VariantType::Int2:
+        case VariantType::Int3:
+        case VariantType::Int4:
         case VariantType::Enum:
             return true;
         default:
@@ -3331,6 +3350,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Double2:
         case VariantType::Double3:
         case VariantType::Double4:
+        case VariantType::Int2:
+        case VariantType::Int3:
+        case VariantType::Int4:
         case VariantType::Enum:
             return true;
         default:
@@ -3354,6 +3376,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Double2:
         case VariantType::Double3:
         case VariantType::Double4:
+        case VariantType::Int2:
+        case VariantType::Int3:
+        case VariantType::Int4:
         case VariantType::Enum:
             return true;
         default:
@@ -3377,6 +3402,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         case VariantType::Double2:
         case VariantType::Double3:
         case VariantType::Double4:
+        case VariantType::Int2:
+        case VariantType::Int3:
+        case VariantType::Int4:
         case VariantType::Enum:
             return true;
         default:
@@ -3520,6 +3548,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Double3(v.AsBool ? 1.0 : 0.0));
         case VariantType::Double4:
             return Variant(Double4(v.AsBool ? 1.0 : 0.0));
+        case VariantType::Int2:
+            return Variant(Int2(v.AsBool ? 1 : 0));
+        case VariantType::Int3:
+            return Variant(Int3(v.AsBool ? 1 : 0));
+        case VariantType::Int4:
+            return Variant(Int4(v.AsBool ? 1 : 0));
     case VariantType::Enum:
             return Enum(to, v.AsBool ? 1 : 0);
         default: ;
@@ -3558,6 +3592,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Double3((double)v.AsInt16));
         case VariantType::Double4:
             return Variant(Double4((double)v.AsInt16));
+        case VariantType::Int2:
+            return Variant(Int2(v.AsInt16));
+        case VariantType::Int3:
+            return Variant(Int3(v.AsInt16));
+        case VariantType::Int4:
+            return Variant(Int4(v.AsInt16));
         case VariantType::Enum:
             return Enum(to, (int64)v.AsInt16);
         default: ;
@@ -3588,6 +3628,18 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Float3((float)v.AsInt));
         case VariantType::Float4:
             return Variant(Float4((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));
+        case VariantType::Int2:
+            return Variant(Int2(v.AsInt));
+        case VariantType::Int3:
+            return Variant(Int3(v.AsInt));
+        case VariantType::Int4:
+            return Variant(Int4(v.AsInt));
         case VariantType::Color:
             return Variant(Color((float)v.AsInt));
         case VariantType::Enum:
@@ -3628,6 +3680,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Double3((double)v.AsUint16));
         case VariantType::Double4:
             return Variant(Double4((double)v.AsUint16));
+        case VariantType::Int2:
+            return Variant(Int2(v.AsUint16));
+        case VariantType::Int3:
+            return Variant(Int3(v.AsUint16));
+        case VariantType::Int4:
+            return Variant(Int4(v.AsUint16));
         case VariantType::Enum:
             return Enum(to, (int64)v.AsUint16);
         default: ;
@@ -3666,6 +3724,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Double3((double)v.AsUint));
         case VariantType::Double4:
             return Variant(Double4((double)v.AsUint));
+        case VariantType::Int2:
+            return Variant(Int2((int32)v.AsUint));
+        case VariantType::Int3:
+            return Variant(Int3((int32)v.AsUint));
+        case VariantType::Int4:
+            return Variant(Int4((int32)v.AsUint));
         case VariantType::Enum:
             return Enum(to, (int64)v.AsUint);
         default: ;
@@ -3704,6 +3768,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Double3((double)v.AsInt64));
         case VariantType::Double4:
             return Variant(Double4((double)v.AsInt64));
+        case VariantType::Int2:
+            return Variant(Int2((int32)v.AsInt64));
+        case VariantType::Int3:
+            return Variant(Int3((int32)v.AsInt64));
+        case VariantType::Int4:
+            return Variant(Int4((int32)v.AsInt64));
         case VariantType::Enum:
             return Enum(to, (int64)v.AsInt64);
         default: ;
@@ -3723,25 +3793,31 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
         case VariantType::Uint16:
             return Variant((uint16)v.AsUint16);
         case VariantType::Uint:
-            return Variant((uint32)v.AsUint);
+            return Variant((uint32)v.AsUint64);
         case VariantType::Float:
             return Variant((float)v.AsUint64);
         case VariantType::Double:
             return Variant((double)v.AsUint64);
         case VariantType::Float2:
-            return Variant(Float2((float)v.AsInt));
+            return Variant(Float2((float)v.AsUint64));
         case VariantType::Float3:
-            return Variant(Float3((float)v.AsInt));
+            return Variant(Float3((float)v.AsUint64));
         case VariantType::Float4:
-            return Variant(Float4((float)v.AsInt));
+            return Variant(Float4((float)v.AsUint64));
         case VariantType::Color:
-            return Variant(Color((float)v.AsInt));
+            return Variant(Color((float)v.AsUint64));
         case VariantType::Double2:
-            return Variant(Double2((double)v.AsInt));
+            return Variant(Double2((double)v.AsUint64));
         case VariantType::Double3:
-            return Variant(Double3((double)v.AsInt));
+            return Variant(Double3((double)v.AsUint64));
         case VariantType::Double4:
-            return Variant(Double4((double)v.AsInt));
+            return Variant(Double4((double)v.AsUint64));
+        case VariantType::Int2:
+            return Variant(Int2((int32)v.AsUint64));
+        case VariantType::Int3:
+            return Variant(Int3((int32)v.AsUint64));
+        case VariantType::Int4:
+            return Variant(Int4((int32)v.AsUint64));
         case VariantType::Enum:
             return Enum(to, (int64)v.AsInt);
         default: ;
@@ -3780,6 +3856,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Double3(v.AsFloat));
         case VariantType::Double4:
             return Variant(Double4(v.AsFloat));
+        case VariantType::Int2:
+            return Variant(Int2((int32)v.AsFloat));
+        case VariantType::Int3:
+            return Variant(Int3((int32)v.AsFloat));
+        case VariantType::Int4:
+            return Variant(Int4((int32)v.AsFloat));
         case VariantType::Enum:
             return Enum(to, (int64)v.AsFloat);
         default: ;
@@ -3818,6 +3900,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
             return Variant(Double3(v.AsDouble));
         case VariantType::Double4:
             return Variant(Double4(v.AsDouble));
+        case VariantType::Int2:
+            return Variant(Int2((int32)v.AsFloat));
+        case VariantType::Int3:
+            return Variant(Int3((int32)v.AsFloat));
+        case VariantType::Int4:
+            return Variant(Int4((int32)v.AsFloat));
         case VariantType::Enum:
             return Enum(to, (int64)v.AsDouble);
         default: ;
@@ -4246,6 +4334,7 @@ void Variant::AllocStructure()
         AsBlob.Length = 2;
         AsBlob.Data = Allocator::Allocate(AsBlob.Length);
         *((int16*)AsBlob.Data) = 0;
+        MARK_CONTENT_DEPRECATED();
     }
 #if USE_CSHARP
     else if (const auto mclass = Scripting::FindClass(typeName))
@@ -4371,6 +4460,13 @@ uint32 GetHash(const Variant& key)
         return GetHash((void*)key.AsObject);
     case VariantType::Structure:
     case VariantType::Blob:
+    case VariantType::Transform:
+    case VariantType::Matrix:
+#if USE_LARGE_WORLDS
+    case VariantType::BoundingSphere:
+    case VariantType::BoundingBox:
+    case VariantType::Ray:
+#endif
         return Crc::MemCrc32(key.AsBlob.Data, key.AsBlob.Length);
     case VariantType::Asset:
         return GetHash((void*)key.AsAsset);
@@ -4380,6 +4476,24 @@ uint32 GetHash(const Variant& key)
         return GetHash(*(Guid*)key.AsData);
     case VariantType::Typename:
         return GetHash((const char*)key.AsBlob.Data);
+    case VariantType::Float2:
+        return GetHash(*(const Float2*)key.AsData);
+    case VariantType::Float3:
+        return GetHash(*(const Float3*)key.AsData);
+    case VariantType::Float4:
+        return GetHash(*(const Float4*)key.AsData);
+    case VariantType::Int2:
+        return GetHash(*(const Int2*)key.AsData);
+    case VariantType::Int3:
+        return GetHash(*(const Int3*)key.AsData);
+    case VariantType::Int4:
+        return GetHash(*(const Int4*)key.AsData);
+    case VariantType::Double2:
+        return GetHash(*(const Double2*)key.AsData);
+    case VariantType::Double3:
+        return GetHash(*(const Double3*)key.AsData);
+    case VariantType::Double4:
+        return GetHash(*(const Double4*)key.AsBlob.Data);
     case VariantType::ManagedObject:
 #if USE_CSHARP
         return key.MANAGED_GC_HANDLE ? (uint32)MCore::Object::GetHashCode(MCore::GCHandle::GetTarget(key.MANAGED_GC_HANDLE)) : 0;
diff --git a/Source/Engine/Graphics/Materials/MaterialParams.cpp b/Source/Engine/Graphics/Materials/MaterialParams.cpp
index 082ac497b..3157f3552 100644
--- a/Source/Engine/Graphics/Materials/MaterialParams.cpp
+++ b/Source/Engine/Graphics/Materials/MaterialParams.cpp
@@ -460,6 +460,18 @@ void MaterialParameter::Bind(BindMeta& meta) const
                     ASSERT_LOW_LAYER(meta.Constants.Get() && meta.Constants.Length() >= (int32)(_offset + sizeof(Float4)));
                     *((Float4*)(meta.Constants.Get() + _offset)) = (Float4)e->Value.AsDouble4();
                     break;
+                case VariantType::Int2:
+                    ASSERT_LOW_LAYER(meta.Constants.Get() && meta.Constants.Length() >= (int32)(_offset + sizeof(Int2)));
+                    *((Int2*)(meta.Constants.Get() + _offset)) = (Int2)e->Value.AsInt2();
+                    break;
+                case VariantType::Int3:
+                    ASSERT_LOW_LAYER(meta.Constants.Get() && meta.Constants.Length() >= (int32)(_offset + sizeof(Int3)));
+                    *((Int3*)(meta.Constants.Get() + _offset)) = (Int3)e->Value.AsInt3();
+                    break;
+                case VariantType::Int4:
+                    ASSERT_LOW_LAYER(meta.Constants.Get() && meta.Constants.Length() >= (int32)(_offset + sizeof(Int4)));
+                    *((Int4*)(meta.Constants.Get() + _offset)) = (Int4)e->Value.AsInt4();
+                    break;
                 default: ;
                 }
             }
diff --git a/Source/Engine/Particles/Graph/CPU/ParticleEmitterGraph.CPU.Particles.cpp b/Source/Engine/Particles/Graph/CPU/ParticleEmitterGraph.CPU.Particles.cpp
index 1a7ba37d1..e12b781b0 100644
--- a/Source/Engine/Particles/Graph/CPU/ParticleEmitterGraph.CPU.Particles.cpp
+++ b/Source/Engine/Particles/Graph/CPU/ParticleEmitterGraph.CPU.Particles.cpp
@@ -27,65 +27,41 @@ void ParticleEmitterGraphCPUExecutor::ProcessGroupParameters(Box* box, Node* nod
             switch (param->Type.Type)
             {
             case VariantType::Float2:
-                switch (box->ID)
-                {
-                case 1:
-                case 2:
+                if (box->ID >= 1 && box->ID <= 2)
                     value = value.AsFloat2().Raw[box->ID - 1];
-                    break;
-                }
                 break;
             case VariantType::Float3:
-                switch (box->ID)
-                {
-                case 1:
-                case 2:
-                case 3:
+                if (box->ID >= 1 && box->ID <= 3)
                     value = value.AsFloat3().Raw[box->ID - 1];
-                    break;
-                }
                 break;
             case VariantType::Float4:
             case VariantType::Color:
-                switch (box->ID)
-                {
-                case 1:
-                case 2:
-                case 3:
-                case 4:
+                if (box->ID >= 1 && box->ID <= 4)
                     value = value.AsFloat4().Raw[box->ID - 1];
-                    break;
-                }
                 break;
             case VariantType::Double2:
-                switch (box->ID)
-                {
-                case 1:
-                case 2:
+                if (box->ID >= 1 && box->ID <= 2)
                     value = value.AsDouble2().Raw[box->ID - 1];
-                    break;
-                }
                 break;
             case VariantType::Double3:
-                switch (box->ID)
-                {
-                case 1:
-                case 2:
-                case 3:
+                if (box->ID >= 1 && box->ID <= 3)
                     value = value.AsDouble3().Raw[box->ID - 1];
-                    break;
-                }
                 break;
             case VariantType::Double4:
-                switch (box->ID)
-                {
-                case 1:
-                case 2:
-                case 3:
-                case 4:
+                if (box->ID >= 1 && box->ID <= 4)
                     value = value.AsDouble4().Raw[box->ID - 1];
-                    break;
-                }
+                break;
+            case VariantType::Int2:
+                if (box->ID >= 1 && box->ID <= 2)
+                    value = value.AsInt2().Raw[box->ID - 1];
+                break;
+            case VariantType::Int3:
+                if (box->ID >= 1 && box->ID <= 3)
+                    value = value.AsInt3().Raw[box->ID - 1];
+                break;
+            case VariantType::Int4:
+                if (box->ID >= 1 && box->ID <= 4)
+                    value = value.AsInt4().Raw[box->ID - 1];
                 break;
             case VariantType::Matrix:
             {
diff --git a/Source/Engine/Scripting/ManagedCLR/MUtils.cpp b/Source/Engine/Scripting/ManagedCLR/MUtils.cpp
index 0d7617e0d..5c0ad1676 100644
--- a/Source/Engine/Scripting/ManagedCLR/MUtils.cpp
+++ b/Source/Engine/Scripting/ManagedCLR/MUtils.cpp
@@ -609,6 +609,12 @@ MObject* MUtils::BoxVariant(const Variant& value)
         return MCore::Object::Box((void*)&value.AsData, Double3::TypeInitializer.GetClass());
     case VariantType::Double4:
         return MCore::Object::Box((void*)&value.AsData, Double4::TypeInitializer.GetClass());
+    case VariantType::Int2:
+        return MCore::Object::Box((void*)&value.AsData, Int2::TypeInitializer.GetClass());
+    case VariantType::Int3:
+        return MCore::Object::Box((void*)&value.AsData, Int3::TypeInitializer.GetClass());
+    case VariantType::Int4:
+        return MCore::Object::Box((void*)&value.AsData, Int4::TypeInitializer.GetClass());
     case VariantType::Color:
         return MCore::Object::Box((void*)&value.AsData, stdTypes.ColorClass);
     case VariantType::Guid:
@@ -889,6 +895,12 @@ MClass* MUtils::GetClass(const VariantType& value)
         return Double3::TypeInitializer.GetClass();
     case VariantType::Double4:
         return Double4::TypeInitializer.GetClass();
+    case VariantType::Int2:
+        return Int2::TypeInitializer.GetClass();
+    case VariantType::Int3:
+        return Int3::TypeInitializer.GetClass();
+    case VariantType::Int4:
+        return Int4::TypeInitializer.GetClass();
     case VariantType::Color:
         return Color::TypeInitializer.GetClass();
     case VariantType::Guid:
@@ -979,6 +991,12 @@ MClass* MUtils::GetClass(const Variant& value)
         return Double3::TypeInitializer.GetClass();
     case VariantType::Double4:
         return Double4::TypeInitializer.GetClass();
+    case VariantType::Int2:
+        return Int2::TypeInitializer.GetClass();
+    case VariantType::Int3:
+        return Int3::TypeInitializer.GetClass();
+    case VariantType::Int4:
+        return Int4::TypeInitializer.GetClass();
     case VariantType::Color:
         return stdTypes.ColorClass;
     case VariantType::Guid:
@@ -1148,6 +1166,9 @@ void* MUtils::VariantToManagedArgPtr(Variant& value, MType* type, bool& failed)
         CASE_IN_BUILD_TYPE(Double2, AsData);
         CASE_IN_BUILD_TYPE(Double3, AsData);
         CASE_IN_BUILD_TYPE(Double4, AsBlob.Data);
+        CASE_IN_BUILD_TYPE(Int2, AsData);
+        CASE_IN_BUILD_TYPE(Int3, AsData);
+        CASE_IN_BUILD_TYPE(Int4, AsData);
 #undef CASE_IN_BUILD_TYPE
         if (klass->IsValueType())
         {
diff --git a/Source/Engine/Serialization/Stream.cpp b/Source/Engine/Serialization/Stream.cpp
index 5b109fd55..0ba3ced8b 100644
--- a/Source/Engine/Serialization/Stream.cpp
+++ b/Source/Engine/Serialization/Stream.cpp
@@ -288,12 +288,15 @@ void ReadStream::Read(Variant& data)
         break;
     }
     case VariantType::Float2:
+    case VariantType::Int2:
         ReadBytes(&data.AsData, sizeof(Float2));
         break;
     case VariantType::Float3:
+    case VariantType::Int3:
         ReadBytes(&data.AsData, sizeof(Float3));
         break;
     case VariantType::Float4:
+    case VariantType::Int4:
         ReadBytes(&data.AsData, sizeof(Float4));
         break;
     case VariantType::Double2:
@@ -687,12 +690,15 @@ void WriteStream::Write(const Variant& data)
         Write(id);
         break;
     case VariantType::Float2:
+    case VariantType::Int2:
         WriteBytes(data.AsData, sizeof(Float2));
         break;
     case VariantType::Float3:
+    case VariantType::Int3:
         WriteBytes(data.AsData, sizeof(Float3));
         break;
     case VariantType::Float4:
+    case VariantType::Int4:
         WriteBytes(data.AsData, sizeof(Float4));
         break;
     case VariantType::Double2:
diff --git a/Source/Engine/Visject/GraphUtilities.cpp b/Source/Engine/Visject/GraphUtilities.cpp
index 36bfe297f..13f43fc1a 100644
--- a/Source/Engine/Visject/GraphUtilities.cpp
+++ b/Source/Engine/Visject/GraphUtilities.cpp
@@ -256,6 +256,33 @@ void GraphUtilities::ApplySomeMathHere(Variant& v, Variant& a, MathOp1 op)
         vv.W = (double)op((float)aa.W);
         break;
     }
+    case VariantType::Int2:
+    {
+        Int2& vv = *(Int2*)v.AsData;
+        const Int2& aa = *(const Int2*)a.AsData;
+        vv.X = (int32)op((float)aa.X);
+        vv.Y = (int32)op((float)aa.Y);
+        break;
+    }
+    case VariantType::Int3:
+    {
+        Int3& vv = *(Int3*)v.AsData;
+        const Int3& aa = *(const Int3*)a.AsData;
+        vv.X = (int32)op((float)aa.X);
+        vv.Y = (int32)op((float)aa.Y);
+        vv.Z = (int32)op((float)aa.Z);
+        break;
+    }
+    case VariantType::Int4:
+    {
+        Int4& vv = *(Int4*)v.AsData;
+        const Int4& aa = *(const Int4*)a.AsData;
+        vv.X = (int32)op((float)aa.X);
+        vv.Y = (int32)op((float)aa.Y);
+        vv.Z = (int32)op((float)aa.Z);
+        vv.W = (int32)op((float)aa.W);
+        break;
+    }
     case VariantType::Quaternion:
     {
         Quaternion& vv = *(Quaternion*)v.AsData;
@@ -381,6 +408,36 @@ void GraphUtilities::ApplySomeMathHere(Variant& v, Variant& a, Variant& b, MathO
         vv.W = (double)op((float)aa.W, (float)bb.W);
         break;
     }
+    case VariantType::Int2:
+    {
+        Int2& vv = *(Int2*)v.AsData;
+        const Int2& aa = *(const Int2*)a.AsData;
+        const Int2& bb = *(const Int2*)b.AsData;
+        vv.X = (int32)op((float)aa.X, (float)bb.X);
+        vv.Y = (int32)op((float)aa.Y, (float)bb.Y);
+        break;
+    }
+    case VariantType::Int3:
+    {
+        Int3& vv = *(Int3*)v.AsData;
+        const Int3& aa = *(const Int3*)a.AsData;
+        const Int3& bb = *(const Int3*)b.AsData;
+        vv.X = (int32)op((float)aa.X, (float)bb.X);
+        vv.Y = (int32)op((float)aa.Y, (float)bb.Y);
+        vv.Z = (int32)op((float)aa.Z, (float)bb.Z);
+        break;
+    }
+    case VariantType::Int4:
+    {
+        Int4& vv = *(Int4*)v.AsData;
+        const Int4& aa = *(const Int4*)a.AsData;
+        const Int4& bb = *(const Int4*)b.AsData;
+        vv.X = (int32)op((float)aa.X, (float)bb.X);
+        vv.Y = (int32)op((float)aa.Y, (float)bb.Y);
+        vv.Z = (int32)op((float)aa.Z, (float)bb.Z);
+        vv.W = (int32)op((float)aa.W, (float)bb.W);
+        break;
+    }
     case VariantType::Quaternion:
     {
         Quaternion& vv = *(Quaternion*)v.AsData;
@@ -499,6 +556,39 @@ void GraphUtilities::ApplySomeMathHere(Variant& v, Variant& a, Variant& b, Varia
         vv.W = (double)op((float)aa.W, (float)bb.W, (float)cc.W);
         break;
     }
+    case VariantType::Int2:
+    {
+        Int2& vv = *(Int2*)v.AsData;
+        const Int3& aa = *(const Int2*)a.AsData;
+        const Int3& bb = *(const Int2*)b.AsData;
+        const Int3& cc = *(const Int2*)c.AsData;
+        vv.X = (int32)op((float)aa.X, (float)bb.X, (float)cc.X);
+        vv.Y = (int32)op((float)aa.Y, (float)bb.Y, (float)cc.Y);
+        break;
+    }
+    case VariantType::Int3:
+    {
+        Int3& vv = *(Int3*)v.AsData;
+        const Int3& aa = *(const Int3*)a.AsData;
+        const Int3& bb = *(const Int3*)b.AsData;
+        const Int3& cc = *(const Int3*)c.AsData;
+        vv.X = (int32)op((float)aa.X, (float)bb.X, (float)cc.X);
+        vv.Y = (int32)op((float)aa.Y, (float)bb.Y, (float)cc.Y);
+        vv.Z = (int32)op((float)aa.Z, (float)bb.Z, (float)cc.Z);
+        break;
+    }
+    case VariantType::Int4:
+    {
+        Int4& vv = *(Int4*)v.AsData;
+        const Int4& aa = *(const Int4*)a.AsData;
+        const Int4& bb = *(const Int4*)b.AsData;
+        const Int4& cc = *(const Int4*)c.AsData;
+        vv.X = (int32)op((float)aa.X, (float)bb.X, (float)cc.X);
+        vv.Y = (int32)op((float)aa.Y, (float)bb.Y, (float)cc.Y);
+        vv.Z = (int32)op((float)aa.Z, (float)bb.Z, (float)cc.Z);
+        vv.W = (int32)op((float)aa.W, (float)bb.W, (float)cc.W);
+        break;
+    }
     case VariantType::Quaternion:
     {
         Quaternion& vv = *(Quaternion*)v.AsData;