SuperMarioOdysseyOnline/include/sead/math/seadVector.h

260 lines
6.6 KiB
C
Raw Normal View History

2022-06-16 21:33:18 +00:00
#pragma once
#include <basis/seadTypes.h>
#include <cmath>
#include <math/seadMathPolicies.h>
#include <math/seadVectorCalcCommon.h>
namespace sead
{
template <typename T>
struct Vector2 : public Policies<T>::Vec2Base
{
/// @warning This constructor leaves member variables uninitialized.
Vector2() {}
Vector2(const Vector2& other) = default;
Vector2(T x, T y);
Vector2& operator=(const Vector2& other);
Vector2& operator+=(const Vector2& other);
friend Vector2 operator+(const Vector2& a, const Vector2& b)
{
Vector2 o;
Vector2CalcCommon<T>::add(o, a, b);
return o;
}
Vector2& operator-=(const Vector2& other);
friend Vector2 operator-(const Vector2& a, const Vector2& b)
{
Vector2 o;
Vector2CalcCommon<T>::sub(o, a, b);
return o;
}
Vector2& operator*=(T t);
friend Vector2 operator*(const Vector2& a, T t)
{
Vector2 o;
o.x = a.x * t;
o.y = a.y * t;
return o;
}
friend Vector2 operator*(T t, const Vector2& a) { return operator*(a, t); }
Vector2& operator/=(T t);
friend Vector2 operator/(const Vector2& a, T t) { return {a.x / t, a.y / t}; }
bool operator==(const Vector2& rhs) const { return this->x == rhs.x && this->y == rhs.y; }
bool operator!=(const Vector2& rhs) const { return !operator==(rhs); }
void set(const Vector2& other);
void set(T x_, T y_);
static const Vector2 zero;
static const Vector2 ex;
static const Vector2 ey;
static const Vector2 ones;
};
template <typename T>
struct Vector3 : public Policies<T>::Vec3Base
{
using Mtx33 = typename Policies<T>::Mtx33Base;
using Mtx34 = typename Policies<T>::Mtx34Base;
/// @warning This constructor leaves member variables uninitialized.
Vector3() {}
Vector3(const Vector3& other) = default;
Vector3(T x, T y, T z);
Vector3& operator=(const Vector3& other);
bool operator==(const Vector3& rhs) const;
bool operator!=(const Vector3& rhs) const;
Vector3& operator+=(const Vector3& other);
friend Vector3 operator+(const Vector3& a, const Vector3& b)
{
Vector3 o;
Vector3CalcCommon<T>::add(o, a, b);
return o;
}
Vector3& operator-=(const Vector3& other);
friend Vector3 operator-(const Vector3& a, const Vector3& b)
{
Vector3 o;
Vector3CalcCommon<T>::sub(o, a, b);
return o;
}
Vector3& operator*=(T t);
Vector3& operator*=(const Mtx33& m);
Vector3& operator*=(const Mtx34& m);
friend Vector3 operator*(const Vector3& a, T t)
{
Vector3 o;
Vector3CalcCommon<T>::multScalar(o, a, t);
return o;
}
friend Vector3 operator*(T t, const Vector3& a) { return operator*(a, t); }
friend Vector3 operator*(const Mtx33& m, const Vector3& a)
{
Vector3 o;
o.setMul(m, a);
return o;
}
friend Vector3 operator*(const Mtx34& m, const Vector3& a)
{
Vector3 o;
o.setMul(m, a);
return o;
}
Vector3& operator/=(T t);
friend Vector3 operator/(const Vector3& a, T t) { return {a.x / t, a.y / t, a.z / t}; }
Vector3 operator-() const { return {-this->x, -this->y, -this->z}; }
T dot(const Vector3& t) const;
T length() const;
T squaredLength() const;
/// Checks if the differences of all components of lhs and rhs are within `epsilon`.
/// (i.e. -epsilon <= lhs.x - rhs.x <= epsilon, and so on).
bool equals(const Vector3& rhs, T epsilon = 0) const;
void add(const Vector3& a);
/// Multiply m by this vector (self = m * self).
void mul(const Mtx33& m);
/// Apply a transformation `m` (rotation + translation) to this vector.
void mul(const Mtx34& m);
void multScalar(T t);
T normalize();
void set(const Vector3& other);
void set(T x, T y, T z);
void setCross(const Vector3<T>& a, const Vector3<T>& b);
void setScaleAdd(T t, const Vector3<T>& a, const Vector3<T>& b);
void setMul(const Mtx33& m, const Vector3& a);
void setMul(const Mtx34& m, const Vector3& a);
static const Vector3 zero;
static const Vector3 ex;
static const Vector3 ey;
static const Vector3 ez;
static const Vector3 ones;
};
template <typename T>
struct Vector4 : public Policies<T>::Vec4Base
{
/// @warning This constructor leaves member variables uninitialized.
Vector4() {}
Vector4(const Vector4& other) = default;
Vector4(T x, T y, T z, T w);
Vector4& operator=(const Vector4& other);
Vector4& operator+=(const Vector4& other);
friend Vector4 operator+(const Vector4& a, const Vector4& b)
{
return {a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w};
}
Vector4& operator-=(const Vector4& other);
friend Vector4 operator-(const Vector4& a, const Vector4& b)
{
return {a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w};
}
Vector4& operator*=(T t);
friend Vector4 operator*(const Vector4& a, T t) { return {a.x * t, a.y * t, a.z * t, a.w * t}; }
friend Vector4 operator*(T t, const Vector4& a) { return operator*(a, t); }
Vector4& operator/=(T t);
friend Vector4 operator/(const Vector4& a, T t) { return {a.x / t, a.y / t, a.z / t, a.w / t}; }
bool operator==(const Vector4& rhs) const
{
return this->x == rhs.x && this->y == rhs.y && this->z == rhs.z && this->w == rhs.w;
}
bool operator!=(const Vector4& rhs) const { return !operator==(rhs); }
void set(const Vector4& v);
void set(T x_, T y_, T z_, T w_);
static const Vector4 zero;
static const Vector4 ex;
static const Vector4 ey;
static const Vector4 ez;
static const Vector4 ew;
static const Vector4 ones;
};
typedef Vector2<f32> Vector2f;
typedef Vector3<f32> Vector3f;
typedef Vector4<f32> Vector4f;
template <>
const Vector2<f32> Vector2<f32>::zero;
template <>
const Vector2<f32> Vector2<f32>::ex;
template <>
const Vector2<f32> Vector2<f32>::ey;
template <>
const Vector2<f32> Vector2<f32>::ones;
template <>
const Vector3<f32> Vector3<f32>::zero;
template <>
const Vector3<f32> Vector3<f32>::ex;
template <>
const Vector3<f32> Vector3<f32>::ey;
template <>
const Vector3<f32> Vector3<f32>::ez;
template <>
const Vector3<f32> Vector3<f32>::ones;
template <>
const Vector4<f32> Vector4<f32>::zero;
template <>
const Vector4<f32> Vector4<f32>::ex;
template <>
const Vector4<f32> Vector4<f32>::ey;
template <>
const Vector4<f32> Vector4<f32>::ez;
template <>
const Vector4<f32> Vector4<f32>::ew;
template <>
const Vector4<f32> Vector4<f32>::ones;
} // namespace sead
#define SEAD_MATH_VECTOR_H_
#include <math/seadVector.hpp>
#undef SEAD_MATH_VECTOR_H_