snow-math 1.3.1 → 1.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 47e38c89d96a20a0925fce136ffa19d925e1bc51
-  data.tar.gz: b09e53bd8b62d9517cfd7dcdf9c479ac5ffa2871
+  metadata.gz: 9a85f485d607f507213ddfc79b09c0f7429364bb
+  data.tar.gz: 3e517d63c5721f56bd5455de3ed62c0d6854581b
 SHA512:
-  metadata.gz: 5512632851857b3fb841d326dfbca46247c7f5d56c5887955ebc380300e1574475f26c50a38935a5c595860240f155d02d7a1f2010af55fb079fe39eca6aa4c8
-  data.tar.gz: 5383e7abf050f611edebd5994196a2631404166db0ae7b0368fb0e2ec462c64bedc73e2c9f28e60d1916e466df95760021a17c4e7512f2f53f04d00eb0a00d85
+  metadata.gz: 3f9ec0589e102f5c9dac662f77fc09cb00fa7878d4a4b9081363db47ab23748c2bef7ee64fab4b3b0425112bb3c8dcb0948ba4d6804c2f88b0cea63de545e699
+  data.tar.gz: 3f72346489f5b5ff2314fcf0c561a27279e57d881db65ee69f4ee8ab9cab74e9e1800c59dc4a1cd527b3e5c59108fcc81d6792665a23d24ec8d5d69cf42c6ad4

data/README.md

@@ -10,6 +10,7 @@ snow-math is a small, fairly simple library of 3D math routines implemented in
 C with Ruby bindings. It's intended for use with OpenGL and such. Currently, it
 provides four 3D math types:
 
+    - Snow::Vec2
     - Snow::Vec3
     - Snow::Vec4
     - Snow::Quat
@@ -29,6 +30,28 @@ Like so:
 
 If you prefer shorter command-line options, `-F` is a synonym for `--use-float`.
 
+All options:
+
+- `--use-float` or `-F` -- Compiles the extension using 32-bit floats instead
+    of 64-bit doubles. This is only really useful if you're concerned about
+    reducing memory usage by math types or don't want the additional precision.
+    You can specify you want doubles by passing `--use-double` or `-NF`, which
+    is essentially a no-op unless it follows a previous argument specifying
+    enabling the use of floats. It is not possible to compile the gem for both
+    types.
+
+- `--debug` or `-D` -- Compiles the extension with debugging symbols. If you
+    want to explicitly indicate that you want a release built (meaning
+    optimization and such), you can pass `--release` or `-ND`
+
+- `--use-fast-math` or `-FM` -- When not compiled for debugging, the extension
+    is built with `-ffast-math` enabled. This may mean that the math code is
+    not entirely IEEE-compliant but may produce slightly faster code. That
+    said, this is generally not a huge benefit and IEEE-compliance is often
+    better than negligible performance improvements in areas that aren't a
+    bottleneck. If you would like to explicitly disable it, you may also pass
+    `--no-fast-math` or `-NFM`.
+
 
 ## Usage
 
@@ -126,20 +149,33 @@ bodies below except where their behaviour is notably different.
     object to the block and returns an object of the same type with the results.
     In the second form, returns an Enumerator.
 
+    Provided by the Snow::ArraySupport module.
+
 - `map!(&block)` and `map!` - Same as the above, but operates on self rather
     than creating a new object.
 
+    Provided by the Snow::ArraySupport module.
+
 - `each(&object)` and `each` - Does what you think it does. Second form returns
     an Enumerator.
 
+    Provided by the Snow::ArraySupport module.
+
 - `to_a` - Returns an array of all components in the given object.
 
+    Provided by the Snow::ArraySupport module.
+
 - `to_ptr` - You have to `require 'snow-math/ptr'` for this. Returns a new
     `Fiddle::Pointer` pointing to the object's address.
 
+    Provided by the Snow::FiddlePointerSupport module.
+
 - `to_s` - Converts the object to a string that looks more or less like
     `"{ fetch(0), fetch(1), ..., fetch(length - 1) }"`.
 
+- `inspect` - does what you think it does. This is provided under the
+    Snow::InspectSupport module.
+
 
 #### Swizzling
 
@@ -149,21 +185,34 @@ that returns a new Vec3 with components Z, Y, and X of the original vector, in
 that order. The components you can use for swizzling on each type are fairly
 obvious but are as follows:
 
+- __Vec2__  
+    Components: X and Y.  
+    Swizzling two components returns a Vec2.  
+    Swizzling three components returns a Vec3.  
+    Swizzling four components returns a Vec4.
+
 - __Vec3__  
     Components: X, Y, and Z.  
+    Swizzling two components returns a Vec2.  
     Swizzling three components returns a Vec3.  
     Swizzling four components returns a Vec4.
 
 - __Vec4__  
     Components: X, Y, Z, and W.  
+    Swizzling two components returns a Vec2.  
     Swizzling three components returns a Vec3.  
     Swizzling four components returns a Vec4.
 
 - __Quat__  
     Components: X, Y, Z, and W.  
+    Swizzling two components returns a Vec2.  
     Swizzling three components returns a Vec3.  
     Swizzling four components returns a Quat.
 
+Swizzling is provided by the Snow::SwizzleSupport module. If you find yourself
+using swizzling heavily and the generated methods aren't peformant enough, it
+might be worth your time to explicitly define the ones you use the most to
+ensure they're not wasting too many cycles for you.
 
 
 ## License

data/ext/snow-math/maths_local.h

@@ -89,6 +89,45 @@ S_INLINE int  float_equals(const s_float_t x, const s_float_t y)
 }
 
 
+/*==============================================================================
+
+  2-Component Vector (vec2_t)
+
+==============================================================================*/
+
+extern const vec2_t g_vec2_zero;
+extern const vec2_t g_vec2_one;
+
+void          vec2_copy(const vec2_t in, vec2_t out);
+void          vec2_set(s_float_t x, s_float_t y, vec2_t v);
+
+/*!
+ * Gets the squared length of a vector.  Useful for approximations and when
+ * you don't need the actual magnitude.
+ */
+s_float_t     vec2_length_squared(const vec2_t v);
+/*!
+ * Gets the length/magnitude of a vector.
+ */
+s_float_t     vec2_length(const vec2_t v);
+void          vec2_normalize(const vec2_t in, vec2_t out);
+
+void          vec2_subtract(const vec2_t left, const vec2_t right, vec2_t out);
+void          vec2_add(const vec2_t left, const vec2_t right, vec2_t out);
+void          vec2_multiply(const vec2_t left, const vec2_t right, vec2_t out);
+void          vec2_negate(const vec2_t v, vec2_t out);
+void          vec2_inverse(const vec2_t v, vec2_t out);
+
+void          vec2_project(const vec2_t in, const vec2_t normal, vec2_t out);
+void          vec2_reflect(const vec2_t in, const vec2_t normal, vec2_t out);
+s_float_t     vec2_dot_product(const vec2_t left, const vec2_t right);
+
+void          vec2_scale(const vec2_t v, s_float_t scalar, vec2_t out);
+int           vec2_divide(const vec2_t v, s_float_t divisor, vec2_t out);
+
+int           vec2_equals(const vec2_t left, const vec2_t right);
+
+
 
 /*==============================================================================
 

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

@@ -8,6 +8,7 @@ See COPYING for license information
 #include "maths_local.h"
 #include "ruby.h"
 
+#define kSM_WANT_TWO_TO_FOUR_FORMAT_LIT ("Expected a Vec2, Vec3, Vec4, or Quat, got %s")
 #define kSM_WANT_THREE_OR_FOUR_FORMAT_LIT ("Expected a Vec3, Vec4, or Quat, got %s")
 #define kSM_WANT_FOUR_FORMAT_LIT ("Expected a Vec4 or Quat, got %s")
 
@@ -95,6 +96,7 @@ static VALUE sm_mathtype_array_length(VALUE sm_self)
 ==============================================================================*/
 
 static VALUE s_sm_snowmath_mod = Qnil;
+static VALUE s_sm_vec2_klass = Qnil;
 static VALUE s_sm_vec3_klass = Qnil;
 static VALUE s_sm_vec4_klass = Qnil;
 static VALUE s_sm_quat_klass = Qnil;
@@ -114,6 +116,8 @@ static VALUE s_sm_mat4_klass = Qnil;
   pass one to another's function. The conversion is easy enough, so it's not a
   huge deal.
 */
+static VALUE    sm_wrap_vec2(const vec2_t value, VALUE klass);
+static vec2_t * sm_unwrap_vec2(VALUE sm_value, vec2_t store);
 static VALUE    sm_wrap_vec3(const vec3_t value, VALUE klass);
 static vec3_t * sm_unwrap_vec3(VALUE sm_value, vec3_t store);
 static VALUE    sm_wrap_vec4(const vec4_t value, VALUE klass);
@@ -135,6 +139,197 @@ static mat4_t * sm_unwrap_mat4(VALUE sm_value, mat4_t store);
 
 #if BUILD_ARRAY_TYPE
 
