cglm 0.1.0 → 0.1.3

data/ext/cglm/cglm-0.6.2/include/cglm/version.h

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglm_version_h
+#define cglm_version_h
+
+#define CGLM_VERSION_MAJOR 0
+#define CGLM_VERSION_MINOR 6
+#define CGLM_VERSION_PATCH 2
+
+#endif /* cglm_version_h */

data/ext/cglm/extconf.rb

@@ -3,11 +3,10 @@ require 'fileutils'
 require 'rubygems/package'
 require 'zlib'
 
-#CGLM_VERSION = '0.5.0'
-CGLM_VERSION = '89f64f079477b1af15f47e6b96db52c767acb057'
+CGLM_VERSION = 'v0.6.2'
 cglm_source_url = "https://github.com/recp/cglm/archive/#{CGLM_VERSION}.tar.gz"
 cglm_tar_gz = File.expand_path("cglm-#{CGLM_VERSION}.tar.gz", __dir__)
-cglm_dir = File.expand_path("cglm-#{CGLM_VERSION}", __dir__)
+cglm_dir = File.expand_path("cglm-0.6.2", __dir__)
 
 # fetch cglm unless it's already on the file system
 unless File.exist?(cglm_dir)

data/ext/cglm/rb_cglm.h

@@ -2,6 +2,7 @@
 #define RB_CGLM_H 1
 
 #include "ruby.h"
+#include "ruby_pre27.h"
 #include <errno.h>
 
 // Based on unit test results I think the FLT_EPSILON that is used for fuzzy
@@ -96,7 +97,7 @@ static inline size_t vec3_size()  { return sizeof(vec3);  }
 static inline size_t vec4_size()  { return sizeof(vec4);  }
 static inline size_t aabb_size()  { return sizeof(aabb);  }
 static inline size_t mat4_size()  { return sizeof(mat4);  }
-static inline size_t mat3_size()  { return sizeof(mat4);  }
+static inline size_t mat3_size()  { return sizeof(mat3);  }
 static inline size_t quat_size()  { return sizeof(mat4);  }
 static inline size_t plane_size() { return sizeof(plane); }
 
