From 048e598858fb3acebecb507f3a8cc242c3debbd2 Mon Sep 17 00:00:00 2001 From: scorpioblood <77296181+scorpioblood@users.noreply.github.com> Date: Fri, 17 May 2024 23:50:37 +0200 Subject: [PATCH] Made core math lib header only. --- .../Runtime/Core/private/Math/IntPoint.cpp | 15 - .../Runtime/Core/private/Math/IntVector2.cpp | 461 ------ .../Runtime/Core/private/Math/MathCommon.cpp | 57 - .../Core/private/Math/MathTypeConversion.cpp | 48 - .../src/Runtime/Core/private/Math/Matrix2.cpp | 145 -- .../src/Runtime/Core/private/Math/Point.cpp | 34 - .../src/Runtime/Core/private/Math/Vector2.cpp | 571 ------- .../src/Runtime/Core/private/Math/Vector3.cpp | 669 -------- .../src/Runtime/Core/public/Math/IntPoint.h | 154 -- .../src/Runtime/Core/public/Math/IntPoint.hpp | 160 ++ .../src/Runtime/Core/public/Math/IntVector2.h | 872 ---------- .../Runtime/Core/public/Math/IntVector2.hpp | 720 ++++++++ .../src/Runtime/Core/public/Math/IntVector3.h | 966 ----------- .../Runtime/Core/public/Math/IntVector3.hpp | 855 ++++++++++ .../src/Runtime/Core/public/Math/MathCommon.h | 98 -- .../Runtime/Core/public/Math/MathCommon.hpp | 130 ++ ...ypeConversion.h => MathTypeConversion.hpp} | 51 +- .../Core/public/Math/MathUnitConversion.h | 112 -- .../Core/public/Math/MathUnitConversion.hpp | 139 ++ Engine/src/Runtime/Core/public/Math/Matrix2.h | 154 -- .../src/Runtime/Core/public/Math/Matrix2.hpp | 307 ++++ Engine/src/Runtime/Core/public/Math/Plane.h | 23 - Engine/src/Runtime/Core/public/Math/Plane.hpp | 134 ++ .../Core/public/Math/{Point.h => Point.hpp} | 15 +- Engine/src/Runtime/Core/public/Math/Vector2.h | 938 ----------- .../src/Runtime/Core/public/Math/Vector2.hpp | 1164 +++++++++++++ Engine/src/Runtime/Core/public/Math/Vector3.h | 1191 -------------- .../src/Runtime/Core/public/Math/Vector3.hpp | 1455 +++++++++++++++++ Tests/TestProject/Main.cpp | 13 +- 29 files changed, 5116 insertions(+), 6535 deletions(-) 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/MathCommon.cpp delete mode 100644 Engine/src/Runtime/Core/private/Math/MathTypeConversion.cpp delete mode 100644 Engine/src/Runtime/Core/private/Math/Matrix2.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/public/Math/IntPoint.h create mode 100644 Engine/src/Runtime/Core/public/Math/IntPoint.hpp delete mode 100644 Engine/src/Runtime/Core/public/Math/IntVector2.h create mode 100644 Engine/src/Runtime/Core/public/Math/IntVector2.hpp delete mode 100644 Engine/src/Runtime/Core/public/Math/IntVector3.h create mode 100644 Engine/src/Runtime/Core/public/Math/IntVector3.hpp delete mode 100644 Engine/src/Runtime/Core/public/Math/MathCommon.h create mode 100644 Engine/src/Runtime/Core/public/Math/MathCommon.hpp rename Engine/src/Runtime/Core/public/Math/{MathTypeConversion.h => MathTypeConversion.hpp} (52%) delete mode 100644 Engine/src/Runtime/Core/public/Math/MathUnitConversion.h create mode 100644 Engine/src/Runtime/Core/public/Math/MathUnitConversion.hpp delete mode 100644 Engine/src/Runtime/Core/public/Math/Matrix2.h create mode 100644 Engine/src/Runtime/Core/public/Math/Matrix2.hpp delete mode 100644 Engine/src/Runtime/Core/public/Math/Plane.h create mode 100644 Engine/src/Runtime/Core/public/Math/Plane.hpp rename Engine/src/Runtime/Core/public/Math/{Point.h => Point.hpp} (91%) delete mode 100644 Engine/src/Runtime/Core/public/Math/Vector2.h create mode 100644 Engine/src/Runtime/Core/public/Math/Vector2.hpp delete mode 100644 Engine/src/Runtime/Core/public/Math/Vector3.h create mode 100644 Engine/src/Runtime/Core/public/Math/Vector3.hpp 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 53c23ff..0000000 --- a/Engine/src/Runtime/Core/private/Math/IntPoint.cpp +++ /dev/null @@ -1,15 +0,0 @@ -#include "PhanesEnginePCH.h" - -#include "Core/public/Math/IntPoint.h" - -template -Rt Phanes::Core::Math::Distance(const TIntPoint3& p1, const TIntPoint3& p2) -{ - return Magnitude(p2 - p1); -} - -template -Rt Phanes::Core::Math::Distance(const TIntPoint2& p1, const TIntPoint2& 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/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/Matrix2.cpp b/Engine/src/Runtime/Core/private/Math/Matrix2.cpp deleted file mode 100644 index a3580b7..0000000 --- a/Engine/src/Runtime/Core/private/Math/Matrix2.cpp +++ /dev/null @@ -1,145 +0,0 @@ -// =========================== // -// Matrix2D implementation // -// =========================== // - -#include "PhanesEnginePCH.h" - -#include "Core/public/Math/Matrix2.h" -#include "Core/public/Math/Vector2.h" - - -template -inline Phanes::Core::Math::TMatrix2::TMatrix2(const TMatrix2& m1) -{ - memcpy(this->m, m1.m, sizeof(T) * 2); -} - -template -Phanes::Core::Math::TMatrix2::TMatrix2(TMatrix2&& m) -{ - this->comp = m.comp; - m.comp = nullptr; -} - -template -Phanes::Core::Math::TMatrix2::TMatrix2(T fields[2][2]) -{ - this->m[0][0] = fields[0][0]; this->m[1][0] = fields[0][1]; - this->m[1][0] = fields[1][0]; this->m[1][1] = fields[1][1]; -} - -template -Phanes::Core::Math::TMatrix2::TMatrix2(T n00, T n10, T n01, T n11) -{ - this->m[0][0] = n00; this->m[1][0] = n01; - this->m[1][0] = n10; this->m[1][1] = n11; -} - -template -Phanes::Core::Math::TMatrix2::TMatrix2(const TVector2& v1, const TVector2& v2) -{ - this->m[0][0] = v1.x; this->m[1][0] = v1.y; - this->m[0][1] = v2.x; this->m[1][1] = v2.y; -} - -template -T& Phanes::Core::Math::TMatrix2::operator()(int n, int m) -{ - return this->m[m][n]; -} - -// ================================= // -// Class Methods for easy access // -// ================================= // - -template -Phanes::Core::Math::TVector2& Phanes::Core::Math::TMatrix2::operator[](int m) -{ - return reinterpret_cast(this->m[m]); -} - -template -const T& Phanes::Core::Math::TMatrix2::operator()(int n, int m) const -{ - return this->m[m][n]; -} - -template -const Phanes::Core::Math::TVector2& Phanes::Core::Math::TMatrix2::operator[](int m) const -{ - return reinterpret_cast(this->m[m]); -} - -// ===================== // -// TMatrix2 operator // -// ===================== // - - -template -Phanes::Core::Math::TMatrix2 Phanes::Core::Math::operator+=(TMatrix2& m1, T s) -{ - m1->m[0][0] += s; - m1->m[0][1] += s; - m1->m[1][0] += s; - m1->m[1][1] += s; - - return m1; -} - -template -Phanes::Core::Math::TMatrix2 Phanes::Core::Math::operator+=(TMatrix2& m1, const TMatrix2& m2) -{ - m1->m[0][0] += m2.m[0][0]; - m1->m[0][1] += m2.m[0][1]; - m1->m[1][0] += m2.m[1][0]; - m1->m[1][1] += m2.m[1][1]; - - return m1; -} - -template -Phanes::Core::Math::TMatrix2 Phanes::Core::Math::operator-=(TMatrix2& m1, T s) -{ - m1->m[0][0] -= s; - m1->m[0][1] -= s; - m1->m[1][0] -= s; - m1->m[1][1] -= s; - - return m1; -} - -template -Phanes::Core::Math::TMatrix2 Phanes::Core::Math::operator-=(TMatrix2& m1, const TMatrix2& m2) -{ - m1->m[0][0] -= m2.m[0][0]; - m1->m[0][1] -= m2.m[0][1]; - m1->m[1][0] -= m2.m[1][0]; - m1->m[1][1] -= m2.m[1][1]; - - return m1; -} - -template -Phanes::Core::Math::TMatrix2 Phanes::Core::Math::operator*=(TMatrix2& m1, T s) -{ - m1->m[0][0] *= s; - m1->m[0][1] *= s; - m1->m[1][0] *= s; - m1->m[1][1] *= s; - - return m1; -} - -template -Phanes::Core::Math::TMatrix2 Phanes::Core::Math::operator*=(TMatrix2& m1, const TMatrix2& m2) -{ - Matrix2 c = m1; - - m1(0, 0) = c(0, 0) * m2(0, 0) + c(0, 1) * m2(1, 0); - m1(0, 1) = c(0, 0) * m2(0, 1) + c(0, 1) * m2(1, 1); - - m1(1, 0) = c(1, 0) * m2(0, 0) + c(1, 1) * m2(1, 0); - m1(1, 1) = c(1, 0) * m2(0, 1) + c(1, 1) * m2(1, 1); - - return m1; -} 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 df6fe9a..0000000 --- a/Engine/src/Runtime/Core/private/Math/Vector2.cpp +++ /dev/null @@ -1,571 +0,0 @@ -// =========================== // -// TVector2 implementation // -// =========================== // - - -#include "PhanesEnginePCH.h" - -#include "Core/public/Math/Vector2.h" -#include "Core/public/Math/Vector3.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/public/Math/IntPoint.h b/Engine/src/Runtime/Core/public/Math/IntPoint.h deleted file mode 100644 index 1328c68..0000000 --- a/Engine/src/Runtime/Core/public/Math/IntPoint.h +++ /dev/null @@ -1,154 +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/IntPoint.hpp b/Engine/src/Runtime/Core/public/Math/IntPoint.hpp new file mode 100644 index 0000000..c7449d5 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/IntPoint.hpp @@ -0,0 +1,160 @@ +#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) + { + return Magnitude(p2 - p1); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + + /** + * 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) + { + return Magnitude(p2 - p1); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + + /** + * 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/IntVector2.hpp b/Engine/src/Runtime/Core/public/Math/IntVector2.hpp new file mode 100644 index 0000000..d692284 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/IntVector2.hpp @@ -0,0 +1,720 @@ +#pragma once + +#include "Core/Core.h" + +#include "Core/public/Misc/Boilerplate.h" + +#include "Core/public/Math/MathCommon.hpp" +#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) + { + memcpy(this->comp, comp, sizeof(T) * 2); + } + + /** + * Move constructor + */ + + TIntVector2(TIntVector2&& v) + { + this->comp = v.comp; + v.comp = nullptr; + } + + /** + * Convert other type of vector + */ + + template + explicit TIntVector2(const TIntVector2& 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) + { + this->x = x; + this->y = y; + } + + /** + * Construct Vector from two component array. + * + * @param comp Array of components + */ + + TIntVector2(const T* comp) + { + memcpy(this->comp, comp, sizeof(T) * 2); + } + + /** + * Construct Vector from 3D integer Vector's xy. + * + * @param v 3D IntVector to copy from + */ + + TIntVector2(const TIntVector3& v) + { + this->x = v.x; + this->y = v.y; + } + + /** + * Constructs a vector pointing from start to end. + * + * @param(start) Startingpoint + * @param(end) Endpoint + */ + + TIntVector2(const TIntPoint2& start, const TIntPoint2& end) + { + this->x = end.x - start.x; + this->y = end.y - start.y; + } + }; + + // ======================== // + // 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) + { + v1.x += s; + v1.y += s; + + return v1; + } + + /** + * 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) + { + v1.x += v2.x; + v1.y += v2.y; + + return v1; + } + + /** + * 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) + { + v1.x -= s; + v1.y -= s; + + return v1; + } + + /** + * 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) + { + v1.x -= v2.x; + v1.y -= v2.y; + + return v1; + } + + /** + * 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) + { + v1.x *= s; + v1.y *= s; + + return v1; + } + + /** + * Devision of Vector + * + * @param(v1) Vector to divide with + * @param(s) Scalar to divide with + * + * @note Result is rounded (obviously) + */ + + template + TIntVector2 operator/= (TIntVector2& v1, T s) + { + float _1_s = 1.0f; + + v1.x *= _1_s; + v1.y *= _1_s; + + return v1; + } + + /** + * Stores the remainder of division by a scalar. + * + * @param(v1) Vector to divide with + * @param(s) Scalar to divide with + */ + + template + TIntVector2 operator%= (TIntVector2& v1, T s) + { + v1.x %= s; + v1.y %= s; + + return v1; + } + + /** + * 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) + { + return TIntVector2(v1.x * s, v1.y * 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) + { + float _1_s = 1.0f; + return TIntVector2(v1.x * _1_s, v1.y * _1_s); + } + + /** + * 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 + FORCEINLINE TIntVector2 operator* (T s, const TIntVector2& v1) + { + return v1 * s; + } + + /** + * 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 + FORCEINLINE TIntVector2 operator/ (T s, const TIntVector2& v1) + { + return v1 / s; + } + + /** + * Dot product between two Vectors. + * + * @see [FUNC]DotP + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @result Dot product + */ + + template + T operator* (const TIntVector2& v1, const TIntVector2& v2) + { + return v1.x * v2.x + v1.y * v2.y; + } + + /** + * 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) + { + return TIntVector2(v1.x + s, v1.y + 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) + { + return TIntVector2(v1.x + v2.x, v1.y + v2.y); + } + + /** + * 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) + { + return TIntVector2(v1.x - s, v1.y - 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) + { + return TIntVector2(v1.x - v2.x, v1.y - v2.y); + } + + /** + * 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 + FORCEINLINE TIntVector2 operator% (const TIntVector2& v1, T s) + { + return TIntVector2(v1.x % s, v1.y % s); + } + + /** + * Negate Vector. + * + * @param(v1) Vector to negate + */ + + template + void operator- (TIntVector2& v1) + { + v1.x = -v1.x; + v1.y = -v1.y; + } + + /** + * 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) + { + return (abs(v1.x - v1.x) < P_FLT_INAC && abs(v1.y - v1.y) < P_FLT_INAC); + } + + + /** + * 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) + { + return (abs(v1.x - v1.x) > P_FLT_INAC || abs(v1.y - v1.y) > P_FLT_INAC); + } + + // ============================================== // + // TIntVector2 static function implementation // + // ============================================== // + + template + TIntVector2 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; + } + + /** + * 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) + { + v1.x = Phanes::Core::Math::Min(v1.x, v2.x); + v1.y = Phanes::Core::Math::Min(v1.y, v2.y); + + return v1; + } + + template + TIntVector2 SignVectorV(TIntVector2& v1) + { + v1.x = (v1.x >= 0) ? 1 : -1; + v1.y = (v1.y >= 0) ? 1 : -1; + + return 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) + { + v1.x *= v2.x; + v1.y *= v2.y; + + return v1; + } + + /** + * Copies one Vector two another + * + * @param(v1) Vector to copy to + * @param(v2) Vector to copy + */ + + template + TIntVector2 Set(TIntVector2& v1, const TIntVector2& v2) + { + v1 = v2; + + return v1; + } + + /** + * 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) + { + v1.x = x; + v1.y = y; + + return v1; + } + + + /** + * Negates Vector + * + * @param(v1) Vector one + */ + + template + TIntVector2 NegateV(TIntVector2& v1) + { + v1.x = -v1.x; + v1.y = -v1.y; + } + + /** + * 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) + { + return (abs(DotP(v1, v2)) = 0); + } + + /** + * 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) + { + return (abs(DotP(v1, v2)) = 1); + } + + /** + * 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) + { + return (DotP(v1, v2) > 1); + } + + /** + * 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 // + // ================================================================ // + + + /** + * Negates Vector + * + * @param(v1) Vector one + * + * @return Componentwise inverted vector + */ + + template + TIntVector2 Negate(const TIntVector2& v1) + { + return TIntVector2(-v1.x, -v1.y); + } + + /** + * 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) + { + return TIntVector2(Phanes::Core::Math::Min(v1.x, v2.x), Phanes::Core::Math::Min(v1.y, v2.y)); + } + + /** + * 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) + { + return TIntVector2(Phanes::Core::Math::Max(v1.x, v2.x), Phanes::Core::Math::Max(v1.y, v2.y)); + } + + + template + TIntVector2 SignVector(const TIntVector2& v1) + { + return TIntVector2((v1.x >= 0) ? 1 : -1, (v1.y >= 0) ? 1 : -1); + } + + +} // 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/IntVector3.hpp b/Engine/src/Runtime/Core/public/Math/IntVector3.hpp new file mode 100644 index 0000000..1ce9626 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/IntVector3.hpp @@ -0,0 +1,855 @@ +#pragma once + +#include "Core/public/Misc/Boilerplate.h" + +#include "Core/public/Math/MathCommon.hpp" +#include "Core/public/Math/MathAbstractTypes.h" +#include "Core/public/Math/MathFwd.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) + { + memcpy(this->comp, comp, sizeof(T) * 3); + } + + /** + * Move constructor + */ + + TIntVector3(TIntVector3&& v) + { + this->comp = v.comp; + v.comp = nullptr; + } + + /** + * Convert other type of vector + */ + + template + explicit TIntVector3(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 + */ + + TIntVector3(const T x, const T y, const T z) : x(x), y(y), z(z) {}; + + /** + * Construct Vector from two component array. + * + * @param(comp) Array of components + */ + + TIntVector3(const T* comp) + { + memcpy(this->comp, comp, sizeof(T) * 3); + } + + /** + * Constructs a vector pointing from start to end. + * + * @param(start) Startingpoint + * @param(end) Endpoint + */ + + 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; + } + + }; + + + // ======================== // + // IntVector3 operators // + // ======================== // + + + /** + * Coponentwise addition of scalar to 3D vector + * + * @param(v1) vector to add to + * @param(s) scalar to add + */ + + template + inline TIntVector3 operator+= (TIntVector3& v1, T s) + { + v1.x += s; + v1.y += s; + v1.z += s; + + return v1; + } + + /** + * 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) + { + v1.x += v2.x; + v1.y += v2.y; + v1.z += v2.z; + + return v1; + } + + /** + * Coponentwise substraction of scalar of 3D vector + * + * @param(v1) vector to substract from + * @param(s) scalar to substract + */ + + template + inline TIntVector3 operator-= (TIntVector3& v1, T s) + { + v1.x -= s; + v1.y -= s; + v1.z -= s; + + return v1; + } + + /** + * 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) + { + v1.x -= v2.x; + v1.y -= v2.y; + v1.z -= v2.z; + + return v1; + } + + /** + * Dot product between two 3D Vectors + * + * @param(v1) vector one + * @param(s) scalar + */ + + template + inline TIntVector3 operator*= (TIntVector3& v1, T s) + { + v1.x *= s; + v1.y *= s; + v1.z *= s; + + return v1; + } + + /** + * Division of vector by scalar + * + * @param(v1) vector one + * @param(s) scalar + */ + + template + inline TIntVector3 operator/= (TIntVector3& v1, T s) + { + float _1_s = 1.0f / s; + + v1.x *= s; + v1.y *= s; + v1.z *= s; + + return v1; + } + + /** + * Stores remainder of division with scalar + * + * @param(v1) vector one + * @param(s) scalar + */ + + template + inline TIntVector3 operator%= (TIntVector3& v1, T s) + { + v1.x %= s; + v1.y %= s; + v1.z %= s; + + return v1; + } + + /** + * Coponentwise multiplication of 3D Vectors with scalar + * + * @param(v1) vector one + * @param(s) scalar + * + * @return Resulting vector + */ + + template + TIntVector3 operator* (const TIntVector3& v1, T s) + { + return TIntVector3(v1.x * s, v1.y * s, v1.z * s); + } + + /** + * Coponentwise multiplication of 3D Vectors with scalar + * + * @param(s) scalar + * @param(v2) vector + * + * @return Solution vector + */ + + template + FORCEINLINE TIntVector3 operator* (T s, const TIntVector3& v1) + { + return v1 * s; + } + + /** + * Division by scalar + * + * @param(s) scalar + * @param(v2) vector + * + * @return Solution vector + */ + + template + inline TIntVector3 operator/ (const TIntVector3& v1, T s) + { + float _1_s = 1.0f / s; + return TIntVector3(v1.x * s, v1.y * s, v1.z * s); + } + + template + FORCEINLINE TIntVector3 operator/ (T s, const TIntVector3& v1) + { + return v1 / s; + } + + /** + * Stores remainder of division by scalar + * + * @param(s) scalar + * @param(v2) vector + * + * @return Solution vector + */ + + template + inline TIntVector3 operator% (T s, const TIntVector3& v1) + { + return TIntVector3(v1.x % s, v1.y % s, v1.z % s); + } + + /** + * 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) + { + return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; + } + + /** + * Coponentwise addition of scalar to 3D vector + * + * @param(v1) vector to add to + * @param(s) scalar to add + * + * @return Resulting vector + */ + + template + TIntVector3 operator+ (const TIntVector3& v1, T s) + { + return TIntVector3(v1.x + s.v1.y + s, v1.z + 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) + { + return TIntVector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z); + } + + /** + * Coponentwise substraction of scalar of 3D vector + * + * @param(v1) vector to substract from + * @param(s) scalar to substract + * + * @return Resulting vector + */ + + template + TIntVector3 operator- (const TIntVector3& v1, T s) + { + return TIntVector3(v1.x - s.v1.y - s, v1.z - s); + } + + /** + * Coponentwise substraction of scalar 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) + { + return TIntVector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z); + } + + /** + * Negates vector + * + * @param(v1) Vector to negate + */ + + template + TIntVector3 operator- (TIntVector3& v1) + { + v1.x = -v1.x; + v1.y = -v1.y; + v1.z = -v1.z; + + return 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) + { + 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); + } + + /** + * 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) + { + 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); + } + + + // ============================================== // + // IntVector3 static function implementation // + // ============================================== // + + /** + * 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) + { + return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; + } + + /** + * 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) + { + return (abs(v1.x - v2.x) < threshold && abs(v1.y - v2.y) < threshold && abs(v1.z - v2.z) < threshold); + } + + /** + * 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) + { + 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; + } + + /** + * 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) + { + v1.x = Phanes::Core::Math::Max(v1.x, v2.x); + v1.y = Phanes::Core::Math::Max(v1.y, v2.y); + v1.z = Phanes::Core::Math::Max(v1.z, v2.z); + + return v1; + } + + /** + * 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) + { + v1.x = Phanes::Core::Math::Min(v1.x, v2.x); + v1.y = Phanes::Core::Math::Min(v1.y, v2.y); + v1.z = Phanes::Core::Math::Min(v1.z, v2.z); + + return v1; + } + + /** + * Gets reversed vector. + * + * @param(v1) Vector one + * + * @note result is stored in v1. + */ + + template + TIntVector3 NegateV(TIntVector3& v1) + { + v1.x = -v1.x; + v1.y = -v1.y; + v1.z = -v1.z; + + return 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) + { + v1.x *= v2.x; + v1.y *= v2.y; + v1.z *= v2.z; + + return v1; + } + + /** + * Copies v1 vector + * + * @param(v1) Vector to copy to + * @param(v2) Vector to copy + */ + + template + TIntVector3 Set(TIntVector3& v1, const TIntVector3& v2) + { + v1 = v2; + + return v1; + } + + /** + * 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) + { + v1.x = x; + v1.y = y; + v1.z = z; + + return v1; + } + + /** + * Returns signs of components in vector: -1 / +1 / 0. + * + * @param(v1) Vector one + */ + + template + TIntVector3 SignVectorV(TIntVector3& v1) + { + v1.x = (v1.x >= 0) ? 1 : -1; + v1.y = (v1.y >= 0) ? 1 : -1; + v1.z = (v1.z >= 0) ? 1 : -1; + + return 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) + { + return CrossP(v1, v2) * v3; + } + + /** + * 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) + { + CrossPV(CrossPV(v1, v2), v3); + + return v1; + } + + /** + * Tests whether two vectors are perpendicular. + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return True if perpendicular, false if not. + */ + + template + inline bool IsPerpendicular(const TIntVector3& v1, const TIntVector3& v2) + { + return (DotP(v1, v2) == 0); + } + + /** + * Tests whether two vectors are parallel. + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return True if parallel, false if not. + */ + + template + inline bool IsParallel(const TIntVector3& v1, const TIntVector3& v2) + { + return (abs(DotP(v1, v2)) == 1); + } + + /** + * Tests whether two vectors are coincident (Parallel and point in same direction). + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return True if coincident, false if not. + */ + + template + inline bool IsCoincident(const TIntVector3& v1, const TIntVector3& v2) + { + return (DotP(v1, v2) == 1); + } + + /** + * Tests if three vectors are coplanar + * + * @param(v1) Vector one + * @param(v2) Vector two + * @param(v3) Vector three + * + * @return True if coplanar, false if not. + */ + + template + inline bool IsCoplanar(const TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3) + { + return (ScalarTriple(v1, v2, v3) == 0); + } + + + // ================================================================ // + // IntVector3 static function implementation with return values // + // ================================================================ // + + /** + * 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) + { + 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)); + } + + /** + * 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) + { + 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); + } + + /** + * 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) + { + 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); + } + + /** + * Gets reversed vector. + * + * @param(v1) Vector one + * + * @note result is stored in v1. + */ + + template + TIntVector3 Negate(const TIntVector3& v1) + { + return TIntVector3(-v1.x, -v1.y, -v1.z); + } + + /** + * 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) + { + return TIntVector3(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z); + } + + /** + * 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) + { + return CrossP(CrossP(v1, v2), v3); + } + +} // phanes::core::math::coretypes + +#endif // !INTVECTOR3_H + 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/MathCommon.hpp b/Engine/src/Runtime/Core/public/Math/MathCommon.hpp new file mode 100644 index 0000000..a6d59d6 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/MathCommon.hpp @@ -0,0 +1,130 @@ +#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) + { + if (value < low) value = low; + if (value > high) value = high; + return value; + } + + + /** + * Gets the larger of two values + * + * @param x + * @param y + * + * @return Larger value + */ + + template + inline T Max(T x, T y) + { + return (x > y) ? x : y; + } + + + /** + * Gets the smaller of two values + * + * @param x + * @param y + * + * @return Smaller value + */ + + template + inline T Min(T x, T y) + { + return (x < y) ? x : y; + } + + /** + * Swaps the values of two variables + * + * @param x + * @param y + */ + + template + inline void Swap(T& x, T& y) + { + float z = x; + x = y; + y = z; + } + + /** + * Test two numbers for equality + * + * @param x + */ + template + bool Equals(T x, T y, T threshold = P_FLT_INAC) + { + if (abs(x - y) < threshold) { + return true; + } + return false; + } + + /** + * 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::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; + } + + +} // phanes + +#endif // !MATH_COMMON_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.hpp similarity index 52% rename from Engine/src/Runtime/Core/public/Math/MathTypeConversion.h rename to Engine/src/Runtime/Core/public/Math/MathTypeConversion.hpp index f444f71..e650448 100644 --- a/Engine/src/Runtime/Core/public/Math/MathTypeConversion.h +++ b/Engine/src/Runtime/Core/public/Math/MathTypeConversion.hpp @@ -10,12 +10,12 @@ #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/Vector2.hpp" +#include "Core/public/Math/Vector3.hpp" //#include "Core/public/Math/Vector4.h" -//#include "Core/public/Math/Matrix2.h" +#include "Core/public/Math/Matrix2.hpp" //#include "Core/public/Math/Matrix3.h" -#include "Core/public/Math/IntVector2.h" +#include "Core/public/Math/IntVector2.hpp" #include "Core/public/Math/IntVector3.h" #ifndef MATH_TYPE_CONVERSION_H @@ -25,50 +25,67 @@ namespace Phanes::Core::Math { // =================================================== // - // std::to_string wrapper // - // // - // This is, to make using ToString more general // + // 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(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(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(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 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); }; + FORCEINLINE std::string ToString(unsigned long val) { return std::to_string(val); }; + // ============ // // ToString // // ============ // template - std::string ToString(const TVector2& v); + std::string ToString(const TVector2& v) + { + return "(" + ToString(v.x) + ", " + ToString(v.y) + ")"; + } template - std::string ToString(const TIntVector2& v); + std::string ToString(const TIntVector2& v) + { + return "(" + ToString(v.x) + ", " + ToString(v.y) + ")"; + } template - std::string ToString(const TVector3& v); + std::string ToString(const TVector3& v) + { + return "(" + ToString(v.x) + ", " + ToString(v.y) + ", " + ToString(v.z) + ")"; + } template - std::string ToString(const TIntVector3& v); + std::string ToString(const TIntVector3& v) + { + return "(" + ToString(v.x) + ", " + ToString(v.y) + ", " + ToString(v.z) + ")"; + } //std::string toString(const Vector4& v); - //std::string toString(const Matrix2& v); + template + std::string toString(const TMatrix2& m) + { + return "[[" + ToString(m.m(0, 0)) + " " + ToString(m.m(0, 1)) + "], [" + ToString(m.m(0, 0)) + " " + ToString(m.m(0, 1)) + "]]" + } //std::string toString(const Matrix3& v); 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 6e4f581..0000000 --- a/Engine/src/Runtime/Core/public/Math/MathUnitConversion.h +++ /dev/null @@ -1,112 +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); - - /** - * Convert rad to rad. - * - * @param(_x) Angle in degress - */ - - double operator ""_rad(long double _x); - - /** - * Convert gradian to rad. - * - * @param(_x) Angle in degress - */ - - double operator ""_g(long double _x); -} \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/MathUnitConversion.hpp b/Engine/src/Runtime/Core/public/Math/MathUnitConversion.hpp new file mode 100644 index 0000000..a1ffa9a --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/MathUnitConversion.hpp @@ -0,0 +1,139 @@ +#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) + { + return deg * P_PI_180_FLT; + } + + /** + * Converts radians to degrees. + * + * @param(rad) Angle in radians (rad) + * + * @return Angle in degrees + */ + + template + inline T RadToDeg(T rad) + { + return rad * P_180_PI_FLT; + } + + /** + * Converts degrees to gradian. + * + * @param(deg) Angle in degress (°) + * + * @return Angle in gradian + */ + + template + inline T DegToGradian(T deg) + { + return deg * 1.111111f; + } + + /** + * Converts gradian to degrees. + * + * @param(rad) Angle in gradians (g) + * + * @return Angle in degrees + */ + + template + inline T GradianToDeg(T g) + { + return g * 0.9f; + } + + /** + * Converts radians to gradians. + * + * @param(deg) Angle in radians (rad) + * + * @return Angle in gradians + */ + + template + inline T RadToGradian(T rad) + { + return rad * 200 / P_PI_FLT; + } + + /** + * Converts gradian to radians. + * + * @param(rad) Angle in gradians (g) + * + * @return Angle in radians + */ + + template + inline T GradianToRad(T g) + { + return g * P_PI_FLT / 200; + } + +} // 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 8feff6a..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& m1); - - /** - * 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; - }; - - // ===================== // - // TMatrix2 operator // - // ===================== // - - template - TMatrix2 operator+= (TMatrix2& m1, T s); - - template - TMatrix2 operator+= (TMatrix2& m1, const TMatrix2& m2); - - template - TMatrix2 operator-= (TMatrix2& m1, T s); - - template - TMatrix2 operator-= (TMatrix2& m1, const TMatrix2& m2); - - template - TMatrix2 operator*= (TMatrix2& m1, T s); - - template - TMatrix2 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/Matrix2.hpp b/Engine/src/Runtime/Core/public/Math/Matrix2.hpp new file mode 100644 index 0000000..24c2230 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/Matrix2.hpp @@ -0,0 +1,307 @@ +#pragma once + +#include "Core/Core.h" +#include "Core/public/Misc/Boilerplate.h" + +#include "Core/public/Math/Vector2.hpp" + +#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& m1) + { + memcpy(this->m, m1.m, sizeof(T) * 2); + } + + /** + * Move constructor. + */ + + TMatrix2(TMatrix2&& m) + { + this->m = m.m; + m.m = nullptr; + } + + /** + * Construct Matrix from 2d array. + * + * @param(fields) 2D Array with column major order. + */ + + TMatrix2(T fields[2][2]) + { + this->m[0][0] = fields[0][0]; this->m[1][0] = fields[0][1]; + this->m[1][0] = fields[1][0]; this->m[1][1] = fields[1][1]; + } + + /** + * 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) + { + this->m[0][0] = n00; this->m[1][0] = n01; + this->m[1][0] = n10; this->m[1][1] = n11; + } + + /** + * Construct Matrix from two 2d vector columns. + * + * @param(v1) Column zero + * @param(v2) Column one + */ + + TMatrix2(const TVector2& v1, const TVector2& v2) + { + this->m[0][0] = v1.x; this->m[1][0] = v1.y; + this->m[0][1] = v2.x; this->m[1][1] = v2.y; + } + + public: + + FORCEINLINE T& operator() (int n, int m) const + { + return this->m[m][n]; + } + FORCEINLINE TVector2& operator[] (int m) const + { + return reinterpret_cast(this->m[m]); + } + + FORCEINLINE const T& operator() (int n, int m) const + { + return this->m[m][n]; + } + FORCEINLINE const TVector2& operator[] (int m) const + { + return reinterpret_cast(this->m[m]); + } + }; + + // ===================== // + // TMatrix2 operator // + // ===================== // + + template + TMatrix2 operator+= (TMatrix2& m1, T s) + { + m1->m(0, 0) += s; + m1->m(0, 1) += s; + m1->m(1, 0) += s; + m1->m(1, 1) += s; + + return m1; + } + + template + TMatrix2 operator+= (TMatrix2& m1, const TMatrix2& m2) + { + m1->m(0, 0) += m2.m(0, 0); + m1->m(0, 1) += m2.m(0, 1); + m1->m(1, 0) += m2.m(1, 0); + m1->m(1, 1) += m2.m(1, 1); + + return m1; + } + + template + TMatrix2 operator-= (TMatrix2& m1, T s) + { + m1->m(0, 0) -= s; + m1->m(0, 1) -= s; + m1->m(1, 0) -= s; + m1->m(1, 1) -= s; + + return m1; + } + + template + TMatrix2 operator-= (TMatrix2& m1, const TMatrix2& m2) + { + m1->m(0, 0) -= m2.m(0, 0); + m1->m(0, 1) -= m2.m(0, 1); + m1->m(1, 0) -= m2.m(1, 0); + m1->m(1, 1) -= m2.m(1, 1); + + return m1; + } + + template + TMatrix2 operator*= (TMatrix2& m1, T s) + { + m1->m[0][0] *= s; + m1->m[0][1] *= s; + m1->m[1][0] *= s; + m1->m[1][1] *= s; + + return m1; + } + + template + TMatrix2 operator*= (TMatrix2& m1, const TMatrix2& m2) + { + Matrix2 c = m1; + + m1(0, 0) = c(0, 0) * m2(0, 0) + c(0, 1) * m2(1, 0); + m1(0, 1) = c(0, 0) * m2(0, 1) + c(0, 1) * m2(1, 1); + + m1(1, 0) = c(1, 0) * m2(0, 0) + c(1, 1) * m2(1, 0); + m1(1, 1) = c(1, 0) * m2(0, 1) + c(1, 1) * m2(1, 1); + + return m1; + } + + template + TMatrix2 operator+ (const TMatrix2& m1, T s) + { + return TMatrix2(m1(0, 0) + s, m1(0, 1) + s, + m1(1, 0) + s, m1(1, 1) + s); + } + + template + TMatrix2 operator+ (const TMatrix2& m1, const TMatrix2& m2) + { + return TMatrix2(m1(0, 0) + m2(0, 0), m1(0, 1) + m2(0, 1), + m1(1, 0) + m2(1, 0), m1(1, 1) + m2(1, 1); + } + + template + TMatrix2 operator- (const TMatrix2& m1, T s) + { + return TMatrix2(m1(0, 0) - s, m1(0, 1) - s, + m1(1, 0) - s, m1(1, 1) - s); + } + + template + TMatrix2 operator- (const TMatrix2& m1, const TMatrix2& m2) + { + return TMatrix2(m1(0, 0) - m2(0, 0), m1(0, 1) - m2(0, 1), + m1(1, 0) - m2(1, 0), m1(1, 1) - m2(1, 1); + } + + template + TMatrix2 operator* (const TMatrix2& m1, T s) + { + return TMatrix2(m1(0, 0) * s, m1(0, 1) * s, + m1(1, 0) * s, m1(1, 1) * s); + } + + template + TMatrix2 operator* (const TMatrix2& m1, const TMatrix2& m2) + { + return TMatrix2(m1(0, 0) * m2(0, 0) + m1(0, 1) * m2(1, 0), m1(0, 0) * m2(0, 1) + m1(0, 1) * m2(1, 1), + m1(1, 0) * m2(0, 0) + m1(1, 1) * m2(1, 0), m1(1, 0) * m2(0, 1) + m1(1, 1) * m2(1, 1)); + } + + template + TVector2 operator* (const TMatrix2& m1, const TVector2& v) + { + return TVector2(m1(0, 0) * v.x + m1(0, 1) * v.y, + m1(1, 0) * v.x + m1(1, 1) * v.y); + } + + template + bool operator== (const TMatrix2& m1, const TMatrix2& m2) + { + return (abs(m1(0, 0) - m2(0, 0)) < P_FLT_INAC && abs(m1(0, 1) - m2(0, 1)) < P_FLT_INAC && + abs(m1(1, 0) - m2(1, 0)) < P_FLT_INAC && abs(m1(1, 1) - m2(1, 1)) < P_FLT_INAC); + } + + template + bool operator!= (const TMatrix2& m1, const TMatrix2& m2) + { + return (abs(m1(0, 0) - m2(0, 0)) > P_FLT_INAC || abs(m1(0, 1) - m2(0, 1)) > P_FLT_INAC || + abs(m1(1, 0) - m2(1, 0)) > P_FLT_INAC || abs(m1(1, 1) - m2(1, 1)) > P_FLT_INAC); + } + + + // =============================== // + // Matrix function definition // + // =============================== // + + template + T Determinant(const Matrix2& m1) + { + return m1(0, 0) * m1(1, 1) - m1(0, 1) * m1(0, 1); + } + + template + TMatrix2 InverseV(TMatrix2& m1) + { + float _1_det = 1.0f / Determinant(m1); + float m00 = m1(0, 0); + + m1(0, 0) = m1(1, 1); + m1(0, 1) = -m1(0, 1); + m1(1, 0) = -m1(1, 0); + m1(1, 1) = m00; + + m1 *= _1_det; + return m1; + } + + template + TMatrix2 TransposeV(TMatrix2& m1) + { + Swap(m1(0, 1), m1(1, 0)); + } + + // =============== // + // WITH RETURN // + // =============== // + + template + TMatrix2 Inverse(TMatrix2& m1) + { + float _1_det = 1.0f / Determinant(m1); + + return TMatrix2(m1(1, 1) * _1_det, m1(1, 0) * _1_det, + m1(0, 1) * _1_det, m1(0, 0) * _1_det); + } + + template + TMatrix2 Transpose(const TMatrix2& m1) + { + return TMatrix2(m1(0, 0), m1(1, 0), + m1(0, 1), m1(1, 1)); + } + + template + bool IsIndentityMatrix(const TMatrix2& m1, T threshold = P_FLT_INAC) + { + return (abs(m1(0, 0) - (T)1.0) < P_FLT_INAC && abs(m1(0, 1) - (T)1.0) < P_FLT_INAC && + abs(m1(1, 0) - (T)1.0) < P_FLT_INAC && abs(m1(1, 1) - (T)1.0) < P_FLT_INAC); + } + +} // Phanes::Core::Math + + +#endif // !MATRIX2_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/Plane.hpp b/Engine/src/Runtime/Core/public/Math/Plane.hpp new file mode 100644 index 0000000..b64ec07 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/Plane.hpp @@ -0,0 +1,134 @@ +#pragma once + +#include "Core/public/Misc/Boilerplate.h" +#include "Core/public/Math/MathFwd.h" + +#include "Core/public/Math/Vector3.hpp" + +namespace Phanes::Core::Math { + + // Plane in 3D space, defined as: P: ax + by + cz = d; + + template + struct TPlane + { + public: + TVector3 normal; + T d; + }; + + /** + * Projects vector onto plane + * + * @param(v1) Vector to reject + * @param(plane) Plane + * + * @note result is stored in v1. + * @note Simply rejects v1 from normal + */ + + template + FORCEINLINE TVector3 ProjectOntoPlaneV(TVector3& v1, const TPlane& plane) + { + return RejectV(v1, plane.normal); + } + + + /** + * 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) + { + return RejectV(v1, normal); + } + + /** + * 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) + { + return ReflectV(v1, plane.normal); + } + + + /** + * 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) + { + return Reflect(v1, plane.normal); + } + + /** + * 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) + { + return Reflect(v1, normal); + } + + /** + * 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) + { + return Reject(v1, 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) + { + return Reject(v1, plane.normal); + } + +} // 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.hpp similarity index 91% rename from Engine/src/Runtime/Core/public/Math/Point.h rename to Engine/src/Runtime/Core/public/Math/Point.hpp index 58a6397..afd2a36 100644 --- a/Engine/src/Runtime/Core/public/Math/Point.h +++ b/Engine/src/Runtime/Core/public/Math/Point.hpp @@ -2,10 +2,13 @@ #include "Core/public/Misc/Boilerplate.h" -#include "Core/public/Math/MathCommon.h" +#include "Core/public/Math/MathCommon.hpp" #include "Core/public/Math/MathAbstractTypes.h" #include "Core/public/Math/MathFwd.h" +#include "Core/public/Math/Vector2.hpp" +#include "Core/public/Math/Vector3.hpp" + #ifndef P_DEBUG #pragma warning(disable : 4244) #endif @@ -67,7 +70,10 @@ namespace Phanes::Core::Math { */ template - T Distance(const TPoint2& p1, const TPoint2& p2); + T Distance(const TPoint2& p1, const TPoint2& p2) + { + return Magnitude(p2 - p1); + } /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -122,7 +128,10 @@ namespace Phanes::Core::Math { */ template - T Distance(const TPoint3& p1, const TPoint3& p2); + T Distance(const TPoint3& p1, const TPoint3& p2) + { + return Magnitude(p2 - p1); + } /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 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 3765c8e..0000000 --- a/Engine/src/Runtime/Core/public/Math/Vector2.h +++ /dev/null @@ -1,938 +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 - -#pragma warning(disable: 4661) - -#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; - - }; - - - - - 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); - - - }; - - // template struct TVector2; - - // ====================== // - // 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/Vector2.hpp b/Engine/src/Runtime/Core/public/Math/Vector2.hpp new file mode 100644 index 0000000..a1a5a1c --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/Vector2.hpp @@ -0,0 +1,1164 @@ +#pragma once + +#include "Core/Core.h" +#include "Core/public/Misc/Boilerplate.h" + +#include "Core/public/Math/MathCommon.hpp" +#include "Core/public/Math/MathAbstractTypes.h" +#include "Core/public/Math/MathFwd.h" + +#ifndef P_DEBUG +#pragma warning(disable : 4244) +#endif + +#pragma warning(disable: 4661) + +#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; + + }; + + + + + public: + + /** + * Default constructor without initialization + */ + + TVector2() = default; + + /** + * Copy constructor + */ + + TVector2(const TVector2& v) + { + memcpy(this->comp, comp, sizeof(T) * 2); + } + + /** + * Move constructor + */ + + TVector2(TVector2&& v) + { + this->comp = v.comp; + v.comp = nullptr; + } + + /** + * Convert other type of vector + */ + + template + explicit TVector2(const TVector2& 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) : x(x), y(y) {}; + + /** + * Construct Vector from two component array. + * + * @param(comp) Array of components + */ + + explicit TVector2(const Real* comp) + { + memcpy(this->comp, comp, sizeof(T) * 2); + } + + + /** + * Constructs a vector pointing from start to end. + * + * @param(start) Startingpoint + * @param(end) Endpoint + */ + + TVector2(const TPoint2& start, const TPoint2& end) + { + this->x = end.x - start.x; + this->y = end.y - start.y; + } + + }; + + // ====================== // + // 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) + { + v1.x += s; + v1.y += s; + + return v1; + } + + /** + * 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) + { + v1.x += v2.x; + v1.y += v2.y; + + return v1; + } + + /** + * 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) + { + v1.x -= s; + v1.y -= s; + + return v1; + } + + /** + * 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) + { + v1.x -= v2.x; + v1.y -= v2.y; + + return v1; + } + + /** + * 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) + { + v1.x *= s; + v1.y *= s; + + return v1; + } + + /** + * 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) + { + s = 1.0f / s; + v1.x *= s; + v1.y *= s; + + return v1; + } + + /** + * 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) + { + return TVector2(v1.x * s, v1.y * 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) + { + s = 1.0f / s; + return TVector2(v1.x * s, v1.y * 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) + { + return v1 * s; + } + + /** + * 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) + { + s = 1.0f / s; + return v1 * s; + } + + /** + * 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) + { + return v1.x * v2.x + v1.y * v2.y; + } + + /** + * 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) + { + return TVector2(v1.x + s, v1.y + 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) + { + return TVector2(v1.x + v2.x, v1.y + v2.y); + } + + /** + * 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) + { + return TVector2(v1.x - s, v1.y - 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) + { + return TVector2(v1.x - v2.x, v1.y - v2.y); + } + + /** + * Negate Vector. + * + * @param(v1) Vector to negate + */ + + template + void operator- (TVector2& v1) + { + v1.x = -v1.x; + v1.y = -v1.y; + } + + + /** + * 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) + { + return (abs(v1.x - v1.x) < P_FLT_INAC && abs(v1.y - v1.y) < P_FLT_INAC); + } + + + /** + * 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) + { + return (abs(v1.x - v1.x) > P_FLT_INAC || abs(v1.y - v1.y) > P_FLT_INAC); + } + + + // ============================================ // + // TVector2 static function implementation // + // ============================================ // + + /** + * Magnitude of Vector + * + * @param(v1) Vector + * + * @return Size of Vector + */ + + template + T Magnitude(const TVector2& v1) + { + return sqrtf(v1.x * v1.x + v1.y * v1.y); + } + + /** + * @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) + { + return v1.x * v1.x + v1.y * v1.y; + } + + /** + * @see [FUNC]SqrMagnitude + */ + template + FORCEINLINE T SqrLength(const TVector2& v1) { return SqrMagnitude(v1); }; + + /** + * Normalize Vector + * + * @param(v1) Vector + */ + + template + TVector2 NormalizeV(TVector2& v1) + { + float vecNorm = Magnitude(v1); + v1 /= (vecNorm < P_FLT_INAC) ? 1 : vecNorm; + return v1; + } + + /** + * Normalize Vector + * + * @param(v1) Vector + * + * @note Does not look for zero vector. + */ + + template + TVector2 UnsafeNormalizeV(TVector2& v1) + { + v1 /= Magnitude(v1); + + return v1; + } + + /** + * Angle between to Vectors + * + * @param(v1) Vector one + * @param(v2) Vector two + */ + + template + T Angle(const TVector2& v1, const TVector2& v2) + { + return acos((v1 * v2) / Magnitude(v1) * Magnitude(v2)); + } + + /** + * Cosine of angle between to Vectors + * + * @param(v1) Vector one + * @param(v2) Vector two + */ + + template + T CosineAngle(const TVector2& v1, const TVector2& v2) + { + return (v1 * v2) / Magnitude(v1) * Magnitude(v2); + } + + /** + * Returns signs of components in vector: -1 / +1 / 0. + * + * @param(v1) Vector one + */ + + template + TVector2 SignVectorV(TVector2& v1) + { + v1.x = (v1.x >= 0) ? 1 : -1; + v1.y = (v1.y >= 0) ? 1 : -1; + + return 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) + { + float k = (abs(v1.x) > abs(v1.y)) ? abs(radius / v1.x) : abs(radius / v1.y); + v1 *= k; + + return v1; + } + + /** + * 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) + { + 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; + } + + /** + * Dot product of two Vectors + * + * @param(v1) Vector one + * @param(v2) Vector two + */ + + template + T DotP(const TVector2& v1, const TVector2& v2) + { + return v1.x * v2.x + v1.y * v2.y; + } + + /** + * 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) + { + v1.x = Phanes::Core::Math::Max(v1.x, v2.x); + v1.y = Phanes::Core::Math::Max(v1.y, v2.y); + + return v1; + } + + /** + * 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) + { + v1.x = Phanes::Core::Math::Min(v1.x, v2.x); + v1.y = Phanes::Core::Math::Min(v1.y, v2.y); + + return v1; + } + + /** + * Gets perpendicular Vector to v1. + * + * @param(v1) Vector one + * + * @note Stores new Vector to v1 + */ + + template + TVector2 GetPerpendicularV(TVector2& v1) + { + T x = v1.x; + v1.x = v1.y; + v1.y = -v1.x; + + return v1; + } + + /** + * Gets perpendicular Vector to v1. + * + * @reg [FUNC]PerpendicularV + * + * @param(v1) Vector one + * + * @note Stores new Vector to v1 + */ + + template + TVector2 GetReversePerpendicularV(TVector2& v1) + { + T x = v1.x; + v1.x = -v1.y; + v1.y = v1.x; + + return 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) + { + v1.x *= v2.x; + v1.y *= v2.y; + + return v1; + } + + /** + * Componentwise inverse of Vector + * + * @param(v1) Vector one + * + * @note Stores new Vector to v1 + */ + + template + TVector2 CompInverseV(TVector2& v1) + { + v1.x = 1.0f / v1.x; + v1.y = 1.0f / v1.y; + + return 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) + { + Set(v1, v1 - (2 * (v1 * normal) * normal)); + + return v1; + } + + /** + * Copies one Vector two another + * + * @param(v1) Vector to copy to + * @param(v2) Vector to copy + */ + + template + TVector2 Set(TVector2& v1, const TVector2& v2) + { + v1 = v2; + + return v1; + } + + /** + * 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) + { + v1.x = x; + v1.y = y; + + return v1; + } + + /** + * Anti-clockwise vector rotation. + * + * @param(v1) Vector to rotate + * + * @note Angle is not clamped + */ + + template + TVector2 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; + } + + + /** + * Clockwise vector rotation. + * + * @param(v1) Vector to rotate + * + * @note Angle is not clamped + */ + + template + FORCEINLINE TVector2 ClockwiseRotateV(TVector2& v1, T angle) + { + RotateV(v1, -angle); + + return v1; + } + + /** + * Negates Vector + * + * @param(v1) Vector one + */ + + template + TVector2 NegateV(TVector2& v1) + { + v1.x = -v1.x; + v1.y = -v1.y; + } + + /** + * 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) + { + return (SqrMagnitude(v1) < threshold); + } + + /** + * 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) + { + return (abs(DotP(v1, v2)) < threshold); + } + + /** + * 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) + { + return (abs(DotP(v1, v2)) > threshold); + } + + /** + * 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) + { + return (DotP(v1, v2) > threshold); + } + + /** + * 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) + { + return TVector2(v1 - (2 * (v1 * normal) * 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) + { + return TVector2(v1.x * v2.x, v1.y * v2.y); + } + + /** + * Componentwise inverse of a vector + * + * @param(v1) Vector one + * + * @return Componentwise inverted vector + */ + + template + TVector2 CompInverse(const TVector2& v1) + { + return TVector2(1.0f / v1.x, 1.0f / v1.y); + } + + /** + * Negates Vector + * + * @param(v1) Vector one + * + * @return Componentwise inverted vector + */ + + template + TVector2 Negate(const TVector2& v1) + { + return TVector2(-v1.x, -v1.y); + } + + /** + * Gets the perpendicular vector of v1 + * + * @param(v1) Vector one + * + * @return Perpendicular vector + */ + + template + TVector2 GetPerpendicular(const TVector2& v1) + { + return TVector2(v1.y, -v1.x); + } + + /** + * Gets reverse of the perpendicular vector of v1 + * + * @param(v1) Vector one + * + * @return Reversed perpendicular vector + */ + + template + TVector2 GetReversePerpendicular(const TVector2& v1) + { + return TVector2(-v1.y, v1.x); + } + + /** + * 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) + { + return TVector2(Phanes::Core::Math::Min(v1.x, v2.x), Phanes::Core::Math::Min(v1.y, v2.y)); + } + + /** + * 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) + { + return TVector2(Phanes::Core::Math::Max(v1.x, v2.x), Phanes::Core::Math::Max(v1.y, v2.y)); + } + + /** + * Creates a normalized instance of the vector + * + * @param(v1) Vector to normalize + * + * @return Unit vector + */ + + template + TVector2 Normalize(const TVector2& v1) + { + float vecNorm = Magnitude(v1); + return (vecNorm < P_FLT_INAC) ? PZeroVector2(T) : (v1 / vecNorm); + } + + /** + * 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) + { + return (v1 / Magnitude(v1)); + } + + /** + * Returns signs of components in vector: -1 / +1. + * + * @param(v1) Vector one + * + * @return Vector with signs as components + */ + + template + TVector2 SignVector(const TVector2& v1) + { + return TVector2((v1.x >= 0) ? 1 : -1, (v1.y >= 0) ? 1 : -1); + } + + /** + * 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) + { + float k = (abs(v1.x) > abs(v1.y)) ? abs(radius / v1.x) : abs(radius / v1.y); + return v1 * k; + } + + /** + * 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) + { + float prime = (abs(v1.x) > abs(v1.y)) ? v1.x : v1.y; + float k = (prime > radius) ? abs(radius / prime) : 1.0f; + + return v1 * k; + } + + /** + * 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) + { + t = Phanes::Core::Math::Clamp(t, (T)0.0, (T)1.0); + + return (t * destVec) + ((1 - t) * startVec); + } + + /** + * 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) + { + return (t * destVec) + ((1 - t) * startVec); + } + + /** + * 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) + { + float sinAngle = sin(angle); + float cosAngle = cos(angle); + + return TVector2(v1.x * cosAngle - v1.y * sinAngle, + v1.y * cosAngle + v1.x * sinAngle); + } + + /** + * Clockwise vector rotation. + * + * @param(v1) Vector to rotate + * + * @return Rotated vector + * + * @note Angle is not clamped + */ + + template + TVector2 ClockwiseRotate(const TVector2& v1, T angle) + { + return Rotate(v1, -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/Vector3.hpp b/Engine/src/Runtime/Core/public/Math/Vector3.hpp new file mode 100644 index 0000000..fcca152 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/Vector3.hpp @@ -0,0 +1,1455 @@ +#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.hpp" +#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) + { + memcpy(this->comp, comp, sizeof(T) * 3); + } + + /** + * Move contructor + */ + + TVector3(TVector3&& v) + { + this->comp = v.comp; + v.comp = nullptr; + } + + /** + * Convert other type of vector + */ + + template + explicit TVector3(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 + */ + + TVector3(const Real x, const Real y, const Real z) + { + this->x = x; + this->y = y; + this->z = z; + } + + /** + * Contructor vector from two component array + * + * @param comp Array of components + */ + + TVector3(const Real* comp) + { + memcpy(this->comp, comp, sizeof(T) * 3); + } + + /** + * Constructs a vector pointing from start to end. + * + * @param(start) Startingpoint + * @param(end) Endpoint + */ + + 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; + }; + + }; + + + // ====================== // + // 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) + { + v1.x += s; + v1.y += s; + v1.z += s; + + return v1; + } + + /** + * 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) + { + v1.x += v2.x; + v1.y += v2.y; + v1.z += v2.z; + + return v1; + } + + /** + * 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) + { + v1.x -= s; + v1.y -= s; + v1.z -= s; + + return v1; + } + + /** + * 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) + { + v1.x -= v2.x; + v1.y -= v2.y; + v1.z -= v2.z; + + return v1; + } + + /** + * Dot product between two 3D Vectors + * + * @param(v1) vector one + * @param(s) floating point + */ + + template + inline TVector3 operator*= (TVector3& v1, T s) + { + v1.x *= s; + v1.y *= s; + v1.z *= s; + + return v1; + } + + /** + * 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) + { + s = (T)1.0 / s; + v1.x *= s; + v1.y *= s; + v1.z *= s; + + return v1; + } + + /** + * 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) + { + return TVector3(v1.x * s.v1.y * s, v1.z * 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) + { + s = (T)1.0 / s; + return TVector3(v1.x * s.v1.y * s, v1.z * s); + } + + /** + * Coponentwise multiplication of 3D Vectors with floating point + * + * @param(s) floating point + * @param(v2) vector + * + * @return Resultion vector + */ + + template + FORCEINLINE TVector3 operator* (T s, const TVector3& v1) + { + return v1 * s; + } + + /** + * Coponentwise multiplication of 3D Vectors with floating point + * + * @param(s) floating point + * @param(v1) vector + * + * @return Resultion vector + */ + + template + FORCEINLINE TVector3 operator/ (T s, const TVector3& v1) + { + return v1 / s; + } + + /** + * 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) + { + return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; + } + + /** + * 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) + { + return TVector3(v1.x + s.v1.y + s, v1.z + 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) + { + return TVector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z); + } + + /** + * 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) + { + return TVector3(v1.x - s.v1.y - s, v1.z - 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) + { + return TVector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z); + } + + /** + * Negates vector + * + * @param(v1) Vector to negate + */ + + template + TVector3 operator- (TVector3& v1) + { + v1.x = -v1.x; + v1.y = -v1.y; + v1.z = -v1.z; + + return 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) + { + 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); + } + + /** + * 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) + { + 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 // + // ==================================== // + + /** + * Gets magnitude of vector + * + * @param(v1) Vector + * + * @return Magnitude of vector + */ + + template + inline T Magnitude(const TVector3& v1) + { + return sqrt(DotP(v1, 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) + { + return DotP(v1, v1); + } + + /** + * @see SqrMagnitude + */ + + template + FORCEINLINE T SqrLength(const TVector3& v1) + { + return SqrMagnitude(v1); + } + + /** + * Normalizes vector + * + * @param(v1) Vector + * + * @note Result is stored in v1 + */ + + template + TVector3 NormalizeV(TVector3& v1) + { + float vecNorm = Magnitude(v1); + v1 /= (vecNorm < P_FLT_INAC) ? 1 : vecNorm; + + return v1; + } + + /** + * Normalizes vector + * + * @param(v1) Vector + * + * @note Does not test for zero vector + */ + + template + TVector3 UnsafeNormalizeV(TVector3& v1) + { + v1 /= Magnitude(v1); + + return v1; + } + + /** + * Reflects a vector on a surface + * + * @param(v1) Vector one + * @param(normal) Normal of surface + */ + + template + TVector3 ReflectV(TVector3& v1, const TVector3& normal) + { + Set(v1, v1 - (2 * (v1 * normal) * normal)); + + return v1; + } + + /** + * 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) + { + return acos((v1 * v2) / (Magnitude(v1) * Magnitude(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) + { + return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; + } + + /** + * Orthogonalizes three vectors. + * + * @param(v1) Vector one + * @param(v2) Vector two + * @param(v3) Vector two + */ + + template + void Orthogonalize(TVector3& v1, TVector3& v2, TVector3& v3) + { + Set(v2, Reject(v2, v1)); + Set(v3, Reject(Reject(v3, v1), v2)); + } + + /** + * 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) + { + Set(v2, Reject(v2, v1)); + Set(v3, Reject(Reject(v3, v1), v2)); + + NormalizeV(v1); + NormalizeV(v2); + NormalizeV(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) + { + return TVector3((v1.x >= 0) ? 1 : -1, + (v1.y >= 0) ? 1 : -1, + (v1.z >= 0) ? 1 : -1); + } + + /** + * 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) + { + return (abs(v1.x - v2.x) < threshold && abs(v1.y - v2.y) < threshold && abs(v1.z - v2.z) < threshold); + } + + /** + * Performs perspective divide on vector. + * + * @param(v1) Vector + */ + + template + TVector3 PerspectiveDivideV(TVector3& v1) + { + float _z = (T)1.0 / v1.z; + v1.x *= _z; + v1.y *= _z; + v1.z = (T)0.0; + return 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) + { + 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; + } + + /** + * 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) + { + v1.x = Max(v1.x, v2.x); + v1.y = Max(v1.y, v2.y); + v1.z = Max(v1.z, v2.z); + + return v1; + } + + /** + * 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) + { + v1.x = Min(v1.x, v2.x); + v1.y = Min(v1.y, v2.y); + v1.z = Min(v1.z, v2.z); + + return v1; + } + + /** + * Gets reversed vector. + * + * @param(v1) Vector one + * + * @note result is stored in v1. + */ + + template + TVector3 NegateV(TVector3& v1) + { + v1.x = -v1.x; + v1.y = -v1.y; + v1.z = -v1.z; + + return 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) + { + v1.x *= v2.x; + v1.y *= v2.y; + v1.z *= v2.z; + + return v1; + } + + /** + * 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) + { + float x = (v1 * v2) / (v2 * v2); + v1 = x * 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) + { + float x = (v1 * v2) / (v2 * v2); + v1 -= x * v2; + + return v1; + } + + /** + * Copies v1 vector + * + * @param(v1) Vector to copy to + * @param(v2) Vector to copy + */ + + template + TVector3 Set(TVector3& v1, const TVector3& v2) + { + v1 = v2; + + return v1; + } + + /** + * 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) + { + v1.x = x; + v1.y = y; + v1.z = z; + + return v1; + } + + /** + * 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) + { + T magnitude = Magnitude(v1); + + v1 = (magnitude > P_FLT_INAC) ? v1 / magnitude : PZeroVector3(T); + + Clamp(magnitude, min, max); + + v1 *= magnitude; + + return v1; + } + + /** + * Inverts the components of vector. + * + * @param(v1) Vector + * + * @note Result is stored in v1 + */ + + template + TVector3 CompInverseV(TVector3& v1) + { + v1.x = 1.0f / v1.x; + v1.y = 1.0f / v1.y; + v1.z = 1.0f / v1.z; + + return 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 TVector3& normal) + { + return ReflectV(v1, 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) + { + 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; + } + + /** + * 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) + { + NormalizeV(v1) *= magnitude; + + return v1; + } + + /** + * Returns signs of components in vector: -1 / +1 / 0. + * + * @param(v1) Vector one + */ + + template + TVector3 SignVectorV(TVector3& v1) + { + v1.x = (v1.x >= 0) ? 1 : -1; + v1.y = (v1.y >= 0) ? 1 : -1; + v1.z = (v1.z >= 0) ? 1 : -1; + + return 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) + { + return CrossP(v1, v2) * 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) + { + return (v1 * v2) / (Magnitude(v1) * Magnitude(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) + { + CrossPV(CrossPV(v1, v2), v3); + + return v1; + } + + /** + * 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) + { + return (abs(DotP(v1, v2)) < threshold); + } + + /** + * 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) + { + return (abs(DotP(v1, v2)) > threshold); + } + + /** + * 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) + { + return (DotP(v1, v2) > threshold); + } + + /** + * 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) + { + return (SqrMagnitude(v1) < threshold); + } + + /** + * 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) + { + return (ScalarTriple(v1, v2, v3) < threshold); + } + + /** + * 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) + { + float vecNorm = Magnitude(v1); + return (vecNorm < P_FLT_INAC) ? PZeroVector3(T) : v1 / vecNorm; + } + + /** + * Normalizes vector + * + * @param(v1) Vector + * + * @note Does not test for zero vector + */ + + template + TVector3 UnsafeNormalize(const TVector3& v1) + { + return v1 / Magnitude(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) + { + return v1 - (2 * (v1 * normal) * normal); + } + + + /** + * Performes perspective divide on vector. + * + * @param(v1) vector to perspective divide + * + * @return Perspective divided vector + */ + + template + TVector3 PerspectiveDivide(const TVector3& v1) + { + float _z = (T)1.0 / v1.z; + return TVector3(v1.x * _z, v1.y * _z, (T)0.0); + } + + /** + * 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) + { + 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)); + } + + /** + * 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) + { + t = Clamp(t, (T)0.0, (T), 1.0); + return (1 - t) * start + t * dest; + } + + /** + * 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) + { + return (1 - t) * start + t * dest; + } + + /** + * 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) + { + 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); + } + + /** + * 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) + { + 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); + } + + /** + * Gets reversed vector. + * + * @param(v1) Vector one + * + * @note result is stored in v1. + */ + + template + TVector3 Negate(const TVector3& v1) + { + return TVector3(-v1.x, -v1.y, -v1.z); + } + + /** + * 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) + { + return TVector3(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z); + } + + /** + * 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) + { + T magnitude = Magnitude(v1); + + const TVector3 unitVec = (magnitude > P_FLT_INAC) ? v1 / magnitude : PZeroVector3(T); + + Clamp(magnitude, min, max); + + return unitVec * magnitude; + } + + /** + * 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) + { + return Normalize(v1) * magnitude; + } + + /** + * Clamps vector into cube. + * + * @param(v1) Vector + * + * @result Vector with inverted components. + */ + + template + TVector3 CompInverse(const TVector3& v1) + { + return TVector3((T)1.0f / v1.x, (T)1.0f / v1.y, (T)1.0f / v1.z); + } + + /** + * 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) + { + T sinAngle = sin(angle); + T cosAngle = cos(angle); + + return (1 - cosAngle) * DotP(v1, axisNormal) * axisNormal + cosAngle * v1 + sinAngle * CrossP(v1, axisNormal); + } + + /** + * 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) + { + return CrossP(CrossP(v1, v2), 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) + { + return (DotP(v1, v2) / DotP(v2, v2)) * 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) + { + return v1 - (DotP(v1, v2) / DotP(v2, v2)) * v2; + } + + /** + * 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/Tests/TestProject/Main.cpp b/Tests/TestProject/Main.cpp index 3c2bc7e..76eff4f 100644 --- a/Tests/TestProject/Main.cpp +++ b/Tests/TestProject/Main.cpp @@ -1,12 +1,11 @@ -#include "Core/public/Math/Vector2.h" - -namespace PMath = Phanes::Core::Math; +#include int main() { - float t = 2; - PMath::Clamp(t, 2.0f, 4.0f); - + int x = 13; + x %= 7; - return 0; + std::cout << x; + + return 0; } \ No newline at end of file