constexpr refactor

CMakeLists.txt

@@ -10,7 +10,6 @@ endif()
 include_directories(include ${ATHENA_INCLUDE_DIR})
 
 set(SOURCES
-    src/CAxisAngle.cpp
     src/CVector3f.cpp
     src/Math.cpp
     src/CQuaternion.cpp
@@ -21,7 +20,6 @@ set(SOURCES
     src/CTransform.cpp
     src/CColor.cpp
     src/CVector2f.cpp
-    src/CVector4f.cpp
     src/CMatrix4f.cpp
     src/CAABox.cpp
     src/COBBox.cpp

include/zeus/CAABox.hpp

@@ -20,20 +20,17 @@ public:
 
   enum class EBoxFaceID {};
 
-  static const CAABox skInvertedBox;
-  static const CAABox skNullBox;
-
   CVector3f min;
   CVector3f max;
 
   // set default AABox to insane inverse min/max to allow for accumulation
-  CAABox() : CAABox(1e16f, -1e16f) {}
+  constexpr CAABox() : CAABox(1e16f, -1e16f) {}
 
-  CAABox(const CVector3f& min, const CVector3f& max) : min(min), max(max) {}
+  constexpr CAABox(const CVector3f& min, const CVector3f& max) : min(min), max(max) {}
 
-  CAABox(float min, float max) : min(CVector3f(min)), max(CVector3f(max)) {}
+  constexpr CAABox(float min, float max) : min(CVector3f(min)), max(CVector3f(max)) {}
 
-  CAABox(float minX, float minY, float minZ, float maxX, float maxY, float maxZ)
+  constexpr CAABox(float minX, float minY, float minZ, float maxX, float maxY, float maxZ)
   : min(minX, minY, minZ), max(maxX, maxY, maxZ) {}
 
 #if ZE_ATHENA_TYPES
@@ -299,6 +296,8 @@ public:
       return max[idx - 3];
   }
 };
+constexpr CAABox skInvertedBox;
+constexpr CAABox skNullBox(CVector3f{}, CVector3f{});
 
 inline bool operator==(const CAABox& left, const CAABox& right) {
   return (left.min == right.min && left.max == right.max);

include/zeus/CAxisAngle.hpp

@@ -6,12 +6,11 @@
 
 namespace zeus {
 struct CAxisAngle : CVector3f {
-  CAxisAngle() = default;
+  constexpr CAxisAngle() = default;
-  CAxisAngle(float x, float y, float z) : CVector3f(x, y, z) {}
+  constexpr CAxisAngle(float x, float y, float z) : CVector3f(x, y, z) {}
   CAxisAngle(const CUnitVector3f& axis, float angle) : CVector3f(angle * axis) {}
-  CAxisAngle(const CVector3f& axisAngle) : CVector3f(axisAngle) {}
+  constexpr CAxisAngle(const CVector3f& axisAngle) : CVector3f(axisAngle) {}
   float angle() const { return magnitude(); }
   const CVector3f& getVector() const { return *this; }
-  static const CAxisAngle sIdentity;
 };
 } // namespace zeus

include/zeus/CColor.hpp

@@ -42,37 +42,33 @@ class CVector4f;
 class CColor {
 public:
   simd<float> mSimd;
-  static const CColor skRed;
-  static const CColor skBlack;
-  static const CColor skBlue;
-  static const CColor skGreen;
-  static const CColor skGrey;
-  static const CColor skOrange;
-  static const CColor skPurple;
-  static const CColor skYellow;
-  static const CColor skWhite;
-  static const CColor skClear;
 
-  CColor() : mSimd(1.f) {}
+  constexpr CColor() : mSimd(1.f) {}
 
-  CColor(float rgb, float a = 1.0) { splat(rgb, a); }
+  constexpr CColor(float rgb, float a = 1.0) : mSimd(rgb, rgb, rgb, a) {}
 
-  CColor(float r, float g, float b, float a = 1.0f) : mSimd(r, g, b, a) {}
+  constexpr CColor(float r, float g, float b, float a = 1.0f) : mSimd(r, g, b, a) {}
 
 #if ZE_ATHENA_TYPES
 
-  CColor(const atVec4f& vec) : mSimd(vec.simd) {}
+  constexpr CColor(const atVec4f& vec) : mSimd(vec.simd) {}
 
 #endif
 
-  CColor(Comp32 rgba) { fromRGBA32(rgba); }
+  constexpr CColor(Comp32 rgba) : mSimd(((COLOR(rgba) >> 0) & 0xff) * OneOver255,
+                                        ((COLOR(rgba) >> 8) & 0xff) * OneOver255,
+                                        ((COLOR(rgba) >> 16) & 0xff) * OneOver255,
+                                        ((COLOR(rgba) >> 24) & 0xff) * OneOver255) {}
 
-  CColor(const Comp8* rgba) { fromRGBA8(rgba[0], rgba[1], rgba[2], rgba[3]); }
+  constexpr CColor(const Comp8* rgba) : mSimd(rgba[0] * OneOver255,
+                                              rgba[1] * OneOver255,
+                                              rgba[2] * OneOver255,
+                                              rgba[3] * OneOver255) {}
 
-  CColor(const CVector4f& other) : mSimd(other.mSimd) {}
+  constexpr CColor(const CVector4f& other) : mSimd(other.mSimd) {}
 
   template <typename T>
-  CColor(const simd<T>& s) : mSimd(s) {}
+  constexpr CColor(const simd<T>& s) : mSimd(s) {}
 
   CColor& operator=(const CVector4f& other) {
     mSimd = other.mSimd;
@@ -237,7 +233,7 @@ public:
   }
 
   void fromRGBA32(Comp32 rgba) {
-    static RGBA32 tmp;
+    RGBA32 tmp;
     tmp.rgba = COLOR(rgba);
     fromRGBA8(tmp.r, tmp.g, tmp.b, tmp.a);
   }
@@ -300,12 +296,29 @@ public:
   simd<float>::reference b() { return mSimd[2]; }
   simd<float>::reference a() { return mSimd[3]; }
 };
+constexpr CVector4f::CVector4f(const zeus::CColor& other) : mSimd(other.mSimd) {}
 
-static inline CColor operator+(float lhs, const CColor& rhs) { return simd<float>(lhs) + rhs.mSimd; }
+constexpr CVector4f& CVector4f::operator=(const CColor& other) {
+  mSimd = other.mSimd;
+  return *this;
+}
 
-static inline CColor operator-(float lhs, const CColor& rhs) { return simd<float>(lhs) - rhs.mSimd; }
+constexpr CColor skRed(1.f, 0.f, 0.f, 1.f);
+constexpr CColor skBlack(0.f, 0.f, 0.f, 1.f);
+constexpr CColor skBlue(0.f, 0.f, 1.f, 1.f);
+constexpr CColor skGreen(0.f, 1.f, 0.f, 1.f);
+constexpr CColor skGrey(0.5f, 0.5f, 0.5f, 1.f);
+constexpr CColor skOrange(1.f, 0.43f, 0.f, 1.f);
+constexpr CColor skPurple(0.63f, 0.f, 1.f, 1.f);
+constexpr CColor skYellow(1.f, 1.f, 0.f, 1.f);
+constexpr CColor skWhite(1.f, 1.f, 1.f, 1.f);
+constexpr CColor skClear(0.f, 0.f, 0.f, 0.f);
 
-static inline CColor operator*(float lhs, const CColor& rhs) { return simd<float>(lhs) * rhs.mSimd; }
+inline CColor operator+(float lhs, const CColor& rhs) { return simd<float>(lhs) + rhs.mSimd; }
 
-static inline CColor operator/(float lhs, const CColor& rhs) { return simd<float>(lhs) / rhs.mSimd; }
+inline CColor operator-(float lhs, const CColor& rhs) { return simd<float>(lhs) - rhs.mSimd; }
+
+inline CColor operator*(float lhs, const CColor& rhs) { return simd<float>(lhs) * rhs.mSimd; }
+
+inline CColor operator/(float lhs, const CColor& rhs) { return simd<float>(lhs) / rhs.mSimd; }
 } // namespace zeus

