constexpr refactor

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 maxVec = CVector3f::skZero;
+  CVector3f minVec;
+  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 CMatrix4f::skIdentityMatrix4f = CMatrix4f();
+const CMatrix4f skIdentityMatrix4f;
 
 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