snow-math 1.1.0 → 1.2.1

data/ext/snow-math/mat4.c

@@ -42,10 +42,22 @@ void mat4_identity(mat4_t out)
 
 void mat4_copy(const mat4_t in, mat4_t out)
 {
-  if (in != out) {
-    int index = 0;
-    for (; index < 16; ++index) out[index] = in[index];
-  }
+  out[0 ] = in[0 ];
+  out[1 ] = in[1 ];
+  out[2 ] = in[2 ];
+  out[3 ] = in[3 ];
+  out[4 ] = in[4 ];
+  out[5 ] = in[5 ];
+  out[6 ] = in[6 ];
+  out[7 ] = in[7 ];
+  out[8 ] = in[8 ];
+  out[9 ] = in[9 ];
+  out[10] = in[10];
+  out[11] = in[11];
+  out[12] = in[12];
+  out[13] = in[13];
+  out[14] = in[14];
+  out[15] = in[15];
 }
 
 void mat4_set(
@@ -73,6 +85,19 @@ void mat4_set(
   out[15] = m15;
 }
 
+void mat4_to_mat3(const mat4_t in, mat3_t out)
+{
+  out[0] = in[0];
+  out[1] = in[1];
+  out[2] = in[2];
+  out[3] = in[4];
+  out[4] = in[5];
+  out[5] = in[6];
+  out[6] = in[8];
+  out[7] = in[9];
+  out[8] = in[10];
+}
+
 void mat4_set_axes3(const vec3_t x, const vec3_t y, const vec3_t z, const vec3_t w, mat4_t out)
 {
   out[0] = x[0];
@@ -418,26 +443,26 @@ int mat4_equals(const mat4_t left, const mat4_t right)
   to vary between checks
   */
   return (
-    s_fabs(left[0] - right[0]) < S_FLOAT_EPSILON &&
-    s_fabs(left[1] - right[1]) < S_FLOAT_EPSILON &&
-    s_fabs(left[2] - right[2]) < S_FLOAT_EPSILON &&
-
-    s_fabs(left[4] - right[4]) < S_FLOAT_EPSILON &&
-    s_fabs(left[5] - right[5]) < S_FLOAT_EPSILON &&
-    s_fabs(left[6] - right[6]) < S_FLOAT_EPSILON &&
-
-    s_fabs(left[8] - right[8]) < S_FLOAT_EPSILON &&
-    s_fabs(left[9] - right[9]) < S_FLOAT_EPSILON &&
-    s_fabs(left[10] - right[10]) < S_FLOAT_EPSILON &&
-
-    s_fabs(left[12] - right[12]) < S_FLOAT_EPSILON &&
-    s_fabs(left[13] - right[13]) < S_FLOAT_EPSILON &&
-    s_fabs(left[14] - right[14]) < S_FLOAT_EPSILON &&
-
-    s_fabs(left[3] - right[3]) < S_FLOAT_EPSILON &&
-    s_fabs(left[7] - right[7]) < S_FLOAT_EPSILON &&
-    s_fabs(left[11] - right[11]) < S_FLOAT_EPSILON &&
-    s_fabs(left[15] - right[15]) < S_FLOAT_EPSILON
+    float_equals(left[0],  right[0])  &&
+    float_equals(left[1],  right[1])  &&
+    float_equals(left[2],  right[2])  &&
+
+    float_equals(left[4],  right[4])  &&
+    float_equals(left[5],  right[5])  &&
+    float_equals(left[6],  right[6])  &&
+
+    float_equals(left[8],  right[8])  &&
+    float_equals(left[9],  right[9])  &&
+    float_equals(left[10], right[10]) &&
+
+    float_equals(left[12], right[12]) &&
+    float_equals(left[13], right[13]) &&
+    float_equals(left[14], right[14]) &&
+
+    float_equals(left[3],  right[3])  &&
+    float_equals(left[7],  right[7])  &&
+    float_equals(left[11], right[11]) &&
+    float_equals(left[15], right[15])
     );
 }
 
@@ -661,25 +686,50 @@ void mat4_translation(s_float_t x, s_float_t y, s_float_t z, mat4_t out) {
 void mat4_multiply(const mat4_t left, const mat4_t right, mat4_t out)
 {
   mat4_t temp;
-  int index;
+  s_float_t cx, cy, cz, cw;
 
   // Transpose the left matrix so we can be a little more cache-friendly.
   mat4_transpose(left, temp);
 
-  for (index = 0; index < 4; ++index) {
-    const int inner_index = index * 4;
-    s_float_t cx, cy, cz, cw;
-
-    cx = temp[inner_index];
-    cy = temp[inner_index + 1];
-    cz = temp[inner_index + 2];
-    cw = temp[inner_index + 3];
-
-    temp[inner_index]     = (cx * right[0 ]) + (cy * right[1 ]) + (cz * right[2 ]) + (cw * right[3 ]);
-    temp[inner_index + 1] = (cx * right[4 ]) + (cy * right[5 ]) + (cz * right[6 ]) + (cw * right[7 ]);
-    temp[inner_index + 2] = (cx * right[8 ]) + (cy * right[9 ]) + (cz * right[10]) + (cw * right[11]);
-    temp[inner_index + 3] = (cx * right[12]) + (cy * right[13]) + (cz * right[14]) + (cw * right[15]);
-  }
+  cx       = temp[0];
+  cy       = temp[1];
+  cz       = temp[2];
+  cw       = temp[3];
+
+  temp[0]  = (cx * right[0 ]) + (cy * right[1 ]) + (cz * right[2 ]) + (cw * right[3 ]);
+  temp[1]  = (cx * right[4 ]) + (cy * right[5 ]) + (cz * right[6 ]) + (cw * right[7 ]);
+  temp[2]  = (cx * right[8 ]) + (cy * right[9 ]) + (cz * right[10]) + (cw * right[11]);
+  temp[3]  = (cx * right[12]) + (cy * right[13]) + (cz * right[14]) + (cw * right[15]);
+
+  cx       = temp[4];
+  cy       = temp[5];
+  cz       = temp[6];
+  cw       = temp[7];
+
+  temp[4]  = (cx * right[0 ]) + (cy * right[1 ]) + (cz * right[2 ]) + (cw * right[3 ]);
+  temp[5]  = (cx * right[4 ]) + (cy * right[5 ]) + (cz * right[6 ]) + (cw * right[7 ]);
+  temp[6]  = (cx * right[8 ]) + (cy * right[9 ]) + (cz * right[10]) + (cw * right[11]);
+  temp[7]  = (cx * right[12]) + (cy * right[13]) + (cz * right[14]) + (cw * right[15]);
+
+  cx       = temp[8];
+  cy       = temp[9];
+  cz       = temp[10];
+  cw       = temp[11];
+
+  temp[8]  = (cx * right[0 ]) + (cy * right[1 ]) + (cz * right[2 ]) + (cw * right[3 ]);
+  temp[9]  = (cx * right[4 ]) + (cy * right[5 ]) + (cz * right[6 ]) + (cw * right[7 ]);
+  temp[10] = (cx * right[8 ]) + (cy * right[9 ]) + (cz * right[10]) + (cw * right[11]);
+  temp[11] = (cx * right[12]) + (cy * right[13]) + (cz * right[14]) + (cw * right[15]);
+
+  cx       = temp[12];
+  cy       = temp[13];
+  cz       = temp[14];
+  cw       = temp[15];
+
+  temp[12] = (cx * right[0 ]) + (cy * right[1 ]) + (cz * right[2 ]) + (cw * right[3 ]);
+  temp[13] = (cx * right[4 ]) + (cy * right[5 ]) + (cz * right[6 ]) + (cw * right[7 ]);
+  temp[14] = (cx * right[8 ]) + (cy * right[9 ]) + (cz * right[10]) + (cw * right[11]);
+  temp[15] = (cx * right[12]) + (cy * right[13]) + (cz * right[14]) + (cw * right[15]);
 
   mat4_transpose(temp, out);
 }
@@ -719,18 +769,22 @@ void mat4_inv_rotate_vec3(const mat4_t left, const vec3_t right, vec3_t out)
 
 void mat4_scale(const mat4_t in, s_float_t x, s_float_t y, s_float_t z, mat4_t out)
 {
-  mat4_copy(in, out);
-  out[0] *= x;
-  out[4] *= x;
-  out[8] *= x;
-
-  out[1] *= y;
-  out[5] *= y;
-  out[9] *= y;
-
-  out[2 ] *= z;
-  out[6 ] *= z;
-  out[10] *= z;
+  out[0]  = in[0]  * x;
+  out[1]  = in[1]  * y;
+  out[2]  = in[2]  * z;
+  out[3]  = in[3];
+  out[4]  = in[4]  * x;
+  out[5]  = in[5]  * y;
+  out[6]  = in[6]  * z;
+  out[7]  = in[7];
+  out[8]  = in[8]  * x;
+  out[9]  = in[9]  * y;
+  out[10] = in[10] * z;
+  out[11] = in[11];
+  out[12] = in[12];
+  out[13] = in[13];
+  out[14] = in[14];
+  out[15] = in[15];
 }
 
 #if defined(__cplusplus)

data/ext/snow-math/maths_local.h

@@ -32,25 +32,28 @@ extern "C" {
 /* Typedefs and macros for specific floating point types */
 #ifdef USE_FLOAT
 typedef float s_float_t;
-#define s_cos cosf
-#define s_sin sinf
-#define s_tan tanf
-#define s_acos acosf
-#define s_asin asinf
-#define s_atan atanf
-#define s_fabs fabsf
+#define s_cos(X)  (cosf((X)))
+#define s_sin(X)  (sinf((X)))
+#define s_tan(X)  (tanf((X)))
+#define s_acos(X) (acosf((X)))
+#define s_asin(X) (asinf((X)))
+#define s_atan(X) (atanf((X)))
+#define s_fabs(X) (fabsf((X)))
+#define s_sqrt(X) (sqrtf((X)))
 #else
 typedef double s_float_t;
-#define s_cos cos
-#define s_sin sin
-#define s_tan tan
-#define s_acos acos
-#define s_asin asin
-#define s_atan atan
-#define s_fabs fabs
+#define s_cos(X)  (cos((X)))
+#define s_sin(X)  (sin((X)))
+#define s_tan(X)  (tan((X)))
+#define s_acos(X) (acos((X)))
+#define s_asin(X) (asin((X)))
+#define s_atan(X) (atan((X)))
+#define s_fabs(X) (fabs((X)))
+#define s_sqrt(X) (sqrt((X)))
 #endif
 
 typedef s_float_t mat4_t[16];
+typedef s_float_t mat3_t[9];
 typedef s_float_t vec4_t[4];
 typedef s_float_t vec3_t[3];
 typedef s_float_t vec2_t[2];
@@ -114,6 +117,8 @@ void          vec3_multiply(const vec3_t left, const vec3_t right, vec3_t out);
 void          vec3_negate(const vec3_t v, vec3_t out);
 void          vec3_inverse(const vec3_t v, vec3_t out);
 
+void          vec3_project(const vec3_t in, const vec3_t normal, vec3_t out);
+void          vec3_reflect(const vec3_t in, const vec3_t normal, vec3_t out);
 void          vec3_cross_product(const vec3_t left, const vec3_t right, vec3_t out);
 s_float_t     vec3_dot_product(const vec3_t left, const vec3_t right);
 
@@ -154,6 +159,8 @@ void          vec4_multiply(const vec4_t left, const vec4_t right, vec4_t out);
 void          vec4_negate(const vec4_t v, vec4_t out);
 void          vec4_inverse(const vec4_t v, vec4_t out);
 
+void          vec4_project(const vec4_t in, const vec4_t normal, vec4_t out);
+void          vec4_reflect(const vec4_t in, const vec4_t normal, vec4_t out);
 s_float_t     vec4_dot_product(const vec4_t left, const vec4_t right);
 
 void          vec4_scale(const vec4_t v, s_float_t scalar, vec4_t out);
@@ -163,6 +170,40 @@ int           vec4_equals(const vec4_t left, const vec4_t right);
 
 
 
+/*==============================================================================
+
+  3x3 Matrix (mat3_t)
+
+==============================================================================*/
+
+extern const mat3_t g_mat3_identity;
+
+void          mat3_identity(mat3_t out);
+void          mat3_copy(const mat3_t in, mat3_t out);
+void          mat3_set(s_float_t m00, s_float_t m10, s_float_t m20,
+                       s_float_t m01, s_float_t m11, s_float_t m21,
+                       s_float_t m02, s_float_t m12, s_float_t m22,
+                       mat3_t out);
+void          mat3_to_mat4(const mat3_t in, mat4_t out);
+void          mat3_rotation(s_float_t angle, s_float_t x, s_float_t y, s_float_t z, mat3_t out);
+void          mat3_from_quat(const quat_t in, mat3_t out);
+void          mat3_transpose(const mat3_t in, mat3_t out);
+void          mat3_scale(const mat3_t in, s_float_t x, s_float_t y, s_float_t z, mat3_t out);
+void          mat3_orthogonal(const mat3_t in, mat3_t out);
+void          mat3_multiply(const mat3_t lhs, const mat3_t rhs, mat3_t out);
+void          mat3_rotate_vec3(const mat3_t lhs, const vec3_t rhs, vec3_t out);
+void          mat3_inv_rotate_vec3(const mat3_t lhs, const vec3_t rhs, vec3_t out);
+void          mat3_cofactor(const mat3_t in, mat3_t out);
+void          mat3_adjoint(const mat3_t in, mat3_t out);
+void          mat3_get_row3(const mat3_t in, int row, vec3_t out);
+void          mat3_get_column3(const mat3_t in, int column, vec3_t out);
+void          mat3_set_row3(int row, const vec3_t in, mat3_t out);
+void          mat3_set_column3(int column, const vec3_t in, mat3_t out);
+s_float_t     mat3_determinant(const mat3_t in);
+int           mat3_equals(const mat3_t lhs, const mat3_t rhs);
+int           mat3_inverse(const mat3_t in, mat3_t out);
+
+
 /*==============================================================================
 
   4x4 Matrix (mat4_t)
@@ -179,6 +220,7 @@ void          mat4_set(
   s_float_t m08, s_float_t m09, s_float_t m10, s_float_t m11,
   s_float_t m12, s_float_t m13, s_float_t m14, s_float_t m15,
   mat4_t out);
+void          mat4_to_mat3(const mat4_t in, mat3_t out);
 
 void          mat4_set_axes3(const vec3_t x, const vec3_t y, const vec3_t z, const vec3_t w, mat4_t out);
 void          mat4_get_axes3(const mat4_t m, vec3_t x, vec3_t y, vec3_t z, vec3_t w);
@@ -251,6 +293,7 @@ void          quat_multiply_vec3(const quat_t left, const vec3_t right, vec3_t o
 
 void          quat_from_angle_axis(s_float_t angle, s_float_t x, s_float_t y, s_float_t z, quat_t out);
 void          quat_from_mat4(const mat4_t mat, quat_t out);
+void          quat_from_mat3(const mat3_t mat, quat_t out);
 
 void          quat_slerp(const quat_t from, const quat_t to, s_float_t delta, quat_t out);
 

data/ext/snow-math/quat.c

@@ -108,7 +108,7 @@ void quat_from_mat4(const mat4_t mat, quat_t out)
 
   trace = mat[0] + mat[5] + mat[10];
   if (trace > 0) {
-    r = sqrtf(trace + 1.0);
+    r = s_sqrt(trace + 1.0);
     out[3] = r * 0.5;
     r = 0.5 / r;
     out[0] = (mat[9] - mat[6]) * r;
@@ -116,10 +116,13 @@ void quat_from_mat4(const mat4_t mat, quat_t out)
     out[2] = (mat[4] - mat[1]) * r;
   } else {
     index = 0;
-    if (mat[5] > mat[0]) index = 1;
-    if (mat[10] > mat[index * 5]) index = 2;
+    if (mat[10] > mat[index * 5]) {
+      index = 2;
+    } else if (mat[5] > mat[0]) {
+      index = 1;
+    }
 
-    r = sqrtf(mat[index * 5] - (mat[((index + 1)) % 3 * 5] + mat[((index + 2) % 3) * 5]) + 1.0);
+    r = s_sqrt(mat[index * 5] - (mat[((index + 1)) % 3 * 5] + mat[((index + 2) % 3) * 5]) + 1.0);
     out[index] = r * 0.5;
 
     if (r) r = 0.5 / r;
@@ -147,6 +150,65 @@ void quat_from_mat4(const mat4_t mat, quat_t out)
   }
 }
 
+void quat_from_mat3(const mat3_t mat, quat_t out)
+{
+  s_float_t trace, r;
+  const s_float_t *m = m;
+  s_float_t m01 = mat[3], m02 = mat[6], m10 = mat[1],
+            m12 = mat[7], m20 = mat[2], m21 = mat[5];
+
+  trace = mat[0] + mat[4] + mat[8];
+
+  if (trace > 0.0) {
+    r = s_sqrt(trace + 1);
+    out[3] = r * 0.5;
+    r = 0.5 / r;
+    out[0] = (m12 - m21) * r;
+    out[1] = (m20 - m02) * r;
+    out[2] = (m01 - m10) * r;
+  } else {
+    int index = 0;
+    if (mat[8] > (index ? mat[4] : mat[0])) {
+      index = 2;
+    } else if (mat[4] > mat[0]) {
+      index = 1;
+    }
+
+    switch (index) {
+    default:
+    case 0:
+      r = out[0] = s_sqrt(mat[0] - (mat[4] + mat[8]) + 1) * 0.5;
+      if (r != 0.0 && r != -0.0) {
+        r = 0.5 / r;
+      }
+      out[1] = (m10 + m01) * r;
+      out[2] = (m20 + m02) * r;
+      out[3] = (m12 - m21) * r;
+      break;
+
+    case 1:
+      r = out[1] = s_sqrt(mat[4] - (mat[8] + mat[0]) + 1) * 0.5;
+      if (r != 0.0 && r != -0.0) {
+        r = 0.5 / r;
+      }
+      out[0] = (m10 + m01) * r;
+      out[2] = (m12 + m21) * r;
+      out[3] = (m20 - m02) * r;
+      break;
+
+    case 2:
+      r = out[2] = s_sqrt(mat[4] - (mat[0] + mat[4]) + 1) * 0.5;
+      if (r != 0.0 && r != -0.0) {
+        r = 0.5 / r;
+      }
+      out[0] = (m20 + m02) * r;
+      out[1] = (m21 + m12) * r;
+      out[3] = (m01 - m10) * r;
+      break;
+    }
+  }
+}
+
 void quat_slerp(const quat_t from, const quat_t to, s_float_t delta, quat_t out)
 {
   s_float_t dot, scale0, scale1, angle, inverse_sin;

data/ext/snow-math/snow-math.c

@@ -381,18 +381,21 @@ static VALUE s_sm_snowmath_mod = Qnil;
 DEF_SM_TYPE_KLASS(vec3);
 DEF_SM_TYPE_KLASS(vec4);
 DEF_SM_TYPE_KLASS(quat);
+DEF_SM_TYPE_KLASS(mat3);
 DEF_SM_TYPE_KLASS(mat4);
 
 // Declare wrapping operations
 DECL_SM_UNWRAP_OP(vec3);
 DECL_SM_UNWRAP_OP(vec4);
 DECL_SM_UNWRAP_OP(quat);
+DECL_SM_UNWRAP_OP(mat3);
 DECL_SM_UNWRAP_OP(mat4);
 
 // Declare unwrapping operations
 DECL_SM_WRAP_OP(vec3);
 DECL_SM_WRAP_OP(vec4);
 DECL_SM_WRAP_OP(quat);
+DECL_SM_WRAP_OP(mat3);
 DECL_SM_WRAP_OP(mat4);
 
 
@@ -407,6 +410,7 @@ DECL_SM_WRAP_OP(mat4);
 DEF_SM_ARR_TYPE(vec3);
 DEF_SM_ARR_TYPE(vec4);
 DEF_SM_ARR_TYPE(quat);
+DEF_SM_ARR_TYPE(mat3);
 DEF_SM_ARR_TYPE(mat4);
 #endif
 
@@ -428,6 +432,8 @@ DEF_SM_UNARY_OP(copy, vec3, vec3);
 DEF_SM_UNARY_OP(normalize, vec3, vec3);
 DEF_SM_UNARY_OP(inverse, vec3, vec3);
 DEF_SM_UNARY_OP(negate, vec3, vec3);
+DEF_SM_BINARY_OP(project, vec3, vec3, vec3);
+DEF_SM_BINARY_OP(reflect, vec3, vec3, vec3);
 DEF_SM_BINARY_OP(cross_product, vec3, vec3, vec3);
 DEF_SM_BINARY_OP(multiply, vec3, vec3, vec3);
 DEF_SM_BINARY_OP(add, vec3, vec3, vec3);
@@ -625,6 +631,8 @@ DEF_SM_UNARY_OP(copy, vec4, vec4);
 DEF_SM_UNARY_OP(normalize, vec4, vec4);
 DEF_SM_UNARY_OP(inverse, vec4, vec4);
 DEF_SM_UNARY_OP(negate, vec4, vec4);
+DEF_SM_BINARY_OP(project, vec4, vec4, vec4);
+DEF_SM_BINARY_OP(reflect, vec4, vec4, vec4);
 DEF_SM_BINARY_OP(multiply, vec4, vec4, vec4);
 DEF_SM_BINARY_OP(add, vec4, vec4, vec4);
 DEF_SM_BINARY_OP(subtract, vec4, vec4, vec4);
@@ -866,6 +874,12 @@ static VALUE sm_quat_init(int argc, VALUE *argv, VALUE sm_self)
       break;
     }
 
+    if (SM_IS_A(argv[0], mat3)) {
+      const mat3_t *mat = sm_unwrap_mat3(argv[0], NULL);
+      quat_from_mat3(*mat, *self);
+      break;
+    }
+
     // Optional offset into array provided
     if (0) {
       case 2:
@@ -921,10 +935,6 @@ static VALUE sm_quat_to_s(VALUE self)
 
 
 
-
-
-
-
 static VALUE sm_quat_angle_axis(int argc, VALUE *argv, VALUE self)
 {
   VALUE sm_angle;
@@ -1141,6 +1151,7 @@ DEF_SM_LENGTH_OP(mat4);
 DEF_SM_FETCH_OP(mat4);
 DEF_SM_STORE_OP(mat4);
 DEF_SM_UNARY_OP(copy, mat4, mat4);
+DEF_SM_UNARY_OP(to_mat3, mat4, mat3);
 DEF_SM_UNARY_OP(transpose, mat4, mat4);
 DEF_SM_UNARY_OP(inverse_orthogonal, mat4, mat4);
 DEF_SM_UNARY_OP(adjoint, mat4, mat4);
@@ -1367,6 +1378,12 @@ static VALUE sm_mat4_init(int argc, VALUE *argv, VALUE sm_self)
       break;
     }
 
+    // Copy Mat3
+    if (SM_IS_A(argv[0], mat3)) {
+      mat3_to_mat4(*sm_unwrap_mat4(argv[0], NULL), *self);
+      break;
+    }
+
     // Build from Quaternion
     if (SM_IS_A(argv[0], quat)) {
       mat4_from_quat(*sm_unwrap_quat(argv[0], NULL), *self);
@@ -1438,9 +1455,9 @@ static VALUE sm_mat4_to_s(VALUE self)
   v = (const s_float_t *)*sm_unwrap_mat4(self, NULL);
   return rb_sprintf(
     "{ "
-    "%f, %f, %f, %f" ", "
-    "%f, %f, %f, %f" ", "
-    "%f, %f, %f, %f" ", "
+    "%f, %f, %f, %f" ",\n "
+    "%f, %f, %f, %f" ",\n "
+    "%f, %f, %f, %f" ",\n "
     "%f, %f, %f, %f"
     " }",
     v[0], v[1], v[2], v[3],
@@ -1977,6 +1994,430 @@ static VALUE sm_mat4_equals(VALUE sm_self, VALUE sm_other)
 
 
 
+/*==============================================================================
+
+  mat3_t functions
+
+==============================================================================*/
+
+DEF_SM_WRAP_OP(mat3);
+DEF_SM_UNWRAP_OP(mat3);
+DEF_SM_SIZE_OP(mat3);
+DEF_SM_LENGTH_OP(mat3);
+DEF_SM_FETCH_OP(mat3);
+DEF_SM_STORE_OP(mat3);
+DEF_SM_UNARY_OP(copy, mat3, mat3);
+DEF_SM_UNARY_OP(to_mat4, mat3, mat4);
+DEF_SM_UNARY_OP(transpose, mat3, mat3);
+DEF_SM_UNARY_OP(adjoint, mat3, mat3);
+DEF_SM_UNARY_OP(orthogonal, mat3, mat3);
+DEF_SM_UNARY_OP(cofactor, mat3, mat3);
+DEF_SM_BINARY_OP(multiply, mat3, mat3, mat3);
+DEF_SM_BINARY_OP(rotate_vec3, mat3, vec3, vec3);
+DEF_SM_BINARY_OP(inv_rotate_vec3, mat3, vec3, vec3);
+
+
+
+static VALUE sm_mat3_determinant(VALUE sm_self)
+{
+  return mat3_determinant(*sm_unwrap_mat3(sm_self, NULL));
+}
+
+
+
+static VALUE sm_mat3_inverse(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out = Qnil;
+  mat3_t *self;
+
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_mat3(sm_self, NULL);
+
+  if (argc == 1) {
+    mat3_t *output;
+
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }
+
+    if (!SM_IS_A(sm_out, mat3)) {
+      rb_raise(rb_eTypeError,
+        "Invalid argument to output of inverse_general: expected %s, got %s",
+        rb_class2name(SM_KLASS(mat3)),
+        rb_obj_classname(sm_out));
+      return Qnil;
+    }
+
+    output = sm_unwrap_mat3(sm_out, NULL);
+    if (!mat3_inverse(*self, *output)) {
+      return Qnil;
+    }
+
+  } else if (argc == 0) {
+    SM_LABEL(skip_output): {
+      mat3_t output;
+      if (!mat3_inverse(*self, output)) {
+        return Qnil;
+      }
+
+      sm_out = sm_wrap_mat3(output, rb_obj_class(sm_self));
+      rb_obj_call_init(sm_out, 0, 0);
+    }
+  } else {
+    rb_raise(rb_eArgError, "Invalid number of arguments to inverse");
+  }
+
+  return sm_out;
+}
+
+
+
+static VALUE sm_mat3_new(int argc, VALUE *argv, VALUE self)
+{
+  VALUE sm_mat = sm_wrap_mat3(g_mat3_identity, self);
+  rb_obj_call_init(sm_mat, argc, argv);
+  return sm_mat;
+}
+
+
+
+static VALUE sm_mat3_init(int argc, VALUE *argv, VALUE sm_self)
+{
+  mat3_t *self = sm_unwrap_mat3(sm_self, NULL);
+  size_t arr_index = 0;
+
+  switch (argc) {
+
+  case 0: {
+    // Identity (handled in _new)
+    break;
+  }
+
+  // Copy Mat3 or provided [Numeric..]
+  case 1: {
+    // Copy Mat3
+    if (SM_IS_A(argv[0], mat3)) {
+      sm_unwrap_mat3(argv[0], *self);
+      break;
+    }
+
+    // Copy Mat4
+    if (SM_IS_A(argv[0], mat4)) {
+      mat4_to_mat3(*sm_unwrap_mat4(argv[0], NULL), *self);
+      break;
+    }
+
+    // Build from Quaternion
+    if (SM_IS_A(argv[0], quat)) {
+      mat3_from_quat(*sm_unwrap_quat(argv[0], NULL), *self);
+      break;
+    }
+
+    // Optional offset into array provided
+    if (0) {
+      case 2:
+      arr_index = NUM2SIZET(argv[1]);
+    }
+
+    // Array of values
+    if (SM_RB_IS_A(argv[0], rb_cArray)) {
+      VALUE arrdata = argv[0];
+      const size_t arr_end = arr_index + 9;
+      s_float_t *mat_elem = *self;
+      for (; arr_index < arr_end; ++arr_index, ++mat_elem) {
+        *mat_elem = rb_num2dbl(rb_ary_entry(arrdata, (long)arr_index));
+      }
+      break;
+    }
+
+    rb_raise(rb_eArgError, "Expected either an array of Numerics or a Mat3");
+    break;
+  }
+
+  // Mat3(Vec3, Vec3, Vec3)
+  case 3: {
+    size_t arg_index;
+    s_float_t *mat_elem = *self;
+    for (arg_index = 0; arg_index < 3; ++arg_index, mat_elem += 3) {
+      if (!SM_IS_A(argv[arg_index], vec3)) {
+        rb_raise(
+          rb_eArgError,
+          "Argument %d must be a Vec3 when supplying three arguments to Mat3.initialize",
+          (int)(arg_index + 1));
+      }
+
+      sm_unwrap_vec3(argv[arg_index], mat_elem);
+    }
+    break;
+  }
+
+  // Mat3(Numeric m00 .. m16)
+  case 9: {
+    s_float_t *mat_elem = *self;
+    VALUE *argv_p = argv;
+    for (; argc; --argc, ++argv_p, ++mat_elem) {
+      *mat_elem = (s_float_t)rb_num2dbl(*argv_p);
+    }
+    break;
+  }
+
+  default: {
+    rb_raise(rb_eArgError, "Invalid arguments to Mat3.initialize");
+    break;
+  }
+  } // swtich (argc)
+
+  return sm_self;
+}
+
+
+
+static VALUE sm_mat3_to_s(VALUE self)
+{
+  const s_float_t *v;
+  v = (const s_float_t *)*sm_unwrap_mat3(self, NULL);
+  return rb_sprintf(
+    "{ "
+    "%f, %f, %f" ",\n "
+    "%f, %f, %f" ",\n "
+    "%f, %f, %f"
+    " }",
+    v[0],   v[1],   v[2],
+    v[3],   v[4],   v[5],
+    v[6],   v[7],   v[8] );
+}
+
+
+
+static VALUE sm_mat3_angle_axis(int argc, VALUE *argv, VALUE self)
+{
+  VALUE sm_angle;
+  VALUE sm_axis;
+  VALUE sm_out;
+  s_float_t angle;
+  const vec3_t *axis;
+
+  rb_scan_args(argc, argv, "21", &sm_angle, &sm_axis, &sm_out);
+  SM_RAISE_IF_NOT_TYPE(sm_axis, vec3);
+
+  angle = (s_float_t)rb_num2dbl(sm_angle);
+  axis = sm_unwrap_vec3(sm_axis, NULL);
+
+  if (SM_IS_A(sm_out, mat3)) {
+    mat3_t *out = sm_unwrap_mat3(sm_out, NULL);
+    mat3_rotation(angle, (*axis)[0], (*axis)[1], (*axis)[2], *out);
+  } else {
+    mat3_t out;
+    mat3_rotation(angle, (*axis)[0], (*axis)[1], (*axis)[2], out);
+    sm_out = sm_wrap_mat3(out, self);
+    rb_obj_call_init(sm_out, 0, 0);
+  }
+
+  return sm_out;
+}
+
+
+
+static VALUE sm_mat3_get_row3(int argc, VALUE *argv, VALUE sm_self)
+{
+  mat3_t *self;
+  int index;
+  VALUE sm_out;
+
+  self = sm_unwrap_mat3(sm_self, NULL);
+  index = NUM2INT(argv[0]);
+  sm_out = Qnil;
+
+  if (index < 0 || index > 3) {
+    rb_raise(rb_eRangeError, "Index %d is out of range, must be (0 .. 3)", index);
+    return Qnil;
+  }
+
+  switch (argc) {
+  case 2: {
+    vec3_t *out;
+
+    sm_out = argv[1];
+
+    if (RTEST(sm_out)) {
+      SM_RAISE_IF_NOT_TYPE(sm_out, vec3);
+    } else {
+      goto SM_LABEL(no_output);
+    }
+
+    out = sm_unwrap_vec3(sm_out, NULL);
+    mat3_get_row3(*self, index, *out);
+
+    break;
+  }
+
+  case 1: SM_LABEL(no_output): {
+    vec3_t out;
+    mat3_get_row3(*self, index, out);
+    sm_out = sm_wrap_vec3(out, Qnil);
+    rb_obj_call_init(sm_out, 0, 0);
+    break;
+  }
+
+  default: {
+    rb_raise(rb_eArgError, "Invalid number of arguments to get_row3 - expected 1 or 2");
+    break;
+  }
+  }
+
+  return sm_out;
+}
+
+
+
+static VALUE sm_mat3_get_column3(int argc, VALUE *argv, VALUE sm_self)
+{
+  mat3_t *self;
+  int index;
+  VALUE sm_out;
+
+  self = sm_unwrap_mat3(sm_self, NULL);
+  index = NUM2INT(argv[0]);
+  sm_out = Qnil;
+
+  if (index < 0 || index > 3) {
+    rb_raise(rb_eRangeError, "Index %d is out of range, must be (0 .. 3)", index);
+    return Qnil;
+  }
+
+  switch (argc) {
+  case 2: {
+    vec3_t *out;
+
+    sm_out = argv[1];
+
+    if (RTEST(sm_out)) {
+      SM_RAISE_IF_NOT_TYPE(sm_out, vec3);
+    } else {
+      goto SM_LABEL(no_output);
+    }
+
+    out = sm_unwrap_vec3(sm_out, NULL);
+    mat3_get_column3(*self, index, *out);
+
+    break;
+  }
+
+  case 1: SM_LABEL(no_output): {
+    vec3_t out;
+    mat3_get_column3(*self, index, out);
+    sm_out = sm_wrap_vec3(out, Qnil);
+    rb_obj_call_init(sm_out, 0, 0);
+    break;
+  }
+
+  default: {
+    rb_raise(rb_eArgError, "Invalid number of arguments to get_column3 - expected 1 or 2");
+    break;
+  }
+  }
+
+  return sm_out;
+}
+
+
+
+static VALUE sm_mat3_set_row3(VALUE sm_self, VALUE sm_index, VALUE sm_value)
+{
+  const vec3_t *value;
+  int index;
+  mat3_t *self;
+
+  SM_RAISE_IF_NOT_TYPE(sm_value, vec3);
+
+  self = sm_unwrap_mat3(sm_self, NULL);
+  value = sm_unwrap_vec3(sm_value, NULL);
+  index = NUM2INT(sm_index);
+
+  if (index < 0 || index > 3) {
+    rb_raise(rb_eRangeError, "Index %d is out of range, must be (0 .. 3)", index);
+    return Qnil;
+  }
+
+  mat3_set_row3(index, *value, *self);
+
+  return sm_self;
+}
+
+
+
+static VALUE sm_mat3_set_column3(VALUE sm_self, VALUE sm_index, VALUE sm_value)
+{
+  const vec3_t *value;
+  int index;
+  mat3_t *self;
+
+  SM_RAISE_IF_NOT_TYPE(sm_value, vec3);
+
+  self = sm_unwrap_mat3(sm_self, NULL);
+  value = sm_unwrap_vec3(sm_value, NULL);
+  index = NUM2INT(sm_index);
+
+  if (index < 0 || index > 3) {
+    rb_raise(rb_eRangeError, "Index %d is out of range, must be (0 .. 3)", index);
+    return Qnil;
+  }
+
+  mat3_set_column3(index, *value, *self);
+
+  return sm_self;
+}
+
+
+
+static VALUE sm_mat3_identity(VALUE sm_self)
+{
+  mat3_t *self = sm_unwrap_mat3(sm_self, NULL);
+  mat3_identity(*self);
+  return sm_self;
+}
+
+
+
+static VALUE sm_mat3_scale(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  VALUE sm_x, sm_y, sm_z;
+  s_float_t x, y, z;
+  mat3_t *self = sm_unwrap_mat3(sm_self, NULL);
+
+  rb_scan_args(argc, argv, "31", &sm_x, &sm_y, &sm_z, &sm_out);
+  x = rb_num2dbl(sm_x);
+  y = rb_num2dbl(sm_y);
+  z = rb_num2dbl(sm_z);
+
+  if (SM_IS_A(sm_out, mat3)) {
+    mat3_scale(*self, x, y, z, *sm_unwrap_mat3(sm_out, NULL));
+  } else {
+    mat3_t out;
+    mat3_scale(*self, x, y, z, out);
+    sm_out = sm_wrap_mat3(out, rb_obj_class(sm_self));
+    rb_obj_call_init(sm_out, 0, 0);
+  }
+
+  return sm_out;
+}
+
+
+
+static VALUE sm_mat3_equals(VALUE sm_self, VALUE sm_other)
+{
+  if (!RTEST(sm_other)) {
+    return Qfalse;
+  } else {
+    SM_RAISE_IF_NOT_TYPE(sm_other, mat3);
+  }
+
+  return mat3_equals(*sm_unwrap_mat3(sm_self, NULL), *sm_unwrap_mat3(sm_other, NULL)) ? Qtrue : Qfalse;
+}
+
+
+
 /*==============================================================================
 
   General-purpose functions
@@ -2001,6 +2442,7 @@ void Init_bindings()
   SM_KLASS(vec3)            = rb_define_class_under(s_sm_snowmath_mod, "Vec3", rb_cObject);
   SM_KLASS(vec4)            = rb_define_class_under(s_sm_snowmath_mod, "Vec4", rb_cObject);
   SM_KLASS(quat)            = rb_define_class_under(s_sm_snowmath_mod, "Quat", rb_cObject);
+  SM_KLASS(mat3)            = rb_define_class_under(s_sm_snowmath_mod, "Mat3", rb_cObject);
   SM_KLASS(mat4)            = rb_define_class_under(s_sm_snowmath_mod, "Mat4", rb_cObject);
 
   rb_define_singleton_method(SM_KLASS(vec3), "new", sm_vec3_new, -1);
@@ -2020,6 +2462,8 @@ void Init_bindings()
   rb_define_method(SM_KLASS(vec3), "multiply_vec3", sm_vec3_multiply, -1);
   rb_define_method(SM_KLASS(vec3), "add", sm_vec3_add, -1);
   rb_define_method(SM_KLASS(vec3), "subtract", sm_vec3_subtract, -1);
+  rb_define_method(SM_KLASS(vec3), "reflect", sm_vec3_reflect, -1);
+  rb_define_method(SM_KLASS(vec3), "project", sm_vec3_project, -1);
   rb_define_method(SM_KLASS(vec3), "dot_product", sm_vec3_dot_product, 1);
   rb_define_method(SM_KLASS(vec3), "magnitude_squared", sm_vec3_magnitude_squared, 0);
   rb_define_method(SM_KLASS(vec3), "magnitude", sm_vec3_magnitude, 0);
@@ -2043,6 +2487,8 @@ void Init_bindings()
   rb_define_method(SM_KLASS(vec4), "multiply_vec4", sm_vec4_multiply, -1);
   rb_define_method(SM_KLASS(vec4), "add", sm_vec4_add, -1);
   rb_define_method(SM_KLASS(vec4), "subtract", sm_vec4_subtract, -1);
+  rb_define_method(SM_KLASS(vec4), "reflect", sm_vec4_reflect, -1);
+  rb_define_method(SM_KLASS(vec4), "project", sm_vec4_project, -1);
   rb_define_method(SM_KLASS(vec4), "dot_product", sm_vec4_dot_product, 1);
   rb_define_method(SM_KLASS(vec4), "magnitude_squared", sm_vec4_magnitude_squared, 0);
   rb_define_method(SM_KLASS(vec4), "magnitude", sm_vec4_magnitude, 0);
@@ -2087,6 +2533,7 @@ void Init_bindings()
   rb_define_singleton_method(SM_KLASS(mat4), "look_at", sm_mat4_look_at, -1);
   rb_define_method(SM_KLASS(mat4), "initialize", sm_mat4_init, -1);
   rb_define_method(SM_KLASS(mat4), "set", sm_mat4_init, -1);
+  rb_define_method(SM_KLASS(mat4), "to_mat3", sm_mat4_to_mat3, -1);
   rb_define_method(SM_KLASS(mat4), "load_identity", sm_mat4_identity, 0);
   rb_define_method(SM_KLASS(mat4), "fetch", sm_mat4_fetch, 1);
   rb_define_method(SM_KLASS(mat4), "store", sm_mat4_store, 2);
@@ -2118,10 +2565,40 @@ void Init_bindings()
   rb_define_method(SM_KLASS(mat4), "get_column4", sm_mat4_get_column4, -1);
   rb_define_method(SM_KLASS(mat4), "==", sm_mat4_equals, 1);
 
+  rb_define_singleton_method(SM_KLASS(mat3), "new", sm_mat3_new, -1);
+  rb_define_singleton_method(SM_KLASS(mat3), "angle_axis", sm_mat3_angle_axis, -1);
+  rb_define_method(SM_KLASS(mat3), "initialize", sm_mat3_init, -1);
+  rb_define_method(SM_KLASS(mat3), "set", sm_mat3_init, -1);
+  rb_define_method(SM_KLASS(mat3), "to_mat4", sm_mat3_to_mat4, -1);
+  rb_define_method(SM_KLASS(mat3), "load_identity", sm_mat3_identity, 0);
+  rb_define_method(SM_KLASS(mat3), "fetch", sm_mat3_fetch, 1);
+  rb_define_method(SM_KLASS(mat3), "store", sm_mat3_store, 2);
+  rb_define_method(SM_KLASS(mat3), "size", sm_mat3_size, 0);
+  rb_define_method(SM_KLASS(mat3), "length", sm_mat3_length, 0);
+  rb_define_method(SM_KLASS(mat3), "to_s", sm_mat3_to_s, 0);
+  rb_define_method(SM_KLASS(mat3), "address", sm_get_address, 0);
+  rb_define_method(SM_KLASS(mat3), "copy", sm_mat3_copy, -1);
+  rb_define_method(SM_KLASS(mat3), "transpose", sm_mat3_transpose, -1);
+  rb_define_method(SM_KLASS(mat3), "adjoint", sm_mat3_adjoint, -1);
+  rb_define_method(SM_KLASS(mat3), "cofactor", sm_mat3_cofactor, -1);
+  rb_define_method(SM_KLASS(mat3), "orthogonal", sm_mat3_orthogonal, -1);
+  rb_define_method(SM_KLASS(mat3), "scale", sm_mat3_scale, -1);
+  rb_define_method(SM_KLASS(mat3), "multiply_mat3", sm_mat3_multiply, -1);
+  rb_define_method(SM_KLASS(mat3), "rotate_vec3", sm_mat3_rotate_vec3, -1);
+  rb_define_method(SM_KLASS(mat3), "inverse_rotate_vec3", sm_mat3_inv_rotate_vec3, -1);
+  rb_define_method(SM_KLASS(mat3), "inverse", sm_mat3_inverse, -1);
+  rb_define_method(SM_KLASS(mat3), "determinant", sm_mat3_determinant, 0);
+  rb_define_method(SM_KLASS(mat3), "set_row3", sm_mat3_set_row3, 2);
+  rb_define_method(SM_KLASS(mat3), "get_row3", sm_mat3_get_row3, -1);
+  rb_define_method(SM_KLASS(mat3), "set_column3", sm_mat3_set_column3, 2);
+  rb_define_method(SM_KLASS(mat3), "get_column3", sm_mat3_get_column3, -1);
+  rb_define_method(SM_KLASS(mat3), "==", sm_mat3_equals, 1);
+
   #ifdef BUILD_ARRAY_TYPE
   REG_SM_ARR_TYPE(vec3, "Vec3Array");
   REG_SM_ARR_TYPE(vec4, "Vec4Array");
   REG_SM_ARR_TYPE(quat, "QuatArray");
+  REG_SM_ARR_TYPE(mat3, "Mat3Array");
   REG_SM_ARR_TYPE(mat4, "Mat4Array");
   #endif