diff --git a/.gitignore b/.gitignore index b34b882..a7ee7c2 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,23 @@ +# Exclude folders +bin/ +bin-int/ +external/ + +# Exclude files + +# Temporary excludes + +Matrix2d.cpp +Matrix3.cpp +Matrix4.cpp +Vector4.cpp + +Matrix3.h +Matrix4.h +Vector4.h + +############################################################################################ + ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. ## @@ -401,13 +421,4 @@ FodyWeavers.xsd *.sln *.vcxproj -*.filters - - - - -# Exclude other folders - -bin/ -bin-int/ -external/ \ No newline at end of file +*.filters \ No newline at end of file diff --git a/.gitmodules b/.gitmodules index e69de29..c1fd6c3 100644 --- a/.gitmodules +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "Engine/ThirdParty/spdlog"] + path = Engine/ThirdParty/spdlog + url = https://github.com/gabime/spdlog diff --git a/Engine/ThirdParty/spdlog b/Engine/ThirdParty/spdlog new file mode 160000 index 0000000..27cb4c7 --- /dev/null +++ b/Engine/ThirdParty/spdlog @@ -0,0 +1 @@ +Subproject commit 27cb4c76708608465c413f6d0e6b8d99a4d84302 diff --git a/Engine/src/Runtime/Core/Core.h b/Engine/src/Runtime/Core/Core.h index 80942d0..d8339dd 100644 --- a/Engine/src/Runtime/Core/Core.h +++ b/Engine/src/Runtime/Core/Core.h @@ -3,6 +3,16 @@ #ifdef P_WIN_BUILD + #ifdef P_BUILD_LIB + + #define PHANES_CORE __declspec(dllexport) + + #else + + #define PHANES_CORE __declspec(dllimport) + + #endif + #ifdef P_DEBUG #define P_DEBUGBREAK DebugBreak(); diff --git a/Engine/src/Runtime/Core/Include.h b/Engine/src/Runtime/Core/Include.h index c8fc837..55e8d35 100644 --- a/Engine/src/Runtime/Core/Include.h +++ b/Engine/src/Runtime/Core/Include.h @@ -1,12 +1,16 @@ #pragma once +// --- Logging ------------------------------------- + +#include "Core/public/Logging/Logging.h" // --- Starting point ------------------------------ - #include "Core/public/StartingPoint/StartingPoint.h" #include "Core/public/StartingPoint/EntryPoint.h" + + // --- OSAL ---------------------------------------- #include "Core/public/OSAL/PlatformTypes.h" @@ -18,6 +22,4 @@ // Starting point namespace PApp = Phanes::Core::Application; - using namespace Phanes::Core::Math::UnitLiterals; - #endif \ No newline at end of file diff --git a/Engine/src/Runtime/Core/private/Logging/Logging.cpp b/Engine/src/Runtime/Core/private/Logging/Logging.cpp new file mode 100644 index 0000000..4f77860 --- /dev/null +++ b/Engine/src/Runtime/Core/private/Logging/Logging.cpp @@ -0,0 +1,14 @@ +#include "PhanesEnginePCH.h" + +#include "Core/public/Logging/Logging.h" + +void Phanes::Core::Logging::Init() +{ + spdlog::set_pattern("%^[%n][%T][%l]:%$ %v"); + + _PEngineLogger = spdlog::stdout_color_mt("PHANES"); + _PEngineLogger->set_level(spdlog::level::trace); + + _PAppLogger = spdlog::stdout_color_mt("GAME"); + _PAppLogger->set_level(spdlog::level::trace); +} \ No newline at end of file diff --git a/Engine/src/Runtime/Core/private/Math/IntPoint.cpp b/Engine/src/Runtime/Core/private/Math/IntPoint.cpp new file mode 100644 index 0000000..53c23ff --- /dev/null +++ b/Engine/src/Runtime/Core/private/Math/IntPoint.cpp @@ -0,0 +1,15 @@ +#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 new file mode 100644 index 0000000..f770a06 --- /dev/null +++ b/Engine/src/Runtime/Core/private/Math/IntVector2.cpp @@ -0,0 +1,461 @@ +// ============================== // +// TIntVector2 implementation // +// ============================== // + + +#include "PhanesEnginePCH.h" + +#include "Core/public/Math/IntVector2.h" + +#include "Core/public/Math/IntPoint.h" + +//#include "Math/Matrix2.h" +//#include "Math/Matrix2.h" +//#include "Math/Vector3.h" +//#include "Math/Vector4.h" +//#include "Math/IntVector2.h" +//#include "Math/IntVector3.h" +//#include "Math/IntVector4.h" + + +// ============================ // +// TIntVector2 constructors // +// ============================ // + +template +Phanes::Core::Math::TIntVector2::TIntVector2(const T x, const T y) +{ + this->x = x; + this->y = y; +} + +template +Phanes::Core::Math::TIntVector2::TIntVector2(const T* comp) +{ + static_assert(sizeof(comp) > 2 * sizeof(T), "PHANES_CORE (IntVector2.cpp): Setting 2D vector coordinates by an array, comp must have a size of at least 2 components."); + memcpy(this->comp, comp, sizeof(T) * 2); +} + +template +Phanes::Core::Math::TIntVector2::TIntVector2(const TIntPoint2& start, const TIntPoint2& end) +{ + this->x = end.x - start.x; + this->y = end.y - start.y; +} + +template +Phanes::Core::Math::TIntVector2::TIntVector2(const TIntVector3& v) +{ + this->x = v.x; + this->y = v.y; +} + +template +Phanes::Core::Math::TIntVector2::TIntVector2(const TIntVector2& v) +{ + memcpy(this->comp, comp, sizeof(T) * 2); +} + +template +Phanes::Core::Math::TIntVector2::TIntVector2(TIntVector2&& v) +{ + this->comp = v.comp; + v.comp = nullptr; +} + + +// ========================= // +// TIntVector2 operators // +// ========================= // + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator+=(TIntVector2& v1, T s) +{ + v1.x += s; + v1.y += s; + + return v1; +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator+=(TIntVector2& v1, const TIntVector2& v2) +{ + v1.x += v2.x; + v1.y += v2.y; + + return v1; +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator-=(TIntVector2& v1, T s) +{ + v1.x -= s; + v1.y -= s; + + return v1; +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator-=(TIntVector2& v1, const TIntVector2& v2) +{ + v1.x -= v2.x; + v1.y -= v2.y; + + return v1; +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator*=(TIntVector2& v1, T s) +{ + v1.x *= s; + v1.y *= s; + + return v1; +} +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator*(const TIntVector2& v1, T s) +{ + return TIntVector2(v1.x * s, v1.y * s); +} + +template +inline Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator*(T s, const TIntVector2& v1) +{ + return v1 * s; +} + +template +Rt Phanes::Core::Math::operator* (const TIntVector2& v1, const TIntVector2& v2) +{ + return v1.x * v2.x + v1.y * v2.y; +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator+(const TIntVector2& v1, T s) +{ + return TIntVector2(v1.x + s, v1.y + s); +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator+(const TIntVector2& v1, const TIntVector2& v2) +{ + return TIntVector2(v1.x + v2.x, v1.y + v2.y); +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator-(const TIntVector2& v1, T s) +{ + return TIntVector2(v1.x - s, v1.y - s); +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::operator-(const TIntVector2& v1, const TIntVector2& v2) +{ + return TIntVector2(v1.x - v2.x, v1.y - v2.y); +} + +template +void Phanes::Core::Math::operator-(TIntVector2& v1) +{ + v1.x = -v1.x; + v1.y = -v1.y; +} + +template +bool Phanes::Core::Math::operator== (const TIntVector2& v1, const TIntVector2& v2) +{ + return (abs(v1.x - v1.x) < P_FLT_INAC && abs(v1.y - v1.y) < P_FLT_INAC); +} + +template +bool Phanes::Core::Math::operator!=(const TIntVector2& v1, const TIntVector2& v2) +{ + return (abs(v1.x - v1.x) > P_FLT_INAC || abs(v1.y - v1.y) > P_FLT_INAC); +} + +template +Rt Phanes::Core::Math::Magnitude(const TIntVector2& v1) +{ + return sqrtf(v1.x * v1.x + v1.y * v1.y); +} + +template +T Phanes::Core::Math::SqrMagnitude(const TIntVector2& v1) +{ + return v1.x * v1.x + v1.y * v1.y; +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::DivideTruncV(TIntVector2& v1, T s) +{ + Rt _s = (Rt)1.0 / s; + + v1.x = trunc(v1.x * s); + v1.y = trunc(v1.y * s); + + return v1; +} + +template +Rt Phanes::Core::Math::Angle(const TIntVector2& v1, const TIntVector2& v2) +{ + return acos((v1 * v2) / Magnitude(v1) * Magnitude(v2)); +} + + +template +Rt Phanes::Core::Math::CosineAngle(const TIntVector2& v1, const TIntVector2& v2) +{ + return (v1 * v2) / Magnitude(v1) * Magnitude(v2); +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::SignVectorV(TIntVector2& v1) +{ + v1.x = (v1.x > 0) ? 1 : -1; + v1.y = (v1.y > 0) ? 1 : -1; + + return v1; +} + +template +T Phanes::Core::Math::DotP(const TIntVector2& v1, const TIntVector2& v2) +{ + return v1.x * v2.x + v1.y * v2.y; +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::MaxV(TIntVector2& v1, const TIntVector2& v2) +{ + v1.x = Phanes::Core::Math::Max(v1.x, v2.x); + v1.y = Phanes::Core::Math::Max(v1.y, v2.y); + + return v1; +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::MinV(TIntVector2& v1, const TIntVector2& v2) +{ + v1.x = Phanes::Core::Math::Min(v1.x, v2.x); + v1.y = Phanes::Core::Math::Min(v1.y, v2.y); + + return v1; +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::GetPerpendicularV(TIntVector2& v1) +{ + T x = v1.x; + v1.x = v1.y; + v1.y = -v1.x; + + return v1; +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::GetReversePerpendicularV(TIntVector2& v1) +{ + T x = v1.x; + v1.x = -v1.y; + v1.y = v1.x; + + return v1; +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::ScaleV(TIntVector2& v1, const TIntVector2& v2) +{ + v1.x *= v2.x; + v1.y *= v2.y; + + return v1; +} + + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::Set(TIntVector2& v1, const TIntVector2& v2) +{ + v1 = v2; + + return v1; +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::Set(TIntVector2& v1, T x, T y) +{ + v1.x = x; + v1.y = y; + + return v1; +} + + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::NegateV(TIntVector2& v1) +{ + v1.x = -v1.x; + v1.y = -v1.y; +} + +template +inline bool Phanes::Core::Math::IsNormalized(const TIntVector2& v1) +{ + return (SqrMagnitude(v1)); +} + +template +inline bool Phanes::Core::Math::IsPerpendicular(const TIntVector2& v1, const TIntVector2& v2) +{ + return (abs(DotP(v1, v2)) = 0); +} + +template +inline bool Phanes::Core::Math::IsParallel(const TIntVector2& v1, const TIntVector2& v2) +{ + return (abs(DotP(v1, v2)) = 1); +} + +template +inline bool Phanes::Core::Math::IsCoincident(const TIntVector2& v1, const TIntVector2& v2) +{ + return (DotP(v1, v2) > 1); +} + +// +//Phanes::Core::Math::Matrix2 Phanes::Core::Math::OuterProduct(const TIntVector2& v1, const TIntVector2& v2) +//{ +// return Matrix2( +// v1.x * v2.x, v1.x * v2.y, +// v1.y * v2.x, v1.y * v2.y +// ); +//} + +// ================================================================= // +// TIntVector2 static function implementation with return values // +// ================================================================= // + +template +Phanes::Core::Math::TVector2 Phanes::Core::Math::Reflect(const TIntVector2& v1, const TVector2& normal) +{ + return TVector2(v1 - (2 * (v1 * normal) * normal)); +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::Scale(const TIntVector2& v1, const TIntVector2& v2) +{ + return TIntVector2(v1.x * v2.x, v1.y * v2.y); +} + +template +Phanes::Core::Math::TVector2 Phanes::Core::Math::CompInverse(const TIntVector2& v1) +{ + return TVector2(1.0f / v1.x, 1.0f / v1.y); +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::Negate(const TIntVector2& v1) +{ + return TIntVector2(-v1.x, -v1.y); +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::GetPerpendicular(const TIntVector2& v1) +{ + return TIntVector2(v1.y, -v1.x); +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::GetReversePerpendicular(const TIntVector2& v1) +{ + return TIntVector2(-v1.y, v1.x); +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::Min(const TIntVector2& v1, const TIntVector2& v2) +{ + return TIntVector2(Phanes::Core::Math::Min(v1.x, v2.x), Phanes::Core::Math::Min(v1.y, v2.y)); +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::Max(const TIntVector2& v1, const TIntVector2& v2) +{ + return TIntVector2(Phanes::Core::Math::Max(v1.x, v2.x), Phanes::Core::Math::Max(v1.y, v2.y)); +} + +template +Phanes::Core::Math::TVector2 Phanes::Core::Math::Normalize(const TIntVector2& v1) +{ + float vecNorm = Magnitude(v1); + return (vecNorm < P_FLT_INAC) ? PIntZeroVector2(T) : (v1 / vecNorm); +} + +template +Phanes::Core::Math::TVector2 Phanes::Core::Math::UnsafeNormalize(const TIntVector2& v1) +{ + return TVector2(v1 / Magnitude(v1)); +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::SignVector(const TIntVector2& v1) +{ + return TIntVector2((v1.x > 0) ? 1 : -1, (v1.y > 0) ? 1 : -1); +} + +template +Phanes::Core::Math::TVector2 Phanes::Core::Math::BindToSquare(const TIntVector2& v1, T radius) +{ + float k = (abs(v1.x) > abs(v1.y)) ? abs(radius / v1.x) : abs(radius / v1.y); + return v1 * k; +} + +template +Phanes::Core::Math::TVector2 Phanes::Core::Math::ClampToSquare(const TIntVector2& v1, T radius) +{ + float prime = (abs(v1.x) > abs(v1.y)) ? v1.x : v1.y; + float k = (prime > radius) ? abs(radius / prime) : 1.0f; + + return TVector2(v1 * k); +} + +template +Phanes::Core::Math::TVector2 Phanes::Core::Math::Lerp(const TIntVector2& startVec, const TIntVector2& destVec, Rt t) +{ + t = Phanes::Core::Math::Clamp(t, (T)0.0, (T)1.0); + + return ((Rt)t * destVec) + (((Rt)1.0 - t) * startVec); +} + +template +Phanes::Core::Math::TVector2 Phanes::Core::Math::LerpUnclamped(const TIntVector2& startVec, const TIntVector2& destVec, Rt t) +{ + return ((Rt)t * destVec) + (((Rt)1.0 - t) * startVec); +} + +template +Phanes::Core::Math::TVector2 Phanes::Core::Math::Rotate(const TIntVector2& v1, Rt angle) +{ + float sinAngle = sin(angle); + float cosAngle = cos(angle); + + return TVector2((Rt)v1.x * cosAngle - (Rt)v1.y * sinAngle, (Rt)v1.y * cosAngle + (Rt)v1.x * sinAngle); +} + +template +Phanes::Core::Math::TVector2 Phanes::Core::Math::ClockwiseRotate(const TIntVector2& v1, Rt angle) +{ + return Rotate(v1, -angle); +} + +template +Phanes::Core::Math::TIntVector2 Phanes::Core::Math::DivideTrunc(const TIntVector2& v1, T s) +{ + Rt _s = (Rt)1.0 / s; + return TIntVector2(trunc(v1.x * _s), trunc(v1.y * _s)); +} + +template +Phanes::Core::Math::TVector2 Phanes::Core::Math::DivideFloat(const TIntVector2& v1, T s) +{ + Rt _s = (Rt)1.0 / s; + return TIntVector2((Rt)v1.x * _s, (Rt)v1.y * _s); +} diff --git a/Engine/src/Runtime/Core/private/Math/IntVector3.cpp b/Engine/src/Runtime/Core/private/Math/IntVector3.cpp new file mode 100644 index 0000000..4e8d81f --- /dev/null +++ b/Engine/src/Runtime/Core/private/Math/IntVector3.cpp @@ -0,0 +1,514 @@ +// ============================== // +// TIntVector2 implementation // +// ============================== // + + +#include "PhanesEnginePCH.h" + +#include "Core/public/Math/IntVector3.h" + +#include "Core/public/Math/IntPoint.h" +#include "Core/public/Math/Plane.h" + + +template +inline Phanes::Core::Math::TIntVector3::TIntVector3(const T x, const T y, const T z) +{ + this->x = x; + this->y = y; + this->z = z; +} + +template +Phanes::Core::Math::TIntVector3::TIntVector3(const T* comp) +{ + static_assert(sizeof(comp) > 2 * sizeof(T), "PHANES_CORE (IntVector3.cpp): Setting 3D vector coordinates by an array, comp must have a size of at least 3 components."); + memcpy(this->comp, comp, sizeof(T) * 3); +} + +template +Phanes::Core::Math::TIntVector3::TIntVector3(const TIntVector2& v) +{ + this->x = v.x; + this->y = v.y; + this->z = (T)0; +} + +template +Phanes::Core::Math::TIntVector3::TIntVector3(const TIntPoint3& start, const TIntPoint3& end) +{ + this->x = end.x - start.x; + this->y = end.y - start.y; + this->z = end.z - start.z; +} + +template +Phanes::Core::Math::TIntVector3::TIntVector3(const TIntVector3& v) +{ + memcpy(this->comp, comp, sizeof(T) * 3); +} + +template +Phanes::Core::Math::TIntVector3::TIntVector3(TIntVector3&& v) +{ + this->comp = v.comp; + v.comp = nullptr; +} + +// ========================= // +// TIntVector3 operators // +// ========================= // + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator+=(TIntVector3& v1, T s) +{ + v1.x += s; + v1.y += s; + v1.z += s; + + return v1; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator+=(TIntVector3& v1, const TIntVector3& v2) +{ + v1.x += v2.x; + v1.y += v2.y; + v1.z += v2.z; + + return v1; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator-=(TIntVector3& v1, T s) +{ + v1.x -= s; + v1.y -= s; + v1.z -= s; + + return v1; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator-=(TIntVector3& v1, const TIntVector3& v2) +{ + v1.x -= v2.x; + v1.y -= v2.y; + v1.z -= v2.z; + + return v1; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator*=(TIntVector3& v1, T s) +{ + v1.x *= s; + v1.y *= s; + v1.z *= s; + + return v1; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator*(const TIntVector3& v1, T s) +{ + return TIntVector3(v1.x * s.v1.y * s, v1.z * s); +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator*(T s, const TIntVector3& v1) +{ + return v1 * s; +} + +template +T Phanes::Core::Math::operator*(const TIntVector3& v1, const TIntVector3& v2) +{ + return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator+(const TIntVector3& v1, T s) +{ + return TIntVector3(v1.x + s.v1.y + s, v1.z + s); +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator+(const TIntVector3& v1, const TIntVector3& v2) +{ + return TIntVector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z); +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator-(const TIntVector3& v1, T s) +{ + return TIntVector3(v1.x - s.v1.y - s, v1.z - s); +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator-(const TIntVector3& v1, const TIntVector3& v2) +{ + return TIntVector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z); +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::operator-(TIntVector3& v1) +{ + v1.x = -v1.x; + v1.y = -v1.y; + v1.z = -v1.z; + + return v1; +} + +template +bool Phanes::Core::Math::operator==(const TIntVector3& v1, const TIntVector3& v2) +{ + return (abs(v1.x - v2.x) < P_FLT_INAC && abs(v1.y - v2.y) < P_FLT_INAC && abs(v1.z - v2.z) < P_FLT_INAC); +} + +template +bool Phanes::Core::Math::operator!=(const TIntVector3& v1, const TIntVector3& v2) +{ + return (abs(v1.x - v2.x) > P_FLT_INAC || abs(v1.y - v2.y) > P_FLT_INAC || abs(v1.z - v2.z) > P_FLT_INAC); +} + +// ======================================= // +// TIntVector3 function implementation // +// ======================================= // + +template +Rt Phanes::Core::Math::Magnitude(const TIntVector3& v1) +{ + return sqrt(DotP(v1, v1)); +} + +template +T Phanes::Core::Math::SqrMagnitude(const TIntVector3& v1) +{ + return DotP(v1, v1); +} + +template +Rt Phanes::Core::Math::Angle(const TIntVector3& v1, const TIntVector3& v2) +{ + return acos((v1 * v2) / (Magnitude(v1) * Magnitude(v2))); +} + +template +T Phanes::Core::Math::DotP(const TIntVector3& v1, const TIntVector3& v2) +{ + return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::VectorTriple(const TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3) +{ + return CrossP(CrossP(v1, v2), v3); +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::SignVector(const TIntVector3& v1) +{ + v1.x = (v1.x > 0) - (v1.x < 0); + v1.y = (v1.y > 0) - (v1.y < 0); + v1.z = (v1.z > 0) - (v1.z < 0); + + + return v1; +} + +template +bool Phanes::Core::Math::Equals(const TIntVector3& v1, const TIntVector3& v2, T threshold) +{ + return (abs(v1.x - v2.x) < threshold && abs(v1.y - v2.y) < threshold && abs(v1.z - v2.z) < threshold); +} + + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::CrossPV(TIntVector3& v1, const TIntVector3& v2) +{ + float x = v1.x; + float y = v1.y; + float z = v1.z; + + v1.x = (y * v2.z) - (z * v2.y); + v1.y = (z * v2.x) - (x * v2.z); + v1.z = (x * v2.y) - (y * v2.x); + + return v1; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::MaxV(TIntVector3& v1, const TIntVector3& v2) +{ + v1.x = Max(v1.x, v2.x); + v1.y = Max(v1.y, v2.y); + v1.z = Max(v1.z, v2.z); + + return v1; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::MinV(TIntVector3& v1, const TIntVector3& v2) +{ + v1.x = Min(v1.x, v2.x); + v1.y = Min(v1.y, v2.y); + v1.z = Min(v1.z, v2.z); + + return v1; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::NegateV(TIntVector3& v1) +{ + v1.x = -v1.x; + v1.y = -v1.y; + v1.z = -v1.z; + + return v1; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::ScaleV(TIntVector3& v1, const TIntVector3& v2) +{ + v1.x *= v2.x; + v1.y *= v2.y; + v1.z *= v2.z; + + return v1; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::Set(TIntVector3& v1, const TIntVector3& v2) +{ + v1 = v2; + + return v1; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::Set(TIntVector3& v1, T x, T y, T z) +{ + v1.x = x; + v1.y = y; + v1.z = z; + + return v1; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::SignVectorV(TIntVector3& v1) +{ + v1.x = (v1.x > 0) ? 1 : 0; + v1.y = (v1.y > 0) ? 1 : 0; + v1.z = (v1.z > 0) ? 1 : 0; + + return v1; +} + +template +T Phanes::Core::Math::ScalarTriple(const TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3) +{ + return CrossP(v1, v2) * v3; +} + +template +T Phanes::Core::Math::CosineAngle(const TIntVector3& v1, const TIntVector3& v2) +{ + return (v1 * v2) / (Magnitude(v1) * Magnitude(v2)); +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::VectorTripleV(TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3) +{ + CrossPV(CrossPV(v1, v2), v3); + + return v1; +} + +template +bool Phanes::Core::Math::IsPerpendicular(const TIntVector3& v1, const TIntVector3& v2, T threshold) +{ + return (abs(DotP(v1, v2)) < threshold); +} + +template +bool Phanes::Core::Math::IsParallel(const TIntVector3& v1, const TIntVector3& v2, T threshold) +{ + return (abs(DotP(v1, v2)) > threshold); +} + +template +bool Phanes::Core::Math::IsCoincident(const TIntVector3& v1, const TIntVector3& v2, T threshold) +{ + return (DotP(v1, v2) > threshold); +} + +template +bool Phanes::Core::Math::IsNormalized(const TIntVector3& v1, T threshold) +{ + return (SqrMagnitude(v1) < threshold); +} + +template +bool Phanes::Core::Math::IsCoplanar(const TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3, T threshold) +{ + return (ScalarTriple(v1, v2, v3) < threshold); +} + + + +// =============== // +// With Return // +// =============== // + + + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Normalize(const TIntVector3& v1) +{ + float vecNorm = Magnitude(v1); + return (vecNorm < P_FLT_INAC) ? PZeroVector3(T) : v1 / vecNorm; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::UnsafeNormalize(const TIntVector3& v1) +{ + return v1 / Magnitude(v1); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Reflect(const TIntVector3& v1, const TVector3& normal) +{ + return v1 - (2 * (v1 * normal) * normal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::PerspectiveDivide(const TIntVector3& v1) +{ + float _z = (T)1.0 / v1.z; + return TIntVector3(v1.x * _z, v1.y * _z, (T)0.0); +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::CrossP(const TIntVector3& v1, const TIntVector3& v2) +{ + return TIntVector3((v1.y * v2.z) - (v1.z * v2.y), + (v1.z * v2.x) - (v1.x * v2.z), + (v1.x * v2.y) - (v1.y * v2.x)); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Lerp(const TIntVector3& start, const TIntVector3& dest, Rt t) +{ + t = Clamp(t, (Rt)0.0, (Rt), 1.0); + return ((Rt)1.0 - t) * start + t * dest; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::LerpUnclamped(const TIntVector3& start, const TIntVector3& dest, Rt t) +{ + return (1 - t) * start + t * dest; +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::Max(const TIntVector3& v1, const TIntVector3& v2) +{ + return TIntVector3((v1.x > v2.x) ? v1.x : v2.x, + (v1.y > v2.y) ? v1.y : v2.y, + (v1.z > v2.z) ? v1.z : v2.z); +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::Min(const TIntVector3& v1, const TIntVector3& v2) +{ + return TIntVector3((v1.x < v2.x) ? v1.x : v2.x, + (v1.y < v2.y) ? v1.y : v2.y, + (v1.z < v2.z) ? v1.z : v2.z); +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::Negate(const TIntVector3& v1) +{ + return TIntVector3(-v1.x, -v1.y, -v1.z); +} + +template +Phanes::Core::Math::TIntVector3 Phanes::Core::Math::Scale(const TIntVector3& v1, const TIntVector3& v2) +{ + return TIntVector3(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ClampMagnitude(const TIntVector3& v1, T min, T max) +{ + Rt magnitude = Magnitude(v1); + + const TVector3 unitVec = (magnitude > P_FLT_INAC) ? v1 / magnitude : PZeroVector3(T); + + Clamp(magnitude, min, max); + + return unitVec * magnitude; +} + + + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ScaleToMagnitude(const TIntVector3& v1, T magnitude) +{ + NormalizeV(v1) *= magnitude; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::CompInverse(const TIntVector3& v1) +{ + return TIntVector3((Rt)1.0 / v1.x, (Rt)1.0 / v1.y, (Rt)1.0 / v1.z); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ReflectFromPlane(const TIntVector3& v1, const TPlane& plane) +{ + return Reflect(v1, plane.normal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ReflectFromPlane(const TIntVector3& v1, const TVector3& normal) +{ + return Reflect(v1, normal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::RotateAroundAxis(const TIntVector3& v1, const TVector3& axisNormal, Rt angle) +{ + T sinAngle = sin(angle); + T cosAngle = cos(angle); + + return ((Rt)1 - cosAngle) * DotP(v1, axisNormal) * axisNormal + cosAngle * v1 + sinAngle * CrossP(v1, axisNormal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Project(const TIntVector3& v1, const TIntVector3& v2) +{ + return (DotP(v1, v2) / DotP(v2, v2)) * v2; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Reject(const TIntVector3& v1, const TIntVector3& v2) +{ + return v1 - (DotP(v1, v2) / DotP(v2, v2)) * v2; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ProjectOntoPlane(const TIntVector3& v1, const TVector3& normal) +{ + return Reject(v1, normal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ProjectOntoPlane(const TIntVector3& v1, const TPlane& plane) +{ + return Reject(v1, plane.normal); +} \ No newline at end of file diff --git a/Engine/src/Runtime/Core/private/Math/MathCommon.cpp b/Engine/src/Runtime/Core/private/Math/MathCommon.cpp new file mode 100644 index 0000000..d673e3d --- /dev/null +++ b/Engine/src/Runtime/Core/private/Math/MathCommon.cpp @@ -0,0 +1,57 @@ +#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 new file mode 100644 index 0000000..c4a0934 --- /dev/null +++ b/Engine/src/Runtime/Core/private/Math/MathTypeConversion.cpp @@ -0,0 +1,48 @@ +#include "PhanesEnginePCH.h" +#include "Core/public/Math/MathTypeConversion.h" + +// ============ // +// ToString // +// ============ // + +template +std::string Phanes::Core::Math::ToString(const Phanes::Core::Math::TVector2& v) { + return "(" + std::to_string(v.x) + ", " + std::to_string(v.y) + ")"; +} + +template +std::string Phanes::Core::Math::ToString(const TIntVector2& v) +{ + return "(" + std::to_string(v.x) + ", " + std::to_string(v.y) + ")"; +} + +template +std::string Phanes::Core::Math::ToString(const Phanes::Core::Math::TVector3& v) { + return "(" + std::to_string(v.x) + ", " + std::to_string(v.y) + ", " + std::to_string(v.z) + ")"; +} + +template +std::string Phanes::Core::Math::ToString(const TIntVector3& v) +{ + std::to_string(3); + + return "(" + std::to_string(v.x) + ", " + std::to_string(v.y) + ", " + std::to_string(v.z) + ")"; +} + +//template +//std::string Phanes::Core::Math::ToString(const Vector4& v) +//{ +// return "(" + std::to_string(v.x) + ", " + std::to_string(v.y) + ", " + std::to_string(v.z) + ", " + std::to_string(v.w) + ")"; +//} +// +//template +//std::string Phanes::Core::Math::ToString(const Matrix2& v) +//{ +// return std::to_string(v(0,0)) + " | " + std::to_string(v(0,1)) + "\n" + std::to_string(v(1,0)) + " | " + std::to_string(v(1,1)); +//} +// +//template +//std::string Phanes::Core::Math::ToString(const Matrix3& v) +//{ +// return std::to_string(v(0, 0)) + " | " + std::to_string(v(0, 1)) + " | " + std::to_string(v(0, 2)) + "\n" + std::to_string(v(1, 0)) + " | " + std::to_string(v(1, 1)) + " | " + std::to_string(v(1, 2)) + "\n" + std::to_string(v(2, 0)) + " | " + std::to_string(v(2, 1)) + " | " + std::to_string(v(2, 2)); +//} diff --git a/Engine/src/Runtime/Core/private/Math/MathUnitConversion.cpp b/Engine/src/Runtime/Core/private/Math/MathUnitConversion.cpp new file mode 100644 index 0000000..81f6b32 --- /dev/null +++ b/Engine/src/Runtime/Core/private/Math/MathUnitConversion.cpp @@ -0,0 +1,60 @@ +#include "PhanesEnginePCH.h" + +#include "Core/public/Math/MathUnitConversion.h" + + +template +inline T Phanes::Core::Math::UnitConversion::DegToRad(T deg) +{ + return deg * P_PI_180_FLT; +} + +template +inline T Phanes::Core::Math::UnitConversion::RadToDeg(T rad) +{ + return rad * P_180_PI_FLT; +} + +template +inline T Phanes::Core::Math::UnitConversion::DegToGradian(T deg) +{ + return deg * 1.111111f; +} + +template +inline T Phanes::Core::Math::UnitConversion::GradianToDeg(T g) +{ + return g * 0.9f; +} + +template +inline T Phanes::Core::Math::UnitConversion::RadToGradian(T rad) +{ + return rad * 200 / P_PI_FLT; +} + +template +inline T Phanes::Core::Math::UnitConversion::GradianToRad(T g) +{ + return g * P_PI_FLT / 200; +} + + + +// Unit Literals + +double Phanes::Core::Math::UnitLiterals::operator""_deg(long double _x) +{ + return _x * P_PI_180_FLT; +} + +double Phanes::Core::Math::UnitLiterals::operator""_rad(long double _x) +{ + return _x; +} + +double Phanes::Core::Math::UnitLiterals::operator""_g(long double _x) +{ + return _x * P_PI_FLT / 200; +} + diff --git a/Engine/src/Runtime/Core/private/Math/Matrix2.cpp b/Engine/src/Runtime/Core/private/Math/Matrix2.cpp new file mode 100644 index 0000000..a3580b7 --- /dev/null +++ b/Engine/src/Runtime/Core/private/Math/Matrix2.cpp @@ -0,0 +1,145 @@ +// =========================== // +// 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 new file mode 100644 index 0000000..75228b4 --- /dev/null +++ b/Engine/src/Runtime/Core/private/Math/Point.cpp @@ -0,0 +1,34 @@ +#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 new file mode 100644 index 0000000..df6fe9a --- /dev/null +++ b/Engine/src/Runtime/Core/private/Math/Vector2.cpp @@ -0,0 +1,571 @@ +// =========================== // +// 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 new file mode 100644 index 0000000..24e8384 --- /dev/null +++ b/Engine/src/Runtime/Core/private/Math/Vector3.cpp @@ -0,0 +1,669 @@ +// =========================== // +// TVector3 implementation // +// =========================== // + +#include "PhanesEnginePCH.h" + +#include "Core/public/Math/Vector3.h" + +#include "Core/public/Math/Point.h" +#include "Core/public/Math/Plane.h" + +template +inline Phanes::Core::Math::TVector3::TVector3(const Real x, const Real y, const Real z) +{ + this->x = x; + this->y = y; + this->z = z; +} + +template +Phanes::Core::Math::TVector3::TVector3(const Real* comp) +{ + static_assert(sizeof(comp) > 2 * sizeof(T), "PHANES_CORE (Vector3.cpp): Setting 3D vector coordinates by an array, comp must have a size of at least 3 components."); + memcpy(this->comp, comp, sizeof(T) * 3); +} + +template +Phanes::Core::Math::TVector3::TVector3(const TPoint3& start, const TPoint3& end) +{ + this->x = end.x - start.x; + this->y = end.y - start.y; + this->z = end.z - start.z; +} + +template +Phanes::Core::Math::TVector3::TVector3(const TVector3& v) +{ + memcpy(this->comp, comp, sizeof(T) * 3); +} + +template +Phanes::Core::Math::TVector3::TVector3(TVector3&& v) +{ + this->comp = v.comp; + v.comp = nullptr; +} + + + + +// ====================== // +// TVector3 operators // +// ====================== // + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator+=(TVector3& v1, T s) +{ + v1.x += s; + v1.y += s; + v1.z += s; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator+=(TVector3& v1, const TVector3& v2) +{ + v1.x += v2.x; + v1.y += v2.y; + v1.z += v2.z; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator-=(TVector3& v1, T s) +{ + v1.x -= s; + v1.y -= s; + v1.z -= s; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator-=(TVector3& v1, const TVector3& v2) +{ + v1.x -= v2.x; + v1.y -= v2.y; + v1.z -= v2.z; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator*=(TVector3& v1, T s) +{ + v1.x *= s; + v1.y *= s; + v1.z *= s; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator/=(TVector3& v1, T s) +{ + s = (T)1.0 / s; + v1.x *= s; + v1.y *= s; + v1.z *= s; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator*(const TVector3& v1, T s) +{ + return TVector3(v1.x * s. v1.y * s, v1.z * s); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator/(const TVector3& v1, T s) +{ + s = (T)1.0 / s; + return TVector3(v1.x * s.v1.y * s, v1.z * s); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator*(T s, const TVector3& v1) +{ + return v1 * s; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator/(T s, const TVector3& v1) +{ + return v1 / s; +} + +template +T Phanes::Core::Math::operator*(const TVector3& v1, const TVector3& v2) +{ + return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator+(const TVector3& v1, T s) +{ + return TVector3(v1.x + s.v1.y + s, v1.z + s); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator+(const TVector3& v1, const TVector3& v2) +{ + return TVector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator-(const TVector3& v1, T s) +{ + return TVector3(v1.x - s.v1.y - s, v1.z - s); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator-(const TVector3& v1, const TVector3& v2) +{ + return TVector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::operator-(TVector3& v1) +{ + v1.x = -v1.x; + v1.y = -v1.y; + v1.z = -v1.z; + + return v1; +} + +template +bool Phanes::Core::Math::operator==(const TVector3& v1, const TVector3& v2) +{ + return (abs(v1.x - v2.x) < P_FLT_INAC && abs(v1.y - v2.y) < P_FLT_INAC && abs(v1.z - v2.z) < P_FLT_INAC); +} + +template +bool Phanes::Core::Math::operator!=(const TVector3& v1, const TVector3& v2) +{ + return (abs(v1.x - v2.x) > P_FLT_INAC || abs(v1.y - v2.y) > P_FLT_INAC || abs(v1.z - v2.z) > P_FLT_INAC); +} + +// ==================================== // +// TVector3 function implementation // +// ==================================== // + +template +T Phanes::Core::Math::Magnitude(const TVector3& v1) +{ + return sqrt(DotP(v1, v1)); +} + +template +T Phanes::Core::Math::SqrMagnitude(const TVector3& v1) +{ + return DotP(v1, v1); +} + +template +T Phanes::Core::Math::SqrLength(const TVector3& v1) +{ + return SqrMagnitude(v1); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::NormalizeV(TVector3& v1) +{ + float vecNorm = Magnitude(v1); + v1 /= (vecNorm < P_FLT_INAC) ? 1 : vecNorm; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::UnsafeNormalizeV(TVector3& v1) +{ + v1 /= Magnitude(v1); + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ReflectV(TVector3& v1, const TVector3& normal) +{ + Set(v1, v1 - (2 * (v1 * normal) * normal)); + + return v1; +} + +template +T Phanes::Core::Math::Angle(const TVector3& v1, const TVector3& v2) +{ + return acos((v1 * v2) / (Magnitude(v1) * Magnitude(v2))); +} + +template +T Phanes::Core::Math::DotP(const TVector3& v1, const TVector3& v2) +{ + return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; +} + +template +void Phanes::Core::Math::Orthogonalize(TVector3& v1, TVector3& v2, TVector3& v3) +{ + Set(v2, Reject(v2, v1)); + Set(v3, Reject(Reject(v3, v1), v2)); +} + +template +void Phanes::Core::Math::OrthoNormalize(TVector3& v1, TVector3& v2, TVector3& v3) +{ + Set(v2, Reject(v2, v1)); + Set(v3, Reject(Reject(v3, v1), v2)); + + NormalizeV(v1); + NormalizeV(v2); + NormalizeV(v3); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ScaleToMagnitude(const TVector3& v1, T magnitude) +{ + NormalizeV(v1) *= magnitude; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::CompInverse(const TVector3& v1) +{ + return TVector3((T)1.0f / v1.x, (T)1.0f / v1.y, (T)1.0f / v1.z); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ReflectFromPlane(const TVector3& v1, const TPlane& plane) +{ + return Reflect(v1, plane.normal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ReflectFromPlane(const TVector3& v1, const TVector3& normal) +{ + return Reflect(v1, normal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::RotateAroundAxis(const TVector3& v1, const TVector3& axisNormal, T angle) +{ + T sinAngle = sin(angle); + T cosAngle = cos(angle); + + return (1 - cosAngle) * DotP(v1, axisNormal) * axisNormal + cosAngle * v1 + sinAngle * CrossP(v1, axisNormal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::VectorTriple(const TVector3& v1, const TVector3& v2, const TVector3& v3) +{ + return CrossP(CrossP(v1, v2), v3); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Project(const TVector3& v1, const TVector3& v2) +{ + return (DotP(v1, v2) / DotP(v2, v2)) * v2; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Reject(const TVector3& v1, const TVector3& v2) +{ + return v1 - (DotP(v1, v2) / DotP(v2, v2)) * v2; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ProjectOntoPlane(const TVector3& v1, const TVector3& normal) +{ + return Reject(v1, normal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ProjectOntoPlane(const TVector3& v1, const TPlane& plane) +{ + return Reject(v1, plane.normal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::SignVector(const TVector3& v1) +{ + v1.x = (v1.x > 0) - (v1.x < 0); + v1.y = (v1.y > 0) - (v1.y < 0); + v1.z = (v1.z > 0) - (v1.z < 0); + + + return v1; +} + +template +bool Phanes::Core::Math::Equals(const TVector3& v1, const TVector3& v2, T threshold) +{ + return (abs(v1.x - v2.x) < threshold && abs(v1.y - v2.y) < threshold && abs(v1.z - v2.z) < threshold); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::PerspectiveDivideV(TVector3& v1) +{ + float _z = (T)1.0 / v1.z; + v1.x *= _z; + v1.y *= _z; + v1.z = (T)0.0; + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::CrossPV(TVector3& v1, const TVector3& v2) +{ + float x = v1.x; + float y = v1.y; + float z = v1.z; + + v1.x = (y * v2.z) - (z * v2.y); + v1.y = (z * v2.x) - (x * v2.z); + v1.z = (x * v2.y) - (y * v2.x); + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::MaxV(TVector3& v1, const TVector3& v2) +{ + v1.x = Max(v1.x, v2.x); + v1.y = Max(v1.y, v2.y); + v1.z = Max(v1.z, v2.z); + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::MinV(TVector3& v1, const TVector3& v2) +{ + v1.x = Min(v1.x, v2.x); + v1.y = Min(v1.y, v2.y); + v1.z = Min(v1.z, v2.z); + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::NegateV(TVector3& v1) +{ + v1.x = -v1.x; + v1.y = -v1.y; + v1.z = -v1.z; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ScaleV(TVector3& v1, const TVector3& v2) +{ + v1.x *= v2.x; + v1.y *= v2.y; + v1.z *= v2.z; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ProjectV(TVector3& v1, const TVector3& v2) +{ + float x = (v1 * v2) / (v2 * v2); + v1 = x * v2; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::RejectV(TVector3& v1, const TVector3& v2) +{ + float x = (v1 * v2) / (v2 * v2); + v1 -= x * v2; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ProjectOntoPlaneV(TVector3& v1, const TVector3& normal) +{ + return RejectV(v1, normal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ProjectOntoPlaneV(TVector3& v1, const TPlane& plane) +{ + return RejectV(v1, plane.normal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Set(TVector3& v1, const TVector3& v2) +{ + v1 = v2; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Set(TVector3& v1, T x, T y, T z) +{ + v1.x = x; + v1.y = y; + v1.z = z; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ClampMagnitudeV(TVector3& v1, T min, T max) +{ + T magnitude = Magnitude(v1); + + v1 = (magnitude > P_FLT_INAC) ? v1 / magnitude : PZeroVector3(T); + + Clamp(magnitude, min, max); + + v1 *= magnitude; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::CompInverseV(TVector3& v1) +{ + v1.x = 1.0f / v1.x; + v1.y = 1.0f / v1.y; + v1.z = 1.0f / v1.z; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ReflectFromPlaneV(TVector3& v1, const TPlane& plane) +{ + return ReflectV(v1, plane.normal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ReflectFromPlaneV(TVector3& v1, const TVector3& normal) +{ + return ReflectV(v1, normal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::RotateAroundAxisV(TVector3& v1, const TVector3& axisNormal, T angle) +{ + T sinAngle = sin(angle); + T cosAngle = cos(angle); + + v1 = ((T)1.0 - cosAngle) * DotP(axisNormal, v1) * axisNormal + cosAngle * v1 + sinAngle * CrossP(axisNormal, v1); + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ScaleToMagnitudeV(TVector3& v1, T magnitude) +{ + NormalizeV(v1) *= magnitude; + + return v1; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::SignVectorV(TVector3& v1) +{ + v1.x = (v1.x > 0) ? 1 : 0; + v1.y = (v1.y > 0) ? 1 : 0; + v1.z = (v1.z > 0) ? 1 : 0; + + return v1; +} + +template +T Phanes::Core::Math::ScalarTriple(const TVector3& v1, const TVector3& v2, const TVector3& v3) +{ + return CrossP(v1, v2) * v3; +} + +template +T Phanes::Core::Math::CosineAngle(const TVector3& v1, const TVector3& v2) +{ + return (v1 * v2) / (Magnitude(v1) * Magnitude(v2)); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::VectorTripleV(TVector3& v1, const TVector3& v2, const TVector3& v3) +{ + CrossPV(CrossPV(v1, v2), v3); + + return v1; +} + +template +bool Phanes::Core::Math::IsPerpendicular(const TVector3& v1, const TVector3& v2, T threshold) +{ + return (abs(DotP(v1, v2)) < threshold); +} + +template +bool Phanes::Core::Math::IsParallel(const TVector3& v1, const TVector3& v2, T threshold) +{ + return (abs(DotP(v1, v2)) > threshold); +} + +template +bool Phanes::Core::Math::IsCoincident(const TVector3& v1, const TVector3& v2, T threshold) +{ + return (DotP(v1, v2) > threshold); +} + +template +bool Phanes::Core::Math::IsNormalized(const TVector3& v1, T threshold) +{ + return (SqrMagnitude(v1) < threshold); +} + +template +bool Phanes::Core::Math::IsCoplanar(const TVector3& v1, const TVector3& v2, const TVector3& v3, T threshold) +{ + return (ScalarTriple(v1, v2, v3) < threshold); +} + + +// ================ // +// With return: // +// ================ // + + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Normalize(const TVector3& v1) +{ + float vecNorm = Magnitude(v1); + return (vecNorm < P_FLT_INAC) ? PZeroVector3(T) : v1 / vecNorm; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::UnsafeNormalize(const TVector3& v1) +{ + return v1 / Magnitude(v1); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Reflect(const TVector3& v1, const TVector3& normal) +{ + return v1 - (2 * (v1 * normal) * normal); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::PerspectiveDivide(const TVector3& v1) +{ + float _z = (T)1.0 / v1.z; + return TVector3(v1.x * _z, v1.y * _z, (T)0.0); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::CrossP(const TVector3& v1, const TVector3& v2) +{ + return TVector3((v1.y * v2.z) - (v1.z * v2.y), + (v1.z * v2.x) - (v1.x * v2.z), + (v1.x * v2.y) - (v1.y * v2.x)); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Lerp(const TVector3& start, const TVector3& dest, T t) +{ + t = Clamp(t, (T)0.0, (T), 1.0); + return (1 - t) * start + t * dest; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::LerpUnclamped(const TVector3& start, const TVector3& dest, T t) +{ + return (1 - t) * start + t * dest; +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Max(const TVector3& v1, const TVector3& v2) +{ + return TVector3((v1.x > v2.x) ? v1.x : v2.x, + (v1.y > v2.y) ? v1.y : v2.y, + (v1.z > v2.z) ? v1.z : v2.z); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Min(const TVector3& v1, const TVector3& v2) +{ + return TVector3((v1.x < v2.x) ? v1.x : v2.x, + (v1.y < v2.y) ? v1.y : v2.y, + (v1.z < v2.z) ? v1.z : v2.z); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Negate(const TVector3& v1) +{ + return TVector3(-v1.x, -v1.y, -v1.z); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::Scale(const TVector3& v1, const TVector3& v2) +{ + return TVector3(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z); +} + +template +Phanes::Core::Math::TVector3 Phanes::Core::Math::ClampMagnitude(const TVector3& v1, T min, T max) +{ + T magnitude = Magnitude(v1); + + const TVector3 unitVec = (magnitude > P_FLT_INAC) ? v1 / magnitude : PZeroVector3(T); + + Clamp(magnitude, min, max); + + return unitVec * magnitude; +} + diff --git a/Engine/src/Runtime/Core/private/StartingPoint/StartingPoint.cpp b/Engine/src/Runtime/Core/private/StartingPoint/StartingPoint.cpp index 14fd0e5..2b0f21a 100644 --- a/Engine/src/Runtime/Core/private/StartingPoint/StartingPoint.cpp +++ b/Engine/src/Runtime/Core/private/StartingPoint/StartingPoint.cpp @@ -35,38 +35,21 @@ static void IdleMsg() -Phanes::Core::Application::PhanesGame::PhanesGame() +Phanes::Core::Application::PhanesProject::PhanesProject(std::string _ProjectName) : projectName(_ProjectName) { } -Phanes::Core::Application::PhanesGame::~PhanesGame() +Phanes::Core::Application::PhanesProject::~PhanesProject() { } -void Phanes::Core::Application::PhanesGame::Run() +std::string Phanes::Core::Application::PhanesProject::GetName() { - HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE); - SetConsoleTextAttribute(hConsole, 12); + return this->projectName; +} - std::cout << "Welcome to PhanesEngine!" << std::endl << std::endl; - - SetConsoleTextAttribute(hConsole, 15); - - std::this_thread::sleep_for(std::chrono::seconds(5)); - - std::cout << "It's silent..." << std::endl << std::endl; - - std::this_thread::sleep_for(std::chrono::seconds(3)); - - std::cout << "To silent." << std::endl; - - std::this_thread::sleep_for(std::chrono::seconds(5)); - - std::cout << "\nI will go now" << std::endl; - - std::this_thread::sleep_for(std::chrono::seconds(4)); - - std::cout << "\nGood by!" << std::endl; - std::this_thread::sleep_for(std::chrono::seconds(3)); +void Phanes::Core::Application::PhanesProject::Run() +{ + std::cin.get(); } \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Logging/Logging.h b/Engine/src/Runtime/Core/public/Logging/Logging.h new file mode 100644 index 0000000..b7ee163 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Logging/Logging.h @@ -0,0 +1,57 @@ +#pragma once + +#include "PhanesEnginePCH.h" + +#include "Core/Core.h" + +#ifndef P_DEBUG +#pragma warning(disable : 4251) // Disable STL dll export warning +#endif + +namespace Phanes::Core::Logging +{ + static std::shared_ptr _PEngineLogger; + static std::shared_ptr _PAppLogger; + + PHANES_CORE void Init(); + + PHANES_CORE inline std::shared_ptr& PEngineLogger() { return _PEngineLogger; }; + PHANES_CORE inline std::shared_ptr& PGameLogger() { return _PAppLogger; }; +} + + +namespace PLog = Phanes::Core::Logging; // User Macros + +#ifdef P_DEBUG + +// Default logger + +#define PENGINE_LOG_TRACE(...) ::Phanes::Core::Logging::PEngineLogger()->trace(__VA_ARGS__) +#define PENGINE_LOG_INFO(...) ::Phanes::Core::Logging::PEngineLogger()->info(__VA_ARGS__) +#define PENGINE_LOG_WARN(...) ::Phanes::Core::Logging::PEngineLogger()->warn(__VA_ARGS__) +#define PENGINE_LOG_ERROR(...) ::Phanes::Core::Logging::PEngineLogger()->error(__VA_ARGS__) +#define PENGINE_LOG_FATAL(...) ::Phanes::Core::Logging::PEngineLogger()->fatal(__VA_ARGS__) + + +#define PAPP_LOG_TRACE(...) ::Phanes::Core::Logging::PAppLogger()->trace(__VA_ARGS__) +#define PAPP_LOG_INFO(...) ::Phanes::Core::Logging::PAppLogger()->info(__VA_ARGS__) +#define PAPP_LOG_WARN(...) ::Phanes::Core::Logging::PAppLogger()->warn(__VA_ARGS__) +#define PAPP_LOG_ERROR(...) ::Phanes::Core::Logging::PAppLogger()->error(__VA_ARGS__) +#define PAPP_LOG_FATAL(...) ::Phanes::Core::Logging::PAppLogger()->fatal(__VA_ARGS__) + +#else + +#define PENGINE_LOG_TRACE(...) +#define PENGINE_LOG_INFO(...) +#define PENGINE_LOG_WARN(...) +#define PENGINE_LOG_ERROR(...) +#define PENGINE_LOG_FATAL(...) + + +#define PAPP_LOG_TRACE(...) +#define PAPP_LOG_INFO(...) +#define PAPP_LOG_WARN(...) +#define PAPP_LOG_ERROR(...) +#define PAPP_LOG_FATAL(...) + +#endif diff --git a/Engine/src/Runtime/Core/public/Math/IntPoint.h b/Engine/src/Runtime/Core/public/Math/IntPoint.h new file mode 100644 index 0000000..1328c68 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/IntPoint.h @@ -0,0 +1,154 @@ +#pragma once + +#include "Core/public/Misc/Boilerplate.h" + +#include "Core/public/Math/MathCommon.h" +#include "Core/public/Math/MathAbstractTypes.h" +#include "Core/public/Math/MathFwd.h" + +#include "Core/public/Math/IntVector2.h" +#include "Core/public/Math/IntVector3.h" +// #include "Core/public/Math/IntVector4.h" + +#ifndef P_DEBUG +#pragma warning(disable : 4244) +#endif + +/** + * General annonation: The Point is the same as a vector. The type exists, to ensure a + * easy differentiation between the two. + */ + +#ifndef INTPOINT_H +#define INTPOINT_H + +namespace Phanes::Core::Math { + + /** + * A 2D Point with components x and y with integer precision. + */ + + template + struct TIntPoint2 : public TIntVector2 { + + using TIntVector2::TIntVector2; + + /** + * Creates IntPoint2 from IntPoint3's xy + * + * @param a IntPoint3 one + */ + + TIntPoint2(const TIntPoint3& a) + { + this->x = a.x; + this->y = a.y; + } + + /** + * Creates IntPoint2 from IntPoint4's xy + * + * @param a IntPoint4 one + */ + + //TIntPoint2(const TIntPoint4& a) + //{ + // this->x = a.x; + // this->y = a.y; + + //} + }; + + template + Rt Distance(const TIntPoint2& p1, const TIntPoint2& p2); + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + + /** + * A 3D Point with components x and y with integer precision. + */ + + + template + struct TIntPoint3 : public TIntVector3 { + + using TIntVector3::TIntVector3; + + /** + * Creates IntPoint3 from IntPoint2's xy and zero + * + * @param a IntPoint2 one + */ + + TIntPoint3(const TIntPoint2& a) + { + this->x = a.x; + this->y = a.y; + this->z = 0; + } + + /** + * Creates IntPoint3 from IntPoint4's xyz + * + * @param a IntPoint4 one + */ + + //TIntPoint3(const TIntPoint4& a) + //{ + // this->components[0] = a.components[0]; + // this->components[1] = a.components[1]; + // this->components[2] = a.components[2]; + //} + }; + + template + Rt Distance(const TIntPoint3& p1, const TIntPoint3& p2); + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + + /** + * A 4D Point with components x and y with integer precision. + */ + + + //template + //struct TIntPoint4 : public TIntVector4 { + // static_assert(std::is_integral_v(T), "T must be an integer type."); + + // using IntVector4::IntVector4; + + // /** + // * Creates IntPoint4 from IntPoint2's xy and the last two zero + // * + // * @param a IntPoint2 one + // */ + + // PHANES_CORE_API IntPoint4(const IntPoint2& a) + // { + // this->components[0] = a.components[0]; + // this->components[1] = a.components[1]; + // this->components[2] = 0; + // this->components[3] = 0; + // } + + // /** + // * Creates IntPoint4 from IntPoint3's xyz and zero + // * + // * @param a IntPoint3 one + // */ + + // PHANES_CORE_API IntPoint4(const IntPoint3& a) + // { + // this->components[0] = a.components[0]; + // this->components[1] = a.components[1]; + // this->components[2] = a.components[2]; + // this->components[3] = 0; + // } + //}; + + +} // phanes::core::math::coretypes + +#endif // !INTPOINT_H diff --git a/Engine/src/Runtime/Core/public/Math/IntVector2.h b/Engine/src/Runtime/Core/public/Math/IntVector2.h new file mode 100644 index 0000000..3035264 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/IntVector2.h @@ -0,0 +1,872 @@ +#pragma once + +#include "Core/Core.h" + +#include "Core/public/Misc/Boilerplate.h" + +#include "Core/public/Math/MathCommon.h" +#include "Core/public/Math/MathAbstractTypes.h" +#include "Core/public/Math/MathFwd.h" + +#ifndef P_DEBUG +#pragma warning(disable : 4244) +#endif + +/** + * Note: Some function are deleted, because, their unusable with int types, except very specific cases. + * To keep the library verbose, these functions are explicitly marked as deleted. + */ + + +#ifndef INTVECTOR2_H +#define INTVECTOR2_H + +#define PIntZeroVector2(type) TIntVector2<##type>(0,0) +#define PIntVectorSouth2(type) TIntVector2<##type>(0,-1) +#define PIntVectorNorth2(type) TIntVector2<##type>(0,1) +#define PIntVectorEast2(type) TIntVector2<##type>(1,0) +#define PIntVectorWest2(type) TIntVector2<##type>(-1,0) + + +namespace Phanes::Core::Math { + + /** + * A 2D Vector with components x and y with integer precision. + */ + + template + struct TIntVector2 { + + static_assert(std::is_integral_v, "T must be an integer type."); + + public: + + // Using in combination with a struct and an array allows us the reflect changes of the x and y variables in the comp array and vise versa. + + union + { + + struct + { + /** X component of Vector + * + * @ref [FIELD]components + * @note x does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. + */ + T x; + + /** Y component of Vector + * + * @ref [FIELD]components + * + * @note y does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. + */ + T y; + }; + + /** Components array holding the data + * + * @ref [FIELD]x + * @ref [FIELD]y + * + * @note Components are split into x and y. Access and manipulation is possible by these variables. + */ + + T comp[2]; + + }; + + + + + public: + + /** + * Default constructor without initialization + */ + + TIntVector2() = default; + + /** + * Copy constructor + */ + + TIntVector2(const TIntVector2& v); + + /** + * Move constructor + */ + + TIntVector2(TIntVector2&& v); + + /** + * Convert other type of vector + */ + + template + explicit TIntVector2(const TIntVector2& v) : x((T)v.x), y((T)v.y) {}; + + template + explicit TIntVector2(const TVector2& v) : x((T)v.x), y((T)v.y) {}; + + /** + * Construct Vector from xy components. + * + * @param x X component + * @param y Y component + */ + + TIntVector2(const T x, const T y); + + /** + * Construct Vector from two component array. + * + * @param comp Array of components + */ + + TIntVector2(const T* comp); + + /** + * Construct Vector from 3D integer Vector's xy. + * + * @param v 3D IntVector to copy from + */ + + TIntVector2(const TIntVector3& v); + + /** + * Construct Vector from 4D integer Vector's xy. + * + * @param v 4D IntVector to copy from + */ + + //TIntVector2(const TIntVector4& v); + + /** + * Construct Vector from 2D Point's xy. + * + * @param v 2D Point to copy from + */ + + //TIntVector2(const TIntPoint2& v); + + + /** + * Constructs a vector pointing from start to end. + * + * @param(start) Startingpoint + * @param(end) Endpoint + */ + + TIntVector2(const TIntPoint2& start, const TIntPoint2& end); + }; + + // ======================== // + // IntVector2 operators // + // ======================== // + + + /** + * Addition operation on same TIntVector2 (this) by a floating point value. + * + * @param(v1) Vector to add to + * @param(s) Floating point to add + */ + + template + TIntVector2 operator+= (TIntVector2& v1, T s); + + /** + * Addition operation on same TIntVector2 (this) by a another TIntVector2. + * + * @param(v1) Vector to add to + * @param(v2) Vector to add + */ + + template + TIntVector2 operator+= (TIntVector2& v1, const TIntVector2& v2); + + /** + * Substraction operation on same TIntVector2 (this) by a floating point. + * + * @param(v1) Vector to substract from + * @param(v2) Floating point to substract + */ + + template + TIntVector2 operator-= (TIntVector2& v1, T s); + + /** + * Substraction operation on same TIntVector2 (this) by a another TIntVector2. + * + * @param(v1) Vector to substract from + * @param(v2) Vector to substract + */ + + template + TIntVector2 operator-= (TIntVector2& v1, const TIntVector2& v2); + + /** + * Multiplication of TIntVector2 (this) with a floating point. + * + * @param(v1) Vector to multiply with + * @param(s Floating point to multiply with + */ + + template + TIntVector2 operator*= (TIntVector2& v1, T s); + + /** + * Devision of Vector (this) by floating point. + * + * @param(v1) Vector to divide with + * @param(s Floating point to divide with + */ + + template + TIntVector2 operator/= (TIntVector2& v1, T s) = delete; + + /** + * Scale of Vector by floating point. (> Creates a new TIntVector2) + * + * @param(v1) Vector to multiply with + * @param(s Floating point to multiply with + * + * @return Result Vector + */ + + template + TIntVector2 operator* (const TIntVector2& v1, T s); + + /** + * Division of Vector by floating point. (> Creates another TIntVector2) + * + * @see [FUNC]DivideFloat + * + * @param(v1) Vector to multiply with + * @param(s Floating point to divide with + * + * @return Result Vector + * @note Deleted, because the returntype might not implicitly be obvious, when using in code or reading. + */ + + template + TIntVector2 operator/ (const TIntVector2& v1, T s) = delete; + + /** + * Scale of Vector by floating point. (> Creates a new TIntVector2) + * + * @param(v1) Vector to multiply with + * @param(s Floating point to multiply with + * + * @return Result Vector + */ + + template + inline TIntVector2 operator* (T s, const TIntVector2& v1); + + /** + * Division of Vector by floating point. (> For convenience not arithmethicaly correct. Works like overloaded counterpart.) + * + * @see [FUNC]DivideFloat + * + * @param(v1) Vector to multiply with + * @param(s Floating point to divide with + * + * @return Result Vector + * + * @note Deleted, because the returntype might not implicitly be obvious, when using in code or reading. + */ + + template + inline TIntVector2 operator/ (T s, const TIntVector2& v1) = delete; + + /** + * Dot product between two Vectors. + * + * @see [FUNC]DotP + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @result Dot product + */ + + template + Rt operator* (const TIntVector2& v1, const TIntVector2& v2); + + /** + * Componentwise addition of Vector with floating point. + * + * @param(v1) Vector to add to + * @param(s Floating point to add + * + * @return Result Vector + */ + + template + TIntVector2 operator+ (const TIntVector2& v1, T s); + + /** + * Componentwise addition of Vector with floating point. + * + * @param(v1) Vector to add to + * @param(s Floating point to add + * + * @return Result Vector + */ + + template + TIntVector2 operator+ (const TIntVector2& v1, const TIntVector2& v2); + + /** + * Componentwise substraction of Vector with floating point. + * + * @param(v1) Vector to substract from + * @param(s Floating point to substract + * + * @return Result Vector + */ + + template + TIntVector2 operator- (const TIntVector2& v1, T s); + + /** + * Componentwise substraction of Vector with Vector. + * + * @param(v1) Vector to substract from + * @param(s Floating point to substract + * + * @return Result Vector + */ + + template + TIntVector2 operator- (const TIntVector2& v1, const TIntVector2& v2); + + /** + * Negate Vector. + * + * @param(v1) Vector to negate + */ + + template + void operator- (TIntVector2& v1); + + /** + * Compare Vector for equality. + * + * @see [FUNC]Equals + * + * @param(v1) Vector to negate + * + * @return true if equal, false if inequal + */ + + template + bool operator== (const TIntVector2& v1, const TIntVector2& v2); + + + /** + * Compare Vector for inequality. + * + * @see [FUNC]Equals + * + * @param(v1) Vector to negate + * + * @return true if inequal, false if equal + */ + + template + bool operator!= (const TIntVector2& v1, const TIntVector2& v2); + + // ============================================== // + // IntVector2 static function implementation // + // ============================================== // + + /** + * Magnitude of Vector + * + * @param(v1) Vector + * + * @return Size of Vector + */ + + template + Rt Magnitude(const TIntVector2& v1); + + /** + * @see [FUNC]Magnitude + */ + template + FORCEINLINE Rt Length(const TIntVector2& v1) { return Magnitude(v1); }; + + /** + * Square of magnitude of Vector + * + * @param(v1) Vector + * + * @return Magnitude without calculating square root + */ + + template + T SqrMagnitude(const TIntVector2& v1); + + /** + * @see [FUNC]SqrMagnitude + */ + template + FORCEINLINE T SqrLength(const TIntVector2& v1) { return SqrMagnitude(v1); }; + + + /** + * Divide vector and truncate result. + * + * @param(v1) Vector to divide + * @param(s) Number to divide with + * + * @note Rt is the type of the reciprocal of s. + */ + + template + TIntVector2 DivideTruncV(TIntVector2& v1, T s); + + /** + * Angle between to Vectors + * + * @param(v1) Vector one + * @param(v2) Vector two + */ + + template + Rt Angle(const TIntVector2& v1, const TIntVector2& v2); + + /** + * Cosine of angle between to Vectors + * + * @param(v1) Vector one + * @param(v2) Vector two + */ + + template + Rt CosineAngle(const TIntVector2& v1, const TIntVector2& v2); + + /** + * Returns signs of components in vector: -1 / +1 / 0. + * + * @param(v1) Vector one + */ + + template + TIntVector2 SignVectorV(TIntVector2& v1); + + /** + * Dot product of two Vectors + * + * @param(v1) Vector one + * @param(v2) Vector two + */ + + template + T DotP(const TIntVector2& v1, const TIntVector2& v2); + + /** + * Creates Vector, with component wise largest values. + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @note Stores new Vector to v1 + */ + + template + TIntVector2 MaxV(TIntVector2& v1, const TIntVector2& v2); + + /** + * Creates Vector, with component wise smallest values. + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @note Stores new Vector to v1 + */ + + template + TIntVector2 MinV(TIntVector2& v1, const TIntVector2& v2); + + /** + * Gets perpendicular Vector to v1. + * + * @param(v1) Vector one + * + * @note Stores new Vector to v1 + */ + + template + TIntVector2 GetPerpendicularV(TIntVector2& v1); + + /** + * Gets perpendicular Vector to v1. + * + * @reg [FUNC]PerpendicularV + * + * @param(v1) Vector one + * + * @note Stores new Vector to v1 + */ + + template + TIntVector2 GetReversePerpendicularV(TIntVector2& v1); + + /** + * Component wise multiplication of Vector + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @note Stores new Vector to v1 + */ + + template + TIntVector2 ScaleV(TIntVector2& v1, const TIntVector2& v2); + + /** + * Copies one Vector two another + * + * @param(v1) Vector to copy to + * @param(v2) Vector to copy + */ + + template + TIntVector2 Set(TIntVector2& v1, const TIntVector2& v2); + + /** + * Sets components of a vector. + * + * @param(v1) Vector to copy to + * @param(v2) Vector to copy + */ + + template + TIntVector2 Set(TIntVector2& v1, T x, T y); + + + /** + * Negates Vector + * + * @param(v1) Vector one + */ + + template + TIntVector2 NegateV(TIntVector2& v1); + + /** + * Tests if vector is a unity vector. + * + * @param(v1) Vector one + * + * @return true if unit vector, false if not + */ + + template + inline bool IsNormalized(const TIntVector2& v1); + + /** + * Tests if 2 vectors are perpendicular to each other. + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return true if perpendicular, false if not + * + * @note Requires v1 and v2 to be normal vectors. + */ + + template + inline bool IsPerpendicular(const TIntVector2& v1, const TIntVector2& v2); + + /** + * Tests if 2 vectors are parallel to each other. (Angle is close to zero.) + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return true if parallel, false if not + * + * @note Requires v1 and v2 to be normal vectors. + */ + + template + inline bool IsParallel(const TIntVector2& v1, const TIntVector2& v2); + + /** + * Tests if 2 vectors are coincident. (Are parallel and point in the same direction.) + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return true if coincident, false if not + * + * @note Requires v1 and v2 to be normal vectors. + */ + + template + inline bool IsCoincident(const TIntVector2& v1, const TIntVector2& v2); + + /** + * Gets outer product of to vectors. + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return Resulting matrix + */ + + //template + //Matrix2 OuterProduct(const TIntVector2& v1, const TIntVector2& v2); + + + // ============================================================= // + // IntVector2 static function implementation with return values // + // ============================================================= // + + + /** + * Reflects a vector on a normal + * + * @param(v1) Vector one + * @param(normal) Normal of surface + * + * @return Reflected vector + */ + + template + TVector2 Reflect(const TIntVector2& v1, const TVector2& normal); + + /** + * Scales a vector component wise + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return Reflected vector + */ + + template + TIntVector2 Scale(const TIntVector2& v1, const TIntVector2& v2); + + /** + * Componentwise inverse of a vector + * + * @param(v1) Vector one + * + * @return Componentwise inverted, floating point vector + */ + + template + TVector2 CompInverse(const TIntVector2& v1); + + + /** + * Negates Vector + * + * @param(v1) Vector one + * + * @return Componentwise inverted vector + */ + + template + TIntVector2 Negate(const TIntVector2& v1); + + /** + * Gets the perpendicular vector of v1 + * + * @param(v1) Vector one + * + * @return Perpendicular vector + */ + + template + TIntVector2 GetPerpendicular(const TIntVector2& v1); + + /** + * Gets reverse of the perpendicular vector of v1 + * + * @param(v1) Vector one + * + * @return Reversed perpendicular vector + */ + + template + TIntVector2 GetReversePerpendicular(const TIntVector2& v1); + + /** + * Creates a new Vector by the component wise minimals of both vectors + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return Minimal vector + */ + + template + TIntVector2 Min(const TIntVector2& v1, const TIntVector2& v2); + + /** + * Creates a new Vector by the component wise maxima of both vectors + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return Maximal vector + */ + + template + TIntVector2 Max(const TIntVector2& v1, const TIntVector2& v2); + + /** + * Creates a normalized instance of the vector + * + * @param(v1) Vector to normalize + * + * @return Unit vector + * @note Returns floating point vector. + */ + + template + TVector2 Normalize(const TIntVector2& v1); + + /** + * Creates a normalized instance of the vector + * + * @param(v1) Vector to normalize + * + * @return Unit vector + * @note Does not test for zero vector + * @note Returns floating point vector. + */ + + template + TVector2 UnsafeNormalize(const TIntVector2& v1); + + /** + * Returns signs of components in vector: -1 / +1 / 0. + * + * @param(v1) Vector one + * + * @return Vector with signs as components + */ + + template + TIntVector2 SignVector(const TIntVector2& v1); + + /** + * Binds a vector to a square with a radius + * + * @param(v1) Vector one + * @param(radius) Radius of square (=> Distance from middle to center of each site.) + * + * @return Bound, floating point vector + */ + + template + TVector2 BindToSquare(const TIntVector2& v1, T radius); + + /** + * Clamps a vector to a square with a radius + * + * @param(v1) Vector one + * @param(radius) Radius of square (=> Distance from middle to center of each site.) + * + * @return Clamped, floating point vector. If the length of the vector fits the square, then the vector is returned. + */ + + template + TVector2 ClampToSquare(const TIntVector2& v1, T radius); + + /** + * Interpolates between to vectors. + * + * @param(startVec) Start vector (t = 0) + * @param(destVec) Destination vector (t = 1) + * @param(t) Interpolation value + * + * @return Interpolated vector + * + * @note Interpolation is clamped between 0 - 1. + */ + + template + TVector2 Lerp(const TIntVector2& startVec, const TIntVector2& destVec, Rt t); + + /** + * Interpolates between to vectors. + * + * @param(startVec) Start vector (t = 0) + * @param(destVec) Destination vector (t = 1) + * @param(t) Interpolation value + * + * @return Interpolated vector + * + * @note Interpolation is not clamped. Make shure t is between 0.0f and 1.0f + */ + + template + TVector2 LerpUnclamped(const TIntVector2& startVec, const TIntVector2& destVec, Rt t); + + /** + * Anti-clockwise vector rotation. + * + * @param(v1) Vector to rotate + * @param(angle) Angle to rotate + * + * @return Rotated vector + * + * @note Angle is not clamped + */ + + template + TVector2 Rotate(const TIntVector2& v1, Rt angle); + + /** + * Clockwise vector rotation. + * + * @param(v1) Vector to rotate + * + * @return Rotated vector + * + * @note Angle is not clamped + */ + + template + FORCEINLINE TVector2 ClockwiseRotate(const TIntVector2& v1, Rt angle); + + /** + * Component wise division of Vector + * + * @param(v1) Vector one + * @param(s) Vector two + * + * @note Truncates result instead of rounding + * @note Rt is the type of the reciprocal of s. + */ + + template + TIntVector2 DivideTrunc(const TIntVector2& v1, T s); + + + /** + * Component wise division of Vector + * + * @param(v1) Vector one + * @param(s) Vector two + * + * @return Floating point vector + */ + + template + TVector2 DivideFloat(const TIntVector2& v1, T s); + +} // phanes::core::math::coretypes + +#endif // !INTVECTOR2_H + diff --git a/Engine/src/Runtime/Core/public/Math/IntVector3.h b/Engine/src/Runtime/Core/public/Math/IntVector3.h new file mode 100644 index 0000000..292f4a6 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/IntVector3.h @@ -0,0 +1,966 @@ +#pragma once + +#include "Core/public/Misc/Boilerplate.h" + +#include "Core/public/Math/MathCommon.h" +#include "Core/public/Math/MathAbstractTypes.h" +#include "Core/public/Math/MathFwd.h" + +#include "Core/public/Math/Vector3.h" + +#ifndef P_DEBUG +#pragma warning(disable : 4244) +#endif + + +#ifndef INTVECTOR3_H +#define INTVECTOR3_H + +#define PIntZeroVector3(type) TIntVector3<##type>(0,0,0) +#define PIntVectorForward3(type) TIntVector3<##type>(1,0,0) +#define PIntVectorBackward3(type) TIntVector3<##type>(-1,0,0) +#define PIntVectorEast3(type) TIntVector3<##type>(0,1,0) +#define PIntVectorWest3(type) TIntVector3<##type>(0,-1,0) +#define PIntVectorUp3(type) TIntVector3<##type>(0,0,1) +#define PIntVectorDown3(type) TIntVector3<##type>(0,0,-1) + +namespace Phanes::Core::Math { + + /** + * A 3D Vector with components x, y and z with integer precision. + */ + + template + struct TIntVector3 { + + public: + + // Using in combination with a struct and an array allows us the reflect changes of the x and y variables in the comp array and vise versa. + + union + { + + struct + { + /** X component of Vector + * + * @ref [FIELD]components + * @note x does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. + */ + T x; + + /** Y component of Vector + * + * @ref [FIELD]components + * + * @note y does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. + */ + T y; + + /** Z component of Vector + * + * @ref [FIELD]components + * + * @note Z does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. + */ + T z; + }; + + /** Components array holding the data + * + * @ref [FIELD]x + * @ref [FIELD]y + * @ref [FIELD]z + * + * @note Components are split into x, y and z. Access and manipulation is possible by these variables. + */ + + T comp[3]; + + }; + + public: + + + /** + * Default constructor without initialization + */ + + TIntVector3() = default; + + /** + * Copy constructor + */ + + TIntVector3(const TIntVector3& v); + + /** + * Move constructor + */ + + TIntVector3(TIntVector3&& v); + + /** + * Convert other type of vector + */ + + template + explicit TIntVector3(const TIntVector3& v) : x((T)v.x), y((T)v.y) {}; + + template + explicit TIntVector3(const TVector3& v) : x((T)v.x), y((T)v.y) {}; + + /** + * Construct Vector from xy components. + * + * @param x X component + * @param y Y component + * @param z Z component + */ + + TIntVector3(const T x, const T y, const T z); + + /** + * Construct Vector from two component array. + * + * @param comp Array of components + */ + + TIntVector3(const T* comp); + + /** + * Construct Vector from 3D integer Vector's xy. + * + * @param v 3D IntVector to copy from + */ + + TIntVector3(const TIntVector2& v); + + /** + * Construct Vector from 4D integer Vector's xy. + * + * @param v 4D IntVector to copy from + */ + + //TIntVector2(const TIntVector4& v); + + /** + * Construct Vector from 2D Point's xy. + * + * @param v 2D Point to copy from + */ + + //TIntVector2(const TIntPoint2& v); + + + /** + * Constructs a vector pointing from start to end. + * + * @param(start) Startingpoint + * @param(end) Endpoint + */ + + TIntVector3(const TIntPoint3& start, const TIntPoint3& end); + + }; + + + // ======================== // + // IntVector3 operators // + // ======================== // + + + /** + * Coponentwise addition of floating point to 3D vector + * + * @param(v1) vector to add to + * @param(s) floating point to add + */ + + template + inline TIntVector3 operator+= (TIntVector3& v1, T s); + + /** + * Coponentwise addition of 3D vector to 3D vector + * + * @param(v1) vector to add to + * @param(v2) vector to add + */ + + template + inline TIntVector3 operator+= (TIntVector3& v1, const TIntVector3& v2); + + /** + * Coponentwise substraction of floating point of 3D vector + * + * @param(v1) vector to substract from + * @param(s) floating point to substract + */ + + template + inline TIntVector3 operator-= (TIntVector3& v1, T s); + + /** + * Coponentwise substraction of 3D vector to 3D vector + * + * @param(v1) vector to substract from + * @param(v2) vector to substract with + */ + + template + inline TIntVector3 operator-= (TIntVector3& v1, const TIntVector3& v2); + + /** + * Dot product between two 3D Vectors + * + * @param(v1) vector one + * @param(s) floating point + */ + + template + inline TIntVector3 operator*= (TIntVector3& v1, T s); + + /** + * Coponentwise multiplication of 3D Vectors with floating point + * + * @param(v1) vector one + * @param(s) floating point + * + * @return Resulting vector + */ + + template + TIntVector3 operator* (const TIntVector3& v1, T s); + + /** + * Coponentwise multiplication of 3D Vectors with floating point + * + * @param(s) floating point + * @param(v2) vector + * + * @return Resultion vector + */ + + template + inline TIntVector3 operator* (T s, const TIntVector3& v1); + + /** + * Dot product between two 3D Vectors + * + * @param(v1) vector one + * @param(v2) vector two + * + * @return Dot product of Vectors + */ + + template + T operator* (const TIntVector3& v1, const TIntVector3& v2); + + /** + * Coponentwise addition of floating point to 3D vector + * + * @param(v1) vector to add to + * @param(s) floating point to add + * + * @return Resulting vector + */ + + template + TIntVector3 operator+ (const TIntVector3& v1, T s); + + /** + * Coponentwise addition of 3D vector to 3D vector + * + * @param(v1) vector to add to + * @param(v2) vector to add + * + * @return Resulting vector + */ + + template + TIntVector3 operator+ (const TIntVector3& v1, const TIntVector3& v2); + + /** + * Coponentwise substraction of floating point of 3D vector + * + * @param(v1) vector to substract from + * @param(s) floating point to substract + * + * @return Resulting vector + */ + + template + TIntVector3 operator- (const TIntVector3& v1, T s); + + /** + * Coponentwise substraction of floating point of 3D vector + * + * @param(v1) vector to substract from + * @param(v2) vector to substract with + * + * @return Resulting vector + */ + + template + TIntVector3 operator- (const TIntVector3& v1, const TIntVector3& v2); + + /** + * Negates vector + * + * @param(v1) Vector to negate + */ + + template + TIntVector3 operator- (TIntVector3& v1); + + /** + * Tests two 3D vectors for equality. + * + * @ref [FUNC]Equals + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return True if equal, false if not. + * + * @note Uses [MACRO]P_FLT_INAC + */ + + template + inline bool operator== (const TIntVector3& v1, const TIntVector3& v2); + + /** + * Tests two 3D vectors for inequality. + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return True if inequal, false if not. + */ + + template + inline bool operator!= (const TIntVector3& v1, const TIntVector3& v2); + + // ============================================== // + // IntVector3 static function implementation // + // ============================================== // + + /** + * Gets magnitude of vector + * + * @param(v1) Vector + * + * @return Magnitude of vector + */ + + template + inline Rt Magnitude(const TIntVector3& v1); + + /** + * @see [FUNC]Magnitude + */ + + template + FORCEINLINE T Length(const TIntVector3& v1) { return Magnitude(v1); }; + + /** + * Gets square magnitude of vector + * + * @param(v1) Vector + * + * @return Square magnitude of vector + */ + + template + inline T SqrMagnitude(const TIntVector3& v1); + + /** + * @see SqrMagnitude + */ + + template + FORCEINLINE T SqrLength(const TIntVector3& v1) { return SqrMagnitude(v1); }; + + /** + * Gets angle between two vectors + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return Angle between vectors + */ + + template + Rt Angle(const TIntVector3& v1, const TIntVector3& v2); + + /** + * Dot product of two vectors + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return Dot product of vectors + */ + + template + T DotP(const TIntVector3& v1, const TIntVector3& v2); + + /** + * Returns signs of components in vector: -1 / +1 / 0. + * + * @param(v1) Vector one + * + * @return Vector with signs a components. + */ + + template + TIntVector3 SignVector(const TIntVector3& v1); + + /** + * Tests two vectors for equality. + * + * @param(v1) Vector one + * @param(v2) Vector two + * @param(threshold) Allowed T inaccuracy. + * + * @return True if equal, false if not. + */ + + template + inline bool Equals(const TIntVector3& v1, const TIntVector3& v2, T threshold = P_FLT_INAC); + + /** + * Calculates the cross product between two vectors. + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @note result is stored in v1. + */ + + template + TIntVector3 CrossPV(TIntVector3& v1, const TIntVector3& v2); + + /** + * Gets the componentwise max of both vectors. + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @note result is stored in v1. + */ + + template + TIntVector3 MaxV(TIntVector3& v1, const TIntVector3& v2); + + /** + * Gets the componentwise min of both vectors. + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @note result is stored in v1. + */ + + template + TIntVector3 MinV(TIntVector3& v1, const TIntVector3& v2); + + /** + * Gets reversed vector. + * + * @param(v1) Vector one + * + * @note result is stored in v1. + */ + + template + TIntVector3 NegateV(TIntVector3& v1); + + /** + * Performes componentwise multiplication of two vectors. + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @note result is stored in v1. + */ + + template + TIntVector3 ScaleV(TIntVector3& v1, const TIntVector3& v2); + + /** + * Copies v1 vector + * + * @param(v1) Vector to copy to + * @param(v2) Vector to copy + */ + + template + TIntVector3 Set(TIntVector3& v1, const TIntVector3& v2); + + /** + * Sets vector. + * + * @param(v1) Vector to copy to + * @param(x) X component + * @param(y) Y component + * @param(z) Z component + */ + + template + TIntVector3 Set(TIntVector3& v1, T x, T y, T z); + + /** + * Returns signs of components in vector: -1 / +1 / 0. + * + * @param(v1) Vector one + */ + + template + TIntVector3 SignVectorV(TIntVector3& v1); + + + /** + * Gets scalar triple product ((v1 x v2) * v3). (Volume of parallelepiped.) + * + * @param(v1) Vector one + * @param(v2) Vector two + * @param(v3) Vector three + * + * @return Vector triple product + */ + + template + T ScalarTriple(const TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3); + + /** + * Gets the cosine of the angle between to vectors. + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return Cosine of angle between vectors. + * @note Simply omits acos of angle. + */ + + template + T CosineAngle(const TIntVector3& v1, const TIntVector3& v2); + + /** + * Gets vector triple product ((v1 x v2) x v3). + * + * @param(v1) Vector one + * @param(v2) Vector two + * @param(v3) Vector three + * + * @note result is stored in v1 + */ + + template + TIntVector3 VectorTripleV(TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3); + + /** + * Tests whether two vectors are perpendicular. + * + * @param(v1) Vector one + * @param(v2) Vector two + * @param(threshold) Allowed T inaccuracy + * + * @return True if perpendicular, false if not. + */ + + template + inline bool IsPerpendicular(const TIntVector3& v1, const TIntVector3& v2, T threshold = P_FLT_INAC); + + /** + * Tests whether two vectors are parallel. + * + * @param(v1) Vector one + * @param(v2) Vector two + * @param(threshold) Allowed T inaccuracy from one (e.g. 0.98f) + * + * @return True if parallel, false if not. + */ + + template + inline bool IsParallel(const TIntVector3& v1, const TIntVector3& v2, T threshold = 1.0f - P_FLT_INAC); + + /** + * Tests whether two vectors are coincident (Parallel and point in same direction). + * + * @param(v1) Vector one + * @param(v2) Vector two + * @param(threshold) Allowed T inaccuracy from one (e.g. 0.98f) + * + * @return True if coincident, false if not. + */ + + template + inline bool IsCoincident(const TIntVector3& v1, const TIntVector3& v2, T threshold = 1.0f - P_FLT_INAC); + + /** + * Tests whether v1 vectors is v1 unit vector. + * + * @param(v1) Vector + * @param(threshold) Allowed T inaccuracy + * + * @return True if unit vector, false if not. + */ + + template + inline bool IsNormalized(const TIntVector3& v1, T threshold = P_FLT_INAC); + + /** + * Tests if three vectors are coplanar + * + * @param(v1) Vector one + * @param(v2) Vector two + * @param(v3) Vector three + * @param(threshold) Allowed T inaccuracy + * + * @return True if coplanar, false if not. + */ + + template + inline bool IsCoplanar(const TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3, T threshold = P_FLT_INAC); + + + /** + * Gets outer product of to vectors. + * + * @param a Vector one + * @param b Vector two + * + * @return Resulting matrix + */ + + //template + //Matrix3 OuterProduct(const IntVector3& a, const IntVector3& b); + + + // ================================================================ // + // IntVector3 static function implementation with return values // + // ================================================================ // + + /** + * Normalized vector + * + * @param(v1) vector to normalize + * + * @return Normalized vector + */ + + template + TVector3 Normalize(const TIntVector3& v1); + + /** + * Normalizes vector + * + * @param(v1) Vector + * + * @note Does not test for zero vector + */ + + template + TVector3 UnsafeNormalize(const TIntVector3& v1); + + /** + * Reflects a vector on a surface + * + * @param(v1) Vector one + * @param(normal) Normal of surface + * + * @return Reflected vector + */ + + template + TVector3 Reflect(const TIntVector3& v1, const TVector3& normal); + + + /** + * Performes perspective divide on vector. + * + * @param(v1) vector to perspective divide + * + * @return Perspective divided vector + */ + + template + TVector3 PerspectiveDivide(const TIntVector3& v1); + + /** + * Gets cross product between two vectors. + * + * @param(v1) vector one + * @param(v2) vector two + * + * @return Cross product of v1 and v2 + */ + + template + TIntVector3 CrossP(const TIntVector3& v1, const TIntVector3& v2); + + /** + * Linearly interpolates between two vectors. + * + * @param(start) Starting vector + * @param(dest) Destination vector + * @param(t) 0.0 to 1.0 interpolation value + * + * @return Cross product of v1 and v2 + */ + + template + TVector3 Lerp(const TIntVector3& start, const TIntVector3& dest, Rt t); + + /** + * Linearly interpolates between two vectors. + * + * @param(v1) Starting vector + * @param(dest) Destination vector + * @param(t) 0.0 to 1.0 interpolation value + * + * @return Cross product of v1 and v2 + * @note Does not clamp t between 0.0 and 1.0. + */ + + template + TVector3 LerpUnclamped(const TIntVector3& start, const TIntVector3& dest, Rt t); + + /** + * Creates a new Vector by the componentwise max of both vectors + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return Vector of componentwise max + */ + + template + TIntVector3 Max(const TIntVector3& v1, const TIntVector3& v2); + + /** + * Creates a new Vector by the componentwise min of both vectors + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return Vector of componentwise min + */ + + template + TIntVector3 Min(const TIntVector3& v1, const TIntVector3& v2); + + /** + * Gets reversed vector. + * + * @param(v1) Vector one + * + * @note result is stored in v1. + */ + + template + TIntVector3 Negate(const TIntVector3& v1); + + /** + * Multiplies vector componentwise. + * + * @param(v1) Vector one + * @param(v2) Vector two + * + * @return Vector with componentwise products + */ + + template + TIntVector3 Scale(const TIntVector3& v1, const TIntVector3& v2); + + /** + * Clamps vector to a range of magnitudes. + * + * @param(v1) Vector to clamp + * @param(min) Min magnitude + * @param(max) Max magnitude + * + * @return Clamped vector + */ + + template + TVector3 ClampMagnitude(const TIntVector3& v1, T min, T max); + + /** + * Binds vector into cube. + * + * @param(v1) Vector to clamp + * @param(cubeRadius) Radius of the cube + * + * @result Vector clamped in cube. + */ + + template + TVector3 BoundToCube(const TIntVector3 v1, T cubeRadius) {}; + + /** + * Clamps vector into cube. + * + * @param(v1) Vector to clamp + * @param(cubeRadius) Radius of the cube + * + * @result Vector clamped in cube. + */ + + template + TVector3 ClampToCube(const TIntVector3 v1, T cubeRadius) {}; + + /** + * Scales vector two specific magnitude. + * + * @param(v1) Vector + * + * @note It's faster to use operator* or operator*= for naturaly normalized vectors. + */ + + template + TVector3 ScaleToMagnitude(const TIntVector3& v1, T magnitude); + + /** + * Clamps vector into cube. + * + * @param(v1) Vector + * + * @result Vector with inverted components. + */ + + template + TVector3 CompInverse(const TIntVector3& v1); + + /** + * Reflect by plane + * + * @param(v1) Vector to mirror + * @param(plane) Plane to mirror on + * + * @return Mirrored vector + */ + + template + FORCEINLINE TVector3 ReflectFromPlane(const TIntVector3& v1, const TPlane& plane); + + /** + * Reflect by plane + * + * @param(v1) Vector to mirror + * @param(plane) Normal of plane + * + * @return Mirrored vector + */ + + template + FORCEINLINE TVector3 ReflectFromPlane(const TIntVector3& v1, const TVector3& normal); + + /** + * Rotates vector around axis + * + * @param(v1) Vector to mirror + * @param(axisNormal) Axis to rotate around + * + * @return Rotated vector + * @note Calculates vector rotation with Rodrigues-Rotation + */ + + template + TVector3 RotateAroundAxis(const TIntVector3& v1, const TVector3& axisNormal, Rt angle); + + /** + * Gets vector triple product ((v1 x v2) x v3). + * + * @param(v1) Vector one + * @param(v2) Vector two + * @param(v3) Vector three + * + * @return Vector triple product + */ + + template + TIntVector3 VectorTriple(const TIntVector3& v1, const TIntVector3& v2, const TIntVector3& v3); + + /** + * Projects vector v1 onto v2 + * + * @param(v1) Vector to project + * @param(v2) Vector to project on + * + * @return Projected vector + */ + + template + TVector3 Project(const TIntVector3& v1, const TIntVector3& v2); + + /** + * Rejects vector v1 from v2 + * + * @param(v1) Vector to reject + * @param(v2) Vector to reject from + * + * @return Rejected vector + */ + + template + TVector3 Reject(const TIntVector3& v1, const TIntVector3& v2); + + /** + * Projects vector onto plane + * + * @param(v1) Vector to reject + * @param(normal) Normal of the plane + * + * @return Projected vector + * @note Simply rejects the vector from normal + */ + + template + FORCEINLINE TVector3 ProjectOntoPlane(const TIntVector3& v1, const TVector3& normal); + + /** + * Projects vector onto plane + * + * @param(v1) Vector to reject + * @param(normal) Plane + * + * @return Projected vector + * @note Simply rejects the vector from normal + */ + + template + FORCEINLINE TVector3 ProjectOntoPlane(const TIntVector3& v1, const TPlane& plane); + + /** + * Interpolate vector v1 to desitnation v2 using v1 constant s. The magnitude of the vector stays the same throughout the interpolation. + * + * @param(v1) Starting vector + * @param(v2) Destination vector + * @param(t) 0.0 to 1.0 interpolation value + * + * @return Interpolated unit vector + */ + + template + TVector3 Slerp(const TIntVector3& v1, const TIntVector3& v2, Rt t) {}; + + /** + * Interpolate vector v1 to desitnation v2 using v1 constant s. The magnitude of the vector stays the same throughout the interpolation. + * + * @param(v1) Starting vector + * @param(v2) Destination vector + * @param(t) 0.0 to 1.0 interpolation value + * + * @return Interpolated unit vector. + * @note Does not clamp s between 0.0 and 1.0. + */ + + template + TVector3 SlerpUnclamped(const TIntVector3& v1, const TIntVector3& v2, Rt t) {}; + +} // phanes::core::math::coretypes + +#endif // !INTVECTOR3_H + diff --git a/Engine/src/Runtime/Core/public/Math/IntVector4.h b/Engine/src/Runtime/Core/public/Math/IntVector4.h new file mode 100644 index 0000000..06b8ccc --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/IntVector4.h @@ -0,0 +1,941 @@ +#pragma once + +#include "Misc/BoilerplateHeader.h" +#include PHANES_CORE_PCH_DEFAULT_PATH + +#include "Math/MathCommon.h" +#include "Math/MathAbstractTypes.h" +#include "Math/MathFwd.h" + + +#ifndef P_DEBUG +#pragma warning(disable : 4244) +#endif + + +#ifndef INTVECTOR4_H +#define INTVECTOR4_H + +namespace phanes::core::math::coretypes { + + /** + * A 4D Vector with components x, y, z and w with integer precision. + */ + + template + struct IntVector4 { + + static_assert(std::is_integral_v(T), "T must be an integer type."); + + public: + + union + { + + struct + { + + /** X component of Vector + * + * @ref [FIELD]components + * + * @note x does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. + */ + T x = &components[1]; + + /** Y component of Vector + * + * @ref [FIELD]components + * + * @note y does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. + */ + T y = &components[1]; + + /** Z component of Vector + * + * @ref [FIELD]components + * + * @note z does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. + */ + T z = &components[2]; + + /** W component of Vector + * + * @ref [FIELD]components + * + * @note w does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience. + */ + T w = &components[3]; + + }; + + /** Components array holding the data + * + * @ref [FIELD]x + * @ref [FIELD]y + * @ref [FIELD]z + * @ref [FIELD]w + * + * @note Components are split into x, y, z and w. Access and manipulation is possible by these variables. + */ + + T components[4]; + }; + + + public: + + /** + * Default constructor without initialization + */ + + PHANES_CORE_API IntVector4() = default; + + + /** + * Construct Vector from xy components. + * + * @param x X component + * @param y Y component + * @param z Z component + * @param w W component + */ + + PHANES_CORE_API IntVector4(const T x, const T y, const T z, const T w); + + /** + * Construct Vector from two component array. + * + * @param comp Array of components + */ + + PHANES_CORE_API IntVector4(const T comp[4]); + + /** + * Construct Vector from 2D Vector's xy and the last two zero. + * + * @param v 2D IntVector to copy from + */ + + PHANES_CORE_API IntVector4(const Vector2& v); + + /** + * Construct Vector from 3D Vector's xyz and zero. + * + * @param v 3D Vector to copy from + */ + + + PHANES_CORE_API IntVector4(const Vector3& v); + + /** + * Construct Vector from 4D Vector's xyzw. + * + * @param v 4D Vector to copy from + */ + + PHANES_CORE_API IntVector4(const Vector4& v); + + + /** + * Construct Vector from 2D integer Vector's xy and the last two zero. + * + * @param v 3D IntVector to copy from + */ + + PHANES_CORE_API IntVector4(const IntVector2& v); + + /** + * Construct Vector from 4D integer Vector's xyz and zero. + * + * @param v 4D IntVector to copy from + */ + + PHANES_CORE_API IntVector4(const IntVector3& v); + + /** + * Construct Vector from 3D Point's xyzw. + * + * @param v 3D Point to copy from + */ + + PHANES_CORE_API IntVector4(const IntPoint4& v); + + + }; + + + // List of IntVector4 for DoP and ECS + + // List of 4D Vectors using int + using IntVector4List = std::vector >; + + + + // ======================== // + // IntVector4 operators // + // ======================== // + + + + /** + * Addition operation on same IntVector4 (this) by a integer value. + * + * @param a Vector to add to + * @param s integer to add + */ + + template + INLINE PHANES_CORE_API void operator+= (IntVector4& a, T s); + + + /** + * Addition operation on same IntVector4 (this) by a another IntVector4. + * + * @param a Vector to add to + * @param b Vector to add + */ + + template + INLINE PHANES_CORE_API void operator+= (IntVector4& a, const IntVector4& b); + + + /** + * Substraction operation on same IntVector4 (this) by a integer. + * + * @param a Vector to substract from + * @param b integer to substract + */ + + template + INLINE PHANES_CORE_API void operator-= (IntVector4& a, T s); + + + /** + * Substraction operation on same IntVector4 (this) by a another IntVector4. + * + * @param a Vector to substract from + * @param b Vector to substract + */ + + template + INLINE PHANES_CORE_API void operator-= (IntVector4& a, const IntVector4& b); + + + /** + * Multiplication of IntVector4 (this) with a integer. (Scale) + * + * @param a Vector to multiply with + * @param s integer to multiply with + */ + + template + INLINE PHANES_CORE_API void operator*= (IntVector4& a, T s); + + + /** + * Devision of Vector (this) by integer. + * + * @ref [FUNC]DivideTruncV + * @ref [FUNC]DivideFloatV + * + * @param a Vector to multiply with + * @param s integer to divide with + * + * @note Rounds components + */ + + template + INLINE PHANES_CORE_API void operator/= (IntVector4& a, T s); + + + /** + * Componentwise divison of Vector (this) by another vector + * + * @ref [FUNC]DivideTruncV + * @ref [FUNC]DivideFloatV + * + * @param a Vector to multiply with + * @param b Vector to divide with + * + * @note Rounds components + */ + + template + INLINE PHANES_CORE_API void operator/= (IntVector4& a, const IntVector4& b); + + + /** + * Scale of Vector by integer. (> Creates a new IntVector4) + * + * @param a Vector to multiply with + * @param s integer to multiply with + * + * @return Result Vector + */ + + template + INLINE PHANES_CORE_API IntVector4 operator* (const IntVector4& a, T s); + + + /** + * Scale of Vector by integer. (> Creates a new IntVector4) + * + * @param a Vector to multiply with + * @param s integer to multiply with + * + * @return Result Vector + */ + + template + INLINE PHANES_CORE_API IntVector4 operator* (T s, const IntVector4& a); + + + /** + * Dot product between two Vectors. + * + * @ref [FUNC]DotP + * + * @param a Vector one + * @param b Vector two + * + * @result Dot product + */ + + template + INLINE PHANES_CORE_API T operator* (const IntVector4& a, const IntVector4& b); + + + /** + * Division of Vector by integer. (> Creates another IntVector4) + * + * @param a Vector to multiply with + * @param s integer to divide with + * + * @return Result Vector + */ + + template + INLINE PHANES_CORE_API IntVector4 operator/ (const IntVector4& a, T s); + + + /** + * Division of Vector by integer. (> For convenience not arithmethicaly correct. Works like overloaded counterpart.) + * + * @ref [FUNC]DivideTrunc + * @ref [FUNC]DivideFloat + * + * @param a Vector to multiply with + * @param s integer to divide with + * + * @note Rounds components + * + * @return Result Vector + */ + + template + INLINE PHANES_CORE_API IntVector4 operator/ (T s, const IntVector4& a); + + + /** + * Componentwise division of Vector (> For convenience not arithmethicaly correct. Works like overloaded counterpart.) + * + * @ref [FUNC]DivideTrunc + * @ref [FUNC]DivideFloat + * + * @param a Vector to multiply with + * @param s integer to divide with + * + * @note Rounds components + * + * @return Result Vector + */ + + template + INLINE PHANES_CORE_API IntVector4 operator/ (const IntVector4& a, const IntVector4& b); + + + /** + * Componentwise addition of Vector with integer. + * + * @param a Vector to add to + * @param s integer to add + * + * @return Result Vector + */ + + template + INLINE PHANES_CORE_API IntVector4 operator+ (const IntVector4& a, T s); + + + /** + * Componentwise addition of Vector with integer. + * + * @param a Vector to add to + * @param s integer to add + * + * @return Result Vector + */ + + template + INLINE PHANES_CORE_API IntVector4 operator+ (const IntVector4& a, const IntVector4& b); + + + /** + * Componentwise substraction of Vector with integer. + * + * @param a Vector to substract from + * @param s integer to substract + * + * @return Result Vector + */ + + template + INLINE PHANES_CORE_API IntVector4 operator- (const IntVector4& a, T s); + + /** + * Componentwise substraction of Vector with Vector. + * + * @param a Vector to substract from + * @param s integer to substract + * + * @return Result Vector + */ + + template + INLINE PHANES_CORE_API IntVector4 operator- (const IntVector4& a, const IntVector4& b); + + + /** + * Negate Vector. + * + * @param a Vector to negate + */ + + template + INLINE PHANES_CORE_API void operator- (IntVector4& a); + + + /** + * Compare Vector for equality. + * + * @ref [FUNC]Equals + * + * @param a Vector to negate + * + * @return true if equal, false if inequal + */ + + template + INLINE PHANES_CORE_API bool operator== (const IntVector4& a, const IntVector4& b); + + + /** + * Compare Vector for inequality. + * + * @ref [FUNC]Equals + * + * @param a Vector to negate + * + * @return true if inequal, false if equal + */ + + template + INLINE PHANES_CORE_API bool operator!= (const IntVector4& a, const IntVector4& b); + + + // ============================================== // + // IntVector4 static function implementation // + // ============================================== // + + /** + * Magnitude of Vector + * + * @param a Vector + * + * @return Size of Vector + */ + + template + PHANES_CORE_API T Magnitude(const IntVector4& a); + + + /** + * Square of magnitude of Vector + * + * @param a Vector + * + * @return Magnitude without calculating square root + */ + + template + PHANES_CORE_API T SqrMagnitude(const IntVector4& a); + + + /** + * Normalize Vector + * + * @param a Vector + */ + + template + PHANES_CORE_API void NormalizeV(IntVector4& a); + + + /** + * Angle between to Vectors + * + * @param a Vector one + * @param b Vector two + */ + + template + PHANES_CORE_API T Angle(const IntVector4& a, const IntVector4& b); + + + /** + * Dot product of two Vectors + * + * @param a Vector one + * @param b Vector two + */ + + template + PHANES_CORE_API T DotP(const IntVector4& a, const IntVector4& b); + + + /** + * Creates Vector, with component wise largest values. + * + * @param a Vector one + * @param b Vector two + * + * @note Stores new Vector to a + */ + + template + PHANES_CORE_API void MaxV(IntVector4& a, const IntVector4& b); + + + /** + * Creates Vector, with component wise smallest values. + * + * @param a Vector one + * @param b Vector two + * + * @note Stores new Vector to a + */ + + template + PHANES_CORE_API void MinV(IntVector4& a, const IntVector4& b); + + + /** + * Gets perpendicular Vector to a. + * + * @reg NO_RETURN(ReversePerpendicular) + * + * @param a Vector one + * + * @note Stores new Vector to a + */ + + template + PHANES_CORE_API void PerpendicularV(IntVector4& a); + + + /** + * Gets perpendicular Vector to a. + * + * @reg NO_RETURN(Perpendicular) + * + * @param a Vector one + * + * @note Stores new Vector to a + */ + + template + PHANES_CORE_API void ReversePerpendicularV(IntVector4& a); + + + /** + * Component wise multiplication of Vector + * + * @param a Vector one + * @param b Vector two + * + * @note Stores new Vector to a + */ + + template + PHANES_CORE_API void ScaleV(IntVector4& a, const IntVector4& b); + + + /** + * Component wise division of Vector + * + * @param a Vector one + * @param b Vector two + * + * @note Truncates result instead of rounding + * @note Stores new Vector to a + */ + + template + PHANES_CORE_API void DivideTruncV(IntVector4& a, const IntVector4& b); + + + /** + * Component wise division of Vector + * + * @param a Vector one + * @param b Vector two + * + * @note Truncates result instead of rounding + * @note Stores new Vector to a + */ + + template + PHANES_CORE_API void DivideTruncV(IntVector4& a, T s); + + + /** + * Componentwise inversion of Vector + * + * @param a Vector one + * + * @note Stores new Vector to a + */ + + template + PHANES_CORE_API void CompInverseV(IntVector4& a); + + + /** + * Reflect Vector by normal vector. + * + * @param a Vector one + * @param b Vector two + * + * @note Stores new Vector to a + */ + + template + PHANES_CORE_API void ReflectV(IntVector4& a, const IntVector4& normal); + + + /** + * Copies one Vector two another + * + * @param a Vector to copy to + * @param b Vector to copy + */ + + template + PHANES_CORE_API void Set(IntVector4& a, const IntVector4& b); + + + /** + * Sets components of a vector. + * + * @param a Vector to copy to + * @param b Vector to copy + */ + + template + PHANES_CORE_API void Set(IntVector4& a, T x, T y, T z, T w); + + + /** + * Tests if vector is a unity vector. + * + * @param a Vector one + * @param threshold Threshold to one + * + * @return true if unit vector, false if not + */ + + template + PHANES_CORE_API bool IsNormalized(const IntVector4& a, T threshold = P_FLT_INAC); + + /** + * Tests if 2 vectors are perpendicular to each other. + * + * @param a Vector one + * @param b Vector two + * @param threshold Threshold + * + * @return true if perpendicular, false if not + */ + + template + PHANES_CORE_API bool IsPerpendicular(const IntVector4& a, const IntVector4& b, T threshold = P_FLT_INAC); + + + /** + * Tests if 2 vectors are parallel to each other. (Angle is close to zero.) + * + * @param a Vector one + * @param b Vector two + * @param threshold Threshold + * + * @return true if parallel, false if not + */ + + template + PHANES_CORE_API bool IsParallel(const IntVector4& a, const IntVector4& b, T threshold = P_FLT_INAC); + + /** + * Tests if 2 vectors are coincident. (Are parallel and point in the same direction.) + * + * @param a Vector one + * @param b Vector two + * @param threshold Threshold + * + * @return true if coincident, false if not + */ + + template + PHANES_CORE_API bool IsCoincident(const IntVector4& a, const IntVector4& b, T threshold = P_FLT_INAC); + + + /** + * Gets outer product of to vectors. + * + * @param a Vector one + * @param b Vector two + * + * @return Resulting matrix + */ + + template + PHANES_CORE_API Matrix2 OuterProduct(const IntVector4& a, const IntVector4& b); + + + // ================================================================ // + // IntVector4 static function implementation with return values // + // ================================================================ // + + + /** + * Reflects a vector on a normal + * + * @param a Vector one + * @param normal Normal vector + * + * @return Reflected vector + */ + + template + PHANES_CORE_API IntVector4 Reflect(const IntVector4& a, const IntVector4& normal); + + + /** + * Scales a vector component wise + * + * @param a Vector one + * @param b Vector two + * + * @return Reflected vector + */ + + template + PHANES_CORE_API IntVector4 Scale(const IntVector4& a, const IntVector4& b); + + + /** + * Component wise division of Vector + * + * @param a Vector one + * @param b Vector two + * + * @note Truncates result instead of rounding + */ + + template + PHANES_CORE_API IntVector4 DivideTrunc(const IntVector4& a, const IntVector4& b); + + + /** + * Component wise division of Vector + * + * @param a Vector one + * @param b Vector two + * + * @note Truncates result instead of rounding + */ + + template + PHANES_CORE_API IntVector4 DivideTrunc(const IntVector4& a, T s); + + + /** + * Component wise division of Vector + * + * @param a Vector one + * @param b Vector two + * + * @return Floating point vector + */ + + template + PHANES_CORE_API Vector2 DivideFloat(const IntVector4& a, const IntVector4& b); + + + /** + * Component wise division of Vector + * + * @param a Vector one + * @param b Vector two + * + * @return Floating point vector + */ + + template + PHANES_CORE_API Vector2 DivideFloat(const IntVector4& a, T s); + + + /** + * Componentwise inverse of Vector + * + * @param a Vector one + * @param b Vector two + * + * @return Reflected vector + */ + + template + PHANES_CORE_API IntVector4 CompInverse(const IntVector4& a); + + + /** + * Gets the perpendicular vector of a + * + * @param a Vector one + * + * @return Perpendicular vector + */ + + template + PHANES_CORE_API IntVector4 Perpendicular(const IntVector4& a); + + + /** + * Gets reverse of the perpendicular vector of a + * + * @param a Vector one + * + * @return Reversed perpendicular vector + */ + + template + PHANES_CORE_API IntVector4 ReversePerpendicular(const IntVector4& a); + + + /** + * Creates a new Vector by the component wise minimals of both vectors + * + * @param a Vector one + * @param b Vector two + * + * @return Minimal vector + */ + + template + PHANES_CORE_API IntVector4 Min(const IntVector4& a, const IntVector4& b); + + + /** + * Creates a new Vector by the component wise maxima of both vectors + * + * @param a Vector one + * @param b Vector two + * + * @return Maximal vector + */ + + template + PHANES_CORE_API IntVector4 Max(const IntVector4& a, const IntVector4& b); + + + /** + * Creates a normalized instance of the vector + * + * @param a Vector to normalize + * + * @return Unit vector + */ + + template + PHANES_CORE_API IntVector4 Normalize(const IntVector4& a); + + + /** + * Interpolates between to vectors. + * + * @param a Start value (t = 0) + * @param b End value (t = 1) + * @param t Interpolation value + * + * @return Interpolated vector + * + * @note Interpolation is clamped between 0 - 1. + */ + + template + INLINE PHANES_CORE_API IntVector4 Lerp(const IntVector4& a, const IntVector4& b, T t); + + + /** + * Interpolates between to vectors. + * + * @param a Start value (t = 0) + * @param b End value (t = 1) + * @param t Interpolation value + * + * @return Interpolated vector + * + * @note Interpolation is not clamped. + */ + + template + INLINE PHANES_CORE_API IntVector4 LerpUnclamped(const IntVector4& a, const IntVector4& b, T t); + + + /** + * Spherical interpolation between two vectors. + * + * @param a Start value (t = 0) + * @param b End value (t = 1) + * @param t Interpolation value + * + * @return Interpolated vector + * + * @note Interpolation is clamped between 0 - 1. + * @note Quaternion are more efficient and should be used if possible. + */ + + template + PHANES_CORE_API IntVector4 Slerp(const IntVector4& a, const IntVector4& b, T t); + + + /** + * Spherical interpolation between two vectors. + * + * @param a Start value (t = 0) + * @param b End value (t = 1) + * @param t Interpolation value + * + * @return Interpolated vector + * + * @note Interpolation is clamped between 0 - 1. + * @note Quaternion are more efficient and should be used if possible. + */ + + template + PHANES_CORE_API IntVector4 SlerpUnclamped(const IntVector4& a, const IntVector4& b, T t); + +} // phanes::core::math::coretypes + +#endif // !INTVECTOR3_H + diff --git a/Engine/src/Runtime/Core/public/Math/MathAbstractTypes.h b/Engine/src/Runtime/Core/public/Math/MathAbstractTypes.h new file mode 100644 index 0000000..910862e --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/MathAbstractTypes.h @@ -0,0 +1,29 @@ +#pragma once + +#ifndef ABSTRACT_TYPES_H +#define ABSTRACT_TYPES_H + +namespace Phanes::Core::Math::Internal { + + template + struct AVector { + public: + + /** + * List of n components of the vector + */ + + T comp[D]; + + }; + + template + struct AMatrix { + public: + T fields[n][m]; + + }; + +}; // Phanes::Core::Math::abstract::coretypes + +#endif // !ABSTRACT_TYPES_H \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/MathCommon.h b/Engine/src/Runtime/Core/public/Math/MathCommon.h new file mode 100644 index 0000000..16745ce --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/MathCommon.h @@ -0,0 +1,98 @@ +#pragma once + +#define P_FLT_INAC_LARGE 0.0001f // large float inaccuracy (1*10^-4); +#define P_FLT_INAC 0.00001f // float inaccuracy (1*10^-5); +#define P_FLT_INAC_SMALL 0.000001f // small float inaccuracy (1*10^-6); + +#define P_180_PI 57.29577951308232 // (double) 180°/pi; +#define P_180_PI_FLT 57.29577951308232f // (float) 180°/pi; + +#define P_PI_180 0.0174532925199432 // double pi/180° +#define P_PI_180_FLT 0.0174532925199432f // (float) pi/180° + +#define P_PI 3.1415926535897932 // PI +#define P_PI_FLT 3.1415926535897932f // PI + + +#include "Core/Core.h" + +#ifndef MATH_COMMON_H +#define MATH_COMMON_H + +namespace Phanes::Core::Math { + + /** + * Clamps a value between minimum and maximum + * + * @param value Value to clamp + * @param low Minimum + * @param high Maximum + * + * @return Minimum, if value is to small / Maximum, if value is to large / value, if value is in range. + */ + + template + T Clamp(T value, T low, T high); + + + /** + * Gets the larger of two values + * + * @param x + * @param y + * + * @return Larger value + */ + + template + inline T Max(T x, T y); + + + /** + * Gets the smaller of two values + * + * @param x + * @param y + * + * @return Smaller value + */ + + template + inline T Min(T x, T y); + + /** + * Swaps the values of two variables + * + * @param x + * @param y + */ + + template + inline void Swap(T& x, T& y); + + /** + * Test two numbers for equality + * + * @param x + */ + template + bool Equals(T x, T y, T threshold = P_FLT_INAC); + + /** + * Calculates the reciprocal of the square root of n using the algorithm of A Quake III + * + * @param n Number to calculate + * + * @return Inverse square root of n + * + * @note a simple 1.0f / sqrtf(x) is faster than this algorithm. Use for research purpose only. + */ + + + template + float FastInvSqrt(T n); + + +} // phanes + +#endif // !MATH_COMMON_H \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/MathFwd.h b/Engine/src/Runtime/Core/public/Math/MathFwd.h new file mode 100644 index 0000000..3f9f523 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/MathFwd.h @@ -0,0 +1,103 @@ +#pragma once + +#include "Core/Core.h" + +#include "Core/public/OSAL/PlatformTypes.h" + +#ifndef MATH_FWD_H +#define MATH_FWD_H + +#include "Core/public/Misc/Boilerplate.h" + +/** + * Includes forward declarations, as well as certain useful typedefs. + * + * @ref OSAL/PlatformTypes.h + */ + + +namespace Phanes::Core::Math { + + /** + * Template forward declarations. + */ + + template struct TColor; + template struct TLinearColor; + template struct TVector2; + template struct TVector3; + template struct TVector4; + template struct TRay; + template struct TPlane; + template struct TMatrix2; + template struct TMatrix3; + template struct TMatrix4; + template struct TQuaternion; + template struct TTransform; + template struct TPoint2; + template struct TPoint3; + template struct TPoint4; + template struct TIntVector2; + template struct TIntVector3; + template struct TIntVector4; + template struct TIntPoint2; + template struct TIntPoint3; + template struct TIntPoint4; + + /** + * Specific instantiation of forward declarations. + */ + + // TVector2 + typedef TVector2 Vector2; + typedef TVector2 Vector2d; + + typedef std::vector Vector2List; + typedef std::vector Vector2Listd; + + // TVector3 + typedef TVector3 Vector3; + typedef TVector3 Vector3d; + + typedef std::vector Vector3List; + typedef std::vector Vector3Listd; + + + + // TIntVector2 + typedef TIntVector2 IntVector2; + typedef TIntVector2 IntVector2l; + + typedef std::vector IntVector2List; + typedef std::vector IntVector2Listl; + + // TIntVector3 + typedef TIntVector3 IntVector3; + typedef TIntVector3 IntVector3l; + + typedef std::vector IntVector3List; + typedef std::vector IntVector3Listl; + + + + // TMatrix2 + typedef TMatrix2 Matrix2; + typedef TMatrix2 Matrix2d; + + typedef std::vector Matrix2List; + typedef std::vector Matrix2Listd; + +} // Phanes::Core::Math::coretypes + +namespace Phanes::Core::Math::Internal +{ + + // Internal types + + template struct AVector; + + template struct AMatrix; +} + + +#endif // !MATH_FWD_H \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/MathTypeConversion.h b/Engine/src/Runtime/Core/public/Math/MathTypeConversion.h new file mode 100644 index 0000000..f444f71 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/MathTypeConversion.h @@ -0,0 +1,77 @@ +#pragma once + +// ============================================= // +// Function to convert types into each other // +// // +// @ref [FILE]MathUnitConversion // +// ============================================= // + +#include "PhanesEnginePCH.h" +#include "Core/public/Misc/Boilerplate.h" + +#include "Core/public/Math/MathAbstractTypes.h" +#include "Core/public/Math/Vector2.h" +#include "Core/public/Math/Vector3.h" +//#include "Core/public/Math/Vector4.h" +//#include "Core/public/Math/Matrix2.h" +//#include "Core/public/Math/Matrix3.h" +#include "Core/public/Math/IntVector2.h" +#include "Core/public/Math/IntVector3.h" + +#ifndef MATH_TYPE_CONVERSION_H +#define MATH_TYPE_CONVERSION_H + + +namespace Phanes::Core::Math { + + // =================================================== // + // std::to_string wrapper // + // // + // This is, to make using ToString more general // + // and allow usage of one function instead of two, // + // for converting a mathmatical type to a string. // + // =================================================== // + + FORCEINLINE std::string ToString(long long val) { return std::to_string(val); }; + + FORCEINLINE std::string ToString(double val) { return std::to_string(val); }; + + FORCEINLINE std::string ToString(float val) { return std::to_string(val); }; + + FORCEINLINE std::string ToString(int val) { return std::to_string(val); }; + + FORCEINLINE std::string ToString(long val) { return std::to_string(val); }; + + FORCEINLINE std::string ToString(long double val) { return std::to_string(val); }; + + FORCEINLINE std::string ToString(unsigned long long val) { return std::to_string(val); }; + + FORCEINLINE std::string ToString(unsigned int val) { return std::to_string(val); }; + + FORCEINLINE std::string ToString(unsigned long val) { return std::to_string(val); }; + + // ============ // + // ToString // + // ============ // + + template + std::string ToString(const TVector2& v); + + template + std::string ToString(const TIntVector2& v); + + template + std::string ToString(const TVector3& v); + + template + std::string ToString(const TIntVector3& v); + + //std::string toString(const Vector4& v); + + //std::string toString(const Matrix2& v); + + //std::string toString(const Matrix3& v); + +} + +#endif // !MATH_TYPE_CONVERSION_H \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/MathUnitConversion.h b/Engine/src/Runtime/Core/public/Math/MathUnitConversion.h new file mode 100644 index 0000000..6e4f581 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/MathUnitConversion.h @@ -0,0 +1,112 @@ +#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/Matrix2.h b/Engine/src/Runtime/Core/public/Math/Matrix2.h new file mode 100644 index 0000000..8feff6a --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/Matrix2.h @@ -0,0 +1,154 @@ +#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/Plane.h b/Engine/src/Runtime/Core/public/Math/Plane.h new file mode 100644 index 0000000..be790bd --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/Plane.h @@ -0,0 +1,23 @@ +#pragma once + +#include "Core/public/Misc/Boilerplate.h" + +#include "Core/public/Math/Vector3.h" + +#include "Core/public/Math/MathFwd.h" + +namespace Phanes::Core::Math { + + // Plane in 3D space, defined as: P: ax + by + cz = d; + + template + struct TPlane + { + public: + TVector3 normal; + T d; + }; + +} // Phanes::Core::Math + + \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/Point.h b/Engine/src/Runtime/Core/public/Math/Point.h new file mode 100644 index 0000000..58a6397 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/Point.h @@ -0,0 +1,184 @@ +#pragma once + +#include "Core/public/Misc/Boilerplate.h" + +#include "Core/public/Math/MathCommon.h" +#include "Core/public/Math/MathAbstractTypes.h" +#include "Core/public/Math/MathFwd.h" + +#ifndef P_DEBUG +#pragma warning(disable : 4244) +#endif + +/** + * The Point is the same as a vector. The type exists, to ensure + * differentiation between the two types. + */ + +#ifndef POINT_H +#define POINT_H + +namespace Phanes::Core::Math { + + /** + * A 2D Point with components x and y with float precision. + */ + + template + struct TPoint2 : public TVector2 { + static_assert(std::is_floating_point_v, "T must be a floating point"); + + using TVector2::TVector2; + + using Real = T; + + /** + * Creates Point2 from Point3's xy + * + * @param a Point3 one + */ + + TPoint2(const TPoint3& p) + { + this->x = p.x; + this->y = p.y; + } + + /** + * Creates Point2 from Point4's xy + * + * @param a Point4 one + */ + + TPoint2(const TPoint4& p) + { + this->x = p.x; + this->y = p.y; + } + }; + + /** + * Calculates distance between two points. + * + * @param(p1) Point one + * @param(p2) Point two + * + * @return Distance between two points. + */ + + template + T Distance(const TPoint2& p1, const TPoint2& p2); + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + + /** + * A 3D Point with components x and y with float precision. + */ + + + template + struct TPoint3 : public TVector3 { + static_assert(std::is_floating_point_v(T), "T must be a floating point"); + + using TVector3::TVector3; + + using Real = T; + + /** + * Creates Point3 from Point2's xy and zero + * + * @param a Point2 one + */ + + TPoint3(const TPoint2& p) + { + this->x = p.x; + this->y = p.y; + this->z = 0; + } + + /** + * Creates Point3 from Point4's xyz + * + * @param a Point4 one + */ + + TPoint3(const TPoint4& p) + { + this->x = p.x; + this->y = p.y; + this->z = p.z; + } + }; + + /** + * Calculates distance between two points. + * + * @param(p1) Point one + * @param(p2) Point two + * + * @return Distance between two points. + */ + + template + T Distance(const TPoint3& p1, const TPoint3& p2); + + /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + + /** + * A 4D Point with components x and y with float precision. + */ + + + //template + //struct TPoint4 : public TVector4 { + // static_assert(std::is_floating_point_v(T), "T must be a floating point"); + + // using TVector4::TVector4; + + // /** + // * Creates Point4 from Point2's xy and the last two zero + // * + // * @param a Point2 one + // */ + + // TPoint4(const TPoint2& p) + // { + // this->x = p.x; + // this->y = p.y; + // this->z = 0; + // this->w = 0; + // } + + // /** + // * Creates Point4 from Point3's xyz and zero + // * + // * @param a Point3 one + // */ + + // TPoint4(const TPoint3& p) + // { + // this->x = p.x; + // this->y = p.y; + // this->z = p.z; + // this->w = 0; + // } + //}; + + ///** + // * Calculates distance between two points. + // * + // * @param(p1) Point one + // * @param(p2) Point two + // * + // * @return Distance between two points. + // */ + + //template + //T Distance(const TPoint4& p1, const TPoint4& p2); + +} // phanes::core::math::coretypes + +#endif // !POINT_H \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/README.md b/Engine/src/Runtime/Core/public/Math/README.md new file mode 100644 index 0000000..ccb30e1 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/README.md @@ -0,0 +1,12 @@ +# PhanesCore + +## Math + +### Description + +Math lib. + + +### Notes + +- Normals are called normals for a reason. \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/Math/Vector2.h b/Engine/src/Runtime/Core/public/Math/Vector2.h new file mode 100644 index 0000000..3765c8e --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/Vector2.h @@ -0,0 +1,938 @@ +#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/Vector3.h b/Engine/src/Runtime/Core/public/Math/Vector3.h new file mode 100644 index 0000000..aea16e0 --- /dev/null +++ b/Engine/src/Runtime/Core/public/Math/Vector3.h @@ -0,0 +1,1191 @@ +#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/StartingPoint/EntryPoint.h b/Engine/src/Runtime/Core/public/StartingPoint/EntryPoint.h index df61aef..00cef89 100644 --- a/Engine/src/Runtime/Core/public/StartingPoint/EntryPoint.h +++ b/Engine/src/Runtime/Core/public/StartingPoint/EntryPoint.h @@ -1,17 +1,26 @@ #pragma once // Entry point for Phanes game -#if defined(P_WIN_BUILD) && defined(P_BUILD_LIB) +#if defined(P_WIN_BUILD) -extern Phanes::Core::Application::PhanesGame* Phanes::Core::Application::CreatePhanesGame(); +extern Phanes::Core::Application::PhanesProject* Phanes::Core::Application::CreatePhanesGame(); int main(int argc, char** argv) { + Phanes::Core::Logging::Init(); + PENGINE_LOG_INFO("Logger initialized!"); + PENGINE_LOG_INFO("Welcome to PhanesEngine!"); + + auto phanes_game = Phanes::Core::Application::CreatePhanesGame(); + + PENGINE_LOG_INFO("Loading project {0}...", phanes_game->GetName()); phanes_game->Run(); delete phanes_game; + + return 0; } #endif \ No newline at end of file diff --git a/Engine/src/Runtime/Core/public/StartingPoint/StartingPoint.h b/Engine/src/Runtime/Core/public/StartingPoint/StartingPoint.h index d6a2421..7b3114d 100644 --- a/Engine/src/Runtime/Core/public/StartingPoint/StartingPoint.h +++ b/Engine/src/Runtime/Core/public/StartingPoint/StartingPoint.h @@ -1,24 +1,36 @@ #pragma once +#include "PhanesEnginePCH.h" + #include "Core/Core.h" // Entrypoint class for any Phanes game. namespace Phanes::Core::Application { - class PhanesGame + class PHANES_CORE PhanesProject { + + private: + + std::string projectName; public: - PhanesGame(); - virtual ~PhanesGame(); + PhanesProject(std::string _ProjectName); + virtual ~PhanesProject(); /** * PhanesEngine main loop. */ void Run(); + /** + * Getter for project name; + */ + + FORCEINLINE std::string GetName(); + }; @@ -26,5 +38,5 @@ namespace Phanes::Core::Application * Function to be overwriten by client. */ - PhanesGame* CreatePhanesGame(); + PhanesProject* CreatePhanesGame(); } diff --git a/Engine/src/Runtime/PhanesEnginePCH.h b/Engine/src/Runtime/PhanesEnginePCH.h index aee3ca9..6474d3f 100644 --- a/Engine/src/Runtime/PhanesEnginePCH.h +++ b/Engine/src/Runtime/PhanesEnginePCH.h @@ -8,7 +8,7 @@ #ifndef PHANES_CORE_PCH_H - + // STL #include #include @@ -17,12 +17,10 @@ #include #include - #include + #include #include - - #include #include @@ -32,6 +30,10 @@ #endif + // spdlog + + #include + #include #endif // !PHANES_CORE_PCH_H diff --git a/Samples/DevPlayground/DevPlayground.cpp b/Samples/DevPlayground/DevPlayground.cpp index 2795340..6f0d5ea 100644 --- a/Samples/DevPlayground/DevPlayground.cpp +++ b/Samples/DevPlayground/DevPlayground.cpp @@ -1,10 +1,13 @@ #define P_USE_NAMESPACE_ALIAS #include -class DevPlayground : public PApp::PhanesGame {}; - - -PApp::PhanesGame* PApp::CreatePhanesGame() +class DevPlayground : public PApp::PhanesProject { - return new DevPlayground(); + using PhanesProject::PhanesProject; +}; + + +PApp::PhanesProject* PApp::CreatePhanesGame() +{ + return new DevPlayground("DevPlayground"); } \ No newline at end of file