New code style refactor

src/CAABox.cpp

@@ -1,8 +1,7 @@
 #include "zeus/CAABox.hpp"
 #include "zeus/CVector3f.hpp"
 
-namespace zeus
-{
+namespace zeus {
 const CAABox CAABox::skInvertedBox = CAABox();
 const CAABox CAABox::skNullBox = CAABox(CVector3f::skZero, CVector3f::skZero);
-}
+} // namespace zeus

src/CAxisAngle.cpp

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

src/CColor.cpp

@@ -115,4 +115,4 @@ void CColor::toHSL(float& h, float& s, float& l) const {
     h /= 6.f;
   }
 }
-}
+} // namespace zeus

src/CEulerAngles.cpp

@@ -1,73 +1,62 @@
 #include "zeus/CEulerAngles.hpp"
 #include "zeus/CQuaternion.hpp"
 
-namespace zeus
-{
+namespace zeus {
 
-CEulerAngles::CEulerAngles(const CQuaternion& quat)
-{
-    float quatDot = quat.dot(quat);
-    float t0 = 0.f;
-    if (quatDot > 0.f)
-        t0 = 2.f / quatDot;
-    double t1 = 1.0 - (t0 * quat.x() * quat.x() + t0 * quat.z() * quat.z());
-    double t2 = t0 * quat.y() * quat.x() - t0 * quat.z() * quat.w();
-    double t3 = t1 * t1 + t2 * t2;
+CEulerAngles::CEulerAngles(const CQuaternion& quat) {
+  float quatDot = quat.dot(quat);
+  float t0 = 0.f;
+  if (quatDot > 0.f)
+    t0 = 2.f / quatDot;
+  double t1 = 1.0 - (t0 * quat.x() * quat.x() + t0 * quat.z() * quat.z());
+  double t2 = t0 * quat.y() * quat.x() - t0 * quat.z() * quat.w();
+  double t3 = t1 * t1 + t2 * t2;
 
-    double t4 = 0.0;
-    if (t3 > 0.0)
-        t4 = std::sqrt(t3);
+  double t4 = 0.0;
+  if (t3 > 0.0)
+    t4 = std::sqrt(t3);
 
-    double t5 = t0 * quat.z() * quat.y() + t0 * quat.x() * quat.w();
+  double t5 = t0 * quat.z() * quat.y() + t0 * quat.x() * quat.w();
 
-    if (std::abs(t4) > 0.00001)
-    {
-        x() = -std::atan2(-t5, t4);
-        y() = -std::atan2(t0 * quat.z() * quat.x() - t0 * quat.y() * quat.w(),
-                          1.0 - (t0 * quat.x() * quat.x() + t0 * quat.y() * quat.y()));
-        z() = -std::atan2(t2, t1);
-    }
-    else
-    {
-        x() = -std::atan2(-t5, t4);
-        y() = -std::atan2(-(t0 * quat.z() * quat.x() + t0 * quat.y() * quat.w()),
-                          1.0 - (t0 * quat.y() * quat.y() + t0 * quat.z() * quat.z()));
-        z() = 0.f;
-    }
+  if (std::abs(t4) > 0.00001) {
+    x() = -std::atan2(-t5, t4);
+    y() = -std::atan2(t0 * quat.z() * quat.x() - t0 * quat.y() * quat.w(),
+                      1.0 - (t0 * quat.x() * quat.x() + t0 * quat.y() * quat.y()));
+    z() = -std::atan2(t2, t1);
+  } else {
+    x() = -std::atan2(-t5, t4);
+    y() = -std::atan2(-(t0 * quat.z() * quat.x() + t0 * quat.y() * quat.w()),
+                      1.0 - (t0 * quat.y() * quat.y() + t0 * quat.z() * quat.z()));
+    z() = 0.f;
+  }
 }
 
-CEulerAngles::CEulerAngles(const CTransform& xf)
-{
-    float xyMagSq = xf.basis[1][1] * xf.basis[1][1] + xf.basis[1][0] * xf.basis[1][0];
-    float f1 = 0.f;
-    if (xyMagSq > 0.f)
-    {
-        f1 = 1.f / std::sqrt(xyMagSq);
-        float f0;
+CEulerAngles::CEulerAngles(const CTransform& xf) {
+  float xyMagSq = xf.basis[1][1] * xf.basis[1][1] + xf.basis[1][0] * xf.basis[1][0];
+  float f1 = 0.f;
+  if (xyMagSq > 0.f) {
+    f1 = 1.f / std::sqrt(xyMagSq);
+    float f0;
 
-        for (int i=0 ; i<4 ; ++i)
-        {
-            f0 = f1 * f1;
-            f1 *= 0.5f;
-            f0 = 3.f - xyMagSq * f0;
-            f1 *= f0;
-        }
-
-        f1 = xyMagSq * f0;
+    for (int i = 0; i < 4; ++i) {
+      f0 = f1 * f1;
+      f1 *= 0.5f;
+      f0 = 3.f - xyMagSq * f0;
+      f1 *= f0;
     }
 
-    if (std::fabs(f1) >= 0.00001)
-    {
-        x() = -std::atan2(-xf.basis[1][2], f1);
-        y() = -std::atan2(xf.basis[0][2], xf.basis[2][2]);
-        z() = -std::atan2(xf.basis[1][0], xf.basis[1][1]);
-    }
-    else
-    {
-        x() = -std::atan2(-xf.basis[1][2], f1);
-        y() = -std::atan2(-xf.basis[2][0], xf.basis[0][0]);
-        z() = 0.f;
-    }
+    f1 = xyMagSq * f0;
+  }
+
+  if (std::fabs(f1) >= 0.00001) {
+    x() = -std::atan2(-xf.basis[1][2], f1);
+    y() = -std::atan2(xf.basis[0][2], xf.basis[2][2]);
+    z() = -std::atan2(xf.basis[1][0], xf.basis[1][1]);
+  } else {
+    x() = -std::atan2(-xf.basis[1][2], f1);
+    y() = -std::atan2(-xf.basis[2][0], xf.basis[0][0]);
+    z() = 0.f;
+  }
 }
 
-}
+} // namespace zeus

src/CFrustum.cpp

@@ -85,4 +85,4 @@ bool CFrustum::pointFrustumTest(const CVector3f& point) const {
   return true;
 }
 
-}
+} // namespace zeus

src/CMatrix3f.cpp

@@ -35,11 +35,11 @@ void CMatrix3f::transpose() {
   m[1].mSimd = _mm_movehl_ps(T2, T0);
   m[2].mSimd = _mm_movelh_ps(T1, T3);
 #elif __ARM_NEON
-  float32x4x2_t P0 = vzipq_f32( M.r[0], M.r[2] );
-  float32x4x2_t P1 = vzipq_f32( M.r[1], M.r[3] );
+  float32x4x2_t P0 = vzipq_f32(M.r[0], M.r[2]);
+  float32x4x2_t P1 = vzipq_f32(M.r[1], M.r[3]);
 
-  float32x4x2_t T0 = vzipq_f32( P0.val[0], P1.val[0] );
-  float32x4x2_t T1 = vzipq_f32( P0.val[1], P1.val[1] );
+  float32x4x2_t T0 = vzipq_f32(P0.val[0], P1.val[0]);
+  float32x4x2_t T1 = vzipq_f32(P0.val[1], P1.val[1]);
 
   m[0].mSimd = T0.val[0];
   m[1].mSimd = T0.val[1];
@@ -70,11 +70,11 @@ CMatrix3f CMatrix3f::transposed() const {
   __m128 T3 = _mm_unpackhi_ps(m[2].mSimd.native(), zero);
   return CMatrix3f(_mm_movelh_ps(T0, T2), _mm_movehl_ps(T2, T0), _mm_movelh_ps(T1, T3));
 #elif __ARM_NEON
-  float32x4x2_t P0 = vzipq_f32( M.r[0], M.r[2] );
-  float32x4x2_t P1 = vzipq_f32( M.r[1], M.r[3] );
+  float32x4x2_t P0 = vzipq_f32(M.r[0], M.r[2]);
+  float32x4x2_t P1 = vzipq_f32(M.r[1], M.r[3]);
 
-  float32x4x2_t T0 = vzipq_f32( P0.val[0], P1.val[0] );
-  float32x4x2_t T1 = vzipq_f32( P0.val[1], P1.val[1] );
+  float32x4x2_t T0 = vzipq_f32(P0.val[0], P1.val[0]);
+  float32x4x2_t T1 = vzipq_f32(P0.val[1], P1.val[1]);
 
   return CMatrix3f(T0.val[0], T0.val[1], T1.val[0]);
 #else
@@ -111,4 +111,4 @@ CMatrix3f CMatrix3f::inverted() const {
                    (m[0][1] * m[1][2] - m[0][2] * m[1][1]) * det, -(m[0][0] * m[1][2] - m[0][2] * m[1][0]) * det,
                    (m[0][0] * m[1][1] - m[0][1] * m[1][0]) * det);
 }
-}
+} // namespace zeus