@@ -106,7 +107,8 @@ static inline VALUE CGLM_NEW(VALUE klass, size_t size, void *addr) {
   VALUE kw = rb_hash_new();
   VALUE ptr = PTR2FIDDLE(addr, size);
   rb_hash_aset(kw, ID2SYM(rb_intern("addr")), ptr);
-  return rb_funcall(klass, rb_intern("new"), 1, kw);
+  VALUE kwarg[] = { kw };
+  return rb_funcallv_kw(klass, rb_intern("new"), 1, kwarg, 1);
 }
 
 static inline void *__aligned_alloc(size_t align, size_t size) {
@@ -151,7 +153,7 @@ static inline void *VAL2ADDR(VALUE val, size_t min_size) {
   VALUE addr = rb_funcall(val, rb_intern("addr"), 0);
   VALUE size = rb_funcall(addr, rb_intern("size"), 0);
   if (min_size > NUM2SIZET(size))
-    rb_raise(rb_eArgError, "memory store (size %zu) is not large enough to be converted into the requested type (size %zu)", NUM2SIZET(size), min_size);
+    rb_raise(rb_eArgError, "memory store (size %zu) is not large enough to be converted into the requested type (size %zu)", (size_t) NUM2SIZET(size), min_size);
   return NUM2PTR(rb_funcall(addr, rb_intern("to_i"), 0));
 }
 

data/ext/cglm/rb_cglm_mat3.c

@@ -54,7 +54,7 @@ VALUE rb_cglm_mat3_transpose(int argc, VALUE *argv, VALUE self) {
  *
  * Transposes this matrix in-place and returns `self`.
  */
-VALUE rb_cglm_mat3_transpose_self(int argc, VALUE *argv, VALUE self) {
+VALUE rb_cglm_mat3_transpose_self(VALUE self) {
   glm_mat3_transpose(VAL2MAT3(self));
   return self;
 }
@@ -117,7 +117,7 @@ VALUE rb_cglm_mat3_inverse(int argc, VALUE *argv, VALUE 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) {
+VALUE rb_cglm_mat3_inverse_self(VALUE self) {
   glm_mat3_inv(VAL2MAT3(self), VAL2MAT3(self));
   return self;
 }
@@ -230,7 +230,7 @@ void Init_cglm_mat3() {
   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, "mul_scalar!", rb_cglm_mat3_mul_scalar_self, 1);
   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);

data/ext/cglm/rb_cglm_mat4.c

@@ -161,7 +161,7 @@ VALUE rb_cglm_mat4_invert(int argc, VALUE *argv, VALUE self) {
  *
  * Computes the inverse of this matrix in-place and returns `self`.
  */
-VALUE rb_cglm_mat4_invert_self(int argc, VALUE *argv, VALUE self) {
+VALUE rb_cglm_mat4_invert_self(VALUE self) {
   glm_mat4_inv(VAL2MAT4(self), VAL2MAT4(self));
   return self;
 }
@@ -191,7 +191,7 @@ VALUE rb_cglm_mat4_invert_fast(int argc, VALUE *argv, VALUE self) {
  *   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) {
+VALUE rb_cglm_mat4_invert_fast_self(VALUE self) {
   glm_mat4_inv_fast(VAL2MAT4(self), VAL2MAT4(self));
   return self;
 }
@@ -285,7 +285,7 @@ void Init_cglm_mat4() {
   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, "mul_scalar!",        rb_cglm_mat4_mul_scalar_self,     1);
   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);

data/ext/cglm/rb_cglm_quat.c

@@ -201,13 +201,13 @@ VALUE rb_cglm_quat_to_mat3t(int argc, VALUE *argv, VALUE self) {
 
 /* 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));
+  glm_quat_lerp(VAL2QUAT(from), VAL2QUAT(to), NUM2FLT(amount), 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));
+  glm_quat_slerp(VAL2QUAT(from), VAL2QUAT(to), NUM2FLT(amount), VAL2QUAT(self));
   return self;
 }
 

data/ext/cglm/rb_cglm_vec3.c

@@ -55,17 +55,17 @@ VALUE rb_cglm_vec3_zero(VALUE self) {
 }
 
 VALUE rb_cglm_vec3_zero_self(VALUE self) {
-  glm_vec_zero(VAL2VEC3(self));
+  glm_vec3_zero(VAL2VEC3(self));
   return self;
 }
 
 VALUE rb_cglm_vec3_one_self(VALUE self) {
-  glm_vec_one(VAL2VEC3(self));
+  glm_vec3_one(VAL2VEC3(self));
   return self;
 }
 
 VALUE rb_cglm_vec3_dot(VALUE self, VALUE other) {
-  return DBL2NUM(glm_vec_dot(VAL2VEC3(self), VAL2VEC3(self)));
+  return DBL2NUM(glm_vec3_dot(VAL2VEC3(self), VAL2VEC3(self)));
 }
 
 /* call-seq: cross(b[, dest]) => dest | new Vec3 */
@@ -73,7 +73,7 @@ VALUE rb_cglm_vec3_cross(int argc, VALUE *argv, VALUE self) {
   VALUE b, dest;
   rb_scan_args(argc, argv, "11", &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_cross(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
+  glm_vec3_cross(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
   return dest;
 }
 
@@ -83,7 +83,7 @@ VALUE rb_cglm_vec3_cross(int argc, VALUE *argv, VALUE self) {
  * `norm ** 2` to avoid an unnecessary square root.
  */
 VALUE rb_cglm_vec3_norm2(VALUE self) {
-  return DBL2NUM(glm_vec_norm2(VAL2VEC3(self)));
+  return DBL2NUM(glm_vec3_norm2(VAL2VEC3(self)));
 }
 
 /* call-seq: norm => Numeric
@@ -91,7 +91,7 @@ VALUE rb_cglm_vec3_norm2(VALUE self) {
  * Returns the norm (magnitude) of this vector.
  */
 VALUE rb_cglm_vec3_norm(VALUE self) {
-  return DBL2NUM(glm_vec_norm(VAL2VEC3(self)));
+  return DBL2NUM(glm_vec3_norm(VAL2VEC3(self)));
 }
 
 /* call-seq: add_vec3(b[, dest]) => dest | new Vec3
@@ -103,7 +103,7 @@ VALUE rb_cglm_vec3_add_vec3(int argc, VALUE *argv, VALUE self) {
   VALUE b, dest;
   rb_scan_args(argc, argv, "11", &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_add(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
+  glm_vec3_add(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
   return dest;
 }
 
@@ -116,7 +116,7 @@ VALUE rb_cglm_vec3_add_scalar(int argc, VALUE *argv, VALUE self) {
   VALUE b, dest;
   rb_scan_args(argc, argv, "11", &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_adds(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(dest));
+  glm_vec3_adds(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(dest));
   return dest;
 }
 
@@ -129,7 +129,7 @@ VALUE rb_cglm_vec3_sub_vec3(int argc, VALUE *argv, VALUE self) {
   VALUE b, dest;
   rb_scan_args(argc, argv, "11", &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_sub(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
+  glm_vec3_sub(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
   return dest;
 }
 
@@ -142,7 +142,7 @@ VALUE rb_cglm_vec3_sub_scalar(int argc, VALUE *argv, VALUE self) {
   VALUE b, dest;
   rb_scan_args(argc, argv, "11", &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_subs(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(dest));
+  glm_vec3_subs(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(dest));
   return dest;
 }
 
@@ -151,7 +151,7 @@ VALUE rb_cglm_vec3_sub_scalar(int argc, VALUE *argv, VALUE self) {
  * Adds `self` and `b` together, modifying `self` in-place and returning it.
  */
 VALUE rb_cglm_vec3_add_vec3_self(VALUE self, VALUE b) {
-  glm_vec_add(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(self));
+  glm_vec3_add(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(self));
   return self;
 }
 
@@ -161,7 +161,7 @@ VALUE rb_cglm_vec3_add_vec3_self(VALUE self, VALUE b) {
  * and returning it.
  */
 VALUE rb_cglm_vec3_add_scalar_self(VALUE self, VALUE b) {
-  glm_vec_adds(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(self));
+  glm_vec3_adds(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(self));
   return self;
 }
 
@@ -170,7 +170,7 @@ VALUE rb_cglm_vec3_add_scalar_self(VALUE self, VALUE b) {
  * Subtracts `b` from `self`, modifying `self` in-place and returning it.
  */
 VALUE rb_cglm_vec3_sub_vec3_self(VALUE self, VALUE b) {
-  glm_vec_sub(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(self));
+  glm_vec3_sub(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(self));
   return self;
 }
 
@@ -180,7 +180,7 @@ VALUE rb_cglm_vec3_sub_vec3_self(VALUE self, VALUE b) {
  * in-place and returning it.
  */
 VALUE rb_cglm_vec3_sub_scalar_self(VALUE self, VALUE b) {
-  glm_vec_subs(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(self));
+  glm_vec3_subs(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(self));
   return self;
 }
 
@@ -194,7 +194,7 @@ VALUE rb_cglm_vec3_mul_vec3(int argc, VALUE *argv, VALUE self) {
   VALUE b, dest;
   rb_scan_args(argc, argv, "11", &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_mul(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
+  glm_vec3_mul(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
   return dest;
 }
 
@@ -204,7 +204,7 @@ VALUE rb_cglm_vec3_mul_vec3(int argc, VALUE *argv, VALUE self) {
  * in-place and returns `self`.
  */
 VALUE rb_cglm_vec3_mul_vec3_self(VALUE self, VALUE b) {
-  glm_vec_mul(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(self));
+  glm_vec3_mul(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(self));
   return self;
 }
 
@@ -218,7 +218,7 @@ VALUE rb_cglm_vec3_mul_scalar(int argc, VALUE *argv, VALUE self) {
   VALUE b, dest;
   rb_scan_args(argc, argv, "11", &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_scale(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(dest));
+  glm_vec3_scale(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(dest));
   return dest;
 }
 
@@ -228,7 +228,7 @@ VALUE rb_cglm_vec3_mul_scalar(int argc, VALUE *argv, VALUE self) {
  * in-place and returns `self`.
  */
 VALUE rb_cglm_vec3_mul_scalar_self(VALUE self, VALUE b) {
-  glm_vec_scale(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(self));
+  glm_vec3_scale(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(self));
   return self;
 }
 
@@ -241,7 +241,7 @@ VALUE rb_cglm_vec3_resize(int argc, VALUE *argv, VALUE self) {
   VALUE b, dest;
   rb_scan_args(argc, argv, "11", &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_scale_as(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(dest));
+  glm_vec3_scale_as(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(dest));
   return dest;
 }
 
@@ -250,7 +250,7 @@ VALUE rb_cglm_vec3_resize(int argc, VALUE *argv, VALUE self) {
  * Same as `normalize(self) * b`. Modifies `self` in-place and returns `self`.
  */
 VALUE rb_cglm_vec3_resize_self(VALUE self, VALUE b) {
-  glm_vec_scale_as(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(self));
+  glm_vec3_scale_as(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(self));
   return self;
 }
 
@@ -264,7 +264,7 @@ VALUE rb_cglm_vec3_div_vec3(int argc, VALUE *argv, VALUE self) {
   VALUE b, dest;
   rb_scan_args(argc, argv, "11", &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_div(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
+  glm_vec3_div(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
   return dest;
 }
 
@@ -274,7 +274,7 @@ VALUE rb_cglm_vec3_div_vec3(int argc, VALUE *argv, VALUE self) {
  * in-place and returns `self`.
  */
 VALUE rb_cglm_vec3_div_vec3_self(VALUE self, VALUE b) {
-  glm_vec_div(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(self));
+  glm_vec3_div(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(self));
   return self;
 }
 
@@ -288,7 +288,7 @@ VALUE rb_cglm_vec3_div_scalar(int argc, VALUE *argv, VALUE self) {
   VALUE b, dest;
   rb_scan_args(argc, argv, "11", &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_divs(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(dest));
+  glm_vec3_divs(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(dest));
   return dest;
 }
 
@@ -298,7 +298,7 @@ VALUE rb_cglm_vec3_div_scalar(int argc, VALUE *argv, VALUE self) {
  * in-place and returns `self`.
  */
 VALUE rb_cglm_vec3_div_scalar_self(VALUE self, VALUE b) {
-  glm_vec_divs(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(self));
+  glm_vec3_divs(VAL2VEC3(self), NUM2FLT(b), VAL2VEC3(self));
   return self;
 }
 
@@ -310,7 +310,7 @@ VALUE rb_cglm_vec3_div_scalar_self(VALUE self, VALUE b) {
  * * `dest` is not optional for this method, as it is for most others.
  */
 VALUE rb_cglm_vec3_addadd_vec3(VALUE self, VALUE other, VALUE dest) {
-  glm_vec_addadd(VAL2VEC3(self), VAL2VEC3(other), VAL2VEC3(dest));
+  glm_vec3_addadd(VAL2VEC3(self), VAL2VEC3(other), VAL2VEC3(dest));
   return dest;
 }
 
@@ -322,7 +322,7 @@ VALUE rb_cglm_vec3_addadd_vec3(VALUE self, VALUE other, VALUE dest) {
  * * `dest` is not optional for this method, as it is for most others.
  */
 VALUE rb_cglm_vec3_subadd_vec3(VALUE self, VALUE other, VALUE dest) {
-  glm_vec_subadd(VAL2VEC3(self), VAL2VEC3(other), VAL2VEC3(dest));
+  glm_vec3_subadd(VAL2VEC3(self), VAL2VEC3(other), VAL2VEC3(dest));
   return dest;
 }
 
@@ -334,7 +334,7 @@ VALUE rb_cglm_vec3_subadd_vec3(VALUE self, VALUE other, VALUE dest) {
  * * `dest` is not optional for this method, as it is for most others.
  */
 VALUE rb_cglm_vec3_muladd_vec3(VALUE self, VALUE other, VALUE dest) {
-  glm_vec_muladd(VAL2VEC3(self), VAL2VEC3(other), VAL2VEC3(dest));
+  glm_vec3_muladd(VAL2VEC3(self), VAL2VEC3(other), VAL2VEC3(dest));
   return dest;
 }
 
@@ -348,7 +348,7 @@ VALUE rb_cglm_vec3_muladd_vec3(VALUE self, VALUE other, VALUE dest) {
  * * `dest` is not optional for this method, as it is for most others.
  */
 VALUE rb_cglm_vec3_muladd_scalar(VALUE self, VALUE other, VALUE dest) {
-  glm_vec_muladds(VAL2VEC3(self), NUM2FLT(other), VAL2VEC3(dest));
+  glm_vec3_muladds(VAL2VEC3(self), NUM2FLT(other), VAL2VEC3(dest));
   return dest;
 }
 
@@ -361,7 +361,7 @@ VALUE rb_cglm_vec3_flip_signs(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_vec_flipsign_to(VAL2VEC3(self), VAL2VEC3(dest));
+  glm_vec3_flipsign_to(VAL2VEC3(self), VAL2VEC3(dest));
   return dest;
 }
 
@@ -370,7 +370,7 @@ VALUE rb_cglm_vec3_flip_signs(int argc, VALUE *argv, VALUE self) {
  * Flips the sign of each component, modifying `self` in-place. Returns `self`.
  */
 VALUE rb_cglm_vec3_flip_signs_self(VALUE self) {
-  glm_vec_flipsign(VAL2VEC3(self));
+  glm_vec3_flipsign(VAL2VEC3(self));
   return self;
 }
 
@@ -383,7 +383,7 @@ VALUE rb_cglm_vec3_normalize(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_vec_normalize_to(VAL2VEC3(self), VAL2VEC3(dest));
+  glm_vec3_normalize_to(VAL2VEC3(self), VAL2VEC3(dest));
   return dest;
 }
 
@@ -392,7 +392,7 @@ VALUE rb_cglm_vec3_normalize(int argc, VALUE *argv, VALUE self) {
  * Normalizes `self` in-place, and returns `self`.
  */
 VALUE rb_cglm_vec3_normalize_self(VALUE self) {
-  glm_vec_normalize(VAL2VEC3(self));
+  glm_vec3_normalize(VAL2VEC3(self));
   return self;
 }
 
@@ -401,7 +401,7 @@ VALUE rb_cglm_vec3_normalize_self(VALUE self) {
  * Returns the angle between `self` and `other`, in radians.
  */
 VALUE rb_cglm_vec3_angle(VALUE self, VALUE other) {
-  return DBL2NUM(glm_vec_angle(VAL2VEC3(self), VAL2VEC3(other)));
+  return DBL2NUM(glm_vec3_angle(VAL2VEC3(self), VAL2VEC3(other)));
 }
 
 /* call-seq: rotate_axis_angle(axis, angle[, dest]) => dest | new Vec3
@@ -415,7 +415,7 @@ VALUE rb_cglm_vec3_rotate_axis_angle(int argc, VALUE *argv, VALUE self) {
   rb_scan_args(argc, argv, "21", &axis, &angle, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
   memcpy(&VAL2VEC3(dest), &VAL2VEC3(self), sizeof(vec3));
-  glm_vec_rotate(VAL2VEC3(dest), NUM2FLT(angle), VAL2VEC3(axis));
+  glm_vec3_rotate(VAL2VEC3(dest), NUM2FLT(angle), VAL2VEC3(axis));
   return dest;
 }
 
@@ -426,7 +426,7 @@ VALUE rb_cglm_vec3_rotate_axis_angle(int argc, VALUE *argv, VALUE self) {
  * returns `self`.
  */
 VALUE rb_cglm_vec3_rotate_axis_angle_self(VALUE self, VALUE axis, VALUE angle) {
-  glm_vec_rotate(VAL2VEC3(self), NUM2FLT(angle), VAL2VEC3(axis));
+  glm_vec3_rotate(VAL2VEC3(self), NUM2FLT(angle), VAL2VEC3(axis));
   return self;
 }
 
@@ -447,7 +447,7 @@ VALUE rb_cglm_vec3_rotate_mat4(int argc, VALUE *argv, VALUE self) {
   VALUE matrix, dest;
   rb_scan_args(argc, argv, "11", &matrix, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_rotate_m4(VAL2MAT4(matrix), VAL2VEC3(self), VAL2VEC3(dest));
+  glm_vec3_rotate_m4(VAL2MAT4(matrix), VAL2VEC3(self), VAL2VEC3(dest));
   return dest;
 }
 
@@ -464,7 +464,7 @@ VALUE rb_cglm_vec3_rotate_mat4(int argc, VALUE *argv, VALUE self) {
  *       0  0  0  w
  */
 VALUE rb_cglm_vec3_rotate_mat4_self(VALUE self, VALUE matrix) {
-  glm_vec_rotate_m4(VAL2MAT4(matrix), VAL2VEC3(self), VAL2VEC3(self));
+  glm_vec3_rotate_m4(VAL2MAT4(matrix), VAL2VEC3(self), VAL2VEC3(self));
   return self;
 }
 
@@ -478,7 +478,7 @@ VALUE rb_cglm_vec3_rotate_mat3(int argc, VALUE *argv, VALUE self) {
   VALUE matrix, dest;
   rb_scan_args(argc, argv, "11", &matrix, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_rotate_m3(VAL2MAT3(matrix), VAL2VEC3(self), VAL2VEC3(dest));
+  glm_vec3_rotate_m3(VAL2MAT3(matrix), VAL2VEC3(self), VAL2VEC3(dest));
   return dest;
 }
 
@@ -488,7 +488,7 @@ VALUE rb_cglm_vec3_rotate_mat3(int argc, VALUE *argv, VALUE self) {
  * `self` and returns `self`.
  */
 VALUE rb_cglm_vec3_rotate_mat3_self(VALUE self, VALUE matrix) {
-  glm_vec_rotate_m3(VAL2MAT3(matrix), VAL2VEC3(self), VAL2VEC3(self));
+  glm_vec3_rotate_m3(VAL2MAT3(matrix), VAL2VEC3(self), VAL2VEC3(self));
   return self;
 }
 
@@ -501,7 +501,7 @@ VALUE rb_cglm_vec3_project(int argc, VALUE *argv, VALUE self) {
   VALUE b, dest;
   rb_scan_args(argc, argv, "11", &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_proj(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
+  glm_vec3_proj(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
   return dest;
 }
 
@@ -511,7 +511,7 @@ VALUE rb_cglm_vec3_project(int argc, VALUE *argv, VALUE self) {
  * returns `self`.
  */
 VALUE rb_cglm_vec3_project_self(VALUE self, VALUE b) {
-  glm_vec_proj(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(self));
+  glm_vec3_proj(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(self));
   return self;
 }
 
@@ -525,7 +525,7 @@ VALUE rb_cglm_vec3_center(int argc, VALUE *argv, VALUE self) {
   VALUE b, dest;
   rb_scan_args(argc, argv, "11", &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_center(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
+  glm_vec3_center(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
   return dest;
 }
 
@@ -534,7 +534,7 @@ VALUE rb_cglm_vec3_center(int argc, VALUE *argv, VALUE self) {
  * Returns the squared distance between this vector and the specified one.
  */
 VALUE rb_cglm_vec3_distance2(VALUE self, VALUE b) {
-  return DBL2NUM(glm_vec_distance2(VAL2VEC3(self), VAL2VEC3(b)));
+  return DBL2NUM(glm_vec3_distance2(VAL2VEC3(self), VAL2VEC3(b)));
 }
 
 /* call-seq: distance(vec) => Numeric
@@ -542,7 +542,7 @@ VALUE rb_cglm_vec3_distance2(VALUE self, VALUE b) {
  * Returns the distance between this vector and the specified one.
  */
 VALUE rb_cglm_vec3_distance(VALUE self, VALUE b) {
-  return DBL2NUM(glm_vec_distance(VAL2VEC3(self), VAL2VEC3(b)));
+  return DBL2NUM(glm_vec3_distance(VAL2VEC3(self), VAL2VEC3(b)));
 }
 
 /* call-seq: max(vec[, dest]) => dest | new Vec3
@@ -555,7 +555,7 @@ VALUE rb_cglm_vec3_max(int argc, VALUE *argv, VALUE self) {
   VALUE b, dest;
   rb_scan_args(argc, argv, "11", &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_maxv(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
+  glm_vec3_maxv(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
   return dest;
 }
 
@@ -569,7 +569,7 @@ VALUE rb_cglm_vec3_min(int argc, VALUE *argv, VALUE self) {
   VALUE b, dest;
   rb_scan_args(argc, argv, "11", &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
-  glm_vec_minv(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
+  glm_vec3_minv(VAL2VEC3(self), VAL2VEC3(b), VAL2VEC3(dest));
   return dest;
 }
 
@@ -583,7 +583,7 @@ VALUE rb_cglm_vec3_ortho(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_vec_ortho(VAL2VEC3(self), VAL2VEC3(dest));
+  glm_vec3_ortho(VAL2VEC3(self), VAL2VEC3(dest));
   return dest;
 }
 
@@ -598,7 +598,7 @@ VALUE rb_cglm_vec3_clamp_scalar(int argc, VALUE *argv, VALUE self) {
   rb_scan_args(argc, argv, "21", &a, &b, &dest);
   if (NIL_P(dest)) dest = VEC3_NEW(ALLOC_VEC3);
   memcpy(&VAL2VEC3(dest), &VAL2VEC3(self), sizeof(vec3));
-  glm_vec_clamp(VAL2VEC3(dest), NUM2FLT(a), NUM2FLT(b));
+  glm_vec3_clamp(VAL2VEC3(dest), NUM2FLT(a), NUM2FLT(b));
   return dest;
 }
 
@@ -608,7 +608,7 @@ VALUE rb_cglm_vec3_clamp_scalar(int argc, VALUE *argv, VALUE self) {
  * Places the result into `self` and returns `self`.
  */
 VALUE rb_cglm_vec3_clamp_scalar_self(VALUE self, VALUE a, VALUE b) {
-  glm_vec_clamp(VAL2VEC3(self), NUM2FLT(a), NUM2FLT(b));
+  glm_vec3_clamp(VAL2VEC3(self), NUM2FLT(a), NUM2FLT(b));
   return self;
 }
 
@@ -619,7 +619,7 @@ VALUE rb_cglm_vec3_clamp_scalar_self(VALUE self, VALUE a, VALUE b) {
  * `self` in-place and returns `self`.
  */
 VALUE rb_cglm_vec3_lerp_self(VALUE self, VALUE from, VALUE to, VALUE amount) {
-  glm_vec_lerp(VAL2VEC3(from), VAL2VEC3(to), NUM2FLT(amount), VAL2VEC3(self));
+  glm_vec3_lerp(VAL2VEC3(from), VAL2VEC3(to), NUM2FLT(amount), VAL2VEC3(self));
   return self;
 }
 
@@ -629,7 +629,7 @@ VALUE rb_cglm_vec3_lerp_self(VALUE self, VALUE from, VALUE to, VALUE amount) {
  * `self`.
  */
 VALUE rb_cglm_vec3_broadcast_self(VALUE self, VALUE val) {
-  glm_vec_broadcast(NUM2FLT(val), VAL2VEC3(self));
+  glm_vec3_broadcast(NUM2FLT(val), VAL2VEC3(self));
   return self;
 }
 
@@ -639,7 +639,7 @@ VALUE rb_cglm_vec3_broadcast_self(VALUE self, VALUE val) {
  * this Vec3, false otherwise.
  */
 VALUE rb_cglm_vec3_equals_scalar(VALUE self, VALUE val) {
-  return glm_vec_eq(VAL2VEC3(self), NUM2FLT(val)) ? Qtrue : Qfalse;
+  return glm_vec3_eq(VAL2VEC3(self), NUM2FLT(val)) ? Qtrue : Qfalse;
 }
 
 /* call-seq: equalish_scalar(val[, epsilon]) => true|false
@@ -665,7 +665,7 @@ VALUE rb_cglm_vec3_equalish_scalar(int argc, VALUE *argv, VALUE self) {
  * Returns true if each component in this Vec3 has the same exact value.
  */
 VALUE rb_cglm_vec3_equals_all(VALUE self) {
-  return glm_vec_eq_all(VAL2VEC3(self)) ? Qtrue : Qfalse;
+  return glm_vec3_eq_all(VAL2VEC3(self)) ? Qtrue : Qfalse;
 }
 
 /* call-seq: equals_vec3(other) => true|false
@@ -673,7 +673,7 @@ VALUE rb_cglm_vec3_equals_all(VALUE self) {
  * Returns true if this vector exactly matches the given one.
  */
 VALUE rb_cglm_vec3_equals_vec3(VALUE self, VALUE other) {
-  return glm_vec_eqv(VAL2VEC3(self), VAL2VEC3(other)) ? Qtrue : Qfalse;
+  return glm_vec3_eqv(VAL2VEC3(self), VAL2VEC3(other)) ? Qtrue : Qfalse;
 }
 
 /* call-seq: equalish_vec3(other[, epsilon]) => true|false
@@ -698,7 +698,7 @@ VALUE rb_cglm_vec3_equalish_vec3(int argc, VALUE *argv, VALUE self) {
  * Returns the value of the highest component in this Vec3.
  */
 VALUE rb_cglm_vec3_highest(VALUE self) {
-  return DBL2NUM(glm_vec_max(VAL2VEC3(self)));
+  return DBL2NUM(glm_vec3_max(VAL2VEC3(self)));
 }
 
 /* call-seq: lowest => Numeric
@@ -706,7 +706,7 @@ VALUE rb_cglm_vec3_highest(VALUE self) {
  * Returns the value of the lowest component in this Vec3.
  */
 VALUE rb_cglm_vec3_lowest(VALUE self) {
-  return DBL2NUM(glm_vec_min(VAL2VEC3(self)));
+  return DBL2NUM(glm_vec3_min(VAL2VEC3(self)));
 }
 
 /* call-seq: nan? => true|false
@@ -715,7 +715,7 @@ VALUE rb_cglm_vec3_lowest(VALUE self) {
  * You should only use this in DEBUG mode or very critical asserts.
  */
 VALUE rb_cglm_vec3_is_nan(VALUE self) {
-  return glm_vec_isnan(VAL2VEC3(self)) ? Qtrue : Qfalse;
+  return glm_vec3_isnan(VAL2VEC3(self)) ? Qtrue : Qfalse;
 }
 
 /* call-seq: inf? => true|false
@@ -724,7 +724,7 @@ VALUE rb_cglm_vec3_is_nan(VALUE self) {
  * You should only use this in DEBUG mode or very critical asserts.
  */
 VALUE rb_cglm_vec3_is_inf(VALUE self) {
-  return glm_vec_isinf(VAL2VEC3(self)) ? Qtrue : Qfalse;
+  return glm_vec3_isinf(VAL2VEC3(self)) ? Qtrue : Qfalse;
 }
 
 /* call-seq: valid? => true|false
@@ -733,7 +733,7 @@ VALUE rb_cglm_vec3_is_inf(VALUE self) {
  * otherwise. You should only use this in DEBUG mode or very critical asserts.
  */
 VALUE rb_cglm_vec3_is_valid(VALUE self) {
-  return glm_vec_isvalid(VAL2VEC3(self)) ? Qtrue : Qfalse;
+  return glm_vec3_isvalid(VAL2VEC3(self)) ? Qtrue : Qfalse;
 }
 
 /* call-seq: signs([dest]) => dest | new Vec3
@@ -746,7 +746,7 @@ VALUE rb_cglm_vec3_signs(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_vec_sign(VAL2VEC3(self), VAL2VEC3(dest));
+  glm_vec3_sign(VAL2VEC3(self), VAL2VEC3(dest));
   return dest;
 }
 
@@ -759,7 +759,7 @@ VALUE rb_cglm_vec3_sqrt(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_vec_sqrt(VAL2VEC3(self), VAL2VEC3(dest));
+  glm_vec3_sqrt(VAL2VEC3(self), VAL2VEC3(dest));
   return dest;
 }
 
@@ -865,6 +865,8 @@ void Init_cglm_vec3() {
 
   rb_define_alias(rb_cVec3, "invert",     "flip_signs");
   rb_define_alias(rb_cVec3, "invert!",    "flip_signs!");
+  rb_define_alias(rb_cVec3, "negate",     "flip_signs");
+  rb_define_alias(rb_cVec3, "negate!",    "flip_signs!");
   rb_define_alias(rb_cVec3, "magnitude",  "norm");
   rb_define_alias(rb_cVec3, "mag",        "norm");
   rb_define_alias(rb_cVec3, "magnitude2", "norm2");

data/ext/cglm/rb_cglm_vec4.c

@@ -711,6 +711,8 @@ void Init_cglm_vec4() {
 
   rb_define_alias(rb_cVec4, "invert",     "flip_signs");
   rb_define_alias(rb_cVec4, "invert!",    "flip_signs!");
+  rb_define_alias(rb_cVec4, "negate",     "flip_signs");
+  rb_define_alias(rb_cVec4, "negate!",    "flip_signs!");
   rb_define_alias(rb_cVec4, "magnitude",  "norm");
   rb_define_alias(rb_cVec4, "mag",        "norm");