+/*==============================================================================
+
+  Snow::Vec2Array methods (s_sm_vec2_array_klass)
+
+==============================================================================*/
+
+static VALUE s_sm_vec2_array_klass = Qnil;
+
+/*
+ * In the first form, a new typed array of Vec2 elements is allocated and
+ * returned. In the second form, a copy of a typed array of Vec2 objects is
+ * made and returned. Copied arrays do not share data.
+ *
+ * call-seq:
+ *    new(size)       -> new vec2_array
+ *    new(vec2_array) -> copy of vec2_array
+ */
+static VALUE sm_vec2_array_new(VALUE sm_self, VALUE sm_length_or_copy)
+{
+  size_t length = 0;
+  vec2_t *arr;
+  VALUE sm_type_array;
+  int copy_array = 0;
+  if ((copy_array = SM_IS_A(sm_length_or_copy, vec2_array))) {
+    length = NUM2SIZET(sm_mathtype_array_length(sm_length_or_copy));
+  } else {
+    length = NUM2SIZET(sm_length_or_copy);
+  }
+  if (length <= 0) {
+    return Qnil;
+  }
+  arr = ALLOC_N(vec2_t, length);
+  if (copy_array) {
+    const vec2_t *source;
+    Data_Get_Struct(sm_length_or_copy, vec2_t, source);
+    MEMCPY(arr, source, vec2_t, length);
+    sm_length_or_copy = sm_mathtype_array_length(sm_length_or_copy);
+    sm_self = rb_obj_class(sm_length_or_copy);
+  }
+  sm_type_array = Data_Wrap_Struct(sm_self, 0, free, arr);
+  rb_ivar_set(sm_type_array, kRB_IVAR_MATHARRAY_LENGTH, sm_length_or_copy);
+  rb_ivar_set(sm_type_array, kRB_IVAR_MATHARRAY_CACHE, rb_ary_new2((long)length));
+  rb_obj_call_init(sm_type_array, 0, 0);
+  return sm_type_array;
+}
+
+
+
+/*
+ * Resizes the array to new_length and returns self.
+ *
+ * If resizing to a length smaller than the previous length, excess array
+ * elements are discarded and the array is truncated. Otherwise, when resizing
+ * the array to a greater length than previous, new elements in the array will
+ * contain garbage values.
+ *
+ * If new_length is equal to self.length, the call does nothing to the array.
+ *
+ * Attempting to resize an array to a new length of zero or less will raise a
+ * RangeError. Do not try to resize arrays to zero or less. Do not be that
+ * person.
+ *
+ * call-seq:
+ *    resize!(new_length) -> self
+ */
+static VALUE sm_vec2_array_resize(VALUE sm_self, VALUE sm_new_length)
+{
+  size_t new_length;
+  size_t old_length;
+
+  old_length = NUM2SIZET(sm_mathtype_array_length(sm_self));
+  new_length = NUM2SIZET(sm_new_length);
+
+  if (old_length == new_length) {
+    /* No change, done */
+    return sm_self;
+  } else if (new_length < 1) {
+    /* Someone decided to be that person. */
+    rb_raise(rb_eRangeError,
+      "Cannot resize array to length less than or equal to 0.");
+    return sm_self;
+  }
+
+  REALLOC_N(RDATA(sm_self)->data, vec2_t, new_length);
+  rb_ivar_set(sm_self, kRB_IVAR_MATHARRAY_LENGTH, sm_new_length);
+  rb_ary_clear(rb_ivar_get(sm_self, kRB_IVAR_MATHARRAY_CACHE));
+
+  return sm_self;
+}
+
+
+
+/*
+ * Fetches a Vec2 from the array at the index and returns it. The returned Vec2
+ * may be a cached object. In all cases, values returned from a typed array are
+ * associated with the memory of the array and not given their own memory. So,
+ * modifying a Vec2 fetched from an array modifies the array's data.
+ *
+ * As a result, objects returned by a Vec2Array should not be considered
+ * thread-safe, nor should manipulating a Vec2Array be considered thread-safe
+ * either. If you want to work with data returned from an array without altering
+ * the array data, you should call Vec2#dup or Vec2#copy to get a new Vec2 with a
+ * copy of the array object's data.
+ *
+ * call-seq: fetch(index) -> vec2
+ */
+static VALUE sm_vec2_array_fetch(VALUE sm_self, VALUE sm_index)
+{
+  vec2_t *arr;
+  size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
+  size_t index = NUM2SIZET(sm_index);
+  VALUE sm_inner;
+  VALUE sm_cache;
+  if (index >= length) {
+    rb_raise(rb_eRangeError,
+      "Index %zu out of bounds for array with length %zu",
+      index, length);
+  }
+
+  sm_cache = rb_ivar_get(sm_self, kRB_IVAR_MATHARRAY_CACHE);
+  if (!RTEST(sm_cache)) {
+    rb_raise(rb_eRuntimeError, "No cache available");
+  }
+  sm_inner = rb_ary_entry(sm_cache, (long)index);
+
+  if (!RTEST(sm_inner)) {
+    /* No cached value, create one. */
+    Data_Get_Struct(sm_self, vec2_t, arr);
+    sm_inner = Data_Wrap_Struct(s_sm_vec2_klass, 0, 0, arr[index]);
+    rb_ivar_set(sm_inner, kRB_IVAR_MATHARRAY_SOURCE, sm_self);
+    /* Store the Vec2 in the cache */
+    rb_ary_store(sm_cache, (long)index, sm_inner);
+  }
+
+  return sm_inner;
+}
+
+
+
+/*
+ * Stores a Vec2 at the given index. If the provided Vec2 is a member of the
+ * array and stored at the index, then no copy is done, otherwise the Vec2 is
+ * copied to the array.
+ *
+ * call-seq: store(index, value) -> value
+ */
+static VALUE sm_vec2_array_store(VALUE sm_self, VALUE sm_index, VALUE sm_value)
+{
+  vec2_t *arr;
+  vec2_t *value;
+  size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
+  size_t index = NUM2SIZET(sm_index);
+
+  if (index >= length) {
+    rb_raise(rb_eRangeError,
+      "Index %zu out of bounds for array with length %zu",
+      index, length);
+  } else if (!SM_IS_A(sm_value, vec2) && !SM_IS_A(sm_value, vec3) && !SM_IS_A(sm_value, vec4) && !SM_IS_A(sm_value, quat)) {
+    rb_raise(rb_eTypeError,
+      "Invalid value to store: expected Vec2, Vec3, Vec4, or Quat, got %s",
+      rb_obj_classname(sm_value));
+  }
+
+  Data_Get_Struct(sm_self, vec2_t, arr);
+  value = sm_unwrap_vec2(sm_value, NULL);
+
+  if (value == &arr[index]) {
+    /* The object's part of the array, don't bother copying */
+    return sm_value;
+  }
+
+  vec2_copy(*value, arr[index]);
+  return sm_value;
+}
+
+
+
+/*
+ * Returns the length of the array.
+ *
+ * call-seq: length -> fixnum
+ */
+static VALUE sm_vec2_array_size(VALUE sm_self)
+{
+  size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
+  return SIZET2NUM(length * sizeof(vec2_t));
+}
+
+
+
+
 /*==============================================================================
 
   Snow::Vec3Array methods (s_sm_vec3_array_klass)
@@ -883,220 +1078,950 @@ static VALUE sm_mat3_array_store(VALUE sm_self, VALUE sm_index, VALUE sm_value)
   } else {
     mat4_to_mat3(*sm_unwrap_mat4(sm_value, NULL), arr[index]);
   }
-  return sm_value;
+  return sm_value;
+}
+
+
+
+/*
+ * Returns the length of the array.
+ *
+ * call-seq: length -> fixnum
+ */
+static VALUE sm_mat3_array_size(VALUE sm_self)
+{
+  size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
+  return SIZET2NUM(length * sizeof(mat3_t));
+}
+
+
+
+/*==============================================================================
+
+  Snow::Mat4Array methods (s_sm_mat4_array_klass)
+
+==============================================================================*/
+
+static VALUE s_sm_mat4_array_klass = Qnil;
+
+/*
+ * In the first form, a new typed array of Mat4 elements is allocated and
+ * returned. In the second form, a copy of a typed array of Mat4 objects is
+ * made and returned. Copied arrays do not share data.
+ *
+ * call-seq:
+ *    new(size)       -> new mat4_array
+ *    new(mat4_array) -> copy of mat4_array
+ */
+static VALUE sm_mat4_array_new(VALUE sm_self, VALUE sm_length_or_copy)
+{
+  size_t length = 0;
+  mat4_t *arr;
+  VALUE sm_type_array;
+  int copy_array = 0;
+  if ((copy_array = SM_IS_A(sm_length_or_copy, mat4_array))) {
+    length = NUM2SIZET(sm_mathtype_array_length(sm_length_or_copy));
+  } else {
+    length = NUM2SIZET(sm_length_or_copy);
+  }
+  if (length <= 0) {
+    return Qnil;
+  }
+  arr = ALLOC_N(mat4_t, length);
+  if (copy_array) {
+    const mat4_t *source;
+    Data_Get_Struct(sm_length_or_copy, mat4_t, source);
+    MEMCPY(arr, source, mat4_t, length);
+    sm_length_or_copy = sm_mathtype_array_length(sm_length_or_copy);
+    sm_self = rb_obj_class(sm_length_or_copy);
+  }
+  sm_type_array = Data_Wrap_Struct(sm_self, 0, free, arr);
+  rb_ivar_set(sm_type_array, kRB_IVAR_MATHARRAY_LENGTH, sm_length_or_copy);
+  rb_ivar_set(sm_type_array, kRB_IVAR_MATHARRAY_CACHE, rb_ary_new2((long)length));
+  rb_obj_call_init(sm_type_array, 0, 0);
+  return sm_type_array;
+}
+
+
+
+/*
+ * Resizes the array to new_length and returns self.
+ *
+ * If resizing to a length smaller than the previous length, excess array
+ * elements are discarded and the array is truncated. Otherwise, when resizing
+ * the array to a greater length than previous, new elements in the array will
+ * contain garbage values.
+ *
+ * If new_length is equal to self.length, the call does nothing to the array.
+ *
+ * Attempting to resize an array to a new length of zero or less will raise a
+ * RangeError. Do not try to resize arrays to zero or less. Do not be that
+ * person.
+ *
+ * call-seq:
+ *    resize!(new_length) -> self
+ */
+static VALUE sm_mat4_array_resize(VALUE sm_self, VALUE sm_new_length)
+{
+  size_t new_length;
+  size_t old_length;
+
+  old_length = NUM2SIZET(sm_mathtype_array_length(sm_self));
+  new_length = NUM2SIZET(sm_new_length);
+
+  if (old_length == new_length) {
+    /* No change, done */
+    return sm_self;
+  } else if (new_length < 1) {
+    /* Someone decided to be that person. */
+    rb_raise(rb_eRangeError,
+      "Cannot resize array to length less than or equal to 0.");
+    return sm_self;
+  }
+
+  REALLOC_N(RDATA(sm_self)->data, mat4_t, new_length);
+  rb_ivar_set(sm_self, kRB_IVAR_MATHARRAY_LENGTH, sm_new_length);
+  rb_ary_clear(rb_ivar_get(sm_self, kRB_IVAR_MATHARRAY_CACHE));
+
+  return sm_self;
+}
+
+
+
+/*
+ * Fetches a Mat4 from the array at the index and returns it. The returned Mat4
+ * may be a cached object. In all cases, values returned from a typed array are
+ * associated with the memory of the array and not given their own memory. So,
+ * modifying a Mat4 fetched from an array modifies the array's data.
+ *
+ * As a result, objects returned by a Mat4Array should not be considered
+ * thread-safe, nor should manipulating a Mat4Array be considered thread-safe
+ * either. If you want to work with data returned from an array without altering
+ * the array data, you should call Mat4#dup or Mat4#copy to get a new Mat4 with a
+ * copy of the array object's data.
+ *
+ * call-seq: fetch(index) -> mat4
+ */
+static VALUE sm_mat4_array_fetch(VALUE sm_self, VALUE sm_index)
+{
+  mat4_t *arr;
+  size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
+  size_t index = NUM2SIZET(sm_index);
+  VALUE sm_inner;
+  VALUE sm_cache;
+  if (index >= length) {
+    rb_raise(rb_eRangeError,
+      "Index %zu out of bounds for array with length %zu",
+      index, length);
+  }
+
+  sm_cache = rb_ivar_get(sm_self, kRB_IVAR_MATHARRAY_CACHE);
+  if (!RTEST(sm_cache)) {
+    rb_raise(rb_eRuntimeError, "No cache available");
+  }
+  sm_inner = rb_ary_entry(sm_cache, (long)index);
+
+  if (!RTEST(sm_inner)) {
+    /* No cached value, create one. */
+    Data_Get_Struct(sm_self, mat4_t, arr);
+    sm_inner = Data_Wrap_Struct(s_sm_mat4_klass, 0, 0, arr[index]);
+    rb_ivar_set(sm_inner, kRB_IVAR_MATHARRAY_SOURCE, sm_self);
+    /* Store the Mat4 in the cache */
+    rb_ary_store(sm_cache, (long)index, sm_inner);
+  }
+
+  return sm_inner;
+}
+
+
+
+/*
+ * Stores a Mat4 at the given index. If the provided Mat4 is a member of the
+ * array and stored at the index, then no copy is done, otherwise the Mat4 is
+ * copied to the array.
+ *
+ * If the value stored is a Mat3, it will be converted to a Mat4 for storage,
+ * though this will not modify the value directly.
+ *
+ * call-seq: store(index, value) -> value
+ */
+static VALUE sm_mat4_array_store(VALUE sm_self, VALUE sm_index, VALUE sm_value)
+{
+  mat4_t *arr;
+  size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
+  size_t index = NUM2SIZET(sm_index);
+  int is_mat4 = 0;
+
+  if (index >= length) {
+    rb_raise(rb_eRangeError,
+      "Index %zu out of bounds for array with length %zu",
+      index, length);
+  } else if (!(is_mat4 = SM_IS_A(sm_value, mat4)) && !SM_IS_A(sm_value, mat3)) {
+    rb_raise(rb_eTypeError,
+      "Invalid value to store: expected Mat3 or Mat4, got %s",
+      rb_obj_classname(sm_value));
+  }
+
+  Data_Get_Struct(sm_self, mat4_t, arr);
+
+  if (is_mat4) {
+    mat4_t *value = sm_unwrap_mat4(sm_value, NULL);
+    if (value == &arr[index]) {
+      /* The object's part of the array, don't bother copying */
+      return sm_value;
+    }
+    mat4_copy(*value, arr[index]);
+  } else {
+    mat3_to_mat4(*sm_unwrap_mat3(sm_value, NULL), arr[index]);
+  }
+  return sm_value;
+}
+
+
+
+/*
+ * Returns the length of the array.
+ *
+ * call-seq: length -> fixnum
+ */
+static VALUE sm_mat4_array_size(VALUE sm_self)
+{
+  size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
+  return SIZET2NUM(length * sizeof(mat4_t));
+}
+
+
+#endif /* BUILD_ARRAY_TYPE */
+
+
+
+/*==============================================================================
+
+  vec2_t functions
+
+==============================================================================*/
+
+static VALUE sm_wrap_vec2(const vec2_t value, VALUE klass)
+{
+  vec2_t *copy;
+  VALUE sm_wrapped = Qnil;
+  if (!RTEST(klass)) {
+    klass = s_sm_vec2_klass;
+  }
+  sm_wrapped = Data_Make_Struct(klass, vec2_t, 0, free, copy);
+  if (value) {
+    vec2_copy(value, *copy);
+  }
+  return sm_wrapped;
+}
+
+
+
+static vec2_t *sm_unwrap_vec2(VALUE sm_value, vec2_t store)
+{
+  vec2_t *value;
+  Data_Get_Struct(sm_value, vec2_t, value);
+  if(store) vec2_copy(*value, store);
+  return value;
+}
+
+
+
+/*
+ * Gets the component of the Vec2 at the given index.
+ *
+ * call-seq: fetch(index) -> float
+ */
+static VALUE sm_vec2_fetch (VALUE sm_self, VALUE sm_index)
+{
+  static const int max_index = sizeof(vec2_t) / sizeof(s_float_t);
+  const vec2_t *self = sm_unwrap_vec2(sm_self, NULL);
+  int index = NUM2INT(sm_index);
+  if (index < 0 || index >= max_index) {
+    rb_raise(rb_eRangeError,
+      "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
+  }
+  return rb_float_new(self[0][NUM2INT(sm_index)]);
+}
+
+
+
+/*
+ * Sets the Vec2's component at the index to the value.
+ *
+ * call-seq: store(index, value) -> value
+ */
+static VALUE sm_vec2_store (VALUE sm_self, VALUE sm_index, VALUE sm_value)
+{
+  static const int max_index = sizeof(vec2_t) / sizeof(s_float_t);
+  vec2_t *self = sm_unwrap_vec2(sm_self, NULL);
+  int index = NUM2INT(sm_index);
+  if (index < 0 || index >= max_index) {
+    rb_raise(rb_eRangeError,
+      "Index %d is out of bounds, must be from 0 through %d", index, max_index - 1);
+  }
+  self[0][index] = (s_float_t)rb_num2dbl(sm_value);
+  return sm_value;
+}
+
+
+
+/*
+ * Returns the length in bytes of the Vec2. When compiled to use doubles as the
+ * base type, this is always 16. Otherwise, when compiled to use floats, it's
+ * always 8.
+ *
+ * call-seq: size -> fixnum
+ */
+static VALUE sm_vec2_size (VALUE self)
+{
+  return SIZET2NUM(sizeof(vec2_t));
+}
+
+
+
+/*
+ * Returns the length of the Vec2 in components. Result is always 2.
+ *
+ * call-seq: length -> fixnum
+ */
+static VALUE sm_vec2_length (VALUE self)
+{
+  return SIZET2NUM(sizeof(vec2_t) / sizeof(s_float_t));
+}
+
+
+
+/*
+ * Returns a copy of self.
+ *
+ * call-seq:
+ *    copy(output = nil) -> output or new vec2
+ */
+ static VALUE sm_vec2_copy(int argc, VALUE *argv, VALUE sm_self)
+ {
+   VALUE sm_out;
+   vec2_t *self;
+   rb_scan_args(argc, argv, "01", &sm_out);
+   self = sm_unwrap_vec2(sm_self, NULL);
+   if (argc == 1) {
+     if (!RTEST(sm_out)) {
+       goto SM_LABEL(skip_output);
+     }{
+     if (!SM_IS_A(sm_out, vec2) && !SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+       rb_raise(rb_eTypeError,
+         kSM_WANT_TWO_TO_FOUR_FORMAT_LIT,
+         rb_obj_classname(sm_out));
+       return Qnil;
+     }
+     vec2_t *output = sm_unwrap_vec2(sm_out, NULL);
+     vec2_copy (*self, *output);
+   }} else if (argc == 0) {
+ SM_LABEL(skip_output): {
+     vec2_t output;
+     vec2_copy (*self, output);
+     sm_out = sm_wrap_vec2(output, rb_obj_class(sm_self));
+     rb_obj_call_init(sm_out, 0, 0);
+   }} else {
+     rb_raise(rb_eArgError, "Invalid number of arguments to copy");
+   }
+   return sm_out;
+ }
+
+
+
+/*
+ * Returns a vector whose components are the multiplicative inverse of this
+ * vector's.
+ *
+ * call-seq:
+ *    normalize(output = nil) -> output or new vec2
+ */
+ static VALUE sm_vec2_normalize(int argc, VALUE *argv, VALUE sm_self)
+ {
+   VALUE sm_out;
+   vec2_t *self;
+   rb_scan_args(argc, argv, "01", &sm_out);
+   self = sm_unwrap_vec2(sm_self, NULL);
+   if (argc == 1) {
+     if (!RTEST(sm_out)) {
+       goto SM_LABEL(skip_output);
+     }{
+     if (!SM_IS_A(sm_out, vec2) && !SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+       rb_raise(rb_eTypeError,
+         kSM_WANT_TWO_TO_FOUR_FORMAT_LIT,
+         rb_obj_classname(sm_out));
+       return Qnil;
+     }
+     vec2_t *output = sm_unwrap_vec2(sm_out, NULL);
+     vec2_normalize (*self, *output);
+   }} else if (argc == 0) {
+ SM_LABEL(skip_output): {
+     vec2_t output;
+     vec2_normalize (*self, output);
+     sm_out = sm_wrap_vec2(output, rb_obj_class(sm_self));
+     rb_obj_call_init(sm_out, 0, 0);
+   }} else {
+     rb_raise(rb_eArgError, "Invalid number of arguments to normalize");
+   }
+   return sm_out;
+ }
+
+
+
+/*
+ * Returns a vector whose components are the multiplicative inverse of this
+ * vector's.
+ *
+ * call-seq:
+ *    inverse(output = nil) -> output or new vec2
+ */
+ static VALUE sm_vec2_inverse(int argc, VALUE *argv, VALUE sm_self)
+ {
+   VALUE sm_out;
+   vec2_t *self;
+   rb_scan_args(argc, argv, "01", &sm_out);
+   self = sm_unwrap_vec2(sm_self, NULL);
+   if (argc == 1) {
+     if (!RTEST(sm_out)) {
+       goto SM_LABEL(skip_output);
+     }{
+     if (!SM_IS_A(sm_out, vec2) && !SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+       rb_raise(rb_eTypeError,
+         kSM_WANT_TWO_TO_FOUR_FORMAT_LIT,
+         rb_obj_classname(sm_out));
+       return Qnil;
+     }
+     vec2_t *output = sm_unwrap_vec2(sm_out, NULL);
+     vec2_inverse (*self, *output);
+   }} else if (argc == 0) {
+ SM_LABEL(skip_output): {
+     vec2_t output;
+     vec2_inverse (*self, output);
+     sm_out = sm_wrap_vec2(output, rb_obj_class(sm_self));
+     rb_obj_call_init(sm_out, 0, 0);
+   }} else {
+     rb_raise(rb_eArgError, "Invalid number of arguments to inverse");
+   }
+   return sm_out;
+ }
+
+
+
+/*
+ * Negates this vector's components and returns the result.
+ *
+ * call-seq:
+ *    negate(output = nil) -> output or new vec2
+ */
+ static VALUE sm_vec2_negate(int argc, VALUE *argv, VALUE sm_self)
+ {
+   VALUE sm_out;
+   vec2_t *self;
+   rb_scan_args(argc, argv, "01", &sm_out);
+   self = sm_unwrap_vec2(sm_self, NULL);
+   if (argc == 1) {
+     if (!RTEST(sm_out)) {
+       goto SM_LABEL(skip_output);
+     }{
+     if (!SM_IS_A(sm_out, vec2) && !SM_IS_A(sm_out, vec2) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+       rb_raise(rb_eTypeError,
+         kSM_WANT_TWO_TO_FOUR_FORMAT_LIT,
+         rb_obj_classname(sm_out));
+       return Qnil;
+     }
+     vec2_t *output = sm_unwrap_vec2(sm_out, NULL);
+     vec2_negate (*self, *output);
+   }} else if (argc == 0) {
+ SM_LABEL(skip_output): {
+     vec2_t output;
+     vec2_negate (*self, output);
+     sm_out = sm_wrap_vec2(output, rb_obj_class(sm_self));
+     rb_obj_call_init(sm_out, 0, 0);
+   }} else {
+     rb_raise(rb_eArgError, "Invalid number of arguments to negate");
+   }
+   return sm_out;
+ }
+
+
+
+/*
+ * Projects this vector onto a normal vector and returns the result.
+ *
+ * call-seq:
+ *    project(normal, output = nil) -> output or new vec2
+ */
+static VALUE sm_vec2_project(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_rhs;
+  VALUE sm_out;
+  vec2_t *self;
+  vec2_t *rhs;
+  rb_scan_args(argc, argv, "11", &sm_rhs, &sm_out);
+  self = sm_unwrap_vec2(sm_self, NULL);
+  if (!SM_IS_A(sm_rhs, vec2) && !SM_IS_A(sm_rhs, vec3) && !SM_IS_A(sm_rhs, vec4) && !SM_IS_A(sm_rhs, quat)) {
+    rb_raise(rb_eTypeError,
+      kSM_WANT_TWO_TO_FOUR_FORMAT_LIT,
+      rb_obj_classname(sm_rhs));
+    return Qnil;
+  }
+  rhs = sm_unwrap_vec2(sm_rhs, NULL);
+  if (argc == 2) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    if (!SM_IS_A(sm_out, vec2) && !SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+      rb_raise(rb_eTypeError,
+        kSM_WANT_TWO_TO_FOUR_FORMAT_LIT,
+        rb_obj_classname(sm_out));
+      return Qnil;
+    }
+    vec2_t *output = sm_unwrap_vec2(sm_out, NULL);
+    vec2_project(*self, *rhs, *output);
+  }} else if (argc == 1) {
+SM_LABEL(skip_output): {
+    vec2_t output;
+    vec2_project(*self, *rhs, output);
+    sm_out = sm_wrap_vec2(output, rb_obj_class(sm_self));
+    rb_obj_call_init(sm_out, 0, 0);
+  }} else {
+    rb_raise(rb_eArgError, "Invalid number of arguments to project");
+  }
+  return sm_out;
+}
+
+
+
+/*
+ * Reflects this vector against a normal vector and returns the result.
+ *
+ * call-seq:
+ *    reflect(normal, output = nil) -> output or new vec2
+ */
+static VALUE sm_vec2_reflect(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_rhs;
+  VALUE sm_out;
+  vec2_t *self;
+  vec2_t *rhs;
+  rb_scan_args(argc, argv, "11", &sm_rhs, &sm_out);
+  self = sm_unwrap_vec2(sm_self, NULL);
+  if (!SM_IS_A(sm_rhs, vec2) && !SM_IS_A(sm_rhs, vec3) && !SM_IS_A(sm_rhs, vec4) && !SM_IS_A(sm_rhs, quat)) {
+    rb_raise(rb_eTypeError,
+      kSM_WANT_TWO_TO_FOUR_FORMAT_LIT,
+      rb_obj_classname(sm_rhs));
+    return Qnil;
+  }
+  rhs = sm_unwrap_vec2(sm_rhs, NULL);
+  if (argc == 2) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    if (!SM_IS_A(sm_out, vec2) && !SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+      rb_raise(rb_eTypeError,
+        kSM_WANT_TWO_TO_FOUR_FORMAT_LIT,
+        rb_obj_classname(sm_out));
+      return Qnil;
+    }
+    vec2_t *output = sm_unwrap_vec2(sm_out, NULL);
+    vec2_reflect(*self, *rhs, *output);
+  }} else if (argc == 1) {
+SM_LABEL(skip_output): {
+    vec2_t output;
+    vec2_reflect(*self, *rhs, output);
+    sm_out = sm_wrap_vec2(output, rb_obj_class(sm_self));
+    rb_obj_call_init(sm_out, 0, 0);
+  }} else {
+    rb_raise(rb_eArgError, "Invalid number of arguments to reflect");
+  }
+  return sm_out;
+}
+
+
+
+/*
+ * Multiplies this and another vector's components together and returns the
+ * result.
+ *
+ * call-seq:
+ *    multiply_vec2(vec2, output = nil) -> output or new vec2
+ */
+static VALUE sm_vec2_multiply(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_rhs;
+  VALUE sm_out;
+  vec2_t *self;
+  vec2_t *rhs;
+  rb_scan_args(argc, argv, "11", &sm_rhs, &sm_out);
+  self = sm_unwrap_vec2(sm_self, NULL);
+  if (!SM_IS_A(sm_rhs, vec2) && !SM_IS_A(sm_rhs, vec3) && !SM_IS_A(sm_rhs, vec4) && !SM_IS_A(sm_rhs, quat)) {
+    rb_raise(rb_eTypeError,
+      kSM_WANT_TWO_TO_FOUR_FORMAT_LIT,
+      rb_obj_classname(sm_rhs));
+    return Qnil;
+  }
+  rhs = sm_unwrap_vec2(sm_rhs, NULL);
+  if (argc == 2) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    if (!SM_IS_A(sm_out, vec2) && !SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+      rb_raise(rb_eTypeError,
+        kSM_WANT_TWO_TO_FOUR_FORMAT_LIT,
+        rb_obj_classname(sm_out));
+      return Qnil;
+    }
+    vec2_t *output = sm_unwrap_vec2(sm_out, NULL);
+    vec2_multiply(*self, *rhs, *output);
+  }} else if (argc == 1) {
+SM_LABEL(skip_output): {
+    vec2_t output;
+    vec2_multiply(*self, *rhs, output);
+    sm_out = sm_wrap_vec2(output, rb_obj_class(sm_self));
+    rb_obj_call_init(sm_out, 0, 0);
+  }} else {
+    rb_raise(rb_eArgError, "Invalid number of arguments to multiply");
+  }
+  return sm_out;
+}
+
+
+
+/*
+ * Adds this and another vector's components together and returns the result.
+ *
+ * call-seq:
+ *    add(vec2, output = nil) -> output or new vec2
+ */
+static VALUE sm_vec2_add(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_rhs;
+  VALUE sm_out;
+  vec2_t *self;
+  vec2_t *rhs;
+  rb_scan_args(argc, argv, "11", &sm_rhs, &sm_out);
+  self = sm_unwrap_vec2(sm_self, NULL);
+  if (!SM_IS_A(sm_rhs, vec2) && !SM_IS_A(sm_rhs, vec3) && !SM_IS_A(sm_rhs, vec4) && !SM_IS_A(sm_rhs, quat)) {
+    rb_raise(rb_eTypeError,
+      kSM_WANT_TWO_TO_FOUR_FORMAT_LIT,
+      rb_obj_classname(sm_rhs));
+    return Qnil;
+  }
+  rhs = sm_unwrap_vec2(sm_rhs, NULL);
+  if (argc == 2) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    if (!SM_IS_A(sm_out, vec2) && !SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+      rb_raise(rb_eTypeError,
+        kSM_WANT_TWO_TO_FOUR_FORMAT_LIT,
+        rb_obj_classname(sm_out));
+      return Qnil;
+    }
+    vec2_t *output = sm_unwrap_vec2(sm_out, NULL);
+    vec2_add(*self, *rhs, *output);
+  }} else if (argc == 1) {
+SM_LABEL(skip_output): {
+    vec2_t output;
+    vec2_add(*self, *rhs, output);
+    sm_out = sm_wrap_vec2(output, rb_obj_class(sm_self));
+    rb_obj_call_init(sm_out, 0, 0);
+  }} else {
+    rb_raise(rb_eArgError, "Invalid number of arguments to add");
+  }
+  return sm_out;
+}
+
+
+
+/*
+ * Subtracts another vector's components from this vector's and returns the
+ * result.
+ *
+ * call-seq:
+ *    subtract(vec2, output = nil) -> output or new vec2
+ */
+static VALUE sm_vec2_subtract(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_rhs;
+  VALUE sm_out;
+  vec2_t *self;
+  vec2_t *rhs;
+  rb_scan_args(argc, argv, "11", &sm_rhs, &sm_out);
+  self = sm_unwrap_vec2(sm_self, NULL);
+  if (!SM_IS_A(sm_rhs, vec2) && !SM_IS_A(sm_rhs, vec3) && !SM_IS_A(sm_rhs, vec4) && !SM_IS_A(sm_rhs, quat)) {
+    rb_raise(rb_eTypeError,
+      kSM_WANT_TWO_TO_FOUR_FORMAT_LIT,
+      rb_obj_classname(sm_rhs));
+    return Qnil;
+  }
+  rhs = sm_unwrap_vec2(sm_rhs, NULL);
+  if (argc == 2) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    if (!SM_IS_A(sm_out, vec2) && !SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+      rb_raise(rb_eTypeError,
+        kSM_WANT_TWO_TO_FOUR_FORMAT_LIT,
+        rb_obj_classname(sm_out));
+      return Qnil;
+    }
+    vec2_t *output = sm_unwrap_vec2(sm_out, NULL);
+    vec2_subtract(*self, *rhs, *output);
+  }} else if (argc == 1) {
+SM_LABEL(skip_output): {
+    vec2_t output;
+    vec2_subtract(*self, *rhs, output);
+    sm_out = sm_wrap_vec2(output, rb_obj_class(sm_self));
+    rb_obj_call_init(sm_out, 0, 0);
+  }} else {
+    rb_raise(rb_eArgError, "Invalid number of arguments to subtract");
+  }
+  return sm_out;
+}
+
+
+
+/*
+ * Returns the dot product of this and another Vec2 or the XY components of a
+ * Vec3, Vec4, or Quat.
+ *
+ * call-seq:
+ *    dot_product(vec2) -> float
+ *    dot_product(vec3) -> float
+ *    dot_product(vec4) -> float
+ *    dot_product(quat) -> float
+ */
+static VALUE sm_vec2_dot_product(VALUE sm_self, VALUE sm_other)
+{
+  if (!SM_IS_A(sm_other, vec2) &&
+      !SM_IS_A(sm_other, vec3) &&
+      !SM_IS_A(sm_other, vec4) &&
+      !SM_IS_A(sm_other, quat)) {
+    rb_raise(rb_eArgError,
+      "Expected a Vec2, Vec3, Vec4, or Quat, got %s",
+      rb_obj_classname(sm_other));
+    return Qnil;
+  }
+  return rb_float_new(
+    vec2_dot_product(
+      *sm_unwrap_vec2(sm_self, NULL),
+      *sm_unwrap_vec2(sm_other, NULL)));
 }
 
 
 
 /*
- * Returns the length of the array.
+ * Allocates a Vec2.
  *
- * call-seq: length -> fixnum
+ * call-seq:
+ *    new()          -> vec2 with components [0, 0]
+ *    new(x, y)      -> vec2 with components [x, y]
+ *    new([x, y])    -> vec2 with components [x, y]
+ *    new(vec2)      -> copy of vec3
+ *    new(vec3)      -> vec2 of vec3's x and y components
+ *    new(vec4)      -> vec2 of vec4's x and y components
+ *    new(quat)      -> vec2 of quat's x and y components
  */