src/CMatrix4f.cpp

@@ -1,54 +1,52 @@
 #include "zeus/CMatrix4f.hpp"
 
-namespace zeus
-{
+namespace zeus {
 
 const CMatrix4f CMatrix4f::skIdentityMatrix4f = CMatrix4f();
 
-CMatrix4f CMatrix4f::transposed() const
-{
-    CMatrix4f ret;
+CMatrix4f CMatrix4f::transposed() const {
+  CMatrix4f ret;
 #if __SSE__
-    __m128 T0 = _mm_unpacklo_ps(m[0].mSimd.native(), m[1].mSimd.native());
-    __m128 T2 = _mm_unpacklo_ps(m[2].mSimd.native(), m[3].mSimd.native());
-    __m128 T1 = _mm_unpackhi_ps(m[0].mSimd.native(), m[1].mSimd.native());
-    __m128 T3 = _mm_unpackhi_ps(m[2].mSimd.native(), m[3].mSimd.native());
-    ret.m[0].mSimd = _mm_movelh_ps(T0, T2);
-    ret.m[1].mSimd = _mm_movehl_ps(T2, T0);
-    ret.m[2].mSimd = _mm_movelh_ps(T1, T3);
-    ret.m[3].mSimd = _mm_movehl_ps(T3, T1);
+  __m128 T0 = _mm_unpacklo_ps(m[0].mSimd.native(), m[1].mSimd.native());
+  __m128 T2 = _mm_unpacklo_ps(m[2].mSimd.native(), m[3].mSimd.native());
+  __m128 T1 = _mm_unpackhi_ps(m[0].mSimd.native(), m[1].mSimd.native());
+  __m128 T3 = _mm_unpackhi_ps(m[2].mSimd.native(), m[3].mSimd.native());
+  ret.m[0].mSimd = _mm_movelh_ps(T0, T2);
+  ret.m[1].mSimd = _mm_movehl_ps(T2, T0);
+  ret.m[2].mSimd = _mm_movelh_ps(T1, T3);
+  ret.m[3].mSimd = _mm_movehl_ps(T3, T1);
 #elif __ARM_NEON
-    float32x4x2_t P0 = vzipq_f32( M.r[0], M.r[2] );
-    float32x4x2_t P1 = vzipq_f32( M.r[1], M.r[3] );
+  float32x4x2_t P0 = vzipq_f32(M.r[0], M.r[2]);
+  float32x4x2_t P1 = vzipq_f32(M.r[1], M.r[3]);
 
-    float32x4x2_t T0 = vzipq_f32( P0.val[0], P1.val[0] );
-    float32x4x2_t T1 = vzipq_f32( P0.val[1], P1.val[1] );
+  float32x4x2_t T0 = vzipq_f32(P0.val[0], P1.val[0]);
+  float32x4x2_t T1 = vzipq_f32(P0.val[1], P1.val[1]);
 
-    ret.m[0].mSimd = T0.val[0];
-    ret.m[1].mSimd = T0.val[1];
-    ret.m[2].mSimd = T1.val[0];
-    ret.m[3].mSimd = T1.val[1];
+  ret.m[0].mSimd = T0.val[0];
+  ret.m[1].mSimd = T0.val[1];
+  ret.m[2].mSimd = T1.val[0];
+  ret.m[3].mSimd = T1.val[1];
 #else
-    ret.m[0][0] = m[0][0];
-    ret.m[1][0] = m[0][1];
-    ret.m[2][0] = m[0][2];
-    ret.m[3][0] = m[0][3];
+  ret.m[0][0] = m[0][0];
+  ret.m[1][0] = m[0][1];
+  ret.m[2][0] = m[0][2];
+  ret.m[3][0] = m[0][3];
 
-    ret.m[0][1] = m[1][0];
-    ret.m[1][1] = m[1][1];
-    ret.m[2][1] = m[1][2];
-    ret.m[3][1] = m[1][3];
+  ret.m[0][1] = m[1][0];
+  ret.m[1][1] = m[1][1];
+  ret.m[2][1] = m[1][2];
+  ret.m[3][1] = m[1][3];
 
-    ret.m[0][2] = m[2][0];
-    ret.m[1][2] = m[2][1];
-    ret.m[2][2] = m[2][2];
-    ret.m[3][2] = m[2][3];
+  ret.m[0][2] = m[2][0];
+  ret.m[1][2] = m[2][1];
+  ret.m[2][2] = m[2][2];
+  ret.m[3][2] = m[2][3];
 
-    ret.m[0][3] = m[3][0];
-    ret.m[1][3] = m[3][1];
-    ret.m[2][3] = m[3][2];
-    ret.m[3][3] = m[3][3];
+  ret.m[0][3] = m[3][0];
+  ret.m[1][3] = m[3][1];
+  ret.m[2][3] = m[3][2];
+  ret.m[3][3] = m[3][3];
 #endif
-    return ret;
-}
+  return ret;
 }
+} // namespace zeus

src/COBBox.cpp

@@ -6,14 +6,8 @@ CAABox COBBox::calculateAABox(const CTransform& worldXf) const {
   CAABox ret = CAABox::skInvertedBox;
 
   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},
-                                     {-1.f, -1.f, -1.f},
-                                     {-1.f, -1.f, 1.f},
-                                     {-1.f, 1.f,  -1.f},
-                                     {-1.f, 1.f,  1.f}};
+  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},
+                                     {-1.f, -1.f, -1.f}, {-1.f, -1.f, 1.f}, {-1.f, 1.f, -1.f}, {-1.f, 1.f, 1.f}};
   CVector3f p = extents * basis[0];
   ret.accumulateBounds(trans * p);
   p = extents * basis[1];
