snow-math 1.5.3 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a51bb323669b2f4f06bba42373bee886ff6fe5b
-  data.tar.gz: 89770e67ef087bd254efd4138ffa60acf345baac
+  metadata.gz: 9fdcc6853dcceb46023eaa23da15f3b86831168b
+  data.tar.gz: 0d4b55799ed535e0fa71eb75b077f78bf8b6805b
 SHA512:
-  metadata.gz: c88c4b0e95a1791b79ce954cd5411e17468a37fa603c00066fdd80133ee4b5275299afed4f0705962bc211d2d2f0c4c2ac6ee550be226a15df313af36386853a
-  data.tar.gz: 39428e2b13941b242a1b642c901751bf857ca08740b57e602c5f8b42653490543a7834e3c9ebf756a48f107bb363589c2cc1e9e43e9696a1748ec3418b42e82a
+  metadata.gz: c688599c54baa7c0f3af312d797d9f571bf6eed518f3cc2c7168f2591ab8bc112159e730853f0f0e1ec766cefc7e334f58e4b21637065433c32d02e632a94731
+  data.tar.gz: 5cc0c1fe37a23f0477e538dce8b2ba2b042cbb02fd711aae10890a3039075e11580a61604ee6dfa56332a7a35460cb08a871ab3cd11b031a700b5f4da8de6366

data/ext/snow-math/mat3.c

@@ -24,12 +24,12 @@ const mat3_t g_mat3_identity = {
 
 
 
-// Rows
+/* Rows */
 #define S_MR 0
 #define S_MS 3
 #define S_MT 6
 
-// row components
+/* row components */
 #define S_MR_X 0
 #define S_MR_Y 1
 #define S_MR_Z 2
@@ -40,7 +40,7 @@ const mat3_t g_mat3_identity = {
 #define S_MT_Y 7
 #define S_MT_Z 8
 
-// columns
+/* columns */
 #define S_MIR_X 0
 #define S_MIR_Y 3
 #define S_MIR_Z 6

data/ext/snow-math/mat4.c

@@ -684,7 +684,7 @@ void mat4_multiply(const mat4_t left, const mat4_t right, mat4_t out)
   mat4_t temp;
   vec4_t c;
 
-  // Transpose the left matrix so we can be a little more cache-friendly.
+  /* Transpose the left matrix so we can be a little more cache-friendly. */
   mat4_transpose(left, temp);
 
   c[0]     = temp[0];

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

@@ -209,6 +209,8 @@ static VALUE sm_vec2_array_resize(VALUE sm_self, VALUE sm_new_length)
   size_t new_length;
   size_t old_length;
 
+  rb_check_frozen(sm_self);
+
   old_length = NUM2SIZET(sm_mathtype_array_length(sm_self));
   new_length = NUM2SIZET(sm_new_length);
 
@@ -292,6 +294,8 @@ static VALUE sm_vec2_array_store(VALUE sm_self, VALUE sm_index, VALUE sm_value)
   size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
   size_t index = NUM2SIZET(sm_index);
 
+  rb_check_frozen(sm_self);
+
   if (index >= length) {
     rb_raise(rb_eRangeError,
       "Index %zu out of bounds for array with length %zu",
@@ -400,6 +404,8 @@ static VALUE sm_vec3_array_resize(VALUE sm_self, VALUE sm_new_length)
   size_t new_length;
   size_t old_length;
 
+  rb_check_frozen(sm_self);
+
   old_length = NUM2SIZET(sm_mathtype_array_length(sm_self));
   new_length = NUM2SIZET(sm_new_length);
 
@@ -483,6 +489,8 @@ static VALUE sm_vec3_array_store(VALUE sm_self, VALUE sm_index, VALUE sm_value)
   size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
   size_t index = NUM2SIZET(sm_index);
 
+  rb_check_frozen(sm_self);
+
   if (index >= length) {
     rb_raise(rb_eRangeError,
       "Index %zu out of bounds for array with length %zu",
@@ -590,6 +598,8 @@ static VALUE sm_vec4_array_resize(VALUE sm_self, VALUE sm_new_length)
   size_t new_length;
   size_t old_length;
 
+  rb_check_frozen(sm_self);
+
   old_length = NUM2SIZET(sm_mathtype_array_length(sm_self));
   new_length = NUM2SIZET(sm_new_length);
 
@@ -673,6 +683,8 @@ static VALUE sm_vec4_array_store(VALUE sm_self, VALUE sm_index, VALUE sm_value)
   size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
   size_t index = NUM2SIZET(sm_index);
 
+  rb_check_frozen(sm_self);
+
   if (index >= length) {
     rb_raise(rb_eRangeError,
       "Index %zu out of bounds for array with length %zu",
@@ -780,6 +792,8 @@ static VALUE sm_quat_array_resize(VALUE sm_self, VALUE sm_new_length)
   size_t new_length;
   size_t old_length;
 
+  rb_check_frozen(sm_self);
+
   old_length = NUM2SIZET(sm_mathtype_array_length(sm_self));
   new_length = NUM2SIZET(sm_new_length);
 
@@ -863,6 +877,8 @@ static VALUE sm_quat_array_store(VALUE sm_self, VALUE sm_index, VALUE sm_value)
   size_t length = NUM2SIZET(sm_mathtype_array_length(sm_self));
   size_t index = NUM2SIZET(sm_index);
 
+  rb_check_frozen(sm_self);
+
   if (index >= length) {
     rb_raise(rb_eRangeError,
       "Index %zu out of bounds for array with length %zu",
@@ -970,6 +986,8 @@ static VALUE sm_mat3_array_resize(VALUE sm_self, VALUE sm_new_length)
   size_t new_length;
   size_t old_length;
 
+  rb_check_frozen(sm_self);
+
   old_length = NUM2SIZET(sm_mathtype_array_length(sm_self));
   new_length = NUM2SIZET(sm_new_length);
 
@@ -1056,6 +1074,8 @@ static VALUE sm_mat3_array_store(VALUE sm_self, VALUE sm_index, VALUE sm_value)
   size_t index = NUM2SIZET(sm_index);
   int is_mat3 = 0;
 
+  rb_check_frozen(sm_self);
+
   if (index >= length) {
     rb_raise(rb_eRangeError,
       "Index %zu out of bounds for array with length %zu",
@@ -1166,6 +1186,8 @@ static VALUE sm_mat4_array_resize(VALUE sm_self, VALUE sm_new_length)
   size_t new_length;
   size_t old_length;
 
+  rb_check_frozen(sm_self);
+
   old_length = NUM2SIZET(sm_mathtype_array_length(sm_self));
   new_length = NUM2SIZET(sm_new_length);
 
@@ -1252,6 +1274,8 @@ static VALUE sm_mat4_array_store(VALUE sm_self, VALUE sm_index, VALUE sm_value)
   size_t index = NUM2SIZET(sm_index);
   int is_mat4 = 0;
 
+  rb_check_frozen(sm_self);
+
   if (index >= length) {
     rb_raise(rb_eRangeError,
       "Index %zu out of bounds for array with length %zu",
@@ -1356,6 +1380,7 @@ 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);
+  rb_check_frozen(sm_self);
   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);
@@ -1398,35 +1423,37 @@ static VALUE sm_vec2_length (VALUE 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;
- }
+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);
+    }{
+   vec2_t *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;
+    }
+    rb_check_frozen(sm_out);
+    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;
+}
 
 
 
@@ -1437,35 +1464,37 @@ static VALUE sm_vec2_length (VALUE self)
  * 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;
- }
+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);
+    }{
+    vec2_t *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;
+    }
+    rb_check_frozen(sm_out);
+    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;
+}
 
 
 
@@ -1476,35 +1505,37 @@ static VALUE sm_vec2_length (VALUE self)
  * 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;
- }
+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);
+    }{
+    vec2_t *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;
+    }
+    rb_check_frozen(sm_out);
+    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;
+}
 
 
 
@@ -1514,35 +1545,37 @@ static VALUE sm_vec2_length (VALUE self)
  * 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;
- }
+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);
+    }{
+    vec2_t *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;
+    }
+    rb_check_frozen(sm_out);
+    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;
+}
 
 
 