-static VALUE sm_mat3_array_size(VALUE sm_self)
+static VALUE sm_vec2_new(int argc, VALUE *argv, VALUE self)
 {
-  size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
-  return SIZET2NUM(length * sizeof(mat3_t));
+  VALUE sm_vec = sm_wrap_vec2(g_vec2_zero, self);
+  rb_obj_call_init(sm_vec, argc, argv);
+  return sm_vec;
 }
 
 
 
-/*==============================================================================
-
-  Snow::Mat4Array methods (s_sm_mat4_array_klass)
-
-==============================================================================*/
-
-static VALUE s_sm_mat4_array_klass = Qnil;
-
 /*
- * In the first form, a new typed array of Mat4 elements is allocated and
- * returned. In the second form, a copy of a typed array of Mat4 objects is
- * made and returned. Copied arrays do not share data.
+ * Sets the Vec2's components.
  *
  * call-seq:
- *    new(size)       -> new mat4_array
- *    new(mat4_array) -> copy of mat4_array
+ *    set(x, y)      -> vec2 with components [x, y]
+ *    set([x, y])    -> vec2 with components [x, y]
+ *    set(vec2)      -> copy of vec2
+ *    set(vec3)      -> vec2 with components [vec3.xy]
+ *    set(vec4)      -> vec2 with components [vec4.xy]
+ *    set(quat)      -> vec2 with components [quat.xy]
  */