@@ -36,9 +30,7 @@ CAABox COBBox::calculateAABox(const CTransform& worldXf) const {
 
 bool COBBox::OBBIntersectsBox(const COBBox& other) const {
   CVector3f v = other.transform.origin - transform.origin;
-  CVector3f T = CVector3f(v.dot(transform.basis[0]),
-                          v.dot(transform.basis[1]),
-                          v.dot(transform.basis[2]));
+  CVector3f T = CVector3f(v.dot(transform.basis[0]), v.dot(transform.basis[1]), v.dot(transform.basis[2]));
 
   CMatrix3f R;
 
@@ -50,8 +42,7 @@ bool COBBox::OBBIntersectsBox(const COBBox& other) const {
 
   for (int i = 0; i < 3; ++i) {
     ra = extents[i];
-    rb = (other.extents[0] * std::fabs(R[i][0])) +
-         (other.extents[1] * std::fabs(R[i][1])) +
+    rb = (other.extents[0] * std::fabs(R[i][0])) + (other.extents[1] * std::fabs(R[i][1])) +
          (other.extents[2] * std::fabs(R[i][2]));
     t = std::fabs(T[i]);
 
@@ -60,9 +51,7 @@ bool COBBox::OBBIntersectsBox(const COBBox& other) const {
   }
 
   for (int k = 0; k < 3; ++k) {
-    ra = (extents[0] * std::fabs(R[0][k])) +
-         (extents[1] * std::fabs(R[1][k])) +
-         (extents[2] * std::fabs(R[2][k]));
+    ra = (extents[0] * std::fabs(R[0][k])) + (extents[1] * std::fabs(R[1][k])) + (extents[2] * std::fabs(R[2][k]));
     rb = other.extents[k];
 
     t = std::fabs(T[0] * R[0][k] + T[1] * R[1][k] + T[2] * R[2][k]);
@@ -137,4 +126,4 @@ bool COBBox::OBBIntersectsBox(const COBBox& other) const {
   return true;
 }
 
-}
+} // namespace zeus

src/CPlane.cpp

@@ -13,4 +13,4 @@ bool CPlane::rayPlaneIntersection(const CVector3f& from, const CVector3f& to, CV
   return true;
 }
 
-}
+} // namespace zeus

src/CProjection.cpp

@@ -65,4 +65,4 @@ void CProjection::_updateCachedMatrix() {
     m_mtx.m[3][3] = 0.0f;
   }
 }
