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

Add support for Double2/3/4 for Variant

Browse Source 
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
This commit is contained in:
Wojtek Figat
2022-05-20 18:10:35 +02:00
parent 2369b6a34a
commit ed908a260e
9 changed files with 894 additions and 442 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -60,6 +60,10 @@ namespace FlaxEditor.Utilities
Int16,
Uint16,
Double2,
Double3,
Double4,
}
internal static VariantType ToVariantType(this Type type)

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

File diff suppressed because it is too large Load Diff

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

@@ -61,6 +61,10 @@ API_STRUCT(InBuild) struct FLAXENGINE_API VariantType
Int16,
Uint16,
Double2,
Double3,
Double4,
MAX
};
@@ -162,7 +166,7 @@ API_STRUCT(InBuild) struct FLAXENGINE_API Variant
Dictionary<Variant, Variant, HeapAllocation>* AsDictionary;
byte AsData[16];
byte AsData[24];
};
public:
@@ -215,6 +219,9 @@ public:
Variant(const Vector2& v);
Variant(const Vector3& v);
Variant(const Vector4& v);
Variant(const Double2& v);
Variant(const Double3& v);
Variant(const Double4& v);
Variant(const Int2& v);
Variant(const Int3& v);
Variant(const Int4& v);
@@ -285,6 +292,9 @@ public:
explicit operator Vector2() const;
explicit operator Vector3() const;
explicit operator Vector4() const;
explicit operator Double2() const;
explicit operator Double3() const;
explicit operator Double4() const;
explicit operator Int2() const;
explicit operator Int3() const;
explicit operator Int4() const;
@@ -302,11 +312,21 @@ public:
Vector3& AsVector3();
const Vector3& AsVector3() const;
const Vector4& AsVector4() const;
const Double2& AsDouble2() const;
const Double3& AsDouble3() const;
const Double4& AsDouble4() const;
const Int2& AsInt2() const;
const Int3& AsInt3() const;
const Int4& AsInt4() const;
const Color& AsColor() const;
const Quaternion& AsQuaternion() const;
const Rectangle& AsRectangle() const;
const Guid& AsGuid() const;
const BoundingSphere& AsBoundingSphere() const;
const BoundingBox& AsBoundingBox() const;
const Ray& AsRay() const;
const Transform& AsTransform() const;
const Matrix& AsMatrix() const;
Array<Variant, HeapAllocation>& AsArray();
const Array<Variant, HeapAllocation>& AsArray() const;

10
Source/Engine/Scripting/BinaryModule.cpp
View File

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

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

