From 9eaa6e622b0ee4b0500055c470bbf5f2bbf70024 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:24:35 +0200
Subject: [PATCH 01/18] Uint16 & Int16 Scripting support.

---
 Source/Editor/Utilities/VariantUtils.cs | 5 ++++-
 Source/Engine/Core/Types/Variant.h      | 5 +++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/Source/Editor/Utilities/VariantUtils.cs b/Source/Editor/Utilities/VariantUtils.cs
index eb044c9e9..046ef7f54 100644
--- a/Source/Editor/Utilities/VariantUtils.cs
+++ b/Source/Editor/Utilities/VariantUtils.cs
@@ -55,7 +55,10 @@ namespace FlaxEditor.Utilities
 
             Int2,
             Int3,
-            Int4
+            Int4,
+            
+            Int16,
+            Uint16
         }
 
         internal static VariantType ToVariantType(this Type type)
diff --git a/Source/Engine/Core/Types/Variant.h b/Source/Engine/Core/Types/Variant.h
index ac9af0e79..2aabcfa17 100644
--- a/Source/Engine/Core/Types/Variant.h
+++ b/Source/Engine/Core/Types/Variant.h
@@ -58,6 +58,9 @@ API_STRUCT(InBuild) struct FLAXENGINE_API VariantType
         Int3,
         Int4,
 
+        Int16,
+        Uint16,
+
         MAX
     };
 
@@ -135,6 +138,8 @@ API_STRUCT(InBuild) struct FLAXENGINE_API Variant
     union
     {
         bool AsBool;
+        int16 AsInt16;
+        uint16 AsUint16;
         int32 AsInt;
         uint32 AsUint;
         int64 AsInt64;

From 0d6f81904d838e338049e2abe4833b7f0e921468 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:46:24 +0200
Subject: [PATCH 02/18] Uint16 & Int16 ScriptType ToString.

---
 Source/Editor/Scripting/ScriptType.cs | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/Source/Editor/Scripting/ScriptType.cs b/Source/Editor/Scripting/ScriptType.cs
index 870d68eba..d5ef0df86 100644
--- a/Source/Editor/Scripting/ScriptType.cs
+++ b/Source/Editor/Scripting/ScriptType.cs
@@ -354,6 +354,10 @@ namespace FlaxEditor.Scripting
 
                 if (Type.Type == typeof(float))
                     sb.Append("Float");
+                else if (Type.Type == typeof(short))
+                    sb.Append("Int16");
+                else if (Type.Type == typeof(ushort))
+                    sb.Append("Uint16");
                 else if (Type.Type == typeof(int))
                     sb.Append("Int");
                 else if (Type.Type == typeof(uint))
@@ -389,6 +393,24 @@ namespace FlaxEditor.Scripting
                         else
                             sb.Append(asUint);
                     }
