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

Merge branch 'intx' of git://github.com/jb-perrier/FlaxEngine into jb-perrier-intx

Browse Source
This commit is contained in:
Wojtek Figat
2021-04-13 09:38:43 +02:00
parent c572d75d1d 992f4b2303
commit 5d0da2c8c2
23 changed files with 1465 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
Source/Editor/Utilities/Utils.cs
View File

@@ -67,6 +67,10 @@ namespace FlaxEditor.Utilities
Dictionary,
ManagedObject,
Typename,
Int2,
Int3,
Int4
}
/// <summary>
@@ -446,6 +450,12 @@ namespace FlaxEditor.Utilities
variantType = VariantType.Vector3;
else if (type == typeof(Vector4))
variantType = VariantType.Vector4;
else if (type == typeof(Int2))
variantType = VariantType.Int2;
else if (type == typeof(Int3))
variantType = VariantType.Int3;
else if (type == typeof(Int4))
variantType = VariantType.Int4;
else if (type == typeof(Color))
variantType = VariantType.Color;
else if (type == typeof(Guid))
@@ -682,6 +692,21 @@ namespace FlaxEditor.Utilities
new Vector3(stream.ReadSingle(), stream.ReadSingle(), stream.ReadSingle()));
break;
}
case 19: // CommonType::Int2
{
value = stream.ReadInt2();
break;
}
case 20: // CommonType::Int3
{
value = stream.ReadInt3();
break;
}
case 21: // CommonType::Int4
{
value = stream.ReadInt4();
break;
}
default: throw new SystemException();
}
}
@@ -733,6 +758,9 @@ namespace FlaxEditor.Utilities
case VariantType.Vector2: return new ScriptType(typeof(Vector2));
case VariantType.Vector3: return new ScriptType(typeof(Vector3));
case VariantType.Vector4: return new ScriptType(typeof(Vector4));
case VariantType.Int2: return new ScriptType(typeof(Int2));
case VariantType.Int3: return new ScriptType(typeof(Int3));
case VariantType.Int4: return new ScriptType(typeof(Int4));
case VariantType.Color: return new ScriptType(typeof(Color));
case VariantType.Guid: return new ScriptType(typeof(Guid));
case VariantType.BoundingBox: return new ScriptType(typeof(BoundingBox));
@@ -797,6 +825,9 @@ namespace FlaxEditor.Utilities
case VariantType.Vector2: return typeof(Vector2);
case VariantType.Vector3: return typeof(Vector3);
case VariantType.Vector4: return typeof(Vector4);
case VariantType.Int2: return typeof(Int2);
case VariantType.Int3: return typeof(Int3);
case VariantType.Int4: return typeof(Int4);
case VariantType.Color: return typeof(Color);
case VariantType.Guid: return typeof(Guid);
case VariantType.BoundingBox: return typeof(BoundingBox);
@@ -894,6 +925,9 @@ namespace FlaxEditor.Utilities
case VariantType.Vector2: return stream.ReadVector2();
case VariantType.Vector3: return stream.ReadVector3();
case VariantType.Vector4: return stream.ReadVector4();
case VariantType.Int2: return stream.ReadInt2();
case VariantType.Int3: return stream.ReadInt3();
case VariantType.Int4: return stream.ReadInt4();
case VariantType.Color: return stream.ReadColor();
case VariantType.Guid: return stream.ReadGuid();
case VariantType.BoundingBox: return stream.ReadBoundingBox();
@@ -1087,6 +1121,21 @@ namespace FlaxEditor.Utilities
stream.Write(asRay.Direction.Y);
stream.Write(asRay.Direction.Z);
}
else if (value is Int2 asInt2)
{
stream.Write((byte)19);
stream.Write(asInt2);
}
else if (value is Int3 asInt3)
{
stream.Write((byte)20);
stream.Write(asInt3);
}
else if (value is Int4 asInt4)
{
stream.Write((byte)21);
stream.Write(asInt4);
}
else
{
throw new NotSupportedException(string.Format("Invalid Common Value type {0}", value != null ? value.GetType().ToString() : "null"));
@@ -1194,6 +1243,15 @@ namespace FlaxEditor.Utilities
case VariantType.Vector4:
stream.Write((Vector4)value);
break;
case VariantType.Int2:
stream.Write((Int2)value);
break;
case VariantType.Int3:
stream.Write((Int3)value);
break;
case VariantType.Int4:
stream.Write((Int4)value);
break;
case VariantType.Color:
stream.Write((Color)value);
break;
@@ -1386,6 +1444,51 @@ namespace FlaxEditor.Utilities
stream.WriteEndObject();
break;
}
case VariantType.Int2:
{
var asInt2 = (Int2)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asInt2.X);
stream.WritePropertyName("Y");
stream.WriteValue(asInt2.Y);
stream.WriteEndObject();
break;
}
case VariantType.Int3:
{
var asInt3 = (Int3)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asInt3.X);
stream.WritePropertyName("Y");
stream.WriteValue(asInt3.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asInt3.Z);
stream.WriteEndObject();
break;
}
case VariantType.Int4:
{
var asInt4 = (Int4)value;
stream.WriteStartObject();
stream.WritePropertyName("X");
stream.WriteValue(asInt4.X);
stream.WritePropertyName("Y");
stream.WriteValue(asInt4.Y);
stream.WritePropertyName("Z");
stream.WriteValue(asInt4.Z);
stream.WritePropertyName("W");
stream.WriteValue(asInt4.W);
stream.WriteEndObject();
break;
}
case VariantType.Color:
{
var asColor = (Color)value;

51
Source/Engine/Core/Math/Int2.cpp Normal file
View File

@@ -0,0 +1,51 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#include "Int2.h"
#include "Int3.h"
#include "Int4.h"
#include "Vector2.h"
#include "Vector3.h"
#include "Vector4.h"
#include "Engine/Core/Types/String.h"
static_assert(sizeof(Int2) == 8, "Invalid Int2 type size.");
const Int2 Int2::Zero(0);
const Int2 Int2::One(1);
const Int2 Int2::Minimum(MIN_int32);
const Int2 Int2::Maximum(MAX_int32);
Int2::Int2(const Int3& xyz)
: X(xyz.X)
, Y(xyz.Y)
{
}
Int2::Int2(const Int4& xyzw)
: X(xyzw.X)
, Y(xyzw.Y)
{
}
Int2::Int2(const Vector2& xy)
: X(static_cast<int32>(xy.X))
, Y(static_cast<int32>(xy.Y))
{
}
Int2::Int2(const Vector3& xyz)
: X(static_cast<int32>(xyz.X))
, Y(static_cast<int32>(xyz.Y))
{
}
Int2::Int2(const Vector4& xyzw)
: X(static_cast<int32>(xyzw.X))
, Y(static_cast<int32>(xyzw.Y))
{
}
String Int2::ToString() const
{
return String::Format(TEXT("{}"), *this);
}

13
Source/Engine/Core/Math/Int2.cs
View File

@@ -12,9 +12,8 @@ namespace FlaxEngine
/// Represents a two dimensional mathematical vector (signed integers).
/// </summary>
[Serializable]
[StructLayout(LayoutKind.Sequential, Pack = 4)]
[TypeConverter(typeof(TypeConverters.Int2Converter))]
public struct Int2 : IEquatable<Int2>, IFormattable
partial struct Int2 : IEquatable<Int2>, IFormattable
{
private static readonly string _formatString = "X:{0} Y:{1}";
@@ -53,16 +52,6 @@ namespace FlaxEngine
/// </summary>
public static readonly Int2 Maximum = new Int2(int.MaxValue);
/// <summary>
/// The X component of the vector.
/// </summary>
public int X;
/// <summary>
/// The Y component of the vector.
/// </summary>
public int Y;
/// <summary>
/// Initializes a new instance of the <see cref="Int2" /> struct.
/// </summary>

160
Source/Engine/Core/Math/Int2.h
View File

@@ -6,26 +6,27 @@
#include "Engine/Core/Formatting.h"
#include "Engine/Core/Templates.h"
struct Vector2;
struct Vector3;
struct Vector4;
/// <summary>
/// Two-components vector (32 bit integer type).
/// </summary>
API_STRUCT(InBuild) struct FLAXENGINE_API Int2
API_STRUCT() struct FLAXENGINE_API Int2
{
DECLARE_SCRIPTING_TYPE_MINIMAL(Int2);
public:
union
{
struct
{
// X component
int32 X;
/// <summary>
/// The X component.
/// </summary>
API_FIELD() int32 X;
// Y component
int32 Y;
/// <summary>
/// The Y component.
/// </summary>
API_FIELD() int32 Y;
};
// Raw values
@@ -40,6 +41,12 @@ public:
// Vector with all components equal 1
static const Int2 One;
// A minimum Int2
static const Int2 Minimum;
// A maximum Int2
static const Int2 Maximum;
public:
/// <summary>
@@ -67,9 +74,25 @@ public:
}
// Init
// @param v Vector to use X and Y components
explicit Int2(const Vector2& v);
// @param xyz Int3 to use X and Y components
Int2(const Int3& xyz);
// Init
// @param xyzw Int4 to use X and Y components
Int2(const Int4& xyzw);
// Init
// @param xy Vector2 to use X and Y components
explicit Int2(const Vector2& xy);
// Init
// @param xyz Vector3 to use X and Y components
explicit Int2(const Vector3& xyz);
// Init
// @param xyzw Vector4 to use X and Y components
explicit Int2(const Vector4& xyzw);
public:
String ToString() const;
@@ -211,29 +234,29 @@ public:
public:
static void Add(const Int2& a, const Int2& b, Int2* result)
static void Add(const Int2& a, const Int2& b, Int2& result)
{
result->X = a.X + b.X;
result->Y = a.Y + b.Y;
result.X = a.X + b.X;
result.Y = a.Y + b.Y;
}
static Int2 Add(const Int2& a, const Int2& b)
{
Int2 result;
Add(a, b, &result);
Add(a, b, result);
return result;
}
static void Subtract(const Int2& a, const Int2& b, Int2* result)
static void Subtract(const Int2& a, const Int2& b, Int2& result)
{
result->X = a.X - b.X;
result->Y = a.Y - b.Y;
result.X = a.X - b.X;
result.Y = a.Y - b.Y;
}
static Int2 Subtract(const Int2& a, const Int2& b)
{
Int2 result;
Subtract(a, b, &result);
Subtract(a, b, result);
return result;
}
@@ -257,17 +280,112 @@ public:
return Int2(a.X / b, a.Y / b);
}
// Creates vector from minimum components of two vectors
/// <summary>
/// Gets a value indicting whether this vector is zero.
/// </summary>
/// <returns> True if the vector is zero, otherwise false.</returns>
bool IsZero() const
{
return X == 0 && Y == 0;
}
/// <summary>
/// Gets a value indicting whether any vector component is zero.
/// </summary>
/// <returns> True if a component is zero, otherwise false.</returns>
bool IsAnyZero() const
{
return X == 0 || Y == 0;
}
/// <summary>
/// Gets a value indicting whether this vector is one.
/// </summary>
/// <returns> True if the vector is one, otherwise false.</returns>
bool IsOne() const
{
return X == 1 && Y == 1;
}
/// <summary>
/// Calculates a vector with values being opposite to values of that vector
/// </summary>
/// <returns>Negative vector</returns>
Int2 GetNegative() const
{
return Int2(-X, -Y);
}
/// <summary>
/// Returns average arithmetic of all the components
/// </summary>
/// <returns>Average arithmetic of all the components</returns>
float AverageArithmetic() const
{
return (X + Y) * 0.5f;
}
/// <summary>
/// Gets sum of all vector components values
/// </summary>
/// <returns>Sum of X, Y, Z and W</returns>
int32 SumValues() const
{
return X + Y;
}
/// <summary>
/// Returns minimum value of all the components
/// </summary>
/// <returns>Minimum value</returns>
int32 MinValue() const
{
return Math::Min(X, Y);
}
/// <summary>
/// Returns maximum value of all the components
/// </summary>
/// <returns>Maximum value</returns>
int32 MaxValue() const
{
return Math::Max(X, Y);
}
// Returns a vector containing the smallest components of the specified vectors
// @param a The first source vector
// @param b The second source vector
static Int2 Min(const Int2& a, const Int2& b)
{
return Int2(a.X < b.X ? a.X : b.X, a.Y < b.Y ? a.Y : b.Y);
}
// Creates vector from maximum components of two vectors
// Returns a vector containing the largest components of the specified vectors
// @param a The first source vector
// @param b The second source vector
static Int2 Max(const Int2& a, const Int2& b)
{
return Int2(a.X > b.X ? a.X : b.X, a.Y > b.Y ? a.Y : b.Y);
}
// Returns a vector containing the smallest components of the specified vectors
// @param a The first source vector
// @param b The second source vector
// @param result When the method completes, contains an new vector composed of the smallest components of the source vectors
static void Min(const Int2& a, const Int2& b, Int2& result)
{
result = Int2(a.X < b.X ? a.X : b.X, a.Y < b.Y ? a.Y : b.Y);
}
// Returns a vector containing the largest components of the specified vectors
// @param a The first source vector
// @param b The second source vector
// @param result When the method completes, contains an new vector composed of the largest components of the source vectors
static void Max(const Int2& a, const Int2& b, Int2& result)
{
result = Int2(a.X > b.X ? a.X : b.X, a.Y > b.Y ? a.Y : b.Y);
}
};
template<>

56
Source/Engine/Core/Math/Int3.cpp Normal file
View File

@@ -0,0 +1,56 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#include "Int2.h"
#include "Int3.h"
#include "Int4.h"
#include "Vector2.h"
#include "Vector3.h"
#include "Vector4.h"
#include "Engine/Core/Types/String.h"
static_assert(sizeof(Int3) == 12, "Invalid Int3 type size.");
const Int3 Int3::Zero(0);
const Int3 Int3::One(1);
const Int3 Int3::Minimum(MIN_int32);
const Int3 Int3::Maximum(MAX_int32);
Int3::Int3(const Int2& xy, int32 z)
: X(xy.X)
, Y(xy.Y)
, Z(z)
{
}
Int3::Int3(const Int4& xyzw)
: X(xyzw.X)
, Y(xyzw.Y)
, Z(xyzw.Z)
{
}
Int3::Int3(const Vector2& xy, int32 z)
: X(static_cast<int32>(xy.X))
, Y(static_cast<int32>(xy.Y))
, Z(z)
{
}
Int3::Int3(const Vector3& xyz)
: X(static_cast<int32>(xyz.X))
, Y(static_cast<int32>(xyz.Y))
, Z(static_cast<int32>(xyz.Z))
{
}
Int3::Int3(const Vector4& xyzw)
: X(static_cast<int32>(xyzw.X))
, Y(static_cast<int32>(xyzw.Y))
, Z(static_cast<int32>(xyzw.Z))
{
}
String Int3::ToString() const
{
return String::Format(TEXT("{}"), *this);
}

18
Source/Engine/Core/Math/Int3.cs
View File

@@ -12,9 +12,8 @@ namespace FlaxEngine
/// Represents a three dimensional mathematical vector (signed integers).
/// </summary>
[Serializable]
[StructLayout(LayoutKind.Sequential, Pack = 4)]
[TypeConverter(typeof(TypeConverters.Int3Converter))]
public struct Int3 : IEquatable<Int3>, IFormattable
partial struct Int3 : IEquatable<Int3>, IFormattable
{
private static readonly string _formatString = "X:{0} Y:{1} Z:{2}";
@@ -58,21 +57,6 @@ namespace FlaxEngine
/// </summary>
public static readonly Int3 Maximum = new Int3(int.MaxValue);
/// <summary>
/// The X component of the vector.
/// </summary>
public int X;
/// <summary>
/// The Y component of the vector.
/// </summary>
public int Y;
/// <summary>
/// The Z component of the vector.
/// </summary>
public int Z;
/// <summary>
/// Initializes a new instance of the <see cref="Int3" /> struct.
/// </summary>

319
Source/Engine/Core/Math/Int3.h
View File

@@ -6,29 +6,33 @@
#include "Engine/Core/Formatting.h"
#include "Engine/Core/Templates.h"
struct Vector2;
struct Vector3;
struct Vector4;
/// <summary>
/// Three-components vector (32 bit integer type).
/// </summary>
API_STRUCT(InBuild) struct FLAXENGINE_API Int3
API_STRUCT() struct FLAXENGINE_API Int3
{
DECLARE_SCRIPTING_TYPE_MINIMAL(Int3);
public:
union
{
struct
{
// X component
int32 X;
/// <summary>
/// The X component.
/// </summary>
API_FIELD() int32 X;
// Y component
int32 Y;
/// <summary>
/// The Y component.
/// </summary>
API_FIELD() int32 Y;
// Y component
int32 Z;
/// <summary>
/// The Z component.
/// </summary>
API_FIELD() int32 Z;
};
// Raw values
@@ -43,6 +47,12 @@ public:
// Vector with all components equal 1
static const Int3 One;
// A minimum Int3
static const Int3 Minimum;
// A maximum Int3
static const Int3 Maximum;
public:
/// <summary>
@@ -73,19 +83,293 @@ public:
}
// Init
// @param v Vector to use X, Y and Z components
explicit Int3(const Vector3& v);
// @param v Int2 to use X and Y components
// @param z Z component value
Int3(const Int2& xy, int32 z);
// Init
// @param v Int4 to use X and Y components
Int3(const Int4& xyzw);
// Init
// @param v Vector2 to use X and Y components
// @param z Z component value
explicit Int3(const Vector2& xy, int32 z);
// Init
// @param v Vector3 to use X, Y and Z components
explicit Int3(const Vector3& xyz);
// Init
// @param v Vector4 to use X and Y components
explicit Int3(const Vector4& xyzw);
public:
String ToString() const;
public:
// Arithmetic operators with Int2
Int3 operator+(const Int3& b) const
{
return Add(*this, b);
}
Int3 operator-(const Int3& b) const
{
return Subtract(*this, b);
}
Int3 operator*(const Int3& b) const
{
return Multiply(*this, b);
}
Int3 operator/(const Int3& b) const
{
return Divide(*this, b);
}
Int3 operator-() const
{
return Int3(-X, -Y, -Z);
}
// op= operators with Int2
Int3& operator+=(const Int3& b)
{
*this = Add(*this, b);
return *this;
}
Int3& operator-=(const Int3& b)
{
*this = Subtract(*this, b);
return *this;
}
Int3& operator*=(const Int3& b)
{
*this = Multiply(*this, b);
return *this;
}
Int3& operator/=(const Int3& b)
{
*this = Divide(*this, b);
return *this;
}
// Arithmetic operators with int32
Int3 operator+(int32 b) const
{
return Add(*this, b);
}
Int3 operator-(int32 b) const
{
return Subtract(*this, b);
}
Int3 operator*(int32 b) const
{
return Multiply(*this, b);
}
Int3 operator/(int32 b) const
{
return Divide(*this, b);
}
// op= operators with int32
Int3& operator+=(int32 b)
{
*this = Add(*this, b);
return *this;
}
Int3& operator-=(int32 b)
{
*this = Subtract(*this, b);
return *this;
}
Int3& operator*=(int32 b)
{
*this = Multiply(*this, b);
return *this;
}
Int3& operator/=(int32 b)
{
*this = Divide(*this, b);
return *this;
}
// Comparison operators
bool operator==(const Int3& b) const
{
return X == b.X && Y == b.Y;
}
bool operator!=(const Int3& b) const
{
return X != b.X || Y != b.Y;
}
bool operator>(const Int3& b) const
{
return X > b.X && Y > b.Y;
}
bool operator>=(const Int3& b) const
{
return X >= b.X && Y >= b.Y;
}
bool operator<(const Int3& b) const
{
return X < b.X && Y < b.Y;
}
bool operator<=(const Int3& b) const
{
return X <= b.X && Y <= b.Y;
}
public:
static void Add(const Int3& a, const Int3& b, Int3& result)
{
result.X = a.X + b.X;
result.Y = a.Y + b.Y;
result.Z = a.Z + b.Z;
}
static Int3 Add(const Int3& a, const Int3& b)
{
Int3 result;
Add(a, b, result);
return result;
}
static void Subtract(const Int3& a, const Int3& b, Int3& result)
{
result.X = a.X - b.X;
result.Y = a.Y - b.Y;
result.Z = a.Z - b.Z;
}
static Int3 Subtract(const Int3& a, const Int3& b)
{
Int3 result;
Subtract(a, b, result);
return result;
}
static Int3 Multiply(const Int3& a, const Int3& b)
{
return Int3(a.X * b.X, a.Y * b.Y, a.Z * b.Z);
}
static Int3 Multiply(const Int3& a, int32 b)
{
return Int3(a.X * b, a.Y * b, a.Z * b);
}
static Int3 Divide(const Int3& a, const Int3& b)
{
return Int3(a.X / b.X, a.Y / b.Y, a.Z / b.Z);
}
static Int3 Divide(const Int3& a, int32 b)
{
return Int3(a.X / b, a.Y / b, a.Z / b);
}
public:
/// <summary>
/// Gets a value indicting whether this vector is zero.
/// </summary>
/// <returns> True if the vector is zero, otherwise false.</returns>
bool IsZero() const
{
return X == 0 && Y == 0 && Z == 0;
}
/// <summary>
/// Gets a value indicting whether any vector component is zero.
/// </summary>
/// <returns> True if a component is zero, otherwise false.</returns>
bool IsAnyZero() const
{
return X == 0 || Y == 0 || Z == 0;
}
/// <summary>
/// Gets a value indicting whether this vector is one.
/// </summary>
/// <returns> True if the vector is one, otherwise false.</returns>
bool IsOne() const
{
return X == 1 && Y == 1 && Z == 1;
}
/// <summary>
/// Calculates a vector with values being opposite to values of that vector
/// </summary>
/// <returns>Negative vector</returns>
Int3 GetNegative() const
{
return Int3(-X, -Y, -Z);
}
/// <summary>
/// Returns average arithmetic of all the components
/// </summary>
/// <returns>Average arithmetic of all the components</returns>
float AverageArithmetic() const
{
return (X + Y + Z) / 3.0f;
}
/// <summary>
/// Gets sum of all vector components values
/// </summary>
/// <returns>Sum of X, Y, Z and W</returns>
int32 SumValues() const
{
return X + Y + Z;
}
/// <summary>
/// Returns minimum value of all the components
/// </summary>
/// <returns>Minimum value</returns>
int32 MinValue() const
{
return Math::Min(X, Y, Z);
}
/// <summary>
/// Returns maximum value of all the components
/// </summary>
/// <returns>Maximum value</returns>
int32 MaxValue() const
{
return Math::Max(X, Y, Z);
}
// Returns a vector containing the largest components of the specified vectors
// @param a The first source vector
// @param b The second source vector
// @param result When the method completes, contains an new vector composed of the largest components of the source vectors
static Int3 Max(const Int3& a, const Int3& b)
{
return Int3(a.X > b.X ? a.X : b.X, a.Y > b.Y ? a.Y : b.Y, a.Z > b.Z ? a.Z : b.Z);
@@ -94,7 +378,6 @@ public:
// Returns a vector containing the smallest components of the specified vectors
// @param a The first source vector
// @param b The second source vector
// @param result When the method completes, contains an new vector composed of the smallest components of the source vectors
static Int3 Min(const Int3& a, const Int3& b)
{
return Int3(a.X < b.X ? a.X : b.X, a.Y < b.Y ? a.Y : b.Y, a.Z < b.Z ? a.Z : b.Z);
@@ -104,18 +387,18 @@ public:
// @param a The first source vector
// @param b The second source vector
// @param result When the method completes, contains an new vector composed of the largest components of the source vectors
static void Max(const Int3& a, const Int3& b, Int3* result)
static void Max(const Int3& a, const Int3& b, Int3& result)
{
*result = Int3(a.X > b.X ? a.X : b.X, a.Y > b.Y ? a.Y : b.Y, a.Z > b.Z ? a.Z : b.Z);
result = Int3(a.X > b.X ? a.X : b.X, a.Y > b.Y ? a.Y : b.Y, a.Z > b.Z ? a.Z : b.Z);
}
// Returns a vector containing the smallest components of the specified vectors
// @param a The first source vector
// @param b The second source vector
// @param result When the method completes, contains an new vector composed of the smallest components of the source vectors
static void Min(const Int3& a, const Int3& b, Int3* result)
static void Min(const Int3& a, const Int3& b, Int3 result)
{
*result = Int3(a.X < b.X ? a.X : b.X, a.Y < b.Y ? a.Y : b.Y, a.Z < b.Z ? a.Z : b.Z);
result = Int3(a.X < b.X ? a.X : b.X, a.Y < b.Y ? a.Y : b.Y, a.Z < b.Z ? a.Z : b.Z);
}
};

67
Source/Engine/Core/Math/VectorInt.cpp → Source/Engine/Core/Math/Int4.cpp
View File

@@ -1,42 +1,51 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#include "VectorInt.h"
#include "Int2.h"
#include "Int3.h"
#include "Int4.h"
#include "Vector2.h"
#include "Vector3.h"
#include "Vector4.h"
#include "Engine/Core/Types/String.h"
const Int2 Int2::Zero(0);
const Int2 Int2::One(1);
Int2::Int2(const Vector2& v)
: X(static_cast<int32>(v.X))
, Y(static_cast<int32>(v.Y))
{
}
String Int2::ToString() const
{
return String::Format(TEXT("{}"), *this);
}
const Int3 Int3::Zero(0);
const Int3 Int3::One(1);
Int3::Int3(const Vector3& v)
: X(static_cast<int32>(v.X))
, Y(static_cast<int32>(v.Y))
, Z(static_cast<int32>(v.Z))
{
}
String Int3::ToString() const
{
return String::Format(TEXT("{}"), *this);
}
static_assert(sizeof(Int4) == 16, "Invalid Int4 type size.");
const Int4 Int4::Zero(0);
const Int4 Int4::One(1);
const Int4 Int4::Minimum(MIN_int32);
const Int4 Int4::Maximum(MAX_int32);
Int4::Int4(const Int2& xy, int32 z, int32 w)
: X(xy.X)
, Y(xy.Y)
, Z(z)
, W(w)
{
}
Int4::Int4(const Int3& xyz, int32 w)
: X(xyz.X)
, Y(xyz.Y)
, Z(xyz.Z)
, W(w)
{
}
Int4::Int4(const Vector2& v, int32 z, int32 w)
: X(static_cast<int32>(v.X))
, Y(static_cast<int32>(v.Y))
, Z(z)
, W(w)
{
}
Int4::Int4(const Vector3& v, int32 w)
: X(static_cast<int32>(v.X))
, Y(static_cast<int32>(v.Y))
, Z(static_cast<int32>(v.Z))
, W(w)
{
}
Int4::Int4(const Vector4& v)
: X(static_cast<int32>(v.X))

23
Source/Engine/Core/Math/Int4.cs
View File

@@ -12,9 +12,8 @@ namespace FlaxEngine
/// Represents a four dimensional mathematical vector (signed integers).
/// </summary>
[Serializable]
[StructLayout(LayoutKind.Sequential, Pack = 4)]
[TypeConverter(typeof(TypeConverters.Int4Converter))]
public struct Int4 : IEquatable<Int4>, IFormattable
partial struct Int4 : IEquatable<Int4>, IFormattable
{
private static readonly string _formatString = "X:{0} Y:{1} Z:{2} W:{3}";
@@ -63,26 +62,6 @@ namespace FlaxEngine
/// </summary>
public static readonly Int4 Maximum = new Int4(int.MaxValue);
/// <summary>
/// The X component of the vector.
/// </summary>
public int X;
/// <summary>
/// The Y component of the vector.
/// </summary>
public int Y;
/// <summary>
/// The Z component of the vector.
/// </summary>
public int Z;
/// <summary>
/// The W component of the vector.
/// </summary>
public int W;
/// <summary>
/// Initializes a new instance of the <see cref="Int4" /> struct.
/// </summary>

318
Source/Engine/Core/Math/Int4.h
View File

@@ -6,32 +6,37 @@
#include "Engine/Core/Formatting.h"
#include "Engine/Core/Templates.h"
struct Vector2;
struct Vector3;
struct Vector4;
/// <summary>
/// Four-components vector (32 bit integer type).
/// </summary>
API_STRUCT(InBuild) struct FLAXENGINE_API Int4
API_STRUCT() struct FLAXENGINE_API Int4
{
DECLARE_SCRIPTING_TYPE_MINIMAL(Int4);
public:
union
{
struct
{
// X component
int32 X;
/// <summary>
/// The X component.
/// </summary>
API_FIELD() int32 X;
// Y component
int32 Y;
/// <summary>
/// The Y component.
/// </summary>
API_FIELD() int32 Y;
// Z component
int32 Z;
/// <summary>
/// The Z component.
/// </summary>
API_FIELD() int32 Z;
// W component
int32 W;
/// <summary>
/// The W component.
/// </summary>
API_FIELD() int32 W;
};
// Raw values
@@ -46,6 +51,12 @@ public:
// Vector with all components equal 1
static const Int4 One;
// A minimum Int4
static const Int4 Minimum;
// A maximum Int4
static const Int4 Maximum;
public:
/// <summary>
@@ -78,9 +89,31 @@ public:
{
}
// Init
// @param v Int2 to use X and Y components
// @param z Z component value
// @param w W component value
Int4(const Int2& xy, int32 z, int32 w);
// Init
// @param v Int3 to use X , Y and Z components
// @param w W component value
Int4(const Int3& xyz, int32 w);
// Init
// @param v Vector2 to use X and Y components
// @param z Z component value
// @param w W component value
explicit Int4(const Vector2& xy, int32 z, int32 w);
// Init
// @param v Vector3 to use X , Y and Z components
// @param w W component value
explicit Int4(const Vector3& xyz, int32 w);
// Init
// @param v Vector to use X, Y, Z and W components
explicit Int4(const Vector4& v);
explicit Int4(const Vector4& xyzw);
public:
@@ -88,6 +121,229 @@ public:
public:
// Arithmetic operators with Int2
Int4 operator+(const Int4& b) const
{
return Add(*this, b);
}
Int4 operator-(const Int4& b) const
{
return Subtract(*this, b);
}
Int4 operator*(const Int4& b) const
{
return Multiply(*this, b);
}
Int4 operator/(const Int4& b) const
{
return Divide(*this, b);
}
Int4 operator-() const
{
return Int4(-X, -Y, -Z, -W);
}
// op= operators with Int2
Int4& operator+=(const Int4& b)
{
*this = Add(*this, b);
return *this;
}
Int4& operator-=(const Int4& b)
{
*this = Subtract(*this, b);
return *this;
}
Int4& operator*=(const Int4& b)
{
*this = Multiply(*this, b);
return *this;
}
Int4& operator/=(const Int4& b)
{
*this = Divide(*this, b);
return *this;
}
// Arithmetic operators with int32
Int4 operator+(int32 b) const
{
return Add(*this, b);
}
Int4 operator-(int32 b) const
{
return Subtract(*this, b);
}
Int4 operator*(int32 b) const
{
return Multiply(*this, b);
}
Int4 operator/(int32 b) const
{
return Divide(*this, b);
}
// op= operators with int32
Int4& operator+=(int32 b)
{
*this = Add(*this, b);
return *this;
}
Int4& operator-=(int32 b)
{
*this = Subtract(*this, b);
return *this;
}
Int4& operator*=(int32 b)
{
*this = Multiply(*this, b);
return *this;
}
Int4& operator/=(int32 b)
{
*this = Divide(*this, b);
return *this;
}
// Comparison operators
bool operator==(const Int4& b) const
{
return X == b.X && Y == b.Y;
}
bool operator!=(const Int4& b) const
{
return X != b.X || Y != b.Y;
}
bool operator>(const Int4& b) const
{
return X > b.X && Y > b.Y;
}
bool operator>=(const Int4& b) const
{
return X >= b.X && Y >= b.Y;
}
bool operator<(const Int4& b) const
{
return X < b.X && Y < b.Y;
}
bool operator<=(const Int4& b) const
{
return X <= b.X && Y <= b.Y;
}
public:
static void Add(const Int4& a, const Int4& b, Int4& result)
{
result.X = a.X + b.X;
result.Y = a.Y + b.Y;
result.Z = a.Z + b.Z;
result.W = a.W + b.W;
}
static Int4 Add(const Int4& a, const Int4& b)
{
Int4 result;
Add(a, b, result);
return result;
}
static void Subtract(const Int4& a, const Int4& b, Int4& result)
{
result.X = a.X - b.X;
result.Y = a.Y - b.Y;
result.Z = a.Z - b.Z;
result.W = a.W - b.W;
}
static Int4 Subtract(const Int4& a, const Int4& b)
{
Int4 result;
Subtract(a, b, result);
return result;
}
static Int4 Multiply(const Int4& a, const Int4& b)
{
return Int4(a.X * b.X, a.Y * b.Y, a.Z * b.Z, a.W * b.W);
}
static Int4 Multiply(const Int4& a, int32 b)
{
return Int4(a.X * b, a.Y * b, a.Z * b, a.W * b);
}
static Int4 Divide(const Int4& a, const Int4& b)
{
return Int4(a.X / b.X, a.Y / b.Y, a.Z / b.Z, a.W / b.W);
}
static Int4 Divide(const Int4& a, int32 b)
{
return Int4(a.X / b, a.Y / b, a.Z / b, a.Y / b);
}
public:
/// <summary>
/// Gets a value indicting whether this vector is zero.
/// </summary>
/// <returns> True if the vector is zero, otherwise false.</returns>
bool IsZero() const
{
return X == 0 && Y == 0 && Z == 0 && W == 0;
}
/// <summary>
/// Gets a value indicting whether any vector component is zero.
/// </summary>
/// <returns> True if a component is zero, otherwise false.</returns>
bool IsAnyZero() const
{
return X == 0 || Y == 0 || Z == 0 || W == 0;
}
/// <summary>
/// Gets a value indicting whether this vector is one.
/// </summary>
/// <returns> True if the vector is one, otherwise false.</returns>
bool IsOne() const
{
return X == 1 && Y == 1 && Z == 1 && W == 1;
}
/// <summary>
/// Calculates a vector with values being opposite to values of that vector
/// </summary>
/// <returns>Negative vector</returns>
Int4 GetNegative() const
{
return Int4(-X, -Y, -Z, -W);
}
/// <summary>
/// Returns average arithmetic of all the components
/// </summary>
@@ -123,6 +379,40 @@ public:
{
return Math::Max(X, Y, Z, W);
}
// Returns a vector containing the largest components of the specified vectors
// @param a The first source vector
// @param b The second source vector
static Int4 Max(const Int4& a, const Int4& b)
{
return Int4(a.X > b.X ? a.X : b.X, a.Y > b.Y ? a.Y : b.Y, a.Z > b.Z ? a.Z : b.Z, a.W > b.W ? a.W : b.W);
}
// Returns a vector containing the smallest components of the specified vectors
// @param a The first source vector
// @param b The second source vector
static Int4 Min(const Int4& a, const Int4& b)
{
return Int4(a.X < b.X ? a.X : b.X, a.Y < b.Y ? a.Y : b.Y, a.Z < b.Z ? a.Z : b.Z, a.W < b.W ? a.W : b.W);
}
// Returns a vector containing the largest components of the specified vectors
// @param a The first source vector
// @param b The second source vector
// @param result When the method completes, contains an new vector composed of the largest components of the source vectors
static void Max(const Int4& a, const Int4& b, Int4& result)
{
result = Int4(a.X > b.X ? a.X : b.X, a.Y > b.Y ? a.Y : b.Y, a.Z > b.Z ? a.Z : b.Z, a.W > b.W ? a.W : b.W);
}
// Returns a vector containing the smallest components of the specified vectors
// @param a The first source vector
// @param b The second source vector
// @param result When the method completes, contains an new vector composed of the smallest components of the source vectors
static void Min(const Int4& a, const Int4& b, Int4& result)
{
result = Int4(a.X < b.X ? a.X : b.X, a.Y < b.Y ? a.Y : b.Y, a.Z < b.Z ? a.Z : b.Z, a.W < b.W ? a.W : b.W);
}
};
template<>

32
Source/Engine/Core/Math/Vector2.cpp
View File

@@ -5,6 +5,8 @@
#include "Vector4.h"
#include "Color.h"
#include "Int2.h"
#include "Int3.h"
#include "Int4.h"
#include "../Types/String.h"
static_assert(sizeof(Vector2) == 8, "Invalid Vector2 type size.");
@@ -16,21 +18,33 @@ const Vector2 Vector2::UnitY(0, 1);
const Vector2 Vector2::Minimum(MIN_float);
const Vector2 Vector2::Maximum(MAX_float);
Vector2::Vector2(const Int2& v)
: X((float)v.X)
, Y((float)v.Y)
Vector2::Vector2(const Int2& xy)
: X(static_cast<float>(xy.X))
, Y(static_cast<float>(xy.Y))
{
}
Vector2::Vector2(const Vector3& v)
: X(v.X)
, Y(v.Y)
Vector2::Vector2(const Int3& xyz)
: X(static_cast<float>(xyz.X))
, Y(static_cast<float>(xyz.Y))
{
}
Vector2::Vector2(const Vector4& v)
: X(v.X)
, Y(v.Y)
Vector2::Vector2(const Int4& xyzw)
: X(static_cast<float>(xyzw.X))
, Y(static_cast<float>(xyzw.Y))
{
}
Vector2::Vector2(const Vector3& xyz)
: X(xyz.X)
, Y(xyz.Y)
{
}
Vector2::Vector2(const Vector4& xyzw)
: X(xyzw.X)
, Y(xyzw.Y)
{
}

21
Source/Engine/Core/Math/Vector2.h
View File

@@ -8,6 +8,9 @@
struct Vector3;
struct Vector4;
struct Int2;
struct Int3;
struct Int4;
struct Color;
struct Matrix;
@@ -85,16 +88,24 @@ public:
}
// Init
// @param v Vector to use X and Y components
explicit Vector2(const Int2& v);
// @param v Int2 to use X and Y components
explicit Vector2(const Int2& xy);
// Init
// @param v Vector to use X and Y components
explicit Vector2(const Vector3& v);
// @param v Int3 to use X and Y components
explicit Vector2(const Int3& xyz);
// Init
// @param v Int4 to use X and Y components
explicit Vector2(const Int4& xyzw);
// Init
// @param v Vector3 to use X and Y components
explicit Vector2(const Vector3& xyz);
// Init
// @param v Vector4 to use X and Y components
explicit Vector2(const Vector4& v);
explicit Vector2(const Vector4& xyzw);
// Init
// @param color Color value

22
Source/Engine/Core/Math/Vector3.cpp
View File

@@ -6,7 +6,9 @@
#include "Color.h"
#include "Quaternion.h"
#include "Matrix.h"
#include "Int2.h"
#include "Int3.h"
#include "Int4.h"
#include "../Types/String.h"
static_assert(sizeof(Vector3) == 12, "Invalid Vector3 type size.");
@@ -40,10 +42,24 @@ Vector3::Vector3(const Vector2& xy)
{
}
Vector3::Vector3(const Int2& xy, float z)
: X(static_cast<float>(xy.X))
, Y(static_cast<float>(xy.Y))
, Z(static_cast<float>(z))
{
}
Vector3::Vector3(const Int3& xyz)
: X((float)xyz.X)
, Y((float)xyz.Y)
, Z((float)xyz.Z)
: X(static_cast<float>(xyz.X))
, Y(static_cast<float>(xyz.Y))
, Z(static_cast<float>(xyz.Z))
{
}
Vector3::Vector3(const Int4& xyzw)
: X(static_cast<float>(xyzw.X))
, Y(static_cast<float>(xyzw.Y))
, Z(static_cast<float>(xyzw.Z))
{
}

11
Source/Engine/Core/Math/Vector3.h
View File

@@ -12,6 +12,8 @@ struct Vector2;
struct Vector4;
struct Color;
class String;
struct Int3;
struct Int4;
/// <summary>
/// Represents a three dimensional mathematical vector.
@@ -138,10 +140,19 @@ public:
// @param xy Vector3 value
explicit Vector3(const Vector2& xy);
// Init
// @param xy Int22 with X and Y components values
// @param z Z component value
explicit Vector3(const Int2& xy, float z);
// Init
// @param xyz Int3 value
explicit Vector3(const Int3& xyz);
// Init
// @param xyzw Int4 value
explicit Vector3(const Int4& xyzw);
// Init
// @param xyz Vector4 value
explicit Vector3(const Vector4& xyz);

28
Source/Engine/Core/Math/Vector4.cpp
View File

@@ -3,10 +3,12 @@
#include "Vector4.h"
#include "Vector2.h"
#include "Vector3.h"
#include "Int2.h"
#include "Int3.h"
#include "Int4.h"
#include "Color.h"
#include "Matrix.h"
#include "Rectangle.h"
#include "Int4.h"
#include "../Types/String.h"
static_assert(sizeof(Vector4) == 16, "Invalid Vector4 type size.");
@@ -49,11 +51,27 @@ Vector4::Vector4(const Vector3& xyz, float w)
{
}
Vector4::Vector4(const Int2& xy, float z, float w)
: X(static_cast<float>(xy.X))
, Y(static_cast<float>(xy.Y))
, Z(z)
, W(w)
{
}
Vector4::Vector4(const Int3& xyz, float w)
: X(static_cast<float>(xyz.X))
, Y(static_cast<float>(xyz.Y))
, Z(static_cast<float>(xyz.Z))
, W(w)
{
}
Vector4::Vector4(const Int4& xyzw)
: X((float)xyzw.X)
, Y((float)xyzw.Y)
, Z((float)xyzw.X)
, W((float)xyzw.Y)
: X(static_cast<float>(xyzw.X))
, Y(static_cast<float>(xyzw.Y))
, Z(static_cast<float>(xyzw.X))
, W(static_cast<float>(xyzw.Y))
{
}

14
Source/Engine/Core/Math/Vector4.h
View File

@@ -13,6 +13,9 @@ struct Color;
struct Matrix;
struct Rectangle;
class String;
struct Int2;
struct Int3;
struct Int4;
/// <summary>
/// Represents a four dimensional mathematical vector.
@@ -133,6 +136,17 @@ public:
// @param w W component value
Vector4(const Vector3& xyz, float w);
// Init
// @param xy X and Y values in the vector
// @param z Z component value
// @param w W component value
explicit Vector4(const Int2& xy, float z, float w);
// Init
// @param xyz X, Y and Z values in the vector
// @param w W component value
explicit Vector4(const Int3& xyz, float w);
// Init
// @param color Int4 value
explicit Vector4(const Int4& xyzw);

7
Source/Engine/Core/Math/VectorInt.h
View File

@@ -1,7 +0,0 @@
// Copyright (c) 2012-2021 Wojciech Figat. All rights reserved.
#pragma once
#include "Int2.h"
#include "Int3.h"
#include "Int4.h"

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

@@ -11,6 +11,9 @@
#include "Engine/Core/Math/Vector2.h"
#include "Engine/Core/Math/Vector3.h"
#include "Engine/Core/Math/Vector4.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/Color.h"
#include "Engine/Core/Math/Matrix.h"
@@ -551,6 +554,24 @@ Variant::Variant(const Vector4& v)
*(Vector4*)AsData = v;
}
Variant::Variant(const Int2& v)
: Type(VariantType::Int2)
{
*(Int2*)AsData = v;
}
Variant::Variant(const Int3& v)
: Type(VariantType::Int3)
{
*(Int3*)AsData = v;
}
Variant::Variant(const Int4& v)
: Type(VariantType::Int4)
{
*(Int4*)AsData = v;
}
Variant::Variant(const Color& v)
: Type(VariantType::Color)
{
@@ -1504,6 +1525,132 @@ Variant::operator Vector4() const
}
}
Variant::operator Int2() const
{
switch (Type.Type)
{
case VariantType::Bool:
return Int2((int32)(AsBool ? 1.0f : 0.0f));
case VariantType::Int:
return Int2((int32)AsInt);
case VariantType::Uint:
return Int2((int32)AsUint);
case VariantType::Int64:
return Int2((int32)AsInt64);
case VariantType::Uint64:
case VariantType::Enum:
return Int2((int32)AsUint64);
case VariantType::Float:
return Int2((int32)AsFloat);
case VariantType::Double:
return Int2((int32)AsDouble);
case VariantType::Pointer:
return Int2((int32)(intptr)AsPointer);
case VariantType::Vector2:
return Int2(*(Vector2*)AsData);
case VariantType::Vector3:
return Int2(*(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);
case VariantType::Structure:
if (StringUtils::Compare(Type.TypeName, Int2::TypeInitializer.GetType().Fullname.Get()) == 0)
return *(Int2*)AsBlob.Data;
default:
return Int3::Zero;
}
}
Variant::operator Int3() const
{
switch (Type.Type)
{
case VariantType::Bool:
return Int3((int32)(AsBool ? 1.0f : 0.0f));
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.0f);
case VariantType::Vector3:
return Int3(*(Vector3*)AsData);
case VariantType::Vector4:
return Int3(*(Vector4*)AsData);
case VariantType::Int2:
return Int3(*(Int2*)AsData, 0.0f);
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;
}
}
Variant::operator Int4() const
{
switch (Type.Type)
{
case VariantType::Bool:
return Int4((int32)(AsBool ? 1.0f : 0.0f));
case VariantType::Int:
return Int4((int32)AsInt);
case VariantType::Uint:
return Int4((int32)AsUint);
case VariantType::Int64:
return Int4((int32)AsInt64);
case VariantType::Uint64:
case VariantType::Enum:
return Int4((int32)AsUint64);
case VariantType::Float:
return Int4((int32)AsFloat);
case VariantType::Double:
return Int4((int32)AsDouble);
case VariantType::Pointer:
return Int4((int32)(intptr)AsPointer);
case VariantType::Vector2:
return Int4(*(Vector2*)AsData, 0.0f, 0.0f);
case VariantType::Vector3:
return Int4(*(Vector3*)AsData, 0.0f);
case VariantType::Vector4:
return Int4(*(Vector4*)AsData);
case VariantType::Int2:
return Int4(*(Int2*)AsData, 0.0f, 0.0f);
case VariantType::Int3:
return Int4(*(Int3*)AsData, 0.0f);
case VariantType::Int4:
case VariantType::Color:
return *(Int4*)AsData;
case VariantType::Structure:
if (StringUtils::Compare(Type.TypeName, Int4::TypeInitializer.GetType().Fullname.Get()) == 0)
return *(Int4*)AsBlob.Data;
default:
return Int4::Zero;
}
}
Variant::operator Color() const
{
switch (Type.Type)
@@ -1670,6 +1817,21 @@ const Vector4& Variant::AsVector4() const
return *(const Vector4*)AsData;
}
const Int2& Variant::AsInt2() const
{
return *(const Int2*)AsData;
}
const Int3& Variant::AsInt3() const
{
return *(const Int3*)AsData;
}
const Int4& Variant::AsInt4() const
{
return *(const Int4*)AsData;
}
const Color& Variant::AsColor() const
{
return *(const Color*)AsData;

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

@@ -54,6 +54,10 @@ API_STRUCT(InBuild) struct FLAXENGINE_API VariantType
ManagedObject,
Typename,
Int2,
Int3,
Int4,
MAX
};
@@ -198,6 +202,9 @@ public:
Variant(const Vector2& v);
Variant(const Vector3& v);
Variant(const Vector4& v);
Variant(const Int2& v);
Variant(const Int3& v);
Variant(const Int4& v);
Variant(const Color& v);
Variant(const Quaternion& v);
Variant(const BoundingSphere& v);
@@ -262,6 +269,9 @@ public:
explicit operator Vector2() const;
explicit operator Vector3() const;
explicit operator Vector4() const;
explicit operator Int2() const;
explicit operator Int3() const;
explicit operator Int4() const;
explicit operator Color() const;
explicit operator Quaternion() const;
explicit operator Guid() const;
@@ -275,6 +285,9 @@ public:
const Vector2& AsVector2() const;
const Vector3& AsVector3() const;
const Vector4& AsVector4() const;
const Int2& AsInt2() const;
const Int3& AsInt3() const;
const Int4& AsInt4() const;
const Color& AsColor() const;
const Quaternion& AsQuaternion() const;

39
Source/Engine/Serialization/JsonWriter.h
View File

@@ -11,6 +11,9 @@
#include "Engine/Core/Math/Vector2.h"
#include "Engine/Core/Math/Vector3.h"
#include "Engine/Core/Math/Vector4.h"
#include "Engine/Core/Math/Int2.h"
#include "Engine/Core/Math/Int3.h"
#include "Engine/Core/Math/Int4.h"
#include "Engine/Core/Math/Color.h"
#include "Engine/Core/Math/Quaternion.h"
#include "Engine/Core/Math/Ray.h"
@@ -149,6 +152,42 @@ public:
EndObject();
}
void Int2(const Int2& value)
{
StartObject();
JKEY("X");
Int(value.X);
JKEY("Y");
Int(value.Y);
EndObject();
}
void Int3(const Int3& value)
{
StartObject();
JKEY("X");
Int(value.X);
JKEY("Y");
Int(value.Y);
JKEY("Z");
Int(value.Z);
EndObject();
}
void Int4(const Int4& value)
{
StartObject();
JKEY("X");
Int(value.X);
JKEY("Y");
Int(value.Y);
JKEY("Z");
Int(value.Z);
JKEY("W");
Int(value.W);
EndObject();
}
void Color(const Color& value)
{
StartObject();

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

@@ -138,6 +138,15 @@ void Serialization::Serialize(ISerializable::SerializeStream& stream, const Vari
case VariantType::Vector4:
stream.Vector4(*(Vector4*)v.AsData);
break;
case VariantType::Int2:
stream.Int2(*(Int2*)v.AsData);
break;
case VariantType::Int3:
stream.Int3(*(Int3*)v.AsData);
break;
case VariantType::Int4:
stream.Int4(*(Int4*)v.AsData);
break;
case VariantType::Color:
stream.Color(*(Color*)v.AsData);
break;
@@ -258,6 +267,15 @@ void Serialization::Deserialize(ISerializable::DeserializeStream& stream, Varian
case VariantType::Vector4:
Deserialize(value, *(Vector4*)v.AsData, modifier);
break;
case VariantType::Int2:
Deserialize(value, *(Int2*)v.AsData, modifier);
break;
case VariantType::Int3:
Deserialize(value, *(Int3*)v.AsData, modifier);
break;
case VariantType::Int4:
Deserialize(value, *(Int4*)v.AsData, modifier);
break;
case VariantType::Color:
Deserialize(value, *(Color*)v.AsData, modifier);
break;
@@ -445,6 +463,51 @@ void Serialization::Deserialize(ISerializable::DeserializeStream& stream, Vector
v.W = mW != stream.MemberEnd() ? mW->value.GetFloat() : 0.0f;
}
bool Serialization::ShouldSerialize(const Int2& v, const void* otherObj)
{
return !otherObj || !(v == *(Int2*)otherObj);
}
void Serialization::Deserialize(ISerializable::DeserializeStream& stream, Int2& v, ISerializeModifier* modifier)
{
const auto mX = SERIALIZE_FIND_MEMBER(stream, "X");
const auto mY = SERIALIZE_FIND_MEMBER(stream, "Y");
v.X = mX != stream.MemberEnd() ? mX->value.GetInt() : 0;
v.Y = mY != stream.MemberEnd() ? mY->value.GetInt() : 0;
}
bool Serialization::ShouldSerialize(const Int3& v, const void* otherObj)
{
return !otherObj || !(v == *(Int3*)otherObj);
}
void Serialization::Deserialize(ISerializable::DeserializeStream& stream, Int3& v, ISerializeModifier* modifier)
{
const auto mX = SERIALIZE_FIND_MEMBER(stream, "X");
const auto mY = SERIALIZE_FIND_MEMBER(stream, "Y");
const auto mZ = SERIALIZE_FIND_MEMBER(stream, "Z");
v.X = mX != stream.MemberEnd() ? mX->value.GetInt() : 0;
v.Y = mY != stream.MemberEnd() ? mY->value.GetInt() : 0;
v.Z = mZ != stream.MemberEnd() ? mZ->value.GetInt() : 0;
}
bool Serialization::ShouldSerialize(const Int4& v, const void* otherObj)
{
return !otherObj || !(v == *(Int4*)otherObj);
}
void Serialization::Deserialize(ISerializable::DeserializeStream& stream, Int4& v, ISerializeModifier* modifier)
{
const auto mX = SERIALIZE_FIND_MEMBER(stream, "X");
const auto mY = SERIALIZE_FIND_MEMBER(stream, "Y");
const auto mZ = SERIALIZE_FIND_MEMBER(stream, "Z");
const auto mW = SERIALIZE_FIND_MEMBER(stream, "W");
v.X = mX != stream.MemberEnd() ? mX->value.GetInt() : 0;
v.Y = mY != stream.MemberEnd() ? mY->value.GetInt() : 0;
v.Z = mZ != stream.MemberEnd() ? mZ->value.GetInt() : 0;
v.W = mW != stream.MemberEnd() ? mW->value.GetInt() : 0;
}
bool Serialization::ShouldSerialize(const Quaternion& v, const void* otherObj)
{
return !otherObj || !Quaternion::NearEqual(v, *(Quaternion*)otherObj, SERIALIZE_EPSILON);

21
Source/Engine/Serialization/Serialization.h
View File

@@ -268,6 +268,27 @@ namespace Serialization
}
FLAXENGINE_API void Deserialize(ISerializable::DeserializeStream& stream, Vector4& v, ISerializeModifier* modifier);
FLAXENGINE_API bool ShouldSerialize(const Int2& v, const void* otherObj);
inline void Serialize(ISerializable::SerializeStream& stream, const Int2& v, const void* otherObj)
{
stream.Int2(v);
}
FLAXENGINE_API void Deserialize(ISerializable::DeserializeStream& stream, Int2& v, ISerializeModifier* modifier);
FLAXENGINE_API bool ShouldSerialize(const Int3& v, const void* otherObj);
inline void Serialize(ISerializable::SerializeStream& stream, const Int3& v, const void* otherObj)
{
stream.Int3(v);
}
FLAXENGINE_API void Deserialize(ISerializable::DeserializeStream& stream, Int3& v, ISerializeModifier* modifier);
FLAXENGINE_API bool ShouldSerialize(const Int4& v, const void* otherObj);
inline void Serialize(ISerializable::SerializeStream& stream, const Int4& v, const void* otherObj)
{
stream.Int4(v);
}
FLAXENGINE_API void Deserialize(ISerializable::DeserializeStream& stream, Int4& v, ISerializeModifier* modifier);
FLAXENGINE_API bool ShouldSerialize(const Quaternion& v, const void* otherObj);
inline void Serialize(ISerializable::SerializeStream& stream, const Quaternion& v, const void* otherObj)
{

66
Source/Engine/Utilities/Utils.cs
View File

@@ -240,6 +240,36 @@ namespace FlaxEngine
return new Vector4(stream.ReadSingle(), stream.ReadSingle(), stream.ReadSingle(), stream.ReadSingle());
}
/// <summary>
/// Reads the Int2 from the binary stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns>The value.</returns>
public static Int2 ReadInt2(this BinaryReader stream)
{
return new Int2(stream.ReadInt32(), stream.ReadInt32());
}
/// <summary>
/// Reads the Int3 from the binary stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns>The value.</returns>
public static Int3 ReadInt3(this BinaryReader stream)
{
return new Int3(stream.ReadInt32(), stream.ReadInt32(), stream.ReadInt32());
}
/// <summary>
/// Reads the Int4 from the binary stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <returns>The value.</returns>
public static Int4 ReadInt4(this BinaryReader stream)
{
return new Int4(stream.ReadInt32(), stream.ReadInt32(), stream.ReadInt32(), stream.ReadInt32());
}
/// <summary>
/// Reads the Quaternion from the binary stream.
/// </summary>
@@ -362,6 +392,42 @@ namespace FlaxEngine
stream.Write(value.W);
}
/// <summary>
/// Writes the Int2 to the binary stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="value">The value to write.</param>
public static void Write(this BinaryWriter stream, Int2 value)
{
stream.Write(value.X);
stream.Write(value.Y);
}
/// <summary>
/// Writes the Int3 to the binary stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="value">The value to write.</param>
public static void Write(this BinaryWriter stream, Int3 value)
{
stream.Write(value.X);
stream.Write(value.Y);
stream.Write(value.Z);
}
/// <summary>
/// Writes the Int4 to the binary stream.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="value">The value to write.</param>
public static void Write(this BinaryWriter stream, Int4 value)
{
stream.Write(value.X);
stream.Write(value.Y);
stream.Write(value.Z);
stream.Write(value.W);
}
/// <summary>
/// Writes the Quaternion to the binary stream.
/// </summary>