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