AxioDL
/
zeus
mirror of https://github.com/AxioDL/zeus.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove error-causing constexprs

This commit is contained in:
Luke Street 2022-05-31 20:17:23 -04:00
parent 8410394d4b
commit 6547f76752
8 changed files with 61 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/zeus/CMatrix3f.hpp
View File

@ -23,13 +23,13 @@ public:
constexpr CMatrix3f(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22) constexpr CMatrix3f(float m00, float m01, float m02, float m10, float m11, float m12, float m20, float m21, float m22)
: m{{{m00, m10, m20}, {m01, m11, m21}, {m02, m12, m22}}} {} : m{{{m00, m10, m20}, {m01, m11, m21}, {m02, m12, m22}}} {}
constexpr CMatrix3f(const CVector3f& scaleVec) { CMatrix3f(const CVector3f& scaleVec) {
m[0][0] = scaleVec[0]; m[0][0] = scaleVec[0];
m[1][1] = scaleVec[1]; m[1][1] = scaleVec[1];
m[2][2] = scaleVec[2]; m[2][2] = scaleVec[2];
} }
constexpr CMatrix3f(float scale) : CMatrix3f(CVector3f(scale)) {} CMatrix3f(float scale) : CMatrix3f(CVector3f(scale)) {}
constexpr CMatrix3f(const CVector3f& r0, const CVector3f& r1, const CVector3f& r2) : m{{r0, r1, r2}} {} constexpr CMatrix3f(const CVector3f& r0, const CVector3f& r1, const CVector3f& r2) : m{{r0, r1, r2}} {}

20
include/zeus/CQuaternion.hpp
View File