-static VALUE sm_mat4_array_new(VALUE sm_self, VALUE sm_length_or_copy)
+static VALUE sm_vec2_init(int argc, VALUE *argv, VALUE sm_self)
 {
-  size_t length = 0;
-  mat4_t *arr;
-  VALUE sm_type_array;
-  int copy_array = 0;
-  if ((copy_array = SM_IS_A(sm_length_or_copy, mat4_array))) {
-    length = NUM2SIZET(sm_mathtype_array_length(sm_length_or_copy));
-  } else {
-    length = NUM2SIZET(sm_length_or_copy);
-  }
-  if (length <= 0) {
-    return Qnil;
+  vec2_t *self = sm_unwrap_vec2(sm_self, NULL);
+  size_t arr_index = 0;
+
+  switch(argc) {
+
+  // Default value
+  case 0: { break; }
+
+  // Copy or by-array
+  case 1: {
+    if (SM_IS_A(argv[0], vec2) ||
+        SM_IS_A(argv[0], vec3) ||
+        SM_IS_A(argv[0], vec4) ||
+        SM_IS_A(argv[0], quat)) {
+      sm_unwrap_vec2(argv[0], *self);
+      break;
+    }
+
+    // Optional offset into array provided
+    if (0) {
+      case 2:
+      if (!SM_RB_IS_A(argv[0], rb_cArray)) {
+        self[0][0] = (s_float_t)rb_num2dbl(argv[0]);
+        self[0][1] = (s_float_t)rb_num2dbl(argv[1]);
+        break;
+      }
+      arr_index = NUM2SIZET(argv[1]);
+    }
+
+    // Array of values
+    VALUE arrdata = argv[0];
+    const size_t arr_end = arr_index + 2;
+    s_float_t *vec_elem = *self;
+    for (; arr_index < arr_end; ++arr_index, ++vec_elem) {
+      *vec_elem = (s_float_t)rb_num2dbl(rb_ary_entry(arrdata, (long)arr_index));
+    }
+    break;
   }
-  arr = ALLOC_N(mat4_t, length);
-  if (copy_array) {
-    const mat4_t *source;
-    Data_Get_Struct(sm_length_or_copy, mat4_t, source);
-    MEMCPY(arr, source, mat4_t, length);
-    sm_length_or_copy = sm_mathtype_array_length(sm_length_or_copy);
-    sm_self = rb_obj_class(sm_length_or_copy);
+
+  default: {
+    rb_raise(rb_eArgError, "Invalid arguments to initialize/set");
+    break;
   }
-  sm_type_array = Data_Wrap_Struct(sm_self, 0, free, arr);
-  rb_ivar_set(sm_type_array, kRB_IVAR_MATHARRAY_LENGTH, sm_length_or_copy);
-  rb_ivar_set(sm_type_array, kRB_IVAR_MATHARRAY_CACHE, rb_ary_new2((long)length));
-  rb_obj_call_init(sm_type_array, 0, 0);
-  return sm_type_array;
+  } // switch (argc)
+
+  return sm_self;
 }
 
 
 
 /*
- * Resizes the array to new_length and returns self.
- *
- * If resizing to a length smaller than the previous length, excess array
- * elements are discarded and the array is truncated. Otherwise, when resizing
- * the array to a greater length than previous, new elements in the array will
- * contain garbage values.
- *
- * If new_length is equal to self.length, the call does nothing to the array.
+ * Returns a string representation of self.
  *
- * Attempting to resize an array to a new length of zero or less will raise a
- * RangeError. Do not try to resize arrays to zero or less. Do not be that
- * person.
+ *    Vec2[].to_s     # => "{ 0.0, 0.0 }"
  *
  * call-seq:
- *    resize!(new_length) -> self
+ *    to_s -> string
  */
-static VALUE sm_mat4_array_resize(VALUE sm_self, VALUE sm_new_length)
+static VALUE sm_vec2_to_s(VALUE self)
 {
-  size_t new_length;
-  size_t old_length;
-
-  old_length = NUM2SIZET(sm_mathtype_array_length(sm_self));
-  new_length = NUM2SIZET(sm_new_length);
+  const s_float_t *v;
+  v = (const s_float_t *)*sm_unwrap_vec2(self, NULL);
+  return rb_sprintf(
+    "{ "
+    "%f, %f"
+    " }",
+    v[0], v[1]);
+}
 
-  if (old_length == new_length) {
-    /* No change, done */
-    return sm_self;
-  } else if (new_length < 1) {
-    /* Someone decided to be that person. */
-    rb_raise(rb_eRangeError,
-      "Cannot resize array to length less than or equal to 0.");
-    return sm_self;
-  }
 
-  REALLOC_N(RDATA(sm_self)->data, mat4_t, new_length);
-  rb_ivar_set(sm_self, kRB_IVAR_MATHARRAY_LENGTH, sm_new_length);
-  rb_ary_clear(rb_ivar_get(sm_self, kRB_IVAR_MATHARRAY_CACHE));
 
-  return sm_self;
+/*
+ * Returns the squared magnitude of self.
+ *
+ * call-seq:
+ *    magnitude_squared -> float
+ */
+static VALUE sm_vec2_magnitude_squared(VALUE sm_self)
+{
+  return rb_float_new(vec2_length_squared(*sm_unwrap_vec2(sm_self, NULL)));
 }
 
 
 
 /*
- * Fetches a Mat4 from the array at the index and returns it. The returned Mat4
- * may be a cached object. In all cases, values returned from a typed array are
- * associated with the memory of the array and not given their own memory. So,
- * modifying a Mat4 fetched from an array modifies the array's data.
+ * Returns the magnitude of self.
  *
- * As a result, objects returned by a Mat4Array should not be considered
- * thread-safe, nor should manipulating a Mat4Array be considered thread-safe
- * either. If you want to work with data returned from an array without altering
- * the array data, you should call Mat4#dup or Mat4#copy to get a new Mat4 with a
- * copy of the array object's data.
+ * call-seq:
+ *    magnitude -> float
+ */
+static VALUE sm_vec2_magnitude(VALUE sm_self)
+{
+  return rb_float_new(vec2_length(*sm_unwrap_vec2(sm_self, NULL)));
+}
+
+
+
+/*
+ * Scales this vector's components by a scalar value and returns the result.
  *
- * call-seq: fetch(index) -> mat4
+ * call-seq:
+ *    scale(scalar, output = nil) -> output or new vec2
  */
-static VALUE sm_mat4_array_fetch(VALUE sm_self, VALUE sm_index)
+static VALUE sm_vec2_scale(int argc, VALUE *argv, VALUE sm_self)
 {
-  mat4_t *arr;
-  size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
-  size_t index = NUM2SIZET(sm_index);
-  VALUE sm_inner;
-  VALUE sm_cache;
-  if (index >= length) {
-    rb_raise(rb_eRangeError,
-      "Index %zu out of bounds for array with length %zu",
-      index, length);
-  }
+  VALUE sm_out;
+  VALUE sm_scalar;
+  s_float_t scalar;
+  vec2_t *self = sm_unwrap_vec2(sm_self, NULL);
 
-  sm_cache = rb_ivar_get(sm_self, kRB_IVAR_MATHARRAY_CACHE);
-  if (!RTEST(sm_cache)) {
-    rb_raise(rb_eRuntimeError, "No cache available");
-  }
-  sm_inner = rb_ary_entry(sm_cache, (long)index);
+  rb_scan_args(argc, argv, "11", &sm_scalar, &sm_out);
+  scalar = rb_num2dbl(sm_scalar);
 
-  if (!RTEST(sm_inner)) {
-    /* No cached value, create one. */
-    Data_Get_Struct(sm_self, mat4_t, arr);
-    sm_inner = Data_Wrap_Struct(s_sm_mat4_klass, 0, 0, arr[index]);
-    rb_ivar_set(sm_inner, kRB_IVAR_MATHARRAY_SOURCE, sm_self);
-    /* Store the Mat4 in the cache */
-    rb_ary_store(sm_cache, (long)index, sm_inner);
+  if (SM_IS_A(sm_out, vec2) || SM_IS_A(sm_out, vec3) || SM_IS_A(sm_out, vec4) || SM_IS_A(sm_out, quat)) {
+    vec2_scale(*self, scalar, *sm_unwrap_vec2(sm_out, NULL));
+  } else {
+    vec2_t out;
+    vec2_scale(*self, scalar, out);
+    sm_out = sm_wrap_vec2(out, rb_obj_class(sm_self));
+    rb_obj_call_init(sm_out, 0, 0);
   }
 
-  return sm_inner;
+  return sm_out;
 }
 
 
 
 /*
- * Stores a Mat4 at the given index. If the provided Mat4 is a member of the
- * array and stored at the index, then no copy is done, otherwise the Mat4 is
- * copied to the array.
- *
- * If the value stored is a Mat3, it will be converted to a Mat4 for storage,
- * though this will not modify the value directly.
+ * Divides this vector's components by a scalar value and returns the result.
  *
- * call-seq: store(index, value) -> value
+ * call-seq:
+ *    divide(scalar, output = nil) -> output or new vec2
  */
-static VALUE sm_mat4_array_store(VALUE sm_self, VALUE sm_index, VALUE sm_value)
+static VALUE sm_vec2_divide(int argc, VALUE *argv, VALUE sm_self)
 {
-  mat4_t *arr;
-  size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
-  size_t index = NUM2SIZET(sm_index);
-  int is_mat4 = 0;
-
-  if (index >= length) {
-    rb_raise(rb_eRangeError,
-      "Index %zu out of bounds for array with length %zu",
-      index, length);
-  } else if (!(is_mat4 = SM_IS_A(sm_value, mat4)) && !SM_IS_A(sm_value, mat3)) {
-    rb_raise(rb_eTypeError,
-      "Invalid value to store: expected Mat3 or Mat4, got %s",
-      rb_obj_classname(sm_value));
-  }
+  VALUE sm_out;
+  VALUE sm_scalar;
+  s_float_t scalar;
+  vec2_t *self = sm_unwrap_vec2(sm_self, NULL);
 
-  Data_Get_Struct(sm_self, mat4_t, arr);
+  rb_scan_args(argc, argv, "11", &sm_scalar, &sm_out);
+  scalar = rb_num2dbl(sm_scalar);
 
-  if (is_mat4) {
-    mat4_t *value = sm_unwrap_mat4(sm_value, NULL);
-    if (value == &arr[index]) {
-      /* The object's part of the array, don't bother copying */
-      return sm_value;
-    }
-    mat4_copy(*value, arr[index]);
+  if (SM_IS_A(sm_out, vec2) || SM_IS_A(sm_out, vec3) || SM_IS_A(sm_out, vec4) || SM_IS_A(sm_out, quat)) {
+    vec2_divide(*self, scalar, *sm_unwrap_vec2(sm_out, NULL));
   } else {
-    mat3_to_mat4(*sm_unwrap_mat3(sm_value, NULL), arr[index]);
+    vec2_t out;
+    vec2_divide(*self, scalar, out);
+    sm_out = sm_wrap_vec2(out, rb_obj_class(sm_self));
+    rb_obj_call_init(sm_out, 0, 0);
   }
-  return sm_value;
+
+  return sm_out;
 }
 
 
 
 /*
- * Returns the length of the array.
+ * Tests whether a Vec2 is equivalent to another Vec2, a Vec3, Vec4, or a Quat.
+ * When testing for equivalency against 4-component objects, only the first two
+ * components are compared.
  *
- * call-seq: length -> fixnum
+ * call-seq:
+ *    vec2 == other_vec2 -> bool
+ *    vec2 == vec3       -> bool
+ *    vec2 == vec4       -> bool
+ *    vec2 == quat       -> bool
  */
-static VALUE sm_mat4_array_size(VALUE sm_self)
+static VALUE sm_vec2_equals(VALUE sm_self, VALUE sm_other)
 {
-  size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
-  return SIZET2NUM(length * sizeof(mat4_t));
-}
-
+  if (!RTEST(sm_other) || (!SM_IS_A(sm_other, vec2) && !SM_IS_A(sm_other, vec3) && !SM_IS_A(sm_other, vec4) && !SM_IS_A(sm_other, quat))) {
+    return Qfalse;
+  }
 
-#endif /* BUILD_ARRAY_TYPE */
+  return vec2_equals(*sm_unwrap_vec2(sm_self, NULL), *sm_unwrap_vec2(sm_other, NULL)) ? Qtrue : Qfalse;
+}
 
 
 
@@ -1391,7 +2316,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec3(output, rb_obj_class(sm_self));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec3");
+    rb_raise(rb_eArgError, "Invalid number of arguments to project");
   }
   return sm_out;
 }
@@ -1438,7 +2363,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec3(output, rb_obj_class(sm_self));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec3");
+    rb_raise(rb_eArgError, "Invalid number of arguments to reflect");
   }
   return sm_out;
 }
