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

You're breathtaking!

Browse Source
This commit is contained in:
Wojtek Figat
2020-12-07 23:40:54 +01:00
commit 6fb9eee74c
5143 changed files with 1153594 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

704
Source/Engine/Visject/GraphUtilities.cpp Normal file
View File

@@ -0,0 +1,704 @@
// Copyright (c) 2012-2020 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;
}
}