diff --git a/src/CRE/Glitter/render_group.cpp b/src/CRE/Glitter/render_group.cpp
index ef3126c8..043f1708 100644
--- a/src/CRE/Glitter/render_group.cpp
+++ b/src/CRE/Glitter/render_group.cpp
@@ -349,7 +349,7 @@ namespace Glitter {
             vec3 axis;
             float_t angle;
             axis_angle_from_vectors(&axis, &angle, &vec1, &vec2);
-            mat4_mult_axis_angle(&mat, &axis, angle, &mat);
+            mat4_mul_rotation(&mat, &axis, angle, &mat);
         }
         else
             mat4_rotate_z((float_t)M_PI, &mat);
@@ -373,7 +373,7 @@ namespace Glitter {
             vec3 axis;
             float_t angle;
             axis_angle_from_vectors(&axis, &angle, &vec1, &vec2);
-            mat4_mult_axis_angle(&mat, &axis, angle, &mat);
+            mat4_mul_rotation(&mat, &axis, angle, &mat);
         }
         return mat;
     }
@@ -733,8 +733,8 @@ namespace Glitter {
         float_t angle;
         axis_angle_from_vectors(&axis, &angle, &vec1, &vec2);
 
-        mat4 mat;
-        mat4_mult_axis_angle(&mat4_identity, &axis, angle, &mat);
+        mat4 mat = mat4_identity;
+        mat4_mul_rotation(&mat, &axis, angle, &mat);
         return mat;
     }
 
@@ -753,8 +753,8 @@ namespace Glitter {
         float_t angle;
         axis_angle_from_vectors(&axis, &angle, &vec1, &vec2);
 
-        mat4 mat;
-        mat4_mult_axis_angle(&mat4_identity, &axis, angle, &mat);
+        mat4 mat = mat4_identity;
+        mat4_mul_rotation(&mat, &axis, angle, &mat);
         return mat;
     }
 
@@ -775,8 +775,8 @@ namespace Glitter {
         float_t angle;
         axis_angle_from_vectors(&axis, &angle, &vec1, &vec2);
 
-        mat4 mat;
-        mat4_mult_axis_angle(&mat4_identity, &axis, angle, &mat);
+        mat4 mat = mat4_identity;
+        mat4_mul_rotation(&mat, &axis, angle, &mat);
         return mat;
     }
 
@@ -795,8 +795,8 @@ namespace Glitter {
         float_t angle;
         axis_angle_from_vectors(&axis, &angle, &vec1, &vec2);
 
-        mat4 mat;
-        mat4_mult_axis_angle(&mat4_identity, &axis, angle, &mat);
+        mat4 mat = mat4_identity;
+        mat4_mul_rotation(&mat, &axis, angle, &mat);
         return mat;
     }
 }
diff --git a/src/CRE/Glitter/render_scene.cpp b/src/CRE/Glitter/render_scene.cpp
index 7d633e28..d8737674 100644
--- a/src/CRE/Glitter/render_scene.cpp
+++ b/src/CRE/Glitter/render_scene.cpp
@@ -297,7 +297,7 @@ namespace Glitter {
                 scale.z = 0.0f;
             mat4_transform_vector(&rend_group->mat_rot, &scale, &scale);
 
-            mat3_from_mat4(&rend_group->mat, &model_mat);
+            mat4_to_mat3(&rend_group->mat, &model_mat);
             mat3_normalize_rotation(&model_mat, &model_mat);
         }
         else