@@ -1485,7 +2410,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec3(output, rb_obj_class(sm_self));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec3");
+    rb_raise(rb_eArgError, "Invalid number of arguments to cross_product");
   }
   return sm_out;
 }
@@ -1497,7 +2422,7 @@ SM_LABEL(skip_output): {
  * result.
  *
  * call-seq:
- *    multiply(vec3, output = nil) -> output or new vec3
+ *    multiply_vec3(vec3, output = nil) -> output or new vec3
  */
 static VALUE sm_vec3_multiply(int argc, VALUE *argv, VALUE sm_self)
 {
@@ -1533,7 +2458,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec3(output, rb_obj_class(sm_self));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec3");
+    rb_raise(rb_eArgError, "Invalid number of arguments to multiply_vec3");
   }
   return sm_out;
 }
@@ -1580,7 +2505,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec3(output, rb_obj_class(sm_self));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec3");
+    rb_raise(rb_eArgError, "Invalid number of arguments to add");
   }
   return sm_out;
 }
@@ -1628,7 +2553,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec3(output, rb_obj_class(sm_self));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec3");
+    rb_raise(rb_eArgError, "Invalid number of arguments to subtract");
   }
   return sm_out;
 }
@@ -1688,9 +2613,10 @@ static VALUE sm_vec3_new(int argc, VALUE *argv, VALUE self)
  * call-seq:
  *    set(x, y, z)   -> vec3 with components [x, y, z]
  *    set([x, y, z]) -> vec3 with components [x, y, z]