+                    else if (DefaultValue is short asInt16)
+                    {
+                        if (asInt16 == short.MaxValue)
+                            sb.Append("Int16.MaxValue");
+                        else if (asInt16 == short.MinValue)
+                            sb.Append("Int16.MinValue");
+                        else
+                            sb.Append(asInt16);
+                    }
+                    else if (DefaultValue is ushort asUint16)
+                    {
+                        if (asUint16 == ushort.MaxValue)
+                            sb.Append("Uint16.MaxValue");
+                        else if (asUint16 == ushort.MinValue)
+                            sb.Append("Uint16.MinValue");
+                        else
+                            sb.Append(asUint16);
+                    }
                     else if (DefaultValue is float asFloat)
                     {
                         if (asFloat == float.MaxValue)

From 74916dddfd86d7b18d1db99647ea1cb76d4bf089 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:47:02 +0200
Subject: [PATCH 03/18] Add Uint16 & Int16 names.

---
 Source/Editor/Scripting/ScriptType.cs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Source/Editor/Scripting/ScriptType.cs b/Source/Editor/Scripting/ScriptType.cs
index d5ef0df86..d5a064546 100644
--- a/Source/Editor/Scripting/ScriptType.cs
+++ b/Source/Editor/Scripting/ScriptType.cs
@@ -725,6 +725,10 @@ namespace FlaxEditor.Scripting
                     return "Int";
                 if (_managed == typeof(uint))
                     return "Uint";
+                if (_managed == typeof(short))
+                    return "Int16";
+                if (_managed == typeof(ushort))
+                    return "Uint16";
                 if (_managed == typeof(bool))
                     return "Bool";
                 return _managed.Name;

From 98ca9161973eb0237f515f597ace88062a56db75 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:48:33 +0200
Subject: [PATCH 04/18] Int16 & Uint16 C# serialization.

---
 Source/Editor/Utilities/VariantUtils.cs | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/Source/Editor/Utilities/VariantUtils.cs b/Source/Editor/Utilities/VariantUtils.cs
index 046ef7f54..69c102343 100644
--- a/Source/Editor/Utilities/VariantUtils.cs
+++ b/Source/Editor/Utilities/VariantUtils.cs
@@ -70,6 +70,10 @@ namespace FlaxEditor.Utilities
                 variantType = VariantType.Void;
             else if (type == typeof(bool))
                 variantType = VariantType.Bool;
+            else if (type == typeof(short))
+                variantType = VariantType.Int16;
+            else if (type == typeof(ushort))
+                variantType = VariantType.Uint16;
             else if (type == typeof(int))
                 variantType = VariantType.Int;
             else if (type == typeof(uint))
@@ -245,6 +249,8 @@ namespace FlaxEditor.Utilities
             case VariantType.Null: return ScriptType.Null;
             case VariantType.Void: return new ScriptType(typeof(void));
             case VariantType.Bool: return new ScriptType(typeof(bool));
+            case VariantType.Int16: return new ScriptType(typeof(short));
+            case VariantType.Uint16: return new ScriptType(typeof(ushort));
             case VariantType.Int: return new ScriptType(typeof(int));
             case VariantType.Uint: return new ScriptType(typeof(uint));
             case VariantType.Int64: return new ScriptType(typeof(long));
@@ -312,6 +318,8 @@ namespace FlaxEditor.Utilities
             case VariantType.Null: return null;
             case VariantType.Void: return typeof(void);
             case VariantType.Bool: return typeof(bool);
+            case VariantType.Int16: return typeof(short);
+            case VariantType.Uint16: return typeof(ushort);
             case VariantType.Int: return typeof(int);
             case VariantType.Uint: return typeof(uint);
             case VariantType.Int64: return typeof(long);
@@ -381,6 +389,8 @@ namespace FlaxEditor.Utilities
             case VariantType.ManagedObject:
             case VariantType.Void: return null;
             case VariantType.Bool: return stream.ReadByte() != 0;
+            case VariantType.Int16: return stream.ReadInt16();
+            case VariantType.Uint16: return stream.ReadUInt16();
             case VariantType.Int: return stream.ReadInt32();
             case VariantType.Uint: return stream.ReadUInt32();
             case VariantType.Int64: return stream.ReadInt64();
@@ -516,6 +526,12 @@ namespace FlaxEditor.Utilities
             case VariantType.Bool:
                 stream.Write((byte)((bool)value ? 1 : 0));
                 break;
+            case VariantType.Int16:
+                stream.Write((short)value);
+                break;
+            case VariantType.Uint16:
+                stream.Write((ushort)value);
+                break;
             case VariantType.Int:
                 stream.Write((int)value);
                 break;
@@ -690,6 +706,12 @@ namespace FlaxEditor.Utilities
             case VariantType.Bool:
                 stream.WriteValue((bool)value);
                 break;
+            case VariantType.Int16:
+                stream.WriteValue((short)value);
+                break;
+            case VariantType.Uint16:
+                stream.WriteValue((ushort)value);
+                break;
             case VariantType.Int:
                 stream.WriteValue((int)value);
                 break;

From c59b61710681c5aeb4bd9450f2c5f888ea0764a1 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:50:07 +0200
Subject: [PATCH 05/18] Int16 & Uint16 Variant ctor.

---
 Source/Engine/Core/Types/Variant.cpp | 12 ++++++++++++
 Source/Engine/Core/Types/Variant.h   |  2 ++
 2 files changed, 14 insertions(+)

diff --git a/Source/Engine/Core/Types/Variant.cpp b/Source/Engine/Core/Types/Variant.cpp
index 97bcfc412..14f5548b7 100644
--- a/Source/Engine/Core/Types/Variant.cpp
+++ b/Source/Engine/Core/Types/Variant.cpp
@@ -417,6 +417,18 @@ Variant::Variant(bool v)
     AsBool = v;
 }
 