@@ -1571,13 +1604,15 @@ static VALUE sm_vec2_project(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec2_t *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);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec2(sm_out, NULL);
     vec2_project(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -1618,13 +1653,15 @@ static VALUE sm_vec2_reflect(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec2_t *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);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec2(sm_out, NULL);
     vec2_reflect(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -1666,13 +1703,15 @@ static VALUE sm_vec2_multiply(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec2_t *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);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec2(sm_out, NULL);
     vec2_multiply(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -1713,13 +1752,15 @@ static VALUE sm_vec2_add(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec2_t *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);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec2(sm_out, NULL);
     vec2_add(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -1761,13 +1802,15 @@ static VALUE sm_vec2_subtract(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec2_t *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);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec2(sm_out, NULL);
     vec2_subtract(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -1849,12 +1892,14 @@ static VALUE sm_vec2_init(int argc, VALUE *argv, VALUE sm_self)
   vec2_t *self = sm_unwrap_vec2(sm_self, NULL);
   size_t arr_index = 0;
 
+  rb_check_frozen(sm_self);
+
   switch(argc) {
 
-  // Default value
+  /* Default value */
   case 0: { break; }
 
-  // Copy or by-array
+  /* Copy or by-array */
   case 1: {
     if (SM_IS_A(argv[0], vec2) ||
         SM_IS_A(argv[0], vec3) ||
@@ -1864,7 +1909,7 @@ static VALUE sm_vec2_init(int argc, VALUE *argv, VALUE sm_self)
       break;
     }
 
-    // Optional offset into array provided
+    /* Optional offset into array provided */
     if (0) {
       case 2:
       if (!SM_RB_IS_A(argv[0], rb_cArray)) {
@@ -1875,7 +1920,7 @@ static VALUE sm_vec2_init(int argc, VALUE *argv, VALUE sm_self)
       arr_index = NUM2SIZET(argv[1]);
     }
 
-    // Array of values
+    /* Array of values */
     VALUE arrdata = argv[0];
     const size_t arr_end = arr_index + 2;
     s_float_t *vec_elem = *self;
@@ -1889,7 +1934,7 @@ static VALUE sm_vec2_init(int argc, VALUE *argv, VALUE sm_self)
     rb_raise(rb_eArgError, "Invalid arguments to initialize/set");
     break;
   }
-  } // switch (argc)
+  } /* switch (argc) */
 
   return sm_self;
 }
@@ -1960,6 +2005,7 @@ static VALUE sm_vec2_scale(int argc, VALUE *argv, VALUE sm_self)
   scalar = rb_num2dbl(sm_scalar);
 
   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_check_frozen(sm_out);
     vec2_scale(*self, scalar, *sm_unwrap_vec2(sm_out, NULL));
   } else {
     vec2_t out;
@@ -1990,6 +2036,7 @@ static VALUE sm_vec2_divide(int argc, VALUE *argv, VALUE sm_self)
   scalar = rb_num2dbl(sm_scalar);
 
   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_check_frozen(sm_out);
     vec2_divide(*self, scalar, *sm_unwrap_vec2(sm_out, NULL));
   } else {
     vec2_t out;
@@ -2086,6 +2133,7 @@ static VALUE sm_vec3_store (VALUE sm_self, VALUE sm_index, VALUE sm_value)
   static const int max_index = sizeof(vec3_t) / sizeof(s_float_t);
   vec3_t *self = sm_unwrap_vec3(sm_self, NULL);
   int index = NUM2INT(sm_index);
+  rb_check_frozen(sm_self);
   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);
@@ -2128,35 +2176,37 @@ static VALUE sm_vec3_length (VALUE self)
  * call-seq:
  *    copy(output = nil) -> output or new vec3
  */
- static VALUE sm_vec3_copy(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   vec3_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_vec3(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
-       rb_raise(rb_eTypeError,
-         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
-         rb_obj_classname(sm_out));
-       return Qnil;
-     }
-     vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
-     vec3_copy (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     vec3_t output;
-     vec3_copy (*self, 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 copy");
-   }
-   return sm_out;
- }
+static VALUE sm_vec3_copy(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  vec3_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_vec3(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    vec3_t *output;
+    if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+      rb_raise(rb_eTypeError,
+        kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
+        rb_obj_classname(sm_out));
+      return Qnil;
+    }
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
+    vec3_copy (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    vec3_t output;
+    vec3_copy (*self, 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 copy");
+  }
+  return sm_out;
+}
 
 
 
@@ -2167,35 +2217,37 @@ static VALUE sm_vec3_length (VALUE self)
  * call-seq:
  *    normalize(output = nil) -> output or new vec3
  */
- static VALUE sm_vec3_normalize(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   vec3_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_vec3(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
-       rb_raise(rb_eTypeError,
-         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
-         rb_obj_classname(sm_out));
-       return Qnil;
-     }
-     vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
-     vec3_normalize (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     vec3_t output;
-     vec3_normalize (*self, 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 normalize");
-   }
-   return sm_out;
- }
+static VALUE sm_vec3_normalize(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  vec3_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_vec3(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    vec3_t *output;
+    if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+      rb_raise(rb_eTypeError,
+        kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
+        rb_obj_classname(sm_out));
+      return Qnil;
+    }
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
+    vec3_normalize (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    vec3_t output;
+    vec3_normalize (*self, 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 normalize");
+  }
+  return sm_out;
+}
 
 
 
@@ -2206,35 +2258,37 @@ static VALUE sm_vec3_length (VALUE self)
  * call-seq:
  *    inverse(output = nil) -> output or new vec3
  */
- static VALUE sm_vec3_inverse(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   vec3_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_vec3(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
-       rb_raise(rb_eTypeError,
-         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
-         rb_obj_classname(sm_out));
-       return Qnil;
-     }
-     vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
-     vec3_inverse (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     vec3_t output;
-     vec3_inverse (*self, 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 inverse");
-   }
-   return sm_out;
- }
+static VALUE sm_vec3_inverse(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  vec3_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_vec3(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    vec3_t *output;
+    if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+      rb_raise(rb_eTypeError,
+        kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
+        rb_obj_classname(sm_out));
+      return Qnil;
+    }
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
+    vec3_inverse (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    vec3_t output;
+    vec3_inverse (*self, 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 inverse");
+  }
+  return sm_out;
+}
 
 
 
@@ -2244,35 +2298,37 @@ static VALUE sm_vec3_length (VALUE self)
  * call-seq:
  *    negate(output = nil) -> output or new vec3
  */
- static VALUE sm_vec3_negate(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   vec3_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_vec3(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
-       rb_raise(rb_eTypeError,
-         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
-         rb_obj_classname(sm_out));
-       return Qnil;
-     }
-     vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
-     vec3_negate (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     vec3_t output;
-     vec3_negate (*self, 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 negate");
-   }
-   return sm_out;
- }
+static VALUE sm_vec3_negate(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  vec3_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_vec3(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    vec3_t *output;
+    if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+      rb_raise(rb_eTypeError,
+        kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
+        rb_obj_classname(sm_out));
+      return Qnil;
+    }
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
+    vec3_negate (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    vec3_t output;
+    vec3_negate (*self, 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 negate");
+  }
+  return sm_out;
+}
 
 
 
@@ -2301,13 +2357,15 @@ static VALUE sm_vec3_project(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec3_t *output;
     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
     vec3_project(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -2348,13 +2406,15 @@ static VALUE sm_vec3_reflect(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec3_t *output;
     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
     vec3_reflect(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -2395,13 +2455,15 @@ static VALUE sm_vec3_cross_product(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec3_t *output;
     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
     vec3_cross_product(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -2443,13 +2505,15 @@ static VALUE sm_vec3_multiply(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec3_t *output;
     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
     vec3_multiply(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -2490,13 +2554,15 @@ static VALUE sm_vec3_add(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec3_t *output;
     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
     vec3_add(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -2538,13 +2604,15 @@ static VALUE sm_vec3_subtract(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec3_t *output;
     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
     vec3_subtract(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -2623,12 +2691,14 @@ static VALUE sm_vec3_init(int argc, VALUE *argv, VALUE sm_self)
   vec3_t *self = sm_unwrap_vec3(sm_self, NULL);
   size_t arr_index = 0;
 
+  rb_check_frozen(sm_self);
+
   switch(argc) {
 
-  // Default value
+  /* Default value */
   case 0: { break; }
 
-  // Copy or by-array
+  /* Copy or by-array */
   case 1: {
     if (SM_IS_A(argv[0], vec3) ||
         SM_IS_A(argv[0], vec4) ||
@@ -2643,13 +2713,13 @@ static VALUE sm_vec3_init(int argc, VALUE *argv, VALUE sm_self)
       break;
     }
 
-    // Optional offset into array provided
+    /* Optional offset into array provided */
     if (0) {
       case 2:
       arr_index = NUM2SIZET(argv[1]);
     }
 
-    // Array of values
+    /* Array of values */
     if (SM_RB_IS_A(argv[0], rb_cArray)) {
       VALUE arrdata = argv[0];
       const size_t arr_end = arr_index + 3;
@@ -2664,7 +2734,7 @@ static VALUE sm_vec3_init(int argc, VALUE *argv, VALUE sm_self)
     break;
   }
 
-  // X, Y, Z
+  /* X, Y, Z */
   case 3: {
     self[0][0] = (s_float_t)rb_num2dbl(argv[0]);
     self[0][1] = (s_float_t)rb_num2dbl(argv[1]);
@@ -2676,7 +2746,7 @@ static VALUE sm_vec3_init(int argc, VALUE *argv, VALUE sm_self)
     rb_raise(rb_eArgError, "Invalid arguments to initialize/set");
     break;
   }
-  } // switch (argc)
+  } /* switch (argc) */
 
   return sm_self;
 }
@@ -2746,7 +2816,8 @@ static VALUE sm_vec3_scale(int argc, VALUE *argv, VALUE sm_self)
   rb_scan_args(argc, argv, "11", &sm_scalar, &sm_out);
   scalar = rb_num2dbl(sm_scalar);
 
-  if (SM_IS_A(sm_out, vec3)) {
+  if (SM_IS_A(sm_out, vec3) || SM_IS_A(sm_out, vec4) || SM_IS_A(sm_out, quat)) {
+    rb_check_frozen(sm_out);
     vec3_scale(*self, scalar, *sm_unwrap_vec3(sm_out, NULL));
   } else {
     vec3_t out;
@@ -2776,7 +2847,8 @@ static VALUE sm_vec3_divide(int argc, VALUE *argv, VALUE sm_self)
   rb_scan_args(argc, argv, "11", &sm_scalar, &sm_out);
   scalar = rb_num2dbl(sm_scalar);
 
-  if (SM_IS_A(sm_out, vec3)) {
+  if (SM_IS_A(sm_out, vec3) || SM_IS_A(sm_out, vec4) || SM_IS_A(sm_out, quat)) {
+    rb_check_frozen(sm_out);
     vec3_divide(*self, scalar, *sm_unwrap_vec3(sm_out, NULL));
   } else {
     vec3_t out;
@@ -2872,6 +2944,7 @@ static VALUE sm_vec4_store (VALUE sm_self, VALUE sm_index, VALUE sm_value)
   static const int max_index = sizeof(vec4_t) / sizeof(s_float_t);
   vec4_t *self = sm_unwrap_vec4(sm_self, NULL);
   int index = NUM2INT(sm_index);
+  rb_check_frozen(sm_self);
   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);
@@ -2914,35 +2987,37 @@ static VALUE sm_vec4_length (VALUE self)
  * call-seq:
  *    copy(output = nil) -> output or new vec4 / quat
  */
- static VALUE sm_vec4_copy(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   vec4_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_vec4(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     if (!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
-       rb_raise(rb_eTypeError,
-         kSM_WANT_FOUR_FORMAT_LIT,
-         rb_obj_classname(sm_out));
-       return Qnil;
-     }
-     vec4_t *output = sm_unwrap_vec4(sm_out, NULL);
-     vec4_copy (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     vec4_t output;
-     vec4_copy (*self, 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 copy");
-   }
-   return sm_out;
- }
+static VALUE sm_vec4_copy(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  vec4_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_vec4(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    vec4_t *output;
+    if (!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+      rb_raise(rb_eTypeError,
+        kSM_WANT_FOUR_FORMAT_LIT,
+        rb_obj_classname(sm_out));
+      return Qnil;
+    }
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec4(sm_out, NULL);
+    vec4_copy (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    vec4_t output;
+    vec4_copy (*self, 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 copy");
+  }
+  return sm_out;
+}
 
 
 
@@ -2953,34 +3028,36 @@ static VALUE sm_vec4_length (VALUE self)
  * call-seq:
  *    normalize(output = nil) -> output or new vec4 / quat
  */
- static VALUE sm_vec4_normalize(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   vec4_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_vec4(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     if (!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
-      rb_raise(rb_eTypeError,
-        kSM_WANT_FOUR_FORMAT_LIT,
-        rb_obj_classname(sm_out));
-     }
-     vec4_t *output = sm_unwrap_vec4(sm_out, NULL);
-     vec4_normalize (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     vec4_t output;
-     vec4_normalize (*self, 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 normalize");
-   }
-   return sm_out;
- }
+static VALUE sm_vec4_normalize(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  vec4_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_vec4(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    vec4_t *output;
+    if (!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+     rb_raise(rb_eTypeError,
+       kSM_WANT_FOUR_FORMAT_LIT,
+       rb_obj_classname(sm_out));
+    }
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec4(sm_out, NULL);
+    vec4_normalize (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    vec4_t output;
+    vec4_normalize (*self, 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 normalize");
+  }
+  return sm_out;
+}
 
 
 
@@ -2991,35 +3068,37 @@ static VALUE sm_vec4_length (VALUE self)
  * call-seq:
  *    inverse(output = nil) -> output or new vec4
  */
- static VALUE sm_vec4_inverse(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   vec4_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_vec4(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     if (!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
-       rb_raise(rb_eTypeError,
-         kSM_WANT_FOUR_FORMAT_LIT,
-         rb_obj_classname(sm_out));
-       return Qnil;
-     }
-     vec4_t *output = sm_unwrap_vec4(sm_out, NULL);
-     vec4_inverse (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     vec4_t output;
-     vec4_inverse (*self, 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 inverse");
-   }
-   return sm_out;
- }
+static VALUE sm_vec4_inverse(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  vec4_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_vec4(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    vec4_t *output;
+    if (!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+      rb_raise(rb_eTypeError,
+        kSM_WANT_FOUR_FORMAT_LIT,
+        rb_obj_classname(sm_out));
+      return Qnil;
+    }
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec4(sm_out, NULL);
+    vec4_inverse (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    vec4_t output;
+    vec4_inverse (*self, 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 inverse");
+  }
+  return sm_out;
+}
 
 
 
@@ -3029,35 +3108,37 @@ static VALUE sm_vec4_length (VALUE self)
  * call-seq:
  *    negate(output = nil) -> output or new vec4 or quat
  */
- static VALUE sm_vec4_negate(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   vec4_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_vec4(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     if (!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
-       rb_raise(rb_eTypeError,
-         kSM_WANT_FOUR_FORMAT_LIT,
-         rb_obj_classname(sm_out));
-       return Qnil;
-     }
-     vec4_t *output = sm_unwrap_vec4(sm_out, NULL);
-     vec4_negate (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     vec4_t output;
-     vec4_negate (*self, 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 negate");
-   }
-   return sm_out;
- }
+static VALUE sm_vec4_negate(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  vec4_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_vec4(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    vec4_t *output;
+    if (!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+      rb_raise(rb_eTypeError,
+        kSM_WANT_FOUR_FORMAT_LIT,
+        rb_obj_classname(sm_out));
+      return Qnil;
+    }
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec4(sm_out, NULL);
+    vec4_negate (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    vec4_t output;
+    vec4_negate (*self, 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 negate");
+  }
+  return sm_out;
+}
 
 
 
@@ -3086,13 +3167,15 @@ static VALUE sm_vec4_project(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec4_t *output;
     if (!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec4_t *output = sm_unwrap_vec4(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec4(sm_out, NULL);
     vec4_project(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -3133,13 +3216,15 @@ static VALUE sm_vec4_reflect(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec4_t *output;
     if (!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec4_t *output = sm_unwrap_vec4(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec4(sm_out, NULL);
     vec4_reflect(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -3181,13 +3266,15 @@ static VALUE sm_vec4_multiply(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec4_t *output;
     if (!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec4_t *output = sm_unwrap_vec4(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec4(sm_out, NULL);
     vec4_multiply(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -3229,13 +3316,15 @@ static VALUE sm_vec4_add(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec4_t *output;
     if (!SM_IS_A(sm_rhs, vec4) && !SM_IS_A(sm_rhs, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_rhs));
       return Qnil;
     }
-    vec4_t *output = sm_unwrap_vec4(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec4(sm_out, NULL);
     vec4_add(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -3277,13 +3366,15 @@ static VALUE sm_vec4_subtract(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec4_t *output;
     if (!SM_IS_A(sm_rhs, vec4) && !SM_IS_A(sm_rhs, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_rhs));
       return Qnil;
     }
-    vec4_t *output = sm_unwrap_vec4(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec4(sm_out, NULL);
     vec4_subtract(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -3360,12 +3451,14 @@ static VALUE sm_vec4_init(int argc, VALUE *argv, VALUE sm_self)
   vec4_t *self = sm_unwrap_vec4(sm_self, NULL);
   size_t arr_index = 0;
 
+  rb_check_frozen(sm_self);
+
   switch(argc) {
 
-  // Default value
+  /* Default value */
   case 0: { break; }
 
-  // Copy or by-array
+  /* Copy or by-array */
   case 1: {
     if (SM_IS_A(argv[0], quat) ||
         SM_IS_A(argv[0], vec4)) {
@@ -3386,13 +3479,13 @@ static VALUE sm_vec4_init(int argc, VALUE *argv, VALUE sm_self)
       break;
     }
 
-    // Optional offset into array provided
+    /* Optional offset into array provided */
     if (0) {
       case 2:
       arr_index = NUM2SIZET(argv[1]);
     }
 
-    // Array of values
+    /* Array of values */
     if (SM_RB_IS_A(argv[0], rb_cArray)) {
       VALUE arrdata = argv[0];
       const size_t arr_end = arr_index + 4;
@@ -3407,10 +3500,10 @@ static VALUE sm_vec4_init(int argc, VALUE *argv, VALUE sm_self)
     break;
   }
 
-  // W
+  /* W */
   case 4: {
     self[0][3] = (s_float_t)rb_num2dbl(argv[3]);
-    case 3: // X, Y, Z
+    case 3: /* X, Y, Z */
     self[0][0] = (s_float_t)rb_num2dbl(argv[0]);
     self[0][1] = (s_float_t)rb_num2dbl(argv[1]);
     self[0][2] = (s_float_t)rb_num2dbl(argv[2]);
@@ -3421,7 +3514,7 @@ static VALUE sm_vec4_init(int argc, VALUE *argv, VALUE sm_self)
     rb_raise(rb_eArgError, "Invalid arguments to initialize/set");
     break;
   }
-  } // switch (argc)
+  } /* switch (argc) */
 
   return sm_self;
 }
@@ -3493,6 +3586,7 @@ static VALUE sm_vec4_scale(int argc, VALUE *argv, VALUE sm_self)
   scalar = rb_num2dbl(sm_scalar);
 
   if ((SM_IS_A(sm_out, vec4) || SM_IS_A(sm_out, quat))) {
+    rb_check_frozen(sm_out);
     vec4_scale(*self, scalar, *sm_unwrap_vec4(sm_out, NULL));
   } else {
     vec4_t out;
@@ -3524,6 +3618,7 @@ static VALUE sm_vec4_divide(int argc, VALUE *argv, VALUE sm_self)
   scalar = rb_num2dbl(sm_scalar);
 
   if ((SM_IS_A(sm_out, vec4) || SM_IS_A(sm_out, quat))) {
+    rb_check_frozen(sm_out);
     vec4_divide(*self, scalar, *sm_unwrap_vec4(sm_out, NULL));
   } else {
     vec4_t out;
@@ -3618,6 +3713,7 @@ static VALUE sm_quat_store (VALUE sm_self, VALUE sm_index, VALUE sm_value)
   static const int max_index = sizeof(quat_t) / sizeof(s_float_t);
   quat_t *self = sm_unwrap_quat(sm_self, NULL);
   int index = NUM2INT(sm_index);
+  rb_check_frozen(sm_self);
   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);
@@ -3661,35 +3757,37 @@ static VALUE sm_quat_length (VALUE self)
  * call-seq:
  *    inverse(output = nil) -> output or new quat
  */
- static VALUE sm_quat_inverse(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   quat_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_quat(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     if (!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
-       rb_raise(rb_eTypeError,
-         kSM_WANT_FOUR_FORMAT_LIT,
-         rb_obj_classname(sm_out));
-       return Qnil;
-     }
-     quat_t *output = sm_unwrap_quat(sm_out, NULL);
-     quat_inverse (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     quat_t output;
-     quat_inverse (*self, 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 inverse");
-   }
-   return sm_out;
- }
+static VALUE sm_quat_inverse(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  quat_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_quat(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    quat_t *output;
+    if (!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
+      rb_raise(rb_eTypeError,
+        kSM_WANT_FOUR_FORMAT_LIT,
+        rb_obj_classname(sm_out));
+      return Qnil;
+    }
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_quat(sm_out, NULL);
+    quat_inverse (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    quat_t output;
+    quat_inverse (*self, 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 inverse");
+  }
+  return sm_out;
+}
 
 
 
@@ -3718,13 +3816,15 @@ static VALUE sm_quat_multiply(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    quat_t *output;
     if (!!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    quat_t *output = sm_unwrap_quat(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_quat(sm_out, NULL);
     quat_multiply(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -3765,13 +3865,15 @@ static VALUE sm_quat_multiply_vec3(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec3_t *output;
     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
     quat_multiply_vec3(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -3827,12 +3929,14 @@ static VALUE sm_quat_init(int argc, VALUE *argv, VALUE sm_self)
   quat_t *self = sm_unwrap_quat(sm_self, NULL);
   size_t arr_index = 0;
 
+  rb_check_frozen(sm_self);
+
   switch(argc) {
 
-  // Default value
+  /* Default value */
   case 0: { break; }
 
-  // Copy or by-array
+  /* Copy or by-array */
   case 1: {
     if (SM_IS_A(argv[0], quat) ||
         SM_IS_A(argv[0], vec4)) {
@@ -3865,13 +3969,13 @@ static VALUE sm_quat_init(int argc, VALUE *argv, VALUE sm_self)
       break;
     }
 
-    // Optional offset into array provided
+    /* Optional offset into array provided */
     if (0) {
       case 2:
       arr_index = NUM2SIZET(argv[1]);
     }
 
-    // Array of values
+    /* Array of values */
     if (SM_RB_IS_A(argv[0], rb_cArray)) {
       VALUE arrdata = argv[0];
       const size_t arr_end = arr_index + 3;
@@ -3886,10 +3990,10 @@ static VALUE sm_quat_init(int argc, VALUE *argv, VALUE sm_self)
     break;
   }
 
-  // W
+  /* W */
   case 4: {
     self[0][3] = (s_float_t)rb_num2dbl(argv[3]);
-    case 3: // X, Y, Z
+    case 3: /* X, Y, Z */
     self[0][0] = (s_float_t)rb_num2dbl(argv[0]);
     self[0][1] = (s_float_t)rb_num2dbl(argv[1]);
     self[0][2] = (s_float_t)rb_num2dbl(argv[2]);
@@ -3900,7 +4004,7 @@ static VALUE sm_quat_init(int argc, VALUE *argv, VALUE sm_self)
     rb_raise(rb_eArgError, "Invalid arguments to initialize/set");
     break;
   }
-  } // switch (argc)
+  } /* switch (argc) */
 
   return sm_self;
 }
@@ -3954,6 +4058,7 @@ static VALUE sm_quat_angle_axis(int argc, VALUE *argv, VALUE self)
   axis = sm_unwrap_vec3(sm_axis, NULL);
 
   if (SM_IS_A(sm_out, quat) || SM_IS_A(sm_out, vec4)) {
+    rb_check_frozen(sm_out);
     quat_t *out = sm_unwrap_quat(sm_out, NULL);
     quat_from_angle_axis(angle, (*axis)[0], (*axis)[1], (*axis)[2], *out);
   } else {
@@ -4013,6 +4118,7 @@ static VALUE sm_quat_slerp(int argc, VALUE *argv, VALUE sm_self)
   destination = sm_unwrap_quat(sm_destination, NULL);
 
   if ((SM_IS_A(sm_out, vec4) || SM_IS_A(sm_out, quat))) {
+    rb_check_frozen(sm_out);
     quat_slerp(*self, *destination, alpha, *sm_unwrap_quat(sm_out, NULL));
   } else {
     quat_t out;
@@ -4087,6 +4193,7 @@ static VALUE sm_mat4_store (VALUE sm_self, VALUE sm_index, VALUE sm_value)
   static const int max_index = sizeof(mat4_t) / sizeof(s_float_t);
   mat4_t *self = sm_unwrap_mat4(sm_self, NULL);
   int index = NUM2INT(sm_index);
+  rb_check_frozen(sm_self);
   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);
@@ -4129,30 +4236,32 @@ static VALUE sm_mat4_length (VALUE self)
  * call-seq:
  *    copy(output = nil) -> output or new mat4
  */
- static VALUE sm_mat4_copy(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   mat4_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_mat4(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     SM_RAISE_IF_NOT_TYPE(sm_out, mat4);
-     mat4_t *output = sm_unwrap_mat4(sm_out, NULL);
-     mat4_copy (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     mat4_t output;
-     mat4_copy (*self, 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 copy");
-   }
-   return sm_out;
- }
+static VALUE sm_mat4_copy(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  mat4_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_mat4(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    mat4_t *output;
+    SM_RAISE_IF_NOT_TYPE(sm_out, mat4);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_mat4(sm_out, NULL);
+    mat4_copy (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    mat4_t output;
+    mat4_copy (*self, 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 copy");
+  }
+  return sm_out;
+}
 
 
 
@@ -4162,30 +4271,32 @@ static VALUE sm_mat4_length (VALUE self)
  * call-seq:
  *    to_mat3(output = nil) -> output or new mat3
  */
- static VALUE sm_mat4_to_mat3(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   mat4_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_mat4(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
-     mat3_t *output = sm_unwrap_mat3(sm_out, NULL);
-     mat4_to_mat3 (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     mat3_t output;
-     mat4_to_mat3 (*self, output);
-     sm_out = sm_wrap_mat3(output, s_sm_mat4_klass);
-     rb_obj_call_init(sm_out, 0, 0);
-   }} else {
-     rb_raise(rb_eArgError, "Invalid number of arguments to to_mat3");
-   }
-   return sm_out;
- }
+static VALUE sm_mat4_to_mat3(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  mat4_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_mat4(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    mat3_t *output;
+    SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_mat3(sm_out, NULL);
+    mat4_to_mat3 (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    mat3_t output;
+    mat4_to_mat3 (*self, output);
+    sm_out = sm_wrap_mat3(output, s_sm_mat4_klass);
+    rb_obj_call_init(sm_out, 0, 0);
+  }} else {
+    rb_raise(rb_eArgError, "Invalid number of arguments to to_mat3");
+  }
+  return sm_out;
+}
 
 
 
@@ -4195,30 +4306,32 @@ static VALUE sm_mat4_length (VALUE self)
  * call-seq:
  *    transpose(output = nil) -> output or new mat4
  */
- static VALUE sm_mat4_transpose(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   mat4_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_mat4(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     SM_RAISE_IF_NOT_TYPE(sm_out, mat4);
-     mat4_t *output = sm_unwrap_mat4(sm_out, NULL);
-     mat4_transpose (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     mat4_t output;
-     mat4_transpose (*self, 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 transpose");
-   }
-   return sm_out;
- }
+static VALUE sm_mat4_transpose(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  mat4_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_mat4(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    mat4_t *output;
+    SM_RAISE_IF_NOT_TYPE(sm_out, mat4);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_mat4(sm_out, NULL);
+    mat4_transpose (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    mat4_t output;
+    mat4_transpose (*self, 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 transpose");
+  }
+  return sm_out;
+}
 
 
 
@@ -4228,30 +4341,32 @@ static VALUE sm_mat4_length (VALUE self)
  * call-seq:
  *    inverse_orthogonal(output = nil) -> output or new mat4
  */
- static VALUE sm_mat4_inverse_orthogonal(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   mat4_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_mat4(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     SM_RAISE_IF_NOT_TYPE(sm_out, mat4);
-     mat4_t *output = sm_unwrap_mat4(sm_out, NULL);
-     mat4_inverse_orthogonal (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     mat4_t output;
-     mat4_inverse_orthogonal (*self, 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 inverse_orthogonal");
-   }
-   return sm_out;
- }
+static VALUE sm_mat4_inverse_orthogonal(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  mat4_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_mat4(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    mat4_t *output;
+    SM_RAISE_IF_NOT_TYPE(sm_out, mat4);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_mat4(sm_out, NULL);
+    mat4_inverse_orthogonal (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    mat4_t output;
+    mat4_inverse_orthogonal (*self, 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 inverse_orthogonal");
+  }
+  return sm_out;
+}
 
 
 
@@ -4261,30 +4376,32 @@ static VALUE sm_mat4_length (VALUE self)
  * call-seq:
  *    adjoint(output = nil) -> output or new mat4
  */
- static VALUE sm_mat4_adjoint(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   mat4_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_mat4(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     SM_RAISE_IF_NOT_TYPE(sm_out, mat4);
-     mat4_t *output = sm_unwrap_mat4(sm_out, NULL);
-     mat4_adjoint (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     mat4_t output;
-     mat4_adjoint (*self, 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 adjoint");
-   }
-   return sm_out;
- }
+static VALUE sm_mat4_adjoint(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  mat4_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_mat4(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    mat4_t *output;
+    SM_RAISE_IF_NOT_TYPE(sm_out, mat4);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_mat4(sm_out, NULL);
+    mat4_adjoint (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    mat4_t output;
+    mat4_adjoint (*self, 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 adjoint");
+  }
+  return sm_out;
+}
 
 
 
@@ -4308,8 +4425,10 @@ static VALUE sm_mat4_multiply(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    mat4_t *output;
     SM_RAISE_IF_NOT_TYPE(sm_out, mat4);
-    mat4_t *output = sm_unwrap_mat4(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_mat4(sm_out, NULL);
     mat4_multiply(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -4350,13 +4469,15 @@ static VALUE sm_mat4_multiply_vec4(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec4_t *output;
     if (!SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec4_t *output = sm_unwrap_vec4(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec4(sm_out, NULL);
     mat4_multiply_vec4(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -4397,13 +4518,15 @@ static VALUE sm_mat4_transform_vec3(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec3_t *output;
     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
     mat4_transform_vec3(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -4445,13 +4568,15 @@ static VALUE sm_mat4_rotate_vec3(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec3_t *output;
     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
     mat4_rotate_vec3(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -4493,13 +4618,15 @@ static VALUE sm_mat4_inv_rotate_vec3(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec3_t *output;
     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
     mat4_inv_rotate_vec3(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -4543,6 +4670,7 @@ static VALUE sm_mat4_inverse_affine(int argc, VALUE *argv, VALUE sm_self)
         rb_obj_classname(sm_out));
       return Qnil;
     }
+    rb_check_frozen(sm_out);
 
     output = sm_unwrap_mat4(sm_out, NULL);
     if (!mat4_inverse_affine(*self, *output)) {
@@ -4596,6 +4724,7 @@ static VALUE sm_mat4_inverse_general(int argc, VALUE *argv, VALUE sm_self)
         rb_obj_classname(sm_out));
       return Qnil;
     }
+    rb_check_frozen(sm_out);
 
     output = sm_unwrap_mat4(sm_out, NULL);
     if (!mat4_inverse_general(*self, *output)) {
@@ -4671,6 +4800,7 @@ static VALUE sm_mat4_translate(int argc, VALUE *argv, VALUE sm_self)
 
     SM_LABEL(get_output):
     if (RTEST(sm_out)) {
+      rb_check_frozen(sm_out);
       mat4_t *out = sm_unwrap_mat4(sm_out, NULL);
       mat4_translate(xyz[0], xyz[1], xyz[2], *self, *out);
     } else {
@@ -4722,6 +4852,7 @@ static VALUE sm_mat4_translation(int argc, VALUE *argv, VALUE sm_self)
 
     SM_LABEL(get_output):
     if (RTEST(sm_out)) {
+      rb_check_frozen(sm_out);
       mat4_t *out = sm_unwrap_mat4(sm_out, NULL);
       mat4_translation(xyz[0], xyz[1], xyz[2], *out);
     } else {
@@ -4775,40 +4906,42 @@ static VALUE sm_mat4_init(int argc, VALUE *argv, VALUE sm_self)
   mat4_t *self = sm_unwrap_mat4(sm_self, NULL);
   size_t arr_index = 0;
 
+  rb_check_frozen(sm_self);
+
   switch (argc) {
 
   case 0: {
-    // Identity (handled in _new)
+    /* Identity (handled in _new) */
     break;
   }
 
-  // Copy Mat4 or provided [Numeric..]
+  /* Copy Mat4 or provided [Numeric..] */
   case 1: {
-    // Copy Mat4
+    /* Copy Mat4 */
     if (SM_IS_A(argv[0], mat4)) {
       sm_unwrap_mat4(argv[0], *self);
       break;
     }
 
-    // Copy Mat3
+    /* Copy Mat3 */
     if (SM_IS_A(argv[0], mat3)) {
       mat3_to_mat4(*sm_unwrap_mat4(argv[0], NULL), *self);
       break;
     }
 
-    // Build from Quaternion
+    /* Build from Quaternion */
     if (SM_IS_A(argv[0], quat)) {
       mat4_from_quat(*sm_unwrap_quat(argv[0], NULL), *self);
       break;
     }
 
-    // Optional offset into array provided
+    /* Optional offset into array provided */
     if (0) {
       case 2:
       arr_index = NUM2SIZET(argv[1]);
     }
 
-    // Array of values
+    /* Array of values */
     if (SM_RB_IS_A(argv[0], rb_cArray)) {
       VALUE arrdata = argv[0];
       const size_t arr_end = arr_index + 16;
@@ -4823,7 +4956,7 @@ static VALUE sm_mat4_init(int argc, VALUE *argv, VALUE sm_self)
     break;
   }
 
-  // Mat4(Vec4, Vec4, Vec4, Vec4)
+  /* Mat4(Vec4, Vec4, Vec4, Vec4) */
   case 4: {
     size_t arg_index;
     s_float_t *mat_elem = *self;
@@ -4840,7 +4973,7 @@ static VALUE sm_mat4_init(int argc, VALUE *argv, VALUE sm_self)
     break;
   }
 
-  // Mat4(Numeric m00 .. m16)
+  /* Mat4(Numeric m00 .. m16) */
   case 16: {
     s_float_t *mat_elem = *self;
     VALUE *argv_p = argv;
@@ -4854,7 +4987,7 @@ static VALUE sm_mat4_init(int argc, VALUE *argv, VALUE sm_self)
     rb_raise(rb_eArgError, "Invalid arguments to initialize/set");
     break;
   }
-  } // swtich (argc)
+  } /* switch (argc) */
 
   return sm_self;
 }
@@ -4917,6 +5050,7 @@ static VALUE sm_mat4_angle_axis(int argc, VALUE *argv, VALUE self)
   axis = sm_unwrap_vec3(sm_axis, NULL);
 
   if (SM_IS_A(sm_out, mat4)) {
+    rb_check_frozen(sm_out);
     mat4_t *out = sm_unwrap_mat4(sm_out, NULL);
     mat4_rotation(angle, (*axis)[0], (*axis)[1], (*axis)[2], *out);
   } else {
@@ -4965,6 +5099,7 @@ static VALUE sm_mat4_get_row3(int argc, VALUE *argv, VALUE sm_self)
           rb_obj_classname(sm_out));
         return Qnil;
       }
+      rb_check_frozen(sm_out);
     } else {
       goto SM_LABEL(no_output);
     }
@@ -5028,6 +5163,7 @@ static VALUE sm_mat4_get_row4(int argc, VALUE *argv, VALUE sm_self)
           rb_obj_classname(sm_out));
         return Qnil;
       }
+      rb_check_frozen(sm_out);
     } else {
       goto SM_LABEL(no_output);
     }
@@ -5091,6 +5227,7 @@ static VALUE sm_mat4_get_column3(int argc, VALUE *argv, VALUE sm_self)
           rb_obj_classname(sm_out));
         return Qnil;
       }
+      rb_check_frozen(sm_out);
     } else {
       goto SM_LABEL(no_output);
     }
@@ -5154,6 +5291,7 @@ static VALUE sm_mat4_get_column4(int argc, VALUE *argv, VALUE sm_self)
           rb_obj_classname(sm_out));
         return Qnil;
       }
+      rb_check_frozen(sm_out);
     } else {
       goto SM_LABEL(no_output);
     }
@@ -5370,6 +5508,7 @@ static VALUE sm_mat4_frustum(int argc, VALUE *argv, VALUE self)
   z_far = (s_float_t)rb_num2dbl(sm_z_far);
 
   if (SM_IS_A(sm_out, mat4)) {
+    rb_check_frozen(sm_out);
     mat4_t *out = sm_unwrap_mat4(sm_out, NULL);
     mat4_frustum(left, right, bottom, top, z_near, z_far, *out);
   } else {
@@ -5416,6 +5555,7 @@ static VALUE sm_mat4_orthographic(int argc, VALUE *argv, VALUE self)
   z_far = (s_float_t)rb_num2dbl(sm_z_far);
 
   if (SM_IS_A(sm_out, mat4)) {
+    rb_check_frozen(sm_out);
     mat4_t *out = sm_unwrap_mat4(sm_out, NULL);
     mat4_orthographic(left, right, bottom, top, z_near, z_far, *out);
   } else {
@@ -5456,6 +5596,7 @@ static VALUE sm_mat4_perspective(int argc, VALUE *argv, VALUE self)
   z_far = (s_float_t)rb_num2dbl(sm_z_far);
 
   if (SM_IS_A(sm_out, mat4)) {
+    rb_check_frozen(sm_out);
     mat4_t *out = sm_unwrap_mat4(sm_out, NULL);
     mat4_perspective(fov_y, aspect, z_near, z_far, *out);
   } else {
@@ -5494,6 +5635,7 @@ static VALUE sm_mat4_look_at(int argc, VALUE *argv, VALUE self)
   up = sm_unwrap_vec3(sm_up, NULL);
 
   if (SM_IS_A(sm_out, mat4)) {
+    rb_check_frozen(sm_out);
     mat4_t *out = sm_unwrap_mat4(sm_out, NULL);
     mat4_look_at(*eye, *center, *up, *out);
   } else {
@@ -5527,6 +5669,7 @@ static VALUE sm_mat4_scale(int argc, VALUE *argv, VALUE sm_self)
   z = rb_num2dbl(sm_z);
 
   if (SM_IS_A(sm_out, mat4)) {
+    rb_check_frozen(sm_out);
     mat4_scale(*self, x, y, z, *sm_unwrap_mat4(sm_out, NULL));
   } else {
     mat4_t out;
@@ -5618,6 +5761,7 @@ static VALUE sm_mat3_store (VALUE sm_self, VALUE sm_index, VALUE sm_value)
   static const int max_index = sizeof(mat3_t) / sizeof(s_float_t);
   mat3_t *self = sm_unwrap_mat3(sm_self, NULL);
   int index = NUM2INT(sm_index);
+  rb_check_frozen(sm_self);
   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);
@@ -5660,30 +5804,32 @@ static VALUE sm_mat3_length (VALUE self)
  * call-seq:
  *    copy(output = nil) -> output or new mat3
  */
- static VALUE sm_mat3_copy(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   mat3_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_mat3(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
-     mat3_t *output = sm_unwrap_mat3(sm_out, NULL);
-     mat3_copy (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     mat3_t output;
-     mat3_copy (*self, 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 copy");
-   }
-   return sm_out;
- }
+static VALUE sm_mat3_copy(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  mat3_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_mat3(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    mat3_t *output;
+    SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_mat3(sm_out, NULL);
+    mat3_copy (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    mat3_t output;
+    mat3_copy (*self, 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 copy");
+  }
+  return sm_out;
+}
 
 
 
@@ -5693,30 +5839,32 @@ static VALUE sm_mat3_length (VALUE self)
  * call-seq:
  *    to_mat4(output = nil) -> output or new mat4
  */
- static VALUE sm_mat3_to_mat4(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   mat3_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_mat3(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     SM_RAISE_IF_NOT_TYPE(sm_out, mat4);
-     mat4_t *output = sm_unwrap_mat4(sm_out, NULL);
-     mat3_to_mat4 (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     mat4_t output;
-     mat3_to_mat4 (*self, output);
-     sm_out = sm_wrap_mat4(output, s_sm_mat3_klass);
-     rb_obj_call_init(sm_out, 0, 0);
-   }} else {
-     rb_raise(rb_eArgError, "Invalid number of arguments to to_mat4");
-   }
-   return sm_out;
- }
+static VALUE sm_mat3_to_mat4(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  mat3_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_mat3(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    mat4_t *output;
+    SM_RAISE_IF_NOT_TYPE(sm_out, mat4);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_mat4(sm_out, NULL);
+    mat3_to_mat4 (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    mat4_t output;
+    mat3_to_mat4 (*self, output);
+    sm_out = sm_wrap_mat4(output, s_sm_mat3_klass);
+    rb_obj_call_init(sm_out, 0, 0);
+  }} else {
+    rb_raise(rb_eArgError, "Invalid number of arguments to to_mat4");
+  }
+  return sm_out;
+}
 
 
 
@@ -5726,30 +5874,32 @@ static VALUE sm_mat3_length (VALUE self)
  * call-seq:
  *    transpose(output = nil) -> output or new mat3
  */
- static VALUE sm_mat3_transpose(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   mat3_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_mat3(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
-     mat3_t *output = sm_unwrap_mat3(sm_out, NULL);
-     mat3_transpose (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     mat3_t output;
-     mat3_transpose (*self, 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 transpose");
-   }
-   return sm_out;
- }
+static VALUE sm_mat3_transpose(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  mat3_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_mat3(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    mat3_t *output;
+    SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_mat3(sm_out, NULL);
+    mat3_transpose (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    mat3_t output;
+    mat3_transpose (*self, 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 transpose");
+  }
+  return sm_out;
+}
 
 
 
@@ -5759,30 +5909,32 @@ static VALUE sm_mat3_length (VALUE self)
  * call-seq:
  *    adjoint(output = nil) -> output or new mat3
  */
- static VALUE sm_mat3_adjoint(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   mat3_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_mat3(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
-     mat3_t *output = sm_unwrap_mat3(sm_out, NULL);
-     mat3_adjoint (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     mat3_t output;
-     mat3_adjoint (*self, 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 adjoint");
-   }
-   return sm_out;
- }
+static VALUE sm_mat3_adjoint(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  mat3_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_mat3(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    mat3_t *output;
+    SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_mat3(sm_out, NULL);
+    mat3_adjoint (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    mat3_t output;
+    mat3_adjoint (*self, 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 adjoint");
+  }
+  return sm_out;
+}
 
 
 
@@ -5792,30 +5944,32 @@ static VALUE sm_mat3_length (VALUE self)
  * call-seq:
  *    orthogonal(output = nil) -> output or new mat3
  */
- static VALUE sm_mat3_orthogonal(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   mat3_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_mat3(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
-     mat3_t *output = sm_unwrap_mat3(sm_out, NULL);
-     mat3_orthogonal (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     mat3_t output;
-     mat3_orthogonal (*self, 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 orthogonal");
-   }
-   return sm_out;
- }
+static VALUE sm_mat3_orthogonal(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  mat3_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_mat3(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    mat3_t *output;
+    SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_mat3(sm_out, NULL);
+    mat3_orthogonal (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    mat3_t output;
+    mat3_orthogonal (*self, 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 orthogonal");
+  }
+  return sm_out;
+}
 
 
 
@@ -5825,30 +5979,32 @@ static VALUE sm_mat3_length (VALUE self)
  * call-seq:
  *    cofactor(output = nil) -> output or new mat3
  */
- static VALUE sm_mat3_cofactor(int argc, VALUE *argv, VALUE sm_self)
- {
-   VALUE sm_out;
-   mat3_t *self;
-   rb_scan_args(argc, argv, "01", &sm_out);
-   self = sm_unwrap_mat3(sm_self, NULL);
-   if (argc == 1) {
-     if (!RTEST(sm_out)) {
-       goto SM_LABEL(skip_output);
-     }{
-     SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
-     mat3_t *output = sm_unwrap_mat3(sm_out, NULL);
-     mat3_cofactor (*self, *output);
-   }} else if (argc == 0) {
- SM_LABEL(skip_output): {
-     mat3_t output;
-     mat3_cofactor (*self, 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 cofactor");
-   }
-   return sm_out;
- }
+static VALUE sm_mat3_cofactor(int argc, VALUE *argv, VALUE sm_self)
+{
+  VALUE sm_out;
+  mat3_t *self;
+  rb_scan_args(argc, argv, "01", &sm_out);
+  self = sm_unwrap_mat3(sm_self, NULL);
+  if (argc == 1) {
+    if (!RTEST(sm_out)) {
+      goto SM_LABEL(skip_output);
+    }{
+    mat3_t *output;
+    SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_mat3(sm_out, NULL);
+    mat3_cofactor (*self, *output);
+  }} else if (argc == 0) {
+SM_LABEL(skip_output): {
+    mat3_t output;
+    mat3_cofactor (*self, 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 cofactor");
+  }
+  return sm_out;
+}
 
 
 
@@ -5872,8 +6028,10 @@ static VALUE sm_mat3_multiply(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    mat3_t *output;
     SM_RAISE_IF_NOT_TYPE(sm_out, mat3);
-    mat3_t *output = sm_unwrap_mat3(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_mat3(sm_out, NULL);
     mat3_multiply(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -5914,13 +6072,15 @@ static VALUE sm_mat3_rotate_vec3(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec3_t *output;
     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
     mat3_rotate_vec3(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -5962,13 +6122,15 @@ static VALUE sm_mat3_inv_rotate_vec3(int argc, VALUE *argv, VALUE sm_self)
     if (!RTEST(sm_out)) {
       goto SM_LABEL(skip_output);
     }{
+    vec3_t *output;
     if (!SM_IS_A(sm_out, vec3) && !SM_IS_A(sm_out, vec4) && !SM_IS_A(sm_out, quat)) {
       rb_raise(rb_eTypeError,
         kSM_WANT_THREE_OR_FOUR_FORMAT_LIT,
         rb_obj_classname(sm_out));
       return Qnil;
     }
-    vec3_t *output = sm_unwrap_vec3(sm_out, NULL);
+    rb_check_frozen(sm_out);
+    output = sm_unwrap_vec3(sm_out, NULL);
     mat3_inv_rotate_vec3(*self, *rhs, *output);
   }} else if (argc == 1) {
 SM_LABEL(skip_output): {
@@ -6026,6 +6188,7 @@ static VALUE sm_mat3_inverse(int argc, VALUE *argv, VALUE sm_self)
       return Qnil;
     }
 
+    rb_check_frozen(sm_out);
     output = sm_unwrap_mat3(sm_out, NULL);
     if (!mat3_inverse(*self, *output)) {
       return Qnil;
@@ -6087,40 +6250,42 @@ static VALUE sm_mat3_init(int argc, VALUE *argv, VALUE sm_self)
   mat3_t *self = sm_unwrap_mat3(sm_self, NULL);
   size_t arr_index = 0;
 
+  rb_check_frozen(sm_self);
+
   switch (argc) {
 
   case 0: {
-    // Identity (handled in _new)
+    /* Identity (handled in _new) */
     break;
   }
 
-  // Copy Mat3 or provided [Numeric..]
+  /* Copy Mat3 or provided [Numeric..] */
   case 1: {
-    // Copy Mat3
+    /* Copy Mat3 */
     if (SM_IS_A(argv[0], mat3)) {
       sm_unwrap_mat3(argv[0], *self);
       break;
     }
 
-    // Copy Mat4
+    /* Copy Mat4 */
     if (SM_IS_A(argv[0], mat4)) {
       mat4_to_mat3(*sm_unwrap_mat4(argv[0], NULL), *self);
       break;
     }
 
-    // Build from Quaternion
+    /* Build from Quaternion */
     if (SM_IS_A(argv[0], quat)) {
       mat3_from_quat(*sm_unwrap_quat(argv[0], NULL), *self);
       break;
     }
 
-    // Optional offset into array provided
+    /* Optional offset into array provided */
     if (0) {
       case 2:
       arr_index = NUM2SIZET(argv[1]);
     }
 
-    // Array of values
+    /* Array of values */
     if (SM_RB_IS_A(argv[0], rb_cArray)) {
       VALUE arrdata = argv[0];
       const size_t arr_end = arr_index + 9;
@@ -6135,7 +6300,7 @@ static VALUE sm_mat3_init(int argc, VALUE *argv, VALUE sm_self)
     break;
   }
 
-  // Mat3(Vec3, Vec3, Vec3)
+  /* Mat3(Vec3, Vec3, Vec3) */
   case 3: {
     size_t arg_index;
     s_float_t *mat_elem = *self;
@@ -6152,7 +6317,7 @@ static VALUE sm_mat3_init(int argc, VALUE *argv, VALUE sm_self)
     break;
   }
 
-  // Mat3(Numeric m00 .. m16)
+  /* Mat3(Numeric m00 .. m16) */
   case 9: {
     s_float_t *mat_elem = *self;
     VALUE *argv_p = argv;
@@ -6166,7 +6331,7 @@ static VALUE sm_mat3_init(int argc, VALUE *argv, VALUE sm_self)
     rb_raise(rb_eArgError, "Invalid arguments to initialize/set");
     break;
   }
-  } // swtich (argc)
+  } /* switch (argc) */
 
   return sm_self;
 }
@@ -6226,6 +6391,7 @@ static VALUE sm_mat3_angle_axis(int argc, VALUE *argv, VALUE self)
   axis = sm_unwrap_vec3(sm_axis, NULL);
 
   if (SM_IS_A(sm_out, mat3)) {
+    rb_check_frozen(sm_out);
     mat3_t *out = sm_unwrap_mat3(sm_out, NULL);
     mat3_rotation(angle, (*axis)[0], (*axis)[1], (*axis)[2], *out);
   } else {
@@ -6274,6 +6440,7 @@ static VALUE sm_mat3_get_row3(int argc, VALUE *argv, VALUE sm_self)
           rb_obj_classname(sm_out));
         return Qnil;
       }
+      rb_check_frozen(sm_out);
     } else {
       goto SM_LABEL(no_output);
     }
@@ -6337,6 +6504,7 @@ static VALUE sm_mat3_get_column3(int argc, VALUE *argv, VALUE sm_self)
           rb_obj_classname(sm_out));
         return Qnil;
       }
+      rb_check_frozen(sm_out);
     } else {
       goto SM_LABEL(no_output);
     }
@@ -6470,6 +6638,7 @@ static VALUE sm_mat3_scale(int argc, VALUE *argv, VALUE sm_self)
   z = rb_num2dbl(sm_z);
 
   if (SM_IS_A(sm_out, mat3)) {
+    rb_check_frozen(sm_out);
     mat3_scale(*self, x, y, z, *sm_unwrap_mat3(sm_out, NULL));
   } else {
     mat3_t out;
@@ -6656,7 +6825,7 @@ void Init_bindings()
   rb_define_method(s_sm_quat_klass, "multiply_quat", sm_quat_multiply, -1);
   rb_define_method(s_sm_quat_klass, "multiply_vec3", sm_quat_multiply_vec3, -1);
   rb_define_method(s_sm_quat_klass, "slerp", sm_quat_slerp, -1);
-  // Borrow some functions from vec4
+  /* Borrow some functions from vec4 */
   rb_define_method(s_sm_quat_klass, "copy", sm_vec4_copy, -1);
   rb_define_method(s_sm_quat_klass, "negate", sm_vec4_negate, -1);
   rb_define_method(s_sm_quat_klass, "normalize", sm_vec4_normalize, -1);