Remove math.
This commit is contained in:
scorpioblood
parent
3e58f65d28
commit
08c2d7b9d1
3
.gitignore
vendored
3
.gitignore
vendored
@ -409,4 +409,5 @@ FodyWeavers.xsd
|
||||
# Exclude other folders
|
||||
|
||||
bin/
|
||||
bin-int/
|
||||
bin-int/
|
||||
external/
|
||||
0
.gitmodules
vendored
Normal file
0
.gitmodules
vendored
Normal file
@ -3,28 +3,28 @@
|
||||
|
||||
#ifdef P_WIN_BUILD
|
||||
|
||||
#ifdef P_DEBUG
|
||||
|
||||
#define P_DEBUGBREAK DebugBreak();
|
||||
#ifdef P_DEBUG
|
||||
|
||||
#define P_DEBUGBREAK DebugBreak();
|
||||
|
||||
#else
|
||||
|
||||
#define P_DEBUGBREAK
|
||||
#else
|
||||
|
||||
#define P_DEBUGBREAK
|
||||
|
||||
#endif // P_DEBUG
|
||||
#endif // P_DEBUG
|
||||
|
||||
#define FORCEINLINE __forceinline
|
||||
#define FORCEINLINE __forceinline
|
||||
|
||||
#elif defined(P_UNIX_BUILD)
|
||||
|
||||
#error Only Windows is supported at the moment.
|
||||
#error Only Windows is supported at the moment.
|
||||
|
||||
#elif defined(P_ARM_BUILD)
|
||||
|
||||
#error Only Windows is supported at the moment.
|
||||
|
||||
#error Only Windows is supported at the moment.
|
||||
|
||||
#else
|
||||
|
||||
#error The target system must be defined. (See https://github.com/scorpioblood/PhanesEngine for more information)
|
||||
#error The target system must be defined. (See https://github.com/scorpioblood/PhanesEngine for more information)
|
||||
|
||||
#endif // P_WIN_BUILD
|
||||
@ -1,41 +1,23 @@
|
||||
#pragma once
|
||||
|
||||
#ifdef P_USE_NAMESPACES
|
||||
|
||||
using namespace Phanes::Core::Math::Literals;
|
||||
|
||||
// Starting point
|
||||
namespace PApp = Phanes::Core::Application;
|
||||
|
||||
|
||||
// Math
|
||||
namespace PMath = Phanes::Core::Math;
|
||||
namespace PMathInternal = Phanes::Core::Math::Internal;
|
||||
|
||||
|
||||
// OSAL
|
||||
namespace PTypes = Phanes::Core::Types
|
||||
|
||||
#endif
|
||||
|
||||
// --- Starting point ------------------------------
|
||||
|
||||
#include "Core/public/StartingPoint/StartingPoint.h"
|
||||
#include "Core/public/StartingPoint/EntryPoint.h"
|
||||
|
||||
// --- Math ----------------------------------------
|
||||
|
||||
#include "Core/public/Math/MathAbstractTypes.h"
|
||||
#include "Core/public/Math/MathCommon.h"
|
||||
#include "Core/public/Math/MathTypeConversion.h"
|
||||
#include "Core/public/Math/MathUnitConversion.h"
|
||||
#include "Core/public/Math/MathFwd.h"
|
||||
#include "Core/public/Math/Vector2.h"
|
||||
#include "Core/public/Math/Vector3.h"
|
||||
|
||||
#include "Core/public/Math/IntVector2.h"
|
||||
#include "Core/public/Math/IntVector3.h"
|
||||
|
||||
// --- OSAL ----------------------------------------
|
||||
|
||||
#include "Core/public/OSAL/PlatformTypes.h"
|
||||
|
||||
|
||||
#ifdef P_USE_NAMESPACE_ALIAS
|
||||
|
||||
|
||||
// Starting point
|
||||
namespace PApp = Phanes::Core::Application;
|
||||
|
||||
using namespace Phanes::Core::Math::UnitLiterals;
|
||||
|
||||
#endif
|
||||
@ -1,22 +0,0 @@
|
||||
#include "PhanesEnginePCH.h"
|
||||
|
||||
#include "Core/public/Math/IntPoint.h"
|
||||
|
||||
|
||||
|
||||
// ----- TIntPoint2 ------------------------------------------
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Rt Phanes::Core::Math::Distance(const TIntPoint2<T>& p1, const TIntPoint2<T>& p2)
|
||||
{
|
||||
return Magnitude(p2 - p1);
|
||||
}
|
||||
|
||||
// ----- TIntPoint3 ------------------------------------------
|
||||
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Rt Phanes::Core::Math::Distance(const TIntPoint3<T>& p1, const TIntPoint3<T>& p2)
|
||||
{
|
||||
return Magnitude(p2 - p1);
|
||||
}
|
||||
@ -1,461 +0,0 @@
|
||||
// ============================== //
|
||||
// TIntVector2 implementation //
|
||||
// ============================== //
|
||||
|
||||
|
||||
#include "PhanesEnginePCH.h"
|
||||
|
||||
#include "Core/public/Math/IntVector2.h"
|
||||
|
||||
#include "Core/public/Math/IntPoint.h"
|
||||
|
||||
//#include "Math/Matrix2.h"
|
||||
//#include "Math/Matrix2.h"
|
||||
//#include "Math/Vector3.h"
|
||||
//#include "Math/Vector4.h"
|
||||
//#include "Math/IntVector2.h"
|
||||
//#include "Math/IntVector3.h"
|
||||
//#include "Math/IntVector4.h"
|
||||
|
||||
|
||||
// ============================ //
|
||||
// TIntVector2 constructors //
|
||||
// ============================ //
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T>::TIntVector2(const T x, const T y)
|
||||
{
|
||||
this->x = x;
|
||||
this->y = y;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T>::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<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T>::TIntVector2(const TIntPoint2<T>& start, const TIntPoint2<T>& end)
|
||||
{
|
||||
this->x = end.x - start.x;
|
||||
this->y = end.y - start.y;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T>::TIntVector2(const TIntVector3<T>& v)
|
||||
{
|
||||
this->x = v.x;
|
||||
this->y = v.y;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T>::TIntVector2(const TIntVector2<T>& v)
|
||||
{
|
||||
memcpy(this->comp, comp, sizeof(T) * 2);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T>::TIntVector2(TIntVector2<T>&& v)
|
||||
{
|
||||
this->comp = v.comp;
|
||||
v.comp = nullptr;
|
||||
}
|
||||
|
||||
|
||||
// ========================= //
|
||||
// TIntVector2 operators //
|
||||
// ========================= //
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::operator+=(TIntVector2<T>& v1, T s)
|
||||
{
|
||||
v1.x += s;
|
||||
v1.y += s;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::operator+=(TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
v1.x += v2.x;
|
||||
v1.y += v2.y;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::operator-=(TIntVector2<T>& v1, T s)
|
||||
{
|
||||
v1.x -= s;
|
||||
v1.y -= s;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::operator-=(TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
v1.x -= v2.x;
|
||||
v1.y -= v2.y;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::operator*=(TIntVector2<T>& v1, T s)
|
||||
{
|
||||
v1.x *= s;
|
||||
v1.y *= s;
|
||||
|
||||
return v1;
|
||||
}
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::operator*(const TIntVector2<T>& v1, T s)
|
||||
{
|
||||
return TIntVector2<T>(v1.x * s, v1.y * s);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
inline Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::operator*(T s, const TIntVector2<T>& v1)
|
||||
{
|
||||
return v1 * s;
|
||||
}
|
||||
|
||||
template<IntType T, IntType Rt>
|
||||
Rt Phanes::Core::Math::operator* (const TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
return v1.x * v2.x + v1.y * v2.y;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::operator+(const TIntVector2<T>& v1, T s)
|
||||
{
|
||||
return TIntVector2<T>(v1.x + s, v1.y + s);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::operator+(const TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
return TIntVector2<T>(v1.x + v2.x, v1.y + v2.y);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::operator-(const TIntVector2<T>& v1, T s)
|
||||
{
|
||||
return TIntVector2<T>(v1.x - s, v1.y - s);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::operator-(const TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
return TIntVector2<T>(v1.x - v2.x, v1.y - v2.y);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
void Phanes::Core::Math::operator-(TIntVector2<T>& v1)
|
||||
{
|
||||
v1.x = -v1.x;
|
||||
v1.y = -v1.y;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
bool Phanes::Core::Math::operator== (const TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
return (abs(v1.x - v1.x) < P_FLT_INAC && abs(v1.y - v1.y) < P_FLT_INAC);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
bool Phanes::Core::Math::operator!=(const TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
return (abs(v1.x - v1.x) > P_FLT_INAC || abs(v1.y - v1.y) > P_FLT_INAC);
|
||||
}
|
||||
|
||||
template<IntType T, IntType Rt>
|
||||
Rt Phanes::Core::Math::Magnitude(const TIntVector2<T>& v1)
|
||||
{
|
||||
return sqrtf(v1.x * v1.x + v1.y * v1.y);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
T Phanes::Core::Math::SqrMagnitude(const TIntVector2<T>& v1)
|
||||
{
|
||||
return v1.x * v1.x + v1.y * v1.y;
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::DivideTruncV(TIntVector2<T>& v1, T s)
|
||||
{
|
||||
Rt _s = (Rt)1.0 / s;
|
||||
|
||||
v1.x = trunc(v1.x * s);
|
||||
v1.y = trunc(v1.y * s);
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Rt Phanes::Core::Math::Angle(const TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
return acos((v1 * v2) / Magnitude(v1) * Magnitude(v2));
|
||||
}
|
||||
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Rt Phanes::Core::Math::CosineAngle(const TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
return (v1 * v2) / Magnitude(v1) * Magnitude(v2);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::SignVectorV(TIntVector2<T>& v1)
|
||||
{
|
||||
v1.x = (v1.x > 0) ? 1 : -1;
|
||||
v1.y = (v1.y > 0) ? 1 : -1;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
T Phanes::Core::Math::DotP(const TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
return v1.x * v2.x + v1.y * v2.y;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::MaxV(TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
v1.x = Phanes::Core::Math::Max(v1.x, v2.x);
|
||||
v1.y = Phanes::Core::Math::Max(v1.y, v2.y);
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::MinV(TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
v1.x = Phanes::Core::Math::Min(v1.x, v2.x);
|
||||
v1.y = Phanes::Core::Math::Min(v1.y, v2.y);
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::GetPerpendicularV(TIntVector2<T>& v1)
|
||||
{
|
||||
T x = v1.x;
|
||||
v1.x = v1.y;
|
||||
v1.y = -v1.x;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::GetReversePerpendicularV(TIntVector2<T>& v1)
|
||||
{
|
||||
T x = v1.x;
|
||||
v1.x = -v1.y;
|
||||
v1.y = v1.x;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::ScaleV(TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
v1.x *= v2.x;
|
||||
v1.y *= v2.y;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::Set(TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
v1 = v2;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::Set(TIntVector2<T>& v1, T x, T y)
|
||||
{
|
||||
v1.x = x;
|
||||
v1.y = y;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::NegateV(TIntVector2<T>& v1)
|
||||
{
|
||||
v1.x = -v1.x;
|
||||
v1.y = -v1.y;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
inline bool Phanes::Core::Math::IsNormalized(const TIntVector2<T>& v1)
|
||||
{
|
||||
return (SqrMagnitude(v1));
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
inline bool Phanes::Core::Math::IsPerpendicular(const TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
return (abs(DotP(v1, v2)) = 0);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
inline bool Phanes::Core::Math::IsParallel(const TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
return (abs(DotP(v1, v2)) = 1);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
inline bool Phanes::Core::Math::IsCoincident(const TIntVector2<T>& v1, const TIntVector2<T>& 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<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector2<Rt> Phanes::Core::Math::Reflect(const TIntVector2<T>& v1, const TVector2<Rt>& normal)
|
||||
{
|
||||
return TVector2<Rt>(v1 - (2 * (v1 * normal) * normal));
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::Scale(const TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
return TIntVector2<T>(v1.x * v2.x, v1.y * v2.y);
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector2<Rt> Phanes::Core::Math::CompInverse(const TIntVector2<T>& v1)
|
||||
{
|
||||
return TVector2<T>(1.0f / v1.x, 1.0f / v1.y);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::Negate(const TIntVector2<T>& v1)
|
||||
{
|
||||
return TIntVector2<T>(-v1.x, -v1.y);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::GetPerpendicular(const TIntVector2<T>& v1)
|
||||
{
|
||||
return TIntVector2<T>(v1.y, -v1.x);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::GetReversePerpendicular(const TIntVector2<T>& v1)
|
||||
{
|
||||
return TIntVector2<T>(-v1.y, v1.x);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::Min(const TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
return TIntVector2<T>(Phanes::Core::Math::Min(v1.x, v2.x), Phanes::Core::Math::Min(v1.y, v2.y));
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::Max(const TIntVector2<T>& v1, const TIntVector2<T>& v2)
|
||||
{
|
||||
return TIntVector2<T>(Phanes::Core::Math::Max(v1.x, v2.x), Phanes::Core::Math::Max(v1.y, v2.y));
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector2<Rt> Phanes::Core::Math::Normalize(const TIntVector2<T>& v1)
|
||||
{
|
||||
float vecNorm = Magnitude(v1);
|
||||
return (vecNorm < P_FLT_INAC) ? PIntZeroVector2(T) : (v1 / vecNorm);
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector2<Rt> Phanes::Core::Math::UnsafeNormalize(const TIntVector2<T>& v1)
|
||||
{
|
||||
return TVector2(v1 / Magnitude(v1));
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::SignVector(const TIntVector2<T>& v1)
|
||||
{
|
||||
return TIntVector2<T>((v1.x > 0) ? 1 : -1, (v1.y > 0) ? 1 : -1);
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector2<Rt> Phanes::Core::Math::BindToSquare(const TIntVector2<T>& v1, T radius)
|
||||
{
|
||||
float k = (abs(v1.x) > abs(v1.y)) ? abs(radius / v1.x) : abs(radius / v1.y);
|
||||
return v1 * k;
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector2<Rt> Phanes::Core::Math::ClampToSquare(const TIntVector2<T>& 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<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector2<Rt> Phanes::Core::Math::Lerp(const TIntVector2<T>& startVec, const TIntVector2<T>& 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<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector2<Rt> Phanes::Core::Math::LerpUnclamped(const TIntVector2<T>& startVec, const TIntVector2<T>& destVec, Rt t)
|
||||
{
|
||||
return ((Rt)t * destVec) + (((Rt)1.0 - t) * startVec);
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector2<Rt> Phanes::Core::Math::Rotate(const TIntVector2<T>& v1, Rt angle)
|
||||
{
|
||||
float sinAngle = sin(angle);
|
||||
float cosAngle = cos(angle);
|
||||
|
||||
return TVector2<Rt>((Rt)v1.x * cosAngle - (Rt)v1.y * sinAngle, (Rt)v1.y * cosAngle + (Rt)v1.x * sinAngle);
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector2<Rt> Phanes::Core::Math::ClockwiseRotate(const TIntVector2<T>& v1, Rt angle)
|
||||
{
|
||||
return Rotate(v1, -angle);
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TIntVector2<T> Phanes::Core::Math::DivideTrunc(const TIntVector2<T>& v1, T s)
|
||||
{
|
||||
Rt _s = (Rt)1.0 / s;
|
||||
return TIntVector2<T>(trunc(v1.x * _s), trunc(v1.y * _s));
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector2<Rt> Phanes::Core::Math::DivideFloat(const TIntVector2<T>& v1, T s)
|
||||
{
|
||||
Rt _s = (Rt)1.0 / s;
|
||||
return TIntVector2<T>((Rt)v1.x * _s, (Rt)v1.y * _s);
|
||||
}
|
||||
@ -1,514 +0,0 @@
|
||||
// ============================== //
|
||||
// TIntVector2 implementation //
|
||||
// ============================== //
|
||||
|
||||
|
||||
#include "PhanesEnginePCH.h"
|
||||
|
||||
#include "Core/public/Math/IntVector3.h"
|
||||
|
||||
#include "Core/public/Math/IntPoint.h"
|
||||
#include "Core/public/Math/Plane.h"
|
||||
|
||||
|
||||
template<IntType T>
|
||||
inline Phanes::Core::Math::TIntVector3<T>::TIntVector3(const T x, const T y, const T z)
|
||||
{
|
||||
this->x = x;
|
||||
this->y = y;
|
||||
this->z = z;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T>::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<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T>::TIntVector3(const TIntVector2<T>& v)
|
||||
{
|
||||
this->x = v.x;
|
||||
this->y = v.y;
|
||||
this->z = (T)0;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T>::TIntVector3(const TIntPoint3<T>& start, const TIntPoint3<T>& end)
|
||||
{
|
||||
this->x = end.x - start.x;
|
||||
this->y = end.y - start.y;
|
||||
this->z = end.z - start.z;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T>::TIntVector3(const TIntVector3<T>& v)
|
||||
{
|
||||
memcpy(this->comp, comp, sizeof(T) * 3);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T>::TIntVector3(TIntVector3<T>&& v)
|
||||
{
|
||||
this->comp = v.comp;
|
||||
v.comp = nullptr;
|
||||
}
|
||||
|
||||
// ========================= //
|
||||
// TIntVector3 operators //
|
||||
// ========================= //
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::operator+=(TIntVector3<T>& v1, T s)
|
||||
{
|
||||
v1.x += s;
|
||||
v1.y += s;
|
||||
v1.z += s;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::operator+=(TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
v1.x += v2.x;
|
||||
v1.y += v2.y;
|
||||
v1.z += v2.z;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::operator-=(TIntVector3<T>& v1, T s)
|
||||
{
|
||||
v1.x -= s;
|
||||
v1.y -= s;
|
||||
v1.z -= s;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::operator-=(TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
v1.x -= v2.x;
|
||||
v1.y -= v2.y;
|
||||
v1.z -= v2.z;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::operator*=(TIntVector3<T>& v1, T s)
|
||||
{
|
||||
v1.x *= s;
|
||||
v1.y *= s;
|
||||
v1.z *= s;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::operator*(const TIntVector3<T>& v1, T s)
|
||||
{
|
||||
return TIntVector3<T>(v1.x * s.v1.y * s, v1.z * s);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::operator*(T s, const TIntVector3<T>& v1)
|
||||
{
|
||||
return v1 * s;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
T Phanes::Core::Math::operator*(const TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::operator+(const TIntVector3<T>& v1, T s)
|
||||
{
|
||||
return TIntVector3<T>(v1.x + s.v1.y + s, v1.z + s);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::operator+(const TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
return TIntVector3<T>(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::operator-(const TIntVector3<T>& v1, T s)
|
||||
{
|
||||
return TIntVector3<T>(v1.x - s.v1.y - s, v1.z - s);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::operator-(const TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
return TIntVector3<T>(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::operator-(TIntVector3<T>& v1)
|
||||
{
|
||||
v1.x = -v1.x;
|
||||
v1.y = -v1.y;
|
||||
v1.z = -v1.z;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
bool Phanes::Core::Math::operator==(const TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T>
|
||||
bool Phanes::Core::Math::operator!=(const TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T, RealType Rt>
|
||||
Rt Phanes::Core::Math::Magnitude(const TIntVector3<T>& v1)
|
||||
{
|
||||
return sqrt(DotP(v1, v1));
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
T Phanes::Core::Math::SqrMagnitude(const TIntVector3<T>& v1)
|
||||
{
|
||||
return DotP(v1, v1);
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Rt Phanes::Core::Math::Angle(const TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
return acos((v1 * v2) / (Magnitude(v1) * Magnitude(v2)));
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
T Phanes::Core::Math::DotP(const TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::VectorTriple(const TIntVector3<T>& v1, const TIntVector3<T>& v2, const TIntVector3<T>& v3)
|
||||
{
|
||||
return CrossP(CrossP(v1, v2), v3);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::SignVector(const TIntVector3<T>& 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<IntType T>
|
||||
bool Phanes::Core::Math::Equals(const TIntVector3<T>& v1, const TIntVector3<T>& v2, T threshold)
|
||||
{
|
||||
return (abs(v1.x - v2.x) < threshold && abs(v1.y - v2.y) < threshold && abs(v1.z - v2.z) < threshold);
|
||||
}
|
||||
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::CrossPV(TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::MaxV(TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::MinV(TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::NegateV(TIntVector3<T>& v1)
|
||||
{
|
||||
v1.x = -v1.x;
|
||||
v1.y = -v1.y;
|
||||
v1.z = -v1.z;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::ScaleV(TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
v1.x *= v2.x;
|
||||
v1.y *= v2.y;
|
||||
v1.z *= v2.z;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::Set(TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
v1 = v2;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::Set(TIntVector3<T>& v1, T x, T y, T z)
|
||||
{
|
||||
v1.x = x;
|
||||
v1.y = y;
|
||||
v1.z = z;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::SignVectorV(TIntVector3<T>& 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<IntType T>
|
||||
T Phanes::Core::Math::ScalarTriple(const TIntVector3<T>& v1, const TIntVector3<T>& v2, const TIntVector3<T>& v3)
|
||||
{
|
||||
return CrossP(v1, v2) * v3;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
T Phanes::Core::Math::CosineAngle(const TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
return (v1 * v2) / (Magnitude(v1) * Magnitude(v2));
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::VectorTripleV(TIntVector3<T>& v1, const TIntVector3<T>& v2, const TIntVector3<T>& v3)
|
||||
{
|
||||
CrossPV(CrossPV(v1, v2), v3);
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
bool Phanes::Core::Math::IsPerpendicular(const TIntVector3<T>& v1, const TIntVector3<T>& v2, T threshold)
|
||||
{
|
||||
return (abs(DotP(v1, v2)) < threshold);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
bool Phanes::Core::Math::IsParallel(const TIntVector3<T>& v1, const TIntVector3<T>& v2, T threshold)
|
||||
{
|
||||
return (abs(DotP(v1, v2)) > threshold);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
bool Phanes::Core::Math::IsCoincident(const TIntVector3<T>& v1, const TIntVector3<T>& v2, T threshold)
|
||||
{
|
||||
return (DotP(v1, v2) > threshold);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
bool Phanes::Core::Math::IsNormalized(const TIntVector3<T>& v1, T threshold)
|
||||
{
|
||||
return (SqrMagnitude(v1) < threshold);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
bool Phanes::Core::Math::IsCoplanar(const TIntVector3<T>& v1, const TIntVector3<T>& v2, const TIntVector3<T>& v3, T threshold)
|
||||
{
|
||||
return (ScalarTriple(v1, v2, v3) < threshold);
|
||||
}
|
||||
|
||||
|
||||
|
||||
// =============== //
|
||||
// With Return //
|
||||
// =============== //
|
||||
|
||||
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::Normalize(const TIntVector3<T>& v1)
|
||||
{
|
||||
float vecNorm = Magnitude(v1);
|
||||
return (vecNorm < P_FLT_INAC) ? PZeroVector3(T) : v1 / vecNorm;
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::UnsafeNormalize(const TIntVector3<T>& v1)
|
||||
{
|
||||
return v1 / Magnitude(v1);
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::Reflect(const TIntVector3<T>& v1, const TVector3<Rt>& normal)
|
||||
{
|
||||
return v1 - (2 * (v1 * normal) * normal);
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::PerspectiveDivide(const TIntVector3<T>& v1)
|
||||
{
|
||||
float _z = (T)1.0 / v1.z;
|
||||
return TIntVector3<T>(v1.x * _z, v1.y * _z, (T)0.0);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::CrossP(const TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
return TIntVector3<T>((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<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::Lerp(const TIntVector3<T>& start, const TIntVector3<T>& dest, Rt t)
|
||||
{
|
||||
t = Clamp(t, (Rt)0.0, (Rt), 1.0);
|
||||
return ((Rt)1.0 - t) * start + t * dest;
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::LerpUnclamped(const TIntVector3<T>& start, const TIntVector3<T>& dest, Rt t)
|
||||
{
|
||||
return (1 - t) * start + t * dest;
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::Max(const TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
return TIntVector3<T>((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<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::Min(const TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
return TIntVector3<T>((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<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::Negate(const TIntVector3<T>& v1)
|
||||
{
|
||||
return TIntVector3<T>(-v1.x, -v1.y, -v1.z);
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
Phanes::Core::Math::TIntVector3<T> Phanes::Core::Math::Scale(const TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
return TIntVector3<T>(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z);
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::ClampMagnitude(const TIntVector3<T>& v1, T min, T max)
|
||||
{
|
||||
Rt magnitude = Magnitude(v1);
|
||||
|
||||
const TVector3<Rt> unitVec = (magnitude > P_FLT_INAC) ? v1 / magnitude : PZeroVector3(T);
|
||||
|
||||
Clamp(magnitude, min, max);
|
||||
|
||||
return unitVec * magnitude;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::ScaleToMagnitude(const TIntVector3<T>& v1, T magnitude)
|
||||
{
|
||||
NormalizeV(v1) *= magnitude;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::CompInverse(const TIntVector3<T>& v1)
|
||||
{
|
||||
return TIntVector3<T>((Rt)1.0 / v1.x, (Rt)1.0 / v1.y, (Rt)1.0 / v1.z);
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::ReflectFromPlane(const TIntVector3<T>& v1, const TPlane<Rt>& plane)
|
||||
{
|
||||
return Reflect(v1, plane.normal);
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::ReflectFromPlane(const TIntVector3<T>& v1, const TVector3<Rt>& normal)
|
||||
{
|
||||
return Reflect(v1, normal);
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::RotateAroundAxis(const TIntVector3<T>& v1, const TVector3<Rt>& 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<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::Project(const TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
return (DotP(v1, v2) / DotP(v2, v2)) * v2;
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::Reject(const TIntVector3<T>& v1, const TIntVector3<T>& v2)
|
||||
{
|
||||
return v1 - (DotP(v1, v2) / DotP(v2, v2)) * v2;
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::ProjectOntoPlane(const TIntVector3<T>& v1, const TVector3<Rt>& normal)
|
||||
{
|
||||
return Reject(v1, normal);
|
||||
}
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Phanes::Core::Math::TVector3<Rt> Phanes::Core::Math::ProjectOntoPlane(const TIntVector3<T>& v1, const TPlane<Rt>& plane)
|
||||
{
|
||||
return Reject(v1, plane.normal);
|
||||
}
|
||||
@ -1,57 +0,0 @@
|
||||
#include "PhanesEnginePCH.h"
|
||||
|
||||
#include "Core/public/Math/MathCommon.h"
|
||||
|
||||
#include "Core/public/OSAL/PlatformTypes.h"
|
||||
|
||||
// NOTE: oneline if statments are much faster than the max / min algorithm or expanded if's (64.519 ms per 1 000 000 operations)
|
||||
|
||||
template<typename T>
|
||||
T Phanes::Core::Math::Clamp(T value, T low, T high)
|
||||
{
|
||||
if (value < low) value = low;
|
||||
if (value > high) value = high;
|
||||
return value;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T Phanes::Core::Math::Max(T x, T y)
|
||||
{
|
||||
return (x > y) ? x : y;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T Phanes::Core::Math::Min(T x, T y)
|
||||
{
|
||||
return (x < y) ? x : y;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void Phanes::Core::Math::Swap(T& x, T& y)
|
||||
{
|
||||
float z = x;
|
||||
x = y;
|
||||
y = z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
bool Phanes::Core::Math::Equals(T x, T y, T threshold)
|
||||
{
|
||||
if (abs(x - y) < threshold) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
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;
|
||||
}
|
||||
@ -1,48 +0,0 @@
|
||||
#include "PhanesEnginePCH.h"
|
||||
#include "Core/public/Math/MathTypeConversion.h"
|
||||
|
||||
// ============ //
|
||||
// ToString //
|
||||
// ============ //
|
||||
|
||||
template<RealType T>
|
||||
std::string Phanes::Core::Math::ToString(const Phanes::Core::Math::TVector2<T>& v) {
|
||||
return "(" + std::to_string(v.x) + ", " + std::to_string(v.y) + ")";
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
std::string Phanes::Core::Math::ToString(const TIntVector2<T>& v)
|
||||
{
|
||||
return "(" + std::to_string(v.x) + ", " + std::to_string(v.y) + ")";
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
std::string Phanes::Core::Math::ToString(const Phanes::Core::Math::TVector3<T>& v) {
|
||||
return "(" + std::to_string(v.x) + ", " + std::to_string(v.y) + ", " + std::to_string(v.z) + ")";
|
||||
}
|
||||
|
||||
template<IntType T>
|
||||
std::string Phanes::Core::Math::ToString(const TIntVector3<T>& v)
|
||||
{
|
||||
std::to_string(3);
|
||||
|
||||
return "(" + std::to_string(v.x) + ", " + std::to_string(v.y) + ", " + std::to_string(v.z) + ")";
|
||||
}
|
||||
|
||||
//template<typename T>
|
||||
//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<typename T>
|
||||
//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<typename T>
|
||||
//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));
|
||||
//}
|
||||
@ -1,40 +0,0 @@
|
||||
#include "PhanesEnginePCH.h"
|
||||
|
||||
#include "Core/public/Math/MathUnitConversion.h"
|
||||
|
||||
|
||||
template<RealType T>
|
||||
inline T Phanes::Core::Math::UnitConversion::DegToRad(T deg)
|
||||
{
|
||||
return deg * P_PI_180_FLT;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
inline T Phanes::Core::Math::UnitConversion::RadToDeg(T rad)
|
||||
{
|
||||
return rad * P_180_PI_FLT;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
inline T Phanes::Core::Math::UnitConversion::DegToGradian(T deg)
|
||||
{
|
||||
return deg * 1.111111f;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
inline T Phanes::Core::Math::UnitConversion::GradianToDeg(T g)
|
||||
{
|
||||
return g * 0.9f;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
inline T Phanes::Core::Math::UnitConversion::RadToGradian(T rad)
|
||||
{
|
||||
return rad * 200 / P_PI_FLT;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
inline T Phanes::Core::Math::UnitConversion::GradianToRad(T g)
|
||||
{
|
||||
return g * P_PI_FLT / 200;
|
||||
}
|
||||
@ -1,237 +0,0 @@
|
||||
// =========================== //
|
||||
// Matrix2D implementation //
|
||||
// =========================== //
|
||||
|
||||
|
||||
#include "Misc/CommonDefines.h"
|
||||
#include PHANES_CORE_PCH_DEFAULT_PATH
|
||||
|
||||
#include "Math/Matrix2.h"
|
||||
|
||||
#pragma warning(disable : 4172)
|
||||
|
||||
// ================================= //
|
||||
// Class Methods for easy access //
|
||||
// ================================= //
|
||||
|
||||
float& phanes::core::math::coretypes::Matrix2::operator()(int n, int m)
|
||||
{
|
||||
return this->fields[m][n];
|
||||
}
|
||||
|
||||
const float& phanes::core::math::coretypes::Matrix2::operator()(int n, int m) const
|
||||
{
|
||||
return this->fields[m][n];
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Vector2& phanes::core::math::coretypes::Matrix2::operator[](int m)
|
||||
{
|
||||
return (*reinterpret_cast<Vector2*>(this->fields[m]));
|
||||
}
|
||||
|
||||
const phanes::core::math::coretypes::Vector2& phanes::core::math::coretypes::Matrix2::operator[](int m) const
|
||||
{
|
||||
return (*reinterpret_cast<const Vector2*>(this->fields[m]));
|
||||
}
|
||||
|
||||
|
||||
// ================= //
|
||||
// Constructors //
|
||||
// ================= //
|
||||
|
||||
phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::createMatrix(float fields[2][2])
|
||||
{
|
||||
Matrix2 a;
|
||||
std::copy(&fields[0][0], &fields[2][2], &a.fields[0][0]);
|
||||
return a;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::createMatrix(float f00, float f01, float f10, float f11)
|
||||
{
|
||||
Matrix2 a;
|
||||
a.fields[0][0] = f00; a.fields[1][0] = f01;
|
||||
a.fields[0][1] = f10; a.fields[1][1] = f11;
|
||||
return a;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::createMatrix(const Vector2& a, const Vector2& b)
|
||||
{
|
||||
Matrix2 m;
|
||||
m.fields[0][0] = a.x; m.fields[1][0] = b.x;
|
||||
m.fields[0][1] = a.y; m.fields[1][1] = b.y;
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
// ============= //
|
||||
// Operators //
|
||||
// ============= //
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::operator+=(Matrix2& a, float s)
|
||||
{
|
||||
a[0] += s;
|
||||
a[1] += s;
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::operator+=(Matrix2& a, const Matrix2& b)
|
||||
{
|
||||
a[0] += b[0];
|
||||
a[1] += b[1];
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::operator-=(Matrix2& a, float s)
|
||||
{
|
||||
a[0] -= s;
|
||||
a[1] -= s;
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::operator-=(Matrix2& a, const Matrix2& b)
|
||||
{
|
||||
a[0] -= b[0];
|
||||
a[1] -= b[1];
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::operator*=(Matrix2& a, float s)
|
||||
{
|
||||
a[0] *= s;
|
||||
a[1] *= s;
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::operator*=(Matrix2& a, const Matrix2& b)
|
||||
{
|
||||
Matrix2 c = a;
|
||||
|
||||
a(0, 0) = c(0, 0) * b(0, 0) + c(0, 1) * b(1, 0);
|
||||
a(0, 1) = c(0, 0) * b(0, 1) + c(0, 1) * b(1, 1);
|
||||
|
||||
a(1, 0) = c(1, 0) * b(0, 0) + c(1, 1) * b(1, 0);
|
||||
a(1, 1) = c(1, 0) * b(0, 1) + c(1, 1) * b(1, 1);
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::operator+(const Matrix2& a, float s)
|
||||
{
|
||||
Matrix2 m;
|
||||
m[0] = a[0] + s;
|
||||
m[1] = a[1] + s;
|
||||
return m;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::operator+(const Matrix2& a, const Matrix2& b)
|
||||
{
|
||||
Matrix2 m;
|
||||
m[0] = a[0] + b[0];
|
||||
m[1] = a[1] + b[1];
|
||||
return m;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::operator-(const Matrix2& a, float s)
|
||||
{
|
||||
Matrix2 m;
|
||||
m[0] = a[0] - s;
|
||||
m[1] = a[1] - s;
|
||||
return m;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::operator-(const Matrix2& a, const Matrix2& b)
|
||||
{
|
||||
Matrix2 m;
|
||||
m[0] = a[0] - b[0];
|
||||
m[1] = a[1] - b[1];
|
||||
return m;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::operator*(const Matrix2& a, float s)
|
||||
{
|
||||
Matrix2 m;
|
||||
m[0] = a[0] * s;
|
||||
m[1] = a[1] * s;
|
||||
return m;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::operator*(const Matrix2& a, const Matrix2& b)
|
||||
{
|
||||
Matrix2 m;
|
||||
|
||||
m(0, 0) = a(0, 0) * b(0, 0) + a(0, 1) * b(1, 0);
|
||||
m(0, 1) = a(0, 0) * b(0, 1) + a(0, 1) * b(1, 1);
|
||||
m(1, 0) = a(1, 0) * b(0, 0) + a(1, 1) * b(1, 0);
|
||||
m(1, 1) = a(1, 0) * b(0, 1) + a(1, 1) * b(1, 1);
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Vector2 phanes::core::math::coretypes::operator*(const Matrix2& a, const Vector2& v)
|
||||
{
|
||||
Vector2 b = createVector(
|
||||
a(0, 0) * v.x + a(0, 1) * v.y,
|
||||
a(1, 0) * v.x + a(1, 1) * v.y
|
||||
);
|
||||
return b;
|
||||
}
|
||||
|
||||
bool phanes::core::math::coretypes::operator==(const Matrix2& a, const Matrix2& b)
|
||||
{
|
||||
if (a[0] == b[0] && a[1] == b[1]) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
float phanes::core::math::coretypes::determinant(const Matrix2& a)
|
||||
{
|
||||
return (a(0, 0) * a(1, 1)) - (a(0, 1) * a(1, 0));
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::inverseNR(Matrix2& a)
|
||||
{
|
||||
float& ref = a(0, 0);
|
||||
float b = ref;
|
||||
float _1_det = 1.0f / determinant(a);
|
||||
|
||||
a(0, 0) = a(1, 1);
|
||||
a(0, 1) = -a(0, 1);
|
||||
a(1, 0) = -a(1, 0);
|
||||
a(1, 1) = b;
|
||||
|
||||
a *= _1_det;
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::transposeNR(Matrix2& a)
|
||||
{
|
||||
swap(a(0, 1), a(1, 0));
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::inverse(Matrix2& a)
|
||||
{
|
||||
Matrix2 m;
|
||||
float _1_det = 1.0f / determinant(a);
|
||||
|
||||
m(0, 0) = a(1, 1);
|
||||
m(0, 1) = -a(0, 1);
|
||||
m(1, 0) = -a(1, 0);
|
||||
m(1, 1) = a(0, 0);
|
||||
|
||||
m *= _1_det;
|
||||
return m;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix2 phanes::core::math::coretypes::transpose(const Matrix2& a)
|
||||
{
|
||||
Matrix2 c;
|
||||
c(0, 0) = a(0, 0);
|
||||
c(1, 0) = a(0, 1);
|
||||
c(0, 1) = a(1, 0);
|
||||
c(1, 1) = a(1, 1);
|
||||
return c;
|
||||
}
|
||||
|
||||
bool phanes::core::math::coretypes::isIndentityMatrix(const Matrix2& a)
|
||||
{
|
||||
|
||||
if (a == phanes::core::math::coretypes::createMatrix(1, 0, 0, 1)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@ -1,303 +0,0 @@
|
||||
// ========================== //
|
||||
// Matrix3 implementation //
|
||||
// ========================== //
|
||||
|
||||
|
||||
|
||||
#include "Misc/CommonDefines.h"
|
||||
#include PHANES_CORE_PCH_DEFAULT_PATH
|
||||
|
||||
#include "Math/Matrix3.h"
|
||||
|
||||
// ================================= //
|
||||
// Class Methods for easy access //
|
||||
// ================================= //
|
||||
|
||||
float& phanes::core::math::coretypes::Matrix3::operator()(int n, int m)
|
||||
{
|
||||
return this->fields[m][n];
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Vector3& phanes::core::math::coretypes::Matrix3::operator[](int m)
|
||||
{
|
||||
return (*reinterpret_cast<Vector3*>(this->fields[m]));
|
||||
}
|
||||
|
||||
const float& phanes::core::math::coretypes::Matrix3::operator()(int n, int m) const
|
||||
{
|
||||
return this->fields[m][n];
|
||||
}
|
||||
|
||||
const phanes::core::math::coretypes::Vector3& phanes::core::math::coretypes::Matrix3::operator[](int m) const
|
||||
{
|
||||
return (*reinterpret_cast<const Vector3*>(this->fields[m]));
|
||||
}
|
||||
|
||||
|
||||
// ================= //
|
||||
// Constructors //
|
||||
// ================= //
|
||||
|
||||
phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::createMatrix(float fields[3][3])
|
||||
{
|
||||
Matrix3 a;
|
||||
std::copy(&fields[0][0], &fields[3][3], &a.fields[0][0]);
|
||||
return a;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::createMatrix(float f00, float f01, float f02, float f10, float f11, float f12, float f20, float f21, float f22)
|
||||
{
|
||||
Matrix3 a;
|
||||
a.fields[0][0] = f00; a.fields[1][0] = f01; a.fields[2][0] = f02;
|
||||
a.fields[0][1] = f10; a.fields[1][1] = f11; a.fields[2][1] = f12;
|
||||
a.fields[0][2] = f20; a.fields[1][2] = f21; a.fields[2][2] = f22;
|
||||
return a;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::createMatrix(const Vector3& a, const Vector3& b, const Vector3& c)
|
||||
{
|
||||
Matrix3 m;
|
||||
m.fields[0][0] = a.x; m.fields[1][0] = b.x; m.fields[2][0] = c.x;
|
||||
m.fields[0][1] = a.y; m.fields[1][1] = b.y; m.fields[2][1] = c.y;
|
||||
m.fields[0][2] = a.z; m.fields[1][2] = b.z; m.fields[2][2] = c.z;
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
// ============= //
|
||||
// Operators //
|
||||
// ============= //
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::operator+=(Matrix3& a, float s)
|
||||
{
|
||||
a[0] += s;
|
||||
a[1] += s;
|
||||
a[2] += s;
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::operator+=(Matrix3& a, const Matrix3& b)
|
||||
{
|
||||
a[0] += b[0];
|
||||
a[1] += b[1];
|
||||
a[2] += b[2];
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::operator-=(Matrix3& a, float s)
|
||||
{
|
||||
a[0] -= s;
|
||||
a[1] -= s;
|
||||
a[2] -= s;
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::operator-=(Matrix3& a, const Matrix3& b)
|
||||
{
|
||||
a[0] -= b[0];
|
||||
a[1] -= b[1];
|
||||
a[2] -= b[2];
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::operator*=(Matrix3& a, float s)
|
||||
{
|
||||
a[0] *= s;
|
||||
a[1] *= s;
|
||||
a[2] *= s;
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::operator*=(Matrix3& a, const Matrix3& b)
|
||||
{
|
||||
Matrix3 c = a;
|
||||
a(0, 0) = c(0, 0) * b(0, 0) + c(0, 1) * b(1, 0) + c(0, 2) * b(2, 0);
|
||||
a(0, 1) = c(0, 0) * b(0, 1) + c(0, 1) * b(1, 1) + c(0, 2) * b(2, 1);
|
||||
a(0, 2) = c(0, 0) * b(0, 2) + c(0, 1) * b(1, 2) + c(0, 2) * b(2, 2);
|
||||
|
||||
a(1, 0) = c(1, 0) * b(0, 0) + c(1, 1) * b(1, 0) + c(1, 2) * b(2, 0);
|
||||
a(1, 1) = c(1, 0) * b(0, 1) + c(1, 1) * b(1, 1) + c(1, 2) * b(2, 1);
|
||||
a(1, 2) = c(1, 0) * b(0, 2) + c(1, 1) * b(1, 2) + c(1, 2) * b(2, 2);
|
||||
|
||||
a(2, 0) = c(2, 0) * b(0, 0) + c(2, 1) * b(1, 0) + c(2, 2) * b(2, 0);
|
||||
a(2, 1) = c(2, 0) * b(0, 1) + c(2, 1) * b(1, 1) + c(2, 2) * b(2, 1);
|
||||
a(2, 2) = c(2, 0) * b(0, 2) + c(2, 1) * b(1, 2) + c(2, 2) * b(2, 2);
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::operator+(const Matrix3& a, float s)
|
||||
{
|
||||
Matrix3 m;
|
||||
m[0] = a[0] + s;
|
||||
m[1] = a[1] + s;
|
||||
m[2] = a[2] + s;
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::operator+(const Matrix3& a, const Matrix3& b)
|
||||
{
|
||||
Matrix3 m;
|
||||
m[0] = a[0] + b[0];
|
||||
m[1] = a[1] + b[1];
|
||||
m[2] = a[2] + b[2];
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::operator-(const Matrix3& a, float s)
|
||||
{
|
||||
Matrix3 m;
|
||||
m[0] = a[0] - s;
|
||||
m[1] = a[1] - s;
|
||||
m[2] = a[2] - s;
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::operator-(const Matrix3& a, const Matrix3& b)
|
||||
{
|
||||
Matrix3 m;
|
||||
m[0] = a[0] - b[0];
|
||||
m[1] = a[1] - b[1];
|
||||
m[2] = a[2] - b[2];
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::operator*(const Matrix3& a, float s)
|
||||
{
|
||||
Matrix3 m;
|
||||
m[0] = a[0] * s;
|
||||
m[1] = a[1] * s;
|
||||
m[2] = a[2] * s;
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::operator*(const Matrix3& a, const Matrix3& b)
|
||||
{
|
||||
Matrix3 m;
|
||||
|
||||
m(0, 0) = a(0, 0) * b(0, 0) + a(0, 1) * b(1, 0) + a(0, 2) * b(2, 0);
|
||||
m(0, 1) = a(0, 0) * b(0, 1) + a(0, 1) * b(1, 1) + a(0, 2) * b(2, 1);
|
||||
m(0, 2) = a(0, 0) * b(0, 2) + a(0, 1) * b(1, 2) + a(0, 2) * b(2, 2);
|
||||
|
||||
m(1, 0) = a(1, 0) * b(0, 0) + a(1, 1) * b(1, 0) + a(1, 2) * b(2, 0);
|
||||
m(1, 1) = a(1, 0) * b(0, 1) + a(1, 1) * b(1, 1) + a(1, 2) * b(2, 1);
|
||||
m(1, 2) = a(1, 0) * b(0, 2) + a(1, 1) * b(1, 2) + a(1, 2) * b(2, 2);
|
||||
|
||||
m(2, 0) = a(2, 0) * b(0, 0) + a(2, 1) * b(1, 0) + a(2, 2) * b(2, 0);
|
||||
m(2, 1) = a(2, 0) * b(0, 1) + a(2, 1) * b(1, 1) + a(2, 2) * b(2, 1);
|
||||
m(2, 2) = a(2, 0) * b(0, 2) + a(2, 1) * b(1, 2) + a(2, 2) * b(2, 2);
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Vector3 phanes::core::math::coretypes::operator*(const Matrix3& a, const Vector3& v)
|
||||
{
|
||||
Vector3 b = createVector(
|
||||
a(0, 0) * v.x + a(0, 1) * v.y + a(0, 2) * v.z,
|
||||
a(1, 0) * v.x + a(1, 1) * v.y + a(1, 2) * v.z,
|
||||
a(2, 0) * v.x + a(2, 1) * v.y + a(2, 2) * v.z
|
||||
);
|
||||
return b;
|
||||
}
|
||||
|
||||
|
||||
bool phanes::core::math::coretypes::operator==(const Matrix3& a, const Matrix3& b)
|
||||
{
|
||||
if (a[0] == b[0] && a[1] == b[1] && a[2] == b[2]) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
// =============================== //
|
||||
// Matrix function definition //
|
||||
// =============================== //
|
||||
|
||||
|
||||
float phanes::core::math::coretypes::determinant(const Matrix3& a)
|
||||
{
|
||||
return (a(0, 0) * (a(1, 1) * a(2, 2) - a(1, 2) * a(2, 1))
|
||||
-a(0, 1) * (a(1, 0) * a(2, 2) - a(1, 2) * a(2, 0))
|
||||
+a(0, 2) * (a(1, 0) * a(2, 1) - a(1, 1) * a(2, 0)));
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::inverseNR(Matrix3& a)
|
||||
{
|
||||
const Vector3& v0 = a[0];
|
||||
const Vector3& v1 = a[1];
|
||||
const Vector3& v2 = a[2];
|
||||
|
||||
Vector3 r0 = crossP(v1, v2);
|
||||
Vector3 r1 = crossP(v2, v0);
|
||||
Vector3 r2 = crossP(v0, v1);
|
||||
|
||||
float _1_det = 1.0f / determinant(a);
|
||||
|
||||
a = createMatrix(
|
||||
r0.x, r0.y, r0.z,
|
||||
r1.x, r1.y, r1.z,
|
||||
r2.x, r2.y, r2.z
|
||||
);
|
||||
|
||||
a *= _1_det;
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::transposeNR(Matrix3& a)
|
||||
{
|
||||
swap(a(0, 1), a(1, 0));
|
||||
swap(a(0, 2), a(2, 0));
|
||||
swap(a(1, 2), a(2, 1));
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::inverse(Matrix3& a)
|
||||
{
|
||||
const Vector3& v0 = a[0];
|
||||
const Vector3& v1 = a[1];
|
||||
const Vector3& v2 = a[2];
|
||||
|
||||
Vector3 r0 = crossP(v1, v2);
|
||||
Vector3 r1 = crossP(v2, v0);
|
||||
Vector3 r2 = crossP(v0, v1);
|
||||
|
||||
float _1_det = 1.0f / determinant(a);
|
||||
|
||||
Matrix3 m = createMatrix(
|
||||
r0.x, r0.y, r0.z,
|
||||
r1.x, r1.y, r1.z,
|
||||
r2.x, r2.y, r2.z
|
||||
);
|
||||
|
||||
m *= _1_det;
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Matrix3 phanes::core::math::coretypes::transpose(const Matrix3& a)
|
||||
{
|
||||
Matrix3 m = createMatrix(
|
||||
a(0, 0), a(1, 0), a(2, 0),
|
||||
a(0, 1), a(1, 1), a(2, 1),
|
||||
a(0, 2), a(1, 2), a(2, 2)
|
||||
);
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
bool phanes::core::math::coretypes::isIndentityMatrix(const Matrix3& a)
|
||||
{
|
||||
if (a == phanes::core::math::coretypes::createMatrix(1, 0, 0, 0, 1, 0, 0, 0, 1)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@ -1,347 +0,0 @@
|
||||
// ========================== //
|
||||
// Matrix4 implementation //
|
||||
// ========================== //
|
||||
|
||||
#include "Misc/CommonDefines.h"
|
||||
#include PHANES_CORE_PCH_DEFAULT_PATH
|
||||
|
||||
#include "Math/Matrix4.h"
|
||||
|
||||
#include "Math/Vector3.h"
|
||||
|
||||
|
||||
// ================================= //
|
||||
// Class Methods for easy access //
|
||||
// ================================= //
|
||||
|
||||
float& phanes::core::math::coretypes::Matrix4::operator()(int n, int m)
|
||||
{
|
||||
return this->fields[m][n];
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Vector4& phanes::core::math::coretypes::Matrix4::operator[](int m)
|
||||
{
|
||||
return (*reinterpret_cast<Vector4*>(this->fields[m]));
|
||||
}
|
||||
|
||||
const float& phanes::core::math::coretypes::Matrix4::operator()(int n, int m) const
|
||||
{
|
||||
return this->fields[m][n];
|
||||
}
|
||||
|
||||
const phanes::core::math::coretypes::Vector4& phanes::core::math::coretypes::Matrix4::operator[](int m) const
|
||||
{
|
||||
return (*reinterpret_cast<const Vector4*>(this->fields[m]));
|
||||
}
|
||||
|
||||
|
||||
// ================= //
|
||||
// Constructors //
|
||||
// ================= //
|
||||
|
||||
phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::createMatrix(float fields[4][4])
|
||||
{
|
||||
Matrix4 a;
|
||||
std::copy(&fields[0][0], &fields[4][4], &a.fields[0][0]);
|
||||
return a;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::createMatrix(float f00, float f01, float f02, float f03, float f10, float f11, float f12, float f13, float f20, float f21, float f22, float f23, float f30, float f31, float f32, float f33)
|
||||
{
|
||||
Matrix4 a;
|
||||
a.fields[0][0] = f00; a.fields[1][0] = f01; a.fields[2][0] = f02; a.fields[3][0] = f03;
|
||||
a.fields[0][1] = f10; a.fields[1][1] = f11; a.fields[2][1] = f12; a.fields[3][1] = f13;
|
||||
a.fields[0][2] = f20; a.fields[1][2] = f21; a.fields[2][2] = f22; a.fields[3][2] = f23;
|
||||
a.fields[0][3] = f30; a.fields[1][3] = f31; a.fields[2][3] = f32; a.fields[3][3] = f33;
|
||||
return a;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::createMatrix(const Vector4& a, const Vector4& b, const Vector4& c, const Vector4& d)
|
||||
{
|
||||
Matrix4 m;
|
||||
m.fields[0][0] = a.x; m.fields[1][0] = b.x; m.fields[2][0] = c.x; m.fields[3][0] = d.x;
|
||||
m.fields[0][1] = a.y; m.fields[1][1] = b.y; m.fields[2][1] = c.y; m.fields[3][1] = d.y;
|
||||
m.fields[0][2] = a.z; m.fields[1][2] = b.z; m.fields[2][2] = c.z; m.fields[3][2] = d.z;
|
||||
m.fields[0][3] = a.w; m.fields[1][3] = b.w; m.fields[2][3] = c.w; m.fields[3][3] = d.w;
|
||||
return m;
|
||||
}
|
||||
|
||||
|
||||
// ============= //
|
||||
// Operators //
|
||||
// ============= //
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::operator+=(Matrix4& a, float s)
|
||||
{
|
||||
a[0] += s;
|
||||
a[1] += s;
|
||||
a[2] += s;
|
||||
a[3] += s;
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::operator+=(Matrix4& a, const Matrix4& b)
|
||||
{
|
||||
a[0] += b[0];
|
||||
a[1] += b[1];
|
||||
a[2] += b[2];
|
||||
a[3] += b[3];
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::operator-=(Matrix4& a, float s)
|
||||
{
|
||||
a[0] -= s;
|
||||
a[1] -= s;
|
||||
a[2] -= s;
|
||||
a[3] -= s;
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::operator-=(Matrix4& a, const Matrix4& b)
|
||||
{
|
||||
a[0] -= b[0];
|
||||
a[1] -= b[1];
|
||||
a[2] -= b[2];
|
||||
a[3] -= b[3];
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::operator*=(Matrix4& a, float s)
|
||||
{
|
||||
a[0] *= s;
|
||||
a[1] *= s;
|
||||
a[2] *= s;
|
||||
a[3] *= s;
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::operator*=(Matrix4& a, const Matrix4& b)
|
||||
{
|
||||
Matrix4 c = a;
|
||||
|
||||
a(0, 0) = c(0, 0) * b(0, 0) + c(0, 1) * b(1, 0) + c(0, 2) * b(2, 0) + c(0, 3) * b(3, 0);
|
||||
a(0, 1) = c(0, 0) * b(0, 1) + c(0, 1) * b(1, 1) + c(0, 2) * b(2, 1) + c(0, 3) * b(3, 1);
|
||||
a(0, 2) = c(0, 0) * b(0, 2) + c(0, 1) * b(1, 2) + c(0, 2) * b(2, 2) + c(0, 3) * b(3, 2);
|
||||
a(0, 3) = c(0, 0) * b(0, 3) + c(0, 1) * b(1, 3) + c(0, 2) * b(2, 3) + c(0, 3) * b(3, 3);
|
||||
|
||||
a(1, 0) = c(1, 0) * b(0, 0) + c(1, 1) * b(1, 0) + c(1, 2) * b(2, 0) + c(1, 3) * b(3, 0);
|
||||
a(1, 1) = c(1, 0) * b(0, 1) + c(1, 1) * b(1, 1) + c(1, 2) * b(2, 1) + c(1, 3) * b(3, 1);
|
||||
a(1, 2) = c(1, 0) * b(0, 2) + c(1, 1) * b(1, 2) + c(1, 2) * b(2, 2) + c(1, 3) * b(3, 2);
|
||||
a(1, 3) = c(1, 0) * b(0, 3) + c(1, 1) * b(1, 3) + c(1, 2) * b(2, 3) + c(1, 3) * b(3, 3);
|
||||
|
||||
a(2, 0) = c(2, 0) * b(0, 0) + c(2, 1) * b(1, 0) + c(2, 2) * b(2, 0) + c(2, 3) * b(3, 0);
|
||||
a(2, 1) = c(2, 0) * b(0, 1) + c(2, 1) * b(1, 1) + c(2, 2) * b(2, 1) + c(2, 3) * b(3, 1);
|
||||
a(2, 2) = c(2, 0) * b(0, 2) + c(2, 1) * b(1, 2) + c(2, 2) * b(2, 2) + c(2, 3) * b(3, 2);
|
||||
a(2, 3) = c(2, 0) * b(0, 3) + c(2, 1) * b(1, 3) + c(2, 2) * b(2, 3) + c(2, 3) * b(3, 3);
|
||||
|
||||
a(3, 0) = c(3, 0) * b(0, 0) + c(3, 1) * b(1, 0) + c(3, 2) * b(2, 0) + c(3, 3) * b(3, 0);
|
||||
a(3, 1) = c(3, 0) * b(0, 1) + c(3, 1) * b(1, 1) + c(3, 2) * b(2, 1) + c(3, 3) * b(3, 1);
|
||||
a(3, 2) = c(3, 0) * b(0, 2) + c(3, 1) * b(1, 2) + c(3, 2) * b(2, 2) + c(3, 3) * b(3, 2);
|
||||
a(3, 3) = c(3, 0) * b(0, 3) + c(3, 1) * b(1, 3) + c(3, 2) * b(2, 3) + c(3, 3) * b(3, 3);
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::operator+(const Matrix4& a, float s)
|
||||
{
|
||||
Matrix4 m;
|
||||
m[0] = a[0] + s;
|
||||
m[1] = a[1] + s;
|
||||
m[2] = a[2] + s;
|
||||
m[3] = a[3] + s;
|
||||
return m;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::operator+(const Matrix4& a, const Matrix4& b)
|
||||
{
|
||||
Matrix4 m;
|
||||
m[0] = a[0] + b[0];
|
||||
m[1] = a[1] + b[1];
|
||||
m[2] = a[2] + b[2];
|
||||
m[3] = a[3] + b[3];
|
||||
return m;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::operator-(const Matrix4& a, float s)
|
||||
{
|
||||
Matrix4 m;
|
||||
m[0] = a[0] - s;
|
||||
m[1] = a[1] - s;
|
||||
m[2] = a[2] - s;
|
||||
m[3] = a[3] - s;
|
||||
return m;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::operator-(const Matrix4& a, const Matrix4& b)
|
||||
{
|
||||
Matrix4 m;
|
||||
m[0] = a[0] - b[0];
|
||||
m[1] = a[1] - b[1];
|
||||
m[2] = a[2] - b[2];
|
||||
m[3] = a[3] - b[3];
|
||||
return m;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::operator*(const Matrix4& a, float s)
|
||||
{
|
||||
Matrix4 m;
|
||||
m[0] = a[0] * s;
|
||||
m[1] = a[1] * s;
|
||||
m[2] = a[2] * s;
|
||||
m[3] = a[3] * s;
|
||||
return m;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::operator*(const Matrix4& a, const Matrix4& b)
|
||||
{
|
||||
Matrix4 m;
|
||||
|
||||
m(0, 0) = a(0, 0) * b(0, 0) + a(0, 1) * b(1, 0) + a(0, 2) * b(2, 0) + a(0, 3) * b(3, 0);
|
||||
m(0, 1) = a(0, 0) * b(0, 1) + a(0, 1) * b(1, 1) + a(0, 2) * b(2, 1) + a(0, 3) * b(3, 1);
|
||||
m(0, 2) = a(0, 0) * b(0, 2) + a(0, 1) * b(1, 2) + a(0, 2) * b(2, 2) + a(0, 3) * b(3, 2);
|
||||
m(0, 3) = a(0, 0) * b(0, 3) + a(0, 1) * b(1, 3) + a(0, 2) * b(2, 3) + a(0, 3) * b(3, 3);
|
||||
|
||||
m(1, 0) = a(1, 0) * b(0, 0) + a(1, 1) * b(1, 0) + a(1, 2) * b(2, 0) + a(1, 3) * b(3, 0);
|
||||
m(1, 1) = a(1, 0) * b(0, 1) + a(1, 1) * b(1, 1) + a(1, 2) * b(2, 1) + a(1, 3) * b(3, 1);
|
||||
m(1, 2) = a(1, 0) * b(0, 2) + a(1, 1) * b(1, 2) + a(1, 2) * b(2, 2) + a(1, 3) * b(3, 2);
|
||||
m(1, 3) = a(1, 0) * b(0, 3) + a(1, 1) * b(1, 3) + a(1, 2) * b(2, 3) + a(1, 3) * b(3, 3);
|
||||
|
||||
m(2, 0) = a(2, 0) * b(0, 0) + a(2, 1) * b(1, 0) + a(2, 2) * b(2, 0) + a(2, 3) * b(3, 0);
|
||||
m(2, 1) = a(2, 0) * b(0, 1) + a(2, 1) * b(1, 1) + a(2, 2) * b(2, 1) + a(2, 3) * b(3, 1);
|
||||
m(2, 2) = a(2, 0) * b(0, 2) + a(2, 1) * b(1, 2) + a(2, 2) * b(2, 2) + a(2, 3) * b(3, 2);
|
||||
m(2, 3) = a(2, 0) * b(0, 3) + a(2, 1) * b(1, 3) + a(2, 2) * b(2, 3) + a(2, 3) * b(3, 3);
|
||||
|
||||
m(3, 0) = a(3, 0) * b(0, 0) + a(3, 1) * b(1, 0) + a(3, 2) * b(2, 0) + a(3, 3) * b(3, 0);
|
||||
m(3, 1) = a(3, 0) * b(0, 1) + a(3, 1) * b(1, 1) + a(3, 2) * b(2, 1) + a(3, 3) * b(3, 1);
|
||||
m(3, 2) = a(3, 0) * b(0, 2) + a(3, 1) * b(1, 2) + a(3, 2) * b(2, 2) + a(3, 3) * b(3, 2);
|
||||
m(3, 3) = a(3, 0) * b(0, 3) + a(3, 1) * b(1, 3) + a(3, 2) * b(2, 3) + a(3, 3) * b(3, 3);
|
||||
return m;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator*(const Matrix4& a, const Vector4& v)
|
||||
{
|
||||
Vector4 b = createVector(
|
||||
a(0, 0) * v.x + a(0, 1) * v.y + a(0, 2) * v.z + a(0, 3) * v.w,
|
||||
a(1, 0) * v.x + a(1, 1) * v.y + a(1, 2) * v.z + a(1, 3) * v.w,
|
||||
a(2, 0) * v.x + a(2, 1) * v.y + a(2, 2) * v.z + a(2, 3) * v.w,
|
||||
a(3, 0) * v.x + a(3, 1) * v.y + a(3, 2) * v.z + a(3, 3) * v.w
|
||||
);
|
||||
return b;
|
||||
}
|
||||
|
||||
bool phanes::core::math::coretypes::operator==(const Matrix4& a, const Matrix4& b)
|
||||
{
|
||||
if (a[0] == b[0] && a[1] == b[1] && a[2] == b[2] && a[3] == b[3]) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// =============================== //
|
||||
// Matrix function definition //
|
||||
// =============================== //
|
||||
|
||||
|
||||
float phanes::core::math::coretypes::determinant(const Matrix4& a)
|
||||
{
|
||||
Vector3 v0 = reinterpret_cast<const Vector3&>(a[0]);
|
||||
Vector3 v1 = reinterpret_cast<const Vector3&>(a[1]);
|
||||
Vector3 v2 = reinterpret_cast<const Vector3&>(a[2]);
|
||||
Vector3 v3 = reinterpret_cast<const Vector3&>(a[3]);
|
||||
|
||||
Vector3 s = crossP(v0, v1);
|
||||
Vector3 t = crossP(v2, v3);
|
||||
Vector3 u = a(3, 1) * v0 + a(3, 0) * v1;
|
||||
Vector3 v = a(3, 3) * v2 + a(3, 2) * v3;
|
||||
|
||||
return s * v + t * u;
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::inverseNR(Matrix4& a)
|
||||
{
|
||||
Vector3 v0 = reinterpret_cast<const Vector3&>(a[0]);
|
||||
Vector3 v1 = reinterpret_cast<const Vector3&>(a[1]);
|
||||
Vector3 v2 = reinterpret_cast<const Vector3&>(a[2]);
|
||||
Vector3 v3 = reinterpret_cast<const Vector3&>(a[3]);
|
||||
|
||||
Vector3 s = crossP(v0, v1);
|
||||
Vector3 t = crossP(v2, v3);
|
||||
Vector3 u = a(3, 1) * v0 + a(3, 0) * v1;
|
||||
Vector3 v = a(3, 3) * v2 + a(3, 2) * v3;
|
||||
|
||||
float _1_det = 1.0f / determinant(a);
|
||||
|
||||
Vector3 r0 = crossP(v1, v) + t * a(3, 1);
|
||||
Vector3 r1 = crossP(v, v0) - t * a(3, 0);
|
||||
Vector3 r2 = crossP(v3, u) + s * a(3, 3);
|
||||
Vector3 r3 = crossP(u, v2) - s * a(3, 2);
|
||||
|
||||
a = createMatrix(
|
||||
r0.x, r0.y, r0.z, -dotP(v1, t),
|
||||
r1.x, r1.y, r1.z, -dotP(v0, t),
|
||||
r2.x, r2.y, r2.z, -dotP(v3, s),
|
||||
r3.x, r3.y, r3.z, -dotP(v2, s)
|
||||
);
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::transposeNR(Matrix4& a)
|
||||
{
|
||||
swap(a(0, 1), a(1, 0));
|
||||
swap(a(0, 2), a(2, 0));
|
||||
swap(a(0, 3), a(3, 0));
|
||||
|
||||
swap(a(1, 2), a(2, 1));
|
||||
swap(a(1, 3), a(3, 1));
|
||||
|
||||
swap(a(2, 3), a(3, 2));
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::inverse(Matrix4& a)
|
||||
{
|
||||
Vector3 v0 = reinterpret_cast<const Vector3&>(a[0]);
|
||||
Vector3 v1 = reinterpret_cast<const Vector3&>(a[1]);
|
||||
Vector3 v2 = reinterpret_cast<const Vector3&>(a[2]);
|
||||
Vector3 v3 = reinterpret_cast<const Vector3&>(a[3]);
|
||||
|
||||
Vector3 s = crossP(v0, v1);
|
||||
Vector3 t = crossP(v2, v3);
|
||||
Vector3 u = a(3, 1) * v0 + a(3, 0) * v1;
|
||||
Vector3 v = a(3, 3) * v2 + a(3, 2) * v3;
|
||||
|
||||
float _1_det = 1.0f / determinant(a);
|
||||
|
||||
Vector3 r0 = crossP(v1, v) + t * a(3, 1);
|
||||
Vector3 r1 = crossP(v, v0) - t * a(3, 0);
|
||||
Vector3 r2 = crossP(v3, u) + s * a(3, 3);
|
||||
Vector3 r3 = crossP(u, v2) - s * a(3, 2);
|
||||
|
||||
Matrix4 m = createMatrix(
|
||||
r0.x, r0.y, r0.z, -dotP(v1, t),
|
||||
r1.x, r1.y, r1.z, -dotP(v0, t),
|
||||
r2.x, r2.y, r2.z, -dotP(v3, s),
|
||||
r3.x, r3.y, r3.z, -dotP(v2, s)
|
||||
);
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Matrix4 phanes::core::math::coretypes::transpose(const Matrix4& a)
|
||||
{
|
||||
Matrix4 m = a;
|
||||
|
||||
swap(m(0, 1), m(1, 0));
|
||||
swap(m(0, 2), m(2, 0));
|
||||
swap(m(0, 3), m(3, 0));
|
||||
|
||||
swap(m(1, 2), m(2, 1));
|
||||
swap(m(1, 3), m(3, 1));
|
||||
|
||||
swap(m(2, 3), m(3, 2));
|
||||
|
||||
return m;
|
||||
}
|
||||
|
||||
bool phanes::core::math::coretypes::isIndentityMatrix(const Matrix4& a)
|
||||
{
|
||||
if (a == phanes::core::math::coretypes::createMatrix(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -1,34 +0,0 @@
|
||||
#include "PhanesEnginePCH.h"
|
||||
|
||||
#include "Core/public/Math/Point.h"
|
||||
|
||||
#include "Core/public/Math/Vector2.h"
|
||||
#include "Core/public/Math/Vector3.h"
|
||||
// #include "Core/public/Math/Vector4.h"
|
||||
|
||||
|
||||
// ----- TPoint2 ------------------------------------------
|
||||
|
||||
template<RealType T>
|
||||
T Phanes::Core::Math::Distance(const TPoint2<T>& p1, const TPoint2<T>& p2)
|
||||
{
|
||||
return Magnitude(p2 - p1);
|
||||
}
|
||||
|
||||
|
||||
// ----- TPoint3 ------------------------------------------
|
||||
|
||||
template<RealType T>
|
||||
T Phanes::Core::Math::Distance(const TPoint3<T>& p1, const TPoint3<T>& p2)
|
||||
{
|
||||
return Magnitude(p2 - p1);
|
||||
}
|
||||
|
||||
|
||||
// ----- TPoint4 ------------------------------------------
|
||||
|
||||
//template<RealType T>
|
||||
//T Phanes::Core::Math::Distance(const TPoint4<T>& p1, const TPoint4<T>& p2)
|
||||
//{
|
||||
// return Magnitude(TVector3<T>(p1, p2));
|
||||
//}
|
||||
@ -1,570 +0,0 @@
|
||||
// =========================== //
|
||||
// TVector2 implementation //
|
||||
// =========================== //
|
||||
|
||||
|
||||
#include "PhanesEnginePCH.h"
|
||||
|
||||
#include "Core/public/Math/Vector2.h"
|
||||
|
||||
#include "Core/public/Math/Point.h"
|
||||
|
||||
//#include "Math/Matrix2.h"
|
||||
//#include "Math/Matrix2.h"
|
||||
//#include "Math/Vector3.h"
|
||||
//#include "Math/Vector4.h"
|
||||
//#include "Math/IntVector2.h"
|
||||
//#include "Math/IntVector3.h"
|
||||
//#include "Math/IntVector4.h"
|
||||
|
||||
|
||||
// ========================= //
|
||||
// TVector2 constructors //
|
||||
// ========================= //
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T>::TVector2(const Real x, const Real y)
|
||||
{
|
||||
this->x = x;
|
||||
this->y = y;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T>::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<RealType T>
|
||||
Phanes::Core::Math::TVector2<T>::TVector2(const TPoint2<Real>& start, const TPoint2<Real>& end)
|
||||
{
|
||||
this->x = end.x - start.x;
|
||||
this->y = end.y - start.y;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T>::TVector2(const TVector3<Real>& v)
|
||||
{
|
||||
this->x = v.x;
|
||||
this->y = v.y;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T>::TVector2(const TVector2<Real>& v)
|
||||
{
|
||||
memcpy(this->comp, comp, sizeof(T) * 2);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T>::TVector2(TVector2<Real>&& 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<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::operator+=(TVector2<T>& v1, T s)
|
||||
{
|
||||
v1.x += s;
|
||||
v1.y += s;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::operator+=(TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
v1.x += v2.x;
|
||||
v1.y += v2.y;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::operator-=(TVector2<T>& v1, T s)
|
||||
{
|
||||
v1.x -= s;
|
||||
v1.y -= s;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::operator-=(TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
v1.x -= v2.x;
|
||||
v1.y -= v2.y;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::operator*=(TVector2<T>& v1, T s)
|
||||
{
|
||||
v1.x *= s;
|
||||
v1.y *= s;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::operator/=(TVector2<T>& v1, T s)
|
||||
{
|
||||
s = 1.0f / s;
|
||||
v1.x *= s;
|
||||
v1.y *= s;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::operator*(const TVector2<T>& v1, T s)
|
||||
{
|
||||
return TVector2<T>(v1.x * s, v1.y * s);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::operator/(const TVector2<T>& v1, T s)
|
||||
{
|
||||
s = 1.0f / s;
|
||||
return TVector2<T>(v1.x * s, v1.y * s);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
inline Phanes::Core::Math::TVector2<T> Phanes::Core::Math::operator*(T s, const TVector2<T>& v1)
|
||||
{
|
||||
return v1 * s;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
inline Phanes::Core::Math::TVector2<T> Phanes::Core::Math::operator/(T s, const TVector2<T>& v1)
|
||||
{
|
||||
s = 1.0f / s;
|
||||
return v1 * s;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
T Phanes::Core::Math::operator* (const TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
return v1.x * v2.x + v1.y * v2.y;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::operator+(const TVector2<T>& v1, T s)
|
||||
{
|
||||
return TVector2<T>(v1.x + s, v1.y + s);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::operator+(const TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
return TVector2<T>(v1.x + v2.x, v1.y + v2.y);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::operator-(const TVector2<T>& v1, T s)
|
||||
{
|
||||
return TVector2<T>(v1.x - s, v1.y - s);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::operator-(const TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
return TVector2<T>(v1.x - v2.x, v1.y - v2.y);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
void Phanes::Core::Math::operator-(TVector2<T>& v1)
|
||||
{
|
||||
v1.x = -v1.x;
|
||||
v1.y = -v1.y;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
bool Phanes::Core::Math::operator== (const TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
return (abs(v1.x - v1.x) < P_FLT_INAC && abs(v1.y - v1.y) < P_FLT_INAC);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
bool Phanes::Core::Math::operator!=(const TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
return (abs(v1.x - v1.x) > P_FLT_INAC || abs(v1.y - v1.y) > P_FLT_INAC);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
T Phanes::Core::Math::Magnitude(const TVector2<T>& v1)
|
||||
{
|
||||
return sqrtf(v1.x * v1.x + v1.y * v1.y);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
T Phanes::Core::Math::SqrMagnitude(const TVector2<T>& v1)
|
||||
{
|
||||
return v1.x * v1.x + v1.y * v1.y;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::NormalizeV(TVector2<T>& v1)
|
||||
{
|
||||
float vecNorm = Magnitude(v1);
|
||||
v1 /= (vecNorm < P_FLT_INAC) ? 1 : vecNorm;
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::UnsafeNormalizeV(TVector2<T>& v1)
|
||||
{
|
||||
v1 /= Magnitude(v1);
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
T Phanes::Core::Math::Angle(const TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
return acos((v1 * v2) / Magnitude(v1) * Magnitude(v2));
|
||||
}
|
||||
|
||||
|
||||
template<RealType T>
|
||||
T Phanes::Core::Math::CosineAngle(const TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
return (v1 * v2) / Magnitude(v1) * Magnitude(v2);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::SignVectorV(TVector2<T>& v1)
|
||||
{
|
||||
v1.x = (v1.x > 0) ? 1 : -1;
|
||||
v1.y = (v1.y > 0) ? 1 : -1;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::BindToSquareV(TVector2<T>& v1, T radius)
|
||||
{
|
||||
float k = (abs(v1.x) > abs(v1.y)) ? abs(radius / v1.x) : abs(radius / v1.y);
|
||||
v1 *= k;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::ClampToSquareV(TVector2<T>& 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<RealType T>
|
||||
T Phanes::Core::Math::DotP(const TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
return v1.x * v2.x + v1.y * v2.y;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::MaxV(TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
v1.x = Phanes::Core::Math::Max(v1.x, v2.x);
|
||||
v1.y = Phanes::Core::Math::Max(v1.y, v2.y);
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::MinV(TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
v1.x = Phanes::Core::Math::Min(v1.x, v2.x);
|
||||
v1.y = Phanes::Core::Math::Min(v1.y, v2.y);
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::GetPerpendicularV(TVector2<T>& v1)
|
||||
{
|
||||
T x = v1.x;
|
||||
v1.x = v1.y;
|
||||
v1.y = -v1.x;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::GetReversePerpendicularV(TVector2<T>& v1)
|
||||
{
|
||||
T x = v1.x;
|
||||
v1.x = -v1.y;
|
||||
v1.y = v1.x;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::ScaleV(TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
v1.x *= v2.x;
|
||||
v1.y *= v2.y;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::CompInverseV(TVector2<T>& v1)
|
||||
{
|
||||
v1.x = 1.0f / v1.x;
|
||||
v1.y = 1.0f / v1.y;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::ReflectV(TVector2<T>& v1, const TVector2<T>& normal)
|
||||
{
|
||||
Set(v1, v1 - (2 * (v1 * normal) * normal));
|
||||
|
||||
return v1;
|
||||
}
|
||||
template<RealType T>
|
||||
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::Set(TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
v1 = v2;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::Set(TVector2<T>& v1, T x, T y)
|
||||
{
|
||||
v1.x = x;
|
||||
v1.y = y;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::RotateV(TVector2<T>& 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<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::ClockwiseRotateV(TVector2<T>& v1, T angle)
|
||||
{
|
||||
RotateV(v1, -angle);
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::NegateV(TVector2<T>& v1)
|
||||
{
|
||||
v1.x = -v1.x;
|
||||
v1.y = -v1.y;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
inline bool Phanes::Core::Math::IsNormalized(const TVector2<T>& v1, T threshold)
|
||||
{
|
||||
return (SqrMagnitude(v1) < threshold);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
inline bool Phanes::Core::Math::IsPerpendicular(const TVector2<T>& v1, const TVector2<T>& v2, T threshold)
|
||||
{
|
||||
return (abs(DotP(v1, v2)) < threshold);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
inline bool Phanes::Core::Math::IsParallel(const TVector2<T>& v1, const TVector2<T>& v2, T threshold)
|
||||
{
|
||||
return (abs(DotP(v1,v2)) > threshold);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
inline bool Phanes::Core::Math::IsCoincident(const TVector2<T>& v1, const TVector2<T>& 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<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::Reflect(const TVector2<T>& v1, const TVector2<T>& normal)
|
||||
{
|
||||
return TVector2<T>(v1 - (2 * (v1 * normal) * normal));
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::Scale(const TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
return TVector2<T>(v1.x * v2.x, v1.y * v2.y);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::CompInverse(const TVector2<T>& v1)
|
||||
{
|
||||
return TVector2<T>(1.0f / v1.x, 1.0f / v1.y);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::Negate(const TVector2<T>& v1)
|
||||
{
|
||||
return TVector2<T>(-v1.x, -v1.y);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::GetPerpendicular(const TVector2<T>& v1)
|
||||
{
|
||||
return TVector2<T>(v1.y, -v1.x);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::GetReversePerpendicular(const TVector2<T>& v1)
|
||||
{
|
||||
return TVector2<T>(-v1.y, v1.x);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::Min(const TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
return TVector2<T>(Phanes::Core::Math::Min(v1.x, v2.x), Phanes::Core::Math::Min(v1.y, v2.y));
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::Max(const TVector2<T>& v1, const TVector2<T>& v2)
|
||||
{
|
||||
return TVector2<T>(Phanes::Core::Math::Max(v1.x, v2.x), Phanes::Core::Math::Max(v1.y, v2.y));
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::Normalize(const TVector2<T>& v1)
|
||||
{
|
||||
float vecNorm = Magnitude(v1);
|
||||
return (vecNorm < P_FLT_INAC) ? PZeroVector2(T) : (v1 / vecNorm);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::UnsafeNormalize(const TVector2<T>& v1)
|
||||
{
|
||||
return (v1 / Magnitude(v1));
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::SignVector(const TVector2<T>& v1)
|
||||
{
|
||||
return TVector2<T>((v1.x > 0) ? 1 : -1, (v1.y > 0) ? 1 : -1);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::BindToSquare(const TVector2<T>& v1, T radius)
|
||||
{
|
||||
float k = (abs(v1.x) > abs(v1.y)) ? abs(radius / v1.x) : abs(radius / v1.y);
|
||||
return v1 * k;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::ClampToSquare(const TVector2<T>& 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<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::Lerp(const TVector2<T>& startVec, const TVector2<T>& destVec, T t)
|
||||
{
|
||||
t = Phanes::Core::Math::Clamp(t, (T)0.0, (T)1.0);
|
||||
|
||||
return (t * destVec) + ((1 - t) * startVec);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::LerpUnclamped(const TVector2<T>& startVec, const TVector2<T>& destVec, T t)
|
||||
{
|
||||
return (t * destVec) + ((1 - t) * startVec);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::Rotate(const TVector2<T>& v1, T angle)
|
||||
{
|
||||
float sinAngle = sin(angle);
|
||||
float cosAngle = cos(angle);
|
||||
|
||||
return TVector2<T>(v1.x * cosAngle - v1.y * sinAngle,
|
||||
v1.y * cosAngle + v1.x * sinAngle);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector2<T> Phanes::Core::Math::ClockwiseRotate(const TVector2<T>& v1, T angle)
|
||||
{
|
||||
return Rotate(v1, -angle);
|
||||
}
|
||||
@ -1,669 +0,0 @@
|
||||
// =========================== //
|
||||
// TVector3 implementation //
|
||||
// =========================== //
|
||||
|
||||
#include "PhanesEnginePCH.h"
|
||||
|
||||
#include "Core/public/Math/Vector3.h"
|
||||
|
||||
#include "Core/public/Math/Point.h"
|
||||
#include "Core/public/Math/Plane.h"
|
||||
|
||||
template<RealType T>
|
||||
inline Phanes::Core::Math::TVector3<T>::TVector3(const Real x, const Real y, const Real z)
|
||||
{
|
||||
this->x = x;
|
||||
this->y = y;
|
||||
this->z = z;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T>::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<RealType T>
|
||||
Phanes::Core::Math::TVector3<T>::TVector3(const TPoint3<T>& start, const TPoint3<T>& end)
|
||||
{
|
||||
this->x = end.x - start.x;
|
||||
this->y = end.y - start.y;
|
||||
this->z = end.z - start.z;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T>::TVector3(const TVector3<Real>& v)
|
||||
{
|
||||
memcpy(this->comp, comp, sizeof(T) * 3);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T>::TVector3(TVector3<Real>&& v)
|
||||
{
|
||||
this->comp = v.comp;
|
||||
v.comp = nullptr;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
// ====================== //
|
||||
// TVector3 operators //
|
||||
// ====================== //
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator+=(TVector3<T>& v1, T s)
|
||||
{
|
||||
v1.x += s;
|
||||
v1.y += s;
|
||||
v1.z += s;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator+=(TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
v1.x += v2.x;
|
||||
v1.y += v2.y;
|
||||
v1.z += v2.z;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator-=(TVector3<T>& v1, T s)
|
||||
{
|
||||
v1.x -= s;
|
||||
v1.y -= s;
|
||||
v1.z -= s;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator-=(TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
v1.x -= v2.x;
|
||||
v1.y -= v2.y;
|
||||
v1.z -= v2.z;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator*=(TVector3<T>& v1, T s)
|
||||
{
|
||||
v1.x *= s;
|
||||
v1.y *= s;
|
||||
v1.z *= s;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator/=(TVector3<T>& v1, T s)
|
||||
{
|
||||
s = (T)1.0 / s;
|
||||
v1.x *= s;
|
||||
v1.y *= s;
|
||||
v1.z *= s;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator*(const TVector3<T>& v1, T s)
|
||||
{
|
||||
return TVector3<T>(v1.x * s. v1.y * s, v1.z * s);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator/(const TVector3<T>& v1, T s)
|
||||
{
|
||||
s = (T)1.0 / s;
|
||||
return TVector3<T>(v1.x * s.v1.y * s, v1.z * s);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator*(T s, const TVector3<T>& v1)
|
||||
{
|
||||
return v1 * s;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator/(T s, const TVector3<T>& v1)
|
||||
{
|
||||
return v1 / s;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
T Phanes::Core::Math::operator*(const TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator+(const TVector3<T>& v1, T s)
|
||||
{
|
||||
return TVector3<T>(v1.x + s.v1.y + s, v1.z + s);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator+(const TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
return TVector3<T>(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator-(const TVector3<T>& v1, T s)
|
||||
{
|
||||
return TVector3<T>(v1.x - s.v1.y - s, v1.z - s);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator-(const TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
return TVector3<T>(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::operator-(TVector3<T>& v1)
|
||||
{
|
||||
v1.x = -v1.x;
|
||||
v1.y = -v1.y;
|
||||
v1.z = -v1.z;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
bool Phanes::Core::Math::operator==(const TVector3<T>& v1, const TVector3<T>& 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<RealType T>
|
||||
bool Phanes::Core::Math::operator!=(const TVector3<T>& v1, const TVector3<T>& 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<RealType T>
|
||||
T Phanes::Core::Math::Magnitude(const TVector3<T>& v1)
|
||||
{
|
||||
return sqrt(DotP(v1, v1));
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
T Phanes::Core::Math::SqrMagnitude(const TVector3<T>& v1)
|
||||
{
|
||||
return DotP(v1, v1);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
T Phanes::Core::Math::SqrLength(const TVector3<T>& v1)
|
||||
{
|
||||
return SqrMagnitude(v1);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::NormalizeV(TVector3<T>& v1)
|
||||
{
|
||||
float vecNorm = Magnitude(v1);
|
||||
v1 /= (vecNorm < P_FLT_INAC) ? 1 : vecNorm;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::UnsafeNormalizeV(TVector3<T>& v1)
|
||||
{
|
||||
v1 /= Magnitude(v1);
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ReflectV(TVector3<T>& v1, const TVector3<T>& normal)
|
||||
{
|
||||
Set(v1, v1 - (2 * (v1 * normal) * normal));
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
T Phanes::Core::Math::Angle(const TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
return acos((v1 * v2) / (Magnitude(v1) * Magnitude(v2)));
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
T Phanes::Core::Math::DotP(const TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
void Phanes::Core::Math::Orthogonalize(TVector3<T>& v1, TVector3<T>& v2, TVector3<T>& v3)
|
||||
{
|
||||
Set(v2, Reject(v2, v1));
|
||||
Set(v3, Reject(Reject(v3, v1), v2));
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
void Phanes::Core::Math::OrthoNormalize(TVector3<T>& v1, TVector3<T>& v2, TVector3<T>& v3)
|
||||
{
|
||||
Set(v2, Reject(v2, v1));
|
||||
Set(v3, Reject(Reject(v3, v1), v2));
|
||||
|
||||
NormalizeV(v1);
|
||||
NormalizeV(v2);
|
||||
NormalizeV(v3);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ScaleToMagnitude(const TVector3<T>& v1, T magnitude)
|
||||
{
|
||||
NormalizeV(v1) *= magnitude;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::CompInverse(const TVector3<T>& v1)
|
||||
{
|
||||
return TVector3<T>((T)1.0f / v1.x, (T)1.0f / v1.y, (T)1.0f / v1.z);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ReflectFromPlane(const TVector3<T>& v1, const TPlane<T>& plane)
|
||||
{
|
||||
return Reflect(v1, plane.normal);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ReflectFromPlane(const TVector3<T>& v1, const TVector3<T>& normal)
|
||||
{
|
||||
return Reflect(v1, normal);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::RotateAroundAxis(const TVector3<T>& v1, const TVector3<T>& 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<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::VectorTriple(const TVector3<T>& v1, const TVector3<T>& v2, const TVector3<T>& v3)
|
||||
{
|
||||
return CrossP(CrossP(v1, v2), v3);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::Project(const TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
return (DotP(v1, v2) / DotP(v2, v2)) * v2;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::Reject(const TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
return v1 - (DotP(v1, v2) / DotP(v2, v2)) * v2;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ProjectOntoPlane(const TVector3<T>& v1, const TVector3<T>& normal)
|
||||
{
|
||||
return Reject(v1, normal);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ProjectOntoPlane(const TVector3<T>& v1, const TPlane<T>& plane)
|
||||
{
|
||||
return Reject(v1, plane.normal);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::SignVector(const TVector3<T>& 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<RealType T>
|
||||
bool Phanes::Core::Math::Equals(const TVector3<T>& v1, const TVector3<T>& v2, T threshold)
|
||||
{
|
||||
return (abs(v1.x - v2.x) < threshold && abs(v1.y - v2.y) < threshold && abs(v1.z - v2.z) < threshold);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::PerspectiveDivideV(TVector3<T>& v1)
|
||||
{
|
||||
float _z = (T)1.0 / v1.z;
|
||||
v1.x *= _z;
|
||||
v1.y *= _z;
|
||||
v1.z = (T)0.0;
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::CrossPV(TVector3<T>& v1, const TVector3<T>& 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<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::MaxV(TVector3<T>& v1, const TVector3<T>& 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<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::MinV(TVector3<T>& v1, const TVector3<T>& 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<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::NegateV(TVector3<T>& v1)
|
||||
{
|
||||
v1.x = -v1.x;
|
||||
v1.y = -v1.y;
|
||||
v1.z = -v1.z;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ScaleV(TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
v1.x *= v2.x;
|
||||
v1.y *= v2.y;
|
||||
v1.z *= v2.z;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ProjectV(TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
float x = (v1 * v2) / (v2 * v2);
|
||||
v1 = x * v2;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::RejectV(TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
float x = (v1 * v2) / (v2 * v2);
|
||||
v1 -= x * v2;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ProjectOntoPlaneV(TVector3<T>& v1, const TVector3<T>& normal)
|
||||
{
|
||||
return RejectV(v1, normal);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ProjectOntoPlaneV(TVector3<T>& v1, const TPlane<T>& plane)
|
||||
{
|
||||
return RejectV(v1, plane.normal);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::Set(TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
v1 = v2;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::Set(TVector3<T>& v1, T x, T y, T z)
|
||||
{
|
||||
v1.x = x;
|
||||
v1.y = y;
|
||||
v1.z = z;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ClampMagnitudeV(TVector3<T>& 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<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::CompInverseV(TVector3<T>& v1)
|
||||
{
|
||||
v1.x = 1.0f / v1.x;
|
||||
v1.y = 1.0f / v1.y;
|
||||
v1.z = 1.0f / v1.z;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ReflectFromPlaneV(TVector3<T>& v1, const TPlane<T>& plane)
|
||||
{
|
||||
return ReflectV(v1, plane.normal);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ReflectFromPlaneV(TVector3<T>& v1, const TVector3<T>& normal)
|
||||
{
|
||||
return ReflectV(v1, normal);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::RotateAroundAxisV(TVector3<T>& v1, const TVector3<T>& 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<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ScaleToMagnitudeV(TVector3<T>& v1, T magnitude)
|
||||
{
|
||||
NormalizeV(v1) *= magnitude;
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::SignVectorV(TVector3<T>& 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<RealType T>
|
||||
T Phanes::Core::Math::ScalarTriple(const TVector3<T>& v1, const TVector3<T>& v2, const TVector3<T>& v3)
|
||||
{
|
||||
return CrossP(v1, v2) * v3;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
T Phanes::Core::Math::CosineAngle(const TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
return (v1 * v2) / (Magnitude(v1) * Magnitude(v2));
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::VectorTripleV(TVector3<T>& v1, const TVector3<T>& v2, const TVector3<T>& v3)
|
||||
{
|
||||
CrossPV(CrossPV(v1, v2), v3);
|
||||
|
||||
return v1;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
bool Phanes::Core::Math::IsPerpendicular(const TVector3<T>& v1, const TVector3<T>& v2, T threshold)
|
||||
{
|
||||
return (abs(DotP(v1, v2)) < threshold);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
bool Phanes::Core::Math::IsParallel(const TVector3<T>& v1, const TVector3<T>& v2, T threshold)
|
||||
{
|
||||
return (abs(DotP(v1, v2)) > threshold);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
bool Phanes::Core::Math::IsCoincident(const TVector3<T>& v1, const TVector3<T>& v2, T threshold)
|
||||
{
|
||||
return (DotP(v1, v2) > threshold);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
bool Phanes::Core::Math::IsNormalized(const TVector3<T>& v1, T threshold)
|
||||
{
|
||||
return (SqrMagnitude(v1) < threshold);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
bool Phanes::Core::Math::IsCoplanar(const TVector3<T>& v1, const TVector3<T>& v2, const TVector3<T>& v3, T threshold)
|
||||
{
|
||||
return (ScalarTriple(v1, v2, v3) < threshold);
|
||||
}
|
||||
|
||||
|
||||
// ================ //
|
||||
// With return: //
|
||||
// ================ //
|
||||
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::Normalize(const TVector3<T>& v1)
|
||||
{
|
||||
float vecNorm = Magnitude(v1);
|
||||
return (vecNorm < P_FLT_INAC) ? PZeroVector3(T) : v1 / vecNorm;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::UnsafeNormalize(const TVector3<T>& v1)
|
||||
{
|
||||
return v1 / Magnitude(v1);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::Reflect(const TVector3<T>& v1, const TVector3<T>& normal)
|
||||
{
|
||||
return v1 - (2 * (v1 * normal) * normal);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::PerspectiveDivide(const TVector3<T>& v1)
|
||||
{
|
||||
float _z = (T)1.0 / v1.z;
|
||||
return TVector3<T>(v1.x * _z, v1.y * _z, (T)0.0);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::CrossP(const TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
return TVector3<T>((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<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::Lerp(const TVector3<T>& start, const TVector3<T>& dest, T t)
|
||||
{
|
||||
t = Clamp(t, (T)0.0, (T), 1.0);
|
||||
return (1 - t) * start + t * dest;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::LerpUnclamped(const TVector3<T>& start, const TVector3<T>& dest, T t)
|
||||
{
|
||||
return (1 - t) * start + t * dest;
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::Max(const TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
return TVector3<T>((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<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::Min(const TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
return TVector3<T>((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<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::Negate(const TVector3<T>& v1)
|
||||
{
|
||||
return TVector3<T>(-v1.x, -v1.y, -v1.z);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::Scale(const TVector3<T>& v1, const TVector3<T>& v2)
|
||||
{
|
||||
return TVector3<T>(v1.x * v2.x, v1.y * v2.y, v1.z * v2.z);
|
||||
}
|
||||
|
||||
template<RealType T>
|
||||
Phanes::Core::Math::TVector3<T> Phanes::Core::Math::ClampMagnitude(const TVector3<T>& v1, T min, T max)
|
||||
{
|
||||
T magnitude = Magnitude(v1);
|
||||
|
||||
const TVector3<T> unitVec = (magnitude > P_FLT_INAC) ? v1 / magnitude : PZeroVector3(T);
|
||||
|
||||
Clamp(magnitude, min, max);
|
||||
|
||||
return unitVec * magnitude;
|
||||
}
|
||||
|
||||
@ -1,388 +0,0 @@
|
||||
// ========================== //
|
||||
// Vector4 implementation //
|
||||
// ========================== //
|
||||
|
||||
|
||||
#include "Misc/CommonDefines.h"
|
||||
#include PHANES_CORE_PCH_DEFAULT_PATH
|
||||
|
||||
#include "Math/Vector4.h"
|
||||
|
||||
#include "Math/Vector3.h"
|
||||
#include "Math/Vector2.h"
|
||||
|
||||
|
||||
// ===================== //
|
||||
// Vector4 operators //
|
||||
// ===================== //
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::createVector(float x, float y, float z, float w)
|
||||
{
|
||||
Vector4 _new{};
|
||||
_new.x = x;
|
||||
_new.y = y;
|
||||
_new.z = z;
|
||||
_new.w = w;
|
||||
return _new;
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::operator+=(Vector4& a, float s)
|
||||
{
|
||||
a.x += s;
|
||||
a.y += s;
|
||||
a.z += s;
|
||||
a.w += s;
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::operator+= (phanes::core::math::coretypes::Vector4& a, const phanes::core::math::coretypes::Vector4& b) {
|
||||
a.x += b.x;
|
||||
a.y += b.y;
|
||||
a.z += b.z;
|
||||
a.w += b.w;
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::operator-=(Vector4& a, float s)
|
||||
{
|
||||
a.x -= s;
|
||||
a.y -= s;
|
||||
a.z -= s;
|
||||
a.w -= s;
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::operator-= (phanes::core::math::coretypes::Vector4& a, const phanes::core::math::coretypes::Vector4& b) {
|
||||
a.x -= b.x;
|
||||
a.y -= b.y;
|
||||
a.z -= b.z;
|
||||
a.w -= b.w;
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::operator*= (phanes::core::math::coretypes::Vector4& a, float s) {
|
||||
a.x *= s;
|
||||
a.y *= s;
|
||||
a.z *= s;
|
||||
a.w *= s;
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::operator/= (phanes::core::math::coretypes::Vector4& a, float s) {
|
||||
s = 1.0f / s;
|
||||
a.x *= s;
|
||||
a.y *= s;
|
||||
a.z *= s;
|
||||
a.w *= s;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator*(const Vector4& a, float s)
|
||||
{
|
||||
Vector4 v;
|
||||
v.x = a.x * s;
|
||||
v.y = a.y * s;
|
||||
v.z = a.z * s;
|
||||
v.w = a.w * s;
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator*(float s, const Vector4& a)
|
||||
{
|
||||
Vector4 v;
|
||||
v.x = a.x * s;
|
||||
v.y = a.y * s;
|
||||
v.z = a.z * s;
|
||||
v.w = a.w * s;
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator/(const Vector4& a, float s)
|
||||
{
|
||||
Vector4 v;
|
||||
s = 1.0f / s;
|
||||
v.x = a.x * s;
|
||||
v.y = a.y * s;
|
||||
v.z = a.z * s;
|
||||
v.w = a.w * s;
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator/(float s, const Vector4& a)
|
||||
{
|
||||
Vector4 v;
|
||||
s = 1.0f / s;
|
||||
v.x = a.x * s;
|
||||
v.y = a.y * s;
|
||||
v.z = a.z * s;
|
||||
v.w = a.w * s;
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
float phanes::core::math::coretypes::operator*(const Vector4& a, const Vector4& b)
|
||||
{
|
||||
return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator+(const Vector4& a, float s)
|
||||
{
|
||||
Vector4 v;
|
||||
v.x = a.x + s;
|
||||
v.y = a.y + s;
|
||||
v.z = a.z + s;
|
||||
v.w = a.w + s;
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator+(const Vector4& a, const Vector4& b)
|
||||
{
|
||||
Vector4 v;
|
||||
v.x = a.x + b.x;
|
||||
v.y = a.y + b.y;
|
||||
v.z = a.z + b.z;
|
||||
v.w = a.w + b.w;
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator-(const Vector4& a, float s)
|
||||
{
|
||||
Vector4 v;
|
||||
v.x = a.x - s;
|
||||
v.y = a.y - s;
|
||||
v.z = a.z - s;
|
||||
v.w = a.w - s;
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::operator-(const Vector4& a, const Vector4& b)
|
||||
{
|
||||
Vector4 v;
|
||||
v.x = a.x - b.x;
|
||||
v.y = a.y - b.y;
|
||||
v.z = a.z - b.z;
|
||||
v.w = a.w - b.w;
|
||||
return v;
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::operator-(Vector4& a)
|
||||
{
|
||||
a.x = -a.x;
|
||||
a.y = -a.y;
|
||||
a.z = -a.z;
|
||||
a.w = -a.w;
|
||||
}
|
||||
|
||||
|
||||
bool phanes::core::math::coretypes::operator==(const Vector4& a, const Vector4& b)
|
||||
{
|
||||
if (abs(a.x - b.x) <= P_FLT_INAC and abs(a.y - b.y) <= P_FLT_INAC and abs(a.z - b.z) <= P_FLT_INAC and abs(a.w - b.w) <= P_FLT_INAC)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// ====================================== //
|
||||
// Vector4 function implementation //
|
||||
// ====================================== //
|
||||
|
||||
|
||||
float phanes::core::math::coretypes::magnitude(const Vector4& a)
|
||||
{
|
||||
return sqrtf(a.x * a.x + a.y * a.y + a.z * a.z + a.w * a.w);
|
||||
}
|
||||
|
||||
float phanes::core::math::coretypes::sqrMagnitude(const Vector4& a)
|
||||
{
|
||||
return a.x * a.x + a.y * a.y + a.z * a.z;
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::normalizeNR(Vector4& a)
|
||||
{
|
||||
a /= sqrtf(a.x * a.x + a.y * a.y + a.z * a.z);
|
||||
}
|
||||
|
||||
|
||||
float phanes::core::math::coretypes::angle(const Vector4& a, const Vector4& b)
|
||||
{
|
||||
return acosf(dotP(a, b) / (magnitude(a) * magnitude(b)));
|
||||
}
|
||||
|
||||
|
||||
float phanes::core::math::coretypes::dotP(const Vector4& a, const Vector4& b)
|
||||
{
|
||||
return a.x * b.x + a.y * b.y + a.z * b.z;
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::orthogonolize(Vector4& a, Vector4& b, Vector4& c)
|
||||
{
|
||||
Set(b, b - project(b, a));
|
||||
Set(c, c - project(c, a) - project(c, b));
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::orthoNormalize(Vector4& a, Vector4& b, Vector4& c)
|
||||
{
|
||||
Set(b, b - project(b, a));
|
||||
Set(c, c - project(c, a) - project(c, b));
|
||||
|
||||
a /= sqrtf(a.x * a.x + a.y * a.y + a.z * a.z);
|
||||
b /= sqrtf(b.x * b.x + b.y * b.y + b.z * b.z);
|
||||
c /= sqrtf(c.x * c.x + c.y * c.y + c.z * c.z);
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::scaleToMagnitude(Vector4& a, float size)
|
||||
{
|
||||
a /= sqrtf(a.x * a.x + a.y * a.y + a.z * a.z);
|
||||
a *= size;
|
||||
}
|
||||
|
||||
bool phanes::core::math::coretypes::equals(const Vector4& a, const Vector4& b, float threshold)
|
||||
{
|
||||
if (abs(a.x - b.x) <= threshold and abs(a.y - b.y) <= threshold and abs(a.z - b.z) <= threshold)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::perpspectiveDivideNR(Vector4& a)
|
||||
{
|
||||
float _z = 1.0f / a.z;
|
||||
a.x *= _z;
|
||||
a.y *= _z;
|
||||
a.z = 0.0f;
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::maxNR(Vector4& a, const Vector4& b)
|
||||
{
|
||||
a.x = phanes::core::math::max(a.x, b.x);
|
||||
a.y = phanes::core::math::max(a.y, b.y);
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::minNR(Vector4& a, const Vector4& b)
|
||||
{
|
||||
a.x = phanes::core::math::min(a.x, b.x);
|
||||
a.y = phanes::core::math::min(a.y, b.y);
|
||||
}
|
||||
|
||||
void phanes::core::math::coretypes::scaleNR(Vector4& a, const Vector4& b)
|
||||
{
|
||||
a.x *= b.x;
|
||||
a.y *= b.y;
|
||||
a.z *= b.z;
|
||||
}
|
||||
|
||||
// projects vector a onto vector b
|
||||
void phanes::core::math::coretypes::projectNR(Vector4& a, const Vector4& b)
|
||||
{
|
||||
float x = (a * b) / (b * b);
|
||||
a.x = x * b.x;
|
||||
a.y = x * b.y;
|
||||
a.z = x * b.z;
|
||||
}
|
||||
|
||||
// rejects vector a from vector b
|
||||
void phanes::core::math::coretypes::rejectNR(Vector4& a, const Vector4& b)
|
||||
{
|
||||
float x = ((a * b) / (b * b));
|
||||
a.x -= x * b.x;
|
||||
a.y -= x * b.y;
|
||||
a.z -= x * b.z;
|
||||
}
|
||||
|
||||
|
||||
void phanes::core::math::coretypes::Set(Vector4& a, const Vector4& b)
|
||||
{
|
||||
a.x = b.x;
|
||||
a.y = b.y;
|
||||
a.z = b.z;
|
||||
}
|
||||
|
||||
|
||||
// WITH RETURN: //
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::perpspectiveDivide(const Vector4& a)
|
||||
{
|
||||
float _z = 1.0f / a.z;
|
||||
return createVector(a.x * _z, a.y * _z, a.z * _z, 0.0f);
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::lerp(const Vector4& a, const Vector4& b, float t)
|
||||
{
|
||||
t = phanes::core::math::clamp(t, .0f, 1.0f);
|
||||
return a * (1 - t) + t * b;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::lerpUnclamped(const Vector4& a, const Vector4& b, float t)
|
||||
{
|
||||
return a * (1 - t) + t * b;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::slerp(const Vector4& a, const Vector4& b, float t)
|
||||
{
|
||||
t = phanes::core::math::clamp(t, 0.0f, 1.0f);
|
||||
Vector4 _a = normalize(a);
|
||||
Vector4 _b = normalize(b);
|
||||
float _angle = angle(_a, _b);
|
||||
return (((sinf(1.0f - t) * _angle) / sinf(_angle)) * _a) + ((sinf(t * _angle) / sinf(_angle)) * _b);
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::slerpUnclamped(const Vector4& a, const Vector4& b, float t)
|
||||
{
|
||||
Vector4 _a = normalize(a);
|
||||
Vector4 _b = normalize(b);
|
||||
float _angle = angle(_a, _b);
|
||||
return (((sinf(1.0f - t) * _angle) / sinf(_angle)) * _a) + ((sinf(t * _angle) / sinf(_angle)) * _b);
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::max(const Vector4& a, const Vector4& b)
|
||||
{
|
||||
Vector4 _new{};
|
||||
_new.x = phanes::core::math::max(a.x, b.x);
|
||||
_new.y = phanes::core::math::max(a.y, b.y);
|
||||
_new.z = phanes::core::math::max(a.z, b.z);
|
||||
return _new;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::min(const Vector4& a, const Vector4& b)
|
||||
{
|
||||
Vector4 _new{};
|
||||
_new.x = phanes::core::math::min(a.x, b.x);
|
||||
_new.y = phanes::core::math::min(a.y, b.y);
|
||||
_new.z = phanes::core::math::min(a.z, b.z);
|
||||
return _new;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::scale(const Vector4& a, const Vector4& b)
|
||||
{
|
||||
return createVector(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w);
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::project(const Vector4& a, const Vector4& b)
|
||||
{
|
||||
return ((a * b) / (b * b)) * b;
|
||||
}
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::reject(const Vector4& a, const Vector4& b)
|
||||
{
|
||||
return a - ((a * b) / (b * b)) * b;
|
||||
}
|
||||
|
||||
|
||||
phanes::core::math::coretypes::Vector4 phanes::core::math::coretypes::normalize(const Vector4& a)
|
||||
{
|
||||
return a / sqrtf(a.x * a.x + a.y * a.y + a.z * a.z);
|
||||
}
|
||||
@ -1,7 +1,40 @@
|
||||
#include "PhanesEnginePCH.h"
|
||||
|
||||
#define P_USE_NAMESPACE_ALIAS
|
||||
#define P_TEST
|
||||
|
||||
#include "Core/public/StartingPoint/StartingPoint.h"
|
||||
|
||||
static void IdleMsg()
|
||||
{
|
||||
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
|
||||
SetConsoleTextAttribute(hConsole, 12);
|
||||
|
||||
std::cout << "Welcome to PhanesEngine!" << std::endl << std::endl;
|
||||
|
||||
SetConsoleTextAttribute(hConsole, 15);
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::seconds(5));
|
||||
|
||||
std::cout << "It's silent..." << std::endl << std::endl;
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::seconds(3));
|
||||
|
||||
std::cout << "To silent." << std::endl;
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::seconds(5));
|
||||
|
||||
std::cout << "\nI will go now" << std::endl;
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::seconds(4));
|
||||
|
||||
std::cout << "\nGood by!" << std::endl;
|
||||
std::this_thread::sleep_for(std::chrono::seconds(3));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
Phanes::Core::Application::PhanesGame::PhanesGame()
|
||||
{
|
||||
}
|
||||
@ -13,5 +46,27 @@ Phanes::Core::Application::PhanesGame::~PhanesGame()
|
||||
|
||||
void Phanes::Core::Application::PhanesGame::Run()
|
||||
{
|
||||
while (true);
|
||||
}
|
||||
HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
|
||||
SetConsoleTextAttribute(hConsole, 12);
|
||||
|
||||
std::cout << "Welcome to PhanesEngine!" << std::endl << std::endl;
|
||||
|
||||
SetConsoleTextAttribute(hConsole, 15);
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::seconds(5));
|
||||
|
||||
std::cout << "It's silent..." << std::endl << std::endl;
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::seconds(3));
|
||||
|
||||
std::cout << "To silent." << std::endl;
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::seconds(5));
|
||||
|
||||
std::cout << "\nI will go now" << std::endl;
|
||||
|
||||
std::this_thread::sleep_for(std::chrono::seconds(4));
|
||||
|
||||
std::cout << "\nGood by!" << std::endl;
|
||||
std::this_thread::sleep_for(std::chrono::seconds(3));
|
||||
}
|
||||
@ -1,156 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Core/public/Misc/Boilerplate.h"
|
||||
|
||||
#include "Core/public/Math/MathCommon.h"
|
||||
#include "Core/public/Math/MathAbstractTypes.h"
|
||||
#include "Core/public/Math/MathFwd.h"
|
||||
|
||||
#include "Core/public/Math/IntVector2.h"
|
||||
#include "Core/public/Math/IntVector3.h"
|
||||
// #include "Core/public/Math/IntVector4.h"
|
||||
|
||||
#ifndef P_DEBUG
|
||||
#pragma warning(disable : 4244)
|
||||
#endif
|
||||
|
||||
/**
|
||||
* General annonation: The Point is the same as a vector. The type exists, to ensure a
|
||||
* easy differentiation between the two.
|
||||
*/
|
||||
|
||||
#ifndef INTPOINT_H
|
||||
#define INTPOINT_H
|
||||
|
||||
namespace Phanes::Core::Math {
|
||||
|
||||
/**
|
||||
* A 2D Point with components x and y with integer precision.
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
struct TIntPoint2 : public TIntVector2<T> {
|
||||
|
||||
using TIntVector2<T>::TIntVector2;
|
||||
|
||||
/**
|
||||
* Creates IntPoint2 from IntPoint3's xy
|
||||
*
|
||||
* @param a IntPoint3 one
|
||||
*/
|
||||
|
||||
TIntPoint2(const TIntPoint3<T>& a)
|
||||
{
|
||||
this->x = a.x;
|
||||
this->y = a.y;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates IntPoint2 from IntPoint4's xy
|
||||
*
|
||||
* @param a IntPoint4 one
|
||||
*/
|
||||
|
||||
//TIntPoint2(const TIntPoint4<T>& a)
|
||||
//{
|
||||
// this->x = a.x;
|
||||
// this->y = a.y;
|
||||
|
||||
//}
|
||||
};
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Rt Distance(const TIntPoint2<T>& p1, const TIntPoint2<T>& p2);
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* A 3D Point with components x and y with integer precision.
|
||||
*/
|
||||
|
||||
|
||||
template<IntType T>
|
||||
struct TIntPoint3 : public TIntVector3<T> {
|
||||
|
||||
using TIntVector3<T>::TIntVector3;
|
||||
|
||||
/**
|
||||
* Creates IntPoint3 from IntPoint2's xy and zero
|
||||
*
|
||||
* @param a IntPoint2 one
|
||||
*/
|
||||
|
||||
TIntPoint3(const TIntPoint2<T>& 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<T>& a)
|
||||
//{
|
||||
// this->components[0] = a.components[0];
|
||||
// this->components[1] = a.components[1];
|
||||
// this->components[2] = a.components[2];
|
||||
//}
|
||||
};
|
||||
|
||||
template<IntType T, RealType Rt>
|
||||
Rt Distance(const TIntPoint3<T>& p1, const TIntPoint3<T>& p2);
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* A 4D Point with components x and y with integer precision.
|
||||
*/
|
||||
|
||||
|
||||
//template<typename T>
|
||||
//struct TIntPoint4 : public TIntVector4<T> {
|
||||
// static_assert(std::is_integral_v(T), "T must be an integer type.");
|
||||
|
||||
// using IntVector4<T>::IntVector4;
|
||||
|
||||
// /**
|
||||
// * Creates IntPoint4 from IntPoint2's xy and the last two zero
|
||||
// *
|
||||
// * @param a IntPoint2 one
|
||||
// */
|
||||
|
||||
// PHANES_CORE_API IntPoint4(const IntPoint2<T>& 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<T>& 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
|
||||
@ -1,872 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Core/Core.h"
|
||||
|
||||
#include "Core/public/Misc/Boilerplate.h"
|
||||
|
||||
#include "Core/public/Math/MathCommon.h"
|
||||
#include "Core/public/Math/MathAbstractTypes.h"
|
||||
#include "Core/public/Math/MathFwd.h"
|
||||
|
||||
#ifndef P_DEBUG
|
||||
#pragma warning(disable : 4244)
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Note: Some function are deleted, because, their unusable with int types, except very specific cases.
|
||||
* To keep the library verbose, these functions are explicitly marked as deleted.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef INTVECTOR2_H
|
||||
#define INTVECTOR2_H
|
||||
|
||||
#define PIntZeroVector2(type) TIntVector2<##type>(0,0)
|
||||
#define PIntVectorSouth2(type) TIntVector2<##type>(0,-1)
|
||||
#define PIntVectorNorth2(type) TIntVector2<##type>(0,1)
|
||||
#define PIntVectorEast2(type) TIntVector2<##type>(1,0)
|
||||
#define PIntVectorWest2(type) TIntVector2<##type>(-1,0)
|
||||
|
||||
|
||||
namespace Phanes::Core::Math {
|
||||
|
||||
/**
|
||||
* A 2D Vector with components x and y with integer precision.
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
struct TIntVector2 {
|
||||
|
||||
static_assert(std::is_integral_v<T>, "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<T>& v);
|
||||
|
||||
/**
|
||||
* Move constructor
|
||||
*/
|
||||
|
||||
TIntVector2(TIntVector2<T>&& v);
|
||||
|
||||
/**
|
||||
* Convert other type of vector
|
||||
*/
|
||||
|
||||
template<IntType OtherIntType>
|
||||
explicit TIntVector2(const TIntVector2<OtherIntType>& v) : x((T)v.x), y((T)v.y) {};
|
||||
|
||||
template<RealType Real>
|
||||
explicit TIntVector2(const TVector2<Real>& 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<T>& v);
|
||||
|
||||
/**
|
||||
* Construct Vector from 4D integer Vector's xy.
|
||||
*
|
||||
* @param v 4D IntVector to copy from
|
||||
*/
|
||||
|
||||
//TIntVector2(const TIntVector4<IntType>& v);
|
||||
|
||||
/**
|
||||
* Construct Vector from 2D Point's xy.
|
||||
*
|
||||
* @param v 2D Point to copy from
|
||||
*/
|
||||
|
||||
//TIntVector2(const TIntPoint2<IntType>& v);
|
||||
|
||||
|
||||
/**
|
||||
* Constructs a vector pointing from start to end.
|
||||
*
|
||||
* @param(start) Startingpoint
|
||||
* @param(end) Endpoint
|
||||
*/
|
||||
|
||||
TIntVector2(const TIntPoint2<T>& start, const TIntPoint2<T>& end);
|
||||
};
|
||||
|
||||
// ======================== //
|
||||
// IntVector2 operators //
|
||||
// ======================== //
|
||||
|
||||
|
||||
/**
|
||||
* Addition operation on same TIntVector2<T> (this) by a floating point value.
|
||||
*
|
||||
* @param(v1) Vector to add to
|
||||
* @param(s) Floating point to add
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> operator+= (TIntVector2<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Addition operation on same TIntVector2<T> (this) by a another TIntVector2<T>.
|
||||
*
|
||||
* @param(v1) Vector to add to
|
||||
* @param(v2) Vector to add
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> operator+= (TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Substraction operation on same TIntVector2<T> (this) by a floating point.
|
||||
*
|
||||
* @param(v1) Vector to substract from
|
||||
* @param(v2) Floating point to substract
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> operator-= (TIntVector2<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Substraction operation on same TIntVector2<T> (this) by a another TIntVector2<T>.
|
||||
*
|
||||
* @param(v1) Vector to substract from
|
||||
* @param(v2) Vector to substract
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> operator-= (TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Multiplication of TIntVector2<T> (this) with a floating point.
|
||||
*
|
||||
* @param(v1) Vector to multiply with
|
||||
* @param(s Floating point to multiply with
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> operator*= (TIntVector2<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Devision of Vector (this) by floating point.
|
||||
*
|
||||
* @param(v1) Vector to divide with
|
||||
* @param(s Floating point to divide with
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> operator/= (TIntVector2<T>& v1, T s) = delete;
|
||||
|
||||
/**
|
||||
* Scale of Vector by floating point. (> Creates a new TIntVector2<T>)
|
||||
*
|
||||
* @param(v1) Vector to multiply with
|
||||
* @param(s Floating point to multiply with
|
||||
*
|
||||
* @return Result Vector
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> operator* (const TIntVector2<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Division of Vector by floating point. (> Creates another TIntVector2<T>)
|
||||
*
|
||||
* @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<IntType T>
|
||||
TIntVector2<T> operator/ (const TIntVector2<T>& v1, T s) = delete;
|
||||
|
||||
/**
|
||||
* Scale of Vector by floating point. (> Creates a new TIntVector2<T>)
|
||||
*
|
||||
* @param(v1) Vector to multiply with
|
||||
* @param(s Floating point to multiply with
|
||||
*
|
||||
* @return Result Vector
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
inline TIntVector2<T> operator* (T s, const TIntVector2<T>& 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<IntType T>
|
||||
inline TIntVector2<T> operator/ (T s, const TIntVector2<T>& v1) = delete;
|
||||
|
||||
/**
|
||||
* Dot product between two Vectors.
|
||||
*
|
||||
* @see [FUNC]DotP
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @result Dot product
|
||||
*/
|
||||
|
||||
template<IntType T, IntType Rt = float>
|
||||
Rt operator* (const TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Componentwise addition of Vector with floating point.
|
||||
*
|
||||
* @param(v1) Vector to add to
|
||||
* @param(s Floating point to add
|
||||
*
|
||||
* @return Result Vector
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> operator+ (const TIntVector2<T>& 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<IntType T>
|
||||
TIntVector2<T> operator+ (const TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Componentwise substraction of Vector with floating point.
|
||||
*
|
||||
* @param(v1) Vector to substract from
|
||||
* @param(s Floating point to substract
|
||||
*
|
||||
* @return Result Vector
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> operator- (const TIntVector2<T>& 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<IntType T>
|
||||
TIntVector2<T> operator- (const TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Negate Vector.
|
||||
*
|
||||
* @param(v1) Vector to negate
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
void operator- (TIntVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Compare Vector for equality.
|
||||
*
|
||||
* @see [FUNC]Equals
|
||||
*
|
||||
* @param(v1) Vector to negate
|
||||
*
|
||||
* @return true if equal, false if inequal
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
bool operator== (const TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
|
||||
/**
|
||||
* Compare Vector for inequality.
|
||||
*
|
||||
* @see [FUNC]Equals
|
||||
*
|
||||
* @param(v1) Vector to negate
|
||||
*
|
||||
* @return true if inequal, false if equal
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
bool operator!= (const TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
// ============================================== //
|
||||
// IntVector2 static function implementation //
|
||||
// ============================================== //
|
||||
|
||||
/**
|
||||
* Magnitude of Vector
|
||||
*
|
||||
* @param(v1) Vector
|
||||
*
|
||||
* @return Size of Vector
|
||||
*/
|
||||
|
||||
template<IntType T, IntType Rt = float>
|
||||
Rt Magnitude(const TIntVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* @see [FUNC]Magnitude
|
||||
*/
|
||||
template<IntType T, IntType Rt = float>
|
||||
FORCEINLINE Rt Length(const TIntVector2<T>& v1) { return Magnitude(v1); };
|
||||
|
||||
/**
|
||||
* Square of magnitude of Vector
|
||||
*
|
||||
* @param(v1) Vector
|
||||
*
|
||||
* @return Magnitude without calculating square root
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
T SqrMagnitude(const TIntVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* @see [FUNC]SqrMagnitude
|
||||
*/
|
||||
template<IntType T>
|
||||
FORCEINLINE T SqrLength(const TIntVector2<T>& 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<IntType T, RealType Rt = float>
|
||||
TIntVector2<T> DivideTruncV(TIntVector2<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Angle between to Vectors
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
Rt Angle(const TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Cosine of angle between to Vectors
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
Rt CosineAngle(const TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Returns signs of components in vector: -1 / +1 / 0.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> SignVectorV(TIntVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Dot product of two Vectors
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
T DotP(const TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Creates Vector, with component wise largest values.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @note Stores new Vector to v1
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> MaxV(TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Creates Vector, with component wise smallest values.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @note Stores new Vector to v1
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> MinV(TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Gets perpendicular Vector to v1.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @note Stores new Vector to v1
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> GetPerpendicularV(TIntVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Gets perpendicular Vector to v1.
|
||||
*
|
||||
* @reg [FUNC]PerpendicularV
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @note Stores new Vector to v1
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> GetReversePerpendicularV(TIntVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Component wise multiplication of Vector
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @note Stores new Vector to v1
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> ScaleV(TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Copies one Vector two another
|
||||
*
|
||||
* @param(v1) Vector to copy to
|
||||
* @param(v2) Vector to copy
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> Set(TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Sets components of a vector.
|
||||
*
|
||||
* @param(v1) Vector to copy to
|
||||
* @param(v2) Vector to copy
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> Set(TIntVector2<T>& v1, T x, T y);
|
||||
|
||||
|
||||
/**
|
||||
* Negates Vector
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> NegateV(TIntVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Tests if vector is a unity vector.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @return true if unit vector, false if not
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
inline bool IsNormalized(const TIntVector2<T>& 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<IntType T>
|
||||
inline bool IsPerpendicular(const TIntVector2<T>& v1, const TIntVector2<T>& 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<IntType T>
|
||||
inline bool IsParallel(const TIntVector2<T>& v1, const TIntVector2<T>& 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<IntType T>
|
||||
inline bool IsCoincident(const TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Gets outer product of to vectors.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @return Resulting matrix
|
||||
*/
|
||||
|
||||
//template<IntType T>
|
||||
//Matrix2<T> OuterProduct(const TIntVector2<T>& v1, const TIntVector2<T>& 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<IntType T, RealType Rt = float>
|
||||
TVector2<Rt> Reflect(const TIntVector2<T>& v1, const TVector2<Rt>& normal);
|
||||
|
||||
/**
|
||||
* Scales a vector component wise
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @return Reflected vector
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> Scale(const TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Componentwise inverse of a vector
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @return Componentwise inverted, floating point vector
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
TVector2<Rt> CompInverse(const TIntVector2<T>& v1);
|
||||
|
||||
|
||||
/**
|
||||
* Negates Vector
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @return Componentwise inverted vector
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> Negate(const TIntVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Gets the perpendicular vector of v1
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @return Perpendicular vector
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> GetPerpendicular(const TIntVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Gets reverse of the perpendicular vector of v1
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @return Reversed perpendicular vector
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> GetReversePerpendicular(const TIntVector2<T>& 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<IntType T>
|
||||
TIntVector2<T> Min(const TIntVector2<T>& v1, const TIntVector2<T>& 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<IntType T>
|
||||
TIntVector2<T> Max(const TIntVector2<T>& v1, const TIntVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Creates a normalized instance of the vector
|
||||
*
|
||||
* @param(v1) Vector to normalize
|
||||
*
|
||||
* @return Unit vector
|
||||
* @note Returns floating point vector.
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
TVector2<Rt> Normalize(const TIntVector2<T>& 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<IntType T, RealType Rt = float>
|
||||
TVector2<Rt> UnsafeNormalize(const TIntVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Returns signs of components in vector: -1 / +1 / 0.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @return Vector with signs as components
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector2<T> SignVector(const TIntVector2<T>& 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<IntType T, RealType Rt = float>
|
||||
TVector2<Rt> BindToSquare(const TIntVector2<T>& 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<IntType T, RealType Rt = float>
|
||||
TVector2<Rt> ClampToSquare(const TIntVector2<T>& 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<IntType T, RealType Rt = float>
|
||||
TVector2<Rt> Lerp(const TIntVector2<T>& startVec, const TIntVector2<T>& 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<IntType T, RealType Rt = float>
|
||||
TVector2<Rt> LerpUnclamped(const TIntVector2<T>& startVec, const TIntVector2<T>& 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<IntType T, RealType Rt = float>
|
||||
TVector2<Rt> Rotate(const TIntVector2<T>& v1, Rt angle);
|
||||
|
||||
/**
|
||||
* Clockwise vector rotation.
|
||||
*
|
||||
* @param(v1) Vector to rotate
|
||||
*
|
||||
* @return Rotated vector
|
||||
*
|
||||
* @note Angle is not clamped
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
FORCEINLINE TVector2<Rt> ClockwiseRotate(const TIntVector2<T>& 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<IntType T, RealType Rt = float>
|
||||
TIntVector2<T> DivideTrunc(const TIntVector2<T>& v1, T s);
|
||||
|
||||
|
||||
/**
|
||||
* Component wise division of Vector
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(s) Vector two
|
||||
*
|
||||
* @return Floating point vector
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
TVector2<Rt> DivideFloat(const TIntVector2<T>& v1, T s);
|
||||
|
||||
} // phanes::core::math::coretypes
|
||||
|
||||
#endif // !INTVECTOR2_H
|
||||
|
||||
@ -1,966 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Core/public/Misc/Boilerplate.h"
|
||||
|
||||
#include "Core/public/Math/MathCommon.h"
|
||||
#include "Core/public/Math/MathAbstractTypes.h"
|
||||
#include "Core/public/Math/MathFwd.h"
|
||||
|
||||
#include "Core/public/Math/Vector3.h"
|
||||
|
||||
#ifndef P_DEBUG
|
||||
#pragma warning(disable : 4244)
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef INTVECTOR3_H
|
||||
#define INTVECTOR3_H
|
||||
|
||||
#define PIntZeroVector3(type) TIntVector3<##type>(0,0,0)
|
||||
#define PIntVectorForward3(type) TIntVector3<##type>(1,0,0)
|
||||
#define PIntVectorBackward3(type) TIntVector3<##type>(-1,0,0)
|
||||
#define PIntVectorEast3(type) TIntVector3<##type>(0,1,0)
|
||||
#define PIntVectorWest3(type) TIntVector3<##type>(0,-1,0)
|
||||
#define PIntVectorUp3(type) TIntVector3<##type>(0,0,1)
|
||||
#define PIntVectorDown3(type) TIntVector3<##type>(0,0,-1)
|
||||
|
||||
namespace Phanes::Core::Math {
|
||||
|
||||
/**
|
||||
* A 3D Vector with components x, y and z with integer precision.
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
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<T>& v);
|
||||
|
||||
/**
|
||||
* Move constructor
|
||||
*/
|
||||
|
||||
TIntVector3(TIntVector3<T>&& v);
|
||||
|
||||
/**
|
||||
* Convert other type of vector
|
||||
*/
|
||||
|
||||
template<IntType OtherIntType>
|
||||
explicit TIntVector3(const TIntVector3<OtherIntType>& v) : x((T)v.x), y((T)v.y) {};
|
||||
|
||||
template<RealType Real>
|
||||
explicit TIntVector3(const TVector3<Real>& 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<T>& v);
|
||||
|
||||
/**
|
||||
* Construct Vector from 4D integer Vector's xy.
|
||||
*
|
||||
* @param v 4D IntVector to copy from
|
||||
*/
|
||||
|
||||
//TIntVector2(const TIntVector4<IntType>& v);
|
||||
|
||||
/**
|
||||
* Construct Vector from 2D Point's xy.
|
||||
*
|
||||
* @param v 2D Point to copy from
|
||||
*/
|
||||
|
||||
//TIntVector2(const TIntPoint2<IntType>& v);
|
||||
|
||||
|
||||
/**
|
||||
* Constructs a vector pointing from start to end.
|
||||
*
|
||||
* @param(start) Startingpoint
|
||||
* @param(end) Endpoint
|
||||
*/
|
||||
|
||||
TIntVector3(const TIntPoint3<T>& start, const TIntPoint3<T>& end);
|
||||
|
||||
};
|
||||
|
||||
|
||||
// ======================== //
|
||||
// IntVector3 operators //
|
||||
// ======================== //
|
||||
|
||||
|
||||
/**
|
||||
* Coponentwise addition of floating point to 3D vector
|
||||
*
|
||||
* @param(v1) vector to add to
|
||||
* @param(s) floating point to add
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
inline TIntVector3<T> operator+= (TIntVector3<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Coponentwise addition of 3D vector to 3D vector
|
||||
*
|
||||
* @param(v1) vector to add to
|
||||
* @param(v2) vector to add
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
inline TIntVector3<T> operator+= (TIntVector3<T>& v1, const TIntVector3<T>& v2);
|
||||
|
||||
/**
|
||||
* Coponentwise substraction of floating point of 3D vector
|
||||
*
|
||||
* @param(v1) vector to substract from
|
||||
* @param(s) floating point to substract
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
inline TIntVector3<T> operator-= (TIntVector3<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Coponentwise substraction of 3D vector to 3D vector
|
||||
*
|
||||
* @param(v1) vector to substract from
|
||||
* @param(v2) vector to substract with
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
inline TIntVector3<T> operator-= (TIntVector3<T>& v1, const TIntVector3<T>& v2);
|
||||
|
||||
/**
|
||||
* Dot product between two 3D Vectors
|
||||
*
|
||||
* @param(v1) vector one
|
||||
* @param(s) floating point
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
inline TIntVector3<T> operator*= (TIntVector3<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Coponentwise multiplication of 3D Vectors with floating point
|
||||
*
|
||||
* @param(v1) vector one
|
||||
* @param(s) floating point
|
||||
*
|
||||
* @return Resulting vector
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector3<T> operator* (const TIntVector3<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Coponentwise multiplication of 3D Vectors with floating point
|
||||
*
|
||||
* @param(s) floating point
|
||||
* @param(v2) vector
|
||||
*
|
||||
* @return Resultion vector
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
inline TIntVector3<T> operator* (T s, const TIntVector3<T>& v1);
|
||||
|
||||
/**
|
||||
* Dot product between two 3D Vectors
|
||||
*
|
||||
* @param(v1) vector one
|
||||
* @param(v2) vector two
|
||||
*
|
||||
* @return Dot product of Vectors
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
T operator* (const TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T>
|
||||
TIntVector3<T> operator+ (const TIntVector3<T>& 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<IntType T>
|
||||
TIntVector3<T> operator+ (const TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T>
|
||||
TIntVector3<T> operator- (const TIntVector3<T>& 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<IntType T>
|
||||
TIntVector3<T> operator- (const TIntVector3<T>& v1, const TIntVector3<T>& v2);
|
||||
|
||||
/**
|
||||
* Negates vector
|
||||
*
|
||||
* @param(v1) Vector to negate
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector3<T> operator- (TIntVector3<T>& 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<IntType T>
|
||||
inline bool operator== (const TIntVector3<T>& v1, const TIntVector3<T>& v2);
|
||||
|
||||
/**
|
||||
* Tests two 3D vectors for inequality.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @return True if inequal, false if not.
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
inline bool operator!= (const TIntVector3<T>& v1, const TIntVector3<T>& v2);
|
||||
|
||||
// ============================================== //
|
||||
// IntVector3 static function implementation //
|
||||
// ============================================== //
|
||||
|
||||
/**
|
||||
* Gets magnitude of vector
|
||||
*
|
||||
* @param(v1) Vector
|
||||
*
|
||||
* @return Magnitude of vector
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
inline Rt Magnitude(const TIntVector3<T>& v1);
|
||||
|
||||
/**
|
||||
* @see [FUNC]Magnitude
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
FORCEINLINE T Length(const TIntVector3<T>& v1) { return Magnitude(v1); };
|
||||
|
||||
/**
|
||||
* Gets square magnitude of vector
|
||||
*
|
||||
* @param(v1) Vector
|
||||
*
|
||||
* @return Square magnitude of vector
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
inline T SqrMagnitude(const TIntVector3<T>& v1);
|
||||
|
||||
/**
|
||||
* @see SqrMagnitude
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
FORCEINLINE T SqrLength(const TIntVector3<T>& v1) { return SqrMagnitude(v1); };
|
||||
|
||||
/**
|
||||
* Gets angle between two vectors
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @return Angle between vectors
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
Rt Angle(const TIntVector3<T>& v1, const TIntVector3<T>& v2);
|
||||
|
||||
/**
|
||||
* Dot product of two vectors
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @return Dot product of vectors
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
T DotP(const TIntVector3<T>& v1, const TIntVector3<T>& v2);
|
||||
|
||||
/**
|
||||
* Returns signs of components in vector: -1 / +1 / 0.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @return Vector with signs a components.
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector3<T> SignVector(const TIntVector3<T>& 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<IntType T>
|
||||
inline bool Equals(const TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T>
|
||||
TIntVector3<T> CrossPV(TIntVector3<T>& v1, const TIntVector3<T>& v2);
|
||||
|
||||
/**
|
||||
* Gets the componentwise max of both vectors.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @note result is stored in v1.
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector3<T> MaxV(TIntVector3<T>& v1, const TIntVector3<T>& v2);
|
||||
|
||||
/**
|
||||
* Gets the componentwise min of both vectors.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @note result is stored in v1.
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector3<T> MinV(TIntVector3<T>& v1, const TIntVector3<T>& v2);
|
||||
|
||||
/**
|
||||
* Gets reversed vector.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @note result is stored in v1.
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector3<T> NegateV(TIntVector3<T>& v1);
|
||||
|
||||
/**
|
||||
* Performes componentwise multiplication of two vectors.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @note result is stored in v1.
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector3<T> ScaleV(TIntVector3<T>& v1, const TIntVector3<T>& v2);
|
||||
|
||||
/**
|
||||
* Copies v1 vector
|
||||
*
|
||||
* @param(v1) Vector to copy to
|
||||
* @param(v2) Vector to copy
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector3<T> Set(TIntVector3<T>& v1, const TIntVector3<T>& v2);
|
||||
|
||||
/**
|
||||
* Sets vector.
|
||||
*
|
||||
* @param(v1) Vector to copy to
|
||||
* @param(x) X component
|
||||
* @param(y) Y component
|
||||
* @param(z) Z component
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector3<T> Set(TIntVector3<T>& v1, T x, T y, T z);
|
||||
|
||||
/**
|
||||
* Returns signs of components in vector: -1 / +1 / 0.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector3<T> SignVectorV(TIntVector3<T>& 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<IntType T>
|
||||
T ScalarTriple(const TIntVector3<T>& v1, const TIntVector3<T>& v2, const TIntVector3<T>& 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<IntType T>
|
||||
T CosineAngle(const TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T>
|
||||
TIntVector3<T> VectorTripleV(TIntVector3<T>& v1, const TIntVector3<T>& v2, const TIntVector3<T>& 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<IntType T>
|
||||
inline bool IsPerpendicular(const TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T>
|
||||
inline bool IsParallel(const TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T>
|
||||
inline bool IsCoincident(const TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T>
|
||||
inline bool IsNormalized(const TIntVector3<T>& 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<IntType T>
|
||||
inline bool IsCoplanar(const TIntVector3<T>& v1, const TIntVector3<T>& v2, const TIntVector3<T>& v3, T threshold = P_FLT_INAC);
|
||||
|
||||
|
||||
/**
|
||||
* Gets outer product of to vectors.
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*
|
||||
* @return Resulting matrix
|
||||
*/
|
||||
|
||||
//template<IntType T>
|
||||
//Matrix3<T> OuterProduct(const IntVector3<T>& a, const IntVector3<T>& b);
|
||||
|
||||
|
||||
// ================================================================ //
|
||||
// IntVector3 static function implementation with return values //
|
||||
// ================================================================ //
|
||||
|
||||
/**
|
||||
* Normalized vector
|
||||
*
|
||||
* @param(v1) vector to normalize
|
||||
*
|
||||
* @return Normalized vector
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> Normalize(const TIntVector3<T>& v1);
|
||||
|
||||
/**
|
||||
* Normalizes vector
|
||||
*
|
||||
* @param(v1) Vector
|
||||
*
|
||||
* @note Does not test for zero vector
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> UnsafeNormalize(const TIntVector3<T>& v1);
|
||||
|
||||
/**
|
||||
* Reflects a vector on a surface
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(normal) Normal of surface
|
||||
*
|
||||
* @return Reflected vector
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> Reflect(const TIntVector3<T>& v1, const TVector3<Rt>& normal);
|
||||
|
||||
|
||||
/**
|
||||
* Performes perspective divide on vector.
|
||||
*
|
||||
* @param(v1) vector to perspective divide
|
||||
*
|
||||
* @return Perspective divided vector
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> PerspectiveDivide(const TIntVector3<T>& v1);
|
||||
|
||||
/**
|
||||
* Gets cross product between two vectors.
|
||||
*
|
||||
* @param(v1) vector one
|
||||
* @param(v2) vector two
|
||||
*
|
||||
* @return Cross product of v1 and v2
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector3<T> CrossP(const TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> Lerp(const TIntVector3<T>& start, const TIntVector3<T>& 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<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> LerpUnclamped(const TIntVector3<T>& start, const TIntVector3<T>& 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<IntType T>
|
||||
TIntVector3<T> Max(const TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T>
|
||||
TIntVector3<T> Min(const TIntVector3<T>& v1, const TIntVector3<T>& v2);
|
||||
|
||||
/**
|
||||
* Gets reversed vector.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @note result is stored in v1.
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector3<T> Negate(const TIntVector3<T>& v1);
|
||||
|
||||
/**
|
||||
* Multiplies vector componentwise.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @return Vector with componentwise products
|
||||
*/
|
||||
|
||||
template<IntType T>
|
||||
TIntVector3<T> Scale(const TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> ClampMagnitude(const TIntVector3<T>& 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<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> BoundToCube(const TIntVector3<T> v1, T cubeRadius) {};
|
||||
|
||||
/**
|
||||
* Clamps vector into cube.
|
||||
*
|
||||
* @param(v1) Vector to clamp
|
||||
* @param(cubeRadius) Radius of the cube
|
||||
*
|
||||
* @result Vector clamped in cube.
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> ClampToCube(const TIntVector3<T> 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<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> ScaleToMagnitude(const TIntVector3<T>& v1, T magnitude);
|
||||
|
||||
/**
|
||||
* Clamps vector into cube.
|
||||
*
|
||||
* @param(v1) Vector
|
||||
*
|
||||
* @result Vector with inverted components.
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> CompInverse(const TIntVector3<T>& v1);
|
||||
|
||||
/**
|
||||
* Reflect by plane
|
||||
*
|
||||
* @param(v1) Vector to mirror
|
||||
* @param(plane) Plane to mirror on
|
||||
*
|
||||
* @return Mirrored vector
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
FORCEINLINE TVector3<Rt> ReflectFromPlane(const TIntVector3<T>& v1, const TPlane<Rt>& plane);
|
||||
|
||||
/**
|
||||
* Reflect by plane
|
||||
*
|
||||
* @param(v1) Vector to mirror
|
||||
* @param(plane) Normal of plane
|
||||
*
|
||||
* @return Mirrored vector
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
FORCEINLINE TVector3<Rt> ReflectFromPlane(const TIntVector3<T>& v1, const TVector3<Rt>& 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<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> RotateAroundAxis(const TIntVector3<T>& v1, const TVector3<Rt>& 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<IntType T>
|
||||
TIntVector3<T> VectorTriple(const TIntVector3<T>& v1, const TIntVector3<T>& v2, const TIntVector3<T>& v3);
|
||||
|
||||
/**
|
||||
* Projects vector v1 onto v2
|
||||
*
|
||||
* @param(v1) Vector to project
|
||||
* @param(v2) Vector to project on
|
||||
*
|
||||
* @return Projected vector
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> Project(const TIntVector3<T>& v1, const TIntVector3<T>& v2);
|
||||
|
||||
/**
|
||||
* Rejects vector v1 from v2
|
||||
*
|
||||
* @param(v1) Vector to reject
|
||||
* @param(v2) Vector to reject from
|
||||
*
|
||||
* @return Rejected vector
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> Reject(const TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T, RealType Rt = float>
|
||||
FORCEINLINE TVector3<Rt> ProjectOntoPlane(const TIntVector3<T>& v1, const TVector3<Rt>& normal);
|
||||
|
||||
/**
|
||||
* Projects vector onto plane
|
||||
*
|
||||
* @param(v1) Vector to reject
|
||||
* @param(normal) Plane
|
||||
*
|
||||
* @return Projected vector
|
||||
* @note Simply rejects the vector from normal
|
||||
*/
|
||||
|
||||
template<IntType T, RealType Rt = float>
|
||||
FORCEINLINE TVector3<Rt> ProjectOntoPlane(const TIntVector3<T>& v1, const TPlane<Rt>& 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<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> Slerp(const TIntVector3<T>& v1, const TIntVector3<T>& 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<IntType T, RealType Rt = float>
|
||||
TVector3<Rt> SlerpUnclamped(const TIntVector3<T>& v1, const TIntVector3<T>& v2, Rt t) {};
|
||||
|
||||
} // phanes::core::math::coretypes
|
||||
|
||||
#endif // !INTVECTOR3_H
|
||||
|
||||
@ -1,941 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Misc/BoilerplateHeader.h"
|
||||
#include PHANES_CORE_PCH_DEFAULT_PATH
|
||||
|
||||
#include "Math/MathCommon.h"
|
||||
#include "Math/MathAbstractTypes.h"
|
||||
#include "Math/MathFwd.h"
|
||||
|
||||
|
||||
#ifndef P_DEBUG
|
||||
#pragma warning(disable : 4244)
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef INTVECTOR4_H
|
||||
#define INTVECTOR4_H
|
||||
|
||||
namespace phanes::core::math::coretypes {
|
||||
|
||||
/**
|
||||
* A 4D Vector with components x, y, z and w with integer precision.
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
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<T>& v);
|
||||
|
||||
/**
|
||||
* Construct Vector from 3D Vector's xyz and zero.
|
||||
*
|
||||
* @param v 3D Vector to copy from
|
||||
*/
|
||||
|
||||
|
||||
PHANES_CORE_API IntVector4(const Vector3<T>& v);
|
||||
|
||||
/**
|
||||
* Construct Vector from 4D Vector's xyzw.
|
||||
*
|
||||
* @param v 4D Vector to copy from
|
||||
*/
|
||||
|
||||
PHANES_CORE_API IntVector4(const Vector4<T>& 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<T>& v);
|
||||
|
||||
/**
|
||||
* Construct Vector from 4D integer Vector's xyz and zero.
|
||||
*
|
||||
* @param v 4D IntVector to copy from
|
||||
*/
|
||||
|
||||
PHANES_CORE_API IntVector4(const IntVector3<T>& v);
|
||||
|
||||
/**
|
||||
* Construct Vector from 3D Point's xyzw.
|
||||
*
|
||||
* @param v 3D Point to copy from
|
||||
*/
|
||||
|
||||
PHANES_CORE_API IntVector4(const IntPoint4<T>& v);
|
||||
|
||||
|
||||
};
|
||||
|
||||
|
||||
// List of IntVector4 for DoP and ECS
|
||||
|
||||
// List of 4D Vectors using int
|
||||
using IntVector4List = std::vector <IntVector4<int>>;
|
||||
|
||||
|
||||
|
||||
// ======================== //
|
||||
// IntVector4 operators //
|
||||
// ======================== //
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Addition operation on same IntVector4 (this) by a integer value.
|
||||
*
|
||||
* @param a Vector to add to
|
||||
* @param s integer to add
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
INLINE PHANES_CORE_API void operator+= (IntVector4<T>& 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<typename T>
|
||||
INLINE PHANES_CORE_API void operator+= (IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Substraction operation on same IntVector4 (this) by a integer.
|
||||
*
|
||||
* @param a Vector to substract from
|
||||
* @param b integer to substract
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
INLINE PHANES_CORE_API void operator-= (IntVector4<T>& 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<typename T>
|
||||
INLINE PHANES_CORE_API void operator-= (IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Multiplication of IntVector4 (this) with a integer. (Scale)
|
||||
*
|
||||
* @param a Vector to multiply with
|
||||
* @param s integer to multiply with
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
INLINE PHANES_CORE_API void operator*= (IntVector4<T>& 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<typename T>
|
||||
INLINE PHANES_CORE_API void operator/= (IntVector4<T>& 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<typename T>
|
||||
INLINE PHANES_CORE_API void operator/= (IntVector4<T>& a, const IntVector4<T>& 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<typename T>
|
||||
INLINE PHANES_CORE_API IntVector4<T> operator* (const IntVector4<T>& 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<typename T>
|
||||
INLINE PHANES_CORE_API IntVector4<T> operator* (T s, const IntVector4<T>& a);
|
||||
|
||||
|
||||
/**
|
||||
* Dot product between two Vectors.
|
||||
*
|
||||
* @ref [FUNC]DotP
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*
|
||||
* @result Dot product
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
INLINE PHANES_CORE_API T operator* (const IntVector4<T>& a, const IntVector4<T>& 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<typename T>
|
||||
INLINE PHANES_CORE_API IntVector4<T> operator/ (const IntVector4<T>& 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<typename T>
|
||||
INLINE PHANES_CORE_API IntVector4<T> operator/ (T s, const IntVector4<T>& 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<typename T>
|
||||
INLINE PHANES_CORE_API IntVector4<T> operator/ (const IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Componentwise addition of Vector with integer.
|
||||
*
|
||||
* @param a Vector to add to
|
||||
* @param s integer to add
|
||||
*
|
||||
* @return Result Vector
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
INLINE PHANES_CORE_API IntVector4<T> operator+ (const IntVector4<T>& a, T s);
|
||||
|
||||
|
||||
/**
|
||||
* Componentwise addition of Vector with integer.
|
||||
*
|
||||
* @param a Vector to add to
|
||||
* @param s integer to add
|
||||
*
|
||||
* @return Result Vector
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
INLINE PHANES_CORE_API IntVector4<T> operator+ (const IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Componentwise substraction of Vector with integer.
|
||||
*
|
||||
* @param a Vector to substract from
|
||||
* @param s integer to substract
|
||||
*
|
||||
* @return Result Vector
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
INLINE PHANES_CORE_API IntVector4<T> operator- (const IntVector4<T>& a, T s);
|
||||
|
||||
/**
|
||||
* Componentwise substraction of Vector with Vector.
|
||||
*
|
||||
* @param a Vector to substract from
|
||||
* @param s integer to substract
|
||||
*
|
||||
* @return Result Vector
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
INLINE PHANES_CORE_API IntVector4<T> operator- (const IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Negate Vector.
|
||||
*
|
||||
* @param a Vector to negate
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
INLINE PHANES_CORE_API void operator- (IntVector4<T>& a);
|
||||
|
||||
|
||||
/**
|
||||
* Compare Vector for equality.
|
||||
*
|
||||
* @ref [FUNC]Equals
|
||||
*
|
||||
* @param a Vector to negate
|
||||
*
|
||||
* @return true if equal, false if inequal
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
INLINE PHANES_CORE_API bool operator== (const IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Compare Vector for inequality.
|
||||
*
|
||||
* @ref [FUNC]Equals
|
||||
*
|
||||
* @param a Vector to negate
|
||||
*
|
||||
* @return true if inequal, false if equal
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
INLINE PHANES_CORE_API bool operator!= (const IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
// ============================================== //
|
||||
// IntVector4 static function implementation //
|
||||
// ============================================== //
|
||||
|
||||
/**
|
||||
* Magnitude of Vector
|
||||
*
|
||||
* @param a Vector
|
||||
*
|
||||
* @return Size of Vector
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API T Magnitude(const IntVector4<T>& a);
|
||||
|
||||
|
||||
/**
|
||||
* Square of magnitude of Vector
|
||||
*
|
||||
* @param a Vector
|
||||
*
|
||||
* @return Magnitude without calculating square root
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API T SqrMagnitude(const IntVector4<T>& a);
|
||||
|
||||
|
||||
/**
|
||||
* Normalize Vector
|
||||
*
|
||||
* @param a Vector
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API void NormalizeV(IntVector4<T>& a);
|
||||
|
||||
|
||||
/**
|
||||
* Angle between to Vectors
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API T Angle(const IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Dot product of two Vectors
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API T DotP(const IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Creates Vector, with component wise largest values.
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*
|
||||
* @note Stores new Vector to a
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API void MaxV(IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Creates Vector, with component wise smallest values.
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*
|
||||
* @note Stores new Vector to a
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API void MinV(IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Gets perpendicular Vector to a.
|
||||
*
|
||||
* @reg NO_RETURN(ReversePerpendicular)
|
||||
*
|
||||
* @param a Vector one
|
||||
*
|
||||
* @note Stores new Vector to a
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API void PerpendicularV(IntVector4<T>& a);
|
||||
|
||||
|
||||
/**
|
||||
* Gets perpendicular Vector to a.
|
||||
*
|
||||
* @reg NO_RETURN(Perpendicular)
|
||||
*
|
||||
* @param a Vector one
|
||||
*
|
||||
* @note Stores new Vector to a
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API void ReversePerpendicularV(IntVector4<T>& a);
|
||||
|
||||
|
||||
/**
|
||||
* Component wise multiplication of Vector
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*
|
||||
* @note Stores new Vector to a
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API void ScaleV(IntVector4<T>& a, const IntVector4<T>& 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<typename T>
|
||||
PHANES_CORE_API void DivideTruncV(IntVector4<T>& a, const IntVector4<T>& 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<typename T>
|
||||
PHANES_CORE_API void DivideTruncV(IntVector4<T>& a, T s);
|
||||
|
||||
|
||||
/**
|
||||
* Componentwise inversion of Vector
|
||||
*
|
||||
* @param a Vector one
|
||||
*
|
||||
* @note Stores new Vector to a
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API void CompInverseV(IntVector4<T>& a);
|
||||
|
||||
|
||||
/**
|
||||
* Reflect Vector by normal vector.
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*
|
||||
* @note Stores new Vector to a
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API void ReflectV(IntVector4<T>& a, const IntVector4<T>& normal);
|
||||
|
||||
|
||||
/**
|
||||
* Copies one Vector two another
|
||||
*
|
||||
* @param a Vector to copy to
|
||||
* @param b Vector to copy
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API void Set(IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Sets components of a vector.
|
||||
*
|
||||
* @param a Vector to copy to
|
||||
* @param b Vector to copy
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API void Set(IntVector4<T>& 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<typename T>
|
||||
PHANES_CORE_API bool IsNormalized(const IntVector4<T>& 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<typename T>
|
||||
PHANES_CORE_API bool IsPerpendicular(const IntVector4<T>& a, const IntVector4<T>& 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<typename T>
|
||||
PHANES_CORE_API bool IsParallel(const IntVector4<T>& a, const IntVector4<T>& 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<typename T>
|
||||
PHANES_CORE_API bool IsCoincident(const IntVector4<T>& a, const IntVector4<T>& b, T threshold = P_FLT_INAC);
|
||||
|
||||
|
||||
/**
|
||||
* Gets outer product of to vectors.
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*
|
||||
* @return Resulting matrix
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API Matrix2<T> OuterProduct(const IntVector4<T>& a, const IntVector4<T>& 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<typename T>
|
||||
PHANES_CORE_API IntVector4<T> Reflect(const IntVector4<T>& a, const IntVector4<T>& normal);
|
||||
|
||||
|
||||
/**
|
||||
* Scales a vector component wise
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*
|
||||
* @return Reflected vector
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API IntVector4<T> Scale(const IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Component wise division of Vector
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*
|
||||
* @note Truncates result instead of rounding
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API IntVector4<T> DivideTrunc(const IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Component wise division of Vector
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*
|
||||
* @note Truncates result instead of rounding
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API IntVector4<T> DivideTrunc(const IntVector4<T>& a, T s);
|
||||
|
||||
|
||||
/**
|
||||
* Component wise division of Vector
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*
|
||||
* @return Floating point vector
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API Vector2<T> DivideFloat(const IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Component wise division of Vector
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*
|
||||
* @return Floating point vector
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API Vector2<T> DivideFloat(const IntVector4<T>& a, T s);
|
||||
|
||||
|
||||
/**
|
||||
* Componentwise inverse of Vector
|
||||
*
|
||||
* @param a Vector one
|
||||
* @param b Vector two
|
||||
*
|
||||
* @return Reflected vector
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API IntVector4<T> CompInverse(const IntVector4<T>& a);
|
||||
|
||||
|
||||
/**
|
||||
* Gets the perpendicular vector of a
|
||||
*
|
||||
* @param a Vector one
|
||||
*
|
||||
* @return Perpendicular vector
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API IntVector4<T> Perpendicular(const IntVector4<T>& a);
|
||||
|
||||
|
||||
/**
|
||||
* Gets reverse of the perpendicular vector of a
|
||||
*
|
||||
* @param a Vector one
|
||||
*
|
||||
* @return Reversed perpendicular vector
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API IntVector4<T> ReversePerpendicular(const IntVector4<T>& 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<typename T>
|
||||
PHANES_CORE_API IntVector4<T> Min(const IntVector4<T>& a, const IntVector4<T>& 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<typename T>
|
||||
PHANES_CORE_API IntVector4<T> Max(const IntVector4<T>& a, const IntVector4<T>& b);
|
||||
|
||||
|
||||
/**
|
||||
* Creates a normalized instance of the vector
|
||||
*
|
||||
* @param a Vector to normalize
|
||||
*
|
||||
* @return Unit vector
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
PHANES_CORE_API IntVector4<T> Normalize(const IntVector4<T>& 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<typename T>
|
||||
INLINE PHANES_CORE_API IntVector4<T> Lerp(const IntVector4<T>& a, const IntVector4<T>& 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<typename T>
|
||||
INLINE PHANES_CORE_API IntVector4<T> LerpUnclamped(const IntVector4<T>& a, const IntVector4<T>& 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<typename T>
|
||||
PHANES_CORE_API IntVector4<T> Slerp(const IntVector4<T>& a, const IntVector4<T>& 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<typename T>
|
||||
PHANES_CORE_API IntVector4<T> SlerpUnclamped(const IntVector4<T>& a, const IntVector4<T>& b, T t);
|
||||
|
||||
} // phanes::core::math::coretypes
|
||||
|
||||
#endif // !INTVECTOR3_H
|
||||
|
||||
@ -1,29 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#ifndef ABSTRACT_TYPES_H
|
||||
#define ABSTRACT_TYPES_H
|
||||
|
||||
namespace Phanes::Core::Math::Internal {
|
||||
|
||||
template <typename T, unsigned int D = 3>
|
||||
struct AVector {
|
||||
public:
|
||||
|
||||
/**
|
||||
* List of n components of the vector
|
||||
*/
|
||||
|
||||
T comp[D];
|
||||
|
||||
};
|
||||
|
||||
template <typename T, unsigned int n = 3, unsigned int m = 3>
|
||||
struct AMatrix {
|
||||
public:
|
||||
T fields[n][m];
|
||||
|
||||
};
|
||||
|
||||
}; // Phanes::Core::Math::abstract::coretypes
|
||||
|
||||
#endif // !ABSTRACT_TYPES_H
|
||||
@ -1,98 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#define P_FLT_INAC_LARGE 0.0001f // large float inaccuracy (1*10^-4);
|
||||
#define P_FLT_INAC 0.00001f // float inaccuracy (1*10^-5);
|
||||
#define P_FLT_INAC_SMALL 0.000001f // small float inaccuracy (1*10^-6);
|
||||
|
||||
#define P_180_PI 57.29577951308232 // (double) 180°/pi;
|
||||
#define P_180_PI_FLT 57.29577951308232f // (float) 180°/pi;
|
||||
|
||||
#define P_PI_180 0.0174532925199432 // double pi/180°
|
||||
#define P_PI_180_FLT 0.0174532925199432f // (float) pi/180°
|
||||
|
||||
#define P_PI 3.1415926535897932 // PI
|
||||
#define P_PI_FLT 3.1415926535897932f // PI
|
||||
|
||||
|
||||
#include "Core/Core.h"
|
||||
|
||||
#ifndef MATH_COMMON_H
|
||||
#define MATH_COMMON_H
|
||||
|
||||
namespace Phanes::Core::Math {
|
||||
|
||||
/**
|
||||
* Clamps a value between minimum and maximum
|
||||
*
|
||||
* @param value Value to clamp
|
||||
* @param low Minimum
|
||||
* @param high Maximum
|
||||
*
|
||||
* @return Minimum, if value is to small / Maximum, if value is to large / value, if value is in range.
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
T Clamp(T value, T low, T high);
|
||||
|
||||
|
||||
/**
|
||||
* Gets the larger of two values
|
||||
*
|
||||
* @param x
|
||||
* @param y
|
||||
*
|
||||
* @return Larger value
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
inline T Max(T x, T y);
|
||||
|
||||
|
||||
/**
|
||||
* Gets the smaller of two values
|
||||
*
|
||||
* @param x
|
||||
* @param y
|
||||
*
|
||||
* @return Smaller value
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
inline T Min(T x, T y);
|
||||
|
||||
/**
|
||||
* Swaps the values of two variables
|
||||
*
|
||||
* @param x
|
||||
* @param y
|
||||
*/
|
||||
|
||||
template<typename T>
|
||||
inline void Swap(T& x, T& y);
|
||||
|
||||
/**
|
||||
* Test two numbers for equality
|
||||
*
|
||||
* @param x
|
||||
*/
|
||||
template<typename T>
|
||||
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<typename T>
|
||||
float FastInvSqrt(T n);
|
||||
|
||||
|
||||
} // phanes
|
||||
|
||||
#endif // !MATH_COMMON_H
|
||||
@ -1,103 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Core/Core.h"
|
||||
|
||||
#include "Core/public/OSAL/PlatformTypes.h"
|
||||
|
||||
#ifndef MATH_FWD_H
|
||||
#define MATH_FWD_H
|
||||
|
||||
#include "Core/public/Misc/Boilerplate.h"
|
||||
|
||||
/**
|
||||
* Includes forward declarations, as well as certain useful typedefs.
|
||||
*
|
||||
* @ref OSAL/PlatformTypes.h
|
||||
*/
|
||||
|
||||
|
||||
namespace Phanes::Core::Math {
|
||||
|
||||
/**
|
||||
* Template forward declarations.
|
||||
*/
|
||||
|
||||
template<RealType T> struct TColor;
|
||||
template<RealType T> struct TLinearColor;
|
||||
template<RealType T> struct TVector2;
|
||||
template<RealType T> struct TVector3;
|
||||
template<RealType T> struct TVector4;
|
||||
template<RealType T> struct TRay;
|
||||
template<RealType T> struct TPlane;
|
||||
template<RealType T> struct TMatrix2;
|
||||
template<RealType T> struct TMatrix3;
|
||||
template<RealType T> struct TMatrix4;
|
||||
template<RealType T> struct TQuaternion;
|
||||
template<RealType T> struct TTransform;
|
||||
template<RealType T> struct TPoint2;
|
||||
template<RealType T> struct TPoint3;
|
||||
template<RealType T> struct TPoint4;
|
||||
template<IntType T> struct TIntVector2;
|
||||
template<IntType T> struct TIntVector3;
|
||||
template<IntType T> struct TIntVector4;
|
||||
template<IntType T> struct TIntPoint2;
|
||||
template<IntType T> struct TIntPoint3;
|
||||
template<IntType T> struct TIntPoint4;
|
||||
|
||||
/**
|
||||
* Specific instantiation of forward declarations.
|
||||
*/
|
||||
|
||||
// TVector2
|
||||
typedef TVector2<float> Vector2;
|
||||
typedef TVector2<double> Vector2d;
|
||||
|
||||
typedef std::vector<Vector2> Vector2List;
|
||||
typedef std::vector<Vector2d> Vector2Listd;
|
||||
|
||||
// TVector3
|
||||
typedef TVector3<float> Vector3;
|
||||
typedef TVector3<double> Vector3d;
|
||||
|
||||
typedef std::vector<Vector3> Vector3List;
|
||||
typedef std::vector<Vector3d> Vector3Listd;
|
||||
|
||||
|
||||
|
||||
// TIntVector2
|
||||
typedef TIntVector2<int> IntVector2;
|
||||
typedef TIntVector2<long> IntVector2l;
|
||||
|
||||
typedef std::vector<IntVector2> IntVector2List;
|
||||
typedef std::vector<IntVector2l> IntVector2Listl;
|
||||
|
||||
// TIntVector3
|
||||
typedef TIntVector3<int> IntVector3;
|
||||
typedef TIntVector3<long> IntVector3l;
|
||||
|
||||
typedef std::vector<IntVector3> IntVector3List;
|
||||
typedef std::vector<IntVector3l> IntVector3Listl;
|
||||
|
||||
|
||||
|
||||
// TMatrix2
|
||||
typedef TMatrix2<float> Matrix2;
|
||||
typedef TMatrix2<double> Matrix2d;
|
||||
|
||||
typedef std::vector<Matrix2> Matrix2List;
|
||||
typedef std::vector<Matrix2d> Matrix2Listd;
|
||||
|
||||
} // Phanes::Core::Math::coretypes
|
||||
|
||||
namespace Phanes::Core::Math::Internal
|
||||
{
|
||||
|
||||
// Internal types
|
||||
|
||||
template <typename T, unsigned int D> struct AVector;
|
||||
|
||||
template <typename T, unsigned int n, unsigned int> struct AMatrix;
|
||||
}
|
||||
|
||||
|
||||
#endif // !MATH_FWD_H
|
||||
@ -1,77 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
// ============================================= //
|
||||
// Function to convert types into each other //
|
||||
// //
|
||||
// @ref [FILE]MathUnitConversion //
|
||||
// ============================================= //
|
||||
|
||||
#include "PhanesEnginePCH.h"
|
||||
#include "Core/public/Misc/Boilerplate.h"
|
||||
|
||||
#include "Core/public/Math/MathAbstractTypes.h"
|
||||
#include "Core/public/Math/Vector2.h"
|
||||
#include "Core/public/Math/Vector3.h"
|
||||
//#include "Core/public/Math/Vector4.h"
|
||||
//#include "Core/public/Math/Matrix2.h"
|
||||
//#include "Core/public/Math/Matrix3.h"
|
||||
#include "Core/public/Math/IntVector2.h"
|
||||
#include "Core/public/Math/IntVector3.h"
|
||||
|
||||
#ifndef MATH_TYPE_CONVERSION_H
|
||||
#define MATH_TYPE_CONVERSION_H
|
||||
|
||||
|
||||
namespace Phanes::Core::Math {
|
||||
|
||||
// =================================================== //
|
||||
// std::to_string wrapper //
|
||||
// //
|
||||
// This is, to make using ToString more general //
|
||||
// and allow usage of one function instead of two, //
|
||||
// for converting a mathmatical type to a string. //
|
||||
// =================================================== //
|
||||
|
||||
FORCEINLINE std::string ToString(long long val) { return std::to_string(val); };
|
||||
|
||||
FORCEINLINE std::string ToString(double val) { return std::to_string(val); };
|
||||
|
||||
FORCEINLINE std::string ToString(float val) { return std::to_string(val); };
|
||||
|
||||
FORCEINLINE std::string ToString(int val) { return std::to_string(val); };
|
||||
|
||||
FORCEINLINE std::string ToString(long val) { return std::to_string(val); };
|
||||
|
||||
FORCEINLINE std::string ToString(long double val) { return std::to_string(val); };
|
||||
|
||||
FORCEINLINE std::string ToString(unsigned long long val) { return std::to_string(val); };
|
||||
|
||||
FORCEINLINE std::string ToString(unsigned int val) { return std::to_string(val); };
|
||||
|
||||
FORCEINLINE std::string ToString(unsigned long val) { return std::to_string(val); };
|
||||
|
||||
// ============ //
|
||||
// ToString //
|
||||
// ============ //
|
||||
|
||||
template<RealType T>
|
||||
std::string ToString(const TVector2<T>& v);
|
||||
|
||||
template<IntType T>
|
||||
std::string ToString(const TIntVector2<T>& v);
|
||||
|
||||
template<RealType T>
|
||||
std::string ToString(const TVector3<T>& v);
|
||||
|
||||
template<IntType T>
|
||||
std::string ToString(const TIntVector3<T>& v);
|
||||
|
||||
//std::string toString(const Vector4& v);
|
||||
|
||||
//std::string toString(const Matrix2& v);
|
||||
|
||||
//std::string toString(const Matrix3& v);
|
||||
|
||||
}
|
||||
|
||||
#endif // !MATH_TYPE_CONVERSION_H
|
||||
@ -1,121 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
// ======================================= //
|
||||
// Contains functions to convert units //
|
||||
// ======================================= //
|
||||
|
||||
#include "Core/public/Misc/Boilerplate.h"
|
||||
|
||||
#include "Core/public/Math/MathCommon.h"
|
||||
|
||||
namespace Phanes::Core::Math::UnitConversion
|
||||
{
|
||||
|
||||
/**
|
||||
* Converts degrees to radians.
|
||||
*
|
||||
* @param(deg) Angle in degress (°)
|
||||
*
|
||||
* @return Angle in radians
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
inline T DegToRad(T deg);
|
||||
|
||||
/**
|
||||
* Converts radians to degrees.
|
||||
*
|
||||
* @param(rad) Angle in radians (rad)
|
||||
*
|
||||
* @return Angle in degrees
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
inline T RadToDeg(T rad);
|
||||
|
||||
/**
|
||||
* Converts degrees to gradian.
|
||||
*
|
||||
* @param(deg) Angle in degress (°)
|
||||
*
|
||||
* @return Angle in gradian
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
inline T DegToGradian(T deg);
|
||||
|
||||
/**
|
||||
* Converts gradian to degrees.
|
||||
*
|
||||
* @param(rad) Angle in gradians (g)
|
||||
*
|
||||
* @return Angle in degrees
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
inline T GradianToDeg(T g);
|
||||
|
||||
/**
|
||||
* Converts radians to gradians.
|
||||
*
|
||||
* @param(deg) Angle in radians (rad)
|
||||
*
|
||||
* @return Angle in gradians
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
inline T RadToGradian(T rad);
|
||||
|
||||
/**
|
||||
* Converts gradian to radians.
|
||||
*
|
||||
* @param(rad) Angle in gradians (g)
|
||||
*
|
||||
* @return Angle in radians
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
inline T GradianToRad(T g);
|
||||
|
||||
} // phanes::core::math::typeconversion
|
||||
|
||||
|
||||
namespace Phanes::Core::Math::UnitLiterals
|
||||
{
|
||||
// ============================================== //
|
||||
// unit conversion with user-defined literals //
|
||||
// ============================================== //
|
||||
|
||||
/**
|
||||
* Convert deg to rad.
|
||||
*
|
||||
* @param(_x) Angle in degress
|
||||
*/
|
||||
|
||||
double operator ""_deg(long double _x)
|
||||
{
|
||||
return _x * P_PI_180_FLT;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert rad to rad.
|
||||
*
|
||||
* @param(_x) Angle in degress
|
||||
*/
|
||||
|
||||
double operator ""_rad(long double _x)
|
||||
{
|
||||
return _x;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert gradian to rad.
|
||||
*
|
||||
* @param(_x) Angle in degress
|
||||
*/
|
||||
|
||||
double operator ""_g(long double _x)
|
||||
{
|
||||
return _x * P_PI_FLT / 200;
|
||||
}
|
||||
}
|
||||
@ -1,154 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Core/Core.h"
|
||||
#include "Core/public/Misc/Boilerplate.h"
|
||||
|
||||
#include "Core/public/Math/Vector2.h"
|
||||
|
||||
#ifndef MATRIX2_H
|
||||
#define MATRIX2_H
|
||||
|
||||
namespace Phanes::Core::Math {
|
||||
|
||||
// 2x2 Matrix defined in column-major order.
|
||||
// Accessed by M[Row][Col].
|
||||
|
||||
template<RealType T>
|
||||
struct alignas(4) TMatrix2
|
||||
{
|
||||
public:
|
||||
|
||||
alignas(4) T m[2][2];
|
||||
|
||||
public:
|
||||
|
||||
TMatrix2() = default;
|
||||
|
||||
/**
|
||||
* Copy constructor.
|
||||
*/
|
||||
|
||||
TMatrix2(const TMatrix2<T>& m);
|
||||
|
||||
/**
|
||||
* Move constructor.
|
||||
*/
|
||||
|
||||
TMatrix2(TMatrix2<T>&& 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<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
public:
|
||||
|
||||
FORCEINLINE T& operator() (int n, int m);
|
||||
FORCEINLINE TVector2<T>& operator[] (int m);
|
||||
|
||||
FORCEINLINE const T& operator() (int n, int m) const;
|
||||
FORCEINLINE const TVector2<T>& operator[] (int m) const;
|
||||
};
|
||||
|
||||
// ==================== //
|
||||
// Matrix2 operator //
|
||||
// ==================== //
|
||||
|
||||
template<RealType T>
|
||||
void operator+= (TMatrix2<T>& m1, T s);
|
||||
|
||||
template<RealType T>
|
||||
void operator+= (TMatrix2<T>& m1, const TMatrix2<T>& m2);
|
||||
|
||||
template<RealType T>
|
||||
void operator-= (TMatrix2<T>& m1, T s);
|
||||
|
||||
template<RealType T>
|
||||
void operator-= (TMatrix2<T>& m1, const TMatrix2<T>& m2);
|
||||
|
||||
template<RealType T>
|
||||
void operator*= (TMatrix2<T>& m1, T s);
|
||||
|
||||
template<RealType T>
|
||||
void operator*= (TMatrix2<T>& m1, const TMatrix2<T>& m2);
|
||||
|
||||
template<RealType T>
|
||||
TMatrix2<T> operator+ (const TMatrix2<T>& m1, T s);
|
||||
|
||||
template<RealType T>
|
||||
TMatrix2<T> operator+ (const TMatrix2<T>& m1, const TMatrix2<T>& m2);
|
||||
|
||||
template<RealType T>
|
||||
TMatrix2<T> operator- (const TMatrix2<T>& m1, T s);
|
||||
|
||||
template<RealType T>
|
||||
TMatrix2<T> operator- (const TMatrix2<T>& m1, const TMatrix2<T>& m2);
|
||||
|
||||
template<RealType T>
|
||||
TMatrix2<T> operator* (const TMatrix2<T>& m1, T s);
|
||||
|
||||
template<RealType T>
|
||||
TMatrix2<T> operator* (const TMatrix2<T>& m1, const TMatrix2<T>& m2);
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> operator* (const TMatrix2<T>& m1, const TVector2<T>& v);
|
||||
|
||||
template<RealType T>
|
||||
bool operator== (const TMatrix2<T>& m1, const TMatrix2<T>& m2);
|
||||
|
||||
|
||||
// =============================== //
|
||||
// Matrix function definition //
|
||||
// =============================== //
|
||||
|
||||
template<RealType T>
|
||||
T Determinant(const Matrix2& m1);
|
||||
|
||||
template<RealType T>
|
||||
void InverseV(TMatrix2<T>& m1);
|
||||
|
||||
template<RealType T>
|
||||
void TransposeV(TMatrix2<T>& m1);
|
||||
|
||||
// =============== //
|
||||
// WITH RETURN //
|
||||
// =============== //
|
||||
|
||||
template<RealType T>
|
||||
TMatrix2<T> Inverse(TMatrix2<T>& m1);
|
||||
|
||||
template<RealType T>
|
||||
TMatrix2<T> Transpose(const TMatrix2<T>& m1);
|
||||
|
||||
template<RealType T>
|
||||
bool IsIndentityMatrix(const TMatrix2<T>& m1, T threshold = P_FLT_INAC);
|
||||
|
||||
} // Phanes::Core::Math
|
||||
|
||||
|
||||
#endif // !MATRIX2_H
|
||||
@ -1,105 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Misc/BoilerplateHeader.h"
|
||||
#include PHANES_CORE_PCH_DEFAULT_PATH
|
||||
|
||||
#include "Math/MathAbstractTypes.h"
|
||||
#include "Math/Vector3.h"
|
||||
|
||||
#ifndef MATRIX3_H
|
||||
#define MATRIX3_H
|
||||
|
||||
namespace phanes {
|
||||
|
||||
namespace core {
|
||||
|
||||
namespace math {
|
||||
|
||||
namespace coretypes {
|
||||
|
||||
// 3x3 Matrix defined in column-major order.
|
||||
|
||||
struct Matrix3 : public phanes::core::math::abstract::coretypes::AMatrix<float, 3, 3>
|
||||
{
|
||||
public:
|
||||
|
||||
FORCEINLINE PHANES_CORE_API float& operator() (int n, int m);
|
||||
FORCEINLINE PHANES_CORE_API Vector3& operator[] (int m);
|
||||
|
||||
FORCEINLINE PHANES_CORE_API const float& operator() (int n, int m) const;
|
||||
FORCEINLINE PHANES_CORE_API const Vector3& operator[] (int m) const;
|
||||
|
||||
};
|
||||
|
||||
// List of Matrices for DoP and ECS
|
||||
typedef std::vector<Matrix3> Matrix3List;
|
||||
|
||||
// Matrix3 constructor
|
||||
PHANES_CORE_API Matrix3 createMatrix(float fields[3][3]);
|
||||
|
||||
PHANES_CORE_API Matrix3 createMatrix(float f00, float f01, float f02,
|
||||
float f10, float f11, float f12,
|
||||
float f20, float f21, float f22);
|
||||
|
||||
PHANES_CORE_API Matrix3 createMatrix(const Vector3& a, const Vector3& b, const Vector3& c);
|
||||
|
||||
|
||||
// ==================== //
|
||||
// Matrix3 operator //
|
||||
// ==================== //
|
||||
|
||||
PHANES_CORE_API void operator+= (Matrix3& a, float s);
|
||||
PHANES_CORE_API void operator+= (Matrix3& a, const Matrix3& b);
|
||||
|
||||
PHANES_CORE_API void operator-= (Matrix3& a, float s);
|
||||
PHANES_CORE_API void operator-= (Matrix3& a, const Matrix3& b);
|
||||
|
||||
PHANES_CORE_API void operator*= (Matrix3& a, float s);
|
||||
PHANES_CORE_API void operator*= (Matrix3& a, const Matrix3& b);
|
||||
|
||||
PHANES_CORE_API Matrix3 operator+ (const Matrix3& a, float s);
|
||||
PHANES_CORE_API Matrix3 operator+ (const Matrix3& a, const Matrix3& b);
|
||||
|
||||
PHANES_CORE_API Matrix3 operator- (const Matrix3& a, float s);
|
||||
PHANES_CORE_API Matrix3 operator- (const Matrix3& a, const Matrix3& b);
|
||||
|
||||
PHANES_CORE_API Matrix3 operator* (const Matrix3& a, float s);
|
||||
PHANES_CORE_API Matrix3 operator* (const Matrix3& a, const Matrix3& b);
|
||||
PHANES_CORE_API Vector3 operator* (const Matrix3& a, const Vector3& v);
|
||||
|
||||
PHANES_CORE_API bool operator== (const Matrix3& a, const Matrix3& b);
|
||||
|
||||
|
||||
|
||||
// =============================== //
|
||||
// Matrix function definition //
|
||||
// =============================== //
|
||||
|
||||
PHANES_CORE_API float determinant(const Matrix3& a);
|
||||
|
||||
|
||||
PHANES_CORE_API void inverseNR(Matrix3& a);
|
||||
|
||||
PHANES_CORE_API void transposeNR(Matrix3& a);
|
||||
|
||||
|
||||
// =============== //
|
||||
// WITH RETURN //
|
||||
// =============== //
|
||||
|
||||
PHANES_CORE_API Matrix3 inverse(Matrix3& a);
|
||||
|
||||
PHANES_CORE_API Matrix3 transpose(const Matrix3& a);
|
||||
|
||||
PHANES_CORE_API bool isIndentityMatrix(const Matrix3& a);
|
||||
|
||||
} // phanes::core::math::coretypes
|
||||
|
||||
} // phanes::core::math
|
||||
|
||||
} // phanes::core
|
||||
|
||||
} // phanes
|
||||
|
||||
|
||||
#endif // !MATRIX3_H
|
||||
@ -1,103 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Misc/BoilerplateHeader.h"
|
||||
#include PHANES_CORE_PCH_DEFAULT_PATH
|
||||
|
||||
#include "Math/MathAbstractTypes.h"
|
||||
#include "Math/Vector4.h"
|
||||
|
||||
#ifndef MATRIX4_H
|
||||
#define MATRIX4_H
|
||||
|
||||
namespace phanes {
|
||||
|
||||
namespace core {
|
||||
|
||||
namespace math {
|
||||
|
||||
namespace coretypes {
|
||||
|
||||
// 4x4 Matrix defined in column-major order.
|
||||
|
||||
struct Matrix4 : public phanes::core::math::abstract::coretypes::AMatrix<float, 4, 4>
|
||||
{
|
||||
public:
|
||||
|
||||
FORCEINLINE PHANES_CORE_API float& operator() (int n, int m);
|
||||
FORCEINLINE PHANES_CORE_API Vector4& operator[] (int m);
|
||||
|
||||
FORCEINLINE PHANES_CORE_API const float& operator() (int n, int m) const;
|
||||
FORCEINLINE PHANES_CORE_API const Vector4& operator[] (int m) const;
|
||||
};
|
||||
|
||||
// List of Matrices for DoP and ECS
|
||||
typedef std::vector<Matrix4> Matrix4List;
|
||||
|
||||
// Matrix4 constructor
|
||||
PHANES_CORE_API Matrix4 createMatrix(float fields[4][4]);
|
||||
|
||||
PHANES_CORE_API Matrix4 createMatrix(float f00, float f01, float f02, float f03,
|
||||
float f10, float f11, float f12, float f13,
|
||||
float f20, float f21, float f22, float f23,
|
||||
float f30, float f31, float f32, float f33
|
||||
);
|
||||
|
||||
PHANES_CORE_API Matrix4 createMatrix(const Vector4& a, const Vector4& b, const Vector4& c, const Vector4& d);
|
||||
|
||||
// ==================== //
|
||||
// Matrix4 operator //
|
||||
// ==================== //
|
||||
|
||||
PHANES_CORE_API void operator+= (Matrix4& a, float s);
|
||||
PHANES_CORE_API void operator+= (Matrix4& a, const Matrix4& b);
|
||||
|
||||
PHANES_CORE_API void operator-= (Matrix4& a, float s);
|
||||
PHANES_CORE_API void operator-= (Matrix4& a, const Matrix4& b);
|
||||
|
||||
PHANES_CORE_API void operator*= (Matrix4& a, float s);
|
||||
PHANES_CORE_API void operator*= (Matrix4& a, const Matrix4& b);
|
||||
|
||||
PHANES_CORE_API Matrix4 operator+ (const Matrix4& a, float s);
|
||||
PHANES_CORE_API Matrix4 operator+ (const Matrix4& a, const Matrix4& b);
|
||||
|
||||
PHANES_CORE_API Matrix4 operator- (const Matrix4& a, float s);
|
||||
PHANES_CORE_API Matrix4 operator- (const Matrix4& a, const Matrix4& b);
|
||||
|
||||
PHANES_CORE_API Matrix4 operator* (const Matrix4& a, float s);
|
||||
PHANES_CORE_API Matrix4 operator* (const Matrix4& a, const Matrix4& b);
|
||||
PHANES_CORE_API Vector4 operator* (const Matrix4& a, const Vector4& v);
|
||||
|
||||
PHANES_CORE_API bool operator== (const Matrix4& a, const Matrix4& b);
|
||||
|
||||
|
||||
// ================================ //
|
||||
// Matrix4 function definition //
|
||||
// ================================ //
|
||||
|
||||
PHANES_CORE_API float determinant(const Matrix4& a);
|
||||
|
||||
PHANES_CORE_API void inverseNR(Matrix4& a);
|
||||
|
||||
PHANES_CORE_API void transposeNR(Matrix4& a);
|
||||
|
||||
// =============== //
|
||||
// WITH RETURN //
|
||||
// =============== //
|
||||
|
||||
PHANES_CORE_API Matrix4 inverse(Matrix4& a);
|
||||
|
||||
PHANES_CORE_API Matrix4 transpose(const Matrix4& a);
|
||||
|
||||
PHANES_CORE_API bool isIndentityMatrix(const Matrix4& a);
|
||||
|
||||
|
||||
} // phanes::core::math::coretypes
|
||||
|
||||
} // phanes::core::math
|
||||
|
||||
} // phanes::core
|
||||
|
||||
} // phanes
|
||||
|
||||
|
||||
#endif // !MATRIX4_H
|
||||
@ -1,23 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Core/public/Misc/Boilerplate.h"
|
||||
|
||||
#include "Core/public/Math/Vector3.h"
|
||||
|
||||
#include "Core/public/Math/MathFwd.h"
|
||||
|
||||
namespace Phanes::Core::Math {
|
||||
|
||||
// Plane in 3D space, defined as: P: ax + by + cz = d;
|
||||
|
||||
template<RealType T>
|
||||
struct TPlane
|
||||
{
|
||||
public:
|
||||
TVector3<T> normal;
|
||||
T d;
|
||||
};
|
||||
|
||||
} // Phanes::Core::Math
|
||||
|
||||
|
||||
@ -1,184 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Core/public/Misc/Boilerplate.h"
|
||||
|
||||
#include "Core/public/Math/MathCommon.h"
|
||||
#include "Core/public/Math/MathAbstractTypes.h"
|
||||
#include "Core/public/Math/MathFwd.h"
|
||||
|
||||
#ifndef P_DEBUG
|
||||
#pragma warning(disable : 4244)
|
||||
#endif
|
||||
|
||||
/**
|
||||
* The Point is the same as a vector. The type exists, to ensure
|
||||
* differentiation between the two types.
|
||||
*/
|
||||
|
||||
#ifndef POINT_H
|
||||
#define POINT_H
|
||||
|
||||
namespace Phanes::Core::Math {
|
||||
|
||||
/**
|
||||
* A 2D Point with components x and y with float precision.
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
struct TPoint2 : public TVector2<T> {
|
||||
static_assert(std::is_floating_point_v<T>, "T must be a floating point");
|
||||
|
||||
using TVector2<T>::TVector2;
|
||||
|
||||
using Real = T;
|
||||
|
||||
/**
|
||||
* Creates Point2 from Point3's xy
|
||||
*
|
||||
* @param a Point3 one
|
||||
*/
|
||||
|
||||
TPoint2(const TPoint3<T>& p)
|
||||
{
|
||||
this->x = p.x;
|
||||
this->y = p.y;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates Point2 from Point4's xy
|
||||
*
|
||||
* @param a Point4 one
|
||||
*/
|
||||
|
||||
TPoint2(const TPoint4<T>& 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<RealType T>
|
||||
T Distance(const TPoint2<T>& p1, const TPoint2<T>& p2);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* A 3D Point with components x and y with float precision.
|
||||
*/
|
||||
|
||||
|
||||
template<RealType T>
|
||||
struct TPoint3 : public TVector3<T> {
|
||||
static_assert(std::is_floating_point_v(T), "T must be a floating point");
|
||||
|
||||
using TVector3<T>::TVector3;
|
||||
|
||||
using Real = T;
|
||||
|
||||
/**
|
||||
* Creates Point3 from Point2's xy and zero
|
||||
*
|
||||
* @param a Point2 one
|
||||
*/
|
||||
|
||||
TPoint3(const TPoint2<T>& 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<T>& 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<RealType T>
|
||||
T Distance(const TPoint3<T>& p1, const TPoint3<T>& p2);
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
/**
|
||||
* A 4D Point with components x and y with float precision.
|
||||
*/
|
||||
|
||||
|
||||
//template<RealType T>
|
||||
//struct TPoint4 : public TVector4<T> {
|
||||
// static_assert(std::is_floating_point_v(T), "T must be a floating point");
|
||||
|
||||
// using TVector4<T>::TVector4;
|
||||
|
||||
// /**
|
||||
// * Creates Point4 from Point2's xy and the last two zero
|
||||
// *
|
||||
// * @param a Point2 one
|
||||
// */
|
||||
|
||||
// TPoint4(const TPoint2<T>& 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<T>& 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<RealType T>
|
||||
//T Distance(const TPoint4<T>& p1, const TPoint4<T>& p2);
|
||||
|
||||
} // phanes::core::math::coretypes
|
||||
|
||||
#endif // !POINT_H
|
||||
@ -1,12 +0,0 @@
|
||||
# PhanesCore
|
||||
|
||||
## Math
|
||||
|
||||
### Description
|
||||
|
||||
Math lib.
|
||||
|
||||
|
||||
### Notes
|
||||
|
||||
- Normals are called normals for a reason.
|
||||
@ -1,934 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "Core/Core.h"
|
||||
#include "Core/public/Misc/Boilerplate.h"
|
||||
|
||||
#include "Core/public/Math/MathCommon.h"
|
||||
#include "Core/public/Math/MathAbstractTypes.h"
|
||||
#include "Core/public/Math/MathFwd.h"
|
||||
|
||||
#ifndef P_DEBUG
|
||||
#pragma warning(disable : 4244)
|
||||
#endif
|
||||
|
||||
#ifndef VECTOR2_H
|
||||
#define VECTOR2_H
|
||||
|
||||
#define PZeroVector2(type) TVector2<##type>(0,0)
|
||||
#define PVectorSouth2(type) TVector2<##type>(0,-1)
|
||||
#define PVectorNorth2(type) TVector2<##type>(0,1)
|
||||
#define PVectorEast2(type) TVector2<##type>(1,0)
|
||||
#define PVectorWest2(type) TVector2<##type>(-1,0)
|
||||
|
||||
|
||||
namespace Phanes::Core::Math {
|
||||
|
||||
/**
|
||||
* A 2D Vector with components x and y with floating point precision.
|
||||
*/
|
||||
|
||||
|
||||
template<RealType T>
|
||||
struct TVector2 {
|
||||
|
||||
public:
|
||||
|
||||
using Real = T;
|
||||
|
||||
// Using in combination with a struct and an array allows us the reflect changes of the x and y variables in the comp array and vise versa.
|
||||
|
||||
union
|
||||
{
|
||||
|
||||
struct
|
||||
{
|
||||
/** X component of Vector
|
||||
*
|
||||
* @see [FIELD]components
|
||||
* @note x does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience.
|
||||
*/
|
||||
Real x;
|
||||
|
||||
/** Y component of Vector
|
||||
*
|
||||
* @see [FIELD]components
|
||||
*
|
||||
* @note y does not hold the component, but is a reference two the second item in the components array. The varibale exists wholly for convenience.
|
||||
*/
|
||||
Real y;
|
||||
};
|
||||
|
||||
/** Components array holding the data
|
||||
*
|
||||
* @see [FIELD]x
|
||||
* @see [FIELD]y
|
||||
*
|
||||
* @note Components are split into x and y. Access and manipulation is possible by these variables.
|
||||
*/
|
||||
|
||||
Real comp[2];
|
||||
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
public:
|
||||
|
||||
/**
|
||||
* Default constructor without initialization
|
||||
*/
|
||||
|
||||
TVector2() = default;
|
||||
|
||||
/**
|
||||
* Copy constructor
|
||||
*/
|
||||
|
||||
TVector2(const TVector2<Real>& v);
|
||||
|
||||
/**
|
||||
* Move constructor
|
||||
*/
|
||||
|
||||
TVector2(TVector2<Real>&& v);
|
||||
|
||||
/**
|
||||
* Convert other type of vector
|
||||
*/
|
||||
|
||||
template<RealType FloatType>
|
||||
explicit TVector2(const TVector2<FloatType>& v) : x((T)v.x), y((T)v.y) {};
|
||||
|
||||
|
||||
template<IntType OtherIntType>
|
||||
explicit TVector2(const TIntVector2<OtherIntType>& 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<Real>& start, const TPoint2<Real>& end);
|
||||
|
||||
/**
|
||||
* Construct Vector from 3D Vector's xy.
|
||||
*
|
||||
* @param(v) 3D Vector to copy from
|
||||
*/
|
||||
|
||||
explicit TVector2(const TVector3<Real>& v);
|
||||
|
||||
/**
|
||||
* Construct Vector from 4D Vector's xy.
|
||||
*
|
||||
* @param(v) 4D Vector to copy from
|
||||
*/
|
||||
|
||||
//TVector2(const TVector4<Real>& v);
|
||||
|
||||
/**
|
||||
* Construct Vector from 2D integer Vector's xy.
|
||||
*
|
||||
* @param(v) 2D IntVector to copy from
|
||||
*/
|
||||
|
||||
//TVector2(const TIntVector2<Real>& v);
|
||||
|
||||
/**
|
||||
* Construct Vector from 3D integer Vector's xy.
|
||||
*
|
||||
* @param(v) 3D IntVector to copy from
|
||||
*/
|
||||
|
||||
//TVector2(const TIntVector3<Real>& v);
|
||||
|
||||
/**
|
||||
* Construct Vector from 4D integer Vector's xy.
|
||||
*
|
||||
* @param(v) 4D IntVector to copy from
|
||||
*/
|
||||
|
||||
//TVector2(const TIntVector4<Real>& v);
|
||||
|
||||
/**
|
||||
* Construct Vector from 2D Point's xy.
|
||||
*
|
||||
* @param(v) 2D Point to copy from
|
||||
*/
|
||||
|
||||
//TVector2(const TPoint2<Real>& v);
|
||||
|
||||
|
||||
};
|
||||
|
||||
// ====================== //
|
||||
// TVector2 operators //
|
||||
// ====================== //
|
||||
|
||||
/**
|
||||
* Addition operation on same TVector2<T> (this) by a floating point value.
|
||||
*
|
||||
* @param(v1) Vector to add to
|
||||
* @param(s) Floating point to add
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> operator+= (TVector2<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Addition operation on same TVector2<T> (this) by a another TVector2<T>.
|
||||
*
|
||||
* @param(v1) Vector to add to
|
||||
* @param(v2) Vector to add
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> operator+= (TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Substraction operation on same TVector2<T> (this) by a floating point.
|
||||
*
|
||||
* @param(v1) Vector to substract from
|
||||
* @param(v2) Floating point to substract
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> operator-= (TVector2<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Substraction operation on same TVector2<T> (this) by a another TVector2<T>.
|
||||
*
|
||||
* @param(v1) Vector to substract from
|
||||
* @param(v2) Vector to substract
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> operator-= (TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Multiplication of TVector2<T> (this) with a floating point.
|
||||
*
|
||||
* @param(v1) Vector to multiply with
|
||||
* @param(s Floating point to multiply with
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> operator*= (TVector2<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Devision of Vector (this) by floating point.
|
||||
*
|
||||
* @param(v1) Vector to divide with
|
||||
* @param(s Floating point to divide with
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> operator/= (TVector2<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Scale of Vector by floating point. (> Creates a new TVector2<T>)
|
||||
*
|
||||
* @param(v1) Vector to multiply with
|
||||
* @param(s Floating point to multiply with
|
||||
*
|
||||
* @return Result Vector
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> operator* (const TVector2<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Division of Vector by floating point. (> Creates another TVector2<T>)
|
||||
*
|
||||
* @param(v1) Vector to multiply with
|
||||
* @param(s Floating point to divide with
|
||||
*
|
||||
* @return Result Vector
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> operator/ (const TVector2<T>& v1, T s);
|
||||
|
||||
/**
|
||||
* Scale of Vector by floating point. (> Creates a new TVector2<T>)
|
||||
*
|
||||
* @param(v1) Vector to multiply with
|
||||
* @param(s Floating point to multiply with
|
||||
*
|
||||
* @return Result Vector
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
inline TVector2<T> operator* (T s, const TVector2<T>& 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<RealType T>
|
||||
inline TVector2<T> operator/ (T s, const TVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Dot product between two Vectors.
|
||||
*
|
||||
* @see [FUNC]DotP
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @result Dot product
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
T operator* (const TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Componentwise addition of Vector with floating point.
|
||||
*
|
||||
* @param(v1) Vector to add to
|
||||
* @param(s Floating point to add
|
||||
*
|
||||
* @return Result Vector
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> operator+ (const TVector2<T>& 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<RealType T>
|
||||
TVector2<T> operator+ (const TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Componentwise substraction of Vector with floating point.
|
||||
*
|
||||
* @param(v1) Vector to substract from
|
||||
* @param(s Floating point to substract
|
||||
*
|
||||
* @return Result Vector
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> operator- (const TVector2<T>& 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<RealType T>
|
||||
TVector2<T> operator- (const TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Negate Vector.
|
||||
*
|
||||
* @param(v1) Vector to negate
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
void operator- (TVector2<T>& v1);
|
||||
|
||||
|
||||
/**
|
||||
* Compare Vector for equality.
|
||||
*
|
||||
* @see [FUNC]Equals
|
||||
*
|
||||
* @param(v1) Vector to negate
|
||||
*
|
||||
* @return true if equal, false if inequal
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
bool operator== (const TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
|
||||
/**
|
||||
* Compare Vector for inequality.
|
||||
*
|
||||
* @see [FUNC]Equals
|
||||
*
|
||||
* @param(v1) Vector to negate
|
||||
*
|
||||
* @return true if inequal, false if equal
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
bool operator!= (const TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
|
||||
// ============================================ //
|
||||
// TVector2 static function implementation //
|
||||
// ============================================ //
|
||||
|
||||
/**
|
||||
* Magnitude of Vector
|
||||
*
|
||||
* @param(v1) Vector
|
||||
*
|
||||
* @return Size of Vector
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
T Magnitude(const TVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* @see [FUNC]Magnitude
|
||||
*/
|
||||
template<RealType T>
|
||||
FORCEINLINE T Length(const TVector2<T>& v1) { return Magnitude(v1); };
|
||||
|
||||
/**
|
||||
* Square of magnitude of Vector
|
||||
*
|
||||
* @param(v1) Vector
|
||||
*
|
||||
* @return Magnitude without calculating square root
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
T SqrMagnitude(const TVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* @see [FUNC]SqrMagnitude
|
||||
*/
|
||||
template<RealType T>
|
||||
FORCEINLINE T SqrLength(const TVector2<T>& v1) { return SqrMagnitude(v1); };
|
||||
|
||||
/**
|
||||
* Normalize Vector
|
||||
*
|
||||
* @param(v1) Vector
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> NormalizeV(TVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Normalize Vector
|
||||
*
|
||||
* @param(v1) Vector
|
||||
*
|
||||
* @note Does not look for zero vector.
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> UnsafeNormalizeV(TVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Angle between to Vectors
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
T Angle(const TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Cosine of angle between to Vectors
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
T CosineAngle(const TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Returns signs of components in vector: -1 / +1 / 0.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> SignVectorV(TVector2<T>& 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<RealType T>
|
||||
TVector2<T> BindToSquareV(TVector2<T>& 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<RealType T>
|
||||
TVector2<T> ClampToSquareV(TVector2<T>& v1, T radius);
|
||||
|
||||
/**
|
||||
* Dot product of two Vectors
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
T DotP(const TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Creates Vector, with component wise largest values.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @note Stores new Vector to v1
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> MaxV (TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Creates Vector, with component wise smallest values.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @note Stores new Vector to v1
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> MinV (TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Gets perpendicular Vector to v1.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @note Stores new Vector to v1
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> GetPerpendicularV (TVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Gets perpendicular Vector to v1.
|
||||
*
|
||||
* @reg [FUNC]PerpendicularV
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @note Stores new Vector to v1
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> GetReversePerpendicularV (TVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Component wise multiplication of Vector
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @note Stores new Vector to v1
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> ScaleV(TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Componentwise inverse of Vector
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @note Stores new Vector to v1
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> CompInverseV(TVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Reflect Vector by normal vector.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(normal) Normal of surface
|
||||
*
|
||||
* @note Stores new Vector to v1
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> ReflectV (TVector2<T>& v1, const TVector2<T>& normal);
|
||||
|
||||
/**
|
||||
* Copies one Vector two another
|
||||
*
|
||||
* @param(v1) Vector to copy to
|
||||
* @param(v2) Vector to copy
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> Set(TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Sets components of a vector.
|
||||
*
|
||||
* @param(v1) Vector to copy to
|
||||
* @param(v2) Vector to copy
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> Set(TVector2<T>& v1, T x, T y);
|
||||
|
||||
/**
|
||||
* Anti-clockwise vector rotation.
|
||||
*
|
||||
* @param(v1) Vector to rotate
|
||||
*
|
||||
* @note Angle is not clamped
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> RotateV(TVector2<T>& v1, T angle);
|
||||
|
||||
|
||||
/**
|
||||
* Clockwise vector rotation.
|
||||
*
|
||||
* @param(v1) Vector to rotate
|
||||
*
|
||||
* @note Angle is not clamped
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
FORCEINLINE TVector2<T> ClockwiseRotateV(TVector2<T>& v1, T angle);
|
||||
|
||||
/**
|
||||
* Negates Vector
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> NegateV(TVector2<T>& 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<RealType T>
|
||||
inline bool IsNormalized(const TVector2<T>& 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<RealType T>
|
||||
inline bool IsPerpendicular(const TVector2<T>& v1, const TVector2<T>& 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<RealType T>
|
||||
inline bool IsParallel(const TVector2<T>& v1, const TVector2<T>& 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<RealType T>
|
||||
inline bool IsCoincident(const TVector2<T>& v1, const TVector2<T>& 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<T>& v1, const TVector2<T>& 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<RealType T>
|
||||
TVector2<T> Reflect(const TVector2<T>& v1, const TVector2<T>& normal);
|
||||
|
||||
/**
|
||||
* Scales a vector component wise
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
* @param(v2) Vector two
|
||||
*
|
||||
* @return Reflected vector
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> Scale(const TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Componentwise inverse of a vector
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @return Componentwise inverted vector
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> CompInverse(const TVector2<T>& v1);
|
||||
|
||||
|
||||
/**
|
||||
* Negates Vector
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @return Componentwise inverted vector
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> Negate(const TVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Gets the perpendicular vector of v1
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @return Perpendicular vector
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> GetPerpendicular(const TVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Gets reverse of the perpendicular vector of v1
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @return Reversed perpendicular vector
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> GetReversePerpendicular(const TVector2<T>& 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<RealType T>
|
||||
TVector2<T> Min(const TVector2<T>& v1, const TVector2<T>& 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<RealType T>
|
||||
TVector2<T> Max(const TVector2<T>& v1, const TVector2<T>& v2);
|
||||
|
||||
/**
|
||||
* Creates a normalized instance of the vector
|
||||
*
|
||||
* @param(v1) Vector to normalize
|
||||
*
|
||||
* @return Unit vector
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> Normalize(const TVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Creates a normalized instance of the vector
|
||||
*
|
||||
* @param(v1) Vector to normalize
|
||||
*
|
||||
* @return Unit vector
|
||||
* @note Does not test for zero vector
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> UnsafeNormalize(const TVector2<T>& v1);
|
||||
|
||||
/**
|
||||
* Returns signs of components in vector: -1 / +1 / 0.
|
||||
*
|
||||
* @param(v1) Vector one
|
||||
*
|
||||
* @return Vector with signs as components
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> SignVector(const TVector2<T>& 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<RealType T>
|
||||
TVector2<T> BindToSquare(const TVector2<T>& 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<RealType T>
|
||||
TVector2<T> ClampToSquare(const TVector2<T>& 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<RealType T>
|
||||
TVector2<T> Lerp(const TVector2<T>& startVec, const TVector2<T>& 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<RealType T>
|
||||
TVector2<T> LerpUnclamped(const TVector2<T>& startVec, const TVector2<T>& 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<RealType T>
|
||||
TVector2<T> Rotate(const TVector2<T>& v1, T angle);
|
||||
|
||||
/**
|
||||
* Clockwise vector rotation.
|
||||
*
|
||||
* @param(v1) Vector to rotate
|
||||
*
|
||||
* @return Rotated vector
|
||||
*
|
||||
* @note Angle is not clamped
|
||||
*/
|
||||
|
||||
template<RealType T>
|
||||
TVector2<T> ClockwiseRotate(const TVector2<T>& v1, T angle);
|
||||
|
||||
} // phanes::core::math::coretypes
|
||||
|
||||
#endif // !VECTOR2_H
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,155 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
|
||||
#include "Core/public/Math/MathCommon.h"
|
||||
#include "Core/public/Math/MathAbstractTypes.h"
|
||||
#include "Core/public/Math/MathFwd.h"
|
||||
|
||||
#pragma warning(disable : 4244)
|
||||
|
||||
#ifdef P_USE_MATH_CONSTANTS
|
||||
|
||||
|
||||
#endif // P_USE_MATH_CONSTANTS
|
||||
|
||||
#ifndef VECTOR4_H
|
||||
#define VECTOR4_H
|
||||
|
||||
|
||||
namespace phanes {
|
||||
|
||||
namespace core {
|
||||
|
||||
namespace math {
|
||||
|
||||
namespace coretypes {
|
||||
|
||||
// Basis 4D Vector (x, y, z, w)
|
||||
|
||||
template<typename T>
|
||||
struct Vector4 {
|
||||
public:
|
||||
float x, y, z, w;
|
||||
};
|
||||
|
||||
// List of Vector3 for DoP and ECS
|
||||
typedef std::vector<Vector4<T>> Vector4List;
|
||||
|
||||
|
||||
Vector4 createVector(float x, float y, float z, float w);
|
||||
|
||||
|
||||
// ===================== //
|
||||
// Vector4 operators //
|
||||
// ===================== //
|
||||
|
||||
void operator+= (Vector4& a, float s);
|
||||
void operator+= (Vector4& a, const Vector4& b);
|
||||
|
||||
void operator-= (Vector4& a, float s);
|
||||
void operator-= (Vector4& a, const Vector4& b);
|
||||
|
||||
void operator*= (Vector4& a, float s);
|
||||
|
||||
void operator/= (Vector4& a, float s);
|
||||
|
||||
Vector4 operator* (const Vector4& a, float s);
|
||||
|
||||
Vector4 operator/ (const Vector4& a, float s);
|
||||
|
||||
Vector4 operator* (float s, const Vector4& a);
|
||||
|
||||
Vector4 operator/ (float s, const Vector4& a);
|
||||
|
||||
// Vector4 dot-product
|
||||
float operator* (const Vector4& a, const Vector4& b);
|
||||
|
||||
Vector4 operator+ (const Vector4& a, float s);
|
||||
Vector4 operator+ (const Vector4& a, const Vector4& b);
|
||||
|
||||
Vector4 operator- (const Vector4& a, float s);
|
||||
Vector4 operator- (const Vector4& a, const Vector4& b);
|
||||
|
||||
void operator- (Vector4& a);
|
||||
|
||||
bool operator== (const Vector4& a, const Vector4& b);
|
||||
|
||||
|
||||
// ==================================== //
|
||||
// Vector4 function implementation //
|
||||
// ==================================== //
|
||||
|
||||
float magnitude(const Vector4& a);
|
||||
|
||||
float sqrMagnitude(const Vector4& a);
|
||||
|
||||
void normalizeNR(Vector4& a);
|
||||
|
||||
float angle(const Vector4& a, const Vector4& b);
|
||||
|
||||
// dot product between two FVector3. Does the same as operator*
|
||||
float dotP(const Vector4& a, const Vector4& b);
|
||||
|
||||
void scaleToMagnitude(Vector4& a, float magnitude);
|
||||
|
||||
bool equals(const Vector4& a, const Vector4& b, float threshold);
|
||||
|
||||
void Set(Vector4& a, const Vector4& b);
|
||||
|
||||
void perpspectiveDivideNR(Vector4& a);
|
||||
|
||||
void maxNR(Vector4& a, const Vector4& b);
|
||||
|
||||
void minNR(Vector4& a, const Vector4& b);
|
||||
|
||||
void scaleNR(Vector4& a, const Vector4& b);
|
||||
|
||||
void orthogonolize(Vector4& a, Vector4& b, Vector4& c);
|
||||
|
||||
void orthoNormalize(Vector4& a, Vector4& b, Vector4& c);
|
||||
|
||||
// projects vector a onto vector b
|
||||
void projectNR(Vector4& a, const Vector4& b);
|
||||
|
||||
// rejects vector a from vector b
|
||||
void rejectNR(Vector4& a, const Vector4& b);
|
||||
|
||||
|
||||
// ============ //
|
||||
// WITH RETURN: //
|
||||
// ============ //
|
||||
|
||||
Vector4 lerp(const Vector4& a, const Vector4& b, float t);
|
||||
|
||||
Vector4 lerpUnclamped(const Vector4& a, const Vector4& b, float t);
|
||||
|
||||
Vector4 slerp(const Vector4& a, const Vector4& b, float t);
|
||||
|
||||
Vector4 slerpUnclamped(const Vector4& a, const Vector4& b, float t);
|
||||
|
||||
Vector4 max(const Vector4& a, const Vector4& b);
|
||||
|
||||
Vector4 min(const Vector4& a, const Vector4& b);
|
||||
|
||||
Vector4 scale(const Vector4& a, const Vector4& b);
|
||||
|
||||
Vector4 perpspectiveDivide(const Vector4& a);
|
||||
|
||||
Vector4 normalize(const Vector4& a);
|
||||
|
||||
// projects vector a onto vector b
|
||||
Vector4 project(const Vector4& a, const Vector4& b);
|
||||
|
||||
// rejects vector a from vector b
|
||||
Vector4 reject(const Vector4& a, const Vector4& b);
|
||||
|
||||
} // phanes::core::math::coretypes
|
||||
|
||||
} // phanes::core::math
|
||||
|
||||
} // phanes::core
|
||||
|
||||
} // phanes
|
||||
|
||||
|
||||
#endif // !VECTOR4_H
|
||||
@ -1,7 +1,7 @@
|
||||
#pragma once
|
||||
// Entry point for Phanes game
|
||||
|
||||
#ifdef P_WIN_BUILD
|
||||
#if defined(P_WIN_BUILD) && defined(P_BUILD_LIB)
|
||||
|
||||
extern Phanes::Core::Application::PhanesGame* Phanes::Core::Application::CreatePhanesGame();
|
||||
|
||||
|
||||
@ -27,5 +27,4 @@ namespace Phanes::Core::Application
|
||||
*/
|
||||
|
||||
PhanesGame* CreatePhanesGame();
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -17,6 +17,15 @@
|
||||
#include <type_traits>
|
||||
#include <string>
|
||||
|
||||
#include<iostream>
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
|
||||
|
||||
#include <chrono>
|
||||
#include <thread>
|
||||
|
||||
#ifdef P_WIN_BUILD
|
||||
|
||||
#include <windows.h>
|
||||
|
||||
15
Engine/src/Runtime/REAME.md
Normal file
15
Engine/src/Runtime/REAME.md
Normal file
@ -0,0 +1,15 @@
|
||||
# PhanesEngine
|
||||
|
||||
## Runtime
|
||||
|
||||
### MACROS
|
||||
|
||||
- P_WIN_BUILD: Game builds for windows.
|
||||
- P_UNIX_BUILD: Game builds for unix system.
|
||||
- P_ARM_BUILD: Game builds for ARM system.
|
||||
- P_DEBUG: Engine compiles for debug game.
|
||||
- P_DEBUGBREAK: Sets a debugbreak at the point.
|
||||
- P_RELEASE: Engine compiles for release.
|
||||
- P_BUILD_LIB: Should only be defined, when the engine is build.
|
||||
- P_TEST: Builds engine for testing.
|
||||
- FORCEINLINE: Causes aggressive inlining.
|
||||
@ -1,11 +1,10 @@
|
||||
#define P_USE_NAMESPACE_ALIAS
|
||||
#include <Phanes.h>
|
||||
|
||||
using namespace Phanes::Core::Math;
|
||||
|
||||
class DevPlayground : public Phanes::Core::Application::PhanesGame {};
|
||||
class DevPlayground : public PApp::PhanesGame {};
|
||||
|
||||
|
||||
Phanes::Core::Application::PhanesGame* Phanes::Core::Application::CreatePhanesGame()
|
||||
PApp::PhanesGame* PApp::CreatePhanesGame()
|
||||
{
|
||||
return new DevPlayground();
|
||||
}
|
||||
@ -6,7 +6,7 @@ int main()
|
||||
{
|
||||
float t = 2;
|
||||
PMath::Clamp(t, 2.0f, 4.0f);
|
||||
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user