@@ -420,7 +420,7 @@ namespace Glitter {
             model_mat = rend_group->mat;
             mat4_normalize_rotation(&model_mat, &view_mat);
             mat4_mul(&view_mat, &GPM_VAL->cam.view, &view_mat);
-            mat4_inverse(&view_mat, &inv_view_mat);
+            mat4_invert(&view_mat, &inv_view_mat);
         }
         else {
             model_mat = mat4_identity;
@@ -431,7 +431,7 @@ namespace Glitter {
         if (rend_group->flags & PARTICLE_LOCAL) {
             mat4_mul(&inv_view_mat, &rend_group->mat, &inv_view_mat);
             mat4_mul(&view_mat, &inv_view_mat, &view_mat);
-            mat4_inverse(&view_mat, &inv_view_mat);
+            mat4_invert(&view_mat, &inv_view_mat);
         }
 
         mat4_mul(&view_mat, &GPM_VAL->cam.inv_view, &rend_group->mat_draw);
@@ -486,7 +486,7 @@ namespace Glitter {
     void F2RenderScene::CalcDispQuadDirectionRotation(
         F2RenderGroup* rend_group, mat4* model_mat, mat4* dir_mat) {
         mat4 inv_model_mat;
-        mat4_inverse(model_mat, &inv_model_mat);
+        mat4_invert(model_mat, &inv_model_mat);
         mat4_clear_trans(&inv_model_mat, &inv_model_mat);
 
         vec3 x_vec_base = { 1.0f, 0.0f, 0.0f };
@@ -614,7 +614,7 @@ namespace Glitter {
     void F2RenderScene::CalcDispQuadNormal(GPM,
         F2RenderGroup* rend_group, mat4* model_mat, mat4* dir_mat) {
         mat4 inv_model_mat;
-        mat4_inverse(model_mat, &inv_model_mat);
+        mat4_invert(model_mat, &inv_model_mat);
         mat4_clear_trans(&inv_model_mat, &inv_model_mat);
 
         vec3 x_vec = { 1.0f, 0.0f, 0.0f };
@@ -628,7 +628,7 @@ namespace Glitter {
             dist_to_cam = GPM_VAL->cam.view_point - dist_to_cam;
             if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
                 mat4_normalize_rotation(model_mat, &z_offset_inv_mat);
-                mat4_inverse(&z_offset_inv_mat, &z_offset_inv_mat);
+                mat4_invert(&z_offset_inv_mat, &z_offset_inv_mat);
             }
         }
 
@@ -1306,7 +1306,7 @@ namespace Glitter {
             if (!(has_scale |= fabsf(scale.z) > 0.000001f ? true : false))
                 scale.z = 0.0f;
 
-            mat3_from_mat4(&rend_group->mat, &model_mat);
+            mat4_to_mat3(&rend_group->mat, &model_mat);
             mat3_normalize_rotation(&model_mat, &model_mat);
         }
         else
@@ -1433,7 +1433,7 @@ namespace Glitter {
             model_mat = rend_group->mat;
             mat4_normalize_rotation(&model_mat, &view_mat);
             mat4_mul(&view_mat, &GPM_VAL->cam.view, &view_mat);
-            mat4_inverse(&view_mat, &inv_view_mat);
+            mat4_invert(&view_mat, &inv_view_mat);
 
             emitter_local = true;
             if (rend_group->flags & PARTICLE_SCALE) {
@@ -1451,7 +1451,7 @@ namespace Glitter {
         if (rend_group->flags & PARTICLE_LOCAL) {
             mat4_mul(&inv_view_mat, &rend_group->mat, &inv_view_mat);
             mat4_mul(&view_mat, &inv_view_mat, &view_mat);
-            mat4_inverse(&view_mat, &inv_view_mat);
+            mat4_invert(&view_mat, &inv_view_mat);
             local = true;
         }
         mat4_mul(&view_mat, &GPM_VAL->cam.inv_view, &rend_group->mat_draw);
@@ -1625,7 +1625,7 @@ namespace Glitter {
             else
                 mat4_normalize_rotation(&rend_group->mat, &view_mat);
             mat4_mul(&view_mat, &GPM_VAL->cam.view, &view_mat);
-            mat4_inverse(&view_mat, &inv_view_mat);
+            mat4_invert(&view_mat, &inv_view_mat);
         }
         else {
             model_mat = mat4_identity;
@@ -1637,7 +1637,7 @@ namespace Glitter {
             if (rend_group->flags & PARTICLE_EMITTER_LOCAL)
                 mat4_mul(&inv_view_mat, &rend_group->mat, &inv_view_mat);
             mat4_mul(&view_mat, &inv_view_mat, &view_mat);
-            mat4_inverse(&view_mat, &inv_view_mat);
+            mat4_invert(&view_mat, &inv_view_mat);
         }
         mat4_mul(&view_mat, &GPM_VAL->cam.inv_view, &rend_group->mat_draw);
 
@@ -1680,7 +1680,7 @@ namespace Glitter {
 
     void XRenderScene::CalcDispQuadDirectionRotation(XRenderGroup* rend_group, mat4* model_mat) {
         mat4 inv_model_mat;
-        mat4_inverse(model_mat, &inv_model_mat);
+        mat4_invert(model_mat, &inv_model_mat);
         mat4_clear_trans(&inv_model_mat, &inv_model_mat);
 
         vec3 x_vec_base = { 1.0f, 0.0f, 0.0f };
@@ -1807,7 +1807,7 @@ namespace Glitter {
 
     void XRenderScene::CalcDispQuadNormal(XRenderGroup* rend_group, mat4* model_mat, mat4* dir_mat) {
         mat4 inv_model_mat;
-        mat4_inverse(model_mat, &inv_model_mat);
+        mat4_invert(model_mat, &inv_model_mat);
         mat4_clear_trans(&inv_model_mat, &inv_model_mat);
 
         vec3 x_vec = { 1.0f, 0.0f, 0.0f };
@@ -1821,7 +1821,7 @@ namespace Glitter {
             dist_to_cam = GPM_VAL->cam.view_point - dist_to_cam;
             if (rend_group->flags & PARTICLE_EMITTER_LOCAL) {
                 mat4_normalize_rotation(model_mat, &z_offset_inv_mat);
-                mat4_inverse(&z_offset_inv_mat, &z_offset_inv_mat);
+                mat4_invert(&z_offset_inv_mat, &z_offset_inv_mat);
             }
         }
 
diff --git a/src/CRE/camera.cpp b/src/CRE/camera.cpp
index ab10fb15..5bf4303e 100644
--- a/src/CRE/camera.cpp
+++ b/src/CRE/camera.cpp
@@ -340,7 +340,7 @@ void camera::update_data() {
 
     if (changed_proj || changed_view) {
         mat4_mul(&view, &projection, &view_projection);
-        mat4_inverse(&view_projection, &inv_view_projection);
+        mat4_invert(&view_projection, &inv_view_projection);
     }
 
     changed_proj = false;
@@ -356,7 +356,7 @@ static void camera_calculate_forward(camera* c) {
 
 static void camera_calculate_projection(camera* c) {
     mat4_persp(c->fov_rad, c->aspect, c->min_distance, c->max_distance, &c->projection);
-    mat4_inverse(&c->projection, &c->inv_projection);
+    mat4_invert(&c->projection, &c->inv_projection);
 
     resolution_struct* res_wind_int = res_window_internal_get();
 
@@ -443,7 +443,7 @@ static void camera_calculate_view(camera* c) {
         *(vec3*)&c->inv_view.row0 = x_axis;
         *(vec3*)&c->inv_view.row1 = y_axis;
         *(vec3*)&c->inv_view.row2 = z_axis;
-        mat4_inverse(&c->inv_view, &c->view);
+        mat4_invert(&c->inv_view, &c->view);
         mat4_get_rotation(&c->inv_view, &c->rotation);
     }
     else {
@@ -461,11 +461,11 @@ static void camera_calculate_view(camera* c) {
 
         mat4_rotate_zxy(&rotation, &c->view);
         mat4_mul_translate(&c->view, &view_point, &c->view);
-        mat4_inverse(&c->view, &c->inv_view);
+        mat4_invert(&c->view, &c->inv_view);
     }
 
-    mat3_from_mat4(&c->view, &c->view_mat3);
-    mat3_inverse(&c->view_mat3, &c->inv_view_mat3);
+    mat4_to_mat3(&c->view, &c->view_mat3);
+    mat3_invert(&c->view_mat3, &c->inv_view_mat3);
     mat4_from_mat3(&c->view_mat3, &c->view_rot);
     mat4_from_mat3(&c->inv_view_mat3, &c->inv_view_rot);
 
diff --git a/src/CRE/draw_object.cpp b/src/CRE/draw_object.cpp
index 166d0a4c..c838b41a 100644
--- a/src/CRE/draw_object.cpp
+++ b/src/CRE/draw_object.cpp
@@ -513,7 +513,7 @@ inline void draw_object_model_mat_load(render_context* rctx, const mat4& mat) {
 
 inline void model_mat_face_camera_position(const mat4* view, const mat4* src, mat4* dst) {
     mat4 mat;
-    mat4_inverse_normalized(view, &mat);
+    mat4_invert_fast(view, &mat);
 
     vec3 dir = vec3::normalize(*(vec3*)&mat.row3 - *(vec3*)&src->row3);
 
@@ -537,8 +537,8 @@ inline void model_mat_face_camera_position(const mat4* view, const mat4* src, ma
 
 inline void model_mat_face_camera_view(const mat4* view, const mat4* src, mat4* dst) {
     mat3 mat;
-    mat3_from_mat4(view, &mat);
-    mat3_inverse(&mat, &mat);
+    mat4_to_mat3(view, &mat);
+    mat3_invert(&mat, &mat);
     mat4_from_mat3(&mat, dst);
     mat4_mul(dst, src, dst);
 }
diff --git a/src/CRE/light_param/light.cpp b/src/CRE/light_param/light.cpp
index f02bd331..983c81bd 100644
--- a/src/CRE/light_param/light.cpp
+++ b/src/CRE/light_param/light.cpp
@@ -500,7 +500,7 @@ void light_set::data_set(face& face, light_set_id id) {
                 if (length != 0.0f)
                     axis *= 1.0f / length;
 
-                mat4_from_axis_angle(&axis, -angle, &normal_tangent_transforms);
+                mat4_set(&axis, -angle, &normal_tangent_transforms);
             }
         }
     }
diff --git a/src/CRE/render_context.cpp b/src/CRE/render_context.cpp
index 2ccc23a6..275112cc 100644
--- a/src/CRE/render_context.cpp
+++ b/src/CRE/render_context.cpp
@@ -1496,8 +1496,9 @@ namespace mdl {
             vec3 axis;
             float_t angle;
             Glitter::axis_angle_from_vectors(&axis, &angle, &up, &dir);
-            mat4 m;
-            mat4_mult_axis_angle(&mat4_identity, &axis, angle, &m);
+
+            mat4 m = mat4_identity;
+            mat4_mul_rotation(&m, &axis, angle, &m);
             mat4_mul(&m, &mat, &mat);
 
             indexed = true;
@@ -1515,8 +1516,9 @@ namespace mdl {
             vec3 axis;
             float_t angle;
             Glitter::axis_angle_from_vectors(&axis, &angle, &up, &dir);
-            mat4 m;
-            mat4_mult_axis_angle(&mat4_identity, &axis, angle, &m);
+
+            mat4 m = mat4_identity;
+            mat4_mul_rotation(&m, &axis, angle, &m);
             mat4_mul(&m, &mat, &mat);
 
             indexed = true;
@@ -3339,7 +3341,7 @@ void obj_scene_shader_data::set_projection_view(const mat4& view, const mat4& pr
     g_view[1] = temp.row1;
     g_view[2] = temp.row2;
 
-    mat4_inverse(&view, &temp);
+    mat4_invert(&view, &temp);
     mat4_transpose(&temp, &temp);
     g_view_inverse[0] = temp.row0;
     g_view_inverse[1] = temp.row1;
@@ -3360,7 +3362,7 @@ void obj_batch_shader_data::set_g_joint(const mat4& mat) {
     g_joint[1] = temp.row1;
     g_joint[2] = temp.row2;
 
-    mat4_inverse(&mat, &temp);
+    mat4_invert(&mat, &temp);
     mat4_transpose(&temp, &temp);
     g_joint_inverse[0] = temp.row0;
     g_joint_inverse[1] = temp.row1;
@@ -3383,7 +3385,7 @@ void obj_batch_shader_data::set_transforms(const mat4& model, const mat4& view,
     g_worlds[1] = temp.row1;
     g_worlds[2] = temp.row2;
 
-    mat4_inverse(&model, &temp);
+    mat4_invert(&model, &temp);
     g_worlds_invtrans[0] = temp.row0;
     g_worlds_invtrans[1] = temp.row1;
     g_worlds_invtrans[2] = temp.row2;
@@ -3396,7 +3398,7 @@ void obj_batch_shader_data::set_transforms(const mat4& model, const mat4& view,
     g_worldview[1] = temp.row1;
     g_worldview[2] = temp.row2;
 
-    mat4_inverse(&mv, &temp);
+    mat4_invert(&mv, &temp);
     mat4_transpose(&temp, &temp);
     g_worldview_inverse[0] = temp.row0;
     g_worldview_inverse[1] = temp.row1;
diff --git a/src/CRE/rob/ex_block.cpp b/src/CRE/rob/ex_block.cpp
index a080e1a3..0b00d397 100644
--- a/src/CRE/rob/ex_block.cpp
+++ b/src/CRE/rob/ex_block.cpp
@@ -1727,7 +1727,7 @@ void RobOsage::InitData(obj_skin_block_osage* osg_data, obj_skin_osage_node* osg
             obj_skin_bone* bone = skin->bone_array;
             for (uint32_t j = 0; j < skin->num_bone; j++, bone++)
                 if (bone->id == osg_nodes->name_index) {
-                    mat4_inverse_normalized(&bone->inv_bind_pose_mat, &v26[i].mat);
+                    mat4_invert_fast(&bone->inv_bind_pose_mat, &v26[i].mat);
                     break;
                 }
 
@@ -2365,7 +2365,7 @@ void ExConstraintBlock::Calc() {
         mat4_get_translation(&mat, &trans);
 
         mat3 rot;
-        mat3_from_mat4(source_node_bone_node->mat, &rot);
+        mat4_to_mat3(source_node_bone_node->mat, &rot);
         mat3_normalize_rotation(&rot, &rot);
         mat3_mul_rotate_zyx(&rot, &orientation->offset, &rot);
         mat4_from_mat3(&rot, node->mat);
@@ -2460,7 +2460,7 @@ void ExConstraintBlock::DataSet() {
     vec3 parent_scale = parent_bone_node->exp_data.parent_scale;
 
     mat4 mat;
-    mat4_inverse_normalized(parent_bone_node->ex_data_mat, &mat);
+    mat4_invert_fast(parent_bone_node->ex_data_mat, &mat);
     mat4_mul(bone_node_ptr->mat, &mat, &mat);
     mat4_get_rotation(&mat, &exp_data->rotation);
     mat4_get_translation(&mat, &exp_data->position);
@@ -3116,7 +3116,7 @@ static void sub_140219940(RobCloth* rob_cls) {
 
         mat4_mul_translate(&m, &root_node.trans_orig, &m);
         root.field_D8 = m;
-        mat4_inverse(&m, &m);
+        mat4_invert(&m, &m);
         root.field_118 = m;
     }
 }
diff --git a/src/CRE/rob/rob.cpp b/src/CRE/rob/rob.cpp
index 30d170be..0015e8f1 100644
--- a/src/CRE/rob/rob.cpp
+++ b/src/CRE/rob/rob.cpp
@@ -4974,7 +4974,7 @@ static void bone_data_mult_1(bone_data* a1, mat4* parent_mat, bone_data* a3, boo
 
                 if (bone_data_mult_1_ik(a1, a3)) {
                     mat4 rot_mat;
-                    mat4_invrot_normalized(&mat, &rot_mat);
+                    mat4_invert_rotation_fast(&mat, &rot_mat);
                     mat4_mul(a1->node[0].mat, &rot_mat, &rot_mat);
                     mat4_clear_trans(&rot_mat, &rot_mat);
                     mat4_get_rotation(&rot_mat, &a1->node[0].exp_data.rotation);
@@ -8360,7 +8360,7 @@ static void sub_140409B70(rob_chara_look_anim* look_anim,
         look_anim->field_190 = true;
 
         mat4 mat;
-        mat4_inverse(adjust_mat, &mat);
+        mat4_invert(adjust_mat, &mat);
 
         vec3 v24;
         mat4_transform_point(&mat, target_view_point, &v24);
@@ -8574,7 +8574,7 @@ static void sub_140407280(rob_chara_look_anim* look_anim, std::vector<bone_data>
     head_rot_axis.x = n_kao_mat->row2.x * 0.5f;
     head_rot_axis.y = (n_kao_mat->row2.y + 1.0f) * 0.5f;
     head_rot_axis.z = n_kao_mat->row2.z * 0.5f;
-    mat4_mult_axis_angle(&cl_kao_mat, &head_rot_axis, head_rot_angle, &cl_kao_mat);
+    mat4_mul_rotation(&cl_kao_mat, &head_rot_axis, head_rot_angle, &cl_kao_mat);
     mat4_inverse_transform_point(&cl_kao_mat, &look_anim->field_184, &v67);
 
     float_t v52;
@@ -8619,7 +8619,7 @@ static void sub_140407280(rob_chara_look_anim* look_anim, std::vector<bone_data>
     mat4 cl_kao_mat_backup = bones[MOTION_BONE_CL_KAO].rot_mat[1];
 
     mat4 v74;
-    mat4_inverse(bones[MOTION_BONE_CL_KAO].node->mat, &v74);
+    mat4_invert(bones[MOTION_BONE_CL_KAO].node->mat, &v74);
     mat4_clear_trans(&v74, &v74);
     mat4_clear_trans(&cl_kao_mat, &cl_kao_mat);
     mat4_mul(&cl_kao_mat, &v74, &bones[MOTION_BONE_CL_KAO].rot_mat[1]);
@@ -8718,7 +8718,7 @@ static void sub_140409170(rob_chara_look_anim* look_anim, mat4* adjust_mat,
 
     look_anim->view_point = look_anim->target_view_point;
     mat4 v61;
-    mat4_inverse(adjust_mat, &v61);
+    mat4_invert(adjust_mat, &v61);
     mat4_transform_point(&v61, &look_anim->view_point, &look_anim->view_point);
 
     mat4* kl_eye_l_parent_mat = bones[MOTION_BONE_KL_EYE_L].parent_mat;
diff --git a/src/CRE/sprite.cpp b/src/CRE/sprite.cpp
index e6cec044..b004956a 100644
--- a/src/CRE/sprite.cpp
+++ b/src/CRE/sprite.cpp
@@ -1284,7 +1284,7 @@ namespace spr {
                     vec3 v42[4];
                     mat4 mat;
                     calc_sprite_vertex(args, v42, &mat, font);
-                    mat4_inverse(&mat, &mat);
+                    mat4_invert(&mat, &mat);
                     mat4_transform_point(&mat, &vtx[0], &v42[0]);
                     mat4_transform_point(&mat, &vtx[1], &v42[1]);
                     mat4_transform_point(&mat, &vtx[2], &v42[2]);
diff --git a/src/KKdLib/mat.cpp b/src/KKdLib/mat.cpp
index 94c4e1d0..1d794670 100644
--- a/src/KKdLib/mat.cpp
+++ b/src/KKdLib/mat.cpp
@@ -32,134 +32,120 @@ const mat4 mat4_null = {
     { 0.0f, 0.0f, 0.0f, 0.0f },
 };
 
-inline void mat3_add(const mat3* x, float_t y, mat3* z) {
-    z->row0 = x->row0 + y;
-    z->row1 = x->row1 + y;
-    z->row2 = x->row2 + y;
+inline void mat3_add(const mat3* in_m1, const float_t value, mat3* out_m) {
+    out_m->row0 = in_m1->row0 + value;
+    out_m->row1 = in_m1->row1 + value;
+    out_m->row2 = in_m1->row2 + value;
 }
 
-inline void mat3_add(const mat3* x, const mat3* y, mat3* z) {
-    z->row0 = x->row0 + y->row0;
-    z->row1 = x->row1 + y->row1;
-    z->row2 = x->row2 + y->row2;
+inline void mat3_add(const mat3* in_m1, const mat3* in_m2, mat3* out_m) {
+    out_m->row0 = in_m1->row0 + in_m2->row0;
+    out_m->row1 = in_m1->row1 + in_m2->row1;
+    out_m->row2 = in_m1->row2 + in_m2->row2;
 }
 
-inline void mat3_sub(const mat3* x, float_t y, mat3* z) {
-    z->row0 = x->row0 - y;
-    z->row1 = x->row1 - y;
-    z->row2 = x->row2 - y;
+inline void mat3_sub(const mat3* in_m1, const float_t value, mat3* out_m) {
+    out_m->row0 = in_m1->row0 - value;
+    out_m->row1 = in_m1->row1 - value;
+    out_m->row2 = in_m1->row2 - value;
 }
 
-inline void mat3_sub(const mat3* x, const mat3* y, mat3* z) {
-    z->row0 = x->row0 - y->row0;
-    z->row1 = x->row1 - y->row1;
-    z->row2 = x->row2 - y->row2;
+inline void mat3_sub(const mat3* in_m1, const mat3* in_m2, mat3* out_m) {
+    out_m->row0 = in_m1->row0 - in_m2->row0;
+    out_m->row1 = in_m1->row1 - in_m2->row1;
+    out_m->row2 = in_m1->row2 - in_m2->row2;
 }
 
-inline void mat3_mul(const mat3* x, float_t y, mat3* z) {
-    z->row0 = x->row0 * y;
-    z->row1 = x->row1 * y;
-    z->row2 = x->row2 * y;
+inline void mat3_mul(const mat3* in_m1, const float_t value, mat3* out_m) {
+    out_m->row0 = in_m1->row0 * value;
+    out_m->row1 = in_m1->row1 * value;
+    out_m->row2 = in_m1->row2 * value;
 }
 
-inline void mat3_mul(const mat3* x, const mat3* y, mat3* z) {
+inline void mat3_mul(const mat3* in_m1, const mat3* in_m2, mat3* out_m) {
     __m128 t0;
     __m128 t1;
     __m128 t2;
     __m128 yt;
-    __m128 zt;
     __m128 xt0;
     __m128 xt1;
     __m128 xt2;
-    *(vec3*)&xt0 = x->row0;
-    *(vec3*)&xt1 = x->row1;
-    *(vec3*)&xt2 = x->row2;
-    *(vec3*)&yt = y->row0;
+    xt0 = vec3::load_xmm(in_m1->row0);
+    xt1 = vec3::load_xmm(in_m1->row1);
+    xt2 = vec3::load_xmm(in_m1->row2);
+    yt = vec3::load_xmm(in_m2->row0);
     t0 = _mm_mul_ps(xt0, _mm_shuffle_ps(yt, yt, 0x00));
     t1 = _mm_mul_ps(xt1, _mm_shuffle_ps(yt, yt, 0x55));
     t2 = _mm_mul_ps(xt2, _mm_shuffle_ps(yt, yt, 0xAA));
-    zt = _mm_add_ps(_mm_add_ps(t0, t1), t2);
-    z->row0 = *(vec3*)&zt;
-    *(vec3*)&yt = y->row1;
+    out_m->row0 = vec3::store_xmm(_mm_add_ps(_mm_add_ps(t0, t1), t2));
+    yt = vec3::load_xmm(in_m2->row1);
     t0 = _mm_mul_ps(xt0, _mm_shuffle_ps(yt, yt, 0x00));
     t1 = _mm_mul_ps(xt1, _mm_shuffle_ps(yt, yt, 0x55));
     t2 = _mm_mul_ps(xt2, _mm_shuffle_ps(yt, yt, 0xAA));
-    zt = _mm_add_ps(_mm_add_ps(t0, t1), t2);
-    z->row1 = *(vec3*)&zt;
-    *(vec3*)&yt = y->row2;
+    out_m->row1 = vec3::store_xmm(_mm_add_ps(_mm_add_ps(t0, t1), t2));
+    yt = vec3::load_xmm(in_m2->row2);
     t0 = _mm_mul_ps(xt0, _mm_shuffle_ps(yt, yt, 0x00));
     t1 = _mm_mul_ps(xt1, _mm_shuffle_ps(yt, yt, 0x55));
     t2 = _mm_mul_ps(xt2, _mm_shuffle_ps(yt, yt, 0xAA));
-    zt = _mm_add_ps(_mm_add_ps(t0, t1), t2);
-    z->row2 = *(vec3*)&zt;
+    out_m->row2 = vec3::store_xmm(_mm_add_ps(_mm_add_ps(t0, t1), t2));
 }
 
-inline void mat3_transform_vector(const mat3* x, const vec2* y, vec2* z) {
-    __m128 xt;
+inline void mat3_mul(const mat3* in_m1, const vec3* in_axis, const float_t in_angle, mat3* out_m) {
+    quat q1 = quat(in_m1->row0.x, in_m1->row1.x, in_m1->row2.x, in_m1->row0.y,
+        in_m1->row1.y, in_m1->row2.y, in_m1->row0.z, in_m1->row1.z, in_m1->row2.z);
+    quat q2 = quat(*in_axis, in_angle);
+    quat q3 = quat::mul(q2, q1);
+    mat3_set(&q3, out_m);
+}
+
+inline void mat3_transform_vector(const mat3* in_m1, const vec2* normal, vec2* normalOut) {
     __m128 yt;
-    __m128 zt;
     __m128 zt0;
     __m128 zt1;
-    *(vec2*)&yt = *y;
-    *(vec3*)&xt = x->row0;
-    zt0 = _mm_mul_ps(xt, _mm_shuffle_ps(yt, yt, 0x00));
-    *(vec3*)&xt = x->row1;
-    zt1 = _mm_mul_ps(xt, _mm_shuffle_ps(yt, yt, 0x55));
-    zt = _mm_add_ps(zt0, zt1);
-    *z = *(vec2*)&zt;
+    yt = vec2::load_xmm(*normal);
+    zt0 = _mm_mul_ps(vec3::load_xmm(in_m1->row0), _mm_shuffle_ps(yt, yt, 0x00));
+    zt1 = _mm_mul_ps(vec3::load_xmm(in_m1->row1), _mm_shuffle_ps(yt, yt, 0x55));
+    *normalOut = vec2::store_xmm(_mm_add_ps(zt0, zt1));
 }
 
-inline void mat3_transform_vector(const mat3* x, const vec3* y, vec3* z) {
-    __m128 xt;
+inline void mat3_transform_vector(const mat3* in_m1, const vec3* normal, vec3* normalOut) {
     __m128 yt;
-    __m128 zt;
     __m128 zt0;
     __m128 zt1;
     __m128 zt2;
-    *(vec3*)&yt = *y;
-    *(vec3*)&xt = x->row0;
-    zt0 = _mm_mul_ps(xt, _mm_shuffle_ps(yt, yt, 0x00));
-    *(vec3*)&xt = x->row1;
-    zt1 = _mm_mul_ps(xt, _mm_shuffle_ps(yt, yt, 0x55));
-    *(vec3*)&xt = x->row2;
-    zt2 = _mm_mul_ps(xt, _mm_shuffle_ps(yt, yt, 0xAA));
-    zt = _mm_add_ps(_mm_add_ps(zt0, zt1), zt2);
-    *z = *(vec3*)&zt;
+    yt = vec3::load_xmm(*normal);
+    zt0 = _mm_mul_ps(vec3::load_xmm(in_m1->row0), _mm_shuffle_ps(yt, yt, 0x00));
+    zt1 = _mm_mul_ps(vec3::load_xmm(in_m1->row1), _mm_shuffle_ps(yt, yt, 0x55));
+    zt2 = _mm_mul_ps(vec3::load_xmm(in_m1->row2), _mm_shuffle_ps(yt, yt, 0xAA));
+    *normalOut = vec3::store_xmm(_mm_add_ps(_mm_add_ps(zt0, zt1), zt2));
 }
 
-inline void mat3_inverse_transform_vector(const mat3* x, const vec2* y, vec2* z) {
-    __m128 xt;
+inline void mat3_inverse_transform_vector(const mat3* in_m1, const vec2* normal, vec2* normalOut) {
     __m128 yt;
     __m128 zt;
-    yt = vec2::load_xmm(*y);
-    *(vec3*)&xt = x->row0;
-    zt = _mm_mul_ps(yt, xt);
-    z->x = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
-    *(vec3*)&xt = x->row1;
-    zt = _mm_mul_ps(yt, xt);
-    z->y = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    yt = vec2::load_xmm(*normal);
+    zt = _mm_mul_ps(yt, vec3::load_xmm(in_m1->row0));
+    normalOut->x = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    zt = _mm_mul_ps(yt, vec3::load_xmm(in_m1->row1));
+    normalOut->y = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
 }
 
-inline void mat3_inverse_transform_vector(const mat3* x, const vec3* y, vec3* z) {
-    __m128 xt;
+inline void mat3_inverse_transform_vector(const mat3* in_m1, const vec3* normal, vec3* normalOut) {
     __m128 yt;
     __m128 zt;
-    yt = vec3::load_xmm(*y);
-    *(vec3*)&xt = x->row0;
-    zt = _mm_mul_ps(yt, xt);
+    yt = vec3::load_xmm(*normal);
+    zt = _mm_mul_ps(yt, vec3::load_xmm(in_m1->row0));
     zt = _mm_hadd_ps(zt, zt);
-    z->x = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
-    *(vec3*)&xt = x->row1;
-    zt = _mm_mul_ps(yt, xt);
+    normalOut->x = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    zt = _mm_mul_ps(yt, vec3::load_xmm(in_m1->row1));
     zt = _mm_hadd_ps(zt, zt);
-    z->y = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
-    *(vec3*)&xt = x->row2;
-    zt = _mm_mul_ps(yt, xt);
+    normalOut->y = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    zt = _mm_mul_ps(yt, vec3::load_xmm(in_m1->row2));
     zt = _mm_hadd_ps(zt, zt);
-    z->z = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    normalOut->z = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
 }
 
-inline void mat3_transpose(const mat3* x, mat3* z) {
+inline void mat3_transpose(const mat3* in_m1, mat3* out_m) {
     __m128 xt0;
     __m128 xt1;
     __m128 xt2;
@@ -168,37 +154,30 @@ inline void mat3_transpose(const mat3* x, mat3* z) {
     __m128 yt1;
     __m128 yt2;
     __m128 yt3;
-    __m128 zt0;
-    __m128 zt1;
-    __m128 zt2;
-    xt0 = vec3::load_xmm(x->row0);
-    xt1 = vec3::load_xmm(x->row1);
-    xt2 = vec3::load_xmm(x->row2);
+    xt0 = vec3::load_xmm(in_m1->row0);
+    xt1 = vec3::load_xmm(in_m1->row1);
+    xt2 = vec3::load_xmm(in_m1->row2);
     xt3 = vec4::load_xmm(0.0f);
     yt0 = _mm_unpacklo_ps(xt0, xt1);
     yt1 = _mm_unpackhi_ps(xt0, xt1);
     yt2 = _mm_unpacklo_ps(xt2, xt3);
     yt3 = _mm_unpackhi_ps(xt2, xt3);
-    zt0 = _mm_movelh_ps(yt0, yt2);
-    zt1 = _mm_movehl_ps(yt2, yt0);
-    zt2 = _mm_movelh_ps(yt1, yt3);
-    z->row0 = *(vec3*)&zt0;
-    z->row1 = *(vec3*)&zt1;
-    z->row2 = *(vec3*)&zt2;
+    out_m->row0 = vec3::store_xmm(_mm_movelh_ps(yt0, yt2));
+    out_m->row1 = vec3::store_xmm(_mm_movehl_ps(yt2, yt0));
+    out_m->row2 = vec3::store_xmm(_mm_movelh_ps(yt1, yt3));
 }
 
-void mat3_inverse(const mat3* x, mat3* z) {
+void mat3_invert(const mat3* in_m1, mat3* out_m) {
     vec3 xt0;
     vec3 xt1;
     vec3 xt2;
-    __m128 yt;
     __m128 zt0;
     __m128 zt1;
     __m128 zt2;
     __m128 wt;
-    xt0 = x->row0;
-    xt1 = x->row1;
-    xt2 = x->row2;
+    xt0 = in_m1->row0;
+    xt1 = in_m1->row1;
+    xt2 = in_m1->row2;
     zt0 = _mm_sub_ps(
         _mm_mul_ps(
             _mm_set_ps(0.0f, xt0.y, xt0.z, xt1.y),
@@ -231,65 +210,43 @@ void mat3_inverse(const mat3* x, mat3* z) {
     );
 
     wt = _mm_movelh_ps(_mm_unpacklo_ps(zt0, zt1), zt2);
-    yt = vec3::load_xmm(xt0);
-    wt = _mm_mul_ps(yt, wt);
+    wt = _mm_mul_ps(vec3::load_xmm(xt0), wt);
     wt = _mm_hadd_ps(wt, wt);
     wt = _mm_hadd_ps(wt, wt);
     if (_mm_cvtss_f32(wt) != 0.0f)
         wt = _mm_div_ss(_mm_set_ss(1.0f), wt);
     wt = _mm_shuffle_ps(wt, wt, 0);
-    yt = _mm_mul_ps(zt0, wt);
-    z->row0 = *(vec3*)&yt;
-    yt = _mm_mul_ps(zt1, wt);
-    z->row1 = *(vec3*)&yt;
-    yt = _mm_mul_ps(zt2, wt);
-    z->row2 = *(vec3*)&yt;
+    out_m->row0 = vec3::store_xmm(_mm_mul_ps(zt0, wt));
+    out_m->row1 = vec3::store_xmm(_mm_mul_ps(zt1, wt));
+    out_m->row2 = vec3::store_xmm(_mm_mul_ps(zt2, wt));
 }
 
-inline void mat3_invtrans(const mat3* x, mat3* z) {
-    mat3 t = *x;
-    mat3_inverse(&t, &t);
-    mat3_transpose(&t, &t);
-    *z = t;
+inline void mat3_invert_fast(const mat3* in_m1, mat3* out_m) {
+    mat3_transpose(in_m1, out_m);
 }
 
-inline void mat3_inverse_normalized(const mat3* x, mat3* z) {
-    mat3_transpose(x, z);
+inline void mat3_normalize(const mat3* in_m1, mat3* out_m) {
+    float_t det = mat3_determinant(in_m1);
+    if (det != 0.0f)
+        det = 1.0f / det;
+    out_m->row0 = in_m1->row0 * det;
+    out_m->row1 = in_m1->row1 * det;
+    out_m->row2 = in_m1->row2 * det;
 }
 
-inline void mat3_normalize(const mat3* x, mat3* z) {
-    __m128 det;
-    __m128 xt0;
-    __m128 xt1;
-    __m128 xt2;
-    det = _mm_set_ss(mat3_determinant(x));
-    if (_mm_cvtss_f32(det) != 0.0f)
-        det = _mm_div_ss(_mm_set_ss(1.0f), det);
-    det = _mm_shuffle_ps(det, det, 0);
-    *(vec3*)&xt0 = x->row0;
-    *(vec3*)&xt1 = x->row1;
-    *(vec3*)&xt2 = x->row2;
-    xt0 = _mm_mul_ps(xt0, det);
-    xt1 = _mm_mul_ps(xt1, det);
-    xt2 = _mm_mul_ps(xt2, det);
-    z->row0 = *(vec3*)&xt0;
-    z->row1 = *(vec3*)&xt1;
-    z->row2 = *(vec3*)&xt2;
+inline void mat3_normalize_rotation(const mat3* in_m1, mat3* out_m) {
+    out_m->row0 = vec3::normalize(in_m1->row0);
+    out_m->row1 = vec3::normalize(in_m1->row1);
+    out_m->row2 = vec3::normalize(in_m1->row2);
 }
 
-inline void mat3_normalize_rotation(const mat3* x, mat3* z) {
-    z->row0 = vec3::normalize(x->row0);
-    z->row1 = vec3::normalize(x->row1);
-    z->row2 = vec3::normalize(x->row2);
-}
-
-inline float_t mat3_determinant(const mat3* x) {
+inline float_t mat3_determinant(const mat3* in_m1) {
     vec3 xt0;
     vec3 xt1;
     vec3 xt2;
-    xt0 = x->row0;
-    xt1 = x->row1;
-    xt2 = x->row2;
+    xt0 = in_m1->row0;
+    xt1 = in_m1->row1;
+    xt2 = in_m1->row2;
     float_t b00 = xt0.x * xt1.y * xt2.z;
     float_t b01 = xt0.y * xt1.z * xt2.x;
     float_t b02 = xt0.z * xt1.x * xt2.y;
@@ -299,61 +256,61 @@ inline float_t mat3_determinant(const mat3* x) {
     return b00 + b01 + b02 - b03 - b04 - b05;
 }
 
-inline void mat3_rotate_x(float_t rad, mat3* y) {
+inline void mat3_rotate_x(float_t rad, mat3* out_m) {
     float_t s = sinf(rad);
     float_t c = cosf(rad);
-    *y = mat3_identity;
-    y->row1.y = c;
-    y->row1.z = s;
-    y->row2.y = -s;
-    y->row2.z = c;
+    *out_m = mat3_identity;
+    out_m->row1.y = c;
+    out_m->row1.z = s;
+    out_m->row2.y = -s;
+    out_m->row2.z = c;
 }
 
-inline void mat3_rotate_y(float_t rad, mat3* y) {
+inline void mat3_rotate_y(float_t rad, mat3* out_m) {
     float_t s = sinf(rad);
     float_t c = cosf(rad);
-    *y = mat3_identity;
-    y->row0.x = c;
-    y->row0.z = -s;
-    y->row2.x = s;
-    y->row2.z = c;
+    *out_m = mat3_identity;
+    out_m->row0.x = c;
+    out_m->row0.z = -s;
+    out_m->row2.x = s;
+    out_m->row2.z = c;
 }
 
-inline void mat3_rotate_z(float_t rad, mat3* y) {
+inline void mat3_rotate_z(float_t rad, mat3* out_m) {
     float_t s = sinf(rad);
     float_t c = cosf(rad);
-    *y = mat3_identity;
-    y->row0.x = c;
-    y->row0.y = s;
-    y->row1.x = -s;
-    y->row1.y = c;
+    *out_m = mat3_identity;
+    out_m->row0.x = c;
+    out_m->row0.y = s;
+    out_m->row1.x = -s;
+    out_m->row1.y = c;
 }
 
-inline void mat3_rotate_x(float_t s, float_t c, mat3* y) {
-    *y = mat3_identity;
-    y->row1.y = c;
-    y->row1.z = s;
-    y->row2.y = -s;
-    y->row2.z = c;
+inline void mat3_rotate_x(float_t s, float_t c, mat3* out_m) {
+    *out_m = mat3_identity;
+    out_m->row1.y = c;
+    out_m->row1.z = s;
+    out_m->row2.y = -s;
+    out_m->row2.z = c;
 }
 
-inline void mat3_rotate_y(float_t s, float_t c, mat3* y) {
-    *y = mat3_identity;
-    y->row0.x = c;
-    y->row0.z = -s;
-    y->row2.x = s;
-    y->row2.z = c;
+inline void mat3_rotate_y(float_t s, float_t c, mat3* out_m) {
+    *out_m = mat3_identity;
+    out_m->row0.x = c;
+    out_m->row0.z = -s;
+    out_m->row2.x = s;
+    out_m->row2.z = c;
 }
 
-inline void mat3_rotate_z(float_t s, float_t c, mat3* y) {
-    *y = mat3_identity;
-    y->row0.x = c;
-    y->row0.y = s;
-    y->row1.x = -s;
-    y->row1.y = c;
+inline void mat3_rotate_z(float_t s, float_t c, mat3* out_m) {
+    *out_m = mat3_identity;
+    out_m->row0.x = c;
+    out_m->row0.y = s;
+    out_m->row1.x = -s;
+    out_m->row1.y = c;
 }
 
-inline void mat3_rotate_xyz(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z) {
+inline void mat3_rotate_xyz(float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m) {
     mat3 dt;
     dt = mat3_identity;
     if (rad_x != 0.0f)
@@ -362,10 +319,10 @@ inline void mat3_rotate_xyz(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z
         mat3_mul_rotate_y(&dt, rad_y, &dt);
     if (rad_z != 0.0f)
         mat3_mul_rotate_z(&dt, rad_z, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat3_rotate_xzy(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z) {
+inline void mat3_rotate_xzy(float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m) {
     mat3 dt;
     dt = mat3_identity;
     if (rad_x != 0.0f)
@@ -374,10 +331,10 @@ inline void mat3_rotate_xzy(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z
         mat3_mul_rotate_z(&dt, rad_z, &dt);
     if (rad_y != 0.0f)
         mat3_mul_rotate_y(&dt, rad_y, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat3_rotate_yxz(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z) {
+inline void mat3_rotate_yxz(float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m) {
     mat3 dt;
     dt = mat3_identity;
     if (rad_y != 0.0f)
@@ -386,10 +343,10 @@ inline void mat3_rotate_yxz(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z
         mat3_mul_rotate_x(&dt, rad_x, &dt);
     if (rad_z != 0.0f)
         mat3_mul_rotate_z(&dt, rad_z, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat3_rotate_yzx(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z) {
+inline void mat3_rotate_yzx(float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m) {
     mat3 dt;
     dt = mat3_identity;
     if (rad_y != 0.0f)
@@ -398,10 +355,10 @@ inline void mat3_rotate_yzx(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z
         mat3_mul_rotate_z(&dt, rad_z, &dt);
     if (rad_x != 0.0f)
         mat3_mul_rotate_x(&dt, rad_x, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat3_rotate_zxy(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z) {
+inline void mat3_rotate_zxy(float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m) {
     mat3 dt;
     dt = mat3_identity;
     if (rad_z != 0.0f)
@@ -410,10 +367,10 @@ inline void mat3_rotate_zxy(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z
         mat3_mul_rotate_x(&dt, rad_x, &dt);
     if (rad_y != 0.0f)
         mat3_mul_rotate_y(&dt, rad_y, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat3_rotate_zyx(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z) {
+inline void mat3_rotate_zyx(float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m) {
     mat3 dt;
     dt = mat3_identity;
     if (rad_z != 0.0f)
@@ -422,409 +379,341 @@ inline void mat3_rotate_zyx(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z
         mat3_mul_rotate_y(&dt, rad_y, &dt);
     if (rad_x != 0.0f)
         mat3_mul_rotate_x(&dt, rad_x, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat3_mul_rotate_x(const mat3* x, float_t rad, mat3* z) {
+inline void mat3_mul_rotate_x(const mat3* in_m1, float_t rad, mat3* out_m) {
     __m128 t1;
     __m128 t2;
     __m128 y0;
     __m128 y1;
     __m128 y2;
-    __m128 zt;
     float_t s = sinf(rad);
     float_t c = cosf(rad);
-    *(vec3*)&y0 = x->row0;
-    *(vec3*)&y1 = x->row1;
-    *(vec3*)&y2 = x->row2;
-    z->row0 = *(vec3*)&y0;
+    y0 = vec3::load_xmm(in_m1->row0);
+    y1 = vec3::load_xmm(in_m1->row1);
+    y2 = vec3::load_xmm(in_m1->row2);
+    out_m->row0 = vec3::store_xmm(y0);
     t1 = _mm_mul_ps(y1, vec4::load_xmm(c));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(s));
-    zt = _mm_add_ps(t1, t2);
-    z->row1 = *(vec3*)&zt;
+    out_m->row1 = vec3::store_xmm(_mm_add_ps(t1, t2));
     t1 = _mm_mul_ps(y1, vec4::load_xmm(-s));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(c));
-    zt = _mm_add_ps(t1, t2);
-    z->row2 = *(vec3*)&zt;
+    out_m->row2 = vec3::store_xmm(_mm_add_ps(t1, t2));
 }
 
-inline void mat3_mul_rotate_y(const mat3* x, float_t rad, mat3* z) {
+inline void mat3_mul_rotate_y(const mat3* in_m1, float_t rad, mat3* out_m) {
     __m128 t0;
     __m128 t2;
     __m128 y0;
     __m128 y1;
     __m128 y2;
-    __m128 zt;
     float_t s = sinf(rad);
     float_t c = cosf(rad);
-    *(vec3*)&y0 = x->row0;
-    *(vec3*)&y1 = x->row1;
-    *(vec3*)&y2 = x->row2;
+    y0 = vec3::load_xmm(in_m1->row0);
+    y1 = vec3::load_xmm(in_m1->row1);
+    y2 = vec3::load_xmm(in_m1->row2);
     t0 = _mm_mul_ps(y0, vec4::load_xmm(c));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(-s));
-    zt = _mm_add_ps(t0, t2);
-    z->row0 = *(vec3*)&zt;
-    z->row1 = *(vec3*)&y1;
+    out_m->row0 = vec3::store_xmm(_mm_add_ps(t0, t2));
+    out_m->row1 = vec3::store_xmm(y1);
     t0 = _mm_mul_ps(y0, vec4::load_xmm(s));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(c));
-    zt = _mm_add_ps(t0, t2);
-    z->row2 = *(vec3*)&zt;
+    out_m->row2 = vec3::store_xmm(_mm_add_ps(t0, t2));
 }
 
-inline void mat3_mul_rotate_z(const mat3* x, float_t rad, mat3* z) {
+inline void mat3_mul_rotate_z(const mat3* in_m1, float_t rad, mat3* out_m) {
     __m128 t0;
     __m128 t1;
     __m128 y0;
     __m128 y1;
     __m128 y2;
-    __m128 zt;
     float_t s = sinf(rad);
     float_t c = cosf(rad);
-    *(vec3*)&y0 = x->row0;
-    *(vec3*)&y1 = x->row1;
-    *(vec3*)&y2 = x->row2;
+    y0 = vec3::load_xmm(in_m1->row0);
+    y1 = vec3::load_xmm(in_m1->row1);
+    y2 = vec3::load_xmm(in_m1->row2);
     t0 = _mm_mul_ps(y0, vec4::load_xmm(c));
     t1 = _mm_mul_ps(y1, vec4::load_xmm(s));
-    zt = _mm_add_ps(t0, t1);
-    z->row0 = *(vec3*)&zt;
+    out_m->row0 = vec3::store_xmm(_mm_add_ps(t0, t1));
     t0 = _mm_mul_ps(y0, vec4::load_xmm(-s));
     t1 = _mm_mul_ps(y1, vec4::load_xmm(c));
-    zt = _mm_add_ps(t0, t1);
-    z->row1 = *(vec3*)&zt;
-    z->row2 = *(vec3*)&y2;
+    out_m->row1 = vec3::store_xmm(_mm_add_ps(t0, t1));
+    out_m->row2 = vec3::store_xmm(y2);
 }
 
-inline void mat3_mul_rotate_x(const mat3* x, float_t s, float_t c, mat3* z) {
+inline void mat3_mul_rotate_x(const mat3* in_m1, float_t s, float_t c, mat3* out_m) {
     __m128 t1;
     __m128 t2;
     __m128 y0;
     __m128 y1;
     __m128 y2;
-    __m128 zt;
-    *(vec3*)&y0 = x->row0;
-    *(vec3*)&y1 = x->row1;
-    *(vec3*)&y2 = x->row2;
-    z->row0 = *(vec3*)&y0;
+    y0 = vec3::load_xmm(in_m1->row0);
+    y1 = vec3::load_xmm(in_m1->row1);
+    y2 = vec3::load_xmm(in_m1->row2);
+    out_m->row0 = vec3::store_xmm(y0);
     t1 = _mm_mul_ps(y1, vec4::load_xmm(c));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(s));
-    zt = _mm_add_ps(t1, t2);
-    z->row1 = *(vec3*)&zt;
+    out_m->row1 = vec3::store_xmm(_mm_add_ps(t1, t2));
     t1 = _mm_mul_ps(y1, vec4::load_xmm(-s));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(c));
-    zt = _mm_add_ps(t1, t2);
-    z->row2 = *(vec3*)&zt;
+    out_m->row2 = vec3::store_xmm(_mm_add_ps(t1, t2));
 }
 
-inline void mat3_mul_rotate_y(const mat3* x, float_t s, float_t c, mat3* z) {
+inline void mat3_mul_rotate_y(const mat3* in_m1, float_t s, float_t c, mat3* out_m) {
     __m128 t0;
     __m128 t2;
     __m128 y0;
     __m128 y1;
     __m128 y2;
-    __m128 zt;
-    *(vec3*)&y0 = x->row0;
-    *(vec3*)&y1 = x->row1;
-    *(vec3*)&y2 = x->row2;
+    y0 = vec3::load_xmm(in_m1->row0);
+    y1 = vec3::load_xmm(in_m1->row1);
+    y2 = vec3::load_xmm(in_m1->row2);
     t0 = _mm_mul_ps(y0, vec4::load_xmm(c));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(-s));
-    zt = _mm_add_ps(t0, t2);
-    z->row0 = *(vec3*)&zt;
-    z->row1 = *(vec3*)&y1;
+    out_m->row0 = vec3::store_xmm(_mm_add_ps(t0, t2));
+    out_m->row1 = vec3::store_xmm(y1);
     t0 = _mm_mul_ps(y0, vec4::load_xmm(s));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(c));
-    zt = _mm_add_ps(t0, t2);
-    z->row2 = *(vec3*)&zt;
+    out_m->row2 = vec3::store_xmm(_mm_add_ps(t0, t2));
 }
 
-inline void mat3_mul_rotate_z(const mat3* x, float_t s, float_t c, mat3* z) {
+inline void mat3_mul_rotate_z(const mat3* in_m1, float_t s, float_t c, mat3* out_m) {
     __m128 t0;
     __m128 t1;
     __m128 y0;
     __m128 y1;
     __m128 y2;
-    __m128 zt;
-    *(vec3*)&y0 = x->row0;
-    *(vec3*)&y1 = x->row1;
-    *(vec3*)&y2 = x->row2;
+    y0 = vec3::load_xmm(in_m1->row0);
+    y1 = vec3::load_xmm(in_m1->row1);
+    y2 = vec3::load_xmm(in_m1->row2);
     t0 = _mm_mul_ps(y0, vec4::load_xmm(c));
     t1 = _mm_mul_ps(y1, vec4::load_xmm(s));
-    zt = _mm_add_ps(t0, t1);
-    z->row0 = *(vec3*)&zt;
+    out_m->row0 = vec3::store_xmm(_mm_add_ps(t0, t1));
     t0 = _mm_mul_ps(y0, vec4::load_xmm(-s));
     t1 = _mm_mul_ps(y1, vec4::load_xmm(c));
-    zt = _mm_add_ps(t0, t1);
-    z->row1 = *(vec3*)&zt;
-    z->row2 = *(vec3*)&y2;
+    out_m->row1 = vec3::store_xmm(_mm_add_ps(t0, t1));
+    out_m->row2 = vec3::store_xmm(y2);
 }
 
-inline void mat3_mul_rotate_xyz(const mat3* x, float_t rad_x, float_t rad_y, float_t rad_z, mat3* z) {
+inline void mat3_mul_rotate_xyz(const mat3* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m) {
     mat3 dt;
-    dt = *x;
+    dt = *in_m1;
     if (rad_x != 0.0f)
         mat3_mul_rotate_x(&dt, rad_x, &dt);
     if (rad_y != 0.0f)
         mat3_mul_rotate_y(&dt, rad_y, &dt);
     if (rad_z != 0.0f)
         mat3_mul_rotate_z(&dt, rad_z, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat3_mul_rotate_xzy(const mat3* x, float_t rad_x, float_t rad_y, float_t rad_z, mat3* z) {
+inline void mat3_mul_rotate_xzy(const mat3* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m) {
     mat3 dt;
-    dt = *x;
+    dt = *in_m1;
     if (rad_x != 0.0f)
         mat3_mul_rotate_x(&dt, rad_x, &dt);
     if (rad_z != 0.0f)
         mat3_mul_rotate_z(&dt, rad_z, &dt);
     if (rad_y != 0.0f)
         mat3_mul_rotate_y(&dt, rad_y, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat3_mul_rotate_yxz(const mat3* x, float_t rad_x, float_t rad_y, float_t rad_z, mat3* z) {
+inline void mat3_mul_rotate_yxz(const mat3* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m) {
     mat3 dt;
-    dt = *x;
+    dt = *in_m1;
     if (rad_y != 0.0f)
         mat3_mul_rotate_y(&dt, rad_y, &dt);
     if (rad_x != 0.0f)
         mat3_mul_rotate_x(&dt, rad_x, &dt);
     if (rad_z != 0.0f)
         mat3_mul_rotate_z(&dt, rad_z, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat3_mul_rotate_yzx(const mat3* x, float_t rad_x, float_t rad_y, float_t rad_z, mat3* z) {
+inline void mat3_mul_rotate_yzx(const mat3* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m) {
     mat3 dt;
-    dt = *x;
+    dt = *in_m1;
     if (rad_y != 0.0f)
         mat3_mul_rotate_y(&dt, rad_y, &dt);
     if (rad_z != 0.0f)
         mat3_mul_rotate_z(&dt, rad_z, &dt);
     if (rad_x != 0.0f)
         mat3_mul_rotate_x(&dt, rad_x, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat3_mul_rotate_zxy(const mat3* x, float_t rad_x, float_t rad_y, float_t rad_z, mat3* z) {
+inline void mat3_mul_rotate_zxy(const mat3* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m) {
     mat3 dt;
-    dt = *x;
+    dt = *in_m1;
     if (rad_z != 0.0f)
         mat3_mul_rotate_z(&dt, rad_z, &dt);
     if (rad_x != 0.0f)
         mat3_mul_rotate_x(&dt, rad_x, &dt);
     if (rad_y != 0.0f)
         mat3_mul_rotate_y(&dt, rad_y, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat3_mul_rotate_zyx(const mat3* x, float_t rad_x, float_t rad_y, float_t rad_z, mat3* z) {
+inline void mat3_mul_rotate_zyx(const mat3* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m) {
     mat3 dt;
-    dt = *x;
+    dt = *in_m1;
     if (rad_z != 0.0f)
         mat3_mul_rotate_z(&dt, rad_z, &dt);
     if (rad_y != 0.0f)
         mat3_mul_rotate_y(&dt, rad_y, &dt);
     if (rad_x != 0.0f)
         mat3_mul_rotate_x(&dt, rad_x, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat3_scale(float_t sx, float_t sy, float_t sz, mat3* z) {
-    *z = mat3_identity;
-    z->row0.x = sx;
-    z->row1.y = sy;
-    z->row2.z = sz;
+inline void mat3_scale(float_t sx, float_t sy, float_t sz, mat3* out_m) {
+    *out_m = mat3_identity;
+    out_m->row0.x = sx;
+    out_m->row1.y = sy;
+    out_m->row2.z = sz;
 }
 
-inline void mat3_scale_x(float_t s, mat3* y) {
-    *y = mat3_identity;
-    y->row0.x = s;
+inline void mat3_scale_x(float_t s, mat3* out_m) {
+    *out_m = mat3_identity;
+    out_m->row0.x = s;
 }
 
-inline void mat3_scale_y(float_t s, mat3* y) {
-    *y = mat3_identity;
-    y->row1.y = s;
+inline void mat3_scale_y(float_t s, mat3* out_m) {
+    *out_m = mat3_identity;
+    out_m->row1.y = s;
 }
 
-inline void mat3_scale_z(float_t s, mat3* y) {
-    *y = mat3_identity;
-    y->row2.z = s;
+inline void mat3_scale_z(float_t s, mat3* out_m) {
+    *out_m = mat3_identity;
+    out_m->row2.z = s;
 }
 
-inline void mat3_mul_scale(const mat3* x, float_t sx, float_t sy, float_t sz, mat3* z) {
-    mat3 st;
-    mat3 dt;
+inline void mat3_mul_scale(const mat3* in_m1, float_t sx, float_t sy, float_t sz, mat3* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
     if (sx != 1.0f || sy != 1.0f || sz != 1.0f) {
-        dt = mat3_identity;
-        dt.row0.x = sx;
-        dt.row1.y = sy;
-        dt.row2.z = sz;
-        mat3_mul(x, &dt, z);
+        out_m->row0 *= sx;
+        out_m->row1 *= sy;
+        out_m->row2 *= sz;
     }
-    else
-        *z = *x;
 }
 
-inline void mat3_mul_scale_x(const mat3* x, float_t s, mat3* z) {
-    mat3 yt;
-    yt = mat3_identity;
-    yt.row0.x = s;
-    mat3_mul(x, &yt, z);
+inline void mat3_mul_scale_x(const mat3* in_m1, float_t s, mat3* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
+    out_m->row0 *= s;
 }
 
-inline void mat3_mul_scale_y(const mat3* x, float_t s, mat3* z) {
-    mat3 yt;
-    yt = mat3_identity;
-    yt.row1.y = s;
-    mat3_mul(x, &yt, z);
+inline void mat3_mul_scale_y(const mat3* in_m1, float_t s, mat3* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
+    out_m->row1 *= s;
 }
 
-inline void mat3_mul_scale_z(const mat3* x, float_t s, mat3* z) {
-    mat3 yt;
-    yt = mat3_identity;
-    yt.row2.z = s;
-    mat3_mul(x, &yt, z);
+inline void mat3_mul_scale_z(const mat3* in_m1, float_t s, mat3* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
+    out_m->row2 *= s;
 }
 
-inline void mat3_from_quat(const quat* quat, mat3* mat) {
-    float_t y;
-    float_t x;
-    float_t z;
-    float_t w;
-    float_t len;
-    float_t xy;
-    float_t yy;
-    float_t xx;
-    float_t wx;
-    float_t wy;
-    float_t zz;
-    float_t xz;
-    float_t wz;
-    float_t yz;
-
-    x = quat->x;
-    y = quat->y;
-    z = quat->z;
-    w = quat->w;
-    len = quat::length_squared(*quat);
+inline void mat3_set(const quat* in_q1, mat3* out_m) {
+    float_t x = in_q1->x;
+    float_t y = in_q1->y;
+    float_t z = in_q1->z;
+    float_t w = in_q1->w;
+    float_t len = quat::length_squared(*in_q1);
     len = len > 0.0f ? 2.0f / len : 0.0f;
-    xx = x * x * len;
-    xy = x * y * len;
-    xz = x * z * len;
-    yy = y * y * len;
-    zz = z * z * len;
-    yz = y * z * len;
-    wx = w * x * len;
-    wy = w * y * len;
-    wz = w * z * len;
-    mat->row0.x = 1.0f - zz - yy;
-    mat->row0.y = xy + wz;
-    mat->row0.z = xz - wy;
-    mat->row1.x = xy - wz;
-    mat->row1.y = 1.0f - zz - xx;
-    mat->row1.z = yz + wx;
-    mat->row2.x = xz + wy;
-    mat->row2.y = yz - wx;
-    mat->row2.z = 1.0f - yy - xx;
+    float_t xx = x * x * len;
+    float_t xy = x * y * len;
+    float_t xz = x * z * len;
+    float_t yy = y * y * len;
+    float_t zz = z * z * len;
+    float_t yz = y * z * len;
+    float_t wx = w * x * len;
+    float_t wy = w * y * len;
+    float_t wz = w * z * len;
+    out_m->row0.x = 1.0f - zz - yy;
+    out_m->row0.y = xy + wz;
+    out_m->row0.z = xz - wy;
+    out_m->row1.x = xy - wz;
+    out_m->row1.y = 1.0f - zz - xx;
+    out_m->row1.z = yz + wx;
+    out_m->row2.x = xz + wy;
+    out_m->row2.y = yz - wx;
+    out_m->row2.z = 1.0f - yy - xx;
 }
 
-inline void mat3_from_axis_angle(const vec3* axis, float_t angle, mat3* mat) {
-    float_t s;
-    float_t c;
-    float_t c_1;
-    vec3 _axis;
-    vec3 _axis_s;
+inline void mat3_set(const vec3* in_axis, float_t in_angle, mat3* out_m) {
+    mat3_set(in_axis, sinf(in_angle), cosf(in_angle), out_m);
+}
+
+inline void mat3_set(const vec3* in_axis, float_t s, float_t c, mat3* out_m) {
+    float_t c_1 = 1.0f - c;
+
+    vec3 axis = vec3::normalize(*in_axis);
+    vec3 axis_s = axis * s;
+
     vec3 temp;
-
-    s = sinf(angle);
-    c = cosf(angle);
-    c_1 = 1.0f - c;
-
-    _axis = vec3::normalize(*axis);
-
-    _axis_s = _axis * s;
-    temp = _axis * (_axis.x * c_1);
-    mat->row0.x = temp.x + c;
-    mat->row1.x = temp.y - _axis_s.z;
-    mat->row2.x = temp.z + _axis_s.y;
-    temp = _axis * (_axis.y * c_1);
-    mat->row0.y = temp.x + _axis_s.z;
-    mat->row1.y = temp.y + c;
-    mat->row2.y = temp.z - _axis_s.x;
-    temp = _axis * (_axis.z * c_1);
-    mat->row0.z = temp.x - _axis_s.y;
-    mat->row1.z = temp.y + _axis_s.x;
-    mat->row2.z = temp.z + c;
+    temp = axis * (axis.x * c_1);
+    out_m->row0.x = temp.x + c;
+    out_m->row1.x = temp.y - axis_s.z;
+    out_m->row2.x = temp.z + axis_s.y;
+    temp = axis * (axis.y * c_1);
+    out_m->row0.y = temp.x + axis_s.z;
+    out_m->row1.y = temp.y + c;
+    out_m->row2.y = temp.z - axis_s.x;
+    temp = axis * (axis.z * c_1);
+    out_m->row0.z = temp.x - axis_s.y;
+    out_m->row1.z = temp.y + axis_s.x;
+    out_m->row2.z = temp.z + c;
 }
 
-inline void mat3_from_axis_angle(const vec3* axis, float_t s, float_t c, mat3* mat) {
-    float_t c_1;
-    vec3 _axis;
-    vec3 _axis_s;
-    vec3 temp;
-
-    c_1 = 1.0f - c;
-
-    _axis = vec3::normalize(*axis);
-
-    _axis_s = _axis * s;
-    temp = _axis * (_axis.x * c_1);
-    mat->row0.x = temp.x + c;
-    mat->row1.x = temp.y - _axis_s.z;
-    mat->row2.x = temp.z + _axis_s.y;
-    temp = _axis * (_axis.y * c_1);
-    mat->row0.y = temp.x + _axis_s.z;
-    mat->row1.y = temp.y + c;
-    mat->row2.y = temp.z - _axis_s.x;
-    temp = _axis * (_axis.z * c_1);
-    mat->row0.z = temp.x - _axis_s.y;
-    mat->row1.z = temp.y + _axis_s.x;
-    mat->row2.z = temp.z + c;
+inline void mat4_to_mat3(const mat4* in_m1, mat3* out_m) {
+    out_m->row0 = *(vec3*)&in_m1->row0;
+    out_m->row1 = *(vec3*)&in_m1->row1;
+    out_m->row2 = *(vec3*)&in_m1->row2;
 }
 
-inline void mat3_from_mat4(const mat4* x, mat3* z) {
-    z->row0 = *(vec3*)&x->row0;
-    z->row1 = *(vec3*)&x->row1;
-    z->row2 = *(vec3*)&x->row2;
-}
-
-inline void mat3_from_mat4_inverse(const mat4* x, mat3* z) {
+inline void mat4_to_mat3_inverse(const mat4* in_m1, mat3* out_m) {
     mat4 yt;
 
-    mat4_inverse(x, &yt);
-    z->row0 = *(vec3*)&yt.row0;
-    z->row1 = *(vec3*)&yt.row1;
-    z->row2 = *(vec3*)&yt.row2;
+    mat4_invert(in_m1, &yt);
+    out_m->row0 = *(vec3*)&yt.row0;
+    out_m->row1 = *(vec3*)&yt.row1;
+    out_m->row2 = *(vec3*)&yt.row2;
 }
 
-inline void mat3_get_rotation(const mat3* x, vec3* z) {
-    if (-x->row0.z >= 1.0f)
-        z->y = (float_t)M_PI_2;
-    else if (-x->row0.z <= -1.0f)
-        z->y = (float_t)-M_PI_2;
+inline void mat3_get_rotation(const mat3* in_m1, vec3* out_rad) {
+    if (-in_m1->row0.z >= 1.0f)
+        out_rad->y = (float_t)M_PI_2;
+    else if (-in_m1->row0.z <= -1.0f)
+        out_rad->y = (float_t)-M_PI_2;
     else
-        z->y = asinf(-x->row0.z);
-    if (fabs(x->row0.z) < 0.99999899f) {
-        z->x = atan2f(x->row1.z, x->row2.z);
-        z->z = atan2f(x->row0.y, x->row0.x);
+        out_rad->y = asinf(-in_m1->row0.z);
+
+    if (fabsf(in_m1->row0.z) < 0.99999899f) {
+        out_rad->x = atan2f(in_m1->row1.z, in_m1->row2.z);
+        out_rad->z = atan2f(in_m1->row0.y, in_m1->row0.x);
     }
     else {
-        z->x = 0.0f;
-        z->z = atan2f(x->row2.y, x->row1.y);
-        if (-x->row0.z < 0.0f)
-            z->z = -z->z;
+        out_rad->x = 0.0f;
+        out_rad->z = atan2f(in_m1->row2.y, in_m1->row1.y);
+        if (in_m1->row0.z > 0.0f)
+            out_rad->z = -out_rad->z;
     }
 }
 
-inline void mat3_get_scale(const mat3* x, vec3* z) {
-    z->x = vec3::length(x->row0);
-    z->y = vec3::length(x->row1);
-    z->z = vec3::length(x->row2);
+inline void mat3_get_scale(const mat3* in_m1, vec3* out_s) {
+    out_s->x = vec3::length(in_m1->row0);
+    out_s->y = vec3::length(in_m1->row1);
+    out_s->z = vec3::length(in_m1->row2);
 }
 
-inline float_t mat3_get_max_scale(const mat3* x) {
+inline float_t mat3_get_max_scale(const mat3* in_m1) {
     mat3 mat;
-    mat3_transpose(x, &mat);
+    mat3_transpose(in_m1, &mat);
 
     float_t length;
     float_t max = 0.0f;
@@ -840,53 +729,143 @@ inline float_t mat3_get_max_scale(const mat3* x) {
     return max;
 }
 
-inline void mat3_mult_axis_angle(const mat3* x, const vec3* axis, const float_t angle, mat3* z) {
-    quat q1;
-    quat q2;
-    quat q3;
-    quat_from_mat3(x->row0.x, x->row1.x, x->row2.x, x->row0.y,
-        x->row1.y, x->row2.y, x->row0.z, x->row1.z, x->row2.z, &q1);
-    quat_from_axis_angle(axis, angle, &q2);
-    quat_mult(&q2, &q1, &q3);
-    mat3_from_quat(&q3, z);
+inline void mat4_set(const quat* in_q1, mat4* out_m) {
+    mat4_set_rotation(out_m, in_q1);
+    out_m->row0.w = 0.0f;
+    out_m->row1.w = 0.0f;
+    out_m->row2.w = 0.0f;
+    out_m->row3 = { 0.0f, 0.0f, 0.0f, 1.0f };
 }
 
-inline void mat4_add(const mat4* x, float_t y, mat4* z) {
-    z->row0 = x->row0 + y;
-    z->row1 = x->row1 + y;
-    z->row2 = x->row2 + y;
-    z->row3 = x->row3 + y;
+static float_t vec3_angle_between_two_vectors(const vec3& in_v1, const vec3& in_v2) {
+    vec3 z_t = vec3::cross(in_v1, in_v2);
+    float_t v2 = vec3::length(z_t);
+    float_t v3 = vec3::dot(in_v1, in_v2);
+    return fabsf(atan2f(v2, v3));
 }
 
-inline void mat4_add(const mat4* x, const mat4* y, mat4* z) {
-    z->row0 = x->row0 + y->row0;
-    z->row1 = x->row1 + y->row1;
-    z->row2 = x->row2 + y->row2;
-    z->row3 = x->row3 + y->row3;
+void mat4_set(const vec3* in_v1, const vec3* in_v2, mat4* out_m) {
+    *out_m = mat4_identity;
+    if (*in_v1 == *in_v2)
+        return;
+
+    if (fabsf(1.0f - vec3::dot(*in_v1, *in_v2)) <= 0.000001f)
+        return;
+
+    vec3 axis = vec3::cross(*in_v1, *in_v2);
+    float_t axis_length = vec3::length(axis);
+    if (axis_length > 0.000001f) {
+        float_t angle = vec3_angle_between_two_vectors(*in_v1, *in_v2);
+        if (axis_length != 0.0)
+            axis *= 1.0f / axis_length;
+        mat4_set(&axis, angle, out_m);
+    }
 }
 
-inline void mat4_sub(const mat4* x, float_t y, mat4* z) {
-    z->row0 = x->row0 - y;
-    z->row1 = x->row1 - y;
-    z->row2 = x->row2 - y;
-    z->row3 = x->row3 - y;
+inline void mat4_set(const vec3* in_axis, float_t in_angle, mat4* out_m) {
+    mat4_set_rotation(out_m, in_axis, sinf(in_angle), cosf(in_angle));
+    out_m->row0.w = 0.0f;
+    out_m->row1.w = 0.0f;
+    out_m->row2.w = 0.0f;
+    out_m->row3 = { 0.0f, 0.0f, 0.0f, 1.0f };
 }
 
-inline void mat4_sub(const mat4* x, const mat4* y, mat4* z) {
-    z->row0 = x->row0 - y->row0;
-    z->row1 = x->row1 - y->row1;
-    z->row2 = x->row2 - y->row2;
-    z->row3 = x->row3 - y->row3;
+inline void mat4_set(const vec3* in_axis, float_t s, float_t c, mat4* out_m) {
+    mat4_set_rotation(out_m, in_axis, s, c);
+    out_m->row0.w = 0.0f;
+    out_m->row1.w = 0.0f;
+    out_m->row2.w = 0.0f;
+    out_m->row3 = { 0.0f, 0.0f, 0.0f, 1.0f };
 }
 
-inline void mat4_mul(const mat4* x, float_t y, mat4* z) {
-    z->row0 = x->row0 * y;
-    z->row1 = x->row1 * y;
-    z->row2 = x->row2 * y;
-    z->row3 = x->row3 * y;
+inline void mat4_set_rotation(mat4* in_m1, const quat* in_q1) {
+    float_t x = in_q1->x;
+    float_t y = in_q1->y;
+    float_t z = in_q1->z;
+    float_t w = in_q1->w;
+    float_t len = quat::length_squared(*in_q1);
+    len = len > 0.0f ? 2.0f / len : 0.0f;
+    float_t xx = x * x * len;
+    float_t xy = x * y * len;
+    float_t xz = x * z * len;
+    float_t yy = y * y * len;
+    float_t zz = z * z * len;
+    float_t yz = y * z * len;
+    float_t wx = w * x * len;
+    float_t wy = w * y * len;
+    float_t wz = w * z * len;
+    in_m1->row0.x = 1.0f - zz - yy;
+    in_m1->row0.y = xy + wz;
+    in_m1->row0.z = xz - wy;
+    in_m1->row1.x = xy - wz;
+    in_m1->row1.y = 1.0f - zz - xx;
+    in_m1->row1.z = yz + wx;
+    in_m1->row2.x = xz + wy;
+    in_m1->row2.y = yz - wx;
+    in_m1->row2.z = 1.0f - yy - xx;
 }
 
-inline void mat4_mul(const mat4* x, const mat4* y, mat4* z) {
+inline void mat4_set_rotation(mat4* in_m1, const vec3* in_axis, const float_t in_angle) {
+    mat4_set_rotation(in_m1, in_axis, sinf(in_angle), cosf(in_angle));
+}
+
+inline void mat4_set_rotation(mat4* in_m1, const vec3* in_axis, const float_t s, const float_t c) {
+    float_t c_1 = 1.0f - c;
+
+    vec3 axis = vec3::normalize(*in_axis);
+    vec3 axis_s = axis * s;
+
+    vec3 temp;
+    temp = axis * (axis.x * c_1);
+    in_m1->row0.x = temp.x + c;
+    in_m1->row1.x = temp.y - axis_s.z;
+    in_m1->row2.x = temp.z + axis_s.y;
+    temp = axis * (axis.y * c_1);
+    in_m1->row0.y = temp.x + axis_s.z;
+    in_m1->row1.y = temp.y + c;
+    in_m1->row2.y = temp.z - axis_s.x;
+    temp = axis * (axis.z * c_1);
+    in_m1->row0.z = temp.x - axis_s.y;
+    in_m1->row1.z = temp.y + axis_s.x;
+    in_m1->row2.z = temp.z + c;
+}
+
+inline void mat4_add(const mat4* in_m1, const float_t value, mat4* out_m) {
+    out_m->row0 = in_m1->row0 + value;
+    out_m->row1 = in_m1->row1 + value;
+    out_m->row2 = in_m1->row2 + value;
+    out_m->row3 = in_m1->row3 + value;
+}
+
+inline void mat4_add(const mat4* in_m1, const mat4* in_m2, mat4* out_m) {
+    out_m->row0 = in_m1->row0 + in_m2->row0;
+    out_m->row1 = in_m1->row1 + in_m2->row1;
+    out_m->row2 = in_m1->row2 + in_m2->row2;
+    out_m->row3 = in_m1->row3 + in_m2->row3;
+}
+
+inline void mat4_sub(const mat4* in_m1, const float_t value, mat4* out_m) {
+    out_m->row0 = in_m1->row0 - value;
+    out_m->row1 = in_m1->row1 - value;
+    out_m->row2 = in_m1->row2 - value;
+    out_m->row3 = in_m1->row3 - value;
+}
+
+inline void mat4_sub(const mat4* in_m1, const mat4* in_m2, mat4* out_m) {
+    out_m->row0 = in_m1->row0 - in_m2->row0;
+    out_m->row1 = in_m1->row1 - in_m2->row1;
+    out_m->row2 = in_m1->row2 - in_m2->row2;
+    out_m->row3 = in_m1->row3 - in_m2->row3;
+}
+
+inline void mat4_mul(const mat4* in_m1, const float_t value, mat4* out_m) {
+    out_m->row0 = in_m1->row0 * value;
+    out_m->row1 = in_m1->row1 * value;
+    out_m->row2 = in_m1->row2 * value;
+    out_m->row3 = in_m1->row3 * value;
+}
+
+inline void mat4_mul(const mat4* in_m1, const mat4* in_m2, mat4* out_m) {
     __m128 t0;
     __m128 t1;
     __m128 t2;
@@ -896,177 +875,177 @@ inline void mat4_mul(const mat4* x, const mat4* y, mat4* z) {
     __m128 y1;
     __m128 y2;
     __m128 y3;
-    y0 = vec4::load_xmm(y->row0);
-    y1 = vec4::load_xmm(y->row1);
-    y2 = vec4::load_xmm(y->row2);
-    y3 = vec4::load_xmm(y->row3);
-    xt = vec4::load_xmm(x->row0);
+    y0 = vec4::load_xmm(in_m2->row0);
+    y1 = vec4::load_xmm(in_m2->row1);
+    y2 = vec4::load_xmm(in_m2->row2);
+    y3 = vec4::load_xmm(in_m2->row3);
+    xt = vec4::load_xmm(in_m1->row0);
     t0 = _mm_mul_ps(y0, _mm_shuffle_ps(xt, xt, 0x00));
     t1 = _mm_mul_ps(y1, _mm_shuffle_ps(xt, xt, 0x55));
     t2 = _mm_mul_ps(y2, _mm_shuffle_ps(xt, xt, 0xAA));
     t3 = _mm_mul_ps(y3, _mm_shuffle_ps(xt, xt, 0xFF));
-    z->row0 = vec4::store_xmm(_mm_add_ps(_mm_add_ps(t0, t1), _mm_add_ps(t2, t3)));
-    xt = vec4::load_xmm(x->row1);
+    out_m->row0 = vec4::store_xmm(_mm_add_ps(_mm_add_ps(t0, t1), _mm_add_ps(t2, t3)));
+    xt = vec4::load_xmm(in_m1->row1);
     t0 = _mm_mul_ps(y0, _mm_shuffle_ps(xt, xt, 0x00));
     t1 = _mm_mul_ps(y1, _mm_shuffle_ps(xt, xt, 0x55));
     t2 = _mm_mul_ps(y2, _mm_shuffle_ps(xt, xt, 0xAA));
     t3 = _mm_mul_ps(y3, _mm_shuffle_ps(xt, xt, 0xFF));
-    z->row1 = vec4::store_xmm(_mm_add_ps(_mm_add_ps(t0, t1), _mm_add_ps(t2, t3)));
-    xt = vec4::load_xmm(x->row2);
+    out_m->row1 = vec4::store_xmm(_mm_add_ps(_mm_add_ps(t0, t1), _mm_add_ps(t2, t3)));
+    xt = vec4::load_xmm(in_m1->row2);
     t0 = _mm_mul_ps(y0, _mm_shuffle_ps(xt, xt, 0x00));
     t1 = _mm_mul_ps(y1, _mm_shuffle_ps(xt, xt, 0x55));
     t2 = _mm_mul_ps(y2, _mm_shuffle_ps(xt, xt, 0xAA));
     t3 = _mm_mul_ps(y3, _mm_shuffle_ps(xt, xt, 0xFF));
-    z->row2 = vec4::store_xmm(_mm_add_ps(_mm_add_ps(t0, t1), _mm_add_ps(t2, t3)));
-    xt = vec4::load_xmm(x->row3);
+    out_m->row2 = vec4::store_xmm(_mm_add_ps(_mm_add_ps(t0, t1), _mm_add_ps(t2, t3)));
+    xt = vec4::load_xmm(in_m1->row3);
     t0 = _mm_mul_ps(y0, _mm_shuffle_ps(xt, xt, 0x00));
     t1 = _mm_mul_ps(y1, _mm_shuffle_ps(xt, xt, 0x55));
     t2 = _mm_mul_ps(y2, _mm_shuffle_ps(xt, xt, 0xAA));
     t3 = _mm_mul_ps(y3, _mm_shuffle_ps(xt, xt, 0xFF));
-    z->row3 = vec4::store_xmm(_mm_add_ps(_mm_add_ps(t0, t1), _mm_add_ps(t2, t3)));
+    out_m->row3 = vec4::store_xmm(_mm_add_ps(_mm_add_ps(t0, t1), _mm_add_ps(t2, t3)));
 }
 
-inline void mat4_transform_vector(const mat4* x, const vec2* y, vec2* z) {
+inline void mat4_mul_rotation(const mat4* in_m1, const vec3* in_axis, const float_t in_angle, mat4* out_m) {
+    quat q1 = quat(in_m1->row0.x, in_m1->row1.x, in_m1->row2.x, in_m1->row0.y,
+        in_m1->row1.y, in_m1->row2.y, in_m1->row0.z, in_m1->row1.z, in_m1->row2.z);
+    quat q2 = quat(*in_axis, in_angle);
+    quat q3 = quat::mul(q2, q1);
+    mat4_set(&q3, out_m);
+}
+
+inline void mat4_transform_vector(const mat4* in_m1, const vec2* normal, vec2* normalOut) {
     __m128 yt;
-    __m128 zt;
     __m128 zt0;
     __m128 zt1;
-    *(vec2*)&yt = *y;
-    zt0 = _mm_mul_ps(vec4::load_xmm(x->row0), _mm_shuffle_ps(yt, yt, 0x00));
-    zt1 = _mm_mul_ps(vec4::load_xmm(x->row1), _mm_shuffle_ps(yt, yt, 0x55));
-    zt = _mm_add_ps(zt0, zt1);
-    *z = *(vec2*)&zt;
+    yt = vec2::load_xmm(*normal);
+    zt0 = _mm_mul_ps(vec4::load_xmm(in_m1->row0), _mm_shuffle_ps(yt, yt, 0x00));
+    zt1 = _mm_mul_ps(vec4::load_xmm(in_m1->row1), _mm_shuffle_ps(yt, yt, 0x55));
+    *normalOut = vec2::store_xmm(_mm_add_ps(zt0, zt1));
 }
 
-inline void mat4_transform_vector(const mat4* x, const vec3* y, vec3* z) {
+inline void mat4_transform_vector(const mat4* in_m1, const vec3* normal, vec3* normalOut) {
     __m128 yt;
-    __m128 zt;
     __m128 zt0;
     __m128 zt1;
     __m128 zt2;
-    *(vec3*)&yt = *y;
-    zt0 = _mm_mul_ps(vec4::load_xmm(x->row0), _mm_shuffle_ps(yt, yt, 0x00));
-    zt1 = _mm_mul_ps(vec4::load_xmm(x->row1), _mm_shuffle_ps(yt, yt, 0x55));
-    zt2 = _mm_mul_ps(vec4::load_xmm(x->row2), _mm_shuffle_ps(yt, yt, 0xAA));
-    zt = _mm_add_ps(_mm_add_ps(zt0, zt1), zt2);
-    *z = *(vec3*)&zt;
+    yt = vec3::load_xmm(*normal);
+    zt0 = _mm_mul_ps(vec4::load_xmm(in_m1->row0), _mm_shuffle_ps(yt, yt, 0x00));
+    zt1 = _mm_mul_ps(vec4::load_xmm(in_m1->row1), _mm_shuffle_ps(yt, yt, 0x55));
+    zt2 = _mm_mul_ps(vec4::load_xmm(in_m1->row2), _mm_shuffle_ps(yt, yt, 0xAA));
+    *normalOut = vec3::store_xmm(_mm_add_ps(_mm_add_ps(zt0, zt1), zt2));
 }
 
-inline void mat4_transform_vector(const mat4* x, const vec4* y, vec4* z) {
+inline void mat4_transform_vector(const mat4* in_m1, const vec4* normal, vec4* normalOut) {
     __m128 yt;
     __m128 zt0;
     __m128 zt1;
     __m128 zt2;
     __m128 zt3;
-    yt = vec4::load_xmm(*y);
-    zt0 = _mm_mul_ps(vec4::load_xmm(x->row0), _mm_shuffle_ps(yt, yt, 0x00));
-    zt1 = _mm_mul_ps(vec4::load_xmm(x->row1), _mm_shuffle_ps(yt, yt, 0x55));
-    zt2 = _mm_mul_ps(vec4::load_xmm(x->row2), _mm_shuffle_ps(yt, yt, 0xAA));
-    zt3 = _mm_mul_ps(vec4::load_xmm(x->row3), _mm_shuffle_ps(yt, yt, 0xFF));
-    *z = vec4::store_xmm(_mm_add_ps(_mm_add_ps(zt0, zt1), _mm_add_ps(zt2, zt3)));
+    yt = vec4::load_xmm(*normal);
+    zt0 = _mm_mul_ps(vec4::load_xmm(in_m1->row0), _mm_shuffle_ps(yt, yt, 0x00));
+    zt1 = _mm_mul_ps(vec4::load_xmm(in_m1->row1), _mm_shuffle_ps(yt, yt, 0x55));
+    zt2 = _mm_mul_ps(vec4::load_xmm(in_m1->row2), _mm_shuffle_ps(yt, yt, 0xAA));
+    zt3 = _mm_mul_ps(vec4::load_xmm(in_m1->row3), _mm_shuffle_ps(yt, yt, 0xFF));
+    *normalOut = vec4::store_xmm(_mm_add_ps(_mm_add_ps(zt0, zt1), _mm_add_ps(zt2, zt3)));
 }
 
-inline void mat4_transform_point(const mat4* x, const vec2* y, vec2* z) {
+inline void mat4_transform_point(const mat4* in_m1, const vec2* point, vec2* normalOut) {
     __m128 yt;
-    __m128 zt;
     __m128 zt0;
     __m128 zt1;
     __m128 zt2;
-    *(vec2*)&yt = *y;
-    zt0 = _mm_mul_ps(vec4::load_xmm(x->row0), _mm_shuffle_ps(yt, yt, 0x00));
-    zt1 = _mm_mul_ps(vec4::load_xmm(x->row1), _mm_shuffle_ps(yt, yt, 0x55));
-    zt2 = vec4::load_xmm(x->row3);
-    zt = _mm_add_ps(_mm_add_ps(zt0, zt1), zt2);
-    *z = *(vec2*)&zt;
+    yt = vec2::load_xmm(*point);
+    zt0 = _mm_mul_ps(vec4::load_xmm(in_m1->row0), _mm_shuffle_ps(yt, yt, 0x00));
+    zt1 = _mm_mul_ps(vec4::load_xmm(in_m1->row1), _mm_shuffle_ps(yt, yt, 0x55));
+    zt2 = vec4::load_xmm(in_m1->row3);
+    *normalOut = vec2::store_xmm(_mm_add_ps(_mm_add_ps(zt0, zt1), zt2));
 }
 
-inline void mat4_transform_point(const mat4* x, const vec3* y, vec3* z) {
+inline void mat4_transform_point(const mat4* in_m1, const vec3* point, vec3* normalOut) {
     __m128 yt;
-    __m128 zt;
     __m128 zt0;
     __m128 zt1;
     __m128 zt2;
     __m128 zt3;
-    *(vec3*)&yt = *y;
-    zt0 = _mm_mul_ps(vec4::load_xmm(x->row0), _mm_shuffle_ps(yt, yt, 0x00));
-    zt1 = _mm_mul_ps(vec4::load_xmm(x->row1), _mm_shuffle_ps(yt, yt, 0x55));
-    zt2 = _mm_mul_ps(vec4::load_xmm(x->row2), _mm_shuffle_ps(yt, yt, 0xAA));
-    zt3 = vec4::load_xmm(x->row3);
-    zt = _mm_add_ps(_mm_add_ps(zt0, zt1), _mm_add_ps(zt2, zt3));
-    *z = *(vec3*)&zt;
+    yt = vec3::load_xmm(*point);
+    zt0 = _mm_mul_ps(vec4::load_xmm(in_m1->row0), _mm_shuffle_ps(yt, yt, 0x00));
+    zt1 = _mm_mul_ps(vec4::load_xmm(in_m1->row1), _mm_shuffle_ps(yt, yt, 0x55));
+    zt2 = _mm_mul_ps(vec4::load_xmm(in_m1->row2), _mm_shuffle_ps(yt, yt, 0xAA));
+    zt3 = vec4::load_xmm(in_m1->row3);
+    *normalOut = vec3::store_xmm(_mm_add_ps(_mm_add_ps(zt0, zt1), _mm_add_ps(zt2, zt3)));
 }
 
-inline void mat4_inverse_transform_vector(const mat4* x, const vec2* y, vec2* z) {
+inline void mat4_inverse_transform_vector(const mat4* in_m1, const vec2* normal, vec2* normalOut) {
     __m128 yt;
     __m128 zt;
-    yt = vec2::load_xmm(*y);
-    zt = _mm_mul_ps(yt, vec4::load_xmm(x->row0));
-    z->x = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
-    zt = _mm_mul_ps(yt, vec4::load_xmm(x->row1));
-    z->y = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    yt = vec2::load_xmm(*normal);
+    zt = _mm_mul_ps(yt, vec4::load_xmm(in_m1->row0));
+    normalOut->x = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    zt = _mm_mul_ps(yt, vec4::load_xmm(in_m1->row1));
+    normalOut->y = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
 }
 
-inline void mat4_inverse_transform_vector(const mat4* x, const vec3* y, vec3* z) {
+inline void mat4_inverse_transform_vector(const mat4* in_m1, const vec3* normal, vec3* normalOut) {
     __m128 yt;
     __m128 zt;
-    yt = vec3::load_xmm(*y);
-    zt = _mm_mul_ps(yt, vec4::load_xmm(x->row0));
+    yt = vec3::load_xmm(*normal);
+    zt = _mm_mul_ps(yt, vec4::load_xmm(in_m1->row0));
     zt = _mm_hadd_ps(zt, zt);
-    z->x = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
-    zt = _mm_mul_ps(yt, vec4::load_xmm(x->row1));
+    normalOut->x = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    zt = _mm_mul_ps(yt, vec4::load_xmm(in_m1->row1));
     zt = _mm_hadd_ps(zt, zt);
-    z->y = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
-    zt = _mm_mul_ps(yt, vec4::load_xmm(x->row2));
+    normalOut->y = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    zt = _mm_mul_ps(yt, vec4::load_xmm(in_m1->row2));
     zt = _mm_hadd_ps(zt, zt);
-    z->z = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    normalOut->z = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
 }
 
-inline void mat4_inverse_transform_vector(const mat4* x, const vec4* y, vec4* z) {
+inline void mat4_inverse_transform_vector(const mat4* in_m1, const vec4* normal, vec4* normalOut) {
     __m128 yt;
     __m128 zt;
-    yt = vec4::load_xmm(*y);
-    zt = _mm_mul_ps(yt, vec4::load_xmm(x->row0));
+    yt = vec4::load_xmm(*normal);
+    zt = _mm_mul_ps(yt, vec4::load_xmm(in_m1->row0));
     zt = _mm_hadd_ps(zt, zt);
-    z->x = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
-    zt = _mm_mul_ps(yt, vec4::load_xmm(x->row1));
+    normalOut->x = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    zt = _mm_mul_ps(yt, vec4::load_xmm(in_m1->row1));
     zt = _mm_hadd_ps(zt, zt);
-    z->y = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
-    zt = _mm_mul_ps(yt, vec4::load_xmm(x->row2));
+    normalOut->y = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    zt = _mm_mul_ps(yt, vec4::load_xmm(in_m1->row2));
     zt = _mm_hadd_ps(zt, zt);
-    z->z = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
-    zt = _mm_mul_ps(yt, vec4::load_xmm(x->row3));
+    normalOut->z = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    zt = _mm_mul_ps(yt, vec4::load_xmm(in_m1->row3));
     zt = _mm_hadd_ps(zt, zt);
-    z->w = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    normalOut->w = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
 }
 
-inline void mat4_inverse_transform_point(const mat4* x, const vec2* y, vec2* z) {
+inline void mat4_inverse_transform_point(const mat4* in_m1, const vec2* point, vec2* pointOut) {
     __m128 yt;
     __m128 zt;
-    yt = vec2::load_xmm(*y);
-    yt = _mm_sub_ps(yt, vec4::load_xmm(x->row3));
-    zt = _mm_mul_ps(yt, vec4::load_xmm(x->row0));
-    z->x = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
-    zt = _mm_mul_ps(yt, vec4::load_xmm(x->row1));
-    z->y = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    yt = vec2::load_xmm(*point);
+    yt = _mm_sub_ps(yt, vec4::load_xmm(in_m1->row3));
+    zt = _mm_mul_ps(yt, vec4::load_xmm(in_m1->row0));
+    pointOut->x = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    zt = _mm_mul_ps(yt, vec4::load_xmm(in_m1->row1));
+    pointOut->y = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
 }
 
-inline void mat4_inverse_transform_point(const mat4* x, const vec3* y, vec3* z) {
+inline void mat4_inverse_transform_point(const mat4* in_m1, const vec3* point, vec3* pointOut) {
     __m128 yt;
     __m128 zt;
-    yt = vec3::load_xmm(*y);
-    yt = _mm_sub_ps(yt, vec4::load_xmm(x->row3));
-    zt = _mm_mul_ps(yt, vec4::load_xmm(x->row0));
+    yt = vec3::load_xmm(*point);
+    yt = _mm_sub_ps(yt, vec4::load_xmm(in_m1->row3));
+    zt = _mm_mul_ps(yt, vec4::load_xmm(in_m1->row0));
     zt = _mm_hadd_ps(zt, zt);
-    z->x = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
-    zt = _mm_mul_ps(yt, vec4::load_xmm(x->row1));
+    pointOut->x = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    zt = _mm_mul_ps(yt, vec4::load_xmm(in_m1->row1));
     zt = _mm_hadd_ps(zt, zt);
-    z->y = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
-    zt = _mm_mul_ps(yt, vec4::load_xmm(x->row2));
+    pointOut->y = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    zt = _mm_mul_ps(yt, vec4::load_xmm(in_m1->row2));
     zt = _mm_hadd_ps(zt, zt);
-    z->z = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
+    pointOut->z = _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
 }
 
-inline void mat4_transpose(const mat4* x, mat4* z) {
+inline void mat4_transpose(const mat4* in_m1, mat4* out_m) {
     __m128 xt0;
     __m128 xt1;
     __m128 xt2;
@@ -1075,21 +1054,21 @@ inline void mat4_transpose(const mat4* x, mat4* z) {
     __m128 yt1;
     __m128 yt2;
     __m128 yt3;
-    xt0 = vec4::load_xmm(x->row0);
-    xt1 = vec4::load_xmm(x->row1);
-    xt2 = vec4::load_xmm(x->row2);
-    xt3 = vec4::load_xmm(x->row3);
+    xt0 = vec4::load_xmm(in_m1->row0);
+    xt1 = vec4::load_xmm(in_m1->row1);
+    xt2 = vec4::load_xmm(in_m1->row2);
+    xt3 = vec4::load_xmm(in_m1->row3);
     yt0 = _mm_unpacklo_ps(xt0, xt1);
     yt1 = _mm_unpackhi_ps(xt0, xt1);
     yt2 = _mm_unpacklo_ps(xt2, xt3);
     yt3 = _mm_unpackhi_ps(xt2, xt3);
-    z->row0 = vec4::store_xmm(_mm_movelh_ps(yt0, yt2));
-    z->row1 = vec4::store_xmm(_mm_movehl_ps(yt2, yt0));
-    z->row2 = vec4::store_xmm(_mm_movelh_ps(yt1, yt3));
-    z->row3 = vec4::store_xmm(_mm_movehl_ps(yt3, yt1));
+    out_m->row0 = vec4::store_xmm(_mm_movelh_ps(yt0, yt2));
+    out_m->row1 = vec4::store_xmm(_mm_movehl_ps(yt2, yt0));
+    out_m->row2 = vec4::store_xmm(_mm_movelh_ps(yt1, yt3));
+    out_m->row3 = vec4::store_xmm(_mm_movehl_ps(yt3, yt1));
 }
 
-void mat4_inverse(const mat4* x, mat4* z) {
+void mat4_invert(const mat4* in_m1, mat4* out_m) {
     static const __m128 xor0 = { -0.0f,  0.0f, -0.0f,  0.0f };
     static const __m128 xor1 = {  0.0f, -0.0f,  0.0f, -0.0f };
 
@@ -1103,10 +1082,10 @@ void mat4_inverse(const mat4* x, mat4* z) {
     __m128 wt;
     __m128 wt0, wt1, wt2;
     __m128 t0, t1, t2, t3, t4, t5;
-    xt0 = vec4::load_xmm(x->row0);
-    xt1 = vec4::load_xmm(x->row1);
-    xt2 = vec4::load_xmm(x->row2);
-    xt3 = vec4::load_xmm(x->row3);
+    xt0 = vec4::load_xmm(in_m1->row0);
+    xt1 = vec4::load_xmm(in_m1->row1);
+    xt2 = vec4::load_xmm(in_m1->row2);
+    xt3 = vec4::load_xmm(in_m1->row3);
     xt0x = _mm_shuffle_ps(xt0, xt0, 0x00);
     xt0y = _mm_shuffle_ps(xt0, xt0, 0x55);
     xt0z = _mm_shuffle_ps(xt0, xt0, 0xAA);
@@ -1171,88 +1150,81 @@ void mat4_inverse(const mat4* x, mat4* z) {
     if (_mm_cvtss_f32(wt) != 0.0f)
         wt = _mm_div_ss(_mm_set_ss(1.0f), wt);
     wt = _mm_shuffle_ps(wt, wt, 0);
-    z->row0 = vec4::store_xmm(_mm_mul_ps(zt0, wt));
-    z->row1 = vec4::store_xmm(_mm_mul_ps(zt1, wt));
-    z->row2 = vec4::store_xmm(_mm_mul_ps(zt2, wt));
-    z->row3 = vec4::store_xmm(_mm_mul_ps(zt3, wt));
+    out_m->row0 = vec4::store_xmm(_mm_mul_ps(zt0, wt));
+    out_m->row1 = vec4::store_xmm(_mm_mul_ps(zt1, wt));
+    out_m->row2 = vec4::store_xmm(_mm_mul_ps(zt2, wt));
+    out_m->row3 = vec4::store_xmm(_mm_mul_ps(zt3, wt));
 }
 
-inline void mat4_invtrans(const mat4* x, mat4* z) {
-    mat4 t = *x;
-    mat4_inverse(&t, &t);
-    mat4_transpose(&t, &t);
-    *z = t;
-}
-
-inline void mat4_invrot(const mat4* x, mat4* z) {
+inline void mat4_invert_rotation(const mat4* in_m1, mat4* out_m) {
     mat3 yt;
-    mat3_from_mat4(x, &yt);
-    mat3_inverse(&yt, &yt);
-    mat4_from_mat3(&yt, z);
-    z->row0.w = x->row0.w;
-    z->row1.w = x->row1.w;
-    z->row2.w = x->row2.w;
-    z->row3 = x->row3;
+    mat4_to_mat3(in_m1, &yt);
+    mat3_invert(&yt, &yt);
+    mat4_from_mat3(&yt, out_m);
+    out_m->row0.w = in_m1->row0.w;
+    out_m->row1.w = in_m1->row1.w;
+    out_m->row2.w = in_m1->row2.w;
+    out_m->row3 = in_m1->row3;
 }
 
-inline void mat4_inverse_normalized(const mat4* x, mat4* z) {
+inline void mat4_invert_fast(const mat4* in_m1, mat4* out_m) {
     mat3 yt;
-    mat3_from_mat4(x, &yt);
+    mat4_to_mat3(in_m1, &yt);
     vec3 row3;
-    row3.x = vec3::dot(*(vec3*)&x->row0, *(vec3*)&x->row3);
-    row3.y = vec3::dot(*(vec3*)&x->row1, *(vec3*)&x->row3);
-    row3.z = vec3::dot(*(vec3*)&x->row2, *(vec3*)&x->row3);
+    row3.x = vec3::dot(*(vec3*)&in_m1->row0, *(vec3*)&in_m1->row3);
+    row3.y = vec3::dot(*(vec3*)&in_m1->row1, *(vec3*)&in_m1->row3);
+    row3.z = vec3::dot(*(vec3*)&in_m1->row2, *(vec3*)&in_m1->row3);
     mat3_transpose(&yt, &yt);
-    mat4_from_mat3(&yt, z);
-    *(vec3*)&z->row3 = -row3;
-    z->row0.w = 0.0f;
-    z->row1.w = 0.0f;
-    z->row2.w = 0.0f;
-    z->row3.w = 1.0f;
+    mat4_from_mat3(&yt, out_m);
+    *(vec3*)&out_m->row3 = -row3;
+    out_m->row0.w = 0.0f;
+    out_m->row1.w = 0.0f;
+    out_m->row2.w = 0.0f;
+    out_m->row3.w = 1.0f;
 }
 
-inline void mat4_invrot_normalized(const mat4* x, mat4* z) {
+inline void mat4_invert_rotation_fast(const mat4* in_m1, mat4* out_m) {
     mat3 yt;
-    mat3_from_mat4(x, &yt);
+    mat4_to_mat3(in_m1, &yt);
     mat3_transpose(&yt, &yt);
-    mat4_from_mat3(&yt, z);
-    z->row0.w = x->row0.w;
-    z->row1.w = x->row1.w;
-    z->row2.w = x->row2.w;
-    z->row3 = x->row3;
+    mat4_from_mat3(&yt, out_m);
+    out_m->row0.w = in_m1->row0.w;
+    out_m->row1.w = in_m1->row1.w;
+    out_m->row2.w = in_m1->row2.w;
+    out_m->row3 = in_m1->row3;
 }
 
-inline void mat4_normalize(const mat4* x, mat4* z) {
+inline void mat4_normalize(const mat4* in_m1, mat4* out_m) {
     __m128 det;
-    det = _mm_set_ss(mat4_determinant(x));
+    det = _mm_set_ss(mat4_determinant(in_m1));
     if (_mm_cvtss_f32(det) != 0.0f)
         det = _mm_div_ss(_mm_set_ss(1.0f), det);
     det = _mm_shuffle_ps(det, det, 0);
-    z->row0 = vec4::store_xmm(_mm_mul_ps(vec4::load_xmm(x->row0), det));
-    z->row1 = vec4::store_xmm(_mm_mul_ps(vec4::load_xmm(x->row1), det));
-    z->row2 = vec4::store_xmm(_mm_mul_ps(vec4::load_xmm(x->row2), det));
-    z->row3 = vec4::store_xmm(_mm_mul_ps(vec4::load_xmm(x->row3), det));
+    out_m->row0 = vec4::store_xmm(_mm_mul_ps(vec4::load_xmm(in_m1->row0), det));
+    out_m->row1 = vec4::store_xmm(_mm_mul_ps(vec4::load_xmm(in_m1->row1), det));
+    out_m->row2 = vec4::store_xmm(_mm_mul_ps(vec4::load_xmm(in_m1->row2), det));
+    out_m->row3 = vec4::store_xmm(_mm_mul_ps(vec4::load_xmm(in_m1->row3), det));
 }
 
-inline void mat4_normalize_rotation(const mat4* x, mat4* z) {
-    *(vec3*)&z->row0 = vec3::normalize(*(vec3*)&x->row0);
-    *(vec3*)&z->row1 = vec3::normalize(*(vec3*)&x->row1);
-    *(vec3*)&z->row2 = vec3::normalize(*(vec3*)&x->row2);
-    z->row0.w = x->row0.w;
-    z->row1.w = x->row1.w;
-    z->row2.w = x->row2.w;
-    z->row3 = x->row3;
+inline void mat4_normalize_rotation(const mat4* in_m1, mat4* out_m) {
+    *(vec3*)&out_m->row0 = vec3::normalize(*(vec3*)&in_m1->row0);
+    *(vec3*)&out_m->row1 = vec3::normalize(*(vec3*)&in_m1->row1);
+    *(vec3*)&out_m->row2 = vec3::normalize(*(vec3*)&in_m1->row2);
+    out_m->row0.w = in_m1->row0.w;
+    out_m->row1.w = in_m1->row1.w;
+    out_m->row2.w = in_m1->row2.w;
+    out_m->row3 = in_m1->row3;
 }
 
-inline float_t mat4_determinant(const mat4* x) {
+inline float_t mat4_determinant(const mat4* in_m1) {
     vec4 xt0;
     vec4 xt1;
     vec4 xt2;
     vec4 xt3;
-    xt0 = x->row0;
-    xt1 = x->row1;
-    xt2 = x->row2;
-    xt3 = x->row3;
+    xt0 = in_m1->row0;
+    xt1 = in_m1->row1;
+    xt2 = in_m1->row2;
+    xt3 = in_m1->row3;
     float_t b00 = xt0.x * xt1.y - xt0.y * xt1.x;
     float_t b01 = xt0.x * xt1.z - xt0.z * xt1.x;
     float_t b02 = xt0.x * xt1.w - xt0.w * xt1.x;
@@ -1268,61 +1240,61 @@ inline float_t mat4_determinant(const mat4* x) {
     return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
 }
 
-inline void mat4_rotate_x(float_t rad, mat4* y) {
+inline void mat4_rotate_x(float_t rad, mat4* out_m) {
     float_t s = sinf(rad);
     float_t c = cosf(rad);
-    *y = mat4_identity;
-    y->row1.y = c;
-    y->row1.z = s;
-    y->row2.y = -s;
-    y->row2.z = c;
+    *out_m = mat4_identity;
+    out_m->row1.y = c;
+    out_m->row1.z = s;
+    out_m->row2.y = -s;
+    out_m->row2.z = c;
 }
 
-inline void mat4_rotate_y(float_t rad, mat4* y) {
+inline void mat4_rotate_y(float_t rad, mat4* out_m) {
     float_t s = sinf(rad);
     float_t c = cosf(rad);
-    *y = mat4_identity;
-    y->row0.x = c;
-    y->row0.z = -s;
-    y->row2.x = s;
-    y->row2.z = c;
+    *out_m = mat4_identity;
+    out_m->row0.x = c;
+    out_m->row0.z = -s;
+    out_m->row2.x = s;
+    out_m->row2.z = c;
 }
 
-inline void mat4_rotate_z(float_t rad, mat4* y) {
+inline void mat4_rotate_z(float_t rad, mat4* out_m) {
     float_t s = sinf(rad);
     float_t c = cosf(rad);
-    *y = mat4_identity;
-    y->row0.x = c;
-    y->row0.y = s;
-    y->row1.x = -s;
-    y->row1.y = c;
+    *out_m = mat4_identity;
+    out_m->row0.x = c;
+    out_m->row0.y = s;
+    out_m->row1.x = -s;
+    out_m->row1.y = c;
 }
 
-inline void mat4_rotate_x(float_t s, float_t c, mat4* y) {
-    *y = mat4_identity;
-    y->row1.y = c;
-    y->row1.z = s;
-    y->row2.y = -s;
-    y->row2.z = c;
+inline void mat4_rotate_x(float_t s, float_t c, mat4* out_m) {
+    *out_m = mat4_identity;
+    out_m->row1.y = c;
+    out_m->row1.z = s;
+    out_m->row2.y = -s;
+    out_m->row2.z = c;
 }
 
-inline void mat4_rotate_y(float_t s, float_t c, mat4* y) {
-    *y = mat4_identity;
-    y->row0.x = c;
-    y->row0.z = -s;
-    y->row2.x = s;
-    y->row2.z = c;
+inline void mat4_rotate_y(float_t s, float_t c, mat4* out_m) {
+    *out_m = mat4_identity;
+    out_m->row0.x = c;
+    out_m->row0.z = -s;
+    out_m->row2.x = s;
+    out_m->row2.z = c;
 }
 
-inline void mat4_rotate_z(float_t s, float_t c, mat4* y) {
-    *y = mat4_identity;
-    y->row0.x = c;
-    y->row0.y = s;
-    y->row1.x = -s;
-    y->row1.y = c;
+inline void mat4_rotate_z(float_t s, float_t c, mat4* out_m) {
+    *out_m = mat4_identity;
+    out_m->row0.x = c;
+    out_m->row0.y = s;
+    out_m->row1.x = -s;
+    out_m->row1.y = c;
 }
 
-inline void mat4_rotate_xyz(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z) {
+inline void mat4_rotate_xyz(float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m) {
     mat4 dt;
     dt = mat4_identity;
     if (rad_x != 0.0f)
@@ -1331,10 +1303,10 @@ inline void mat4_rotate_xyz(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z
         mat4_mul_rotate_y(&dt, rad_y, &dt);
     if (rad_z != 0.0f)
         mat4_mul_rotate_z(&dt, rad_z, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat4_rotate_xzy(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z) {
+inline void mat4_rotate_xzy(float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m) {
     mat4 dt;
     dt = mat4_identity;
     if (rad_x != 0.0f)
@@ -1343,10 +1315,10 @@ inline void mat4_rotate_xzy(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z
         mat4_mul_rotate_z(&dt, rad_z, &dt);
     if (rad_y != 0.0f)
         mat4_mul_rotate_y(&dt, rad_y, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat4_rotate_yxz(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z) {
+inline void mat4_rotate_yxz(float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m) {
     mat4 dt;
     dt = mat4_identity;
     if (rad_y != 0.0f)
@@ -1355,10 +1327,10 @@ inline void mat4_rotate_yxz(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z
         mat4_mul_rotate_x(&dt, rad_x, &dt);
     if (rad_z != 0.0f)
         mat4_mul_rotate_z(&dt, rad_z, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat4_rotate_yzx(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z) {
+inline void mat4_rotate_yzx(float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m) {
     mat4 dt;
     dt = mat4_identity;
     if (rad_y != 0.0f)
@@ -1367,10 +1339,10 @@ inline void mat4_rotate_yzx(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z
         mat4_mul_rotate_z(&dt, rad_z, &dt);
     if (rad_x != 0.0f)
         mat4_mul_rotate_x(&dt, rad_x, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat4_rotate_zxy(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z) {
+inline void mat4_rotate_zxy(float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m) {
     mat4 dt;
     dt = mat4_identity;
     if (rad_z != 0.0f)
@@ -1379,10 +1351,10 @@ inline void mat4_rotate_zxy(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z
         mat4_mul_rotate_x(&dt, rad_x, &dt);
     if (rad_y != 0.0f)
         mat4_mul_rotate_y(&dt, rad_y, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat4_rotate_zyx(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z) {
+inline void mat4_rotate_zyx(float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m) {
     mat4 dt;
     dt = mat4_identity;
     if (rad_z != 0.0f)
@@ -1391,10 +1363,10 @@ inline void mat4_rotate_zyx(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z
         mat4_mul_rotate_y(&dt, rad_y, &dt);
     if (rad_x != 0.0f)
         mat4_mul_rotate_x(&dt, rad_x, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat4_mul_rotate_x(const mat4* x, float_t rad, mat4* z) {
+inline void mat4_mul_rotate_x(const mat4* in_m1, float_t rad, mat4* out_m) {
     __m128 t1;
     __m128 t2;
     __m128 y0;
@@ -1403,21 +1375,21 @@ inline void mat4_mul_rotate_x(const mat4* x, float_t rad, mat4* z) {
     __m128 y3;
     float_t s = sinf(rad);
     float_t c = cosf(rad);
-    y0 = vec4::load_xmm(x->row0);
-    y1 = vec4::load_xmm(x->row1);
-    y2 = vec4::load_xmm(x->row2);
-    y3 = vec4::load_xmm(x->row3);
-    z->row0 = vec4::store_xmm(y0);
+    y0 = vec4::load_xmm(in_m1->row0);
+    y1 = vec4::load_xmm(in_m1->row1);
+    y2 = vec4::load_xmm(in_m1->row2);
+    y3 = vec4::load_xmm(in_m1->row3);
+    out_m->row0 = vec4::store_xmm(y0);
     t1 = _mm_mul_ps(y1, vec4::load_xmm(c));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(s));
-    z->row1 = vec4::store_xmm(_mm_add_ps(t1, t2));
+    out_m->row1 = vec4::store_xmm(_mm_add_ps(t1, t2));
     t1 = _mm_mul_ps(y1, vec4::load_xmm(-s));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(c));
-    z->row2 = vec4::store_xmm(_mm_add_ps(t1, t2));
-    z->row3 = vec4::store_xmm(y3);
+    out_m->row2 = vec4::store_xmm(_mm_add_ps(t1, t2));
+    out_m->row3 = vec4::store_xmm(y3);
 }
 
-inline void mat4_mul_rotate_y(const mat4* x, float_t rad, mat4* z) {
+inline void mat4_mul_rotate_y(const mat4* in_m1, float_t rad, mat4* out_m) {
     __m128 t0;
     __m128 t2;
     __m128 y0;
@@ -1426,21 +1398,21 @@ inline void mat4_mul_rotate_y(const mat4* x, float_t rad, mat4* z) {
     __m128 y3;
     float_t s = sinf(rad);
     float_t c = cosf(rad);
-    y0 = vec4::load_xmm(x->row0);
-    y1 = vec4::load_xmm(x->row1);
-    y2 = vec4::load_xmm(x->row2);
-    y3 = vec4::load_xmm(x->row3);
+    y0 = vec4::load_xmm(in_m1->row0);
+    y1 = vec4::load_xmm(in_m1->row1);
+    y2 = vec4::load_xmm(in_m1->row2);
+    y3 = vec4::load_xmm(in_m1->row3);
     t0 = _mm_mul_ps(y0, vec4::load_xmm(c));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(-s));
-    z->row0 = vec4::store_xmm(_mm_add_ps(t0, t2));
-    z->row1 = vec4::store_xmm(y1);
+    out_m->row0 = vec4::store_xmm(_mm_add_ps(t0, t2));
+    out_m->row1 = vec4::store_xmm(y1);
     t0 = _mm_mul_ps(y0, vec4::load_xmm(s));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(c));
-    z->row2 = vec4::store_xmm(_mm_add_ps(t0, t2));
-    z->row3 = vec4::store_xmm(y3);
+    out_m->row2 = vec4::store_xmm(_mm_add_ps(t0, t2));
+    out_m->row3 = vec4::store_xmm(y3);
 }
 
-inline void mat4_mul_rotate_z(const mat4* x, float_t rad, mat4* z) {
+inline void mat4_mul_rotate_z(const mat4* in_m1, float_t rad, mat4* out_m) {
     __m128 t0;
     __m128 t1;
     __m128 y0;
@@ -1449,698 +1421,425 @@ inline void mat4_mul_rotate_z(const mat4* x, float_t rad, mat4* z) {
     __m128 y3;
     float_t s = sinf(rad);
     float_t c = cosf(rad);
-    y0 = vec4::load_xmm(x->row0);
-    y1 = vec4::load_xmm(x->row1);
-    y2 = vec4::load_xmm(x->row2);
-    y3 = vec4::load_xmm(x->row3);
+    y0 = vec4::load_xmm(in_m1->row0);
+    y1 = vec4::load_xmm(in_m1->row1);
+    y2 = vec4::load_xmm(in_m1->row2);
+    y3 = vec4::load_xmm(in_m1->row3);
     t0 = _mm_mul_ps(y0, vec4::load_xmm(c));
     t1 = _mm_mul_ps(y1, vec4::load_xmm(s));
-    z->row0 = vec4::store_xmm(_mm_add_ps(t0, t1));
+    out_m->row0 = vec4::store_xmm(_mm_add_ps(t0, t1));
     t0 = _mm_mul_ps(y0, vec4::load_xmm(-s));
     t1 = _mm_mul_ps(y1, vec4::load_xmm(c));
-    z->row1 = vec4::store_xmm(_mm_add_ps(t0, t1));
-    z->row2 = vec4::store_xmm(y2);
-    z->row3 = vec4::store_xmm(y3);
+    out_m->row1 = vec4::store_xmm(_mm_add_ps(t0, t1));
+    out_m->row2 = vec4::store_xmm(y2);
+    out_m->row3 = vec4::store_xmm(y3);
 }
 
-inline void mat4_mul_rotate_x(const mat4* x, float_t s, float_t c, mat4* z) {
+inline void mat4_mul_rotate_x(const mat4* in_m1, float_t s, float_t c, mat4* out_m) {
     __m128 t1;
     __m128 t2;
     __m128 y0;
     __m128 y1;
     __m128 y2;
     __m128 y3;
-    y0 = vec4::load_xmm(x->row0);
-    y1 = vec4::load_xmm(x->row1);
-    y2 = vec4::load_xmm(x->row2);
-    y3 = vec4::load_xmm(x->row3);
-    z->row0 = vec4::store_xmm(y0);
+    y0 = vec4::load_xmm(in_m1->row0);
+    y1 = vec4::load_xmm(in_m1->row1);
+    y2 = vec4::load_xmm(in_m1->row2);
+    y3 = vec4::load_xmm(in_m1->row3);
+    out_m->row0 = vec4::store_xmm(y0);
     t1 = _mm_mul_ps(y1, vec4::load_xmm(c));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(s));
-    z->row1 = vec4::store_xmm(_mm_add_ps(t1, t2));
+    out_m->row1 = vec4::store_xmm(_mm_add_ps(t1, t2));
     t1 = _mm_mul_ps(y1, vec4::load_xmm(-s));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(c));
-    z->row2 = vec4::store_xmm(_mm_add_ps(t1, t2));
-    z->row3 = vec4::store_xmm(y3);
+    out_m->row2 = vec4::store_xmm(_mm_add_ps(t1, t2));
+    out_m->row3 = vec4::store_xmm(y3);
 }
 
-inline void mat4_mul_rotate_y(const mat4* x, float_t s, float_t c, mat4* z) {
+inline void mat4_mul_rotate_y(const mat4* in_m1, float_t s, float_t c, mat4* out_m) {
     __m128 t0;
     __m128 t2;
     __m128 y0;
     __m128 y1;
     __m128 y2;
     __m128 y3;
-    y0 = vec4::load_xmm(x->row0);
-    y1 = vec4::load_xmm(x->row1);
-    y2 = vec4::load_xmm(x->row2);
-    y3 = vec4::load_xmm(x->row3);
+    y0 = vec4::load_xmm(in_m1->row0);
+    y1 = vec4::load_xmm(in_m1->row1);
+    y2 = vec4::load_xmm(in_m1->row2);
+    y3 = vec4::load_xmm(in_m1->row3);
     t0 = _mm_mul_ps(y0, vec4::load_xmm(c));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(-s));
-    z->row0 = vec4::store_xmm(_mm_add_ps(t0, t2));
-    z->row1 = vec4::store_xmm(y1);
+    out_m->row0 = vec4::store_xmm(_mm_add_ps(t0, t2));
+    out_m->row1 = vec4::store_xmm(y1);
     t0 = _mm_mul_ps(y0, vec4::load_xmm(s));
     t2 = _mm_mul_ps(y2, vec4::load_xmm(c));
-    z->row2 = vec4::store_xmm(_mm_add_ps(t0, t2));
-    z->row3 = vec4::store_xmm(y3);
+    out_m->row2 = vec4::store_xmm(_mm_add_ps(t0, t2));
+    out_m->row3 = vec4::store_xmm(y3);
 }
 
-inline void mat4_mul_rotate_z(const mat4* x, float_t s, float_t c, mat4* z) {
+inline void mat4_mul_rotate_z(const mat4* in_m1, float_t s, float_t c, mat4* out_m) {
     __m128 t0;
     __m128 t1;
     __m128 y0;
     __m128 y1;
     __m128 y2;
     __m128 y3;
-    y0 = vec4::load_xmm(x->row0);
-    y1 = vec4::load_xmm(x->row1);
-    y2 = vec4::load_xmm(x->row2);
-    y3 = vec4::load_xmm(x->row3);
+    y0 = vec4::load_xmm(in_m1->row0);
+    y1 = vec4::load_xmm(in_m1->row1);
+    y2 = vec4::load_xmm(in_m1->row2);
+    y3 = vec4::load_xmm(in_m1->row3);
     t0 = _mm_mul_ps(y0, vec4::load_xmm(c));
     t1 = _mm_mul_ps(y1, vec4::load_xmm(s));
-    z->row0 = vec4::store_xmm(_mm_add_ps(t0, t1));
+    out_m->row0 = vec4::store_xmm(_mm_add_ps(t0, t1));
     t0 = _mm_mul_ps(y0, vec4::load_xmm(-s));
     t1 = _mm_mul_ps(y1, vec4::load_xmm(c));
-    z->row1 = vec4::store_xmm(_mm_add_ps(t0, t1));
-    z->row2 = vec4::store_xmm(y2);
-    z->row3 = vec4::store_xmm(y3);
+    out_m->row1 = vec4::store_xmm(_mm_add_ps(t0, t1));
+    out_m->row2 = vec4::store_xmm(y2);
+    out_m->row3 = vec4::store_xmm(y3);
 }
 
-inline void mat4_mul_rotate_xyz(const mat4* x, float_t rad_x, float_t rad_y, float_t rad_z, mat4* z) {
+inline void mat4_mul_rotate_xyz(const mat4* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m) {
     mat4 dt;
-    dt = *x;
+    dt = *in_m1;
     if (rad_x != 0.0f)
         mat4_mul_rotate_x(&dt, rad_x, &dt);
     if (rad_y != 0.0f)
         mat4_mul_rotate_y(&dt, rad_y, &dt);
     if (rad_z != 0.0f)
         mat4_mul_rotate_z(&dt, rad_z, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat4_mul_rotate_xzy(const mat4* x, float_t rad_x, float_t rad_y, float_t rad_z, mat4* z) {
+inline void mat4_mul_rotate_xzy(const mat4* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m) {
     mat4 dt;
-    dt = *x;
+    dt = *in_m1;
     if (rad_x != 0.0f)
         mat4_mul_rotate_x(&dt, rad_x, &dt);
     if (rad_z != 0.0f)
         mat4_mul_rotate_z(&dt, rad_z, &dt);
     if (rad_y != 0.0f)
         mat4_mul_rotate_y(&dt, rad_y, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat4_mul_rotate_yxz(const mat4* x, float_t rad_x, float_t rad_y, float_t rad_z, mat4* z) {
+inline void mat4_mul_rotate_yxz(const mat4* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m) {
     mat4 dt;
-    dt = *x;
+    dt = *in_m1;
     if (rad_y != 0.0f)
         mat4_mul_rotate_y(&dt, rad_y, &dt);
     if (rad_x != 0.0f)
         mat4_mul_rotate_x(&dt, rad_x, &dt);
     if (rad_z != 0.0f)
         mat4_mul_rotate_z(&dt, rad_z, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat4_mul_rotate_yzx(const mat4* x, float_t rad_x, float_t rad_y, float_t rad_z, mat4* z) {
+inline void mat4_mul_rotate_yzx(const mat4* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m) {
     mat4 dt;
-    dt = *x;
+    dt = *in_m1;
     if (rad_y != 0.0f)
         mat4_mul_rotate_y(&dt, rad_y, &dt);
     if (rad_z != 0.0f)
         mat4_mul_rotate_z(&dt, rad_z, &dt);
     if (rad_x != 0.0f)
         mat4_mul_rotate_x(&dt, rad_x, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat4_mul_rotate_zxy(const mat4* x, float_t rad_x, float_t rad_y, float_t rad_z, mat4* z) {
+inline void mat4_mul_rotate_zxy(const mat4* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m) {
     mat4 dt;
-    dt = *x;
+    dt = *in_m1;
     if (rad_z != 0.0f)
         mat4_mul_rotate_z(&dt, rad_z, &dt);
     if (rad_x != 0.0f)
         mat4_mul_rotate_x(&dt, rad_x, &dt);
     if (rad_y != 0.0f)
         mat4_mul_rotate_y(&dt, rad_y, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat4_mul_rotate_zyx(const mat4* x, float_t rad_x, float_t rad_y, float_t rad_z, mat4* z) {
+inline void mat4_mul_rotate_zyx(const mat4* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m) {
     mat4 dt;
-    dt = *x;
+    dt = *in_m1;
     if (rad_z != 0.0f)
         mat4_mul_rotate_z(&dt, rad_z, &dt);
     if (rad_y != 0.0f)
         mat4_mul_rotate_y(&dt, rad_y, &dt);
     if (rad_x != 0.0f)
         mat4_mul_rotate_x(&dt, rad_x, &dt);
-    *z = dt;
+    *out_m = dt;
 }
 
-inline void mat4_scale(float_t sx, float_t sy, float_t sz, mat4* z) {
-    *z = mat4_identity;
-    z->row0.x = sx;
-    z->row1.y = sy;
-    z->row2.z = sz;
+inline void mat4_scale(float_t sx, float_t sy, float_t sz, mat4* out_m) {
+    *out_m = mat4_identity;
+    out_m->row0.x = sx;
+    out_m->row1.y = sy;
+    out_m->row2.z = sz;
 }
 
-inline void mat4_scale_x(float_t s, mat4* y) {
-    *y = mat4_identity;
-    y->row0.x = s;
+inline void mat4_scale_x(float_t s, mat4* out_m) {
+    *out_m = mat4_identity;
+    out_m->row0.x = s;
 }
 
-inline void mat4_scale_y(float_t s, mat4* y) {
-    *y = mat4_identity;
-    y->row1.y = s;
+inline void mat4_scale_y(float_t s, mat4* out_m) {
+    *out_m = mat4_identity;
+    out_m->row1.y = s;
 }
 
-inline void mat4_scale_z(float_t s, mat4* y) {
-    *y = mat4_identity;
-    y->row2.z = s;
+inline void mat4_scale_z(float_t s, mat4* out_m) {
+    *out_m = mat4_identity;
+    out_m->row2.z = s;
 }
 
-inline void mat4_mul_scale(const mat4* x, float_t sx, float_t sy, float_t sz, float_t sw, mat4* z) {
-    mat4 dt;
+inline void mat4_mul_scale(const mat4* in_m1, float_t sx, float_t sy, float_t sz, float_t sw, mat4* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
     if (sx != 1.0f || sy != 1.0f || sz != 1.0f || sw != 1.0f) {
-        dt = mat4_identity;
-        dt.row0.x = sx;
-        dt.row1.y = sy;
-        dt.row2.z = sz;
-        dt.row3.w = sw;
-        mat4_mul(x, &dt, z);
+        out_m->row0 *= sx;
+        out_m->row1 *= sy;
+        out_m->row2 *= sz;
+        out_m->row3 *= sw;
     }
-    else if (x != z)
-        *z = *x;
 }
 
-inline void mat4_mul_scale_x(const mat4* x, float_t s, mat4* z) {
-    mat4 yt;
-    yt = mat4_identity;
-    yt.row0.x = s;
-    mat4_mul(x, &yt, z);
+inline void mat4_mul_scale_x(const mat4* in_m1, float_t s, mat4* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
+    out_m->row0 *= s;
 }
 
-inline void mat4_mul_scale_y(const mat4* x, float_t s, mat4* z) {
-    mat4 yt;
-    yt = mat4_identity;
-    yt.row1.y = s;
-    mat4_mul(x, &yt, z);
+inline void mat4_mul_scale_y(const mat4* in_m1, float_t s, mat4* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
+    out_m->row1 *= s;
 }
 
-inline void mat4_mul_scale_z(const mat4* x, float_t s, mat4* z) {
-    mat4 yt;
-    yt = mat4_identity;
-    yt.row2.z = s;
-    mat4_mul(x, &yt, z);
+inline void mat4_mul_scale_z(const mat4* in_m1, float_t s, mat4* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
+    out_m->row2 *= s;
 }
 
-inline void mat4_scale_w_mult(const mat4* x, float_t s, mat4* z) {
-    mat4 yt;
-    yt = mat4_identity;
-    yt.row3.w = s;
-    mat4_mul(x, &yt, z);
+inline void mat4_scale_w_mult(const mat4* in_m1, float_t s, mat4* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
+    out_m->row3 *= s;
 }
 
-inline void mat4_scale_rot(const mat4* x, float_t sx, float_t sy, float_t sz, mat4* z) {
-    mat3 st;
-    mat3 dt;
+inline void mat4_scale_rot(const mat4* in_m1, float_t sx, float_t sy, float_t sz, mat4* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
     if (sx != 1.0f || sy != 1.0f || sz != 1.0f) {
-        st.row0 = *(vec3*)&x->row0;
-        st.row1 = *(vec3*)&x->row1;
-        st.row2 = *(vec3*)&x->row2;
-        dt = mat3_identity;
-        dt.row0.x = sx;
-        dt.row1.y = sy;
-        dt.row2.z = sz;
-        mat3_mul(&st, &dt, &dt);
-        *(vec3*)&z->row0 = dt.row0;
-        *(vec3*)&z->row1 = dt.row1;
-        *(vec3*)&z->row2 = dt.row2;
-        z->row0.w = x->row0.w;
-        z->row1.w = x->row1.w;
-        z->row2.w = x->row2.w;
-        z->row3 = x->row3;
+        *(vec3*)&out_m->row0 *= sx;
+        *(vec3*)&out_m->row1 *= sy;
+        *(vec3*)&out_m->row2 *= sz;
     }
     else
-        *z = *x;
+        *out_m = *in_m1;
 }
 
-inline void mat4_scale_x_rot(const mat4* x, float_t s, mat4* z) {
-    mat3 xt;
-    mat3 yt;
-    mat3 zt;
-    xt.row0 = *(vec3*)&x->row0;
-    xt.row1 = *(vec3*)&x->row1;
-    xt.row2 = *(vec3*)&x->row2;
-    yt = mat3_identity;
-    yt.row0.x = s;
-    mat3_mul(&xt, &yt, &zt);
-    *(vec3*)&z->row0 = zt.row0;
-    *(vec3*)&z->row1 = zt.row1;
-    *(vec3*)&z->row2 = zt.row2;
-    z->row0.w = x->row0.w;
-    z->row1.w = x->row1.w;
-    z->row2.w = x->row2.w;
-    z->row3 = x->row3;
+inline void mat4_scale_x_rot(const mat4* in_m1, float_t s, mat4* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
+    *(vec3*)&out_m->row0 *= s;
 }
 
-inline void mat4_scale_y_rot(const mat4* x, float_t s, mat4* z) {
-    mat3 xt;
-    mat3 yt;
-    mat3 zt;
-    xt.row0 = *(vec3*)&x->row0;
-    xt.row1 = *(vec3*)&x->row1;
-    xt.row2 = *(vec3*)&x->row2;
-    yt = mat3_identity;
-    yt.row1.y = s;
-    mat3_mul(&xt, &yt, &zt);
-    *(vec3*)&z->row0 = zt.row0;
-    *(vec3*)&z->row1 = zt.row1;
-    *(vec3*)&z->row2 = zt.row2;
-    z->row0.w = x->row0.w;
-    z->row1.w = x->row1.w;
-    z->row2.w = x->row2.w;
-    z->row3 = x->row3;
+inline void mat4_scale_y_rot(const mat4* in_m1, float_t s, mat4* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
+    *(vec3*)&out_m->row1 *= s;
 }
 
-inline void mat4_scale_z_rot(const mat4* x, float_t s, mat4* z) {
-    mat3 xt;
-    mat3 yt;
-    mat3 zt;
-    xt.row0 = *(vec3*)&x->row0;
-    xt.row1 = *(vec3*)&x->row1;
-    xt.row2 = *(vec3*)&x->row2;
-    yt = mat3_identity;
-    yt.row2.z = s;
-    mat3_mul(&xt, &yt, &zt);
-    *(vec3*)&z->row0 = zt.row0;
-    *(vec3*)&z->row1 = zt.row1;
-    *(vec3*)&z->row2 = zt.row2;
-    z->row0.w = x->row0.w;
-    z->row1.w = x->row1.w;
-    z->row2.w = x->row2.w;
-    z->row3 = x->row3;
+inline void mat4_scale_z_rot(const mat4* in_m1, float_t s, mat4* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
+    *(vec3*)&out_m->row2 *= s;
 }
 
-inline void mat4_translate(float_t tx, float_t ty, float_t tz, mat4* z) {
-    *z = mat4_identity;
-    z->row3.x = tx;
-    z->row3.y = ty;
-    z->row3.z = tz;
+inline void mat4_translate(float_t tx, float_t ty, float_t tz, mat4* out_m) {
+    *out_m = mat4_identity;
+    out_m->row3.x = tx;
+    out_m->row3.y = ty;
+    out_m->row3.z = tz;
 }
 
-inline void mat4_translate_x(float_t t, mat4* y) {
-    *y = mat4_identity;
-    y->row3.x = t;
+inline void mat4_translate_x(float_t t, mat4* out_m) {
+    *out_m = mat4_identity;
+    out_m->row3.x = t;
 }
 
-inline void mat4_translate_y(float_t t, mat4* y) {
-    *y = mat4_identity;
-    y->row3.y = t;
+inline void mat4_translate_y(float_t t, mat4* out_m) {
+    *out_m = mat4_identity;
+    out_m->row3.y = t;
 }
 
-inline void mat4_translate_z(float_t t, mat4* y) {
-    *y = mat4_identity;
-    y->row3.z = t;
+inline void mat4_translate_z(float_t t, mat4* out_m) {
+    *out_m = mat4_identity;
+    out_m->row3.z = t;
 }
 
-inline void mat4_mul_translate(const mat4* x, float_t tx, float_t ty, float_t tz, mat4* z) {
+inline void mat4_mul_translate(const mat4* in_m1, float_t tx, float_t ty, float_t tz, mat4* out_m) {
     __m128 yt;
     __m128 yt0;
     __m128 yt1;
     __m128 yt2;
     __m128 yt3;
-    if (x != z)
-        *z = *x;
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
     if (tx != 0.0f || ty != 0.0f || tz != 0.0f) {
-        yt0 = _mm_mul_ps(vec4::load_xmm(x->row0), vec4::load_xmm(tx));
-        yt1 = _mm_mul_ps(vec4::load_xmm(x->row1), vec4::load_xmm(ty));
-        yt2 = _mm_mul_ps(vec4::load_xmm(x->row2), vec4::load_xmm(tz));
-        yt3 = vec4::load_xmm(x->row3);
+        yt0 = _mm_mul_ps(vec4::load_xmm(in_m1->row0), vec4::load_xmm(tx));
+        yt1 = _mm_mul_ps(vec4::load_xmm(in_m1->row1), vec4::load_xmm(ty));
+        yt2 = _mm_mul_ps(vec4::load_xmm(in_m1->row2), vec4::load_xmm(tz));
+        yt3 = vec4::load_xmm(in_m1->row3);
         yt = _mm_add_ps(_mm_add_ps(yt0, yt1), _mm_add_ps(yt2, yt3));
-        *(vec3*)&z->row3 = vec3::store_xmm(yt);
+        *(vec3*)&out_m->row3 = vec3::store_xmm(yt);
     }
 }
 
-inline void mat4_mul_translate_x(const mat4* x, float_t t, mat4* z) {
+inline void mat4_mul_translate_x(const mat4* in_m1, float_t t, mat4* out_m) {
     __m128 yt0;
     __m128 yt1;
-    if (x != z)
-        *z = *x;
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
     if (t != 0.0f) {
-        yt0 = vec4::load_xmm(x->row0);
-        yt1 = vec4::load_xmm(x->row3);
+        yt0 = vec4::load_xmm(in_m1->row0);
+        yt1 = vec4::load_xmm(in_m1->row3);
         yt0 = _mm_add_ps(_mm_mul_ps(yt0, vec4::load_xmm(t)), yt1);
-        *(vec3*)&z->row3 = vec3::store_xmm(yt0);
+        *(vec3*)&out_m->row3 = vec3::store_xmm(yt0);
     }
 }
 
-inline void mat4_mul_translate_y(const mat4* x, float_t t, mat4* z) {
+inline void mat4_mul_translate_y(const mat4* in_m1, float_t t, mat4* out_m) {
     __m128 yt0;
     __m128 yt1;
-    if (x != z)
-        *z = *x;
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
     if (t != 0.0f) {
-        yt0 = vec4::load_xmm(x->row1);
-        yt1 = vec4::load_xmm(x->row3);
+        yt0 = vec4::load_xmm(in_m1->row1);
+        yt1 = vec4::load_xmm(in_m1->row3);
         yt0 = _mm_add_ps(_mm_mul_ps(yt0, vec4::load_xmm(t)), yt1);
-        *(vec3*)&z->row3 = vec3::store_xmm(yt0);
+        *(vec3*)&out_m->row3 = vec3::store_xmm(yt0);
     }
 }
 
-inline void mat4_mul_translate_z(const mat4* x, float_t t, mat4* z) {
+inline void mat4_mul_translate_z(const mat4* in_m1, float_t t, mat4* out_m) {
     __m128 yt0;
     __m128 yt1;
-    if (x != z)
-        *z = *x;
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
     if (t != 0.0f) {
-        yt0 = vec4::load_xmm(x->row2);
-        yt1 = vec4::load_xmm(x->row3);
+        yt0 = vec4::load_xmm(in_m1->row2);
+        yt1 = vec4::load_xmm(in_m1->row3);
         yt0 = _mm_add_ps(_mm_mul_ps(yt0, vec4::load_xmm(t)), yt1);
-        *(vec3*)&z->row3 = vec3::store_xmm(yt0);
+        *(vec3*)&out_m->row3 = vec3::store_xmm(yt0);
     }
 }
 
-inline void mat4_add_translate(const mat4* x, float_t tx, float_t ty, float_t tz, mat4* z) {
-    if (x != z)
-        *z = *x;
+inline void mat4_add_translate(const mat4* in_m1, float_t tx, float_t ty, float_t tz, mat4* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
     if (tx != 0.0f || ty != 0.0f || tz != 0.0f)
-        z->row3 = vec4::store_xmm(_mm_add_ps(vec4::load_xmm(x->row3), vec4::load_xmm(vec4(tx, ty, tz, 0.0f))));
+        out_m->row3 = vec4::store_xmm(_mm_add_ps(vec4::load_xmm(in_m1->row3), vec4::load_xmm(vec4(tx, ty, tz, 0.0f))));
 }
 
-inline void mat4_add_translate_x(const mat4* x, float_t t, mat4* z) {
-    if (x != z)
-        *z = *x;
+inline void mat4_add_translate_x(const mat4* in_m1, float_t t, mat4* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
     if (t != 0.0f)
-        z->row3.x += t;
+        out_m->row3.x += t;
 }
 
-inline void mat4_add_translate_y(const mat4* x, float_t t, mat4* z) {
-    if (x != z)
-        *z = *x;
+inline void mat4_add_translate_y(const mat4* in_m1, float_t t, mat4* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
     if (t != 0.0f)
-        z->row3.y += t;
+        out_m->row3.y += t;
 }
 
-inline void mat4_add_translate_z(const mat4* x, float_t t, mat4* z) {
-    if (x != z)
-        *z = *x;
+inline void mat4_add_translate_z(const mat4* in_m1, float_t t, mat4* out_m) {
+    if (in_m1 != out_m)
+        *out_m = *in_m1;
     if (t != 0.0f)
-        z->row3.z += t;
+        out_m->row3.z += t;
 }
 
-inline void mat4_from_quat(const quat* quat, mat4* mat) {
-    float_t y;
-    float_t x;
-    float_t z;
-    float_t w;
-    float_t len;
-    float_t xy;
-    float_t yy;
-    float_t xx;
-    float_t wx;
-    float_t wy;
-    float_t zz;
-    float_t xz;
-    float_t wz;
-    float_t yz;
-
-    x = quat->x;
-    y = quat->y;
-    z = quat->z;
-    w = quat->w;
-    len = quat::length_squared(*quat);
-    len = len > 0.0f ? 2.0f / len : 0.0f;
-    xx = x * x * len;
-    xy = x * y * len;
-    xz = x * z * len;
-    yy = y * y * len;
-    zz = z * z * len;
-    yz = y * z * len;
-    wx = w * x * len;
-    wy = w * y * len;
-    wz = w * z * len;
-    mat->row0.x = 1.0f - zz - yy;
-    mat->row0.y = xy + wz;
-    mat->row0.z = xz - wy;
-    mat->row0.w = 0.0f;
-    mat->row1.x = xy - wz;
-    mat->row1.y = 1.0f - zz - xx;
-    mat->row1.z = yz + wx;
-    mat->row1.w = 0.0f;
-    mat->row2.x = xz + wy;
-    mat->row2.y = yz - wx;
-    mat->row2.z = 1.0f - yy - xx;
-    mat->row2.w = 0.0f;
-    mat->row3 = { 0.0f, 0.0f, 0.0f, 1.0f };
+inline void mat4_from_mat3(const mat3* in_m1, mat4* out_m) {
+    *(vec3*)&out_m->row0 = in_m1->row0;
+    out_m->row0.w = 0.0f;
+    *(vec3*)&out_m->row1 = in_m1->row1;
+    out_m->row1.w = 0.0f;
+    *(vec3*)&out_m->row2 = in_m1->row2;
+    out_m->row2.w = 0.0f;
+    out_m->row3 = { 0.0f, 0.0f, 0.0f, 1.0f };
 }
 
-float_t vec3_angle_between_two_vectors(const vec3* x, const vec3* y) {
-    vec3 z_t = vec3::cross(*x, *y);
-    float_t v2 = vec3::length(z_t);
-    float_t v3 = vec3::dot(*x, *y);
-    return fabsf(atan2f(v2, v3));
-}
-
-void mat4_from_two_vectors(const vec3* x, const vec3* y, mat4* mat) {
-    *mat = mat4_identity;
-    if (x->x == y->x && y->y == x->y && y->z == x->z)
-        return;
-
-    if (fabsf(1.0f - vec3::dot(*x, *y)) <= 0.000001f)
-        return;
-
-    vec3 axis = vec3::cross(*x, *y);
-    float_t axis_length = vec3::length(axis);
-    if (axis_length > 0.000001f) {
-        float_t angle = vec3_angle_between_two_vectors(x, y);
-        if (axis_length != 0.0)
-            axis *= 1.0f / axis_length;
-        mat4_from_axis_angle(&axis, angle, mat);
-    }
-}
-
-inline void mat4_from_axis_angle(const vec3* axis, float_t angle, mat4* mat) {
-    float_t s;
-    float_t c;
-    float_t c_1;
-    vec3 _axis;
-    vec3 _axis_s;
-    vec3 temp;
-
-    s = sinf(angle);
-    c = cosf(angle);
-    c_1 = 1.0f - c;
-
-    _axis = vec3::normalize(*axis);
-
-    _axis_s = _axis * s;
-    temp = _axis * (_axis.x * c_1);
-    mat->row0.x = temp.x + c;
-    mat->row1.x = temp.y - _axis_s.z;
-    mat->row2.x = temp.z + _axis_s.y;
-    temp = _axis * (_axis.y * c_1);
-    mat->row0.y = temp.x + _axis_s.z;
-    mat->row1.y = temp.y + c;
-    mat->row2.y = temp.z - _axis_s.x;
-    temp = _axis * (_axis.z * c_1);
-    mat->row0.z = temp.x - _axis_s.y;
-    mat->row1.z = temp.y + _axis_s.x;
-    mat->row2.z = temp.z + c;
-    mat->row0.w = 0.0f;
-    mat->row1.w = 0.0f;
-    mat->row2.w = 0.0f;
-    mat->row3 = { 0.0f, 0.0f, 0.0f, 1.0f };
-}
-
-inline void mat4_from_axis_angle(const vec3* axis, float_t s, float_t c, mat4* mat) {
-    float_t c_1;
-    vec3 _axis;
-    vec3 _axis_s;
-    vec3 temp;
-
-    c_1 = 1.0f - c;
-
-    _axis = vec3::normalize(*axis);
-
-    _axis_s = _axis * s;
-    temp = _axis * (_axis.x * c_1);
-    mat->row0.x = temp.x + c;
-    mat->row1.x = temp.y - _axis_s.z;
-    mat->row2.x = temp.z + _axis_s.y;
-    temp = _axis * (_axis.y * c_1);
-    mat->row0.y = temp.x + _axis_s.z;
-    mat->row1.y = temp.y + c;
-    mat->row2.y = temp.z - _axis_s.x;
-    temp = _axis * (_axis.z * c_1);
-    mat->row0.z = temp.x - _axis_s.y;
-    mat->row1.z = temp.y + _axis_s.x;
-    mat->row2.z = temp.z + c;
-    mat->row0.w = 0.0f;
-    mat->row1.w = 0.0f;
-    mat->row2.w = 0.0f;
-    mat->row3 = { 0.0f, 0.0f, 0.0f, 1.0f };
-}
-
-inline void mat4_from_mat3(const mat3* x, mat4* z) {
-    *(vec3*)&z->row0 = x->row0;
-    z->row0.w = 0.0f;
-    *(vec3*)&z->row1 = x->row1;
-    z->row1.w = 0.0f;
-    *(vec3*)&z->row2 = x->row2;
-    z->row2.w = 0.0f;
-    z->row3 = { 0.0f, 0.0f, 0.0f, 1.0f };
-}
-
-inline void mat4_from_mat3_inverse(const mat3* x, mat4* z) {
+inline void mat4_from_mat3_inverse(const mat3* in_m1, mat4* out_m) {
     mat3 yt;
 
-    mat3_inverse(x, &yt);
-    *(vec3*)&z->row0 = yt.row0;
-    z->row0.w = 0.0f;
-    *(vec3*)&z->row1 = yt.row1;
-    z->row1.w = 0.0f;
-    *(vec3*)&z->row2 = yt.row2;
-    z->row2.w = 0.0f;
-    z->row3 = { 0.0f, 0.0f, 0.0f, 1.0f };
+    mat3_invert(in_m1, &yt);
+    *(vec3*)&out_m->row0 = yt.row0;
+    out_m->row0.w = 0.0f;
+    *(vec3*)&out_m->row1 = yt.row1;
+    out_m->row1.w = 0.0f;
+    *(vec3*)&out_m->row2 = yt.row2;
+    out_m->row2.w = 0.0f;
+    out_m->row3 = { 0.0f, 0.0f, 0.0f, 1.0f };
 }
 
-inline void mat4_clear_rot(mat4* x, mat4* z) {
-    z->row0 = mat4_identity.row0;
-    z->row1 = mat4_identity.row1;
-    z->row2 = mat4_identity.row2;
-    z->row3 = x->row3;
+inline void mat4_clear_rot(const mat4* in_m1, mat4* out_m) {
+    out_m->row0 = mat4_identity.row0;
+    out_m->row1 = mat4_identity.row1;
+    out_m->row2 = mat4_identity.row2;
+    out_m->row3 = in_m1->row3;
 }
 
-inline void mat4_clear_trans(mat4* x, mat4* z) {
-    if (x != z) {
-        z->row0 = x->row0;
-        z->row1 = x->row1;
-        z->row2 = x->row2;
+inline void mat4_clear_trans(const mat4* in_m1, mat4* out_m) {
+    if (in_m1 != out_m) {
+        out_m->row0 = in_m1->row0;
+        out_m->row1 = in_m1->row1;
+        out_m->row2 = in_m1->row2;
     }
-    z->row3 = { 0.0f, 0.0f, 0.0f, 1.0f };
+    out_m->row3 = { 0.0f, 0.0f, 0.0f, 1.0f };
 }
 
-inline void mat4_get_rotation(const mat4* x, vec3* z) {
-    if (-x->row0.z >= 1.0f)
-        z->y = (float_t)M_PI_2;
-    else if (-x->row0.z <= -1.0f)
-        z->y = (float_t)-M_PI_2;
+inline void mat4_get_rotation(const mat4* in_m1, vec3* out_rad) {
+    if (-in_m1->row0.z >= 1.0f)
+        out_rad->y = (float_t)M_PI_2;
+    else if (-in_m1->row0.z <= -1.0f)
+        out_rad->y = (float_t)-M_PI_2;
     else
-        z->y = asinf(-x->row0.z);
+        out_rad->y = asinf(-in_m1->row0.z);
 
-    if (fabsf(x->row0.z) < 0.99999899f) {
-        z->x = atan2f(x->row1.z, x->row2.z);
-        z->z = atan2f(x->row0.y, x->row0.x);
+    if (fabsf(in_m1->row0.z) < 0.99999899f) {
+        out_rad->x = atan2f(in_m1->row1.z, in_m1->row2.z);
+        out_rad->z = atan2f(in_m1->row0.y, in_m1->row0.x);
     }
     else {
-        z->x = 0.0f;
-        z->z = atan2f(x->row2.y, x->row1.y);
-        if (x->row0.z > 0.0f)
-            z->z = -z->z;
+        out_rad->x = 0.0f;
+        out_rad->z = atan2f(in_m1->row2.y, in_m1->row1.y);
+        if (in_m1->row0.z > 0.0f)
+            out_rad->z = -out_rad->z;
     }
 }
 
-inline void mat4_get_scale(const mat4* x, vec3* z) {
-    z->x = vec4::length(x->row0);
-    z->y = vec4::length(x->row1);
-    z->z = vec4::length(x->row2);
+inline void mat4_get_scale(const mat4* in_m1, vec3* out_s) {
+    out_s->x = vec4::length(in_m1->row0);
+    out_s->y = vec4::length(in_m1->row1);
+    out_s->z = vec4::length(in_m1->row2);
 }
 
-inline void mat4_get_translation(const mat4* x, vec3* z) {
-    *z = *(vec3*)&x->row3;
+inline void mat4_get_translation(const mat4* in_m1, vec3* out_t) {
+    *out_t = *(vec3*)&in_m1->row3;
 }
 
-inline void mat4_set_translation(mat4* x, vec3* z) {
-    *(vec3*)&x->row3 = *z;
+inline void mat4_set_translation(mat4* in_m1, const vec3* in_t) {
+    *(vec3*)&in_m1->row3 = *in_t;
 }
 
-inline void mat4_blend(const mat4* x, const mat4* y, mat4* z, float_t blend) {
-    quat q0;
-    quat q1;
-    quat q2;
-
-    quat_from_mat3(x->row0.x, x->row1.x, x->row2.x, x->row0.y,
-        x->row1.y, x->row2.y, x->row0.z, x->row1.z, x->row2.z, &q0);
-    q0 = quat::normalize(q0);
-    quat_from_mat3(y->row0.x, y->row1.x, y->row2.x, y->row0.y,
-        y->row1.y, y->row2.y, y->row0.z, y->row1.z, y->row2.z, &q1);
-    q1 = quat::normalize(q1);
-
-    vec3 t0;
-    vec3 t1;
-    vec3 t2;
-    mat4_get_translation(x, &t0);
-    mat4_get_translation(y, &t1);
-
-    q2 = quat::lerp(q0, q1, blend);
-    t2 = vec3::lerp(t0, t1, blend);
-
-    mat4_from_quat(&q2, z);
-    mat4_set_translation(z, &t2);
-}
-
-inline void mat4_blend_rotation(const mat4* x, const mat4* y, mat4* z, float_t blend) {
-    quat q0;
-    quat q1;
-    quat q2;
-
-    quat_from_mat3(x->row0.x, x->row1.x, x->row2.x, x->row0.y,
-        x->row1.y, x->row2.y, x->row0.z, x->row1.z, x->row2.z, &q0);
-    quat_from_mat3(y->row0.x, y->row1.x, y->row2.x, y->row0.y,
-        y->row1.y, y->row2.y, y->row0.z, y->row1.z, y->row2.z, &q1);
-    q2 = quat::slerp(q0, q1, blend);
-    mat4_from_quat(&q2, z);
-}
-
-void mat4_lerp_rotation(const mat4* x, const mat4* y, mat4* z, float_t blend) {
-    vec3 m0;
-    vec3 m1;
-    m0 = vec3::lerp(*(vec3*)&x->row0, *(vec3*)&y->row0, blend);
-    m1 = vec3::lerp(*(vec3*)&x->row1, *(vec3*)&y->row1, blend);
-
-    float_t m0_len_sq = vec3::length_squared(m0);
-    float_t m1_len_sq = vec3::length_squared(m1);
-
-    if (m0_len_sq <= 0.000001f || m1_len_sq <= 0.000001f) {
-        *z = *y;
-        return;
-    }
-
-    vec3 m2;
-    m2 = vec3::cross(m0, m1);
-    m1 = vec3::cross(m2, m0);
-
-    float_t m2_len_sq;
-    m1_len_sq = vec3::length_squared(m1);
-    m2_len_sq = vec3::length_squared(m2);
-    if (m2_len_sq <= 0.000001f || m1_len_sq <= 0.000001) {
-        *z = *y;
-        return;
-    }
-
-    float_t m0_len = sqrtf(m0_len_sq);
-    if (m0_len != 0.0f)
-        m0 *= 1.0f / m0_len;
-
-    float_t m1_len = sqrtf(m1_len_sq);
-    if (m1_len != 0.0f)
-        m1 *= 1.0f / m1_len;
-
-    float_t m2_len = sqrtf(m2_len_sq);
-    if (m2_len != 0.0f)
-        m2 *= 1.0f / m2_len;
-
-    *z = mat4_identity;
-    *(vec3*)&z->row0 = m0;
-    *(vec3*)&z->row1 = m1;
-    *(vec3*)&z->row2 = m2;
-}
-
-inline float_t mat4_get_max_scale(const mat4* x) {
+inline float_t mat4_get_max_scale(const mat4* in_m1) {
     mat4 mat;
-    mat4_transpose(x, &mat);
+    mat4_transpose(in_m1, &mat);
 
     float_t length;
     float_t max = 0.0f;
@@ -2156,65 +1855,120 @@ inline float_t mat4_get_max_scale(const mat4* x) {
     return max;
 }
 
-inline void mat4_mult_axis_angle(const mat4* x, const vec3* axis, const float_t angle, mat4* z) {
+inline void mat4_blend(const mat4* in_m1, const mat4* in_m2, mat4* out_m, float_t blend) {
+    quat q0;
     quat q1;
     quat q2;
-    quat q3;
-    float_t t0;
-    float_t t1;
-    float_t t2;
-    vec4 t3;
 
-    t0 = x->row0.w;
-    t1 = x->row1.w;
-    t2 = x->row2.w;
-    t3 = x->row3;
-    quat_from_mat3(x->row0.x, x->row1.x, x->row2.x, x->row0.y,
-        x->row1.y, x->row2.y, x->row0.z, x->row1.z, x->row2.z, &q1);
-    quat_from_axis_angle(axis, angle, &q2);
-    quat_mult(&q2, &q1, &q3);
-    mat4_from_quat(&q3, z);
-    z->row0.w = t0;
-    z->row1.w = t1;
-    z->row2.w = t2;
-    z->row3 = t3;
+    q0 = quat(in_m1->row0.x, in_m1->row1.x, in_m1->row2.x, in_m1->row0.y,
+        in_m1->row1.y, in_m1->row2.y, in_m1->row0.z, in_m1->row1.z, in_m1->row2.z);
+    q0 = quat::normalize(q0);
+    q1 = quat(in_m2->row0.x, in_m2->row1.x, in_m2->row2.x, in_m2->row0.y,
+        in_m2->row1.y, in_m2->row2.y, in_m2->row0.z, in_m2->row1.z, in_m2->row2.z);
+    q1 = quat::normalize(q1);
+
+    vec3 t0;
+    vec3 t1;
+    vec3 t2;
+    mat4_get_translation(in_m1, &t0);
+    mat4_get_translation(in_m2, &t1);
+
+    q2 = quat::lerp(q0, q1, blend);
+    t2 = vec3::lerp(t0, t1, blend);
+
+    mat4_set(&q2, out_m);
+    mat4_set_translation(out_m, &t2);
+}
+
+inline void mat4_blend_rotation(const mat4* in_m1, const mat4* in_m2, mat4* out_m, float_t blend) {
+    quat q1 = quat(in_m1->row0.x, in_m1->row1.x, in_m1->row2.x, in_m1->row0.y,
+        in_m1->row1.y, in_m1->row2.y, in_m1->row0.z, in_m1->row1.z, in_m1->row2.z);
+    quat q2 = quat(in_m2->row0.x, in_m2->row1.x, in_m2->row2.x, in_m2->row0.y,
+        in_m2->row1.y, in_m2->row2.y, in_m2->row0.z, in_m2->row1.z, in_m2->row2.z);
+    quat q3 = quat::slerp(q1, q2, blend);
+    mat4_set(&q3, out_m);
+}
+
+void mat4_lerp_rotation(const mat4* in_m1, const mat4* in_m2, mat4* out_m, float_t blend) {
+    vec3 m0;
+    vec3 m1;
+    m0 = vec3::lerp(*(vec3*)&in_m1->row0, *(vec3*)&in_m2->row0, blend);
+    m1 = vec3::lerp(*(vec3*)&in_m1->row1, *(vec3*)&in_m2->row1, blend);
+
+    float_t m0_len_sq = vec3::length_squared(m0);
+    float_t m1_len_sq = vec3::length_squared(m1);
+
+    if (m0_len_sq <= 0.000001f || m1_len_sq <= 0.000001f) {
+        *out_m = *in_m2;
+        return;
+    }
+
+    vec3 m2;
+    m2 = vec3::cross(m0, m1);
+    m1 = vec3::cross(m2, m0);
+
+    float_t m2_len_sq;
+    m1_len_sq = vec3::length_squared(m1);
+    m2_len_sq = vec3::length_squared(m2);
+    if (m2_len_sq <= 0.000001f || m1_len_sq <= 0.000001) {
+        *out_m = *in_m2;
+        return;
+    }
+
+    float_t m0_len = sqrtf(m0_len_sq);
+    if (m0_len != 0.0f)
+        m0 *= 1.0f / m0_len;
+
+    float_t m1_len = sqrtf(m1_len_sq);
+    if (m1_len != 0.0f)
+        m1 *= 1.0f / m1_len;
+
+    float_t m2_len = sqrtf(m2_len_sq);
+    if (m2_len != 0.0f)
+        m2 *= 1.0f / m2_len;
+
+    *out_m = mat4_identity;
+    *(vec3*)&out_m->row0 = m0;
+    *(vec3*)&out_m->row1 = m1;
+    *(vec3*)&out_m->row2 = m2;
 }
 
 inline void mat4_frustrum(double_t left, double_t right,
-    double_t bottom, double_t top, double_t z_near, double_t z_far, mat4* mat) {
-    *mat = mat4_null;
-    mat->row0.x = (float_t)((2.0 * z_near) / (right - left));
-    mat->row1.y = (float_t)((2.0 * z_near) / (top - bottom));
-    mat->row2.x = (float_t)((right + left) / (right - left));
-    mat->row2.y = (float_t)((top + bottom) / (top - bottom));
-    mat->row2.z = -(float_t)((z_far + z_near) / (z_far - z_near));
-    mat->row2.w = -1.0f;
-    mat->row3.z = -(float_t)((2.0 * z_far * z_near) / (z_far - z_near));
+    double_t bottom, double_t top, double_t z_near, double_t z_far, mat4* out_m) {
+    *out_m = mat4_null;
+    out_m->row0.x = (float_t)((2.0 * z_near) / (right - left));
+    out_m->row1.y = (float_t)((2.0 * z_near) / (top - bottom));
+    out_m->row2.x = (float_t)((right + left) / (right - left));
+    out_m->row2.y = (float_t)((top + bottom) / (top - bottom));
+    out_m->row2.z = -(float_t)((z_far + z_near) / (z_far - z_near));
+    out_m->row2.w = -1.0f;
+    out_m->row3.z = -(float_t)((2.0 * z_far * z_near) / (z_far - z_near));
 }
 
 inline void mat4_ortho(double_t left, double_t right,
-    double_t bottom, double_t top, double_t z_near, double_t z_far, mat4* mat) {
-    *mat = mat4_identity;
-    mat->row0.x = (float_t)(2.0 / (right - left));
-    mat->row1.y = (float_t)(2.0 / (top - bottom));
-    mat->row2.z = (float_t)(-2.0 / (z_far - z_near));
-    mat->row3.x = -(float_t)((right + left) / (right - left));
-    mat->row3.y = -(float_t)((top + bottom) / (top - bottom));
-    mat->row3.z = -(float_t)((z_far + z_near) / (z_far - z_near));
+    double_t bottom, double_t top, double_t z_near, double_t z_far, mat4* out_m) {
+    *out_m = mat4_null;
+    out_m->row0.x = (float_t)(2.0 / (right - left));
+    out_m->row1.y = (float_t)(2.0 / (top - bottom));
+    out_m->row2.z = (float_t)(-2.0 / (z_far - z_near));
+    out_m->row3.x = -(float_t)((right + left) / (right - left));
+    out_m->row3.y = -(float_t)((top + bottom) / (top - bottom));
+    out_m->row3.z = -(float_t)((z_far + z_near) / (z_far - z_near));
+    out_m->row3.w = 1.0f;
 }
 
-inline void mat4_persp(double_t fov_y, double_t aspect, double_t z_near, double_t z_far, mat4* mat) {
+inline void mat4_persp(double_t fov_y, double_t aspect, double_t z_near, double_t z_far, mat4* out_m) {
     double_t tan_fov = tan(fov_y * 0.5);
 
-    *mat = mat4_null;
-    mat->row0.x = (float_t)(1.0 / (aspect * tan_fov));
-    mat->row1.y = (float_t)(1.0 / tan_fov);
-    mat->row2.z = -(float_t)((z_far + z_near) / (z_far - z_near));
-    mat->row2.w = -1.0f;
-    mat->row3.z = -(float_t)((2.0 * z_far * z_near) / (z_far - z_near));
+    *out_m = mat4_null;
+    out_m->row0.x = (float_t)(1.0 / (aspect * tan_fov));
+    out_m->row1.y = (float_t)(1.0 / tan_fov);
+    out_m->row2.z = -(float_t)((z_far + z_near) / (z_far - z_near));
+    out_m->row2.w = -1.0f;
+    out_m->row3.z = -(float_t)((2.0 * z_far * z_near) / (z_far - z_near));
 }
 
-inline void mat4_look_at(const vec3* eye, const vec3* target, const vec3* up, mat4* mat) {
+inline void mat4_look_at(const vec3* eye, const vec3* target, const vec3* up, mat4* out_m) {
     vec3 x_axis, y_axis, z_axis;
     vec3 xyz;
 
@@ -2230,14 +1984,14 @@ inline void mat4_look_at(const vec3* eye, const vec3* target, const vec3* up, ma
     xyz.y = vec3::dot(y_axis, *eye);
     xyz.z = vec3::dot(z_axis, *eye);
 
-    mat->row0 = { x_axis.x, y_axis.x, z_axis.x, 0.0f };
-    mat->row1 = { x_axis.y, y_axis.y, z_axis.y, 0.0f };
-    mat->row2 = { x_axis.z, y_axis.z, z_axis.z, 0.0f };
-    *(vec3*)&mat->row3 = -xyz;
-    mat->row3.w = 1.0f;
+    out_m->row0 = { x_axis.x, y_axis.x, z_axis.x, 0.0f };
+    out_m->row1 = { x_axis.y, y_axis.y, z_axis.y, 0.0f };
+    out_m->row2 = { x_axis.z, y_axis.z, z_axis.z, 0.0f };
+    *(vec3*)&out_m->row3 = -xyz;
+    out_m->row3.w = 1.0f;
 }
 
-inline void mat4_look_at(const vec3* eye, const vec3* target, mat4* mat) {
+inline void mat4_look_at(const vec3* eye, const vec3* target, mat4* out_m) {
     vec3 up = { 0.0f, 1.0f, 0.0f };
     vec3 dir;
     dir = *target - *eye;
@@ -2250,5 +2004,5 @@ inline void mat4_look_at(const vec3* eye, const vec3* target, mat4* mat) {
             up.z = -1.0f;
     }
 
-    mat4_look_at(eye, target, &up, mat);
+    mat4_look_at(eye, target, &up, out_m);
 }
diff --git a/src/KKdLib/mat.hpp b/src/KKdLib/mat.hpp
index eb572cea..4f0cde1f 100644
--- a/src/KKdLib/mat.hpp
+++ b/src/KKdLib/mat.hpp
@@ -45,300 +45,301 @@ extern const mat3 mat3_null;
 extern const mat4 mat4_identity;
 extern const mat4 mat4_null;
 
-extern void mat3_add(const mat3* x, float_t y, mat3* z);
-extern void mat3_add(const mat3* x, const mat3* y, mat3* z);
-extern void mat3_sub(const mat3* x, float_t y, mat3* z);
-extern void mat3_sub(const mat3* x, const mat3* y, mat3* z);
-extern void mat3_mul(const mat3* x, float_t y, mat3* z);
-extern void mat3_mul(const mat3* x, const mat3* y, mat3* z);
-extern void mat3_transform_vector(const mat3* x, const vec2* y, vec2* z);
-extern void mat3_transform_vector(const mat3* x, const vec3* y, vec3* z);
-extern void mat3_inverse_transform_vector(const mat3* x, const vec2* y, vec2* z);
-extern void mat3_inverse_transform_vector(const mat3* x, const vec3* y, vec3* z);
-extern void mat3_transpose(const mat3* x, mat3* z);
-extern void mat3_inverse(const mat3* x, mat3* z);
-extern void mat3_invtrans(const mat3* x, mat3* z);
-extern void mat3_inverse_normalized(const mat3* x, mat3* z);
-extern void mat3_normalize(const mat3* x, mat3* z);
-extern void mat3_normalize_rotation(const mat3* x, mat3* z);
-extern float_t mat3_determinant(const mat3* x);
-extern void mat3_rotate_x(float_t rad, mat3* y);
-extern void mat3_rotate_y(float_t rad, mat3* y);
-extern void mat3_rotate_z(float_t rad, mat3* y);
-extern void mat3_rotate_x(float_t s, float_t c, mat3* y);
-extern void mat3_rotate_y(float_t s, float_t c, mat3* y);
-extern void mat3_rotate_z(float_t s, float_t c, mat3* y);
-extern void mat3_rotate_xyz(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z);
-extern void mat3_rotate_xzy(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z);
-extern void mat3_rotate_yxz(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z);
-extern void mat3_rotate_yzx(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z);
-extern void mat3_rotate_zxy(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z);
-extern void mat3_rotate_zyx(float_t rad_x, float_t rad_y, float_t rad_z, mat3* z);
-extern void mat3_mul_rotate_x(const mat3* x, float_t rad, mat3* z);
-extern void mat3_mul_rotate_y(const mat3* x, float_t rad, mat3* z);
-extern void mat3_mul_rotate_z(const mat3* x, float_t rad, mat3* z);
-extern void mat3_mul_rotate_x(const mat3* x, float_t s, float_t c, mat3* z);
-extern void mat3_mul_rotate_y(const mat3* x, float_t s, float_t c, mat3* z);
-extern void mat3_mul_rotate_z(const mat3* x, float_t s, float_t c, mat3* z);
-extern void mat3_mul_rotate_xyz(const mat3* x, float_t rad_x, float_t rad_y, float_t rad_z, mat3* z);
-extern void mat3_mul_rotate_xzy(const mat3* x, float_t rad_x, float_t rad_y, float_t rad_z, mat3* z);
-extern void mat3_mul_rotate_yxz(const mat3* x, float_t rad_x, float_t rad_y, float_t rad_z, mat3* z);
-extern void mat3_mul_rotate_yzx(const mat3* x, float_t rad_x, float_t rad_y, float_t rad_z, mat3* z);
-extern void mat3_mul_rotate_zxy(const mat3* x, float_t rad_x, float_t rad_y, float_t rad_z, mat3* z);
-extern void mat3_mul_rotate_zyx(const mat3* x, float_t rad_x, float_t rad_y, float_t rad_z, mat3* z);
-extern void mat3_scale(float_t sx, float_t sy, float_t sz, mat3* z);
-extern void mat3_scale_x(float_t s, mat3* y);
-extern void mat3_scale_y(float_t s, mat3* y);
-extern void mat3_scale_z(float_t s, mat3* y);
-extern void mat3_mul_scale(const mat3* x, float_t sx, float_t sy, float_t sz, mat3* z);
-extern void mat3_mul_scale_x(const mat3* x, float_t s, mat3* z);
-extern void mat3_mul_scale_y(const mat3* x, float_t s, mat3* z);
-extern void mat3_mul_scale_z(const mat3* x, float_t s, mat3* z);
-extern void mat3_from_quat(const quat* quat, mat3* mat);
-extern void mat3_from_axis_angle(const vec3* axis, float_t angle, mat3* mat);
-extern void mat3_from_axis_angle(const vec3* axis, float_t s, float_t c, mat3* mat);
-extern void mat3_from_mat4(const mat4* x, mat3* z);
-extern void mat3_from_mat4_inverse(const mat4* x, mat3* z);
-extern void mat3_get_rotation(const mat3* x, vec3* z);
-extern void mat3_get_scale(const mat3* x, vec3* z);
-extern float_t mat3_get_max_scale(const mat3* x);
-extern void mat3_mult_axis_angle(const mat3* x, const vec3* axis, const float_t angle, mat3* z);
+extern void mat3_set(const quat* in_q1, mat3* out_m);
+extern void mat3_set(const vec3* in_axis, const float_t in_angle, mat3* out_m);
+extern void mat3_set(const vec3* in_axis, const float_t s, const float_t c, mat3* out_m);
+extern void mat3_add(const mat3* in_m1, const float_t value, mat3* out_m);
+extern void mat3_add(const mat3* in_m1, const mat3* in_m2, mat3* out_m);
+extern void mat3_sub(const mat3* in_m1, const float_t value, mat3* out_m);
+extern void mat3_sub(const mat3* in_m1, const mat3* in_m2, mat3* out_m);
+extern void mat3_mul(const mat3* in_m1, const float_t value, mat3* out_m);
+extern void mat3_mul(const mat3* in_m1, const mat3* in_m2, mat3* out_m);
+extern void mat3_mul(const mat3* in_m1, const vec3* in_axis, const float_t in_angle, mat3* out_m);
+extern void mat3_transform_vector(const mat3* in_m1, const vec2* normal, vec2* normalOut);
+extern void mat3_transform_vector(const mat3* in_m1, const vec3* normal, vec3* normalOut);
+extern void mat3_inverse_transform_vector(const mat3* in_m1, const vec2* normal, vec2* normalOut);
+extern void mat3_inverse_transform_vector(const mat3* in_m1, const vec3* normal, vec3* normalOut);
+extern void mat3_transpose(const mat3* in_m1, mat3* out_m);
+extern void mat3_invert(const mat3* in_m1, mat3* out_m);
+extern void mat3_invert_fast(const mat3* in_m1, mat3* out_m);
+extern void mat3_normalize(const mat3* in_m1, mat3* out_m);
+extern void mat3_normalize_rotation(const mat3* in_m1, mat3* out_m);
+extern float_t mat3_determinant(const mat3* in_m1);
+extern void mat3_rotate_x(float_t rad, mat3* out_m);
+extern void mat3_rotate_y(float_t rad, mat3* out_m);
+extern void mat3_rotate_z(float_t rad, mat3* out_m);
+extern void mat3_rotate_x(float_t s, float_t c, mat3* out_m);
+extern void mat3_rotate_y(float_t s, float_t c, mat3* out_m);
+extern void mat3_rotate_z(float_t s, float_t c, mat3* out_m);
+extern void mat3_rotate_xyz(float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m);
+extern void mat3_rotate_xzy(float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m);
+extern void mat3_rotate_yxz(float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m);
+extern void mat3_rotate_yzx(float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m);
+extern void mat3_rotate_zxy(float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m);
+extern void mat3_rotate_zyx(float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m);
+extern void mat3_mul_rotate_x(const mat3* in_m1, float_t rad, mat3* out_m);
+extern void mat3_mul_rotate_y(const mat3* in_m1, float_t rad, mat3* out_m);
+extern void mat3_mul_rotate_z(const mat3* in_m1, float_t rad, mat3* out_m);
+extern void mat3_mul_rotate_x(const mat3* in_m1, float_t s, float_t c, mat3* out_m);
+extern void mat3_mul_rotate_y(const mat3* in_m1, float_t s, float_t c, mat3* out_m);
+extern void mat3_mul_rotate_z(const mat3* in_m1, float_t s, float_t c, mat3* out_m);
+extern void mat3_mul_rotate_xyz(const mat3* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m);
+extern void mat3_mul_rotate_xzy(const mat3* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m);
+extern void mat3_mul_rotate_yxz(const mat3* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m);
+extern void mat3_mul_rotate_yzx(const mat3* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m);
+extern void mat3_mul_rotate_zxy(const mat3* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m);
+extern void mat3_mul_rotate_zyx(const mat3* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat3* out_m);
+extern void mat3_scale(float_t sx, float_t sy, float_t sz, mat3* out_m);
+extern void mat3_scale_x(float_t s, mat3* out_m);
+extern void mat3_scale_y(float_t s, mat3* out_m);
+extern void mat3_scale_z(float_t s, mat3* out_m);
+extern void mat3_mul_scale(const mat3* in_m1, float_t sx, float_t sy, float_t sz, mat3* out_m);
+extern void mat3_mul_scale_x(const mat3* in_m1, float_t s, mat3* out_m);
+extern void mat3_mul_scale_y(const mat3* in_m1, float_t s, mat3* out_m);
+extern void mat3_mul_scale_z(const mat3* in_m1, float_t s, mat3* out_m);
+extern void mat3_get_rotation(const mat3* in_m1, vec3* out_rad);
+extern void mat3_get_scale(const mat3* in_m1, vec3* out_s);
+extern float_t mat3_get_max_scale(const mat3* in_m1);
 
-extern void mat4_add(const mat4* x, float_t y, mat4* z);
-extern void mat4_add(const mat4* x, const mat4* y, mat4* z);
-extern void mat4_sub(const mat4* x, float_t y, mat4* z);
-extern void mat4_sub(const mat4* x, const mat4* y, mat4* z);
-extern void mat4_mul(const mat4* x, float_t y, mat4* z);
-extern void mat4_mul(const mat4* x, const mat4* y, mat4* z);
-extern void mat4_transform_vector(const mat4* x, const vec2* y, vec2* z);
-extern void mat4_transform_vector(const mat4* x, const vec3* y, vec3* z);
-extern void mat4_transform_vector(const mat4* x, const vec4* y, vec4* z);
-extern void mat4_transform_point(const mat4* x, const vec2* y, vec2* z);
-extern void mat4_transform_point(const mat4* x, const vec3* y, vec3* z);
-extern void mat4_inverse_transform_vector(const mat4* x, const vec2* y, vec2* z);
-extern void mat4_inverse_transform_vector(const mat4* x, const vec3* y, vec3* z);
-extern void mat4_inverse_transform_vector(const mat4* x, const vec4* y, vec4* z);
-extern void mat4_inverse_transform_point(const mat4* x, const vec2* y, vec2* z);
-extern void mat4_inverse_transform_point(const mat4* x, const vec3* y, vec3* z);
-extern void mat4_transpose(const mat4* x, mat4* z);
-extern void mat4_inverse(const mat4* x, mat4* z);
-extern void mat4_invtrans(const mat4* x, mat4* z);
-extern void mat4_invrot(const mat4* x, mat4* z);
-extern void mat4_inverse_normalized(const mat4* x, mat4* z);
-extern void mat4_invrot_normalized(const mat4* x, mat4* z);
-extern void mat4_normalize(const mat4* x, mat4* z);
-extern void mat4_normalize_rotation(const mat4* x, mat4* z);
-extern float_t mat4_determinant(const mat4* x);
-extern void mat4_rotate_x(float_t rad, mat4* y);
-extern void mat4_rotate_y(float_t rad, mat4* y);
-extern void mat4_rotate_z(float_t rad, mat4* y);
-extern void mat4_rotate_x(float_t s, float_t c, mat4* y);
-extern void mat4_rotate_y(float_t s, float_t c, mat4* y);
-extern void mat4_rotate_z(float_t s, float_t c, mat4* y);
-extern void mat4_rotate_xyz(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z);
-extern void mat4_rotate_xzy(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z);
-extern void mat4_rotate_yxz(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z);
-extern void mat4_rotate_yzx(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z);
-extern void mat4_rotate_zxy(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z);
-extern void mat4_rotate_zyx(float_t rad_x, float_t rad_y, float_t rad_z, mat4* z);
-extern void mat4_mul_rotate_x(const mat4* x, float_t rad, mat4* z);
-extern void mat4_mul_rotate_y(const mat4* x, float_t rad, mat4* z);
-extern void mat4_mul_rotate_z(const mat4* x, float_t rad, mat4* z);
-extern void mat4_mul_rotate_x(const mat4* x, float_t s, float_t c, mat4* z);
-extern void mat4_mul_rotate_y(const mat4* x, float_t s, float_t c, mat4* z);
-extern void mat4_mul_rotate_z(const mat4* x, float_t s, float_t c, mat4* z);
-extern void mat4_mul_rotate_xyz(const mat4* x, float_t rad_x, float_t rad_y, float_t rad_z, mat4* z);
-extern void mat4_mul_rotate_xzy(const mat4* x, float_t rad_x, float_t rad_y, float_t rad_z, mat4* z);
-extern void mat4_mul_rotate_yxz(const mat4* x, float_t rad_x, float_t rad_y, float_t rad_z, mat4* z);
-extern void mat4_mul_rotate_yzx(const mat4* x, float_t rad_x, float_t rad_y, float_t rad_z, mat4* z);
-extern void mat4_mul_rotate_zxy(const mat4* x, float_t rad_x, float_t rad_y, float_t rad_z, mat4* z);
-extern void mat4_mul_rotate_zyx(const mat4* x, float_t rad_x, float_t rad_y, float_t rad_z, mat4* z);
-extern void mat4_scale(float_t sx, float_t sy, float_t sz, mat4* z);
-extern void mat4_scale_x(float_t s, mat4* y);
-extern void mat4_scale_y(float_t s, mat4* y);
-extern void mat4_scale_z(float_t s, mat4* y);
-extern void mat4_mul_scale(const mat4* x, float_t sx, float_t sy, float_t sz, float_t sw, mat4* z);
-extern void mat4_mul_scale_x(const mat4* x, float_t s, mat4* z);
-extern void mat4_mul_scale_y(const mat4* x, float_t s, mat4* z);
-extern void mat4_mul_scale_z(const mat4* x, float_t s, mat4* z);
-extern void mat4_scale_w_mult(const mat4* x, float_t s, mat4* z);
-extern void mat4_scale_rot(const mat4* x, float_t sx, float_t sy, float_t sz, mat4* z);
-extern void mat4_scale_x_rot(const mat4* x, float_t s, mat4* z);
-extern void mat4_scale_y_rot(const mat4* x, float_t s, mat4* z);
-extern void mat4_scale_z_rot(const mat4* x, float_t s, mat4* z);
-extern void mat4_translate(float_t tx, float_t ty, float_t tz, mat4* z);
-extern void mat4_translate_x(float_t t, mat4* y);
-extern void mat4_translate_y(float_t t, mat4* y);
-extern void mat4_translate_z(float_t t, mat4* y);
-extern void mat4_mul_translate(const mat4* x, float_t tx, float_t ty, float_t tz, mat4* z);
-extern void mat4_mul_translate_x(const mat4* x, float_t t, mat4* z);
-extern void mat4_mul_translate_y(const mat4* x, float_t t, mat4* z);
-extern void mat4_mul_translate_z(const mat4* x, float_t t, mat4* z);
-extern void mat4_add_translate(const mat4* x, float_t tx, float_t ty, float_t tz, mat4* z);
-extern void mat4_add_translate_x(const mat4* x, float_t t, mat4* z);
-extern void mat4_add_translate_y(const mat4* x, float_t t, mat4* z);
-extern void mat4_add_translate_z(const mat4* x, float_t t, mat4* z);
-extern void mat4_from_quat(const quat* quat, mat4* mat);
-extern void mat4_from_two_vectors(const vec3* x, const vec3* y, mat4* mat);
-extern void mat4_from_axis_angle(const vec3* axis, float_t angle, mat4* mat);
-extern void mat4_from_axis_angle(const vec3* axis, float_t s, float_t c, mat4* mat);
-extern void mat4_from_mat3(const mat3* x, mat4* z);
-extern void mat4_from_mat3_inverse(const mat3* x, mat4* z);
-extern void mat4_clear_rot(mat4* x, mat4* z);
-extern void mat4_clear_trans(mat4* x, mat4* z);
-extern void mat4_get_scale(const mat4* x, vec3* z);
-extern void mat4_get_rotation(const mat4* x, vec3* z);
-extern void mat4_get_translation(const mat4* x, vec3* z);
-extern void mat4_set_translation(mat4* x, vec3* z);
-extern void mat4_blend(const mat4* x, const mat4* y, mat4* z, float_t blend);
-extern void mat4_blend_rotation(const mat4* x, const mat4* y, mat4* z, float_t blend);
-extern void mat4_lerp_rotation(const mat4* x, const mat4* y, mat4* z, float_t blend);
-extern float_t mat4_get_max_scale(const mat4* x);
-extern void mat4_mult_axis_angle(const mat4* x, const vec3* axis, const float_t angle, mat4* z);
+extern void mat4_set(const quat* in_q1, mat4* out_m);
+extern void mat4_set(const vec3* in_v1, const vec3* in_v2, mat4* out_m);
+extern void mat4_set(const vec3* in_axis, const float_t in_angle, mat4* out_m);
+extern void mat4_set(const vec3* in_axis, const float_t s, const float_t c, mat4* out_m);
+extern void mat4_set_rotation(mat4* in_m1, const quat* in_q1);
+extern void mat4_set_rotation(mat4* in_m1, const vec3* in_axis, const float_t in_angle);
+extern void mat4_set_rotation(mat4* in_m1, const vec3* in_axis, const float_t s, const float_t c);
+extern void mat4_add(const mat4* in_m1, const float_t value, mat4* out_m);
+extern void mat4_add(const mat4* in_m1, const mat4* in_m2, mat4* out_m);
+extern void mat4_sub(const mat4* in_m1, const float_t value, mat4* out_m);
+extern void mat4_sub(const mat4* in_m1, const mat4* in_m2, mat4* out_m);
+extern void mat4_mul(const mat4* in_m1, const float_t value, mat4* out_m);
+extern void mat4_mul(const mat4* in_m1, const mat4* in_m2, mat4* out_m);
+extern void mat4_mul_rotation(const mat4* in_m1, const vec3* in_axis, const float_t angle, mat4* out_m);
+extern void mat4_transform_vector(const mat4* in_m1, const vec2* normal, vec2* normalOut);
+extern void mat4_transform_vector(const mat4* in_m1, const vec3* normal, vec3* normalOut);
+extern void mat4_transform_vector(const mat4* in_m1, const vec4* normal, vec4* normalOut);
+extern void mat4_transform_point(const mat4* in_m1, const vec2* point, vec2* pointOut);
+extern void mat4_transform_point(const mat4* in_m1, const vec3* point, vec3* pointOut);
+extern void mat4_inverse_transform_vector(const mat4* in_m1, const vec2* normal, vec2* normalOut);
+extern void mat4_inverse_transform_vector(const mat4* in_m1, const vec3* normal, vec3* normalOut);
+extern void mat4_inverse_transform_vector(const mat4* in_m1, const vec4* normal, vec4* normalOut);
+extern void mat4_inverse_transform_point(const mat4* in_m1, const vec2* point, vec2* pointOut);
+extern void mat4_inverse_transform_point(const mat4* in_m1, const vec3* point, vec3* pointOut);
+extern void mat4_transpose(const mat4* in_m1, mat4* out_m);
+extern void mat4_invert(const mat4* in_m1, mat4* out_m);
+extern void mat4_invert_rotation(const mat4* in_m1, mat4* out_m);
+extern void mat4_invert_fast(const mat4* in_m1, mat4* out_m);
+extern void mat4_invert_rotation_fast(const mat4* in_m1, mat4* out_m);
+extern void mat4_normalize(const mat4* in_m1, mat4* out_m);
+extern void mat4_normalize_rotation(const mat4* in_m1, mat4* out_m);
+extern float_t mat4_determinant(const mat4* in_m1);
+extern void mat4_rotate_x(float_t rad, mat4* out_m);
+extern void mat4_rotate_y(float_t rad, mat4* out_m);
+extern void mat4_rotate_z(float_t rad, mat4* out_m);
+extern void mat4_rotate_x(float_t s, float_t c, mat4* out_m);
+extern void mat4_rotate_y(float_t s, float_t c, mat4* out_m);
+extern void mat4_rotate_z(float_t s, float_t c, mat4* out_m);
+extern void mat4_rotate_xyz(float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m);
+extern void mat4_rotate_xzy(float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m);
+extern void mat4_rotate_yxz(float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m);
+extern void mat4_rotate_yzx(float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m);
+extern void mat4_rotate_zxy(float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m);
+extern void mat4_rotate_zyx(float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m);
+extern void mat4_mul_rotate_x(const mat4* in_m1, float_t rad, mat4* out_m);
+extern void mat4_mul_rotate_y(const mat4* in_m1, float_t rad, mat4* out_m);
+extern void mat4_mul_rotate_z(const mat4* in_m1, float_t rad, mat4* out_m);
+extern void mat4_mul_rotate_x(const mat4* in_m1, float_t s, float_t c, mat4* out_m);
+extern void mat4_mul_rotate_y(const mat4* in_m1, float_t s, float_t c, mat4* out_m);
+extern void mat4_mul_rotate_z(const mat4* in_m1, float_t s, float_t c, mat4* out_m);
+extern void mat4_mul_rotate_xyz(const mat4* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m);
+extern void mat4_mul_rotate_xzy(const mat4* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m);
+extern void mat4_mul_rotate_yxz(const mat4* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m);
+extern void mat4_mul_rotate_yzx(const mat4* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m);
+extern void mat4_mul_rotate_zxy(const mat4* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m);
+extern void mat4_mul_rotate_zyx(const mat4* in_m1, float_t rad_x, float_t rad_y, float_t rad_z, mat4* out_m);
+extern void mat4_scale(float_t sx, float_t sy, float_t sz, mat4* out_m);
+extern void mat4_scale_x(float_t s, mat4* out_m);
+extern void mat4_scale_y(float_t s, mat4* out_m);
+extern void mat4_scale_z(float_t s, mat4* out_m);
+extern void mat4_mul_scale(const mat4* in_m1, float_t sx, float_t sy, float_t sz, float_t sw, mat4* out_m);
+extern void mat4_mul_scale_x(const mat4* in_m1, float_t s, mat4* out_m);
+extern void mat4_mul_scale_y(const mat4* in_m1, float_t s, mat4* out_m);
+extern void mat4_mul_scale_z(const mat4* in_m1, float_t s, mat4* out_m);
+extern void mat4_scale_w_mult(const mat4* in_m1, float_t s, mat4* out_m);
+extern void mat4_scale_rot(const mat4* in_m1, float_t sx, float_t sy, float_t sz, mat4* out_m);
+extern void mat4_scale_x_rot(const mat4* in_m1, float_t s, mat4* out_m);
+extern void mat4_scale_y_rot(const mat4* in_m1, float_t s, mat4* out_m);
+extern void mat4_scale_z_rot(const mat4* in_m1, float_t s, mat4* out_m);
+extern void mat4_translate(float_t tx, float_t ty, float_t tz, mat4* out_m);
+extern void mat4_translate_x(float_t t, mat4* out_m);
+extern void mat4_translate_y(float_t t, mat4* out_m);
+extern void mat4_translate_z(float_t t, mat4* out_m);
+extern void mat4_mul_translate(const mat4* in_m1, float_t tx, float_t ty, float_t tz, mat4* out_m);
+extern void mat4_mul_translate_x(const mat4* in_m1, float_t t, mat4* out_m);
+extern void mat4_mul_translate_y(const mat4* in_m1, float_t t, mat4* out_m);
+extern void mat4_mul_translate_z(const mat4* in_m1, float_t t, mat4* out_m);
+extern void mat4_add_translate(const mat4* in_m1, float_t tx, float_t ty, float_t tz, mat4* out_m);
+extern void mat4_add_translate_x(const mat4* in_m1, float_t t, mat4* out_m);
+extern void mat4_add_translate_y(const mat4* in_m1, float_t t, mat4* out_m);
+extern void mat4_add_translate_z(const mat4* in_m1, float_t t, mat4* out_m);
+extern void mat4_to_mat3(const mat4* in_m1, mat3* out_m);
+extern void mat4_to_mat3_inverse(const mat4* in_m1, mat3* out_m);
+extern void mat4_from_mat3(const mat3* in_m1, mat4* out_m);
+extern void mat4_from_mat3_inverse(const mat3* in_m1, mat4* out_m);
+extern void mat4_clear_rot(const mat4* in_m1, mat4* out_m);
+extern void mat4_clear_trans(const mat4* in_m1, mat4* out_m);
+extern void mat4_get_scale(const mat4* in_m1, vec3* out_s);
+extern void mat4_get_rotation(const mat4* in_m1, vec3* out_rad);
+extern void mat4_get_translation(const mat4* in_m1, vec3* out_t);
+extern void mat4_set_translation(mat4* in_m1, const vec3* in_t);
+extern float_t mat4_get_max_scale(const mat4* in_m1);
+extern void mat4_blend(const mat4* in_m1, const mat4* in_m2, mat4* out_m, float_t blend);
+extern void mat4_blend_rotation(const mat4* in_m1, const mat4* in_m2, mat4* out_m, float_t blend);
+extern void mat4_lerp_rotation(const mat4* in_m1, const mat4* in_m2, mat4* out_m, float_t blend);
 extern void mat4_frustrum(double_t left, double_t right,
-    double_t bottom, double_t top, double_t z_near, double_t z_far, mat4* mat);
+    double_t bottom, double_t top, double_t z_near, double_t z_far, mat4* out_m);
 extern void mat4_ortho(double_t left, double_t right,
-    double_t bottom, double_t top, double_t z_near, double_t z_far, mat4* mat);
-extern void mat4_persp(double_t fov_y, double_t aspect, double_t z_near, double_t z_far, mat4* mat);
-extern void mat4_look_at(const vec3* eye, const vec3* target, const vec3* up, mat4* mat);
-extern void mat4_look_at(const vec3* eye, const vec3* target, mat4* mat);
+    double_t bottom, double_t top, double_t z_near, double_t z_far, mat4* out_m);
+extern void mat4_persp(double_t fov_y, double_t aspect, double_t z_near, double_t z_far, mat4* out_m);
+extern void mat4_look_at(const vec3* eye, const vec3* target, const vec3* up, mat4* out_m);
+extern void mat4_look_at(const vec3* eye, const vec3* target, mat4* out_m);
 
-inline void mat3_rotate_xyz(const vec3* rad, mat3* z) {
-    mat3_rotate_xyz(rad->x, rad->y, rad->z, z);
+inline void mat3_rotate_xyz(const vec3* rad, mat3* out_m) {
+    mat3_rotate_xyz(rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat3_rotate_xzy(const vec3* rad, mat3* z) {
-    mat3_rotate_xzy(rad->x, rad->y, rad->z, z);
+inline void mat3_rotate_xzy(const vec3* rad, mat3* out_m) {
+    mat3_rotate_xzy(rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat3_rotate_yxz(const vec3* rad, mat3* z) {
-    mat3_rotate_yxz(rad->x, rad->y, rad->z, z);
+inline void mat3_rotate_yxz(const vec3* rad, mat3* out_m) {
+    mat3_rotate_yxz(rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat3_rotate_yzx(const vec3* rad, mat3* z) {
-    mat3_rotate_yzx(rad->x, rad->y, rad->z, z);
+inline void mat3_rotate_yzx(const vec3* rad, mat3* out_m) {
+    mat3_rotate_yzx(rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat3_rotate_zxy(const vec3* rad, mat3* z) {
-    mat3_rotate_zxy(rad->x, rad->y, rad->z, z);
+inline void mat3_rotate_zxy(const vec3* rad, mat3* out_m) {
+    mat3_rotate_zxy(rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat3_rotate_zyx(const vec3* rad, mat3* z) {
-    mat3_rotate_zyx(rad->x, rad->y, rad->z, z);
+inline void mat3_rotate_zyx(const vec3* rad, mat3* out_m) {
+    mat3_rotate_zyx(rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat3_mul_rotate_xyz(const mat3* x, const vec3* rad, mat3* z) {
-    mat3_mul_rotate_xyz(x, rad->x, rad->y, rad->z, z);
+inline void mat3_mul_rotate_xyz(const mat3* in_m1, const vec3* rad, mat3* out_m) {
+    mat3_mul_rotate_xyz(in_m1, rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat3_mul_rotate_xzy(const mat3* x, const vec3* rad, mat3* z) {
-    mat3_mul_rotate_xzy(x, rad->x, rad->y, rad->z, z);
+inline void mat3_mul_rotate_xzy(const mat3* in_m1, const vec3* rad, mat3* out_m) {
+    mat3_mul_rotate_xzy(in_m1, rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat3_mul_rotate_yxz(const mat3* x, const vec3* rad, mat3* z) {
-    mat3_mul_rotate_yxz(x, rad->x, rad->y, rad->z, z);
+inline void mat3_mul_rotate_yxz(const mat3* in_m1, const vec3* rad, mat3* out_m) {
+    mat3_mul_rotate_yxz(in_m1, rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat3_mul_rotate_yzx(const mat3* x, const vec3* rad, mat3* z) {
-    mat3_mul_rotate_yzx(x, rad->x, rad->y, rad->z, z);
+inline void mat3_mul_rotate_yzx(const mat3* in_m1, const vec3* rad, mat3* out_m) {
+    mat3_mul_rotate_yzx(in_m1, rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat3_mul_rotate_zxy(const mat3* x, const vec3* rad, mat3* z) {
-    mat3_mul_rotate_zxy(x, rad->x, rad->y, rad->z, z);
+inline void mat3_mul_rotate_zxy(const mat3* in_m1, const vec3* rad, mat3* out_m) {
+    mat3_mul_rotate_zxy(in_m1, rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat3_mul_rotate_zyx(const mat3* x, const vec3* rad, mat3* z) {
-    mat3_mul_rotate_zyx(x, rad->x, rad->y, rad->z, z);
+inline void mat3_mul_rotate_zyx(const mat3* in_m1, const vec3* rad, mat3* out_m) {
+    mat3_mul_rotate_zyx(in_m1, rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat3_scale(const vec3* s, mat3* z) {
-    mat3_scale(s->x, s->y, s->z, z);
+inline void mat3_scale(const vec3* s, mat3* out_m) {
+    mat3_scale(s->x, s->y, s->z, out_m);
 }
 
-inline void mat3_mul_scale(const mat3* x, float_t s, mat3* z) {
-    mat3_mul_scale(x, s, s, s, z);
+inline void mat3_mul_scale(const mat3* in_m1, float_t s, mat3* out_m) {
+    mat3_mul_scale(in_m1, s, s, s, out_m);
 }
 
-inline void mat3_mul_scale(const mat3* x, const vec3* s, mat3* z) {
-    mat3_mul_scale(x, s->x, s->y, s->z, z);
+inline void mat3_mul_scale(const mat3* in_m1, const vec3* s, mat3* out_m) {
+    mat3_mul_scale(in_m1, s->x, s->y, s->z, out_m);
 }
 
-inline void mat4_rotate_xyz(const vec3* rad, mat4* z) {
-    mat4_rotate_xyz(rad->x, rad->y, rad->z, z);
+inline void mat4_rotate_xyz(const vec3* rad, mat4* out_m) {
+    mat4_rotate_xyz(rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat4_rotate_xzy(const vec3* rad, mat4* z) {
-    mat4_rotate_xzy(rad->x, rad->y, rad->z, z);
+inline void mat4_rotate_xzy(const vec3* rad, mat4* out_m) {
+    mat4_rotate_xzy(rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat4_rotate_yxz(const vec3* rad, mat4* z) {
-    mat4_rotate_yxz(rad->x, rad->y, rad->z, z);
+inline void mat4_rotate_yxz(const vec3* rad, mat4* out_m) {
+    mat4_rotate_yxz(rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat4_rotate_yzx(const vec3* rad, mat4* z) {
-    mat4_rotate_yzx(rad->x, rad->y, rad->z, z);
+inline void mat4_rotate_yzx(const vec3* rad, mat4* out_m) {
+    mat4_rotate_yzx(rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat4_rotate_zxy(const vec3* rad, mat4* z) {
-    mat4_rotate_zxy(rad->x, rad->y, rad->z, z);
+inline void mat4_rotate_zxy(const vec3* rad, mat4* out_m) {
+    mat4_rotate_zxy(rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat4_rotate_zyx(const vec3* rad, mat4* z) {
-    mat4_rotate_zyx(rad->x, rad->y, rad->z, z);
+inline void mat4_rotate_zyx(const vec3* rad, mat4* out_m) {
+    mat4_rotate_zyx(rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat4_mul_rotate_xyz(const mat4* x, const vec3* rad, mat4* z) {
-    mat4_mul_rotate_xyz(x, rad->x, rad->y, rad->z, z);
+inline void mat4_mul_rotate_xyz(const mat4* in_m1, const vec3* rad, mat4* out_m) {
+    mat4_mul_rotate_xyz(in_m1, rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat4_mul_rotate_xzy(const mat4* x, const vec3* rad, mat4* z) {
-    mat4_mul_rotate_xzy(x, rad->x, rad->y, rad->z, z);
+inline void mat4_mul_rotate_xzy(const mat4* in_m1, const vec3* rad, mat4* out_m) {
+    mat4_mul_rotate_xzy(in_m1, rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat4_mul_rotate_yxz(const mat4* x, const vec3* rad, mat4* z) {
-    mat4_mul_rotate_yxz(x, rad->x, rad->y, rad->z, z);
+inline void mat4_mul_rotate_yxz(const mat4* in_m1, const vec3* rad, mat4* out_m) {
+    mat4_mul_rotate_yxz(in_m1, rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat4_mul_rotate_yzx(const mat4* x, const vec3* rad, mat4* z) {
-    mat4_mul_rotate_yzx(x, rad->x, rad->y, rad->z, z);
+inline void mat4_mul_rotate_yzx(const mat4* in_m1, const vec3* rad, mat4* out_m) {
+    mat4_mul_rotate_yzx(in_m1, rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat4_mul_rotate_zxy(const mat4* x, const vec3* rad, mat4* z) {
-    mat4_mul_rotate_zxy(x, rad->x, rad->y, rad->z, z);
+inline void mat4_mul_rotate_zxy(const mat4* in_m1, const vec3* rad, mat4* out_m) {
+    mat4_mul_rotate_zxy(in_m1, rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat4_mul_rotate_zyx(const mat4* x, const vec3* rad, mat4* z) {
-    mat4_mul_rotate_zyx(x, rad->x, rad->y, rad->z, z);
+inline void mat4_mul_rotate_zyx(const mat4* in_m1, const vec3* rad, mat4* out_m) {
+    mat4_mul_rotate_zyx(in_m1, rad->x, rad->y, rad->z, out_m);
 }
 
-inline void mat4_scale(const vec3* s, mat4* z) {
-    mat4_scale(s->x, s->y, s->z, z);
+inline void mat4_scale(const vec3* s, mat4* out_m) {
+    mat4_scale(s->x, s->y, s->z, out_m);
 }
 
-inline void mat4_mul_scale(const mat4* x, float_t s, mat4* z) {
-    mat4_mul_scale(x, s, s, s, s, z);
+inline void mat4_mul_scale(const mat4* in_m1, float_t s, mat4* out_m) {
+    mat4_mul_scale(in_m1, s, s, s, s, out_m);
 }
 
-inline void mat4_mul_scale(const mat4* x, vec4* s, mat4* z) {
-    mat4_mul_scale(x, s->x, s->y, s->z, s->w, z);
+inline void mat4_mul_scale(const mat4* in_m1, vec4* s, mat4* out_m) {
+    mat4_mul_scale(in_m1, s->x, s->y, s->z, s->w, out_m);
 }
 
-inline void mat4_scale_rot(const mat4* x, const float_t s, mat4* z) {
-    mat4_scale_rot(x, s, s, s, z);
+inline void mat4_scale_rot(const mat4* in_m1, const float_t s, mat4* out_m) {
+    mat4_scale_rot(in_m1, s, s, s, out_m);
 }
 
-inline void mat4_scale_rot(const mat4* x, const vec3* s, mat4* z) {
-    mat4_scale_rot(x, s->x, s->y, s->z, z);
+inline void mat4_scale_rot(const mat4* in_m1, const vec3* s, mat4* out_m) {
+    mat4_scale_rot(in_m1, s->x, s->y, s->z, out_m);
 }
 
-inline void mat4_translate(const vec3* s, mat4* z) {
-    mat4_translate(s->x, s->y, s->z, z);
+inline void mat4_translate(const vec3* s, mat4* out_m) {
+    mat4_translate(s->x, s->y, s->z, out_m);
 }
 
-inline void mat4_mul_translate(const mat4* x, const vec3* t, mat4* z) {
-    mat4_mul_translate(x, t->x, t->y, t->z, z);
+inline void mat4_mul_translate(const mat4* in_m1, const vec3* t, mat4* out_m) {
+    mat4_mul_translate(in_m1, t->x, t->y, t->z, out_m);
 }
 
-inline void mat4_add_translate(const mat4* x, const vec3* t, mat4* z) {
-    mat4_add_translate(x, t->x, t->y, t->z, z);
+inline void mat4_add_translate(const mat4* in_m1, const vec3* t, mat4* out_m) {
+    mat4_add_translate(in_m1, t->x, t->y, t->z, out_m);
 }
diff --git a/src/KKdLib/quat.cpp b/src/KKdLib/quat.cpp
index 070154b4..44870414 100644
--- a/src/KKdLib/quat.cpp
+++ b/src/KKdLib/quat.cpp
@@ -7,76 +7,4 @@
 #include <pmmintrin.h>
 #include <xmmintrin.h>
 
-inline void quat_mult(const quat* x, const quat* y, quat* z) {
-    __m128 xt;
-    __m128 yt;
-    quat zt;
-    __m128 zt0;
-    __m128 zt1;
-    __m128 zt2;
-    __m128 zt3;
-
-    xt = _mm_loadu_ps((const float*)x);
-    yt = _mm_loadu_ps((const float*)y);
-    zt0 = _mm_mul_ps(xt, _mm_shuffle_ps(yt, yt, 0x1B));
-    zt1 = _mm_mul_ps(xt, _mm_shuffle_ps(yt, yt, 0x4E));
-    zt2 = _mm_mul_ps(xt, _mm_shuffle_ps(yt, yt, 0xB1));
-    zt3 = _mm_mul_ps(xt, _mm_shuffle_ps(yt, yt, 0xE4));
-    zt0 = _mm_xor_ps(zt0, __m128( {  0.0f,  0.0f, -0.0f, 0.0f } ));
-    zt1 = _mm_xor_ps(zt1, __m128( { -0.0f,  0.0f,  0.0f, 0.0f } ));
-    zt2 = _mm_xor_ps(zt2, __m128( {  0.0f, -0.0f,  0.0f, 0.0f } ));
-    zt3 = _mm_xor_ps(zt3, __m128( { -0.0f, -0.0f, -0.0f, 0.0f } ));
-    zt0 = _mm_hadd_ps(zt0, zt0);
-    zt1 = _mm_hadd_ps(zt1, zt1);
-    zt2 = _mm_hadd_ps(zt2, zt2);
-    zt3 = _mm_hadd_ps(zt3, zt3);
-    zt.x = _mm_cvtss_f32(_mm_hadd_ps(zt0, zt0));
-    zt.y = _mm_cvtss_f32(_mm_hadd_ps(zt1, zt1));
-    zt.z = _mm_cvtss_f32(_mm_hadd_ps(zt2, zt2));
-    zt.w = _mm_cvtss_f32(_mm_hadd_ps(zt3, zt3));
-    *z = zt;
-}
-
-void quat_from_mat3(float_t m00, float_t m01, float_t m02, float_t m10,
-    float_t m11, float_t m12, float_t m20, float_t m21, float_t m22, quat* quat) {
-    if (m00 + m11 + m22 >= 0.0f) {
-        float_t sq = sqrtf(m00 + m11 + m22 + 1.0f);
-        quat->w = sq * 0.5f;
-        sq = 0.5f / sq;
-        quat->x = (m21 - m12) * sq;
-        quat->y = (m02 - m20) * sq;
-        quat->z = (m10 - m01) * sq;
-        return;
-    }
-
-    float_t max = max_def(m22, max_def(m11, m00));
-    if (max == m00) {
-        float_t sq = sqrtf(m00 - (m11 + m22) + 1.0f);
-        quat->x = sq * 0.5f;
-        sq = 0.5f / sq;
-        quat->y = (m01 + m10) * sq;
-        quat->z = (m02 + m20) * sq;
-        quat->w = (m21 - m12) * sq;
-    }
-    else if (max == m11) {
-        float_t sq = sqrtf(m11 - (m00 + m22) + 1.0f);
-        quat->y = sq * 0.5f;
-        sq = 0.5f / sq;
-        quat->x = (m01 + m10) * sq;
-        quat->z = (m12 + m21) * sq;
-        quat->w = (m02 - m20) * sq;
-    }
-    else {
-        float_t sq = sqrtf(m22 - (m00 + m11) + 1.0f);
-        quat->z = sq * 0.5f;
-        sq = 0.5f / sq;
-        quat->x = (m02 + m20) * sq;
-        quat->y = (m12 + m21) * sq;
-        quat->w = (m10 - m01) * sq;
-    }
-}
-
-inline void quat_from_axis_angle(const vec3* axis, const float_t angle, quat* quat) {
-    *(vec3*)quat = vec3::normalize(*axis) * sinf(angle * 0.5f);
-    quat->w = cosf(angle * 0.5f);
-}
+static const quat quat_identity = { 0.0f, 0.0f, 0.0f, 1.0f };
diff --git a/src/KKdLib/quat.hpp b/src/KKdLib/quat.hpp
index d6fa34f5..09583de9 100644
--- a/src/KKdLib/quat.hpp
+++ b/src/KKdLib/quat.hpp
@@ -14,17 +14,33 @@ struct quat {
     float_t z;
     float_t w;
 
+    quat();
+    quat(float_t value);
+    quat(float_t x, float_t y, float_t z, float_t w);
+    quat(const vec3& axis, const float_t angle);
+    quat(float_t m00, float_t m01, float_t m02, float_t m10,
+        float_t m11, float_t m12, float_t m20, float_t m21, float_t m22);
+
+    static __m128 load_xmm(const float_t data);
+    static __m128 load_xmm(const quat& data);
+    static __m128 load_xmm(const quat&& data);
+    static quat store_xmm(const __m128& data);
+    static quat store_xmm(const __m128&& data);
+
+    static quat mul(const quat& in_q1, const quat& in_q2);
+
     static float_t dot(const quat& left, const quat& right);
     static float_t length(const quat& left);
     static float_t length_squared(const quat& left);
     static float_t distance(const quat& left, const quat& right);
     static float_t distance_squared(const quat& left, const quat& right);
+    static quat abs(const quat& left);
     static quat lerp(const quat& left, const quat& right, const float_t blend);
     static quat slerp(const quat& left, const quat& right, const float_t blend);
     static quat normalize(const quat& left);
     static quat rcp(const quat& left);
-    static quat min(const quat& left, const quat& right);
-    static quat max(const quat& left, const quat& right);
+    static quat min(const quat& min, const quat& max);
+    static quat max(const quat& min, const quat& max);
     static quat clamp(const quat& left, const quat& min, const quat& max);
     static quat clamp(const quat& left, const float_t min, const float_t max);
     static quat mult_min_max(const quat& left, const quat& min, const quat& max);
@@ -33,7 +49,66 @@ struct quat {
     static quat div_min_max(const quat& left, const float_t min, const float_t max);
 };
 
-static const quat quat_identity = { 0.0f, 0.0f, 0.0f, 1.0f };
+extern const quat quat_identity;
+
+inline quat::quat() : x(), y(), z(), w() {
+
+}
+
+inline quat::quat(float_t value) : x(value), y(value), z(value), w(value) {
+
+}
+
+inline quat::quat(float_t x, float_t y, float_t z, float_t w) : x(x), y(y), z(z), w(w) {
+
+}
+
+inline quat::quat(const vec3& axis, const float_t angle) {
+    vec3 _axis = vec3::normalize(axis) * sinf(angle * 0.5f);
+    x = _axis.x;
+    y = _axis.y;
+    z = _axis.z;
+    w = cosf(angle * 0.5f);
+}
+
+inline quat::quat(float_t m00, float_t m01, float_t m02, float_t m10,
+    float_t m11, float_t m12, float_t m20, float_t m21, float_t m22) {
+    if (m00 + m11 + m22 >= 0.0f) {
+        float_t sq = sqrtf(m00 + m11 + m22 + 1.0f);
+        w = sq * 0.5f;
+        sq = 0.5f / sq;
+        x = (m21 - m12) * sq;
+        y = (m02 - m20) * sq;
+        z = (m10 - m01) * sq;
+        return;
+    }
+
+    float_t max = max_def(m22, max_def(m11, m00));
+    if (max == m00) {
+        float_t sq = sqrtf(m00 - (m11 + m22) + 1.0f);
+        x = sq * 0.5f;
+        sq = 0.5f / sq;
+        y = (m01 + m10) * sq;
+        z = (m02 + m20) * sq;
+        w = (m21 - m12) * sq;
+    }
+    else if (max == m11) {
+        float_t sq = sqrtf(m11 - (m00 + m22) + 1.0f);
+        y = sq * 0.5f;
+        sq = 0.5f / sq;
+        x = (m01 + m10) * sq;
+        z = (m12 + m21) * sq;
+        w = (m02 - m20) * sq;
+    }
+    else {
+        float_t sq = sqrtf(m22 - (m00 + m11) + 1.0f);
+        z = sq * 0.5f;
+        sq = 0.5f / sq;
+        x = (m02 + m20) * sq;
+        y = (m12 + m21) * sq;
+        w = (m10 - m01) * sq;
+    }
+}
 
 inline quat operator +(const quat& left, const quat& right) {
     __m128 yt;
@@ -137,6 +212,62 @@ inline quat operator -(const quat& left) {
     return z;
 }
 
+inline __m128 quat::load_xmm(const float_t data) {
+    __m128 _data = _mm_set_ss(data);
+    return _mm_shuffle_ps(_data, _data, 0);
+}
+
+inline __m128 quat::load_xmm(const quat& data) {
+    return _mm_loadu_ps((const float*)&data);
+}
+
+inline __m128 quat::load_xmm(const quat&& data) {
+    return _mm_loadu_ps((const float*)&data);
+}
+
+inline quat quat::store_xmm(const __m128& data) {
+    quat _data;
+    _mm_storeu_ps((float*)&_data, data);
+    return _data;
+}
+
+inline quat quat::store_xmm(const __m128&& data) {
+    quat _data;
+    _mm_storeu_ps((float*)&_data, data);
+    return _data;
+}
+
+inline quat quat::mul(const quat& in_q1, const quat& in_q2) {
+    __m128 xt;
+    __m128 yt;
+    __m128 zt0;
+    __m128 zt1;
+    __m128 zt2;
+    __m128 zt3;
+
+    xt = quat::load_xmm(in_q1);
+    yt = quat::load_xmm(in_q2);
+    zt0 = _mm_mul_ps(xt, _mm_shuffle_ps(yt, yt, 0x1B));
+    zt1 = _mm_mul_ps(xt, _mm_shuffle_ps(yt, yt, 0x4E));
+    zt2 = _mm_mul_ps(xt, _mm_shuffle_ps(yt, yt, 0xB1));
+    zt3 = _mm_mul_ps(xt, _mm_shuffle_ps(yt, yt, 0xE4));
+    zt0 = _mm_xor_ps(zt0, __m128({ 0.0f,  0.0f, -0.0f, 0.0f }));
+    zt1 = _mm_xor_ps(zt1, __m128({ -0.0f,  0.0f,  0.0f, 0.0f }));
+    zt2 = _mm_xor_ps(zt2, __m128({ 0.0f, -0.0f,  0.0f, 0.0f }));
+    zt3 = _mm_xor_ps(zt3, __m128({ -0.0f, -0.0f, -0.0f, 0.0f }));
+    zt0 = _mm_hadd_ps(zt0, zt0);
+    zt1 = _mm_hadd_ps(zt1, zt1);
+    zt2 = _mm_hadd_ps(zt2, zt2);
+    zt3 = _mm_hadd_ps(zt3, zt3);
+
+    quat out_q;
+    out_q.x = _mm_cvtss_f32(_mm_hadd_ps(zt0, zt0));
+    out_q.y = _mm_cvtss_f32(_mm_hadd_ps(zt1, zt1));
+    out_q.z = _mm_cvtss_f32(_mm_hadd_ps(zt2, zt2));
+    out_q.w = _mm_cvtss_f32(_mm_hadd_ps(zt3, zt3));
+    return out_q;
+}
+
 inline float_t quat::dot(const quat& left, const quat& right) {
     __m128 zt;
     zt = _mm_mul_ps(_mm_loadu_ps((const float*)&(left)), _mm_loadu_ps((const float*)&(right)));
@@ -178,6 +309,10 @@ inline float_t quat::distance_squared(const quat& left, const quat& right) {
     return _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
 }
 
+inline quat quat::abs(const quat& left) {
+    return quat::store_xmm(_mm_castsi128_ps(_mm_and_si128(_mm_castps_si128(quat::load_xmm(left)), vec4i_abs)));
+}
+
 inline quat quat::lerp(const quat& left, const quat& right, const float_t blend) {
     quat x_t;
     quat y_t;
@@ -325,8 +460,3 @@ inline quat quat::div_min_max(const quat& left, const float_t min, const float_t
     _mm_storeu_ps((float*)&w, _mm_div_ps(xt, wt));
     return w;
 }
-
-extern void quat_mult(const quat* x, const quat* y, quat* z);
-extern void quat_from_mat3(float_t m00, float_t m01, float_t m02, float_t m10,
-    float_t m11, float_t m12, float_t m20, float_t m21, float_t m22, quat* quat);
-extern void quat_from_axis_angle(const vec3* axis, const float_t angle, quat* quat);
diff --git a/src/KKdLib/vec.hpp b/src/KKdLib/vec.hpp
index a8464f17..0563943c 100644
--- a/src/KKdLib/vec.hpp
+++ b/src/KKdLib/vec.hpp
@@ -499,135 +499,6 @@ inline vec2 vec2::store_xmm(const __m128&& data) {
     return _data;
 }
 
-inline __m128 vec3::load_xmm(const float_t data) {
-    __m128 _data = _mm_set_ss(data);
-    return _mm_shuffle_ps(_data, _data, 0x40);
-}
-
-inline __m128 vec3::load_xmm(const vec3& data) {
-    return _mm_movelh_ps(_mm_castsi128_ps(_mm_loadl_epi64((const __m128i*) & data)), _mm_set_ss(data.z));
-}
-
-inline __m128 vec3::load_xmm(const vec3&& data) {
-    return _mm_movelh_ps(_mm_castsi128_ps(_mm_loadl_epi64((const __m128i*) & data)), _mm_set_ss(data.z));
-}
-
-inline vec3 vec3::store_xmm(const __m128& data) {
-    vec3 _data;
-    _mm_storel_epi64((__m128i*) & _data, _mm_castps_si128(data));
-    *(int32_t*)&_data.z = _mm_cvtsi128_si32(_mm_srli_si128(_mm_castps_si128(data), 8));
-    return _data;
-}
-
-inline vec3 vec3::store_xmm(const __m128&& data) {
-    vec3 _data;
-    _mm_storel_epi64((__m128i*) & _data, _mm_castps_si128(data));
-    *(int32_t*)&_data.z = _mm_cvtsi128_si32(_mm_srli_si128(_mm_castps_si128(data), 8));
-    return _data;
-}
-
-inline __m128 vec4::load_xmm(const float_t data) {
-    __m128 _data = _mm_set_ss(data);
-    return _mm_shuffle_ps(_data, _data, 0);
-}
-
-inline __m128 vec4::load_xmm(const vec4& data) {
-    return _mm_loadu_ps((const float*)&data);
-}
-
-inline __m128 vec4::load_xmm(const vec4&& data) {
-    return _mm_loadu_ps((const float*)&data);
-}
-
-inline vec4 vec4::store_xmm(const __m128& data) {
-    vec4 _data;
-    _mm_storeu_ps((float*)&_data, data);
-    return _data;
-}
-
-inline vec4 vec4::store_xmm(const __m128&& data) {
-    vec4 _data;
-    _mm_storeu_ps((float*)&_data, data);
-    return _data;
-}
-
-inline __m128i vec2i::load_xmm(const int32_t data) {
-    __m128i _data = _mm_cvtsi32_si128(data);
-    return _mm_shuffle_epi32(_data, 0);
-}
-
-inline __m128i vec2i::load_xmm(const vec2i& data) {
-    return _mm_loadl_epi64((const __m128i*) & data);
-}
-
-inline __m128i vec2i::load_xmm(const vec2i&& data) {
-    return _mm_loadl_epi64((const __m128i*) & data);
-}
-
-inline vec2i vec2i::store_xmm(const __m128i& data) {
-    vec2i _data;
-    _mm_storel_epi64((__m128i*) & _data, data);
-    return _data;
-}
-
-inline vec2i vec2i::store_xmm(const __m128i&& data) {
-    vec2i _data;
-    _mm_storel_epi64((__m128i*) & _data, data);
-    return _data;
-}
-
-inline __m128i vec3i::load_xmm(const int32_t data) {
-    __m128i _data = _mm_cvtsi32_si128(data);
-    return _mm_shuffle_epi32(_data, 0);
-}
-
-inline __m128i vec3i::load_xmm(const vec3i& data) {
-    return _mm_unpacklo_epi64(_mm_loadl_epi64((const __m128i*) & data), _mm_cvtsi32_si128(data.z));
-}
-
-inline __m128i vec3i::load_xmm(const vec3i&& data) {
-    return _mm_unpacklo_epi64(_mm_loadl_epi64((const __m128i*) & data), _mm_cvtsi32_si128(data.z));
-}
-
-inline vec3i vec3i::store_xmm(const __m128i& data) {
-    vec3i _data;
-    _mm_storel_epi64((__m128i*) & _data, data);
-    _data.z = _mm_cvtsi128_si32(_mm_srli_si128(data, 8));
-    return _data;
-}
-
-inline vec3i vec3i::store_xmm(const __m128i&& data) {
-    vec3i _data;
-    _mm_storel_epi64((__m128i*) & _data, data);
-    _data.z = _mm_cvtsi128_si32(_mm_srli_si128(data, 8));
-    return _data;
-}
-
-inline __m128i vec4i::load_xmm(const int32_t data) {
-    __m128i _data = _mm_cvtsi32_si128(data);
-    return _mm_shuffle_epi32(_data, 0);
-}
-
-inline __m128i vec4i::load_xmm(const vec4i& data) {
-    return _mm_loadu_si128((const __m128i*)&data);
-}
-
-inline __m128i vec4i::load_xmm(const vec4i&& data) {
-    return _mm_loadu_si128((const __m128i*)&data);
-}
-
-inline vec4i vec4i::store_xmm(const __m128i& data) {
-    vec4i _data;
-    _mm_storeu_si128((__m128i*)&_data, data);
-    return _data;
-}
-
-inline vec4i vec4i::store_xmm(const __m128i&& data) {
-    vec4i _data;
-    _mm_storeu_si128((__m128i*)&_data, data);
-    return _data;
-}
-
 inline vec2 operator +(const vec2& left, const vec2& right) {
     return vec2::store_xmm(_mm_add_ps(vec2::load_xmm(left), vec2::load_xmm(right)));
 }
@@ -1039,17 +910,40 @@ inline bool operator !=(const vec3& left, const vec3& right) {
     return !!memcmp(&left, &right, sizeof(vec3));
 }
 
+inline __m128 vec3::load_xmm(const float_t data) {
+    __m128 _data = _mm_set_ss(data);
+    return _mm_shuffle_ps(_data, _data, 0x40);
+}
+
+inline __m128 vec3::load_xmm(const vec3& data) {
+    return _mm_movelh_ps(_mm_castsi128_ps(_mm_loadl_epi64((const __m128i*) & data)), _mm_load_ss(&data.z));
+}
+
+inline __m128 vec3::load_xmm(const vec3&& data) {
+    return _mm_movelh_ps(_mm_castsi128_ps(_mm_loadl_epi64((const __m128i*) & data)), _mm_load_ss(&data.z));
+}
+
+inline vec3 vec3::store_xmm(const __m128& data) {
+    vec3 _data;
+    _mm_storel_epi64((__m128i*) & _data, _mm_castps_si128(data));
+    _mm_store_ss(&_data.z, _mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(data), 8)));
+    return _data;
+}
+
+inline vec3 vec3::store_xmm(const __m128&& data) {
+    vec3 _data;
+    _mm_storel_epi64((__m128i*) & _data, _mm_castps_si128(data));
+    _mm_store_ss(&_data.z, _mm_castsi128_ps(_mm_srli_si128(_mm_castps_si128(data), 8)));
+    return _data;
+}
+
 inline float_t vec3::angle(const vec3& left, const vec3& right) {
     return acosf(vec3::dot(left, right) / (vec3::length(left) * vec3::length(right)));
 }
 
 inline float_t vec3::dot(const vec3& left, const vec3& right) {
-    __m128 xt;
-    __m128 yt;
     __m128 zt;
-    xt = vec3::load_xmm(left);
-    yt = vec3::load_xmm(right);
-    zt = _mm_mul_ps(xt, yt);
+    zt = _mm_mul_ps(vec3::load_xmm(left), vec3::load_xmm(right));
     zt = _mm_hadd_ps(zt, zt);
     return _mm_cvtss_f32(_mm_hadd_ps(zt, zt));
 }
@@ -1349,6 +1243,31 @@ inline bool operator !=(const vec4& left, const vec4& right) {
     return !!memcmp(&left, &right, sizeof(vec4));
 }
 
+inline __m128 vec4::load_xmm(const float_t data) {
+    __m128 _data = _mm_set_ss(data);
+    return _mm_shuffle_ps(_data, _data, 0);
+}
+
+inline __m128 vec4::load_xmm(const vec4& data) {
+    return _mm_loadu_ps((const float*)&data);
+}
+
+inline __m128 vec4::load_xmm(const vec4&& data) {
+    return _mm_loadu_ps((const float*)&data);
+}
+
+inline vec4 vec4::store_xmm(const __m128& data) {
+    vec4 _data;
+    _mm_storeu_ps((float*)&_data, data);
+    return _data;
+}
+
+inline vec4 vec4::store_xmm(const __m128&& data) {
+    vec4 _data;
+    _mm_storeu_ps((float*)&_data, data);
+    return _data;
+}
+
 inline float_t vec4::angle(const vec4& left, const vec4& right) {
     return acosf(vec4::dot(left, right) / (vec4::length(left) * vec4::length(right)));
 }
@@ -1526,6 +1445,31 @@ inline vec2i operator -(const int32_t left, const vec2i& right) {
     return vec2i::store_xmm(_mm_sub_epi32(vec2i::load_xmm(left), vec2i::load_xmm(right)));
 }
 
+inline __m128i vec2i::load_xmm(const int32_t data) {
+    __m128i _data = _mm_cvtsi32_si128(data);
+    return _mm_shuffle_epi32(_data, 0);
+}
+
+inline __m128i vec2i::load_xmm(const vec2i& data) {
+    return _mm_loadl_epi64((const __m128i*) & data);
+}
+
+inline __m128i vec2i::load_xmm(const vec2i&& data) {
+    return _mm_loadl_epi64((const __m128i*) & data);
+}
+
+inline vec2i vec2i::store_xmm(const __m128i& data) {
+    vec2i _data;
+    _mm_storel_epi64((__m128i*) & _data, data);
+    return _data;
+}
+
+inline vec2i vec2i::store_xmm(const __m128i&& data) {
+    vec2i _data;
+    _mm_storel_epi64((__m128i*) & _data, data);
+    return _data;
+}
+
 inline vec2i vec2i::min(const vec2i& left, const vec2i& right) {
     return vec2i::store_xmm(_mm_min_epi32(vec2i::load_xmm(left), vec2i::load_xmm(right)));
 }
@@ -1580,6 +1524,33 @@ inline vec3i operator -(const int32_t left, const vec3i& right) {
     return vec3i::store_xmm(_mm_sub_epi32(vec3i::load_xmm(left), vec3i::load_xmm(right)));
 }
 
+inline __m128i vec3i::load_xmm(const int32_t data) {
+    __m128i _data = _mm_cvtsi32_si128(data);
+    return _mm_shuffle_epi32(_data, 0);
+}
+
+inline __m128i vec3i::load_xmm(const vec3i& data) {
+    return _mm_unpacklo_epi64(_mm_loadl_epi64((const __m128i*) & data), _mm_cvtsi32_si128(data.z));
+}
+
+inline __m128i vec3i::load_xmm(const vec3i&& data) {
+    return _mm_unpacklo_epi64(_mm_loadl_epi64((const __m128i*) & data), _mm_cvtsi32_si128(data.z));
+}
+
+inline vec3i vec3i::store_xmm(const __m128i& data) {
+    vec3i _data;
+    _mm_storel_epi64((__m128i*) & _data, data);
+    _data.z = _mm_cvtsi128_si32(_mm_srli_si128(data, 8));
+    return _data;
+}
+
+inline vec3i vec3i::store_xmm(const __m128i&& data) {
+    vec3i _data;
+    _mm_storel_epi64((__m128i*) & _data, data);
+    _data.z = _mm_cvtsi128_si32(_mm_srli_si128(data, 8));
+    return _data;
+}
+
 inline vec3i vec3i::min(const vec3i& left, const vec3i& right) {
     return vec3i::store_xmm(_mm_min_epi32(vec3i::load_xmm(left), vec3i::load_xmm(right)));
 }
@@ -1634,6 +1605,31 @@ inline vec4i operator -(const int32_t left, const vec4i& right) {
     return vec4i::store_xmm(_mm_sub_epi32(vec4i::load_xmm(left), vec4i::load_xmm(right)));
 }
 
+inline __m128i vec4i::load_xmm(const int32_t data) {
+    __m128i _data = _mm_cvtsi32_si128(data);
+    return _mm_shuffle_epi32(_data, 0);
+}
+
+inline __m128i vec4i::load_xmm(const vec4i& data) {
+    return _mm_loadu_si128((const __m128i*) & data);
+}
+
+inline __m128i vec4i::load_xmm(const vec4i&& data) {
+    return _mm_loadu_si128((const __m128i*) & data);
+}
+
+inline vec4i vec4i::store_xmm(const __m128i& data) {
+    vec4i _data;
+    _mm_storeu_si128((__m128i*) & _data, data);
+    return _data;
+}
+
+inline vec4i vec4i::store_xmm(const __m128i&& data) {
+    vec4i _data;
+    _mm_storeu_si128((__m128i*) & _data, data);
+    return _data;
+}
+
 inline vec4i vec4i::min(const vec4i& left, const vec4i& right) {
     return vec4i::store_xmm(_mm_min_epi32(vec4i::load_xmm(left), vec4i::load_xmm(right)));
 }
diff --git a/src/ReDIVA/pv_game/pv_game_camera.cpp b/src/ReDIVA/pv_game/pv_game_camera.cpp
index 4f6a3a1b..ce197f2a 100644
--- a/src/ReDIVA/pv_game/pv_game_camera.cpp
+++ b/src/ReDIVA/pv_game/pv_game_camera.cpp
@@ -132,8 +132,8 @@ void pv_game_camera_set_dsc_data(float_t duration, pv_game_camera_dsc_data& star
         pv_game_camera_data.view_direction = start_direction;
         pv_game_camera_data.up_vec = start.up_vec;
 
-        mat4_from_two_vectors(&start_direction, &end_direction, &pv_game_camera_data.dir_mat);
-        mat4_from_two_vectors(&start.up_vec, &end.up_vec, &pv_game_camera_data.up_mat);
+        mat4_set(&start_direction, &end_direction, &pv_game_camera_data.dir_mat);
+        mat4_set(&start.up_vec, &end.up_vec, &pv_game_camera_data.up_mat);
     }
 
     pv_game_camera_data.duration = duration;
diff --git a/src/ReDIVA/x_pv_game.cpp b/src/ReDIVA/x_pv_game.cpp
index 3c1e449c..a6e4ba10 100644
--- a/src/ReDIVA/x_pv_game.cpp
+++ b/src/ReDIVA/x_pv_game.cpp
@@ -8872,7 +8872,7 @@ static void x_pv_game_split_auth_3d_hrc_material_list(x_pv_game* xpvgm,
                         obj_skin_bone* hrc_bone = hrc_bones_elem->second;
                         mat4 rot_mat;
                         mat4_clear_trans(&hrc_bone->inv_bind_pose_mat, &rot_mat);
-                        mat4_invrot(&rot_mat, &rot_mat);
+                        mat4_invert_rotation(&rot_mat, &rot_mat);
 
                         vec3 rot_mat_rot;
                         mat4_get_rotation(&rot_mat, &rot_mat_rot);