@@ -12,6 +12,12 @@
#include "Engine/Core/Math/Vector2.h"
#include "Engine/Core/Math/Vector3.h"
#include "Engine/Core/Math/Vector4.h"
#include "Engine/Core/Math/Double2.h"
#include "Engine/Core/Math/Double3.h"
#include "Engine/Core/Math/Double4.h"
#include "Engine/Core/Math/Int2.h"
#include "Engine/Core/Math/Int3.h"
#include "Engine/Core/Math/Int4.h"
#include "Engine/Core/Math/Quaternion.h"
#include "Engine/Core/Math/Matrix.h"
#include "Engine/Core/Math/Transform.h"
@@ -236,6 +242,18 @@ VariantType MUtils::UnboxVariantType(MonoType* monoType)
return VariantType(VariantType::Vector3);
if (klass == stdTypes.Vector4Class->GetNative())
return VariantType(VariantType::Vector4);
if (klass == Int2::TypeInitializer.GetMonoClass())
return VariantType(VariantType::Int2);
if (klass == Int3::TypeInitializer.GetMonoClass())
return VariantType(VariantType::Int3);
if (klass == Int4::TypeInitializer.GetMonoClass())
return VariantType(VariantType::Int4);
if (klass == Double2::TypeInitializer.GetMonoClass())
return VariantType(VariantType::Double2);
if (klass == Double3::TypeInitializer.GetMonoClass())
return VariantType(VariantType::Double3);
if (klass == Double4::TypeInitializer.GetMonoClass())
return VariantType(VariantType::Double4);
if (klass == stdTypes.ColorClass->GetNative())
return VariantType(VariantType::Color);
if (klass == stdTypes.BoundingBoxClass->GetNative())
@@ -359,6 +377,18 @@ Variant MUtils::UnboxVariant(MonoObject* value)
return *static_cast<Vector3*>(unboxed);
if (klass == stdTypes.Vector4Class->GetNative())
return *static_cast<Vector4*>(unboxed);
if (klass == Int2::TypeInitializer.GetType().ManagedClass->GetNative())
return *static_cast<Int2*>(unboxed);
if (klass == Int3::TypeInitializer.GetType().ManagedClass->GetNative())
return *static_cast<Int3*>(unboxed);
if (klass == Int4::TypeInitializer.GetType().ManagedClass->GetNative())
return *static_cast<Int4*>(unboxed);
if (klass == Double2::TypeInitializer.GetType().ManagedClass->GetNative())
return *static_cast<Double2*>(unboxed);
if (klass == Double3::TypeInitializer.GetType().ManagedClass->GetNative())
return *static_cast<Double3*>(unboxed);
if (klass == Double4::TypeInitializer.GetType().ManagedClass->GetNative())
return *static_cast<Double4*>(unboxed);
if (klass == stdTypes.ColorClass->GetNative())
return *static_cast<Color*>(unboxed);
if (klass == stdTypes.BoundingBoxClass->GetNative())
@@ -421,6 +451,8 @@ Variant MUtils::UnboxVariant(MonoObject* value)
case VariantType::Color:
case VariantType::Guid:
case VariantType::BoundingSphere:
case VariantType::BoundingBox:
case VariantType::Ray:
case VariantType::Quaternion:
case VariantType::Rectangle:
case VariantType::Int2:
@@ -428,6 +460,8 @@ Variant MUtils::UnboxVariant(MonoObject* value)
case VariantType::Int4:
case VariantType::Int16:
case VariantType::Uint16:
case VariantType::Double2:
case VariantType::Double3:
// Optimized unboxing of raw data type
for (int32 i = 0; i < array.Count(); i++)
{
@@ -436,10 +470,9 @@ Variant MUtils::UnboxVariant(MonoObject* value)
Platform::MemoryCopy(&a.AsData, mono_array_addr_with_size((MonoArray*)value, elementSize, i), elementSize);
}
break;
case VariantType::BoundingBox:
case VariantType::Transform:
case VariantType::Ray:
case VariantType::Matrix:
case VariantType::Double4:
// Optimized unboxing of raw data type
for (int32 i = 0; i < array.Count(); i++)
{
@@ -579,6 +612,12 @@ MonoObject* MUtils::BoxVariant(const Variant& value)
return mono_value_box(mono_domain_get(), stdTypes.Vector3Class->GetNative(), (void*)&value.AsData);
case VariantType::Vector4:
return mono_value_box(mono_domain_get(), stdTypes.Vector4Class->GetNative(), (void*)&value.AsData);
case VariantType::Double2:
return mono_value_box(mono_domain_get(), Double2::TypeInitializer.GetMonoClass(), (void*)&value.AsData);
case VariantType::Double3:
return mono_value_box(mono_domain_get(), Double3::TypeInitializer.GetMonoClass(), (void*)&value.AsData);
case VariantType::Double4:
return mono_value_box(mono_domain_get(), Double4::TypeInitializer.GetMonoClass(), value.AsBlob.Data);
case VariantType::Color:
return mono_value_box(mono_domain_get(), stdTypes.ColorClass->GetNative(), (void*)&value.AsData);
case VariantType::Guid:
@@ -594,9 +633,9 @@ MonoObject* MUtils::BoxVariant(const Variant& value)
case VariantType::Pointer:
return mono_value_box(mono_domain_get(), mono_get_intptr_class(), (void*)&value.AsPointer);
case VariantType::Ray:
return mono_value_box(mono_domain_get(), stdTypes.RayClass->GetNative(), value.AsBlob.Data);
return mono_value_box(mono_domain_get(), stdTypes.RayClass->GetNative(), (void*)&value.AsData);
case VariantType::BoundingBox:
return mono_value_box(mono_domain_get(), stdTypes.BoundingBoxClass->GetNative(), value.AsBlob.Data);
return mono_value_box(mono_domain_get(), stdTypes.BoundingBoxClass->GetNative(), (void*)&value.AsData);
case VariantType::Transform:
return mono_value_box(mono_domain_get(), stdTypes.TransformClass->GetNative(), value.AsBlob.Data);
case VariantType::Matrix:
@@ -656,21 +695,24 @@ MonoObject* MUtils::BoxVariant(const Variant& value)
case VariantType::Color:
case VariantType::Guid:
case VariantType::BoundingSphere:
case VariantType::BoundingBox:
case VariantType::Quaternion:
case VariantType::Ray:
case VariantType::Rectangle:
case VariantType::Int2:
case VariantType::Int3:
case VariantType::Int4:
case VariantType::Int16:
case VariantType::Uint16:
case VariantType::Double2:
case VariantType::Double3:
// Optimized boxing of raw data type
for (int32 i = 0; i < array.Count(); i++)
Platform::MemoryCopy(mono_array_addr_with_size(managed, elementSize, i), &array[i].AsData, elementSize);
break;
case VariantType::BoundingBox:
case VariantType::Transform:
case VariantType::Ray:
case VariantType::Matrix:
case VariantType::Double4:
// Optimized boxing of raw data type
for (int32 i = 0; i < array.Count(); i++)
Platform::MemoryCopy(mono_array_addr_with_size(managed, elementSize, i), array[i].AsBlob.Data, elementSize);
@@ -888,6 +930,12 @@ MonoClass* MUtils::GetClass(const VariantType& value)
return stdTypes.Vector3Class->GetNative();
case VariantType::Vector4:
return stdTypes.Vector4Class->GetNative();
case VariantType::Double2:
return Double2::TypeInitializer.GetMonoClass();
case VariantType::Double3:
return Double3::TypeInitializer.GetMonoClass();
case VariantType::Double4:
return Double4::TypeInitializer.GetMonoClass();
case VariantType::Color:
return stdTypes.ColorClass->GetNative();
case VariantType::Guid:
@@ -972,6 +1020,12 @@ MonoClass* MUtils::GetClass(const Variant& value)
return stdTypes.Vector3Class->GetNative();
case VariantType::Vector4:
return stdTypes.Vector4Class->GetNative();
case VariantType::Double2:
return Double2::TypeInitializer.GetMonoClass();
case VariantType::Double3:
return Double3::TypeInitializer.GetMonoClass();
case VariantType::Double4:
return Double4::TypeInitializer.GetMonoClass();
case VariantType::Color:
return stdTypes.ColorClass->GetNative();
case VariantType::Guid:
@@ -1096,33 +1150,36 @@ void* MUtils::VariantToManagedArgPtr(Variant& value, const MType& type, bool& fa
return &value.AsUint64;
}
const auto stdTypes = StdTypesContainer::Instance();
#define CASE_IN_BUILD_TYPE(type) \
if (klass == stdTypes->type##Class->GetNative()) \
{ \
if (value.Type.Type != VariantType::type) \
value = (type)value; \
return value.AsData; \
}
CASE_IN_BUILD_TYPE(Vector2);
CASE_IN_BUILD_TYPE(Vector3);
CASE_IN_BUILD_TYPE(Vector4);
CASE_IN_BUILD_TYPE(Color);
CASE_IN_BUILD_TYPE(Quaternion);
CASE_IN_BUILD_TYPE(Guid);
CASE_IN_BUILD_TYPE(Rectangle);
CASE_IN_BUILD_TYPE(BoundingSphere);
#undef CASE_IN_BUILD_TYPE
#define CASE_IN_BUILD_TYPE(type) \
#define CASE_IN_BUILD_TYPE(type, access) \
if (klass == stdTypes->type##Class->GetNative()) \
{ \
if (value.Type.Type != VariantType::type) \
value = Variant((type)value); \
return value.AsBlob.Data; \
return value.access; \
}
CASE_IN_BUILD_TYPE(Matrix);
CASE_IN_BUILD_TYPE(BoundingBox);
CASE_IN_BUILD_TYPE(Transform);
CASE_IN_BUILD_TYPE(Ray);
CASE_IN_BUILD_TYPE(Vector2, AsData);
CASE_IN_BUILD_TYPE(Vector3, AsData);
CASE_IN_BUILD_TYPE(Vector4, AsData);
CASE_IN_BUILD_TYPE(Color, AsData);
CASE_IN_BUILD_TYPE(Quaternion, AsData);
CASE_IN_BUILD_TYPE(Guid, AsData);
CASE_IN_BUILD_TYPE(Ray, AsData);
CASE_IN_BUILD_TYPE(Rectangle, AsData);
CASE_IN_BUILD_TYPE(BoundingSphere, AsData);
CASE_IN_BUILD_TYPE(BoundingBox, AsData);
CASE_IN_BUILD_TYPE(Matrix, AsBlob.Data);
CASE_IN_BUILD_TYPE(Transform, AsBlob.Data);
#undef CASE_IN_BUILD_TYPE
#define CASE_IN_BUILD_TYPE(type, access) \
if (klass == type::TypeInitializer.GetMonoClass()) \
{ \
if (value.Type.Type != VariantType::type) \
value = Variant((type)value); \
return value.access; \
}
CASE_IN_BUILD_TYPE(Double2, AsData);
CASE_IN_BUILD_TYPE(Double3, AsData);
CASE_IN_BUILD_TYPE(Double4, AsBlob.Data);
#undef CASE_IN_BUILD_TYPE
if (mono_class_is_valuetype(klass))
{

3
Source/Engine/Scripting/ScriptingType.h
View File

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

48
Source/Engine/Serialization/Serialization.cpp
View File

@@ -162,44 +162,53 @@ void Serialization::Serialize(ISerializable::SerializeStream& stream, const Vari
case VariantType::Vector4:
stream.Vector4(*(Vector4*)v.AsData);
break;
case VariantType::Double2:
stream.Double2(v.AsDouble2());
break;
case VariantType::Double3:
stream.Double3(v.AsDouble3());
break;
case VariantType::Double4:
stream.Double4(v.AsDouble4());
break;
case VariantType::Int2:
stream.Int2(*(Int2*)v.AsData);
stream.Int2(v.AsInt2());
break;
case VariantType::Int3:
stream.Int3(*(Int3*)v.AsData);
stream.Int3(v.AsInt3());
break;
case VariantType::Int4:
stream.Int4(*(Int4*)v.AsData);
stream.Int4(v.AsInt4());
break;
case VariantType::Color:
stream.Color(*(Color*)v.AsData);
stream.Color(v.AsColor());
break;
case VariantType::Guid:
stream.Guid(*(Guid*)v.AsData);
stream.Guid(v.AsGuid());
break;
case VariantType::BoundingSphere:
stream.BoundingSphere(*(BoundingSphere*)v.AsData);
stream.BoundingSphere(v.AsBoundingSphere());
break;
case VariantType::Quaternion:
stream.Quaternion(*(Quaternion*)v.AsData);
stream.Quaternion(v.AsQuaternion());
break;
case VariantType::Rectangle:
stream.Rectangle(*(Rectangle*)v.AsData);
stream.Rectangle(v.AsRectangle());
break;
case VariantType::BoundingBox:
stream.BoundingBox(*(BoundingBox*)v.AsBlob.Data);
stream.BoundingBox(v.AsBoundingBox());
break;
case VariantType::Transform:
stream.Transform(*(Transform*)v.AsBlob.Data);
stream.Transform(v.AsTransform());
break;
case VariantType::Ray:
stream.Ray(*(Ray*)v.AsBlob.Data);
stream.Ray(v.AsRay());
break;
case VariantType::Matrix:
stream.Matrix(*(Matrix*)v.AsBlob.Data);
stream.Matrix(v.AsMatrix());
break;
case VariantType::Array:
Serialize(stream, *(Array<Variant, HeapAllocation>*)v.AsData, nullptr);
Serialize(stream, v.AsArray(), nullptr);
break;
case VariantType::Dictionary:
Serialize(stream, *v.AsDictionary, nullptr);
@@ -304,6 +313,15 @@ void Serialization::Deserialize(ISerializable::DeserializeStream& stream, Varian
case VariantType::Vector4:
Deserialize(value, *(Vector4*)v.AsData, modifier);
break;
case VariantType::Double2:
Deserialize(value, *(Double2*)v.AsData, modifier);
break;
case VariantType::Double3:
Deserialize(value, *(Double3*)v.AsData, modifier);
break;
case VariantType::Double4:
Deserialize(value, *(Double4*)v.AsBlob.Data, modifier);
break;
case VariantType::Int2:
Deserialize(value, *(Int2*)v.AsData, modifier);
break;
@@ -329,13 +347,13 @@ void Serialization::Deserialize(ISerializable::DeserializeStream& stream, Varian
Deserialize(value, *(Rectangle*)v.AsData, modifier);
break;
case VariantType::BoundingBox:
Deserialize(value, *(BoundingBox*)v.AsBlob.Data, modifier);
Deserialize(value, *(BoundingBox*)v.AsData, modifier);
break;
case VariantType::Transform:
Deserialize(value, *(Transform*)v.AsBlob.Data, modifier);
break;
case VariantType::Ray:
Deserialize(value, *(Ray*)v.AsBlob.Data, modifier);
Deserialize(value, *(Ray*)v.AsData, modifier);
break;
case VariantType::Matrix:
Deserialize(value, *(Matrix*)v.AsBlob.Data, modifier);

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

@@ -7,6 +7,9 @@
#include "MemoryReadStream.h"
#include "Engine/Core/Types/CommonValue.h"
#include "Engine/Core/Types/Variant.h"
#include "Engine/Core/Math/Double2.h"
#include "Engine/Core/Math/Double3.h"
#include "Engine/Core/Math/Double4.h"
#include "Engine/Core/Collections/Dictionary.h"
#include "Engine/Content/Asset.h"
#include "Engine/Core/Cache.h"
@@ -413,6 +416,15 @@ void ReadStream::ReadVariant(Variant* data)
case VariantType::Vector4:
ReadBytes(&data->AsData, sizeof(Vector4));
break;
case VariantType::Double2:
ReadBytes(&data->AsData, sizeof(Double2));
break;
case VariantType::Double3:
ReadBytes(&data->AsData, sizeof(Double3));
break;
case VariantType::Double4:
ReadBytes(data->AsBlob.Data, sizeof(Double4));
break;
case VariantType::Color:
ReadBytes(&data->AsData, sizeof(Color));
break;
@@ -420,7 +432,7 @@ void ReadStream::ReadVariant(Variant* data)
ReadBytes(&data->AsData, sizeof(Guid));
break;
case VariantType::BoundingBox:
ReadBytes(data->AsBlob.Data, sizeof(BoundingBox));
ReadBytes(&data->AsData, sizeof(BoundingBox));
break;
case VariantType::BoundingSphere:
ReadBytes(&data->AsData, sizeof(BoundingSphere));
@@ -435,7 +447,7 @@ void ReadStream::ReadVariant(Variant* data)
ReadBytes(&data->AsData, sizeof(Rectangle));
break;
case VariantType::Ray:
ReadBytes(data->AsBlob.Data, sizeof(Ray));
ReadBytes(&data->AsData, sizeof(Ray));
break;
case VariantType::Matrix:
ReadBytes(data->AsBlob.Data, sizeof(Matrix));
@@ -679,13 +691,13 @@ void WriteStream::WriteVariant(const Variant& data)
WriteBytes(data.AsBlob.Data, data.AsBlob.Length);
break;
case VariantType::BoundingBox:
WriteBytes(data.AsBlob.Data, sizeof(BoundingBox));
WriteBytes(data.AsData, sizeof(BoundingBox));
break;
case VariantType::Transform:
WriteBytes(data.AsBlob.Data, sizeof(Transform));
break;
case VariantType::Ray:
WriteBytes(data.AsBlob.Data, sizeof(Ray));
WriteBytes(data.AsData, sizeof(Ray));
break;
case VariantType::Matrix:
WriteBytes(data.AsBlob.Data, sizeof(Matrix));
@@ -695,28 +707,37 @@ void WriteStream::WriteVariant(const Variant& data)
Write(&id);
break;
case VariantType::Vector2:
Write(data.AsData, sizeof(Vector2));
WriteBytes(data.AsData, sizeof(Vector2));
break;
case VariantType::Vector3:
Write(data.AsData, sizeof(Vector3));
WriteBytes(data.AsData, sizeof(Vector3));
break;
case VariantType::Vector4:
Write(data.AsData, sizeof(Vector4));
WriteBytes(data.AsData, sizeof(Vector4));
break;
case VariantType::Double2:
WriteBytes(data.AsData, sizeof(Double2));
break;
case VariantType::Double3:
WriteBytes(data.AsData, sizeof(Double3));
break;
case VariantType::Double4:
WriteBytes(data.AsBlob.Data, sizeof(Double4));
break;
case VariantType::Color:
Write(data.AsData, sizeof(Color));
WriteBytes(data.AsData, sizeof(Color));
break;
case VariantType::Guid:
Write(data.AsData, sizeof(Guid));
WriteBytes(data.AsData, sizeof(Guid));
break;
case VariantType::Quaternion:
Write(data.AsData, sizeof(Quaternion));
WriteBytes(data.AsData, sizeof(Quaternion));
break;
case VariantType::Rectangle:
Write(data.AsData, sizeof(Rectangle));
WriteBytes(data.AsData, sizeof(Rectangle));
break;
case VariantType::BoundingSphere:
Write(data.AsData, sizeof(BoundingSphere));
WriteBytes(data.AsData, sizeof(BoundingSphere));
break;
case VariantType::Array:
id.A = ((Array<Variant>*)data.AsData)->Count();

320
Source/Engine/Visject/GraphUtilities.cpp
View File

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