mirror of
https://github.com/Kbz-8/42_vox.git
synced 2026-01-11 14:43:34 +00:00
initial commit
This commit is contained in:
108
ScopEngine/Runtime/Includes/Maths/Angles.h
git.filemode.normal_file
108
ScopEngine/Runtime/Includes/Maths/Angles.h
git.filemode.normal_file
@@ -0,0 +1,108 @@
|
||||
#ifndef __SCOP_ANGLES__
|
||||
#define __SCOP_ANGLES__
|
||||
|
||||
#include <Maths/Enums.h>
|
||||
#include <utility>
|
||||
#include <string>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T> struct EulerAngles;
|
||||
template<typename T> struct Quat;
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
struct Angle
|
||||
{
|
||||
T value;
|
||||
|
||||
constexpr Angle() = default;
|
||||
constexpr Angle(T angle);
|
||||
template<typename U> constexpr explicit Angle(const Angle<Unit, U>& Angle);
|
||||
template<AngleUnit FromUnit> constexpr Angle(const Angle<FromUnit, T>& angle);
|
||||
constexpr Angle(const Angle&) = default;
|
||||
constexpr Angle(Angle&&) noexcept = default;
|
||||
~Angle() = default;
|
||||
|
||||
constexpr bool ApproxEqual(const Angle& angle) const;
|
||||
constexpr bool ApproxEqual(const Angle& angle, T max_difference) const;
|
||||
|
||||
T GetCos() const;
|
||||
T GetSin() const;
|
||||
std::pair<T, T> GetSinCos() const;
|
||||
T GetTan() const;
|
||||
|
||||
constexpr Angle& Normalize();
|
||||
|
||||
template<AngleUnit ToUnit> T To() const;
|
||||
template<AngleUnit ToUnit> Angle<ToUnit, T> ToAngle() const;
|
||||
constexpr T ToDegrees() const;
|
||||
constexpr Angle<AngleUnit::Degree, T> ToDegreeAngle() const;
|
||||
EulerAngles<T> ToEulerAngles() const;
|
||||
Quat<T> ToQuat() const;
|
||||
constexpr T ToRadians() const;
|
||||
constexpr Angle<AngleUnit::Radian, T> ToRadianAngle() const;
|
||||
std::string ToString() const;
|
||||
constexpr T ToTurns() const;
|
||||
constexpr Angle<AngleUnit::Turn, T> ToTurnAngle() const;
|
||||
|
||||
constexpr Angle& operator=(const Angle&) = default;
|
||||
constexpr Angle& operator=(Angle&&) noexcept = default;
|
||||
|
||||
constexpr Angle operator+() const;
|
||||
constexpr Angle operator-() const;
|
||||
|
||||
constexpr Angle operator+(Angle other) const;
|
||||
constexpr Angle operator-(Angle other) const;
|
||||
constexpr Angle operator*(T scalar) const;
|
||||
constexpr Angle operator/(T divider) const;
|
||||
|
||||
constexpr Angle& operator+=(Angle other);
|
||||
constexpr Angle& operator-=(Angle other);
|
||||
constexpr Angle& operator*=(T scalar);
|
||||
constexpr Angle& operator/=(T divider);
|
||||
|
||||
constexpr bool operator==(Angle other) const;
|
||||
constexpr bool operator!=(Angle other) const;
|
||||
constexpr bool operator<(Angle other) const;
|
||||
constexpr bool operator<=(Angle other) const;
|
||||
constexpr bool operator>(Angle other) const;
|
||||
constexpr bool operator>=(Angle other) const;
|
||||
|
||||
static constexpr bool ApproxEqual(const Angle& lhs, const Angle& rhs);
|
||||
static constexpr bool ApproxEqual(const Angle& lhs, const Angle& rhs, T max_difference);
|
||||
static constexpr Angle Clamp(Angle angle, Angle min, Angle max);
|
||||
template<AngleUnit FromUnit> static constexpr Angle From(T value);
|
||||
static constexpr Angle FromDegrees(T degrees);
|
||||
static constexpr Angle FromRadians(T radians);
|
||||
static constexpr Angle FromTurns(T turn);
|
||||
static constexpr Angle Zero();
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
using DegreeAngle = Angle<AngleUnit::Degree, T>;
|
||||
|
||||
using DegreeAngled = DegreeAngle<double>;
|
||||
using DegreeAnglef = DegreeAngle<float>;
|
||||
|
||||
template<typename T>
|
||||
using RadianAngle = Angle<AngleUnit::Radian, T>;
|
||||
|
||||
using RadianAngled = RadianAngle<double>;
|
||||
using RadianAnglef = RadianAngle<float>;
|
||||
|
||||
template<typename T>
|
||||
using TurnAngle = Angle<AngleUnit::Turn, T>;
|
||||
|
||||
using TurnAngled = TurnAngle<double>;
|
||||
using TurnAnglef = TurnAngle<float>;
|
||||
|
||||
template<AngleUnit Unit, typename T> Angle<Unit, T> operator*(T scale, Angle<Unit, T> angle);
|
||||
|
||||
template<AngleUnit Unit, typename T> Angle<Unit, T> operator/(T divider, Angle<Unit, T> angle);
|
||||
|
||||
template<AngleUnit Unit, typename T> std::ostream& operator<<(std::ostream& out, Angle<Unit, T> angle);
|
||||
}
|
||||
|
||||
#include <Maths/Angles.inl>
|
||||
|
||||
#endif
|
||||
488
ScopEngine/Runtime/Includes/Maths/Angles.inl
git.filemode.normal_file
488
ScopEngine/Runtime/Includes/Maths/Angles.inl
git.filemode.normal_file
@@ -0,0 +1,488 @@
|
||||
#pragma once
|
||||
#include <Maths/Angles.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <sstream>
|
||||
|
||||
#include <Maths/Constants.h>
|
||||
#include <Maths/MathsUtils.h>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
namespace Internal
|
||||
{
|
||||
template<AngleUnit From, AngleUnit To> struct AngleConversion;
|
||||
|
||||
template<AngleUnit Unit>
|
||||
struct AngleConversion<Unit, Unit>
|
||||
{
|
||||
template<typename T>
|
||||
static constexpr T Convert(T angle)
|
||||
{
|
||||
return angle;
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct AngleConversion<AngleUnit::Degree, AngleUnit::Radian>
|
||||
{
|
||||
template<typename T>
|
||||
static constexpr T Convert(T angle)
|
||||
{
|
||||
return DegreeToRadian(angle);
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct AngleConversion<AngleUnit::Degree, AngleUnit::Turn>
|
||||
{
|
||||
template<typename T>
|
||||
static constexpr T Convert(T angle)
|
||||
{
|
||||
return angle / T(360);
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct AngleConversion<AngleUnit::Radian, AngleUnit::Degree>
|
||||
{
|
||||
template<typename T>
|
||||
static constexpr T Convert(T angle)
|
||||
{
|
||||
return RadianToDegree(angle);
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct AngleConversion<AngleUnit::Radian, AngleUnit::Turn>
|
||||
{
|
||||
template<typename T>
|
||||
static constexpr T Convert(T angle)
|
||||
{
|
||||
return angle / Tau<T>();
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct AngleConversion<AngleUnit::Turn, AngleUnit::Degree>
|
||||
{
|
||||
template<typename T>
|
||||
static constexpr T Convert(T angle)
|
||||
{
|
||||
return angle * T(360);
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct AngleConversion<AngleUnit::Turn, AngleUnit::Radian>
|
||||
{
|
||||
template<typename T>
|
||||
static constexpr T Convert(T angle)
|
||||
{
|
||||
return angle * Tau<T>();
|
||||
}
|
||||
};
|
||||
|
||||
template<AngleUnit Unit> struct AngleUtils;
|
||||
|
||||
template<>
|
||||
struct AngleUtils<AngleUnit::Degree>
|
||||
{
|
||||
template<typename T>
|
||||
static constexpr T GetEpsilon()
|
||||
{
|
||||
return T(1e-4);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
static constexpr T GetLimit()
|
||||
{
|
||||
return 360;
|
||||
}
|
||||
|
||||
template<typename T> static std::ostream& ToString(std::ostream& out, T value)
|
||||
{
|
||||
return out << "Angle(" << value << "deg)";
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct AngleUtils<AngleUnit::Radian>
|
||||
{
|
||||
template<typename T>
|
||||
static constexpr T GetEpsilon()
|
||||
{
|
||||
return T(1e-5);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
static constexpr T GetLimit()
|
||||
{
|
||||
return Tau<T>();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
static std::ostream& ToString(std::ostream& out, T value)
|
||||
{
|
||||
return out << "Angle(" << value << "rad)";
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct AngleUtils<AngleUnit::Turn>
|
||||
{
|
||||
template<typename T>
|
||||
static constexpr T GetEpsilon()
|
||||
{
|
||||
return T(1e-5);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
static constexpr T GetLimit()
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
static std::ostream& ToString(std::ostream& out, T value)
|
||||
{
|
||||
return out << "Angle(" << value << "turn)";
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
void SinCos(T x, T* sin, T* cos)
|
||||
{
|
||||
double s, c;
|
||||
::sincos(x, &s, &c);
|
||||
|
||||
*sin = static_cast<T>(s);
|
||||
*cos = static_cast<T>(c);
|
||||
}
|
||||
|
||||
template<>
|
||||
inline void SinCos(float x, float* s, float* c)
|
||||
{
|
||||
::sincosf(x, s, c);
|
||||
}
|
||||
|
||||
template<>
|
||||
inline void SinCos(long double x, long double* s, long double* c)
|
||||
{
|
||||
::sincosl(x, s, c);
|
||||
}
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T>::Angle(T angle) :
|
||||
value(angle)
|
||||
{
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
template<typename U>
|
||||
constexpr Angle<Unit, T>::Angle(const Angle<Unit, U>& angle) :
|
||||
value(static_cast<T>(angle.value))
|
||||
{
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
template<AngleUnit FromUnit>
|
||||
constexpr Angle<Unit, T>::Angle(const Angle<FromUnit, T>& angle) :
|
||||
value(Internal::AngleConversion<FromUnit, Unit>::Convert(angle.value))
|
||||
{
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr bool Angle<Unit, T>::ApproxEqual(const Angle& angle) const
|
||||
{
|
||||
return ApproxEqual(angle, Internal::AngleUtils<Unit>::template GetEpsilon<T>());
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr bool Angle<Unit, T>::ApproxEqual(const Angle& angle, T maxDifference) const
|
||||
{
|
||||
return NumberEquals(value, angle.value, maxDifference);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
T Angle<Unit, T>::GetCos() const
|
||||
{
|
||||
return std::cos(ToRadians());
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
T Angle<Unit, T>::GetSin() const
|
||||
{
|
||||
return std::sin(ToRadians());
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
std::pair<T, T> Angle<Unit, T>::GetSinCos() const
|
||||
{
|
||||
T sin, cos;
|
||||
Internal::SinCos<T>(ToRadians(), &sin, &cos);
|
||||
|
||||
return std::make_pair(sin, cos);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
T Angle<Unit, T>::GetTan() const
|
||||
{
|
||||
return std::tan(ToRadians());
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T>& Angle<Unit, T>::Normalize()
|
||||
{
|
||||
constexpr T limit = Internal::AngleUtils<Unit>::template GetLimit<T>();
|
||||
constexpr T halfLimit = limit / T(2);
|
||||
|
||||
value = Mod(value + halfLimit, limit);
|
||||
if (value < T(0))
|
||||
value += limit;
|
||||
|
||||
value -= halfLimit;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
template<AngleUnit ToUnit>
|
||||
T Angle<Unit, T>::To() const
|
||||
{
|
||||
return Internal::AngleConversion<Unit, ToUnit>::Convert(value);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
template<AngleUnit ToUnit>
|
||||
Angle<ToUnit, T> Angle<Unit, T>::ToAngle() const
|
||||
{
|
||||
return Angle<ToUnit, T>(To<ToUnit>());
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr T Angle<Unit, T>::ToDegrees() const
|
||||
{
|
||||
return To<AngleUnit::Degree>();
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<AngleUnit::Degree, T> Angle<Unit, T>::ToDegreeAngle() const
|
||||
{
|
||||
return ToAngle<AngleUnit::Degree>();
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
EulerAngles<T> Angle<Unit, T>::ToEulerAngles() const
|
||||
{
|
||||
return EulerAngles<T>(0, 0, ToDegrees());
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
Quat<T> Angle<Unit, T>::ToQuat() const
|
||||
{
|
||||
auto halfAngle = Angle(*this) / 2.f;
|
||||
auto sincos = halfAngle.GetSinCos();
|
||||
return Quat<T>(sincos.second, 0, 0, sincos.first);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr T Angle<Unit, T>::ToRadians() const
|
||||
{
|
||||
return To<AngleUnit::Radian>();
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<AngleUnit::Radian, T> Angle<Unit, T>::ToRadianAngle() const
|
||||
{
|
||||
return ToAngle<AngleUnit::Radian>();
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
std::string Angle<Unit, T>::ToString() const
|
||||
{
|
||||
std::ostringstream oss;
|
||||
Internal::AngleUtils<Unit>::ToString(oss, value);
|
||||
|
||||
return oss.str();
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr T Angle<Unit, T>::ToTurns() const
|
||||
{
|
||||
return To<AngleUnit::Turn>(value);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<AngleUnit::Turn, T> Angle<Unit, T>::ToTurnAngle() const
|
||||
{
|
||||
return ToAngle<AngleUnit::Turn>();
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T> Angle<Unit, T>::operator+() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T> Angle<Unit, T>::operator-() const
|
||||
{
|
||||
return Angle(-value);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T> Angle<Unit, T>::operator+(Angle other) const
|
||||
{
|
||||
return Angle(value + other.value);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T> Angle<Unit, T>::operator-(Angle other) const
|
||||
{
|
||||
return Angle(value - other.value);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T> Angle<Unit, T>::operator*(T scalar) const
|
||||
{
|
||||
return Angle(value * scalar);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T> Angle<Unit, T>::operator/(T divider) const
|
||||
{
|
||||
return Angle(value / divider);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T>& Angle<Unit, T>::operator+=(Angle other)
|
||||
{
|
||||
value += other.value;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T>& Angle<Unit, T>::operator-=(Angle other)
|
||||
{
|
||||
value -= other.value;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T>& Angle<Unit, T>::operator*=(T scalar)
|
||||
{
|
||||
value *= scalar;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T>& Angle<Unit, T>::operator/=(T divider)
|
||||
{
|
||||
value /= divider;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr bool Angle<Unit, T>::operator==(Angle other) const
|
||||
{
|
||||
return value == other.value;
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr bool Angle<Unit, T>::operator!=(Angle other) const
|
||||
{
|
||||
return value != other.value;
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr bool Angle<Unit, T>::operator<(Angle other) const
|
||||
{
|
||||
return value < other.value;
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr bool Angle<Unit, T>::operator<=(Angle other) const
|
||||
{
|
||||
return value <= other.value;
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr bool Angle<Unit, T>::operator>(Angle other) const
|
||||
{
|
||||
return value > other.value;
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr bool Angle<Unit, T>::operator>=(Angle other) const
|
||||
{
|
||||
return value >= other.value;
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr bool Angle<Unit, T>::ApproxEqual(const Angle& lhs, const Angle& rhs)
|
||||
{
|
||||
return lhs.ApproxEqual(rhs);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr bool Angle<Unit, T>::ApproxEqual(const Angle& lhs, const Angle& rhs, T maxDifference)
|
||||
{
|
||||
return lhs.ApproxEqual(rhs, maxDifference);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T> Angle<Unit, T>::Clamp(Angle angle, Angle min, Angle max)
|
||||
{
|
||||
return Angle(std::clamp(angle.value, min.value, max.value));
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
template<AngleUnit FromUnit>
|
||||
constexpr Angle<Unit, T> Angle<Unit, T>::From(T value)
|
||||
{
|
||||
return Angle(Internal::AngleConversion<FromUnit, Unit>::Convert(value));
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T> Angle<Unit, T>::FromDegrees(T degrees)
|
||||
{
|
||||
return From<AngleUnit::Degree>(degrees);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T> Angle<Unit, T>::FromRadians(T radians)
|
||||
{
|
||||
return From<AngleUnit::Radian>(radians);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T> Angle<Unit, T>::FromTurns(T turns)
|
||||
{
|
||||
return From<AngleUnit::Turn>(turns);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
constexpr Angle<Unit, T> Angle<Unit, T>::Zero()
|
||||
{
|
||||
return Angle(0);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
Angle<Unit, T> operator/(T scale, Angle<Unit, T> angle)
|
||||
{
|
||||
return Angle<Unit, T>(scale / angle.value);
|
||||
}
|
||||
|
||||
template<AngleUnit Unit, typename T>
|
||||
std::ostream& operator<<(std::ostream& out, Angle<Unit, T> angle)
|
||||
{
|
||||
return Internal::AngleUtils<Unit>::ToString(out, angle.value);
|
||||
}
|
||||
|
||||
template<typename T, AngleUnit Unit>
|
||||
constexpr Angle<Unit, T> Clamp(Angle<Unit, T> value, T min, T max)
|
||||
{
|
||||
return std::max(std::min(value.value, max), min);
|
||||
}
|
||||
}
|
||||
87
ScopEngine/Runtime/Includes/Maths/Constants.h
git.filemode.normal_file
87
ScopEngine/Runtime/Includes/Maths/Constants.h
git.filemode.normal_file
@@ -0,0 +1,87 @@
|
||||
#ifndef __SCOP_MATHS_CONSTANTS__
|
||||
#define __SCOP_MATHS_CONSTANTS__
|
||||
|
||||
#include <climits>
|
||||
#include <limits>
|
||||
#include <type_traits>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T> constexpr std::size_t BitCount = CHAR_BIT * sizeof(T);
|
||||
|
||||
template<typename T>
|
||||
struct MathConstants
|
||||
{
|
||||
static constexpr T Infinity()
|
||||
{
|
||||
static_assert(std::numeric_limits<T>::has_infinity);
|
||||
return std::numeric_limits<T>::infinity();
|
||||
}
|
||||
|
||||
static constexpr T Max()
|
||||
{
|
||||
return std::numeric_limits<T>::max();
|
||||
}
|
||||
|
||||
static constexpr T Min()
|
||||
{
|
||||
return std::numeric_limits<T>::min();
|
||||
}
|
||||
|
||||
static constexpr T NaN()
|
||||
{
|
||||
static_assert(std::numeric_limits<T>::has_signaling_NaN);
|
||||
return std::numeric_limits<T>::quiet_NaN();
|
||||
}
|
||||
|
||||
// Math constants
|
||||
static constexpr T HalfPi()
|
||||
{
|
||||
static_assert(std::is_floating_point_v<T>);
|
||||
return T(1.5707963267948966192313216916398);
|
||||
}
|
||||
|
||||
static constexpr T Pi()
|
||||
{
|
||||
static_assert(std::is_floating_point_v<T>);
|
||||
return T(3.1415926535897932384626433832795);
|
||||
}
|
||||
|
||||
static constexpr T Sqrt2()
|
||||
{
|
||||
static_assert(std::is_floating_point_v<T>);
|
||||
return T(1.4142135623730950488016887242097);
|
||||
}
|
||||
|
||||
static constexpr T Sqrt3()
|
||||
{
|
||||
static_assert(std::is_floating_point_v<T>);
|
||||
return T(1.7320508075688772935274463415059);
|
||||
}
|
||||
|
||||
static constexpr T Sqrt5()
|
||||
{
|
||||
static_assert(std::is_floating_point_v<T>);
|
||||
return T(2.2360679774997896964091736687313);
|
||||
}
|
||||
|
||||
static constexpr T Tau()
|
||||
{
|
||||
static_assert(std::is_floating_point_v<T>);
|
||||
return T(6.2831853071795864769252867665590);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename T = void> constexpr auto Infinity() { return MathConstants<T>::Infinity(); }
|
||||
template<typename T = void> constexpr auto MaxValue() { return MathConstants<T>::Max(); }
|
||||
template<typename T = void> constexpr auto MinValue() { return MathConstants<T>::Min(); }
|
||||
template<typename T = void> constexpr auto NaN() { return MathConstants<T>::NaN(); }
|
||||
template<typename T = void> constexpr auto HalfPi() { return MathConstants<T>::HalfPi(); }
|
||||
template<typename T = void> constexpr auto Pi() { return MathConstants<T>::Pi(); }
|
||||
template<typename T = void> constexpr auto Sqrt2() { return MathConstants<T>::Sqrt2(); }
|
||||
template<typename T = void> constexpr auto Sqrt3() { return MathConstants<T>::Sqrt3(); }
|
||||
template<typename T = void> constexpr auto Sqrt5() { return MathConstants<T>::Sqrt5(); }
|
||||
template<typename T = void> constexpr auto Tau() { return MathConstants<T>::Tau(); }
|
||||
}
|
||||
|
||||
#endif
|
||||
20
ScopEngine/Runtime/Includes/Maths/Enums.h
git.filemode.normal_file
20
ScopEngine/Runtime/Includes/Maths/Enums.h
git.filemode.normal_file
@@ -0,0 +1,20 @@
|
||||
#ifndef __SCOPE_MATHS_ENUMS__
|
||||
#define __SCOPE_MATHS_ENUMS__
|
||||
|
||||
#include <cstddef>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
enum class AngleUnit
|
||||
{
|
||||
Degree = 0,
|
||||
Radian,
|
||||
Turn,
|
||||
|
||||
EndEnum
|
||||
};
|
||||
|
||||
constexpr std::size_t AngleUnitCount = static_cast<std::size_t>(AngleUnit::EndEnum);
|
||||
}
|
||||
|
||||
#endif
|
||||
57
ScopEngine/Runtime/Includes/Maths/EulerAngles.h
git.filemode.normal_file
57
ScopEngine/Runtime/Includes/Maths/EulerAngles.h
git.filemode.normal_file
@@ -0,0 +1,57 @@
|
||||
#ifndef __SCOP_EULER_ANGLES__
|
||||
#define __SCOP_EULER_ANGLES__
|
||||
|
||||
#include <string>
|
||||
|
||||
#include <Maths/Angles.h>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T>
|
||||
struct EulerAngles
|
||||
{
|
||||
constexpr EulerAngles() = default;
|
||||
constexpr EulerAngles(DegreeAngle<T> P, DegreeAngle<T> Y, DegreeAngle<T> R);
|
||||
constexpr EulerAngles(const DegreeAngle<T> angles[3]);
|
||||
template<AngleUnit Unit> constexpr EulerAngles(const Angle<Unit, T>& angle);
|
||||
constexpr EulerAngles(const Quat<T>& quat);
|
||||
template<typename U> constexpr explicit EulerAngles(const EulerAngles<U>& angles);
|
||||
constexpr EulerAngles(const EulerAngles&) = default;
|
||||
constexpr EulerAngles(EulerAngles&&) = default;
|
||||
~EulerAngles() = default;
|
||||
|
||||
constexpr bool ApproxEqual(const EulerAngles& angles, T maxDifference = std::numeric_limits<T>::epsilon()) const;
|
||||
|
||||
constexpr EulerAngles& Normalize();
|
||||
|
||||
Quat<T> ToQuat() const;
|
||||
std::string ToString() const;
|
||||
|
||||
constexpr EulerAngles operator+(const EulerAngles& angles) const;
|
||||
constexpr EulerAngles operator-(const EulerAngles& angles) const;
|
||||
|
||||
constexpr EulerAngles& operator=(const EulerAngles&) = default;
|
||||
constexpr EulerAngles& operator=(EulerAngles&&) = default;
|
||||
|
||||
constexpr EulerAngles& operator+=(const EulerAngles& angles);
|
||||
constexpr EulerAngles& operator-=(const EulerAngles& angles);
|
||||
|
||||
constexpr bool operator==(const EulerAngles& angles) const;
|
||||
constexpr bool operator!=(const EulerAngles& angles) const;
|
||||
constexpr bool operator<(const EulerAngles& angles) const;
|
||||
constexpr bool operator<=(const EulerAngles& angles) const;
|
||||
constexpr bool operator>(const EulerAngles& angles) const;
|
||||
constexpr bool operator>=(const EulerAngles& angles) const;
|
||||
|
||||
static constexpr bool ApproxEqual(const EulerAngles& lhs, const EulerAngles& rhs, T maxDifference = std::numeric_limits<T>::epsilon());
|
||||
static constexpr EulerAngles Zero();
|
||||
|
||||
DegreeAngle<T> pitch, yaw, roll;
|
||||
};
|
||||
|
||||
using EulerAnglesf = EulerAngles<float>;
|
||||
}
|
||||
|
||||
#include <Maths/EulerAngles.inl>
|
||||
|
||||
#endif
|
||||
169
ScopEngine/Runtime/Includes/Maths/EulerAngles.inl
git.filemode.normal_file
169
ScopEngine/Runtime/Includes/Maths/EulerAngles.inl
git.filemode.normal_file
@@ -0,0 +1,169 @@
|
||||
#pragma once
|
||||
#include <Maths/EulerAngles.h>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T>
|
||||
constexpr EulerAngles<T>::EulerAngles(DegreeAngle<T> P, DegreeAngle<T> Y, DegreeAngle<T> R) :
|
||||
pitch(P), yaw(Y), roll(R)
|
||||
{}
|
||||
|
||||
template<typename T>
|
||||
constexpr EulerAngles<T>::EulerAngles(const DegreeAngle<T> angles[3]) :
|
||||
EulerAngles(angles[0], angles[1], angles[2])
|
||||
{}
|
||||
|
||||
template<typename T>
|
||||
template<AngleUnit Unit>
|
||||
constexpr EulerAngles<T>::EulerAngles(const Angle<Unit, T>& angle) :
|
||||
EulerAngles(angle.ToEulerAngles())
|
||||
{}
|
||||
|
||||
template<typename T>
|
||||
constexpr EulerAngles<T>::EulerAngles(const Quat<T>& quat) :
|
||||
EulerAngles(quat.ToEulerAngles())
|
||||
{}
|
||||
|
||||
template<typename T>
|
||||
template<typename U>
|
||||
constexpr EulerAngles<T>::EulerAngles(const EulerAngles<U>& angles) :
|
||||
pitch(DegreeAngle<T>(angles.pitch)), yaw(DegreeAngle<T>(angles.yaw)), roll(DegreeAngle<T>(angles.roll))
|
||||
{}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool EulerAngles<T>::ApproxEqual(const EulerAngles& angles, T maxDifference) const
|
||||
{
|
||||
return pitch.ApproxEqual(angles.pitch, maxDifference) && yaw.ApproxEqual(angles.yaw, maxDifference) && roll.ApproxEqual(angles.roll, maxDifference);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr EulerAngles<T>& EulerAngles<T>::Normalize()
|
||||
{
|
||||
pitch.Normalize();
|
||||
yaw.Normalize();
|
||||
roll.Normalize();
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Quat<T> EulerAngles<T>::ToQuat() const
|
||||
{
|
||||
// XYZ
|
||||
auto [s1, c1] = (yaw / T(2.0)).GetSinCos();
|
||||
auto [s2, c2] = (roll / T(2.0)).GetSinCos();
|
||||
auto [s3, c3] = (pitch / T(2.0)).GetSinCos();
|
||||
|
||||
return Quat<T>(c1 * c2 * c3 - s1 * s2 * s3,
|
||||
s1 * s2 * c3 + c1 * c2 * s3,
|
||||
s1 * c2 * c3 + c1 * s2 * s3,
|
||||
c1 * s2 * c3 - s1 * c2 * s3);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::string EulerAngles<T>::ToString() const
|
||||
{
|
||||
std::ostringstream ss;
|
||||
ss << *this;
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr EulerAngles<T> EulerAngles<T>::operator+(const EulerAngles& angles) const
|
||||
{
|
||||
return EulerAngles(pitch + angles.pitch, yaw + angles.yaw, roll + angles.roll);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr EulerAngles<T> EulerAngles<T>::operator-(const EulerAngles& angles) const
|
||||
{
|
||||
return EulerAngles(pitch - angles.pitch, yaw - angles.yaw, roll - angles.roll);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr EulerAngles<T>& EulerAngles<T>::operator+=(const EulerAngles& angles)
|
||||
{
|
||||
pitch += angles.pitch;
|
||||
yaw += angles.yaw;
|
||||
roll += angles.roll;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr EulerAngles<T>& EulerAngles<T>::operator-=(const EulerAngles& angles)
|
||||
{
|
||||
pitch -= angles.pitch;
|
||||
yaw -= angles.yaw;
|
||||
roll -= angles.roll;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool EulerAngles<T>::operator==(const EulerAngles& angles) const
|
||||
{
|
||||
return pitch == angles.pitch && yaw == angles.yaw && roll == angles.roll;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool EulerAngles<T>::operator!=(const EulerAngles& angles) const
|
||||
{
|
||||
return !operator==(angles);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool EulerAngles<T>::operator<(const EulerAngles& angles) const
|
||||
{
|
||||
if (pitch != angles.pitch)
|
||||
return pitch < angles.pitch;
|
||||
if (yaw != angles.yaw)
|
||||
return yaw < angles.yaw;
|
||||
return roll < angles.roll;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool EulerAngles<T>::operator<=(const EulerAngles& angles) const
|
||||
{
|
||||
if (pitch != angles.pitch)
|
||||
return pitch < angles.pitch;
|
||||
if (yaw != angles.yaw)
|
||||
return yaw < angles.yaw;
|
||||
return roll <= angles.roll;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool EulerAngles<T>::operator>(const EulerAngles& angles) const
|
||||
{
|
||||
if (pitch != angles.pitch)
|
||||
return pitch > angles.pitch;
|
||||
if (yaw != angles.yaw)
|
||||
return yaw > angles.yaw;
|
||||
return roll > angles.roll;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool EulerAngles<T>::operator>=(const EulerAngles& angles) const
|
||||
{
|
||||
if (pitch != angles.pitch)
|
||||
return pitch > angles.pitch;
|
||||
if (yaw != angles.yaw)
|
||||
return yaw > angles.yaw;
|
||||
return roll >= angles.roll;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool EulerAngles<T>::ApproxEqual(const EulerAngles& lhs, const EulerAngles& rhs, T maxDifference)
|
||||
{
|
||||
return lhs.ApproxEqual(rhs, maxDifference);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr EulerAngles<T> EulerAngles<T>::Zero()
|
||||
{
|
||||
return EulerAngles(0, 0, 0);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::ostream& operator<<(std::ostream& out, const EulerAngles<T>& angles)
|
||||
{
|
||||
return out << "EulerAngles(" << angles.pitch << ", " << angles.yaw << ", " << angles.roll << ')';
|
||||
}
|
||||
}
|
||||
122
ScopEngine/Runtime/Includes/Maths/Mat4.h
git.filemode.normal_file
122
ScopEngine/Runtime/Includes/Maths/Mat4.h
git.filemode.normal_file
@@ -0,0 +1,122 @@
|
||||
#ifndef __SCOP_MAT4__
|
||||
#define __SCOP_MAT4__
|
||||
|
||||
#include <cstddef>
|
||||
#include <limits>
|
||||
#include <string>
|
||||
|
||||
#include <Maths/Angles.h>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T> struct Vec2;
|
||||
template<typename T> struct Vec3;
|
||||
template<typename T> struct Vec4;
|
||||
template<typename T> struct Quat;
|
||||
|
||||
template<typename T>
|
||||
struct Mat4
|
||||
{
|
||||
T m11, m12, m13, m14;
|
||||
T m21, m22, m23, m24;
|
||||
T m31, m32, m33, m34;
|
||||
T m41, m42, m43, m44;
|
||||
|
||||
constexpr Mat4() = default;
|
||||
constexpr Mat4(T r11, T r12, T r13, T r14,
|
||||
T r21, T r22, T r23, T r24,
|
||||
T r31, T r32, T r33, T r34,
|
||||
T r41, T r42, T r43, T r44);
|
||||
constexpr Mat4(const T matrix[16]);
|
||||
constexpr Mat4(const Mat4&) = default;
|
||||
constexpr Mat4(Mat4&&) = default;
|
||||
|
||||
constexpr Mat4& ApplyRotation(const Quat<T>& rotation);
|
||||
constexpr Mat4& ApplyScale(const Vec3<T>& scale);
|
||||
constexpr Mat4& ApplyTranslation(const Vec3<T>& translation);
|
||||
|
||||
constexpr bool ApproxEqual(const Mat4& vec, T max_difference = std::numeric_limits<T>::epsilon()) const;
|
||||
|
||||
constexpr Mat4& Concatenate(const Mat4& matrix);
|
||||
constexpr Mat4& ConcatenateTransform(const Mat4& matrix);
|
||||
|
||||
constexpr Vec4<T> GetColumn(std::size_t column) const;
|
||||
constexpr T GetDeterminant() const;
|
||||
constexpr T GetDeterminantTransform() const;
|
||||
constexpr bool GetInverse(Mat4* dest) const;
|
||||
constexpr bool GetInverseTransform(Mat4* dest) const;
|
||||
Quat<T> GetRotation() const;
|
||||
constexpr Vec4<T> GetRow(std::size_t row) const;
|
||||
constexpr Vec3<T> GetScale() const;
|
||||
constexpr Vec3<T> GetSquaredScale() const;
|
||||
constexpr Vec3<T> GetTranslation() const;
|
||||
constexpr void GetTransposed(Mat4* dest) const;
|
||||
|
||||
constexpr bool HasNegativeScale() const;
|
||||
constexpr bool HasScale() const;
|
||||
|
||||
constexpr Mat4& Inverse(bool* succeeded = nullptr);
|
||||
constexpr Mat4& InverseTransform(bool* succeeded = nullptr);
|
||||
|
||||
constexpr bool IsTransformMatrix() const;
|
||||
constexpr bool IsIdentity() const;
|
||||
|
||||
constexpr Mat4& SetRotation(const Quat<T>& rotation);
|
||||
constexpr Mat4& SetScale(const Vec3<T>& scale);
|
||||
constexpr Mat4& SetTranslation(const Vec3<T>& translation);
|
||||
|
||||
std::string ToString() const;
|
||||
|
||||
constexpr Vec2<T> Transform(const Vec2<T>& vector, T z = 0.0, T w = 1.0) const;
|
||||
constexpr Vec3<T> Transform(const Vec3<T>& vector, T w = 1.0) const;
|
||||
constexpr Vec4<T> Transform(const Vec4<T>& vector) const;
|
||||
|
||||
constexpr Mat4& Transpose();
|
||||
|
||||
constexpr T& operator()(std::size_t x, std::size_t y);
|
||||
constexpr const T& operator()(std::size_t x, std::size_t y) const;
|
||||
|
||||
constexpr T& operator[](std::size_t i);
|
||||
constexpr const T& operator[](std::size_t i) const;
|
||||
|
||||
constexpr Mat4& operator=(const Mat4&) = default;
|
||||
constexpr Mat4& operator=(Mat4&&) = default;
|
||||
|
||||
constexpr Mat4 operator*(const Mat4& matrix) const;
|
||||
constexpr Vec2<T> operator*(const Vec2<T>& vector) const;
|
||||
constexpr Vec3<T> operator*(const Vec3<T>& vector) const;
|
||||
constexpr Vec4<T> operator*(const Vec4<T>& vector) const;
|
||||
constexpr Mat4 operator*(T scalar) const;
|
||||
|
||||
constexpr Mat4& operator*=(const Mat4& matrix);
|
||||
constexpr Mat4& operator*=(T scalar);
|
||||
|
||||
constexpr bool operator==(const Mat4& mat) const;
|
||||
constexpr bool operator!=(const Mat4& mat) const;
|
||||
|
||||
static constexpr bool ApproxEqual(const Mat4& lhs, const Mat4& rhs, T max_difference = std::numeric_limits<T>::epsilon());
|
||||
static constexpr Mat4 Concatenate(const Mat4& left, const Mat4& right);
|
||||
static constexpr Mat4 ConcatenateTransform(const Mat4& left, const Mat4& right);
|
||||
static constexpr Mat4 Identity();
|
||||
static constexpr Mat4 LookAt(const Vec3<T>& eye, const Vec3<T>& target, const Vec3<T>& up = Vec3<T>::Up());
|
||||
static constexpr Mat4 Ortho(T left, T right, T top, T bottom, T zNear = -1.0, T zFar = 1.0);
|
||||
static Mat4 Perspective(RadianAngle<T> angle, T ratio, T zNear, T zFar);
|
||||
static constexpr Mat4 Rotate(const Quat<T>& rotation);
|
||||
static constexpr Mat4 Scale(const Vec3<T>& scale);
|
||||
static constexpr Mat4 Translate(const Vec3<T>& translation);
|
||||
static constexpr Mat4 Transform(const Vec3<T>& translation, const Quat<T>& rotation);
|
||||
static constexpr Mat4 Transform(const Vec3<T>& translation, const Quat<T>& rotation, const Vec3<T>& scale);
|
||||
static constexpr Mat4 TransformInverse(const Vec3<T>& translation, const Quat<T>& rotation);
|
||||
static constexpr Mat4 TransformInverse(const Vec3<T>& translation, const Quat<T>& rotation, const Vec3<T>& scale);
|
||||
static constexpr Mat4 Zero();
|
||||
|
||||
~Mat4() = default;
|
||||
};
|
||||
|
||||
using Mat4d = Mat4<double>;
|
||||
using Mat4f = Mat4<float>;
|
||||
}
|
||||
|
||||
#include <Maths/Mat4.inl>
|
||||
|
||||
#endif
|
||||
879
ScopEngine/Runtime/Includes/Maths/Mat4.inl
git.filemode.normal_file
879
ScopEngine/Runtime/Includes/Maths/Mat4.inl
git.filemode.normal_file
@@ -0,0 +1,879 @@
|
||||
#pragma once
|
||||
#include <Maths/Mat4.h>
|
||||
|
||||
#include <Core/Logs.h>
|
||||
#include <Maths/EulerAngles.h>
|
||||
#include <Maths/Quaternions.h>
|
||||
#include <Maths/Vec2.h>
|
||||
#include <Maths/Vec3.h>
|
||||
#include <Maths/Vec4.h>
|
||||
#include <Maths/MathsUtils.h>
|
||||
|
||||
#include <cstring>
|
||||
#include <sstream>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T>
|
||||
constexpr Mat4<T>::Mat4(T r11, T r12, T r13, T r14,
|
||||
T r21, T r22, T r23, T r24,
|
||||
T r31, T r32, T r33, T r34,
|
||||
T r41, T r42, T r43, T r44) :
|
||||
m11(r11), m12(r12), m13(r13), m14(r14),
|
||||
m21(r21), m22(r22), m23(r23), m24(r24),
|
||||
m31(r31), m32(r32), m33(r33), m34(r34),
|
||||
m41(r41), m42(r42), m43(r43), m44(r44)
|
||||
{}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T>::Mat4(const T matrix[16]) :
|
||||
Mat4(matrix[ 0], matrix[ 1], matrix[ 2], matrix[ 3],
|
||||
matrix[ 4], matrix[ 5], matrix[ 6], matrix[ 7],
|
||||
matrix[ 8], matrix[ 9], matrix[10], matrix[11],
|
||||
matrix[12], matrix[13], matrix[14], matrix[15])
|
||||
{}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T>& Mat4<T>::ApplyRotation(const Quat<T>& rotation)
|
||||
{
|
||||
return Concatenate(Mat4<T>::Rotate(rotation));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T>& Mat4<T>::ApplyScale(const Vec3<T>& scale)
|
||||
{
|
||||
m11 *= scale.x;
|
||||
m12 *= scale.x;
|
||||
m13 *= scale.x;
|
||||
|
||||
m21 *= scale.y;
|
||||
m22 *= scale.y;
|
||||
m23 *= scale.y;
|
||||
|
||||
m31 *= scale.z;
|
||||
m32 *= scale.z;
|
||||
m33 *= scale.z;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T>& Mat4<T>::ApplyTranslation(const Vec3<T>& translation)
|
||||
{
|
||||
m41 += translation.x;
|
||||
m42 += translation.y;
|
||||
m43 += translation.z;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Mat4<T>::ApproxEqual(const Mat4& mat, T maxDifference) const
|
||||
{
|
||||
for(unsigned int i = 0; i < 16; ++i)
|
||||
if(!NumberEquals((&m11)[i], (&mat.m11)[i], maxDifference))
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T>& Mat4<T>::Concatenate(const Mat4& matrix)
|
||||
{
|
||||
return operator=(Mat4(
|
||||
m11 * matrix.m11 + m12 * matrix.m21 + m13 * matrix.m31 + m14 * matrix.m41,
|
||||
m11 * matrix.m12 + m12 * matrix.m22 + m13 * matrix.m32 + m14 * matrix.m42,
|
||||
m11 * matrix.m13 + m12 * matrix.m23 + m13 * matrix.m33 + m14 * matrix.m43,
|
||||
m11 * matrix.m14 + m12 * matrix.m24 + m13 * matrix.m34 + m14 * matrix.m44,
|
||||
|
||||
m21 * matrix.m11 + m22 * matrix.m21 + m23 * matrix.m31 + m24 * matrix.m41,
|
||||
m21 * matrix.m12 + m22 * matrix.m22 + m23 * matrix.m32 + m24 * matrix.m42,
|
||||
m21 * matrix.m13 + m22 * matrix.m23 + m23 * matrix.m33 + m24 * matrix.m43,
|
||||
m21 * matrix.m14 + m22 * matrix.m24 + m23 * matrix.m34 + m24 * matrix.m44,
|
||||
|
||||
m31 * matrix.m11 + m32 * matrix.m21 + m33 * matrix.m31 + m34 * matrix.m41,
|
||||
m31 * matrix.m12 + m32 * matrix.m22 + m33 * matrix.m32 + m34 * matrix.m42,
|
||||
m31 * matrix.m13 + m32 * matrix.m23 + m33 * matrix.m33 + m34 * matrix.m43,
|
||||
m31 * matrix.m14 + m32 * matrix.m24 + m33 * matrix.m34 + m34 * matrix.m44,
|
||||
|
||||
m41 * matrix.m11 + m42 * matrix.m21 + m43 * matrix.m31 + m44 * matrix.m41,
|
||||
m41 * matrix.m12 + m42 * matrix.m22 + m43 * matrix.m32 + m44 * matrix.m42,
|
||||
m41 * matrix.m13 + m42 * matrix.m23 + m43 * matrix.m33 + m44 * matrix.m43,
|
||||
m41 * matrix.m14 + m42 * matrix.m24 + m43 * matrix.m34 + m44 * matrix.m44
|
||||
));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T>& Mat4<T>::ConcatenateTransform(const Mat4& matrix)
|
||||
{
|
||||
return operator=(Mat4(
|
||||
m11*matrix.m11 + m12*matrix.m21 + m13*matrix.m31,
|
||||
m11*matrix.m12 + m12*matrix.m22 + m13*matrix.m32,
|
||||
m11*matrix.m13 + m12*matrix.m23 + m13*matrix.m33,
|
||||
T(0.0),
|
||||
|
||||
m21*matrix.m11 + m22*matrix.m21 + m23*matrix.m31,
|
||||
m21*matrix.m12 + m22*matrix.m22 + m23*matrix.m32,
|
||||
m21*matrix.m13 + m22*matrix.m23 + m23*matrix.m33,
|
||||
T(0.0),
|
||||
|
||||
m31*matrix.m11 + m32*matrix.m21 + m33*matrix.m31,
|
||||
m31*matrix.m12 + m32*matrix.m22 + m33*matrix.m32,
|
||||
m31*matrix.m13 + m32*matrix.m23 + m33*matrix.m33,
|
||||
T(0.0),
|
||||
|
||||
m41*matrix.m11 + m42*matrix.m21 + m43*matrix.m31 + matrix.m41,
|
||||
m41*matrix.m12 + m42*matrix.m22 + m43*matrix.m32 + matrix.m42,
|
||||
m41*matrix.m13 + m42*matrix.m23 + m43*matrix.m33 + matrix.m43,
|
||||
T(1.0)
|
||||
));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Mat4<T>::GetColumn(std::size_t column) const
|
||||
{
|
||||
Assert(column < 4, "column index out of range");
|
||||
const T* ptr = &m11 + column * 4;
|
||||
return Vec4<T>(ptr[0], ptr[1], ptr[2], ptr[3]);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Mat4<T>::GetDeterminant() const
|
||||
{
|
||||
T A = m22*(m33*m44 - m43*m34) - m32*(m23*m44 - m43*m24) + m42*(m23*m34 - m33*m24);
|
||||
T B = m12*(m33*m44 - m43*m34) - m32*(m13*m44 - m43*m14) + m42*(m13*m34 - m33*m14);
|
||||
T C = m12*(m23*m44 - m43*m24) - m22*(m13*m44 - m43*m14) + m42*(m13*m24 - m23*m14);
|
||||
T D = m12*(m23*m34 - m33*m24) - m22*(m13*m34 - m33*m14) + m32*(m13*m24 - m23*m14);
|
||||
|
||||
return m11*A - m21*B + m31*C - m41*D;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Mat4<T>::GetDeterminantTransform() const
|
||||
{
|
||||
T A = m22*m33 - m32*m23;
|
||||
T B = m12*m33 - m32*m13;
|
||||
T C = m12*m23 - m22*m13;
|
||||
|
||||
return m11*A - m21*B + m31*C;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Mat4<T>::GetInverse(Mat4* dest) const
|
||||
{
|
||||
Assert(dest, "destination matrix must be valid");
|
||||
|
||||
T det = GetDeterminant();
|
||||
if(det == T(0.0))
|
||||
return false;
|
||||
|
||||
// http://stackoverflow.com/questions/1148309/inverting-a-4x4-matrix
|
||||
T inv[16];
|
||||
inv[0] = m22 * m33 * m44 -
|
||||
m22 * m34 * m43 -
|
||||
m32 * m23 * m44 +
|
||||
m32 * m24 * m43 +
|
||||
m42 * m23 * m34 -
|
||||
m42 * m24 * m33;
|
||||
|
||||
inv[1] = -m12 * m33 * m44 +
|
||||
m12 * m34 * m43 +
|
||||
m32 * m13 * m44 -
|
||||
m32 * m14 * m43 -
|
||||
m42 * m13 * m34 +
|
||||
m42 * m14 * m33;
|
||||
|
||||
inv[2] = m12 * m23 * m44 -
|
||||
m12 * m24 * m43 -
|
||||
m22 * m13 * m44 +
|
||||
m22 * m14 * m43 +
|
||||
m42 * m13 * m24 -
|
||||
m42 * m14 * m23;
|
||||
|
||||
inv[3] = -m12 * m23 * m34 +
|
||||
m12 * m24 * m33 +
|
||||
m22 * m13 * m34 -
|
||||
m22 * m14 * m33 -
|
||||
m32 * m13 * m24 +
|
||||
m32 * m14 * m23;
|
||||
|
||||
inv[4] = -m21 * m33 * m44 +
|
||||
m21 * m34 * m43 +
|
||||
m31 * m23 * m44 -
|
||||
m31 * m24 * m43 -
|
||||
m41 * m23 * m34 +
|
||||
m41 * m24 * m33;
|
||||
|
||||
inv[5] = m11 * m33 * m44 -
|
||||
m11 * m34 * m43 -
|
||||
m31 * m13 * m44 +
|
||||
m31 * m14 * m43 +
|
||||
m41 * m13 * m34 -
|
||||
m41 * m14 * m33;
|
||||
|
||||
inv[6] = -m11 * m23 * m44 +
|
||||
m11 * m24 * m43 +
|
||||
m21 * m13 * m44 -
|
||||
m21 * m14 * m43 -
|
||||
m41 * m13 * m24 +
|
||||
m41 * m14 * m23;
|
||||
|
||||
inv[7] = m11 * m23 * m34 -
|
||||
m11 * m24 * m33 -
|
||||
m21 * m13 * m34 +
|
||||
m21 * m14 * m33 +
|
||||
m31 * m13 * m24 -
|
||||
m31 * m14 * m23;
|
||||
|
||||
inv[8] = m21 * m32 * m44 -
|
||||
m21 * m34 * m42 -
|
||||
m31 * m22 * m44 +
|
||||
m31 * m24 * m42 +
|
||||
m41 * m22 * m34 -
|
||||
m41 * m24 * m32;
|
||||
|
||||
inv[9] = -m11 * m32 * m44 +
|
||||
m11 * m34 * m42 +
|
||||
m31 * m12 * m44 -
|
||||
m31 * m14 * m42 -
|
||||
m41 * m12 * m34 +
|
||||
m41 * m14 * m32;
|
||||
|
||||
inv[10] = m11 * m22 * m44 -
|
||||
m11 * m24 * m42 -
|
||||
m21 * m12 * m44 +
|
||||
m21 * m14 * m42 +
|
||||
m41 * m12 * m24 -
|
||||
m41 * m14 * m22;
|
||||
|
||||
inv[11] = -m11 * m22 * m34 +
|
||||
m11 * m24 * m32 +
|
||||
m21 * m12 * m34 -
|
||||
m21 * m14 * m32 -
|
||||
m31 * m12 * m24 +
|
||||
m31 * m14 * m22;
|
||||
|
||||
inv[12] = -m21 * m32 * m43 +
|
||||
m21 * m33 * m42 +
|
||||
m31 * m22 * m43 -
|
||||
m31 * m23 * m42 -
|
||||
m41 * m22 * m33 +
|
||||
m41 * m23 * m32;
|
||||
|
||||
inv[13] = m11 * m32 * m43 -
|
||||
m11 * m33 * m42 -
|
||||
m31 * m12 * m43 +
|
||||
m31 * m13 * m42 +
|
||||
m41 * m12 * m33 -
|
||||
m41 * m13 * m32;
|
||||
|
||||
inv[14] = -m11 * m22 * m43 +
|
||||
m11 * m23 * m42 +
|
||||
m21 * m12 * m43 -
|
||||
m21 * m13 * m42 -
|
||||
m41 * m12 * m23 +
|
||||
m41 * m13 * m22;
|
||||
|
||||
inv[15] = m11 * m22 * m33 -
|
||||
m11 * m23 * m32 -
|
||||
m21 * m12 * m33 +
|
||||
m21 * m13 * m32 +
|
||||
m31 * m12 * m23 -
|
||||
m31 * m13 * m22;
|
||||
|
||||
T invDet = T(1.0) / det;
|
||||
for(unsigned int i = 0; i < 16; ++i)
|
||||
inv[i] *= invDet;
|
||||
|
||||
*dest = inv;
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Mat4<T>::GetInverseTransform(Mat4* dest) const
|
||||
{
|
||||
Assert(dest, "destination matrix must be valid");
|
||||
|
||||
T det = GetDeterminantTransform();
|
||||
if(det == T(0.0))
|
||||
return false;
|
||||
|
||||
|
||||
// http://stackoverflow.com/questions/1148309/inverting-a-4x4-matrix
|
||||
T inv[16];
|
||||
inv[0] = m22 * m33 -
|
||||
m32 * m23;
|
||||
|
||||
inv[1] = -m12 * m33 +
|
||||
m32 * m13;
|
||||
|
||||
inv[2] = m12 * m23 -
|
||||
m22 * m13;
|
||||
|
||||
inv[3] = T(0.0);
|
||||
|
||||
inv[4] = -m21 * m33 +
|
||||
m31 * m23;
|
||||
|
||||
inv[5] = m11 * m33 -
|
||||
m31 * m13;
|
||||
|
||||
inv[6] = -m11 * m23 +
|
||||
m21 * m13;
|
||||
|
||||
inv[7] = T(0.0);
|
||||
|
||||
inv[8] = m21 * m32 -
|
||||
m31 * m22;
|
||||
|
||||
inv[9] = -m11 * m32 +
|
||||
m31 * m12;
|
||||
|
||||
inv[10] = m11 * m22 -
|
||||
m21 * m12;
|
||||
|
||||
inv[11] = T(0.0);
|
||||
|
||||
inv[12] = -m21 * m32 * m43 +
|
||||
m21 * m33 * m42 +
|
||||
m31 * m22 * m43 -
|
||||
m31 * m23 * m42 -
|
||||
m41 * m22 * m33 +
|
||||
m41 * m23 * m32;
|
||||
|
||||
inv[13] = m11 * m32 * m43 -
|
||||
m11 * m33 * m42 -
|
||||
m31 * m12 * m43 +
|
||||
m31 * m13 * m42 +
|
||||
m41 * m12 * m33 -
|
||||
m41 * m13 * m32;
|
||||
|
||||
inv[14] = -m11 * m22 * m43 +
|
||||
m11 * m23 * m42 +
|
||||
m21 * m12 * m43 -
|
||||
m21 * m13 * m42 -
|
||||
m41 * m12 * m23 +
|
||||
m41 * m13 * m22;
|
||||
|
||||
T invDet = T(1.0) / det;
|
||||
for(unsigned int i = 0; i < 16; ++i)
|
||||
inv[i] *= invDet;
|
||||
|
||||
inv[15] = T(1.0);
|
||||
|
||||
*dest = inv;
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Quat<T> Mat4<T>::GetRotation() const
|
||||
{
|
||||
// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuat/
|
||||
Quat<T> quat;
|
||||
|
||||
T trace = m11 + m22 + m33;
|
||||
if(trace > T(0.0))
|
||||
{
|
||||
T s = T(0.5) / std::sqrt(trace + T(1.0));
|
||||
quat.w = T(0.25) / s;
|
||||
quat.x = (m23 - m32) * s;
|
||||
quat.y = (m31 - m13) * s;
|
||||
quat.z = (m12 - m21) * s;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(m11 > m22 && m11 > m33)
|
||||
{
|
||||
T s = T(2.0) * std::sqrt(T(1.0) + m11 - m22 - m33);
|
||||
|
||||
quat.w = (m23 - m32) / s;
|
||||
quat.x = T(0.25) * s;
|
||||
quat.y = (m21 + m12) / s;
|
||||
quat.z = (m31 + m13) / s;
|
||||
}
|
||||
else if(m22 > m33)
|
||||
{
|
||||
T s = T(2.0) * std::sqrt(T(1.0) + m22 - m11 - m33);
|
||||
|
||||
quat.w = (m31 - m13) / s;
|
||||
quat.x = (m21 + m12) / s;
|
||||
quat.y = T(0.25) * s;
|
||||
quat.z = (m32 + m23) / s;
|
||||
}
|
||||
else
|
||||
{
|
||||
T s = T(2.0) * std::sqrt(T(1.0) + m33 - m11 - m22);
|
||||
|
||||
quat.w = (m12 - m21) / s;
|
||||
quat.x = (m31 + m13) / s;
|
||||
quat.y = (m32 + m23) / s;
|
||||
quat.z = T(0.25) * s;
|
||||
}
|
||||
}
|
||||
|
||||
return quat;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Mat4<T>::GetRow(std::size_t row) const
|
||||
{
|
||||
Assert(row < 4, "row index out of range");
|
||||
|
||||
const T* ptr = &m11;
|
||||
return Vec4<T>(ptr[row], ptr[row+4], ptr[row+8], ptr[row+12]);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Mat4<T>::GetScale() const
|
||||
{
|
||||
Vec3<T> squaredScale = GetSquaredScale();
|
||||
return Vec3<T>(std::sqrt(squaredScale.x), std::sqrt(squaredScale.y), std::sqrt(squaredScale.z));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Mat4<T>::GetSquaredScale() const
|
||||
{
|
||||
return Vec3<T>(m11 * m11 + m12 * m12 + m13 * m13,
|
||||
m21 * m21 + m22 * m22 + m23 * m23,
|
||||
m31 * m31 + m32 * m32 + m33 * m33);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Mat4<T>::GetTranslation() const
|
||||
{
|
||||
return Vec3<T>(m41, m42, m43);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr void Mat4<T>::GetTransposed(Mat4* dest) const
|
||||
{
|
||||
(*dest) = Mat4f(
|
||||
m11, m21, m31, m41,
|
||||
m12, m22, m32, m42,
|
||||
m13, m23, m33, m43,
|
||||
m14, m24, m34, m44
|
||||
);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Mat4<T>::HasNegativeScale() const
|
||||
{
|
||||
return GetDeterminant() < T(0.0);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Mat4<T>::HasScale() const
|
||||
{
|
||||
T t = m11*m11 + m21*m21 + m31*m31;
|
||||
if(!NumberEquals(t, T(1.0)))
|
||||
return true;
|
||||
|
||||
t = m12*m12 + m22*m22 + m32*m32;
|
||||
if(!NumberEquals(t, T(1.0)))
|
||||
return true;
|
||||
|
||||
t = m13*m13 + m23*m23 + m33*m33;
|
||||
if(!NumberEquals(t, T(1.0)))
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T>& Mat4<T>::Inverse(bool* succeeded)
|
||||
{
|
||||
bool result = GetInverse(this);
|
||||
if(succeeded)
|
||||
*succeeded = result;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T>& Mat4<T>::InverseTransform(bool* succeeded)
|
||||
{
|
||||
bool result = GetInverseTransform(this);
|
||||
if(succeeded)
|
||||
*succeeded = result;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Mat4<T>::IsTransformMatrix() const
|
||||
{
|
||||
return NumberEquals(m14, T(0.0)) && NumberEquals(m24, T(0.0)) && NumberEquals(m34, T(0.0)) && NumberEquals(m44, T(1.0));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Mat4<T>::IsIdentity() const
|
||||
{
|
||||
return (NumberEquals(m11, T(1.0)) && NumberEquals(m12, T(0.0)) && NumberEquals(m13, T(0.0)) && NumberEquals(m14, T(0.0)) &&
|
||||
NumberEquals(m21, T(0.0)) && NumberEquals(m22, T(1.0)) && NumberEquals(m23, T(0.0)) && NumberEquals(m24, T(0.0)) &&
|
||||
NumberEquals(m31, T(0.0)) && NumberEquals(m32, T(0.0)) && NumberEquals(m33, T(1.0)) && NumberEquals(m34, T(0.0)) &&
|
||||
NumberEquals(m41, T(0.0)) && NumberEquals(m42, T(0.0)) && NumberEquals(m43, T(0.0)) && NumberEquals(m44, T(1.0)));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T>& Mat4<T>::SetRotation(const Quat<T>& rotation)
|
||||
{
|
||||
T qw = rotation.w;
|
||||
T qx = rotation.x;
|
||||
T qy = rotation.y;
|
||||
T qz = rotation.z;
|
||||
|
||||
T qx2 = qx * qx;
|
||||
T qy2 = qy * qy;
|
||||
T qz2 = qz * qz;
|
||||
|
||||
m11 = T(1.0) - T(2.0) * qy2 - T(2.0) * qz2;
|
||||
m21 = T(2.0) * qx * qy - T(2.0) * qz * qw;
|
||||
m31 = T(2.0) * qx * qz + T(2.0) * qy * qw;
|
||||
|
||||
m12 = T(2.0) * qx * qy + T(2.0) * qz * qw;
|
||||
m22 = T(1.0) - T(2.0) * qx2 - T(2.0) * qz2;
|
||||
m32 = T(2.0) * qy * qz - T(2.0) * qx * qw;
|
||||
|
||||
m13 = T(2.0) * qx * qz - T(2.0) * qy * qw;
|
||||
m23 = T(2.0) * qy * qz + T(2.0) * qx * qw;
|
||||
m33 = T(1.0) - T(2.0) * qx2 - T(2.0) * qy2;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T>& Mat4<T>::SetScale(const Vec3<T>& scale)
|
||||
{
|
||||
m11 = scale.x;
|
||||
m22 = scale.y;
|
||||
m33 = scale.z;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T>& Mat4<T>::SetTranslation(const Vec3<T>& translation)
|
||||
{
|
||||
m41 = translation.x;
|
||||
m42 = translation.y;
|
||||
m43 = translation.z;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::string Mat4<T>::ToString() const
|
||||
{
|
||||
std::ostringstream ss;
|
||||
ss << *this;
|
||||
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Mat4<T>::Transform(const Vec2<T>& vector, T z, T w) const
|
||||
{
|
||||
return Vec2<T>(m11 * vector.x + m21 * vector.y + m31 * z + m41 * w,
|
||||
m12 * vector.x + m22 * vector.y + m32 * z + m42 * w);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Mat4<T>::Transform(const Vec3<T>& vector, T w) const
|
||||
{
|
||||
return Vec3<T>(m11 * vector.x + m21 * vector.y + m31 * vector.z + m41 * w,
|
||||
m12 * vector.x + m22 * vector.y + m32 * vector.z + m42 * w,
|
||||
m13 * vector.x + m23 * vector.y + m33 * vector.z + m43 * w);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Mat4<T>::Transform(const Vec4<T>& vector) const
|
||||
{
|
||||
return Vec4<T>(m11 * vector.x + m21 * vector.y + m31 * vector.z + m41 * vector.w,
|
||||
m12 * vector.x + m22 * vector.y + m32 * vector.z + m42 * vector.w,
|
||||
m13 * vector.x + m23 * vector.y + m33 * vector.z + m43 * vector.w,
|
||||
m14 * vector.x + m24 * vector.y + m34 * vector.z + m44 * vector.w);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T>& Mat4<T>::Transpose()
|
||||
{
|
||||
std::swap(m12, m21);
|
||||
std::swap(m13, m31);
|
||||
std::swap(m14, m41);
|
||||
std::swap(m23, m32);
|
||||
std::swap(m24, m42);
|
||||
std::swap(m34, m43);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T& Mat4<T>::operator()(std::size_t x, std::size_t y)
|
||||
{
|
||||
Assert(x <= 3, "index out of range");
|
||||
Assert(y <= 3, "index out of range");
|
||||
|
||||
return (&m11)[y*4 + x];
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr const T& Mat4<T>::operator()(std::size_t x, std::size_t y) const
|
||||
{
|
||||
Assert(x <= 3, "index out of range");
|
||||
Assert(y <= 3, "index out of range");
|
||||
|
||||
return (&m11)[y*4+x];
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T& Mat4<T>::operator[](std::size_t i)
|
||||
{
|
||||
Assert(i <= 16, "index out of range");
|
||||
|
||||
return (&m11)[i];
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr const T& Mat4<T>::operator[](std::size_t i) const
|
||||
{
|
||||
Assert(i <= 16, "index out of range");
|
||||
|
||||
return (&m11)[i];
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::operator*(const Mat4& matrix) const
|
||||
{
|
||||
Mat4 result(*this);
|
||||
return result.Concatenate(matrix);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Mat4<T>::operator*(const Vec2<T>& vector) const
|
||||
{
|
||||
return Transform(vector);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Mat4<T>::operator*(const Vec3<T>& vector) const
|
||||
{
|
||||
return Transform(vector);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Mat4<T>::operator*(const Vec4<T>& vector) const
|
||||
{
|
||||
return Transform(vector);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::operator*(T scalar) const
|
||||
{
|
||||
Mat4 mat;
|
||||
for(unsigned int i = 0; i < 16; ++i)
|
||||
mat[i] = (&m11)[i] * scalar;
|
||||
|
||||
return mat;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T>& Mat4<T>::operator*=(const Mat4& matrix)
|
||||
{
|
||||
Concatenate(matrix);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T>& Mat4<T>::operator*=(T scalar)
|
||||
{
|
||||
for(unsigned int i = 0; i < 16; ++i)
|
||||
(&m11)[i] *= scalar;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Mat4<T>::operator==(const Mat4& mat) const
|
||||
{
|
||||
for(unsigned int i = 0; i < 16; ++i)
|
||||
if((&m11)[i] != (&mat.m11)[i])
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Mat4<T>::operator!=(const Mat4& mat) const
|
||||
{
|
||||
return !operator==(mat);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Mat4<T>::ApproxEqual(const Mat4& lhs, const Mat4& rhs, T maxDifference)
|
||||
{
|
||||
return lhs.ApproxEqual(rhs, maxDifference);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::Concatenate(const Mat4& left, const Mat4& right)
|
||||
{
|
||||
Mat4 matrix(left); // Copy of left-hand side matrix
|
||||
matrix.Concatenate(right); // Concatenation with right-hand side
|
||||
|
||||
return matrix;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::ConcatenateTransform(const Mat4& left, const Mat4& right)
|
||||
{
|
||||
Mat4 matrix(left); // Copy of left-hand side matrix
|
||||
matrix.ConcatenateTransform(right); // Affine concatenation with right-hand side
|
||||
|
||||
return matrix;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::Identity()
|
||||
{
|
||||
return Mat4(
|
||||
T(1.0), T(0.0), T(0.0), T(0.0),
|
||||
T(0.0), T(1.0), T(0.0), T(0.0),
|
||||
T(0.0), T(0.0), T(1.0), T(0.0),
|
||||
T(0.0), T(0.0), T(0.0), T(1.0)
|
||||
);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::LookAt(const Vec3<T>& eye, const Vec3<T>& target, const Vec3<T>& up)
|
||||
{
|
||||
Vec3<T> f = Vec3<T>::Normalize(target - eye);
|
||||
Vec3<T> s = Vec3<T>::Normalize(f.CrossProduct(up));
|
||||
Vec3<T> u = s.CrossProduct(f);
|
||||
|
||||
return Mat4(
|
||||
s.x, u.x, -f.x, T(0.0),
|
||||
s.y, u.y, -f.y, T(0.0),
|
||||
s.z, u.z, -f.z, T(0.0),
|
||||
-s.DotProduct(eye), -u.DotProduct(eye), f.DotProduct(eye), T(1.0)
|
||||
);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::Ortho(T left, T right, T top, T bottom, T zNear, T zFar)
|
||||
{
|
||||
// http://msdn.microsoft.com/en-us/library/windows/desktop/bb204942(v=vs.85).aspx
|
||||
return Mat4(
|
||||
T(2.0) / (right - left), T(0.0), T(0.0), T(0.0),
|
||||
T(0.0), T(2.0) / (top - bottom), T(0.0), T(0.0),
|
||||
T(0.0), T(0.0), T(1.0) / (zNear - zFar), T(0.0),
|
||||
(left + right) / (left - right), (top + bottom) / (bottom - top), zNear / (zNear - zFar), T(1.0)
|
||||
);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Mat4<T> Mat4<T>::Perspective(RadianAngle<T> angle, T ratio, T zNear, T zFar)
|
||||
{
|
||||
angle /= T(2.0);
|
||||
|
||||
T yScale = angle.GetTan();
|
||||
|
||||
return Mat4(
|
||||
T(1.0) / (ratio * yScale), T(0.0), T(0.0), T(0.0),
|
||||
T(0.0), T(-1.0) / (yScale), T(0.0), T(0.0),
|
||||
T(0.0), T(0.0), zFar / (zNear - zFar), T(-1.0),
|
||||
T(0.0), T(0.0), -(zNear * zFar) / (zFar - zNear), T(0.0)
|
||||
);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::Rotate(const Quat<T>& rotation)
|
||||
{
|
||||
Mat4 matrix = Mat4::Identity();
|
||||
matrix.SetRotation(rotation);
|
||||
|
||||
return matrix;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::Scale(const Vec3<T>& scale)
|
||||
{
|
||||
return Mat4(
|
||||
scale.x, T(0.0), T(0.0), T(0.0),
|
||||
T(0.0), scale.y, T(0.0), T(0.0),
|
||||
T(0.0), T(0.0), scale.z, T(0.0),
|
||||
T(0.0), T(0.0), T(0.0), T(1.0)
|
||||
);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::Translate(const Vec3<T>& translation)
|
||||
{
|
||||
return Mat4(
|
||||
T(1.0), T(0.0), T(0.0), T(0.0),
|
||||
T(0.0), T(1.0), T(0.0), T(0.0),
|
||||
T(0.0), T(0.0), T(1.0), T(0.0),
|
||||
translation.x, translation.y, translation.z, T(1.0)
|
||||
);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::Transform(const Vec3<T>& translation, const Quat<T>& rotation)
|
||||
{
|
||||
Mat4 mat = Mat4f::Identity();
|
||||
mat.SetRotation(rotation);
|
||||
mat.SetTranslation(translation);
|
||||
|
||||
return mat;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::Transform(const Vec3<T>& translation, const Quat<T>& rotation, const Vec3<T>& scale)
|
||||
{
|
||||
Mat4 mat = Transform(translation, rotation);
|
||||
mat.ApplyScale(scale);
|
||||
|
||||
return mat;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::TransformInverse(const Vec3<T>& translation, const Quat<T>& rotation)
|
||||
{
|
||||
// A view matrix must apply an inverse transformation of the 'world' matrix
|
||||
Quat<T> invRot = rotation.GetConjugate(); // Inverse of the rotation
|
||||
|
||||
return Transform(-(invRot * translation), invRot);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::TransformInverse(const Vec3<T>& translation, const Quat<T>& rotation, const Vec3<T>& scale)
|
||||
{
|
||||
return TransformInverse(translation, rotation).ApplyScale(T(1.0) / scale);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> Mat4<T>::Zero()
|
||||
{
|
||||
return Mat4(
|
||||
T(0.0), T(0.0), T(0.0), T(0.0),
|
||||
T(0.0), T(0.0), T(0.0), T(0.0),
|
||||
T(0.0), T(0.0), T(0.0), T(0.0),
|
||||
T(0.0), T(0.0), T(0.0), T(0.0)
|
||||
);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::ostream& operator<<(std::ostream& out, const Mat4<T>& matrix)
|
||||
{
|
||||
return out << "Mat4(" << matrix.m11 << ", " << matrix.m12 << ", " << matrix.m13 << ", " << matrix.m14 << ",\n"
|
||||
<< " " << matrix.m21 << ", " << matrix.m22 << ", " << matrix.m23 << ", " << matrix.m24 << ",\n"
|
||||
<< " " << matrix.m31 << ", " << matrix.m32 << ", " << matrix.m33 << ", " << matrix.m34 << ",\n"
|
||||
<< " " << matrix.m41 << ", " << matrix.m42 << ", " << matrix.m43 << ", " << matrix.m44 << ')';
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Mat4<T> operator*(T scale, const Mat4<T>& matrix)
|
||||
{
|
||||
return matrix * scale;
|
||||
}
|
||||
}
|
||||
26
ScopEngine/Runtime/Includes/Maths/MathsUtils.h
git.filemode.normal_file
26
ScopEngine/Runtime/Includes/Maths/MathsUtils.h
git.filemode.normal_file
@@ -0,0 +1,26 @@
|
||||
#ifndef __SCOP_MATHS_UTILS__
|
||||
#define __SCOP_MATHS_UTILS__
|
||||
|
||||
#include <concepts>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T>
|
||||
[[nodiscard]] constexpr T Mod(T x, T y) noexcept;
|
||||
|
||||
template<std::floating_point T>
|
||||
[[nodiscard]] constexpr T DegreeToRadian(T degrees) noexcept;
|
||||
|
||||
template<std::floating_point T>
|
||||
[[nodiscard]] constexpr T RadianToDegree(T radians) noexcept;
|
||||
|
||||
template<typename T>
|
||||
[[nodiscard]] constexpr T Clamp(T value, T min, T max) noexcept;
|
||||
|
||||
template<typename T, typename T2>
|
||||
[[nodiscard]] constexpr T Lerp(const T& from, const T& to, const T2& interpolation) noexcept;
|
||||
}
|
||||
|
||||
#include <Maths/MathsUtils.inl>
|
||||
|
||||
#endif
|
||||
47
ScopEngine/Runtime/Includes/Maths/MathsUtils.inl
git.filemode.normal_file
47
ScopEngine/Runtime/Includes/Maths/MathsUtils.inl
git.filemode.normal_file
@@ -0,0 +1,47 @@
|
||||
#pragma once
|
||||
#include <Maths/MathsUtils.h>
|
||||
|
||||
#include <type_traits>
|
||||
#include <cmath>
|
||||
|
||||
#include <Maths/Constants.h>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T>
|
||||
[[nodiscard]] constexpr T Mod(T x, T y) noexcept
|
||||
{
|
||||
if constexpr(std::is_floating_point_v<T>)
|
||||
{
|
||||
if(!std::is_constant_evaluated())
|
||||
return x - static_cast<long long>(x / y) * y;
|
||||
else
|
||||
return std::fmod(x, y);
|
||||
}
|
||||
return x % y;
|
||||
}
|
||||
|
||||
template<std::floating_point T>
|
||||
[[nodiscard]] constexpr T DegreeToRadian(T degrees) noexcept
|
||||
{
|
||||
return degrees * (Pi<T>() / T(180.0));
|
||||
}
|
||||
|
||||
template<std::floating_point T>
|
||||
[[nodiscard]] constexpr T RadianToDegree(T radians) noexcept
|
||||
{
|
||||
return radians * (T(180.0) / Pi<T>());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
[[nodiscard]] constexpr T Clamp(T value, T min, T max) noexcept
|
||||
{
|
||||
return std::max(std::min(value, max), min);
|
||||
}
|
||||
|
||||
template<typename T, typename T2>
|
||||
[[nodiscard]] constexpr T Lerp(const T& from, const T& to, const T2& interpolation) noexcept
|
||||
{
|
||||
return static_cast<T>(from + interpolation * (to - from));
|
||||
}
|
||||
}
|
||||
91
ScopEngine/Runtime/Includes/Maths/Quaternions.h
git.filemode.normal_file
91
ScopEngine/Runtime/Includes/Maths/Quaternions.h
git.filemode.normal_file
@@ -0,0 +1,91 @@
|
||||
#ifndef __SCOP_QUATERNIONS__
|
||||
#define __SCOP_QUATERNIONS__
|
||||
|
||||
#include <Maths/Angles.h>
|
||||
#include <Maths/Vec3.h>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T>
|
||||
struct Quat
|
||||
{
|
||||
T w, x, y, z;
|
||||
|
||||
constexpr Quat() = default;
|
||||
constexpr Quat(T W, T X, T Y, T Z);
|
||||
template<AngleUnit Unit> Quat(const Angle<Unit, T>& angle);
|
||||
Quat(const EulerAngles<T>& angles);
|
||||
constexpr Quat(RadianAngle<T> angle, const Vec3<T>& axis);
|
||||
constexpr Quat(const T quat[4]);
|
||||
template<typename U> constexpr explicit Quat(const Quat<U>& quat);
|
||||
constexpr Quat(const Quat&) = default;
|
||||
constexpr Quat(Quat&&) = default;
|
||||
~Quat() = default;
|
||||
|
||||
RadianAngle<T> AngleBetween(const Quat& vec) const;
|
||||
constexpr bool ApproxEqual(const Quat& quat, T maxDifference = std::numeric_limits<T>::epsilon()) const;
|
||||
|
||||
Quat& ComputeW();
|
||||
constexpr Quat& Conjugate();
|
||||
|
||||
constexpr T DotProduct(const Quat& vec) const;
|
||||
|
||||
constexpr Quat GetConjugate() const;
|
||||
Quat GetInverse() const;
|
||||
Quat GetNormal(T* length = nullptr) const;
|
||||
|
||||
Quat& Inverse();
|
||||
|
||||
T Magnitude() const;
|
||||
|
||||
Quat& Normalize(T* length = nullptr);
|
||||
|
||||
constexpr T SquaredMagnitude() const;
|
||||
|
||||
RadianAngle<T> To2DAngle() const;
|
||||
EulerAngles<T> ToEulerAngles() const;
|
||||
std::string ToString() const;
|
||||
|
||||
constexpr Quat& operator=(const Quat& quat) = default;
|
||||
constexpr Quat& operator=(Quat&&) = default;
|
||||
|
||||
constexpr Quat operator+(const Quat& quat) const;
|
||||
constexpr Quat operator*(const Quat& quat) const;
|
||||
constexpr Vec3<T> operator*(const Vec3<T>& vec) const;
|
||||
constexpr Quat operator*(T scale) const;
|
||||
constexpr Quat operator/(const Quat& quat) const;
|
||||
|
||||
constexpr Quat& operator+=(const Quat& quat);
|
||||
constexpr Quat& operator*=(const Quat& quat);
|
||||
constexpr Quat& operator*=(T scale);
|
||||
constexpr Quat& operator/=(const Quat& quat);
|
||||
|
||||
constexpr bool operator==(const Quat& quat) const;
|
||||
constexpr bool operator!=(const Quat& quat) const;
|
||||
constexpr bool operator<(const Quat& quat) const;
|
||||
constexpr bool operator<=(const Quat& quat) const;
|
||||
constexpr bool operator>(const Quat& quat) const;
|
||||
constexpr bool operator>=(const Quat& quat) const;
|
||||
|
||||
static RadianAngle<T> AngleBetween(const Quat& lhs, const Quat& rhs);
|
||||
static constexpr bool ApproxEqual(const Quat& lhs, const Quat& rhs, T maxDifference = std::numeric_limits<T>::epsilon());
|
||||
static constexpr Quat Identity();
|
||||
static constexpr Quat Lerp(const Quat& from, const Quat& to, T interpolation);
|
||||
static Quat LookAt(const Vec3<T>& forward, const Vec3<T>& up);
|
||||
static Quat Normalize(const Quat& quat, T* length = nullptr);
|
||||
static Quat RotationBetween(const Vec3<T>& from, const Vec3<T>& to);
|
||||
static Quat RotateTowards(const Quat& from, const Quat& to, RadianAngle<T> maxRotation);
|
||||
static Quat Mirror(Quat quat, const Vec3<T>& axis);
|
||||
static Quat Slerp(const Quat& from, const Quat& to, T interpolation);
|
||||
static constexpr Quat Zero();
|
||||
};
|
||||
|
||||
using Quatd = Quat<double>;
|
||||
using Quatf = Quat<float>;
|
||||
|
||||
template<typename T> std::ostream& operator<<(std::ostream& out, const Quat<T>& quat);
|
||||
}
|
||||
|
||||
#include <Maths/Quaternions.inl>
|
||||
|
||||
#endif
|
||||
508
ScopEngine/Runtime/Includes/Maths/Quaternions.inl
git.filemode.normal_file
508
ScopEngine/Runtime/Includes/Maths/Quaternions.inl
git.filemode.normal_file
@@ -0,0 +1,508 @@
|
||||
#pragma once
|
||||
#include <Maths/Quaternions.h>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T>
|
||||
constexpr Quat<T>::Quat(T W, T X, T Y, T Z) : w(W), x(X), y(Y), z(Z)
|
||||
{}
|
||||
|
||||
template<typename T>
|
||||
template<AngleUnit Unit>
|
||||
Quat<T>::Quat(const Angle<Unit, T>& angle) : Quat(angle.ToQuat())
|
||||
{}
|
||||
|
||||
template<typename T>
|
||||
Quat<T>::Quat(const EulerAngles<T>& angles) : Quat(angles.ToQuat())
|
||||
{}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T>::Quat(RadianAngle<T> angle, const Vec3<T>& axis)
|
||||
{
|
||||
angle /= T(2.0);
|
||||
|
||||
Vec3<T> normalizedAxis = axis.GetNormal();
|
||||
|
||||
auto sincos = angle.GetSinCos();
|
||||
|
||||
w = sincos.second;
|
||||
x = normalizedAxis.x * sincos.first;
|
||||
y = normalizedAxis.y * sincos.first;
|
||||
z = normalizedAxis.z * sincos.first;
|
||||
|
||||
Normalize();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T>::Quat(const T quat[4]) : w(quat[0]), x(quat[1]), y(quat[2]), z(quat[3])
|
||||
{}
|
||||
|
||||
template<typename T>
|
||||
template<typename U>
|
||||
constexpr Quat<T>::Quat(const Quat<U>& quat) : w(static_cast<T>(quat.w)), x(static_cast<T>(quat.x)), y(static_cast<T>(quat.y)), z(static_cast<T>(quat.z))
|
||||
{}
|
||||
|
||||
template<typename T>
|
||||
RadianAngle<T> Quat<T>::AngleBetween(const Quat& quat) const
|
||||
{
|
||||
T alpha = Vec3<T>::DotProduct(Vec3<T>(x, y, z), Vec3<T>(quat.x, quat.y, quat.z));
|
||||
return std::acos(Scop::Clamp(alpha, T(-1.0), T(1.0)));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Quat<T>::ApproxEqual(const Quat& quat, T maxDifference) const
|
||||
{
|
||||
return NumberEquals(w, quat.w, maxDifference) &&
|
||||
NumberEquals(x, quat.x, maxDifference) &&
|
||||
NumberEquals(y, quat.y, maxDifference) &&
|
||||
NumberEquals(z, quat.z, maxDifference);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Quat<T>& Quat<T>::ComputeW()
|
||||
{
|
||||
T t = T(1.0) - SquaredMagnitude();
|
||||
|
||||
if(t < T(0.0))
|
||||
w = T(0.0);
|
||||
else
|
||||
w = -std::sqrt(t);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T>& Quat<T>::Conjugate()
|
||||
{
|
||||
x = -x;
|
||||
y = -y;
|
||||
z = -z;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Quat<T>::DotProduct(const Quat& quat) const
|
||||
{
|
||||
return w * quat.w + x * quat.x + y * quat.y + z * quat.z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T> Quat<T>::GetConjugate() const
|
||||
{
|
||||
Quat<T> quat(*this);
|
||||
quat.Conjugate();
|
||||
return quat;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Quat<T> Quat<T>::GetInverse() const
|
||||
{
|
||||
Quat<T> quat(*this);
|
||||
quat.Inverse();
|
||||
return quat;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Quat<T> Quat<T>::GetNormal(T* length) const
|
||||
{
|
||||
Quat<T> quat(*this);
|
||||
quat.Normalize(length);
|
||||
return quat;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Quat<T>& Quat<T>::Inverse()
|
||||
{
|
||||
T norm = SquaredMagnitude();
|
||||
if(norm > T(0.0))
|
||||
{
|
||||
T invNorm = T(1.0) / std::sqrt(norm);
|
||||
|
||||
w *= invNorm;
|
||||
x *= -invNorm;
|
||||
y *= -invNorm;
|
||||
z *= -invNorm;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
T Quat<T>::Magnitude() const
|
||||
{
|
||||
return std::sqrt(SquaredMagnitude());
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Quat<T>& Quat<T>::Normalize(T* length)
|
||||
{
|
||||
T norm = std::sqrt(SquaredMagnitude());
|
||||
if(norm > T(0.0))
|
||||
{
|
||||
T invNorm = T(1.0) / norm;
|
||||
w *= invNorm;
|
||||
x *= invNorm;
|
||||
y *= invNorm;
|
||||
z *= invNorm;
|
||||
}
|
||||
|
||||
if(length)
|
||||
*length = norm;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Quat<T>::SquaredMagnitude() const
|
||||
{
|
||||
return w * w + x * x + y * y + z * z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
RadianAngle<T> Quat<T>::To2DAngle() const
|
||||
{
|
||||
T siny_cosp = T(2.0) * (w * z + x * y);
|
||||
T cosy_cosp = T(1.0) - T(2.0) * (y * y + z * z);
|
||||
|
||||
return std::atan2(siny_cosp, cosy_cosp);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
EulerAngles<T> Quat<T>::ToEulerAngles() const
|
||||
{
|
||||
T test = x * y + z * w;
|
||||
if(test > T(0.499))
|
||||
// singularity at north pole
|
||||
return EulerAngles<T>(DegreeAngle<T>(T(0.0)), RadianAngle<T>(T(2.0) * std::atan2(x, w)), DegreeAngle<T>(T(90.0)));
|
||||
|
||||
if(test < T(-0.499))
|
||||
// singularity at south pole
|
||||
return EulerAngles<T>(DegreeAngle<T>(T(0.0)), RadianAngle<T>(T(-2.0) * std::atan2(x, w)), DegreeAngle<T>(T(-90.0)));
|
||||
|
||||
return EulerAngles<T>(RadianAngle<T>(std::atan2(T(2.0) * x * w - T(2.0) * y * z, T(1.0) - T(2.0) * x * x - T(2.0) * z * z)),
|
||||
RadianAngle<T>(std::atan2(T(2.0) * y * w - T(2.0) * x * z, T(1.0) - T(2.0) * y * y - T(2.0) * z * z)),
|
||||
RadianAngle<T>(std::asin(T(2.0) * test)));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::string Quat<T>::ToString() const
|
||||
{
|
||||
std::ostringstream ss;
|
||||
ss << *this;
|
||||
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T> Quat<T>::operator+(const Quat& quat) const
|
||||
{
|
||||
Quat result;
|
||||
result.w = w + quat.w;
|
||||
result.x = x + quat.x;
|
||||
result.y = y + quat.y;
|
||||
result.z = z + quat.z;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T> Quat<T>::operator*(const Quat& quat) const
|
||||
{
|
||||
Quat result;
|
||||
result.w = w * quat.w - x * quat.x - y * quat.y - z * quat.z;
|
||||
result.x = w * quat.x + x * quat.w + y * quat.z - z * quat.y;
|
||||
result.y = w * quat.y + y * quat.w + z * quat.x - x * quat.z;
|
||||
result.z = w * quat.z + z * quat.w + x * quat.y - y * quat.x;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Quat<T>::operator*(const Vec3<T>& vec) const
|
||||
{
|
||||
Vec3<T> quatVec(x, y, z);
|
||||
Vec3<T> uv = quatVec.CrossProduct(vec);
|
||||
Vec3<T> uuv = quatVec.CrossProduct(uv);
|
||||
uv *= T(2.0) * w;
|
||||
uuv *= T(2.0);
|
||||
|
||||
return vec + uv + uuv;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T> Quat<T>::operator*(T scale) const
|
||||
{
|
||||
return Quat(w * scale,
|
||||
x * scale,
|
||||
y * scale,
|
||||
z * scale);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T> Quat<T>::operator/(const Quat& quat) const
|
||||
{
|
||||
return quat.GetConjugate() * (*this);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T>& Quat<T>::operator+=(const Quat& quat)
|
||||
{
|
||||
return operator=(operator+(quat));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T>& Quat<T>::operator*=(const Quat& quat)
|
||||
{
|
||||
return operator=(operator*(quat));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T>& Quat<T>::operator*=(T scale)
|
||||
{
|
||||
return operator=(operator*(scale));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T>& Quat<T>::operator/=(const Quat& quat)
|
||||
{
|
||||
return operator=(operator/(quat));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Quat<T>::operator==(const Quat& quat) const
|
||||
{
|
||||
return w == quat.w && x == quat.x && y == quat.y && z == quat.z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Quat<T>::operator!=(const Quat& quat) const
|
||||
{
|
||||
return !operator==(quat);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Quat<T>::operator<(const Quat& quat) const
|
||||
{
|
||||
if(w != quat.w)
|
||||
return w < quat.w;
|
||||
|
||||
if(x != quat.x)
|
||||
return x < quat.x;
|
||||
|
||||
if(y != quat.y)
|
||||
return y < quat.y;
|
||||
|
||||
if(z != quat.z)
|
||||
return z < quat.z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Quat<T>::operator<=(const Quat& quat) const
|
||||
{
|
||||
if(w != quat.w)
|
||||
return w < quat.w;
|
||||
|
||||
if(x != quat.x)
|
||||
return x < quat.x;
|
||||
|
||||
if(y != quat.y)
|
||||
return y < quat.y;
|
||||
|
||||
if(z != quat.z)
|
||||
return z <= quat.z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Quat<T>::operator>(const Quat& quat) const
|
||||
{
|
||||
if(w != quat.w)
|
||||
return w > quat.w;
|
||||
|
||||
if(x != quat.x)
|
||||
return x > quat.x;
|
||||
|
||||
if(y != quat.y)
|
||||
return y > quat.y;
|
||||
|
||||
if(z != quat.z)
|
||||
return z > quat.z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Quat<T>::operator>=(const Quat& quat) const
|
||||
{
|
||||
if(w != quat.w)
|
||||
return w > quat.w;
|
||||
|
||||
if(x != quat.x)
|
||||
return x > quat.x;
|
||||
|
||||
if(y != quat.y)
|
||||
return y > quat.y;
|
||||
|
||||
if(z != quat.z)
|
||||
return z >= quat.z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
RadianAngle<T> Quat<T>::AngleBetween(const Quat& lhs, const Quat& rhs)
|
||||
{
|
||||
return lhs.AngleBetween(rhs);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Quat<T>::ApproxEqual(const Quat& lhs, const Quat& rhs, T maxDifference)
|
||||
{
|
||||
return lhs.ApproxEqual(rhs, maxDifference);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T> Quat<T>::Identity()
|
||||
{
|
||||
return Quat(1, 0, 0, 0);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T> Quat<T>::Lerp(const Quat& from, const Quat& to, T interpolation)
|
||||
{
|
||||
Quat interpolated;
|
||||
interpolated.w = Scop::Lerp(from.w, to.w, interpolation);
|
||||
interpolated.x = Scop::Lerp(from.x, to.x, interpolation);
|
||||
interpolated.y = Scop::Lerp(from.y, to.y, interpolation);
|
||||
interpolated.z = Scop::Lerp(from.z, to.z, interpolation);
|
||||
|
||||
return interpolated;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Quat<T> Quat<T>::LookAt(const Vec3<T>& forward, const Vec3<T>& up)
|
||||
{
|
||||
// From https://gamedev.stackexchange.com/questions/53129/quaternion-look-at-with-up-vector
|
||||
Vec3<T> forward_w = Vec3<T>::Forward();
|
||||
Vec3<T> axis = Vec3<T>::CrossProduct(forward, forward_w);
|
||||
RadianAngle<T> angle = std::acos(Vec3<T>::DotProduct(forward, forward_w));
|
||||
|
||||
Vec3<T> third = Vec3<T>::CrossProduct(axis, forward_w);
|
||||
if(Vec3<T>::DotProduct(third, forward) < 0)
|
||||
angle = -angle;
|
||||
|
||||
Quat<T> q1 = Quat(angle, axis);
|
||||
|
||||
Vec3<T> up_l = q1 * up;
|
||||
Vec3<T> right = Vec3<T>::Normalize(Vec3<T>::CrossProduct(forward, up));
|
||||
Vec3<T> up_w = Vec3<T>::Normalize(Vec3<T>::CrossProduct(right, forward));
|
||||
|
||||
Vec3<T> axis2 = Vec3<T>::CrossProduct(up_l, up_w);
|
||||
RadianAngle<T> angle2 = std::acos(Vec3<T>::DotProduct(forward, forward_w));
|
||||
|
||||
Quat<T> q2 = Quat(angle2, axis2);
|
||||
|
||||
return q2 * q1;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Quat<T> Quat<T>::Normalize(const Quat& quat, T* length)
|
||||
{
|
||||
return quat.GetNormal(length);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Quat<T> Quat<T>::RotationBetween(const Vec3<T>& from, const Vec3<T>& to)
|
||||
{
|
||||
T dot = from.DotProduct(to);
|
||||
if(dot < T(-0.999999))
|
||||
{
|
||||
Vec3<T> crossProduct;
|
||||
if(from.DotProduct(Vec3<T>::UnitX()) < T(0.999999))
|
||||
crossProduct = Vec3<T>::UnitX().CrossProduct(from);
|
||||
else
|
||||
crossProduct = Vec3<T>::UnitY().CrossProduct(from);
|
||||
|
||||
crossProduct.Normalize();
|
||||
return Quat(Pi<T>(), crossProduct);
|
||||
}
|
||||
else if(dot > T(0.999999))
|
||||
return Quat::Identity();
|
||||
else
|
||||
{
|
||||
T norm = std::sqrt(from.GetSquaredLength() * to.GetSquaredLength());
|
||||
Vec3<T> crossProduct = from.CrossProduct(to);
|
||||
|
||||
return Quat(norm + dot, crossProduct.x, crossProduct.y, crossProduct.z).GetNormal();
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Quat<T> Quat<T>::RotateTowards(const Quat& from, const Quat& to, RadianAngle<T> maxRotation)
|
||||
{
|
||||
RadianAngle<T> rotationBetween = AngleBetween(from, to);
|
||||
if(rotationBetween < maxRotation)
|
||||
return to;
|
||||
|
||||
return Slerp(from, to, std::min(maxRotation.value / rotationBetween.value), 1.f);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Quat<T> Quat<T>::Mirror(Quat quat, const Vec3<T>& axis)
|
||||
{
|
||||
T x = std::copysign(T(1.0), axis.x);
|
||||
T y = std::copysign(T(1.0), axis.y);
|
||||
T z = std::copysign(T(1.0), axis.z);
|
||||
|
||||
quat.x = y * z * quat.x;
|
||||
quat.y = x * z * quat.y;
|
||||
quat.z = x * y * quat.z;
|
||||
|
||||
return quat;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Quat<T> Quat<T>::Slerp(const Quat& from, const Quat& to, T interpolation)
|
||||
{
|
||||
Quat q;
|
||||
|
||||
T cosOmega = from.DotProduct(to);
|
||||
if(cosOmega < T(0.0))
|
||||
{
|
||||
// We invert everything
|
||||
q = Quat(-to.w, -to.x, -to.y, -to.z);
|
||||
cosOmega = -cosOmega;
|
||||
}
|
||||
else
|
||||
q = Quat(to);
|
||||
|
||||
T k0, k1;
|
||||
if(cosOmega > T(0.9999))
|
||||
{
|
||||
// Linear interpolation to avoid division by zero
|
||||
k0 = T(1.0) - interpolation;
|
||||
k1 = interpolation;
|
||||
}
|
||||
else
|
||||
{
|
||||
T sinOmega = std::sqrt(T(1.0) - cosOmega*cosOmega);
|
||||
T omega = std::atan2(sinOmega, cosOmega);
|
||||
|
||||
// To avoid two divisions
|
||||
sinOmega = T(1.0)/sinOmega;
|
||||
|
||||
k0 = std::sin((T(1.0) - interpolation) * omega) * sinOmega;
|
||||
k1 = std::sin(interpolation*omega) * sinOmega;
|
||||
}
|
||||
|
||||
Quat result(k0 * from.w, k0 * from.x, k0 * from.y, k0 * from.z);
|
||||
return result += q * k1;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Quat<T> Quat<T>::Zero()
|
||||
{
|
||||
return Quat(0, 0, 0, 0);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::ostream& operator<<(std::ostream& out, const Quat<T>& quat)
|
||||
{
|
||||
return out << "Quat(" << quat.w << " | " << quat.x << ", " << quat.y << ", " << quat.z << ')';
|
||||
}
|
||||
}
|
||||
116
ScopEngine/Runtime/Includes/Maths/Vec2.h
git.filemode.executable_file
116
ScopEngine/Runtime/Includes/Maths/Vec2.h
git.filemode.executable_file
@@ -0,0 +1,116 @@
|
||||
#ifndef __SCOP_VEC2__
|
||||
#define __SCOP_VEC2__
|
||||
|
||||
#include <string>
|
||||
#include <limits>
|
||||
#include <cstdint>
|
||||
#include <cmath>
|
||||
|
||||
#include <Core/Logs.h>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template <typename T> class Vec3;
|
||||
template <typename T> class Vec4;
|
||||
|
||||
template <typename T>
|
||||
struct Vec2
|
||||
{
|
||||
T x;
|
||||
T y;
|
||||
|
||||
constexpr Vec2() = default;
|
||||
constexpr Vec2(T X, T Y);
|
||||
constexpr explicit Vec2(T scale);
|
||||
template<typename U> constexpr explicit Vec2(const Vec2<U>& vec);
|
||||
constexpr Vec2(const Vec2&) = default;
|
||||
constexpr Vec2(Vec2&&) = default;
|
||||
constexpr explicit Vec2(const Vec3<T>& vec);
|
||||
constexpr explicit Vec2(const Vec4<T>& vec);
|
||||
|
||||
T AbsDotProduct(const Vec2& vec) const;
|
||||
constexpr bool ApproxEqual(const Vec2& vec, T max_difference = std::numeric_limits<T>::epsilon()) const;
|
||||
|
||||
template<typename U = T> U Distance(const Vec2& vec) const;
|
||||
constexpr T DotProduct(const Vec2& vec) const;
|
||||
|
||||
template<typename U = T> T GetLength() const;
|
||||
Vec2 GetNormal(T* length = nullptr) const;
|
||||
constexpr T GetSquaredLength() const;
|
||||
|
||||
constexpr Vec2& Maximize(const Vec2& vec);
|
||||
constexpr Vec2& Minimize(const Vec2& vec);
|
||||
|
||||
Vec2& Normalize(T* length = nullptr);
|
||||
|
||||
constexpr T SquaredDistance(const Vec2& vec) const;
|
||||
|
||||
std::string ToString() const;
|
||||
|
||||
constexpr T& operator[](std::size_t i);
|
||||
constexpr T operator[](std::size_t i) const;
|
||||
|
||||
constexpr const Vec2& operator+() const;
|
||||
constexpr Vec2 operator-() const;
|
||||
|
||||
constexpr Vec2 operator+(const Vec2& vec) const;
|
||||
constexpr Vec2 operator-(const Vec2& vec) const;
|
||||
constexpr Vec2 operator*(const Vec2& vec) const;
|
||||
constexpr Vec2 operator*(T scale) const;
|
||||
constexpr Vec2 operator/(const Vec2& vec) const;
|
||||
constexpr Vec2 operator/(T scale) const;
|
||||
constexpr Vec2 operator%(const Vec2& vec) const;
|
||||
constexpr Vec2 operator%(T mod) const;
|
||||
|
||||
constexpr Vec2& operator=(const Vec2&) = default;
|
||||
constexpr Vec2& operator=(Vec2&&) = default;
|
||||
|
||||
constexpr Vec2& operator+=(const Vec2& vec);
|
||||
constexpr Vec2& operator-=(const Vec2& vec);
|
||||
constexpr Vec2& operator*=(const Vec2& vec);
|
||||
constexpr Vec2& operator*=(T scale);
|
||||
constexpr Vec2& operator/=(const Vec2& vec);
|
||||
constexpr Vec2& operator/=(T scale);
|
||||
constexpr Vec2& operator%=(const Vec2& vec);
|
||||
constexpr Vec2& operator%=(T mod);
|
||||
|
||||
constexpr bool operator==(const Vec2& vec) const;
|
||||
constexpr bool operator!=(const Vec2& vec) const;
|
||||
constexpr bool operator<(const Vec2& vec) const;
|
||||
constexpr bool operator<=(const Vec2& vec) const;
|
||||
constexpr bool operator>(const Vec2& vec) const;
|
||||
constexpr bool operator>=(const Vec2& vec) const;
|
||||
|
||||
static constexpr Vec2 Apply(T(*func)(T), const Vec2& vec);
|
||||
static constexpr bool ApproxEqual(const Vec2& lhs, const Vec2& rhs, T max_difference = std::numeric_limits<T>::epsilon());
|
||||
template<typename U = T> static U Distance(const Vec2& vec1, const Vec2& vec2);
|
||||
static constexpr T DotProduct(const Vec2& vec1, const Vec2& vec2);
|
||||
static constexpr Vec2 Lerp(const Vec2& from, const Vec2& to, T interpolation);
|
||||
static Vec2 Normalize(const Vec2& vec);
|
||||
static constexpr Vec2 Unit();
|
||||
static constexpr Vec2 UnitX();
|
||||
static constexpr Vec2 UnitY();
|
||||
static constexpr Vec2 Zero();
|
||||
|
||||
~Vec2() = default;
|
||||
};
|
||||
|
||||
using Vec2d = Vec2<double>;
|
||||
using Vec2f = Vec2<float>;
|
||||
using Vec2i = Vec2<int>;
|
||||
using Vec2ui = Vec2<unsigned int>;
|
||||
using Vec2i32 = Vec2<std::int32_t>;
|
||||
using Vec2i64 = Vec2<std::int64_t>;
|
||||
using Vec2ui32 = Vec2<std::uint32_t>;
|
||||
using Vec2ui64 = Vec2<std::uint64_t>;
|
||||
|
||||
template<typename T> std::ostream& operator<<(std::ostream& out, const Vec2<T>& vec);
|
||||
|
||||
template<typename T> constexpr Vec2<T> operator*(T scale, const Vec2<T>& vec);
|
||||
template<typename T> constexpr Vec2<T> operator/(T scale, const Vec2<T>& vec);
|
||||
template<typename T> constexpr Vec2<T> operator%(T mod, const Vec2<T>& vec);
|
||||
}
|
||||
|
||||
#include <Maths/Vec2.inl>
|
||||
|
||||
#endif
|
||||
388
ScopEngine/Runtime/Includes/Maths/Vec2.inl
git.filemode.executable_file
388
ScopEngine/Runtime/Includes/Maths/Vec2.inl
git.filemode.executable_file
@@ -0,0 +1,388 @@
|
||||
#pragma once
|
||||
|
||||
#include <Maths/Vec2.h>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T>
|
||||
constexpr Vec2<T>::Vec2(T X, T Y) : x(X), y(Y) {}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T>::Vec2(T scale) : x(scale), y(scale) {}
|
||||
|
||||
template<typename T>
|
||||
template<typename U>
|
||||
constexpr Vec2<T>::Vec2(const Vec2<U>& vec) : x(static_cast<T>(vec.x)), y(static_cast<T>(vec.y)) {}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T>::Vec2(const Vec3<T>& vec) : x(vec.x), y(vec.y) {}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T>::Vec2(const Vec4<T>& vec) : x(vec.x), y(vec.y) {}
|
||||
|
||||
template<typename T>
|
||||
T Vec2<T>::AbsDotProduct(const Vec2& vec) const
|
||||
{
|
||||
return std::abs(x * vec.x) + std::abs(y * vec.y);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec2<T>::ApproxEqual(const Vec2& vec, T maxDifference) const
|
||||
{
|
||||
return NumberEquals(x, vec.x, maxDifference) && NumberEquals(y, vec.y, maxDifference);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template<typename U>
|
||||
U Vec2<T>::Distance(const Vec2& vec) const
|
||||
{
|
||||
return static_cast<U>(std::sqrt(SquaredDistance(vec)));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Vec2<T>::DotProduct(const Vec2& vec) const
|
||||
{
|
||||
return x * vec.x + y * vec.y;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template<typename U>
|
||||
T Vec2<T>::GetLength() const
|
||||
{
|
||||
return static_cast<U>(std::sqrt(static_cast<U>(GetSquaredLength())));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Vec2<T> Vec2<T>::GetNormal(T* length) const
|
||||
{
|
||||
Vec2 vec(*this);
|
||||
vec.Normalize(length);
|
||||
return vec;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Vec2<T>::GetSquaredLength() const
|
||||
{
|
||||
return x * x + y * y;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T>& Vec2<T>::Maximize(const Vec2& vec)
|
||||
{
|
||||
if(vec.x > x)
|
||||
x = vec.x;
|
||||
if(vec.y > y)
|
||||
y = vec.y;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T>& Vec2<T>::Minimize(const Vec2& vec)
|
||||
{
|
||||
if(vec.x < x)
|
||||
x = vec.x;
|
||||
if(vec.y < y)
|
||||
y = vec.y;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Vec2<T>& Vec2<T>::Normalize(T* length)
|
||||
{
|
||||
T norm = GetLength();
|
||||
if(norm > T(0.0))
|
||||
{
|
||||
T invNorm = T(1.0) / norm;
|
||||
x *= invNorm;
|
||||
y *= invNorm;
|
||||
}
|
||||
if(length)
|
||||
*length = norm;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Vec2<T>::SquaredDistance(const Vec2& vec) const
|
||||
{
|
||||
return (*this - vec).GetSquaredLength();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::string Vec2<T>::ToString() const
|
||||
{
|
||||
return "Vec2(" + std::to_string(x) + ", " + std::to_string(y) + ')';
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T& Vec2<T>::operator[](std::size_t i)
|
||||
{
|
||||
Scop::Assert(i < 2, "index out of range");
|
||||
return *(&x + i);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Vec2<T>::operator[](std::size_t i) const
|
||||
{
|
||||
Scop::Assert(i < 2, "index out of range");
|
||||
return *(&x + i);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr const Vec2<T>& Vec2<T>::operator+() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Vec2<T>::operator-() const
|
||||
{
|
||||
return Vec2(-x, -y);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Vec2<T>::operator+(const Vec2& vec) const
|
||||
{
|
||||
return Vec2(x + vec.x, y + vec.y);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Vec2<T>::operator-(const Vec2& vec) const
|
||||
{
|
||||
return Vec2(x - vec.x, y - vec.y);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Vec2<T>::operator*(const Vec2& vec) const
|
||||
{
|
||||
return Vec2(x * vec.x, y * vec.y);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Vec2<T>::operator*(T scale) const
|
||||
{
|
||||
return Vec2(x * scale, y * scale);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Vec2<T>::operator/(const Vec2& vec) const
|
||||
{
|
||||
return Vec2(x / vec.x, y / vec.y);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Vec2<T>::operator/(T scale) const
|
||||
{
|
||||
return Vec2(x / scale, y / scale);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Vec2<T>::operator%(const Vec2& vec) const
|
||||
{
|
||||
return Vec2(Mod(x, vec.x), Mod(y, vec.y));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Vec2<T>::operator%(T mod) const
|
||||
{
|
||||
return Vec2(Mod(x, mod), Mod(y, mod));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T>& Vec2<T>::operator+=(const Vec2& vec)
|
||||
{
|
||||
x += vec.x;
|
||||
y += vec.y;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T>& Vec2<T>::operator-=(const Vec2& vec)
|
||||
{
|
||||
x -= vec.x;
|
||||
y -= vec.y;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T>& Vec2<T>::operator*=(const Vec2& vec)
|
||||
{
|
||||
x *= vec.x;
|
||||
y *= vec.y;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T>& Vec2<T>::operator*=(T scale)
|
||||
{
|
||||
x *= scale;
|
||||
y *= scale;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T>& Vec2<T>::operator/=(const Vec2& vec)
|
||||
{
|
||||
x /= vec.x;
|
||||
y /= vec.y;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T>& Vec2<T>::operator/=(T scale)
|
||||
{
|
||||
x /= scale;
|
||||
y /= scale;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T>& Vec2<T>::operator%=(const Vec2& vec)
|
||||
{
|
||||
x = Mod(x, vec.x);
|
||||
y = Mod(y, vec.y);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T>& Vec2<T>::operator%=(T value)
|
||||
{
|
||||
x = Mod(x, value);
|
||||
y = Mod(y, value);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec2<T>::operator==(const Vec2& vec) const
|
||||
{
|
||||
return x == vec.x && y == vec.y;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec2<T>::operator!=(const Vec2& vec) const
|
||||
{
|
||||
return !operator==(vec);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec2<T>::operator<(const Vec2& vec) const
|
||||
{
|
||||
if (x != vec.x)
|
||||
return x < vec.x;
|
||||
|
||||
return y < vec.y;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec2<T>::operator<=(const Vec2& vec) const
|
||||
{
|
||||
if (x != vec.x)
|
||||
return x < vec.x;
|
||||
|
||||
return y <= vec.y;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec2<T>::operator>(const Vec2& vec) const
|
||||
{
|
||||
if (x != vec.x)
|
||||
return x > vec.x;
|
||||
|
||||
return y > vec.y;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec2<T>::operator>=(const Vec2& vec) const
|
||||
{
|
||||
if (x != vec.x)
|
||||
return x > vec.x;
|
||||
|
||||
return y >= vec.y;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Vec2<T>::Apply(T(*func)(T), const Vec2& vec)
|
||||
{
|
||||
return Vec2(func(vec.x), func(vec.y));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec2<T>::ApproxEqual(const Vec2& lhs, const Vec2& rhs, T maxDifference)
|
||||
{
|
||||
return lhs.ApproxEqual(rhs, maxDifference);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template<typename U>
|
||||
U Vec2<T>::Distance(const Vec2& vec1, const Vec2& vec2)
|
||||
{
|
||||
return vec1.Distance<U>(vec2);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Vec2<T>::DotProduct(const Vec2& vec1, const Vec2& vec2)
|
||||
{
|
||||
return vec1.DotProduct(vec2);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Vec2<T> Vec2<T>::Normalize(const Vec2& vec)
|
||||
{
|
||||
return vec.GetNormal();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Vec2<T>::Unit()
|
||||
{
|
||||
return Vec2(1, 1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Vec2<T>::UnitX()
|
||||
{
|
||||
return Vec2(1, 0);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Vec2<T>::UnitY()
|
||||
{
|
||||
return Vec2(0, 1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> Vec2<T>::Zero()
|
||||
{
|
||||
return Vec2(0, 0);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::ostream& operator<<(std::ostream& out, const Vec2<T>& vec)
|
||||
{
|
||||
return out << "Vec2(" << vec.x << ", " << vec.y << ')';
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> operator*(T scale, const Vec2<T>& vec)
|
||||
{
|
||||
return Vec2<T>(scale * vec.x, scale * vec.y);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> operator/(T scale, const Vec2<T>& vec)
|
||||
{
|
||||
return Vec2<T>(scale / vec.x, scale / vec.y);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec2<T> operator%(T mod, const Vec2<T>& vec)
|
||||
{
|
||||
return Vec2<T>(Mod(mod, vec.x), Mod(mod, vec.y));
|
||||
}
|
||||
}
|
||||
133
ScopEngine/Runtime/Includes/Maths/Vec3.h
git.filemode.executable_file
133
ScopEngine/Runtime/Includes/Maths/Vec3.h
git.filemode.executable_file
@@ -0,0 +1,133 @@
|
||||
#ifndef __SCOP_VEC3__
|
||||
#define __SCOP_VEC3__
|
||||
|
||||
#include <string>
|
||||
#include <limits>
|
||||
#include <cstdint>
|
||||
#include <cmath>
|
||||
|
||||
#include <Core/Logs.h>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T> class Vec2;
|
||||
template<typename T> class Vec4;
|
||||
|
||||
template<typename T>
|
||||
struct Vec3
|
||||
{
|
||||
T x;
|
||||
T y;
|
||||
T z;
|
||||
|
||||
constexpr Vec3() = default;
|
||||
constexpr Vec3(T X, T Y, T Z);
|
||||
constexpr Vec3(T X, const Vec2<T>& vec);
|
||||
constexpr explicit Vec3(T scale);
|
||||
constexpr Vec3(const Vec2<T>& vec, T Z = 0.0);
|
||||
template<typename U> constexpr explicit Vec3(const Vec3<U>& vec);
|
||||
constexpr Vec3(const Vec3&) = default;
|
||||
constexpr Vec3(Vec3&&) = default;
|
||||
constexpr explicit Vec3(const Vec4<T>& vec);
|
||||
|
||||
T AbsDotProduct(const Vec3& vec) const;
|
||||
constexpr bool ApproxEqual(const Vec3& vec, T max_difference = std::numeric_limits<T>::epsilon()) const;
|
||||
|
||||
constexpr Vec3 CrossProduct(const Vec3& vec) const;
|
||||
|
||||
template<typename U = T> U Distance(const Vec3& vec) const;
|
||||
constexpr T DotProduct(const Vec3& vec) const;
|
||||
|
||||
Vec3 GetAbs() const;
|
||||
template<typename U = T> U GetLength() const;
|
||||
Vec3 GetNormal(T* length = nullptr) const;
|
||||
constexpr T GetSquaredLength() const;
|
||||
|
||||
constexpr Vec3& Maximize(const Vec3& vec);
|
||||
constexpr Vec3& Minimize(const Vec3& vec);
|
||||
|
||||
Vec3& Normalize(T* length = nullptr);
|
||||
|
||||
constexpr T SquaredDistance(const Vec3& vec) const;
|
||||
|
||||
std::string ToString() const;
|
||||
|
||||
constexpr T& operator[](std::size_t i);
|
||||
constexpr const T& operator[](std::size_t i) const;
|
||||
|
||||
constexpr const Vec3& operator+() const;
|
||||
constexpr Vec3 operator-() const;
|
||||
|
||||
constexpr Vec3 operator+(const Vec3& vec) const;
|
||||
constexpr Vec3 operator-(const Vec3& vec) const;
|
||||
constexpr Vec3 operator*(const Vec3& vec) const;
|
||||
constexpr Vec3 operator*(T scale) const;
|
||||
constexpr Vec3 operator/(const Vec3& vec) const;
|
||||
constexpr Vec3 operator/(T scale) const;
|
||||
constexpr Vec3 operator%(const Vec3& vec) const;
|
||||
constexpr Vec3 operator%(T mod) const;
|
||||
|
||||
constexpr Vec3& operator=(const Vec3&) = default;
|
||||
constexpr Vec3& operator=(Vec3&&) = default;
|
||||
|
||||
constexpr Vec3& operator+=(const Vec3& vec);
|
||||
constexpr Vec3& operator-=(const Vec3& vec);
|
||||
constexpr Vec3& operator*=(const Vec3& vec);
|
||||
constexpr Vec3& operator*=(T scale);
|
||||
constexpr Vec3& operator/=(const Vec3& vec);
|
||||
constexpr Vec3& operator/=(T scale);
|
||||
constexpr Vec3& operator%=(const Vec3& vec);
|
||||
constexpr Vec3& operator%=(T mod);
|
||||
|
||||
constexpr bool operator==(const Vec3& vec) const;
|
||||
constexpr bool operator!=(const Vec3& vec) const;
|
||||
constexpr bool operator<(const Vec3& vec) const;
|
||||
constexpr bool operator<=(const Vec3& vec) const;
|
||||
constexpr bool operator>(const Vec3& vec) const;
|
||||
constexpr bool operator>=(const Vec3& vec) const;
|
||||
|
||||
static constexpr Vec3 Apply(T(*func)(T), const Vec3& vec);
|
||||
static constexpr bool ApproxEqual(const Vec3& lhs, const Vec3& rhs, T max_difference = std::numeric_limits<T>::epsilon());
|
||||
static constexpr Vec3 Backward();
|
||||
static constexpr Vec3 Clamp(const Vec3& vec, const Vec3& min, const Vec3& max);
|
||||
static constexpr Vec3 CrossProduct(const Vec3& vec1, const Vec3& vec2);
|
||||
template<typename U = T> static U Distance(const Vec3& vec1, const Vec3& vec2);
|
||||
static constexpr T DotProduct(const Vec3& vec1, const Vec3& vec2);
|
||||
static constexpr Vec3 Down();
|
||||
static constexpr Vec3 Forward();
|
||||
static constexpr Vec3 Left();
|
||||
static constexpr Vec3 Max(const Vec3& lhs, const Vec3& rhs);
|
||||
static constexpr Vec3 Min(const Vec3& lhs, const Vec3& rhs);
|
||||
static Vec3 Normalize(const Vec3& vec);
|
||||
static constexpr Vec3 Right();
|
||||
static constexpr T SquaredDistance(const Vec3& vec1, const Vec3& vec2);
|
||||
static constexpr Vec3 Unit();
|
||||
static constexpr Vec3 UnitX();
|
||||
static constexpr Vec3 UnitY();
|
||||
static constexpr Vec3 UnitZ();
|
||||
static constexpr Vec3 Up();
|
||||
static constexpr Vec3 Zero();
|
||||
|
||||
~Vec3() = default;
|
||||
};
|
||||
|
||||
using Vec3b = Vec3<std::uint8_t>;
|
||||
using Vec3d = Vec3<double>;
|
||||
using Vec3f = Vec3<float>;
|
||||
using Vec3i = Vec3<int>;
|
||||
using Vec3ui = Vec3<unsigned int>;
|
||||
using Vec3i32 = Vec3<std::int32_t>;
|
||||
using Vec3i64 = Vec3<std::int64_t>;
|
||||
using Vec3ui32 = Vec3<std::uint32_t>;
|
||||
using Vec3ui64 = Vec3<std::uint64_t>;
|
||||
|
||||
template<typename T> std::ostream& operator<<(std::ostream& out, const Vec3<T>& vec);
|
||||
|
||||
template<typename T> constexpr Vec3<T> operator*(T scale, const Vec3<T>& vec);
|
||||
template<typename T> constexpr Vec3<T> operator/(T scale, const Vec3<T>& vec);
|
||||
template<typename T> constexpr Vec3<T> operator%(T scale, const Vec3<T>& vec);
|
||||
}
|
||||
|
||||
#include <Maths/Vec3.inl>
|
||||
|
||||
#endif
|
||||
509
ScopEngine/Runtime/Includes/Maths/Vec3.inl
git.filemode.executable_file
509
ScopEngine/Runtime/Includes/Maths/Vec3.inl
git.filemode.executable_file
@@ -0,0 +1,509 @@
|
||||
#pragma once
|
||||
|
||||
#include <Maths/Vec3.h>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T>
|
||||
constexpr Vec3<T>::Vec3(T X, T Y, T Z) : x(X), y(Y), z(Z) {}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T>::Vec3(T X, const Vec2<T>& vec) : x(X), y(vec.x), z(vec.y) {}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T>::Vec3(T scale) : x(scale), y(scale), z(scale) {}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T>::Vec3(const Vec2<T>& vec, T Z) : x(vec.x), y(vec.y), z(Z) {}
|
||||
|
||||
template<typename T>
|
||||
template<typename U>
|
||||
constexpr Vec3<T>::Vec3(const Vec3<U>& vec) : x(static_cast<T>(vec.x)), y(static_cast<T>(vec.y)), z(static_cast<T>(vec.z)) {}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T>::Vec3(const Vec4<T>& vec) : x(vec.x), y(vec.y), z(vec.z) {}
|
||||
|
||||
template<typename T>
|
||||
T Vec3<T>::AbsDotProduct(const Vec3& vec) const
|
||||
{
|
||||
return std::abs(x * vec.x) + std::abs(y * vec.y) + std::abs(z * vec.z);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec3<T>::ApproxEqual(const Vec3& vec, T maxDifference) const
|
||||
{
|
||||
return NumberEquals(x, vec.x, maxDifference) && NumberEquals(y, vec.y, maxDifference) && NumberEquals(z, vec.z, maxDifference);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::CrossProduct(const Vec3& vec) const
|
||||
{
|
||||
return Vec3(y * vec.z - z * vec.y, z * vec.x - x * vec.z, x * vec.y - y * vec.x);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template<typename U>
|
||||
U Vec3<T>::Distance(const Vec3& vec) const
|
||||
{
|
||||
return static_cast<U>(std::sqrt(static_cast<U>(SquaredDistance(vec))));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Vec3<T>::DotProduct(const Vec3& vec) const
|
||||
{
|
||||
return x * vec.x + y * vec.y + z * vec.z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Vec3<T> Vec3<T>::GetAbs() const
|
||||
{
|
||||
return Vec3(std::abs(x), std::abs(y), std::abs(z));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template<typename U>
|
||||
U Vec3<T>::GetLength() const
|
||||
{
|
||||
return static_cast<U>(std::sqrt(static_cast<U>(GetSquaredLength())));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Vec3<T> Vec3<T>::GetNormal(T* length) const
|
||||
{
|
||||
Vec3 vec(*this);
|
||||
vec.Normalize(length);
|
||||
|
||||
return vec;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Vec3<T>::GetSquaredLength() const
|
||||
{
|
||||
return x*x + y*y + z*z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T>& Vec3<T>::Maximize(const Vec3& vec)
|
||||
{
|
||||
if (vec.x > x)
|
||||
x = vec.x;
|
||||
|
||||
if (vec.y > y)
|
||||
y = vec.y;
|
||||
|
||||
if (vec.z > z)
|
||||
z = vec.z;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T>& Vec3<T>::Minimize(const Vec3& vec)
|
||||
{
|
||||
if (vec.x < x)
|
||||
x = vec.x;
|
||||
|
||||
if (vec.y < y)
|
||||
y = vec.y;
|
||||
|
||||
if (vec.z < z)
|
||||
z = vec.z;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Vec3<T>& Vec3<T>::Normalize(T* length)
|
||||
{
|
||||
T norm = GetLength();
|
||||
if (norm > T(0.0))
|
||||
{
|
||||
T invNorm = T(1.0) / norm;
|
||||
x *= invNorm;
|
||||
y *= invNorm;
|
||||
z *= invNorm;
|
||||
}
|
||||
|
||||
if (length)
|
||||
*length = norm;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Vec3<T>::SquaredDistance(const Vec3& vec) const
|
||||
{
|
||||
return (*this - vec).GetSquaredLength();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::string Vec3<T>::ToString() const
|
||||
{
|
||||
return "Vec3(" + std::to_string(x) + ", " + std::to_string(y) + ", " + std::to_string(z) + ')';
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T& Vec3<T>::operator[](std::size_t i)
|
||||
{
|
||||
Scop::Assert(i < 3, "index out of range");
|
||||
return *(&x + i);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr const T& Vec3<T>::operator[](std::size_t i) const
|
||||
{
|
||||
Scop::Assert(i < 3, "index out of range");
|
||||
return *(&x + i);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr const Vec3<T>& Vec3<T>::operator+() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::operator-() const
|
||||
{
|
||||
return Vec3(-x, -y, -z);
|
||||
}
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::operator+(const Vec3& vec) const
|
||||
{
|
||||
return Vec3(x + vec.x, y + vec.y, z + vec.z);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::operator-(const Vec3& vec) const
|
||||
{
|
||||
return Vec3(x - vec.x, y - vec.y, z - vec.z);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::operator*(const Vec3& vec) const
|
||||
{
|
||||
return Vec3(x * vec.x, y * vec.y, z * vec.z);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::operator*(T scale) const
|
||||
{
|
||||
return Vec3(x * scale, y * scale, z * scale);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::operator/(const Vec3& vec) const
|
||||
{
|
||||
return Vec3(x / vec.x, y / vec.y, z / vec.z);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::operator/(T scale) const
|
||||
{
|
||||
return Vec3(x / scale, y / scale, z / scale);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::operator%(const Vec3& vec) const
|
||||
{
|
||||
return Vec3(Mod(x, vec.x), Mod(y, vec.y), Mod(z, vec.z));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::operator%(T mod) const
|
||||
{
|
||||
return Vec3(Mod(x, mod), Mod(y, mod), Mod(z, mod));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T>& Vec3<T>::operator+=(const Vec3& vec)
|
||||
{
|
||||
x += vec.x;
|
||||
y += vec.y;
|
||||
z += vec.z;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T>& Vec3<T>::operator-=(const Vec3& vec)
|
||||
{
|
||||
x -= vec.x;
|
||||
y -= vec.y;
|
||||
z -= vec.z;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T>& Vec3<T>::operator*=(const Vec3& vec)
|
||||
{
|
||||
x *= vec.x;
|
||||
y *= vec.y;
|
||||
z *= vec.z;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T>& Vec3<T>::operator*=(T scale)
|
||||
{
|
||||
x *= scale;
|
||||
y *= scale;
|
||||
z *= scale;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T>& Vec3<T>::operator/=(const Vec3& vec)
|
||||
{
|
||||
x /= vec.x;
|
||||
y /= vec.y;
|
||||
z /= vec.z;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T>& Vec3<T>::operator/=(T scale)
|
||||
{
|
||||
x /= scale;
|
||||
y /= scale;
|
||||
z /= scale;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T>& Vec3<T>::operator%=(const Vec3& vec)
|
||||
{
|
||||
x = Mod(x, vec.x);
|
||||
y = Mod(y, vec.y);
|
||||
z = Mod(z, vec.z);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T>& Vec3<T>::operator%=(T mod)
|
||||
{
|
||||
x = Mod(x, mod);
|
||||
y = Mod(y, mod);
|
||||
z = Mod(z, mod);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec3<T>::operator==(const Vec3& vec) const
|
||||
{
|
||||
return x == vec.x && y == vec.y && z == vec.z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec3<T>::operator!=(const Vec3& vec) const
|
||||
{
|
||||
return !operator==(vec);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec3<T>::operator<(const Vec3& vec) const
|
||||
{
|
||||
if (x != vec.x)
|
||||
return x < vec.x;
|
||||
|
||||
if (y != vec.y)
|
||||
return y < vec.y;
|
||||
|
||||
return z < vec.z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec3<T>::operator<=(const Vec3& vec) const
|
||||
{
|
||||
if (x != vec.x)
|
||||
return x < vec.x;
|
||||
|
||||
if (y != vec.y)
|
||||
return y < vec.y;
|
||||
|
||||
return z <= vec.z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec3<T>::operator>(const Vec3& vec) const
|
||||
{
|
||||
if (x != vec.x)
|
||||
return x > vec.x;
|
||||
|
||||
if (y != vec.y)
|
||||
return y > vec.y;
|
||||
|
||||
return z > vec.z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec3<T>::operator>=(const Vec3& vec) const
|
||||
{
|
||||
if (x != vec.x)
|
||||
return x > vec.x;
|
||||
|
||||
if (y != vec.y)
|
||||
return y > vec.y;
|
||||
|
||||
return z >= vec.z;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::Apply(T(*func)(T), const Vec3& vec)
|
||||
{
|
||||
return Vec3(func(vec.x), func(vec.y), func(vec.z));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec3<T>::ApproxEqual(const Vec3& lhs, const Vec3& rhs, T maxDifference)
|
||||
{
|
||||
return lhs.ApproxEqual(rhs, maxDifference);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::CrossProduct(const Vec3& vec1, const Vec3& vec2)
|
||||
{
|
||||
return vec1.CrossProduct(vec2);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Vec3<T>::DotProduct(const Vec3& vec1, const Vec3& vec2)
|
||||
{
|
||||
return vec1.DotProduct(vec2);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::Backward()
|
||||
{
|
||||
return Vec3(0, 0, 1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
template<typename U>
|
||||
U Vec3<T>::Distance(const Vec3& vec1, const Vec3& vec2)
|
||||
{
|
||||
return vec1.Distance<U>(vec2);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::Down()
|
||||
{
|
||||
return Vec3(0, -1, 0);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::Forward()
|
||||
{
|
||||
return Vec3(0, 0, -1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::Left()
|
||||
{
|
||||
return Vec3(-1, 0, 0);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::Max(const Vec3& lhs, const Vec3& rhs)
|
||||
{
|
||||
Vec3 max = lhs;
|
||||
max.Maximize(rhs);
|
||||
|
||||
return max;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::Min(const Vec3& lhs, const Vec3& rhs)
|
||||
{
|
||||
Vec3 min = lhs;
|
||||
min.Minimize(rhs);
|
||||
|
||||
return min;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Vec3<T> Vec3<T>::Normalize(const Vec3& vec)
|
||||
{
|
||||
return vec.GetNormal();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::Right()
|
||||
{
|
||||
return Vec3(1, 0, 0);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Vec3<T>::SquaredDistance(const Vec3& vec1, const Vec3& vec2)
|
||||
{
|
||||
return vec1.SquaredDistance(vec2);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::Unit()
|
||||
{
|
||||
return Vec3(1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::UnitX()
|
||||
{
|
||||
return Vec3(1, 0, 0);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::UnitY()
|
||||
{
|
||||
return Vec3(0, 1, 0);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::UnitZ()
|
||||
{
|
||||
return Vec3(0, 0, 1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::Up()
|
||||
{
|
||||
return Vec3(0, 1, 0);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> Vec3<T>::Zero()
|
||||
{
|
||||
return Vec3(0, 0, 0);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::ostream& operator<<(std::ostream& out, const Vec3<T>& vec)
|
||||
{
|
||||
return out << "Vec3(" << vec.x << ", " << vec.y << ", " << vec.z << ')';
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> operator*(T scale, const Vec3<T>& vec)
|
||||
{
|
||||
return Vec3<T>(scale * vec.x, scale * vec.y, scale * vec.z);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> operator/(T scale, const Vec3<T>& vec)
|
||||
{
|
||||
return Vec3<T>(scale / vec.x, scale / vec.y, scale / vec.z);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec3<T> operator%(T mod, const Vec3<T>& vec)
|
||||
{
|
||||
return Vec3<T>(Mod(mod, vec.x), Mod(mod, vec.y), Mod(mod, vec.z));
|
||||
}
|
||||
}
|
||||
|
||||
115
ScopEngine/Runtime/Includes/Maths/Vec4.h
git.filemode.executable_file
115
ScopEngine/Runtime/Includes/Maths/Vec4.h
git.filemode.executable_file
@@ -0,0 +1,115 @@
|
||||
#ifndef __SCOP_VEC4__
|
||||
#define __SCOP_VEC4__
|
||||
|
||||
#include <string>
|
||||
#include <limits>
|
||||
#include <cstdint>
|
||||
#include <cmath>
|
||||
|
||||
#include <Core/Logs.h>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T> class Vec2;
|
||||
template<typename T> class Vec3;
|
||||
|
||||
template<typename T>
|
||||
struct Vec4
|
||||
{
|
||||
T x;
|
||||
T y;
|
||||
T z;
|
||||
T w;
|
||||
|
||||
constexpr Vec4() = default;
|
||||
constexpr Vec4(T X, T Y, T Z, T W = 1.0);
|
||||
constexpr Vec4(T X, T Y, const Vec2<T>& vec);
|
||||
constexpr Vec4(T X, const Vec2<T>& vec, T W);
|
||||
constexpr Vec4(T X, const Vec3<T>& vec);
|
||||
constexpr explicit Vec4(T scale);
|
||||
constexpr Vec4(const Vec2<T>& vec, T Z = 0.0, T W = 1.0);
|
||||
constexpr Vec4(const Vec3<T>& vec, T W = 1.0);
|
||||
template<typename U> constexpr explicit Vec4(const Vec4<U>& vec);
|
||||
constexpr Vec4(const Vec4&) = default;
|
||||
constexpr Vec4(Vec4&&) = default;
|
||||
|
||||
T AbsDotProduct(const Vec4& vec) const;
|
||||
constexpr bool ApproxEqual(const Vec4& vec, T max_difference = std::numeric_limits<T>::epsilon()) const;
|
||||
|
||||
constexpr T DotProduct(const Vec4& vec) const;
|
||||
|
||||
Vec4 GetNormal(T* length = nullptr) const;
|
||||
|
||||
constexpr Vec4& Maximize(const Vec4& vec);
|
||||
constexpr Vec4& Minimize(const Vec4& vec);
|
||||
|
||||
Vec4& Normalize(T* length = nullptr);
|
||||
|
||||
std::string ToString() const;
|
||||
|
||||
constexpr Vec4& operator=(const Vec4&) = default;
|
||||
constexpr Vec4& operator=(Vec4&&) = default;
|
||||
|
||||
constexpr T& operator[](std::size_t i);
|
||||
constexpr const T& operator[](std::size_t i) const;
|
||||
|
||||
constexpr const Vec4& operator+() const;
|
||||
constexpr Vec4 operator-() const;
|
||||
|
||||
constexpr Vec4 operator+(const Vec4& vec) const;
|
||||
constexpr Vec4 operator-(const Vec4& vec) const;
|
||||
constexpr Vec4 operator*(const Vec4& vec) const;
|
||||
constexpr Vec4 operator*(T scale) const;
|
||||
constexpr Vec4 operator/(const Vec4& vec) const;
|
||||
constexpr Vec4 operator/(T scale) const;
|
||||
constexpr Vec4 operator%(const Vec4& vec) const;
|
||||
constexpr Vec4 operator%(T mod) const;
|
||||
|
||||
constexpr Vec4& operator+=(const Vec4& vec);
|
||||
constexpr Vec4& operator-=(const Vec4& vec);
|
||||
constexpr Vec4& operator*=(const Vec4& vec);
|
||||
constexpr Vec4& operator*=(T scale);
|
||||
constexpr Vec4& operator/=(const Vec4& vec);
|
||||
constexpr Vec4& operator/=(T scale);
|
||||
constexpr Vec4& operator%=(const Vec4& vec);
|
||||
constexpr Vec4& operator%=(T mod);
|
||||
|
||||
constexpr bool operator==(const Vec4& vec) const;
|
||||
constexpr bool operator!=(const Vec4& vec) const;
|
||||
constexpr bool operator<(const Vec4& vec) const;
|
||||
constexpr bool operator<=(const Vec4& vec) const;
|
||||
constexpr bool operator>(const Vec4& vec) const;
|
||||
constexpr bool operator>=(const Vec4& vec) const;
|
||||
|
||||
static constexpr Vec4 Apply(T(*func)(T), const Vec4& vec);
|
||||
static constexpr bool ApproxEqual(const Vec4& lhs, const Vec4& rhs, T max_difference = std::numeric_limits<T>::epsilon());
|
||||
static constexpr T DotProduct(const Vec4& vec1, const Vec4& vec2);
|
||||
static Vec4 Normalize(const Vec4& vec);
|
||||
static constexpr Vec4 UnitX();
|
||||
static constexpr Vec4 UnitY();
|
||||
static constexpr Vec4 UnitZ();
|
||||
static constexpr Vec4 Zero();
|
||||
|
||||
~Vec4() = default;
|
||||
};
|
||||
|
||||
using Vec4d = Vec4<double>;
|
||||
using Vec4f = Vec4<float>;
|
||||
using Vec4i = Vec4<int>;
|
||||
using Vec4ui = Vec4<unsigned int>;
|
||||
using Vec4i32 = Vec4<std::int32_t>;
|
||||
using Vec4i64 = Vec4<std::int64_t>;
|
||||
using Vec4ui32 = Vec4<std::uint32_t>;
|
||||
using Vec4ui64 = Vec4<std::uint64_t>;
|
||||
|
||||
template<typename T> std::ostream& operator<<(std::ostream& out, const Vec4<T>& vec);
|
||||
|
||||
template<typename T> constexpr Vec4<T> operator*(T scale, const Vec4<T>& vec);
|
||||
template<typename T> constexpr Vec4<T> operator/(T scale, const Vec4<T>& vec);
|
||||
template<typename T> constexpr Vec4<T> operator%(T mod, const Vec4<T>& vec);
|
||||
}
|
||||
|
||||
#include <Maths/Vec4.inl>
|
||||
|
||||
#endif
|
||||
|
||||
424
ScopEngine/Runtime/Includes/Maths/Vec4.inl
git.filemode.executable_file
424
ScopEngine/Runtime/Includes/Maths/Vec4.inl
git.filemode.executable_file
@@ -0,0 +1,424 @@
|
||||
#pragma once
|
||||
|
||||
#include <Maths/Vec4.h>
|
||||
|
||||
namespace Scop
|
||||
{
|
||||
template<typename T>
|
||||
constexpr Vec4<T>::Vec4(T X, T Y, T Z, T W) : x(X), y(Y), z(Z), w(W) {}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>::Vec4(T X, T Y, const Vec2<T>& vec) : x(X), y(Y), z(vec.x), w(vec.y) {}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>::Vec4(T X, const Vec2<T>& vec, T W) : x(X), y(vec.x), z(vec.y), w(W) {}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>::Vec4(T X, const Vec3<T>& vec) : x(X), y(vec.x), z(vec.y), w(vec.z) {}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>::Vec4(T scale) : x(scale), y(scale), z(scale), w(scale) {}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>::Vec4(const Vec2<T>& vec, T Z, T W) : x(vec.x), y(vec.y), z(Z), w(W) {}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>::Vec4(const Vec3<T>& vec, T W) : x(vec.x), y(vec.y), z(vec.z), w(W) {}
|
||||
|
||||
template<typename T>
|
||||
template<typename U>
|
||||
constexpr Vec4<T>::Vec4(const Vec4<U>& vec) : x(static_cast<T>(vec.x)), y(static_cast<T>(vec.y)), z(static_cast<T>(vec.z)), w(static_cast<T>(vec.w)) {}
|
||||
|
||||
template<typename T>
|
||||
T Vec4<T>::AbsDotProduct(const Vec4& vec) const
|
||||
{
|
||||
return std::abs(x * vec.x) + std::abs(y * vec.y) + std::abs(z * vec.z) + std::abs(w * vec.w);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec4<T>::ApproxEqual(const Vec4& vec, T maxDifference) const
|
||||
{
|
||||
return NumberEquals(x, vec.x, maxDifference) && NumberEquals(y, vec.y, maxDifference) && NumberEquals(z, vec.z, maxDifference) && NumberEquals(w, vec.w, maxDifference);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Vec4<T>::DotProduct(const Vec4& vec) const
|
||||
{
|
||||
return x*vec.x + y*vec.y + z*vec.z + w*vec.w;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Vec4<T> Vec4<T>::GetNormal(T* length) const
|
||||
{
|
||||
Vec4<T> vec(*this);
|
||||
vec.Normalize(length);
|
||||
|
||||
return vec;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>& Vec4<T>::Maximize(const Vec4& vec)
|
||||
{
|
||||
if (vec.x > x)
|
||||
x = vec.x;
|
||||
|
||||
if (vec.y > y)
|
||||
y = vec.y;
|
||||
|
||||
if (vec.z > z)
|
||||
z = vec.z;
|
||||
|
||||
if (vec.w > w)
|
||||
w = vec.w;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>& Vec4<T>::Minimize(const Vec4& vec)
|
||||
{
|
||||
if (vec.x < x)
|
||||
x = vec.x;
|
||||
|
||||
if (vec.y < y)
|
||||
y = vec.y;
|
||||
|
||||
if (vec.z < z)
|
||||
z = vec.z;
|
||||
|
||||
if (vec.w < w)
|
||||
w = vec.w;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Vec4<T>& Vec4<T>::Normalize(T* length)
|
||||
{
|
||||
T invLength = T(1.0) / w;
|
||||
x *= invLength;
|
||||
y *= invLength;
|
||||
z *= invLength;
|
||||
|
||||
if (length)
|
||||
*length = w;
|
||||
|
||||
w = T(1.0);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::string Vec4<T>::ToString() const
|
||||
{
|
||||
std::ostringstream ss;
|
||||
ss << *this;
|
||||
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T& Vec4<T>::operator[](std::size_t i)
|
||||
{
|
||||
Scop::Assert(i < 4, "index out of range");
|
||||
return *(&x + i);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr const T& Vec4<T>::operator[](std::size_t i) const
|
||||
{
|
||||
Scop::Assert(i < 4, "index out of range");
|
||||
return *(&x + i);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr const Vec4<T>& Vec4<T>::operator+() const
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Vec4<T>::operator-() const
|
||||
{
|
||||
return Vec4(-x, -y, -z, -w);
|
||||
}
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Vec4<T>::operator+(const Vec4& vec) const
|
||||
{
|
||||
return Vec4(x + vec.x, y + vec.y, z + vec.z, w + vec.w);
|
||||
}
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Vec4<T>::operator-(const Vec4& vec) const
|
||||
{
|
||||
return Vec4(x - vec.x, y - vec.y, z - vec.z, w - vec.w);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Vec4<T>::operator*(const Vec4& vec) const
|
||||
{
|
||||
return Vec4(x * vec.x, y * vec.y, z * vec.z, w * vec.w);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Vec4<T>::operator*(T scale) const
|
||||
{
|
||||
return Vec4(x * scale, y * scale, z * scale, w * scale);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Vec4<T>::operator/(const Vec4& vec) const
|
||||
{
|
||||
return Vec4(x / vec.x, y / vec.y, z / vec.z, w / vec.w);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Vec4<T>::operator/(T scale) const
|
||||
{
|
||||
return Vec4(x / scale, y / scale, z / scale, w / scale);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Vec4<T>::operator%(const Vec4& vec) const
|
||||
{
|
||||
return Vec4(Mod(x, vec.x), Mod(y, vec.y), Mod(z, vec.z), Mod(w, vec.w));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Vec4<T>::operator%(T mod) const
|
||||
{
|
||||
return Vec4(Mod(x, mod), Mod(y, mod), Mod(z, mod), Mod(z, mod));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>& Vec4<T>::operator+=(const Vec4& vec)
|
||||
{
|
||||
x += vec.x;
|
||||
y += vec.y;
|
||||
z += vec.z;
|
||||
w += vec.w;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>& Vec4<T>::operator-=(const Vec4& vec)
|
||||
{
|
||||
x -= vec.x;
|
||||
y -= vec.y;
|
||||
z -= vec.z;
|
||||
w -= vec.w;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>& Vec4<T>::operator*=(const Vec4& vec)
|
||||
{
|
||||
x *= vec.x;
|
||||
y *= vec.y;
|
||||
z *= vec.z;
|
||||
w *= vec.w;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>& Vec4<T>::operator*=(T scale)
|
||||
{
|
||||
x *= scale;
|
||||
y *= scale;
|
||||
z *= scale;
|
||||
w *= scale;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>& Vec4<T>::operator/=(const Vec4& vec)
|
||||
{
|
||||
x /= vec.x;
|
||||
y /= vec.y;
|
||||
z /= vec.z;
|
||||
w /= vec.w;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>& Vec4<T>::operator/=(T scale)
|
||||
{
|
||||
x /= scale;
|
||||
y /= scale;
|
||||
z /= scale;
|
||||
w /= scale;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>& Vec4<T>::operator%=(const Vec4& vec)
|
||||
{
|
||||
x = Mod(x, vec.x);
|
||||
y = Mod(y, vec.y);
|
||||
z = Mod(z, vec.z);
|
||||
w = Mod(w, vec.w);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T>& Vec4<T>::operator%=(T mod)
|
||||
{
|
||||
x = Mod(x, mod);
|
||||
y = Mod(y, mod);
|
||||
z = Mod(z, mod);
|
||||
w = Mod(w, mod);
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec4<T>::operator==(const Vec4& vec) const
|
||||
{
|
||||
return x == vec.x && y == vec.y && z == vec.z && w == vec.w;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec4<T>::operator!=(const Vec4& vec) const
|
||||
{
|
||||
return !operator==(vec);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec4<T>::operator<(const Vec4& vec) const
|
||||
{
|
||||
if (x != vec.x)
|
||||
return x < vec.x;
|
||||
|
||||
if (y != vec.y)
|
||||
return y < vec.y;
|
||||
|
||||
if (z != vec.z)
|
||||
return z < vec.z;
|
||||
|
||||
return w < vec.w;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec4<T>::operator<=(const Vec4& vec) const
|
||||
{
|
||||
if (x != vec.x)
|
||||
return x < vec.x;
|
||||
|
||||
if (y != vec.y)
|
||||
return y < vec.y;
|
||||
|
||||
if (z != vec.z)
|
||||
return z < vec.z;
|
||||
|
||||
return w <= vec.w;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec4<T>::operator>(const Vec4& vec) const
|
||||
{
|
||||
if (x != vec.x)
|
||||
return x > vec.x;
|
||||
|
||||
if (y != vec.y)
|
||||
return y > vec.y;
|
||||
|
||||
if (z != vec.z)
|
||||
return z > vec.z;
|
||||
|
||||
return w > vec.w;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec4<T>::operator>=(const Vec4& vec) const
|
||||
{
|
||||
if (x != vec.x)
|
||||
return x > vec.x;
|
||||
|
||||
if (y != vec.y)
|
||||
return y > vec.y;
|
||||
|
||||
if (z != vec.z)
|
||||
return z > vec.z;
|
||||
|
||||
return w >= vec.w;
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Vec4<T>::Apply(T(*func)(T), const Vec4& vec)
|
||||
{
|
||||
return Vec4(func(vec.x), func(vec.y), func(vec.z), func(vec.w));
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr bool Vec4<T>::ApproxEqual(const Vec4& lhs, const Vec4& rhs, T maxDifference)
|
||||
{
|
||||
return lhs.ApproxEqual(rhs, maxDifference);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr T Vec4<T>::DotProduct(const Vec4& vec1, const Vec4& vec2)
|
||||
{
|
||||
return vec1.DotProduct(vec2);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
Vec4<T> Vec4<T>::Normalize(const Vec4& vec)
|
||||
{
|
||||
return vec.GetNormal();
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Vec4<T>::UnitX()
|
||||
{
|
||||
return Vec4(1, 0, 0, 1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Vec4<T>::UnitY()
|
||||
{
|
||||
return Vec4(0, 1, 0, 1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Vec4<T>::UnitZ()
|
||||
{
|
||||
return Vec4(0, 0, 1, 1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> Vec4<T>::Zero()
|
||||
{
|
||||
return Vec4(0, 0, 0, 1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
std::ostream& operator<<(std::ostream& out, const Vec4<T>& vec)
|
||||
{
|
||||
return out << "Vec4(" << vec.x << ", " << vec.y << ", " << vec.z << ", " << vec.w << ')';
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> operator*(T scale, const Vec4<T>& vec)
|
||||
{
|
||||
return Vec4<T>(scale * vec.x, scale * vec.y, scale * vec.z, scale * vec.w);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> operator/(T scale, const Vec4<T>& vec)
|
||||
{
|
||||
return Vec4<T>(scale / vec.x, scale / vec.y, scale / vec.z, scale / vec.w);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
constexpr Vec4<T> operator%(T mod, const Vec4<T>& vec)
|
||||
{
|
||||
return Vec4<T>(Mod(mod, vec.x), Mod(mod, vec.y), Mod(mod, vec.z), Mod(mod, vec.w));
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user