From 08c2d7b9d179886e0173d476bdd6534670b9622a Mon Sep 17 00:00:00 2001 From: scorpioblood <77296181+scorpioblood@users.noreply.github.com> Date: Wed, 15 May 2024 18:02:01 +0200 Subject: [PATCH] Remove math. --- .gitignore | 3 +- .gitmodules | 0 Engine/src/Runtime/Core/Core.h | 24 +- Engine/src/Runtime/Core/Include.h | 40 +- .../Runtime/Core/private/Math/IntPoint.cpp | 22 - .../Runtime/Core/private/Math/IntVector2.cpp | 461 ------- .../Runtime/Core/private/Math/IntVector3.cpp | 514 ------- .../Runtime/Core/private/Math/MathCommon.cpp | 57 - .../Core/private/Math/MathTypeConversion.cpp | 48 - .../Core/private/Math/MathUnitConversion.cpp | 40 - .../src/Runtime/Core/private/Math/Matrix2.cpp | 237 ---- .../src/Runtime/Core/private/Math/Matrix3.cpp | 303 ----- .../src/Runtime/Core/private/Math/Matrix4.cpp | 347 ----- .../src/Runtime/Core/private/Math/Point.cpp | 34 - .../src/Runtime/Core/private/Math/Vector2.cpp | 570 -------- .../src/Runtime/Core/private/Math/Vector3.cpp | 669 --------- .../src/Runtime/Core/private/Math/Vector4.cpp | 388 ------ .../private/StartingPoint/StartingPoint.cpp | 59 +- .../src/Runtime/Core/public/Math/IntPoint.h | 156 --- .../src/Runtime/Core/public/Math/IntVector2.h | 872 ------------ .../src/Runtime/Core/public/Math/IntVector3.h | 966 ------------- .../src/Runtime/Core/public/Math/IntVector4.h | 941 ------------- .../Core/public/Math/MathAbstractTypes.h | 29 - .../src/Runtime/Core/public/Math/MathCommon.h | 98 -- Engine/src/Runtime/Core/public/Math/MathFwd.h | 103 -- .../Core/public/Math/MathTypeConversion.h | 77 -- .../Core/public/Math/MathUnitConversion.h | 121 -- Engine/src/Runtime/Core/public/Math/Matrix2.h | 154 --- Engine/src/Runtime/Core/public/Math/Matrix3.h | 105 -- Engine/src/Runtime/Core/public/Math/Matrix4.h | 103 -- Engine/src/Runtime/Core/public/Math/Plane.h | 23 - Engine/src/Runtime/Core/public/Math/Point.h | 184 --- Engine/src/Runtime/Core/public/Math/README.md | 12 - Engine/src/Runtime/Core/public/Math/Vector2.h | 934 ------------- Engine/src/Runtime/Core/public/Math/Vector3.h | 1191 ----------------- Engine/src/Runtime/Core/public/Math/Vector4.h | 155 --- .../Core/public/StartingPoint/EntryPoint.h | 2 +- .../Core/public/StartingPoint/StartingPoint.h | 3 +- Engine/src/Runtime/PhanesEnginePCH.h | 9 + Engine/src/Runtime/REAME.md | 15 + Samples/DevPlayground/DevPlayground.cpp | 7 +- Tests/TestProject/Main.cpp | 2 +- 42 files changed, 112 insertions(+), 9966 deletions(-) create mode 100644 .gitmodules delete mode 100644 Engine/src/Runtime/Core/private/Math/IntPoint.cpp delete mode 100644 Engine/src/Runtime/Core/private/Math/IntVector2.cpp delete mode 100644 Engine/src/Runtime/Core/private/Math/IntVector3.cpp delete mode 100644 Engine/src/Runtime/Core/private/Math/MathCommon.cpp delete mode 100644 Engine/src/Runtime/Core/private/Math/MathTypeConversion.cpp delete mode 100644 Engine/src/Runtime/Core/private/Math/MathUnitConversion.cpp delete mode 100644 Engine/src/Runtime/Core/private/Math/Matrix2.cpp delete mode 100644 Engine/src/Runtime/Core/private/Math/Matrix3.cpp delete mode 100644 Engine/src/Runtime/Core/private/Math/Matrix4.cpp delete mode 100644 Engine/src/Runtime/Core/private/Math/Point.cpp delete mode 100644 Engine/src/Runtime/Core/private/Math/Vector2.cpp delete mode 100644 Engine/src/Runtime/Core/private/Math/Vector3.cpp delete mode 100644 Engine/src/Runtime/Core/private/Math/Vector4.cpp delete mode 100644 Engine/src/Runtime/Core/public/Math/IntPoint.h delete mode 100644 Engine/src/Runtime/Core/public/Math/IntVector2.h delete mode 100644 Engine/src/Runtime/Core/public/Math/IntVector3.h delete mode 100644 Engine/src/Runtime/Core/public/Math/IntVector4.h delete mode 100644 Engine/src/Runtime/Core/public/Math/MathAbstractTypes.h delete mode 100644 Engine/src/Runtime/Core/public/Math/MathCommon.h delete mode 100644 Engine/src/Runtime/Core/public/Math/MathFwd.h delete mode 100644 Engine/src/Runtime/Core/public/Math/MathTypeConversion.h delete mode 100644 Engine/src/Runtime/Core/public/Math/MathUnitConversion.h delete mode 100644 Engine/src/Runtime/Core/public/Math/Matrix2.h delete mode 100644 Engine/src/Runtime/Core/public/Math/Matrix3.h delete mode 100644 Engine/src/Runtime/Core/public/Math/Matrix4.h delete mode 100644 Engine/src/Runtime/Core/public/Math/Plane.h delete mode 100644 Engine/src/Runtime/Core/public/Math/Point.h delete mode 100644 Engine/src/Runtime/Core/public/Math/README.md delete mode 100644 Engine/src/Runtime/Core/public/Math/Vector2.h delete mode 100644 Engine/src/Runtime/Core/public/Math/Vector3.h delete mode 100644 Engine/src/Runtime/Core/public/Math/Vector4.h create mode 100644 Engine/src/Runtime/REAME.md diff --git a/.gitignore b/.gitignore index 44a8d38..b34b882 100644 --- a/.gitignore +++ b/.gitignore @@ -409,4 +409,5 @@ FodyWeavers.xsd # Exclude other folders bin/ -bin-int/ \ No newline at end of file +bin-int/ +external/ \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..e69de29 diff --git a/Engine/src/Runtime/Core/Core.h b/Engine/src/Runtime/Core/Core.h index 0625e01..80942d0 100644 --- a/Engine/src/Runtime/Core/Core.h +++ b/Engine/src/Runtime/Core/Core.h @@ -3,28 +3,28 @@ #ifdef P_WIN_BUILD - #ifdef P_DEBUG - - #define P_DEBUGBREAK DebugBreak(); + #ifdef P_DEBUG + + #define P_DEBUGBREAK DebugBreak(); - #else - - #define P_DEBUGBREAK + #else + + #define P_DEBUGBREAK - #endif // P_DEBUG + #endif // P_DEBUG - #define FORCEINLINE __forceinline + #define FORCEINLINE __forceinline #elif defined(P_UNIX_BUILD) - #error Only Windows is supported at the moment. + #error Only Windows is supported at the moment. #elif defined(P_ARM_BUILD) - - #error Only Windows is supported at the moment. + + #error Only Windows is supported at the moment. #else - #error The target system must be defined. (See https://github.com/scorpioblood/PhanesEngine for more information) + #error The target system must be defined. (See https://github.com/scorpioblood/PhanesEngine for more information) #endif // P_WIN_BUILD \ No newline at end of file diff --git a/Engine/src/Runtime/Core/Include.h b/Engine/src/Runtime/Core/Include.h index d8b9a19..c8fc837 100644 --- a/Engine/src/Runtime/Core/Include.h +++ b/Engine/src/Runtime/Core/Include.h @@ -1,41 +1,23 @@ #pragma once -#ifdef P_USE_NAMESPACES - -using namespace Phanes::Core::Math::Literals; - -// Starting point -namespace PApp = Phanes::Core::Application; - - -// Math -namespace PMath = Phanes::Core::Math; -namespace PMathInternal = Phanes::Core::Math::Internal; - - -// OSAL -namespace PTypes = Phanes::Core::Types - -#endif // --- Starting point ------------------------------ #include "Core/public/StartingPoint/StartingPoint.h" #include "Core/public/StartingPoint/EntryPoint.h" -// --- Math ---------------------------------------- - -#include "Core/public/Math/MathAbstractTypes.h" -#include "Core/public/Math/MathCommon.h" -#include "Core/public/Math/MathTypeConversion.h" -#include "Core/public/Math/MathUnitConversion.h" -#include "Core/public/Math/MathFwd.h" -#include "Core/public/Math/Vector2.h" -#include "Core/public/Math/Vector3.h" - -#include "Core/public/Math/IntVector2.h" -#include "Core/public/Math/IntVector3.h" // --- OSAL ---------------------------------------- #include "Core/public/OSAL/PlatformTypes.h" + + +#ifdef P_USE_NAMESPACE_ALIAS + + +// Starting point +namespace PApp = Phanes::Core::Application; + + using namespace Phanes::Core::Math::UnitLiterals; + +#endif \ No newline at end of file diff --git a/Engine/src/Runtime/Core/private/Math/IntPoint.cpp b/Engine/src/Runtime/Core/private/Math/IntPoint.cpp deleted file mode 100644 index a6936e9..0000000 --- a/Engine/src/Runtime/Core/private/Math/IntPoint.cpp +++ /dev/null @@ -1,22 +0,0 @@ -#include "PhanesEnginePCH.h" - -#include "Core/public/Math/IntPoint.h" - - - -// ----- TIntPoint2 ------------------------------------------ - -template -Rt Phanes::Core::Math::Distance(const TIntPoint2& p1, const TIntPoint2& p2) -{ - return Magnitude(p2 - p1); -} - -// ----- TIntPoint3 ------------------------------------------ - - -template -Rt Phanes::Core::Math::Distance(const TIntPoint3& p1, const TIntPoint3& p2) -{ - return Magnitude(p2 - p1); -} \ No newline at end of file diff --git a/Engine/src/Runtime/Core/private/Math/IntVector2.cpp b/Engine/src/Runtime/Core/private/Math/IntVector2.cpp deleted file mode 100644 index f770a06..0000000 --- a/Engine/src/Runtime/Core/private/Math/IntVector2.cpp +++ /dev/null @@ -1,461 +0,0 @@ -// ============================== // -// TIntVector2 implementation // -// ============================== // - - -#include "PhanesEnginePCH.h" - -#include "Core/public/Math/IntVector2.h" - -#include "Core/public/Math/IntPoint.h" - -//#include "Math/Matrix2.h" -//#include "Math/Matrix2.h" -//#include "Math/Vector3.h" -//#include "Math/Vector4.h" -//#include "Math/IntVector2.h" -//#include "Math/IntVector3.h" -//#include "Math/IntVector4.h" - - -// ============================ // -// TIntVector2 constructors // -// ============================ // - -template -Phanes::Core::Math::TIntVector2::TIntVector2(const T x, const T y) -{ - this->x = x; - this->y = y; -} - -template -Phanes::Core::Math::TIntVector2::TIntVector2(const T* comp) -{ - static_assert(sizeof(comp) > 2 * sizeof(T), "PHANES_CORE (IntVector2.cpp): Setting 2D vector coordinates by an array, comp must have a size of at least 2 components."); - memcpy(this->comp, comp, sizeof(T) * 2); -} - -template -Phanes::Core::Math::TIntVector2::TIntVector2(const TIntPoint2& start, const TIntPoint2& end) -{ - this->x = end.x - start.x; - this->y = end.y - start.y; -} - -template -Phanes::Core::Math::TIntVector2::TIntVector2(const TIntVector3& v) -{ - this->x = v.x; - this->y = v.y; -} - -template -Phanes::Core::Math::TIntVector2::TIntVector2(const TIntVector2& v) -{ - memcpy(this->comp, comp, sizeof(T) * 2); -} - -template -Phanes::Core::Math::TIntVector2::TIntVector2(TIntVector2&& v) -{ - this->comp = v.comp; - v.comp = nullptr; -} - - -// ========================= // -// TIntVector2 operators // -// ========================= // - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator+=(TIntVector2& v1, T s) -{ - v1.x += s; - v1.y += s; - - return v1; -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator+=(TIntVector2& v1, const TIntVector2& v2) -{ - v1.x += v2.x; - v1.y += v2.y; - - return v1; -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator-=(TIntVector2& v1, T s) -{ - v1.x -= s; - v1.y -= s; - - return v1; -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator-=(TIntVector2& v1, const TIntVector2& v2) -{ - v1.x -= v2.x; - v1.y -= v2.y; - - return v1; -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator*=(TIntVector2& v1, T s) -{ - v1.x *= s; - v1.y *= s; - - return v1; -} -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator*(const TIntVector2& v1, T s) -{ - return TIntVector2(v1.x * s, v1.y * s); -} - -template -inline Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator*(T s, const TIntVector2& v1) -{ - return v1 * s; -} - -template -Rt Phanes::Core::Math::operator* (const TIntVector2& v1, const TIntVector2& v2) -{ - return v1.x * v2.x + v1.y * v2.y; -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator+(const TIntVector2& v1, T s) -{ - return TIntVector2(v1.x + s, v1.y + s); -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator+(const TIntVector2& v1, const TIntVector2& v2) -{ - return TIntVector2(v1.x + v2.x, v1.y + v2.y); -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator-(const TIntVector2& v1, T s) -{ - return TIntVector2(v1.x - s, v1.y - s); -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator-(const TIntVector2& v1, const TIntVector2& v2) -{ - return TIntVector2(v1.x - v2.x, v1.y - v2.y); -} - -template -void Phanes::Core::Math::operator-(TIntVector2& v1) -{ - v1.x = -v1.x; - v1.y = -v1.y; -} - -template -bool Phanes::Core::Math::operator== (const TIntVector2& v1, const TIntVector2& v2) -{ - return (abs(v1.x - v1.x) < P_FLT_INAC && abs(v1.y - v1.y) < P_FLT_INAC); -} - -template -bool Phanes::Core::Math::operator!=(const TIntVector2& v1, const TIntVector2& v2) -{ - return (abs(v1.x - v1.x) > P_FLT_INAC || abs(v1.y - v1.y) > P_FLT_INAC); -} - -template -Rt Phanes::Core::Math::Magnitude(const TIntVector2& v1) -{ - return sqrtf(v1.x * v1.x + v1.y * v1.y); -} - -template -T Phanes::Core::Math::SqrMagnitude(const TIntVector2& v1) -{ - return v1.x * v1.x + v1.y * v1.y; -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::DivideTruncV(TIntVector2& v1, T s) -{ - Rt _s = (Rt)1.0 / s; - - v1.x = trunc(v1.x * s); - v1.y = trunc(v1.y * s); - - return v1; -} - -template -Rt Phanes::Core::Math::Angle(const TIntVector2& v1, const TIntVector2& v2) -{ - return acos((v1 * v2) / Magnitude(v1) * Magnitude(v2)); -} - - -template -Rt Phanes::Core::Math::CosineAngle(const TIntVector2& v1, const TIntVector2& v2) -{ - return (v1 * v2) / Magnitude(v1) * Magnitude(v2); -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::SignVectorV(TIntVector2& v1) -{ - v1.x = (v1.x > 0) ? 1 : -1; - v1.y = (v1.y > 0) ? 1 : -1; - - return v1; -} - -template -T Phanes::Core::Math::DotP(const TIntVector2& v1, const TIntVector2& v2) -{ - return v1.x * v2.x + v1.y * v2.y; -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::MaxV(TIntVector2& v1, const TIntVector2& v2) -{ - v1.x = Phanes::Core::Math::Max(v1.x, v2.x); - v1.y = Phanes::Core::Math::Max(v1.y, v2.y); - - return v1; -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::MinV(TIntVector2& v1, const TIntVector2& v2) -{ - v1.x = Phanes::Core::Math::Min(v1.x, v2.x); - v1.y = Phanes::Core::Math::Min(v1.y, v2.y); - - return v1; -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::GetPerpendicularV(TIntVector2& v1) -{ - T x = v1.x; - v1.x = v1.y; - v1.y = -v1.x; - - return v1; -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::GetReversePerpendicularV(TIntVector2& v1) -{ - T x = v1.x; - v1.x = -v1.y; - v1.y = v1.x; - - return v1; -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::ScaleV(TIntVector2& v1, const TIntVector2& v2) -{ - v1.x *= v2.x; - v1.y *= v2.y; - - return v1; -} - - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::Set(TIntVector2& v1, const TIntVector2& v2) -{ - v1 = v2; - - return v1; -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::Set(TIntVector2& v1, T x, T y) -{ - v1.x = x; - v1.y = y; - - return v1; -} - - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::NegateV(TIntVector2& v1) -{ - v1.x = -v1.x; - v1.y = -v1.y; -} - -template -inline bool Phanes::Core::Math::IsNormalized(const TIntVector2& v1) -{ - return (SqrMagnitude(v1)); -} - -template -inline bool Phanes::Core::Math::IsPerpendicular(const TIntVector2& v1, const TIntVector2& v2) -{ - return (abs(DotP(v1, v2)) = 0); -} - -template -inline bool Phanes::Core::Math::IsParallel(const TIntVector2& v1, const TIntVector2& v2) -{ - return (abs(DotP(v1, v2)) = 1); -} - -template -inline bool Phanes::Core::Math::IsCoincident(const TIntVector2& v1, const TIntVector2& v2) -{ - return (DotP(v1, v2) > 1); -} - -// -//Phanes::Core::Math::Matrix2 Phanes::Core::Math::OuterProduct(const TIntVector2& v1, const TIntVector2& v2) -//{ -// return Matrix2( -// v1.x * v2.x, v1.x * v2.y, -// v1.y * v2.x, v1.y * v2.y -// ); -//} - -// ================================================================= // -// TIntVector2 static function implementation with return values // -// ================================================================= // - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::Reflect(const TIntVector2& v1, const TVector2& normal) -{ - return TVector2(v1 - (2 * (v1 * normal) * normal)); -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::Scale(const TIntVector2& v1, const TIntVector2& v2) -{ - return TIntVector2(v1.x * v2.x, v1.y * v2.y); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::CompInverse(const TIntVector2& v1) -{ - return TVector2(1.0f / v1.x, 1.0f / v1.y); -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::Negate(const TIntVector2& v1) -{ - return TIntVector2(-v1.x, -v1.y); -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::GetPerpendicular(const TIntVector2& v1) -{ - return TIntVector2(v1.y, -v1.x); -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::GetReversePerpendicular(const TIntVector2& v1) -{ - return TIntVector2(-v1.y, v1.x); -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::Min(const TIntVector2& v1, const TIntVector2& v2) -{ - return TIntVector2(Phanes::Core::Math::Min(v1.x, v2.x), Phanes::Core::Math::Min(v1.y, v2.y)); -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::Max(const TIntVector2& v1, const TIntVector2& v2) -{ - return TIntVector2(Phanes::Core::Math::Max(v1.x, v2.x), Phanes::Core::Math::Max(v1.y, v2.y)); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::Normalize(const TIntVector2& v1) -{ - float vecNorm = Magnitude(v1); - return (vecNorm < P_FLT_INAC) ? PIntZeroVector2(T) : (v1 / vecNorm); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::UnsafeNormalize(const TIntVector2& v1) -{ - return TVector2(v1 / Magnitude(v1)); -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::SignVector(const TIntVector2& v1) -{ - return TIntVector2((v1.x > 0) ? 1 : -1, (v1.y > 0) ? 1 : -1); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::BindToSquare(const TIntVector2& v1, T radius) -{ - float k = (abs(v1.x) > abs(v1.y)) ? abs(radius / v1.x) : abs(radius / v1.y); - return v1 * k; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::ClampToSquare(const TIntVector2& v1, T radius) -{ - float prime = (abs(v1.x) > abs(v1.y)) ? v1.x : v1.y; - float k = (prime > radius) ? abs(radius / prime) : 1.0f; - - return TVector2(v1 * k); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::Lerp(const TIntVector2& startVec, const TIntVector2& destVec, Rt t) -{ - t = Phanes::Core::Math::Clamp(t, (T)0.0, (T)1.0); - - return ((Rt)t * destVec) + (((Rt)1.0 - t) * startVec); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::LerpUnclamped(const TIntVector2& startVec, const TIntVector2& destVec, Rt t) -{ - return ((Rt)t * destVec) + (((Rt)1.0 - t) * startVec); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::Rotate(const TIntVector2& v1, Rt angle) -{ - float sinAngle = sin(angle); - float cosAngle = cos(angle); - - return TVector2((Rt)v1.x * cosAngle - (Rt)v1.y * sinAngle, (Rt)v1.y * cosAngle + (Rt)v1.x * sinAngle); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::ClockwiseRotate(const TIntVector2& v1, Rt angle) -{ - return Rotate(v1, -angle); -} - -template -Phanes::Core::Math::TIntVector2 Phanes::Core::Math::DivideTrunc(const TIntVector2& v1, T s) -{ - Rt _s = (Rt)1.0 / s; - return TIntVector2(trunc(v1.x * _s), trunc(v1.y * _s)); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::DivideFloat(const TIntVector2& v1, T s) -{ - Rt _s = (Rt)1.0 / s; - return TIntVector2((Rt)v1.x * _s, (Rt)v1.y * _s); -} diff --git a/Engine/src/Runtime/Core/private/Math/IntVector3.cpp b/Engine/src/Runtime/Core/private/Math/IntVector3.cpp deleted file mode 100644 index 4e8d81f..0000000 --- a/Engine/src/Runtime/Core/private/Math/IntVector3.cpp +++ /dev/null @@ -1,514 +0,0 @@ -// ============================== // -// TIntVector2 implementation // -// ============================== // - - -#include "PhanesEnginePCH.h" - -#include "Core/public/Math/IntVector3.h" - -#include "Core/public/Math/IntPoint.h" -#include "Core/public/Math/Plane.h" - - -template -inline Phanes::Core::Math::TIntVector3::TIntVector3(const T x, const T y, const T z) -{ - this->x = x; - this->y = y; - this->z = z; -} - -template -Phanes::Core::Math::TIntVector3::TIntVector3(const T* comp) -{ - static_assert(sizeof(comp) > 2 * sizeof(T), "PHANES_CORE (IntVector3.cpp): Setting 3D vector coordinates by an array, comp must have a size of at least 3 components."); - memcpy(this->comp, comp, sizeof(T) * 3); -} - -template -Phanes::Core::Math::TIntVector3::TIntVector3(const TIntVector2& v) -{ - this->x = v.x; - this->y = v.y; - this->z = (T)0; -} - -template -Phanes::Core::Math::TIntVector3::TIntVector3(const TIntPoint3& start, const TIntPoint3& end) -{ - this->x = end.x - start.x; - this->y = end.y - start.y; - this->z = end.z - start.z; -} - -template -Phanes::Core::Math::TIntVector3::TIntVector3(const TIntVector3& v) -{ - memcpy(this->comp, comp, sizeof(T) * 3); -} - -template -Phanes::Core::Math::TIntVector3::TIntVector3(TIntVector3&& v) -{ - this->comp = v.comp; - v.comp = nullptr; -} - -// ========================= // -// TIntVector3 operators // -// ========================= // - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator+=(TIntVector3& v1, T s) -{ - v1.x += s; - v1.y += s; - v1.z += s; - - return v1; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator+=(TIntVector3& v1, const TIntVector3& v2) -{ - v1.x += v2.x; - v1.y += v2.y; - v1.z += v2.z; - - return v1; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator-=(TIntVector3& v1, T s) -{ - v1.x -= s; - v1.y -= s; - v1.z -= s; - - return v1; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator-=(TIntVector3& v1, const TIntVector3& v2) -{ - v1.x -= v2.x; - v1.y -= v2.y; - v1.z -= v2.z; - - return v1; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator*=(TIntVector3& v1, T s) -{ - v1.x *= s; - v1.y *= s; - v1.z *= s; - - return v1; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator*(const TIntVector3& v1, T s) -{ - return TIntVector3(v1.x * s.v1.y * s, v1.z * s); -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator*(T s, const TIntVector3& v1) -{ - return v1 * s; -} - -template -T Phanes::Core::Math::operator*(const TIntVector3& v1, const TIntVector3& v2) -{ - return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator+(const TIntVector3& v1, T s) -{ - return TIntVector3(v1.x + s.v1.y + s, v1.z + s); -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator+(const TIntVector3& v1, const TIntVector3& v2) -{ - return TIntVector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z); -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator-(const TIntVector3& v1, T s) -{ - return TIntVector3(v1.x - s.v1.y - s, v1.z - s); -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator-(const TIntVector3& v1, const TIntVector3& v2) -{ - return TIntVector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z); -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator-(TIntVector3& v1) -{ - v1.x = -v1.x; - v1.y = -v1.y; - v1.z = -v1.z; - - return v1; -} - -template -bool Phanes::Core::Math::operator==(const TIntVector3& v1, const TIntVector3& v2) -{ - return (abs(v1.x - v2.x) < P_FLT_INAC && abs(v1.y - v2.y) < P_FLT_INAC && abs(v1.z - v2.z) < P_FLT_INAC); -} - -template -bool Phanes::Core::Math::operator!=(const TIntVector3& v1, const TIntVector3& v2) -{ - return (abs(v1.x - v2.x) > P_FLT_INAC || abs(v1.y - v2.y) > P_FLT_INAC || abs(v1.z - v2.z) > P_FLT_INAC); -} - -// ======================================= // -// TIntVector3 function implementation // -// ======================================= // - -template -Rt Phanes::Core::Math::Magnitude(const TIntVector3& v1) -{ - return sqrt(DotP(v1, v1)); -} - -template -T Phanes::Core::Math::SqrMagnitude(const TIntVector3& v1) -{ - return DotP(v1, v1); -} - -template -Rt Phanes::Core::Math::Angle(const TIntVector3& v1, const TIntVector3& v2) -{ - return acos((v1 * v2) / (Magnitude(v1) * Magnitude(v2))); -} - -template -T Phanes::Core::Math::DotP(const TIntVector3& v1, const TIntVector3& v2) -{ - return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::VectorTriple(const TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3) -{ - return CrossP(CrossP(v1, v2), v3); -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::SignVector(const TIntVector3& v1) -{ - v1.x = (v1.x > 0) - (v1.x < 0); - v1.y = (v1.y > 0) - (v1.y < 0); - v1.z = (v1.z > 0) - (v1.z < 0); - - - return v1; -} - -template -bool Phanes::Core::Math::Equals(const TIntVector3& v1, const TIntVector3& v2, T threshold) -{ - return (abs(v1.x - v2.x) < threshold && abs(v1.y - v2.y) < threshold && abs(v1.z - v2.z) < threshold); -} - - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::CrossPV(TIntVector3& v1, const TIntVector3& v2) -{ - float x = v1.x; - float y = v1.y; - float z = v1.z; - - v1.x = (y * v2.z) - (z * v2.y); - v1.y = (z * v2.x) - (x * v2.z); - v1.z = (x * v2.y) - (y * v2.x); - - return v1; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::MaxV(TIntVector3& v1, const TIntVector3& v2) -{ - v1.x = Max(v1.x, v2.x); - v1.y = Max(v1.y, v2.y); - v1.z = Max(v1.z, v2.z); - - return v1; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::MinV(TIntVector3& v1, const TIntVector3& v2) -{ - v1.x = Min(v1.x, v2.x); - v1.y = Min(v1.y, v2.y); - v1.z = Min(v1.z, v2.z); - - return v1; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::NegateV(TIntVector3& v1) -{ - v1.x = -v1.x; - v1.y = -v1.y; - v1.z = -v1.z; - - return v1; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::ScaleV(TIntVector3& v1, const TIntVector3& v2) -{ - v1.x *= v2.x; - v1.y *= v2.y; - v1.z *= v2.z; - - return v1; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::Set(TIntVector3& v1, const TIntVector3& v2) -{ - v1 = v2; - - return v1; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::Set(TIntVector3& v1, T x, T y, T z) -{ - v1.x = x; - v1.y = y; - v1.z = z; - - return v1; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::SignVectorV(TIntVector3& v1) -{ - v1.x = (v1.x > 0) ? 1 : 0; - v1.y = (v1.y > 0) ? 1 : 0; - v1.z = (v1.z > 0) ? 1 : 0; - - return v1; -} - -template -T Phanes::Core::Math::ScalarTriple(const TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3) -{ - return CrossP(v1, v2) * v3; -} - -template -T Phanes::Core::Math::CosineAngle(const TIntVector3& v1, const TIntVector3& v2) -{ - return (v1 * v2) / (Magnitude(v1) * Magnitude(v2)); -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::VectorTripleV(TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3) -{ - CrossPV(CrossPV(v1, v2), v3); - - return v1; -} - -template -bool Phanes::Core::Math::IsPerpendicular(const TIntVector3& v1, const TIntVector3& v2, T threshold) -{ - return (abs(DotP(v1, v2)) < threshold); -} - -template -bool Phanes::Core::Math::IsParallel(const TIntVector3& v1, const TIntVector3& v2, T threshold) -{ - return (abs(DotP(v1, v2)) > threshold); -} - -template -bool Phanes::Core::Math::IsCoincident(const TIntVector3& v1, const TIntVector3& v2, T threshold) -{ - return (DotP(v1, v2) > threshold); -} - -template -bool Phanes::Core::Math::IsNormalized(const TIntVector3& v1, T threshold) -{ - return (SqrMagnitude(v1) < threshold); -} - -template -bool Phanes::Core::Math::IsCoplanar(const TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3, T threshold) -{ - return (ScalarTriple(v1, v2, v3) < threshold); -} - - - -// =============== // -// With Return // -// =============== // - - - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Normalize(const TIntVector3& v1) -{ - float vecNorm = Magnitude(v1); - return (vecNorm < P_FLT_INAC) ? PZeroVector3(T) : v1 / vecNorm; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::UnsafeNormalize(const TIntVector3& v1) -{ - return v1 / Magnitude(v1); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Reflect(const TIntVector3& v1, const TVector3& normal) -{ - return v1 - (2 * (v1 * normal) * normal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::PerspectiveDivide(const TIntVector3& v1) -{ - float _z = (T)1.0 / v1.z; - return TIntVector3(v1.x * _z, v1.y * _z, (T)0.0); -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::CrossP(const TIntVector3& v1, const TIntVector3& v2) -{ - return TIntVector3((v1.y * v2.z) - (v1.z * v2.y), - (v1.z * v2.x) - (v1.x * v2.z), - (v1.x * v2.y) - (v1.y * v2.x)); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Lerp(const TIntVector3& start, const TIntVector3& dest, Rt t) -{ - t = Clamp(t, (Rt)0.0, (Rt), 1.0); - return ((Rt)1.0 - t) * start + t * dest; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::LerpUnclamped(const TIntVector3& start, const TIntVector3& dest, Rt t) -{ - return (1 - t) * start + t * dest; -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::Max(const TIntVector3& v1, const TIntVector3& v2) -{ - return TIntVector3((v1.x > v2.x) ? v1.x : v2.x, - (v1.y > v2.y) ? v1.y : v2.y, - (v1.z > v2.z) ? v1.z : v2.z); -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::Min(const TIntVector3& v1, const TIntVector3& v2) -{ - return TIntVector3((v1.x < v2.x) ? v1.x : v2.x, - (v1.y < v2.y) ? v1.y : v2.y, - (v1.z < v2.z) ? v1.z : v2.z); -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::Negate(const TIntVector3& v1) -{ - return TIntVector3(-v1.x, -v1.y, -v1.z); -} - -template -Phanes::Core::Math::TIntVector3 Phanes::Core::Math::Scale(const TIntVector3& v1, const TIntVector3& v2) -{ - return TIntVector3(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ClampMagnitude(const TIntVector3& v1, T min, T max) -{ - Rt magnitude = Magnitude(v1); - - const TVector3 unitVec = (magnitude > P_FLT_INAC) ? v1 / magnitude : PZeroVector3(T); - - Clamp(magnitude, min, max); - - return unitVec * magnitude; -} - - - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ScaleToMagnitude(const TIntVector3& v1, T magnitude) -{ - NormalizeV(v1) *= magnitude; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::CompInverse(const TIntVector3& v1) -{ - return TIntVector3((Rt)1.0 / v1.x, (Rt)1.0 / v1.y, (Rt)1.0 / v1.z); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ReflectFromPlane(const TIntVector3& v1, const TPlane& plane) -{ - return Reflect(v1, plane.normal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ReflectFromPlane(const TIntVector3& v1, const TVector3& normal) -{ - return Reflect(v1, normal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::RotateAroundAxis(const TIntVector3& v1, const TVector3& axisNormal, Rt angle) -{ - T sinAngle = sin(angle); - T cosAngle = cos(angle); - - return ((Rt)1 - cosAngle) * DotP(v1, axisNormal) * axisNormal + cosAngle * v1 + sinAngle * CrossP(v1, axisNormal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Project(const TIntVector3& v1, const TIntVector3& v2) -{ - return (DotP(v1, v2) / DotP(v2, v2)) * v2; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Reject(const TIntVector3& v1, const TIntVector3& v2) -{ - return v1 - (DotP(v1, v2) / DotP(v2, v2)) * v2; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ProjectOntoPlane(const TIntVector3& v1, const TVector3& normal) -{ - return Reject(v1, normal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ProjectOntoPlane(const TIntVector3& v1, const TPlane& plane) -{ - return Reject(v1, plane.normal); -} \ No newline at end of file diff --git a/Engine/src/Runtime/Core/private/Math/MathCommon.cpp b/Engine/src/Runtime/Core/private/Math/MathCommon.cpp deleted file mode 100644 index d673e3d..0000000 --- a/Engine/src/Runtime/Core/private/Math/MathCommon.cpp +++ /dev/null @@ -1,57 +0,0 @@ -#include "PhanesEnginePCH.h" - -#include "Core/public/Math/MathCommon.h" - -#include "Core/public/OSAL/PlatformTypes.h" - -// NOTE: oneline if statments are much faster than the max / min algorithm or expanded if's (64.519 ms per 1 000 000 operations) - -template -T Phanes::Core::Math::Clamp(T value, T low, T high) -{ - if (value < low) value = low; - if (value > high) value = high; - return value; -} - -template -T Phanes::Core::Math::Max(T x, T y) -{ - return (x > y) ? x : y; -} - -template -T Phanes::Core::Math::Min(T x, T y) -{ - return (x < y) ? x : y; -} - -template -void Phanes::Core::Math::Swap(T& x, T& y) -{ - float z = x; - x = y; - y = z; -} - -template -bool Phanes::Core::Math::Equals(T x, T y, T threshold) -{ - if (abs(x - y) < threshold) { - return true; - } - return false; -} - -template -float Phanes::Core::Math::FastInvSqrt(T n) -{ - Phanes::Core::Types::int32 i = * ( int * ) &n; - float x2 = n * 0.5f; - - i = 0x5f3759df - (i >> 1); - n = * ( float * ) &i; - n = n * (1.5f - (x2 * n * n)); - - return n; -} \ No newline at end of file diff --git a/Engine/src/Runtime/Core/private/Math/MathTypeConversion.cpp b/Engine/src/Runtime/Core/private/Math/MathTypeConversion.cpp deleted file mode 100644 index c4a0934..0000000 --- a/Engine/src/Runtime/Core/private/Math/MathTypeConversion.cpp +++ /dev/null @@ -1,48 +0,0 @@ -#include "PhanesEnginePCH.h" -#include "Core/public/Math/MathTypeConversion.h" - -// ============ // -// ToString // -// ============ // - -template -std::string Phanes::Core::Math::ToString(const Phanes::Core::Math::TVector2& v) { - return "(" + std::to_string(v.x) + ", " + std::to_string(v.y) + ")"; -} - -template -std::string Phanes::Core::Math::ToString(const TIntVector2& v) -{ - return "(" + std::to_string(v.x) + ", " + std::to_string(v.y) + ")"; -} - -template -std::string Phanes::Core::Math::ToString(const Phanes::Core::Math::TVector3& v) { - return "(" + std::to_string(v.x) + ", " + std::to_string(v.y) + ", " + std::to_string(v.z) + ")"; -} - -template -std::string Phanes::Core::Math::ToString(const TIntVector3& v) -{ - std::to_string(3); - - return "(" + std::to_string(v.x) + ", " + std::to_string(v.y) + ", " + std::to_string(v.z) + ")"; -} - -//template -//std::string Phanes::Core::Math::ToString(const Vector4& v) -//{ -// return "(" + std::to_string(v.x) + ", " + std::to_string(v.y) + ", " + std::to_string(v.z) + ", " + std::to_string(v.w) + ")"; -//} -// -//template -//std::string Phanes::Core::Math::ToString(const Matrix2& v) -//{ -// return std::to_string(v(0,0)) + " | " + std::to_string(v(0,1)) + "\n" + std::to_string(v(1,0)) + " | " + std::to_string(v(1,1)); -//} -// -//template -//std::string Phanes::Core::Math::ToString(const Matrix3& v) -//{ -// return std::to_string(v(0, 0)) + " | " + std::to_string(v(0, 1)) + " | " + std::to_string(v(0, 2)) + "\n" + std::to_string(v(1, 0)) + " | " + std::to_string(v(1, 1)) + " | " + std::to_string(v(1, 2)) + "\n" + std::to_string(v(2, 0)) + " | " + std::to_string(v(2, 1)) + " | " + std::to_string(v(2, 2)); -//} diff --git a/Engine/src/Runtime/Core/private/Math/MathUnitConversion.cpp b/Engine/src/Runtime/Core/private/Math/MathUnitConversion.cpp deleted file mode 100644 index e43776b..0000000 --- a/Engine/src/Runtime/Core/private/Math/MathUnitConversion.cpp +++ /dev/null @@ -1,40 +0,0 @@ -#include "PhanesEnginePCH.h" - -#include "Core/public/Math/MathUnitConversion.h" - - -template -inline T Phanes::Core::Math::UnitConversion::DegToRad(T deg) -{ - return deg * P_PI_180_FLT; -} - -template -inline T Phanes::Core::Math::UnitConversion::RadToDeg(T rad) -{ - return rad * P_180_PI_FLT; -} - -template -inline T Phanes::Core::Math::UnitConversion::DegToGradian(T deg) -{ - return deg * 1.111111f; -} - -template -inline T Phanes::Core::Math::UnitConversion::GradianToDeg(T g) -{ - return g * 0.9f; -} - -template -inline T Phanes::Core::Math::UnitConversion::RadToGradian(T rad) -{ - return rad * 200 / P_PI_FLT; -} - -template -inline T Phanes::Core::Math::UnitConversion::GradianToRad(T g) -{ - return g * P_PI_FLT / 200; -} \ No newline at end of file diff --git a/Engine/src/Runtime/Core/private/Math/Matrix2.cpp b/Engine/src/Runtime/Core/private/Math/Matrix2.cpp deleted file mode 100644 index fa48784..0000000 --- a/Engine/src/Runtime/Core/private/Math/Matrix2.cpp +++ /dev/null @@ -1,237 +0,0 @@ -// =========================== // -// Matrix2D implementation // -// =========================== // - - -#include "Misc/CommonDefines.h" -#include PHANES_CORE_PCH_DEFAULT_PATH - -#include "Math/Matrix2.h" - -#pragma warning(disable : 4172) - -// ================================= // -// Class Methods for easy access // -// ================================= // - -float& phanes::core::math::coretypes::Matrix2::operator()(int n, int m) -{ - return this->fields[m][n]; -} - -const float& phanes::core::math::coretypes::Matrix2::operator()(int n, int m) const -{ - return this->fields[m][n]; -} - -phanes::core::math::coretypes::Vector2& phanes::core::math::coretypes::Matrix2::operator[](int m) -{ - return (*reinterpret_cast(this->fields[m])); -} - -const phanes::core::math::coretypes::Vector2& phanes::core::math::coretypes::Matrix2::operator[](int m) const -{ - return (*reinterpret_cast(this->fields[m])); -} - - -// ================= // -// Constructors // -// ================= // - -phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::createMatrix(float fields[2][2]) -{ - Matrix2 a; - std::copy(&fields[0][0], &fields[2][2], &a.fields[0][0]); - return a; -} - -phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::createMatrix(float f00, float f01, float f10, float f11) -{ - Matrix2 a; - a.fields[0][0] = f00; a.fields[1][0] = f01; - a.fields[0][1] = f10; a.fields[1][1] = f11; - return a; -} - -phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::createMatrix(const Vector2& a, const Vector2& b) -{ - Matrix2 m; - m.fields[0][0] = a.x; m.fields[1][0] = b.x; - m.fields[0][1] = a.y; m.fields[1][1] = b.y; - return m; -} - - -// ============= // -// Operators // -// ============= // - - -void phanes::core::math::coretypes::operator+=(Matrix2& a, float s) -{ - a[0] += s; - a[1] += s; -} - -void phanes::core::math::coretypes::operator+=(Matrix2& a, const Matrix2& b) -{ - a[0] += b[0]; - a[1] += b[1]; -} - -void phanes::core::math::coretypes::operator-=(Matrix2& a, float s) -{ - a[0] -= s; - a[1] -= s; -} - -void phanes::core::math::coretypes::operator-=(Matrix2& a, const Matrix2& b) -{ - a[0] -= b[0]; - a[1] -= b[1]; -} - -void phanes::core::math::coretypes::operator*=(Matrix2& a, float s) -{ - a[0] *= s; - a[1] *= s; -} - -void phanes::core::math::coretypes::operator*=(Matrix2& a, const Matrix2& b) -{ - Matrix2 c = a; - - a(0, 0) = c(0, 0) * b(0, 0) + c(0, 1) * b(1, 0); - a(0, 1) = c(0, 0) * b(0, 1) + c(0, 1) * b(1, 1); - - a(1, 0) = c(1, 0) * b(0, 0) + c(1, 1) * b(1, 0); - a(1, 1) = c(1, 0) * b(0, 1) + c(1, 1) * b(1, 1); -} - - -phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::operator+(const Matrix2& a, float s) -{ - Matrix2 m; - m[0] = a[0] + s; - m[1] = a[1] + s; - return m; -} - -phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::operator+(const Matrix2& a, const Matrix2& b) -{ - Matrix2 m; - m[0] = a[0] + b[0]; - m[1] = a[1] + b[1]; - return m; -} - -phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::operator-(const Matrix2& a, float s) -{ - Matrix2 m; - m[0] = a[0] - s; - m[1] = a[1] - s; - return m; -} - -phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::operator-(const Matrix2& a, const Matrix2& b) -{ - Matrix2 m; - m[0] = a[0] - b[0]; - m[1] = a[1] - b[1]; - return m; -} - -phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::operator*(const Matrix2& a, float s) -{ - Matrix2 m; - m[0] = a[0] * s; - m[1] = a[1] * s; - return m; -} - -phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::operator*(const Matrix2& a, const Matrix2& b) -{ - Matrix2 m; - - m(0, 0) = a(0, 0) * b(0, 0) + a(0, 1) * b(1, 0); - m(0, 1) = a(0, 0) * b(0, 1) + a(0, 1) * b(1, 1); - m(1, 0) = a(1, 0) * b(0, 0) + a(1, 1) * b(1, 0); - m(1, 1) = a(1, 0) * b(0, 1) + a(1, 1) * b(1, 1); - - return m; -} - -phanes::core::math::coretypes::Vector2 phanes::core::math::coretypes::operator*(const Matrix2& a, const Vector2& v) -{ - Vector2 b = createVector( - a(0, 0) * v.x + a(0, 1) * v.y, - a(1, 0) * v.x + a(1, 1) * v.y - ); - return b; -} - -bool phanes::core::math::coretypes::operator==(const Matrix2& a, const Matrix2& b) -{ - if (a[0] == b[0] && a[1] == b[1]) { - return true; - } - return false; -} - -float phanes::core::math::coretypes::determinant(const Matrix2& a) -{ - return (a(0, 0) * a(1, 1)) - (a(0, 1) * a(1, 0)); -} - -void phanes::core::math::coretypes::inverseNR(Matrix2& a) -{ - float& ref = a(0, 0); - float b = ref; - float _1_det = 1.0f / determinant(a); - - a(0, 0) = a(1, 1); - a(0, 1) = -a(0, 1); - a(1, 0) = -a(1, 0); - a(1, 1) = b; - - a *= _1_det; -} - -void phanes::core::math::coretypes::transposeNR(Matrix2& a) -{ - swap(a(0, 1), a(1, 0)); -} - -phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::inverse(Matrix2& a) -{ - Matrix2 m; - float _1_det = 1.0f / determinant(a); - - m(0, 0) = a(1, 1); - m(0, 1) = -a(0, 1); - m(1, 0) = -a(1, 0); - m(1, 1) = a(0, 0); - - m *= _1_det; - return m; -} - -phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::transpose(const Matrix2& a) -{ - Matrix2 c; - c(0, 0) = a(0, 0); - c(1, 0) = a(0, 1); - c(0, 1) = a(1, 0); - c(1, 1) = a(1, 1); - return c; -} - -bool phanes::core::math::coretypes::isIndentityMatrix(const Matrix2& a) -{ - - if (a == phanes::core::math::coretypes::createMatrix(1, 0, 0, 1)) { - return true; - } - return false; -} \ No newline at end of file diff --git a/Engine/src/Runtime/Core/private/Math/Matrix3.cpp b/Engine/src/Runtime/Core/private/Math/Matrix3.cpp deleted file mode 100644 index c0c2a6b..0000000 --- a/Engine/src/Runtime/Core/private/Math/Matrix3.cpp +++ /dev/null @@ -1,303 +0,0 @@ -// ========================== // -// Matrix3 implementation // -// ========================== // - - - -#include "Misc/CommonDefines.h" -#include PHANES_CORE_PCH_DEFAULT_PATH - -#include "Math/Matrix3.h" - -// ================================= // -// Class Methods for easy access // -// ================================= // - -float& phanes::core::math::coretypes::Matrix3::operator()(int n, int m) -{ - return this->fields[m][n]; -} - -phanes::core::math::coretypes::Vector3& phanes::core::math::coretypes::Matrix3::operator[](int m) -{ - return (*reinterpret_cast(this->fields[m])); -} - -const float& phanes::core::math::coretypes::Matrix3::operator()(int n, int m) const -{ - return this->fields[m][n]; -} - -const phanes::core::math::coretypes::Vector3& phanes::core::math::coretypes::Matrix3::operator[](int m) const -{ - return (*reinterpret_cast(this->fields[m])); -} - - -// ================= // -// Constructors // -// ================= // - -phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::createMatrix(float fields[3][3]) -{ - Matrix3 a; - std::copy(&fields[0][0], &fields[3][3], &a.fields[0][0]); - return a; -} - -phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::createMatrix(float f00, float f01, float f02, float f10, float f11, float f12, float f20, float f21, float f22) -{ - Matrix3 a; - a.fields[0][0] = f00; a.fields[1][0] = f01; a.fields[2][0] = f02; - a.fields[0][1] = f10; a.fields[1][1] = f11; a.fields[2][1] = f12; - a.fields[0][2] = f20; a.fields[1][2] = f21; a.fields[2][2] = f22; - return a; -} - -phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::createMatrix(const Vector3& a, const Vector3& b, const Vector3& c) -{ - Matrix3 m; - m.fields[0][0] = a.x; m.fields[1][0] = b.x; m.fields[2][0] = c.x; - m.fields[0][1] = a.y; m.fields[1][1] = b.y; m.fields[2][1] = c.y; - m.fields[0][2] = a.z; m.fields[1][2] = b.z; m.fields[2][2] = c.z; - return m; -} - - -// ============= // -// Operators // -// ============= // - - -void phanes::core::math::coretypes::operator+=(Matrix3& a, float s) -{ - a[0] += s; - a[1] += s; - a[2] += s; -} - - -void phanes::core::math::coretypes::operator+=(Matrix3& a, const Matrix3& b) -{ - a[0] += b[0]; - a[1] += b[1]; - a[2] += b[2]; -} - - -void phanes::core::math::coretypes::operator-=(Matrix3& a, float s) -{ - a[0] -= s; - a[1] -= s; - a[2] -= s; -} - - -void phanes::core::math::coretypes::operator-=(Matrix3& a, const Matrix3& b) -{ - a[0] -= b[0]; - a[1] -= b[1]; - a[2] -= b[2]; -} - - -void phanes::core::math::coretypes::operator*=(Matrix3& a, float s) -{ - a[0] *= s; - a[1] *= s; - a[2] *= s; -} - - -void phanes::core::math::coretypes::operator*=(Matrix3& a, const Matrix3& b) -{ - Matrix3 c = a; - a(0, 0) = c(0, 0) * b(0, 0) + c(0, 1) * b(1, 0) + c(0, 2) * b(2, 0); - a(0, 1) = c(0, 0) * b(0, 1) + c(0, 1) * b(1, 1) + c(0, 2) * b(2, 1); - a(0, 2) = c(0, 0) * b(0, 2) + c(0, 1) * b(1, 2) + c(0, 2) * b(2, 2); - - a(1, 0) = c(1, 0) * b(0, 0) + c(1, 1) * b(1, 0) + c(1, 2) * b(2, 0); - a(1, 1) = c(1, 0) * b(0, 1) + c(1, 1) * b(1, 1) + c(1, 2) * b(2, 1); - a(1, 2) = c(1, 0) * b(0, 2) + c(1, 1) * b(1, 2) + c(1, 2) * b(2, 2); - - a(2, 0) = c(2, 0) * b(0, 0) + c(2, 1) * b(1, 0) + c(2, 2) * b(2, 0); - a(2, 1) = c(2, 0) * b(0, 1) + c(2, 1) * b(1, 1) + c(2, 2) * b(2, 1); - a(2, 2) = c(2, 0) * b(0, 2) + c(2, 1) * b(1, 2) + c(2, 2) * b(2, 2); -} - - -phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::operator+(const Matrix3& a, float s) -{ - Matrix3 m; - m[0] = a[0] + s; - m[1] = a[1] + s; - m[2] = a[2] + s; - return m; -} - - -phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::operator+(const Matrix3& a, const Matrix3& b) -{ - Matrix3 m; - m[0] = a[0] + b[0]; - m[1] = a[1] + b[1]; - m[2] = a[2] + b[2]; - return m; -} - - -phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::operator-(const Matrix3& a, float s) -{ - Matrix3 m; - m[0] = a[0] - s; - m[1] = a[1] - s; - m[2] = a[2] - s; - return m; -} - - -phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::operator-(const Matrix3& a, const Matrix3& b) -{ - Matrix3 m; - m[0] = a[0] - b[0]; - m[1] = a[1] - b[1]; - m[2] = a[2] - b[2]; - return m; -} - - -phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::operator*(const Matrix3& a, float s) -{ - Matrix3 m; - m[0] = a[0] * s; - m[1] = a[1] * s; - m[2] = a[2] * s; - return m; -} - - -phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::operator*(const Matrix3& a, const Matrix3& b) -{ - Matrix3 m; - - m(0, 0) = a(0, 0) * b(0, 0) + a(0, 1) * b(1, 0) + a(0, 2) * b(2, 0); - m(0, 1) = a(0, 0) * b(0, 1) + a(0, 1) * b(1, 1) + a(0, 2) * b(2, 1); - m(0, 2) = a(0, 0) * b(0, 2) + a(0, 1) * b(1, 2) + a(0, 2) * b(2, 2); - - m(1, 0) = a(1, 0) * b(0, 0) + a(1, 1) * b(1, 0) + a(1, 2) * b(2, 0); - m(1, 1) = a(1, 0) * b(0, 1) + a(1, 1) * b(1, 1) + a(1, 2) * b(2, 1); - m(1, 2) = a(1, 0) * b(0, 2) + a(1, 1) * b(1, 2) + a(1, 2) * b(2, 2); - - m(2, 0) = a(2, 0) * b(0, 0) + a(2, 1) * b(1, 0) + a(2, 2) * b(2, 0); - m(2, 1) = a(2, 0) * b(0, 1) + a(2, 1) * b(1, 1) + a(2, 2) * b(2, 1); - m(2, 2) = a(2, 0) * b(0, 2) + a(2, 1) * b(1, 2) + a(2, 2) * b(2, 2); - - return m; -} - - -phanes::core::math::coretypes::Vector3 phanes::core::math::coretypes::operator*(const Matrix3& a, const Vector3& v) -{ - Vector3 b = createVector( - a(0, 0) * v.x + a(0, 1) * v.y + a(0, 2) * v.z, - a(1, 0) * v.x + a(1, 1) * v.y + a(1, 2) * v.z, - a(2, 0) * v.x + a(2, 1) * v.y + a(2, 2) * v.z - ); - return b; -} - - -bool phanes::core::math::coretypes::operator==(const Matrix3& a, const Matrix3& b) -{ - if (a[0] == b[0] && a[1] == b[1] && a[2] == b[2]) { - return true; - } - return false; -} - - -// =============================== // -// Matrix function definition // -// =============================== // - - -float phanes::core::math::coretypes::determinant(const Matrix3& a) -{ - return (a(0, 0) * (a(1, 1) * a(2, 2) - a(1, 2) * a(2, 1)) - -a(0, 1) * (a(1, 0) * a(2, 2) - a(1, 2) * a(2, 0)) - +a(0, 2) * (a(1, 0) * a(2, 1) - a(1, 1) * a(2, 0))); -} - - -void phanes::core::math::coretypes::inverseNR(Matrix3& a) -{ - const Vector3& v0 = a[0]; - const Vector3& v1 = a[1]; - const Vector3& v2 = a[2]; - - Vector3 r0 = crossP(v1, v2); - Vector3 r1 = crossP(v2, v0); - Vector3 r2 = crossP(v0, v1); - - float _1_det = 1.0f / determinant(a); - - a = createMatrix( - r0.x, r0.y, r0.z, - r1.x, r1.y, r1.z, - r2.x, r2.y, r2.z - ); - - a *= _1_det; -} - - -void phanes::core::math::coretypes::transposeNR(Matrix3& a) -{ - swap(a(0, 1), a(1, 0)); - swap(a(0, 2), a(2, 0)); - swap(a(1, 2), a(2, 1)); -} - - -phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::inverse(Matrix3& a) -{ - const Vector3& v0 = a[0]; - const Vector3& v1 = a[1]; - const Vector3& v2 = a[2]; - - Vector3 r0 = crossP(v1, v2); - Vector3 r1 = crossP(v2, v0); - Vector3 r2 = crossP(v0, v1); - - float _1_det = 1.0f / determinant(a); - - Matrix3 m = createMatrix( - r0.x, r0.y, r0.z, - r1.x, r1.y, r1.z, - r2.x, r2.y, r2.z - ); - - m *= _1_det; - return m; -} - - -phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::transpose(const Matrix3& a) -{ - Matrix3 m = createMatrix( - a(0, 0), a(1, 0), a(2, 0), - a(0, 1), a(1, 1), a(2, 1), - a(0, 2), a(1, 2), a(2, 2) - ); - - return m; -} - - -bool phanes::core::math::coretypes::isIndentityMatrix(const Matrix3& a) -{ - if (a == phanes::core::math::coretypes::createMatrix(1, 0, 0, 0, 1, 0, 0, 0, 1)) { - return true; - } - return false; -} \ No newline at end of file diff --git a/Engine/src/Runtime/Core/private/Math/Matrix4.cpp b/Engine/src/Runtime/Core/private/Math/Matrix4.cpp deleted file mode 100644 index 3769eb2..0000000 --- a/Engine/src/Runtime/Core/private/Math/Matrix4.cpp +++ /dev/null @@ -1,347 +0,0 @@ -// ========================== // -// Matrix4 implementation // -// ========================== // - -#include "Misc/CommonDefines.h" -#include PHANES_CORE_PCH_DEFAULT_PATH - -#include "Math/Matrix4.h" - -#include "Math/Vector3.h" - - -// ================================= // -// Class Methods for easy access // -// ================================= // - -float& phanes::core::math::coretypes::Matrix4::operator()(int n, int m) -{ - return this->fields[m][n]; -} - -phanes::core::math::coretypes::Vector4& phanes::core::math::coretypes::Matrix4::operator[](int m) -{ - return (*reinterpret_cast(this->fields[m])); -} - -const float& phanes::core::math::coretypes::Matrix4::operator()(int n, int m) const -{ - return this->fields[m][n]; -} - -const phanes::core::math::coretypes::Vector4& phanes::core::math::coretypes::Matrix4::operator[](int m) const -{ - return (*reinterpret_cast(this->fields[m])); -} - - -// ================= // -// Constructors // -// ================= // - -phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::createMatrix(float fields[4][4]) -{ - Matrix4 a; - std::copy(&fields[0][0], &fields[4][4], &a.fields[0][0]); - return a; -} - -phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::createMatrix(float f00, float f01, float f02, float f03, float f10, float f11, float f12, float f13, float f20, float f21, float f22, float f23, float f30, float f31, float f32, float f33) -{ - Matrix4 a; - a.fields[0][0] = f00; a.fields[1][0] = f01; a.fields[2][0] = f02; a.fields[3][0] = f03; - a.fields[0][1] = f10; a.fields[1][1] = f11; a.fields[2][1] = f12; a.fields[3][1] = f13; - a.fields[0][2] = f20; a.fields[1][2] = f21; a.fields[2][2] = f22; a.fields[3][2] = f23; - a.fields[0][3] = f30; a.fields[1][3] = f31; a.fields[2][3] = f32; a.fields[3][3] = f33; - return a; -} - -phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::createMatrix(const Vector4& a, const Vector4& b, const Vector4& c, const Vector4& d) -{ - Matrix4 m; - m.fields[0][0] = a.x; m.fields[1][0] = b.x; m.fields[2][0] = c.x; m.fields[3][0] = d.x; - m.fields[0][1] = a.y; m.fields[1][1] = b.y; m.fields[2][1] = c.y; m.fields[3][1] = d.y; - m.fields[0][2] = a.z; m.fields[1][2] = b.z; m.fields[2][2] = c.z; m.fields[3][2] = d.z; - m.fields[0][3] = a.w; m.fields[1][3] = b.w; m.fields[2][3] = c.w; m.fields[3][3] = d.w; - return m; -} - - -// ============= // -// Operators // -// ============= // - - -void phanes::core::math::coretypes::operator+=(Matrix4& a, float s) -{ - a[0] += s; - a[1] += s; - a[2] += s; - a[3] += s; -} - -void phanes::core::math::coretypes::operator+=(Matrix4& a, const Matrix4& b) -{ - a[0] += b[0]; - a[1] += b[1]; - a[2] += b[2]; - a[3] += b[3]; -} - -void phanes::core::math::coretypes::operator-=(Matrix4& a, float s) -{ - a[0] -= s; - a[1] -= s; - a[2] -= s; - a[3] -= s; -} - -void phanes::core::math::coretypes::operator-=(Matrix4& a, const Matrix4& b) -{ - a[0] -= b[0]; - a[1] -= b[1]; - a[2] -= b[2]; - a[3] -= b[3]; -} - -void phanes::core::math::coretypes::operator*=(Matrix4& a, float s) -{ - a[0] *= s; - a[1] *= s; - a[2] *= s; - a[3] *= s; -} - -void phanes::core::math::coretypes::operator*=(Matrix4& a, const Matrix4& b) -{ - Matrix4 c = a; - - a(0, 0) = c(0, 0) * b(0, 0) + c(0, 1) * b(1, 0) + c(0, 2) * b(2, 0) + c(0, 3) * b(3, 0); - a(0, 1) = c(0, 0) * b(0, 1) + c(0, 1) * b(1, 1) + c(0, 2) * b(2, 1) + c(0, 3) * b(3, 1); - a(0, 2) = c(0, 0) * b(0, 2) + c(0, 1) * b(1, 2) + c(0, 2) * b(2, 2) + c(0, 3) * b(3, 2); - a(0, 3) = c(0, 0) * b(0, 3) + c(0, 1) * b(1, 3) + c(0, 2) * b(2, 3) + c(0, 3) * b(3, 3); - - a(1, 0) = c(1, 0) * b(0, 0) + c(1, 1) * b(1, 0) + c(1, 2) * b(2, 0) + c(1, 3) * b(3, 0); - a(1, 1) = c(1, 0) * b(0, 1) + c(1, 1) * b(1, 1) + c(1, 2) * b(2, 1) + c(1, 3) * b(3, 1); - a(1, 2) = c(1, 0) * b(0, 2) + c(1, 1) * b(1, 2) + c(1, 2) * b(2, 2) + c(1, 3) * b(3, 2); - a(1, 3) = c(1, 0) * b(0, 3) + c(1, 1) * b(1, 3) + c(1, 2) * b(2, 3) + c(1, 3) * b(3, 3); - - a(2, 0) = c(2, 0) * b(0, 0) + c(2, 1) * b(1, 0) + c(2, 2) * b(2, 0) + c(2, 3) * b(3, 0); - a(2, 1) = c(2, 0) * b(0, 1) + c(2, 1) * b(1, 1) + c(2, 2) * b(2, 1) + c(2, 3) * b(3, 1); - a(2, 2) = c(2, 0) * b(0, 2) + c(2, 1) * b(1, 2) + c(2, 2) * b(2, 2) + c(2, 3) * b(3, 2); - a(2, 3) = c(2, 0) * b(0, 3) + c(2, 1) * b(1, 3) + c(2, 2) * b(2, 3) + c(2, 3) * b(3, 3); - - a(3, 0) = c(3, 0) * b(0, 0) + c(3, 1) * b(1, 0) + c(3, 2) * b(2, 0) + c(3, 3) * b(3, 0); - a(3, 1) = c(3, 0) * b(0, 1) + c(3, 1) * b(1, 1) + c(3, 2) * b(2, 1) + c(3, 3) * b(3, 1); - a(3, 2) = c(3, 0) * b(0, 2) + c(3, 1) * b(1, 2) + c(3, 2) * b(2, 2) + c(3, 3) * b(3, 2); - a(3, 3) = c(3, 0) * b(0, 3) + c(3, 1) * b(1, 3) + c(3, 2) * b(2, 3) + c(3, 3) * b(3, 3); -} - - -phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::operator+(const Matrix4& a, float s) -{ - Matrix4 m; - m[0] = a[0] + s; - m[1] = a[1] + s; - m[2] = a[2] + s; - m[3] = a[3] + s; - return m; -} - -phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::operator+(const Matrix4& a, const Matrix4& b) -{ - Matrix4 m; - m[0] = a[0] + b[0]; - m[1] = a[1] + b[1]; - m[2] = a[2] + b[2]; - m[3] = a[3] + b[3]; - return m; -} - -phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::operator-(const Matrix4& a, float s) -{ - Matrix4 m; - m[0] = a[0] - s; - m[1] = a[1] - s; - m[2] = a[2] - s; - m[3] = a[3] - s; - return m; -} - -phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::operator-(const Matrix4& a, const Matrix4& b) -{ - Matrix4 m; - m[0] = a[0] - b[0]; - m[1] = a[1] - b[1]; - m[2] = a[2] - b[2]; - m[3] = a[3] - b[3]; - return m; -} - -phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::operator*(const Matrix4& a, float s) -{ - Matrix4 m; - m[0] = a[0] * s; - m[1] = a[1] * s; - m[2] = a[2] * s; - m[3] = a[3] * s; - return m; -} - -phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::operator*(const Matrix4& a, const Matrix4& b) -{ - Matrix4 m; - - m(0, 0) = a(0, 0) * b(0, 0) + a(0, 1) * b(1, 0) + a(0, 2) * b(2, 0) + a(0, 3) * b(3, 0); - m(0, 1) = a(0, 0) * b(0, 1) + a(0, 1) * b(1, 1) + a(0, 2) * b(2, 1) + a(0, 3) * b(3, 1); - m(0, 2) = a(0, 0) * b(0, 2) + a(0, 1) * b(1, 2) + a(0, 2) * b(2, 2) + a(0, 3) * b(3, 2); - m(0, 3) = a(0, 0) * b(0, 3) + a(0, 1) * b(1, 3) + a(0, 2) * b(2, 3) + a(0, 3) * b(3, 3); - - m(1, 0) = a(1, 0) * b(0, 0) + a(1, 1) * b(1, 0) + a(1, 2) * b(2, 0) + a(1, 3) * b(3, 0); - m(1, 1) = a(1, 0) * b(0, 1) + a(1, 1) * b(1, 1) + a(1, 2) * b(2, 1) + a(1, 3) * b(3, 1); - m(1, 2) = a(1, 0) * b(0, 2) + a(1, 1) * b(1, 2) + a(1, 2) * b(2, 2) + a(1, 3) * b(3, 2); - m(1, 3) = a(1, 0) * b(0, 3) + a(1, 1) * b(1, 3) + a(1, 2) * b(2, 3) + a(1, 3) * b(3, 3); - - m(2, 0) = a(2, 0) * b(0, 0) + a(2, 1) * b(1, 0) + a(2, 2) * b(2, 0) + a(2, 3) * b(3, 0); - m(2, 1) = a(2, 0) * b(0, 1) + a(2, 1) * b(1, 1) + a(2, 2) * b(2, 1) + a(2, 3) * b(3, 1); - m(2, 2) = a(2, 0) * b(0, 2) + a(2, 1) * b(1, 2) + a(2, 2) * b(2, 2) + a(2, 3) * b(3, 2); - m(2, 3) = a(2, 0) * b(0, 3) + a(2, 1) * b(1, 3) + a(2, 2) * b(2, 3) + a(2, 3) * b(3, 3); - - m(3, 0) = a(3, 0) * b(0, 0) + a(3, 1) * b(1, 0) + a(3, 2) * b(2, 0) + a(3, 3) * b(3, 0); - m(3, 1) = a(3, 0) * b(0, 1) + a(3, 1) * b(1, 1) + a(3, 2) * b(2, 1) + a(3, 3) * b(3, 1); - m(3, 2) = a(3, 0) * b(0, 2) + a(3, 1) * b(1, 2) + a(3, 2) * b(2, 2) + a(3, 3) * b(3, 2); - m(3, 3) = a(3, 0) * b(0, 3) + a(3, 1) * b(1, 3) + a(3, 2) * b(2, 3) + a(3, 3) * b(3, 3); - return m; -} - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator*(const Matrix4& a, const Vector4& v) -{ - Vector4 b = createVector( - a(0, 0) * v.x + a(0, 1) * v.y + a(0, 2) * v.z + a(0, 3) * v.w, - a(1, 0) * v.x + a(1, 1) * v.y + a(1, 2) * v.z + a(1, 3) * v.w, - a(2, 0) * v.x + a(2, 1) * v.y + a(2, 2) * v.z + a(2, 3) * v.w, - a(3, 0) * v.x + a(3, 1) * v.y + a(3, 2) * v.z + a(3, 3) * v.w - ); - return b; -} - -bool phanes::core::math::coretypes::operator==(const Matrix4& a, const Matrix4& b) -{ - if (a[0] == b[0] && a[1] == b[1] && a[2] == b[2] && a[3] == b[3]) { - return true; - } - return false; -} - -// =============================== // -// Matrix function definition // -// =============================== // - - -float phanes::core::math::coretypes::determinant(const Matrix4& a) -{ - Vector3 v0 = reinterpret_cast(a[0]); - Vector3 v1 = reinterpret_cast(a[1]); - Vector3 v2 = reinterpret_cast(a[2]); - Vector3 v3 = reinterpret_cast(a[3]); - - Vector3 s = crossP(v0, v1); - Vector3 t = crossP(v2, v3); - Vector3 u = a(3, 1) * v0 + a(3, 0) * v1; - Vector3 v = a(3, 3) * v2 + a(3, 2) * v3; - - return s * v + t * u; -} - -void phanes::core::math::coretypes::inverseNR(Matrix4& a) -{ - Vector3 v0 = reinterpret_cast(a[0]); - Vector3 v1 = reinterpret_cast(a[1]); - Vector3 v2 = reinterpret_cast(a[2]); - Vector3 v3 = reinterpret_cast(a[3]); - - Vector3 s = crossP(v0, v1); - Vector3 t = crossP(v2, v3); - Vector3 u = a(3, 1) * v0 + a(3, 0) * v1; - Vector3 v = a(3, 3) * v2 + a(3, 2) * v3; - - float _1_det = 1.0f / determinant(a); - - Vector3 r0 = crossP(v1, v) + t * a(3, 1); - Vector3 r1 = crossP(v, v0) - t * a(3, 0); - Vector3 r2 = crossP(v3, u) + s * a(3, 3); - Vector3 r3 = crossP(u, v2) - s * a(3, 2); - - a = createMatrix( - r0.x, r0.y, r0.z, -dotP(v1, t), - r1.x, r1.y, r1.z, -dotP(v0, t), - r2.x, r2.y, r2.z, -dotP(v3, s), - r3.x, r3.y, r3.z, -dotP(v2, s) - ); -} - -void phanes::core::math::coretypes::transposeNR(Matrix4& a) -{ - swap(a(0, 1), a(1, 0)); - swap(a(0, 2), a(2, 0)); - swap(a(0, 3), a(3, 0)); - - swap(a(1, 2), a(2, 1)); - swap(a(1, 3), a(3, 1)); - - swap(a(2, 3), a(3, 2)); -} - -phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::inverse(Matrix4& a) -{ - Vector3 v0 = reinterpret_cast(a[0]); - Vector3 v1 = reinterpret_cast(a[1]); - Vector3 v2 = reinterpret_cast(a[2]); - Vector3 v3 = reinterpret_cast(a[3]); - - Vector3 s = crossP(v0, v1); - Vector3 t = crossP(v2, v3); - Vector3 u = a(3, 1) * v0 + a(3, 0) * v1; - Vector3 v = a(3, 3) * v2 + a(3, 2) * v3; - - float _1_det = 1.0f / determinant(a); - - Vector3 r0 = crossP(v1, v) + t * a(3, 1); - Vector3 r1 = crossP(v, v0) - t * a(3, 0); - Vector3 r2 = crossP(v3, u) + s * a(3, 3); - Vector3 r3 = crossP(u, v2) - s * a(3, 2); - - Matrix4 m = createMatrix( - r0.x, r0.y, r0.z, -dotP(v1, t), - r1.x, r1.y, r1.z, -dotP(v0, t), - r2.x, r2.y, r2.z, -dotP(v3, s), - r3.x, r3.y, r3.z, -dotP(v2, s) - ); - - return m; -} - -phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::transpose(const Matrix4& a) -{ - Matrix4 m = a; - - swap(m(0, 1), m(1, 0)); - swap(m(0, 2), m(2, 0)); - swap(m(0, 3), m(3, 0)); - - swap(m(1, 2), m(2, 1)); - swap(m(1, 3), m(3, 1)); - - swap(m(2, 3), m(3, 2)); - - return m; -} - -bool phanes::core::math::coretypes::isIndentityMatrix(const Matrix4& a) -{ - if (a == phanes::core::math::coretypes::createMatrix(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)) { - return true; - } - return false; -} - diff --git a/Engine/src/Runtime/Core/private/Math/Point.cpp b/Engine/src/Runtime/Core/private/Math/Point.cpp deleted file mode 100644 index 75228b4..0000000 --- a/Engine/src/Runtime/Core/private/Math/Point.cpp +++ /dev/null @@ -1,34 +0,0 @@ -#include "PhanesEnginePCH.h" - -#include "Core/public/Math/Point.h" - -#include "Core/public/Math/Vector2.h" -#include "Core/public/Math/Vector3.h" -// #include "Core/public/Math/Vector4.h" - - -// ----- TPoint2 ------------------------------------------ - -template -T Phanes::Core::Math::Distance(const TPoint2& p1, const TPoint2& p2) -{ - return Magnitude(p2 - p1); -} - - -// ----- TPoint3 ------------------------------------------ - -template -T Phanes::Core::Math::Distance(const TPoint3& p1, const TPoint3& p2) -{ - return Magnitude(p2 - p1); -} - - -// ----- TPoint4 ------------------------------------------ - -//template -//T Phanes::Core::Math::Distance(const TPoint4& p1, const TPoint4& p2) -//{ -// return Magnitude(TVector3(p1, p2)); -//} diff --git a/Engine/src/Runtime/Core/private/Math/Vector2.cpp b/Engine/src/Runtime/Core/private/Math/Vector2.cpp deleted file mode 100644 index d9a8de7..0000000 --- a/Engine/src/Runtime/Core/private/Math/Vector2.cpp +++ /dev/null @@ -1,570 +0,0 @@ -// =========================== // -// TVector2 implementation // -// =========================== // - - -#include "PhanesEnginePCH.h" - -#include "Core/public/Math/Vector2.h" - -#include "Core/public/Math/Point.h" - -//#include "Math/Matrix2.h" -//#include "Math/Matrix2.h" -//#include "Math/Vector3.h" -//#include "Math/Vector4.h" -//#include "Math/IntVector2.h" -//#include "Math/IntVector3.h" -//#include "Math/IntVector4.h" - - -// ========================= // -// TVector2 constructors // -// ========================= // - -template -Phanes::Core::Math::TVector2::TVector2(const Real x, const Real y) -{ - this->x = x; - this->y = y; -} - -template -Phanes::Core::Math::TVector2::TVector2(const Real* comp) -{ - static_assert(sizeof(comp) > 2 * sizeof(T), "PHANES_CORE (Vector2.cpp): Setting 2D vector coordinates by an array, comp must have a size of at least 2 components."); - memcpy(this->comp, comp, sizeof(T) * 2); -} - -template -Phanes::Core::Math::TVector2::TVector2(const TPoint2& start, const TPoint2& end) -{ - this->x = end.x - start.x; - this->y = end.y - start.y; -} - -template -Phanes::Core::Math::TVector2::TVector2(const TVector3& v) -{ - this->x = v.x; - this->y = v.y; -} - -template -Phanes::Core::Math::TVector2::TVector2(const TVector2& v) -{ - memcpy(this->comp, comp, sizeof(T) * 2); -} - -template -Phanes::Core::Math::TVector2::TVector2(TVector2&& v) -{ - this->comp = v.comp; - v.comp = nullptr; -} - - -// -//Phanes::Core::Math::TVector2::TVector2(const Vector3& v) -//{ -// std::copy(v.components, v.components + 2, this->components); -//} -// -// -//Phanes::Core::Math::TVector2::TVector2(const Vector4& v) -//{ -// std::copy(v.components, v.components + 2, this->components); -//} -// -// -//Phanes::Core::Math::TVector2::TVector2(const IntVector2& v) -//{ -// std::copy(v.components, v.components + 2, this->components); -//} -// -// -//Phanes::Core::Math::TVector2::TVector2(const IntVector3& v) -//{ -// std::copy(v.components, v.components + 2, this->components); -//} -// -// -//Phanes::Core::Math::TVector2::TVector2(const IntVector4& v) -//{ -// std::copy(v.components, v.components + 2, this->components); -//} -// -// -//Phanes::Core::Math::TVector2::TVector2(const Point2& v) -//{ -// std::copy(v.components, v.components + 2, this->components); -//} - -// ====================== // -// TVector2 operators // -// ====================== // - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::operator+=(TVector2& v1, T s) -{ - v1.x += s; - v1.y += s; - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::operator+=(TVector2& v1, const TVector2& v2) -{ - v1.x += v2.x; - v1.y += v2.y; - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::operator-=(TVector2& v1, T s) -{ - v1.x -= s; - v1.y -= s; - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::operator-=(TVector2& v1, const TVector2& v2) -{ - v1.x -= v2.x; - v1.y -= v2.y; - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::operator*=(TVector2& v1, T s) -{ - v1.x *= s; - v1.y *= s; - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::operator/=(TVector2& v1, T s) -{ - s = 1.0f / s; - v1.x *= s; - v1.y *= s; - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::operator*(const TVector2& v1, T s) -{ - return TVector2(v1.x * s, v1.y * s); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::operator/(const TVector2& v1, T s) -{ - s = 1.0f / s; - return TVector2(v1.x * s, v1.y * s); -} - -template -inline Phanes::Core::Math::TVector2 Phanes::Core::Math::operator*(T s, const TVector2& v1) -{ - return v1 * s; -} - -template -inline Phanes::Core::Math::TVector2 Phanes::Core::Math::operator/(T s, const TVector2& v1) -{ - s = 1.0f / s; - return v1 * s; -} - -template -T Phanes::Core::Math::operator* (const TVector2& v1, const TVector2& v2) -{ - return v1.x * v2.x + v1.y * v2.y; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::operator+(const TVector2& v1, T s) -{ - return TVector2(v1.x + s, v1.y + s); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::operator+(const TVector2& v1, const TVector2& v2) -{ - return TVector2(v1.x + v2.x, v1.y + v2.y); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::operator-(const TVector2& v1, T s) -{ - return TVector2(v1.x - s, v1.y - s); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::operator-(const TVector2& v1, const TVector2& v2) -{ - return TVector2(v1.x - v2.x, v1.y - v2.y); -} - -template -void Phanes::Core::Math::operator-(TVector2& v1) -{ - v1.x = -v1.x; - v1.y = -v1.y; -} - -template -bool Phanes::Core::Math::operator== (const TVector2& v1, const TVector2& v2) -{ - return (abs(v1.x - v1.x) < P_FLT_INAC && abs(v1.y - v1.y) < P_FLT_INAC); -} - -template -bool Phanes::Core::Math::operator!=(const TVector2& v1, const TVector2& v2) -{ - return (abs(v1.x - v1.x) > P_FLT_INAC || abs(v1.y - v1.y) > P_FLT_INAC); -} - -template -T Phanes::Core::Math::Magnitude(const TVector2& v1) -{ - return sqrtf(v1.x * v1.x + v1.y * v1.y); -} - -template -T Phanes::Core::Math::SqrMagnitude(const TVector2& v1) -{ - return v1.x * v1.x + v1.y * v1.y; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::NormalizeV(TVector2& v1) -{ - float vecNorm = Magnitude(v1); - v1 /= (vecNorm < P_FLT_INAC) ? 1 : vecNorm; - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::UnsafeNormalizeV(TVector2& v1) -{ - v1 /= Magnitude(v1); - - return v1; -} - -template -T Phanes::Core::Math::Angle(const TVector2& v1, const TVector2& v2) -{ - return acos((v1 * v2) / Magnitude(v1) * Magnitude(v2)); -} - - -template -T Phanes::Core::Math::CosineAngle(const TVector2& v1, const TVector2& v2) -{ - return (v1 * v2) / Magnitude(v1) * Magnitude(v2); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::SignVectorV(TVector2& v1) -{ - v1.x = (v1.x > 0) ? 1 : -1; - v1.y = (v1.y > 0) ? 1 : -1; - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::BindToSquareV(TVector2& v1, T radius) -{ - float k = (abs(v1.x) > abs(v1.y)) ? abs(radius / v1.x) : abs(radius / v1.y); - v1 *= k; - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::ClampToSquareV(TVector2& v1, T radius) -{ - float prime = (abs(v1.x) > abs(v1.y)) ? v1.x : v1.y; - float k = (prime > radius) ? abs(radius / prime) : 1.0f; - v1 *= k; - - return v1; -} - -template -T Phanes::Core::Math::DotP(const TVector2& v1, const TVector2& v2) -{ - return v1.x * v2.x + v1.y * v2.y; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::MaxV(TVector2& v1, const TVector2& v2) -{ - v1.x = Phanes::Core::Math::Max(v1.x, v2.x); - v1.y = Phanes::Core::Math::Max(v1.y, v2.y); - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::MinV(TVector2& v1, const TVector2& v2) -{ - v1.x = Phanes::Core::Math::Min(v1.x, v2.x); - v1.y = Phanes::Core::Math::Min(v1.y, v2.y); - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::GetPerpendicularV(TVector2& v1) -{ - T x = v1.x; - v1.x = v1.y; - v1.y = -v1.x; - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::GetReversePerpendicularV(TVector2& v1) -{ - T x = v1.x; - v1.x = -v1.y; - v1.y = v1.x; - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::ScaleV(TVector2& v1, const TVector2& v2) -{ - v1.x *= v2.x; - v1.y *= v2.y; - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::CompInverseV(TVector2& v1) -{ - v1.x = 1.0f / v1.x; - v1.y = 1.0f / v1.y; - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::ReflectV(TVector2& v1, const TVector2& normal) -{ - Set(v1, v1 - (2 * (v1 * normal) * normal)); - - return v1; -} -template - -Phanes::Core::Math::TVector2 Phanes::Core::Math::Set(TVector2& v1, const TVector2& v2) -{ - v1 = v2; - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::Set(TVector2& v1, T x, T y) -{ - v1.x = x; - v1.y = y; - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::RotateV(TVector2& v1, T angle) -{ - float sinAngle = sin(angle); - float cosAngle = cos(angle); - - Set(v1, - v1.x * cosAngle - v1.y * sinAngle, - v1.y * cosAngle + v1.x * sinAngle - ); - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::ClockwiseRotateV(TVector2& v1, T angle) -{ - RotateV(v1, -angle); - - return v1; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::NegateV(TVector2& v1) -{ - v1.x = -v1.x; - v1.y = -v1.y; -} - -template -inline bool Phanes::Core::Math::IsNormalized(const TVector2& v1, T threshold) -{ - return (SqrMagnitude(v1) < threshold); -} - -template -inline bool Phanes::Core::Math::IsPerpendicular(const TVector2& v1, const TVector2& v2, T threshold) -{ - return (abs(DotP(v1, v2)) < threshold); -} - -template -inline bool Phanes::Core::Math::IsParallel(const TVector2& v1, const TVector2& v2, T threshold) -{ - return (abs(DotP(v1,v2)) > threshold); -} - -template -inline bool Phanes::Core::Math::IsCoincident(const TVector2& v1, const TVector2& v2, T threshold) -{ - return (DotP(v1, v2) > threshold); -} - -// -//Phanes::Core::Math::Matrix2 Phanes::Core::Math::OuterProduct(const TVector2& v1, const TVector2& v2) -//{ -// return Matrix2( -// v1.x * v2.x, v1.x * v2.y, -// v1.y * v2.x, v1.y * v2.y -// ); -//} - -// ============================================================== // -// TVector2 static function implementation with return values // -// ============================================================== // - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::Reflect(const TVector2& v1, const TVector2& normal) -{ - return TVector2(v1 - (2 * (v1 * normal) * normal)); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::Scale(const TVector2& v1, const TVector2& v2) -{ - return TVector2(v1.x * v2.x, v1.y * v2.y); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::CompInverse(const TVector2& v1) -{ - return TVector2(1.0f / v1.x, 1.0f / v1.y); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::Negate(const TVector2& v1) -{ - return TVector2(-v1.x, -v1.y); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::GetPerpendicular(const TVector2& v1) -{ - return TVector2(v1.y, -v1.x); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::GetReversePerpendicular(const TVector2& v1) -{ - return TVector2(-v1.y, v1.x); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::Min(const TVector2& v1, const TVector2& v2) -{ - return TVector2(Phanes::Core::Math::Min(v1.x, v2.x), Phanes::Core::Math::Min(v1.y, v2.y)); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::Max(const TVector2& v1, const TVector2& v2) -{ - return TVector2(Phanes::Core::Math::Max(v1.x, v2.x), Phanes::Core::Math::Max(v1.y, v2.y)); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::Normalize(const TVector2& v1) -{ - float vecNorm = Magnitude(v1); - return (vecNorm < P_FLT_INAC) ? PZeroVector2(T) : (v1 / vecNorm); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::UnsafeNormalize(const TVector2& v1) -{ - return (v1 / Magnitude(v1)); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::SignVector(const TVector2& v1) -{ - return TVector2((v1.x > 0) ? 1 : -1, (v1.y > 0) ? 1 : -1); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::BindToSquare(const TVector2& v1, T radius) -{ - float k = (abs(v1.x) > abs(v1.y)) ? abs(radius / v1.x) : abs(radius / v1.y); - return v1 * k; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::ClampToSquare(const TVector2& v1, T radius) -{ - float prime = (abs(v1.x) > abs(v1.y)) ? v1.x : v1.y; - float k = (prime > radius) ? abs(radius / prime) : 1.0f; - - return v1 * k; -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::Lerp(const TVector2& startVec, const TVector2& destVec, T t) -{ - t = Phanes::Core::Math::Clamp(t, (T)0.0, (T)1.0); - - return (t * destVec) + ((1 - t) * startVec); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::LerpUnclamped(const TVector2& startVec, const TVector2& destVec, T t) -{ - return (t * destVec) + ((1 - t) * startVec); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::Rotate(const TVector2& v1, T angle) -{ - float sinAngle = sin(angle); - float cosAngle = cos(angle); - - return TVector2(v1.x * cosAngle - v1.y * sinAngle, - v1.y * cosAngle + v1.x * sinAngle); -} - -template -Phanes::Core::Math::TVector2 Phanes::Core::Math::ClockwiseRotate(const TVector2& v1, T angle) -{ - return Rotate(v1, -angle); -} \ No newline at end of file diff --git a/Engine/src/Runtime/Core/private/Math/Vector3.cpp b/Engine/src/Runtime/Core/private/Math/Vector3.cpp deleted file mode 100644 index 24e8384..0000000 --- a/Engine/src/Runtime/Core/private/Math/Vector3.cpp +++ /dev/null @@ -1,669 +0,0 @@ -// =========================== // -// TVector3 implementation // -// =========================== // - -#include "PhanesEnginePCH.h" - -#include "Core/public/Math/Vector3.h" - -#include "Core/public/Math/Point.h" -#include "Core/public/Math/Plane.h" - -template -inline Phanes::Core::Math::TVector3::TVector3(const Real x, const Real y, const Real z) -{ - this->x = x; - this->y = y; - this->z = z; -} - -template -Phanes::Core::Math::TVector3::TVector3(const Real* comp) -{ - static_assert(sizeof(comp) > 2 * sizeof(T), "PHANES_CORE (Vector3.cpp): Setting 3D vector coordinates by an array, comp must have a size of at least 3 components."); - memcpy(this->comp, comp, sizeof(T) * 3); -} - -template -Phanes::Core::Math::TVector3::TVector3(const TPoint3& start, const TPoint3& end) -{ - this->x = end.x - start.x; - this->y = end.y - start.y; - this->z = end.z - start.z; -} - -template -Phanes::Core::Math::TVector3::TVector3(const TVector3& v) -{ - memcpy(this->comp, comp, sizeof(T) * 3); -} - -template -Phanes::Core::Math::TVector3::TVector3(TVector3&& v) -{ - this->comp = v.comp; - v.comp = nullptr; -} - - - - -// ====================== // -// TVector3 operators // -// ====================== // - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator+=(TVector3& v1, T s) -{ - v1.x += s; - v1.y += s; - v1.z += s; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator+=(TVector3& v1, const TVector3& v2) -{ - v1.x += v2.x; - v1.y += v2.y; - v1.z += v2.z; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator-=(TVector3& v1, T s) -{ - v1.x -= s; - v1.y -= s; - v1.z -= s; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator-=(TVector3& v1, const TVector3& v2) -{ - v1.x -= v2.x; - v1.y -= v2.y; - v1.z -= v2.z; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator*=(TVector3& v1, T s) -{ - v1.x *= s; - v1.y *= s; - v1.z *= s; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator/=(TVector3& v1, T s) -{ - s = (T)1.0 / s; - v1.x *= s; - v1.y *= s; - v1.z *= s; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator*(const TVector3& v1, T s) -{ - return TVector3(v1.x * s. v1.y * s, v1.z * s); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator/(const TVector3& v1, T s) -{ - s = (T)1.0 / s; - return TVector3(v1.x * s.v1.y * s, v1.z * s); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator*(T s, const TVector3& v1) -{ - return v1 * s; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator/(T s, const TVector3& v1) -{ - return v1 / s; -} - -template -T Phanes::Core::Math::operator*(const TVector3& v1, const TVector3& v2) -{ - return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator+(const TVector3& v1, T s) -{ - return TVector3(v1.x + s.v1.y + s, v1.z + s); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator+(const TVector3& v1, const TVector3& v2) -{ - return TVector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator-(const TVector3& v1, T s) -{ - return TVector3(v1.x - s.v1.y - s, v1.z - s); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator-(const TVector3& v1, const TVector3& v2) -{ - return TVector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::operator-(TVector3& v1) -{ - v1.x = -v1.x; - v1.y = -v1.y; - v1.z = -v1.z; - - return v1; -} - -template -bool Phanes::Core::Math::operator==(const TVector3& v1, const TVector3& v2) -{ - return (abs(v1.x - v2.x) < P_FLT_INAC && abs(v1.y - v2.y) < P_FLT_INAC && abs(v1.z - v2.z) < P_FLT_INAC); -} - -template -bool Phanes::Core::Math::operator!=(const TVector3& v1, const TVector3& v2) -{ - return (abs(v1.x - v2.x) > P_FLT_INAC || abs(v1.y - v2.y) > P_FLT_INAC || abs(v1.z - v2.z) > P_FLT_INAC); -} - -// ==================================== // -// TVector3 function implementation // -// ==================================== // - -template -T Phanes::Core::Math::Magnitude(const TVector3& v1) -{ - return sqrt(DotP(v1, v1)); -} - -template -T Phanes::Core::Math::SqrMagnitude(const TVector3& v1) -{ - return DotP(v1, v1); -} - -template -T Phanes::Core::Math::SqrLength(const TVector3& v1) -{ - return SqrMagnitude(v1); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::NormalizeV(TVector3& v1) -{ - float vecNorm = Magnitude(v1); - v1 /= (vecNorm < P_FLT_INAC) ? 1 : vecNorm; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::UnsafeNormalizeV(TVector3& v1) -{ - v1 /= Magnitude(v1); - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ReflectV(TVector3& v1, const TVector3& normal) -{ - Set(v1, v1 - (2 * (v1 * normal) * normal)); - - return v1; -} - -template -T Phanes::Core::Math::Angle(const TVector3& v1, const TVector3& v2) -{ - return acos((v1 * v2) / (Magnitude(v1) * Magnitude(v2))); -} - -template -T Phanes::Core::Math::DotP(const TVector3& v1, const TVector3& v2) -{ - return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; -} - -template -void Phanes::Core::Math::Orthogonalize(TVector3& v1, TVector3& v2, TVector3& v3) -{ - Set(v2, Reject(v2, v1)); - Set(v3, Reject(Reject(v3, v1), v2)); -} - -template -void Phanes::Core::Math::OrthoNormalize(TVector3& v1, TVector3& v2, TVector3& v3) -{ - Set(v2, Reject(v2, v1)); - Set(v3, Reject(Reject(v3, v1), v2)); - - NormalizeV(v1); - NormalizeV(v2); - NormalizeV(v3); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ScaleToMagnitude(const TVector3& v1, T magnitude) -{ - NormalizeV(v1) *= magnitude; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::CompInverse(const TVector3& v1) -{ - return TVector3((T)1.0f / v1.x, (T)1.0f / v1.y, (T)1.0f / v1.z); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ReflectFromPlane(const TVector3& v1, const TPlane& plane) -{ - return Reflect(v1, plane.normal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ReflectFromPlane(const TVector3& v1, const TVector3& normal) -{ - return Reflect(v1, normal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::RotateAroundAxis(const TVector3& v1, const TVector3& axisNormal, T angle) -{ - T sinAngle = sin(angle); - T cosAngle = cos(angle); - - return (1 - cosAngle) * DotP(v1, axisNormal) * axisNormal + cosAngle * v1 + sinAngle * CrossP(v1, axisNormal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::VectorTriple(const TVector3& v1, const TVector3& v2, const TVector3& v3) -{ - return CrossP(CrossP(v1, v2), v3); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Project(const TVector3& v1, const TVector3& v2) -{ - return (DotP(v1, v2) / DotP(v2, v2)) * v2; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Reject(const TVector3& v1, const TVector3& v2) -{ - return v1 - (DotP(v1, v2) / DotP(v2, v2)) * v2; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ProjectOntoPlane(const TVector3& v1, const TVector3& normal) -{ - return Reject(v1, normal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ProjectOntoPlane(const TVector3& v1, const TPlane& plane) -{ - return Reject(v1, plane.normal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::SignVector(const TVector3& v1) -{ - v1.x = (v1.x > 0) - (v1.x < 0); - v1.y = (v1.y > 0) - (v1.y < 0); - v1.z = (v1.z > 0) - (v1.z < 0); - - - return v1; -} - -template -bool Phanes::Core::Math::Equals(const TVector3& v1, const TVector3& v2, T threshold) -{ - return (abs(v1.x - v2.x) < threshold && abs(v1.y - v2.y) < threshold && abs(v1.z - v2.z) < threshold); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::PerspectiveDivideV(TVector3& v1) -{ - float _z = (T)1.0 / v1.z; - v1.x *= _z; - v1.y *= _z; - v1.z = (T)0.0; - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::CrossPV(TVector3& v1, const TVector3& v2) -{ - float x = v1.x; - float y = v1.y; - float z = v1.z; - - v1.x = (y * v2.z) - (z * v2.y); - v1.y = (z * v2.x) - (x * v2.z); - v1.z = (x * v2.y) - (y * v2.x); - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::MaxV(TVector3& v1, const TVector3& v2) -{ - v1.x = Max(v1.x, v2.x); - v1.y = Max(v1.y, v2.y); - v1.z = Max(v1.z, v2.z); - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::MinV(TVector3& v1, const TVector3& v2) -{ - v1.x = Min(v1.x, v2.x); - v1.y = Min(v1.y, v2.y); - v1.z = Min(v1.z, v2.z); - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::NegateV(TVector3& v1) -{ - v1.x = -v1.x; - v1.y = -v1.y; - v1.z = -v1.z; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ScaleV(TVector3& v1, const TVector3& v2) -{ - v1.x *= v2.x; - v1.y *= v2.y; - v1.z *= v2.z; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ProjectV(TVector3& v1, const TVector3& v2) -{ - float x = (v1 * v2) / (v2 * v2); - v1 = x * v2; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::RejectV(TVector3& v1, const TVector3& v2) -{ - float x = (v1 * v2) / (v2 * v2); - v1 -= x * v2; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ProjectOntoPlaneV(TVector3& v1, const TVector3& normal) -{ - return RejectV(v1, normal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ProjectOntoPlaneV(TVector3& v1, const TPlane& plane) -{ - return RejectV(v1, plane.normal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Set(TVector3& v1, const TVector3& v2) -{ - v1 = v2; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Set(TVector3& v1, T x, T y, T z) -{ - v1.x = x; - v1.y = y; - v1.z = z; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ClampMagnitudeV(TVector3& v1, T min, T max) -{ - T magnitude = Magnitude(v1); - - v1 = (magnitude > P_FLT_INAC) ? v1 / magnitude : PZeroVector3(T); - - Clamp(magnitude, min, max); - - v1 *= magnitude; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::CompInverseV(TVector3& v1) -{ - v1.x = 1.0f / v1.x; - v1.y = 1.0f / v1.y; - v1.z = 1.0f / v1.z; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ReflectFromPlaneV(TVector3& v1, const TPlane& plane) -{ - return ReflectV(v1, plane.normal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ReflectFromPlaneV(TVector3& v1, const TVector3& normal) -{ - return ReflectV(v1, normal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::RotateAroundAxisV(TVector3& v1, const TVector3& axisNormal, T angle) -{ - T sinAngle = sin(angle); - T cosAngle = cos(angle); - - v1 = ((T)1.0 - cosAngle) * DotP(axisNormal, v1) * axisNormal + cosAngle * v1 + sinAngle * CrossP(axisNormal, v1); - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ScaleToMagnitudeV(TVector3& v1, T magnitude) -{ - NormalizeV(v1) *= magnitude; - - return v1; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::SignVectorV(TVector3& v1) -{ - v1.x = (v1.x > 0) ? 1 : 0; - v1.y = (v1.y > 0) ? 1 : 0; - v1.z = (v1.z > 0) ? 1 : 0; - - return v1; -} - -template -T Phanes::Core::Math::ScalarTriple(const TVector3& v1, const TVector3& v2, const TVector3& v3) -{ - return CrossP(v1, v2) * v3; -} - -template -T Phanes::Core::Math::CosineAngle(const TVector3& v1, const TVector3& v2) -{ - return (v1 * v2) / (Magnitude(v1) * Magnitude(v2)); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::VectorTripleV(TVector3& v1, const TVector3& v2, const TVector3& v3) -{ - CrossPV(CrossPV(v1, v2), v3); - - return v1; -} - -template -bool Phanes::Core::Math::IsPerpendicular(const TVector3& v1, const TVector3& v2, T threshold) -{ - return (abs(DotP(v1, v2)) < threshold); -} - -template -bool Phanes::Core::Math::IsParallel(const TVector3& v1, const TVector3& v2, T threshold) -{ - return (abs(DotP(v1, v2)) > threshold); -} - -template -bool Phanes::Core::Math::IsCoincident(const TVector3& v1, const TVector3& v2, T threshold) -{ - return (DotP(v1, v2) > threshold); -} - -template -bool Phanes::Core::Math::IsNormalized(const TVector3& v1, T threshold) -{ - return (SqrMagnitude(v1) < threshold); -} - -template -bool Phanes::Core::Math::IsCoplanar(const TVector3& v1, const TVector3& v2, const TVector3& v3, T threshold) -{ - return (ScalarTriple(v1, v2, v3) < threshold); -} - - -// ================ // -// With return: // -// ================ // - - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Normalize(const TVector3& v1) -{ - float vecNorm = Magnitude(v1); - return (vecNorm < P_FLT_INAC) ? PZeroVector3(T) : v1 / vecNorm; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::UnsafeNormalize(const TVector3& v1) -{ - return v1 / Magnitude(v1); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Reflect(const TVector3& v1, const TVector3& normal) -{ - return v1 - (2 * (v1 * normal) * normal); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::PerspectiveDivide(const TVector3& v1) -{ - float _z = (T)1.0 / v1.z; - return TVector3(v1.x * _z, v1.y * _z, (T)0.0); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::CrossP(const TVector3& v1, const TVector3& v2) -{ - return TVector3((v1.y * v2.z) - (v1.z * v2.y), - (v1.z * v2.x) - (v1.x * v2.z), - (v1.x * v2.y) - (v1.y * v2.x)); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Lerp(const TVector3& start, const TVector3& dest, T t) -{ - t = Clamp(t, (T)0.0, (T), 1.0); - return (1 - t) * start + t * dest; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::LerpUnclamped(const TVector3& start, const TVector3& dest, T t) -{ - return (1 - t) * start + t * dest; -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Max(const TVector3& v1, const TVector3& v2) -{ - return TVector3((v1.x > v2.x) ? v1.x : v2.x, - (v1.y > v2.y) ? v1.y : v2.y, - (v1.z > v2.z) ? v1.z : v2.z); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Min(const TVector3& v1, const TVector3& v2) -{ - return TVector3((v1.x < v2.x) ? v1.x : v2.x, - (v1.y < v2.y) ? v1.y : v2.y, - (v1.z < v2.z) ? v1.z : v2.z); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Negate(const TVector3& v1) -{ - return TVector3(-v1.x, -v1.y, -v1.z); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::Scale(const TVector3& v1, const TVector3& v2) -{ - return TVector3(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z); -} - -template -Phanes::Core::Math::TVector3 Phanes::Core::Math::ClampMagnitude(const TVector3& v1, T min, T max) -{ - T magnitude = Magnitude(v1); - - const TVector3 unitVec = (magnitude > P_FLT_INAC) ? v1 / magnitude : PZeroVector3(T); - - Clamp(magnitude, min, max); - - return unitVec * magnitude; -} - diff --git a/Engine/src/Runtime/Core/private/Math/Vector4.cpp b/Engine/src/Runtime/Core/private/Math/Vector4.cpp deleted file mode 100644 index 884d3fe..0000000 --- a/Engine/src/Runtime/Core/private/Math/Vector4.cpp +++ /dev/null @@ -1,388 +0,0 @@ -// ========================== // -// Vector4 implementation // -// ========================== // - - -#include "Misc/CommonDefines.h" -#include PHANES_CORE_PCH_DEFAULT_PATH - -#include "Math/Vector4.h" - -#include "Math/Vector3.h" -#include "Math/Vector2.h" - - -// ===================== // -// Vector4 operators // -// ===================== // - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::createVector(float x, float y, float z, float w) -{ - Vector4 _new{}; - _new.x = x; - _new.y = y; - _new.z = z; - _new.w = w; - return _new; -} - - -void phanes::core::math::coretypes::operator+=(Vector4& a, float s) -{ - a.x += s; - a.y += s; - a.z += s; - a.w += s; -} - - -void phanes::core::math::coretypes::operator+= (phanes::core::math::coretypes::Vector4& a, const phanes::core::math::coretypes::Vector4& b) { - a.x += b.x; - a.y += b.y; - a.z += b.z; - a.w += b.w; -} - -void phanes::core::math::coretypes::operator-=(Vector4& a, float s) -{ - a.x -= s; - a.y -= s; - a.z -= s; - a.w -= s; -} - -void phanes::core::math::coretypes::operator-= (phanes::core::math::coretypes::Vector4& a, const phanes::core::math::coretypes::Vector4& b) { - a.x -= b.x; - a.y -= b.y; - a.z -= b.z; - a.w -= b.w; -} - - -void phanes::core::math::coretypes::operator*= (phanes::core::math::coretypes::Vector4& a, float s) { - a.x *= s; - a.y *= s; - a.z *= s; - a.w *= s; -} - - -void phanes::core::math::coretypes::operator/= (phanes::core::math::coretypes::Vector4& a, float s) { - s = 1.0f / s; - a.x *= s; - a.y *= s; - a.z *= s; - a.w *= s; -} - - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator*(const Vector4& a, float s) -{ - Vector4 v; - v.x = a.x * s; - v.y = a.y * s; - v.z = a.z * s; - v.w = a.w * s; - return v; -} - - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator*(float s, const Vector4& a) -{ - Vector4 v; - v.x = a.x * s; - v.y = a.y * s; - v.z = a.z * s; - v.w = a.w * s; - return v; -} - - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator/(const Vector4& a, float s) -{ - Vector4 v; - s = 1.0f / s; - v.x = a.x * s; - v.y = a.y * s; - v.z = a.z * s; - v.w = a.w * s; - return v; -} - - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator/(float s, const Vector4& a) -{ - Vector4 v; - s = 1.0f / s; - v.x = a.x * s; - v.y = a.y * s; - v.z = a.z * s; - v.w = a.w * s; - return v; -} - - -float phanes::core::math::coretypes::operator*(const Vector4& a, const Vector4& b) -{ - return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w; -} - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator+(const Vector4& a, float s) -{ - Vector4 v; - v.x = a.x + s; - v.y = a.y + s; - v.z = a.z + s; - v.w = a.w + s; - return v; -} - - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator+(const Vector4& a, const Vector4& b) -{ - Vector4 v; - v.x = a.x + b.x; - v.y = a.y + b.y; - v.z = a.z + b.z; - v.w = a.w + b.w; - return v; -} - - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator-(const Vector4& a, float s) -{ - Vector4 v; - v.x = a.x - s; - v.y = a.y - s; - v.z = a.z - s; - v.w = a.w - s; - return v; -} - - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator-(const Vector4& a, const Vector4& b) -{ - Vector4 v; - v.x = a.x - b.x; - v.y = a.y - b.y; - v.z = a.z - b.z; - v.w = a.w - b.w; - return v; -} - - -void phanes::core::math::coretypes::operator-(Vector4& a) -{ - a.x = -a.x; - a.y = -a.y; - a.z = -a.z; - a.w = -a.w; -} - - -bool phanes::core::math::coretypes::operator==(const Vector4& a, const Vector4& b) -{ - if (abs(a.x - b.x) <= P_FLT_INAC and abs(a.y - b.y) <= P_FLT_INAC and abs(a.z - b.z) <= P_FLT_INAC and abs(a.w - b.w) <= P_FLT_INAC) - { - return true; - } - return false; -} - -// ====================================== // -// Vector4 function implementation // -// ====================================== // - - -float phanes::core::math::coretypes::magnitude(const Vector4& a) -{ - return sqrtf(a.x * a.x + a.y * a.y + a.z * a.z + a.w * a.w); -} - -float phanes::core::math::coretypes::sqrMagnitude(const Vector4& a) -{ - return a.x * a.x + a.y * a.y + a.z * a.z; -} - - -void phanes::core::math::coretypes::normalizeNR(Vector4& a) -{ - a /= sqrtf(a.x * a.x + a.y * a.y + a.z * a.z); -} - - -float phanes::core::math::coretypes::angle(const Vector4& a, const Vector4& b) -{ - return acosf(dotP(a, b) / (magnitude(a) * magnitude(b))); -} - - -float phanes::core::math::coretypes::dotP(const Vector4& a, const Vector4& b) -{ - return a.x * b.x + a.y * b.y + a.z * b.z; -} - - -void phanes::core::math::coretypes::orthogonolize(Vector4& a, Vector4& b, Vector4& c) -{ - Set(b, b - project(b, a)); - Set(c, c - project(c, a) - project(c, b)); -} - -void phanes::core::math::coretypes::orthoNormalize(Vector4& a, Vector4& b, Vector4& c) -{ - Set(b, b - project(b, a)); - Set(c, c - project(c, a) - project(c, b)); - - a /= sqrtf(a.x * a.x + a.y * a.y + a.z * a.z); - b /= sqrtf(b.x * b.x + b.y * b.y + b.z * b.z); - c /= sqrtf(c.x * c.x + c.y * c.y + c.z * c.z); -} - -void phanes::core::math::coretypes::scaleToMagnitude(Vector4& a, float size) -{ - a /= sqrtf(a.x * a.x + a.y * a.y + a.z * a.z); - a *= size; -} - -bool phanes::core::math::coretypes::equals(const Vector4& a, const Vector4& b, float threshold) -{ - if (abs(a.x - b.x) <= threshold and abs(a.y - b.y) <= threshold and abs(a.z - b.z) <= threshold) - { - return true; - } - return false; -} - -void phanes::core::math::coretypes::perpspectiveDivideNR(Vector4& a) -{ - float _z = 1.0f / a.z; - a.x *= _z; - a.y *= _z; - a.z = 0.0f; -} - -void phanes::core::math::coretypes::maxNR(Vector4& a, const Vector4& b) -{ - a.x = phanes::core::math::max(a.x, b.x); - a.y = phanes::core::math::max(a.y, b.y); -} - -void phanes::core::math::coretypes::minNR(Vector4& a, const Vector4& b) -{ - a.x = phanes::core::math::min(a.x, b.x); - a.y = phanes::core::math::min(a.y, b.y); -} - -void phanes::core::math::coretypes::scaleNR(Vector4& a, const Vector4& b) -{ - a.x *= b.x; - a.y *= b.y; - a.z *= b.z; -} - -// projects vector a onto vector b -void phanes::core::math::coretypes::projectNR(Vector4& a, const Vector4& b) -{ - float x = (a * b) / (b * b); - a.x = x * b.x; - a.y = x * b.y; - a.z = x * b.z; -} - -// rejects vector a from vector b -void phanes::core::math::coretypes::rejectNR(Vector4& a, const Vector4& b) -{ - float x = ((a * b) / (b * b)); - a.x -= x * b.x; - a.y -= x * b.y; - a.z -= x * b.z; -} - - -void phanes::core::math::coretypes::Set(Vector4& a, const Vector4& b) -{ - a.x = b.x; - a.y = b.y; - a.z = b.z; -} - - -// WITH RETURN: // - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::perpspectiveDivide(const Vector4& a) -{ - float _z = 1.0f / a.z; - return createVector(a.x * _z, a.y * _z, a.z * _z, 0.0f); -} - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::lerp(const Vector4& a, const Vector4& b, float t) -{ - t = phanes::core::math::clamp(t, .0f, 1.0f); - return a * (1 - t) + t * b; -} - - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::lerpUnclamped(const Vector4& a, const Vector4& b, float t) -{ - return a * (1 - t) + t * b; -} - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::slerp(const Vector4& a, const Vector4& b, float t) -{ - t = phanes::core::math::clamp(t, 0.0f, 1.0f); - Vector4 _a = normalize(a); - Vector4 _b = normalize(b); - float _angle = angle(_a, _b); - return (((sinf(1.0f - t) * _angle) / sinf(_angle)) * _a) + ((sinf(t * _angle) / sinf(_angle)) * _b); -} - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::slerpUnclamped(const Vector4& a, const Vector4& b, float t) -{ - Vector4 _a = normalize(a); - Vector4 _b = normalize(b); - float _angle = angle(_a, _b); - return (((sinf(1.0f - t) * _angle) / sinf(_angle)) * _a) + ((sinf(t * _angle) / sinf(_angle)) * _b); -} - - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::max(const Vector4& a, const Vector4& b) -{ - Vector4 _new{}; - _new.x = phanes::core::math::max(a.x, b.x); - _new.y = phanes::core::math::max(a.y, b.y); - _new.z = phanes::core::math::max(a.z, b.z); - return _new; -} - - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::min(const Vector4& a, const Vector4& b) -{ - Vector4 _new{}; - _new.x = phanes::core::math::min(a.x, b.x); - _new.y = phanes::core::math::min(a.y, b.y); - _new.z = phanes::core::math::min(a.z, b.z); - return _new; -} - - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::scale(const Vector4& a, const Vector4& b) -{ - return createVector(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w); -} - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::project(const Vector4& a, const Vector4& b) -{ - return ((a * b) / (b * b)) * b; -} - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::reject(const Vector4& a, const Vector4& b) -{ - return a - ((a * b) / (b * b)) * b; -} - - -phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::normalize(const Vector4& a) -{ - return a / sqrtf(a.x * a.x + a.y * a.y + a.z * a.z); -} \ No newline at end of file diff --git a/Engine/src/Runtime/Core/private/StartingPoint/StartingPoint.cpp b/Engine/src/Runtime/Core/private/StartingPoint/StartingPoint.cpp index 7c6c5e5..14fd0e5 100644 --- a/Engine/src/Runtime/Core/private/StartingPoint/StartingPoint.cpp +++ b/Engine/src/Runtime/Core/private/StartingPoint/StartingPoint.cpp @@ -1,7 +1,40 @@ #include "PhanesEnginePCH.h" +#define P_USE_NAMESPACE_ALIAS +#define P_TEST + #include "Core/public/StartingPoint/StartingPoint.h" +static void IdleMsg() +{ + HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); + SetConsoleTextAttribute(hConsole, 12); + + std::cout << "Welcome to PhanesEngine!" << std::endl << std::endl; + + SetConsoleTextAttribute(hConsole, 15); + + std::this_thread::sleep_for(std::chrono::seconds(5)); + + std::cout << "It's silent..." << std::endl << std::endl; + + std::this_thread::sleep_for(std::chrono::seconds(3)); + + std::cout << "To silent." << std::endl; + + std::this_thread::sleep_for(std::chrono::seconds(5)); + + std::cout << "\nI will go now" << std::endl; + + std::this_thread::sleep_for(std::chrono::seconds(4)); + + std::cout << "\nGood by!" << std::endl; + std::this_thread::sleep_for(std::chrono::seconds(3)); +} + + + + Phanes::Core::Application::PhanesGame::PhanesGame() { } @@ -13,5 +46,27 @@ Phanes::Core::Application::PhanesGame::~PhanesGame() void Phanes::Core::Application::PhanesGame::Run() { - while (true); -} + HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); + SetConsoleTextAttribute(hConsole, 12); + + std::cout << "Welcome to PhanesEngine!" << std::endl << std::endl; + + SetConsoleTextAttribute(hConsole, 15); + + std::this_thread::sleep_for(std::chrono::seconds(5)); + + std::cout << "It's silent..." << std::endl << std::endl; + + std::this_thread::sleep_for(std::chrono::seconds(3)); + + std::cout << "To silent." << std::endl; + + std::this_thread::sleep_for(std::chrono::seconds(5)); + + std::cout << "\nI will go now" << std::endl; + + std::this_thread::sleep_for(std::chrono::seconds(4)); + + std::cout << "\nGood by!" << std::endl; + std::this_thread::sleep_for(std::chrono::seconds(3)); +} \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/IntPoint.h b/Engine/src/Runtime/Core/public/Math/IntPoint.h deleted file mode 100644 index 24369c6..0000000 --- a/Engine/src/Runtime/Core/public/Math/IntPoint.h +++ /dev/null @@ -1,156 +0,0 @@ -#pragma once - -#include "Core/public/Misc/Boilerplate.h" - -#include "Core/public/Math/MathCommon.h" -#include "Core/public/Math/MathAbstractTypes.h" -#include "Core/public/Math/MathFwd.h" - -#include "Core/public/Math/IntVector2.h" -#include "Core/public/Math/IntVector3.h" -// #include "Core/public/Math/IntVector4.h" - -#ifndef P_DEBUG -#pragma warning(disable : 4244) -#endif - -/** - * General annonation: The Point is the same as a vector. The type exists, to ensure a - * easy differentiation between the two. - */ - -#ifndef INTPOINT_H -#define INTPOINT_H - -namespace Phanes::Core::Math { - - /** - * A 2D Point with components x and y with integer precision. - */ - - template - struct TIntPoint2 : public TIntVector2 { - - using TIntVector2::TIntVector2; - - /** - * Creates IntPoint2 from IntPoint3's xy - * - * @param a IntPoint3 one - */ - - TIntPoint2(const TIntPoint3& a) - { - this->x = a.x; - this->y = a.y; - } - - /** - * Creates IntPoint2 from IntPoint4's xy - * - * @param a IntPoint4 one - */ - - //TIntPoint2(const TIntPoint4& a) - //{ - // this->x = a.x; - // this->y = a.y; - - //} - }; - - template - Rt Distance(const TIntPoint2& p1, const TIntPoint2& p2); - - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - - - /** - * A 3D Point with components x and y with integer precision. - */ - - - template - struct TIntPoint3 : public TIntVector3 { - - using TIntVector3::TIntVector3; - - /** - * Creates IntPoint3 from IntPoint2's xy and zero - * - * @param a IntPoint2 one - */ - - TIntPoint3(const TIntPoint2& a) - { - this->x = a.x; - this->y = a.y; - this->z = 0; - } - - /** - * Creates IntPoint3 from IntPoint4's xyz - * - * @param a IntPoint4 one - */ - - //TIntPoint3(const TIntPoint4& a) - //{ - // this->components[0] = a.components[0]; - // this->components[1] = a.components[1]; - // this->components[2] = a.components[2]; - //} - }; - - template - Rt Distance(const TIntPoint3& p1, const TIntPoint3& p2); - - -/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - - - /** - * A 4D Point with components x and y with integer precision. - */ - - - //template - //struct TIntPoint4 : public TIntVector4 { - // static_assert(std::is_integral_v(T), "T must be an integer type."); - - // using IntVector4::IntVector4; - - // /** - // * Creates IntPoint4 from IntPoint2's xy and the last two zero - // * - // * @param a IntPoint2 one - // */ - - // PHANES_CORE_API IntPoint4(const IntPoint2& a) - // { - // this->components[0] = a.components[0]; - // this->components[1] = a.components[1]; - // this->components[2] = 0; - // this->components[3] = 0; - // } - - // /** - // * Creates IntPoint4 from IntPoint3's xyz and zero - // * - // * @param a IntPoint3 one - // */ - - // PHANES_CORE_API IntPoint4(const IntPoint3& a) - // { - // this->components[0] = a.components[0]; - // this->components[1] = a.components[1]; - // this->components[2] = a.components[2]; - // this->components[3] = 0; - // } - //}; - - -} // phanes::core::math::coretypes - -#endif // !INTPOINT_H diff --git a/Engine/src/Runtime/Core/public/Math/IntVector2.h b/Engine/src/Runtime/Core/public/Math/IntVector2.h deleted file mode 100644 index 3035264..0000000 --- a/Engine/src/Runtime/Core/public/Math/IntVector2.h +++ /dev/null @@ -1,872 +0,0 @@ -#pragma once - -#include "Core/Core.h" - -#include "Core/public/Misc/Boilerplate.h" - -#include "Core/public/Math/MathCommon.h" -#include "Core/public/Math/MathAbstractTypes.h" -#include "Core/public/Math/MathFwd.h" - -#ifndef P_DEBUG -#pragma warning(disable : 4244) -#endif - -/** - * Note: Some function are deleted, because, their unusable with int types, except very specific cases. - * To keep the library verbose, these functions are explicitly marked as deleted. - */ - - -#ifndef INTVECTOR2_H -#define INTVECTOR2_H - -#define PIntZeroVector2(type) TIntVector2<##type>(0,0) -#define PIntVectorSouth2(type) TIntVector2<##type>(0,-1) -#define PIntVectorNorth2(type) TIntVector2<##type>(0,1) -#define PIntVectorEast2(type) TIntVector2<##type>(1,0) -#define PIntVectorWest2(type) TIntVector2<##type>(-1,0) - - -namespace Phanes::Core::Math { - - /** - * A 2D Vector with components x and y with integer precision. - */ - - template - struct TIntVector2 { - - static_assert(std::is_integral_v, "T must be an integer type."); - - public: - - // Using in combination with a struct and an array allows us the reflect changes of the x and y variables in the comp array and vise versa. - - union - { - - struct - { - /** X component of Vector - * - * @ref [FIELD]components - * @note x does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. - */ - T x; - - /** Y component of Vector - * - * @ref [FIELD]components - * - * @note y does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. - */ - T y; - }; - - /** Components array holding the data - * - * @ref [FIELD]x - * @ref [FIELD]y - * - * @note Components are split into x and y. Access and manipulation is possible by these variables. - */ - - T comp[2]; - - }; - - - - - public: - - /** - * Default constructor without initialization - */ - - TIntVector2() = default; - - /** - * Copy constructor - */ - - TIntVector2(const TIntVector2& v); - - /** - * Move constructor - */ - - TIntVector2(TIntVector2&& v); - - /** - * Convert other type of vector - */ - - template - explicit TIntVector2(const TIntVector2& v) : x((T)v.x), y((T)v.y) {}; - - template - explicit TIntVector2(const TVector2& v) : x((T)v.x), y((T)v.y) {}; - - /** - * Construct Vector from xy components. - * - * @param x X component - * @param y Y component - */ - - TIntVector2(const T x, const T y); - - /** - * Construct Vector from two component array. - * - * @param comp Array of components - */ - - TIntVector2(const T* comp); - - /** - * Construct Vector from 3D integer Vector's xy. - * - * @param v 3D IntVector to copy from - */ - - TIntVector2(const TIntVector3& v); - - /** - * Construct Vector from 4D integer Vector's xy. - * - * @param v 4D IntVector to copy from - */ - - //TIntVector2(const TIntVector4& v); - - /** - * Construct Vector from 2D Point's xy. - * - * @param v 2D Point to copy from - */ - - //TIntVector2(const TIntPoint2& v); - - - /** - * Constructs a vector pointing from start to end. - * - * @param(start) Startingpoint - * @param(end) Endpoint - */ - - TIntVector2(const TIntPoint2& start, const TIntPoint2& end); - }; - - // ======================== // - // IntVector2 operators // - // ======================== // - - - /** - * Addition operation on same TIntVector2 (this) by a floating point value. - * - * @param(v1) Vector to add to - * @param(s) Floating point to add - */ - - template - TIntVector2 operator+= (TIntVector2& v1, T s); - - /** - * Addition operation on same TIntVector2 (this) by a another TIntVector2. - * - * @param(v1) Vector to add to - * @param(v2) Vector to add - */ - - template - TIntVector2 operator+= (TIntVector2& v1, const TIntVector2& v2); - - /** - * Substraction operation on same TIntVector2 (this) by a floating point. - * - * @param(v1) Vector to substract from - * @param(v2) Floating point to substract - */ - - template - TIntVector2 operator-= (TIntVector2& v1, T s); - - /** - * Substraction operation on same TIntVector2 (this) by a another TIntVector2. - * - * @param(v1) Vector to substract from - * @param(v2) Vector to substract - */ - - template - TIntVector2 operator-= (TIntVector2& v1, const TIntVector2& v2); - - /** - * Multiplication of TIntVector2 (this) with a floating point. - * - * @param(v1) Vector to multiply with - * @param(s Floating point to multiply with - */ - - template - TIntVector2 operator*= (TIntVector2& v1, T s); - - /** - * Devision of Vector (this) by floating point. - * - * @param(v1) Vector to divide with - * @param(s Floating point to divide with - */ - - template - TIntVector2 operator/= (TIntVector2& v1, T s) = delete; - - /** - * Scale of Vector by floating point. (> Creates a new TIntVector2) - * - * @param(v1) Vector to multiply with - * @param(s Floating point to multiply with - * - * @return Result Vector - */ - - template - TIntVector2 operator* (const TIntVector2& v1, T s); - - /** - * Division of Vector by floating point. (> Creates another TIntVector2) - * - * @see [FUNC]DivideFloat - * - * @param(v1) Vector to multiply with - * @param(s Floating point to divide with - * - * @return Result Vector - * @note Deleted, because the returntype might not implicitly be obvious, when using in code or reading. - */ - - template - TIntVector2 operator/ (const TIntVector2& v1, T s) = delete; - - /** - * Scale of Vector by floating point. (> Creates a new TIntVector2) - * - * @param(v1) Vector to multiply with - * @param(s Floating point to multiply with - * - * @return Result Vector - */ - - template - inline TIntVector2 operator* (T s, const TIntVector2& v1); - - /** - * Division of Vector by floating point. (> For convenience not arithmethicaly correct. Works like overloaded counterpart.) - * - * @see [FUNC]DivideFloat - * - * @param(v1) Vector to multiply with - * @param(s Floating point to divide with - * - * @return Result Vector - * - * @note Deleted, because the returntype might not implicitly be obvious, when using in code or reading. - */ - - template - inline TIntVector2 operator/ (T s, const TIntVector2& v1) = delete; - - /** - * Dot product between two Vectors. - * - * @see [FUNC]DotP - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @result Dot product - */ - - template - Rt operator* (const TIntVector2& v1, const TIntVector2& v2); - - /** - * Componentwise addition of Vector with floating point. - * - * @param(v1) Vector to add to - * @param(s Floating point to add - * - * @return Result Vector - */ - - template - TIntVector2 operator+ (const TIntVector2& v1, T s); - - /** - * Componentwise addition of Vector with floating point. - * - * @param(v1) Vector to add to - * @param(s Floating point to add - * - * @return Result Vector - */ - - template - TIntVector2 operator+ (const TIntVector2& v1, const TIntVector2& v2); - - /** - * Componentwise substraction of Vector with floating point. - * - * @param(v1) Vector to substract from - * @param(s Floating point to substract - * - * @return Result Vector - */ - - template - TIntVector2 operator- (const TIntVector2& v1, T s); - - /** - * Componentwise substraction of Vector with Vector. - * - * @param(v1) Vector to substract from - * @param(s Floating point to substract - * - * @return Result Vector - */ - - template - TIntVector2 operator- (const TIntVector2& v1, const TIntVector2& v2); - - /** - * Negate Vector. - * - * @param(v1) Vector to negate - */ - - template - void operator- (TIntVector2& v1); - - /** - * Compare Vector for equality. - * - * @see [FUNC]Equals - * - * @param(v1) Vector to negate - * - * @return true if equal, false if inequal - */ - - template - bool operator== (const TIntVector2& v1, const TIntVector2& v2); - - - /** - * Compare Vector for inequality. - * - * @see [FUNC]Equals - * - * @param(v1) Vector to negate - * - * @return true if inequal, false if equal - */ - - template - bool operator!= (const TIntVector2& v1, const TIntVector2& v2); - - // ============================================== // - // IntVector2 static function implementation // - // ============================================== // - - /** - * Magnitude of Vector - * - * @param(v1) Vector - * - * @return Size of Vector - */ - - template - Rt Magnitude(const TIntVector2& v1); - - /** - * @see [FUNC]Magnitude - */ - template - FORCEINLINE Rt Length(const TIntVector2& v1) { return Magnitude(v1); }; - - /** - * Square of magnitude of Vector - * - * @param(v1) Vector - * - * @return Magnitude without calculating square root - */ - - template - T SqrMagnitude(const TIntVector2& v1); - - /** - * @see [FUNC]SqrMagnitude - */ - template - FORCEINLINE T SqrLength(const TIntVector2& v1) { return SqrMagnitude(v1); }; - - - /** - * Divide vector and truncate result. - * - * @param(v1) Vector to divide - * @param(s) Number to divide with - * - * @note Rt is the type of the reciprocal of s. - */ - - template - TIntVector2 DivideTruncV(TIntVector2& v1, T s); - - /** - * Angle between to Vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - */ - - template - Rt Angle(const TIntVector2& v1, const TIntVector2& v2); - - /** - * Cosine of angle between to Vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - */ - - template - Rt CosineAngle(const TIntVector2& v1, const TIntVector2& v2); - - /** - * Returns signs of components in vector: -1 / +1 / 0. - * - * @param(v1) Vector one - */ - - template - TIntVector2 SignVectorV(TIntVector2& v1); - - /** - * Dot product of two Vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - */ - - template - T DotP(const TIntVector2& v1, const TIntVector2& v2); - - /** - * Creates Vector, with component wise largest values. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @note Stores new Vector to v1 - */ - - template - TIntVector2 MaxV(TIntVector2& v1, const TIntVector2& v2); - - /** - * Creates Vector, with component wise smallest values. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @note Stores new Vector to v1 - */ - - template - TIntVector2 MinV(TIntVector2& v1, const TIntVector2& v2); - - /** - * Gets perpendicular Vector to v1. - * - * @param(v1) Vector one - * - * @note Stores new Vector to v1 - */ - - template - TIntVector2 GetPerpendicularV(TIntVector2& v1); - - /** - * Gets perpendicular Vector to v1. - * - * @reg [FUNC]PerpendicularV - * - * @param(v1) Vector one - * - * @note Stores new Vector to v1 - */ - - template - TIntVector2 GetReversePerpendicularV(TIntVector2& v1); - - /** - * Component wise multiplication of Vector - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @note Stores new Vector to v1 - */ - - template - TIntVector2 ScaleV(TIntVector2& v1, const TIntVector2& v2); - - /** - * Copies one Vector two another - * - * @param(v1) Vector to copy to - * @param(v2) Vector to copy - */ - - template - TIntVector2 Set(TIntVector2& v1, const TIntVector2& v2); - - /** - * Sets components of a vector. - * - * @param(v1) Vector to copy to - * @param(v2) Vector to copy - */ - - template - TIntVector2 Set(TIntVector2& v1, T x, T y); - - - /** - * Negates Vector - * - * @param(v1) Vector one - */ - - template - TIntVector2 NegateV(TIntVector2& v1); - - /** - * Tests if vector is a unity vector. - * - * @param(v1) Vector one - * - * @return true if unit vector, false if not - */ - - template - inline bool IsNormalized(const TIntVector2& v1); - - /** - * Tests if 2 vectors are perpendicular to each other. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return true if perpendicular, false if not - * - * @note Requires v1 and v2 to be normal vectors. - */ - - template - inline bool IsPerpendicular(const TIntVector2& v1, const TIntVector2& v2); - - /** - * Tests if 2 vectors are parallel to each other. (Angle is close to zero.) - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return true if parallel, false if not - * - * @note Requires v1 and v2 to be normal vectors. - */ - - template - inline bool IsParallel(const TIntVector2& v1, const TIntVector2& v2); - - /** - * Tests if 2 vectors are coincident. (Are parallel and point in the same direction.) - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return true if coincident, false if not - * - * @note Requires v1 and v2 to be normal vectors. - */ - - template - inline bool IsCoincident(const TIntVector2& v1, const TIntVector2& v2); - - /** - * Gets outer product of to vectors. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Resulting matrix - */ - - //template - //Matrix2 OuterProduct(const TIntVector2& v1, const TIntVector2& v2); - - - // ============================================================= // - // IntVector2 static function implementation with return values // - // ============================================================= // - - - /** - * Reflects a vector on a normal - * - * @param(v1) Vector one - * @param(normal) Normal of surface - * - * @return Reflected vector - */ - - template - TVector2 Reflect(const TIntVector2& v1, const TVector2& normal); - - /** - * Scales a vector component wise - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Reflected vector - */ - - template - TIntVector2 Scale(const TIntVector2& v1, const TIntVector2& v2); - - /** - * Componentwise inverse of a vector - * - * @param(v1) Vector one - * - * @return Componentwise inverted, floating point vector - */ - - template - TVector2 CompInverse(const TIntVector2& v1); - - - /** - * Negates Vector - * - * @param(v1) Vector one - * - * @return Componentwise inverted vector - */ - - template - TIntVector2 Negate(const TIntVector2& v1); - - /** - * Gets the perpendicular vector of v1 - * - * @param(v1) Vector one - * - * @return Perpendicular vector - */ - - template - TIntVector2 GetPerpendicular(const TIntVector2& v1); - - /** - * Gets reverse of the perpendicular vector of v1 - * - * @param(v1) Vector one - * - * @return Reversed perpendicular vector - */ - - template - TIntVector2 GetReversePerpendicular(const TIntVector2& v1); - - /** - * Creates a new Vector by the component wise minimals of both vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Minimal vector - */ - - template - TIntVector2 Min(const TIntVector2& v1, const TIntVector2& v2); - - /** - * Creates a new Vector by the component wise maxima of both vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Maximal vector - */ - - template - TIntVector2 Max(const TIntVector2& v1, const TIntVector2& v2); - - /** - * Creates a normalized instance of the vector - * - * @param(v1) Vector to normalize - * - * @return Unit vector - * @note Returns floating point vector. - */ - - template - TVector2 Normalize(const TIntVector2& v1); - - /** - * Creates a normalized instance of the vector - * - * @param(v1) Vector to normalize - * - * @return Unit vector - * @note Does not test for zero vector - * @note Returns floating point vector. - */ - - template - TVector2 UnsafeNormalize(const TIntVector2& v1); - - /** - * Returns signs of components in vector: -1 / +1 / 0. - * - * @param(v1) Vector one - * - * @return Vector with signs as components - */ - - template - TIntVector2 SignVector(const TIntVector2& v1); - - /** - * Binds a vector to a square with a radius - * - * @param(v1) Vector one - * @param(radius) Radius of square (=> Distance from middle to center of each site.) - * - * @return Bound, floating point vector - */ - - template - TVector2 BindToSquare(const TIntVector2& v1, T radius); - - /** - * Clamps a vector to a square with a radius - * - * @param(v1) Vector one - * @param(radius) Radius of square (=> Distance from middle to center of each site.) - * - * @return Clamped, floating point vector. If the length of the vector fits the square, then the vector is returned. - */ - - template - TVector2 ClampToSquare(const TIntVector2& v1, T radius); - - /** - * Interpolates between to vectors. - * - * @param(startVec) Start vector (t = 0) - * @param(destVec) Destination vector (t = 1) - * @param(t) Interpolation value - * - * @return Interpolated vector - * - * @note Interpolation is clamped between 0 - 1. - */ - - template - TVector2 Lerp(const TIntVector2& startVec, const TIntVector2& destVec, Rt t); - - /** - * Interpolates between to vectors. - * - * @param(startVec) Start vector (t = 0) - * @param(destVec) Destination vector (t = 1) - * @param(t) Interpolation value - * - * @return Interpolated vector - * - * @note Interpolation is not clamped. Make shure t is between 0.0f and 1.0f - */ - - template - TVector2 LerpUnclamped(const TIntVector2& startVec, const TIntVector2& destVec, Rt t); - - /** - * Anti-clockwise vector rotation. - * - * @param(v1) Vector to rotate - * @param(angle) Angle to rotate - * - * @return Rotated vector - * - * @note Angle is not clamped - */ - - template - TVector2 Rotate(const TIntVector2& v1, Rt angle); - - /** - * Clockwise vector rotation. - * - * @param(v1) Vector to rotate - * - * @return Rotated vector - * - * @note Angle is not clamped - */ - - template - FORCEINLINE TVector2 ClockwiseRotate(const TIntVector2& v1, Rt angle); - - /** - * Component wise division of Vector - * - * @param(v1) Vector one - * @param(s) Vector two - * - * @note Truncates result instead of rounding - * @note Rt is the type of the reciprocal of s. - */ - - template - TIntVector2 DivideTrunc(const TIntVector2& v1, T s); - - - /** - * Component wise division of Vector - * - * @param(v1) Vector one - * @param(s) Vector two - * - * @return Floating point vector - */ - - template - TVector2 DivideFloat(const TIntVector2& v1, T s); - -} // phanes::core::math::coretypes - -#endif // !INTVECTOR2_H - diff --git a/Engine/src/Runtime/Core/public/Math/IntVector3.h b/Engine/src/Runtime/Core/public/Math/IntVector3.h deleted file mode 100644 index 292f4a6..0000000 --- a/Engine/src/Runtime/Core/public/Math/IntVector3.h +++ /dev/null @@ -1,966 +0,0 @@ -#pragma once - -#include "Core/public/Misc/Boilerplate.h" - -#include "Core/public/Math/MathCommon.h" -#include "Core/public/Math/MathAbstractTypes.h" -#include "Core/public/Math/MathFwd.h" - -#include "Core/public/Math/Vector3.h" - -#ifndef P_DEBUG -#pragma warning(disable : 4244) -#endif - - -#ifndef INTVECTOR3_H -#define INTVECTOR3_H - -#define PIntZeroVector3(type) TIntVector3<##type>(0,0,0) -#define PIntVectorForward3(type) TIntVector3<##type>(1,0,0) -#define PIntVectorBackward3(type) TIntVector3<##type>(-1,0,0) -#define PIntVectorEast3(type) TIntVector3<##type>(0,1,0) -#define PIntVectorWest3(type) TIntVector3<##type>(0,-1,0) -#define PIntVectorUp3(type) TIntVector3<##type>(0,0,1) -#define PIntVectorDown3(type) TIntVector3<##type>(0,0,-1) - -namespace Phanes::Core::Math { - - /** - * A 3D Vector with components x, y and z with integer precision. - */ - - template - struct TIntVector3 { - - public: - - // Using in combination with a struct and an array allows us the reflect changes of the x and y variables in the comp array and vise versa. - - union - { - - struct - { - /** X component of Vector - * - * @ref [FIELD]components - * @note x does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. - */ - T x; - - /** Y component of Vector - * - * @ref [FIELD]components - * - * @note y does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. - */ - T y; - - /** Z component of Vector - * - * @ref [FIELD]components - * - * @note Z does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. - */ - T z; - }; - - /** Components array holding the data - * - * @ref [FIELD]x - * @ref [FIELD]y - * @ref [FIELD]z - * - * @note Components are split into x, y and z. Access and manipulation is possible by these variables. - */ - - T comp[3]; - - }; - - public: - - - /** - * Default constructor without initialization - */ - - TIntVector3() = default; - - /** - * Copy constructor - */ - - TIntVector3(const TIntVector3& v); - - /** - * Move constructor - */ - - TIntVector3(TIntVector3&& v); - - /** - * Convert other type of vector - */ - - template - explicit TIntVector3(const TIntVector3& v) : x((T)v.x), y((T)v.y) {}; - - template - explicit TIntVector3(const TVector3& v) : x((T)v.x), y((T)v.y) {}; - - /** - * Construct Vector from xy components. - * - * @param x X component - * @param y Y component - * @param z Z component - */ - - TIntVector3(const T x, const T y, const T z); - - /** - * Construct Vector from two component array. - * - * @param comp Array of components - */ - - TIntVector3(const T* comp); - - /** - * Construct Vector from 3D integer Vector's xy. - * - * @param v 3D IntVector to copy from - */ - - TIntVector3(const TIntVector2& v); - - /** - * Construct Vector from 4D integer Vector's xy. - * - * @param v 4D IntVector to copy from - */ - - //TIntVector2(const TIntVector4& v); - - /** - * Construct Vector from 2D Point's xy. - * - * @param v 2D Point to copy from - */ - - //TIntVector2(const TIntPoint2& v); - - - /** - * Constructs a vector pointing from start to end. - * - * @param(start) Startingpoint - * @param(end) Endpoint - */ - - TIntVector3(const TIntPoint3& start, const TIntPoint3& end); - - }; - - - // ======================== // - // IntVector3 operators // - // ======================== // - - - /** - * Coponentwise addition of floating point to 3D vector - * - * @param(v1) vector to add to - * @param(s) floating point to add - */ - - template - inline TIntVector3 operator+= (TIntVector3& v1, T s); - - /** - * Coponentwise addition of 3D vector to 3D vector - * - * @param(v1) vector to add to - * @param(v2) vector to add - */ - - template - inline TIntVector3 operator+= (TIntVector3& v1, const TIntVector3& v2); - - /** - * Coponentwise substraction of floating point of 3D vector - * - * @param(v1) vector to substract from - * @param(s) floating point to substract - */ - - template - inline TIntVector3 operator-= (TIntVector3& v1, T s); - - /** - * Coponentwise substraction of 3D vector to 3D vector - * - * @param(v1) vector to substract from - * @param(v2) vector to substract with - */ - - template - inline TIntVector3 operator-= (TIntVector3& v1, const TIntVector3& v2); - - /** - * Dot product between two 3D Vectors - * - * @param(v1) vector one - * @param(s) floating point - */ - - template - inline TIntVector3 operator*= (TIntVector3& v1, T s); - - /** - * Coponentwise multiplication of 3D Vectors with floating point - * - * @param(v1) vector one - * @param(s) floating point - * - * @return Resulting vector - */ - - template - TIntVector3 operator* (const TIntVector3& v1, T s); - - /** - * Coponentwise multiplication of 3D Vectors with floating point - * - * @param(s) floating point - * @param(v2) vector - * - * @return Resultion vector - */ - - template - inline TIntVector3 operator* (T s, const TIntVector3& v1); - - /** - * Dot product between two 3D Vectors - * - * @param(v1) vector one - * @param(v2) vector two - * - * @return Dot product of Vectors - */ - - template - T operator* (const TIntVector3& v1, const TIntVector3& v2); - - /** - * Coponentwise addition of floating point to 3D vector - * - * @param(v1) vector to add to - * @param(s) floating point to add - * - * @return Resulting vector - */ - - template - TIntVector3 operator+ (const TIntVector3& v1, T s); - - /** - * Coponentwise addition of 3D vector to 3D vector - * - * @param(v1) vector to add to - * @param(v2) vector to add - * - * @return Resulting vector - */ - - template - TIntVector3 operator+ (const TIntVector3& v1, const TIntVector3& v2); - - /** - * Coponentwise substraction of floating point of 3D vector - * - * @param(v1) vector to substract from - * @param(s) floating point to substract - * - * @return Resulting vector - */ - - template - TIntVector3 operator- (const TIntVector3& v1, T s); - - /** - * Coponentwise substraction of floating point of 3D vector - * - * @param(v1) vector to substract from - * @param(v2) vector to substract with - * - * @return Resulting vector - */ - - template - TIntVector3 operator- (const TIntVector3& v1, const TIntVector3& v2); - - /** - * Negates vector - * - * @param(v1) Vector to negate - */ - - template - TIntVector3 operator- (TIntVector3& v1); - - /** - * Tests two 3D vectors for equality. - * - * @ref [FUNC]Equals - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return True if equal, false if not. - * - * @note Uses [MACRO]P_FLT_INAC - */ - - template - inline bool operator== (const TIntVector3& v1, const TIntVector3& v2); - - /** - * Tests two 3D vectors for inequality. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return True if inequal, false if not. - */ - - template - inline bool operator!= (const TIntVector3& v1, const TIntVector3& v2); - - // ============================================== // - // IntVector3 static function implementation // - // ============================================== // - - /** - * Gets magnitude of vector - * - * @param(v1) Vector - * - * @return Magnitude of vector - */ - - template - inline Rt Magnitude(const TIntVector3& v1); - - /** - * @see [FUNC]Magnitude - */ - - template - FORCEINLINE T Length(const TIntVector3& v1) { return Magnitude(v1); }; - - /** - * Gets square magnitude of vector - * - * @param(v1) Vector - * - * @return Square magnitude of vector - */ - - template - inline T SqrMagnitude(const TIntVector3& v1); - - /** - * @see SqrMagnitude - */ - - template - FORCEINLINE T SqrLength(const TIntVector3& v1) { return SqrMagnitude(v1); }; - - /** - * Gets angle between two vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Angle between vectors - */ - - template - Rt Angle(const TIntVector3& v1, const TIntVector3& v2); - - /** - * Dot product of two vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Dot product of vectors - */ - - template - T DotP(const TIntVector3& v1, const TIntVector3& v2); - - /** - * Returns signs of components in vector: -1 / +1 / 0. - * - * @param(v1) Vector one - * - * @return Vector with signs a components. - */ - - template - TIntVector3 SignVector(const TIntVector3& v1); - - /** - * Tests two vectors for equality. - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(threshold) Allowed T inaccuracy. - * - * @return True if equal, false if not. - */ - - template - inline bool Equals(const TIntVector3& v1, const TIntVector3& v2, T threshold = P_FLT_INAC); - - /** - * Calculates the cross product between two vectors. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @note result is stored in v1. - */ - - template - TIntVector3 CrossPV(TIntVector3& v1, const TIntVector3& v2); - - /** - * Gets the componentwise max of both vectors. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @note result is stored in v1. - */ - - template - TIntVector3 MaxV(TIntVector3& v1, const TIntVector3& v2); - - /** - * Gets the componentwise min of both vectors. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @note result is stored in v1. - */ - - template - TIntVector3 MinV(TIntVector3& v1, const TIntVector3& v2); - - /** - * Gets reversed vector. - * - * @param(v1) Vector one - * - * @note result is stored in v1. - */ - - template - TIntVector3 NegateV(TIntVector3& v1); - - /** - * Performes componentwise multiplication of two vectors. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @note result is stored in v1. - */ - - template - TIntVector3 ScaleV(TIntVector3& v1, const TIntVector3& v2); - - /** - * Copies v1 vector - * - * @param(v1) Vector to copy to - * @param(v2) Vector to copy - */ - - template - TIntVector3 Set(TIntVector3& v1, const TIntVector3& v2); - - /** - * Sets vector. - * - * @param(v1) Vector to copy to - * @param(x) X component - * @param(y) Y component - * @param(z) Z component - */ - - template - TIntVector3 Set(TIntVector3& v1, T x, T y, T z); - - /** - * Returns signs of components in vector: -1 / +1 / 0. - * - * @param(v1) Vector one - */ - - template - TIntVector3 SignVectorV(TIntVector3& v1); - - - /** - * Gets scalar triple product ((v1 x v2) * v3). (Volume of parallelepiped.) - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(v3) Vector three - * - * @return Vector triple product - */ - - template - T ScalarTriple(const TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3); - - /** - * Gets the cosine of the angle between to vectors. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Cosine of angle between vectors. - * @note Simply omits acos of angle. - */ - - template - T CosineAngle(const TIntVector3& v1, const TIntVector3& v2); - - /** - * Gets vector triple product ((v1 x v2) x v3). - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(v3) Vector three - * - * @note result is stored in v1 - */ - - template - TIntVector3 VectorTripleV(TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3); - - /** - * Tests whether two vectors are perpendicular. - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(threshold) Allowed T inaccuracy - * - * @return True if perpendicular, false if not. - */ - - template - inline bool IsPerpendicular(const TIntVector3& v1, const TIntVector3& v2, T threshold = P_FLT_INAC); - - /** - * Tests whether two vectors are parallel. - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(threshold) Allowed T inaccuracy from one (e.g. 0.98f) - * - * @return True if parallel, false if not. - */ - - template - inline bool IsParallel(const TIntVector3& v1, const TIntVector3& v2, T threshold = 1.0f - P_FLT_INAC); - - /** - * Tests whether two vectors are coincident (Parallel and point in same direction). - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(threshold) Allowed T inaccuracy from one (e.g. 0.98f) - * - * @return True if coincident, false if not. - */ - - template - inline bool IsCoincident(const TIntVector3& v1, const TIntVector3& v2, T threshold = 1.0f - P_FLT_INAC); - - /** - * Tests whether v1 vectors is v1 unit vector. - * - * @param(v1) Vector - * @param(threshold) Allowed T inaccuracy - * - * @return True if unit vector, false if not. - */ - - template - inline bool IsNormalized(const TIntVector3& v1, T threshold = P_FLT_INAC); - - /** - * Tests if three vectors are coplanar - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(v3) Vector three - * @param(threshold) Allowed T inaccuracy - * - * @return True if coplanar, false if not. - */ - - template - inline bool IsCoplanar(const TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3, T threshold = P_FLT_INAC); - - - /** - * Gets outer product of to vectors. - * - * @param a Vector one - * @param b Vector two - * - * @return Resulting matrix - */ - - //template - //Matrix3 OuterProduct(const IntVector3& a, const IntVector3& b); - - - // ================================================================ // - // IntVector3 static function implementation with return values // - // ================================================================ // - - /** - * Normalized vector - * - * @param(v1) vector to normalize - * - * @return Normalized vector - */ - - template - TVector3 Normalize(const TIntVector3& v1); - - /** - * Normalizes vector - * - * @param(v1) Vector - * - * @note Does not test for zero vector - */ - - template - TVector3 UnsafeNormalize(const TIntVector3& v1); - - /** - * Reflects a vector on a surface - * - * @param(v1) Vector one - * @param(normal) Normal of surface - * - * @return Reflected vector - */ - - template - TVector3 Reflect(const TIntVector3& v1, const TVector3& normal); - - - /** - * Performes perspective divide on vector. - * - * @param(v1) vector to perspective divide - * - * @return Perspective divided vector - */ - - template - TVector3 PerspectiveDivide(const TIntVector3& v1); - - /** - * Gets cross product between two vectors. - * - * @param(v1) vector one - * @param(v2) vector two - * - * @return Cross product of v1 and v2 - */ - - template - TIntVector3 CrossP(const TIntVector3& v1, const TIntVector3& v2); - - /** - * Linearly interpolates between two vectors. - * - * @param(start) Starting vector - * @param(dest) Destination vector - * @param(t) 0.0 to 1.0 interpolation value - * - * @return Cross product of v1 and v2 - */ - - template - TVector3 Lerp(const TIntVector3& start, const TIntVector3& dest, Rt t); - - /** - * Linearly interpolates between two vectors. - * - * @param(v1) Starting vector - * @param(dest) Destination vector - * @param(t) 0.0 to 1.0 interpolation value - * - * @return Cross product of v1 and v2 - * @note Does not clamp t between 0.0 and 1.0. - */ - - template - TVector3 LerpUnclamped(const TIntVector3& start, const TIntVector3& dest, Rt t); - - /** - * Creates a new Vector by the componentwise max of both vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Vector of componentwise max - */ - - template - TIntVector3 Max(const TIntVector3& v1, const TIntVector3& v2); - - /** - * Creates a new Vector by the componentwise min of both vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Vector of componentwise min - */ - - template - TIntVector3 Min(const TIntVector3& v1, const TIntVector3& v2); - - /** - * Gets reversed vector. - * - * @param(v1) Vector one - * - * @note result is stored in v1. - */ - - template - TIntVector3 Negate(const TIntVector3& v1); - - /** - * Multiplies vector componentwise. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Vector with componentwise products - */ - - template - TIntVector3 Scale(const TIntVector3& v1, const TIntVector3& v2); - - /** - * Clamps vector to a range of magnitudes. - * - * @param(v1) Vector to clamp - * @param(min) Min magnitude - * @param(max) Max magnitude - * - * @return Clamped vector - */ - - template - TVector3 ClampMagnitude(const TIntVector3& v1, T min, T max); - - /** - * Binds vector into cube. - * - * @param(v1) Vector to clamp - * @param(cubeRadius) Radius of the cube - * - * @result Vector clamped in cube. - */ - - template - TVector3 BoundToCube(const TIntVector3 v1, T cubeRadius) {}; - - /** - * Clamps vector into cube. - * - * @param(v1) Vector to clamp - * @param(cubeRadius) Radius of the cube - * - * @result Vector clamped in cube. - */ - - template - TVector3 ClampToCube(const TIntVector3 v1, T cubeRadius) {}; - - /** - * Scales vector two specific magnitude. - * - * @param(v1) Vector - * - * @note It's faster to use operator* or operator*= for naturaly normalized vectors. - */ - - template - TVector3 ScaleToMagnitude(const TIntVector3& v1, T magnitude); - - /** - * Clamps vector into cube. - * - * @param(v1) Vector - * - * @result Vector with inverted components. - */ - - template - TVector3 CompInverse(const TIntVector3& v1); - - /** - * Reflect by plane - * - * @param(v1) Vector to mirror - * @param(plane) Plane to mirror on - * - * @return Mirrored vector - */ - - template - FORCEINLINE TVector3 ReflectFromPlane(const TIntVector3& v1, const TPlane& plane); - - /** - * Reflect by plane - * - * @param(v1) Vector to mirror - * @param(plane) Normal of plane - * - * @return Mirrored vector - */ - - template - FORCEINLINE TVector3 ReflectFromPlane(const TIntVector3& v1, const TVector3& normal); - - /** - * Rotates vector around axis - * - * @param(v1) Vector to mirror - * @param(axisNormal) Axis to rotate around - * - * @return Rotated vector - * @note Calculates vector rotation with Rodrigues-Rotation - */ - - template - TVector3 RotateAroundAxis(const TIntVector3& v1, const TVector3& axisNormal, Rt angle); - - /** - * Gets vector triple product ((v1 x v2) x v3). - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(v3) Vector three - * - * @return Vector triple product - */ - - template - TIntVector3 VectorTriple(const TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3); - - /** - * Projects vector v1 onto v2 - * - * @param(v1) Vector to project - * @param(v2) Vector to project on - * - * @return Projected vector - */ - - template - TVector3 Project(const TIntVector3& v1, const TIntVector3& v2); - - /** - * Rejects vector v1 from v2 - * - * @param(v1) Vector to reject - * @param(v2) Vector to reject from - * - * @return Rejected vector - */ - - template - TVector3 Reject(const TIntVector3& v1, const TIntVector3& v2); - - /** - * Projects vector onto plane - * - * @param(v1) Vector to reject - * @param(normal) Normal of the plane - * - * @return Projected vector - * @note Simply rejects the vector from normal - */ - - template - FORCEINLINE TVector3 ProjectOntoPlane(const TIntVector3& v1, const TVector3& normal); - - /** - * Projects vector onto plane - * - * @param(v1) Vector to reject - * @param(normal) Plane - * - * @return Projected vector - * @note Simply rejects the vector from normal - */ - - template - FORCEINLINE TVector3 ProjectOntoPlane(const TIntVector3& v1, const TPlane& plane); - - /** - * Interpolate vector v1 to desitnation v2 using v1 constant s. The magnitude of the vector stays the same throughout the interpolation. - * - * @param(v1) Starting vector - * @param(v2) Destination vector - * @param(t) 0.0 to 1.0 interpolation value - * - * @return Interpolated unit vector - */ - - template - TVector3 Slerp(const TIntVector3& v1, const TIntVector3& v2, Rt t) {}; - - /** - * Interpolate vector v1 to desitnation v2 using v1 constant s. The magnitude of the vector stays the same throughout the interpolation. - * - * @param(v1) Starting vector - * @param(v2) Destination vector - * @param(t) 0.0 to 1.0 interpolation value - * - * @return Interpolated unit vector. - * @note Does not clamp s between 0.0 and 1.0. - */ - - template - TVector3 SlerpUnclamped(const TIntVector3& v1, const TIntVector3& v2, Rt t) {}; - -} // phanes::core::math::coretypes - -#endif // !INTVECTOR3_H - diff --git a/Engine/src/Runtime/Core/public/Math/IntVector4.h b/Engine/src/Runtime/Core/public/Math/IntVector4.h deleted file mode 100644 index 06b8ccc..0000000 --- a/Engine/src/Runtime/Core/public/Math/IntVector4.h +++ /dev/null @@ -1,941 +0,0 @@ -#pragma once - -#include "Misc/BoilerplateHeader.h" -#include PHANES_CORE_PCH_DEFAULT_PATH - -#include "Math/MathCommon.h" -#include "Math/MathAbstractTypes.h" -#include "Math/MathFwd.h" - - -#ifndef P_DEBUG -#pragma warning(disable : 4244) -#endif - - -#ifndef INTVECTOR4_H -#define INTVECTOR4_H - -namespace phanes::core::math::coretypes { - - /** - * A 4D Vector with components x, y, z and w with integer precision. - */ - - template - struct IntVector4 { - - static_assert(std::is_integral_v(T), "T must be an integer type."); - - public: - - union - { - - struct - { - - /** X component of Vector - * - * @ref [FIELD]components - * - * @note x does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. - */ - T x = &components[1]; - - /** Y component of Vector - * - * @ref [FIELD]components - * - * @note y does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. - */ - T y = &components[1]; - - /** Z component of Vector - * - * @ref [FIELD]components - * - * @note z does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. - */ - T z = &components[2]; - - /** W component of Vector - * - * @ref [FIELD]components - * - * @note w does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. - */ - T w = &components[3]; - - }; - - /** Components array holding the data - * - * @ref [FIELD]x - * @ref [FIELD]y - * @ref [FIELD]z - * @ref [FIELD]w - * - * @note Components are split into x, y, z and w. Access and manipulation is possible by these variables. - */ - - T components[4]; - }; - - - public: - - /** - * Default constructor without initialization - */ - - PHANES_CORE_API IntVector4() = default; - - - /** - * Construct Vector from xy components. - * - * @param x X component - * @param y Y component - * @param z Z component - * @param w W component - */ - - PHANES_CORE_API IntVector4(const T x, const T y, const T z, const T w); - - /** - * Construct Vector from two component array. - * - * @param comp Array of components - */ - - PHANES_CORE_API IntVector4(const T comp[4]); - - /** - * Construct Vector from 2D Vector's xy and the last two zero. - * - * @param v 2D IntVector to copy from - */ - - PHANES_CORE_API IntVector4(const Vector2& v); - - /** - * Construct Vector from 3D Vector's xyz and zero. - * - * @param v 3D Vector to copy from - */ - - - PHANES_CORE_API IntVector4(const Vector3& v); - - /** - * Construct Vector from 4D Vector's xyzw. - * - * @param v 4D Vector to copy from - */ - - PHANES_CORE_API IntVector4(const Vector4& v); - - - /** - * Construct Vector from 2D integer Vector's xy and the last two zero. - * - * @param v 3D IntVector to copy from - */ - - PHANES_CORE_API IntVector4(const IntVector2& v); - - /** - * Construct Vector from 4D integer Vector's xyz and zero. - * - * @param v 4D IntVector to copy from - */ - - PHANES_CORE_API IntVector4(const IntVector3& v); - - /** - * Construct Vector from 3D Point's xyzw. - * - * @param v 3D Point to copy from - */ - - PHANES_CORE_API IntVector4(const IntPoint4& v); - - - }; - - - // List of IntVector4 for DoP and ECS - - // List of 4D Vectors using int - using IntVector4List = std::vector >; - - - - // ======================== // - // IntVector4 operators // - // ======================== // - - - - /** - * Addition operation on same IntVector4 (this) by a integer value. - * - * @param a Vector to add to - * @param s integer to add - */ - - template - INLINE PHANES_CORE_API void operator+= (IntVector4& a, T s); - - - /** - * Addition operation on same IntVector4 (this) by a another IntVector4. - * - * @param a Vector to add to - * @param b Vector to add - */ - - template - INLINE PHANES_CORE_API void operator+= (IntVector4& a, const IntVector4& b); - - - /** - * Substraction operation on same IntVector4 (this) by a integer. - * - * @param a Vector to substract from - * @param b integer to substract - */ - - template - INLINE PHANES_CORE_API void operator-= (IntVector4& a, T s); - - - /** - * Substraction operation on same IntVector4 (this) by a another IntVector4. - * - * @param a Vector to substract from - * @param b Vector to substract - */ - - template - INLINE PHANES_CORE_API void operator-= (IntVector4& a, const IntVector4& b); - - - /** - * Multiplication of IntVector4 (this) with a integer. (Scale) - * - * @param a Vector to multiply with - * @param s integer to multiply with - */ - - template - INLINE PHANES_CORE_API void operator*= (IntVector4& a, T s); - - - /** - * Devision of Vector (this) by integer. - * - * @ref [FUNC]DivideTruncV - * @ref [FUNC]DivideFloatV - * - * @param a Vector to multiply with - * @param s integer to divide with - * - * @note Rounds components - */ - - template - INLINE PHANES_CORE_API void operator/= (IntVector4& a, T s); - - - /** - * Componentwise divison of Vector (this) by another vector - * - * @ref [FUNC]DivideTruncV - * @ref [FUNC]DivideFloatV - * - * @param a Vector to multiply with - * @param b Vector to divide with - * - * @note Rounds components - */ - - template - INLINE PHANES_CORE_API void operator/= (IntVector4& a, const IntVector4& b); - - - /** - * Scale of Vector by integer. (> Creates a new IntVector4) - * - * @param a Vector to multiply with - * @param s integer to multiply with - * - * @return Result Vector - */ - - template - INLINE PHANES_CORE_API IntVector4 operator* (const IntVector4& a, T s); - - - /** - * Scale of Vector by integer. (> Creates a new IntVector4) - * - * @param a Vector to multiply with - * @param s integer to multiply with - * - * @return Result Vector - */ - - template - INLINE PHANES_CORE_API IntVector4 operator* (T s, const IntVector4& a); - - - /** - * Dot product between two Vectors. - * - * @ref [FUNC]DotP - * - * @param a Vector one - * @param b Vector two - * - * @result Dot product - */ - - template - INLINE PHANES_CORE_API T operator* (const IntVector4& a, const IntVector4& b); - - - /** - * Division of Vector by integer. (> Creates another IntVector4) - * - * @param a Vector to multiply with - * @param s integer to divide with - * - * @return Result Vector - */ - - template - INLINE PHANES_CORE_API IntVector4 operator/ (const IntVector4& a, T s); - - - /** - * Division of Vector by integer. (> For convenience not arithmethicaly correct. Works like overloaded counterpart.) - * - * @ref [FUNC]DivideTrunc - * @ref [FUNC]DivideFloat - * - * @param a Vector to multiply with - * @param s integer to divide with - * - * @note Rounds components - * - * @return Result Vector - */ - - template - INLINE PHANES_CORE_API IntVector4 operator/ (T s, const IntVector4& a); - - - /** - * Componentwise division of Vector (> For convenience not arithmethicaly correct. Works like overloaded counterpart.) - * - * @ref [FUNC]DivideTrunc - * @ref [FUNC]DivideFloat - * - * @param a Vector to multiply with - * @param s integer to divide with - * - * @note Rounds components - * - * @return Result Vector - */ - - template - INLINE PHANES_CORE_API IntVector4 operator/ (const IntVector4& a, const IntVector4& b); - - - /** - * Componentwise addition of Vector with integer. - * - * @param a Vector to add to - * @param s integer to add - * - * @return Result Vector - */ - - template - INLINE PHANES_CORE_API IntVector4 operator+ (const IntVector4& a, T s); - - - /** - * Componentwise addition of Vector with integer. - * - * @param a Vector to add to - * @param s integer to add - * - * @return Result Vector - */ - - template - INLINE PHANES_CORE_API IntVector4 operator+ (const IntVector4& a, const IntVector4& b); - - - /** - * Componentwise substraction of Vector with integer. - * - * @param a Vector to substract from - * @param s integer to substract - * - * @return Result Vector - */ - - template - INLINE PHANES_CORE_API IntVector4 operator- (const IntVector4& a, T s); - - /** - * Componentwise substraction of Vector with Vector. - * - * @param a Vector to substract from - * @param s integer to substract - * - * @return Result Vector - */ - - template - INLINE PHANES_CORE_API IntVector4 operator- (const IntVector4& a, const IntVector4& b); - - - /** - * Negate Vector. - * - * @param a Vector to negate - */ - - template - INLINE PHANES_CORE_API void operator- (IntVector4& a); - - - /** - * Compare Vector for equality. - * - * @ref [FUNC]Equals - * - * @param a Vector to negate - * - * @return true if equal, false if inequal - */ - - template - INLINE PHANES_CORE_API bool operator== (const IntVector4& a, const IntVector4& b); - - - /** - * Compare Vector for inequality. - * - * @ref [FUNC]Equals - * - * @param a Vector to negate - * - * @return true if inequal, false if equal - */ - - template - INLINE PHANES_CORE_API bool operator!= (const IntVector4& a, const IntVector4& b); - - - // ============================================== // - // IntVector4 static function implementation // - // ============================================== // - - /** - * Magnitude of Vector - * - * @param a Vector - * - * @return Size of Vector - */ - - template - PHANES_CORE_API T Magnitude(const IntVector4& a); - - - /** - * Square of magnitude of Vector - * - * @param a Vector - * - * @return Magnitude without calculating square root - */ - - template - PHANES_CORE_API T SqrMagnitude(const IntVector4& a); - - - /** - * Normalize Vector - * - * @param a Vector - */ - - template - PHANES_CORE_API void NormalizeV(IntVector4& a); - - - /** - * Angle between to Vectors - * - * @param a Vector one - * @param b Vector two - */ - - template - PHANES_CORE_API T Angle(const IntVector4& a, const IntVector4& b); - - - /** - * Dot product of two Vectors - * - * @param a Vector one - * @param b Vector two - */ - - template - PHANES_CORE_API T DotP(const IntVector4& a, const IntVector4& b); - - - /** - * Creates Vector, with component wise largest values. - * - * @param a Vector one - * @param b Vector two - * - * @note Stores new Vector to a - */ - - template - PHANES_CORE_API void MaxV(IntVector4& a, const IntVector4& b); - - - /** - * Creates Vector, with component wise smallest values. - * - * @param a Vector one - * @param b Vector two - * - * @note Stores new Vector to a - */ - - template - PHANES_CORE_API void MinV(IntVector4& a, const IntVector4& b); - - - /** - * Gets perpendicular Vector to a. - * - * @reg NO_RETURN(ReversePerpendicular) - * - * @param a Vector one - * - * @note Stores new Vector to a - */ - - template - PHANES_CORE_API void PerpendicularV(IntVector4& a); - - - /** - * Gets perpendicular Vector to a. - * - * @reg NO_RETURN(Perpendicular) - * - * @param a Vector one - * - * @note Stores new Vector to a - */ - - template - PHANES_CORE_API void ReversePerpendicularV(IntVector4& a); - - - /** - * Component wise multiplication of Vector - * - * @param a Vector one - * @param b Vector two - * - * @note Stores new Vector to a - */ - - template - PHANES_CORE_API void ScaleV(IntVector4& a, const IntVector4& b); - - - /** - * Component wise division of Vector - * - * @param a Vector one - * @param b Vector two - * - * @note Truncates result instead of rounding - * @note Stores new Vector to a - */ - - template - PHANES_CORE_API void DivideTruncV(IntVector4& a, const IntVector4& b); - - - /** - * Component wise division of Vector - * - * @param a Vector one - * @param b Vector two - * - * @note Truncates result instead of rounding - * @note Stores new Vector to a - */ - - template - PHANES_CORE_API void DivideTruncV(IntVector4& a, T s); - - - /** - * Componentwise inversion of Vector - * - * @param a Vector one - * - * @note Stores new Vector to a - */ - - template - PHANES_CORE_API void CompInverseV(IntVector4& a); - - - /** - * Reflect Vector by normal vector. - * - * @param a Vector one - * @param b Vector two - * - * @note Stores new Vector to a - */ - - template - PHANES_CORE_API void ReflectV(IntVector4& a, const IntVector4& normal); - - - /** - * Copies one Vector two another - * - * @param a Vector to copy to - * @param b Vector to copy - */ - - template - PHANES_CORE_API void Set(IntVector4& a, const IntVector4& b); - - - /** - * Sets components of a vector. - * - * @param a Vector to copy to - * @param b Vector to copy - */ - - template - PHANES_CORE_API void Set(IntVector4& a, T x, T y, T z, T w); - - - /** - * Tests if vector is a unity vector. - * - * @param a Vector one - * @param threshold Threshold to one - * - * @return true if unit vector, false if not - */ - - template - PHANES_CORE_API bool IsNormalized(const IntVector4& a, T threshold = P_FLT_INAC); - - /** - * Tests if 2 vectors are perpendicular to each other. - * - * @param a Vector one - * @param b Vector two - * @param threshold Threshold - * - * @return true if perpendicular, false if not - */ - - template - PHANES_CORE_API bool IsPerpendicular(const IntVector4& a, const IntVector4& b, T threshold = P_FLT_INAC); - - - /** - * Tests if 2 vectors are parallel to each other. (Angle is close to zero.) - * - * @param a Vector one - * @param b Vector two - * @param threshold Threshold - * - * @return true if parallel, false if not - */ - - template - PHANES_CORE_API bool IsParallel(const IntVector4& a, const IntVector4& b, T threshold = P_FLT_INAC); - - /** - * Tests if 2 vectors are coincident. (Are parallel and point in the same direction.) - * - * @param a Vector one - * @param b Vector two - * @param threshold Threshold - * - * @return true if coincident, false if not - */ - - template - PHANES_CORE_API bool IsCoincident(const IntVector4& a, const IntVector4& b, T threshold = P_FLT_INAC); - - - /** - * Gets outer product of to vectors. - * - * @param a Vector one - * @param b Vector two - * - * @return Resulting matrix - */ - - template - PHANES_CORE_API Matrix2 OuterProduct(const IntVector4& a, const IntVector4& b); - - - // ================================================================ // - // IntVector4 static function implementation with return values // - // ================================================================ // - - - /** - * Reflects a vector on a normal - * - * @param a Vector one - * @param normal Normal vector - * - * @return Reflected vector - */ - - template - PHANES_CORE_API IntVector4 Reflect(const IntVector4& a, const IntVector4& normal); - - - /** - * Scales a vector component wise - * - * @param a Vector one - * @param b Vector two - * - * @return Reflected vector - */ - - template - PHANES_CORE_API IntVector4 Scale(const IntVector4& a, const IntVector4& b); - - - /** - * Component wise division of Vector - * - * @param a Vector one - * @param b Vector two - * - * @note Truncates result instead of rounding - */ - - template - PHANES_CORE_API IntVector4 DivideTrunc(const IntVector4& a, const IntVector4& b); - - - /** - * Component wise division of Vector - * - * @param a Vector one - * @param b Vector two - * - * @note Truncates result instead of rounding - */ - - template - PHANES_CORE_API IntVector4 DivideTrunc(const IntVector4& a, T s); - - - /** - * Component wise division of Vector - * - * @param a Vector one - * @param b Vector two - * - * @return Floating point vector - */ - - template - PHANES_CORE_API Vector2 DivideFloat(const IntVector4& a, const IntVector4& b); - - - /** - * Component wise division of Vector - * - * @param a Vector one - * @param b Vector two - * - * @return Floating point vector - */ - - template - PHANES_CORE_API Vector2 DivideFloat(const IntVector4& a, T s); - - - /** - * Componentwise inverse of Vector - * - * @param a Vector one - * @param b Vector two - * - * @return Reflected vector - */ - - template - PHANES_CORE_API IntVector4 CompInverse(const IntVector4& a); - - - /** - * Gets the perpendicular vector of a - * - * @param a Vector one - * - * @return Perpendicular vector - */ - - template - PHANES_CORE_API IntVector4 Perpendicular(const IntVector4& a); - - - /** - * Gets reverse of the perpendicular vector of a - * - * @param a Vector one - * - * @return Reversed perpendicular vector - */ - - template - PHANES_CORE_API IntVector4 ReversePerpendicular(const IntVector4& a); - - - /** - * Creates a new Vector by the component wise minimals of both vectors - * - * @param a Vector one - * @param b Vector two - * - * @return Minimal vector - */ - - template - PHANES_CORE_API IntVector4 Min(const IntVector4& a, const IntVector4& b); - - - /** - * Creates a new Vector by the component wise maxima of both vectors - * - * @param a Vector one - * @param b Vector two - * - * @return Maximal vector - */ - - template - PHANES_CORE_API IntVector4 Max(const IntVector4& a, const IntVector4& b); - - - /** - * Creates a normalized instance of the vector - * - * @param a Vector to normalize - * - * @return Unit vector - */ - - template - PHANES_CORE_API IntVector4 Normalize(const IntVector4& a); - - - /** - * Interpolates between to vectors. - * - * @param a Start value (t = 0) - * @param b End value (t = 1) - * @param t Interpolation value - * - * @return Interpolated vector - * - * @note Interpolation is clamped between 0 - 1. - */ - - template - INLINE PHANES_CORE_API IntVector4 Lerp(const IntVector4& a, const IntVector4& b, T t); - - - /** - * Interpolates between to vectors. - * - * @param a Start value (t = 0) - * @param b End value (t = 1) - * @param t Interpolation value - * - * @return Interpolated vector - * - * @note Interpolation is not clamped. - */ - - template - INLINE PHANES_CORE_API IntVector4 LerpUnclamped(const IntVector4& a, const IntVector4& b, T t); - - - /** - * Spherical interpolation between two vectors. - * - * @param a Start value (t = 0) - * @param b End value (t = 1) - * @param t Interpolation value - * - * @return Interpolated vector - * - * @note Interpolation is clamped between 0 - 1. - * @note Quaternion are more efficient and should be used if possible. - */ - - template - PHANES_CORE_API IntVector4 Slerp(const IntVector4& a, const IntVector4& b, T t); - - - /** - * Spherical interpolation between two vectors. - * - * @param a Start value (t = 0) - * @param b End value (t = 1) - * @param t Interpolation value - * - * @return Interpolated vector - * - * @note Interpolation is clamped between 0 - 1. - * @note Quaternion are more efficient and should be used if possible. - */ - - template - PHANES_CORE_API IntVector4 SlerpUnclamped(const IntVector4& a, const IntVector4& b, T t); - -} // phanes::core::math::coretypes - -#endif // !INTVECTOR3_H - diff --git a/Engine/src/Runtime/Core/public/Math/MathAbstractTypes.h b/Engine/src/Runtime/Core/public/Math/MathAbstractTypes.h deleted file mode 100644 index 910862e..0000000 --- a/Engine/src/Runtime/Core/public/Math/MathAbstractTypes.h +++ /dev/null @@ -1,29 +0,0 @@ -#pragma once - -#ifndef ABSTRACT_TYPES_H -#define ABSTRACT_TYPES_H - -namespace Phanes::Core::Math::Internal { - - template - struct AVector { - public: - - /** - * List of n components of the vector - */ - - T comp[D]; - - }; - - template - struct AMatrix { - public: - T fields[n][m]; - - }; - -}; // Phanes::Core::Math::abstract::coretypes - -#endif // !ABSTRACT_TYPES_H \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/MathCommon.h b/Engine/src/Runtime/Core/public/Math/MathCommon.h deleted file mode 100644 index 16745ce..0000000 --- a/Engine/src/Runtime/Core/public/Math/MathCommon.h +++ /dev/null @@ -1,98 +0,0 @@ -#pragma once - -#define P_FLT_INAC_LARGE 0.0001f // large float inaccuracy (1*10^-4); -#define P_FLT_INAC 0.00001f // float inaccuracy (1*10^-5); -#define P_FLT_INAC_SMALL 0.000001f // small float inaccuracy (1*10^-6); - -#define P_180_PI 57.29577951308232 // (double) 180°/pi; -#define P_180_PI_FLT 57.29577951308232f // (float) 180°/pi; - -#define P_PI_180 0.0174532925199432 // double pi/180° -#define P_PI_180_FLT 0.0174532925199432f // (float) pi/180° - -#define P_PI 3.1415926535897932 // PI -#define P_PI_FLT 3.1415926535897932f // PI - - -#include "Core/Core.h" - -#ifndef MATH_COMMON_H -#define MATH_COMMON_H - -namespace Phanes::Core::Math { - - /** - * Clamps a value between minimum and maximum - * - * @param value Value to clamp - * @param low Minimum - * @param high Maximum - * - * @return Minimum, if value is to small / Maximum, if value is to large / value, if value is in range. - */ - - template - T Clamp(T value, T low, T high); - - - /** - * Gets the larger of two values - * - * @param x - * @param y - * - * @return Larger value - */ - - template - inline T Max(T x, T y); - - - /** - * Gets the smaller of two values - * - * @param x - * @param y - * - * @return Smaller value - */ - - template - inline T Min(T x, T y); - - /** - * Swaps the values of two variables - * - * @param x - * @param y - */ - - template - inline void Swap(T& x, T& y); - - /** - * Test two numbers for equality - * - * @param x - */ - template - bool Equals(T x, T y, T threshold = P_FLT_INAC); - - /** - * Calculates the reciprocal of the square root of n using the algorithm of A Quake III - * - * @param n Number to calculate - * - * @return Inverse square root of n - * - * @note a simple 1.0f / sqrtf(x) is faster than this algorithm. Use for research purpose only. - */ - - - template - float FastInvSqrt(T n); - - -} // phanes - -#endif // !MATH_COMMON_H \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/MathFwd.h b/Engine/src/Runtime/Core/public/Math/MathFwd.h deleted file mode 100644 index 3f9f523..0000000 --- a/Engine/src/Runtime/Core/public/Math/MathFwd.h +++ /dev/null @@ -1,103 +0,0 @@ -#pragma once - -#include "Core/Core.h" - -#include "Core/public/OSAL/PlatformTypes.h" - -#ifndef MATH_FWD_H -#define MATH_FWD_H - -#include "Core/public/Misc/Boilerplate.h" - -/** - * Includes forward declarations, as well as certain useful typedefs. - * - * @ref OSAL/PlatformTypes.h - */ - - -namespace Phanes::Core::Math { - - /** - * Template forward declarations. - */ - - template struct TColor; - template struct TLinearColor; - template struct TVector2; - template struct TVector3; - template struct TVector4; - template struct TRay; - template struct TPlane; - template struct TMatrix2; - template struct TMatrix3; - template struct TMatrix4; - template struct TQuaternion; - template struct TTransform; - template struct TPoint2; - template struct TPoint3; - template struct TPoint4; - template struct TIntVector2; - template struct TIntVector3; - template struct TIntVector4; - template struct TIntPoint2; - template struct TIntPoint3; - template struct TIntPoint4; - - /** - * Specific instantiation of forward declarations. - */ - - // TVector2 - typedef TVector2 Vector2; - typedef TVector2 Vector2d; - - typedef std::vector Vector2List; - typedef std::vector Vector2Listd; - - // TVector3 - typedef TVector3 Vector3; - typedef TVector3 Vector3d; - - typedef std::vector Vector3List; - typedef std::vector Vector3Listd; - - - - // TIntVector2 - typedef TIntVector2 IntVector2; - typedef TIntVector2 IntVector2l; - - typedef std::vector IntVector2List; - typedef std::vector IntVector2Listl; - - // TIntVector3 - typedef TIntVector3 IntVector3; - typedef TIntVector3 IntVector3l; - - typedef std::vector IntVector3List; - typedef std::vector IntVector3Listl; - - - - // TMatrix2 - typedef TMatrix2 Matrix2; - typedef TMatrix2 Matrix2d; - - typedef std::vector Matrix2List; - typedef std::vector Matrix2Listd; - -} // Phanes::Core::Math::coretypes - -namespace Phanes::Core::Math::Internal -{ - - // Internal types - - template struct AVector; - - template struct AMatrix; -} - - -#endif // !MATH_FWD_H \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/MathTypeConversion.h b/Engine/src/Runtime/Core/public/Math/MathTypeConversion.h deleted file mode 100644 index f444f71..0000000 --- a/Engine/src/Runtime/Core/public/Math/MathTypeConversion.h +++ /dev/null @@ -1,77 +0,0 @@ -#pragma once - -// ============================================= // -// Function to convert types into each other // -// // -// @ref [FILE]MathUnitConversion // -// ============================================= // - -#include "PhanesEnginePCH.h" -#include "Core/public/Misc/Boilerplate.h" - -#include "Core/public/Math/MathAbstractTypes.h" -#include "Core/public/Math/Vector2.h" -#include "Core/public/Math/Vector3.h" -//#include "Core/public/Math/Vector4.h" -//#include "Core/public/Math/Matrix2.h" -//#include "Core/public/Math/Matrix3.h" -#include "Core/public/Math/IntVector2.h" -#include "Core/public/Math/IntVector3.h" - -#ifndef MATH_TYPE_CONVERSION_H -#define MATH_TYPE_CONVERSION_H - - -namespace Phanes::Core::Math { - - // =================================================== // - // std::to_string wrapper // - // // - // This is, to make using ToString more general // - // and allow usage of one function instead of two, // - // for converting a mathmatical type to a string. // - // =================================================== // - - FORCEINLINE std::string ToString(long long val) { return std::to_string(val); }; - - FORCEINLINE std::string ToString(double val) { return std::to_string(val); }; - - FORCEINLINE std::string ToString(float val) { return std::to_string(val); }; - - FORCEINLINE std::string ToString(int val) { return std::to_string(val); }; - - FORCEINLINE std::string ToString(long val) { return std::to_string(val); }; - - FORCEINLINE std::string ToString(long double val) { return std::to_string(val); }; - - FORCEINLINE std::string ToString(unsigned long long val) { return std::to_string(val); }; - - FORCEINLINE std::string ToString(unsigned int val) { return std::to_string(val); }; - - FORCEINLINE std::string ToString(unsigned long val) { return std::to_string(val); }; - - // ============ // - // ToString // - // ============ // - - template - std::string ToString(const TVector2& v); - - template - std::string ToString(const TIntVector2& v); - - template - std::string ToString(const TVector3& v); - - template - std::string ToString(const TIntVector3& v); - - //std::string toString(const Vector4& v); - - //std::string toString(const Matrix2& v); - - //std::string toString(const Matrix3& v); - -} - -#endif // !MATH_TYPE_CONVERSION_H \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/MathUnitConversion.h b/Engine/src/Runtime/Core/public/Math/MathUnitConversion.h deleted file mode 100644 index 6cab5b2..0000000 --- a/Engine/src/Runtime/Core/public/Math/MathUnitConversion.h +++ /dev/null @@ -1,121 +0,0 @@ -#pragma once - -// ======================================= // -// Contains functions to convert units // -// ======================================= // - -#include "Core/public/Misc/Boilerplate.h" - -#include "Core/public/Math/MathCommon.h" - -namespace Phanes::Core::Math::UnitConversion -{ - - /** - * Converts degrees to radians. - * - * @param(deg) Angle in degress (°) - * - * @return Angle in radians - */ - - template - inline T DegToRad(T deg); - - /** - * Converts radians to degrees. - * - * @param(rad) Angle in radians (rad) - * - * @return Angle in degrees - */ - - template - inline T RadToDeg(T rad); - - /** - * Converts degrees to gradian. - * - * @param(deg) Angle in degress (°) - * - * @return Angle in gradian - */ - - template - inline T DegToGradian(T deg); - - /** - * Converts gradian to degrees. - * - * @param(rad) Angle in gradians (g) - * - * @return Angle in degrees - */ - - template - inline T GradianToDeg(T g); - - /** - * Converts radians to gradians. - * - * @param(deg) Angle in radians (rad) - * - * @return Angle in gradians - */ - - template - inline T RadToGradian(T rad); - - /** - * Converts gradian to radians. - * - * @param(rad) Angle in gradians (g) - * - * @return Angle in radians - */ - - template - inline T GradianToRad(T g); - -} // phanes::core::math::typeconversion - - -namespace Phanes::Core::Math::UnitLiterals -{ - // ============================================== // - // unit conversion with user-defined literals // - // ============================================== // - - /** - * Convert deg to rad. - * - * @param(_x) Angle in degress - */ - - double operator ""_deg(long double _x) - { - return _x * P_PI_180_FLT; - } - - /** - * Convert rad to rad. - * - * @param(_x) Angle in degress - */ - - double operator ""_rad(long double _x) - { - return _x; - } - - /** - * Convert gradian to rad. - * - * @param(_x) Angle in degress - */ - - double operator ""_g(long double _x) - { - return _x * P_PI_FLT / 200; - } -} \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/Matrix2.h b/Engine/src/Runtime/Core/public/Math/Matrix2.h deleted file mode 100644 index 21a10a7..0000000 --- a/Engine/src/Runtime/Core/public/Math/Matrix2.h +++ /dev/null @@ -1,154 +0,0 @@ -#pragma once - -#include "Core/Core.h" -#include "Core/public/Misc/Boilerplate.h" - -#include "Core/public/Math/Vector2.h" - -#ifndef MATRIX2_H -#define MATRIX2_H - -namespace Phanes::Core::Math { - - // 2x2 Matrix defined in column-major order. - // Accessed by M[Row][Col]. - - template - struct alignas(4) TMatrix2 - { - public: - - alignas(4) T m[2][2]; - - public: - - TMatrix2() = default; - - /** - * Copy constructor. - */ - - TMatrix2(const TMatrix2& m); - - /** - * Move constructor. - */ - - TMatrix2(TMatrix2&& m); - - /** - * Construct Matrix from 2d array. - * - * @param(fields) 2D Array with column major order. - */ - - TMatrix2(T fields[2][2]); - - /** - * Construct Matrix from parameters. - * - * @param(n00) M[0][0] - * @param(n10) M[1][0] - * @param(n01) M[0][1] - * @param(n11) M[1][1] - * - * @note nXY = n[Row][Col] - */ - - TMatrix2(T n00, T n10, T n01, T n11); - - /** - * Construct Matrix from two 2d vector columns. - * - * @param(v1) Column zero - * @param(v2) Column one - */ - - TMatrix2(const TVector2& v1, const TVector2& v2); - - public: - - FORCEINLINE T& operator() (int n, int m); - FORCEINLINE TVector2& operator[] (int m); - - FORCEINLINE const T& operator() (int n, int m) const; - FORCEINLINE const TVector2& operator[] (int m) const; - }; - - // ==================== // - // Matrix2 operator // - // ==================== // - - template - void operator+= (TMatrix2& m1, T s); - - template - void operator+= (TMatrix2& m1, const TMatrix2& m2); - - template - void operator-= (TMatrix2& m1, T s); - - template - void operator-= (TMatrix2& m1, const TMatrix2& m2); - - template - void operator*= (TMatrix2& m1, T s); - - template - void operator*= (TMatrix2& m1, const TMatrix2& m2); - - template - TMatrix2 operator+ (const TMatrix2& m1, T s); - - template - TMatrix2 operator+ (const TMatrix2& m1, const TMatrix2& m2); - - template - TMatrix2 operator- (const TMatrix2& m1, T s); - - template - TMatrix2 operator- (const TMatrix2& m1, const TMatrix2& m2); - - template - TMatrix2 operator* (const TMatrix2& m1, T s); - - template - TMatrix2 operator* (const TMatrix2& m1, const TMatrix2& m2); - - template - TVector2 operator* (const TMatrix2& m1, const TVector2& v); - - template - bool operator== (const TMatrix2& m1, const TMatrix2& m2); - - - // =============================== // - // Matrix function definition // - // =============================== // - - template - T Determinant(const Matrix2& m1); - - template - void InverseV(TMatrix2& m1); - - template - void TransposeV(TMatrix2& m1); - - // =============== // - // WITH RETURN // - // =============== // - - template - TMatrix2 Inverse(TMatrix2& m1); - - template - TMatrix2 Transpose(const TMatrix2& m1); - - template - bool IsIndentityMatrix(const TMatrix2& m1, T threshold = P_FLT_INAC); - -} // Phanes::Core::Math - - -#endif // !MATRIX2_H \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/Matrix3.h b/Engine/src/Runtime/Core/public/Math/Matrix3.h deleted file mode 100644 index 8e5deac..0000000 --- a/Engine/src/Runtime/Core/public/Math/Matrix3.h +++ /dev/null @@ -1,105 +0,0 @@ -#pragma once - -#include "Misc/BoilerplateHeader.h" -#include PHANES_CORE_PCH_DEFAULT_PATH - -#include "Math/MathAbstractTypes.h" -#include "Math/Vector3.h" - -#ifndef MATRIX3_H -#define MATRIX3_H - -namespace phanes { - - namespace core { - - namespace math { - - namespace coretypes { - - // 3x3 Matrix defined in column-major order. - - struct Matrix3 : public phanes::core::math::abstract::coretypes::AMatrix - { - public: - - FORCEINLINE PHANES_CORE_API float& operator() (int n, int m); - FORCEINLINE PHANES_CORE_API Vector3& operator[] (int m); - - FORCEINLINE PHANES_CORE_API const float& operator() (int n, int m) const; - FORCEINLINE PHANES_CORE_API const Vector3& operator[] (int m) const; - - }; - - // List of Matrices for DoP and ECS - typedef std::vector Matrix3List; - - // Matrix3 constructor - PHANES_CORE_API Matrix3 createMatrix(float fields[3][3]); - - PHANES_CORE_API Matrix3 createMatrix(float f00, float f01, float f02, - float f10, float f11, float f12, - float f20, float f21, float f22); - - PHANES_CORE_API Matrix3 createMatrix(const Vector3& a, const Vector3& b, const Vector3& c); - - - // ==================== // - // Matrix3 operator // - // ==================== // - - PHANES_CORE_API void operator+= (Matrix3& a, float s); - PHANES_CORE_API void operator+= (Matrix3& a, const Matrix3& b); - - PHANES_CORE_API void operator-= (Matrix3& a, float s); - PHANES_CORE_API void operator-= (Matrix3& a, const Matrix3& b); - - PHANES_CORE_API void operator*= (Matrix3& a, float s); - PHANES_CORE_API void operator*= (Matrix3& a, const Matrix3& b); - - PHANES_CORE_API Matrix3 operator+ (const Matrix3& a, float s); - PHANES_CORE_API Matrix3 operator+ (const Matrix3& a, const Matrix3& b); - - PHANES_CORE_API Matrix3 operator- (const Matrix3& a, float s); - PHANES_CORE_API Matrix3 operator- (const Matrix3& a, const Matrix3& b); - - PHANES_CORE_API Matrix3 operator* (const Matrix3& a, float s); - PHANES_CORE_API Matrix3 operator* (const Matrix3& a, const Matrix3& b); - PHANES_CORE_API Vector3 operator* (const Matrix3& a, const Vector3& v); - - PHANES_CORE_API bool operator== (const Matrix3& a, const Matrix3& b); - - - - // =============================== // - // Matrix function definition // - // =============================== // - - PHANES_CORE_API float determinant(const Matrix3& a); - - - PHANES_CORE_API void inverseNR(Matrix3& a); - - PHANES_CORE_API void transposeNR(Matrix3& a); - - - // =============== // - // WITH RETURN // - // =============== // - - PHANES_CORE_API Matrix3 inverse(Matrix3& a); - - PHANES_CORE_API Matrix3 transpose(const Matrix3& a); - - PHANES_CORE_API bool isIndentityMatrix(const Matrix3& a); - - } // phanes::core::math::coretypes - - } // phanes::core::math - - } // phanes::core - -} // phanes - - -#endif // !MATRIX3_H diff --git a/Engine/src/Runtime/Core/public/Math/Matrix4.h b/Engine/src/Runtime/Core/public/Math/Matrix4.h deleted file mode 100644 index cfdec02..0000000 --- a/Engine/src/Runtime/Core/public/Math/Matrix4.h +++ /dev/null @@ -1,103 +0,0 @@ -#pragma once - -#include "Misc/BoilerplateHeader.h" -#include PHANES_CORE_PCH_DEFAULT_PATH - -#include "Math/MathAbstractTypes.h" -#include "Math/Vector4.h" - -#ifndef MATRIX4_H -#define MATRIX4_H - -namespace phanes { - - namespace core { - - namespace math { - - namespace coretypes { - - // 4x4 Matrix defined in column-major order. - - struct Matrix4 : public phanes::core::math::abstract::coretypes::AMatrix - { - public: - - FORCEINLINE PHANES_CORE_API float& operator() (int n, int m); - FORCEINLINE PHANES_CORE_API Vector4& operator[] (int m); - - FORCEINLINE PHANES_CORE_API const float& operator() (int n, int m) const; - FORCEINLINE PHANES_CORE_API const Vector4& operator[] (int m) const; - }; - - // List of Matrices for DoP and ECS - typedef std::vector Matrix4List; - - // Matrix4 constructor - PHANES_CORE_API Matrix4 createMatrix(float fields[4][4]); - - PHANES_CORE_API Matrix4 createMatrix(float f00, float f01, float f02, float f03, - float f10, float f11, float f12, float f13, - float f20, float f21, float f22, float f23, - float f30, float f31, float f32, float f33 - ); - - PHANES_CORE_API Matrix4 createMatrix(const Vector4& a, const Vector4& b, const Vector4& c, const Vector4& d); - - // ==================== // - // Matrix4 operator // - // ==================== // - - PHANES_CORE_API void operator+= (Matrix4& a, float s); - PHANES_CORE_API void operator+= (Matrix4& a, const Matrix4& b); - - PHANES_CORE_API void operator-= (Matrix4& a, float s); - PHANES_CORE_API void operator-= (Matrix4& a, const Matrix4& b); - - PHANES_CORE_API void operator*= (Matrix4& a, float s); - PHANES_CORE_API void operator*= (Matrix4& a, const Matrix4& b); - - PHANES_CORE_API Matrix4 operator+ (const Matrix4& a, float s); - PHANES_CORE_API Matrix4 operator+ (const Matrix4& a, const Matrix4& b); - - PHANES_CORE_API Matrix4 operator- (const Matrix4& a, float s); - PHANES_CORE_API Matrix4 operator- (const Matrix4& a, const Matrix4& b); - - PHANES_CORE_API Matrix4 operator* (const Matrix4& a, float s); - PHANES_CORE_API Matrix4 operator* (const Matrix4& a, const Matrix4& b); - PHANES_CORE_API Vector4 operator* (const Matrix4& a, const Vector4& v); - - PHANES_CORE_API bool operator== (const Matrix4& a, const Matrix4& b); - - - // ================================ // - // Matrix4 function definition // - // ================================ // - - PHANES_CORE_API float determinant(const Matrix4& a); - - PHANES_CORE_API void inverseNR(Matrix4& a); - - PHANES_CORE_API void transposeNR(Matrix4& a); - - // =============== // - // WITH RETURN // - // =============== // - - PHANES_CORE_API Matrix4 inverse(Matrix4& a); - - PHANES_CORE_API Matrix4 transpose(const Matrix4& a); - - PHANES_CORE_API bool isIndentityMatrix(const Matrix4& a); - - - } // phanes::core::math::coretypes - - } // phanes::core::math - - } // phanes::core - -} // phanes - - -#endif // !MATRIX4_H \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/Plane.h b/Engine/src/Runtime/Core/public/Math/Plane.h deleted file mode 100644 index be790bd..0000000 --- a/Engine/src/Runtime/Core/public/Math/Plane.h +++ /dev/null @@ -1,23 +0,0 @@ -#pragma once - -#include "Core/public/Misc/Boilerplate.h" - -#include "Core/public/Math/Vector3.h" - -#include "Core/public/Math/MathFwd.h" - -namespace Phanes::Core::Math { - - // Plane in 3D space, defined as: P: ax + by + cz = d; - - template - struct TPlane - { - public: - TVector3 normal; - T d; - }; - -} // Phanes::Core::Math - - \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/Point.h b/Engine/src/Runtime/Core/public/Math/Point.h deleted file mode 100644 index 58a6397..0000000 --- a/Engine/src/Runtime/Core/public/Math/Point.h +++ /dev/null @@ -1,184 +0,0 @@ -#pragma once - -#include "Core/public/Misc/Boilerplate.h" - -#include "Core/public/Math/MathCommon.h" -#include "Core/public/Math/MathAbstractTypes.h" -#include "Core/public/Math/MathFwd.h" - -#ifndef P_DEBUG -#pragma warning(disable : 4244) -#endif - -/** - * The Point is the same as a vector. The type exists, to ensure - * differentiation between the two types. - */ - -#ifndef POINT_H -#define POINT_H - -namespace Phanes::Core::Math { - - /** - * A 2D Point with components x and y with float precision. - */ - - template - struct TPoint2 : public TVector2 { - static_assert(std::is_floating_point_v, "T must be a floating point"); - - using TVector2::TVector2; - - using Real = T; - - /** - * Creates Point2 from Point3's xy - * - * @param a Point3 one - */ - - TPoint2(const TPoint3& p) - { - this->x = p.x; - this->y = p.y; - } - - /** - * Creates Point2 from Point4's xy - * - * @param a Point4 one - */ - - TPoint2(const TPoint4& p) - { - this->x = p.x; - this->y = p.y; - } - }; - - /** - * Calculates distance between two points. - * - * @param(p1) Point one - * @param(p2) Point two - * - * @return Distance between two points. - */ - - template - T Distance(const TPoint2& p1, const TPoint2& p2); - - /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - - - /** - * A 3D Point with components x and y with float precision. - */ - - - template - struct TPoint3 : public TVector3 { - static_assert(std::is_floating_point_v(T), "T must be a floating point"); - - using TVector3::TVector3; - - using Real = T; - - /** - * Creates Point3 from Point2's xy and zero - * - * @param a Point2 one - */ - - TPoint3(const TPoint2& p) - { - this->x = p.x; - this->y = p.y; - this->z = 0; - } - - /** - * Creates Point3 from Point4's xyz - * - * @param a Point4 one - */ - - TPoint3(const TPoint4& p) - { - this->x = p.x; - this->y = p.y; - this->z = p.z; - } - }; - - /** - * Calculates distance between two points. - * - * @param(p1) Point one - * @param(p2) Point two - * - * @return Distance between two points. - */ - - template - T Distance(const TPoint3& p1, const TPoint3& p2); - - /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// - - - /** - * A 4D Point with components x and y with float precision. - */ - - - //template - //struct TPoint4 : public TVector4 { - // static_assert(std::is_floating_point_v(T), "T must be a floating point"); - - // using TVector4::TVector4; - - // /** - // * Creates Point4 from Point2's xy and the last two zero - // * - // * @param a Point2 one - // */ - - // TPoint4(const TPoint2& p) - // { - // this->x = p.x; - // this->y = p.y; - // this->z = 0; - // this->w = 0; - // } - - // /** - // * Creates Point4 from Point3's xyz and zero - // * - // * @param a Point3 one - // */ - - // TPoint4(const TPoint3& p) - // { - // this->x = p.x; - // this->y = p.y; - // this->z = p.z; - // this->w = 0; - // } - //}; - - ///** - // * Calculates distance between two points. - // * - // * @param(p1) Point one - // * @param(p2) Point two - // * - // * @return Distance between two points. - // */ - - //template - //T Distance(const TPoint4& p1, const TPoint4& p2); - -} // phanes::core::math::coretypes - -#endif // !POINT_H \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/README.md b/Engine/src/Runtime/Core/public/Math/README.md deleted file mode 100644 index ccb30e1..0000000 --- a/Engine/src/Runtime/Core/public/Math/README.md +++ /dev/null @@ -1,12 +0,0 @@ -# PhanesCore - -## Math - -### Description - -Math lib. - - -### Notes - -- Normals are called normals for a reason. \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/Vector2.h b/Engine/src/Runtime/Core/public/Math/Vector2.h deleted file mode 100644 index 06c25c2..0000000 --- a/Engine/src/Runtime/Core/public/Math/Vector2.h +++ /dev/null @@ -1,934 +0,0 @@ -#pragma once - -#include "Core/Core.h" -#include "Core/public/Misc/Boilerplate.h" - -#include "Core/public/Math/MathCommon.h" -#include "Core/public/Math/MathAbstractTypes.h" -#include "Core/public/Math/MathFwd.h" - -#ifndef P_DEBUG -#pragma warning(disable : 4244) -#endif - -#ifndef VECTOR2_H -#define VECTOR2_H - -#define PZeroVector2(type) TVector2<##type>(0,0) -#define PVectorSouth2(type) TVector2<##type>(0,-1) -#define PVectorNorth2(type) TVector2<##type>(0,1) -#define PVectorEast2(type) TVector2<##type>(1,0) -#define PVectorWest2(type) TVector2<##type>(-1,0) - - -namespace Phanes::Core::Math { - - /** - * A 2D Vector with components x and y with floating point precision. - */ - - - template - struct TVector2 { - - public: - - using Real = T; - - // Using in combination with a struct and an array allows us the reflect changes of the x and y variables in the comp array and vise versa. - - union - { - - struct - { - /** X component of Vector - * - * @see [FIELD]components - * @note x does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. - */ - Real x; - - /** Y component of Vector - * - * @see [FIELD]components - * - * @note y does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. - */ - Real y; - }; - - /** Components array holding the data - * - * @see [FIELD]x - * @see [FIELD]y - * - * @note Components are split into x and y. Access and manipulation is possible by these variables. - */ - - Real comp[2]; - - }; - - - - - public: - - /** - * Default constructor without initialization - */ - - TVector2() = default; - - /** - * Copy constructor - */ - - TVector2(const TVector2& v); - - /** - * Move constructor - */ - - TVector2(TVector2&& v); - - /** - * Convert other type of vector - */ - - template - explicit TVector2(const TVector2& v) : x((T)v.x), y((T)v.y) {}; - - - template - explicit TVector2(const TIntVector2& v) : x((T)v.x), y((T)v.y) {}; - - /** - * Construct Vector from xy components. - * - * @param(x) X component - * @param(y) Y component - */ - - TVector2(const Real x, const Real y); - - /** - * Construct Vector from two component array. - * - * @param(comp) Array of components - */ - - explicit TVector2(const Real* comp); - - - /** - * Constructs a vector pointing from start to end. - * - * @param(start) Startingpoint - * @param(end) Endpoint - */ - - TVector2(const TPoint2& start, const TPoint2& end); - - /** - * Construct Vector from 3D Vector's xy. - * - * @param(v) 3D Vector to copy from - */ - - explicit TVector2(const TVector3& v); - - /** - * Construct Vector from 4D Vector's xy. - * - * @param(v) 4D Vector to copy from - */ - - //TVector2(const TVector4& v); - - /** - * Construct Vector from 2D integer Vector's xy. - * - * @param(v) 2D IntVector to copy from - */ - - //TVector2(const TIntVector2& v); - - /** - * Construct Vector from 3D integer Vector's xy. - * - * @param(v) 3D IntVector to copy from - */ - - //TVector2(const TIntVector3& v); - - /** - * Construct Vector from 4D integer Vector's xy. - * - * @param(v) 4D IntVector to copy from - */ - - //TVector2(const TIntVector4& v); - - /** - * Construct Vector from 2D Point's xy. - * - * @param(v) 2D Point to copy from - */ - - //TVector2(const TPoint2& v); - - - }; - - // ====================== // - // TVector2 operators // - // ====================== // - - /** - * Addition operation on same TVector2 (this) by a floating point value. - * - * @param(v1) Vector to add to - * @param(s) Floating point to add - */ - - template - TVector2 operator+= (TVector2& v1, T s); - - /** - * Addition operation on same TVector2 (this) by a another TVector2. - * - * @param(v1) Vector to add to - * @param(v2) Vector to add - */ - - template - TVector2 operator+= (TVector2& v1, const TVector2& v2); - - /** - * Substraction operation on same TVector2 (this) by a floating point. - * - * @param(v1) Vector to substract from - * @param(v2) Floating point to substract - */ - - template - TVector2 operator-= (TVector2& v1, T s); - - /** - * Substraction operation on same TVector2 (this) by a another TVector2. - * - * @param(v1) Vector to substract from - * @param(v2) Vector to substract - */ - - template - TVector2 operator-= (TVector2& v1, const TVector2& v2); - - /** - * Multiplication of TVector2 (this) with a floating point. - * - * @param(v1) Vector to multiply with - * @param(s Floating point to multiply with - */ - - template - TVector2 operator*= (TVector2& v1, T s); - - /** - * Devision of Vector (this) by floating point. - * - * @param(v1) Vector to divide with - * @param(s Floating point to divide with - */ - - template - TVector2 operator/= (TVector2& v1, T s); - - /** - * Scale of Vector by floating point. (> Creates a new TVector2) - * - * @param(v1) Vector to multiply with - * @param(s Floating point to multiply with - * - * @return Result Vector - */ - - template - TVector2 operator* (const TVector2& v1, T s); - - /** - * Division of Vector by floating point. (> Creates another TVector2) - * - * @param(v1) Vector to multiply with - * @param(s Floating point to divide with - * - * @return Result Vector - */ - - template - TVector2 operator/ (const TVector2& v1, T s); - - /** - * Scale of Vector by floating point. (> Creates a new TVector2) - * - * @param(v1) Vector to multiply with - * @param(s Floating point to multiply with - * - * @return Result Vector - */ - - template - inline TVector2 operator* (T s, const TVector2& v1); - - /** - * Division of Vector by floating point. (> For convenience not arithmethicaly correct. Works like overloaded counterpart.) - * - * @param(v1) Vector to multiply with - * @param(s Floating point to divide with - * - * @return Result Vector - */ - - template - inline TVector2 operator/ (T s, const TVector2& v1); - - /** - * Dot product between two Vectors. - * - * @see [FUNC]DotP - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @result Dot product - */ - - template - T operator* (const TVector2& v1, const TVector2& v2); - - /** - * Componentwise addition of Vector with floating point. - * - * @param(v1) Vector to add to - * @param(s Floating point to add - * - * @return Result Vector - */ - - template - TVector2 operator+ (const TVector2& v1, T s); - - /** - * Componentwise addition of Vector with floating point. - * - * @param(v1) Vector to add to - * @param(s Floating point to add - * - * @return Result Vector - */ - - template - TVector2 operator+ (const TVector2& v1, const TVector2& v2); - - /** - * Componentwise substraction of Vector with floating point. - * - * @param(v1) Vector to substract from - * @param(s Floating point to substract - * - * @return Result Vector - */ - - template - TVector2 operator- (const TVector2& v1, T s); - - /** - * Componentwise substraction of Vector with Vector. - * - * @param(v1) Vector to substract from - * @param(s Floating point to substract - * - * @return Result Vector - */ - - template - TVector2 operator- (const TVector2& v1, const TVector2& v2); - - /** - * Negate Vector. - * - * @param(v1) Vector to negate - */ - - template - void operator- (TVector2& v1); - - - /** - * Compare Vector for equality. - * - * @see [FUNC]Equals - * - * @param(v1) Vector to negate - * - * @return true if equal, false if inequal - */ - - template - bool operator== (const TVector2& v1, const TVector2& v2); - - - /** - * Compare Vector for inequality. - * - * @see [FUNC]Equals - * - * @param(v1) Vector to negate - * - * @return true if inequal, false if equal - */ - - template - bool operator!= (const TVector2& v1, const TVector2& v2); - - - // ============================================ // - // TVector2 static function implementation // - // ============================================ // - - /** - * Magnitude of Vector - * - * @param(v1) Vector - * - * @return Size of Vector - */ - - template - T Magnitude(const TVector2& v1); - - /** - * @see [FUNC]Magnitude - */ - template - FORCEINLINE T Length(const TVector2& v1) { return Magnitude(v1); }; - - /** - * Square of magnitude of Vector - * - * @param(v1) Vector - * - * @return Magnitude without calculating square root - */ - - template - T SqrMagnitude(const TVector2& v1); - - /** - * @see [FUNC]SqrMagnitude - */ - template - FORCEINLINE T SqrLength(const TVector2& v1) { return SqrMagnitude(v1); }; - - /** - * Normalize Vector - * - * @param(v1) Vector - */ - - template - TVector2 NormalizeV(TVector2& v1); - - /** - * Normalize Vector - * - * @param(v1) Vector - * - * @note Does not look for zero vector. - */ - - template - TVector2 UnsafeNormalizeV(TVector2& v1); - - /** - * Angle between to Vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - */ - - template - T Angle(const TVector2& v1, const TVector2& v2); - - /** - * Cosine of angle between to Vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - */ - - template - T CosineAngle(const TVector2& v1, const TVector2& v2); - - /** - * Returns signs of components in vector: -1 / +1 / 0. - * - * @param(v1) Vector one - */ - - template - TVector2 SignVectorV(TVector2& v1); - - /** - * Binds a vector to a square with a radius - * - * @param(v1) Vector one - * @param(radius) Radius of square (=> Distance from middle to center of each site.) - */ - - template - TVector2 BindToSquareV(TVector2& v1, T radius); - - /** - * Clamps a vector to a square with a radius - * - * @param(v1) Vector one - * @param(radius) Radius of square (=> Distance from middle to center of each site.) - */ - - template - TVector2 ClampToSquareV(TVector2& v1, T radius); - - /** - * Dot product of two Vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - */ - - template - T DotP(const TVector2& v1, const TVector2& v2); - - /** - * Creates Vector, with component wise largest values. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @note Stores new Vector to v1 - */ - - template - TVector2 MaxV (TVector2& v1, const TVector2& v2); - - /** - * Creates Vector, with component wise smallest values. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @note Stores new Vector to v1 - */ - - template - TVector2 MinV (TVector2& v1, const TVector2& v2); - - /** - * Gets perpendicular Vector to v1. - * - * @param(v1) Vector one - * - * @note Stores new Vector to v1 - */ - - template - TVector2 GetPerpendicularV (TVector2& v1); - - /** - * Gets perpendicular Vector to v1. - * - * @reg [FUNC]PerpendicularV - * - * @param(v1) Vector one - * - * @note Stores new Vector to v1 - */ - - template - TVector2 GetReversePerpendicularV (TVector2& v1); - - /** - * Component wise multiplication of Vector - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @note Stores new Vector to v1 - */ - - template - TVector2 ScaleV(TVector2& v1, const TVector2& v2); - - /** - * Componentwise inverse of Vector - * - * @param(v1) Vector one - * - * @note Stores new Vector to v1 - */ - - template - TVector2 CompInverseV(TVector2& v1); - - /** - * Reflect Vector by normal vector. - * - * @param(v1) Vector one - * @param(normal) Normal of surface - * - * @note Stores new Vector to v1 - */ - - template - TVector2 ReflectV (TVector2& v1, const TVector2& normal); - - /** - * Copies one Vector two another - * - * @param(v1) Vector to copy to - * @param(v2) Vector to copy - */ - - template - TVector2 Set(TVector2& v1, const TVector2& v2); - - /** - * Sets components of a vector. - * - * @param(v1) Vector to copy to - * @param(v2) Vector to copy - */ - - template - TVector2 Set(TVector2& v1, T x, T y); - - /** - * Anti-clockwise vector rotation. - * - * @param(v1) Vector to rotate - * - * @note Angle is not clamped - */ - - template - TVector2 RotateV(TVector2& v1, T angle); - - - /** - * Clockwise vector rotation. - * - * @param(v1) Vector to rotate - * - * @note Angle is not clamped - */ - - template - FORCEINLINE TVector2 ClockwiseRotateV(TVector2& v1, T angle); - - /** - * Negates Vector - * - * @param(v1) Vector one - */ - - template - TVector2 NegateV(TVector2& v1); - - /** - * Tests if vector is a unity vector. - * - * @param(v1) Vector one - * @param(threshold) Threshold to zero - * - * @return true if unit vector, false if not - */ - - template - inline bool IsNormalized(const TVector2& v1, T threshold = P_FLT_INAC); - - /** - * Tests if 2 vectors are perpendicular to each other. - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(threshold) Threshold to zero - * - * @return true if perpendicular, false if not - * - * @note Requires v1 and v2 to be normal vectors. - */ - - template - inline bool IsPerpendicular(const TVector2& v1, const TVector2& v2, T threshold = P_FLT_INAC); - - /** - * Tests if 2 vectors are parallel to each other. (Angle is close to zero.) - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(t) threshold Threshold from one (e.g. 0.98f) - * - * @return true if parallel, false if not - * - * @note Requires v1 and v2 to be normal vectors. - */ - - template - inline bool IsParallel(const TVector2& v1, const TVector2& v2, T threshold = 1.0f - P_FLT_INAC); - - /** - * Tests if 2 vectors are coincident. (Are parallel and point in the same direction.) - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(threshold) from one (e.g. 0.98f) - * - * @return true if coincident, false if not - * - * @note Requires v1 and v2 to be normal vectors. - */ - - template - inline bool IsCoincident(const TVector2& v1, const TVector2& v2, T threshold = 1.0f - P_FLT_INAC); - - /** - * Gets outer product of to vectors. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Resulting matrix - */ - - // - //Matrix2 OuterProduct(const TVector2& v1, const TVector2& v2); - - - // ============================================================== // - // TVector2 static function implementation with return values // - // ============================================================== // - - - /** - * Reflects a vector on a normal - * - * @param(v1) Vector one - * @param(normal) Normal of surface - * - * @return Reflected vector - */ - - template - TVector2 Reflect(const TVector2& v1, const TVector2& normal); - - /** - * Scales a vector component wise - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Reflected vector - */ - - template - TVector2 Scale(const TVector2& v1, const TVector2& v2); - - /** - * Componentwise inverse of a vector - * - * @param(v1) Vector one - * - * @return Componentwise inverted vector - */ - - template - TVector2 CompInverse(const TVector2& v1); - - - /** - * Negates Vector - * - * @param(v1) Vector one - * - * @return Componentwise inverted vector - */ - - template - TVector2 Negate(const TVector2& v1); - - /** - * Gets the perpendicular vector of v1 - * - * @param(v1) Vector one - * - * @return Perpendicular vector - */ - - template - TVector2 GetPerpendicular(const TVector2& v1); - - /** - * Gets reverse of the perpendicular vector of v1 - * - * @param(v1) Vector one - * - * @return Reversed perpendicular vector - */ - - template - TVector2 GetReversePerpendicular(const TVector2& v1); - - /** - * Creates a new Vector by the component wise minimals of both vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Minimal vector - */ - - template - TVector2 Min(const TVector2& v1, const TVector2& v2); - - /** - * Creates a new Vector by the component wise maxima of both vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Maximal vector - */ - - template - TVector2 Max(const TVector2& v1, const TVector2& v2); - - /** - * Creates a normalized instance of the vector - * - * @param(v1) Vector to normalize - * - * @return Unit vector - */ - - template - TVector2 Normalize(const TVector2& v1); - - /** - * Creates a normalized instance of the vector - * - * @param(v1) Vector to normalize - * - * @return Unit vector - * @note Does not test for zero vector - */ - - template - TVector2 UnsafeNormalize(const TVector2& v1); - - /** - * Returns signs of components in vector: -1 / +1 / 0. - * - * @param(v1) Vector one - * - * @return Vector with signs as components - */ - - template - TVector2 SignVector(const TVector2& v1); - - /** - * Binds a vector to a square with a radius - * - * @param(v1) Vector one - * @param(radius) Radius of square (=> Distance from middle to center of each site.) - * - * @return Bound vector - */ - - template - TVector2 BindToSquare(const TVector2& v1, T radius); - - /** - * Clamps a vector to a square with a radius - * - * @param(v1) Vector one - * @param(radius) Radius of square (=> Distance from middle to center of each site.) - * - * @return Clamped vector. If the length of the vector fits the square, then the vector is returned. - */ - - template - TVector2 ClampToSquare(const TVector2& v1, T radius); - - /** - * Interpolates between to vectors. - * - * @param(startVec) Start vector (t = 0) - * @param(destVec) Destination vector (t = 1) - * @param(t) Interpolation value - * - * @return Interpolated vector - * - * @note Interpolation is clamped between 0 - 1. - */ - - template - TVector2 Lerp(const TVector2& startVec, const TVector2& destVec, T t); - - /** - * Interpolates between to vectors. - * - * @param(startVec) Start vector (t = 0) - * @param(destVec) Destination vector (t = 1) - * @param(t) Interpolation value - * - * @return Interpolated vector - * - * @note Interpolation is not clamped. Make shure t is between 0.0f and 1.0f - */ - - template - TVector2 LerpUnclamped(const TVector2& startVec, const TVector2& destVec, T t); - - /** - * Anti-clockwise vector rotation. - * - * @param(v1) Vector to rotate - * @param(angle) Angle to rotate - * - * @return Rotated vector - * - * @note Angle is not clamped - */ - - template - TVector2 Rotate(const TVector2& v1, T angle); - - /** - * Clockwise vector rotation. - * - * @param(v1) Vector to rotate - * - * @return Rotated vector - * - * @note Angle is not clamped - */ - - template - TVector2 ClockwiseRotate(const TVector2& v1, T angle); - -} // phanes::core::math::coretypes - -#endif // !VECTOR2_H \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/Vector3.h b/Engine/src/Runtime/Core/public/Math/Vector3.h deleted file mode 100644 index aea16e0..0000000 --- a/Engine/src/Runtime/Core/public/Math/Vector3.h +++ /dev/null @@ -1,1191 +0,0 @@ -#pragma once - - -// TODO: BoundToCube -// TODO: ClampToCube -// TODO: Slerp (using Quaternions) - -#include "Core/Core.h" -#include "Core/public/Misc/Boilerplate.h" - -#include "Core/public/Math/MathCommon.h" -#include "Core/public/Math/MathAbstractTypes.h" -#include "Core/public/Math/MathFwd.h" - -#ifndef P_DEBUG -#pragma warning(disable : 4244) -#endif - -#ifndef VECTOR3_H -#define VECTOR3_H - -#define PZeroVector3(type) TVector3<##type>(0,0,0) -#define PVectorForward3(type) TVector3<##type>(1,0,0) -#define PVectorBackward3(type) TVector3<##type>(-1,0,0) -#define PVectorEast3(type) TVector3<##type>(0,1,0) -#define PVectorWest3(type) TVector3<##type>(0,-1,0) -#define PVectorUp3(type) TVector3<##type>(0,0,1) -#define PVectorDown3(type) TVector3<##type>(0,0,-1) - -namespace Phanes::Core::Math { - - - // Basic 3D vector (x, y, z) - - template - struct TVector3 { - public: - - using Real = T; - - union - { - struct - { - - /** X component of vector - * - * @ref [FIELD]components - * @note x does not hold the component, but is v1 reference two the second item in the components array. The varibale exists wholly for convenience. - */ - Real x; - - /** Y component of vector - * - * @ref [FIELD]components - * - * @note y does not hold the component, but is v1 reference two the second item in the components array. The varibale exists wholly for convenience. - */ - Real y; - - /** Z component of vector - * - * @ref [FIELD]components - * - * @note Z does not hold the component, but is v1 reference two the second item in the components array. The varibale exists wholly for convenience. - */ - Real z; - - }; - - /** Components array holding the data - * - * @ref [FIELD]x - * @ref [FIELD]y - * @ref [FIELD]z - * - * @note Components are split into x, y and z. Access and manipulation is possible by these variables. - */ - - Real comp[3]; - }; - - public: - - /** - * Default contructor without initialization - */ - - TVector3() = default; - - - /** - * Copy contructor - */ - - TVector3(const TVector3& v); - - - /** - * Move contructor - */ - - TVector3(TVector3&& v); - - /** - * Convert other type of vector - */ - - template - explicit TVector3(const TVector3& v) : x((T)v.x), y((T)v.y) {}; - - - template - explicit TVector3(const TIntVector3& v) : x((T)v.x), y((T)v.y) {}; - - /** - * Construct vector from xy components. - * - * @param x X component - * @param y Y component - * @param z Z component - */ - - TVector3(const Real x, const Real y, const Real z); - - - /** - * Contructor vector from two component array - * - * @param comp Array of components - */ - - TVector3(const Real* comp); - - /** - * Constructs a vector pointing from start to end. - * - * @param(start) Startingpoint - * @param(end) Endpoint - */ - - TVector3(const TPoint3& start, const TPoint3& end); - - }; - - - - - // ====================== // - // TVector3 operators // - // ====================== // - - /** - * Coponentwise addition of floating point to 3D vector - * - * @param(v1) vector to add to - * @param(s) floating point to add - */ - - template - inline TVector3 operator+= (TVector3& v1, T s); - - /** - * Coponentwise addition of 3D vector to 3D vector - * - * @param(v1) vector to add to - * @param(v2) vector to add - */ - - template - inline TVector3 operator+= (TVector3& v1, const TVector3& v2); - - /** - * Coponentwise substraction of floating point of 3D vector - * - * @param(v1) vector to substract from - * @param(s) floating point to substract - */ - - template - inline TVector3 operator-= (TVector3& v1, T s); - - /** - * Coponentwise substraction of 3D vector to 3D vector - * - * @param(v1) vector to substract from - * @param(v2) vector to substract with - */ - - template - inline TVector3 operator-= (TVector3& v1, const TVector3& v2); - - /** - * Dot product between two 3D Vectors - * - * @param(v1) vector one - * @param(s) floating point - */ - - template - inline TVector3 operator*= (TVector3& v1, T s); - - /** - * Coponentwise division of 3D vector with floating point - * - * @param(v1) vector divide - * @param(s) floating point to divide with - */ - - template - inline TVector3 operator/= (TVector3& v1, T s); - - /** - * Coponentwise multiplication of 3D Vectors with floating point - * - * @param(v1) vector one - * @param(s) floating point - * - * @return Resulting vector - */ - - template - TVector3 operator* (const TVector3& v1, T s); - - /** - * Coponentwise division of 3D Vectors with floating point - * - * @param(v1) vector one - * @param(s) floating point - * - * @return Resulting vector - */ - - template - TVector3 operator/ (const TVector3& v1, T s); - - /** - * Coponentwise multiplication of 3D Vectors with floating point - * - * @param(s) floating point - * @param(v2) vector - * - * @return Resultion vector - */ - - template - inline TVector3 operator* (T s, const TVector3& v1); - - /** - * Coponentwise multiplication of 3D Vectors with floating point - * - * @param(s) floating point - * @param(v1) vector - * - * @return Resultion vector - */ - - template - inline TVector3 operator/ (T s, const TVector3& v1); - - /** - * Dot product between two 3D Vectors - * - * @param(v1) vector one - * @param(v2) vector two - * - * @return Dot product of Vectors - */ - - template - T operator* (const TVector3& v1, const TVector3& v2); - - /** - * Coponentwise addition of floating point to 3D vector - * - * @param(v1) vector to add to - * @param(s) floating point to add - * - * @return Resulting vector - */ - - template - TVector3 operator+ (const TVector3& v1, T s); - - /** - * Coponentwise addition of 3D vector to 3D vector - * - * @param(v1) vector to add to - * @param(v2) vector to add - * - * @return Resulting vector - */ - - template - TVector3 operator+ (const TVector3& v1, const TVector3& v2); - - /** - * Coponentwise substraction of floating point of 3D vector - * - * @param(v1) vector to substract from - * @param(s) floating point to substract - * - * @return Resulting vector - */ - - template - TVector3 operator- (const TVector3& v1, T s); - - /** - * Coponentwise substraction of floating point of 3D vector - * - * @param(v1) vector to substract from - * @param(v2) vector to substract with - * - * @return Resulting vector - */ - - template - TVector3 operator- (const TVector3& v1, const TVector3& v2); - - /** - * Negates vector - * - * @param(v1) Vector to negate - */ - - template - TVector3 operator- (TVector3& v1); - - /** - * Tests two 3D vectors for equality. - * - * @ref [FUNC]Equals - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return True if equal, false if not. - * - * @note Uses [MACRO]P_FLT_INAC - */ - - template - inline bool operator== (const TVector3& v1, const TVector3& v2); - - /** - * Tests two 3D vectors for inequality. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return True if inequal, false if not. - */ - - template - inline bool operator!= (const TVector3& v1, const TVector3& v2); - - - // ==================================== // - // TVector3 function implementation // - // ==================================== // - - /** - * Gets magnitude of vector - * - * @param(v1) Vector - * - * @return Magnitude of vector - */ - - template - inline T Magnitude(const TVector3& v1); - - /** - * @see [FUNC]Magnitude - */ - - template - FORCEINLINE T Length(const TVector3& v1) { return Magnitude(v1); }; - - /** - * Gets square magnitude of vector - * - * @param(v1) Vector - * - * @return Square magnitude of vector - */ - - template - inline T SqrMagnitude(const TVector3& v1); - - /** - * @see SqrMagnitude - */ - - template - FORCEINLINE T SqrLength(const TVector3& v1); - - /** - * Normalizes vector - * - * @param(v1) Vector - * - * @note Result is stored in v1 - */ - - template - TVector3 NormalizeV(TVector3& v1); - - /** - * Normalizes vector - * - * @param(v1) Vector - * - * @note Does not test for zero vector - */ - - template - TVector3 UnsafeNormalizeV(TVector3& v1); - - /** - * Reflects a vector on a surface - * - * @param(v1) Vector one - * @param(normal) Normal of surface - */ - - template - TVector3 ReflectV(TVector3& v1, const TVector3& normal); - - /** - * Gets angle between two vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Angle between vectors - */ - - template - T Angle(const TVector3& v1, const TVector3& v2); - - /** - * Dot product of two vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Dot product of vectors - */ - - template - T DotP(const TVector3& v1, const TVector3& v2); - - /** - * Orthogonalizes three vectors. - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(v3) Vector two - */ - - template - void Orthogonalize(TVector3& v1, TVector3& v2, TVector3& v3); - - /** - * Orthogonalizes three vectors and turns them into unit vectors. Usefull for making sure coordinate axis are still orthogonal. - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(v3) Vector two - * - * @note Usefull for making sure coordinate axis are still orthogonal. - */ - - template - void OrthoNormalize(TVector3& v1, TVector3& v2, TVector3& v3); - - /** - * Returns signs of components in vector: -1 / +1 / 0. - * - * @param(v1) Vector one - * - * @return Vector with signs a components. - */ - - template - TVector3 SignVector(const TVector3& v1); - - /** - * Tests two vectors for equality. - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(threshold) Allowed T inaccuracy. - * - * @return True if equal, false if not. - */ - - template - inline bool Equals(const TVector3& v1, const TVector3& v2, T threshold = P_FLT_INAC); - - /** - * Performs perspective divide on vector. - * - * @param(v1) Vector - */ - - template - TVector3 PerspectiveDivideV(TVector3& v1); - - /** - * Calculates the cross product between two vectors. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @note result is stored in v1. - */ - - template - TVector3 CrossPV(TVector3& v1, const TVector3& v2); - - /** - * Gets the componentwise max of both vectors. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @note result is stored in v1. - */ - - template - TVector3 MaxV(TVector3& v1, const TVector3& v2); - - /** - * Gets the componentwise min of both vectors. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @note result is stored in v1. - */ - - template - TVector3 MinV(TVector3& v1, const TVector3& v2); - - /** - * Gets reversed vector. - * - * @param(v1) Vector one - * - * @note result is stored in v1. - */ - - template - TVector3 NegateV(TVector3& v1); - - /** - * Performes componentwise multiplication of two vectors. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @note result is stored in v1. - */ - - template - TVector3 ScaleV(TVector3& v1, const TVector3& v2); - - /** - * Projects vector v1 onto v2 - * - * @param(v1) Vector to project - * @param(v2) Vector to project on - * - * @note result is stored in v1. - */ - - template - TVector3 ProjectV(TVector3& v1, const TVector3& v2); - - /** - * Rejects vector v1 from v2 - * - * @param(v1) Vector to reject - * @param(v2) Vector to reject from - * - * @note result is stored in v1. - */ - - template - TVector3 RejectV(TVector3& v1, const TVector3& v2); - - /** - * Projects vector onto plane - * - * @param(v1) Vector to reject - * @param(normal) Normal of the plane - * - * @note result is stored in v1. - * @note Simply rejects v1 from normal - */ - - template - FORCEINLINE TVector3 ProjectOntoPlaneV(TVector3& v1, const TVector3& normal); - - /** - * Projects vector onto plane - * - * @param(v1) Vector to reject - * @param(normal) Plane - * - * @note result is stored in v1. - * @note Simply rejects v1 from normal - */ - - template - FORCEINLINE TVector3 ProjectOntoPlaneV(TVector3& v1, const TPlane& plane); - - /** - * Copies v1 vector - * - * @param(v1) Vector to copy to - * @param(v2) Vector to copy - */ - - template - TVector3 Set(TVector3& v1, const TVector3& v2); - - /** - * Sets vector. - * - * @param(v1) Vector to copy to - * @param(x) X component - * @param(y) Y component - * @param(z) Z component - */ - - template - TVector3 Set(TVector3& v1, T x, T y, T z); - - /** - * Clamps vector to a range of magnitudes. - * - * @param(v1) Vector to clamp - * @param(min) Min magnitude - * @param(max) Max magnitude - * - * @note Result is stored in v1 - */ - - template - TVector3 ClampMagnitudeV(TVector3& v1, T min, T max); - - /** - * Inverts the components of vector. - * - * @param(v1) Vector - * - * @note Result is stored in v1 - */ - - template - TVector3 CompInverseV(TVector3& v1); - - /** - * Binds vector into cube. - * - * @param(v1) Vector to clamp - * @param(cubeRadius) Radius of the cube - * - * @note result is stored in v1. - */ - - template - TVector3 BoundToCubeV(TVector3 v1, T cubeRadius) {}; - - /** - * Clamps vector into cube. - * - * @param(v1) Vector to clamp - * @param(cubeRadius) Radius of the cube - * - * @note result is stored in v1. - */ - - template - TVector3 ClampToCubeV(TVector3 v1, T cubeRadius) {}; - - /** - * Reflect by plane - * - * @param(v1) Vector to mirror - * @param(plane) Plane to mirror on - * - * @note result is stored in v1. - */ - - template - FORCEINLINE TVector3 ReflectFromPlaneV(TVector3& v1, const TPlane& plane); - - /** - * Reflect by plane - * - * @param(v1) Vector to mirror - * @param(plane) Plane to mirror on - * - * @note result is stored in v1. - */ - - template - FORCEINLINE TVector3 ReflectFromPlaneV(TVector3& v1, const TVector3& normal); - - /** - * Rotates vector around axis - * - * @param(v1) Vector to mirror - * @param(axisNormal) Axis to rotate around. - * - * @note result is stored in v1. - */ - - template - TVector3 RotateAroundAxisV(TVector3& v1, const TVector3& axisNormal, T angle); - - /** - * Scales vector two specific magnitude. - * - * @param(v1) Vector - * - * @note It's faster to use operator* or operator*= for naturaly normalized vectors. - */ - - template - TVector3 ScaleToMagnitudeV(TVector3& v1, T magnitude); - - /** - * Returns signs of components in vector: -1 / +1 / 0. - * - * @param(v1) Vector one - */ - - template - TVector3 SignVectorV(TVector3& v1); - - - /** - * Gets scalar triple product ((v1 x v2) * v3). (Volume of parallelepiped.) - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(v3) Vector three - * - * @return Vector triple product - */ - - template - T ScalarTriple(const TVector3& v1, const TVector3& v2, const TVector3& v3); - - /** - * Gets the cosine of the angle between to vectors. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Cosine of angle between vectors. - * @note Simply omits acos of angle. - */ - - template - T CosineAngle(const TVector3& v1, const TVector3& v2); - - /** - * Gets vector triple product ((v1 x v2) x v3). - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(v3) Vector three - * - * @note result is stored in v1 - */ - - template - TVector3 VectorTripleV(TVector3& v1, const TVector3& v2, const TVector3& v3); - - /** - * Tests whether two vectors are perpendicular. - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(threshold) Allowed T inaccuracy - * - * @return True if perpendicular, false if not. - */ - - template - inline bool IsPerpendicular(const TVector3& v1, const TVector3& v2, T threshold = P_FLT_INAC); - - /** - * Tests whether two vectors are parallel. - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(threshold) Allowed T inaccuracy from one (e.g. 0.98f) - * - * @return True if parallel, false if not. - */ - - template - inline bool IsParallel(const TVector3& v1, const TVector3& v2, T threshold = 1.0f - P_FLT_INAC); - - /** - * Tests whether two vectors are coincident (Parallel and point in same direction). - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(threshold) Allowed T inaccuracy from one (e.g. 0.98f) - * - * @return True if coincident, false if not. - */ - - template - inline bool IsCoincident(const TVector3& v1, const TVector3& v2, T threshold = 1.0f - P_FLT_INAC); - - /** - * Tests whether v1 vectors is v1 unit vector. - * - * @param(v1) Vector - * @param(threshold) Allowed T inaccuracy - * - * @return True if unit vector, false if not. - */ - - template - inline bool IsNormalized(const TVector3& v1, T threshold = P_FLT_INAC); - - /** - * Tests if three vectors are coplanar - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(v3) Vector three - * @param(threshold) Allowed T inaccuracy - * - * @return True if coplanar, false if not. - */ - - template - inline bool IsCoplanar(const TVector3& v1, const TVector3& v2, const TVector3& v3, T threshold = P_FLT_INAC); - - /** - * Gets outer product of to vectors. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Resulting matrix - */ - - // - //Matrix3 OuterProduct(const TVector3& v1, const TVector3& v2); - - // ============ // - // WITH RETURN: // - // ============ // - - /** - * Normalized vector - * - * @param(v1) vector to normalize - * - * @return Normalized vector - */ - - template - TVector3 Normalize(const TVector3& v1); - - /** - * Normalizes vector - * - * @param(v1) Vector - * - * @note Does not test for zero vector - */ - - template - TVector3 UnsafeNormalize(const TVector3& v1); - - /** - * Reflects a vector on a surface - * - * @param(v1) Vector one - * @param(normal) Normal of surface - * - * @return Reflected vector - */ - - template - TVector3 Reflect(const TVector3& v1, const TVector3& normal); - - - /** - * Performes perspective divide on vector. - * - * @param(v1) vector to perspective divide - * - * @return Perspective divided vector - */ - - template - TVector3 PerspectiveDivide(const TVector3& v1); - - /** - * Gets cross product between two vectors. - * - * @param(v1) vector one - * @param(v2) vector two - * - * @return Cross product of v1 and v2 - */ - - template - TVector3 CrossP(const TVector3& v1, const TVector3& v2); - - /** - * Linearly interpolates between two vectors. - * - * @param(start) Starting vector - * @param(dest) Destination vector - * @param(t) 0.0 to 1.0 interpolation value - * - * @return Cross product of v1 and v2 - */ - - template - TVector3 Lerp(const TVector3& start, const TVector3& dest, T t); - - /** - * Linearly interpolates between two vectors. - * - * @param(v1) Starting vector - * @param(dest) Destination vector - * @param(t) 0.0 to 1.0 interpolation value - * - * @return Cross product of v1 and v2 - * @note Does not clamp t between 0.0 and 1.0. - */ - - template - TVector3 LerpUnclamped(const TVector3& start, const TVector3& dest, T t); - - /** - * Creates a new Vector by the componentwise max of both vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Vector of componentwise max - */ - - template - TVector3 Max(const TVector3& v1, const TVector3& v2); - - /** - * Creates a new Vector by the componentwise min of both vectors - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Vector of componentwise min - */ - - template - TVector3 Min(const TVector3& v1, const TVector3& v2); - - /** - * Gets reversed vector. - * - * @param(v1) Vector one - * - * @note result is stored in v1. - */ - - template - TVector3 Negate(const TVector3& v1); - - /** - * Multiplies vector componentwise. - * - * @param(v1) Vector one - * @param(v2) Vector two - * - * @return Vector with componentwise products - */ - - template - TVector3 Scale(const TVector3& v1, const TVector3& v2); - - /** - * Clamps vector to a range of magnitudes. - * - * @param(v1) Vector to clamp - * @param(min) Min magnitude - * @param(max) Max magnitude - * - * @return Clamped vector - */ - - template - TVector3 ClampMagnitude(const TVector3& v1, T min, T max); - - /** - * Binds vector into cube. - * - * @param(v1) Vector to clamp - * @param(cubeRadius) Radius of the cube - * - * @result Vector clamped in cube. - */ - - template - TVector3 BoundToCube(const TVector3& v1, T cubeRadius) {}; - - /** - * Clamps vector into cube. - * - * @param(v1) Vector to clamp - * @param(cubeRadius) Radius of the cube - * - * @result Vector clamped in cube. - */ - - template - TVector3 ClampToCube(const TVector3& v1, T cubeRadius) {}; - - /** - * Scales vector two specific magnitude. - * - * @param(v1) Vector - * - * @note It's faster to use operator* or operator*= for naturaly normalized vectors. - */ - - template - TVector3 ScaleToMagnitude(const TVector3& v1, T magnitude); - - /** - * Clamps vector into cube. - * - * @param(v1) Vector - * - * @result Vector with inverted components. - */ - - template - TVector3 CompInverse(const TVector3& v1); - - - /** - * Reflect from plane - * - * @param(v1) Vector to mirror - * @param(plane) Plane to mirror on - * - * @return Reflected vector - */ - - template - FORCEINLINE TVector3 ReflectFromPlane(const TVector3& v1, const TPlane& plane); - - /** - * Reflect from plane - * - * @param(v1) Vector to mirror - * @param(plane) Normal of plane - * - * @return Reflected vector - */ - - template - FORCEINLINE TVector3 ReflectFromPlane(const TVector3& v1, const TVector3& normal); - - /** - * Rotates vector around axis - * - * @param(v1) Vector to mirror - * @param(axisNormal) Axis to rotate around - * - * @return Rotated vector - * @note Calculates vector rotation with Rodrigues-Rotation - */ - - template - TVector3 RotateAroundAxis(const TVector3& v1, const TVector3& axisNormal, T angle); - - /** - * Gets vector triple product ((v1 x v2) x v3). - * - * @param(v1) Vector one - * @param(v2) Vector two - * @param(v3) Vector three - * - * @return Vector triple product - */ - - template - TVector3 VectorTriple(const TVector3& v1, const TVector3& v2, const TVector3& v3); - - /** - * Projects vector v1 onto v2 - * - * @param(v1) Vector to project - * @param(v2) Vector to project on - * - * @return Projected vector - */ - - template - TVector3 Project(const TVector3& v1, const TVector3& v2); - - /** - * Rejects vector v1 from v2 - * - * @param(v1) Vector to reject - * @param(v2) Vector to reject from - * - * @return Rejected vector - */ - - template - TVector3 Reject(const TVector3& v1, const TVector3& v2); - - /** - * Projects vector onto plane - * - * @param(v1) Vector to reject - * @param(normal) Normal of the plane - * - * @return Projected vector - * @note Simply rejects the vector from normal - */ - - template - FORCEINLINE TVector3 ProjectOntoPlane(const TVector3& v1, const TVector3& normal); - - - /** - * Projects vector onto plane - * - * @param(v1) Vector to reject - * @param(plane) Plane - * - * @return Projected vector - * @note Simply rejects the vector from normal - */ - - template - FORCEINLINE TVector3 ProjectOntoPlane(const TVector3& v1, const TPlane& plane); - - /** - * Interpolate vector v1 to desitnation v2 using v1 constant s. The magnitude of the vector stays the same throughout the interpolation. - * - * @param(v1) Starting vector - * @param(v2) Destination vector - * @param(t) 0.0 to 1.0 interpolation value - * - * @return Interpolated unit vector - */ - - template - TVector3 Slerp(const TVector3& v1, const TVector3& v2, T t) {}; - - /** - * Interpolate vector v1 to desitnation v2 using v1 constant s. The magnitude of the vector stays the same throughout the interpolation. - * - * @param(v1) Starting vector - * @param(v2) Destination vector - * @param(t) 0.0 to 1.0 interpolation value - * - * @return Interpolated unit vector. - * @note Does not clamp s between 0.0 and 1.0. - */ - - template - TVector3 SlerpUnclamped(const TVector3& v1, const TVector3& v2, T t) {}; - -} // phanes - -#endif // !VECTOR3_H - diff --git a/Engine/src/Runtime/Core/public/Math/Vector4.h b/Engine/src/Runtime/Core/public/Math/Vector4.h deleted file mode 100644 index bd1d3b3..0000000 --- a/Engine/src/Runtime/Core/public/Math/Vector4.h +++ /dev/null @@ -1,155 +0,0 @@ -#pragma once - - -#include "Core/public/Math/MathCommon.h" -#include "Core/public/Math/MathAbstractTypes.h" -#include "Core/public/Math/MathFwd.h" - -#pragma warning(disable : 4244) - -#ifdef P_USE_MATH_CONSTANTS - - -#endif // P_USE_MATH_CONSTANTS - -#ifndef VECTOR4_H -#define VECTOR4_H - - -namespace phanes { - - namespace core { - - namespace math { - - namespace coretypes { - - // Basis 4D Vector (x, y, z, w) - - template - struct Vector4 { - public: - float x, y, z, w; - }; - - // List of Vector3 for DoP and ECS - typedef std::vector> Vector4List; - - - Vector4 createVector(float x, float y, float z, float w); - - - // ===================== // - // Vector4 operators // - // ===================== // - - void operator+= (Vector4& a, float s); - void operator+= (Vector4& a, const Vector4& b); - - void operator-= (Vector4& a, float s); - void operator-= (Vector4& a, const Vector4& b); - - void operator*= (Vector4& a, float s); - - void operator/= (Vector4& a, float s); - - Vector4 operator* (const Vector4& a, float s); - - Vector4 operator/ (const Vector4& a, float s); - - Vector4 operator* (float s, const Vector4& a); - - Vector4 operator/ (float s, const Vector4& a); - - // Vector4 dot-product - float operator* (const Vector4& a, const Vector4& b); - - Vector4 operator+ (const Vector4& a, float s); - Vector4 operator+ (const Vector4& a, const Vector4& b); - - Vector4 operator- (const Vector4& a, float s); - Vector4 operator- (const Vector4& a, const Vector4& b); - - void operator- (Vector4& a); - - bool operator== (const Vector4& a, const Vector4& b); - - - // ==================================== // - // Vector4 function implementation // - // ==================================== // - - float magnitude(const Vector4& a); - - float sqrMagnitude(const Vector4& a); - - void normalizeNR(Vector4& a); - - float angle(const Vector4& a, const Vector4& b); - - // dot product between two FVector3. Does the same as operator* - float dotP(const Vector4& a, const Vector4& b); - - void scaleToMagnitude(Vector4& a, float magnitude); - - bool equals(const Vector4& a, const Vector4& b, float threshold); - - void Set(Vector4& a, const Vector4& b); - - void perpspectiveDivideNR(Vector4& a); - - void maxNR(Vector4& a, const Vector4& b); - - void minNR(Vector4& a, const Vector4& b); - - void scaleNR(Vector4& a, const Vector4& b); - - void orthogonolize(Vector4& a, Vector4& b, Vector4& c); - - void orthoNormalize(Vector4& a, Vector4& b, Vector4& c); - - // projects vector a onto vector b - void projectNR(Vector4& a, const Vector4& b); - - // rejects vector a from vector b - void rejectNR(Vector4& a, const Vector4& b); - - - // ============ // - // WITH RETURN: // - // ============ // - - Vector4 lerp(const Vector4& a, const Vector4& b, float t); - - Vector4 lerpUnclamped(const Vector4& a, const Vector4& b, float t); - - Vector4 slerp(const Vector4& a, const Vector4& b, float t); - - Vector4 slerpUnclamped(const Vector4& a, const Vector4& b, float t); - - Vector4 max(const Vector4& a, const Vector4& b); - - Vector4 min(const Vector4& a, const Vector4& b); - - Vector4 scale(const Vector4& a, const Vector4& b); - - Vector4 perpspectiveDivide(const Vector4& a); - - Vector4 normalize(const Vector4& a); - - // projects vector a onto vector b - Vector4 project(const Vector4& a, const Vector4& b); - - // rejects vector a from vector b - Vector4 reject(const Vector4& a, const Vector4& b); - - } // phanes::core::math::coretypes - - } // phanes::core::math - - } // phanes::core - -} // phanes - - -#endif // !VECTOR4_H \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/StartingPoint/EntryPoint.h b/Engine/src/Runtime/Core/public/StartingPoint/EntryPoint.h index 7671fd0..df61aef 100644 --- a/Engine/src/Runtime/Core/public/StartingPoint/EntryPoint.h +++ b/Engine/src/Runtime/Core/public/StartingPoint/EntryPoint.h @@ -1,7 +1,7 @@ #pragma once // Entry point for Phanes game -#ifdef P_WIN_BUILD +#if defined(P_WIN_BUILD) && defined(P_BUILD_LIB) extern Phanes::Core::Application::PhanesGame* Phanes::Core::Application::CreatePhanesGame(); diff --git a/Engine/src/Runtime/Core/public/StartingPoint/StartingPoint.h b/Engine/src/Runtime/Core/public/StartingPoint/StartingPoint.h index 034f9ef..d6a2421 100644 --- a/Engine/src/Runtime/Core/public/StartingPoint/StartingPoint.h +++ b/Engine/src/Runtime/Core/public/StartingPoint/StartingPoint.h @@ -27,5 +27,4 @@ namespace Phanes::Core::Application */ PhanesGame* CreatePhanesGame(); - -} \ No newline at end of file +} diff --git a/Engine/src/Runtime/PhanesEnginePCH.h b/Engine/src/Runtime/PhanesEnginePCH.h index 7df62fb..aee3ca9 100644 --- a/Engine/src/Runtime/PhanesEnginePCH.h +++ b/Engine/src/Runtime/PhanesEnginePCH.h @@ -17,6 +17,15 @@ #include #include + #include + #include + + + + + #include + #include + #ifdef P_WIN_BUILD #include diff --git a/Engine/src/Runtime/REAME.md b/Engine/src/Runtime/REAME.md new file mode 100644 index 0000000..ba25286 --- /dev/null +++ b/Engine/src/Runtime/REAME.md @@ -0,0 +1,15 @@ +# PhanesEngine + +## Runtime + +### MACROS + +- P_WIN_BUILD: Game builds for windows. +- P_UNIX_BUILD: Game builds for unix system. +- P_ARM_BUILD: Game builds for ARM system. +- P_DEBUG: Engine compiles for debug game. +- P_DEBUGBREAK: Sets a debugbreak at the point. +- P_RELEASE: Engine compiles for release. +- P_BUILD_LIB: Should only be defined, when the engine is build. +- P_TEST: Builds engine for testing. +- FORCEINLINE: Causes aggressive inlining. \ No newline at end of file diff --git a/Samples/DevPlayground/DevPlayground.cpp b/Samples/DevPlayground/DevPlayground.cpp index a1ca5c1..2795340 100644 --- a/Samples/DevPlayground/DevPlayground.cpp +++ b/Samples/DevPlayground/DevPlayground.cpp @@ -1,11 +1,10 @@ +#define P_USE_NAMESPACE_ALIAS #include -using namespace Phanes::Core::Math; - -class DevPlayground : public Phanes::Core::Application::PhanesGame {}; +class DevPlayground : public PApp::PhanesGame {}; -Phanes::Core::Application::PhanesGame* Phanes::Core::Application::CreatePhanesGame() +PApp::PhanesGame* PApp::CreatePhanesGame() { return new DevPlayground(); } \ No newline at end of file diff --git a/Tests/TestProject/Main.cpp b/Tests/TestProject/Main.cpp index 9f86376..3c2bc7e 100644 --- a/Tests/TestProject/Main.cpp +++ b/Tests/TestProject/Main.cpp @@ -6,7 +6,7 @@ int main() { float t = 2; PMath::Clamp(t, 2.0f, 4.0f); - + return 0; } \ No newline at end of file