GoaLitiuM/FlaxEngine
1
0
Fork 0
Code Issues Pull Requests Actions 7 Packages Projects Releases Wiki Activity

Merge branch 'scripting-int16-support' of git://github.com/jb-perrier/FlaxEngine into jb-perrier-scripting-int16-support

Browse Source
This commit is contained in:
Wojtek Figat
2021-05-19 19:50:06 +02:00
parent 62cca0682c 03c95b5597
commit 7edf3e5b36
6 changed files with 385 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
Source/Editor/Scripting/ScriptType.cs
View File

@@ -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)
@@ -703,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;

27
Source/Editor/Utilities/VariantUtils.cs
View File

@@ -55,7 +55,10 @@ namespace FlaxEditor.Utilities
Int2,
Int3,
Int4
Int4,
Int16,
Uint16,
}
internal static VariantType ToVariantType(this Type type)
@@ -67,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))
@@ -242,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));
@@ -309,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);
@@ -378,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();
@@ -513,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;
@@ -687,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;

292
Source/Engine/Core/Types/Variant.cpp
View File

@@ -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;
@@ -417,6 +427,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)
{
@@ -896,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:
@@ -1004,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:
@@ -1040,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:
@@ -1075,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:
@@ -1101,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:
@@ -1127,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:
@@ -1153,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:
@@ -1179,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:
@@ -1205,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:
@@ -1231,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:
@@ -1257,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:
@@ -1283,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:
@@ -1309,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:
@@ -1333,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:
@@ -1423,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:
@@ -1459,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:
@@ -1495,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:
@@ -1531,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:
@@ -1573,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:
@@ -1615,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:
@@ -1657,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:
@@ -2139,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:
@@ -2207,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:
@@ -2221,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:
@@ -2242,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:
@@ -2259,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:
@@ -2276,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:
@@ -2293,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:
@@ -2310,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:
@@ -2327,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:
@@ -2343,7 +2507,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:
@@ -2359,7 +2525,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:
@@ -2375,7 +2543,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:
@@ -2401,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:
@@ -2424,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:
@@ -2450,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:
@@ -2481,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:
@@ -2507,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:
@@ -2533,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:
@@ -2559,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:
@@ -2585,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:
@@ -2611,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:
@@ -2637,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:
@@ -2663,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:
@@ -2696,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:
@@ -2737,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:
@@ -2844,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:

7
Source/Engine/Core/Types/Variant.h
View File

@@ -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;
@@ -184,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);

34
Source/Engine/Scripting/ManagedCLR/MUtils.cpp
View File

@@ -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;

12
Source/Engine/Serialization/Stream.cpp
View File

@@ -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;