+ *    set(vec2)      -> vec3 with components [vec2.xy, 0]
  *    set(vec3)      -> copy of vec3
- *    set(vec4)      -> vec3 of vec4's x, y, and z components
- *    set(quat)      -> vec3 of quat's x, y, and z components
+ *    set(vec4)      -> vec3 with components [vec4.xyz]
+ *    set(quat)      -> vec3 with components [quat.xyz]
  */
 static VALUE sm_vec3_init(int argc, VALUE *argv, VALUE sm_self)
 {
@@ -1711,6 +2637,12 @@ static VALUE sm_vec3_init(int argc, VALUE *argv, VALUE sm_self)
       break;
     }
 
+    if (SM_IS_A(argv[0], vec2)) {
+      sm_unwrap_vec2(argv[0], *self);
+      self[0][2] = s_float_lit(0.0);
+      break;
+    }
+
     // Optional offset into array provided
     if (0) {
       case 2:
@@ -1741,7 +2673,7 @@ static VALUE sm_vec3_init(int argc, VALUE *argv, VALUE sm_self)
   }
 
   default: {
-    rb_raise(rb_eArgError, "Invalid arguments to Vec3.initialize");
+    rb_raise(rb_eArgError, "Invalid arguments to initialize/set");
     break;
   }
   } // switch (argc)
