rgss 0.0.1

data/ext/rgss/vec.c

@@ -0,0 +1,114 @@
+/** 
+ * Copyright (c) 2014 rxi
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include "vec.h"
+
+
+int vec_expand_(char **data, int *length, int *capacity, int memsz) {
+  if (*length + 1 > *capacity) {
+    void *ptr;
+    int n = (*capacity == 0) ? 1 : *capacity << 1;
+    ptr = VEC_REALLOC(*data, n * memsz);
+    if (ptr == NULL) return -1;
+    *data = ptr;
+    *capacity = n;
+  }
+  return 0;
+}
+
+
+int vec_reserve_(char **data, int *length, int *capacity, int memsz, int n) {
+  (void) length;
+  if (n > *capacity) {
+    void *ptr = VEC_REALLOC(*data, n * memsz);
+    if (ptr == NULL) return -1;
+    *data = ptr;
+    *capacity = n;
+  }
+  return 0;
+}
+
+
+int vec_reserve_po2_(
+  char **data, int *length, int *capacity, int memsz, int n
+) {
+  int n2 = 1;
+  if (n == 0) return 0;
+  while (n2 < n) n2 <<= 1;
+  return vec_reserve_(data, length, capacity, memsz, n2);
+}
+
+
+int vec_compact_(char **data, int *length, int *capacity, int memsz) {
+  if (*length == 0) {
+    VEC_FREE(*data);
+    *data = NULL;
+    *capacity = 0;
+    return 0;
+  } else {
+    void *ptr;
+    int n = *length;
+    ptr = VEC_REALLOC(*data, n * memsz);
+    if (ptr == NULL) return -1;
+    *capacity = n;
+    *data = ptr;
+  }
+  return 0;
+}
+
+
+int vec_insert_(char **data, int *length, int *capacity, int memsz,
+                 int idx
+) {
+  int err = vec_expand_(data, length, capacity, memsz);
+  if (err) return err;
+  memmove(*data + (idx + 1) * memsz,
+          *data + idx * memsz,
+          (*length - idx) * memsz);
+  return 0;
+}
+
+
+void vec_splice_(char **data, int *length, int *capacity, int memsz,
+                 int start, int count
+) {
+  (void) capacity;
+  memmove(*data + start * memsz,
+          *data + (start + count) * memsz,
+          (*length - start - count) * memsz);
+}
+
+
+void vec_swapsplice_(char **data, int *length, int *capacity, int memsz,
+                     int start, int count
+) {
+  (void) capacity;
+  memmove(*data + start * memsz,
+          *data + (*length - count) * memsz,
+          count * memsz);
+}
+
+
+void vec_swap_(char **data, int *length, int *capacity, int memsz,
+               int idx1, int idx2 
+) {
+  unsigned char *a, *b, tmp;
+  int count;
+  (void) length;
+  (void) capacity;
+  if (idx1 == idx2) return;
+  a = (unsigned char*) *data + idx1 * memsz;
+  b = (unsigned char*) *data + idx2 * memsz;
+  count = memsz;
+  while (count--) {
+    tmp = *a;
+    *a = *b;
+    *b = tmp;
+    a++, b++;
+  }
+}
+

data/ext/rgss/vec.h

@@ -0,0 +1,192 @@
+/** 
+ * Copyright (c) 2014 rxi
+ *
+ * This library is free software; you can redistribute it and/or modify it
+ * under the terms of the MIT license. See LICENSE for details.
+ */
+
+#ifndef VEC_H
+#define VEC_H
+
+#include <stdlib.h>
+#include <string.h>
+
+#define VEC_VERSION "0.2.1"
+
+
+#define vec_unpack_(v)\
+  (char**)&(v)->data, &(v)->length, &(v)->capacity, sizeof(*(v)->data)
+
+
+#define vec_t(T)\
+  struct { T *data; int length, capacity; }
+
+
+#define vec_init(v)\
+  memset((v), 0, sizeof(*(v)))
+
+
+#define vec_deinit(v)\
+  ( VEC_FREE((v)->data),\
+    vec_init(v) ) 
+
+
+#define vec_push(v, val)\
+  ( vec_expand_(vec_unpack_(v)) ? -1 :\
+    ((v)->data[(v)->length++] = (val), 0), 0 )
+
+
+#define vec_pop(v)\
+  (v)->data[--(v)->length]
+
+
+#define vec_splice(v, start, count)\
+  ( vec_splice_(vec_unpack_(v), start, count),\
+    (v)->length -= (count) )
+
+
+#define vec_swapsplice(v, start, count)\
+  ( vec_swapsplice_(vec_unpack_(v), start, count),\
+    (v)->length -= (count) )
+
+
+#define vec_insert(v, idx, val)\
+  ( vec_insert_(vec_unpack_(v), idx) ? -1 :\
+    ((v)->data[idx] = (val), 0), (v)->length++, 0 )
+    
+
+#define vec_sort(v, fn)\
+  qsort((v)->data, (v)->length, sizeof(*(v)->data), fn)
+
+
+#define vec_swap(v, idx1, idx2)\
+  vec_swap_(vec_unpack_(v), idx1, idx2)
+
+
+#define vec_truncate(v, len)\
+  ((v)->length = (len) < (v)->length ? (len) : (v)->length)
+
+
+#define vec_clear(v)\
+  ((v)->length = 0)
+
+
+#define vec_first(v)\
+  (v)->data[0]
+
+
+#define vec_last(v)\
+  (v)->data[(v)->length - 1]
+
+
+#define vec_reserve(v, n)\
+  vec_reserve_(vec_unpack_(v), n)
+
+ 
+#define vec_compact(v)\
+  vec_compact_(vec_unpack_(v))
+
+
+#define vec_pusharr(v, arr, count)\
+  do {\
+    int i__, n__ = (count);\
+    if (vec_reserve_po2_(vec_unpack_(v), (v)->length + n__) != 0) break;\
+    for (i__ = 0; i__ < n__; i__++) {\
+      (v)->data[(v)->length++] = (arr)[i__];\
+    }\
+  } while (0)
+
+
+#define vec_extend(v, v2)\
+  vec_pusharr((v), (v2)->data, (v2)->length)
+
+
+#define vec_find(v, val, idx)\
+  do {\
+    for ((idx) = 0; (idx) < (v)->length; (idx)++) {\
+      if ((v)->data[(idx)] == (val)) break;\
+    }\
+    if ((idx) == (v)->length) (idx) = -1;\
+  } while (0)
+
+
+#define vec_remove(v, val)\
+  do {\
+    int idx__;\
+    vec_find(v, val, idx__);\
+    if (idx__ != -1) vec_splice(v, idx__, 1);\
+  } while (0)
+
+
+#define vec_reverse(v)\
+  do {\
+    int i__ = (v)->length / 2;\
+    while (i__--) {\
+      vec_swap((v), i__, (v)->length - (i__ + 1));\
+    }\
+  } while (0)
+
+
+#define vec_foreach(v, var, iter)\
+  if  ( (v)->length > 0 )\
+  for ( (iter) = 0;\
+        (iter) < (v)->length && (((var) = (v)->data[(iter)]), 1);\
+        ++(iter))
+
+
+#define vec_foreach_rev(v, var, iter)\
+  if  ( (v)->length > 0 )\
+  for ( (iter) = (v)->length - 1;\
+        (iter) >= 0 && (((var) = (v)->data[(iter)]), 1);\
+        --(iter))
+
+
+#define vec_foreach_ptr(v, var, iter)\
+  if  ( (v)->length > 0 )\
+  for ( (iter) = 0;\
+        (iter) < (v)->length && (((var) = &(v)->data[(iter)]), 1);\
+        ++(iter))
+
+
+#define vec_foreach_ptr_rev(v, var, iter)\
+  if  ( (v)->length > 0 )\
+  for ( (iter) = (v)->length - 1;\
+        (iter) >= 0 && (((var) = &(v)->data[(iter)]), 1);\
+        --(iter))
+
+
+
+#if defined(VEC_FREE) && defined(VEC_REALLOC)
+// Both defined, no error
+#elif !defined(VEC_REALLOC) && !defined(VEC_FREE)
+// Neither defined, use stdlib
+#define VEC_FREE free
+#define VEC_REALLOC realloc
+#else
+#error "Must define all or none of VEC_FREE and VEC_REALLOC."
+#endif
+
+
+int vec_expand_(char **data, int *length, int *capacity, int memsz);
+int vec_reserve_(char **data, int *length, int *capacity, int memsz, int n);
+int vec_reserve_po2_(char **data, int *length, int *capacity, int memsz,
+                     int n);
+int vec_compact_(char **data, int *length, int *capacity, int memsz);
+int vec_insert_(char **data, int *length, int *capacity, int memsz,
+                int idx);
+void vec_splice_(char **data, int *length, int *capacity, int memsz,
+                 int start, int count);
+void vec_swapsplice_(char **data, int *length, int *capacity, int memsz,
+                     int start, int count);
+void vec_swap_(char **data, int *length, int *capacity, int memsz,
+               int idx1, int idx2);
+
+
+typedef vec_t(void*) vec_void_t;
+typedef vec_t(char*) vec_str_t;
+typedef vec_t(int) vec_int_t;
+typedef vec_t(char) vec_char_t;
+typedef vec_t(float) vec_float_t;
+typedef vec_t(double) vec_double_t;
+
+#endif

