705 lines
24 KiB
C++
705 lines
24 KiB
C++
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
|
|
|
|
#include "GraphUtilities.h"
|
|
|
|
// [Deprecated on 31.07.2020, expires on 31.07.2022]
|
|
enum class GraphParamType_Deprecated
|
|
{
|
|
Bool = 0,
|
|
Integer = 1,
|
|
Float = 2,
|
|
Vector2 = 3,
|
|
Vector3 = 4,
|
|
Vector4 = 5,
|
|
Color = 6,
|
|
Texture = 7,
|
|
NormalMap = 8,
|
|
String = 9,
|
|
Box = 10,
|
|
Rotation = 11,
|
|
Transform = 12,
|
|
Asset = 13,
|
|
Actor = 14,
|
|
Rectangle = 15,
|
|
CubeTexture = 16,
|
|
SceneTexture = 17,
|
|
GPUTexture = 18,
|
|
Matrix = 19,
|
|
GPUTextureArray = 20,
|
|
GPUTextureVolume = 21,
|
|
GPUTextureCube = 22,
|
|
ChannelMask = 23,
|
|
};
|
|
|
|
// [Deprecated on 31.07.2020, expires on 31.07.2022]
|
|
enum class GraphConnectionType_Deprecated : uint32
|
|
{
|
|
Invalid = 0,
|
|
Impulse = 1 << 0,
|
|
Bool = 1 << 1,
|
|
Integer = 1 << 2,
|
|
Float = 1 << 3,
|
|
Vector2 = 1 << 4,
|
|
Vector3 = 1 << 5,
|
|
Vector4 = 1 << 6,
|
|
String = 1 << 7,
|
|
Object = 1 << 8,
|
|
Rotation = 1 << 9,
|
|
Transform = 1 << 10,
|
|
Box = 1 << 11,
|
|
ImpulseSecondary = 1 << 12,
|
|
UnsignedInteger = 1 << 13,
|
|
Scalar = Bool | Integer | Float | UnsignedInteger,
|
|
Vector = Vector2 | Vector3 | Vector4,
|
|
Variable = Scalar | Vector | String | Object | Rotation | Transform | Box,
|
|
All = Variable | Impulse,
|
|
};
|
|
|
|
// Required by deprecated graph data upgrade code
|
|
#include "Engine/Content/Assets/Texture.h"
|
|
#include "Engine/Content/Assets/CubeTexture.h"
|
|
#include "Engine/Scripting/ScriptingObjectReference.h"
|
|
#include "Engine/Core/Types/CommonValue.h"
|
|
#include "Engine/Level/Actor.h"
|
|
|
|
FLAXENGINE_API void ReadOldGraphParamValue_Deprecated(byte graphParamType, ReadStream* stream, GraphParameter* param)
|
|
{
|
|
// [Deprecated on 31.07.2020, expires on 31.07.2022]
|
|
CommonValue value;
|
|
stream->ReadCommonValue(&value);
|
|
switch ((GraphParamType_Deprecated)graphParamType)
|
|
{
|
|
case GraphParamType_Deprecated::Bool:
|
|
param->Type = VariantType(VariantType::Bool);
|
|
param->Value = value.GetBool();
|
|
break;
|
|
case GraphParamType_Deprecated::Integer:
|
|
param->Type = VariantType(VariantType::Int);
|
|
param->Value = value.GetInteger();
|
|
break;
|
|
case GraphParamType_Deprecated::Float:
|
|
param->Type = VariantType(VariantType::Float);
|
|
param->Value = value.GetFloat();
|
|
break;
|
|
case GraphParamType_Deprecated::Vector2:
|
|
param->Type = VariantType(VariantType::Vector2);
|
|
param->Value = value.GetVector2();
|
|
break;
|
|
case GraphParamType_Deprecated::Vector3:
|
|
param->Type = VariantType(VariantType::Vector3);
|
|
param->Value = value.GetVector3();
|
|
break;
|
|
case GraphParamType_Deprecated::Vector4:
|
|
param->Type = VariantType(VariantType::Vector4);
|
|
param->Value = value.GetVector4();
|
|
break;
|
|
case GraphParamType_Deprecated::Color:
|
|
param->Type = VariantType(VariantType::Color);
|
|
param->Value = value.GetColor();
|
|
break;
|
|
case GraphParamType_Deprecated::Texture:
|
|
case GraphParamType_Deprecated::NormalMap:
|
|
ASSERT(value.Type == CommonType::Guid);
|
|
param->Type = VariantType(VariantType::Asset, TEXT("FlaxEngine.Texture"));
|
|
param->Value.SetAsset(LoadAsset(value.AsGuid, Texture::TypeInitializer));
|
|
break;
|
|
case GraphParamType_Deprecated::String:
|
|
ASSERT(value.Type == CommonType::String);
|
|
param->Type = VariantType(VariantType::String);
|
|
param->Value.SetString(StringView(value.AsString));
|
|
break;
|
|
case GraphParamType_Deprecated::Box:
|
|
ASSERT(value.Type == CommonType::Box);
|
|
param->Type = VariantType(VariantType::BoundingBox);
|
|
param->Value = Variant(value.AsBox);
|
|
break;
|
|
case GraphParamType_Deprecated::Rotation:
|
|
ASSERT(value.Type == CommonType::Rotation);
|
|
param->Type = VariantType(VariantType::Quaternion);
|
|
param->Value = value.AsRotation;
|
|
break;
|
|
case GraphParamType_Deprecated::Transform:
|
|
ASSERT(value.Type == CommonType::Transform);
|
|
param->Type = VariantType(VariantType::Transform);
|
|
param->Value = Variant(value.AsTransform);
|
|
break;
|
|
case GraphParamType_Deprecated::Asset:
|
|
ASSERT(value.Type == CommonType::Guid);
|
|
param->Type = VariantType(VariantType::Asset);
|
|
param->Value.SetAsset(LoadAsset(value.AsGuid, Asset::TypeInitializer));
|
|
break;
|
|
case GraphParamType_Deprecated::Rectangle:
|
|
ASSERT(value.Type == CommonType::Rectangle);
|
|
param->Type = VariantType(VariantType::Rectangle);
|
|
param->Value = value.AsRectangle;
|
|
break;
|
|
case GraphParamType_Deprecated::Matrix:
|
|
ASSERT(value.Type == CommonType::Matrix);
|
|
param->Type = VariantType(VariantType::Matrix);
|
|
param->Value = Variant(value.AsMatrix);
|
|
break;
|
|
case GraphParamType_Deprecated::Actor:
|
|
ASSERT(value.Type == CommonType::Guid);
|
|
param->Type = VariantType(VariantType::Object, TEXT("FlaxEngine.Actor"));
|
|
param->Value.SetObject(FindObject(value.AsGuid, Actor::GetStaticClass()));
|
|
break;
|
|
case GraphParamType_Deprecated::CubeTexture:
|
|
ASSERT(value.Type == CommonType::Guid);
|
|
param->Type = VariantType(VariantType::Asset, TEXT("FlaxEngine.CubeTexture"));
|
|
param->Value.SetAsset(LoadAsset(value.AsGuid, CubeTexture::TypeInitializer));
|
|
break;
|
|
case GraphParamType_Deprecated::GPUTexture:
|
|
case GraphParamType_Deprecated::GPUTextureArray:
|
|
case GraphParamType_Deprecated::GPUTextureVolume:
|
|
case GraphParamType_Deprecated::GPUTextureCube:
|
|
param->Type = VariantType(VariantType::Object, TEXT("FlaxEngine.GPUTexture"));
|
|
param->Value.SetObject(nullptr);
|
|
break;
|
|
case GraphParamType_Deprecated::SceneTexture:
|
|
param->Type = VariantType(VariantType::Enum, TEXT("FlaxEngine.MaterialSceneTextures"));
|
|
param->Value.AsUint64 = (uint64)value.AsInteger;
|
|
break;
|
|
case GraphParamType_Deprecated::ChannelMask:
|
|
param->Type = VariantType(VariantType::Enum, TEXT("FlaxEngine.ChannelMask"));
|
|
param->Value.AsUint64 = (uint64)value.AsInteger;
|
|
break;
|
|
default:
|
|
CRASH;
|
|
}
|
|
}
|
|
|
|
FLAXENGINE_API void ReadOldGraphNodeValue_Deprecated(ReadStream* stream, Variant& result)
|
|
{
|
|
// [Deprecated on 31.07.2020, expires on 31.07.2022]
|
|
CommonValue value;
|
|
stream->ReadCommonValue(&value);
|
|
result = Variant(value);
|
|
}
|
|
|
|
FLAXENGINE_API void ReadOldGraphBoxType_Deprecated(uint32 connectionType, VariantType& type)
|
|
{
|
|
// [Deprecated on 31.07.2020, expires on 31.07.2022]
|
|
switch ((GraphConnectionType_Deprecated)connectionType)
|
|
{
|
|
case GraphConnectionType_Deprecated::Invalid:
|
|
type = VariantType(VariantType::Null);
|
|
break;
|
|
case GraphConnectionType_Deprecated::Impulse:
|
|
type = VariantType(VariantType::Void);
|
|
break;
|
|
case GraphConnectionType_Deprecated::Bool:
|
|
type = VariantType(VariantType::Bool);
|
|
break;
|
|
case GraphConnectionType_Deprecated::Integer:
|
|
type = VariantType(VariantType::Int);
|
|
break;
|
|
case GraphConnectionType_Deprecated::Float:
|
|
type = VariantType(VariantType::Float);
|
|
break;
|
|
case GraphConnectionType_Deprecated::Vector2:
|
|
type = VariantType(VariantType::Vector2);
|
|
break;
|
|
case GraphConnectionType_Deprecated::Vector3:
|
|
type = VariantType(VariantType::Vector3);
|
|
break;
|
|
case GraphConnectionType_Deprecated::Vector4:
|
|
type = VariantType(VariantType::Vector4);
|
|
break;
|
|
case GraphConnectionType_Deprecated::String:
|
|
type = VariantType(VariantType::String);
|
|
break;
|
|
case GraphConnectionType_Deprecated::Object:
|
|
type = VariantType(VariantType::Object);
|
|
break;
|
|
case GraphConnectionType_Deprecated::Rotation:
|
|
type = VariantType(VariantType::Quaternion);
|
|
break;
|
|
case GraphConnectionType_Deprecated::Transform:
|
|
type = VariantType(VariantType::Transform);
|
|
break;
|
|
case GraphConnectionType_Deprecated::Box:
|
|
type = VariantType(VariantType::BoundingBox);
|
|
break;
|
|
case GraphConnectionType_Deprecated::ImpulseSecondary:
|
|
type = VariantType(VariantType::Void);
|
|
break;
|
|
case GraphConnectionType_Deprecated::UnsignedInteger:
|
|
type = VariantType(VariantType::Uint);
|
|
break;
|
|
case GraphConnectionType_Deprecated::Scalar:
|
|
type = VariantType(VariantType::Null);
|
|
break;
|
|
case GraphConnectionType_Deprecated::Vector:
|
|
type = VariantType(VariantType::Null);
|
|
break;
|
|
case GraphConnectionType_Deprecated::Variable:
|
|
type = VariantType(VariantType::Null);
|
|
break;
|
|
case GraphConnectionType_Deprecated::All:
|
|
type = VariantType(VariantType::Null);
|
|
break;
|
|
default:
|
|
type = VariantType(VariantType::Null);
|
|
}
|
|
}
|
|
|
|
FLAXENGINE_API StringView GetGraphFunctionTypeName_Deprecated(const Variant& v)
|
|
{
|
|
// [Deprecated on 31.07.2020, expires on 31.07.2022]
|
|
if (v.Type.Type == VariantType::String)
|
|
return (StringView)v;
|
|
if (v.Type.Type == VariantType::Int)
|
|
{
|
|
switch ((GraphConnectionType_Deprecated)v.AsInt)
|
|
{
|
|
case GraphConnectionType_Deprecated::Impulse:
|
|
case GraphConnectionType_Deprecated::ImpulseSecondary:
|
|
return TEXT("System.Void");
|
|
case GraphConnectionType_Deprecated::Invalid:
|
|
case GraphConnectionType_Deprecated::Variable:
|
|
case GraphConnectionType_Deprecated::All:
|
|
return StringView::Empty;
|
|
case GraphConnectionType_Deprecated::Bool:
|
|
return TEXT("System.Boolean");
|
|
case GraphConnectionType_Deprecated::Integer:
|
|
return TEXT("System.Int32");
|
|
case GraphConnectionType_Deprecated::Float:
|
|
case GraphConnectionType_Deprecated::Scalar:
|
|
return TEXT("System.Single");
|
|
case GraphConnectionType_Deprecated::Vector2:
|
|
return TEXT("FlaxEngine.Vector2");
|
|
case GraphConnectionType_Deprecated::Vector3:
|
|
return TEXT("FlaxEngine.Vector3");
|
|
case GraphConnectionType_Deprecated::Vector4:
|
|
case GraphConnectionType_Deprecated::Vector:
|
|
return TEXT("FlaxEngine.Vector4");
|
|
case GraphConnectionType_Deprecated::String:
|
|
return TEXT("System.String");
|
|
case GraphConnectionType_Deprecated::Object:
|
|
return TEXT("FlaxEngine.Object");
|
|
case GraphConnectionType_Deprecated::Rotation:
|
|
return TEXT("System.Quaternion");
|
|
case GraphConnectionType_Deprecated::Transform:
|
|
return TEXT("System.Transform");
|
|
case GraphConnectionType_Deprecated::Box:
|
|
return TEXT("System.BoundingBox");
|
|
case GraphConnectionType_Deprecated::UnsignedInteger:
|
|
return TEXT("System.UInt32");
|
|
default: ;
|
|
}
|
|
}
|
|
return StringView::Empty;
|
|
}
|
|
|
|
void GraphUtilities::ApplySomeMathHere(Variant& v, Variant& a, MathOp1 op)
|
|
{
|
|
v.SetType(a.Type);
|
|
switch (a.Type.Type)
|
|
{
|
|
case VariantType::Bool:
|
|
v.AsBool = op(a.AsBool ? 1.0f : 0.0f) > ZeroTolerance;
|
|
break;
|
|
case VariantType::Int:
|
|
v.AsInt = (int32)op((float)a.AsInt);
|
|
break;
|
|
case VariantType::Uint:
|
|
v.AsUint = (uint32)op((float)a.AsUint);
|
|
break;
|
|
case VariantType::Float:
|
|
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);
|
|
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);
|
|
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);
|
|
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);
|
|
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);
|
|
break;
|
|
}
|
|
default:
|
|
v = a;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void GraphUtilities::ApplySomeMathHere(Variant& v, Variant& a, Variant& b, MathOp2 op)
|
|
{
|
|
v.SetType(a.Type);
|
|
switch (a.Type.Type)
|
|
{
|
|
case VariantType::Bool:
|
|
v.AsBool = op(a.AsBool ? 1.0f : 0.0f, b.AsBool ? 1.0f : 0.0f) > ZeroTolerance;
|
|
break;
|
|
case VariantType::Int:
|
|
v.AsInt = (int32)op((float)a.AsInt, (float)b.AsInt);
|
|
break;
|
|
case VariantType::Uint:
|
|
v.AsUint = (uint32)op((float)a.AsUint, (float)b.AsUint);
|
|
break;
|
|
case VariantType::Float:
|
|
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);
|
|
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);
|
|
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);
|
|
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);
|
|
break;
|
|
}
|
|
default:
|
|
v = a;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void GraphUtilities::ApplySomeMathHere(Variant& v, Variant& a, Variant& b, Variant& c, MathOp3 op)
|
|
{
|
|
v.SetType(a.Type);
|
|
switch (a.Type.Type)
|
|
{
|
|
case VariantType::Bool:
|
|
v.AsBool = op(a.AsBool ? 1.0f : 0.0f, b.AsBool ? 1.0f : 0.0f, c.AsBool ? 1.0f : 0.0f) > ZeroTolerance;
|
|
break;
|
|
case VariantType::Int:
|
|
v.AsInt = (int32)op((float)a.AsInt, (float)b.AsInt, (float)c.AsInt);
|
|
break;
|
|
case VariantType::Uint:
|
|
v.AsUint = (int32)op((float)a.AsUint, (float)b.AsUint, (float)c.AsUint);
|
|
break;
|
|
case VariantType::Float:
|
|
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);
|
|
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);
|
|
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);
|
|
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);
|
|
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);
|
|
break;
|
|
}
|
|
default:
|
|
v = a;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void GraphUtilities::ApplySomeMathHere(uint16 typeId, Variant& v, Variant& a)
|
|
{
|
|
// Select operation
|
|
MathOp1 op;
|
|
switch (typeId)
|
|
{
|
|
case 7:
|
|
op = [](float a)
|
|
{
|
|
return Math::Abs(a);
|
|
};
|
|
break;
|
|
case 8:
|
|
op = [](float a)
|
|
{
|
|
return Math::Ceil(a);
|
|
};
|
|
break;
|
|
case 9:
|
|
op = [](float a)
|
|
{
|
|
return Math::Cos(a);
|
|
};
|
|
break;
|
|
case 10:
|
|
op = [](float a)
|
|
{
|
|
return Math::Floor(a);
|
|
};
|
|
break;
|
|
case 13:
|
|
op = [](float a)
|
|
{
|
|
return Math::Round(a);
|
|
};
|
|
break;
|
|
case 14:
|
|
op = [](float a)
|
|
{
|
|
return Math::Saturate(a);
|
|
};
|
|
break;
|
|
case 15:
|
|
op = [](float a)
|
|
{
|
|
return Math::Sin(a);
|
|
};
|
|
break;
|
|
case 16:
|
|
op = [](float a)
|
|
{
|
|
return Math::Sqrt(a);
|
|
};
|
|
break;
|
|
case 17:
|
|
op = [](float a)
|
|
{
|
|
return Math::Tan(a);
|
|
};
|
|
break;
|
|
case 27:
|
|
op = [](float a)
|
|
{
|
|
return -a;
|
|
};
|
|
break;
|
|
case 28:
|
|
op = [](float a)
|
|
{
|
|
return 1 - a;
|
|
};
|
|
break;
|
|
case 33:
|
|
op = [](float a)
|
|
{
|
|
return Math::Asin(a);
|
|
};
|
|
break;
|
|
case 34:
|
|
op = [](float a)
|
|
{
|
|
return Math::Acos(a);
|
|
};
|
|
break;
|
|
case 35:
|
|
op = [](float a)
|
|
{
|
|
return Math::Atan(a);
|
|
};
|
|
break;
|
|
case 38:
|
|
op = [](float a)
|
|
{
|
|
return Math::Trunc(a);
|
|
};
|
|
break;
|
|
case 39:
|
|
op = [](float a)
|
|
{
|
|
float tmp;
|
|
return Math::ModF(a, &tmp);
|
|
};
|
|
break;
|
|
case 43:
|
|
{
|
|
op = [](float a)
|
|
{
|
|
return a * RadiansToDegrees;
|
|
};
|
|
break;
|
|
}
|
|
case 44:
|
|
{
|
|
op = [](float a)
|
|
{
|
|
return a * DegreesToRadians;
|
|
};
|
|
break;
|
|
}
|
|
|
|
default:
|
|
return;
|
|
}
|
|
|
|
// Perform operation
|
|
ApplySomeMathHere(v, a, op);
|
|
}
|
|
|
|
void GraphUtilities::ApplySomeMathHere(uint16 typeId, Variant& v, Variant& a, Variant& b)
|
|
{
|
|
// Select operation
|
|
MathOp2 op;
|
|
switch (typeId)
|
|
{
|
|
case 1:
|
|
op = [](float a, float b)
|
|
{
|
|
return a + b;
|
|
};
|
|
break;
|
|
case 2:
|
|
op = [](float a, float b)
|
|
{
|
|
return a - b;
|
|
};
|
|
break;
|
|
case 3:
|
|
op = [](float a, float b)
|
|
{
|
|
return a * b;
|
|
};
|
|
break;
|
|
case 4:
|
|
op = [](float a, float b)
|
|
{
|
|
return (float)((int)a % (int)b);
|
|
};
|
|
break;
|
|
case 5:
|
|
op = [](float a, float b)
|
|
{
|
|
return a / b;
|
|
};
|
|
break;
|
|
case 21:
|
|
op = [](float a, float b)
|
|
{
|
|
return Math::Max(a, b);
|
|
};
|
|
break;
|
|
case 22:
|
|
op = [](float a, float b)
|
|
{
|
|
return Math::Min(a, b);
|
|
};
|
|
break;
|
|
case 23:
|
|
op = [](float a, float b)
|
|
{
|
|
return Math::Pow(a, b);
|
|
};
|
|
break;
|
|
case 40:
|
|
op = [](float a, float b)
|
|
{
|
|
return Math::Mod(a, b);
|
|
};
|
|
break;
|
|
case 41:
|
|
op = [](float a, float b)
|
|
{
|
|
return Math::Atan2(a, b);
|
|
};
|
|
break;
|
|
default:
|
|
return;
|
|
}
|
|
|
|
// Perform operation
|
|
ApplySomeMathHere(v, a, b, op);
|
|
}
|
|
|
|
int32 GraphUtilities::CountComponents(VariantType::Types type)
|
|
{
|
|
switch (type)
|
|
{
|
|
case VariantType::Bool:
|
|
case VariantType::Int:
|
|
case VariantType::Int64:
|
|
case VariantType::Uint:
|
|
case VariantType::Uint64:
|
|
case VariantType::Float:
|
|
case VariantType::Double:
|
|
case VariantType::Pointer:
|
|
return 1;
|
|
case VariantType::Vector2:
|
|
return 2;
|
|
case VariantType::Vector3:
|
|
return 3;
|
|
case VariantType::Vector4:
|
|
case VariantType::Color:
|
|
return 4;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|