@@ -2169,7 +3101,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec4(output, rb_obj_class(sm_self));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec4");
+    rb_raise(rb_eArgError, "Invalid number of arguments to project");
   }
   return sm_out;
 }
@@ -2216,7 +3148,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec4(output, rb_obj_class(sm_self));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec4");
+    rb_raise(rb_eArgError, "Invalid number of arguments to reflect");
   }
   return sm_out;
 }
@@ -2228,7 +3160,7 @@ SM_LABEL(skip_output): {
  * result.
  *
  * call-seq:
- *    multiply(vec4, output = nil) -> output or new vec4
+ *    multiply_vec4(vec4, output = nil) -> output or new vec4
  */
 static VALUE sm_vec4_multiply(int argc, VALUE *argv, VALUE sm_self)
 {
@@ -2264,7 +3196,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec4(output, rb_obj_class(sm_self));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec4");
+    rb_raise(rb_eArgError, "Invalid number of arguments to multiply_vec4");
   }
   return sm_out;
 }
@@ -2312,7 +3244,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec4(output, rb_obj_class(sm_self));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec4");
+    rb_raise(rb_eArgError, "Invalid number of arguments to add");
   }
   return sm_out;
 }
@@ -2360,7 +3292,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec4(output, rb_obj_class(sm_self));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec4");
+    rb_raise(rb_eArgError, "Invalid number of arguments to subtract");
   }
   return sm_out;
 }
@@ -2418,8 +3350,9 @@ static VALUE sm_vec4_new(int argc, VALUE *argv, VALUE self)
  * call-seq:
  *    set(x, y, z, w = 1) -> new vec4 with components [x, y, z, w]
  *    set([x, y, z, w])   -> new vec4 with components [x, y, z, w]
+ *    set(vec3)           -> vec4 with components [vec3.xyz, 1]
+ *    set(vec2)           -> vec4 with components [vec2.xy, 0, 1]
  *    set(vec4)           -> copy of vec4
- *    set(vec3)           -> copy of vec3 with w component of 1
  *    set(quat)           -> copy of quat as vec4
  */
 static VALUE sm_vec4_init(int argc, VALUE *argv, VALUE sm_self)
@@ -2442,6 +3375,14 @@ static VALUE sm_vec4_init(int argc, VALUE *argv, VALUE sm_self)
 
     if (SM_IS_A(argv[0], vec3)) {
       sm_unwrap_vec3(argv[0], *self);
+      self[0][3] = s_float_lit(1.0);
+      break;
+    }
+
+    if (SM_IS_A(argv[0], vec2)) {
+      sm_unwrap_vec2(argv[0], *self);
+      self[0][2] = s_float_lit(0.0);
+      self[0][3] = s_float_lit(1.0);
       break;
     }
 
@@ -2477,7 +3418,7 @@ static VALUE sm_vec4_init(int argc, VALUE *argv, VALUE sm_self)
   }
 
   default: {
-    rb_raise(rb_eArgError, "Invalid arguments to Vec4.initialize");
+    rb_raise(rb_eArgError, "Invalid arguments to initialize/set");
     break;
   }
   } // switch (argc)
@@ -2792,7 +3733,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_quat(output, rb_obj_class(sm_self));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to quat");
+    rb_raise(rb_eArgError, "Invalid number of arguments to multiply_quat");
   }
   return sm_out;
 }
@@ -2839,7 +3780,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec3(output, rb_obj_class(sm_rhs));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to quat");
+    rb_raise(rb_eArgError, "Invalid number of arguments to multiply_vec3");
   }
   return sm_out;
 }
@@ -2875,6 +3816,7 @@ static VALUE sm_quat_new(int argc, VALUE *argv, VALUE self)
  *    set(x, y, z, w = 1) -> new quaternion with components [x, y, z, w]
  *    set([x, y, z, w])   -> new quaternion with components [x, y, z, w]
  *    set(quat)           -> copy of quat
+ *    set(vec2)           -> new quaternion with the components [vec2.xy, 0, 1]
  *    set(vec3)           -> new quaternion with the components [vec3.xyz, 1]
  *    set(vec4)           -> new quaternion with the components of vec4
  *    set(mat3)           -> new quaternion from mat3
@@ -2892,17 +3834,25 @@ static VALUE sm_quat_init(int argc, VALUE *argv, VALUE sm_self)
 
   // Copy or by-array
   case 1: {
-    if (SM_IS_A(argv[0], vec3)) {
-      sm_unwrap_vec3(argv[0], *self);
-      break;
-    }
-
     if (SM_IS_A(argv[0], quat) ||
         SM_IS_A(argv[0], vec4)) {
       sm_unwrap_quat(argv[0], *self);
       break;
     }
 
+    if (SM_IS_A(argv[0], vec2)) {
+      sm_unwrap_vec2(argv[0], *self);
+      self[0][2] = s_float_lit(0.0);
+      self[0][3] = s_float_lit(1.0);
+      break;
+    }
+
+    if (SM_IS_A(argv[0], vec3)) {
+      sm_unwrap_vec3(argv[0], *self);
+      self[0][3] = s_float_lit(1.0);
+      break;
+    }
+
     if (SM_IS_A(argv[0], mat4)) {
       const mat4_t *mat = sm_unwrap_mat4(argv[0], NULL);
       quat_from_mat4(*mat, *self);
@@ -2947,7 +3897,7 @@ static VALUE sm_quat_init(int argc, VALUE *argv, VALUE sm_self)
   }
 
   default: {
-    rb_raise(rb_eArgError, "Invalid arguments to Quat.initialize");
+    rb_raise(rb_eArgError, "Invalid arguments to initialize/set");
     break;
   }
   } // switch (argc)
@@ -3368,7 +4318,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_mat4(output, rb_obj_class(sm_self));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to mat4");
+    rb_raise(rb_eArgError, "Invalid number of arguments to multiply_mat4");
   }
   return sm_out;
 }
@@ -3415,7 +4365,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec4(output, rb_obj_class(sm_rhs));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec4");
+    rb_raise(rb_eArgError, "Invalid number of arguments to multiply_vec4");
   }
   return sm_out;
 }
@@ -3462,7 +4412,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec3(output, rb_obj_class(sm_rhs));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec3");
+    rb_raise(rb_eArgError, "Invalid number of arguments to transform_vec3");
   }
   return sm_out;
 }
@@ -3510,7 +4460,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec3(output, rb_obj_class(sm_rhs));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec3");
+    rb_raise(rb_eArgError, "Invalid number of arguments to rotate_vec3");
   }
   return sm_out;
 }
@@ -3558,7 +4508,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec3(output, rb_obj_class(sm_rhs));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec3");
+    rb_raise(rb_eArgError, "Invalid number of arguments to inverse_rotate_vec3");
   }
   return sm_out;
 }