include/zeus/CEulerAngles.hpp

@@ -7,7 +7,7 @@ class CQuaternion;
 
 class CEulerAngles : public CVector3f {
 public:
-  CEulerAngles(float x, float y, float z) { assign(x, y, z); }
+  constexpr CEulerAngles(float x, float y, float z) : CVector3f(x, y, z) {}
   CEulerAngles(const CQuaternion& quat);
   CEulerAngles(const CTransform& xf);
 };

include/zeus/CLine.hpp

@@ -6,7 +6,7 @@
 namespace zeus {
 class CLine {
 public:
-  CLine(const CVector3f& origin, const CVector3f& dir) : origin(origin), dir(dir) {}
+  constexpr CLine(const CVector3f& origin, const CVector3f& dir) : origin(origin), dir(dir) {}
 
   CVector3f origin;
   CVector3f dir;

include/zeus/CLineSeg.hpp

@@ -11,7 +11,7 @@ public:
     if (tmp.x() != 0.f || tmp.y() != 0.f || tmp.z() != 0.f)
       xc_dir = tmp.normalized();
     else
-      xc_dir = CVector3f::skZero;
+      xc_dir = CVector3f();
   }
 
   CVector3f x0_start;

include/zeus/CMatrix3f.hpp

@@ -11,10 +11,7 @@ class CQuaternion;
 
 class CMatrix3f {
 public:
-  explicit CMatrix3f(bool zero = false) {
+  explicit constexpr CMatrix3f(bool zero = false) {
-    m[0] = simd<float>(0.f);
-    m[1] = simd<float>(0.f);
-    m[2] = simd<float>(0.f);
     if (!zero) {
       m[0][0] = 1.0;
       m[1][1] = 1.0;
@@ -22,33 +19,30 @@ public:
     }
   }
 
-  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}} {}
 
-  CMatrix3f(const CVector3f& scaleVec) {
+  constexpr CMatrix3f(const CVector3f& scaleVec) {
-    m[0] = simd<float>(0.f);
-    m[1] = simd<float>(0.f);
-    m[2] = simd<float>(0.f);
     m[0][0] = scaleVec[0];
     m[1][1] = scaleVec[1];
     m[2][2] = scaleVec[2];
   }
 
-  CMatrix3f(float scale) : CMatrix3f(CVector3f(scale)) {}
+  constexpr CMatrix3f(float scale) : CMatrix3f(CVector3f(scale)) {}
 
-  CMatrix3f(const CVector3f& r0, const CVector3f& r1, const CVector3f& r2) {
+  constexpr CMatrix3f(const CVector3f& r0, const CVector3f& r1, const CVector3f& r2) {
     m[0] = r0;
     m[1] = r1;
     m[2] = r2;
   }
 
-  CMatrix3f(const CMatrix3f& other) {
+  constexpr CMatrix3f(const CMatrix3f& other) {
     m[0] = other.m[0];
     m[1] = other.m[1];
     m[2] = other.m[2];
   }
 
-  CMatrix3f(const simd<float>& r0, const simd<float>& r1, const simd<float>& r2) {
+  constexpr CMatrix3f(const simd<float>& r0, const simd<float>& r1, const simd<float>& r2) {
     m[0].mSimd = r0;
     m[1].mSimd = r1;
     m[2].mSimd = r2;
@@ -56,7 +50,7 @@ public:
 
 #if ZE_ATHENA_TYPES
 
-  CMatrix3f(const atVec4f& r0, const atVec4f& r1, const atVec4f& r2) {
+  constexpr CMatrix3f(const atVec4f& r0, const atVec4f& r1, const atVec4f& r2) {
     m[0].mSimd = r0.simd;
     m[1].mSimd = r1.simd;
     m[2].mSimd = r2.simd;
@@ -82,8 +76,6 @@ public:
 
 #endif
 
-  CMatrix3f(const CVector3f& axis, float angle);
-
   CMatrix3f(const CQuaternion& quat);
 
   CMatrix3f& operator=(const CMatrix3f& other) {
@@ -121,8 +113,6 @@ public:
     return m[0] == other.m[0] && m[1] == other.m[1] && m[2] == other.m[2];
   }
 
-  static const CMatrix3f skIdentityMatrix3f;
-
   void transpose();
 
   CMatrix3f transposed() const;
@@ -167,7 +157,7 @@ public:
   CVector3f m[3];
 };
 
-static inline CMatrix3f operator*(const CMatrix3f& lhs, const CMatrix3f& rhs) {
+inline CMatrix3f operator*(const CMatrix3f& lhs, const CMatrix3f& rhs) {
   simd<float> v[3];
   for (int i = 0; i < 3; ++i)
     v[i] = lhs.m[0].mSimd * rhs[i].mSimd.shuffle<0, 0, 0, 0>() + lhs.m[1].mSimd * rhs[i].mSimd.shuffle<1, 1, 1, 1>() +

include/zeus/CMatrix4f.hpp

@@ -7,9 +7,7 @@
 namespace zeus {
 class CMatrix4f {
 public:
-  static const CMatrix4f skIdentityMatrix4f;
+  explicit constexpr CMatrix4f(bool zero = false) {
-
-  explicit CMatrix4f(bool zero = false) {
     if (!zero) {
       m[0][0] = 1.0;
       m[1][1] = 1.0;
@@ -18,39 +16,39 @@ public:
     }
   }
 
-  CMatrix4f(float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20,
+  constexpr CMatrix4f(float m00, float m01, float m02, float m03, float m10, float m11, float m12, float m13, float m20,
                       float m21, float m22, float m23, float m30, float m31, float m32, float m33)
   : m{{m00, m10, m20, m30}, {m01, m11, m21, m31}, {m02, m12, m22, m32}, {m03, m13, m23, m33}} {}
 
-  CMatrix4f(const CVector3f& scaleVec) {
+  constexpr CMatrix4f(const CVector3f& scaleVec) {
     m[0][0] = scaleVec[0];
     m[1][1] = scaleVec[1];
     m[2][2] = scaleVec[2];
     m[3][3] = 1.0f;
   }
 
-  CMatrix4f(const CVector4f& r0, const CVector4f& r1, const CVector4f& r2, const CVector4f& r3) {
+  constexpr CMatrix4f(const CVector4f& r0, const CVector4f& r1, const CVector4f& r2, const CVector4f& r3) {
     m[0] = r0;
     m[1] = r1;
     m[2] = r2;
     m[3] = r3;
   }
 
-  CMatrix4f(const CMatrix4f& other) {
+  constexpr CMatrix4f(const CMatrix4f& other) {
     m[0] = other.m[0];
     m[1] = other.m[1];
     m[2] = other.m[2];
     m[3] = other.m[3];
   }
 
-  CMatrix4f(const simd<float>& r0, const simd<float>& r1, const simd<float>& r2, const simd<float>& r3) {
+  constexpr CMatrix4f(const simd<float>& r0, const simd<float>& r1, const simd<float>& r2, const simd<float>& r3) {
     m[0].mSimd = r0;
     m[1].mSimd = r1;
     m[2].mSimd = r2;
     m[3].mSimd = r3;
   }
 
-  CMatrix4f(const CMatrix3f& other) {
+  constexpr CMatrix4f(const CMatrix3f& other) {
     m[0] = other.m[0];
     m[1] = other.m[1];
     m[2] = other.m[2];
@@ -95,8 +93,9 @@ public:
 
   CVector4f m[4];
 };
+extern const CMatrix4f skIdentityMatrix4f;
 
-static inline CMatrix4f operator*(const CMatrix4f& lhs, const CMatrix4f& rhs) {
+inline CMatrix4f operator*(const CMatrix4f& lhs, const CMatrix4f& rhs) {
   simd<float> v[4];
   for (int i = 0; i < 4; ++i)
     v[i] = lhs.m[0].mSimd * rhs[i].mSimd.shuffle<0, 0, 0, 0>() + lhs.m[1].mSimd * rhs[i].mSimd.shuffle<1, 1, 1, 1>() +

include/zeus/COBBox.hpp

@@ -26,11 +26,11 @@ public:
   CTransform transform;
   CVector3f extents;
 
-  COBBox() = default;
+  constexpr COBBox() = default;
 
   COBBox(const CAABox& aabb) : extents(aabb.extents()) { transform.origin = aabb.center(); }
 
-  COBBox(const CTransform& xf, const CVector3f& extents) : transform(xf), extents(extents) {}
+  constexpr COBBox(const CTransform& xf, const CVector3f& extents) : transform(xf), extents(extents) {}
 
   CAABox calculateAABox(const CTransform& worldXf = CTransform()) const;
 
@@ -42,6 +42,6 @@ public:
 
   bool OBBIntersectsBox(const COBBox& other) const;
 
-  bool AABoxIntersectsBox(const CAABox& other) { return OBBIntersectsBox(FromAABox(other, CTransform::Identity())); }
+  bool AABoxIntersectsBox(const CAABox& other) { return OBBIntersectsBox(FromAABox(other, CTransform())); }
 };
 } // namespace zeus

include/zeus/CPlane.hpp

@@ -7,9 +7,9 @@
 namespace zeus {
 class CPlane {
 public:
-  CPlane() : mSimd(1.0, 0.f, 0.f, 0.f) {}
+  constexpr CPlane() : mSimd(1.f, 0.f, 0.f, 0.f) {}
 
-  CPlane(float a, float b, float c, float d) : mSimd(a, b, c, d) {}
+  constexpr CPlane(float a, float b, float c, float d) : mSimd(a, b, c, d) {}
 
   CPlane(const CVector3f& a, const CVector3f& b, const CVector3f& c) {
     mSimd = (b - a).cross(c - a).normalized().mSimd;

include/zeus/CProjection.hpp

@@ -34,7 +34,7 @@ public:
   CProjection() {
     m_projType = EProjType::Orthographic;
     m_ortho = SProjOrtho();
-    m_mtx = CMatrix4f::skIdentityMatrix4f;
+    m_mtx = CMatrix4f();
   }
 
   CProjection(const CProjection& other) { *this = other; }

include/zeus/CQuaternion.hpp

@@ -31,16 +31,16 @@ class CNUQuaternion;
 /** Unit quaternion, used for all quaternion arithmetic */
 class CQuaternion {
 public:
-  CQuaternion() : mSimd(1.f, 0.f, 0.f, 0.f) {}
+  constexpr CQuaternion() : mSimd(1.f, 0.f, 0.f, 0.f) {}
 
-  CQuaternion(float wi, float xi, float yi, float zi) : mSimd(wi, xi, yi, zi) {}
+  constexpr CQuaternion(float wi, float xi, float yi, float zi) : mSimd(wi, xi, yi, zi) {}
 
   CQuaternion(float xi, float yi, float zi) { fromVector3f(CVector3f(xi, yi, zi)); }
 
   CQuaternion(float wi, const CVector3f& vec) : mSimd(vec.mSimd.shuffle<0, 0, 1, 2>()) { mSimd[0] = wi; }
 
   template <typename T>
-  CQuaternion(const simd<T>& s) : mSimd(s) {}
+  constexpr CQuaternion(const simd<T>& s) : mSimd(s) {}
 
 #if ZE_ATHENA_TYPES
 
@@ -53,7 +53,7 @@ public:
     mSimd.copy_from(f);
   }
 
-  CQuaternion(const atVec4f& vec) : mSimd(vec.simd) {}
+  constexpr CQuaternion(const atVec4f& vec) : mSimd(vec.simd) {}
 
   operator atVec4f&() { return *reinterpret_cast<atVec4f*>(this); }
 
@@ -65,7 +65,7 @@ public:
 
   CQuaternion(const CVector3f& vec) { fromVector3f(vec); }
 
-  CQuaternion(const CVector4f& vec) : mSimd(vec.mSimd) {}
+  constexpr CQuaternion(const CVector4f& vec) : mSimd(vec.mSimd) {}
 
   CQuaternion(const CVector3f& vecA, const CVector3f& vecB) {
     CVector3f vecAN = vecA.normalized();
@@ -216,8 +216,6 @@ public:
 
   simd<float> mSimd;
 
-  static const CQuaternion skNoRotation;
-
   static CQuaternion fromNUQuaternion(const CNUQuaternion& q);
 };
 

include/zeus/CRectangle.hpp

@@ -5,9 +5,9 @@
 namespace zeus {
 class CRectangle {
 public:
-  CRectangle() {}
+  constexpr CRectangle() = default;
 
-  CRectangle(float x, float y, float w, float h) : position(x, y), size(w, h) {}
+  constexpr CRectangle(float x, float y, float w, float h) : position(x, y), size(w, h) {}
 
   bool contains(const CVector2f& point) const {
     if (point.x() < position.x() || point.x() > position.x() + size.x())

include/zeus/CRelAngle.hpp

@@ -19,9 +19,9 @@ public:
     return ret;
   }
 
-  CRelAngle() = default;
+  constexpr CRelAngle() = default;
 
-  CRelAngle(float angle) : angle(angle) {}
+  constexpr CRelAngle(float angle) : angle(angle) {}
 
   CRelAngle& operator=(float ang) {
     angle = ang;

include/zeus/CSphere.hpp

@@ -5,7 +5,7 @@
 namespace zeus {
 class CSphere {
 public:
-  CSphere(const CVector3f& position, float radius) : position(position), radius(radius) {}
+  constexpr CSphere(const CVector3f& position, float radius) : position(position), radius(radius) {}
 
   CVector3f getSurfaceNormal(const CVector3f& coord) const { return (coord - position).normalized(); }
 

include/zeus/CTransform.hpp

@@ -11,9 +11,10 @@
 namespace zeus {
 class CTransform {
 public:
-  CTransform() : basis(false) {}
+  constexpr CTransform() : basis(false) {}
 
-  CTransform(const CMatrix3f& basis, const CVector3f& offset = CVector3f::skZero) : basis(basis), origin(offset) {}
+  constexpr CTransform(const CMatrix3f& basis, const CVector3f& offset = {})
+  : basis(basis), origin(offset) {}
 
 #if ZE_ATHENA_TYPES
 
@@ -32,13 +33,9 @@ public:
 #endif
 
   /* Column constructor */
-  CTransform(const CVector3f& c0, const CVector3f& c1, const CVector3f& c2, const CVector3f& c3)
+  constexpr CTransform(const CVector3f& c0, const CVector3f& c1, const CVector3f& c2, const CVector3f& c3)
   : basis(c0, c1, c2), origin(c3) {}
 
-  static const CTransform skIdentityTransform;
-
-  static const CTransform& Identity() { return skIdentityTransform; }
-
   bool operator==(const CTransform& other) const { return origin == other.origin && basis == other.basis; }
 
   CTransform operator*(const CTransform& rhs) const {
@@ -50,7 +47,7 @@ public:
     return CTransform(inv, inv * -origin);
   }
 
-  static CTransform Translate(const CVector3f& position) { return {CMatrix3f::skIdentityMatrix3f, position}; }
+  static CTransform Translate(const CVector3f& position) { return {CMatrix3f(), position}; }
 
   static CTransform Translate(float x, float y, float z) { return Translate({x, y, z}); }
 
@@ -224,17 +221,17 @@ public:
     else
       i = 1;
 
-    CVector3f v = CVector3f::skZero;
+    CVector3f v;
     v[i] = 1.f;
     CUnitVector3f newUVec(uVec.cross(v));
-    return {newUVec, uVec, uVec.cross(newUVec), CVector3f::skZero};
+    return {newUVec, uVec, uVec.cross(newUVec), CVector3f()};
   }
 
   CMatrix3f basis;
   CVector3f origin;
 };
 
-static inline CTransform CTransformFromScaleVector(const CVector3f& scale) { return CTransform(CMatrix3f(scale)); }
+constexpr CTransform CTransformFromScaleVector(const CVector3f& scale) { return CTransform(CMatrix3f(scale)); }
 
 CTransform CTransformFromEditorEuler(const CVector3f& eulerVec);
 
@@ -242,5 +239,5 @@ CTransform CTransformFromEditorEulers(const CVector3f& eulerVec, const CVector3f
 
 CTransform CTransformFromAxisAngle(const CVector3f& axis, float angle);
 
-CTransform lookAt(const CVector3f& pos, const CVector3f& lookPos, const CVector3f& up = CVector3f::skUp);
+CTransform lookAt(const CVector3f& pos, const CVector3f& lookPos, const CVector3f& up = skUp);
 } // namespace zeus

include/zeus/CUnitVector.hpp

@@ -5,14 +5,14 @@
 namespace zeus {
 class CUnitVector3f : public CVector3f {
 public:
-  CUnitVector3f() : CVector3f(0.f, 1.f, 0.f) {}
+  constexpr CUnitVector3f() : CVector3f(0.f, 1.f, 0.f) {}
 
-  CUnitVector3f(float x, float y, float z, bool doNormalize = true) : CVector3f(x, y, z) {
+  constexpr CUnitVector3f(float x, float y, float z, bool doNormalize = true) : CVector3f(x, y, z) {
     if (doNormalize && canBeNormalized())
       normalize();
   }
 
-  CUnitVector3f(const CVector3f& vec, bool doNormalize = true) : CVector3f(vec) {
+  constexpr CUnitVector3f(const CVector3f& vec, bool doNormalize = true) : CVector3f(vec) {
     if (doNormalize && canBeNormalized())
       normalize();
   }

include/zeus/CVector2f.hpp

@@ -9,14 +9,14 @@ namespace zeus {
 class CVector2f {
 public:
   simd<float> mSimd;
-  CVector2f() : mSimd(0.f) {}
+  constexpr CVector2f() : mSimd(0.f) {}
 
   template <typename T>
-  CVector2f(const simd<T>& s) : mSimd(s) {}
+  constexpr CVector2f(const simd<T>& s) : mSimd(s) {}
 
 #if ZE_ATHENA_TYPES
 
-  CVector2f(const atVec2f& vec) : mSimd(vec.simd) {}
+  constexpr CVector2f(const atVec2f& vec) : mSimd(vec.simd) {}
 
   operator atVec2f&() { return *reinterpret_cast<atVec2f*>(this); }
 
@@ -37,7 +37,7 @@ public:
 
 #endif
 
-  explicit CVector2f(float xy) { splat(xy); }
+  explicit constexpr CVector2f(float xy) : mSimd(xy) {}
 
   void assign(float x, float y) {
     mSimd[0] = x;
@@ -46,7 +46,7 @@ public:
     mSimd[3] = 0.0f;
   }
 
-  CVector2f(float x, float y) { assign(x, y); }
+  constexpr CVector2f(float x, float y) : mSimd(x, y, 0.f, 0.f) {}
 
   bool operator==(const CVector2f& rhs) const { return mSimd[0] == rhs.mSimd[0] && mSimd[1] == rhs.mSimd[1]; }
 
@@ -144,7 +144,7 @@ public:
 
   float magnitude() const { return std::sqrt(magSquared()); }
 
-  void zeroOut() { *this = CVector2f::skZero; }
+  void zeroOut() { mSimd = zeus::simd<float>(0.f); }
 
   void splat(float xy) { mSimd = zeus::simd<float>(xy); }
 
@@ -188,17 +188,16 @@ public:
 
   simd<float>::reference x() { return mSimd[0]; }
   simd<float>::reference y() { return mSimd[1]; }
-
-  static const CVector2f skOne;
-  static const CVector2f skNegOne;
-  static const CVector2f skZero;
 };
+constexpr CVector2f skOne2f(1.f);
+constexpr CVector2f skNegOne2f(-1.f);
+constexpr CVector2f skZero2f(0.f);
 
-static inline CVector2f operator+(float lhs, const CVector2f& rhs) { return zeus::simd<float>(lhs) + rhs.mSimd; }
+inline CVector2f operator+(float lhs, const CVector2f& rhs) { return zeus::simd<float>(lhs) + rhs.mSimd; }
 
-static inline CVector2f operator-(float lhs, const CVector2f& rhs) { return zeus::simd<float>(lhs) - rhs.mSimd; }
+inline CVector2f operator-(float lhs, const CVector2f& rhs) { return zeus::simd<float>(lhs) - rhs.mSimd; }
 
-static inline CVector2f operator*(float lhs, const CVector2f& rhs) { return zeus::simd<float>(lhs) * rhs.mSimd; }
+inline CVector2f operator*(float lhs, const CVector2f& rhs) { return zeus::simd<float>(lhs) * rhs.mSimd; }
 
-static inline CVector2f operator/(float lhs, const CVector2f& rhs) { return zeus::simd<float>(lhs) / rhs.mSimd; }
+inline CVector2f operator/(float lhs, const CVector2f& rhs) { return zeus::simd<float>(lhs) / rhs.mSimd; }
 } // namespace zeus

include/zeus/CVector2i.hpp

@@ -21,9 +21,9 @@ public:
     int v[2];
   };
 
-  CVector2i() = default;
+  constexpr CVector2i() : x(0), y(0) {}
 
-  CVector2i(int xin, int yin) : x(xin), y(yin) {}
+  constexpr CVector2i(int xin, int yin) : x(xin), y(yin) {}
 
   CVector2i(const CVector2f& vec) : x(int(vec.x())), y(int(vec.y())) {}
 

include/zeus/CVector3d.hpp

@@ -10,20 +10,20 @@ namespace zeus {
 class CVector3d {
 public:
   zeus::simd<double> mSimd;
-  CVector3d() : mSimd(0.0) {}
+  constexpr CVector3d() : mSimd(0.0) {}
 
   template <typename T>
-  CVector3d(const simd<T>& s) : mSimd(s) {}
+  constexpr CVector3d(const simd<T>& s) : mSimd(s) {}
 
 #if ZE_ATHENA_TYPES
-  CVector3d(const atVec3d& vec) : mSimd(vec.simd) {}
+  constexpr CVector3d(const atVec3d& vec) : mSimd(vec.simd) {}
 #endif
 
-  explicit CVector3d(double xyz) : mSimd(xyz) {}
+  explicit constexpr CVector3d(double xyz) : mSimd(xyz) {}
 
   CVector3d(const CVector3f& vec) : mSimd(vec.mSimd) {}
 
-  CVector3d(double x, double y, double z) : mSimd(x, y, z) {}
+  constexpr CVector3d(double x, double y, double z) : mSimd(x, y, z) {}
 
   CVector3f asCVector3f() { return mSimd; }
 
@@ -45,7 +45,7 @@ public:
 
   void splat(double xyz) { mSimd = zeus::simd<double>(xyz); }
 
-  void zeroOut() { *this = skZero; }
+  void zeroOut() { mSimd = zeus::simd<double>(0.0); }
 
   CVector3d operator+(const CVector3d& rhs) const { return mSimd + rhs.mSimd; }
 
@@ -72,16 +72,17 @@ public:
   simd<double>::reference x() { return mSimd[0]; }
   simd<double>::reference y() { return mSimd[1]; }
   simd<double>::reference z() { return mSimd[2]; }
-
-  static const CVector3d skZero;
 };
+inline CVector3f::CVector3f(const CVector3d& vec) : mSimd(vec.mSimd) {}
 
-static inline CVector3d operator+(double lhs, const CVector3d& rhs) { return zeus::simd<double>(lhs) + rhs.mSimd; }
+constexpr CVector3d skZero3d(0.0);
 
-static inline CVector3d operator-(double lhs, const CVector3d& rhs) { return zeus::simd<double>(lhs) - rhs.mSimd; }
+inline CVector3d operator+(double lhs, const CVector3d& rhs) { return zeus::simd<double>(lhs) + rhs.mSimd; }
 
-static inline CVector3d operator*(double lhs, const CVector3d& rhs) { return zeus::simd<double>(lhs) * rhs.mSimd; }
+inline CVector3d operator-(double lhs, const CVector3d& rhs) { return zeus::simd<double>(lhs) - rhs.mSimd; }
 
-static inline CVector3d operator/(double lhs, const CVector3d& rhs) { return zeus::simd<double>(lhs) / rhs.mSimd; }
+inline CVector3d operator*(double lhs, const CVector3d& rhs) { return zeus::simd<double>(lhs) * rhs.mSimd; }
+
+inline CVector3d operator/(double lhs, const CVector3d& rhs) { return zeus::simd<double>(lhs) / rhs.mSimd; }
 
 } // namespace zeus

include/zeus/CVector3f.hpp

@@ -15,14 +15,14 @@ class CRelAngle;
 class CVector3f {
 public:
   zeus::simd<float> mSimd;
-  CVector3f() : mSimd(0.f) {}
+  constexpr CVector3f() : mSimd(0.f) {}
 
   template <typename T>
-  CVector3f(const simd<T>& s) : mSimd(s) {}
+  constexpr CVector3f(const simd<T>& s) : mSimd(s) {}
 
 #if ZE_ATHENA_TYPES
 
-  CVector3f(const atVec3f& vec) : mSimd(vec.simd) {}
+  constexpr CVector3f(const atVec3f& vec) : mSimd(vec.simd) {}
 
   operator atVec3f&() { return *reinterpret_cast<atVec3f*>(this); }
 
@@ -45,20 +45,20 @@ public:
 
 #endif
 
-  CVector3f(const CVector3d& vec);
+  inline CVector3f(const CVector3d& vec);
 
-  explicit CVector3f(float xyz) : mSimd(xyz) {}
+  explicit constexpr CVector3f(float xyz) : mSimd(xyz) {}
 
   void assign(float x, float y, float z) { mSimd = zeus::simd<float>(x, y, z); }
 
-  CVector3f(float x, float y, float z) : mSimd(x, y, z) {}
+  constexpr CVector3f(float x, float y, float z) : mSimd(x, y, z) {}
 
-  CVector3f(const float* floats) : mSimd(floats[0], floats[1], floats[2]) {}
+  constexpr CVector3f(const float* floats) : mSimd(floats[0], floats[1], floats[2]) {}
 
   CVector3f(const CVector2f& other, float z = 0.f) {
     mSimd = other.mSimd;
     mSimd[2] = z;
-    mSimd[3] = 0.0f;
+    mSimd[3] = 0.f;
   }
 
   CVector2f toVec2f() const { return CVector2f(mSimd); }
@@ -134,7 +134,7 @@ public:
 
   bool isMagnitudeSafe() const { return isNotInf() && magSquared() >= 9.9999994e-29; }
 
-  void zeroOut() { *this = CVector3f::skZero; }
+  void zeroOut() { mSimd = zeus::simd<float>(0.f); }
 
   void splat(float xyz) { mSimd = zeus::simd<float>(xyz); }
 
@@ -199,29 +199,32 @@ public:
   simd<float>::reference y() { return mSimd[1]; }
   simd<float>::reference z() { return mSimd[2]; }
 
-  static const CVector3f skOne;
+  static inline CVector3f radToDeg(const CVector3f& rad);
-  static const CVector3f skNegOne;
-  static const CVector3f skZero;
-  static const CVector3f skForward;
-  static const CVector3f skBack;
-  static const CVector3f skLeft;
-  static const CVector3f skRight;
-  static const CVector3f skUp;
-  static const CVector3f skDown;
-  static const CVector3f skRadToDegVec;
-  static const CVector3f skDegToRadVec;
 
-  static CVector3f radToDeg(const CVector3f& rad) { return rad * skRadToDegVec; }
+  static inline CVector3f degToRad(const CVector3f& deg);
-
-  static CVector3f degToRad(const CVector3f& deg) { return deg * skDegToRadVec; }
 };
+constexpr CVector3f skOne3f(1.f);
+constexpr CVector3f skNegOne3f(-1.f);
+constexpr CVector3f skZero3f(0.f);
+constexpr CVector3f skForward(0.f, 1.f, 0.f);
+constexpr CVector3f skBack(0.f, -1.f, 0.f);
+constexpr CVector3f skLeft(-1.f, 0.f, 0.f);
+constexpr CVector3f skRight(1.f, 0.f, 0.f);
+constexpr CVector3f skUp(0.f, 0.f, 1.f);
+constexpr CVector3f skDown(0.f, 0.f, -1.f);
+constexpr CVector3f skRadToDegVec(180.f / M_PIF);
+constexpr CVector3f skDegToRadVec(M_PIF / 180.f);
 
-static inline CVector3f operator+(float lhs, const CVector3f& rhs) { return zeus::simd<float>(lhs) + rhs.mSimd; }
+inline CVector3f operator+(float lhs, const CVector3f& rhs) { return zeus::simd<float>(lhs) + rhs.mSimd; }
 
-static inline CVector3f operator-(float lhs, const CVector3f& rhs) { return zeus::simd<float>(lhs) - rhs.mSimd; }
+inline CVector3f operator-(float lhs, const CVector3f& rhs) { return zeus::simd<float>(lhs) - rhs.mSimd; }
 
-static inline CVector3f operator*(float lhs, const CVector3f& rhs) { return zeus::simd<float>(lhs) * rhs.mSimd; }
+inline CVector3f operator*(float lhs, const CVector3f& rhs) { return zeus::simd<float>(lhs) * rhs.mSimd; }
 
-static inline CVector3f operator/(float lhs, const CVector3f& rhs) { return zeus::simd<float>(lhs) / rhs.mSimd; }
+inline CVector3f operator/(float lhs, const CVector3f& rhs) { return zeus::simd<float>(lhs) / rhs.mSimd; }
+
+inline CVector3f CVector3f::radToDeg(const CVector3f& rad) { return rad * skRadToDegVec; }
+
+inline CVector3f CVector3f::degToRad(const CVector3f& deg) { return deg * skDegToRadVec; }
 
 } // namespace zeus

include/zeus/CVector4f.hpp

@@ -20,14 +20,14 @@ class CVector4f {
 public:
   zeus::simd<float> mSimd;
 
-  CVector4f() : mSimd(0.f) {}
+  constexpr CVector4f() : mSimd(0.f) {}
 
   template <typename T>
-  CVector4f(const simd<T>& s) : mSimd(s) {}
+  constexpr CVector4f(const simd<T>& s) : mSimd(s) {}
 
 #if ZE_ATHENA_TYPES
 
-  CVector4f(const atVec4f& vec) : mSimd(vec.simd) {}
+  constexpr CVector4f(const atVec4f& vec) : mSimd(vec.simd) {}
 
   operator atVec4f&() { return *reinterpret_cast<atVec4f*>(this); }
 
@@ -44,21 +44,21 @@ public:
 
 #endif
 
-  explicit CVector4f(float xyzw) : mSimd(xyzw) {}
+  explicit constexpr CVector4f(float xyzw) : mSimd(xyzw) {}
 
   void assign(float x, float y, float z, float w) { mSimd = simd<float>(x, y, z, w); }
 
-  CVector4f(float x, float y, float z, float w) : mSimd(x, y, z, w) {}
+  constexpr CVector4f(float x, float y, float z, float w) : mSimd(x, y, z, w) {}
 
-  CVector4f(const CColor& other);
+  constexpr CVector4f(const CColor& other);
 
-  CVector4f(const CVector3f& other, float wIn = 1.f) : mSimd(other.mSimd) { mSimd[3] = wIn; }
+  constexpr CVector4f(const CVector3f& other, float wIn = 1.f) : mSimd(other.mSimd) { mSimd[3] = wIn; }
 
   static CVector4f ToClip(const zeus::CVector3f& v, float w) { return CVector4f(v * w, w); }
 
   CVector3f toVec3f() const { return CVector3f(mSimd); }
 
-  CVector4f& operator=(const CColor& other);
+  constexpr CVector4f& operator=(const CColor& other);
 
   bool operator==(const CVector4f& rhs) const {
     auto eq_mask = mSimd == rhs.mSimd;
@@ -149,7 +149,7 @@ public:
 
   float magnitude() const { return std::sqrt(magSquared()); }
 
-  void zeroOut() { *this = CVector4f::skZero; }
+  void zeroOut() { mSimd = zeus::simd<float>(0.f); }
 
   void splat(float xyzw) { mSimd = zeus::simd<float>(xyzw); }
 
@@ -192,18 +192,17 @@ public:
   simd<float>::reference y() { return mSimd[1]; }
   simd<float>::reference z() { return mSimd[2]; }
   simd<float>::reference w() { return mSimd[3]; }
-
-  static const CVector4f skOne;
-  static const CVector4f skNegOne;
-  static const CVector4f skZero;
 };
+constexpr CVector4f skOne4f(1.f);
+constexpr CVector4f skNegOne4f(-1.f);
+constexpr CVector4f skZero4f(0.f);
 
-static CVector4f operator+(float lhs, const CVector4f& rhs) { return zeus::simd<float>(lhs) + rhs.mSimd; }
+inline CVector4f operator+(float lhs, const CVector4f& rhs) { return zeus::simd<float>(lhs) + rhs.mSimd; }
 
-static CVector4f operator-(float lhs, const CVector4f& rhs) { return zeus::simd<float>(lhs) - rhs.mSimd; }
+inline CVector4f operator-(float lhs, const CVector4f& rhs) { return zeus::simd<float>(lhs) - rhs.mSimd; }
 
-static CVector4f operator*(float lhs, const CVector4f& rhs) { return zeus::simd<float>(lhs) * rhs.mSimd; }
+inline CVector4f operator*(float lhs, const CVector4f& rhs) { return zeus::simd<float>(lhs) * rhs.mSimd; }
 
-static CVector4f operator/(float lhs, const CVector4f& rhs) { return zeus::simd<float>(lhs) / rhs.mSimd; }
+inline CVector4f operator/(float lhs, const CVector4f& rhs) { return zeus::simd<float>(lhs) / rhs.mSimd; }
 
 } // namespace zeus

include/zeus/Global.hpp

@@ -16,5 +16,5 @@ using simd_doubles = athena::simd_doubles;
 #endif
 } // namespace zeus
 
-inline int rotr(int x, int n) { return ((x >> n) | (x << (32 - n))); }
+constexpr int rotr(int x, int n) { return ((x >> n) | (x << (32 - n))); }
-inline int rotl(int x, int n) { return ((x << n) | (x >> (32 - n))); }
+constexpr int rotl(int x, int n) { return ((x << n) | (x >> (32 - n))); }

include/zeus/Math.hpp

@@ -81,12 +81,12 @@ class CVector2f;
 class CTransform;
 
 template <typename T>
-inline constexpr T min(const T& a, const T& b) {
+constexpr T min(const T& a, const T& b) {
   return a < b ? a : b;
 }
 
 template <typename T>
-inline constexpr T max(const T& a, const T& b) {
+constexpr T max(const T& a, const T& b) {
   return a > b ? a : b;
 }
 
@@ -97,17 +97,17 @@ template <>
 CVector3f max(const CVector3f& a, const CVector3f& b);
 
 template <typename T>
-inline constexpr T clamp(const T& a, const T& val, const T& b) {
+constexpr T clamp(const T& a, const T& val, const T& b) {
   return max<T>(a, min<T>(b, val));
 }
 
 inline constexpr float radToDeg(float rad) { return rad * (180.f / M_PIF); }
 
-inline constexpr float degToRad(float deg) { return deg * (M_PIF / 180.f); }
+constexpr float degToRad(float deg) { return deg * (M_PIF / 180.f); }
 
-inline constexpr double radToDeg(double rad) { return rad * (180.0 / M_PI); }
+constexpr double radToDeg(double rad) { return rad * (180.0 / M_PI); }
 
-inline constexpr double degToRad(double deg) { return deg * (M_PI / 180.0); }
+constexpr double degToRad(double deg) { return deg * (M_PI / 180.0); }
 
 CVector3f baryToWorld(const CVector3f& p0, const CVector3f& p1, const CVector3f& p2, const CVector3f& bary);
 

include/zeus/simd/parallelism_v2_simd.hpp

@@ -1274,9 +1274,10 @@ public:
     __s_.__broadcast(v);
   }
 #endif
-  simd(_Tp __rv) { __s_.__broadcast(__rv); }
 
-  simd(_Tp a, _Tp b, _Tp c = {}, _Tp d = {}) { __s_.__set4(a, b, c, d); }
+  constexpr simd(_Tp __rv) : __s_(__rv) {}
+
+  constexpr simd(_Tp a, _Tp b, _Tp c = {}, _Tp d = {}) : __s_(a, b, c, d) {}
 
   // generator constructor
   template <class _Generator,

include/zeus/simd/simd_avx.hpp

@@ -22,7 +22,9 @@ public:
     sse_data[__index] = __val;
     __storage_ = _mm256_load_pd(sse_data.data());
   }
+  constexpr __simd_storage(double a, double b, double c, double d) : __storage_{a, b, c, d} {}
   void __set4(double a, double b, double c, double d) noexcept { __storage_ = _mm256_set_pd(d, c, b, a); }
+  constexpr __simd_storage(double rv) : __storage_{rv, rv, rv, rv} {}
   void __broadcast(double __val) noexcept { __storage_ = _mm256_set1_pd(__val); }
   double __dot2(const __simd_storage<double, m256d_abi>& other) const noexcept {
     alignas(32) std::array<double, 4> sse_data;

include/zeus/simd/simd_sse.hpp

@@ -41,7 +41,9 @@ public:
     sse_data[__index] = __val;
     __storage_ = _mm_load_ps(sse_data.data());
   }
+  constexpr __simd_storage(float a, float b, float c, float d) : __storage_{a, b, c, d} {}
   void __set4(float a, float b, float c, float d) noexcept { __storage_ = _mm_set_ps(d, c, b, a); }
+  constexpr __simd_storage(float rv) : __storage_{rv, rv, rv, rv} {}
   void __broadcast(float __val) noexcept { __storage_ = _mm_set1_ps(__val); }
   float __dot2(const __simd_storage<float, m128_abi>& other) const noexcept {
 #if __SSE4_1__
@@ -219,10 +221,12 @@ public:
     sse_data[__index % 2] = __val;
     __storage_[__index / 2] = _mm_load_pd(sse_data.data());
   }
+  constexpr __simd_storage(double a, double b, double c, double d) : __storage_{__m128d{a, b}, __m128d{c, d}} {}
   void __set4(double a, double b, double c, double d) noexcept {
     __storage_[0] = _mm_set_pd(b, a);
     __storage_[1] = _mm_set_pd(d, c);
   }
+  constexpr __simd_storage(double rv) : __storage_{__m128d{rv, rv}, __m128d{rv, rv}} {}
   void __broadcast(double __val) noexcept {
     for (int i = 0; i < 2; ++i)
       __storage_[i] = _mm_set1_pd(__val);

src/CAABox.cpp

@@ -2,9 +2,6 @@
 #include "zeus/CVector3f.hpp"
 
 namespace zeus {
-const CAABox CAABox::skInvertedBox = CAABox();
-const CAABox CAABox::skNullBox = CAABox(CVector3f::skZero, CVector3f::skZero);
-
 static const int ProjWindings[6][4] = {
   {2, 0, 4, 6}, // -X
   {0, 1, 5, 4}, // -Y
@@ -91,8 +88,8 @@ float CAABox::intersectionRadius(const CSphere& other) const {
 }
 
 CAABox CAABox::booleanIntersection(const CAABox& other) const {
-  CVector3f minVec = CVector3f::skZero;
+  CVector3f minVec;
-  CVector3f maxVec = CVector3f::skZero;
+  CVector3f maxVec;
 
   for (int i = 0; i < 3; ++i) {
     if (min[i] <= other.min[i] && max[i] >= other.max[i]) {

src/CAxisAngle.cpp

@@ -1,5 +0,0 @@
-#include "zeus/CAxisAngle.hpp"
-
-namespace zeus {
-const CAxisAngle CAxisAngle::sIdentity = {};
-}

src/CColor.cpp

@@ -2,17 +2,6 @@
 #include "zeus/CVector4f.hpp"
 
 namespace zeus {
-const CColor CColor::skRed(Comp32(0xFF0000FFul));
-const CColor CColor::skBlack(Comp32(0x000000FFul));
-const CColor CColor::skBlue(Comp32(0x0000FFFFul));
-const CColor CColor::skGreen(Comp32(0x00FF00FFul));
-const CColor CColor::skGrey(Comp32(0x808080FFul));
-const CColor CColor::skOrange(Comp32(0xFF7000FFul));
-const CColor CColor::skPurple(Comp32(0xA000FFFFul));
-const CColor CColor::skYellow(Comp32(0xFFFF00FFul));
-const CColor CColor::skWhite(Comp32(0xFFFFFFFFul));
-const CColor CColor::skClear(Comp32(0x00000000ul));
-
 float hueToRgb(float p, float q, float t) {
   if (t < 0.0f)
     t += 1.0f;

src/CMatrix3f.cpp

@@ -3,7 +3,6 @@
 #include "zeus/Global.hpp"
 
 namespace zeus {
-const CMatrix3f CMatrix3f::skIdentityMatrix3f = CMatrix3f();
 
 CMatrix3f::CMatrix3f(const CQuaternion& quat) {
   CQuaternion nq = quat.normalized();

src/CMatrix4f.cpp

@@ -1,8 +1,7 @@
 #include "zeus/CMatrix4f.hpp"
 
 namespace zeus {
-
+const CMatrix4f skIdentityMatrix4f;
-const CMatrix4f CMatrix4f::skIdentityMatrix4f = CMatrix4f();
 
 CMatrix4f CMatrix4f::transposed() const {
   CMatrix4f ret;

src/COBBox.cpp

@@ -3,7 +3,7 @@
 namespace zeus {
 
 CAABox COBBox::calculateAABox(const CTransform& worldXf) const {
-  CAABox ret = CAABox::skInvertedBox;
+  CAABox ret;
 
   CTransform trans = worldXf * transform;
   static const CVector3f basis[8] = {{1.f, 1.f, 1.f},    {1.f, 1.f, -1.f},  {1.f, -1.f, 1.f},  {1.f, -1.f, -1.f},

src/CQuaternion.cpp

@@ -2,8 +2,6 @@
 #include "zeus/Math.hpp"
 
 namespace zeus {
-const CQuaternion CQuaternion::skNoRotation;
-
 CQuaternion::CQuaternion(const CMatrix3f& mat) {
   float trace = mat[0][0] + mat[1][1] + mat[2][2];
   if (trace >= 0.f) {
@@ -234,10 +232,10 @@ CQuaternion CQuaternion::shortestRotationArc(const zeus::CVector3f& v0, const ze
 
   if (cross.magSquared() < 0.001f) {
     if (v0N.dot(v1N) > 0.f)
-      return CQuaternion::skNoRotation;
+      return CQuaternion();
     if (cross.canBeNormalized())
       return CQuaternion(0.0f, cross.normalized());
-    return CQuaternion::skNoRotation;
+    return CQuaternion();
   } else {
     float w = std::sqrt((1.f + zeus::clamp(-1.f, v0N.dot(v1N), 1.f)) * 2.f);
     return CQuaternion(0.5f * w, cross * (1.f / w));
@@ -278,7 +276,7 @@ CRelAngle CQuaternion::angleFrom(const zeus::CQuaternion& other) {
 }
 
 CQuaternion CQuaternion::lookAt(const CUnitVector3f& source, const CUnitVector3f& dest, const CRelAngle& maxAng) {
-  CQuaternion q = skNoRotation;
+  CQuaternion q;
   zeus::CVector3f destNoZ = dest;
   zeus::CVector3f sourceNoZ = source;
   destNoZ.z() = 0.f;
@@ -300,11 +298,11 @@ CQuaternion CQuaternion::lookAt(const CUnitVector3f& source, const CUnitVector3f
   else if (destNoZ.magSquared() > 0.0001f)
     tmp = destNoZ.normalized();
   else
-    return skNoRotation;
+    return CQuaternion();
 
   float realAngle = zeus::clamp(-maxAng.asRadians(), normalize_angle(std::acos(dest.z()) - std::acos(source.z())),
                                 maxAng.asRadians());
-  return CQuaternion::fromAxisAngle(tmp.cross(CVector3f::skUp), -realAngle) * q;
+  return CQuaternion::fromAxisAngle(tmp.cross(skUp), -realAngle) * q;
 }
 
 } // namespace zeus

src/CTransform.cpp

@@ -1,8 +1,6 @@
 #include "zeus/CTransform.hpp"
 
 namespace zeus {
-const CTransform CTransform::skIdentityTransform;
-
 CTransform CTransformFromEditorEuler(const CVector3f& eulerVec) {
   CTransform result;
   double ti, tj, th, ci, cj, ch, si, sj, sh, cc, cs, sc, ss;

src/CVector2f.cpp

@@ -5,10 +5,6 @@
 #include "zeus/Math.hpp"
 
 namespace zeus {
-const CVector2f CVector2f::skOne = CVector2f(1.0);
-const CVector2f CVector2f::skNegOne = CVector2f(-1.0);
-const CVector2f CVector2f::skZero(0.f, 0.f);
-
 float CVector2f::getAngleDiff(const CVector2f& a, const CVector2f& b) {
   float mag1 = a.magnitude();
   float mag2 = b.magnitude();

src/CVector3f.cpp

@@ -7,21 +7,6 @@
 #include "zeus/CRelAngle.hpp"
 
 namespace zeus {
-const CVector3f CVector3f::skOne(1.f);
-const CVector3f CVector3f::skNegOne(-1.f);
-const CVector3f CVector3f::skZero;
-const CVector3f CVector3f::skForward(0.f, 1.f, 0.f);
-const CVector3f CVector3f::skBack(0.f, -1.f, 0.f);
-const CVector3f CVector3f::skLeft(-1.f, 0.f, 0.f);
-const CVector3f CVector3f::skRight(1.f, 0.f, 0.f);
-const CVector3f CVector3f::skUp(0.f, 0.f, 1.f);
-const CVector3f CVector3f::skDown(0.f, 0.f, -1.f);
-const CVector3f CVector3f::skRadToDegVec(180.0f / M_PIF);
-const CVector3f CVector3f::skDegToRadVec(M_PIF / 180.0f);
-const CVector3d CVector3d::skZero(0.0, 0.0, 0.0);
-
-CVector3f::CVector3f(const CVector3d& vec) : mSimd(vec.mSimd) {}
-
 float CVector3f::getAngleDiff(const CVector3f& a, const CVector3f& b) {
   float mag1 = a.magnitude();
   float mag2 = b.magnitude();

src/CVector4f.cpp

@@ -1,13 +0,0 @@
-#include "zeus/CVector4f.hpp"
-#include "zeus/CColor.hpp"
-
-namespace zeus {
-const CVector4f CVector4f::skZero(0.f, 0.f, 0.f, 0.f);
-
-CVector4f::CVector4f(const zeus::CColor& other) : mSimd(other.mSimd) {}
-
-CVector4f& CVector4f::operator=(const CColor& other) {
-  mSimd = other.mSimd;
-  return *this;
-}
-} // namespace zeus