@ -48,26 +48,26 @@ public:
return *this; return *this;
} }
[[nodiscard]] constexpr CQuaternion operator+(const CQuaternion& q) const { return mSimd + q.mSimd; } [[nodiscard]] CQuaternion operator+(const CQuaternion& q) const { return mSimd + q.mSimd; }
[[nodiscard]] constexpr CQuaternion operator-(const CQuaternion& q) const { return mSimd - q.mSimd; } [[nodiscard]] CQuaternion operator-(const CQuaternion& q) const { return mSimd - q.mSimd; }
[[nodiscard]] constexpr CQuaternion operator*(const CQuaternion& q) const { [[nodiscard]] CQuaternion operator*(const CQuaternion& q) const {
return CQuaternion(w() * q.w() - CVector3f(x(), y(), z()).dot({q.x(), q.y(), q.z()}), return CQuaternion(w() * q.w() - CVector3f(x(), y(), z()).dot({q.x(), q.y(), q.z()}),
y() * q.z() - z() * q.y() + w() * q.x() + x() * q.w(), y() * q.z() - z() * q.y() + w() * q.x() + x() * q.w(),
z() * q.x() - x() * q.z() + w() * q.y() + y() * q.w(), z() * q.x() - x() * q.z() + w() * q.y() + y() * q.w(),
x() * q.y() - y() * q.x() + w() * q.z() + z() * q.w()); x() * q.y() - y() * q.x() + w() * q.z() + z() * q.w());
} }
[[nodiscard]] constexpr CQuaternion operator/(const CQuaternion& q) const { [[nodiscard]] CQuaternion operator/(const CQuaternion& q) const {
return *this * q.inverse(); return *this * q.inverse();
} }
[[nodiscard]] constexpr CQuaternion operator*(float scale) const { return mSimd * simd<float>(scale); } [[nodiscard]] CQuaternion operator*(float scale) const { return mSimd * simd<float>(scale); }
[[nodiscard]] constexpr CQuaternion operator/(float scale) const { return mSimd / simd<float>(scale); } [[nodiscard]] CQuaternion operator/(float scale) const { return mSimd / simd<float>(scale); }
[[nodiscard]] constexpr CQuaternion operator-() const { return -mSimd; } [[nodiscard]] CQuaternion operator-() const { return -mSimd; }
const CQuaternion& operator+=(const CQuaternion& q) { const CQuaternion& operator+=(const CQuaternion& q) {
mSimd += q.mSimd; mSimd += q.mSimd;
@ -103,7 +103,7 @@ public:
void invert() { mSimd *= InvertQuat; } void invert() { mSimd *= InvertQuat; }
[[nodiscard]] constexpr CQuaternion inverse() const { return mSimd * InvertQuat; } [[nodiscard]] CQuaternion inverse() const { return mSimd * InvertQuat; }
/** /**
* @brief Set the rotation using axis angle notation * @brief Set the rotation using axis angle notation
@ -248,14 +248,14 @@ public:
return mSimd * simd<float>(magDiv); return mSimd * simd<float>(magDiv);
} }
[[nodiscard]] constexpr CNUQuaternion operator*(const CNUQuaternion& q) const { [[nodiscard]] CNUQuaternion operator*(const CNUQuaternion& q) const {
return CNUQuaternion(w() * q.w() - CVector3f(x(), y(), z()).dot({q.x(), q.y(), q.z()}), return CNUQuaternion(w() * q.w() - CVector3f(x(), y(), z()).dot({q.x(), q.y(), q.z()}),
y() * q.z() - z() * q.y() + w() * q.x() + x() * q.w(), y() * q.z() - z() * q.y() + w() * q.x() + x() * q.w(),
z() * q.x() - x() * q.z() + w() * q.y() + y() * q.w(), z() * q.x() - x() * q.z() + w() * q.y() + y() * q.w(),
x() * q.y() - y() * q.x() + w() * q.z() + z() * q.w()); x() * q.y() - y() * q.x() + w() * q.z() + z() * q.w());
} }
[[nodiscard]] constexpr CNUQuaternion operator*(float f) const { return mSimd * simd<float>(f); } [[nodiscard]] CNUQuaternion operator*(float f) const { return mSimd * simd<float>(f); }
const CNUQuaternion& operator+=(const CNUQuaternion& q) { const CNUQuaternion& operator+=(const CNUQuaternion& q) {
mSimd += q.mSimd; mSimd += q.mSimd;

18
include/zeus/CVector2d.hpp
View File

@ -46,23 +46,23 @@ public:
return mSimd[0] >= rhs.mSimd[0] && mSimd[1] >= rhs.mSimd[1]; return mSimd[0] >= rhs.mSimd[0] && mSimd[1] >= rhs.mSimd[1];
} }
[[nodiscard]] constexpr CVector2d operator+(const CVector2d& rhs) const { return mSimd + rhs.mSimd; } [[nodiscard]] CVector2d operator+(const CVector2d& rhs) const { return mSimd + rhs.mSimd; }
[[nodiscard]] constexpr CVector2d operator-(const CVector2d& rhs) const { return mSimd - rhs.mSimd; } [[nodiscard]] CVector2d operator-(const CVector2d& rhs) const { return mSimd - rhs.mSimd; }
[[nodiscard]] constexpr CVector2d operator-() const { return -mSimd; } [[nodiscard]] CVector2d operator-() const { return -mSimd; }
[[nodiscard]] constexpr CVector2d operator*(const CVector2d& rhs) const { return mSimd * rhs.mSimd; } [[nodiscard]] CVector2d operator*(const CVector2d& rhs) const { return mSimd * rhs.mSimd; }
[[nodiscard]] constexpr CVector2d operator/(const CVector2d& rhs) const { return mSimd / rhs.mSimd; } [[nodiscard]] CVector2d operator/(const CVector2d& rhs) const { return mSimd / rhs.mSimd; }
[[nodiscard]] constexpr CVector2d operator+(double val) const { return mSimd + simd<double>(val); } [[nodiscard]] CVector2d operator+(double val) const { return mSimd + simd<double>(val); }
[[nodiscard]] constexpr CVector2d operator-(double val) const { return mSimd - simd<double>(val); } [[nodiscard]] CVector2d operator-(double val) const { return mSimd - simd<double>(val); }
[[nodiscard]] constexpr CVector2d operator*(double val) const { return mSimd * simd<double>(val); } [[nodiscard]] CVector2d operator*(double val) const { return mSimd * simd<double>(val); }
[[nodiscard]] constexpr CVector2d operator/(double val) const { [[nodiscard]] CVector2d operator/(double val) const {
double ooval = 1.0 / val; double ooval = 1.0 / val;
return mSimd * simd<double>(ooval); return mSimd * simd<double>(ooval);
} }

18
include/zeus/CVector2f.hpp
View File

@ -46,23 +46,23 @@ public:
return mSimd[0] >= rhs.mSimd[0] && mSimd[1] >= rhs.mSimd[1]; return mSimd[0] >= rhs.mSimd[0] && mSimd[1] >= rhs.mSimd[1];
} }
[[nodiscard]] constexpr CVector2f operator+(const CVector2f& rhs) const { return mSimd + rhs.mSimd; } [[nodiscard]] CVector2f operator+(const CVector2f& rhs) const { return mSimd + rhs.mSimd; }
[[nodiscard]] constexpr CVector2f operator-(const CVector2f& rhs) const { return mSimd - rhs.mSimd; } [[nodiscard]] CVector2f operator-(const CVector2f& rhs) const { return mSimd - rhs.mSimd; }
[[nodiscard]] constexpr CVector2f operator-() const { return -mSimd; } [[nodiscard]] CVector2f operator-() const { return -mSimd; }
[[nodiscard]] constexpr CVector2f operator*(const CVector2f& rhs) const { return mSimd * rhs.mSimd; } [[nodiscard]] CVector2f operator*(const CVector2f& rhs) const { return mSimd * rhs.mSimd; }
[[nodiscard]] constexpr CVector2f operator/(const CVector2f& rhs) const { return mSimd / rhs.mSimd; } [[nodiscard]] CVector2f operator/(const CVector2f& rhs) const { return mSimd / rhs.mSimd; }
[[nodiscard]] constexpr CVector2f operator+(float val) const { return mSimd + simd<float>(val); } [[nodiscard]] CVector2f operator+(float val) const { return mSimd + simd<float>(val); }
[[nodiscard]] constexpr CVector2f operator-(float val) const { return mSimd - simd<float>(val); } [[nodiscard]] CVector2f operator-(float val) const { return mSimd - simd<float>(val); }
[[nodiscard]] constexpr CVector2f operator*(float val) const { return mSimd * simd<float>(val); } [[nodiscard]] CVector2f operator*(float val) const { return mSimd * simd<float>(val); }
[[nodiscard]] constexpr CVector2f operator/(float val) const { [[nodiscard]] CVector2f operator/(float val) const {
float ooval = 1.f / val; float ooval = 1.f / val;
return mSimd * simd<float>(ooval); return mSimd * simd<float>(ooval);
} }

8
include/zeus/CVector3d.hpp
View File

@ -43,13 +43,13 @@ public:
void zeroOut() { mSimd = zeus::simd<double>(0.0); } void zeroOut() { mSimd = zeus::simd<double>(0.0); }
[[nodiscard]] constexpr CVector3d operator+(const CVector3d& rhs) const { return mSimd + rhs.mSimd; } [[nodiscard]] CVector3d operator+(const CVector3d& rhs) const { return mSimd + rhs.mSimd; }
[[nodiscard]] constexpr CVector3d operator-(const CVector3d& rhs) const { return mSimd - rhs.mSimd; } [[nodiscard]] CVector3d operator-(const CVector3d& rhs) const { return mSimd - rhs.mSimd; }
[[nodiscard]] constexpr CVector3d operator*(const CVector3d& rhs) const { return mSimd * rhs.mSimd; } [[nodiscard]] CVector3d operator*(const CVector3d& rhs) const { return mSimd * rhs.mSimd; }
[[nodiscard]] constexpr CVector3d operator/(const CVector3d& rhs) const { return mSimd / rhs.mSimd; } [[nodiscard]] CVector3d operator/(const CVector3d& rhs) const { return mSimd / rhs.mSimd; }
[[nodiscard]] simd<double>::reference operator[](size_t idx) { [[nodiscard]] simd<double>::reference operator[](size_t idx) {
assert(idx < 3); assert(idx < 3);

18
include/zeus/CVector3f.hpp
View File

@ -49,23 +49,23 @@ public:
[[nodiscard]] simd<float>::mask_type operator<(const CVector3f& rhs) const { return mSimd < rhs.mSimd; } [[nodiscard]] simd<float>::mask_type operator<(const CVector3f& rhs) const { return mSimd < rhs.mSimd; }
[[nodiscard]] simd<float>::mask_type operator<=(const CVector3f& rhs) const { return mSimd <= rhs.mSimd; } [[nodiscard]] simd<float>::mask_type operator<=(const CVector3f& rhs) const { return mSimd <= rhs.mSimd; }
[[nodiscard]] constexpr CVector3f operator+(const CVector3f& rhs) const { return mSimd + rhs.mSimd; } [[nodiscard]] CVector3f operator+(const CVector3f& rhs) const { return mSimd + rhs.mSimd; }
[[nodiscard]] constexpr CVector3f operator-(const CVector3f& rhs) const { return mSimd - rhs.mSimd; } [[nodiscard]] CVector3f operator-(const CVector3f& rhs) const { return mSimd - rhs.mSimd; }
[[nodiscard]] constexpr CVector3f operator-() const { return -mSimd; } [[nodiscard]] CVector3f operator-() const { return -mSimd; }
[[nodiscard]] constexpr CVector3f operator*(const CVector3f& rhs) const { return mSimd * rhs.mSimd; } [[nodiscard]] CVector3f operator*(const CVector3f& rhs) const { return mSimd * rhs.mSimd; }
[[nodiscard]] constexpr CVector3f operator/(const CVector3f& rhs) const { return mSimd / rhs.mSimd; } [[nodiscard]] CVector3f operator/(const CVector3f& rhs) const { return mSimd / rhs.mSimd; }
[[nodiscard]] constexpr CVector3f operator+(float val) const { return mSimd + val; } [[nodiscard]] CVector3f operator+(float val) const { return mSimd + val; }
[[nodiscard]] constexpr CVector3f operator-(float val) const { return mSimd - val; } [[nodiscard]] CVector3f operator-(float val) const { return mSimd - val; }
[[nodiscard]] constexpr CVector3f operator*(float val) const { return mSimd * val; } [[nodiscard]] CVector3f operator*(float val) const { return mSimd * val; }
[[nodiscard]] constexpr CVector3f operator/(float val) const { return mSimd / val; } [[nodiscard]] CVector3f operator/(float val) const { return mSimd / val; }
const CVector3f& operator+=(const CVector3f& rhs) { const CVector3f& operator+=(const CVector3f& rhs) {
mSimd += rhs.mSimd; mSimd += rhs.mSimd;

18
include/zeus/CVector4d.hpp
View File

@ -69,23 +69,23 @@ public:
return eq_mask[0] && eq_mask[1] && eq_mask[2] && eq_mask[3]; return eq_mask[0] && eq_mask[1] && eq_mask[2] && eq_mask[3];
} }
[[nodiscard]] constexpr CVector4d operator+(const CVector4d& rhs) const { return mSimd + rhs.mSimd; } [[nodiscard]] CVector4d operator+(const CVector4d& rhs) const { return mSimd + rhs.mSimd; }
[[nodiscard]] constexpr CVector4d operator-(const CVector4d& rhs) const { return mSimd - rhs.mSimd; } [[nodiscard]] CVector4d operator-(const CVector4d& rhs) const { return mSimd - rhs.mSimd; }
[[nodiscard]] constexpr CVector4d operator-() const { return -mSimd; } [[nodiscard]] CVector4d operator-() const { return -mSimd; }
[[nodiscard]] constexpr CVector4d operator*(const CVector4d& rhs) const { return mSimd * rhs.mSimd; } [[nodiscard]] CVector4d operator*(const CVector4d& rhs) const { return mSimd * rhs.mSimd; }
[[nodiscard]] constexpr CVector4d operator/(const CVector4d& rhs) const { return mSimd / rhs.mSimd; } [[nodiscard]] CVector4d operator/(const CVector4d& rhs) const { return mSimd / rhs.mSimd; }
[[nodiscard]] constexpr CVector4d operator+(double val) const { return mSimd + zeus::simd<double>(val); } [[nodiscard]] CVector4d operator+(double val) const { return mSimd + zeus::simd<double>(val); }
[[nodiscard]] constexpr CVector4d operator-(double val) const { return mSimd - zeus::simd<double>(val); } [[nodiscard]] CVector4d operator-(double val) const { return mSimd - zeus::simd<double>(val); }
[[nodiscard]] constexpr CVector4d operator*(double val) const { return mSimd * zeus::simd<double>(val); } [[nodiscard]] CVector4d operator*(double val) const { return mSimd * zeus::simd<double>(val); }
[[nodiscard]] constexpr CVector4d operator/(double val) const { [[nodiscard]] CVector4d operator/(double val) const {
double ooval = 1.0 / val; double ooval = 1.0 / val;
return mSimd * zeus::simd<double>(ooval); return mSimd * zeus::simd<double>(ooval);
} }

18
include/zeus/CVector4f.hpp
View File

@ -69,23 +69,23 @@ public:
return eq_mask[0] && eq_mask[1] && eq_mask[2] && eq_mask[3]; return eq_mask[0] && eq_mask[1] && eq_mask[2] && eq_mask[3];
} }
[[nodiscard]] constexpr CVector4f operator+(const CVector4f& rhs) const { return mSimd + rhs.mSimd; } [[nodiscard]] CVector4f operator+(const CVector4f& rhs) const { return mSimd + rhs.mSimd; }
[[nodiscard]] constexpr CVector4f operator-(const CVector4f& rhs) const { return mSimd - rhs.mSimd; } [[nodiscard]] CVector4f operator-(const CVector4f& rhs) const { return mSimd - rhs.mSimd; }
[[nodiscard]] constexpr CVector4f operator-() const { return -mSimd; } [[nodiscard]] CVector4f operator-() const { return -mSimd; }
[[nodiscard]] constexpr CVector4f operator*(const CVector4f& rhs) const { return mSimd * rhs.mSimd; } [[nodiscard]] CVector4f operator*(const CVector4f& rhs) const { return mSimd * rhs.mSimd; }
[[nodiscard]] constexpr CVector4f operator/(const CVector4f& rhs) const { return mSimd / rhs.mSimd; } [[nodiscard]] CVector4f operator/(const CVector4f& rhs) const { return mSimd / rhs.mSimd; }
[[nodiscard]] constexpr CVector4f operator+(float val) const { return mSimd + zeus::simd<float>(val); } [[nodiscard]] CVector4f operator+(float val) const { return mSimd + zeus::simd<float>(val); }
[[nodiscard]] constexpr CVector4f operator-(float val) const { return mSimd - zeus::simd<float>(val); } [[nodiscard]] CVector4f operator-(float val) const { return mSimd - zeus::simd<float>(val); }
[[nodiscard]] constexpr CVector4f operator*(float val) const { return mSimd * zeus::simd<float>(val); } [[nodiscard]] CVector4f operator*(float val) const { return mSimd * zeus::simd<float>(val); }
[[nodiscard]] constexpr CVector4f operator/(float val) const { [[nodiscard]] CVector4f operator/(float val) const {
float ooval = 1.f / val; float ooval = 1.f / val;
return mSimd * zeus::simd<float>(ooval); return mSimd * zeus::simd<float>(ooval);
} }