@@ -3881,7 +4831,7 @@ static VALUE sm_mat4_init(int argc, VALUE *argv, VALUE sm_self)
       if (!SM_IS_A(argv[arg_index], vec4) && !SM_IS_A(argv[arg_index], quat)) {
         rb_raise(
           rb_eArgError,
-          "Argument %d must be a Vec4 or Quat when supplying four arguments to Mat4.initialize/set",
+          "Argument %d must be a Vec4 or Quat when supplying four arguments to initialize/set",
           (int)(arg_index + 1));
       }
 
@@ -3901,7 +4851,7 @@ static VALUE sm_mat4_init(int argc, VALUE *argv, VALUE sm_self)
   }
 
   default: {
-    rb_raise(rb_eArgError, "Invalid arguments to Mat4.initialize");
+    rb_raise(rb_eArgError, "Invalid arguments to initialize/set");
     break;
   }
   } // swtich (argc)
@@ -4932,7 +5882,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_mat3(output, rb_obj_class(sm_self));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to mat3");
+    rb_raise(rb_eArgError, "Invalid number of arguments to multiply_mat3");
   }
   return sm_out;
 }
@@ -4979,7 +5929,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec3(output, rb_obj_class(sm_rhs));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec3");
+    rb_raise(rb_eArgError, "Invalid number of arguments to rotate_vec3");
   }
   return sm_out;
 }
@@ -5027,7 +5977,7 @@ SM_LABEL(skip_output): {
     sm_out = sm_wrap_vec3(output, rb_obj_class(sm_rhs));
     rb_obj_call_init(sm_out, 0, 0);
   }} else {
-    rb_raise(rb_eArgError, "Invalid number of arguments to vec3");
+    rb_raise(rb_eArgError, "Invalid number of arguments to inverse_rotate_vec3");
   }
   return sm_out;
 }
@@ -5190,10 +6140,10 @@ static VALUE sm_mat3_init(int argc, VALUE *argv, VALUE sm_self)
     size_t arg_index;
     s_float_t *mat_elem = *self;
     for (arg_index = 0; arg_index < 3; ++arg_index, mat_elem += 3) {
-      if (!SM_IS_A(argv[arg_index], vec3)) {
+      if (!SM_IS_A(argv[arg_index], vec3) && !SM_IS_A(argv[arg_index], vec4) && !SM_IS_A(argv[arg_index], quat)) {
         rb_raise(
           rb_eArgError,
-          "Argument %d must be a Vec3 when supplying three arguments to Mat3.initialize",
+          "Argument %d must be a Vec3, Vec4, or Quat when supplying three arguments to initialize/set",
           (int)(arg_index + 1));
       }
 
@@ -5213,7 +6163,7 @@ static VALUE sm_mat3_init(int argc, VALUE *argv, VALUE sm_self)
   }
 
   default: {
-    rb_raise(rb_eArgError, "Invalid arguments to Mat3.initialize");
+    rb_raise(rb_eArgError, "Invalid arguments to initialize/set");
     break;
   }
   } // swtich (argc)
@@ -5588,6 +6538,7 @@ void Init_bindings()
    */
 
   s_sm_snowmath_mod = rb_define_module("Snow");
+  s_sm_vec2_klass   = rb_define_class_under(s_sm_snowmath_mod, "Vec2", rb_cObject);
   s_sm_vec3_klass   = rb_define_class_under(s_sm_snowmath_mod, "Vec3", rb_cObject);
   s_sm_vec4_klass   = rb_define_class_under(s_sm_snowmath_mod, "Vec4", rb_cObject);
   s_sm_quat_klass   = rb_define_class_under(s_sm_snowmath_mod, "Quat", rb_cObject);
@@ -5595,17 +6546,44 @@ void Init_bindings()
   s_sm_mat4_klass   = rb_define_class_under(s_sm_snowmath_mod, "Mat4", rb_cObject);
 
   rb_const_set(s_sm_snowmath_mod, kRB_CONST_FLOAT_SIZE, INT2FIX(sizeof(s_float_t)));
+  rb_const_set(s_sm_vec2_klass, kRB_CONST_SIZE, INT2FIX(sizeof(vec2_t)));
   rb_const_set(s_sm_vec3_klass, kRB_CONST_SIZE, INT2FIX(sizeof(vec3_t)));
   rb_const_set(s_sm_vec4_klass, kRB_CONST_SIZE, INT2FIX(sizeof(vec4_t)));
   rb_const_set(s_sm_quat_klass, kRB_CONST_SIZE, INT2FIX(sizeof(quat_t)));
   rb_const_set(s_sm_mat3_klass, kRB_CONST_SIZE, INT2FIX(sizeof(mat3_t)));
   rb_const_set(s_sm_mat4_klass, kRB_CONST_SIZE, INT2FIX(sizeof(mat4_t)));
+  rb_const_set(s_sm_vec2_klass, kRB_CONST_LENGTH, INT2FIX(sizeof(vec2_t) / sizeof(s_float_t)));
   rb_const_set(s_sm_vec3_klass, kRB_CONST_LENGTH, INT2FIX(sizeof(vec3_t) / sizeof(s_float_t)));
   rb_const_set(s_sm_vec4_klass, kRB_CONST_LENGTH, INT2FIX(sizeof(vec4_t) / sizeof(s_float_t)));
   rb_const_set(s_sm_quat_klass, kRB_CONST_LENGTH, INT2FIX(sizeof(quat_t) / sizeof(s_float_t)));
   rb_const_set(s_sm_mat3_klass, kRB_CONST_LENGTH, INT2FIX(sizeof(mat3_t) / sizeof(s_float_t)));
   rb_const_set(s_sm_mat4_klass, kRB_CONST_LENGTH, INT2FIX(sizeof(mat4_t) / sizeof(s_float_t)));
 
+  rb_define_singleton_method(s_sm_vec2_klass, "new", sm_vec2_new, -1);
+  rb_define_method(s_sm_vec2_klass, "initialize", sm_vec2_init, -1);
+  rb_define_method(s_sm_vec2_klass, "set", sm_vec2_init, -1);
+  rb_define_method(s_sm_vec2_klass, "fetch", sm_vec2_fetch, 1);
+  rb_define_method(s_sm_vec2_klass, "store", sm_vec2_store, 2);
+  rb_define_method(s_sm_vec2_klass, "size", sm_vec2_size, 0);
+  rb_define_method(s_sm_vec2_klass, "length", sm_vec2_length, 0);
+  rb_define_method(s_sm_vec2_klass, "to_s", sm_vec2_to_s, 0);
+  rb_define_method(s_sm_vec2_klass, "address", sm_get_address, 0);
+  rb_define_method(s_sm_vec2_klass, "copy", sm_vec2_copy, -1);
+  rb_define_method(s_sm_vec2_klass, "normalize", sm_vec2_normalize, -1);
+  rb_define_method(s_sm_vec2_klass, "inverse", sm_vec2_inverse, -1);
+  rb_define_method(s_sm_vec2_klass, "negate", sm_vec2_negate, -1);
+  rb_define_method(s_sm_vec2_klass, "multiply_vec2", sm_vec2_multiply, -1);
+  rb_define_method(s_sm_vec2_klass, "add", sm_vec2_add, -1);
+  rb_define_method(s_sm_vec2_klass, "subtract", sm_vec2_subtract, -1);
+  rb_define_method(s_sm_vec2_klass, "reflect", sm_vec2_reflect, -1);
+  rb_define_method(s_sm_vec2_klass, "project", sm_vec2_project, -1);
+  rb_define_method(s_sm_vec2_klass, "dot_product", sm_vec2_dot_product, 1);
+  rb_define_method(s_sm_vec2_klass, "magnitude_squared", sm_vec2_magnitude_squared, 0);
+  rb_define_method(s_sm_vec2_klass, "magnitude", sm_vec2_magnitude, 0);
+  rb_define_method(s_sm_vec2_klass, "scale", sm_vec2_scale, -1);
+  rb_define_method(s_sm_vec2_klass, "divide", sm_vec2_divide, -1);
+  rb_define_method(s_sm_vec2_klass, "==", sm_vec2_equals, 1);
+
   rb_define_singleton_method(s_sm_vec3_klass, "new", sm_vec3_new, -1);
   rb_define_method(s_sm_vec3_klass, "initialize", sm_vec3_init, -1);
   rb_define_method(s_sm_vec3_klass, "set", sm_vec3_init, -1);
@@ -5757,6 +6735,16 @@ void Init_bindings()
 
   #if BUILD_ARRAY_TYPE
 
+  s_sm_vec2_array_klass = rb_define_class_under(s_sm_snowmath_mod, "Vec2Array", rb_cObject);
+  rb_const_set(s_sm_vec2_array_klass, kRB_CONST_TYPE, s_sm_vec2_klass);
+  rb_define_singleton_method(s_sm_vec2_array_klass, "new", sm_vec2_array_new, 1);
+  rb_define_method(s_sm_vec2_array_klass, "fetch", sm_vec2_array_fetch, 1);
+  rb_define_method(s_sm_vec2_array_klass, "store", sm_vec2_array_store, 2);
+  rb_define_method(s_sm_vec2_array_klass, "resize!", sm_vec2_array_resize, 1);
+  rb_define_method(s_sm_vec2_array_klass, "size", sm_vec2_array_size, 0);
+  rb_define_method(s_sm_vec2_array_klass, "length", sm_mathtype_array_length, 0);
+  rb_define_method(s_sm_vec2_array_klass, "address", sm_get_address, 0);
+
   s_sm_vec3_array_klass = rb_define_class_under(s_sm_snowmath_mod, "Vec3Array", rb_cObject);
   rb_const_set(s_sm_vec3_array_klass, kRB_CONST_TYPE, s_sm_vec3_klass);
   rb_define_singleton_method(s_sm_vec3_array_klass, "new", sm_vec3_array_new, 1);