data/ext/rgss/vec2.c

@@ -0,0 +1,489 @@
+#include "game.h"
+
+VALUE rb_cVec2;
+
+CREATE_ALLOC_FUNC(vec2, RGSS_VEC2_ALIGN, RGSS_VEC2_SIZE)
+VEC_ATTR_ACCESSOR(vec2, x, 0)
+VEC_ATTR_ACCESSOR(vec2, y, 1)
+
+static VALUE vec2_get(VALUE self, VALUE index)
+{
+    int i = NUM2INT(index);
+    if (index < 0 || index > 1)
+        rb_raise(rb_eArgError, "index of of range (must be 0..1)");
+    return DBL2NUM(((float*) DATA_PTR(self))[i]);
+}
+
+static VALUE vec2_set(VALUE self, VALUE index, VALUE value)
+{
+    int i = NUM2INT(index);
+    if (index < 0 || index > 1)
+        rb_raise(rb_eArgError, "index of of range (must be 0..1)");
+    ((float*) DATA_PTR(self))[i] = NUM2FLT(value);
+    return value;
+}
+
+static VALUE vec2_copy(VALUE self)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_copy(DATA_PTR(self), d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_zero(VALUE klass)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_zero(d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_one(VALUE klass)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_one(d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_dot(VALUE self, VALUE other)
+{
+    return DBL2NUM(glm_vec2_dot(DATA_PTR(self), DATA_PTR(other)));
+}
+
+static VALUE vec2_cross(VALUE self, VALUE other)
+{
+    return DBL2NUM(glm_vec2_cross(DATA_PTR(self), DATA_PTR(other)));
+}
+
+static VALUE vec2_length(VALUE self)
+{
+    return DBL2NUM(glm_vec2_norm(DATA_PTR(self)));
+}
+
+static VALUE vec2_length_squared(VALUE self)
+{
+    return DBL2NUM(glm_vec2_norm2(DATA_PTR(self)));
+}
+
+static VALUE vec2_add(VALUE self, VALUE other)
+{
+    float *v = DATA_PTR(self);
+    float *d = RGSS_VEC2_NEW;
+
+    if (RB_TYPE_P(other, T_DATA))
+    {
+        glm_vec2_add(v, DATA_PTR(other), d);
+    }
+    else
+    {
+        glm_vec2_adds(v, NUM2FLT(other), d);
+    }
+    
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_sub(VALUE self, VALUE other)
+{
+    float *v = DATA_PTR(self);
+    float *d = RGSS_VEC2_NEW;
+
+    if (RB_TYPE_P(other, T_DATA))
+    {
+        glm_vec2_sub(v, DATA_PTR(other), d);
+    }
+    else
+    {
+        glm_vec2_subs(v, NUM2FLT(other), d);
+    }
+    
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_mul(VALUE self, VALUE other)
+{
+    float *v = DATA_PTR(self);
+    float *d = RGSS_VEC2_NEW;
+
+    if (RB_TYPE_P(other, T_DATA))
+    {
+        glm_vec2_mul(v, DATA_PTR(other), d);
+    }
+    else
+    {
+        glm_vec2_scale(v, NUM2FLT(other), d);
+    }
+    
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_div(VALUE self, VALUE other)
+{
+    float *v = DATA_PTR(self);
+    float *d = RGSS_VEC2_NEW;
+
+    if (RB_TYPE_P(other, T_DATA))
+    {
+        glm_vec2_div(v, DATA_PTR(other), d);
+    }
+    else
+    {
+        glm_vec2_divs(v, NUM2FLT(other), d);
+    }
+    
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_norm_scale(VALUE self, VALUE scalar)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_scale_as(DATA_PTR(self), NUM2FLT(scalar), d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_add_add(VALUE self, VALUE other)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_addadd(DATA_PTR(self), DATA_PTR(other), d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_sub_add(VALUE self, VALUE other)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_subadd(DATA_PTR(self), DATA_PTR(other), d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_mul_add(VALUE self, VALUE other)
+{
+    float *d = RGSS_VEC2_NEW;
+    float *v = DATA_PTR(self);
+
+    if (RB_TYPE_P(other, T_DATA))
+    {
+        glm_vec2_muladd(v, DATA_PTR(other), d);
+    }
+    else
+    {
+        glm_vec2_muladds(v, NUM2FLT(other), d);
+    }
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_max_add(VALUE self, VALUE other)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_maxadd(DATA_PTR(self), DATA_PTR(other), d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_min_add(VALUE self, VALUE other)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_minadd(DATA_PTR(self), DATA_PTR(other), d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_negate_bang(VALUE self)
+{
+    glm_vec2_negate(DATA_PTR(self));
+    return self;
+}
+
+static VALUE vec2_negate(VALUE self)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_negate_to(DATA_PTR(self), d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_normalize(VALUE self)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_normalize_to(DATA_PTR(self), d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_normalize_bang(VALUE self)
+{
+    glm_vec2_normalize(DATA_PTR(self));
+    return self;
+}
+
+static VALUE vec2_rotate_bang(VALUE self, VALUE angle)
+{
+    float *v = DATA_PTR(self);
+    vec2 temp;
+    glm_vec2_rotate(v, NUM2FLT(angle), v);
+    return self;
+}
+
+static VALUE vec2_rotate(VALUE self, VALUE angle)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_rotate(DATA_PTR(self), NUM2FLT(angle), d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_distance(VALUE self, VALUE other)
+{
+    return DBL2NUM(glm_vec2_distance(DATA_PTR(self), DATA_PTR(other)));
+}
+
+static VALUE vec2_distance_squared(VALUE self, VALUE other)
+{
+    return DBL2NUM(glm_vec2_distance2(DATA_PTR(self), DATA_PTR(other)));
+}
+
+static VALUE vec2_maxv(VALUE self, VALUE other)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_maxv(DATA_PTR(self), DATA_PTR(other), d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_minv(VALUE self, VALUE other)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_minv(DATA_PTR(self), DATA_PTR(other), d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_clamp_bang(VALUE self, VALUE min, VALUE max)
+{
+    glm_vec2_clamp(DATA_PTR(self), NUM2FLT(min), NUM2FLT(max));
+    return self;
+}
+
+static VALUE vec2_clamp(VALUE self, VALUE min, VALUE max)
+{
+    return vec2_clamp(vec2_copy(self), min, max);
+}
+
+static VALUE vec2_lerp(VALUE self, VALUE other, VALUE weight)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_lerp(DATA_PTR(self), DATA_PTR(other), NUM2FLT(weight), d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_lerp_bang(VALUE self, VALUE other, VALUE weight)
+{
+    vec2 temp;
+    float *v = DATA_PTR(self);
+    glm_vec2_lerp(v, DATA_PTR(other), NUM2FLT(weight), temp);
+    glm_vec2_copy(temp, v);
+    return self;
+}
+
+static VALUE vec2_equal(int argc, VALUE *argv, VALUE self)
+{
+    VALUE other, epsilon;
+    rb_scan_args(argc, argv, "11", &other, &epsilon);
+
+    if (CLASS_OF(self) != CLASS_OF(other))
+        return Qfalse;
+
+    float *v1 = DATA_PTR(self), *v2 = DATA_PTR(other);
+    bool result = RTEST(epsilon) ? glm_vec2_eqv_eps(v1, v2) : glm_vec2_eqv(v1, v2);
+
+    return RB_BOOL(result);
+}
+
+static VALUE vec2_all_p(int argc, VALUE *argv, VALUE self)
+{
+    VALUE value, epsilon;
+    rb_scan_args(argc, argv, "11", &value, &epsilon);
+
+    float *v1 = DATA_PTR(self), v2 = NUM2FLT(value);
+    bool result = RTEST(epsilon) ? glm_vec2_eq_eps(v1, v2) : glm_vec2_eq(v1, v2);
+
+    return RB_BOOL(result);
+}
+
+static VALUE vec2_max_value(VALUE self)
+{
+    return DBL2NUM(glm_vec2_max(DATA_PTR(self)));
+}
+
+static VALUE vec2_min_value(VALUE self)
+{
+    return DBL2NUM(glm_vec2_min(DATA_PTR(self)));
+}
+
+static VALUE vec2_infinite_p(VALUE self)
+{
+    return RB_BOOL(glm_vec2_isinf(DATA_PTR(self)));
+}
+
+static VALUE vec2_nan_p(VALUE self)
+{
+    return RB_BOOL(glm_vec2_isnan(DATA_PTR(self)));
+}
+
+static VALUE vec2_sqrt(VALUE self)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_sqrt(DATA_PTR(self), d);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_abs(VALUE self)
+{
+    float *d = RGSS_VEC2_NEW;
+    float *v = DATA_PTR(self);
+    d[0] = fabsf(v[0]);
+    d[1] = fabsf(v[1]);
+    return VEC2_WRAP(d);
+}
+
+static VALUE vec2_sign(VALUE self)
+{
+    float *d = RGSS_VEC2_NEW;
+    glm_vec2_sign(DATA_PTR(self), d);
+    return VEC2_WRAP(d);
+}
+
+static void vec2_create(int argc, VALUE *argv, vec2 v)
+{
+    VALUE a1, a2;
+    rb_scan_args(argc, argv, "02", &a1, &a2);
+
+    switch (argc)
+    {
+        case 0:
+        {
+            glm_vec2_zero(v);
+            break;
+        }
+        case 1:
+        {
+            if (RB_TYPE_P(a1, T_DATA))
+            {
+                glm_vec2_copy(DATA_PTR(a1), v);
+            }
+            else
+            {
+                glm_vec2_fill(v, NUM2FLT(a1));
+            }
+            break;
+        }
+        case 2:
+        {
+            v[0] = NUM2FLT(a1);    
+            v[1] = NUM2FLT(a2);        
+            break;
+        }
+    }
+}
+
+static VALUE vec2_initialize(int argc, VALUE *argv, VALUE self)
+{
+    if (CLASS_OF(self) != rb_cVec2)
+        rb_warn("inheriting from %s may result in undefined behavior", rb_class2name(rb_cVec3));
+
+    vec2_create(argc, argv, DATA_PTR(self));
+    return Qnil;
+}
+
+static VALUE vec2_kernel_create(int argc, VALUE *argv, VALUE module)
+{
+    float *v = RGSS_VEC2_NEW;
+    vec2_create(argc, argv, v);
+    return VEC2_WRAP(v);
+}
+
+static VALUE vec2_unitx(VALUE klass)
+{
+    return RGSS_Vec2_New(1.0f, 0.0f);
+}
+
+static VALUE vec2_unity(VALUE klass)
+{
+    return RGSS_Vec2_New(0.0f, 1.0f);
+}
+
+static VALUE vec2_inspect(VALUE self)
+{
+    float *v = DATA_PTR(self);
+    return rb_sprintf("<%f, %f>", v[0], v[1]);
+}
+
+void RGSS_Init_Vec2(VALUE parent)
+{
+    rb_cVec2 = rb_define_class_under(parent, "Vec2", rb_cObject);
+    rb_define_alloc_func(rb_cVec2, vec2_alloc);
+    rb_define_methodm1(rb_cVec2, "initialize", vec2_initialize, -1);
+    rb_define_methodm1(rb_mKernel, "vec2", vec2_kernel_create, -1);
+
+    rb_define_const(rb_cVec2, "SIZE", SIZET2NUM(RGSS_VEC2_SIZE));
+    rb_define_const(rb_cVec2, "ALIGN", SIZET2NUM(RGSS_VEC2_ALIGN));
+
+    rb_define_method1(rb_cVec2, "[]", vec2_get, 1);
+    rb_define_method2(rb_cVec2, "[]=", vec2_set, 2);
+    rb_define_method0(rb_cVec2, "x", vec2_get_x, 0);
+    rb_define_method0(rb_cVec2, "y", vec2_get_y, 0);
+    rb_define_method1(rb_cVec2, "x=", vec2_set_x, 1);
+    rb_define_method1(rb_cVec2, "y=", vec2_set_y, 1);
+    rb_define_method0(rb_cVec2, "copy", vec2_copy, 0);
+    rb_define_method1(rb_cVec2, "dot", vec2_dot, 1);
+    rb_define_method1(rb_cVec2, "cross", vec2_cross, 1);
+    rb_define_method0(rb_cVec2, "length", vec2_length, 0);
+    rb_define_method0(rb_cVec2, "length_squared", vec2_length_squared, 0);
+    rb_define_method1(rb_cVec2, "add", vec2_add, 1);
+    rb_define_method1(rb_cVec2, "subtract", vec2_sub, 1);
+    rb_define_method1(rb_cVec2, "multiply", vec2_mul, 1);
+    rb_define_method1(rb_cVec2, "divide", vec2_div, 1);
+    rb_define_method1(rb_cVec2, "norm_scale", vec2_norm_scale, 1);
+    rb_define_method1(rb_cVec2, "add_add", vec2_add_add, 1);
+    rb_define_method1(rb_cVec2, "sub_add", vec2_sub_add, 1);
+    rb_define_method1(rb_cVec2, "mul_add", vec2_mul_add, 1);
+    rb_define_method1(rb_cVec2, "max_add", vec2_max_add, 1);
+    rb_define_method1(rb_cVec2, "min_add", vec2_min_add, 1);
+    rb_define_method0(rb_cVec2, "negate", vec2_negate, 0);
+    rb_define_method0(rb_cVec2, "negate!", vec2_negate_bang, 0);
+    rb_define_method0(rb_cVec2, "normalize", vec2_normalize, 0);
+    rb_define_method0(rb_cVec2, "normalize!", vec2_normalize_bang, 0);
+    rb_define_method1(rb_cVec2, "rotate",  vec2_rotate, 1);
+    rb_define_method1(rb_cVec2, "rotate!", vec2_rotate_bang, 1);
+    rb_define_method1(rb_cVec2, "distance",  vec2_distance, 1);
+    rb_define_method1(rb_cVec2, "distance_squared", vec2_distance_squared, 1);
+    rb_define_method1(rb_cVec2, "max", vec2_maxv, 1);
+    rb_define_method1(rb_cVec2, "min", vec2_minv, 1);
+    rb_define_method2(rb_cVec2, "clamp", vec2_clamp, 2);
+    rb_define_method2(rb_cVec2, "clamp!", vec2_clamp_bang, 2);
+    rb_define_method2(rb_cVec2, "lerp", vec2_lerp, 2);
+    rb_define_method2(rb_cVec2, "lerp!", vec2_lerp_bang, 2);
+    rb_define_method0(rb_cVec2, "infinite?", vec2_infinite_p, 0);
+    rb_define_method0(rb_cVec2, "nan?", vec2_nan_p, 0);
+    rb_define_method0(rb_cVec2, "sqrt", vec2_sqrt, 0);
+    rb_define_method0(rb_cVec2, "abs", vec2_abs, 0);
+    rb_define_method0(rb_cVec2, "sign", vec2_sign, 0);
+    rb_define_methodm1(rb_cVec2, "eql?", vec2_equal, -1);
+    rb_define_methodm1(rb_cVec2, "all?", vec2_all_p, -1);
+    rb_define_method0(rb_cVec2, "max_value", vec2_max_value, 0);
+    rb_define_method0(rb_cVec2, "min_value", vec2_min_value, 0);
+
+    rb_define_method0(rb_cVec2, "inspect", vec2_inspect, 0);
+    rb_define_method0(rb_cVec2, "to_s", vec2_inspect, 0);
+    rb_define_method0(rb_cVec2, "to_str", vec2_inspect, 0);
+
+    rb_define_alias(rb_cVec2, "dup", "copy");
+    rb_define_alias(rb_cVec2, "magnitude", "length");
+    rb_define_alias(rb_cVec2, "magnitude_squared", "length_squared");
+    rb_define_alias(rb_cVec2, "norm", "length");
+    rb_define_alias(rb_cVec2, "norm2", "length_squared");
+    rb_define_alias(rb_cVec2, "+", "add");
+    rb_define_alias(rb_cVec2, "-", "subtract");
+    rb_define_alias(rb_cVec2, "*", "multiply");
+    rb_define_alias(rb_cVec2, "/", "divide");
+    rb_define_alias(rb_cVec2, "-@", "negate");
+    rb_define_alias(rb_cVec2, "==", "eql?");
+    rb_define_alias(rb_cVec2, "scale", "multiply");
+    rb_define_alias(rb_cVec2, "mix", "lerp");
+    rb_define_alias(rb_cVec2, "mix!", "lerp!");
+
+    rb_define_singleton_method0(rb_cVec2, "zero", vec2_zero, 0);
+    rb_define_singleton_method0(rb_cVec2, "one", vec2_one, 0);
+    rb_define_singleton_method0(rb_cVec2, "unit_x", vec2_unitx, 0);
+    rb_define_singleton_method0(rb_cVec2, "unit_y", vec2_unity, 0);
+}