1 files changed, 86 insertions, 76 deletions

diff --git a/include/math/mat4.h b/include/math/mat4.h
index 3ceb75b..e808d73 100644
--- a/include/math/mat4.h
+++ b/include/math/mat4.h
@@ -20,9 +20,9 @@ typedef struct mat4 {
 /// [ m10 m11 m12 m13 ]
 /// [ m20 m21 m22 m23 ]
 /// [ m30 m31 m32 m33 ]
-static inline mat4 mat4_make(R m00, R m01, R m02, R m03, R m10, R m11, R m12,
-                             R m13, R m20, R m21, R m22, R m23, R m30, R m31,
-                             R m32, R m33) {
+static inline mat4 mat4_make(
+    R m00, R m01, R m02, R m03, R m10, R m11, R m12, R m13, R m20, R m21, R m22,
+    R m23, R m30, R m31, R m32, R m33) {
   mat4 m;
   m.val[0][0] = m00;
   m.val[0][1] = m10;
@@ -73,22 +73,24 @@ static inline mat4 mat4_from_array(const R M[16]) {
 
 /// Construct the identity matrix.
 static inline mat4 mat4_id() {
-  return mat4_make(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0,
-                   0.0, 0.0, 0.0, 1.0);
+  return mat4_make(
+      1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0,
+      1.0);
 }
 
 /// Construct a matrix from 4 column vectors.
 static inline mat4 mat4_from_vec4(vec4 v0, vec4 v1, vec4 v2, vec4 v3) {
-  return mat4_make(v0.x, v0.y, v0.z, v0.w, v1.x, v1.y, v1.z, v1.w, v2.x, v2.y,
-                   v2.z, v2.w, v3.x, v3.y, v3.z, v3.w);
+  return mat4_make(
+      v0.x, v0.y, v0.z, v0.w, v1.x, v1.y, v1.z, v1.w, v2.x, v2.y, v2.z, v2.w,
+      v3.x, v3.y, v3.z, v3.w);
 }
 
 /// Construct a transformation matrix from 4 vectors.
-static inline mat4 mat4_from_vec3(vec3 right, vec3 up, vec3 forward,
-                                  vec3 position) {
-  return mat4_make(right.x, right.y, right.z, 0.0, up.x, up.y, up.z, 0.0,
-                   forward.x, forward.y, forward.z, 0.0, position.x, position.y,
-                   position.z, 1.0);
+static inline mat4 mat4_from_vec3(
+    vec3 right, vec3 up, vec3 forward, vec3 position) {
+  return mat4_make(
+      right.x, right.y, right.z, 0.0, up.x, up.y, up.z, 0.0, forward.x,
+      forward.y, forward.z, 0.0, position.x, position.y, position.z, 1.0);
 }
 
 /// Return the value at the specified position.
@@ -205,23 +207,25 @@ static inline mat4 mat4_mul(mat4 A, mat4 B) {
           mat4_at(A, 3, 2) * mat4_at(B, 2, 3) +
           mat4_at(A, 3, 3) * mat4_at(B, 3, 3);
 
-  return mat4_make(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23,
-                   m30, m31, m32, m33);
+  return mat4_make(
+      m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32,
+      m33);
 }
 
 /// Return the translation component of the matrix.
 static inline mat4 mat4_translation(mat4 m) {
-  return mat4_make(1.0, 0.0, 0.0, mat4_at(m, 0, 3), 0.0, 1.0, 0.0,
-                   mat4_at(m, 1, 3), 0.0, 0.0, 1.0, mat4_at(m, 2, 3), 0.0, 0.0,
-                   0.0, 1.0);
+  return mat4_make(
+      1.0, 0.0, 0.0, mat4_at(m, 0, 3), 0.0, 1.0, 0.0, mat4_at(m, 1, 3), 0.0,
+      0.0, 1.0, mat4_at(m, 2, 3), 0.0, 0.0, 0.0, 1.0);
 }
 
 /// Return the rotation component of the matrix.
 static inline mat4 mat4_rotation(mat4 m) {
-  return mat4_make(mat4_at(m, 0, 0), mat4_at(m, 0, 1), mat4_at(m, 0, 2), 0.0,
-                   mat4_at(m, 1, 0), mat4_at(m, 1, 1), mat4_at(m, 1, 2), 0.0,
-                   mat4_at(m, 2, 0), mat4_at(m, 2, 1), mat4_at(m, 2, 2), 0.0,
-                   0.0, 0.0, 0.0, 1.0);
+  return mat4_make(
+      mat4_at(m, 0, 0), mat4_at(m, 0, 1), mat4_at(m, 0, 2), 0.0,
+      mat4_at(m, 1, 0), mat4_at(m, 1, 1), mat4_at(m, 1, 2), 0.0,
+      mat4_at(m, 2, 0), mat4_at(m, 2, 1), mat4_at(m, 2, 2), 0.0, 0.0, 0.0, 0.0,
+      1.0);
 }
 
 /// Create an X-axis rotation matrix.
@@ -247,22 +251,22 @@ static inline mat4 mat4_rotz(R angle) {
 
 /// Create a rotation matrix.
 static inline mat4 mat4_rot(vec3 axis, R angle) {
-  const R s = sin(angle);
-  const R c = cos(angle);
-  const R x = axis.x;
-  const R y = axis.y;
-  const R z = axis.z;
-  const R xy = x * y;
-  const R xz = x * z;
-  const R yz = y * z;
-  const R sx = s * x;
-  const R sy = s * y;
-  const R sz = s * z;
+  const R s   = sin(angle);
+  const R c   = cos(angle);
+  const R x   = axis.x;
+  const R y   = axis.y;
+  const R z   = axis.z;
+  const R xy  = x * y;
+  const R xz  = x * z;
+  const R yz  = y * z;
+  const R sx  = s * x;
+  const R sy  = s * y;
+  const R sz  = s * z;
   const R omc = 1.0 - c;
-  return mat4_make(c + omc * x * x, omc * xy - sz, omc * xz + sy, 0,
-                   omc * xy + sz, c + omc * y * y, omc * yz - sx, 0,
-                   omc * xz - sy, omc * yz + sx, c + omc * z * z, 0, 0, 0, 0,
-                   1);
+  return mat4_make(
+      c + omc * x * x, omc * xy - sz, omc * xz + sy, 0, omc * xy + sz,
+      c + omc * y * y, omc * yz - sx, 0, omc * xz - sy, omc * yz + sx,
+      c + omc * z * z, 0, 0, 0, 0, 1);
 }
 
 /// Create a scaling matrix.
@@ -295,15 +299,16 @@ static inline mat4 mat4_from_forward(vec3 forward) {
   const vec3 f = vec3_normalize(forward);
   const vec3 r = vec3_normalize(vec3_cross(f, up3()));
   const vec3 u = vec3_normalize(vec3_cross(r, f));
-  return mat4_make(r.x, u.x, -f.x, 0.0, r.y, u.y, -f.y, 0.0, r.z, u.z, -f.z,
-                   0.0, 0.0, 0.0, 0.0, 1.0);
+  return mat4_make(
+      r.x, u.x, -f.x, 0.0, r.y, u.y, -f.y, 0.0, r.z, u.z, -f.z, 0.0, 0.0, 0.0,
+      0.0, 1.0);
 }
 
 /// Create a transformation matrix.
 static inline mat4 mat4_lookat(vec3 position, vec3 target, vec3 up) {
-  const vec3 fwd = vec3_normalize(vec3_sub(target, position));
+  const vec3 fwd   = vec3_normalize(vec3_sub(target, position));
   const vec3 right = vec3_normalize(vec3_cross(fwd, up));
-  up = vec3_normalize(vec3_cross(right, fwd));
+  up               = vec3_normalize(vec3_cross(right, fwd));
   return mat4_from_vec3(right, up, fwd, position);
 }
 
@@ -318,8 +323,9 @@ static inline mat4 mat4_ortho(R left, R right, R bottom, R top, R near, R far) {
   const R tx = -(right + left) / (right - left);
   const R ty = -(top + bottom) / (top - bottom);
   const R tz = -(far + near) / (far - near);
-  return mat4_make(2 / (right - left), 0, 0, tx, 0, 2 / (top - bottom), 0, ty,
-                   0, 0, -2 / (far - near), tz, 0, 0, 0, 1);
+  return mat4_make(
+      2 / (right - left), 0, 0, tx, 0, 2 / (top - bottom), 0, ty, 0, 0,
+      -2 / (far - near), tz, 0, 0, 0, 1);
 }
 
 /// Create a perspective projection matrix.
@@ -332,9 +338,11 @@ static inline mat4 mat4_perspective(R fovy, R aspect, R near, R far) {
   R f = tan(fovy / 2.0);
   assert(f > 0.0);
   f = 1.0 / f;
+
   const R a = near - far;
-  return mat4_make(f / aspect, 0, 0, 0, 0, f, 0, 0, 0, 0, (far + near) / a,
-                   (2 * far * near / a), 0, 0, -1, 0);
+  return mat4_make(
+      f / aspect, 0, 0, 0, 0, f, 0, 0, 0, 0, (far + near) / a,
+      (2 * far * near / a), 0, 0, -1, 0);
 }
 
 /// Create the inverse of a perspective projection matrix.
@@ -346,18 +354,18 @@ static inline mat4 mat4_perspective(R fovy, R aspect, R near, R far) {
 static inline mat4 mat4_perspective_inverse(R fovy, R aspect, R near, R far) {
   R f = tan(fovy / 2.0);
   assert(f > 0.0);
-  f = 1.0 / f;
-  const R a = far * near;
+  f           = 1.0 / f;
+  const R a   = far * near;
   const R P32 = 0.5 * (near - far) / a;
   const R P33 = 0.5 * (far + near) / a;
-  return mat4_make(aspect / f, 0, 0, 0, 0, 1.0f / f, 0, 0, 0, 0, 0, -1, 0, 0,
-                   P32, P33);
+  return mat4_make(
+      aspect / f, 0, 0, 0, 0, 1.0f / f, 0, 0, 0, 0, 0, -1, 0, 0, P32, P33);
 }
 
 /// Return the matrix's determinant.
 static inline R mat4_det(mat4 m) {
-  const R* M = (const R*)(m.val);
-  const R inv0 = M[5] * M[10] * M[15] - M[5] * M[11] * M[14] -
+  const R* M    = (const R*)(m.val);
+  const R  inv0 = M[5] * M[10] * M[15] - M[5] * M[11] * M[14] -
                  M[9] * M[6] * M[15] + M[9] * M[7] * M[14] +
                  M[13] * M[6] * M[11] - M[13] * M[7] * M[10];
   const R inv1 = -M[4] * M[10] * M[15] + M[4] * M[11] * M[14] +
@@ -413,10 +421,11 @@ static inline mat4 mat4_inverse(mat4 m) {
   R det = M[0] * inv[0] + M[1] * inv[4] + M[2] * inv[8] + M[3] * inv[12];
   assert(det != 0.0);
   det = 1.0 / det;
-  return mat4_make(inv[0] * det, inv[4] * det, inv[8] * det, inv[12] * det,
-                   inv[1] * det, inv[5] * det, inv[9] * det, inv[13] * det,
-                   inv[2] * det, inv[6] * det, inv[10] * det, inv[14] * det,
-                   inv[3] * det, inv[7] * det, inv[11] * det, inv[15] * det);
+  return mat4_make(
+      inv[0] * det, inv[4] * det, inv[8] * det, inv[12] * det, inv[1] * det,
+      inv[5] * det, inv[9] * det, inv[13] * det, inv[2] * det, inv[6] * det,
+      inv[10] * det, inv[14] * det, inv[3] * det, inv[7] * det, inv[11] * det,
+      inv[15] * det);
 }
 
 /// Invert the transformation matrix.
@@ -428,9 +437,9 @@ static inline mat4 mat4_inverse_transform(mat4 m) {
   const vec3 u = mat4_v1(m);
   const vec3 f = mat4_v2(m);
   const vec3 t = mat4_v3(m);
-  return mat4_make(r.x, r.y, r.z, -vec3_dot(r, t), u.x, u.y, u.z,
-                   -vec3_dot(u, t), f.x, f.y, f.z, -vec3_dot(f, t), 0.0, 0.0,
-                   0.0, 1.0);
+  return mat4_make(
+      r.x, r.y, r.z, -vec3_dot(r, t), u.x, u.y, u.z, -vec3_dot(u, t), f.x, f.y,
+      f.z, -vec3_dot(f, t), 0.0, 0.0, 0.0, 1.0);
 }
 
 /// Transpose the matrix.
@@ -473,23 +482,24 @@ static inline vec4 mat4_mul_vec4(mat4 m, vec4 v) {
 /// within |eps|, false if there is at least one ij-value difference that is
 /// greater than eps.
 static inline bool mat4_eq(mat4 m, mat4 w, float eps) {
-  return (float_eq(mat4_at(m, 0, 0), mat4_at(w, 0, 0), eps) &&
-          float_eq(mat4_at(m, 0, 1), mat4_at(w, 0, 1), eps) &&
-          float_eq(mat4_at(m, 0, 2), mat4_at(w, 0, 2), eps) &&
-          float_eq(mat4_at(m, 0, 3), mat4_at(w, 0, 3), eps) &&
-
-          float_eq(mat4_at(m, 1, 0), mat4_at(w, 1, 0), eps) &&
-          float_eq(mat4_at(m, 1, 1), mat4_at(w, 1, 1), eps) &&
-          float_eq(mat4_at(m, 1, 2), mat4_at(w, 1, 2), eps) &&
-          float_eq(mat4_at(m, 1, 3), mat4_at(w, 1, 3), eps) &&
-
-          float_eq(mat4_at(m, 2, 0), mat4_at(w, 2, 0), eps) &&
-          float_eq(mat4_at(m, 2, 1), mat4_at(w, 2, 1), eps) &&
-          float_eq(mat4_at(m, 2, 2), mat4_at(w, 2, 2), eps) &&
-          float_eq(mat4_at(m, 2, 3), mat4_at(w, 2, 3), eps) &&
-
-          float_eq(mat4_at(m, 3, 0), mat4_at(w, 3, 0), eps) &&
-          float_eq(mat4_at(m, 3, 1), mat4_at(w, 3, 1), eps) &&
-          float_eq(mat4_at(m, 3, 2), mat4_at(w, 3, 2), eps) &&
-          float_eq(mat4_at(m, 3, 3), mat4_at(w, 3, 3), eps));
+  return (
+      float_eq(mat4_at(m, 0, 0), mat4_at(w, 0, 0), eps) &&
+      float_eq(mat4_at(m, 0, 1), mat4_at(w, 0, 1), eps) &&
+      float_eq(mat4_at(m, 0, 2), mat4_at(w, 0, 2), eps) &&
+      float_eq(mat4_at(m, 0, 3), mat4_at(w, 0, 3), eps) &&
+
+      float_eq(mat4_at(m, 1, 0), mat4_at(w, 1, 0), eps) &&
+      float_eq(mat4_at(m, 1, 1), mat4_at(w, 1, 1), eps) &&
+      float_eq(mat4_at(m, 1, 2), mat4_at(w, 1, 2), eps) &&
+      float_eq(mat4_at(m, 1, 3), mat4_at(w, 1, 3), eps) &&
+
+      float_eq(mat4_at(m, 2, 0), mat4_at(w, 2, 0), eps) &&
+      float_eq(mat4_at(m, 2, 1), mat4_at(w, 2, 1), eps) &&
+      float_eq(mat4_at(m, 2, 2), mat4_at(w, 2, 2), eps) &&
+      float_eq(mat4_at(m, 2, 3), mat4_at(w, 2, 3), eps) &&
+
+      float_eq(mat4_at(m, 3, 0), mat4_at(w, 3, 0), eps) &&
+      float_eq(mat4_at(m, 3, 1), mat4_at(w, 3, 1), eps) &&
+      float_eq(mat4_at(m, 3, 2), mat4_at(w, 3, 2), eps) &&
+      float_eq(mat4_at(m, 3, 3), mat4_at(w, 3, 3), eps));
 }