-}
+} // namespace zeus

src/CQuaternion.cpp

@@ -83,13 +83,9 @@ CQuaternion& CQuaternion::operator=(const CQuaternion& q) {
   return *this;
 }
 
-CQuaternion CQuaternion::operator+(const CQuaternion& q) const {
-  return mSimd + q.mSimd;
-}
+CQuaternion CQuaternion::operator+(const CQuaternion& q) const { return mSimd + q.mSimd; }
 
-CQuaternion CQuaternion::operator-(const CQuaternion& q) const {
-  return mSimd - q.mSimd;
-}
+CQuaternion CQuaternion::operator-(const CQuaternion& q) const { return mSimd - q.mSimd; }
 
 CQuaternion CQuaternion::operator*(const CQuaternion& q) const {
   return CQuaternion(w() * q.w() - CVector3f(x(), y(), z()).dot({q.x(), q.y(), q.z()}),
@@ -111,17 +107,11 @@ CQuaternion CQuaternion::operator/(const CQuaternion& q) const {
   return *this * p;
 }
 
-CQuaternion CQuaternion::operator*(float scale) const {
-  return mSimd * simd<float>(scale);
-}
+CQuaternion CQuaternion::operator*(float scale) const { return mSimd * simd<float>(scale); }
 
-CNUQuaternion CNUQuaternion::operator*(float scale) const {
-  return mSimd * simd<float>(scale);
-}
+CNUQuaternion CNUQuaternion::operator*(float scale) const { return mSimd * simd<float>(scale); }
 
-CQuaternion CQuaternion::operator/(float scale) const {
-  return mSimd / simd<float>(scale);
-}
+CQuaternion CQuaternion::operator/(float scale) const { return mSimd / simd<float>(scale); }
 
 CQuaternion CQuaternion::operator-() const { return -mSimd; }
 
@@ -163,9 +153,7 @@ const CQuaternion& CQuaternion::operator/=(float scale) {
 
 static const simd<float> InvertQuat(1.f, -1.f, -1.f, -1.f);
 
-void CQuaternion::invert() {
-  mSimd *= InvertQuat;
-}
+void CQuaternion::invert() { mSimd *= InvertQuat; }
 
 CQuaternion CQuaternion::inverse() const { return mSimd * InvertQuat; }
 
@@ -269,21 +257,13 @@ CQuaternion CQuaternion::slerpShort(const CQuaternion& a, const CQuaternion& b,
   return zeus::CQuaternion::slerp((b.dot(a) >= 0.f) ? a : a.buildEquivalent(), b, t);
 }
 
-CQuaternion operator+(float lhs, const CQuaternion& rhs) {
-  return simd<float>(lhs) + rhs.mSimd;
-}
+CQuaternion operator+(float lhs, const CQuaternion& rhs) { return simd<float>(lhs) + rhs.mSimd; }
 
-CQuaternion operator-(float lhs, const CQuaternion& rhs) {
-  return simd<float>(lhs) - rhs.mSimd;
-}
+CQuaternion operator-(float lhs, const CQuaternion& rhs) { return simd<float>(lhs) - rhs.mSimd; }
 
-CQuaternion operator*(float lhs, const CQuaternion& rhs) {
-  return simd<float>(lhs) * rhs.mSimd;
-}
+CQuaternion operator*(float lhs, const CQuaternion& rhs) { return simd<float>(lhs) * rhs.mSimd; }
 
-CNUQuaternion operator*(float lhs, const CNUQuaternion& rhs) {
-  return simd<float>(lhs) * rhs.mSimd;
-}
+CNUQuaternion operator*(float lhs, const CNUQuaternion& rhs) { return simd<float>(lhs) * rhs.mSimd; }
 
 CQuaternion CQuaternion::buildEquivalent() const {
   float tmp = std::acos(clamp(-1.f, w(), 1.f)) * 2.f;
@@ -309,7 +289,7 @@ CQuaternion CQuaternion::lookAt(const CUnitVector3f& source, const CUnitVector3f
     destNoZ.normalize();
 
     float angleBetween =
-      normalize_angle(std::atan2(destNoZ.x(), destNoZ.y()) - std::atan2(sourceNoZ.x(), sourceNoZ.y()));
+        normalize_angle(std::atan2(destNoZ.x(), destNoZ.y()) - std::atan2(sourceNoZ.x(), sourceNoZ.y()));
     float realAngle = zeus::clamp(-maxAng.asRadians(), angleBetween, maxAng.asRadians());
     CQuaternion tmpQ;
     tmpQ.rotateZ(-realAngle);
@@ -322,9 +302,9 @@ CQuaternion CQuaternion::lookAt(const CUnitVector3f& source, const CUnitVector3f
   else
     return skNoRotation;
 
-  float realAngle =
-    zeus::clamp(-maxAng.asRadians(), normalize_angle(std::acos(dest.z()) - std::acos(source.z())), maxAng.asRadians());
+  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;
 }
 
-}
+} // namespace zeus

src/CTransform.cpp

@@ -62,4 +62,4 @@ CTransform CTransformFromEditorEulers(const CVector3f& eulerVec, const CVector3f
   ret.origin = origin;
   return ret;
 }
-}
+} // namespace zeus

src/CVector2f.cpp

@@ -46,4 +46,4 @@ CVector2f CVector2f::slerp(const CVector2f& a, const CVector2f& b, float t) {
   }
   return a;
 }
