cglm 0.1.0

data/ext/cglm/rb_cglm_euler.c

@@ -0,0 +1,141 @@
+#include "rb_cglm.h"
+
+/* call-seq: angles(mat4[, dest]) => dest or new Vec3
+ *
+ * Extracts euler angles (in radians) using xyz order.
+ */
+VALUE rb_cglm_euler_angles(int argc, VALUE *argv, VALUE self) {
+  VALUE m, dest;
+  rb_scan_args(argc, argv, "11", &m, &dest);
+  if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
+  glm_euler_angles(VAL2MAT4(m), VAL2VEC3(dest));
+  return dest;
+}
+
+/* call-seq: xyz(angles[, dest]) => dest or new Mat4
+ *
+ * Builds a rotation matrix from the specified angles, in xyz order. `angles`
+ * must be a Vec3 specifying the X, Y and Z angles (in that order).
+ */
+VALUE rb_cglm_euler_xyz(int argc, VALUE *argv, VALUE self) {
+  VALUE angles, dest;
+  rb_scan_args(argc, argv, "11", &angles, &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_euler_xyz(VAL2VEC3(angles), VAL2MAT4(dest));
+  return dest;
+}
+
+/* call-seq: zyx(angles[, dest]) => dest or new Mat4
+ *
+ * Builds a rotation matrix from the specified angles, in zyx order. `angles`
+ * must be a Vec3 specifying the X, Y and Z angles (in that order).
+ */
+VALUE rb_cglm_euler_zyx(int argc, VALUE *argv, VALUE self) {
+  VALUE angles, dest;
+  rb_scan_args(argc, argv, "11", &angles, &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_euler_zyx(VAL2VEC3(angles), VAL2MAT4(dest));
+  return dest;
+}
+
+/* call-seq: zxy(angles[, dest]) => dest or new Mat4
+ *
+ * Builds a rotation matrix from the specified angles, in zxy order. `angles`
+ * must be a Vec3 specifying the X, Y and Z angles (in that order).
+ */
+VALUE rb_cglm_euler_zxy(int argc, VALUE *argv, VALUE self) {
+  VALUE angles, dest;
+  rb_scan_args(argc, argv, "11", &angles, &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_euler_zxy(VAL2VEC3(angles), VAL2MAT4(dest));
+  return dest;
+}
+
+/* call-seq: xzy(angles[, dest]) => dest or new Mat4
+ *
+ * Builds a rotation matrix from the specified angles, in xzy order. `angles`
+ * must be a Vec3 specifying the X, Y and Z angles (in that order).
+ */
+VALUE rb_cglm_euler_xzy(int argc, VALUE *argv, VALUE self) {
+  VALUE angles, dest;
+  rb_scan_args(argc, argv, "11", &angles, &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_euler_xzy(VAL2VEC3(angles), VAL2MAT4(dest));
+  return dest;
+}
+
+/* call-seq: yzx(angles[, dest]) => dest or new Mat4
+ *
+ * Builds a rotation matrix from the specified angles, in yzx order. `angles`
+ * must be a Vec3 specifying the X, Y and Z angles (in that order).
+ */
+VALUE rb_cglm_euler_yzx(int argc, VALUE *argv, VALUE self) {
+  VALUE angles, dest;
+  rb_scan_args(argc, argv, "11", &angles, &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_euler_yzx(VAL2VEC3(angles), VAL2MAT4(dest));
+  return dest;
+}
+
+/* call-seq: yxz(angles[, dest]) => dest or new Mat4
+ *
+ * Builds a rotation matrix from the specified angles, in yxz order. `angles`
+ * must be a Vec3 specifying the X, Y and Z angles (in that order).
+ */
+VALUE rb_cglm_euler_yxz(int argc, VALUE *argv, VALUE self) {
+  VALUE angles, dest;
+  rb_scan_args(argc, argv, "11", &angles, &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_euler_yxz(VAL2VEC3(angles), VAL2MAT4(dest));
+  return dest;
+}
+
+/* call-seq: by_order(axis, angles[, dest]) => dest or new Mat4
+ *
+ * Builds a rotation matrix from the specified angles, in the specified order,
+ * which can be one of the constants from the Euler module, or computed using
+ * #order. `angles` must be a Vec3 specifying the X, Y and Z angles (in that
+ * order).
+ */
+VALUE rb_cglm_euler_by_order(int argc, VALUE *argv, VALUE self) {
+  VALUE angles, axis, dest;
+  rb_scan_args(argc, argv, "21", &axis, &angles, &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_euler_by_order(VAL2VEC3(angles), NUM2INT(axis), VAL2MAT4(dest));
+  return dest;
+}
+
+
+/* call-seq: order(axis) => Numeric
+ *
+ * Returns a numeric handle representing the specified axis order. `axis` is
+ * an array containing axis indices (0 for X, 1 for Y, 2 for Z).
+ *
+ * Example:
+ *
+ *     order([0, 2, 1]) #=> first X, then Z, then Y
+ */
+VALUE rb_cglm_euler_order(VALUE klass, VALUE order_ary) {
+  int order[3] = { NUM2INT(rb_ary_entry(order_ary, 0)),
+                   NUM2INT(rb_ary_entry(order_ary, 1)),
+                   NUM2INT(rb_ary_entry(order_ary, 2)) };
+  return INT2NUM(glm_euler_order(order));
+}
+
+void Init_cglm_euler() {
+  rb_define_const(rb_mEuler, "XYZ", INT2NUM(GLM_EULER_XYZ));
+  rb_define_const(rb_mEuler, "XZY", INT2NUM(GLM_EULER_XZY));
+  rb_define_const(rb_mEuler, "YZX", INT2NUM(GLM_EULER_YZX));
+  rb_define_const(rb_mEuler, "YXZ", INT2NUM(GLM_EULER_YXZ));
+  rb_define_const(rb_mEuler, "ZXY", INT2NUM(GLM_EULER_ZXY));
+  rb_define_const(rb_mEuler, "ZYX", INT2NUM(GLM_EULER_ZYX));
+  rb_define_singleton_method(rb_mEuler, "order",    rb_cglm_euler_order, 1);
+  rb_define_singleton_method(rb_mEuler, "xyz",      rb_cglm_euler_xyz, -1);
+  rb_define_singleton_method(rb_mEuler, "zyx",      rb_cglm_euler_zyx, -1);
+  rb_define_singleton_method(rb_mEuler, "zxy",      rb_cglm_euler_zxy, -1);
+  rb_define_singleton_method(rb_mEuler, "xzy",      rb_cglm_euler_xzy, -1);
+  rb_define_singleton_method(rb_mEuler, "yzx",      rb_cglm_euler_yzx, -1);
+  rb_define_singleton_method(rb_mEuler, "yxz",      rb_cglm_euler_yxz, -1);
+  rb_define_singleton_method(rb_mEuler, "by_order", rb_cglm_euler_by_order, -1);
+  rb_define_singleton_method(rb_mEuler, "angles",   rb_cglm_euler_angles, -1);
+}

data/ext/cglm/rb_cglm_frustum.c

@@ -0,0 +1,306 @@
+#define GLM_CUSTOM_CLIPSPACE 1
+#include "cglm/types.h"
+
+#undef near
+#undef far
+
+/* near */
+static float CSCOORD_LBN[4] = {-1.0f, -1.0f, -1.0f, 1.0f};
+static float CSCOORD_LTN[4] = {-1.0f,  1.0f, -1.0f, 1.0f};
+static float CSCOORD_RTN[4] = { 1.0f,  1.0f, -1.0f, 1.0f};
+static float CSCOORD_RBN[4] = { 1.0f, -1.0f, -1.0f, 1.0f};
+
+/* far */
+static float CSCOORD_LBF[4] = {-1.0f, -1.0f,  1.0f, 1.0f};
+static float CSCOORD_LTF[4] = {-1.0f,  1.0f,  1.0f, 1.0f};
+static float CSCOORD_RTF[4] = { 1.0f,  1.0f,  1.0f, 1.0f};
+static float CSCOORD_RBF[4] = { 1.0f, -1.0f,  1.0f, 1.0f};
+
+#define GLM_CSCOORD_LBN { CSCOORD_LBN[0], CSCOORD_LBN[1], CSCOORD_LBN[2], CSCOORD_LBN[3] }
+#define GLM_CSCOORD_LTN { CSCOORD_LTN[0], CSCOORD_LTN[1], CSCOORD_LTN[2], CSCOORD_LTN[3] }
+#define GLM_CSCOORD_RTN { CSCOORD_RTN[0], CSCOORD_RTN[1], CSCOORD_RTN[2], CSCOORD_RTN[3] }
+#define GLM_CSCOORD_RBN { CSCOORD_RBN[0], CSCOORD_RBN[1], CSCOORD_RBN[2], CSCOORD_RBN[3] }
+#define GLM_CSCOORD_LBF { CSCOORD_LBF[0], CSCOORD_LBF[1], CSCOORD_LBF[2], CSCOORD_LBF[3] }
+#define GLM_CSCOORD_LTF { CSCOORD_LTF[0], CSCOORD_LTF[1], CSCOORD_LTF[2], CSCOORD_LTF[3] }
+#define GLM_CSCOORD_RTF { CSCOORD_RTF[0], CSCOORD_RTF[1], CSCOORD_RTF[2], CSCOORD_RTF[3] }
+#define GLM_CSCOORD_RBF { CSCOORD_RBF[0], CSCOORD_RBF[1], CSCOORD_RBF[2], CSCOORD_RBF[3] }
+
+#include "rb_cglm.h"
+#define SYMBOL(cstr) ID2SYM(rb_intern(cstr))
+
+/* call-seq: planes(space[, dest]) => dest | new Hash
+ *
+ * Extracts the 6 view frustum planes into an hash of 6 Vec4's. If `dest` is
+ * omitted, a new Hash is allocated.
+ *
+ * * `space` is the Mat4 representing the space in which the 6 frustum planes
+ *   are defined. If it's a `projection` matrix, the result is in view space. If
+ *   it's a `(view * projection)` matrix, the result is in world space. If it's
+ *   a `(model * view * projection)` matrix, the result is in object space.
+ *
+ * * `dest` is a Hash containing the following keys: `:left`, `:right`, `:bottom`,
+ *   `:top`, `:near`, `:far`. Each value is a Vec4.
+ *
+ * You probably want to extract planes in world space, so use `(view * projection)`
+ * as `space`.
+ */
+VALUE rb_cglm_frustum_singleton_planes(int argc, VALUE *argv, VALUE self) {
+  VALUE mat, dest;
+  rb_scan_args(argc, argv, "11", &mat, &dest);
+  if (NIL_P(dest)) dest = rb_hash_new();
+  vec4 planes[6];
+  glm_frustum_planes(VAL2MAT4(mat), planes);
+
+  #define HASH_GET_OR_SET(index, name, str)                     \
+    VALUE name = rb_hash_aref(dest, SYMBOL(str));        \
+    if (NIL_P(name)) {                                     \
+      name = VEC4_NEW(ALLOC_VEC4);                     \
+      rb_hash_aset(dest, SYMBOL(str), name);             \
+    }                                                      \
+    memcpy(&VAL2VEC4(name), &planes[index], sizeof(vec4));
+
+    HASH_GET_OR_SET(GLM_LEFT,   left, "left");
+    HASH_GET_OR_SET(GLM_RIGHT,  right, "right");
+    HASH_GET_OR_SET(GLM_BOTTOM, bottom, "bottom");
+    HASH_GET_OR_SET(GLM_TOP,    top, "top");
+    HASH_GET_OR_SET(GLM_NEAR,   n, "near");
+    HASH_GET_OR_SET(GLM_FAR,    f, "far");
+  #undef HASH_GET_OR_SET
+
+  return dest;
+}
+
+
+/* call-seq: corners(inv_space[, dest]) => dest | new Hash
+ *
+ * Extracts the view frustum corners using clip-space coordinates.
+ *
+ * * `inv_space` is the inverse of the Mat4 representing the space in which
+ *   the 8 frustum corners are defined. If it's an `(inverse(view * projection))`
+ *   matrix, the result is in world space. If it's an `(inverse(model * view * projection))`
+ *   matrix, the result is in object space.
+ *
+ *   * You probably want to extract planes in world space, so use
+ *     `(inverse(view * projection))` as `inv_space`.
+ *
+ * * `dest` is a Hash containing the following keys: `:lbn`, `:ltn`, `:rtn`,
+ *   `:rbn`, `:lbf`, `:ltf`, `:rtf`, `:rbf`. Each value is a Vec4.
+ *
+ *   * The `dest` hash, if created, is ordered such that you can index into
+ *     the array of values with the Frustum class constants. For example,
+ *     `hash.values[Frustum::RTN]`.
+ *
+ *   * If you know the index of a near coord, you can get its far coord by
+ *     adding 4. For example,
+ *     `hash.values[Frustum::RTN + 4] == hash.values[Frustum::RTF]`.
+ *
+ */
+VALUE rb_cglm_frustum_singleton_corners(int argc, VALUE *argv, VALUE self) {
+  VALUE mat, dest;
+  rb_scan_args(argc, argv, "11", &mat, &dest);
+  if (NIL_P(dest)) dest = rb_hash_new();
+  vec4 corners[8];
+  glm_frustum_corners(VAL2MAT4(mat), corners);
+
+  #define HASH_GET_OR_SET(index, name)                     \
+    VALUE name = rb_hash_aref(dest, SYMBOL(#name));        \
+    if (NIL_P(name)) {                                     \
+      name = VEC4_NEW(ALLOC_VEC4);                     \
+      rb_hash_aset(dest, SYMBOL(#name), name);             \
+    }                                                      \
+    memcpy(&VAL2VEC4(name), &corners[index], sizeof(vec4));
+
+    HASH_GET_OR_SET(GLM_LBN, lbn);
+    HASH_GET_OR_SET(GLM_LTN, ltn);
+    HASH_GET_OR_SET(GLM_RTN, rtn);
+    HASH_GET_OR_SET(GLM_RBN, rbn);
+    HASH_GET_OR_SET(GLM_LBF, lbf);
+    HASH_GET_OR_SET(GLM_LTF, ltf);
+    HASH_GET_OR_SET(GLM_RTF, rtf);
+    HASH_GET_OR_SET(GLM_RBF, rbf);
+  #undef HASH_GET_OR_SET
+
+  return dest;
+}
+
+#define hash_to_corner(corners, corners_v, index, name)     \
+  {                                                         \
+    VALUE v = rb_hash_aref(corners_v, SYMBOL(name));        \
+    if (NIL_P(v)) v = VEC4_NEW(ALLOC_VEC4);             \
+    memcpy(&corners[index][0], &VAL2VEC4(v), sizeof(vec4)); \
+  }
+
+#define hash_to_corners(corners, corners_v)           \
+  hash_to_corner(corners, corners_v, GLM_LBN, "lbn"); \
+  hash_to_corner(corners, corners_v, GLM_LTN, "ltn"); \
+  hash_to_corner(corners, corners_v, GLM_RTN, "rtn"); \
+  hash_to_corner(corners, corners_v, GLM_RBN, "rbn"); \
+  hash_to_corner(corners, corners_v, GLM_LBF, "lbf"); \
+  hash_to_corner(corners, corners_v, GLM_LTF, "ltf"); \
+  hash_to_corner(corners, corners_v, GLM_RTF, "rtf"); \
+  hash_to_corner(corners, corners_v, GLM_RBF, "rbf");
+
+/* call-seq: center(corners[, dest]) => dest | new vec4
+ *
+ * Returns the center of the view frustum described by the hash `corners`,
+ * which must follow the format returned by {corners}.
+ */
+VALUE rb_cglm_frustum_singleton_center(int argc, VALUE *argv, VALUE self) {
+  VALUE corners_v, dest;
+  rb_scan_args(argc, argv, "11", &corners_v, &dest);
+  if (NIL_P(dest)) dest = VEC4_NEW(ALLOC_VEC4);
+  vec4 corners[8];
+  hash_to_corners(corners, corners_v);
+  glm_frustum_center(corners, VAL2VEC4(dest));
+  return dest;
+}
+
+/* call-seq: aabb(matr, corners[, dest]) => dest | new AABB
+ *
+ * Finds a bounding box for the frustum defined by `corners` relative to the
+ * givn matrix (e.g. a view matrix). Places the result in `dest` and returns
+ * `dest`, or a new AABB if `dest` is omitted.
+ */
+VALUE rb_cglm_frustum_singleton_aabb(int argc, VALUE *argv, VALUE self) {
+  VALUE matr, corners_v, dest;
+  rb_scan_args(argc, argv, "21", &matr, &corners_v, &dest);
+  if (NIL_P(dest)) dest = rb_funcall(rb_cAABB, rb_intern("new"), 0);
+  vec4 corners[8];
+  hash_to_corners(corners, corners_v);
+  glm_frustum_box(corners, VAL2MAT4(matr), VAL2AABB(dest).corners);
+  return dest;
+}
+
+/* call-seq: corners_at(corners, split, far[, dest]) => dest | new Hash
+ *
+ * Finds the corners of a plane which lies between the near and far planes of
+ * the frustum.
+ *
+ * This will be helpful if you want to split a frustum, e.g. CSM/PSSM.
+ *
+ * * `corners` are the 8 corners of the frustum and follow the same format as
+ *   is returned by {corners}.
+ *
+ * * `split` is the distance at which to calculate the 4 corners.
+ *
+ * * `far` is the far distance of the frustum.
+ *
+ * * `dest` is a Hash containing :lb, :lt, :rt, and :rb (all of which are
+ *   Vec4's). If omitted, one will be created.
+ */
+VALUE rb_cglm_frustum_singleton_corners_at(int argc, VALUE *argv, VALUE self) {
+  VALUE corners_v, split, f, dest;
+  rb_scan_args(argc, argv, "31", &corners_v, &split, &f, &dest);
+  if (NIL_P(dest)) dest = rb_hash_new();
+  vec4 corners[8];
+  hash_to_corners(corners, corners_v);
+  vec4 plane_corners[4];
+  glm_frustum_corners_at(corners, NUM2FLT(split), NUM2FLT(f), plane_corners);
+
+  #define HASH_GET_OR_SET(index, name)                     \
+    VALUE name = rb_hash_aref(dest, SYMBOL(#name));        \
+    if (NIL_P(name)) {                                     \
+      name = VEC4_NEW(ALLOC_VEC4);                     \
+      rb_hash_aset(dest, SYMBOL(#name), name);             \
+    }                                                      \
+    memcpy(&VAL2VEC4(name), &plane_corners[index], sizeof(vec4));
+
+    HASH_GET_OR_SET(0, lb);
+    HASH_GET_OR_SET(1, lt);
+    HASH_GET_OR_SET(2, rt);
+    HASH_GET_OR_SET(3, rb);
+  #undef HASH_GET_OR_SET
+
+  return dest;
+}
+
+/* call-seq: planes([dest]) => dest | new Hash
+ *
+ * Same as calling {planes} with `self.matrix` as the first argument.
+ */
+VALUE rb_cglm_frustum_planes(int argc, VALUE *argv, VALUE self) {
+  VALUE mat = rb_ivar_get(self, rb_intern("@matrix"));
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  return rb_funcall(rb_cFrustum, rb_intern("planes"), 2, mat, dest);
+}
+
+/* call-seq: corners([dest]) => dest | new Hash
+ *
+ * Same as calling {corners} with `self.matrix.inverse` as the first argument.
+ */
+VALUE rb_cglm_frustum_corners(int argc, VALUE *argv, VALUE self) {
+  VALUE mat = rb_funcall(rb_ivar_get(self, rb_intern("@matrix")), rb_intern("inverse"), 0);
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  return rb_funcall(rb_cFrustum, rb_intern("corners"), 2, mat, dest);
+}
+
+/* call-seq: center([dest]) => dest | new Hash
+ *
+ * Same as calling {center} with #corners as the first argument.
+ */
+VALUE rb_cglm_frustum_center(int argc, VALUE *argv, VALUE self) {
+  VALUE corners = rb_funcall(self, rb_intern("corners"), 0);
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  return rb_funcall(rb_cFrustum, rb_intern("center"), 2, corners, dest);
+}
+
+/* call-seq: to_aabb(matr[, dest]) => dest | new AABB
+ *
+ * Same as calling {aabb} with #corners as the first argument.
+ */
+VALUE rb_cglm_frustum_to_aabb(int argc, VALUE *argv, VALUE self) {
+  VALUE corners = rb_funcall(self, rb_intern("corners"), 0);
+  VALUE split, f, dest;
+  rb_scan_args(argc, argv, "21", &split, &f, &dest);
+  return rb_funcall(rb_cFrustum, rb_intern("aabb"), 4, corners, split, f, dest);
+}
+
+/* call-seq: corners_at(split, far[, dest]) => dest | new Hash
+ *
+ * Same as calling {corners_at} with #corners as the first argument.
+ */
+VALUE rb_cglm_frustum_corners_at(int argc, VALUE *argv, VALUE self) {
+  VALUE corners = rb_funcall(self, rb_intern("corners"), 0);
+  VALUE split, f, dest;
+  rb_scan_args(argc, argv, "21", &split, &f, &dest);
+  return rb_funcall(rb_cFrustum, rb_intern("corners_at"), 4, corners, split, f, dest);
+}
+
+void Init_cglm_frustum() {
+  /* left  bottom near */ rb_define_const(rb_cFrustum, "LBN",                 GLM_LBN);
+  /* left  top    near */ rb_define_const(rb_cFrustum, "LTN",                 GLM_LTN);
+  /* right top    near */ rb_define_const(rb_cFrustum, "RTN",                 GLM_RTN);
+  /* right bottom near */ rb_define_const(rb_cFrustum, "RBN",                 GLM_RBN);
+  /* left  bottom far  */ rb_define_const(rb_cFrustum, "LBF",                 GLM_LBF);
+  /* left  top    far  */ rb_define_const(rb_cFrustum, "LTF",                 GLM_LTF);
+  /* right top    far  */ rb_define_const(rb_cFrustum, "RTF",                 GLM_RTF);
+  /* right bottom far  */ rb_define_const(rb_cFrustum, "RBF",                 GLM_RBF);
+                          rb_define_const(rb_cFrustum, "LEFT",                GLM_LEFT);
+                          rb_define_const(rb_cFrustum, "RIGHT",               GLM_RIGHT);
+                          rb_define_const(rb_cFrustum, "BOTTOM",              GLM_BOTTOM);
+                          rb_define_const(rb_cFrustum, "TOP",                 GLM_TOP);
+                          rb_define_const(rb_cFrustum, "NEAR",                GLM_NEAR);
+                          rb_define_const(rb_cFrustum, "FAR",                 GLM_FAR);
+  /* left  bottom near */ rb_define_const(rb_cFrustum, "CLIPSPACE_COORD_LBN", VEC4_NEW(CSCOORD_LBN));
+  /* left  top    near */ rb_define_const(rb_cFrustum, "CLIPSPACE_COORD_LTN", VEC4_NEW(CSCOORD_LTN));
+  /* right top    near */ rb_define_const(rb_cFrustum, "CLIPSPACE_COORD_RTN", VEC4_NEW(CSCOORD_RTN));
+  /* right bottom near */ rb_define_const(rb_cFrustum, "CLIPSPACE_COORD_RBN", VEC4_NEW(CSCOORD_RBN));
+  /* left  bottom far  */ rb_define_const(rb_cFrustum, "CLIPSPACE_COORD_LBF", VEC4_NEW(CSCOORD_LBF));
+  /* left  top    far  */ rb_define_const(rb_cFrustum, "CLIPSPACE_COORD_LTF", VEC4_NEW(CSCOORD_LTF));
+  /* right top    far  */ rb_define_const(rb_cFrustum, "CLIPSPACE_COORD_RTF", VEC4_NEW(CSCOORD_RTF));
+  /* right bottom far  */ rb_define_const(rb_cFrustum, "CLIPSPACE_COORD_RBF", VEC4_NEW(CSCOORD_RBF));
+
+  rb_define_method(rb_cFrustum, "planes",     rb_cglm_frustum_planes,  -1);
+  rb_define_method(rb_cFrustum, "corners",    rb_cglm_frustum_corners, -1);
+  rb_define_method(rb_cFrustum, "center",     rb_cglm_frustum_center,  -1);
+  rb_define_method(rb_cFrustum, "aabb",       rb_cglm_frustum_to_aabb, -1);
+  rb_define_method(rb_cFrustum, "corners_at", rb_cglm_frustum_to_aabb, -1);
+
+  rb_define_singleton_method(rb_cFrustum, "planes",     rb_cglm_frustum_singleton_planes,     -1);
+  rb_define_singleton_method(rb_cFrustum, "corners",    rb_cglm_frustum_singleton_corners,    -1);
+  rb_define_singleton_method(rb_cFrustum, "to_aabb",    rb_cglm_frustum_singleton_aabb,       -1);
+  rb_define_singleton_method(rb_cFrustum, "corners_at", rb_cglm_frustum_singleton_corners_at, -1);
+}

data/ext/cglm/rb_cglm_mat3.c

@@ -0,0 +1,252 @@
+#include "rb_cglm.h"
+
+/* call-seq: identity([dest]) => dest | new Mat3
+ *
+ * Sets `dest` to the identity if provided. If omitted, a new Mat4 is created
+ * and set to the identity. `dest` or the new Mat3 is returned.
+ */
+VALUE rb_cglm_mat3_new_identity(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = MAT3_NEW(ALLOC_MAT3);
+  glm_mat3_identity(VAL2MAT3(dest));
+  return dest;
+}
+
+/* call-seq: mul_mat3(other[, dest]) => dest | new Mat3
+ *
+ * Multiplies this Mat3 with `other`, returning the result.
+ */
+VALUE rb_cglm_mat3_mul_mat3(int argc, VALUE *argv, VALUE self) {
+  VALUE other, dest;
+  rb_scan_args(argc, argv, "11", &other, &dest);
+  if (NIL_P(dest)) dest = MAT3_NEW(ALLOC_MAT3);
+  glm_mat3_mul(VAL2MAT3(self), VAL2MAT3(other), VAL2MAT3(dest));
+  return dest;
+}
+
+/* call-seq: mul_vec3(other[, dest]) => dest | new Vec3
+ *
+ * Multiplies this Vec3 with `other`, returning the result.
+ */
+VALUE rb_cglm_mat3_mul_vec3(int argc, VALUE *argv, VALUE self) {
+  VALUE other, dest;
+  rb_scan_args(argc, argv, "11", &other, &dest);
+  if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
+  glm_mat3_mulv(VAL2MAT3(self), VAL2VEC3(other), VAL2VEC3(dest));
+  return dest;
+}
+
+/* call-seq: transpose([dest]) => dest | new Mat3
+ *
+ * Transposes this matrix and places it into `dest`. If `dest` is omitted, a
+ * new Mat3 will be allocated.
+ */
+VALUE rb_cglm_mat3_transpose(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = MAT3_NEW(ALLOC_MAT3);
+  glm_mat3_transpose_to(VAL2MAT3(self), VAL2MAT3(dest));
+  return dest;
+}
+
+/* call-seq: transpose! => self
+ *
+ * Transposes this matrix in-place and returns `self`.
+ */
+VALUE rb_cglm_mat3_transpose_self(int argc, VALUE *argv, VALUE self) {
+  glm_mat3_transpose(VAL2MAT3(self));
+  return self;
+}
+
+/* call-seq: to_quat([dest]) => dest | new Quat
+ *
+ * Converts `self` to a Quat. If `dest` is omitted, a new Quat is created.
+ */
+VALUE rb_cglm_mat3_to_quat(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = QUAT_NEW(ALLOC_QUAT);
+  glm_mat3_quat(VAL2MAT3(self), VAL2QUAT(dest));
+  return dest;
+}
+
+/* call-seq: mul_scalar(scalar[, dest]) => dest | new Mat3
+ *
+ * Multiplies each element in this matrix by the specified scalar amount.
+ * Places the result in `dest` and returns it, creating a new Mat3 if `dest`
+ * is omitted.
+ */
+VALUE rb_cglm_mat3_mul_scalar(int argc, VALUE *argv, VALUE self) {
+  VALUE scalar, dest;
+  rb_scan_args(argc, argv, "11", &scalar, &dest);
+  if (NIL_P(dest)) dest = MAT3_NEW(ALLOC_MAT3);
+  glm_mat3_scale(VAL2MAT3(dest), NUM2FLT(scalar));
+  return dest;
+}
+
+/* call-seq: mul_scalar!(scalar) => self
+ *
+ * Multiplies each element in this matrix by the specified scalar amount,
+ * modifying `self` in-place and returning it.
+ */
+VALUE rb_cglm_mat3_mul_scalar_self(VALUE self, VALUE scalar) {
+  glm_mat3_scale(VAL2MAT3(self), NUM2FLT(scalar));
+  return self;
+}
+
+VALUE rb_cglm_mat3_determinant(VALUE self) {
+  return glm_mat3_det(VAL2MAT3(self));
+}
+
+/* call-seq: inverse([dest]) => dest | new Mat3
+ *
+ * Places the inverse of `self` into `dest`, creating a new Mat3 if `dest` is
+ * omitted. Returns `dest`.
+ */
+VALUE rb_cglm_mat3_inverse(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = MAT3_NEW(ALLOC_MAT3);
+  glm_mat3_inv(VAL2MAT3(self), VAL2MAT3(dest));
+  return dest;
+}
+
+/* call-seq: invert! => self
+ *
+ * Calcaultes the inverse of `self`, modifies `self` in-place, and returns
+ * `self`.
+ */
+VALUE rb_cglm_mat3_inverse_self(int argc, VALUE *argv, VALUE self) {
+  glm_mat3_inv(VAL2MAT3(self), VAL2MAT3(self));
+  return self;
+}
+
+/* call-seq: swap_col!(col1, col2) => self
+ *
+ * Swaps two matrix columns and returns `self`.
+ */
+VALUE rb_cglm_mat3_swap_col_self(VALUE self, VALUE col1, VALUE col2) {
+  glm_mat3_swap_col(VAL2MAT3(self), NUM2INT(col1), NUM2INT(col2));
+  return self;
+}
+
+/* call-seq: swap_row!(row1, row2) => self
+ *
+ * Swaps two matrix rows and returns `self`.
+ */
+VALUE rb_cglm_mat3_swap_row_self(VALUE self, VALUE row1, VALUE row2) {
+  glm_mat3_swap_row(VAL2MAT3(self), NUM2INT(row1), NUM2INT(row2));
+  return self;
+}
+
+VALUE rb_cglm_mat3_aref(VALUE self, VALUE index) {
+  CHECK_RANGE(index, 0, 2);
+  float *addr = (float *) VAL2MAT3(self);
+  return VEC3_NEW(addr + (NUM2INT(index) * 3));
+}
+
+VALUE rb_cglm_mat3_aset(VALUE self, VALUE index, VALUE val) {
+  CHECK_RANGE(index, 0, 2);
+  if (rb_funcall(val, rb_intern("kind_of?"), 1, rb_cVec4))
+    memcpy(&(VAL2MAT4(self)[NUM2INT(index)]), &VAL2VEC4(val), sizeof(vec3));
+  else if (rb_funcall(val, rb_intern("kind_of?"), 1, rb_cVec3))
+    memcpy(&(VAL2MAT4(self)[NUM2INT(index)]), &VAL2VEC3(val), sizeof(vec3));
+  else {
+    VALUE row = rb_cglm_mat3_aref(self, index);
+    for (int i = 0; i < 3; i++) {
+      VALUE v = rb_funcall(val, rb_intern("[]"), 1, INT2NUM(i));
+      if (!NIL_P(v)) {
+        rb_funcall(row, rb_intern("[]="), 2, INT2NUM(i), v);
+      }
+    }
+  }
+  return self;
+}
+
+VALUE rb_cglm_mat3_to_mat4(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  if (argc == 0) dest = MAT4_NEW(ALLOC_MAT4);
+  dest = argv[0];
+  glm_mat4_ins3(VAL2MAT3(self), VAL2MAT4(dest));
+  return dest;
+}
+
+VALUE rb_cglm_mat3_size_bytes(VALUE klass) { return SIZET2NUM(mat3_size()); }
+
+VALUE rb_cglm_mat3_alignment_bytes(VALUE klass) { return SIZET2NUM(MAT3_ALIGNMENT); }
+
+VALUE rb_cglm_mat3_equal(VALUE self, VALUE other) {
+  if (memcmp(&VAL2MAT3(self), &VAL2MAT3(other), sizeof(mat3))) return Qfalse;
+  return Qtrue;
+}
+
+/* call-seq: a =~ b => true|false
+ *
+ * Returns true if each member of `a` is very close to, but not necessarily
+ * exactly equal to, each corresponding member of `b`. This is useful in many
+ * circumstances because imprecision introduced by floating point calculations
+ * can lead to two expressions which are otherwise mathematically equivalent
+ * returning false.
+ */
+VALUE rb_cglm_mat3_equalish(int argc, VALUE *argv, VALUE self) {
+  VALUE other, epsilon;
+  float feps = FLT_EPSILON;
+  rb_scan_args(argc, argv, "11", &other, &epsilon);
+  if (!NIL_P(epsilon)) feps = NUM2FLT(epsilon);
+  mat3 *a = &VAL2MAT3(self);
+  mat3 *b = &VAL2MAT3(other);
+  for (int i = 0; i < 3; i++) {
+    for (int j = 0; j < 3; j++) {
+      if (fabsf((*a)[i][j] - (*b)[i][j]) > feps)
+        return Qfalse;
+    }
+  }
+  return Qtrue;
+}
+
+/* call-seq: random([dest]) => dest | new Mat3
+ *
+ * Fills `dest` or a new Mat3 with a random rotation about a random axis with
+ * a random angle, and returns it.
+ */
+VALUE rb_cglm_mat3_new_random(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = MAT3_NEW(ALLOC_MAT3);
+
+  mat4 m4;
+  glm_rotate_make(m4, drand48(), (vec3){drand48(), drand48(), drand48()});
+  glm_mat4_pick3(m4, VAL2MAT3(dest));
+
+  return dest;
+}
+
+void Init_cglm_mat3() {
+  rb_define_method(rb_cMat3, "equalish",    rb_cglm_mat3_equalish,       -1);
+  rb_define_method(rb_cMat3, "==",          rb_cglm_mat3_equal,           1);
+  rb_define_method(rb_cMat3, "[]",          rb_cglm_mat3_aref,            1);
+  rb_define_method(rb_cMat3, "[]=",         rb_cglm_mat3_aset,            2);
+  rb_define_method(rb_cMat3, "mul_mat3",    rb_cglm_mat3_mul_mat3,       -1);
+  rb_define_method(rb_cMat3, "mul_vec3",    rb_cglm_mat3_mul_vec3,       -1);
+  rb_define_method(rb_cMat3, "mul_scalar",  rb_cglm_mat3_mul_scalar,     -1);
+  rb_define_method(rb_cMat3, "mul_scalar!", rb_cglm_mat3_mul_scalar_self, 0);
+  rb_define_method(rb_cMat3, "transpose",   rb_cglm_mat3_transpose,      -1);
+  rb_define_method(rb_cMat3, "transpose!",  rb_cglm_mat3_transpose_self,  0);
+  rb_define_method(rb_cMat3, "to_quat",     rb_cglm_mat3_to_quat,        -1);
+  rb_define_method(rb_cMat3, "determinant", rb_cglm_mat3_determinant,     0);
+  rb_define_method(rb_cMat3, "invert",      rb_cglm_mat3_inverse,        -1);
+  rb_define_method(rb_cMat3, "invert!",     rb_cglm_mat3_inverse_self,    0);
+  rb_define_method(rb_cMat3, "swap_col!",   rb_cglm_mat3_swap_col_self,   2);
+  rb_define_method(rb_cMat3, "swap_row!",   rb_cglm_mat3_swap_row_self,   2);
+  rb_define_method(rb_cMat3, "to_mat4",     rb_cglm_mat3_to_mat4,        -1);
+
+  rb_define_alias(rb_cMat3, "=~",   "equalish");
+  rb_define_alias(rb_cMat3, "det",  "determinant");
+
+  rb_define_singleton_method(rb_cMat3, "identity",  rb_cglm_mat3_new_identity,   -1);
+  rb_define_singleton_method(rb_cMat3, "size",      rb_cglm_mat3_size_bytes,      0);
+  rb_define_singleton_method(rb_cMat3, "alignment", rb_cglm_mat3_alignment_bytes, 0);
+  rb_define_singleton_method(rb_cMat3, "random",    rb_cglm_mat3_new_random,     -1);
+  rb_define_singleton_method(rb_cMat3, "rand",      rb_cglm_mat3_new_random,     -1);
+}