cglm 0.1.0

data/ext/cglm/rb_cglm_mat4.c

@@ -0,0 +1,308 @@
+#include "rb_cglm.h"
+
+/* call-seq: identity([dest]) => dest | new Mat4
+ *
+ * Sets `dest` to the identity if provided. If omitted, a new Mat4 is created
+ * and set to the identity. `dest` or the new Mat4 is returned.
+ */
+VALUE rb_cglm_mat4_new_identity(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_mat4_identity(VAL2MAT4(dest));
+  return dest;
+}
+
+/* call-seq: quat_rotate_at(quat, pivot_point[, dest]) => dest | new Mat4
+ *
+ * Creates a new transformation matrix using the quaternion at the pivot
+ * point. Places the result into `dest`, or creates a new Mat4 if `dest` is
+ * omitted. Returns `dest`.
+ */
+VALUE rb_cglm_mat4_new_rotate_at(int argc, VALUE *argv, VALUE self) {
+  VALUE q, pivot, dest;
+  rb_scan_args(argc, argv, "21", &q, &pivot, &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_quat_rotate_atm(VAL2MAT4(dest), VAL2QUAT(q), VAL2VEC3(pivot));
+  return dest;
+}
+
+VALUE rb_cglm_mat4_aref(VALUE self, VALUE index) {
+  CHECK_RANGE(index, 0, 3);
+  float *addr = (float *) VAL2MAT4(self);
+  return VEC4_NEW(addr + (NUM2INT(index) * 4));
+}
+
+VALUE rb_cglm_mat4_aset(VALUE self, VALUE index, VALUE val) {
+  CHECK_RANGE(index, 0, 3);
+  if (rb_funcall(val, rb_intern("kind_of?"), 1, rb_cVec4))
+    memcpy(&(VAL2MAT4(self)[NUM2INT(index)]), &VAL2VEC4(val), sizeof(vec4));
+  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_mat4_aref(self, index);
+    for (int i = 0; i < 4; 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_mat4_to_mat3(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  if (argc == 0) dest = MAT3_NEW(ALLOC_MAT3);
+  else dest = argv[0];
+  glm_mat4_pick3(VAL2MAT4(self), VAL2MAT3(dest));
+  return dest;
+}
+
+VALUE rb_cglm_mat4_to_transposed_mat3(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  if (argc == 0) dest = MAT3_NEW(ALLOC_MAT3);
+  dest = argv[0];
+  glm_mat4_pick3t(VAL2MAT4(self), VAL2MAT3(dest));
+  return dest;
+}
+
+VALUE rb_cglm_mat4_mul_mat4(int argc, VALUE *argv, VALUE self) {
+  VALUE other, dest;
+  rb_scan_args(argc, argv, "11", &other, &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_mat4_mul(VAL2MAT4(self), VAL2MAT4(other), VAL2MAT4(dest));
+  return dest;
+}
+
+VALUE rb_cglm_mat4_mul_vec4(int argc, VALUE *argv, VALUE self) {
+  VALUE other, dest;
+  rb_scan_args(argc, argv, "11", &other, &dest);
+  if (NIL_P(dest)) dest = VEC4_NEW(ALLOC_VEC4);
+  glm_mat4_mulv(VAL2MAT4(self), VAL2VEC4(other), VAL2VEC4(dest));
+  return dest;
+}
+
+VALUE rb_cglm_mat4_mul_vec3(int argc, VALUE *argv, VALUE self) {
+  VALUE other, last, dest;
+  rb_scan_args(argc, argv, "12", &other, &last, &dest);
+  if (NIL_P(last)) last = DBL2NUM(1.0);
+  if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
+  glm_mat4_mulv3(VAL2MAT4(self), VAL2VEC3(other), NUM2FLT(last), VAL2VEC3(dest));
+  return dest;
+}
+
+VALUE rb_cglm_mat4_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_mat4_quat(VAL2MAT4(self), VAL2QUAT(dest));
+  return dest;
+}
+
+VALUE rb_cglm_mat4_transpose(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_mat4_transpose_to(VAL2MAT4(self), VAL2MAT4(dest));
+  return dest;
+}
+
+VALUE rb_cglm_mat4_transpose_self(VALUE self) {
+  glm_mat4_transpose(VAL2MAT4(self));
+  return self;
+}
+
+/* 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 Mat4 if `dest`
+ * is omitted.
+ */
+VALUE rb_cglm_mat4_mul_scalar(int argc, VALUE *argv, VALUE self) {
+  VALUE scalar, dest;
+  rb_scan_args(argc, argv, "11", &scalar, &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  memcpy(&VAL2MAT4(self), &VAL2MAT4(dest), sizeof(mat4));
+  glm_mat4_scale(VAL2MAT4(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_mat4_mul_scalar_self(VALUE self, VALUE scalar) {
+  glm_mat4_scale(VAL2MAT4(self), NUM2FLT(scalar));
+  return self;
+}
+
+/* call-seq: determinant => Numeric
+ */
+VALUE rb_cglm_mat4_determinant(VALUE self) {
+  return DBL2NUM(glm_mat4_det(VAL2MAT4(self)));
+}
+
+/* call-seq: invert([dest]) => dest | new Mat4
+ *
+ * Computes the inverse of this matrix and stores it in `dest`, creating a
+ * new Mat4 if `dest` is omitted. Returns `dest`.
+ */
+VALUE rb_cglm_mat4_invert(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_mat4_inv(VAL2MAT4(self), VAL2MAT4(dest));
+  return dest;
+}
+
+/* call-seq: invert! => self
+ *
+ * Computes the inverse of this matrix in-place and returns `self`.
+ */
+VALUE rb_cglm_mat4_invert_self(int argc, VALUE *argv, VALUE self) {
+  glm_mat4_inv(VAL2MAT4(self), VAL2MAT4(self));
+  return self;
+}
+
+/* call-seq: invert_fast([dest]) => dest | new Mat4
+ *
+ * Computes the inverse of this matrix and stores it in `dest`, creating a
+ * new Mat4 if `dest` is omitted. Returns `dest`.
+ *
+ * * NOTE: This method uses reciprocal approximation without extra corrections,
+ *   e.g Newton-Raphson. This should work faster than normal, but will be less
+ *   precise.
+ */
+VALUE rb_cglm_mat4_invert_fast(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_mat4_inv_fast(VAL2MAT4(self), VAL2MAT4(dest));
+  return dest;
+}
+
+/* call-seq: invert_fast!([dest]) => dest | new Mat4
+ *
+ * Computes the inverse of this matrix in-place and returns `self`.
+ *
+ * * NOTE: This method uses reciprocal approximation without extra corrections,
+ *   e.g Newton-Raphson. This should work faster than normal, but will be less
+ *   precise.
+ */
+VALUE rb_cglm_mat4_invert_fast_self(int argc, VALUE *argv, VALUE self) {
+  glm_mat4_inv_fast(VAL2MAT4(self), VAL2MAT4(self));
+  return self;
+}
+
+/* call-seq: swap_col!(col1, col2) => self
+ *
+ * Swaps two matrix columns and returns `self`.
+ */
+VALUE rb_cglm_mat4_swap_col_self(VALUE self, VALUE col1, VALUE col2) {
+  glm_mat4_swap_col(VAL2MAT4(self), NUM2INT(col1), NUM2INT(col2));
+  return self;
+}
+
+/* call-seq: swap_row!(row1, row2) => self
+ *
+ * Swaps two matrix rows and returns `self`.
+ */
+VALUE rb_cglm_mat4_swap_row_self(VALUE self, VALUE row1, VALUE row2) {
+  glm_mat4_swap_row(VAL2MAT4(self), NUM2INT(row1), NUM2INT(row2));
+  return self;
+}
+
+VALUE rb_cglm_mat4_size_bytes(VALUE klass) { return SIZET2NUM(mat4_size()); }
+
+VALUE rb_cglm_mat4_alignment_bytes(VALUE klass) { return SIZET2NUM(MAT4_ALIGNMENT); }
+
+VALUE rb_cglm_mat4_equal(VALUE self, VALUE other) {
+  if (memcmp(&VAL2MAT4(self), &VAL2MAT4(other), sizeof(mat4))) 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_mat4_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);
+  mat4 *a = &VAL2MAT4(self);
+  mat4 *b = &VAL2MAT4(other);
+  for (int i = 0; i < 4; i++) {
+    for (int j = 0; j < 4; j++) {
+      if (fabsf((*a)[i][j] - (*b)[i][j]) > feps)
+        return Qfalse;
+    }
+  }
+  return Qtrue;
+}
+
+/* call-seq: random([dest]) => dest | new Mat4
+ *
+ * Fills `dest` or a new Mat4 with a random translation and rotation, and
+ * returns it.
+ */
+VALUE rb_cglm_mat4_new_random(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+
+  glm_mat4_copy(GLM_MAT4_IDENTITY, VAL2MAT4(dest));
+  
+  /* random position */
+  VAL2MAT4(dest)[3][0] = drand48();
+  VAL2MAT4(dest)[3][1] = drand48();
+  VAL2MAT4(dest)[3][2] = drand48();
+  
+  /* random rotatation around random axis with random angle */
+  glm_rotate(VAL2MAT4(dest), drand48(), (vec3){drand48(), drand48(), drand48()});
+  
+  /* random scale */
+  /* glm_scale(dest, (vec3){drand48(), drand48(), drand48()}); */
+
+  return dest;
+}
+
+void Init_cglm_mat4() {
+  rb_define_method(rb_cMat4, "equalish",           rb_cglm_mat4_equalish,           -1);
+  rb_define_method(rb_cMat4, "==",                 rb_cglm_mat4_equal,               1);
+  rb_define_method(rb_cMat4, "[]",                 rb_cglm_mat4_aref,                1);
+  rb_define_method(rb_cMat4, "[]=",                rb_cglm_mat4_aset,                2);
+  rb_define_method(rb_cMat4, "to_mat3",            rb_cglm_mat4_to_mat3,            -1);
+  rb_define_method(rb_cMat4, "to_transposed_mat3", rb_cglm_mat4_to_transposed_mat3, -1);
+  rb_define_method(rb_cMat4, "to_quat",            rb_cglm_mat4_to_quat,            -1);
+  rb_define_method(rb_cMat4, "mul_mat4",           rb_cglm_mat4_mul_mat4,           -1);
+  rb_define_method(rb_cMat4, "mul_vec4",           rb_cglm_mat4_mul_vec4,           -1);
+  rb_define_method(rb_cMat4, "mul_vec3",           rb_cglm_mat4_mul_vec3,           -1);
+  rb_define_method(rb_cMat4, "mul_scalar",         rb_cglm_mat4_mul_scalar,         -1);
+  rb_define_method(rb_cMat4, "mul_scalar!",        rb_cglm_mat4_mul_scalar_self,     0);
+  rb_define_method(rb_cMat4, "transpose",          rb_cglm_mat4_transpose,          -1);
+  rb_define_method(rb_cMat4, "transpose!",         rb_cglm_mat4_transpose_self,      0);
+  rb_define_method(rb_cMat4, "determinant",        rb_cglm_mat4_determinant,         0);
+  rb_define_method(rb_cMat4, "invert",             rb_cglm_mat4_invert,             -1);
+  rb_define_method(rb_cMat4, "invert_fast",        rb_cglm_mat4_invert_fast,        -1);
+  rb_define_method(rb_cMat4, "invert!",            rb_cglm_mat4_invert_self,         0);
+  rb_define_method(rb_cMat4, "invert_fast!",       rb_cglm_mat4_invert_fast_self,    0);
+  rb_define_method(rb_cMat4, "swap_col!",          rb_cglm_mat4_swap_col_self,       2);
+  rb_define_method(rb_cMat4, "swap_row!",          rb_cglm_mat4_swap_row_self,       2);
+
+  rb_define_alias(rb_cMat4, "det",  "determinant");
+  rb_define_alias(rb_cMat4, "=~",   "equalish");
+
+  rb_define_singleton_method(rb_cMat4, "random",         rb_cglm_mat4_new_random,     -1);
+  rb_define_singleton_method(rb_cMat4, "rand",           rb_cglm_mat4_new_random,     -1);
+  rb_define_singleton_method(rb_cMat4, "identity",       rb_cglm_mat4_new_identity,   -1);
+  rb_define_singleton_method(rb_cMat4, "quat_rotate_at", rb_cglm_mat4_new_rotate_at,  -1);
+  rb_define_singleton_method(rb_cMat4, "size",           rb_cglm_mat4_size_bytes,      0);
+  rb_define_singleton_method(rb_cMat4, "alignment",      rb_cglm_mat4_alignment_bytes, 0);
+}

data/ext/cglm/rb_cglm_plane.c

@@ -0,0 +1,36 @@
+#include "rb_cglm.h"
+
+/* call-seq: normalize([dest]) => dest | new Plane
+ *
+ * Normalizes this plane and places the result in `dest`, or allocates a new
+ * Plane if `dest` is omitted.
+ */
+VALUE rb_cglm_plane_normalize(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = PLANE_NEW(ALLOC_PLANE);
+  memcpy(&(VAL2VEC4(self)), &(VAL2VEC4(dest)), sizeof(vec4));
+  glm_plane_normalize(VAL2VEC4(dest));
+  return dest;
+}
+
+/* call-seq: normalize! => self
+ *
+ * Normalizes this Vec4 (which represents a plane) and returns it.
+ */
+VALUE rb_cglm_plane_normalize_self(VALUE self) {
+  glm_plane_normalize(VAL2VEC4(self));
+  return self;
+}
+
+VALUE rb_cglm_plane_size_bytes(VALUE klass) { return SIZET2NUM(plane_size()); }
+
+VALUE rb_cglm_plane_alignment_bytes(VALUE klass) { return SIZET2NUM(PLANE_ALIGNMENT); }
+
+void Init_cglm_plane() {
+  rb_define_method(rb_cPlane, "normalize",  rb_cglm_plane_normalize,     -1);
+  rb_define_method(rb_cPlane, "normalize!", rb_cglm_plane_normalize_self, 0);
+
+  rb_define_singleton_method(rb_cPlane, "size",      rb_cglm_plane_size_bytes,      0);
+  rb_define_singleton_method(rb_cPlane, "alignment", rb_cglm_plane_alignment_bytes, 0);
+}

data/ext/cglm/rb_cglm_project.c

@@ -0,0 +1,99 @@
+#include "rb_cglm.h"
+
+/* call-seq: unproject_i(pos, viewport[, dest]) => dest | new Vec3
+ *
+ * Maps the specified position into the space represented by this matrix,
+ * places it in `dest` or a new Vec3 if `dest` is omitted, and returns it.
+ *
+ * * NOTE: This method assumes that `self` represents the **inverse** of a
+ *   projection matrix. It's faster than calling #unproject assuming you
+ *   already have an inverse matrix. If you don't have an inverse, you should
+ *   just rely on #unproject (to save the overhead of the extra method call),
+ *   but if you have or need the inverse for other computations, you can use
+ *   #unproject_i to save yourself the cost of the inversion.
+ *
+ * * If `self` is an `inverse(projection)` matrix, then the result will be
+ *   in view space.
+ *
+ * * If `self` is an `inverse(projection * view)` matrix, then the result will
+ *   be in world space.
+ *
+ * * If `self` is an `inverse(projection * view * model)` matrix, then the
+ *   result will be in object space.
+ *
+ * * `pos` is a Vec3 specifying the coordinates to unproject.
+ *
+ * * `viewport` is a Vec4 specifying the dimensions of the viewport in
+ *   `[x, y, width, height]` format.
+ *
+ * * `dest` is the Vec3 to place the results into, and will be created if
+ *   omitted.
+ */
+VALUE rb_cglm_project_unproject_i(int argc, VALUE *argv, VALUE self) {
+  VALUE pos, viewport, dest;
+  rb_scan_args(argc, argv, "21", &pos, &viewport, &dest);
+  if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
+  glm_unprojecti(VAL2VEC3(pos), VAL2MAT4(self), VAL2VEC4(viewport), VAL2VEC3(dest));
+  return dest;
+}
+
+/* call-seq: unproject(pos, viewport[, dest]) => dest | new Vec3
+ *
+ * Maps the specified position into the space represented by this matrix,
+ * places it in `dest` or a new Vec3 if `dest` is omitted, and returns it.
+ *
+ * * NOTE: This method must calculate the inverse of the current matrix. If
+ *   you already have the inverse handy, you should use #unproject_i for
+ *   better performance.
+ *
+ * * If `self` is a `projection` matrix, then the result will be
+ *   in view space.
+ *
+ * * If `self` is a `projection * view` matrix, then the result will
+ *   be in world space.
+ *
+ * * If `self` is an `projection * view * model` matrix, then the
+ *   result will be in object space.
+ *
+ * * `pos` is a Vec3 specifying the coordinates to unproject.
+ *
+ * * `viewport` is a Vec4 specifying the dimensions of the viewport in
+ *   `[x, y, width, height]` format.
+ *
+ * * `dest` is the Vec3 to place the results into, and will be created if
+ *   omitted.
+ */
+VALUE rb_cglm_project_unproject(int argc, VALUE *argv, VALUE self) {
+  VALUE pos, viewport, dest;
+  rb_scan_args(argc, argv, "21", &pos, &viewport, &dest);
+  if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
+  glm_unproject(VAL2VEC3(pos), VAL2MAT4(self), VAL2VEC4(viewport), VAL2VEC3(dest));
+  return dest;
+}
+
+/* call-seq: project(pos, viewport[, dest]) => dest | new Vec3
+ *
+ * Maps the given object-space coordinates into window coordinates using
+ * `self` as the projection matrix.
+ *
+ * * `pos` is a Vec3 specifying the object-space coordinates.
+ *
+ * * `viewport` is a Vec4 specifying the dimensions of the viewport in
+ *   `[x, y, width, height]` format.
+ *
+ * * `dest` is the Vec3 to place the results into, and will be created if
+ *   omitted.
+ */
+VALUE rb_cglm_project_project(int argc, VALUE *argv, VALUE self) {
+  VALUE pos, viewport, dest;
+  rb_scan_args(argc, argv, "21", &pos, &viewport, &dest);
+  if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
+  glm_project(VAL2VEC3(pos), VAL2MAT4(self), VAL2VEC4(viewport), VAL2VEC3(dest));
+  return dest;
+}
+
+void Init_cglm_project() {
+  rb_define_method(rb_cMat4, "unproject_i", rb_cglm_project_unproject_i, -1);
+  rb_define_method(rb_cMat4, "unproject",   rb_cglm_project_unproject,   -1);
+  rb_define_method(rb_cMat4, "project",     rb_cglm_project_project,     -1);
+}

data/ext/cglm/rb_cglm_quat.c

@@ -0,0 +1,358 @@
+#include "rb_cglm.h"
+
+/* call-seq: identity([dest]) => dest | new Quat */
+VALUE rb_cglm_quat_new_identity(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_quat_identity(VAL2QUAT(dest));
+  return dest;
+}
+
+/* call-seq: axis_angle(axis, angle[, dest]) => dest | new Quat */
+VALUE rb_cglm_quat_new_axis_angle(int argc, VALUE *argv, VALUE self) {
+  VALUE axis, angle, dest;
+  rb_scan_args(argc, argv, "21", &axis, &angle, &dest);
+  if (NIL_P(dest)) dest = QUAT_NEW(ALLOC_QUAT);
+  glm_quatv(VAL2QUAT(dest), NUM2FLT(angle), VAL2VEC3(axis));
+  return dest;
+}
+
+/* call-seq: copy_to(dest) => dest */
+VALUE rb_cglm_quat_copy_to(VALUE self, VALUE dest) {
+  glm_quat_copy(VAL2QUAT(self), VAL2QUAT(dest));
+  return dest;
+}
+
+/* call-seq: normalize([dest]) => dest */
+VALUE rb_cglm_quat_normalize(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_quat_normalize_to(VAL2QUAT(self), VAL2QUAT(dest));
+  return dest;
+}
+
+/* call-seq: normalize! => self */
+VALUE rb_cglm_quat_normalize_self(VALUE self) {
+  glm_quat_normalize(VAL2QUAT(self));
+  return self;
+}
+
+/* call-seq: conjugate([dest]) => dest | new Quat */
+VALUE rb_cglm_quat_conjugate(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_quat_conjugate(VAL2QUAT(self), VAL2QUAT(dest));
+  return dest;
+}
+
+/* call-seq: invert([dest]) => dest | new Quat */
+VALUE rb_cglm_quat_invert(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_quat_inv(VAL2QUAT(self), VAL2QUAT(dest));
+  return dest;
+}
+
+/* call-seq: invert! => self */
+VALUE rb_cglm_quat_invert_self(VALUE self) {
+  glm_quat_inv(VAL2QUAT(self), VAL2QUAT(self));
+  return self;
+}
+
+/* call-seq: real => Numeric
+ *
+ * Returns the real part of the quaternion.
+ */
+VALUE rb_cglm_quat_real(VALUE self) {
+  return DBL2NUM(glm_quat_real(VAL2QUAT(self)));
+}
+
+/* call-seq: imag([dest]) => dest | new Vec3
+ *
+ * Returns the imaginary part of the quaternion in `dest`.
+ */
+VALUE rb_cglm_quat_imag(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
+  glm_quat_imag(VAL2QUAT(self), VAL2VEC3(dest));
+  return dest;
+}
+
+/* call-seq: imagn([dest]) => dest | new Vec3
+ *
+ * Returns the imaginary part of the quaternion in `dest`, normalized.
+ */
+VALUE rb_cglm_quat_imagn(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
+  glm_quat_imagn(VAL2QUAT(self), VAL2VEC3(dest));
+  return dest;
+}
+
+/* call-seq: imaglen => Numeric
+ *
+ * Returns the length of the imaginary part of the quaternion.
+ */
+VALUE rb_cglm_quat_imaglen(VALUE self) {
+  return DBL2NUM(glm_quat_imaglen(VAL2QUAT(self)));
+}
+
+/* call-seq: angle => Numeric
+ *
+ * Returns the angle of the quaternion.
+ */
+VALUE rb_cglm_quat_angle(VALUE self) {
+  return DBL2NUM(glm_quat_angle(VAL2QUAT(self)));
+}
+
+/* call-seq: axis([dest]) => dest | new Vec3
+ *
+ * Returns the axis of the quaternion in `dest`.
+ */
+VALUE rb_cglm_quat_axis(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
+  glm_quat_axis(VAL2QUAT(self), VAL2VEC3(dest));
+  return dest;
+}
+
+/* call-seq: mul_quat(other[, dest]) => dest | new Quat
+ *
+ * Multiplies `self` by `other` and stores the result in `dest`. If `dest`
+ * is omitted, a new Quat is created. `dest` or the new Quat is returned.
+ */
+VALUE rb_cglm_quat_mul_quat(int argc, VALUE *argv, VALUE self) {
+  VALUE other, dest;
+  rb_scan_args(argc, argv, "11", &other, &dest);
+  if (NIL_P(dest)) dest = QUAT_NEW(ALLOC_QUAT);
+  glm_quat_mul(VAL2QUAT(self), VAL2QUAT(other), VAL2QUAT(dest));
+  return dest;
+}
+
+/* call-seq: mul_quat!(other) => self
+ *
+ * Multiplies `self` by `other`. Modifies `self` in-place and returns `self`.
+ */
+VALUE rb_cglm_quat_mul_quat_self(VALUE self, VALUE other) {
+  quat dest;
+  glm_quat_mul(VAL2QUAT(self), VAL2QUAT(other), dest);
+  memcpy(&VAL2QUAT(self), &dest, sizeof(quat));
+  return self;
+}
+
+/* call-seq: to_mat4([dest]) => dest | new Mat4
+ *
+ * Converts this quaternion into a Mat4. Places the result into `dest` or
+ * creates a new Mat4.
+ */
+VALUE rb_cglm_quat_to_mat4(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_quat_mat4(VAL2QUAT(self), VAL2MAT4(dest));
+  return dest;
+}
+
+/* call-seq: to_transposed_mat4([dest]) => dest | new Mat4
+ *
+ * Converts this quaternion into a transposed Mat4. Places the result into
+ * `dest` or creates a new Mat4.
+ */
+VALUE rb_cglm_quat_to_mat4t(int argc, VALUE *argv, VALUE self) {
+  VALUE dest;
+  rb_scan_args(argc, argv, "01", &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_quat_mat4t(VAL2QUAT(self), VAL2MAT4(dest));
+  return dest;
+}
+
+/* call-seq: to_mat3([dest]) => dest | new Mat3
+ *
+ * Converts this quaternion into a Mat3. Places the result into `dest` or
+ * creates a new Mat3.
+ */
+VALUE rb_cglm_quat_to_mat3(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_quat_mat3(VAL2QUAT(self), VAL2MAT3(dest));
+  return dest;
+}
+
+/* call-seq: to_transposed_mat3([dest]) => dest | new Mat3
+ *
+ * Converts this quaternion into a transposed Mat3. Places the result into
+ * `dest` or creates a new Mat3.
+ */
+VALUE rb_cglm_quat_to_mat3t(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_quat_mat3t(VAL2QUAT(self), VAL2MAT3(dest));
+  return dest;
+}
+
+/* call-seq: lerp!(from, to, amount) => self */
+VALUE rb_cglm_quat_lerp_self(VALUE self, VALUE from, VALUE to, VALUE amount) {
+  glm_quat_lerp(VAL2QUAT(from), VAL2QUAT(to), NUM2FLT(to), VAL2QUAT(self));
+  return self;
+}
+
+/* call-seq: slerp!(from, to, amount) => self */
+VALUE rb_cglm_quat_slerp_self(VALUE self, VALUE from, VALUE to, VALUE amount) {
+  glm_quat_slerp(VAL2QUAT(from), VAL2QUAT(to), NUM2FLT(to), VAL2QUAT(self));
+  return self;
+}
+
+/* call-seq: look(position[, dest]) => dest | new Mat4
+ *
+ * Creates a view matrix, stored in `dest`, using this quaternion as the
+ * camera orientation. Returns `dest`. Creates a new Mat4 if `dest` is
+ * omitted.
+ */
+VALUE rb_cglm_quat_look(int argc, VALUE *argv, VALUE self) {
+  VALUE position, dest;
+  rb_scan_args(argc, argv, "11", &position, &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_quat_look(VAL2VEC3(position), VAL2QUAT(self), VAL2MAT4(dest));
+  return dest;
+}
+
+/* call-seq: look(dir, fwd, up[, dest]) => dest | new Quat
+ *
+ * Creates a rotation quaternion that has the specified orientation. Places
+ * the result in `dest`, or creates a new Quat if `dest` was omitted. Returns
+ * `dest`.
+ *
+ * * `dir` is the direction to look (a Vec3).
+ *
+ * * `fwd` is the forward vector (a Vec3).
+ *
+ * * `up` is the up vector (a Vec3).
+ */
+VALUE rb_cglm_quat_new_look(int argc, VALUE *argv, VALUE self) {
+  VALUE dir, fwd, up, dest;
+  rb_scan_args(argc, argv, "31", &dir, &fwd, &up, &dest);
+  if (NIL_P(dest)) dest = QUAT_NEW(ALLOC_QUAT);
+  glm_quat_for(VAL2VEC3(dir), VAL2VEC3(fwd), VAL2VEC3(up), VAL2QUAT(dest));
+  return dest;
+}
+
+/* call-seq: look_at(position, target, fwd, up[, dest]) => dest | new Quat
+ *
+ * Creates a rotation quaternion that has the specified orientation. Places
+ * the result in `dest`, or creates a new Quat if `dest` was omitted. Returns
+ * `dest`.
+ *
+ * * `position` is the current position to look from (a Vec3).
+ *
+ * * `target` is the position to look toward (a Vec3).
+ *
+ * * `fwd` is the forward vector (a Vec3).
+ *
+ * * `up` is the up vector (a Vec3).
+ */
+VALUE rb_cglm_quat_new_look_at(int argc, VALUE *argv, VALUE self) {
+  VALUE position, target, fwd, up, dest;
+  rb_scan_args(argc, argv, "41", &position, &target, &fwd, &up, &dest);
+  if (NIL_P(dest)) dest = QUAT_NEW(ALLOC_QUAT);
+  glm_quat_forp(VAL2VEC3(position), VAL2VEC3(target), VAL2VEC3(fwd), VAL2VEC3(up), VAL2QUAT(dest));
+  return dest;
+}
+
+/* call-seq: rotate_vec3(vec[, dest]) => dest | new Vec3
+ *
+ * Rotates the given Vec3 by this quaternion. Returns the result in `dest`,
+ * or a new Vec3 if `dest` was omitted.
+ */
+VALUE rb_cglm_quat_rotate_vec3(int argc, VALUE *argv, VALUE self) {
+  VALUE vec, dest;
+  rb_scan_args(argc, argv, "11", &vec, &dest);
+  if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
+  glm_quat_rotatev(VAL2QUAT(self), VAL2VEC3(vec), VAL2VEC3(dest));
+  return dest;
+}
+
+/* call-seq: rotate_mat4(vec[, dest]) => dest | new Mat4
+ *
+ * Rotates the given Mat4 by this quaternion. Returns the result in `dest`,
+ * or a new Mat4 if `dest` was omitted.
+ */
+VALUE rb_cglm_quat_rotate_mat4(int argc, VALUE *argv, VALUE self) {
+  VALUE mat, dest;
+  rb_scan_args(argc, argv, "11", &mat, &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  glm_quat_rotate(VAL2MAT4(mat), VAL2QUAT(self), VAL2MAT4(dest));
+  return dest;
+}
+
+/* call-seq: pivot_mat4(mat, pivot_point[, dest]) => dest | new Mat4
+ *
+ * Rotates the given transform matrix using this quaternion at the pivot
+ * point (a Vec3). Places the resultant Mat4 into `dest`, or creates a new
+ * Mat4 if `dest` is omitted. Returns `dest`.
+ */
+VALUE rb_cglm_quat_pivot_mat4(int argc, VALUE *argv, VALUE self) {
+  VALUE mat, pivot, dest;
+  rb_scan_args(argc, argv, "21", &mat, &pivot, &dest);
+  if (NIL_P(dest)) dest = MAT4_NEW(ALLOC_MAT4);
+  memcpy(&VAL2MAT4(dest), &VAL2MAT4(mat), sizeof(mat4));
+  glm_quat_rotate_at(VAL2MAT4(dest), VAL2QUAT(self), VAL2VEC3(pivot));
+  return dest;
+}
+
+/* call-seq: random([dest]) => dest | new Quat
+ *
+ * Fills `dest` or a new Quat with a random orientation, and returns it.
+ */
+VALUE rb_cglm_quat_new_random(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_quat(VAL2QUAT(dest), drand48(), drand48(), drand48(), drand48());
+  glm_quat_normalize(VAL2QUAT(dest));
+
+  return dest;
+}
+
+void Init_cglm_quat() {
+  rb_define_method(rb_cQuat, "copy_to",            rb_cglm_quat_copy_to,        1);
+  rb_define_method(rb_cQuat, "normalize",          rb_cglm_quat_normalize,     -1);
+  rb_define_method(rb_cQuat, "normalize!",         rb_cglm_quat_normalize_self, 0);
+  rb_define_method(rb_cQuat, "conjugate",          rb_cglm_quat_conjugate,     -1);
+  rb_define_method(rb_cQuat, "invert",             rb_cglm_quat_invert,        -1);
+  rb_define_method(rb_cQuat, "invert!",            rb_cglm_quat_invert_self,    0);
+  rb_define_method(rb_cQuat, "real",               rb_cglm_quat_real,           0);
+  rb_define_method(rb_cQuat, "imag",               rb_cglm_quat_imag,          -1);
+  rb_define_method(rb_cQuat, "imagn",              rb_cglm_quat_imagn,         -1);
+  rb_define_method(rb_cQuat, "imaglen",            rb_cglm_quat_imaglen,        0);
+  rb_define_method(rb_cQuat, "angle",              rb_cglm_quat_angle,          0);
+  rb_define_method(rb_cQuat, "axis",               rb_cglm_quat_axis,          -1);
+  rb_define_method(rb_cQuat, "mul_quat",           rb_cglm_quat_mul_quat,      -1);
+  rb_define_method(rb_cQuat, "mul_quat!",          rb_cglm_quat_mul_quat_self,  1);
+  rb_define_method(rb_cQuat, "to_mat4",            rb_cglm_quat_to_mat4,       -1);
+  rb_define_method(rb_cQuat, "to_transposed_mat4", rb_cglm_quat_to_mat4t,      -1);
+  rb_define_method(rb_cQuat, "to_mat3",            rb_cglm_quat_to_mat3,       -1);
+  rb_define_method(rb_cQuat, "to_transposed_mat3", rb_cglm_quat_to_mat3t,      -1);
+  rb_define_method(rb_cQuat, "lerp!",              rb_cglm_quat_lerp_self,      3);
+  rb_define_method(rb_cQuat, "slerp!",             rb_cglm_quat_slerp_self,     3);
+  rb_define_method(rb_cQuat, "look",               rb_cglm_quat_look,          -1);
+  rb_define_method(rb_cQuat, "rotate_vec3",        rb_cglm_quat_rotate_vec3,   -1);
+  rb_define_method(rb_cQuat, "rotate_mat4",        rb_cglm_quat_rotate_mat4,   -1);
+  rb_define_method(rb_cQuat, "pivot_mat4",         rb_cglm_quat_pivot_mat4,    -1);
+
+  rb_define_singleton_method(rb_cQuat, "random",     rb_cglm_quat_new_random,     -1);
+  rb_define_singleton_method(rb_cQuat, "rand",       rb_cglm_quat_new_random,     -1);
+  rb_define_singleton_method(rb_cQuat, "identity",   rb_cglm_quat_new_identity,   -1);
+  rb_define_singleton_method(rb_cQuat, "axis_angle", rb_cglm_quat_new_axis_angle, -1);
+  rb_define_singleton_method(rb_cQuat, "look",       rb_cglm_quat_new_look,       -1);
+  rb_define_singleton_method(rb_cQuat, "look_at",    rb_cglm_quat_new_look_at,    -1);
+}