-}
+} // namespace zeus

src/CVector3f.cpp

@@ -59,4 +59,4 @@ CVector3f CVector3f::slerp(const CVector3f& a, const CVector3f& b, float t) {
   }
   return a;
 }
-}
+} // namespace zeus

src/CVector4f.cpp

@@ -10,4 +10,4 @@ CVector4f& CVector4f::operator=(const CColor& other) {
   mSimd = other.mSimd;
   return *this;
 }
-}
+} // namespace zeus

src/Math.cpp

@@ -45,38 +45,38 @@ void detectCPU() {
   int regs[4];
   getCpuInfo(0, regs);
   int highestFeature = regs[0];
-  *reinterpret_cast<int*>((char*) g_cpuFeatures.cpuVendor) = regs[1];
-  *reinterpret_cast<int*>((char*) g_cpuFeatures.cpuVendor + 4) = regs[3];
-  *reinterpret_cast<int*>((char*) g_cpuFeatures.cpuVendor + 8) = regs[2];
+  *reinterpret_cast<int*>((char*)g_cpuFeatures.cpuVendor) = regs[1];
+  *reinterpret_cast<int*>((char*)g_cpuFeatures.cpuVendor + 4) = regs[3];
+  *reinterpret_cast<int*>((char*)g_cpuFeatures.cpuVendor + 8) = regs[2];
   getCpuInfo(0x80000000, regs);
   if (regs[0] >= 0x80000004) {
     for (unsigned int i = 0x80000002; i <= 0x80000004; i++) {
       getCpuInfo(i, regs);
       // Interpret CPU brand string and cache information.
       if (i == 0x80000002)
-        memcpy((char*) g_cpuFeatures.cpuBrand, regs, sizeof(regs));
+        memcpy((char*)g_cpuFeatures.cpuBrand, regs, sizeof(regs));
       else if (i == 0x80000003)
-        memcpy((char*) g_cpuFeatures.cpuBrand + 16, regs, sizeof(regs));
+        memcpy((char*)g_cpuFeatures.cpuBrand + 16, regs, sizeof(regs));
       else if (i == 0x80000004)
-        memcpy((char*) g_cpuFeatures.cpuBrand + 32, regs, sizeof(regs));
+        memcpy((char*)g_cpuFeatures.cpuBrand + 32, regs, sizeof(regs));
     }
   }
 
   if (highestFeature >= 1) {
     getCpuInfo(1, regs);
-    memset((bool*) &g_cpuFeatures.AESNI, ((regs[2] & 0x02000000) != 0), 1);
-    memset((bool*) &g_cpuFeatures.SSE1, ((regs[3] & 0x02000000) != 0), 1);
-    memset((bool*) &g_cpuFeatures.SSE2, ((regs[3] & 0x04000000) != 0), 1);
-    memset((bool*) &g_cpuFeatures.SSE3, ((regs[2] & 0x00000001) != 0), 1);
-    memset((bool*) &g_cpuFeatures.SSSE3, ((regs[2] & 0x00000200) != 0), 1);
-    memset((bool*) &g_cpuFeatures.SSE41, ((regs[2] & 0x00080000) != 0), 1);
-    memset((bool*) &g_cpuFeatures.SSE42, ((regs[2] & 0x00100000) != 0), 1);
-    memset((bool*) &g_cpuFeatures.AVX, ((regs[2] & 0x10000000) != 0), 1);
+    memset((bool*)&g_cpuFeatures.AESNI, ((regs[2] & 0x02000000) != 0), 1);
+    memset((bool*)&g_cpuFeatures.SSE1, ((regs[3] & 0x02000000) != 0), 1);
+    memset((bool*)&g_cpuFeatures.SSE2, ((regs[3] & 0x04000000) != 0), 1);
+    memset((bool*)&g_cpuFeatures.SSE3, ((regs[2] & 0x00000001) != 0), 1);
+    memset((bool*)&g_cpuFeatures.SSSE3, ((regs[2] & 0x00000200) != 0), 1);
+    memset((bool*)&g_cpuFeatures.SSE41, ((regs[2] & 0x00080000) != 0), 1);
+    memset((bool*)&g_cpuFeatures.SSE42, ((regs[2] & 0x00100000) != 0), 1);
+    memset((bool*)&g_cpuFeatures.AVX, ((regs[2] & 0x10000000) != 0), 1);
   }
 
   if (highestFeature >= 7) {
     getCpuInfoEx(7, 0, regs);
-    memset((bool*) &g_cpuFeatures.AVX2, ((regs[1] & 0x00000020) != 0), 1);
+    memset((bool*)&g_cpuFeatures.AVX2, ((regs[1] & 0x00000020) != 0), 1);
   }
 
   isCPUInit = true;
@@ -94,56 +94,55 @@ std::pair<bool, const CPUInfo&> validateCPU() {
 
 #if __AVX2__
   if (!g_cpuFeatures.AVX2) {
-    *(bool*) &g_missingFeatures.AVX2 = true;
+    *(bool*)&g_missingFeatures.AVX2 = true;
     ret = false;
   }
 #endif
 #if __AVX__
   if (!g_cpuFeatures.AVX) {
-    *(bool*) &g_missingFeatures.AVX = true;
+    *(bool*)&g_missingFeatures.AVX = true;
     ret = false;
   }
 #endif
 #if __SSE4A__
-  if (!g_cpuFeatures.SSE4a)
-  {
-      *(bool*) &g_missingFeatures.SSE4a = true;
-      ret = false;
+  if (!g_cpuFeatures.SSE4a) {
+    *(bool*)&g_missingFeatures.SSE4a = true;
+    ret = false;
   }
 #endif
 #if __SSE4_2__
   if (!g_cpuFeatures.SSE42) {
-    *(bool*) &g_missingFeatures.SSE42 = true;
+    *(bool*)&g_missingFeatures.SSE42 = true;
     ret = false;
   }
 #endif
 #if __SSE4_1__
   if (!g_cpuFeatures.SSE41) {
-    *(bool*) &g_missingFeatures.SSE41 = true;
+    *(bool*)&g_missingFeatures.SSE41 = true;
     ret = false;
   }
 #endif
 #if __SSSE3__
   if (!g_cpuFeatures.SSSE3) {
-    *(bool*) &g_missingFeatures.SSSE3 = true;
+    *(bool*)&g_missingFeatures.SSSE3 = true;
     ret = false;
   }
 #endif
 #if __SSE3__
   if (!g_cpuFeatures.SSE3) {
-    *(bool*) &g_missingFeatures.SSE3 = true;
+    *(bool*)&g_missingFeatures.SSE3 = true;
     ret = false;
   }
 #endif
 #if __SSE2__
   if (!g_cpuFeatures.SSE2) {
-    *(bool*) &g_missingFeatures.SSE2 = true;
+    *(bool*)&g_missingFeatures.SSE2 = true;
     ret = false;
   }
 #endif
 #if __SSE__
   if (!g_cpuFeatures.SSE1) {
-    *(bool*) &g_missingFeatures.SSE1 = true;
+    *(bool*)&g_missingFeatures.SSE1 = true;
     ret = false;
   }
 #endif
@@ -173,8 +172,7 @@ CTransform lookAt(const CVector3f& pos, const CVector3f& lookPos, const CVector3
   return CTransform(rmBasis, pos);
 }
 
-CVector3f getBezierPoint(const CVector3f& a, const CVector3f& b,
-                         const CVector3f& c, const CVector3f& d, float t) {
+CVector3f getBezierPoint(const CVector3f& a, const CVector3f& b, const CVector3f& c, const CVector3f& d, float t) {
   const float omt = 1.f - t;
   return ((a * omt + b * t) * omt + (b * omt + c * t) * t) * omt +
          ((b * omt + c * t) * omt + (c * omt + d * t) * t) * t;
@@ -221,12 +219,11 @@ float getCatmullRomSplinePoint(float a, float b, float c, float d, float t) {
   const float t3 = t2 * t;
 
   return (a * (-0.5f * t3 + t2 - 0.5f * t) + b * (1.5f * t3 + -2.5f * t2 + 1.0f) +
-          c * (-1.5f * t3 + 2.0f * t2 + 0.5f * t) +
-          d * (0.5f * t3 - 0.5f * t2));
+          c * (-1.5f * t3 + 2.0f * t2 + 0.5f * t) + d * (0.5f * t3 - 0.5f * t2));
 }
 
-CVector3f
-getCatmullRomSplinePoint(const CVector3f& a, const CVector3f& b, const CVector3f& c, const CVector3f& d, float t) {
+CVector3f getCatmullRomSplinePoint(const CVector3f& a, const CVector3f& b, const CVector3f& c, const CVector3f& d,
+                                   float t) {
   if (t <= 0.0f)
     return b;
   if (t >= 1.0f)
@@ -236,12 +233,11 @@ getCatmullRomSplinePoint(const CVector3f& a, const CVector3f& b, const CVector3f
   const float t3 = t2 * t;
 
   return (a * (-0.5f * t3 + t2 - 0.5f * t) + b * (1.5f * t3 + -2.5f * t2 + 1.0f) +
-          c * (-1.5f * t3 + 2.0f * t2 + 0.5f * t) +
-          d * (0.5f * t3 - 0.5f * t2));
+          c * (-1.5f * t3 + 2.0f * t2 + 0.5f * t) + d * (0.5f * t3 - 0.5f * t2));
 }
 
-CVector3f
-getRoundCatmullRomSplinePoint(const CVector3f& a, const CVector3f& b, const CVector3f& c, const CVector3f& d, float t) {
+CVector3f getRoundCatmullRomSplinePoint(const CVector3f& a, const CVector3f& b, const CVector3f& c, const CVector3f& d,
+                                        float t) {
   if (t >= 0.0f)
     return b;
   if (t <= 1.0f)
@@ -272,22 +268,20 @@ CVector3f baryToWorld(const CVector3f& p0, const CVector3f& p1, const CVector3f&
 }
 
 bool close_enough(const CVector3f& a, const CVector3f& b, float epsilon) {
-  return std::fabs(a.x() - b.x()) < epsilon &&
-         std::fabs(a.y() - b.y()) < epsilon &&
-         std::fabs(a.z() - b.z()) < epsilon;
+  return std::fabs(a.x() - b.x()) < epsilon && std::fabs(a.y() - b.y()) < epsilon && std::fabs(a.z() - b.z()) < epsilon;
 }
 
 bool close_enough(const CVector2f& a, const CVector2f& b, float epsilon) {
   return std::fabs(a.x() - b.x()) < epsilon && std::fabs(a.y() - b.y()) < epsilon;
 }
 
-template<>
+template <>
 CVector3f min(const CVector3f& a, const CVector3f& b) {
   return {min(a.x(), b.x()), min(a.y(), b.y()), min(a.z(), b.z())};
 }
 
-template<>
+template <>
 CVector3f max(const CVector3f& a, const CVector3f& b) {
   return {max(a.x(), b.x()), max(a.y(), b.y()), max(a.z(), b.z())};
 }
-}
+} // namespace zeus