+Variant::Variant(int16 v)
+    : Type(VariantType::Int16)
+{
+    AsInt16 = v;
+}
+
+Variant::Variant(uint16 v)
+    : Type(VariantType::Uint16)
+{
+    AsUint16 = v;
+}
+
 Variant::Variant(int32 v)
     : Type(VariantType::Int)
 {
diff --git a/Source/Engine/Core/Types/Variant.h b/Source/Engine/Core/Types/Variant.h
index 2aabcfa17..6ab7a7a67 100644
--- a/Source/Engine/Core/Types/Variant.h
+++ b/Source/Engine/Core/Types/Variant.h
@@ -189,6 +189,8 @@ public:
     Variant(Variant&& other) noexcept;
 
     Variant(bool v);
+    Variant(int16 v);
+    Variant(uint16 v);
     Variant(int32 v);
     Variant(uint32 v);
     Variant(int64 v);

From 7ed39ef375445bc4d2137a650a415a85147256f3 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:50:35 +0200
Subject: [PATCH 06/18] Uint16 & Int16 ToString, Typename.

---
 Source/Engine/Core/Types/Variant.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/Source/Engine/Core/Types/Variant.cpp b/Source/Engine/Core/Types/Variant.cpp
index 14f5548b7..bb4467e23 100644
--- a/Source/Engine/Core/Types/Variant.cpp
+++ b/Source/Engine/Core/Types/Variant.cpp
@@ -160,6 +160,10 @@ const char* VariantType::GetTypeName() const
         return "System.Void";
     case Bool:
         return "System.Boolean";
+    case Int16:
+        return "System.Int16";
+    case Uint16:
+        return "System.UInt16";
     case Int:
         return "System.Int32";
     case Uint:
@@ -225,6 +229,12 @@ const char* VariantType::GetTypeName() const
     case Bool:
         result = TEXT("Bool");
         break;
+    case Int16:
+        result = TEXT("Int16");
+        break;
+    case Uint16:
+        result = TEXT("Uint16");
+        break;
     case Int:
         result = TEXT("Int");
         break;

From cff8c57dba94a3d2be93c17db7540be21facd8bc Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:51:18 +0200
Subject: [PATCH 07/18] Uint16 & int16 op overload.

---
 Source/Engine/Core/Types/Variant.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/Source/Engine/Core/Types/Variant.cpp b/Source/Engine/Core/Types/Variant.cpp
index bb4467e23..53f3bf889 100644
--- a/Source/Engine/Core/Types/Variant.cpp
+++ b/Source/Engine/Core/Types/Variant.cpp
@@ -918,6 +918,10 @@ bool Variant::operator==(const Variant& other) const
             return true;
         case VariantType::Bool:
             return AsBool == other.AsBool;
+        case VariantType::Int16:
+            return AsInt16 == other.AsInt16;
+        case VariantType::Uint16:
+            return AsUint16 == other.AsUint16;
         case VariantType::Int:
             return AsInt == other.AsInt;
         case VariantType::Uint:
@@ -1026,6 +1030,10 @@ bool Variant::operator<(const Variant& other) const
             return true;
         case VariantType::Bool:
             return AsBool < other.AsBool;
+        case VariantType::Int16:
+            return AsInt16 < other.AsInt16;
+        case VariantType::Uint16:
+            return AsUint16 < other.AsUint16;
         case VariantType::Int:
             return AsInt < other.AsInt;
         case VariantType::Uint:
@@ -1062,6 +1070,10 @@ Variant::operator bool() const
     {
     case VariantType::Bool:
         return AsBool;
+    case VariantType::Int16:
+        return AsInt16 != 0;
+    case VariantType::Uint16:
+        return AsUint16 != 0;
     case VariantType::Int:
         return AsInt != 0;
     case VariantType::Uint:
@@ -1097,6 +1109,10 @@ Variant::operator Char() const
     {
     case VariantType::Bool:
         return AsBool ? 1 : 0;
+    case VariantType::Int16:
+        return (Char)AsInt16;
+    case VariantType::Uint16:
+        return (Char)AsUint16;
     case VariantType::Int:
         return (Char)AsInt;
     case VariantType::Uint:

From ab5d78973279d7c6d067273f227f21a6dd0d2e26 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:52:13 +0200
Subject: [PATCH 08/18] Uint16 & Int16 Variant cast.

---
 Source/Engine/Core/Types/Variant.cpp | 40 ++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/Source/Engine/Core/Types/Variant.cpp b/Source/Engine/Core/Types/Variant.cpp
index 53f3bf889..42476afd8 100644
--- a/Source/Engine/Core/Types/Variant.cpp
+++ b/Source/Engine/Core/Types/Variant.cpp
@@ -1139,6 +1139,10 @@ Variant::operator int8() const
     {
     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:
@@ -1165,6 +1169,10 @@ Variant::operator int16() const
     {
     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:
@@ -1191,6 +1199,10 @@ Variant::operator int32() const
     {
     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:
@@ -1217,6 +1229,10 @@ Variant::operator int64() const
     {
     case VariantType::Bool:
         return AsBool ? 1 : 0;
+    case VariantType::Int16:
+        return (int64)AsInt16;
+    case VariantType::Uint16:
+        return (int64)AsUint16;
     case VariantType::Int:
         return (int64)AsInt;
     case VariantType::Uint:
@@ -1243,6 +1259,10 @@ Variant::operator uint8() const
     {
     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:
@@ -1269,6 +1289,10 @@ Variant::operator uint16() const
     {
     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:
@@ -1295,6 +1319,10 @@ Variant::operator uint32() const
     {
     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:
@@ -1321,6 +1349,10 @@ Variant::operator uint64() const
     {
     case VariantType::Bool:
         return AsBool ? 1 : 0;
+    case VariantType::Int16:
+        return (uint64)AsInt16;
+    case VariantType::Uint16:
+        return (uint64)AsUint16;
     case VariantType::Int:
         return (uint64)AsInt;
     case VariantType::Uint:
@@ -1347,6 +1379,10 @@ Variant::operator float() const
     {
     case VariantType::Bool:
         return AsBool ? 1.0f : 0.0f;
+    case VariantType::Int16:
+        return (float)AsInt16;
+    case VariantType::Uint16:
+        return (float)AsUint16;
     case VariantType::Int:
         return (float)AsInt;
     case VariantType::Uint:
@@ -1371,6 +1407,10 @@ Variant::operator double() const
     {
     case VariantType::Bool:
         return AsBool ? 1.0 : 0.0;
+    case VariantType::Int16:
+        return (double)AsInt16;
+    case VariantType::Uint16:
+        return (double)AsUint16;
     case VariantType::Int:
         return (double)AsInt;
     case VariantType::Uint:

From 08ca32657115d8d521d1f8b35d5ba13a7ed4b98f Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:52:48 +0200
Subject: [PATCH 09/18] Uint16 & Int16 more cast.

---
 Source/Engine/Core/Types/Variant.cpp | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/Source/Engine/Core/Types/Variant.cpp b/Source/Engine/Core/Types/Variant.cpp
index 42476afd8..c922ea6b4 100644
--- a/Source/Engine/Core/Types/Variant.cpp
+++ b/Source/Engine/Core/Types/Variant.cpp
@@ -1501,6 +1501,10 @@ Variant::operator Vector2() const
     {
     case VariantType::Bool:
         return Vector2(AsBool ? 1.0f : 0.0f);
+    case VariantType::Int16:
+        return Vector2((float)AsInt16);
+    case VariantType::Uint16:
+        return Vector2((float)AsUint16);
     case VariantType::Int:
         return Vector2((float)AsInt);
     case VariantType::Uint:
@@ -1537,6 +1541,10 @@ Variant::operator Vector3() const
     {
     case VariantType::Bool:
         return Vector3(AsBool ? 1.0f : 0.0f);
+    case VariantType::Int16:
+        return Vector3((float)AsInt16);
+    case VariantType::Uint16:
+        return Vector3((float)AsUint16);
     case VariantType::Int:
         return Vector3((float)AsInt);
     case VariantType::Uint:
@@ -1573,6 +1581,10 @@ Variant::operator Vector4() const
     {
     case VariantType::Bool:
         return Vector4(AsBool ? 1.0f : 0.0f);
+    case VariantType::Int16:
+        return Vector4((float)AsInt16);
+    case VariantType::Uint16:
+        return Vector4((float)AsUint16);
     case VariantType::Int:
         return Vector4((float)AsInt);
     case VariantType::Uint:
@@ -1609,6 +1621,10 @@ Variant::operator Int2() const
     {
     case VariantType::Bool:
         return Int2((int32)(AsBool ? 1.0f : 0.0f));
+    case VariantType::Int16:
+        return Int2((int32)AsInt16);
+    case VariantType::Uint16:
+        return Int2((int32)AsUint16);
     case VariantType::Int:
         return Int2((int32)AsInt);
     case VariantType::Uint:
@@ -1651,6 +1667,10 @@ Variant::operator Int3() const
     {
     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:
@@ -1693,6 +1713,10 @@ Variant::operator Int4() const
     {
     case VariantType::Bool:
         return Int4((int32)(AsBool ? 1 : 0));
+    case VariantType::Int16:
+        return Int4(AsInt16);
+    case VariantType::Uint16:
+        return Int4((int32)AsUint16);
     case VariantType::Int:
         return Int4(AsInt);
     case VariantType::Uint:
@@ -1735,6 +1759,10 @@ Variant::operator Color() const
     {
     case VariantType::Bool:
         return Color(AsBool ? 1.0f : 0.0f);
+    case VariantType::Int16:
+        return Color((float)AsInt16);
+    case VariantType::Uint16:
+        return Color((float)AsUint16);
     case VariantType::Int:
         return Color((float)AsInt);
     case VariantType::Uint:

From ab3de4777c62399f20f3b6b5c0854ff064ca050e Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:53:40 +0200
Subject: [PATCH 10/18] Uint16 & Int16 Variant ToString.

---
 Source/Engine/Core/Types/Variant.cpp | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Source/Engine/Core/Types/Variant.cpp b/Source/Engine/Core/Types/Variant.cpp
index c922ea6b4..06fd3a9f3 100644
--- a/Source/Engine/Core/Types/Variant.cpp
+++ b/Source/Engine/Core/Types/Variant.cpp
@@ -2245,6 +2245,10 @@ String Variant::ToString() const
         return TEXT("null");
     case VariantType::Bool:
         return AsBool ? TEXT("true") : TEXT("false");
+    case VariantType::Int16:
+        return StringUtils::ToString(AsInt16);
+    case VariantType::Uint16:
+        return StringUtils::ToString(AsUint16);
     case VariantType::Int:
         return StringUtils::ToString(AsInt);
     case VariantType::Uint:

From a5ec9d749bb2118edaec8f215145df1350a9e6e5 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:54:52 +0200
Subject: [PATCH 11/18] Uint16 & Int16 Variant CanCast.

---
 Source/Engine/Core/Types/Variant.cpp | 58 ++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)

diff --git a/Source/Engine/Core/Types/Variant.cpp b/Source/Engine/Core/Types/Variant.cpp
index 06fd3a9f3..5ef66879d 100644
--- a/Source/Engine/Core/Types/Variant.cpp
+++ b/Source/Engine/Core/Types/Variant.cpp
@@ -2317,6 +2317,8 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
     case VariantType::Bool:
         switch (to.Type)
         {
+        case VariantType::Int16:
+        case VariantType::Uint16:
         case VariantType::Int:
         case VariantType::Uint:
         case VariantType::Int64:
@@ -2331,10 +2333,50 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         default:
             return false;
         }
+    case VariantType::Int16:
+        switch (to.Type)
+        {
+        case VariantType::Bool:
+        case VariantType::Int:
+        case VariantType::Int64:
+        case VariantType::Uint16:
+        case VariantType::Uint:
+        case VariantType::Uint64:
+        case VariantType::Float:
+        case VariantType::Double:
+        case VariantType::Vector2:
+        case VariantType::Vector3:
+        case VariantType::Vector4:
+        case VariantType::Color:
+            return true;
+        default:
+            return false;
+        }
     case VariantType::Int:
         switch (to.Type)
         {
         case VariantType::Bool:
+        case VariantType::Int16:
+        case VariantType::Int64:
+        case VariantType::Uint16:
+        case VariantType::Uint:
+        case VariantType::Uint64:
+        case VariantType::Float:
+        case VariantType::Double:
+        case VariantType::Vector2:
+        case VariantType::Vector3:
+        case VariantType::Vector4:
+        case VariantType::Color:
+            return true;
+        default:
+            return false;
+        }
+    case VariantType::Uint16:
+        switch (to.Type)
+        {
+        case VariantType::Bool:
+        case VariantType::Int16:
+        case VariantType::Int:
         case VariantType::Int64:
         case VariantType::Uint:
         case VariantType::Uint64:
@@ -2352,7 +2394,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         switch (to.Type)
         {
         case VariantType::Bool:
+        case VariantType::Uint16:
         case VariantType::Uint64:
+        case VariantType::Int16:
         case VariantType::Int:
         case VariantType::Int64:
         case VariantType::Float:
@@ -2369,7 +2413,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         switch (to.Type)
         {
         case VariantType::Bool:
+        case VariantType::Int16:
         case VariantType::Int:
+        case VariantType::Uint16:
         case VariantType::Uint:
         case VariantType::Uint64:
         case VariantType::Float:
@@ -2386,7 +2432,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         switch (to.Type)
         {
         case VariantType::Bool:
+        case VariantType::Uint16:
         case VariantType::Uint:
+        case VariantType::Int16:
         case VariantType::Int:
         case VariantType::Int64:
         case VariantType::Float:
@@ -2403,7 +2451,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         switch (to.Type)
         {
         case VariantType::Bool:
+        case VariantType::Int16:
         case VariantType::Int:
+        case VariantType::Uint16:
         case VariantType::Uint:
         case VariantType::Int64:
         case VariantType::Uint64:
@@ -2420,8 +2470,10 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         switch (to.Type)
         {
         case VariantType::Bool:
+        case VariantType::Int16:
         case VariantType::Int:
         case VariantType::Uint:
+        case VariantType::Uint16:
         case VariantType::Int64:
         case VariantType::Uint64:
         case VariantType::Float:
@@ -2437,7 +2489,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         switch (to.Type)
         {
         case VariantType::Bool:
+        case VariantType::Uint16:
         case VariantType::Uint:
+        case VariantType::Int16:
         case VariantType::Int:
         case VariantType::Int64:
         case VariantType::Float:
@@ -2454,6 +2508,7 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         {
         case VariantType::Bool:
         case VariantType::Uint:
+        case VariantType::Int16:
         case VariantType::Int:
         case VariantType::Int64:
         case VariantType::Float:
@@ -2469,7 +2524,9 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         switch (to.Type)
         {
         case VariantType::Bool:
+        case VariantType::Uint16:
         case VariantType::Uint:
+        case VariantType::Int16:
         case VariantType::Int:
         case VariantType::Int64:
         case VariantType::Float:
@@ -2486,6 +2543,7 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         {
         case VariantType::Bool:
         case VariantType::Uint:
+        case VariantType::Int16:
         case VariantType::Int:
         case VariantType::Int64:
         case VariantType::Float:

From 954a11a1b0ef9826ca6a8218194c47423e2f9027 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:55:17 +0200
Subject: [PATCH 12/18] Uint16 & Int16 Variant CanCast.

---
 Source/Engine/Core/Types/Variant.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Source/Engine/Core/Types/Variant.cpp b/Source/Engine/Core/Types/Variant.cpp
index 5ef66879d..5a8315fc5 100644
--- a/Source/Engine/Core/Types/Variant.cpp
+++ b/Source/Engine/Core/Types/Variant.cpp
@@ -2507,6 +2507,7 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         switch (to.Type)
         {
         case VariantType::Bool:
+        case VariantType::Uint16:
         case VariantType::Uint:
         case VariantType::Int16:
         case VariantType::Int:

From 78ed675edabbb7b57a61c797150ad2fd034cdd48 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:55:43 +0200
Subject: [PATCH 13/18] Uint16 & Int16 Variant CanCast.

---
 Source/Engine/Core/Types/Variant.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Source/Engine/Core/Types/Variant.cpp b/Source/Engine/Core/Types/Variant.cpp
index 5a8315fc5..945337192 100644
--- a/Source/Engine/Core/Types/Variant.cpp
+++ b/Source/Engine/Core/Types/Variant.cpp
@@ -2543,6 +2543,7 @@ bool Variant::CanCast(const Variant& v, const VariantType& to)
         switch (to.Type)
         {
         case VariantType::Bool:
+        case VariantType::Uint16:
         case VariantType::Uint:
         case VariantType::Int16:
         case VariantType::Int:

From 97338d61d2deec1d0158e594987811e8b29cdb36 Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:56:48 +0200
Subject: [PATCH 14/18] Uint16 & Int16 Variant Cast.

---
 Source/Engine/Core/Types/Variant.cpp | 112 ++++++++++++++++++++++++++-
 1 file changed, 108 insertions(+), 4 deletions(-)

diff --git a/Source/Engine/Core/Types/Variant.cpp b/Source/Engine/Core/Types/Variant.cpp
index 945337192..82aa3c8af 100644
--- a/Source/Engine/Core/Types/Variant.cpp
+++ b/Source/Engine/Core/Types/Variant.cpp
@@ -2571,6 +2571,10 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
     case VariantType::Bool:
         switch (to.Type)
         {
+        case VariantType::Int16: // No portable literal suffix for short ( Available in MSVC but Undocumented : i16 )
+            return Variant((int16)(v.AsBool ? 1 : 0));
+        case VariantType::Uint16: // No portable literal suffix for short ( Available in MSVC but Undocumented : ui16 )
+            return Variant((uint16)(v.AsBool ? 1 : 0));
         case VariantType::Int:
             return Variant(v.AsBool ? 1 : 0);
         case VariantType::Uint:
@@ -2594,17 +2598,51 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
         default: ;
         }
         break;
+    case VariantType::Int16:
+        switch (to.Type)
+        {
+        case VariantType::Bool:
+            return Variant(v.AsInt != 0);
+        case VariantType::Int:
+            return Variant((int32)v.AsInt16);
+        case VariantType::Int64:
+            return Variant((int64)v.AsInt16);
+        case VariantType::Uint16:
+            return Variant((uint16)v.AsInt16);
+        case VariantType::Uint:
+            return Variant((uint32)v.AsInt16);
+        case VariantType::Uint64:
+            return Variant((uint64)v.AsInt16);
+        case VariantType::Float:
+            return Variant((float)v.AsInt16);
+        case VariantType::Double:
+            return Variant((double)v.AsInt16);
+        case VariantType::Vector2:
+            return Variant(Vector2((float)v.AsInt16));
+        case VariantType::Vector3:
+            return Variant(Vector3((float)v.AsInt16));
+        case VariantType::Vector4:
+            return Variant(Vector4((float)v.AsInt16));
+        case VariantType::Color:
+            return Variant(Color((float)v.AsInt16));
+        default: ;
+        }
+        break;
     case VariantType::Int:
         switch (to.Type)
         {
         case VariantType::Bool:
             return Variant(v.AsInt != 0);
+        case VariantType::Int16:
+            return Variant((int16)v.AsInt);
         case VariantType::Int64:
-            return Variant((int64)v.AsUint);
+            return Variant((int64)v.AsInt);
+        case VariantType::Uint16:
+            return Variant((uint16)v.AsInt);
         case VariantType::Uint:
             return Variant((uint32)v.AsInt);
         case VariantType::Uint64:
-            return Variant((uint64)v.AsUint);
+            return Variant((uint64)v.AsInt);
         case VariantType::Float:
             return Variant((float)v.AsInt);
         case VariantType::Double:
@@ -2620,15 +2658,49 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
         default: ;
         }
         break;
+    case VariantType::Uint16:
+        switch (to.Type)
+        {
+        case VariantType::Bool:
+            return Variant(v.AsUint16 != 0);
+        case VariantType::Int16:
+            return Variant((int16)v.AsUint16);
+        case VariantType::Int:
+            return Variant((int32)v.AsUint16);
+        case VariantType::Int64:
+            return Variant((int64)v.AsUint16);
+        case VariantType::Uint16:
+            return Variant((uint16)v.AsUint16);
+        case VariantType::Uint64:
+            return Variant((uint64)v.AsUint16);
+        case VariantType::Float:
+            return Variant((float)v.AsUint16);
+        case VariantType::Double:
+            return Variant((double)v.AsUint16);
+        case VariantType::Vector2:
+            return Variant(Vector2((float)v.AsUint16));
+        case VariantType::Vector3:
+            return Variant(Vector3((float)v.AsUint16));
+        case VariantType::Vector4:
+            return Variant(Vector4((float)v.AsUint16));
+        case VariantType::Color:
+            return Variant(Color((float)v.AsUint16));
+        default: ;
+        }
+        break;
     case VariantType::Uint:
         switch (to.Type)
         {
         case VariantType::Bool:
             return Variant(v.AsUint != 0);
+        case VariantType::Int16:
+            return Variant((int16)v.AsUint);
         case VariantType::Int:
             return Variant((int32)v.AsUint);
         case VariantType::Int64:
             return Variant((int64)v.AsUint);
+        case VariantType::Uint16:
+            return Variant((uint16)v.AsUint);
         case VariantType::Uint64:
             return Variant((uint64)v.AsUint);
         case VariantType::Float:
@@ -2651,8 +2723,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
         {
         case VariantType::Bool:
             return Variant(v.AsInt64 != 0);
-        case VariantType::Int64:
-            return Variant((int64)v.AsUint);
+        case VariantType::Int16:
+            return Variant((int16)v.AsInt64);
+        case VariantType::Int:
+            return Variant((int32)v.AsInt64);
+        case VariantType::Uint16:
+            return Variant((uint16)v.AsInt64);
         case VariantType::Uint:
             return Variant((uint32)v.AsInt64);
         case VariantType::Uint64:
@@ -2677,10 +2753,14 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
         {
         case VariantType::Bool:
             return Variant(v.AsUint64 != 0);
+        case VariantType::Int16:
+            return Variant((int16)v.AsUint64);
         case VariantType::Int:
             return Variant((int32)v.AsUint64);
         case VariantType::Int64:
             return Variant((int64)v.AsUint64);
+        case VariantType::Uint16:
+            return Variant((uint16)v.AsUint16);
         case VariantType::Uint:
             return Variant((uint32)v.AsUint);
         case VariantType::Float:
@@ -2703,8 +2783,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
         {
         case VariantType::Bool:
             return Variant(Math::Abs(v.AsFloat) > ZeroTolerance);
+        case VariantType::Int16:
+            return Variant((int16)v.AsFloat);
         case VariantType::Int:
             return Variant((int32)v.AsFloat);
+        case VariantType::Uint16:
+            return Variant((uint16)v.AsFloat);
         case VariantType::Uint:
             return Variant((uint32)v.AsFloat);
         case VariantType::Int64:
@@ -2729,8 +2813,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
         {
         case VariantType::Bool:
             return Variant(Math::Abs(v.AsDouble) > ZeroTolerance);
+        case VariantType::Int16:
+            return Variant((int16)v.AsDouble);
         case VariantType::Int:
             return Variant((int32)v.AsDouble);
+        case VariantType::Uint16:
+            return Variant((uint16)v.AsDouble);
         case VariantType::Uint:
             return Variant((uint32)v.AsDouble);
         case VariantType::Int64:
@@ -2755,8 +2843,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
         {
         case VariantType::Bool:
             return Variant(Math::Abs(((Vector2*)v.AsData)->X) > ZeroTolerance);
+        case VariantType::Int16:
+            return Variant((int16)((Vector2*)v.AsData)->X);
         case VariantType::Int:
             return Variant((int32)((Vector2*)v.AsData)->X);
+        case VariantType::Uint16:
+            return Variant((uint16)((Vector2*)v.AsData)->X);
         case VariantType::Uint:
             return Variant((uint32)((Vector2*)v.AsData)->X);
         case VariantType::Int64:
@@ -2781,8 +2873,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
         {
         case VariantType::Bool:
             return Variant(Math::Abs(((Vector3*)v.AsData)->X) > ZeroTolerance);
+        case VariantType::Int16:
+            return Variant((int16)((Vector3*)v.AsData)->X);
         case VariantType::Int:
             return Variant((int32)((Vector3*)v.AsData)->X);
+        case VariantType::Uint16:
+            return Variant((uint16)((Vector3*)v.AsData)->X);
         case VariantType::Uint:
             return Variant((uint32)((Vector3*)v.AsData)->X);
         case VariantType::Int64:
@@ -2807,8 +2903,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
         {
         case VariantType::Bool:
             return Variant(Math::Abs(((Vector4*)v.AsData)->X) > ZeroTolerance);
+        case VariantType::Int16:
+            return Variant((int16)((Vector4*)v.AsData)->X);
         case VariantType::Int:
             return Variant((int32)((Vector4*)v.AsData)->X);
+        case VariantType::Uint16:
+            return Variant((uint16)((Vector4*)v.AsData)->X);
         case VariantType::Uint:
             return Variant((uint32)((Vector4*)v.AsData)->X);
         case VariantType::Int64:
@@ -2833,8 +2933,12 @@ Variant Variant::Cast(const Variant& v, const VariantType& to)
         {
         case VariantType::Bool:
             return Variant(Math::Abs(((Color*)v.AsData)->R) > ZeroTolerance);
+        case VariantType::Int16:
+            return Variant((int16)((Color*)v.AsData)->R);
         case VariantType::Int:
             return Variant((int32)((Color*)v.AsData)->R);
+        case VariantType::Uint16:
+            return Variant((uint16)((Color*)v.AsData)->R);
         case VariantType::Uint:
             return Variant((uint32)((Color*)v.AsData)->R);
         case VariantType::Int64:

From 4764e7914d5f18abfb437b6e5bfab58d2a17759b Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:57:26 +0200
Subject: [PATCH 15/18] Int16 & Uint16 NearEqual, Lerp, Hash.

---
 Source/Engine/Core/Types/Variant.cpp | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/Source/Engine/Core/Types/Variant.cpp b/Source/Engine/Core/Types/Variant.cpp
index 82aa3c8af..ac150d44d 100644
--- a/Source/Engine/Core/Types/Variant.cpp
+++ b/Source/Engine/Core/Types/Variant.cpp
@@ -2970,6 +2970,8 @@ bool Variant::NearEqual(const Variant& a, const Variant& b, float epsilon)
         return false;
     switch (a.Type.Type)
     {
+    case VariantType::Int16:
+        return Math::Abs(a.AsInt16 - b.AsInt16) <= (int32)epsilon;
     case VariantType::Int:
         return Math::Abs(a.AsInt - b.AsInt) <= (int32)epsilon;
     case VariantType::Int64:
@@ -3011,8 +3013,12 @@ Variant Variant::Lerp(const Variant& a, const Variant& b, float alpha)
     {
     case VariantType::Bool:
         return alpha < 0.5f ? a : b;
+    case VariantType::Int16:
+        return Math::Lerp(a.AsInt16, b.AsInt16, alpha);
     case VariantType::Int:
         return Math::Lerp(a.AsInt, b.AsInt, alpha);
+    case VariantType::Uint16:
+        return Math::Lerp(a.AsUint16, b.AsUint16, alpha);
     case VariantType::Uint:
         return Math::Lerp(a.AsUint, b.AsUint, alpha);
     case VariantType::Int64:
@@ -3118,8 +3124,12 @@ uint32 GetHash(const Variant& key)
     {
     case VariantType::Bool:
         return GetHash(key.AsBool);
+    case VariantType::Int16:
+        return GetHash(key.AsInt16);
     case VariantType::Int:
         return GetHash(key.AsInt);
+    case VariantType::Uint16:
+        return GetHash(key.AsUint16);
     case VariantType::Uint:
         return GetHash(key.AsUint);
     case VariantType::Int64:

From 7506142dbb4839b9f443dcc27f87f99285287fca Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:57:49 +0200
Subject: [PATCH 16/18] Uint16 & Int16 CPP serialization.

---
 Source/Engine/Serialization/Stream.cpp | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/Source/Engine/Serialization/Stream.cpp b/Source/Engine/Serialization/Stream.cpp
index 269d49562..21d10f987 100644
--- a/Source/Engine/Serialization/Stream.cpp
+++ b/Source/Engine/Serialization/Stream.cpp
@@ -274,6 +274,12 @@ void ReadStream::ReadVariant(Variant* data)
     case VariantType::Bool:
         data->AsBool = ReadBool();
         break;
+    case VariantType::Int16:
+        ReadInt16(&data->AsInt16);
+        break;
+    case VariantType::Uint16:
+        ReadUint16(&data->AsUint16);
+        break;
     case VariantType::Int:
         ReadInt32(&data->AsInt);
         break;
@@ -573,6 +579,12 @@ void WriteStream::WriteVariant(const Variant& data)
     case VariantType::Bool:
         WriteBool(data.AsBool);
         break;
+    case VariantType::Int16:
+        WriteInt16(data.AsInt16);
+        break;
+    case VariantType::Uint16:
+        WriteUint16(data.AsUint16);
+        break;
     case VariantType::Int:
         WriteInt32(data.AsInt);
         break;

From 95c4004ad8a180c30697ba4e47740eae811154bb Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Mon, 10 May 2021 22:59:10 +0200
Subject: [PATCH 17/18] Uint16 & Int16 Mono glue code.

---
 Source/Engine/Scripting/ManagedCLR/MUtils.cpp | 34 ++++++++++++++-----
 1 file changed, 26 insertions(+), 8 deletions(-)

diff --git a/Source/Engine/Scripting/ManagedCLR/MUtils.cpp b/Source/Engine/Scripting/ManagedCLR/MUtils.cpp
index 8c9326337..a43220f08 100644
--- a/Source/Engine/Scripting/ManagedCLR/MUtils.cpp
+++ b/Source/Engine/Scripting/ManagedCLR/MUtils.cpp
@@ -154,13 +154,13 @@ VariantType MUtils::UnboxVariantType(MonoType* monoType)
     if (klass == mono_get_boolean_class() || monoType->type == MONO_TYPE_BOOLEAN)
         return VariantType(VariantType::Bool);
     if (klass == mono_get_byte_class() || monoType->type == MONO_TYPE_U1)
-        return VariantType(VariantType::Int);
+        return VariantType(VariantType::Int16);
     if (klass == mono_get_sbyte_class() || monoType->type == MONO_TYPE_I1)
-        return VariantType(VariantType::Int);
+        return VariantType(VariantType::Int16);
     if (klass == mono_get_int16_class() || monoType->type == MONO_TYPE_I2)
-        return VariantType(VariantType::Int);
+        return VariantType(VariantType::Int16);
     if (klass == mono_get_uint16_class() || monoType->type == MONO_TYPE_U2)
-        return VariantType(VariantType::Uint);
+        return VariantType(VariantType::Uint16);
     if (klass == mono_get_int32_class() || monoType->type == MONO_TYPE_I4)
         return VariantType(VariantType::Int);
     if (klass == mono_get_uint32_class() || monoType->type == MONO_TYPE_U4)
@@ -266,13 +266,13 @@ Variant MUtils::UnboxVariant(MonoObject* value)
     if (klass == mono_get_boolean_class())
         return *static_cast<bool*>(mono_object_unbox(value));
     if (klass == mono_get_byte_class())
-        return (int32)*static_cast<byte*>(mono_object_unbox(value));
+        return (int16)*static_cast<byte*>(mono_object_unbox(value));
     if (klass == mono_get_sbyte_class())
-        return (int32)*static_cast<int8*>(mono_object_unbox(value));
+        return (int16)*static_cast<int8*>(mono_object_unbox(value));
     if (klass == mono_get_int16_class())
-        return (int32)*static_cast<int16*>(mono_object_unbox(value));
+        return *static_cast<int16*>(mono_object_unbox(value));
     if (klass == mono_get_uint16_class())
-        return (uint32)*static_cast<uint16*>(mono_object_unbox(value));
+        return *static_cast<uint16*>(mono_object_unbox(value));
     if (klass == mono_get_int32_class())
         return *static_cast<int32*>(mono_object_unbox(value));
     if (klass == mono_get_uint32_class())
@@ -365,6 +365,10 @@ MonoObject* MUtils::BoxVariant(const Variant& value)
         return nullptr;
     case VariantType::Bool:
         return mono_value_box(mono_domain_get(), mono_get_boolean_class(), (void*)&value.AsBool);
+    case VariantType::Int16:
+        return mono_value_box(mono_domain_get(), mono_get_int16_class(), (void*)&value.AsInt16);
+    case VariantType::Uint16:
+        return mono_value_box(mono_domain_get(), mono_get_uint16_class(), (void*)&value.AsUint16);
     case VariantType::Int:
         return mono_value_box(mono_domain_get(), mono_get_int32_class(), (void*)&value.AsInt);
     case VariantType::Uint:
@@ -534,6 +538,10 @@ MonoClass* MUtils::GetClass(const VariantType& value)
         return mono_get_void_class();
     case VariantType::Bool:
         return mono_get_boolean_class();
+    case VariantType::Int16:
+        return mono_get_int16_class();
+    case VariantType::Uint16:
+        return mono_get_uint16_class();
     case VariantType::Int:
         return mono_get_int32_class();
     case VariantType::Uint:
@@ -600,6 +608,10 @@ MonoClass* MUtils::GetClass(const Variant& value)
         return mono_get_void_class();
     case VariantType::Bool:
         return mono_get_boolean_class();
+    case VariantType::Int16:
+        return mono_get_int16_class();
+    case VariantType::Uint16:
+        return mono_get_uint16_class();
     case VariantType::Int:
         return mono_get_int32_class();
     case VariantType::Uint:
@@ -700,12 +712,18 @@ void* MUtils::VariantToManagedArgPtr(Variant& value, const MType& type, bool& fa
     case MONO_TYPE_CHAR:
     case MONO_TYPE_I1:
     case MONO_TYPE_I2:
+        if (value.Type.Type != VariantType::Int16)
+            value = (int16)value;
+        return &value.AsInt16;
     case MONO_TYPE_I4:
         if (value.Type.Type != VariantType::Int)
             value = (int32)value;
         return &value.AsInt;
     case MONO_TYPE_U1:
     case MONO_TYPE_U2:
+        if (value.Type.Type != VariantType::Uint16)
+            value = (uint16)value;
+        return &value.AsUint16;
     case MONO_TYPE_U4:
         if (value.Type.Type != VariantType::Uint)
             value = (uint32)value;

From 03c95b55979e8a498d95c0011534bb3c90d301fe Mon Sep 17 00:00:00 2001
From: Jean-Baptiste Perrier <jeanbapt.perrier@gmail.com>
Date: Wed, 12 May 2021 18:38:17 +0200
Subject: [PATCH 18/18] Add , to enum.

---
 Source/Editor/Utilities/VariantUtils.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Source/Editor/Utilities/VariantUtils.cs b/Source/Editor/Utilities/VariantUtils.cs
index 69c102343..3af1a891b 100644
--- a/Source/Editor/Utilities/VariantUtils.cs
+++ b/Source/Editor/Utilities/VariantUtils.cs
@@ -58,7 +58,7 @@ namespace FlaxEditor.Utilities
             Int4,
             
             Int16,
-            Uint16
+            Uint16,
         }
 
         internal static VariantType ToVariantType(this Type type)