From cc23728dfeca5f80ff3b692ecbfa0485c1b2f378 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Mon, 16 Oct 2017 20:38:57 -0300
Subject: [PATCH 001/102] Remove unneeded parentheses

---
 mathc.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/mathc.c b/mathc.c
index 9af25d6..e1b2aee 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1211,10 +1211,10 @@ void pquaternion_yaw_pitch_roll(float yaw, float pitch, float roll, struct vec *
 	float cos_pitch = cosf(half_pitch);
 	float sin_yaw = sinf(half_yaw);
 	float cos_yaw = cosf(half_yaw);
-	result->x = (cos_yaw * sin_pitch * cos_roll) + (sin_yaw * cos_pitch * sin_roll);
-	result->y = (sin_yaw * cos_pitch * cos_roll) - (cos_yaw * sin_pitch * sin_roll);
-	result->z = (cos_yaw * cos_pitch * sin_roll) - (sin_yaw * sin_pitch * cos_roll);
-	result->w = (cos_yaw * cos_pitch * cos_roll) + (sin_yaw * sin_pitch * sin_roll);
+	result->x = cos_yaw * sin_pitch * cos_roll + sin_yaw * cos_pitch * sin_roll;
+	result->y = sin_yaw * cos_pitch * cos_roll - cos_yaw * sin_pitch * sin_roll;
+	result->z = cos_yaw * cos_pitch * sin_roll - sin_yaw * sin_pitch * cos_roll;
+	result->w = cos_yaw * cos_pitch * cos_roll + sin_yaw * sin_pitch * sin_roll;
 }
 
 MATHC_EXTERN_INLINE struct vec quaternion_yaw_pitch_roll(float yaw, float pitch, float roll)

From 87aece489167efa626b1aa7480f3377557572a3a Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Mon, 16 Oct 2017 20:39:06 -0300
Subject: [PATCH 002/102] Update REFERENCE.md

---
 REFERENCE.md | 358 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 357 insertions(+), 1 deletion(-)

diff --git a/REFERENCE.md b/REFERENCE.md
index 53446b1..6fe56f3 100644
--- a/REFERENCE.md
+++ b/REFERENCE.md
@@ -54,7 +54,7 @@ void to_pvector2(float x, float y, struct vec *result);
 struct vec to_vector2(float x, float y);
 ```
 
-The result is a 2D vector for the position `x` and `y`. The value of `z` is set to `0.0f` and the value of `w` is set to `1.0f`.
+The result is a 2D vector for the position `x` and `y`. The value of `z` is set to `0.0f`.
 
 ```c
 void pvector2_add(struct vec *a, struct vec *b, struct vec *result);
@@ -231,6 +231,362 @@ struct vec vector2_linear_interpolation(struct vec a, struct vec b, float p);
 
 The result is a 2D vector for the linear interpolation between the 2D vector `a` and the 2D vector `b` with the value `p`.
 
+## 3D Vector
+
+Every function for 3D vectors will set the value of `w` to `1.0f`.
+
+```c
+void to_pvector3(float x, float y, float z, struct vec *result);
+struct vec to_vector2(float x, float y, float z);
+```
+
+The result is a 3D vector for the position `x`, `y` and `z`.
+
+```c
+void pvector3_add(struct vec *a, struct vec *b, struct vec *result);
+struct vec vector3_add(struct vec a, struct vec b);
+```
+
+The result is a 3D vector for the addition of the 3D vector `a` with the 3D vector `b`.
+
+```c
+void pvector3_subtract(struct vec *a, struct vec *b, struct vec *result);
+struct vec vector3_subtract(struct vec a, struct vec b);
+```
+
+The result is a 3D vector for the subraction of the 3D vector `a` with the 3D vector `b`.
+
+```c
+void pvector3_scale(struct vec *a, float scale, struct vec *result);
+struct vec vector3_scale(struct vec a, float scale);
+```
+
+The result is a 3D vector for the scaling of the 3D vector `a` with the value `scale`.
+
+```c
+void pvector3_multiply(struct vec *a, struct vec *b, struct vec *result);
+struct vec vector3_multiply(struct vec a, struct vec b);
+```
+
+The result is a 3D vector for the multiplication of the 3D vector `a` with the 3D vector `b`.
+
+```c
+void pvector3_divide(struct vec *a, struct vec *b, struct vec *result);
+struct vec vector3_divide(struct vec a, struct vec b);
+```
+
+The result is a 3D vector for the division of the 3D vector `a` with the 3D vector `b`.
+
+```c
+void pvector3_negative(struct vec *a, struct vec *result);
+struct vec vector3_negative(struct vec a);
+```
+
+The result is a 3D vector for the negation of the 3D vector `a`.
+
+```c
+void pvector3_inverse(struct vec *a, struct vec *result);
+struct vec vector3_inverse(struct vec a);
+```
+
+The result is a 3D vector for the inversion of the 3D vector `a`.
+
+```c
+void pvector3_abs(struct vec *a, struct vec *result);
+struct vec vector3_abs(struct vec a);
+```
+
+The result is a 3D vector for the 3D vector `a` with absolute values.
+
+```c
+void pvector3_floor(struct vec *a, struct vec *result);
+struct vec vector3_floor(struct vec a);
+```
+
+The result is a 3D vector for the 3D vector `a` with floored values.
+
+```c
+void pvector3_ceil(struct vec *a, struct vec *result);
+struct vec vector3_ceil(struct vec a);
+```
+
+The result is a 3D vector for the 3D vector `a` with ceiled values.
+
+```c
+void pvector3_round(struct vec *a, struct vec *result);
+struct vec vector3_round(struct vec a);
+```
+
+The result is a 3D vector for the 3D vector `a` with rounded values.
+
+```c
+void pvector3_max(struct vec *a, struct vec *b, struct vec *result);
+struct vec vector3_max(struct vec a, struct vec b);
+```
+
+The result is a 3D vector with the maximum values between the 3D vector `a` and the 3D vector `b`.
+
+```c
+void pvector3_min(struct vec *a, struct vec *b, struct vec *result);
+struct vec vector3_min(struct vec a, struct vec b);
+```
+
+The result is a 3D vector with the minimum values between the 3D vector `a` and the 3D vector `b`.
+
+```c
+float pvector3_dot(struct vec *a, struct vec *b);
+float vector3_dot(struct vec a, struct vec b);
+```
+
+The result is the dot product of the 3D vector `a` with the 3D vector `b`.
+
+```c
+float pvector3_cross(struct vec *a, struct vec *b);
+float vector3_cross(struct vec a, struct vec b);
+```
+
+The result is the cross product of the 3D vector `a` with the 3D vector `b`.
+
+```c
+float pvector3_length_squared(struct vec *a);
+float vector3_length_squared(struct vec a);
+```
+
+The result is the length squared of the 3D vector `a`.
+
+```c
+float pvector3_length(struct vec *a);
+float vector3_length(struct vec a);
+```
+
+The result is the length of the 3D vector `a`.
+
+```c
+void pvector3_normalize(struct vec *a, struct vec *result);
+struct vec vector3_normalize(struct vec a);
+```
+
+The result is a 3D vector for the normalized 3D vector `a`.
+
+```c
+void pvector3_slide(struct vec *a, struct vec *normal, struct vec *result);
+struct vec vector3_slide(struct vec a, struct vec normal);
+```
+
+The result is a 3D vector for the slided 3D vector `a` against the 3D vector `normal`.
+
+```c
+void pvector3_reflect(struct vec *a, struct vec *normal, struct vec *result);
+struct vec vector3_reflect(struct vec a, struct vec normal);
+```
+
+The result is a 3D vector for the reflected 3D vector `a` against the 3D vector `normal`.
+
+```c
+float pvector3_distance_to(struct vec *a, struct vec *b);
+float vector3_distance_to(struct vec a, struct vec b);
+```
+
+The result is the distance between the 3D vector `a` and the 3D vector `b`.
+
+```c
+float pvector3_distance_squared_to(struct vec *a, struct vec *b);
+float vector3_distance_squared_to(struct vec a, struct vec b);
+```
+
+The result is the distance squared between the 3D vector `a` and the 3D vector `b`.
+
+```c
+void pvector3_linear_interpolation(struct vec *a, struct vec *b, float, p, struct vec *result);
+struct vec vector3_linear_interpolation(struct vec a, struct vec b, float p);
+```
+
+The result is a 3D vector for the linear interpolation between the 3D vector `a` and the 3D vector `b` with the value `p`.
+
+## Quaternion
+
+```c
+void to_pquaternion(float x, float y, float z, struct vec *result);
+struct vec to_quaternion(float x, float y, float z);
+```
+
+The result is a quaternion for the position `x`, `y` and `z`.
+
+```c
+void pquaternion_add(struct vec *a, struct vec *b, struct vec *result);
+struct vec quaternion_add(struct vec a, struct vec b);
+```
+
+The result is a quaternion for the addition of the quaternion `a` with the quaternion `b`.
+
+```c
+void pquaternion_subtract(struct vec *a, struct vec *b, struct vec *result);
+struct vec quaternion_subtract(struct vec a, struct vec b);
+```
+
+The result is a quaternion for the subraction of the quaternion `a` with the quaternion `b`.
+
+```c
+void pquaternion_scale(struct vec *a, float scale, struct vec *result);
+struct vec quaternion_scale(struct vec a, float scale);
+```
+
+The result is a quaternion for the scaling of the quaternion `a` with the value `scale`.
+
+```c
+void pquaternion_multiply(struct vec *a, struct vec *b, struct vec *result);
+struct vec quaternion_multiply(struct vec a, struct vec b);
+```
+
+The result is a quaternion for the multiplication of the quaternion `a` with the quaternion `b`.
+
+```c
+void pquaternion_divide(struct vec *a, struct vec *b, struct vec *result);
+struct vec quaternion_divide(struct vec a, struct vec b);
+```
+
+The result is a quaternion for the division of the quaternion `a` with the quaternion `b`.
+
+```c
+void pquaternion_negative(struct vec *a, struct vec *result);
+struct vec quaternion_negative(struct vec a);
+```
+
+The result is a quaternion for the negation of the quaternion `a`.
+
+```c
+void pquaternion_conjugate(struct vec *a, struct vec *result);
+struct vec quaternion_conjugate(struct vec a);
+```
+
+The result is a quaternion for the conjugate of the quaternion `a`.
+
+```c
+void pquaternion_inverse(struct vec *a, struct vec *result);
+struct vec quaternion_inverse(struct vec a);
+```
+
+The result is a quaternion for the inversion of the quaternion `a`.
+
+```c
+void pquaternion_abs(struct vec *a, struct vec *result);
+struct vec quaternion_abs(struct vec a);
+```
+
+The result is a quaternion for the quaternion `a` with absolute values.
+
+```c
+void pquaternion_floor(struct vec *a, struct vec *result);
+struct vec quaternion_floor(struct vec a);
+```
+
+The result is a quaternion for the quaternion `a` with floored values.
+
+```c
+void pquaternion_ceil(struct vec *a, struct vec *result);
+struct vec quaternion_ceil(struct vec a);
+```
+
+The result is a quaternion for the quaternion `a` with ceiled values.
+
+```c
+void pquaternion_round(struct vec *a, struct vec *result);
+struct vec quaternion_round(struct vec a);
+```
+
+The result is a quaternion for the quaternion `a` with rounded values.
+
+```c
+void pquaternion_max(struct vec *a, struct vec *b, struct vec *result);
+struct vec quaternion_max(struct vec a, struct vec b);
+```
+
+The result is a quaternion with the maximum values between the quaternion `a` and the quaternion `b`.
+
+```c
+void pquaternion_min(struct vec *a, struct vec *b, struct vec *result);
+struct vec quaternion_min(struct vec a, struct vec b);
+```
+
+The result is a quaternion with the minimum values between the quaternion `a` and the quaternion `b`.
+
+```c
+float pquaternion_dot(struct vec *a, struct vec *b);
+float quaternion_dot(struct vec a, struct vec b);
+```
+
+The result is the dot product of the quaternion `a` with the quaternion `b`.
+
+```c
+float pquaternion_angle(struct vec *a, struct vec *b);
+float quaternion_angle(struct vec a, struct vec b);
+```
+
+The result is the angle between the quaternion `a` and the quaternion `b`.
+
+```c
+float pquaternion_length_squared(struct vec *a);
+float quaternion_length_squared(struct vec a);
+```
+
+The result is the length squared of the quaternion `a`.
+
+```c
+float pquaternion_length(struct vec *a);
+float quaternion_length(struct vec a);
+```
+
+The result is the length of the quaternion `a`.
+
+```c
+void pquaternion_normalize(struct vec *a, struct vec *result);
+struct vec quaternion_normalize(struct vec a);
+```
+
+The result is a quaternion for the normalized quaternion `a`.
+
+```c
+void pquaternion_power(struct vec *a, float exponent, struct vec *result);
+struct vec quaternion_power(struct vec a, float exponent);
+```
+
+The result is a quaternion for the quaternion `a` raised to the exponent `exponent`.
+
+```c
+void pquaternion_from_axis_angle(struct vec *a, float angle, struct vec *result);
+struct vec quaternion_from_axis_angle(struct vec a, float angle);
+```
+
+The result is a quaternion for the 3D vector `a` with the value in radians `angle`.
+
+```c
+void pquaternion_rotation_matrix(struct mat *m, struct vec *result);
+struct vec quaternion_rotation_matrix(struct mat m);
+```
+
+The result is a quaternion for the rotation matrix `m`.
+
+```c
+void pquaternion_yaw_pitch_roll(float yaw, float pitch, float roll, struct vec *result);
+struct vec quaternion_yaw_pitch_roll(float yaw, float pitch, float roll);
+```
+
+The result is a quaternion for the vertical axis `yaw`, the lateral axis `pitch` and the longitudinal axis `roll`.
+
+```c
+void pquaternion_linear_interpolation(struct vec *a, struct vec *b, float, p, struct vec *result);
+struct vec quaternion_linear_interpolation(struct vec a, struct vec b, float p);
+```
+
+The result is a quaternion for the linear interpolation between the quaternion `a` and the quaternion `b` with the value `p`.
+
+```c
+void pquaternion_spherical_linear_interpolation(struct vec *a, struct vec *b, float, p, struct vec *result);
+struct vec quaternion_spherical_linear_interpolation(struct vec a, struct vec b, float p);
+```
+
+The result is a quaternion for the spherical linear interpolation between the quaternion `a` and the quaternion `b` with the value `p`.
+
 ### Easing Functions
 
 ```c

From 088d24aa15dc9408864512a2e81e0e79d512abca Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Tue, 17 Oct 2017 08:57:35 -0300
Subject: [PATCH 003/102] Update REFERENCE.md

---
 REFERENCE.md | 130 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 129 insertions(+), 1 deletion(-)

diff --git a/REFERENCE.md b/REFERENCE.md
index 6fe56f3..f75aba6 100644
--- a/REFERENCE.md
+++ b/REFERENCE.md
@@ -587,7 +587,135 @@ struct vec quaternion_spherical_linear_interpolation(struct vec a, struct vec b,
 
 The result is a quaternion for the spherical linear interpolation between the quaternion `a` and the quaternion `b` with the value `p`.
 
-### Easing Functions
+## Matrix
+
+```c
+void pmatrix_identity(struct mat *result);
+struct mat matrix_identity(void);
+```
+
+The result is a identity matrix.
+
+```c
+void pmatrix_ortho(float l, float r, float b, float t, float n, float f, struct mat *result);
+struct mat matrix_ortho(float l, float r, float b, float t, float n, float f);
+```
+
+The result is a orthographic projection matrix with the left `l`, right `r`, bottom `b`, top `t`, near distance `n` and far distance `f`.
+
+```c
+void pmatrix_perspective(float y_fov, float aspect, float n, float f, struct mat *result);
+struct mat matrix_perspective(float y_fov, float aspect, float n, float f);
+```
+
+The result is a perspective projection matrix with the field of view, in radians, on the Y axis `y_fov`, aspect ratio `aspect`, near distance `n` and far distance `f`.
+
+```c
+void pmatrix_rotation_x(float angle, struct mat *result);
+struct mat matrix_rotation_x(float angle);
+```
+
+The result is a rotation matrix with radians `angle` on the X axis.
+
+```c
+void pmatrix_rotation_y(float angle, struct mat *result);
+struct mat matrix_rotation_y(float angle);
+```
+
+The result is a rotation matrix with radians `angle` on the Y axis.
+
+```c
+void pmatrix_rotation_z(float angle, struct mat *result);
+struct mat matrix_rotation_z(float angle);
+```
+
+The result is a rotation matrix with radians `angle` on the Z axis.
+
+```c
+void pmatrix_rotation_axis(struct vec *a, float angle, struct mat *result);
+struct mat matrix_rotation_axis(struct vec a, float angle);
+```
+
+The result is a rotation matrix with radians `angle` on the axis of the 3D vector `a`.
+
+```c
+void pmatrix_rotation_quaternion(struct vec *q, struct mat *result);
+struct mat matrix_rotation_quaternion(struct vec q);
+```
+
+The result is a rotation matrix from the quaternion `q`.
+
+```c
+void pmatrix_look_at(struct vec *pos, struct vec *target, struct vec *up, struct mat *result);
+struct mat matrix_look_at(struct vec pos, struct vec target, struct vec up);
+```
+
+The result is a view matrix with the position at the 3D vector `pos`, looking at the 3d vector `target` and up direction by the 3D vector `up`.
+
+```c
+void pmatrix_scale(struct vec *v, struct mat *result);
+struct mat matrix_scale(struct vec v);
+```
+
+The result is a scaling matrix for the 3D vector `v`.
+
+```c
+void pmatrix_get_scale(struct mat *m, struct vec *result);
+struct vec matrix_get_scale(struct mat m);
+```
+
+The result is a 3D vector from the scale of the scale matrix `m`.
+
+```c
+void pmatrix_translation(struct vec *v, struct mat *result);
+struct mat matrix_translation(struct vec v);
+```
+
+The result is a translation matrix for the 3D vector `v`.
+
+```c
+void pmatrix_get_translation(struct mat *m, struct vec *result);
+struct vec matrix_get_translation(struct mat m);
+```
+
+The result is a 3D vector from the translation of the translation matrix `m`.
+
+```c
+void pmatrix_negative(struct mat *m, struct mat *result);
+struct mat matrix_negative(struct mat m);
+```
+
+The result is a matrix for the negation of the matrix `m`.
+
+```c
+void pmatrix_multiply(struct mat *m, float s, struct mat *result);
+struct mat matrix_multiply(struct mat m, float s);
+```
+
+The result is a matrix for the multiplication of the matrix `a` with the scale `s`.
+
+```c
+void pmatrix_multiply_matrix(struct mat *a, struct mat *b, struct mat *result);
+struct mat matrix_multiply_matrix(struct mat a, struct mat b);
+```
+
+The result is a matrix for the multiplication of the matrix `a` with the matrix `b`.
+
+```c
+void pmatrix_multiply_f4(struct mat *m, float *result);
+void matrix_multiply_f4(struct mat m, float *result);
+```
+
+Multiply the values of the array `result` with 4 `float` elements by the matrix `m`.
+
+```c
+void pmatrix_to_array(struct mat *m, float *result);
+void matrix_to_array(struct mat m, float *result);
+```
+
+Copy the elements of the matrix `m` to the array `result` with 16 `float` elements.
+
+## Easing Functions
 
 ```c
 float quadratic_ease_in(float p);

From 4d459e998f6a3a54ac1d1249cba2fe9c1027efbd Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Tue, 17 Oct 2017 09:03:32 -0300
Subject: [PATCH 004/102] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index dfc63cd..dd9d594 100644
--- a/README.md
+++ b/README.md
@@ -56,7 +56,7 @@ pmatrix_multiply_matrix(&projection, &view, &multiplied_matrix);
 
 # Vectors
 
-All vectors (2D, 3D and quaternions ) use the same structure type `struct vec`.
+All vectors (2D, 3D and quaternions) use the same structure type `struct vec`. The `z` component is still useful for 2D vectors, as it is used by OpenGL for depth testing. This means the only extra component on 2D and 3D vectors is the `w` component, which is used by quaternions.
 
 Examples:
 

From 6dabf9f1d1d9db9623078a1537409106b2e25784 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Tue, 17 Oct 2017 13:37:31 -0300
Subject: [PATCH 005/102] Update README.md

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index dd9d594..1f646a2 100644
--- a/README.md
+++ b/README.md
@@ -77,6 +77,8 @@ struct vec quaternion = to_quaternion(0.0f, 0.0f, 0.0f, 1.0f);
 struct vec interpolated = quaternion_spherical_linear_interpolation(a, b, 0.5f);
 ```
 
+You don't need to create your OpenGL buffer (VBO) to take 4 elements. When using `glMapBufferRange()`/`glMapBuffer()` and `glUnmapBuffer()`, you can pass only the used elements to the VBO that has element count of your choice.
+
 # Matrices
 
 All matrices are 4×4. There are functions for setting up projection matrices, view matrices and model matrices.

From 5c505d0879a5dc2d28508bdb015711546478da8c Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Wed, 18 Oct 2017 21:06:23 -0300
Subject: [PATCH 006/102] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 1f646a2..0cd9426 100644
--- a/README.md
+++ b/README.md
@@ -77,7 +77,7 @@ struct vec quaternion = to_quaternion(0.0f, 0.0f, 0.0f, 1.0f);
 struct vec interpolated = quaternion_spherical_linear_interpolation(a, b, 0.5f);
 ```
 
-You don't need to create your OpenGL buffer (VBO) to take 4 elements. When using `glMapBufferRange()`/`glMapBuffer()` and `glUnmapBuffer()`, you can pass only the used elements to the VBO that has element count of your choice.
+You don't need to create your OpenGL buffer (VBO) to take 4 elements. When using `glMapBufferRange()`/`glMapBuffer()` and `glUnmapBuffer()`, you can pass only the used elements to the VBO, that has element count of your choice.
 
 # Matrices
 

From 7c78bc74fd66d7ce20002bcf42e086fdf7e474f8 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Wed, 18 Oct 2017 21:09:03 -0300
Subject: [PATCH 007/102] Update matrix

---
 mathc.c | 162 ++++++++++++++++++++++++++++++++++----------------------
 mathc.h |   6 ++-
 2 files changed, 103 insertions(+), 65 deletions(-)

diff --git a/mathc.c b/mathc.c
index e1b2aee..993a809 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1276,6 +1276,33 @@ MATHC_EXTERN_INLINE struct vec quaternion_spherical_linear_interpolation(struct
 }
 
 /* Matrix */
+void pmatrix_zero(struct mat *result)
+{
+	result->m11 = 0.0f;
+	result->m12 = 0.0f;
+	result->m13 = 0.0f;
+	result->m14 = 0.0f;
+	result->m21 = 0.0f;
+	result->m22 = 0.0f;
+	result->m23 = 0.0f;
+	result->m24 = 0.0f;
+	result->m31 = 0.0f;
+	result->m32 = 0.0f;
+	result->m33 = 0.0f;
+	result->m34 = 0.0f;
+	result->m41 = 0.0f;
+	result->m42 = 0.0f;
+	result->m43 = 0.0f;
+	result->m44 = 0.0f;
+}
+
+MATHC_EXTERN_INLINE struct mat matrix_zero(void)
+{
+	struct mat result;
+	pmatrix_zero(&result);
+	return result;
+}
+
 void pmatrix_identity(struct mat *result)
 {
 	result->m11 = 1.0f;
@@ -1307,11 +1334,11 @@ void pmatrix_ortho(float l, float r, float b, float t, float n, float f, struct
 {
 	pmatrix_identity(result);
 	result->m11 = 2.0f / (r - l);
-	result->m22 = 2.0f / (b - t);
+	result->m22 = 2.0f / (t - b);
 	result->m33 = 1.0f / (n - f);
 	result->m41 = (l + r) / (l - r);
-	result->m42 = (t + b) / (b - t);
-	result->m43 = n / (n - f);
+	result->m42 = (b + t) / (b - t);
+	result->m43 = n / (f - n);
 }
 
 MATHC_EXTERN_INLINE struct mat matrix_ortho(float l, float r, float b, float t, float n, float f)
@@ -1321,22 +1348,22 @@ MATHC_EXTERN_INLINE struct mat matrix_ortho(float l, float r, float b, float t,
 	return result;
 }
 
-void pmatrix_perspective(float y_fov, float aspect, float n, float f, struct mat *result)
+void pmatrix_perspective(float fov, float aspect, float n, float f, struct mat *result)
 {
-	pmatrix_identity(result);
-	/* Right-handed */
-	float a = 1.0f / tanf(y_fov * 0.5f);
-	result->m11 = a / aspect;
-	result->m22 = a;
-	result->m33 = f / (n - f);
+	const float inverse_half_fov_tan = 1.0f / tanf(fov * 0.5f);
+	pmatrix_zero(result);
+	/* linmath.h */
+	result->m11 = inverse_half_fov_tan / aspect;
+	result->m22 = inverse_half_fov_tan;
+	result->m33 = -(f + n) / (f - n);
 	result->m34 = -1.0f;
-	result->m43 = (n * f) / (n - f);
+	result->m43 = -(2.0f * f * n) / (f - n);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_perspective(float y_fov, float aspect, float n, float f)
+MATHC_EXTERN_INLINE struct mat matrix_perspective(float fov, float aspect, float n, float f)
 {
 	struct mat result;
-	pmatrix_perspective(y_fov, aspect, n, f, &result);
+	pmatrix_perspective(fov, aspect, n, f, &result);
 	return result;
 }
 
@@ -1399,21 +1426,25 @@ void pmatrix_rotation_axis(struct vec *a, float angle, struct mat *result)
 	pmatrix_identity(result);
 	float c = cosf(angle);
 	float s = sinf(angle);
-	float n1 = a->x * a->x;
-	float n2 = a->y * a->y;
-	float n3 = a->z * a->z;
-	float n4 = a->x * a->y;
-	float n5 = a->x * a->z;
-	float n6 = a->y * a->z;
-	result->m11 = n1 + (c * (1.0f - n1));
-	result->m12 = (n4 - (c * n4)) + (s * a->z);
-	result->m13 = (n5 - (c * n5)) - (s * a->y);
-	result->m21 = (n4 - (c * n4)) - (s * a->z);
-	result->m22 = n2 + (c * (1.0f - n2));
-	result->m23 = (n6 - (c * n6)) + (s * a->x);
-	result->m31 = (n5 - (c * n5)) + (s * a->y);
-	result->m32 = (n6 - (c * n6)) - (s * a->x);
-	result->m33 = n3 + (c * (1.0f - n3));
+	float one_c = 1.0f - c;
+	float x = a->x;
+	float y = a->y;
+	float z = a->z;
+	float xx = x * x;
+	float xy = x * y;
+	float xz = x * z;
+	float yy = y * y;
+	float yz = y * z;
+	float zz = z * z;
+	result->m11 = c + xx * (one_c);
+	result->m12 = xy * (one_c) - z * s;
+	result->m13 = xz * (one_c) + y * s;
+	result->m21 = xy * (one_c) + z * s;
+	result->m22 = c + yy * (one_c);
+	result->m23 = yz * (one_c) - x * s;
+	result->m31 = xz * (one_c) - y * s;
+	result->m32 = yz * (one_c) + x * s;
+	result->m33 = c + zz * (one_c);
 }
 
 MATHC_EXTERN_INLINE struct mat matrix_rotation_axis(struct vec a, float angle)
@@ -1453,29 +1484,34 @@ MATHC_EXTERN_INLINE struct mat matrix_rotation_quaternion(struct vec q)
 	return result;
 }
 
-void pmatrix_look_at(struct vec *pos, struct vec *target, struct vec *up, struct mat *result)
-{
-	struct vec v1;
-	struct vec v2;
-	struct vec v3;
-	pmatrix_identity(result);
-	pvector3_subtract(pos, target, &v1);
-	pvector3_normalize(&v1, &v1);
-	pvector3_cross(up, &v1, &v2);
-	pvector3_normalize(&v2, &v2);
-	pvector3_cross(&v1, &v2, &v3);
-	result->m11 = v2.x;
-	result->m12 = v3.x;
-	result->m13 = v1.x;
-	result->m21 = v2.y;
-	result->m22 = v3.y;
-	result->m23 = v1.y;
-	result->m31 = v2.z;
-	result->m32 = v3.z;
-	result->m33 = v1.z;
-	result->m41 = -pvector3_dot(&v2, pos);
-	result->m42 = -pvector3_dot(&v3, pos);
-	result->m43 = -pvector3_dot(&v1, pos);
+void pmatrix_look_at(struct vec *position, struct vec *target, struct vec *up, struct mat *result)
+{
+	struct vec direction;
+	struct vec right_direction;
+	struct vec up_direction;
+	pmatrix_zero(result);
+	/* Direction */
+	pvector3_subtract(target, position, &direction);
+	pvector3_normalize(&direction, &direction);
+	/* Right direction */
+	pvector3_cross(&direction, up, &right_direction);
+	pvector3_normalize(&right_direction, &right_direction);
+	/* Up direction */
+	pvector3_cross(&right_direction, &direction, &up_direction);
+	//pvector3_normalize(&up_direction, &up_direction);
+	result->m11 = right_direction.x;
+	result->m12 = right_direction.y;
+	result->m13 = right_direction.z;
+	result->m21 = up_direction.x;
+	result->m22 = up_direction.y;
+	result->m23 = up_direction.z;
+	result->m31 = direction.x;
+	result->m32 = direction.y;
+	result->m33 = direction.z;
+	result->m14 = -pvector3_dot(&right_direction, position);
+	result->m24 = -pvector3_dot(&up_direction, position);
+	result->m34 = pvector3_dot(&direction, position);
+	result->m44 = 1.0f;
 }
 
 MATHC_EXTERN_INLINE struct mat matrix_look_at(struct vec pos, struct vec target, struct vec up)
@@ -1645,20 +1681,20 @@ MATHC_EXTERN_INLINE void matrix_multiply_f4(struct mat m, float *result)
 void pmatrix_to_array(struct mat *m, float *result)
 {
 	result[0] = m->m11;
-	result[1] = m->m12;
-	result[2] = m->m13;
-	result[3] = m->m14;
-	result[4] = m->m21;
+	result[1] = m->m21;
+	result[2] = m->m31;
+	result[3] = m->m41;
+	result[4] = m->m12;
 	result[5] = m->m22;
-	result[6] = m->m23;
-	result[7] = m->m24;
-	result[8] = m->m31;
-	result[9] = m->m32;
+	result[6] = m->m32;
+	result[7] = m->m42;
+	result[8] = m->m13;
+	result[9] = m->m23;
 	result[10] = m->m33;
-	result[11] = m->m34;
-	result[12] = m->m41;
-	result[13] = m->m42;
-	result[14] = m->m43;
+	result[11] = m->m43;
+	result[12] = m->m14;
+	result[13] = m->m24;
+	result[14] = m->m34;
 	result[15] = m->m44;
 }
 
diff --git a/mathc.h b/mathc.h
index cfc7dce..1c420e0 100644
--- a/mathc.h
+++ b/mathc.h
@@ -220,9 +220,10 @@ struct vec quaternion_linear_interpolation(struct vec a, struct vec b, float p);
 struct vec quaternion_spherical_linear_interpolation(struct vec a, struct vec b, float p);
 
 /* Matrix */
+void pmatrix_zero(struct mat *result);
 void pmatrix_identity(struct mat *result);
 void pmatrix_ortho(float l, float r, float b, float t, float n, float f, struct mat *result);
-void pmatrix_perspective(float y_fov, float aspect, float n, float f, struct mat *result);
+void pmatrix_perspective(float fov, float aspect, float n, float f, struct mat *result);
 void pmatrix_rotation_x(float angle, struct mat *result);
 void pmatrix_rotation_y(float angle, struct mat *result);
 void pmatrix_rotation_z(float angle, struct mat *result);
@@ -239,9 +240,10 @@ void pmatrix_multiply_matrix(struct mat *a, struct mat *b, struct mat *result);
 void pmatrix_multiply_f4(struct mat *m, float *result);
 void pmatrix_to_array(struct mat *m, float *result);
 
+struct mat matrix_zero(void);
 struct mat matrix_identity(void);
 struct mat matrix_ortho(float l, float r, float b, float t, float n, float f);
-struct mat matrix_perspective(float y_fov, float aspect, float n, float f);
+struct mat matrix_perspective(float fov, float aspect, float n, float f);
 struct mat matrix_rotation_x(float angle);
 struct mat matrix_rotation_y(float angle);
 struct mat matrix_rotation_z(float angle);

From f5bdfb777811389f1d05fa2cc82a707b9a17c095 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Fri, 20 Oct 2017 16:30:57 -0300
Subject: [PATCH 008/102] Add link to CGDFW examples

---
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/README.md b/README.md
index 0cd9426..cd3a0be 100644
--- a/README.md
+++ b/README.md
@@ -16,6 +16,10 @@ It support C99 standard or later.
 
 The reference is the file `REFERENCE.md`.
 
+There are examples on my other repository using this math library:
+
+[CGDFW examples](https://github.com/ferreiradaselva/cgdfw/tree/master/examples)
+
 # Float
 
 Every structure and function uses `float`, because it is the most used type on 2D and 3D programming with OpenGL.

From 4eeb11f710ca8e2b30f6c6eb299f97f1468ed6ad Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Fri, 20 Oct 2017 16:48:02 -0300
Subject: [PATCH 009/102] Add util macro with number of matrix elements

The macro `MAT_SIZE` is just a syntactic sugar to make easier to declare
`float` arrays containing the number of elements of a matrix.
---
 mathc.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mathc.h b/mathc.h
index 1c420e0..a91a39c 100644
--- a/mathc.h
+++ b/mathc.h
@@ -23,6 +23,7 @@ the following restrictions:
 
 #define M_PIF 3.1415926536f
 #define M_PIF_2 1.5707963268f
+#define MAT_SIZE 16
 
 struct vec {
 	float x;

From bf65abd361456c4331e7697e82ff5bf098539a23 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 21 Oct 2017 11:35:28 -0300
Subject: [PATCH 010/102] Fix matrix for 3D view and projection

---
 mathc.c | 104 ++++++++++++++++++++++++++------------------------------
 1 file changed, 49 insertions(+), 55 deletions(-)

diff --git a/mathc.c b/mathc.c
index 993a809..fe2dd2b 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1335,10 +1335,10 @@ void pmatrix_ortho(float l, float r, float b, float t, float n, float f, struct
 	pmatrix_identity(result);
 	result->m11 = 2.0f / (r - l);
 	result->m22 = 2.0f / (t - b);
-	result->m33 = 1.0f / (n - f);
-	result->m41 = (l + r) / (l - r);
-	result->m42 = (b + t) / (b - t);
-	result->m43 = n / (f - n);
+	result->m33 = -2.0f / (f - n);
+	result->m41 = -(r + l) / (r - l);
+	result->m42 = -(t + b) / (t - b);
+	result->m43 = -(f + n) / (f - n);
 }
 
 MATHC_EXTERN_INLINE struct mat matrix_ortho(float l, float r, float b, float t, float n, float f)
@@ -1350,14 +1350,13 @@ MATHC_EXTERN_INLINE struct mat matrix_ortho(float l, float r, float b, float t,
 
 void pmatrix_perspective(float fov, float aspect, float n, float f, struct mat *result)
 {
-	const float inverse_half_fov_tan = 1.0f / tanf(fov * 0.5f);
+	const float cotan = 1.0f / tanf(fov * 0.5f);
 	pmatrix_zero(result);
-	/* linmath.h */
-	result->m11 = inverse_half_fov_tan / aspect;
-	result->m22 = inverse_half_fov_tan;
-	result->m33 = -(f + n) / (f - n);
-	result->m34 = -1.0f;
-	result->m43 = -(2.0f * f * n) / (f - n);
+	result->m11 = cotan / aspect;
+	result->m22 = cotan;
+	result->m33 = (f + n) / (n - f);
+	result->m43 = -1.0f;
+	result->m34 = 2.0f * f * n / (n - f);
 }
 
 MATHC_EXTERN_INLINE struct mat matrix_perspective(float fov, float aspect, float n, float f)
@@ -1457,24 +1456,24 @@ MATHC_EXTERN_INLINE struct mat matrix_rotation_axis(struct vec a, float angle)
 void pmatrix_rotation_quaternion(struct vec *q, struct mat *result)
 {
 	pmatrix_identity(result);
-	float n9 = q->x * q->x;
-	float n8 = q->y * q->y;
-	float n7 = q->z * q->z;
-	float n6 = q->x * q->y;
-	float n5 = q->z * q->w;
-	float n4 = q->z * q->x;
-	float n3 = q->y * q->w;
-	float n2 = q->y * q->z;
-	float n1 = q->x * q->w;
-	result->m11 = 1.0f - 2.0f * (n8 + n7);
-	result->m12 = 2.0f * (n6 + n5);
-	result->m13 = 2.0f * (n4 - n3);
-	result->m21 = 2.0f * (n6 - n5);
-	result->m22 = 1.0f - 2.0f * (n7 + n9);
-	result->m23 = 2.0f * (n2 + n1);
-	result->m31 = 2.0f * (n4 + n3);
-	result->m32 = 2.0f * (n2 - n1);
-	result->m33 = 1.0f - 2.0f * (n8 + n9);
+	float xx = q->x * q->x;
+	float yy = q->y * q->y;
+	float zz = q->z * q->z;
+	float xy = q->x * q->y;
+	float zw = q->z * q->w;
+	float xz = q->z * q->x;
+	float yw = q->y * q->w;
+	float yz = q->y * q->z;
+	float xw = q->x * q->w;
+	result->m11 = 1.0f - 2.0f * (yy - zz);
+	result->m12 = 2.0f * (xy - zw);
+	result->m13 = 2.0f * (xz + yw);
+	result->m21 = 2.0f * (xy + zw);
+	result->m22 = 1.0f - 2.0f * (xx - zz);
+	result->m23 = 2.0f * (yz - xw);
+	result->m31 = 2.0f * (xz - yw);
+	result->m32 = 2.0f * (yz + xw);
+	result->m33 = 1.0f - 2.0f * (xx - yy);
 }
 
 MATHC_EXTERN_INLINE struct mat matrix_rotation_quaternion(struct vec q)
@@ -1486,32 +1485,27 @@ MATHC_EXTERN_INLINE struct mat matrix_rotation_quaternion(struct vec q)
 
 void pmatrix_look_at(struct vec *position, struct vec *target, struct vec *up, struct mat *result)
 {
-	struct vec direction;
-	struct vec right_direction;
-	struct vec up_direction;
-	pmatrix_zero(result);
-	/* Direction */
-	pvector3_subtract(target, position, &direction);
-	pvector3_normalize(&direction, &direction);
-	/* Right direction */
-	pvector3_cross(&direction, up, &right_direction);
-	pvector3_normalize(&right_direction, &right_direction);
-	/* Up direction */
-	pvector3_cross(&right_direction, &direction, &up_direction);
-	//pvector3_normalize(&up_direction, &up_direction);
-	result->m11 = right_direction.x;
-	result->m12 = right_direction.y;
-	result->m13 = right_direction.z;
-	result->m21 = up_direction.x;
-	result->m22 = up_direction.y;
-	result->m23 = up_direction.z;
-	result->m31 = direction.x;
-	result->m32 = direction.y;
-	result->m33 = direction.z;
-	result->m14 = -pvector3_dot(&right_direction, position);
-	result->m24 = -pvector3_dot(&up_direction, position);
-	result->m34 = pvector3_dot(&direction, position);
-	result->m44 = 1.0f;
+	struct vec z_axis;
+	struct vec x_axis;
+	struct vec y_axis;
+	pvector3_subtract(target, position, &z_axis);
+	pvector3_normalize(&z_axis, &z_axis);
+	pvector3_cross(&z_axis, up, &x_axis);
+	pvector3_normalize(&x_axis, &x_axis);
+	pvector3_cross(&x_axis, &z_axis, &y_axis);
+	pmatrix_identity(result);
+	result->m11 = x_axis.x;
+	result->m12 = x_axis.y;
+	result->m13 = x_axis.z;
+	result->m21 = y_axis.x;
+	result->m22 = y_axis.y;
+	result->m23 = y_axis.z;
+	result->m31 = -z_axis.x;
+	result->m32 = -z_axis.y;
+	result->m33 = -z_axis.z;
+	result->m14 = -pvector3_dot(&x_axis, position);
+	result->m24 = -pvector3_dot(&y_axis, position);
+	result->m34 = pvector3_dot(&z_axis, position);
 }
 
 MATHC_EXTERN_INLINE struct mat matrix_look_at(struct vec pos, struct vec target, struct vec up)

From dfaf948d3cb03853af837c6c624488cc0170cfc2 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 21 Oct 2017 11:41:11 -0300
Subject: [PATCH 011/102] Rename variables to clearer names

---
 mathc.c | 48 +++++++++++++++++++++---------------------------
 1 file changed, 21 insertions(+), 27 deletions(-)

diff --git a/mathc.c b/mathc.c
index fe2dd2b..5a34cfc 100644
--- a/mathc.c
+++ b/mathc.c
@@ -323,9 +323,9 @@ void pvector2_normalize(struct vec *a, struct vec *result)
 {
 	float length = a->x * a->x + a->y * a->y;
 	if (length != 0.0f) {
-		length = sqrtf(length);
-		result->x = a->x / length;
-		result->y = a->y / length;
+		length = 1.0f / sqrtf(length);
+		result->x = a->x * length;
+		result->y = a->y * length;
 	} else {
 		result->x = 0.0f;
 		result->y = 0.0f;
@@ -708,10 +708,10 @@ void pvector3_normalize(struct vec *a, struct vec *result)
 {
 	float length = a->x * a->x + a->y * a->y + a->z * a->z;
 	if (length != 0.0f) {
-		length = sqrtf(length);
-		result->x = a->x / length;
-		result->y = a->y / length;
-		result->z = a->z / length;
+		length = 1.0f / sqrtf(length);
+		result->x = a->x * length;
+		result->y = a->y * length;
+		result->z = a->z * length;
 	} else {
 		result->x = 0.0f;
 		result->y = 0.0f;
@@ -876,20 +876,15 @@ void pquaternion_divide(struct vec *a, struct vec *b, struct vec *result)
 	float y = a->y;
 	float z = a->z;
 	float w = a->w;
-	float n1 = b->x * b->x + b->y * b->y + b->z * b->z + b->w * b->w;
-	float n2 = 1.0f / n1;
-	float n3 = -b->x * n2;
-	float n4 = -b->y * n2;
-	float n5 = -b->z * n2;
-	float n6 = b->w * n2;
-	float n7 = y * n5 - z * n4;
-	float n8 = z * n3 - x * n5;
-	float n9 = x * n4 - y * n3;
-	float n10 = x * n3 + y * n4 + z * n5;
-	result->x = x * n6 + n3 * w + n7;
-	result->y = y * n6 + n4 * w + n8;
-	result->z = z * n6 + n5 * w + n9;
-	result->w = w * n6 - n10;
+	float length_squared = 1.0f / (b->x * b->x + b->y * b->y + b->z * b->z + b->w * b->w);
+	float normalized_x = -b->x * length_squared;
+	float normalized_y = -b->y * length_squared;
+	float normalized_z = -b->z * length_squared;
+	float normalized_w = b->w * length_squared;
+	result->x = x * normalized_w + normalized_x * w + (y * normalized_z - z * normalized_y);
+	result->y = y * normalized_w + normalized_y * w + (z * normalized_x - x * normalized_z);
+	result->z = z * normalized_w + normalized_z * w + (x * normalized_y - y * normalized_x);
+	result->w = w * normalized_w - (x * normalized_x + y * normalized_y + z * normalized_z);
 }
 
 MATHC_EXTERN_INLINE struct vec quaternion_divide(struct vec a, struct vec b)
@@ -931,12 +926,11 @@ MATHC_EXTERN_INLINE struct vec quaternion_conjugate(struct vec a)
 
 void pquaternion_inverse(struct vec *a, struct vec *result)
 {
-	float n1 = sqrtf(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
-	float n2 = 1.0f / n1;
-	result->x = -a->x * n2;
-	result->y = -a->y * n2;
-	result->z = -a->z * n2;
-	result->w = a->w * n2;
+	float length = 1.0f / sqrtf(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
+	result->x = -a->x * length;
+	result->y = -a->y * length;
+	result->z = -a->z * length;
+	result->w = a->w * length;
 }
 
 MATHC_EXTERN_INLINE struct vec quaternion_inverse(struct vec a)

From 9cb5f930981d1230c9f7043ecd24cc4d37add3f0 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 21 Oct 2017 11:51:35 -0300
Subject: [PATCH 012/102] Change constants from integer to float

---
 mathc.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/mathc.c b/mathc.c
index 5a34cfc..7bf736e 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1902,14 +1902,14 @@ float bounce_ease_in(float p)
 float bounce_ease_out(float p)
 {
 	float f = 0.0f;
-	if (p < 4 / 11.0f) {
-		f = (121 * p * p) / 16.0f;
-	} else if (p < 8 / 11.0f) {
-		f = (363 / 40.0f * p * p) - (99 / 10.0f * p) + 17 / 5.0f;
-	} else if (p < 9 / 10.0f) {
-		f = (4356 / 361.0f * p * p) - (35442 / 1805.0f * p) + 16061 / 1805.0f;
+	if (p < 4.0f / 11.0f) {
+		f = (121.0f * p * p) / 16.0f;
+	} else if (p < 8.0f / 11.0f) {
+		f = (363.0f / 40.0f * p * p) - (99.0f / 10.0f * p) + 17.0f / 5.0f;
+	} else if (p < 9.0f / 10.0f) {
+		f = (4356.0f / 361.0f * p * p) - (35442.0f / 1805.0f * p) + 16061 / 1805.0f;
 	} else {
-		f = (54 / 5.0f * p * p) - (513 / 25.0f * p) + 268 / 25.0f;
+		f = (54.0f / 5.0f * p * p) - (513.0f / 25.0f * p) + 268.0f / 25.0f;
 	}
 	return f;
 }

From 2d4d7692a9cd0b0ab831a9aa692f9c286d2b3ead Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 21 Oct 2017 21:15:08 -0300
Subject: [PATCH 013/102] Update and add new projection and view matrices

The look-at view matrix has automatic up vector.

There are two functions to obtain a projection matrix. One using the
field of view and aspect-ratio, and the other using boundaries.

The orthographic projection matrix was updated to match the perspective
projection matrices.
---
 mathc.c | 70 ++++++++++++++++++++++++++++++++++++++++-----------------
 mathc.h | 12 +++++-----
 2 files changed, 56 insertions(+), 26 deletions(-)

diff --git a/mathc.c b/mathc.c
index 7bf736e..8c86ee6 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1324,25 +1324,25 @@ MATHC_EXTERN_INLINE struct mat matrix_identity(void)
 	return result;
 }
 
-void pmatrix_ortho(float l, float r, float b, float t, float n, float f, struct mat *result)
+void pmatrix_ortho(float l, float r, float t, float b, float n, float f, struct mat *result)
 {
 	pmatrix_identity(result);
 	result->m11 = 2.0f / (r - l);
 	result->m22 = 2.0f / (t - b);
 	result->m33 = -2.0f / (f - n);
-	result->m41 = -(r + l) / (r - l);
-	result->m42 = -(t + b) / (t - b);
-	result->m43 = -(f + n) / (f - n);
+	result->m14 = -(r + l) / (r - l);
+	result->m24 = -(t + b) / (t - b);
+	result->m34 = -(f + n) / (f - n);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_ortho(float l, float r, float b, float t, float n, float f)
+MATHC_EXTERN_INLINE struct mat matrix_ortho(float l, float r, float t, float b, float n, float f)
 {
 	struct mat result;
 	pmatrix_ortho(l, r, b, t, n, f, &result);
 	return result;
 }
 
-void pmatrix_perspective(float fov, float aspect, float n, float f, struct mat *result)
+void pmatrix_perspective_fov(float fov, float aspect, float n, float f, struct mat *result)
 {
 	const float cotan = 1.0f / tanf(fov * 0.5f);
 	pmatrix_zero(result);
@@ -1353,10 +1353,29 @@ void pmatrix_perspective(float fov, float aspect, float n, float f, struct mat *
 	result->m34 = 2.0f * f * n / (n - f);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_perspective(float fov, float aspect, float n, float f)
+MATHC_EXTERN_INLINE struct mat matrix_perspective_fov(float fov, float aspect, float n, float f)
 {
 	struct mat result;
-	pmatrix_perspective(fov, aspect, n, f, &result);
+	pmatrix_perspective_fov(fov, aspect, n, f, &result);
+	return result;
+}
+
+void pmatrix_perspective(float l, float r, float t, float b, float n, float f, struct mat *result)
+{
+	pmatrix_zero(result);
+	result->m11 = 2.0f * n / (r - l);
+	result->m22 = 2.0f / (t - b);
+	result->m33 = -(f + n) / (f - n);
+	result->m13 = (r + l) / (r - l);
+	result->m23 = (t + b) / (t - b);
+	result->m34 = -2.0f * f * n / (f - n);
+	result->m43 = -1.0f;
+}
+
+MATHC_EXTERN_INLINE struct mat matrix_perspective(float l, float r, float t, float b, float n, float f)
+{
+	struct mat result;
+	pmatrix_perspective(l, r, t, b, n, f, &result);
 	return result;
 }
 
@@ -1477,16 +1496,25 @@ MATHC_EXTERN_INLINE struct mat matrix_rotation_quaternion(struct vec q)
 	return result;
 }
 
-void pmatrix_look_at(struct vec *position, struct vec *target, struct vec *up, struct mat *result)
+void pmatrix_look_at(struct vec *position, struct vec *target, struct mat *result)
 {
-	struct vec z_axis;
-	struct vec x_axis;
-	struct vec y_axis;
+	struct vec z_axis; /* Forward */
+	struct vec x_axis; /* Side */
+	struct vec y_axis; /* Up */
 	pvector3_subtract(target, position, &z_axis);
 	pvector3_normalize(&z_axis, &z_axis);
-	pvector3_cross(&z_axis, up, &x_axis);
+	if (fabsf(z_axis.x) < FLT_EPSILON && fabsf(z_axis.z) < FLT_EPSILON) {
+		if (z_axis.y > 0.0f) {
+			to_pvector3(0.0f, 0.0f, -1.0f, &y_axis);
+		} else {
+			to_pvector3(0.0f, 0.0f, 1.0f, &y_axis);
+		}
+	} else {
+		to_pvector3(0.0f, 1.0f, 0.0f, &y_axis);
+	}
+	pvector3_cross(&y_axis, &z_axis, &x_axis);
 	pvector3_normalize(&x_axis, &x_axis);
-	pvector3_cross(&x_axis, &z_axis, &y_axis);
+	pvector3_cross(&z_axis, &x_axis, &y_axis);
 	pmatrix_identity(result);
 	result->m11 = x_axis.x;
 	result->m12 = x_axis.y;
@@ -1494,18 +1522,18 @@ void pmatrix_look_at(struct vec *position, struct vec *target, struct vec *up, s
 	result->m21 = y_axis.x;
 	result->m22 = y_axis.y;
 	result->m23 = y_axis.z;
-	result->m31 = -z_axis.x;
-	result->m32 = -z_axis.y;
-	result->m33 = -z_axis.z;
-	result->m14 = -pvector3_dot(&x_axis, position);
-	result->m24 = -pvector3_dot(&y_axis, position);
+	result->m31 = z_axis.x;
+	result->m32 = z_axis.y;
+	result->m33 = z_axis.z;
+	result->m14 = pvector3_dot(&x_axis, position);
+	result->m24 = pvector3_dot(&y_axis, position);
 	result->m34 = pvector3_dot(&z_axis, position);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_look_at(struct vec pos, struct vec target, struct vec up)
+MATHC_EXTERN_INLINE struct mat matrix_look_at(struct vec pos, struct vec target)
 {
 	struct mat result;
-	pmatrix_look_at(&pos, &target, &up, &result);
+	pmatrix_look_at(&pos, &target, &result);
 	return result;
 }
 
diff --git a/mathc.h b/mathc.h
index a91a39c..24f501b 100644
--- a/mathc.h
+++ b/mathc.h
@@ -224,13 +224,14 @@ struct vec quaternion_spherical_linear_interpolation(struct vec a, struct vec b,
 void pmatrix_zero(struct mat *result);
 void pmatrix_identity(struct mat *result);
 void pmatrix_ortho(float l, float r, float b, float t, float n, float f, struct mat *result);
-void pmatrix_perspective(float fov, float aspect, float n, float f, struct mat *result);
+void pmatrix_perspective_fov(float fov, float aspect, float n, float f, struct mat *result);
+void pmatrix_perspective(float l, float r, float t, float b, float n, float f, struct mat *result);
 void pmatrix_rotation_x(float angle, struct mat *result);
 void pmatrix_rotation_y(float angle, struct mat *result);
 void pmatrix_rotation_z(float angle, struct mat *result);
 void pmatrix_rotation_axis(struct vec *a, float angle, struct mat *result);
 void pmatrix_rotation_quaternion(struct vec *q, struct mat *result);
-void pmatrix_look_at(struct vec *pos, struct vec *target, struct vec *up, struct mat *result);
+void pmatrix_look_at(struct vec *pos, struct vec *target, struct mat *result);
 void pmatrix_scale(struct vec *v, struct mat *result);
 void pmatrix_get_scale(struct mat *m, struct vec *result);
 void pmatrix_translation(struct vec *v, struct mat *result);
@@ -243,14 +244,15 @@ void pmatrix_to_array(struct mat *m, float *result);
 
 struct mat matrix_zero(void);
 struct mat matrix_identity(void);
-struct mat matrix_ortho(float l, float r, float b, float t, float n, float f);
-struct mat matrix_perspective(float fov, float aspect, float n, float f);
+struct mat matrix_ortho(float l, float r, float t, float b, float n, float f);
+struct mat matrix_perspective_fov(float fov, float aspect, float n, float f);
+struct mat matrix_perspective(float l, float r, float t, float b, float n, float f);
 struct mat matrix_rotation_x(float angle);
 struct mat matrix_rotation_y(float angle);
 struct mat matrix_rotation_z(float angle);
 struct mat matrix_rotation_axis(struct vec a, float angle);
 struct mat matrix_rotation_quaternion(struct vec q);
-struct mat matrix_look_at(struct vec pos, struct vec target, struct vec up);
+struct mat matrix_look_at(struct vec pos, struct vec target);
 struct mat matrix_scale(struct vec v);
 struct vec matrix_get_scale(struct mat m);
 struct mat matrix_translation(struct vec v);

From 9ebe22fdec5b058a97ec1878ec741d4e7ee05816 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 21 Oct 2017 21:27:26 -0300
Subject: [PATCH 014/102] Update REFERENCE.md

---
 REFERENCE.md | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/REFERENCE.md b/REFERENCE.md
index f75aba6..3b0bd59 100644
--- a/REFERENCE.md
+++ b/REFERENCE.md
@@ -604,11 +604,18 @@ struct mat matrix_ortho(float l, float r, float b, float t, float n, float f);
 The result is a orthographic projection matrix with the left `l`, right `r`, bottom `b`, top `t`, near distance `n` and far distance `f`.
 
 ```c
-void pmatrix_perspective(float y_fov, float aspect, float n, float f, struct mat *result);
-struct mat matrix_perspective(float y_fov, float aspect, float n, float f);
+void pmatrix_perspective_fov(float fov, float aspect, float n, float f, struct mat *result);
+struct mat matrix_perspective_fov(float fov, float aspect, float n, float f);
 ```
 
-The result is a perspective projection matrix with the field of view, in radians, on the Y axis `y_fov`, aspect ratio `aspect`, near distance `n` and far distance `f`.
+The result is a perspective projection matrix with the field of view `fov`, in radians, aspect ratio `aspect`, near distance `n` and far distance `f`.
+
+```c
+void pmatrix_perspective(float l, float r, float t, float b, float n, float f, struct mat *result);
+struct mat matrix_perspective(float l, float r, float t, float b, float n, float f);
+```
+
+The result is a perspective projection matrix with the bountadies set tot hte left `l`, right `r`, top `t`, bottom `b`, near distance `n` and far distance `f`.
 
 ```c
 void pmatrix_rotation_x(float angle, struct mat *result);
@@ -646,11 +653,11 @@ struct mat matrix_rotation_quaternion(struct vec q);
 The result is a rotation matrix from the quaternion `q`.
 
 ```c
-void pmatrix_look_at(struct vec *pos, struct vec *target, struct vec *up, struct mat *result);
-struct mat matrix_look_at(struct vec pos, struct vec target, struct vec up);
+void pmatrix_look_at(struct vec *pos, struct vec *target, struct mat *result);
+struct mat matrix_look_at(struct vec pos, struct vec target);
 ```
 
-The result is a view matrix with the position at the 3D vector `pos`, looking at the 3d vector `target` and up direction by the 3D vector `up`.
+The result is a view matrix with the position at the 3D vector `pos`, looking at the 3d vector `target`. The up direction is assumed `[0.0f, 1.0f, 0.0f]`.
 
 ```c
 void pmatrix_scale(struct vec *v, struct mat *result);

From 11ae9e2aec6d13f28cce55fefc0c503e99288956 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 21 Oct 2017 22:25:41 -0300
Subject: [PATCH 015/102] Update examples in README.md

---
 README.md | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index cd3a0be..971eb34 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 [![Build Status](https://travis-ci.org/ferreiradaselva/mathc.svg?branch=master)](https://travis-ci.org/ferreiradaselva/mathc)
 
-MathC is a simple math library for 2D and 3D programming. It contains implementations for:
+MathC is a simple math library for 2D and 3D game programming. It contains implementations for:
 
 - 2D vectors
 - 3D vectors
@@ -38,23 +38,21 @@ Examples:
 /* Pass by value and return a value */
 struct mat projection = matrix_ortho(-100.0f, 100.0f, -100.0f, 100.0f, 0.0f, 1.0f);
 struct mat view = matrix_look_at(to_vector3(0.0f, 0.0f, 1.0f),
-	to_vector3(0.0f, 0.0f, 0.0f),
-	to_vector3(0.0f, 1.0f, 0.0f));
+	to_vector3(0.0f, 0.0f, 0.0f));
 struct mat pv = matrix_multiply_matrix(projection, view);
 
 /* Pass by pointer */
 struct vec pos = {0};
 struct vec target = {0};
-struct vec up = {0};
-struct mat projection;
-struct mat view;
-struct mat multiplied_matrix;
+struct mat projection = {0};
+struct mat view = {0};
+struct mat multiplied_matrix = {0};
 
 to_pvector3(0.0f, 0.0f, 1.0f, &pos);
 to_pvector3(0.0f, 0.0f, 0.0f, &target);
 to_pvector3(0.0f, 1.0f, 0.0f, &up);
 pmatrix_ortho(-100.0f, 100.0f, -100.0f, 100.0f, 0.0f, 1.0f, &projection);
-pmatrix_look_at(&pos, &target, &up, &view);
+pmatrix_look_at(&pos, &target, &view);
 pmatrix_multiply_matrix(&projection, &view, &multiplied_matrix);
 ```
 
@@ -101,8 +99,7 @@ If you want to modify on GPU-side, you can use the functions `matrix_to_array()`
 float v[16];
 struct mat projection = matrix_ortho(-100.0f, 100.0f, -100.0f, 100.0f, 0.0f, 1.0f);
 struct mat view = matrix_look_at(to_vector3(0.0f, 0.0f, 1.0f),
-	to_vector3(0.0f, 0.0f, 0.0f),
-	to_vector3(0.0f, 1.0f, 0.0f));
+	to_vector3(0.0f, 0.0f, 0.0f));
 struct mat pv = matrix_multiply_matrix(projection, view);
 matrix_to_array(pv, v);
 ```

From b72a37580209c00475daa545ec3b0f24fbe491b6 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Mon, 23 Oct 2017 11:51:24 -0300
Subject: [PATCH 016/102] Normalize quaternion from axis angle

---
 mathc.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mathc.c b/mathc.c
index 8c86ee6..d03f091 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1120,6 +1120,7 @@ void pquaternion_from_axis_angle(struct vec *a, float angle, struct vec *result)
 	result->y = a->y * s;
 	result->z = a->z * s;
 	result->w = cosf(half);
+	pquaternion_normalize(result, result);
 }
 
 MATHC_EXTERN_INLINE struct vec quaternion_from_axis_angle(struct vec a, float angle)

From 53b1dcc4dbfb30c29005d041b64e39444d0c27b0 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Mon, 23 Oct 2017 11:53:27 -0300
Subject: [PATCH 017/102] Use float to convert quaternion to axis angle

---
 mathc.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/mathc.c b/mathc.c
index d03f091..573a724 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1132,11 +1132,11 @@ MATHC_EXTERN_INLINE struct vec quaternion_from_axis_angle(struct vec a, float an
 
 void pquaternion_to_axis_angle(struct vec *a, struct vec *result)
 {
-	double sa;
+	float sa;
 	struct vec tmp;
 	pquaternion_normalize(a, &tmp);
-	sa = sqrt(1.0f - tmp.w * tmp.w);
-	if (fabs(sa) <= FLT_EPSILON) {
+	sa = sqrtf(1.0f - tmp.w * tmp.w);
+	if (fabsf(sa) <= FLT_EPSILON) {
 		sa = 1.0f;
 	}
 	result->x = tmp.x / sa;

From 0f4247a01f11c4130ba9a2cad3a732c8229a0479 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Wed, 1 Nov 2017 06:29:49 -0300
Subject: [PATCH 018/102] Avoid division by zero to get inverse quaternion

---
 mathc.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/mathc.c b/mathc.c
index 573a724..f4e5f04 100644
--- a/mathc.c
+++ b/mathc.c
@@ -926,7 +926,10 @@ MATHC_EXTERN_INLINE struct vec quaternion_conjugate(struct vec a)
 
 void pquaternion_inverse(struct vec *a, struct vec *result)
 {
-	float length = 1.0f / sqrtf(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
+	float length = sqrtf(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
+	if (fabs(length) > FLT_EPSILON) {
+		length = 1.0f / length;
+	}
 	result->x = -a->x * length;
 	result->y = -a->y * length;
 	result->z = -a->z * length;

From cf51f98d3e3d083a7111c98d07857e4ed1b6f05c Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Wed, 1 Nov 2017 06:36:00 -0300
Subject: [PATCH 019/102] Avoid division by zero to get quaternions angle

---
 mathc.c | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/mathc.c b/mathc.c
index f4e5f04..a524603 100644
--- a/mathc.c
+++ b/mathc.c
@@ -929,6 +929,8 @@ void pquaternion_inverse(struct vec *a, struct vec *result)
 	float length = sqrtf(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
 	if (fabs(length) > FLT_EPSILON) {
 		length = 1.0f / length;
+	} else {
+		length = 0.0f;
 	}
 	result->x = -a->x * length;
 	result->y = -a->y * length;
@@ -1046,7 +1048,12 @@ MATHC_EXTERN_INLINE float quaternion_dot(struct vec a, struct vec b)
 float pquaternion_angle(struct vec *a, struct vec *b)
 {
 	float s = sqrtf(pquaternion_length_squared(a) * pquaternion_length_squared(b));
-	return acosf(pquaternion_dot(a, b) / s);
+	if (fabs(s) > FLT_EPSILON) {
+		s = 1.0f / s;
+	} else {
+		s = 0.0f;
+	}
+	return acosf(pquaternion_dot(a, b) * s);
 }
 
 MATHC_EXTERN_INLINE float quaternion_angle(struct vec a, struct vec b)

From 9622e62731c599620890a3f177a080ba86a6f375 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Wed, 1 Nov 2017 06:44:42 -0300
Subject: [PATCH 020/102] Avoid division by zero in vectors normalization

---
 mathc.c | 30 +++++++++++++++++++-----------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/mathc.c b/mathc.c
index a524603..6b30a01 100644
--- a/mathc.c
+++ b/mathc.c
@@ -321,9 +321,9 @@ MATHC_EXTERN_INLINE float vector2_length(struct vec a)
 
 void pvector2_normalize(struct vec *a, struct vec *result)
 {
-	float length = a->x * a->x + a->y * a->y;
-	if (length != 0.0f) {
-		length = 1.0f / sqrtf(length);
+	float length = sqrtf(a->x * a->x + a->y * a->y);
+	if (length > FLT_EPSILON) {
+		length = 1.0f / length;
 		result->x = a->x * length;
 		result->y = a->y * length;
 	} else {
@@ -706,9 +706,9 @@ MATHC_EXTERN_INLINE float vector3_length(struct vec a)
 
 void pvector3_normalize(struct vec *a, struct vec *result)
 {
-	float length = a->x * a->x + a->y * a->y + a->z * a->z;
-	if (length != 0.0f) {
-		length = 1.0f / sqrtf(length);
+	float length = sqrtf(a->x * a->x + a->y * a->y + a->z * a->z);
+	if (length > FLT_EPSILON) {
+		length = 1.0f / length;
 		result->x = a->x * length;
 		result->y = a->y * length;
 		result->z = a->z * length;
@@ -1083,11 +1083,19 @@ MATHC_EXTERN_INLINE float quaternion_length(struct vec a)
 
 void pquaternion_normalize(struct vec *a, struct vec *result)
 {
-	float n = 1.0f / sqrtf(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
-	result->x = a->x * n;
-	result->y = a->y * n;
-	result->z = a->z * n;
-	result->w = a->w * n;
+	float length = sqrtf(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
+	if (length > FLT_EPSILON) {
+		length = 1.0f / length;
+		result->x = a->x * length;
+		result->y = a->y * length;
+		result->z = a->z * length;
+		result->w = a->w * length;
+	} else {
+		result->x = 0.0f;
+		result->y = 0.0f;
+		result->z = 0.0f;
+	}
+	result->w = 1.0f;
 }
 
 MATHC_EXTERN_INLINE struct vec quaternion_normalize(struct vec a)

From 5a148f5ce67e4579d7876076593a2cda277b63c8 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 2 Nov 2017 12:53:23 -0300
Subject: [PATCH 021/102] Add bezier functions for 2D and 3D vectors

---
 mathc.c | 76 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 mathc.h |  8 ++++++
 2 files changed, 84 insertions(+)

diff --git a/mathc.c b/mathc.c
index 6b30a01..005f729 100644
--- a/mathc.c
+++ b/mathc.c
@@ -436,6 +436,44 @@ MATHC_EXTERN_INLINE struct vec vector2_linear_interpolation(struct vec a, struct
 	return result;
 }
 
+void pvector2_bezier3(struct vec *a, struct vec *b, struct vec *c, float p, struct vec *result)
+{
+	struct vec tmp_a;
+	struct vec tmp_b;
+	pvector2_linear_interpolation(a, b, p, &tmp_a);
+	pvector2_linear_interpolation(b, c, p, &tmp_b);
+	pvector2_linear_interpolation(&tmp_a, &tmp_b, p, result);
+}
+
+MATHC_EXTERN_INLINE struct vec vector2_bezier3(struct vec a, struct vec b, struct vec c, float p)
+{
+	struct vec result;
+	pvector2_bezier3(&a, &b, &c, p, &result);
+	return result;
+}
+
+void pvector2_bezier4(struct vec *a, struct vec *b, struct vec *c, struct vec *d, float p, struct vec *result)
+{
+	struct vec tmp_a;
+	struct vec tmp_b;
+	struct vec tmp_c;
+	struct vec tmp_d;
+	struct vec tmp_e;
+	pvector2_linear_interpolation(a, b, p, &tmp_a);
+	pvector2_linear_interpolation(b, c, p, &tmp_b);
+	pvector2_linear_interpolation(c, d, p, &tmp_c);
+	pvector2_linear_interpolation(&tmp_a, &tmp_b, p, &tmp_d);
+	pvector2_linear_interpolation(&tmp_b, &tmp_c, p, &tmp_e);
+	pvector2_linear_interpolation(&tmp_d, &tmp_e, p, result);
+}
+
+MATHC_EXTERN_INLINE struct vec vector2_bezier4(struct vec a, struct vec b, struct vec c, struct vec d, float p)
+{
+	struct vec result;
+	pvector2_bezier4(&a, &b, &c, &d, p, &result);
+	return result;
+}
+
 /* Vector 3D */
 void to_pvector3(float x, float y, float z, struct vec *result)
 {
@@ -794,6 +832,44 @@ MATHC_EXTERN_INLINE struct vec vector3_linear_interpolation(struct vec a, struct
 	return result;
 }
 
+void pvector3_bezier3(struct vec *a, struct vec *b, struct vec *c, float p, struct vec *result)
+{
+	struct vec tmp_a;
+	struct vec tmp_b;
+	pvector3_linear_interpolation(a, b, p, &tmp_a);
+	pvector3_linear_interpolation(b, c, p, &tmp_b);
+	pvector3_linear_interpolation(&tmp_a, &tmp_b, p, result);
+}
+
+MATHC_EXTERN_INLINE struct vec vector3_bezier3(struct vec a, struct vec b, struct vec c, float p)
+{
+	struct vec result;
+	pvector3_bezier3(&a, &b, &c, p, &result);
+	return result;
+}
+
+void pvector3_bezier4(struct vec *a, struct vec *b, struct vec *c, struct vec *d, float p, struct vec *result)
+{
+	struct vec tmp_a;
+	struct vec tmp_b;
+	struct vec tmp_c;
+	struct vec tmp_d;
+	struct vec tmp_e;
+	pvector3_linear_interpolation(a, b, p, &tmp_a);
+	pvector3_linear_interpolation(b, c, p, &tmp_b);
+	pvector3_linear_interpolation(c, d, p, &tmp_c);
+	pvector3_linear_interpolation(&tmp_a, &tmp_b, p, &tmp_d);
+	pvector3_linear_interpolation(&tmp_b, &tmp_c, p, &tmp_e);
+	pvector3_linear_interpolation(&tmp_d, &tmp_e, p, result);
+}
+
+MATHC_EXTERN_INLINE struct vec vector3_bezier4(struct vec a, struct vec b, struct vec c, struct vec d, float p)
+{
+	struct vec result;
+	pvector3_bezier4(&a, &b, &c, &d, p, &result);
+	return result;
+}
+
 /* Quaternion */
 void to_pquaternion(float x, float y, float z, float w, struct vec *result)
 {
diff --git a/mathc.h b/mathc.h
index 24f501b..bd0a8bf 100644
--- a/mathc.h
+++ b/mathc.h
@@ -84,6 +84,8 @@ void pvector2_rotate(struct vec *a, float angle, struct vec *result);
 float pvector2_distance_to(struct vec *a, struct vec *b);
 float pvector2_distance_squared_to(struct vec *a, struct vec *b);
 void pvector2_linear_interpolation(struct vec *a, struct vec *b, float p, struct vec *result);
+void pvector2_bezier3(struct vec *a, struct vec *b, struct vec *c, float p, struct vec *result);
+void pvector2_bezier4(struct vec *a, struct vec *b, struct vec *c, struct vec *d, float p, struct vec *result);
 
 struct vec to_vector2(float x, float y);
 struct vec vector2_add(struct vec a, struct vec b);
@@ -111,6 +113,8 @@ struct vec vector2_rotate(struct vec a, float angle);
 float vector2_distance_to(struct vec a, struct vec b);
 float vector2_distance_squared_to(struct vec a, struct vec b);
 struct vec vector2_linear_interpolation(struct vec a, struct vec b, float p);
+struct vec vector2_bezier3(struct vec a, struct vec b, struct vec c, float p);
+struct vec vector2_bezier4(struct vec a, struct vec b, struct vec c, struct vec d, float p);
 
 /* Vector 3D */
 void to_pvector3(float x, float y, float z, struct vec *result);
@@ -137,6 +141,8 @@ void pvector3_reflect(struct vec *a, struct vec *normal, struct vec *result);
 float pvector3_distance_to(struct vec *a, struct vec *b);
 float pvector3_distance_squared_to(struct vec *a, struct vec *b);
 void pvector3_linear_interpolation(struct vec *a, struct vec *b, float p, struct vec *result);
+void pvector3_bezier3(struct vec *a, struct vec *b, struct vec *c, float p, struct vec *result);
+void pvector3_bezier4(struct vec *a, struct vec *b, struct vec *c, struct vec *d, float p, struct vec *result);
 
 struct vec to_vector3(float x, float y, float z);
 struct vec vector3_add(struct vec a, struct vec b);
@@ -162,6 +168,8 @@ struct vec vector3_reflect(struct vec a, struct vec normal);
 float vector3_distance_to(struct vec a, struct vec b);
 float vector3_distance_squared_to(struct vec a, struct vec b);
 struct vec vector3_linear_interpolation(struct vec a, struct vec b, float p);
+struct vec vector3_bezier3(struct vec a, struct vec b, struct vec c, float p);
+struct vec vector3_bezier4(struct vec a, struct vec b, struct vec c, struct vec d, float p);
 
 /* Quaternion */
 void to_pquaternion(float x, float y, float z, float w, struct vec *result);

From 1deeb88d7da30aa8b3d49ff45eddf97fb5513c7a Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 2 Nov 2017 22:04:45 -0300
Subject: [PATCH 022/102] Fix quaternion normalization

---
 mathc.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/mathc.c b/mathc.c
index 005f729..1a9e39d 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1159,9 +1159,8 @@ MATHC_EXTERN_INLINE float quaternion_length(struct vec a)
 
 void pquaternion_normalize(struct vec *a, struct vec *result)
 {
-	float length = sqrtf(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
+	float length = 1.0f / sqrtf(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
 	if (length > FLT_EPSILON) {
-		length = 1.0f / length;
 		result->x = a->x * length;
 		result->y = a->y * length;
 		result->z = a->z * length;
@@ -1170,8 +1169,8 @@ void pquaternion_normalize(struct vec *a, struct vec *result)
 		result->x = 0.0f;
 		result->y = 0.0f;
 		result->z = 0.0f;
+		result->w = 1.0f;
 	}
-	result->w = 1.0f;
 }
 
 MATHC_EXTERN_INLINE struct vec quaternion_normalize(struct vec a)

From 37d087a26abacd9cc04d105e65c68c0e38bc1c93 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 2 Nov 2017 22:05:49 -0300
Subject: [PATCH 023/102] Update quaternion test precision

---
 test.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test.c b/test.c
index ea98a98..ac2f7b6 100644
--- a/test.c
+++ b/test.c
@@ -373,11 +373,11 @@ void quaternion_tests(struct cerror *error)
 	printf("\n# Making tests with quaternions...\n");
 	a = to_quaternion(0.0f, 1.0f, 0.0f, 1.0f);
 	r = quaternion_normalize(a);
-	printf_4f_test(error, "Normalize quaternion", 0.707099974f, 0.0, 0.707099974f, 0.0f, r.w, r.x, r.y, r.z);
+	printf_4f_test(error, "Normalize quaternion", 0.7071067812f, 0.0, 0.7071067812f, 0.0f, r.w, r.x, r.y, r.z);
 	a = to_vector3(1.0f, 0.0f, 0.0f);
 	r = quaternion_from_axis_angle(a, M_PIF_2);
 	printf_4f_test(error, "Quaternion from axis-angle", 0.707099974f, 0.707099974f, 0.0f, 0.0f, r.w, r.x, r.y, r.z);
-	a = to_quaternion(0.7071f, 0.0f, 0.0f, 0.7071f);
+	a = to_quaternion(0.7071067812f, 0.0f, 0.0f, 0.7071067812f);
 	r = quaternion_to_axis_angle(a);
 	printf_4f_test(error, "Quaternion to axis-angle", 1.0f, 0.0f, 0.0f, 1.570796371f, r.x, r.y, r.z, r.w);
 }

From 597f68a450446111c9566a4ace73d36ac719603f Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 2 Nov 2017 22:06:52 -0300
Subject: [PATCH 024/102] Add projection and view functions

---
 REFERENCE.md |  53 ++++++++++---
 mathc.c      | 212 ++++++++++++++++++++++++++++++++++++++++-----------
 mathc.h      |  24 ++++--
 3 files changed, 230 insertions(+), 59 deletions(-)

diff --git a/REFERENCE.md b/REFERENCE.md
index 3b0bd59..953f515 100644
--- a/REFERENCE.md
+++ b/REFERENCE.md
@@ -597,25 +597,60 @@ struct mat matrix_identity(void);
 The result is a identity matrix.
 
 ```c
-void pmatrix_ortho(float l, float r, float b, float t, float n, float f, struct mat *result);
-struct mat matrix_ortho(float l, float r, float b, float t, float n, float f);
+void pmatrix_ortho_zo(float l, float r, float b, float t, float n, float f, struct mat *result);
+struct mat matrix_ortho_zo(float l, float r, float b, float t, float n, float f);
 ```
 
-The result is a orthographic projection matrix with the left `l`, right `r`, bottom `b`, top `t`, near distance `n` and far distance `f`.
+The result is a orthographic projection matrix with depth from zero to one, left `l`, right `r`, bottom `b` top `t`, near clipping `n` and far clipping `f`.
 
 ```c
-void pmatrix_perspective_fov(float fov, float aspect, float n, float f, struct mat *result);
-struct mat matrix_perspective_fov(float fov, float aspect, float n, float f);
+void pmatrix_ortho_no(float l, float r, float b, float t, float n, float f, struct mat *result);
+struct mat matrix_ortho_no(float l, float r, float b, float t, float n, float f);
 ```
 
-The result is a perspective projection matrix with the field of view `fov`, in radians, aspect ratio `aspect`, near distance `n` and far distance `f`.
+The result is a orthographic projection matrix with depth from negatie one to one, left `l`, right `r`, bottom `b` top `t`, near clipping `n` and far clipping `f`.
 
 ```c
-void pmatrix_perspective(float l, float r, float t, float b, float n, float f, struct mat *result);
-struct mat matrix_perspective(float l, float r, float t, float b, float n, float f);
+void pmatrix_ortho(float l, float r, float b, float t, struct mat *result);
+struct mat matrix_ortho(float l, float r, float b, float t);
 ```
 
-The result is a perspective projection matrix with the bountadies set tot hte left `l`, right `r`, top `t`, bottom `b`, near distance `n` and far distance `f`.
+The result is a orthographic projection matrix with the left `l`, right `r`, bottom `b`, and top `t`.
+
+```c
+void pmatrix_perspective_zo(float fov_y, float aspect, float n, float f, struct mat *result);
+struct mat matrix_perspective_zo(float fov_y, float aspect, float n, float f);
+```
+
+The result is a perspective projection matrix with depth from zero to one, field of view of Y axis `fov_y`, in radians, aspect ratio `aspect`, near clipping `n` and far clipping `f`.
+
+```c
+void pmatrix_perspective_no(float fov_y, float aspect, float n, float f, struct mat *result);
+struct mat matrix_perspective_no(float fov_y, float aspect, float n, float f);
+```
+
+The result is a perspective projection matrix with depth from negative one to one, field of view of Y axis `fov_y`, in radians, aspect ratio `aspect`, near clipping `n` and far clipping `f`.
+
+```c
+void pmatrix_perspective_fov_zo(float fov, float w, float h, float n, float f, struct mat *result);
+struct mat matrix_perspective_fov_zo(float fov, float w, float h, float n, float f);
+```
+
+The result is a perspective projection matrix with depth from zero to one, field of view `fov`, width `w`, height `h`, near clipping `n` and far clipping `f`.
+
+```c
+void pmatrix_perspective_fov_no(float fov, float w, float h, float n, float f, struct mat *result);
+struct mat matrix_perspective_fov_no(float fov, float w, float h, float n, float f);
+```
+
+The result is a perspective projection matrix with depth from negatve one to one, field of view `fov`, width `w`, height `h`, near clipping `n` and far clipping `f`.
+
+```c
+void pmatrix_perspective_infinite(float fov_y, float aspect, float n, struct mat *result);
+struct mat matrix_perspective_infinite(float fov_y, float aspect, float n);
+```
+
+The result is a perspective projection matrix with field of view of Y axis `fov_y`, aspect ratio `aspct` and near clipping `n`.
 
 ```c
 void pmatrix_rotation_x(float angle, struct mat *result);
diff --git a/mathc.c b/mathc.c
index 1a9e39d..e2e7915 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1418,7 +1418,25 @@ MATHC_EXTERN_INLINE struct mat matrix_identity(void)
 	return result;
 }
 
-void pmatrix_ortho(float l, float r, float t, float b, float n, float f, struct mat *result)
+void pmatrix_ortho_zo(float l, float r, float t, float b, float n, float f, struct mat *result)
+{
+	pmatrix_identity(result);
+	result->m11 = 2.0f / (r - l);
+	result->m22 = 2.0f / (t - b);
+	result->m33 = -1.0f / (f - n);
+	result->m14 = -(r + l) / (r - l);
+	result->m24 = -(t + b) / (t - b);
+	result->m34 = -n / (f - n);
+}
+
+MATHC_EXTERN_INLINE struct mat matrix_ortho_zo(float l, float r, float t, float b, float n, float f)
+{
+	struct mat result;
+	pmatrix_ortho_zo(l, r, b, t, n, f, &result);
+	return result;
+}
+
+void pmatrix_ortho_no(float l, float r, float t, float b, float n, float f, struct mat *result)
 {
 	pmatrix_identity(result);
 	result->m11 = 2.0f / (r - l);
@@ -1429,47 +1447,122 @@ void pmatrix_ortho(float l, float r, float t, float b, float n, float f, struct
 	result->m34 = -(f + n) / (f - n);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_ortho(float l, float r, float t, float b, float n, float f)
+MATHC_EXTERN_INLINE struct mat matrix_ortho_no(float l, float r, float t, float b, float n, float f)
 {
 	struct mat result;
-	pmatrix_ortho(l, r, b, t, n, f, &result);
+	pmatrix_ortho_no(l, r, b, t, n, f, &result);
 	return result;
 }
 
-void pmatrix_perspective_fov(float fov, float aspect, float n, float f, struct mat *result)
+void pmatrix_ortho(float l, float r, float t, float b, struct mat *result)
 {
-	const float cotan = 1.0f / tanf(fov * 0.5f);
+	pmatrix_identity(result);
+	result->m11 = 2.0f / (r - l);
+	result->m22 = 2.0f / (t - b);
+	result->m14 = -(r + l) / (r - l);
+	result->m24 = -(t + b) / (t - b);
+}
+
+MATHC_EXTERN_INLINE struct mat matrix_ortho(float l, float r, float t, float b)
+{
+	struct mat result;
+	pmatrix_ortho(l, r, b, t, &result);
+	return result;
+}
+
+void pmatrix_perspective_zo(float fov_y, float aspect, float n, float f, struct mat *result)
+{
+	const float tan_half_fov_y = 1.0f / tanf(fov_y * 0.5f);
 	pmatrix_zero(result);
-	result->m11 = cotan / aspect;
-	result->m22 = cotan;
-	result->m33 = (f + n) / (n - f);
+	result->m11 = 1.0f / aspect * tan_half_fov_y;
+	result->m22 = 1.0f / tan_half_fov_y;
+	result->m33 = f / (n - f);
 	result->m43 = -1.0f;
-	result->m34 = 2.0f * f * n / (n - f);
+	result->m34 = -(f * n) / (f - n);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_perspective_fov(float fov, float aspect, float n, float f)
+MATHC_EXTERN_INLINE struct mat matrix_perspective_zo(float fov_y, float aspect, float n, float f)
 {
 	struct mat result;
-	pmatrix_perspective_fov(fov, aspect, n, f, &result);
+	pmatrix_perspective_zo(fov_y, aspect, n, f, &result);
 	return result;
 }
 
-void pmatrix_perspective(float l, float r, float t, float b, float n, float f, struct mat *result)
+void pmatrix_perspective_no(float fov_y, float aspect, float n, float f, struct mat *result)
 {
+	const float tan_half_fov_y = 1.0f / tanf(fov_y * 0.5f);
 	pmatrix_zero(result);
-	result->m11 = 2.0f * n / (r - l);
-	result->m22 = 2.0f / (t - b);
+	result->m11 = 1.0f / aspect * tan_half_fov_y;
+	result->m22 = 1.0f / tan_half_fov_y;
 	result->m33 = -(f + n) / (f - n);
-	result->m13 = (r + l) / (r - l);
-	result->m23 = (t + b) / (t - b);
-	result->m34 = -2.0f * f * n / (f - n);
 	result->m43 = -1.0f;
+	result->m34 = -(2.0f * f * n) / (f - n);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_perspective(float l, float r, float t, float b, float n, float f)
+MATHC_EXTERN_INLINE struct mat matrix_perspective_no(float fov_y, float aspect, float n, float f)
 {
 	struct mat result;
-	pmatrix_perspective(l, r, t, b, n, f, &result);
+	pmatrix_perspective_no(fov_y, aspect, n, f, &result);
+	return result;
+}
+
+void pmatrix_perspective_fov_zo(float fov, float w, float h, float n, float f, struct mat *result)
+{
+	const float h2 = cosf(fov * 0.5f) / sinf(fov * 0.5f);
+	const float w2 = h2 * h / w;
+	pmatrix_zero(result);
+	result->m11 = w2;
+	result->m22 = h2;
+	result->m33 = f / (n - f);
+	result->m43 = -1.0f;
+	result->m34 = -(f * n) / (f - n);
+}
+
+MATHC_EXTERN_INLINE struct mat matrix_perspective_fov_zo(float fov, float w, float h, float n, float f)
+{
+	struct mat result;
+	pmatrix_perspective_fov_zo(fov, w, h, n, f, &result);
+	return result;
+}
+
+void pmatrix_perspective_fov_no(float fov, float w, float h, float n, float f, struct mat *result)
+{
+	const float h2 = cosf(fov * 0.5f) / sinf(fov * 0.5f);
+	const float w2 = h2 * h / w;
+	pmatrix_zero(result);
+	result->m11 = w2;
+	result->m22 = h2;
+	result->m33 = -(f + n) / (f - n);
+	result->m43 = -1.0f;
+	result->m34 = -(2.0f * f * n) / (f - n);
+}
+
+MATHC_EXTERN_INLINE struct mat matrix_perspective_fov_no(float fov, float w, float h, float n, float f)
+{
+	struct mat result;
+	pmatrix_perspective_fov_no(fov, w, h, n, f, &result);
+	return result;
+}
+
+void pmatrix_perspective_infinite(float fov_y, float aspect, float n, struct mat *result)
+{
+	const float range = tanf(fov_y * 0.5f) * n;
+	const float left = -range * aspect;
+	const float right = range * aspect;
+	const float top = range;
+	const float bottom = -range;
+	pmatrix_zero(result);
+	result->m11 = 2.0f * n / (right - left);
+	result->m22 = 2.0f * n / (top - bottom);
+	result->m33 = -1.0f;
+	result->m43 = -1.0f;
+	result->m34 = -2.0f * n;
+}
+
+MATHC_EXTERN_INLINE struct mat matrix_perspective_infinite(float fov_y, float aspect, float n)
+{
+	struct mat result;
+	pmatrix_perspective_infinite(fov_y, aspect, n, &result);
 	return result;
 }
 
@@ -1590,38 +1683,69 @@ MATHC_EXTERN_INLINE struct mat matrix_rotation_quaternion(struct vec q)
 	return result;
 }
 
+void pmatrix_look_at_up(struct vec *position, struct vec *target, struct vec *up_axis, struct mat *result)
+{
+	struct vec forward_axis;
+	struct vec side_axis;
+	pvector3_subtract(target, position, &forward_axis);
+	pvector3_normalize(&forward_axis, &forward_axis);
+	pvector3_cross(&forward_axis, up_axis, &side_axis);
+	pvector3_normalize(&side_axis, &side_axis);
+	pvector3_cross(&side_axis, &forward_axis, up_axis);
+	pmatrix_identity(result);
+	result->m11 = side_axis.x;
+	result->m12 = side_axis.y;
+	result->m13 = side_axis.z;
+	result->m21 = up_axis->x;
+	result->m22 = up_axis->y;
+	result->m23 = up_axis->z;
+	result->m31 = -forward_axis.x;
+	result->m32 = -forward_axis.y;
+	result->m33 = -forward_axis.z;
+	result->m14 = -pvector3_dot(&side_axis, position);
+	result->m24 = -pvector3_dot(up_axis, position);
+	result->m34 = pvector3_dot(&forward_axis, position);
+}
+
+MATHC_EXTERN_INLINE struct mat matrix_look_at_up(struct vec pos, struct vec target, struct vec up_axis)
+{
+	struct mat result;
+	pmatrix_look_at_up(&pos, &target, &up_axis, &result);
+	return result;
+}
+
 void pmatrix_look_at(struct vec *position, struct vec *target, struct mat *result)
 {
-	struct vec z_axis; /* Forward */
-	struct vec x_axis; /* Side */
-	struct vec y_axis; /* Up */
-	pvector3_subtract(target, position, &z_axis);
-	pvector3_normalize(&z_axis, &z_axis);
-	if (fabsf(z_axis.x) < FLT_EPSILON && fabsf(z_axis.z) < FLT_EPSILON) {
-		if (z_axis.y > 0.0f) {
-			to_pvector3(0.0f, 0.0f, -1.0f, &y_axis);
+	struct vec forward_axis;
+	struct vec side_axis;
+	struct vec up_axis;
+	pvector3_subtract(target, position, &forward_axis);
+	pvector3_normalize(&forward_axis, &forward_axis);
+	if (fabsf(forward_axis.x) < FLT_EPSILON && fabsf(forward_axis.z) < FLT_EPSILON) {
+		if (forward_axis.y > 0.0f) {
+			to_pvector3(0.0f, 0.0f, -1.0f, &up_axis);
 		} else {
-			to_pvector3(0.0f, 0.0f, 1.0f, &y_axis);
+			to_pvector3(0.0f, 0.0f, 1.0f, &up_axis);
 		}
 	} else {
-		to_pvector3(0.0f, 1.0f, 0.0f, &y_axis);
+		to_pvector3(0.0f, 1.0f, 0.0f, &up_axis);
 	}
-	pvector3_cross(&y_axis, &z_axis, &x_axis);
-	pvector3_normalize(&x_axis, &x_axis);
-	pvector3_cross(&z_axis, &x_axis, &y_axis);
+	pvector3_cross(&forward_axis, &up_axis, &side_axis);
+	pvector3_normalize(&side_axis, &side_axis);
+	pvector3_cross(&side_axis, &forward_axis, &up_axis);
 	pmatrix_identity(result);
-	result->m11 = x_axis.x;
-	result->m12 = x_axis.y;
-	result->m13 = x_axis.z;
-	result->m21 = y_axis.x;
-	result->m22 = y_axis.y;
-	result->m23 = y_axis.z;
-	result->m31 = z_axis.x;
-	result->m32 = z_axis.y;
-	result->m33 = z_axis.z;
-	result->m14 = pvector3_dot(&x_axis, position);
-	result->m24 = pvector3_dot(&y_axis, position);
-	result->m34 = pvector3_dot(&z_axis, position);
+	result->m11 = side_axis.x;
+	result->m12 = side_axis.y;
+	result->m13 = side_axis.z;
+	result->m21 = up_axis.x;
+	result->m22 = up_axis.y;
+	result->m23 = up_axis.z;
+	result->m31 = -forward_axis.x;
+	result->m32 = -forward_axis.y;
+	result->m33 = -forward_axis.z;
+	result->m14 = -pvector3_dot(&side_axis, position);
+	result->m24 = -pvector3_dot(&up_axis, position);
+	result->m34 = pvector3_dot(&forward_axis, position);
 }
 
 MATHC_EXTERN_INLINE struct mat matrix_look_at(struct vec pos, struct vec target)
diff --git a/mathc.h b/mathc.h
index bd0a8bf..050ea0a 100644
--- a/mathc.h
+++ b/mathc.h
@@ -231,14 +231,20 @@ struct vec quaternion_spherical_linear_interpolation(struct vec a, struct vec b,
 /* Matrix */
 void pmatrix_zero(struct mat *result);
 void pmatrix_identity(struct mat *result);
-void pmatrix_ortho(float l, float r, float b, float t, float n, float f, struct mat *result);
-void pmatrix_perspective_fov(float fov, float aspect, float n, float f, struct mat *result);
-void pmatrix_perspective(float l, float r, float t, float b, float n, float f, struct mat *result);
+void pmatrix_ortho_zo(float l, float r, float b, float t, float n, float f, struct mat *result);
+void pmatrix_ortho_no(float l, float r, float b, float t, float n, float f, struct mat *result);
+void pmatrix_ortho(float l, float r, float b, float t, struct mat *result);
+void pmatrix_perspective_zo(float fov_y, float aspect, float n, float f, struct mat *result);
+void pmatrix_perspective_no(float fov_y, float aspect, float n, float f, struct mat *result);
+void pmatrix_perspective_fov_zo(float fov, float w, float h, float n, float f, struct mat *result);
+void pmatrix_perspective_fov_no(float fov, float w, float h, float n, float f, struct mat *result);
+void pmatrix_perspective_infinite(float fov_y, float aspect, float n, struct mat *result);
 void pmatrix_rotation_x(float angle, struct mat *result);
 void pmatrix_rotation_y(float angle, struct mat *result);
 void pmatrix_rotation_z(float angle, struct mat *result);
 void pmatrix_rotation_axis(struct vec *a, float angle, struct mat *result);
 void pmatrix_rotation_quaternion(struct vec *q, struct mat *result);
+void pmatrix_look_at_up(struct vec *pos, struct vec *target, struct vec *up_axis, struct mat *result);
 void pmatrix_look_at(struct vec *pos, struct vec *target, struct mat *result);
 void pmatrix_scale(struct vec *v, struct mat *result);
 void pmatrix_get_scale(struct mat *m, struct vec *result);
@@ -252,14 +258,20 @@ void pmatrix_to_array(struct mat *m, float *result);
 
 struct mat matrix_zero(void);
 struct mat matrix_identity(void);
-struct mat matrix_ortho(float l, float r, float t, float b, float n, float f);
-struct mat matrix_perspective_fov(float fov, float aspect, float n, float f);
-struct mat matrix_perspective(float l, float r, float t, float b, float n, float f);
+struct mat matrix_ortho_zo(float l, float r, float t, float b, float n, float f);
+struct mat matrix_ortho_no(float l, float r, float t, float b, float n, float f);
+struct mat matrix_ortho(float l, float r, float t, float b);
+struct mat matrix_perspective_zo(float fov_y, float aspect, float n, float f);
+struct mat matrix_perspective_no(float fov_y, float aspect, float n, float f);
+struct mat matrix_perspective_fov_zo(float fov, float w, float h, float n, float f);
+struct mat matrix_perspective_fov_no(float fov, float w, float h, float n, float f);
+struct mat matrix_perspective_infinite(float fov_y, float aspect, float n);
 struct mat matrix_rotation_x(float angle);
 struct mat matrix_rotation_y(float angle);
 struct mat matrix_rotation_z(float angle);
 struct mat matrix_rotation_axis(struct vec a, float angle);
 struct mat matrix_rotation_quaternion(struct vec q);
+struct mat matrix_look_at_up(struct vec pos, struct vec target, struct vec up_axis);
 struct mat matrix_look_at(struct vec pos, struct vec target);
 struct mat matrix_scale(struct vec v);
 struct vec matrix_get_scale(struct mat m);

From 41ea8d47460b5020c36b3b669fd7a7a091953347 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 2 Nov 2017 22:20:53 -0300
Subject: [PATCH 025/102] Fix vertical orientation in orthographic function

---
 mathc.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/mathc.c b/mathc.c
index e2e7915..8883ea9 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1425,7 +1425,7 @@ void pmatrix_ortho_zo(float l, float r, float t, float b, float n, float f, stru
 	result->m22 = 2.0f / (t - b);
 	result->m33 = -1.0f / (f - n);
 	result->m14 = -(r + l) / (r - l);
-	result->m24 = -(t + b) / (t - b);
+	result->m24 = -(b + t) / (b - t);
 	result->m34 = -n / (f - n);
 }
 
@@ -1443,7 +1443,7 @@ void pmatrix_ortho_no(float l, float r, float t, float b, float n, float f, stru
 	result->m22 = 2.0f / (t - b);
 	result->m33 = -2.0f / (f - n);
 	result->m14 = -(r + l) / (r - l);
-	result->m24 = -(t + b) / (t - b);
+	result->m24 = -(b + t) / (b - t);
 	result->m34 = -(f + n) / (f - n);
 }
 
@@ -1460,7 +1460,7 @@ void pmatrix_ortho(float l, float r, float t, float b, struct mat *result)
 	result->m11 = 2.0f / (r - l);
 	result->m22 = 2.0f / (t - b);
 	result->m14 = -(r + l) / (r - l);
-	result->m24 = -(t + b) / (t - b);
+	result->m24 = -(b + t) / (b - t);
 }
 
 MATHC_EXTERN_INLINE struct mat matrix_ortho(float l, float r, float t, float b)

From 1066f8fa77d619110ba3aa8a7369c44fea1044f9 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 4 Nov 2017 14:27:48 -0300
Subject: [PATCH 026/102] Fix rotation matrix from axis

---
 mathc.c | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/mathc.c b/mathc.c
index 8883ea9..accac7b 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1635,15 +1635,18 @@ void pmatrix_rotation_axis(struct vec *a, float angle, struct mat *result)
 	float yy = y * y;
 	float yz = y * z;
 	float zz = z * z;
-	result->m11 = c + xx * (one_c);
-	result->m12 = xy * (one_c) - z * s;
-	result->m13 = xz * (one_c) + y * s;
-	result->m21 = xy * (one_c) + z * s;
-	result->m22 = c + yy * (one_c);
-	result->m23 = yz * (one_c) - x * s;
-	result->m31 = xz * (one_c) - y * s;
-	result->m32 = yz * (one_c) + x * s;
-	result->m33 = c + zz * (one_c);
+	float l = xx + yy + zz;
+	float sqrt_l = sqrtf(l);
+	pmatrix_identity(result);
+	result->m11 = (xx + (yy + zz) * c) / l;
+	result->m12 = (xy * one_c - a->z * sqrt_l * s) / l;
+	result->m13 = (xz * one_c + a->y * sqrt_l * s) / l;
+	result->m21 = (xy * one_c + a->z * sqrt_l * s) / l;
+	result->m22 = (yy + (xx + zz) * c) / l;
+	result->m23 = (yz * one_c - a->x * sqrt_l * s) / l;
+	result->m31 = (xz * one_c - a->y * sqrt_l * s) / l;
+	result->m32 = (yz * one_c + a->x * sqrt_l * s) / l;
+	result->m33 = (zz + (xx + yy) * c) / l;
 }
 
 MATHC_EXTERN_INLINE struct mat matrix_rotation_axis(struct vec a, float angle)

From 792d780bc42692b2222abc2f87904bb045764d05 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 4 Nov 2017 14:27:57 -0300
Subject: [PATCH 027/102] Add CONTRIBUTORS.md

---
 CONTRIBUTORS.md | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 CONTRIBUTORS.md

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
new file mode 100644
index 0000000..6b0f4e3
--- /dev/null
+++ b/CONTRIBUTORS.md
@@ -0,0 +1,5 @@
+# Contributors
+
+- [@Randy Gaul](https://github.com/RandyGaul) for helping and giving several suggestions
+- [@barrotsteindev](https://github.com/barrotsteindev) for providing Travis CI integration
+- [Ankush-p](https://github.com/Ankush-p) for fixing `pmatrix_rotation_axis`/`matrix_rotation_axis`

From 17a38b2da4a548ad91caf1552c43cb89e381efc0 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 4 Nov 2017 14:29:53 -0300
Subject: [PATCH 028/102] Update CONTRIBUTORS.md

---
 CONTRIBUTORS.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 6b0f4e3..e390822 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -2,4 +2,4 @@
 
 - [@Randy Gaul](https://github.com/RandyGaul) for helping and giving several suggestions
 - [@barrotsteindev](https://github.com/barrotsteindev) for providing Travis CI integration
-- [Ankush-p](https://github.com/Ankush-p) for fixing `pmatrix_rotation_axis`/`matrix_rotation_axis`
+- [@Ankush-p](https://github.com/Ankush-p) for fixing `pmatrix_rotation_axis`/`matrix_rotation_axis`

From 49848fe9b60bf0227b239e2b5d66ae1f692d3a6d Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 4 Nov 2017 22:40:06 -0300
Subject: [PATCH 029/102] Update README.md

---
 README.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 971eb34..c7559df 100644
--- a/README.md
+++ b/README.md
@@ -24,7 +24,7 @@ There are examples on my other repository using this math library:
 
 Every structure and function uses `float`, because it is the most used type on 2D and 3D programming with OpenGL.
 
-**The type `float` loses precision with large numbers, why not use `double`?** Because every `double` value would be converted to `float` before sending to OpenGL, anyway. Which means your physics would run with high precision, but the rendering would still be affected by the `float` imprecision. Instead, *the good practice* to solve the problem with large numbers is to truncate the world position back to `[0.0f, 0.0f, 0.0f]` when the world distance to the center is too large. If the world is too big that even when truncating there is stil large numbers, the correct approach is to divide the world in chunks.
+**The type `float` loses precision with large numbers, why not use `double`?** Because every `double` value would be converted to `float` before sending to OpenGL, anyway. Which means your physics would run with high precision, but the rendering would still be affected by the `float` imprecision. Instead, *the good practice* to solve the problem with large numbers is to truncate the world position back to `[0.0f, 0.0f, 0.0f]` when the world distance to the center is too large. If the world is too big that even when truncating there are stil large numbers, the correct approach is to divide the world in chunks.
 
 # Passing Arguments as Value or Pointer
 
@@ -36,7 +36,7 @@ Examples:
 
 ```c
 /* Pass by value and return a value */
-struct mat projection = matrix_ortho(-100.0f, 100.0f, -100.0f, 100.0f, 0.0f, 1.0f);
+struct mat projection = matrix_ortho(-100.0f, 100.0f, 100.0f, -100.0f);
 struct mat view = matrix_look_at(to_vector3(0.0f, 0.0f, 1.0f),
 	to_vector3(0.0f, 0.0f, 0.0f));
 struct mat pv = matrix_multiply_matrix(projection, view);
@@ -51,7 +51,7 @@ struct mat multiplied_matrix = {0};
 to_pvector3(0.0f, 0.0f, 1.0f, &pos);
 to_pvector3(0.0f, 0.0f, 0.0f, &target);
 to_pvector3(0.0f, 1.0f, 0.0f, &up);
-pmatrix_ortho(-100.0f, 100.0f, -100.0f, 100.0f, 0.0f, 1.0f, &projection);
+pmatrix_ortho(-100.0f, 100.0f, 100.0f, -100.0f, &projection);
 pmatrix_look_at(&pos, &target, &view);
 pmatrix_multiply_matrix(&projection, &view, &multiplied_matrix);
 ```

From 649d0dae8aa755164396500164f128d369282450 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Wed, 8 Nov 2017 21:35:38 -0300
Subject: [PATCH 030/102] Add functions to get matrix transpose and inverse

---
 CONTRIBUTORS.md |   1 +
 REFERENCE.md    |  14 +++++
 mathc.c         | 157 ++++++++++++++++++++++++++++++++++++++++++++++++
 mathc.h         |   4 ++
 4 files changed, 176 insertions(+)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index e390822..f028857 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -3,3 +3,4 @@
 - [@Randy Gaul](https://github.com/RandyGaul) for helping and giving several suggestions
 - [@barrotsteindev](https://github.com/barrotsteindev) for providing Travis CI integration
 - [@Ankush-p](https://github.com/Ankush-p) for fixing `pmatrix_rotation_axis`/`matrix_rotation_axis`
+- [@Ankush-p](https://github.com/Ankush-p) for adding `pmatrix_transpose`/`matrix_transpose` and `pmatrix_inverse`/`matrix_inverse`
diff --git a/REFERENCE.md b/REFERENCE.md
index 953f515..1576e69 100644
--- a/REFERENCE.md
+++ b/REFERENCE.md
@@ -596,6 +596,20 @@ struct mat matrix_identity(void);
 
 The result is a identity matrix.
 
+```c
+void pmatrix_transpose(struct mat *m, struct mat *result);
+struct mat matrix_transpose(struct mat m);
+```
+
+The result is the transpose of the matrix `m`.
+
+```c
+void pmatrix_inverse(struct mat *m, struct mat *result);
+struct mat matrix_inverse(struct mat m);
+```
+
+The result is the inverse of the matrix `m`.
+
 ```c
 void pmatrix_ortho_zo(float l, float r, float b, float t, float n, float f, struct mat *result);
 struct mat matrix_ortho_zo(float l, float r, float b, float t, float n, float f);
diff --git a/mathc.c b/mathc.c
index accac7b..4695986 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1418,6 +1418,163 @@ MATHC_EXTERN_INLINE struct mat matrix_identity(void)
 	return result;
 }
 
+void pmatrix_transpose(struct mat *m, struct mat *result)
+{
+	result->m11 = m->m11;
+	result->m21 = m->m12;
+	result->m31 = m->m13;
+	result->m41 = m->m14;
+	result->m12 = m->m21;
+	result->m22 = m->m22;
+	result->m32 = m->m23;
+	result->m42 = m->m24;
+	result->m13 = m->m31;
+	result->m23 = m->m32;
+	result->m33 = m->m33;
+	result->m43 = m->m34;
+	result->m14 = m->m41;
+	result->m24 = m->m42;
+	result->m34 = m->m43;
+	result->m44 = m->m44;
+}
+
+struct mat matrix_transpose(struct mat m)
+{
+	struct mat result;
+	pmatrix_transpose(&m, &result);
+	return result;
+}
+
+void pmatrix_inverse(struct mat *m, struct mat *result)
+{
+	struct mat inv;
+	float det;
+	inv.m11 = m->m22 * m->m33 * m->m44 -
+		m->m22 * m->m43 * m->m34 -
+		m->m23 * m->m32 * m->m44 +
+		m->m23 * m->m42 * m->m34 +
+		m->m24 * m->m32 * m->m43 -
+		m->m24 * m->m42 * m->m33;
+	inv.m12 = -m->m12 * m->m33 * m->m44 +
+		m->m12 * m->m43 * m->m34 +
+		m->m13 * m->m32 * m->m44 -
+		m->m13 * m->m42 * m->m34 -
+		m->m14 * m->m32 * m->m43 +
+		m->m14 * m->m42 * m->m33;
+	inv.m13 = m->m12 * m->m23 * m->m44 -
+		m->m12 * m->m43 * m->m24 -
+		m->m13 * m->m22 * m->m44 +
+		m->m13 * m->m42 * m->m24 +
+		m->m14 * m->m22 * m->m43 -
+		m->m14 * m->m42 * m->m23;
+	inv.m14 = -m->m12 * m->m23 * m->m34 +
+		m->m12 * m->m33 * m->m24 +
+		m->m13 * m->m22 * m->m34 -
+		m->m13 * m->m32 * m->m24 -
+		m->m14 * m->m22 * m->m33 +
+		m->m14 * m->m32 * m->m23;
+	inv.m21 = -m->m21 * m->m33 * m->m44 +
+		m->m21 * m->m43 * m->m34 +
+		m->m23 * m->m31 * m->m44 -
+		m->m23 * m->m41 * m->m34 -
+		m->m24 * m->m31 * m->m43 +
+		m->m24 * m->m41 * m->m33;
+	inv.m22 = m->m11 * m->m33 * m->m44 -
+		m->m11 * m->m43 * m->m34 -
+		m->m13 * m->m31 * m->m44 +
+		m->m13 * m->m41 * m->m34 +
+		m->m14 * m->m31 * m->m43 -
+		m->m14 * m->m41 * m->m33;
+	inv.m23 = -m->m11 * m->m23 * m->m44 +
+		m->m11 * m->m43 * m->m24 +
+		m->m13 * m->m21 * m->m44 -
+		m->m13 * m->m41 * m->m24 -
+		m->m14 * m->m21 * m->m43 +
+		m->m14 * m->m41 * m->m23;
+	inv.m24 = m->m11 * m->m23 * m->m34 -
+		m->m11 * m->m33 * m->m24 -
+		m->m13 * m->m21 * m->m34 +
+		m->m13 * m->m31 * m->m24 +
+		m->m14 * m->m21 * m->m33 -
+		m->m14 * m->m31 * m->m23;
+	inv.m31 = m->m21 * m->m32 * m->m44 -
+		m->m21 * m->m42 * m->m34 -
+		m->m22 * m->m31 * m->m44 +
+		m->m22 * m->m41 * m->m34 +
+		m->m24 * m->m31 * m->m42 -
+		m->m24 * m->m41 * m->m32;
+	inv.m32 = -m->m11 * m->m32 * m->m44 +
+		m->m11 * m->m42 * m->m34 +
+		m->m12 * m->m31 * m->m44 -
+		m->m12 * m->m41 * m->m34 -
+		m->m14 * m->m31 * m->m42 +
+		m->m14 * m->m41 * m->m32;
+	inv.m33 = m->m11 * m->m22 * m->m44 -
+		m->m11 * m->m42 * m->m24 -
+		m->m12 * m->m21 * m->m44 +
+		m->m12 * m->m41 * m->m24 +
+		m->m14 * m->m21 * m->m42 -
+		m->m14 * m->m41 * m->m22;
+	inv.m34 = -m->m11 * m->m22 * m->m34 +
+		m->m11 * m->m32 * m->m24 +
+		m->m12 * m->m21 * m->m34 -
+		m->m12 * m->m31 * m->m24 -
+		m->m14 * m->m21 * m->m32 +
+		m->m14 * m->m31 * m->m22;
+	inv.m41 = -m->m21 * m->m32 * m->m43 +
+		m->m21 * m->m42 * m->m33 +
+		m->m22 * m->m31 * m->m43 -
+		m->m22 * m->m41 * m->m33 -
+		m->m23 * m->m31 * m->m42 +
+		m->m23 * m->m41 * m->m32;
+	inv.m42 = m->m11 * m->m32 * m->m43 -
+		m->m11 * m->m42 * m->m33 -
+		m->m12 * m->m31 * m->m43 +
+		m->m12 * m->m41 * m->m33 +
+		m->m13 * m->m31 * m->m42 -
+		m->m13 * m->m41 * m->m32;
+	inv.m43 = -m->m11 * m->m22 * m->m43 +
+		m->m11 * m->m42 * m->m23 +
+		m->m12 * m->m21 * m->m43 -
+		m->m12 * m->m41 * m->m23 -
+		m->m13 * m->m21 * m->m42 +
+		m->m13 * m->m41 * m->m22;
+	inv.m44 = m->m11 * m->m22 * m->m33 -
+		m->m11 * m->m32 * m->m23 -
+		m->m12 * m->m21 * m->m33 +
+		m->m12 * m->m31 * m->m23 +
+		m->m13 * m->m21 * m->m32 -
+		m->m13 * m->m31 * m->m22;
+	det = m->m11 * inv.m11 + m->m21 * inv.m12 + m->m31 * inv.m13 + m->m41 * inv.m14;
+	/* Matrix can not be inverted if det == 0 */
+	if (det != 0) {
+		det = 1.0 / det;
+	}
+	result->m11 = inv.m11 * det;
+	result->m21 = inv.m21 * det;
+	result->m31 = inv.m31 * det;
+	result->m41 = inv.m41 * det;
+	result->m12 = inv.m12 * det;
+	result->m22 = inv.m22 * det;
+	result->m32 = inv.m32 * det;
+	result->m42 = inv.m42 * det;
+	result->m13 = inv.m13 * det;
+	result->m23 = inv.m23 * det;
+	result->m33 = inv.m33 * det;
+	result->m43 = inv.m43 * det;
+	result->m14 = inv.m14 * det;
+	result->m24 = inv.m24 * det;
+	result->m34 = inv.m34 * det;
+	result->m44 = inv.m44 * det;
+}
+
+struct mat matrix_inverse(struct mat m)
+{
+	struct mat result;
+	pmatrix_inverse(&m, &result);
+	return result;
+}
+
 void pmatrix_ortho_zo(float l, float r, float t, float b, float n, float f, struct mat *result)
 {
 	pmatrix_identity(result);
diff --git a/mathc.h b/mathc.h
index 050ea0a..495eb0b 100644
--- a/mathc.h
+++ b/mathc.h
@@ -231,6 +231,8 @@ struct vec quaternion_spherical_linear_interpolation(struct vec a, struct vec b,
 /* Matrix */
 void pmatrix_zero(struct mat *result);
 void pmatrix_identity(struct mat *result);
+void pmatrix_transpose(struct mat *m, struct mat *result);
+void pmatrix_inverse(struct mat *m, struct mat *result);
 void pmatrix_ortho_zo(float l, float r, float b, float t, float n, float f, struct mat *result);
 void pmatrix_ortho_no(float l, float r, float b, float t, float n, float f, struct mat *result);
 void pmatrix_ortho(float l, float r, float b, float t, struct mat *result);
@@ -258,6 +260,8 @@ void pmatrix_to_array(struct mat *m, float *result);
 
 struct mat matrix_zero(void);
 struct mat matrix_identity(void);
+struct mat matrix_transpose(struct mat m);
+struct mat matrix_inverse(struct mat m);
 struct mat matrix_ortho_zo(float l, float r, float t, float b, float n, float f);
 struct mat matrix_ortho_no(float l, float r, float t, float b, float n, float f);
 struct mat matrix_ortho(float l, float r, float t, float b);

From b9bb644638c9d3656e0ab757bac727fc621a1e5d Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Wed, 8 Nov 2017 22:01:42 -0300
Subject: [PATCH 031/102] Update README.md example

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index c7559df..e9b3535 100644
--- a/README.md
+++ b/README.md
@@ -96,7 +96,7 @@ matrix_multiply_f4(rotation, v);
 If you want to modify on GPU-side, you can use the functions `matrix_to_array()` or `pmatrix_to_array()` to push the matrix to an array with 16 `float` elements. Example:
 
 ```c
-float v[16];
+float v[MAT_SIZE]; /* MAT_SIZE is a macro in mathc.h with value 16 */
 struct mat projection = matrix_ortho(-100.0f, 100.0f, -100.0f, 100.0f, 0.0f, 1.0f);
 struct mat view = matrix_look_at(to_vector3(0.0f, 0.0f, 1.0f),
 	to_vector3(0.0f, 0.0f, 0.0f));

From 0af7ca479844cf9e68dc68900aadf69723680d59 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Wed, 8 Nov 2017 22:13:33 -0300
Subject: [PATCH 032/102] Add macros explanation in REFERENCE.md

---
 REFERENCE.md | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/REFERENCE.md b/REFERENCE.md
index 1576e69..cf1435a 100644
--- a/REFERENCE.md
+++ b/REFERENCE.md
@@ -2,6 +2,18 @@
 
 ## Utils
 
+```c
+#define M_PIF 3.1415926536f
+#define M_PIF_2 1.5707963268f
+#define MAT_SIZE 16
+```
+
+These are "syntactic sugar" macros that might be useful for the user.
+
+The `M_PIF` is the `float` value of Pi, and `M_PIF_2` is the `float` value of Pi divided by `2`. The macros `M_PI` and `M_PI_2` are not part of the C standard, and for that reason they are added here.
+
+The `MAT_SIZE` is more often useful, that allows the user to declare an array with the correct number of elements (`16`) of a 4x4 matrix instead of writing a [magic number](https://en.wikipedia.org/wiki/Magic_number_\(programming\)#Unnamed_numerical_constants) in the code.
+
 ```c
 int nearly_equal(float a, float b, float epsilon);
 ```

From 899beb415e81c834886717de68101945fa094b7b Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 9 Nov 2017 04:05:45 -0300
Subject: [PATCH 033/102] Update CONTRIBUTOR.md

---
 CONTRIBUTORS.md | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index f028857..e6d8e56 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -1,6 +1,8 @@
 # Contributors
 
-- [@Randy Gaul](https://github.com/RandyGaul) for helping and giving several suggestions
-- [@barrotsteindev](https://github.com/barrotsteindev) for providing Travis CI integration
-- [@Ankush-p](https://github.com/Ankush-p) for fixing `pmatrix_rotation_axis`/`matrix_rotation_axis`
+Thank you...
+
 - [@Ankush-p](https://github.com/Ankush-p) for adding `pmatrix_transpose`/`matrix_transpose` and `pmatrix_inverse`/`matrix_inverse`
+- [@Ankush-p](https://github.com/Ankush-p) for fixing `pmatrix_rotation_axis`/`matrix_rotation_axis`
+- [@barrotsteindev](https://github.com/barrotsteindev) for providing Travis CI integration
+- [@Randy Gaul](https://github.com/RandyGaul) for helping and giving several suggestions

From bc9ff217bf0f9d42fc16f47750b548b3a120bc67 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 9 Nov 2017 04:44:31 -0300
Subject: [PATCH 034/102] Update CONTRIBUTORS.md

---
 CONTRIBUTORS.md | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index e6d8e56..ea61482 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -1,8 +1,6 @@
 # Contributors
 
-Thank you...
-
-- [@Ankush-p](https://github.com/Ankush-p) for adding `pmatrix_transpose`/`matrix_transpose` and `pmatrix_inverse`/`matrix_inverse`
-- [@Ankush-p](https://github.com/Ankush-p) for fixing `pmatrix_rotation_axis`/`matrix_rotation_axis`
-- [@barrotsteindev](https://github.com/barrotsteindev) for providing Travis CI integration
-- [@Randy Gaul](https://github.com/RandyGaul) for helping and giving several suggestions
+- [@Ankush-p](https://github.com/Ankush-p) added `pmatrix_transpose`/`matrix_transpose` and `pmatrix_inverse`/`matrix_inverse`
+- [@Ankush-p](https://github.com/Ankush-p) fixed `pmatrix_rotation_axis`/`matrix_rotation_axis`
+- [@barrotsteindev](https://github.com/barrotsteindev) added Travis CI integration
+- [@Randy Gaul](https://github.com/RandyGaul) helped giving useful suggestions

From 99d001af5d494fda9170f31a3c424c5ad4379926 Mon Sep 17 00:00:00 2001
From: Cong <congusbongus@gmail.com>
Date: Fri, 10 Nov 2017 02:52:47 +0800
Subject: [PATCH 035/102] Fix subtract typos

---
 REFERENCE.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/REFERENCE.md b/REFERENCE.md
index cf1435a..d0a599b 100644
--- a/REFERENCE.md
+++ b/REFERENCE.md
@@ -80,7 +80,7 @@ void pvector2_subtract(struct vec *a, struct vec *b, struct vec *result);
 struct vec vector2_subtract(struct vec a, struct vec b);
 ```
 
-The result is a 2D vector for the subraction of the 2D vector `a` with the 2D vector `b`.
+The result is a 2D vector for the subtraction of the 2D vector `a` with the 2D vector `b`.
 
 ```c
 void pvector2_scale(struct vec *a, float scale, struct vec *result);
@@ -266,7 +266,7 @@ void pvector3_subtract(struct vec *a, struct vec *b, struct vec *result);
 struct vec vector3_subtract(struct vec a, struct vec b);
 ```
 
-The result is a 3D vector for the subraction of the 3D vector `a` with the 3D vector `b`.
+The result is a 3D vector for the subtraction of the 3D vector `a` with the 3D vector `b`.
 
 ```c
 void pvector3_scale(struct vec *a, float scale, struct vec *result);
@@ -436,7 +436,7 @@ void pquaternion_subtract(struct vec *a, struct vec *b, struct vec *result);
 struct vec quaternion_subtract(struct vec a, struct vec b);
 ```
 
-The result is a quaternion for the subraction of the quaternion `a` with the quaternion `b`.
+The result is a quaternion for the subtraction of the quaternion `a` with the quaternion `b`.
 
 ```c
 void pquaternion_scale(struct vec *a, float scale, struct vec *result);

From 8a424e42da0745190678aa28b6fc63aad86ba8cb Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 9 Nov 2017 17:30:05 -0300
Subject: [PATCH 036/102] Update CONTRIBUTORS.md

---
 CONTRIBUTORS.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index ea61482..0b38f82 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -1,5 +1,6 @@
 # Contributors
 
+- [@cxong](https://github.com/cxong) fixed typos in `REFERENCE.md`
 - [@Ankush-p](https://github.com/Ankush-p) added `pmatrix_transpose`/`matrix_transpose` and `pmatrix_inverse`/`matrix_inverse`
 - [@Ankush-p](https://github.com/Ankush-p) fixed `pmatrix_rotation_axis`/`matrix_rotation_axis`
 - [@barrotsteindev](https://github.com/barrotsteindev) added Travis CI integration

From 2ff96eaf29007e51b33d5a92b3500d7e48de6c01 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 9 Nov 2017 17:37:35 -0300
Subject: [PATCH 037/102] Add function to return zeroed vectors

---
 REFERENCE.md | 21 +++++++++++++++++++++
 mathc.c      | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 mathc.h      |  5 +++++
 3 files changed, 72 insertions(+)

diff --git a/REFERENCE.md b/REFERENCE.md
index d0a599b..509f60e 100644
--- a/REFERENCE.md
+++ b/REFERENCE.md
@@ -68,6 +68,13 @@ struct vec to_vector2(float x, float y);
 
 The result is a 2D vector for the position `x` and `y`. The value of `z` is set to `0.0f`.
 
+```c
+void pvector2_zero(struct vec *result);
+struct vec vector2_zero(void);
+```
+
+The result is a zeroed 2D vector.
+
 ```c
 void pvector2_add(struct vec *a, struct vec *b, struct vec *result);
 struct vec vector2_add(struct vec a, struct vec b);
@@ -254,6 +261,13 @@ struct vec to_vector2(float x, float y, float z);
 
 The result is a 3D vector for the position `x`, `y` and `z`.
 
+```c
+void pvector3_zero(struct vec *result);
+struct vec vector3_zero(void);
+```
+
+The result is a zeroed 3D vector.
+
 ```c
 void pvector3_add(struct vec *a, struct vec *b, struct vec *result);
 struct vec vector3_add(struct vec a, struct vec b);
@@ -424,6 +438,13 @@ struct vec to_quaternion(float x, float y, float z);
 
 The result is a quaternion for the position `x`, `y` and `z`.
 
+```c
+void pquaternion_zero(struct vec *result);
+struct vec quaternion_zero();
+```
+
+The result is a zeroed quaternion.
+
 ```c
 void pquaternion_add(struct vec *a, struct vec *b, struct vec *result);
 struct vec quaternion_add(struct vec a, struct vec b);
diff --git a/mathc.c b/mathc.c
index 4695986..ea9a94c 100644
--- a/mathc.c
+++ b/mathc.c
@@ -89,6 +89,21 @@ MATHC_EXTERN_INLINE struct vec to_vector2(float x, float y)
 	return result;
 }
 
+void pvector2_zero(struct vec *result)
+{
+	result->x = 0.0f;
+	result->y = 0.0f;
+	result->z = 0.0f;
+	result->w = 0.0f;
+}
+
+MATHC_EXTERN_INLINE struct vec vector2_zero(void)
+{
+	struct vec result;
+	pvector2_zero(&result);
+	return result;
+}
+
 void pvector2_add(struct vec *a, struct vec *b, struct vec *result)
 {
 	result->x = a->x + b->x;
@@ -490,6 +505,21 @@ MATHC_EXTERN_INLINE struct vec to_vector3(float x, float y, float z)
 	return result;
 }
 
+void pvector3_zero(struct vec *result)
+{
+	result->x = 0.0f;
+	result->y = 0.0f;
+	result->z = 0.0f;
+	result->w = 0.0f;
+}
+
+MATHC_EXTERN_INLINE struct vec vector3_zero(void)
+{
+	struct vec result;
+	pvector3_zero(&result);
+	return result;
+}
+
 void pvector3_add(struct vec *a, struct vec *b, struct vec *result)
 {
 	result->x = a->x + b->x;
@@ -886,6 +916,22 @@ struct vec to_quaternion(float x, float y, float z, float w)
 	return result;
 }
 
+
+void pquaternion_zero(struct vec *result)
+{
+	result->x = 0.0f;
+	result->y = 0.0f;
+	result->z = 0.0f;
+	result->w = 0.0f;
+}
+
+MATHC_EXTERN_INLINE struct vec quaternion_zero(void)
+{
+	struct vec result;
+	pquaternion_zero(&result);
+	return result;
+}
+
 void pquaternion_add(struct vec *a, struct vec *b, struct vec *result)
 {
 	result->x = a->x + b->x;
diff --git a/mathc.h b/mathc.h
index 495eb0b..0a36db0 100644
--- a/mathc.h
+++ b/mathc.h
@@ -59,6 +59,7 @@ float to_degrees(float radians);
 
 /* Vector 2D */
 void to_pvector2(float x, float y, struct vec *result);
+void pvector2_zero(struct vec *result);
 void pvector2_add(struct vec *a, struct vec *b, struct vec *result);
 void pvector2_subtract(struct vec *a, struct vec *b, struct vec *result);
 void pvector2_scale(struct vec *a, float scale, struct vec *result);
@@ -88,6 +89,7 @@ void pvector2_bezier3(struct vec *a, struct vec *b, struct vec *c, float p, stru
 void pvector2_bezier4(struct vec *a, struct vec *b, struct vec *c, struct vec *d, float p, struct vec *result);
 
 struct vec to_vector2(float x, float y);
+struct vec vector2_zero(void);
 struct vec vector2_add(struct vec a, struct vec b);
 struct vec vector2_subtract(struct vec a, struct vec b);
 struct vec vector2_scale(struct vec a, float scale);
@@ -118,6 +120,7 @@ struct vec vector2_bezier4(struct vec a, struct vec b, struct vec c, struct vec
 
 /* Vector 3D */
 void to_pvector3(float x, float y, float z, struct vec *result);
+void pvector3_zero(struct vec *result);
 void pvector3_add(struct vec *a, struct vec *b, struct vec *result);
 void pvector3_subtract(struct vec *a, struct vec *b, struct vec *result);
 void pvector3_scale(struct vec *a, float scale, struct vec *result);
@@ -173,6 +176,7 @@ struct vec vector3_bezier4(struct vec a, struct vec b, struct vec c, struct vec
 
 /* Quaternion */
 void to_pquaternion(float x, float y, float z, float w, struct vec *result);
+void pquaternion_zero(struct vec *result);
 void pquaternion_add(struct vec *a, struct vec *b, struct vec *result);
 void pquaternion_subtract(struct vec *a, struct vec *b, struct vec *result);
 void pquaternion_scale(struct vec *a, float scale, struct vec *result);
@@ -201,6 +205,7 @@ void pquaternion_linear_interpolation(struct vec *a, struct vec *b, float p, str
 void pquaternion_spherical_linear_interpolation(struct vec *a, struct vec *b, float p, struct vec *result);
 
 struct vec to_quaternion(float x, float y, float z, float w);
+struct vec quaternion_zero(void);
 struct vec quaternion_add(struct vec a, struct vec b);
 struct vec quaternion_subtract(struct vec a, struct vec b);
 struct vec quaternion_scale(struct vec a, float scale);

From 9541b76b4623bb4594176e445e93b589b5ef54f5 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 9 Nov 2017 17:38:23 -0300
Subject: [PATCH 038/102] Update CONTRIBUTORS.md

---
 CONTRIBUTORS.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 0b38f82..0d55f70 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -1,5 +1,6 @@
 # Contributors
 
+- [@cxong](https://github.com/cxong) suggested function to return zeroed vectors
 - [@cxong](https://github.com/cxong) fixed typos in `REFERENCE.md`
 - [@Ankush-p](https://github.com/Ankush-p) added `pmatrix_transpose`/`matrix_transpose` and `pmatrix_inverse`/`matrix_inverse`
 - [@Ankush-p](https://github.com/Ankush-p) fixed `pmatrix_rotation_axis`/`matrix_rotation_axis`

From b247ac865e083bf8fb7f5fc3927ef89289891db0 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Fri, 10 Nov 2017 21:37:39 -0300
Subject: [PATCH 039/102] Add CHANGELOG.md

---
 CHANGELOG.md | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 CHANGELOG.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..bdb0ff2
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,11 @@
+# Changelog
+
+All notable changes to this project will be documented in this file, following semantic versioning.
+
+## Unreleased
+
+## 0.1.0 - 2017-11-11
+
+### Added
+
+- This CHANGELOG file.

From 09af764e00b574cd4384c31d2227dee958e9613b Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 11 Nov 2017 08:55:13 -0300
Subject: [PATCH 040/102] Update projection matrices

---
 REFERENCE.md | 46 +++++--------------------
 mathc.c      | 95 +++++++---------------------------------------------
 mathc.h      | 20 ++++-------
 3 files changed, 28 insertions(+), 133 deletions(-)

diff --git a/REFERENCE.md b/REFERENCE.md
index 509f60e..f1a2617 100644
--- a/REFERENCE.md
+++ b/REFERENCE.md
@@ -644,53 +644,25 @@ struct mat matrix_inverse(struct mat m);
 The result is the inverse of the matrix `m`.
 
 ```c
-void pmatrix_ortho_zo(float l, float r, float b, float t, float n, float f, struct mat *result);
-struct mat matrix_ortho_zo(float l, float r, float b, float t, float n, float f);
+void pmatrix_ortho(float l, float r, float b, float t, float n, float f, struct mat *result);
+struct mat matrix_ortho(float l, float r, float b, float t, float n, float f);
 ```
 
-The result is a orthographic projection matrix with depth from zero to one, left `l`, right `r`, bottom `b` top `t`, near clipping `n` and far clipping `f`.
+The result is a orthographic projection matrix with left `l`, right `r`, bottom `b` top `t`, near clipping `n` and far clipping `f`.
 
 ```c
-void pmatrix_ortho_no(float l, float r, float b, float t, float n, float f, struct mat *result);
-struct mat matrix_ortho_no(float l, float r, float b, float t, float n, float f);
+void pmatrix_perspective(float fov_y, float aspect, float n, float f, struct mat *result);
+struct mat matrix_perspective(float fov_y, float aspect, float n, float f);
 ```
 
-The result is a orthographic projection matrix with depth from negatie one to one, left `l`, right `r`, bottom `b` top `t`, near clipping `n` and far clipping `f`.
+The result is a perspective projection matrix with field of view of Y axis `fov_y`, in radians, aspect ratio `aspect`, near clipping `n` and far clipping `f`.
 
 ```c
-void pmatrix_ortho(float l, float r, float b, float t, struct mat *result);
-struct mat matrix_ortho(float l, float r, float b, float t);
+void pmatrix_perspective_fov(float fov, float w, float h, float n, float f, struct mat *result);
+struct mat matrix_perspective_fov(float fov, float w, float h, float n, float f);
 ```
 
-The result is a orthographic projection matrix with the left `l`, right `r`, bottom `b`, and top `t`.
-
-```c
-void pmatrix_perspective_zo(float fov_y, float aspect, float n, float f, struct mat *result);
-struct mat matrix_perspective_zo(float fov_y, float aspect, float n, float f);
-```
-
-The result is a perspective projection matrix with depth from zero to one, field of view of Y axis `fov_y`, in radians, aspect ratio `aspect`, near clipping `n` and far clipping `f`.
-
-```c
-void pmatrix_perspective_no(float fov_y, float aspect, float n, float f, struct mat *result);
-struct mat matrix_perspective_no(float fov_y, float aspect, float n, float f);
-```
-
-The result is a perspective projection matrix with depth from negative one to one, field of view of Y axis `fov_y`, in radians, aspect ratio `aspect`, near clipping `n` and far clipping `f`.
-
-```c
-void pmatrix_perspective_fov_zo(float fov, float w, float h, float n, float f, struct mat *result);
-struct mat matrix_perspective_fov_zo(float fov, float w, float h, float n, float f);
-```
-
-The result is a perspective projection matrix with depth from zero to one, field of view `fov`, width `w`, height `h`, near clipping `n` and far clipping `f`.
-
-```c
-void pmatrix_perspective_fov_no(float fov, float w, float h, float n, float f, struct mat *result);
-struct mat matrix_perspective_fov_no(float fov, float w, float h, float n, float f);
-```
-
-The result is a perspective projection matrix with depth from negatve one to one, field of view `fov`, width `w`, height `h`, near clipping `n` and far clipping `f`.
+The result is a perspective projection matrix with field of view `fov`, width `w`, height `h`, near clipping `n` and far clipping `f`.
 
 ```c
 void pmatrix_perspective_infinite(float fov_y, float aspect, float n, struct mat *result);
diff --git a/mathc.c b/mathc.c
index ea9a94c..288fd28 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1621,59 +1621,27 @@ struct mat matrix_inverse(struct mat m)
 	return result;
 }
 
-void pmatrix_ortho_zo(float l, float r, float t, float b, float n, float f, struct mat *result)
-{
-	pmatrix_identity(result);
-	result->m11 = 2.0f / (r - l);
-	result->m22 = 2.0f / (t - b);
-	result->m33 = -1.0f / (f - n);
-	result->m14 = -(r + l) / (r - l);
-	result->m24 = -(b + t) / (b - t);
-	result->m34 = -n / (f - n);
-}
-
-MATHC_EXTERN_INLINE struct mat matrix_ortho_zo(float l, float r, float t, float b, float n, float f)
-{
-	struct mat result;
-	pmatrix_ortho_zo(l, r, b, t, n, f, &result);
-	return result;
-}
+#include <stdio.h>
 
-void pmatrix_ortho_no(float l, float r, float t, float b, float n, float f, struct mat *result)
+void pmatrix_ortho(float l, float r, float b, float t, float n, float f, struct mat *result)
 {
 	pmatrix_identity(result);
 	result->m11 = 2.0f / (r - l);
 	result->m22 = 2.0f / (t - b);
 	result->m33 = -2.0f / (f - n);
-	result->m14 = -(r + l) / (r - l);
-	result->m24 = -(b + t) / (b - t);
-	result->m34 = -(f + n) / (f - n);
-}
-
-MATHC_EXTERN_INLINE struct mat matrix_ortho_no(float l, float r, float t, float b, float n, float f)
-{
-	struct mat result;
-	pmatrix_ortho_no(l, r, b, t, n, f, &result);
-	return result;
-}
-
-void pmatrix_ortho(float l, float r, float t, float b, struct mat *result)
-{
-	pmatrix_identity(result);
-	result->m11 = 2.0f / (r - l);
-	result->m22 = 2.0f / (t - b);
-	result->m14 = -(r + l) / (r - l);
-	result->m24 = -(b + t) / (b - t);
+	result->m14 = -((r + l) / (r - l));
+	result->m24 = -((t + b) / (t - b));
+	result->m34 = -((f + n) / (f - n));
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_ortho(float l, float r, float t, float b)
+MATHC_EXTERN_INLINE struct mat matrix_ortho(float l, float r, float b, float t, float n, float f)
 {
 	struct mat result;
-	pmatrix_ortho(l, r, b, t, &result);
+	pmatrix_ortho(l, r, b, t, n, f, &result);
 	return result;
 }
 
-void pmatrix_perspective_zo(float fov_y, float aspect, float n, float f, struct mat *result)
+void pmatrix_perspective(float fov_y, float aspect, float n, float f, struct mat *result)
 {
 	const float tan_half_fov_y = 1.0f / tanf(fov_y * 0.5f);
 	pmatrix_zero(result);
@@ -1684,32 +1652,14 @@ void pmatrix_perspective_zo(float fov_y, float aspect, float n, float f, struct
 	result->m34 = -(f * n) / (f - n);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_perspective_zo(float fov_y, float aspect, float n, float f)
-{
-	struct mat result;
-	pmatrix_perspective_zo(fov_y, aspect, n, f, &result);
-	return result;
-}
-
-void pmatrix_perspective_no(float fov_y, float aspect, float n, float f, struct mat *result)
-{
-	const float tan_half_fov_y = 1.0f / tanf(fov_y * 0.5f);
-	pmatrix_zero(result);
-	result->m11 = 1.0f / aspect * tan_half_fov_y;
-	result->m22 = 1.0f / tan_half_fov_y;
-	result->m33 = -(f + n) / (f - n);
-	result->m43 = -1.0f;
-	result->m34 = -(2.0f * f * n) / (f - n);
-}
-
-MATHC_EXTERN_INLINE struct mat matrix_perspective_no(float fov_y, float aspect, float n, float f)
+MATHC_EXTERN_INLINE struct mat matrix_perspective(float fov_y, float aspect, float n, float f)
 {
 	struct mat result;
-	pmatrix_perspective_no(fov_y, aspect, n, f, &result);
+	pmatrix_perspective(fov_y, aspect, n, f, &result);
 	return result;
 }
 
-void pmatrix_perspective_fov_zo(float fov, float w, float h, float n, float f, struct mat *result)
+void pmatrix_perspective_fov(float fov, float w, float h, float n, float f, struct mat *result)
 {
 	const float h2 = cosf(fov * 0.5f) / sinf(fov * 0.5f);
 	const float w2 = h2 * h / w;
@@ -1721,29 +1671,10 @@ void pmatrix_perspective_fov_zo(float fov, float w, float h, float n, float f, s
 	result->m34 = -(f * n) / (f - n);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_perspective_fov_zo(float fov, float w, float h, float n, float f)
-{
-	struct mat result;
-	pmatrix_perspective_fov_zo(fov, w, h, n, f, &result);
-	return result;
-}
-
-void pmatrix_perspective_fov_no(float fov, float w, float h, float n, float f, struct mat *result)
-{
-	const float h2 = cosf(fov * 0.5f) / sinf(fov * 0.5f);
-	const float w2 = h2 * h / w;
-	pmatrix_zero(result);
-	result->m11 = w2;
-	result->m22 = h2;
-	result->m33 = -(f + n) / (f - n);
-	result->m43 = -1.0f;
-	result->m34 = -(2.0f * f * n) / (f - n);
-}
-
-MATHC_EXTERN_INLINE struct mat matrix_perspective_fov_no(float fov, float w, float h, float n, float f)
+MATHC_EXTERN_INLINE struct mat matrix_perspective_fov(float fov, float w, float h, float n, float f)
 {
 	struct mat result;
-	pmatrix_perspective_fov_no(fov, w, h, n, f, &result);
+	pmatrix_perspective_fov(fov, w, h, n, f, &result);
 	return result;
 }
 
diff --git a/mathc.h b/mathc.h
index 0a36db0..05d771d 100644
--- a/mathc.h
+++ b/mathc.h
@@ -238,13 +238,9 @@ void pmatrix_zero(struct mat *result);
 void pmatrix_identity(struct mat *result);
 void pmatrix_transpose(struct mat *m, struct mat *result);
 void pmatrix_inverse(struct mat *m, struct mat *result);
-void pmatrix_ortho_zo(float l, float r, float b, float t, float n, float f, struct mat *result);
-void pmatrix_ortho_no(float l, float r, float b, float t, float n, float f, struct mat *result);
-void pmatrix_ortho(float l, float r, float b, float t, struct mat *result);
-void pmatrix_perspective_zo(float fov_y, float aspect, float n, float f, struct mat *result);
-void pmatrix_perspective_no(float fov_y, float aspect, float n, float f, struct mat *result);
-void pmatrix_perspective_fov_zo(float fov, float w, float h, float n, float f, struct mat *result);
-void pmatrix_perspective_fov_no(float fov, float w, float h, float n, float f, struct mat *result);
+void pmatrix_ortho(float l, float r, float b, float t, float n, float f, struct mat *result);
+void pmatrix_perspective(float fov_y, float aspect, float n, float f, struct mat *result);
+void pmatrix_perspective_fov(float fov, float w, float h, float n, float f, struct mat *result);
 void pmatrix_perspective_infinite(float fov_y, float aspect, float n, struct mat *result);
 void pmatrix_rotation_x(float angle, struct mat *result);
 void pmatrix_rotation_y(float angle, struct mat *result);
@@ -267,13 +263,9 @@ struct mat matrix_zero(void);
 struct mat matrix_identity(void);
 struct mat matrix_transpose(struct mat m);
 struct mat matrix_inverse(struct mat m);
-struct mat matrix_ortho_zo(float l, float r, float t, float b, float n, float f);
-struct mat matrix_ortho_no(float l, float r, float t, float b, float n, float f);
-struct mat matrix_ortho(float l, float r, float t, float b);
-struct mat matrix_perspective_zo(float fov_y, float aspect, float n, float f);
-struct mat matrix_perspective_no(float fov_y, float aspect, float n, float f);
-struct mat matrix_perspective_fov_zo(float fov, float w, float h, float n, float f);
-struct mat matrix_perspective_fov_no(float fov, float w, float h, float n, float f);
+struct mat matrix_ortho(float l, float r, float b, float t, float n, float f);
+struct mat matrix_perspective(float fov_y, float aspect, float n, float f);
+struct mat matrix_perspective_fov(float fov, float w, float h, float n, float f);
 struct mat matrix_perspective_infinite(float fov_y, float aspect, float n);
 struct mat matrix_rotation_x(float angle);
 struct mat matrix_rotation_y(float angle);

From 17400fa316a719b0a012c2b04db4253811a71a52 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 11 Nov 2017 08:55:45 -0300
Subject: [PATCH 041/102] Update README.md

---
 README.md | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/README.md b/README.md
index e9b3535..d546dc1 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,8 @@
-# MathC
+# MATHC
 
 [![Build Status](https://travis-ci.org/ferreiradaselva/mathc.svg?branch=master)](https://travis-ci.org/ferreiradaselva/mathc)
 
-MathC is a simple math library for 2D and 3D game programming. It contains implementations for:
+MATHC is a simple math library for 2D and 3D game programming. It contains implementations for:
 
 - 2D vectors
 - 3D vectors
@@ -12,7 +12,11 @@ MathC is a simple math library for 2D and 3D game programming. It contains imple
 
 It support C99 standard or later.
 
-# Reference
+## Release
+
+The curreny unstable version is 0.2.0 and its CHANGELOG and RELEASE NOTES can be found in [CHANGELOG.md](CHANGELOG.md#0.2.0---2017-11-11).
+
+## Reference
 
 The reference is the file `REFERENCE.md`.
 
@@ -20,13 +24,13 @@ There are examples on my other repository using this math library:
 
 [CGDFW examples](https://github.com/ferreiradaselva/cgdfw/tree/master/examples)
 
-# Float
+## Float
 
 Every structure and function uses `float`, because it is the most used type on 2D and 3D programming with OpenGL.
 
 **The type `float` loses precision with large numbers, why not use `double`?** Because every `double` value would be converted to `float` before sending to OpenGL, anyway. Which means your physics would run with high precision, but the rendering would still be affected by the `float` imprecision. Instead, *the good practice* to solve the problem with large numbers is to truncate the world position back to `[0.0f, 0.0f, 0.0f]` when the world distance to the center is too large. If the world is too big that even when truncating there are stil large numbers, the correct approach is to divide the world in chunks.
 
-# Passing Arguments as Value or Pointer
+## Passing Arguments as Value or Pointer
 
 For every function **that takes a structure**, there are two versions. One that you pass structures as value and other that you pass as pointer. The functions that pass the value by pointer have a prefix `p` before the type name (pvector2, pvector3, pquaternion and pmatrix) and the result is the `*result` argument or a returned `float`.
 
@@ -56,7 +60,7 @@ pmatrix_look_at(&pos, &target, &view);
 pmatrix_multiply_matrix(&projection, &view, &multiplied_matrix);
 ```
 
-# Vectors
+## Vectors
 
 All vectors (2D, 3D and quaternions) use the same structure type `struct vec`. The `z` component is still useful for 2D vectors, as it is used by OpenGL for depth testing. This means the only extra component on 2D and 3D vectors is the `w` component, which is used by quaternions.
 
@@ -81,7 +85,7 @@ struct vec interpolated = quaternion_spherical_linear_interpolation(a, b, 0.5f);
 
 You don't need to create your OpenGL buffer (VBO) to take 4 elements. When using `glMapBufferRange()`/`glMapBuffer()` and `glUnmapBuffer()`, you can pass only the used elements to the VBO, that has element count of your choice.
 
-# Matrices
+## Matrices
 
 All matrices are 4×4. There are functions for setting up projection matrices, view matrices and model matrices.
 
@@ -104,20 +108,20 @@ struct mat pv = matrix_multiply_matrix(projection, view);
 matrix_to_array(pv, v);
 ```
 
-# Easing Functions
+## Easing Functions
 
 The easing functions are an implementation of the functions presented in [easing.net](http://easings.net/). They are mainly useful for animations.
 
 Easing functions take a value that range from `0.0f` to `1.0f` and usually will return a value inside that same range. However, in some of the easing functions, the returned value extrapolate that range.
 
-# Contributing
+## Contributing
 
 - Before sending any pull request, open an issue asking if the feature or fix is already being worked on.
 - If you find any error, you can open an issue.
 - You can request more useful functions in the issues regarding 2D vectors, 3D vectors, quaternions and matrices. If you have already an implementation or know where to find, better.
 - Everything here will stay licensed under ZLIB, which is a ***very*** permissive license.
 
-# LICENSE
+## LICENSE
 
 The source code of this project is licensed under the terms of the ZLIB license:
 

From 8197f4f8a27191ee14659b3f36e8cb3b25cf3ad3 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 11 Nov 2017 08:55:58 -0300
Subject: [PATCH 042/102] Update CHANGELOG.md

---
 CHANGELOG.md | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bdb0ff2..f872f55 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,29 @@ All notable changes to this project will be documented in this file, following s
 
 ## Unreleased
 
+## 0.2.0 - 2017-11-11
+
+### Notes
+
+If you are using any of the functions to generate an projection matrices, you should update to one of the newer version. The perspective matrices only chaged in name, but the orthographic matrices changed in implementation, fixing the top-down orientation, and requiring a near and far clipping.
+
+### Added
+
+- Link in the `README.md` to this CHANGELOG file.
+- Functions `pmatrix_ortho`/`matrix_ortho` based on the old `pmatrix_ortho_zo`/`matrix_ortho_zo`.
+- Functions `pmatrix_perspective`/`matrix_perspective` based on the old `pmatrix_perspective_zo`/`matrix_perspective_zo`.
+- Functions `pmatrix_perspective_fov`/`matrix_perspective_fov` based on the old `pmatrix_perspective_fov_zo`/`matrix_perspective_fov_zo`.
+
+### Removed
+
+- Functions `pmatrix_ortho_zo`/`matrix_ortho_zo`.
+- Functions `pmatrix_ortho_no`/`matrix_ortho_no`.
+- Old functions `pmatrix_ortho`/`matrix_ortho`.
+- Functions `pmatrix_perspective_zo`/`matrix_perspective_zo`.
+- Functions `pmatrix_perspective_no`/`matrix_perspective_no`.
+- Functions `pmatrix_perspective_fov_zo`/`matrix_perspective_fov_zo`.
+- Functions `pmatrix_perspective_fov_no`/`matrix_perspective_fov_no`.
+
 ## 0.1.0 - 2017-11-11
 
 ### Added

From e2afdcf7fcb3f53d718a03063d6f4ad2458b3783 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 11 Nov 2017 08:59:00 -0300
Subject: [PATCH 043/102] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index d546dc1..ffbaf65 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@ It support C99 standard or later.
 
 ## Release
 
-The curreny unstable version is 0.2.0 and its CHANGELOG and RELEASE NOTES can be found in [CHANGELOG.md](CHANGELOG.md#0.2.0---2017-11-11).
+The curreny unstable version is 0.2.0 and its CHANGELOG and RELEASE NOTES can be found in [CHANGELOG.md](CHANGELOG.md#020---2017-11-11).
 
 ## Reference
 

From 38ab0f96c657ec96490b20d417d7696d3345cc32 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 11 Nov 2017 19:45:08 -0300
Subject: [PATCH 044/102] Add CONTRIBUTING.md

---
 CONTRIBUTING.md | 14 ++++++++++++++
 README.md       | 11 ++++-------
 2 files changed, 18 insertions(+), 7 deletions(-)
 create mode 100644 CONTRIBUTING.md

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..b31a3e1
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,14 @@
+# Contributing
+
+To contribute, open an issue or a pull request describing the feature or fix. Don't leave the explanation of the issue or pull request in blank.
+
+- At least until the version 2.0.0, the structure `vec` will remain as the structure for 2D vectors, 3D vectors and quaternions.
+- At least until the version 2.0.0, there will be only 4x4 matrices.
+- The orientation is right-handed for OpenGL compatibility. Focus on compatibility with other API is not of interest.
+- The library will remain licensed under ZLIB.
+
+## Contributions of interest
+
+- Adding functions useful for 2D or 3D graphics, physics or animation.
+- Deleting functions that prove useless.
+- Fixes.
diff --git a/README.md b/README.md
index ffbaf65..eea90e2 100644
--- a/README.md
+++ b/README.md
@@ -24,6 +24,10 @@ There are examples on my other repository using this math library:
 
 [CGDFW examples](https://github.com/ferreiradaselva/cgdfw/tree/master/examples)
 
+## Contributing
+
+Check the file `CONTRIBUTING.md` for contribution rules and contributions of interest.
+
 ## Float
 
 Every structure and function uses `float`, because it is the most used type on 2D and 3D programming with OpenGL.
@@ -114,13 +118,6 @@ The easing functions are an implementation of the functions presented in [easing
 
 Easing functions take a value that range from `0.0f` to `1.0f` and usually will return a value inside that same range. However, in some of the easing functions, the returned value extrapolate that range.
 
-## Contributing
-
-- Before sending any pull request, open an issue asking if the feature or fix is already being worked on.
-- If you find any error, you can open an issue.
-- You can request more useful functions in the issues regarding 2D vectors, 3D vectors, quaternions and matrices. If you have already an implementation or know where to find, better.
-- Everything here will stay licensed under ZLIB, which is a ***very*** permissive license.
-
 ## LICENSE
 
 The source code of this project is licensed under the terms of the ZLIB license:

From 851dc5ba9c608e8cd558173bc7dcefa8ddedcd7a Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 11 Nov 2017 20:20:09 -0300
Subject: [PATCH 045/102] Add function for matrix linear interpolation

---
 REFERENCE.md |  7 +++++++
 mathc.c      | 27 +++++++++++++++++++++++++++
 mathc.h      |  2 ++
 3 files changed, 36 insertions(+)

diff --git a/REFERENCE.md b/REFERENCE.md
index f1a2617..f64c987 100644
--- a/REFERENCE.md
+++ b/REFERENCE.md
@@ -762,6 +762,13 @@ struct mat matrix_multiply_matrix(struct mat a, struct mat b);
 
 The result is a matrix for the multiplication of the matrix `a` with the matrix `b`.
 
+```c
+void pmatrix_linear_interpolation(struct mat *a, struct mat *b, float p, struct mat *result);
+struct mat matrix_linear_interpolation(struct mat a, struct mat b, float p);
+```
+
+The result is a matrix for the linear interpolation between the matrix `a` and the matrix `b` with the value `p`.
+
 ```c
 void pmatrix_multiply_f4(struct mat *m, float *result);
 void matrix_multiply_f4(struct mat m, float *result);
diff --git a/mathc.c b/mathc.c
index 288fd28..6bc7b96 100644
--- a/mathc.c
+++ b/mathc.c
@@ -2032,6 +2032,33 @@ MATHC_EXTERN_INLINE struct mat matrix_multiply_matrix(struct mat a, struct mat b
 	return result;
 }
 
+void pmatrix_linear_interpolation(struct mat *a, struct mat *b, float p, struct mat *result)
+{
+	result->m11 = a->m11 + (b->m11 - a->m11) * p;
+	result->m12 = a->m12 + (b->m12 - a->m12) * p;
+	result->m13 = a->m13 + (b->m13 - a->m13) * p;
+	result->m14 = a->m14 + (b->m14 - a->m14) * p;
+	result->m21 = a->m21 + (b->m21 - a->m21) * p;
+	result->m22 = a->m22 + (b->m22 - a->m22) * p;
+	result->m23 = a->m23 + (b->m23 - a->m23) * p;
+	result->m24 = a->m24 + (b->m24 - a->m24) * p;
+	result->m31 = a->m31 + (b->m31 - a->m31) * p;
+	result->m32 = a->m32 + (b->m32 - a->m32) * p;
+	result->m33 = a->m33 + (b->m33 - a->m33) * p;
+	result->m34 = a->m34 + (b->m34 - a->m34) * p;
+	result->m41 = a->m41 + (b->m41 - a->m41) * p;
+	result->m42 = a->m42 + (b->m42 - a->m42) * p;
+	result->m43 = a->m43 + (b->m43 - a->m43) * p;
+	result->m44 = a->m44 + (b->m44 - a->m44) * p;
+}
+
+MATHC_EXTERN_INLINE struct mat matrix_linear_interpolation(struct mat a, struct mat b, float p)
+{
+	struct mat result;
+	pmatrix_linear_interpolation(&a, &b, p, &result);
+	return result;
+}
+
 void pmatrix_multiply_f4(struct mat *m, float *result)
 {
 	float v0 = result[0];
diff --git a/mathc.h b/mathc.h
index 05d771d..96610cf 100644
--- a/mathc.h
+++ b/mathc.h
@@ -256,6 +256,7 @@ void pmatrix_get_translation(struct mat *m, struct vec *result);
 void pmatrix_negative(struct mat *m, struct mat *result);
 void pmatrix_multiply(struct mat *m, float s, struct mat *result);
 void pmatrix_multiply_matrix(struct mat *a, struct mat *b, struct mat *result);
+void pmatrix_linear_interpolation(struct mat *a, struct mat *b, float p, struct mat *result);
 void pmatrix_multiply_f4(struct mat *m, float *result);
 void pmatrix_to_array(struct mat *m, float *result);
 
@@ -281,6 +282,7 @@ struct vec matrix_get_translation(struct mat m);
 struct mat matrix_negative(struct mat m);
 struct mat matrix_multiply(struct mat m, float s);
 struct mat matrix_multiply_matrix(struct mat a, struct mat b);
+struct mat matrix_linear_interpolation(struct mat a, struct mat b, float p);
 void matrix_multiply_f4(struct mat m, float *result);
 void matrix_to_array(struct mat m, float *result);
 

From 451806b60e206ff8359c526da2baf923e10ff9fc Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 11 Nov 2017 20:24:57 -0300
Subject: [PATCH 046/102] Update CHANGELOG.md

---
 CHANGELOG.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f872f55..07ede14 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,10 @@ All notable changes to this project will be documented in this file, following s
 
 ## Unreleased
 
+### Added
+
+- Functions `pmatrix_linear_interpolation`/`matrix_linear_interpolation` for matrix linear interpolation.
+
 ## 0.2.0 - 2017-11-11
 
 ### Notes

From 4758ea273d035198814352b0a3cd72c3f4a06186 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Mon, 13 Nov 2017 13:00:38 -0300
Subject: [PATCH 047/102] Add vector equality test functions

---
 CHANGELOG.md |  12 +++++
 REFERENCE.md |  63 ++++++++++++++++++++++++++
 mathc.c      | 126 +++++++++++++++++++++++++++++++++++++++++++++++++++
 mathc.h      |  18 ++++++++
 4 files changed, 219 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 07ede14..df49c20 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,9 +4,21 @@ All notable changes to this project will be documented in this file, following s
 
 ## Unreleased
 
+## 0.3.0 - 2017-11-13
+
 ### Added
 
 - Functions `pmatrix_linear_interpolation`/`matrix_linear_interpolation` for matrix linear interpolation.
+- Functions to test vector and quaternion equality:
+  - `pvector2_is_zero`/`vector2_is_zero`
+  - `pvector2_is_near_zero`/`vector2_is_near_zero`
+  - `pvector2_is_equal`/`vector2_is_equal`
+  - `pvector3_is_zero`/`vector3_is_zero`
+  - `pvector3_is_near_zero`/`vector3_is_near_zero`
+  - `pvector3_is_equal`/`vector3_is_equal`
+  - `pquatertion_is_zero`/`quatertion_is_zero`
+  - `pquatertion_is_near_zero`/`quatertion_is_near_zero`
+  - `pquatertion_is_equal`/`quatertion_is_equal`
 
 ## 0.2.0 - 2017-11-11
 
diff --git a/REFERENCE.md b/REFERENCE.md
index f64c987..a9284af 100644
--- a/REFERENCE.md
+++ b/REFERENCE.md
@@ -75,6 +75,27 @@ struct vec vector2_zero(void);
 
 The result is a zeroed 2D vector.
 
+```c
+int pvector2_is_zero(struct vec *a);
+int vector2_is_zero(struct vec a);
+```
+
+Test if the 2D vector is zero with `FLT_EPSILON` as error margin. Returns `TRUE` if the values are accepted as equal to zero and `FALSE` otherwise.
+
+```c
+int pvector2_is_near_zero(struct vec *a, float epsilon);
+int vector2_is_near_zero(struct vec a, float epsilon);
+```
+
+Test if the 2D vector is near zero with `epsilon` as error margin. Returns `TRUE` if the values are accepted as nearly equal to zero and `FALSE` otherwise.
+
+```c
+int pvector2_is_equal(struct vec *a, struct vec *b, float epsilon);
+int vector2_is_equal(struct vec a, struct vec b, float epsilon);
+```
+
+Test if the 2D vector `a` and the 2D vector `b` are equal with `epsilon` as error margin. Returns `TRUE` if the values are accepted as equal and `FALSE` otherwise.
+
 ```c
 void pvector2_add(struct vec *a, struct vec *b, struct vec *result);
 struct vec vector2_add(struct vec a, struct vec b);
@@ -268,6 +289,27 @@ struct vec vector3_zero(void);
 
 The result is a zeroed 3D vector.
 
+```c
+int pvector3_is_zero(struct vec *a);
+int vector3_is_zero(struct vec a);
+```
+
+Test if the 3D vector is zero with `FLT_EPSILON` as error margin. Returns `TRUE` if the values are accepted as equal to zero and `FALSE` otherwise.
+
+```c
+int pvector3_is_near_zero(struct vec *a, float epsilon);
+int vector3_is_near_zero(struct vec a, float epsilon);
+```
+
+Test if the 3D vector is near zero with `epsilon` as error margin. Returns `TRUE` if the values are accepted as nearly equal to zero and `FALSE` otherwise.
+
+```c
+int pvector3_is_equal(struct vec *a, struct vec *b, float epsilon);
+int vector3_is_equal(struct vec a, struct vec b, float epsilon);
+```
+
+Test if the 3D vector `a` and the 3D vector `b` are equal with `epsilon` as error margin. Returns `TRUE` if the values are accepted as equal and `FALSE` otherwise.
+
 ```c
 void pvector3_add(struct vec *a, struct vec *b, struct vec *result);
 struct vec vector3_add(struct vec a, struct vec b);
@@ -445,6 +487,27 @@ struct vec quaternion_zero();
 
 The result is a zeroed quaternion.
 
+```c
+int pquaternion_is_zero(struct vec *a);
+int quaternion_is_zero(struct vec a);
+```
+
+Test if the quaternion is zero with `FLT_EPSILON` as error margin. Returns `TRUE` if the values are accepted as equal to zero and `FALSE` otherwise.
+
+```c
+int pquaternion_is_near_zero(struct vec *a, float epsilon);
+int quaternion_is_near_zero(struct vec a, float epsilon);
+```
+
+Test if the quaternion is near zero with `epsilon` as error margin. Returns `TRUE` if the values are accepted as nearly equal to zero and `FALSE` otherwise.
+
+```c
+int pquaternion_is_equal(struct vec *a, struct vec *b, float epsilon);
+int quaternion_is_equal(struct vec a, struct vec b, float epsilon);
+```
+
+Test if the quaternion `a` and the quaternion `b` are equal with `epsilon` as error margin. Returns `TRUE` if the values are accepted as equal and `FALSE` otherwise.
+
 ```c
 void pquaternion_add(struct vec *a, struct vec *b, struct vec *result);
 struct vec quaternion_add(struct vec a, struct vec b);
diff --git a/mathc.c b/mathc.c
index 6bc7b96..83d6a76 100644
--- a/mathc.c
+++ b/mathc.c
@@ -104,6 +104,48 @@ MATHC_EXTERN_INLINE struct vec vector2_zero(void)
 	return result;
 }
 
+int pvector2_is_zero(struct vec *a)
+{
+	int is_zero = FALSE;
+	if (fabs(a->x) < FLT_EPSILON && fabs(a->y) < FLT_EPSILON) {
+		is_zero = TRUE;
+	}
+	return is_zero;
+}
+
+MATHC_EXTERN_INLINE int vector2_is_zero(struct vec a)
+{
+	return pvector2_is_zero(&a);
+}
+
+int pvector2_is_near_zero(struct vec *a, float epsilon)
+{
+	int is_near_zero = FALSE;
+	if (fabs(a->x) < epsilon && fabs(a->y) < epsilon) {
+		is_near_zero = TRUE;
+	}
+	return is_near_zero;
+}
+
+MATHC_EXTERN_INLINE int vector2_is_near_zero(struct vec a, float epsilon)
+{
+	return pvector2_is_near_zero(&a, epsilon);
+}
+
+int pvector2_is_equal(struct vec *a, struct vec *b, float epsilon)
+{
+	int is_equal = FALSE;
+	if (fabs(a->x - b->x) < epsilon && fabs(a->y - b->y) < FLT_EPSILON) {
+		is_equal = TRUE;
+	}
+	return is_equal;
+}
+
+MATHC_EXTERN_INLINE int vector2_is_equal(struct vec a, struct vec b, float epsilon)
+{
+	return pvector2_is_equal(&a, &b, epsilon);
+}
+
 void pvector2_add(struct vec *a, struct vec *b, struct vec *result)
 {
 	result->x = a->x + b->x;
@@ -520,6 +562,48 @@ MATHC_EXTERN_INLINE struct vec vector3_zero(void)
 	return result;
 }
 
+int pvector3_is_zero(struct vec *a)
+{
+	int is_zero = FALSE;
+	if (fabs(a->x) < FLT_EPSILON && fabs(a->y) < FLT_EPSILON && fabs(a->z) < FLT_EPSILON) {
+		is_zero = TRUE;
+	}
+	return is_zero;
+}
+
+MATHC_EXTERN_INLINE int vector3_is_zero(struct vec a)
+{
+	return pvector3_is_zero(&a);
+}
+
+int pvector3_is_near_zero(struct vec *a, float epsilon)
+{
+	int is_near_zero = FALSE;
+	if (fabs(a->x) < epsilon && fabs(a->y) < epsilon && fabs(a->z) < epsilon) {
+		is_near_zero = TRUE;
+	}
+	return is_near_zero;
+}
+
+MATHC_EXTERN_INLINE int vector3_is_near_zero(struct vec a, float epsilon)
+{
+	return pvector3_is_near_zero(&a, epsilon);
+}
+
+int pvector3_is_equal(struct vec *a, struct vec *b, float epsilon)
+{
+	int is_equal = FALSE;
+	if (fabs(a->x - b->x) < epsilon && fabs(a->y - b->y) < FLT_EPSILON && fabs(a->z - b->z) < FLT_EPSILON) {
+		is_equal = TRUE;
+	}
+	return is_equal;
+}
+
+MATHC_EXTERN_INLINE int vector3_is_equal(struct vec a, struct vec b, float epsilon)
+{
+	return pvector3_is_equal(&a, &b, epsilon);
+}
+
 void pvector3_add(struct vec *a, struct vec *b, struct vec *result)
 {
 	result->x = a->x + b->x;
@@ -932,6 +1016,48 @@ MATHC_EXTERN_INLINE struct vec quaternion_zero(void)
 	return result;
 }
 
+int pquaternion_is_zero(struct vec *a)
+{
+	int is_zero = FALSE;
+	if (fabs(a->x) < FLT_EPSILON && fabs(a->y) < FLT_EPSILON && fabs(a->z) < FLT_EPSILON && fabs(a->w) < FLT_EPSILON) {
+		is_zero = TRUE;
+	}
+	return is_zero;
+}
+
+MATHC_EXTERN_INLINE int quaternion_is_zero(struct vec a)
+{
+	return pvector3_is_zero(&a);
+}
+
+int pquaternion_is_near_zero(struct vec *a, float epsilon)
+{
+	int is_near_zero = FALSE;
+	if (fabs(a->x) < epsilon && fabs(a->y) < epsilon && fabs(a->z) < epsilon && fabs(a->w) < epsilon) {
+		is_near_zero = TRUE;
+	}
+	return is_near_zero;
+}
+
+MATHC_EXTERN_INLINE int quaternion_is_near_zero(struct vec a, float epsilon)
+{
+	return pquaternion_is_near_zero(&a, epsilon);
+}
+
+int pquaternion_is_equal(struct vec *a, struct vec *b, float epsilon)
+{
+	int is_equal = FALSE;
+	if (fabs(a->x - b->x) < epsilon && fabs(a->y - b->y) < FLT_EPSILON && fabs(a->z - b->z) < FLT_EPSILON) {
+		is_equal = TRUE;
+	}
+	return is_equal;
+}
+
+MATHC_EXTERN_INLINE int quaternion_is_equal(struct vec a, struct vec b, float epsilon)
+{
+	return pquaternion_is_equal(&a, &b, epsilon);
+}
+
 void pquaternion_add(struct vec *a, struct vec *b, struct vec *result)
 {
 	result->x = a->x + b->x;
diff --git a/mathc.h b/mathc.h
index 96610cf..038c241 100644
--- a/mathc.h
+++ b/mathc.h
@@ -60,6 +60,9 @@ float to_degrees(float radians);
 /* Vector 2D */
 void to_pvector2(float x, float y, struct vec *result);
 void pvector2_zero(struct vec *result);
+int pvector2_is_zero(struct vec *a);
+int pvector2_is_near_zero(struct vec *a, float epsilon);
+int pvector2_is_equal(struct vec *a, struct vec *b, float epsilon);
 void pvector2_add(struct vec *a, struct vec *b, struct vec *result);
 void pvector2_subtract(struct vec *a, struct vec *b, struct vec *result);
 void pvector2_scale(struct vec *a, float scale, struct vec *result);
@@ -90,6 +93,9 @@ void pvector2_bezier4(struct vec *a, struct vec *b, struct vec *c, struct vec *d
 
 struct vec to_vector2(float x, float y);
 struct vec vector2_zero(void);
+int vector2_is_zero(struct vec a);
+int vector2_is_near_zero(struct vec a, float epsilon);
+int vector2_is_equal(struct vec a, struct vec b, float epsilon);
 struct vec vector2_add(struct vec a, struct vec b);
 struct vec vector2_subtract(struct vec a, struct vec b);
 struct vec vector2_scale(struct vec a, float scale);
@@ -121,6 +127,9 @@ struct vec vector2_bezier4(struct vec a, struct vec b, struct vec c, struct vec
 /* Vector 3D */
 void to_pvector3(float x, float y, float z, struct vec *result);
 void pvector3_zero(struct vec *result);
+int pvector3_is_zero(struct vec *a);
+int pvector3_is_near_zero(struct vec *a, float epsilon);
+int pvector3_is_equal(struct vec *a, struct vec *b, float epsilon);
 void pvector3_add(struct vec *a, struct vec *b, struct vec *result);
 void pvector3_subtract(struct vec *a, struct vec *b, struct vec *result);
 void pvector3_scale(struct vec *a, float scale, struct vec *result);
@@ -149,6 +158,9 @@ void pvector3_bezier4(struct vec *a, struct vec *b, struct vec *c, struct vec *d
 
 struct vec to_vector3(float x, float y, float z);
 struct vec vector3_add(struct vec a, struct vec b);
+int vector3_is_zero(struct vec a);
+int vector3_is_near_zero(struct vec a, float epsilon);
+int vector3_is_equal(struct vec a, struct vec b, float epsilon);
 struct vec vector3_subtract(struct vec a, struct vec b);
 struct vec vector3_scale(struct vec a, float scale);
 struct vec vector3_multiply(struct vec a, struct vec b);
@@ -177,6 +189,9 @@ struct vec vector3_bezier4(struct vec a, struct vec b, struct vec c, struct vec
 /* Quaternion */
 void to_pquaternion(float x, float y, float z, float w, struct vec *result);
 void pquaternion_zero(struct vec *result);
+int pquaternion_is_zero(struct vec *a);
+int pquaternion_is_near_zero(struct vec *a, float epsilon);
+int pquaternion_is_equal(struct vec *a, struct vec *b, float epsilon);
 void pquaternion_add(struct vec *a, struct vec *b, struct vec *result);
 void pquaternion_subtract(struct vec *a, struct vec *b, struct vec *result);
 void pquaternion_scale(struct vec *a, float scale, struct vec *result);
@@ -206,6 +221,9 @@ void pquaternion_spherical_linear_interpolation(struct vec *a, struct vec *b, fl
 
 struct vec to_quaternion(float x, float y, float z, float w);
 struct vec quaternion_zero(void);
+int quaternion_is_zero(struct vec a);
+int quaternion_is_near_zero(struct vec a, float epsilon);
+int quaternion_is_equal(struct vec a, struct vec b, float epsilon);
 struct vec quaternion_add(struct vec a, struct vec b);
 struct vec quaternion_subtract(struct vec a, struct vec b);
 struct vec quaternion_scale(struct vec a, float scale);

From 18feec6c385f1a553e2f178b1e150417497512d5 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Mon, 13 Nov 2017 13:23:55 -0300
Subject: [PATCH 048/102] Update CONTRIBUTORS.md

---
 CONTRIBUTORS.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 0d55f70..bd72fe9 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -1,5 +1,6 @@
 # Contributors
 
+- [@cxong](https://github.com/cxong) suggested functions to test vectors equality
 - [@cxong](https://github.com/cxong) suggested function to return zeroed vectors
 - [@cxong](https://github.com/cxong) fixed typos in `REFERENCE.md`
 - [@Ankush-p](https://github.com/Ankush-p) added `pmatrix_transpose`/`matrix_transpose` and `pmatrix_inverse`/`matrix_inverse`

From 694d751d65f54d52d81ca3a37d9265db4d48952e Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Mon, 13 Nov 2017 13:28:56 -0300
Subject: [PATCH 049/102] Add version macros

---
 mathc.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/mathc.h b/mathc.h
index 038c241..a996b7b 100644
--- a/mathc.h
+++ b/mathc.h
@@ -21,6 +21,9 @@ the following restrictions:
 #ifndef MATHC_H
 #define MATHC_H
 
+#define MATHC_MAJOR_VERSION 1
+#define MATHC_MINOR_VERSION 0
+#define MATHC_PATCH_VERSION 0
 #define M_PIF 3.1415926536f
 #define M_PIF_2 1.5707963268f
 #define MAT_SIZE 16

From 4f59f441b1db11d5bb186bedbf336bedb580c0ba Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Mon, 13 Nov 2017 13:30:40 -0300
Subject: [PATCH 050/102] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index eea90e2..ebc08fd 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@ It support C99 standard or later.
 
 ## Release
 
-The curreny unstable version is 0.2.0 and its CHANGELOG and RELEASE NOTES can be found in [CHANGELOG.md](CHANGELOG.md#020---2017-11-11).
+The CHANGELOG and RELEASE NOTES can be found in [CHANGELOG.md](CHANGELOG.md#020---2017-11-11).
 
 ## Reference
 

From a0f1db9885a133b67fa20ad9487dc4eb5dc84dd9 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Mon, 13 Nov 2017 22:15:17 -0300
Subject: [PATCH 051/102] Use standard boolean

---
 mathc.c | 85 ++++++++++++++++++++++++++-------------------------------
 mathc.h | 40 ++++++++++++++-------------
 2 files changed, 60 insertions(+), 65 deletions(-)

diff --git a/mathc.c b/mathc.c
index 83d6a76..13e3b9b 100644
--- a/mathc.c
+++ b/mathc.c
@@ -39,22 +39,15 @@ the following restrictions:
 #define MATHC_EXTERN_INLINE
 #endif
 
-#ifndef TRUE
-#define TRUE 1
-#endif
-#ifndef FALSE
-#define FALSE 0
-#endif
-
 /* Utils */
-int nearly_equal(float a, float b, float epsilon)
+bool nearly_equal(float a, float b, float epsilon)
 {
-	int result = FALSE;
+	bool result = false;
 	float abs_a = fabsf(a);
 	float abs_b = fabsf(b);
 	float diff = fabsf(a - b);
 	if (a == b) {
-		result = TRUE;
+		result = true;
 	} else if (a == 0.0f || b == 0.0f || diff < FLT_EPSILON) {
 		result = diff < epsilon;
 	} else {
@@ -104,44 +97,44 @@ MATHC_EXTERN_INLINE struct vec vector2_zero(void)
 	return result;
 }
 
-int pvector2_is_zero(struct vec *a)
+bool pvector2_is_zero(struct vec *a)
 {
-	int is_zero = FALSE;
+	bool is_zero = false;
 	if (fabs(a->x) < FLT_EPSILON && fabs(a->y) < FLT_EPSILON) {
-		is_zero = TRUE;
+		is_zero = true;
 	}
 	return is_zero;
 }
 
-MATHC_EXTERN_INLINE int vector2_is_zero(struct vec a)
+MATHC_EXTERN_INLINE bool vector2_is_zero(struct vec a)
 {
 	return pvector2_is_zero(&a);
 }
 
-int pvector2_is_near_zero(struct vec *a, float epsilon)
+bool pvector2_is_near_zero(struct vec *a, float epsilon)
 {
-	int is_near_zero = FALSE;
+	bool is_near_zero = false;
 	if (fabs(a->x) < epsilon && fabs(a->y) < epsilon) {
-		is_near_zero = TRUE;
+		is_near_zero = true;
 	}
 	return is_near_zero;
 }
 
-MATHC_EXTERN_INLINE int vector2_is_near_zero(struct vec a, float epsilon)
+MATHC_EXTERN_INLINE bool vector2_is_near_zero(struct vec a, float epsilon)
 {
 	return pvector2_is_near_zero(&a, epsilon);
 }
 
-int pvector2_is_equal(struct vec *a, struct vec *b, float epsilon)
+bool pvector2_is_equal(struct vec *a, struct vec *b, float epsilon)
 {
-	int is_equal = FALSE;
+	bool is_equal = false;
 	if (fabs(a->x - b->x) < epsilon && fabs(a->y - b->y) < FLT_EPSILON) {
-		is_equal = TRUE;
+		is_equal = true;
 	}
 	return is_equal;
 }
 
-MATHC_EXTERN_INLINE int vector2_is_equal(struct vec a, struct vec b, float epsilon)
+MATHC_EXTERN_INLINE bool vector2_is_equal(struct vec a, struct vec b, float epsilon)
 {
 	return pvector2_is_equal(&a, &b, epsilon);
 }
@@ -562,44 +555,44 @@ MATHC_EXTERN_INLINE struct vec vector3_zero(void)
 	return result;
 }
 
-int pvector3_is_zero(struct vec *a)
+bool pvector3_is_zero(struct vec *a)
 {
-	int is_zero = FALSE;
+	bool is_zero = false;
 	if (fabs(a->x) < FLT_EPSILON && fabs(a->y) < FLT_EPSILON && fabs(a->z) < FLT_EPSILON) {
-		is_zero = TRUE;
+		is_zero = true;
 	}
 	return is_zero;
 }
 
-MATHC_EXTERN_INLINE int vector3_is_zero(struct vec a)
+MATHC_EXTERN_INLINE bool vector3_is_zero(struct vec a)
 {
 	return pvector3_is_zero(&a);
 }
 
-int pvector3_is_near_zero(struct vec *a, float epsilon)
+bool pvector3_is_near_zero(struct vec *a, float epsilon)
 {
-	int is_near_zero = FALSE;
+	bool is_near_zero = false;
 	if (fabs(a->x) < epsilon && fabs(a->y) < epsilon && fabs(a->z) < epsilon) {
-		is_near_zero = TRUE;
+		is_near_zero = true;
 	}
 	return is_near_zero;
 }
 
-MATHC_EXTERN_INLINE int vector3_is_near_zero(struct vec a, float epsilon)
+MATHC_EXTERN_INLINE bool vector3_is_near_zero(struct vec a, float epsilon)
 {
 	return pvector3_is_near_zero(&a, epsilon);
 }
 
-int pvector3_is_equal(struct vec *a, struct vec *b, float epsilon)
+bool pvector3_is_equal(struct vec *a, struct vec *b, float epsilon)
 {
-	int is_equal = FALSE;
+	bool is_equal = false;
 	if (fabs(a->x - b->x) < epsilon && fabs(a->y - b->y) < FLT_EPSILON && fabs(a->z - b->z) < FLT_EPSILON) {
-		is_equal = TRUE;
+		is_equal = true;
 	}
 	return is_equal;
 }
 
-MATHC_EXTERN_INLINE int vector3_is_equal(struct vec a, struct vec b, float epsilon)
+MATHC_EXTERN_INLINE bool vector3_is_equal(struct vec a, struct vec b, float epsilon)
 {
 	return pvector3_is_equal(&a, &b, epsilon);
 }
@@ -1016,44 +1009,44 @@ MATHC_EXTERN_INLINE struct vec quaternion_zero(void)
 	return result;
 }
 
-int pquaternion_is_zero(struct vec *a)
+bool pquaternion_is_zero(struct vec *a)
 {
-	int is_zero = FALSE;
+	bool is_zero = false;
 	if (fabs(a->x) < FLT_EPSILON && fabs(a->y) < FLT_EPSILON && fabs(a->z) < FLT_EPSILON && fabs(a->w) < FLT_EPSILON) {
-		is_zero = TRUE;
+		is_zero = true;
 	}
 	return is_zero;
 }
 
-MATHC_EXTERN_INLINE int quaternion_is_zero(struct vec a)
+MATHC_EXTERN_INLINE bool quaternion_is_zero(struct vec a)
 {
 	return pvector3_is_zero(&a);
 }
 
-int pquaternion_is_near_zero(struct vec *a, float epsilon)
+bool pquaternion_is_near_zero(struct vec *a, float epsilon)
 {
-	int is_near_zero = FALSE;
+	bool is_near_zero = false;
 	if (fabs(a->x) < epsilon && fabs(a->y) < epsilon && fabs(a->z) < epsilon && fabs(a->w) < epsilon) {
-		is_near_zero = TRUE;
+		is_near_zero = true;
 	}
 	return is_near_zero;
 }
 
-MATHC_EXTERN_INLINE int quaternion_is_near_zero(struct vec a, float epsilon)
+MATHC_EXTERN_INLINE bool quaternion_is_near_zero(struct vec a, float epsilon)
 {
 	return pquaternion_is_near_zero(&a, epsilon);
 }
 
-int pquaternion_is_equal(struct vec *a, struct vec *b, float epsilon)
+bool pquaternion_is_equal(struct vec *a, struct vec *b, float epsilon)
 {
-	int is_equal = FALSE;
+	bool is_equal = fa;
 	if (fabs(a->x - b->x) < epsilon && fabs(a->y - b->y) < FLT_EPSILON && fabs(a->z - b->z) < FLT_EPSILON) {
-		is_equal = TRUE;
+		is_equal = true;
 	}
 	return is_equal;
 }
 
-MATHC_EXTERN_INLINE int quaternion_is_equal(struct vec a, struct vec b, float epsilon)
+MATHC_EXTERN_INLINE bool quaternion_is_equal(struct vec a, struct vec b, float epsilon)
 {
 	return pquaternion_is_equal(&a, &b, epsilon);
 }
diff --git a/mathc.h b/mathc.h
index a996b7b..2ee0460 100644
--- a/mathc.h
+++ b/mathc.h
@@ -21,6 +21,8 @@ the following restrictions:
 #ifndef MATHC_H
 #define MATHC_H
 
+#include <stdbool.h>
+
 #define MATHC_MAJOR_VERSION 1
 #define MATHC_MINOR_VERSION 0
 #define MATHC_PATCH_VERSION 0
@@ -56,16 +58,16 @@ struct mat {
 };
 
 /* Utils */
-int nearly_equal(float a, float b, float epsilon);
+bool nearly_equal(float a, float b, float epsilon);
 float to_radians(float degrees);
 float to_degrees(float radians);
 
 /* Vector 2D */
 void to_pvector2(float x, float y, struct vec *result);
 void pvector2_zero(struct vec *result);
-int pvector2_is_zero(struct vec *a);
-int pvector2_is_near_zero(struct vec *a, float epsilon);
-int pvector2_is_equal(struct vec *a, struct vec *b, float epsilon);
+bool pvector2_is_zero(struct vec *a);
+bool pvector2_is_near_zero(struct vec *a, float epsilon);
+bool pvector2_is_equal(struct vec *a, struct vec *b, float epsilon);
 void pvector2_add(struct vec *a, struct vec *b, struct vec *result);
 void pvector2_subtract(struct vec *a, struct vec *b, struct vec *result);
 void pvector2_scale(struct vec *a, float scale, struct vec *result);
@@ -96,9 +98,9 @@ void pvector2_bezier4(struct vec *a, struct vec *b, struct vec *c, struct vec *d
 
 struct vec to_vector2(float x, float y);
 struct vec vector2_zero(void);
-int vector2_is_zero(struct vec a);
-int vector2_is_near_zero(struct vec a, float epsilon);
-int vector2_is_equal(struct vec a, struct vec b, float epsilon);
+bool vector2_is_zero(struct vec a);
+bool vector2_is_near_zero(struct vec a, float epsilon);
+bool vector2_is_equal(struct vec a, struct vec b, float epsilon);
 struct vec vector2_add(struct vec a, struct vec b);
 struct vec vector2_subtract(struct vec a, struct vec b);
 struct vec vector2_scale(struct vec a, float scale);
@@ -130,9 +132,9 @@ struct vec vector2_bezier4(struct vec a, struct vec b, struct vec c, struct vec
 /* Vector 3D */
 void to_pvector3(float x, float y, float z, struct vec *result);
 void pvector3_zero(struct vec *result);
-int pvector3_is_zero(struct vec *a);
-int pvector3_is_near_zero(struct vec *a, float epsilon);
-int pvector3_is_equal(struct vec *a, struct vec *b, float epsilon);
+bool pvector3_is_zero(struct vec *a);
+bool pvector3_is_near_zero(struct vec *a, float epsilon);
+bool pvector3_is_equal(struct vec *a, struct vec *b, float epsilon);
 void pvector3_add(struct vec *a, struct vec *b, struct vec *result);
 void pvector3_subtract(struct vec *a, struct vec *b, struct vec *result);
 void pvector3_scale(struct vec *a, float scale, struct vec *result);
@@ -161,9 +163,9 @@ void pvector3_bezier4(struct vec *a, struct vec *b, struct vec *c, struct vec *d
 
 struct vec to_vector3(float x, float y, float z);
 struct vec vector3_add(struct vec a, struct vec b);
-int vector3_is_zero(struct vec a);
-int vector3_is_near_zero(struct vec a, float epsilon);
-int vector3_is_equal(struct vec a, struct vec b, float epsilon);
+bool vector3_is_zero(struct vec a);
+bool vector3_is_near_zero(struct vec a, float epsilon);
+bool vector3_is_equal(struct vec a, struct vec b, float epsilon);
 struct vec vector3_subtract(struct vec a, struct vec b);
 struct vec vector3_scale(struct vec a, float scale);
 struct vec vector3_multiply(struct vec a, struct vec b);
@@ -192,9 +194,9 @@ struct vec vector3_bezier4(struct vec a, struct vec b, struct vec c, struct vec
 /* Quaternion */
 void to_pquaternion(float x, float y, float z, float w, struct vec *result);
 void pquaternion_zero(struct vec *result);
-int pquaternion_is_zero(struct vec *a);
-int pquaternion_is_near_zero(struct vec *a, float epsilon);
-int pquaternion_is_equal(struct vec *a, struct vec *b, float epsilon);
+bool pquaternion_is_zero(struct vec *a);
+bool pquaternion_is_near_zero(struct vec *a, float epsilon);
+bool pquaternion_is_equal(struct vec *a, struct vec *b, float epsilon);
 void pquaternion_add(struct vec *a, struct vec *b, struct vec *result);
 void pquaternion_subtract(struct vec *a, struct vec *b, struct vec *result);
 void pquaternion_scale(struct vec *a, float scale, struct vec *result);
@@ -224,9 +226,9 @@ void pquaternion_spherical_linear_interpolation(struct vec *a, struct vec *b, fl
 
 struct vec to_quaternion(float x, float y, float z, float w);
 struct vec quaternion_zero(void);
-int quaternion_is_zero(struct vec a);
-int quaternion_is_near_zero(struct vec a, float epsilon);
-int quaternion_is_equal(struct vec a, struct vec b, float epsilon);
+bool quaternion_is_zero(struct vec a);
+bool quaternion_is_near_zero(struct vec a, float epsilon);
+bool quaternion_is_equal(struct vec a, struct vec b, float epsilon);
 struct vec quaternion_add(struct vec a, struct vec b);
 struct vec quaternion_subtract(struct vec a, struct vec b);
 struct vec quaternion_scale(struct vec a, float scale);

From e93c24b976b1cbce383e7e94f375d9e9a457098c Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Mon, 13 Nov 2017 22:21:12 -0300
Subject: [PATCH 052/102] Fix typo

---
 mathc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mathc.c b/mathc.c
index 13e3b9b..6687162 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1039,7 +1039,7 @@ MATHC_EXTERN_INLINE bool quaternion_is_near_zero(struct vec a, float epsilon)
 
 bool pquaternion_is_equal(struct vec *a, struct vec *b, float epsilon)
 {
-	bool is_equal = fa;
+	bool is_equal = false;
 	if (fabs(a->x - b->x) < epsilon && fabs(a->y - b->y) < FLT_EPSILON && fabs(a->z - b->z) < FLT_EPSILON) {
 		is_equal = true;
 	}

From 85d1a6ab0d2b9880cdf8eb557d68fa22611633d2 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Wed, 15 Nov 2017 05:42:24 -0300
Subject: [PATCH 053/102] Fix typo in README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index ebc08fd..7e306bf 100644
--- a/README.md
+++ b/README.md
@@ -114,7 +114,7 @@ matrix_to_array(pv, v);
 
 ## Easing Functions
 
-The easing functions are an implementation of the functions presented in [easing.net](http://easings.net/). They are mainly useful for animations.
+The easing functions are an implementation of the functions presented in [easings.net](http://easings.net/). They are mainly useful for animations.
 
 Easing functions take a value that range from `0.0f` to `1.0f` and usually will return a value inside that same range. However, in some of the easing functions, the returned value extrapolate that range.
 

From f7b303d767479f30eadafa3a33494b2072bdc17c Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 18 Nov 2017 08:20:26 -0300
Subject: [PATCH 054/102] Fix checking if quaternion is zero

---
 mathc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mathc.c b/mathc.c
index 6687162..e066e6a 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1020,7 +1020,7 @@ bool pquaternion_is_zero(struct vec *a)
 
 MATHC_EXTERN_INLINE bool quaternion_is_zero(struct vec a)
 {
-	return pvector3_is_zero(&a);
+	return pquaternion_is_zero(&a);
 }
 
 bool pquaternion_is_near_zero(struct vec *a, float epsilon)

From aa441153cb2dcc87ea5ced76a56acebede9bad19 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 18 Nov 2017 08:33:54 -0300
Subject: [PATCH 055/102] Fix quaternion inverse function

---
 mathc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mathc.c b/mathc.c
index e066e6a..a7ace25 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1167,7 +1167,7 @@ MATHC_EXTERN_INLINE struct vec quaternion_conjugate(struct vec a)
 
 void pquaternion_inverse(struct vec *a, struct vec *result)
 {
-	float length = sqrtf(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
+	float length = a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w;
 	if (fabs(length) > FLT_EPSILON) {
 		length = 1.0f / length;
 	} else {

From d36c6ac985717d6768e4c1c4ad3379603c1f3ff5 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 18 Nov 2017 08:35:34 -0300
Subject: [PATCH 056/102] Update CONTRIBUTORS.md

---
 CONTRIBUTORS.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index bd72fe9..fc9de58 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -1,5 +1,7 @@
 # Contributors
 
+- [@ratchetfreak](https://github.com/ratchetfreak) found bug with function for quaternion inverse
+- [@ratchetfreak](https://github.com/ratchetfreak) found bug with function for testing if quaternion is zero
 - [@cxong](https://github.com/cxong) suggested functions to test vectors equality
 - [@cxong](https://github.com/cxong) suggested function to return zeroed vectors
 - [@cxong](https://github.com/cxong) fixed typos in `REFERENCE.md`

From f254d0a8a4354edb1048b213e9eebf66b5da8dcd Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 18 Nov 2017 09:13:20 -0300
Subject: [PATCH 057/102] Fix missing declaration of zero 3D vector

---
 mathc.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mathc.h b/mathc.h
index 2ee0460..5b6ca50 100644
--- a/mathc.h
+++ b/mathc.h
@@ -162,6 +162,7 @@ void pvector3_bezier3(struct vec *a, struct vec *b, struct vec *c, float p, stru
 void pvector3_bezier4(struct vec *a, struct vec *b, struct vec *c, struct vec *d, float p, struct vec *result);
 
 struct vec to_vector3(float x, float y, float z);
+struct vec vector3_zero(void);
 struct vec vector3_add(struct vec a, struct vec b);
 bool vector3_is_zero(struct vec a);
 bool vector3_is_near_zero(struct vec a, float epsilon);

From 1bee0435548aecf551384da8dd824a72890a2087 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 18 Nov 2017 09:14:03 -0300
Subject: [PATCH 058/102] Fix formatting

---
 mathc.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/mathc.c b/mathc.c
index a7ace25..b95e002 100644
--- a/mathc.c
+++ b/mathc.c
@@ -993,7 +993,6 @@ struct vec to_quaternion(float x, float y, float z, float w)
 	return result;
 }
 
-
 void pquaternion_zero(struct vec *result)
 {
 	result->x = 0.0f;

From d10ed5c45e558561bfb56c3c8fb91dac01cc8706 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 18 Nov 2017 09:14:37 -0300
Subject: [PATCH 059/102] Add null quaternion function

---
 mathc.c | 15 +++++++++++++++
 mathc.h |  2 ++
 2 files changed, 17 insertions(+)

diff --git a/mathc.c b/mathc.c
index b95e002..ee03889 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1008,6 +1008,21 @@ MATHC_EXTERN_INLINE struct vec quaternion_zero(void)
 	return result;
 }
 
+void pquaternion_null(struct vec *result)
+{
+	result->x = 0.0f;
+	result->y = 0.0f;
+	result->z = 0.0f;
+	result->w = 1.0f;
+}
+
+MATHC_EXTERN_INLINE struct vec quaternion_null(void)
+{
+	struct vec result;
+	pquaternion_null(&result);
+	return result;
+}
+
 bool pquaternion_is_zero(struct vec *a)
 {
 	bool is_zero = false;
diff --git a/mathc.h b/mathc.h
index 5b6ca50..1b6ac16 100644
--- a/mathc.h
+++ b/mathc.h
@@ -195,6 +195,7 @@ struct vec vector3_bezier4(struct vec a, struct vec b, struct vec c, struct vec
 /* Quaternion */
 void to_pquaternion(float x, float y, float z, float w, struct vec *result);
 void pquaternion_zero(struct vec *result);
+void pquaternion_null(struct vec *result);
 bool pquaternion_is_zero(struct vec *a);
 bool pquaternion_is_near_zero(struct vec *a, float epsilon);
 bool pquaternion_is_equal(struct vec *a, struct vec *b, float epsilon);
@@ -227,6 +228,7 @@ void pquaternion_spherical_linear_interpolation(struct vec *a, struct vec *b, fl
 
 struct vec to_quaternion(float x, float y, float z, float w);
 struct vec quaternion_zero(void);
+struct vec quaternion_null(void);
 bool quaternion_is_zero(struct vec a);
 bool quaternion_is_near_zero(struct vec a, float epsilon);
 bool quaternion_is_equal(struct vec a, struct vec b, float epsilon);

From bf71abd00ed09f852e005e86da218a34debbaba9 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 18 Nov 2017 09:19:42 -0300
Subject: [PATCH 060/102] Add function to get quaternion from 2 vectors

---
 mathc.c | 17 +++++++++++++++++
 mathc.h |  2 ++
 2 files changed, 19 insertions(+)

diff --git a/mathc.c b/mathc.c
index ee03889..2ea97ee 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1424,6 +1424,23 @@ MATHC_EXTERN_INLINE struct vec quaternion_to_axis_angle(struct vec a)
 	return result;
 }
 
+void pquaternion_from_2_vectors(struct vec *a, struct vec *b, struct vec *result){
+	struct vec cross;
+	float dot = pvector3_dot(a, b);
+	float a_length_sq = pvector3_length_squared(a);
+	float b_length_sq = pvector3_length_squared(a);
+	pvector3_cross(a, b, &cross);
+	to_pquaternion(cross.x, cross.y, cross.z, dot + sqrtf(a_length_sq * b_length_sq), result);
+	pquaternion_normalize(result, result);
+}
+
+MATHC_EXTERN_INLINE struct vec quaternion_from_2_vectors(struct vec a, struct vec b)
+{
+	struct vec result;
+	pquaternion_from_2_vectors(&a, &b, &result);
+	return result;
+}
+
 void pquaternion_rotation_matrix(struct mat *m, struct vec *result)
 {
 	float sr;
diff --git a/mathc.h b/mathc.h
index 1b6ac16..0041540 100644
--- a/mathc.h
+++ b/mathc.h
@@ -221,6 +221,7 @@ void pquaternion_normalize(struct vec *a, struct vec *result);
 void pquaternion_power(struct vec *a, float exponent, struct vec *result);
 void pquaternion_from_axis_angle(struct vec *a, float angle, struct vec *result);
 void pquaternion_to_axis_angle(struct vec *a, struct vec *result);
+void pquaternion_from_2_vectors(struct vec *a, struct vec *b, struct vec *result);
 void pquaternion_rotation_matrix(struct mat *m, struct vec *result);
 void pquaternion_yaw_pitch_roll(float yaw, float pitch, float roll, struct vec *result);
 void pquaternion_linear_interpolation(struct vec *a, struct vec *b, float p, struct vec *result);
@@ -254,6 +255,7 @@ struct vec quaternion_normalize(struct vec a);
 struct vec quaternion_power(struct vec a, float exponent);
 struct vec quaternion_from_axis_angle(struct vec a, float angle);
 struct vec quaternion_to_axis_angle(struct vec a);
+struct vec quaternion_from_2_vectors(struct vec a, struct vec b);
 struct vec quaternion_rotation_matrix(struct mat m);
 struct vec quaternion_yaw_pitch_roll(float yaw, float pitch, float roll);
 struct vec quaternion_linear_interpolation(struct vec a, struct vec b, float p);

From c06ccf85b07b8e2699b8f6cb574e41716b203786 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 18 Nov 2017 09:21:39 -0300
Subject: [PATCH 061/102] Update CONTRIBUTORS.md

---
 CONTRIBUTORS.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index fc9de58..e577312 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -1,5 +1,6 @@
 # Contributors
 
+- [@ratchetfreak](https://github.com/ratchetfreak) added `pquaternion_null`/`quaternion_null` and `pquaternion_from_2_vectors`/`quaternion_from_2_vectors`
 - [@ratchetfreak](https://github.com/ratchetfreak) found bug with function for quaternion inverse
 - [@ratchetfreak](https://github.com/ratchetfreak) found bug with function for testing if quaternion is zero
 - [@cxong](https://github.com/cxong) suggested functions to test vectors equality

From 228e1850f92885f00383422797de868400a41bb6 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 18 Nov 2017 09:31:11 -0300
Subject: [PATCH 062/102] Update CHANGELOG.md

---
 CHANGELOG.md | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index df49c20..fbcebcf 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,47 @@ All notable changes to this project will be documented in this file, following s
 
 ## Unreleased
 
+## 1.1.0 - 2017-11-18
+
+### Added
+
+- Function to get quaternion from two vectors.
+- Function to get null quaternion.
+
+### Changed
+
+- Fix missing declaration of function to get zero 3D vector.
+
+## 1.0.4 - 2017-11-18
+
+### Changed
+
+- Fix quaternion inverse function.
+
+## 1.0.3 - 2017-11-18
+
+### Changed
+
+- Fix checking if quaternion is zero.
+
+## 1.0.2 - 2017-11-13
+
+### Changed
+
+- Fix typo.
+
+## 1.0.1 - 2017-11-13
+
+### Changed
+
+- Use standard boolean.
+
+## 1.0.0 - 2017-11-13
+
+### Added
+
+- Version macros.
+
 ## 0.3.0 - 2017-11-13
 
 ### Added

From f079f069085424d6eff2342ff85de356e609e96d Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Tue, 21 Nov 2017 14:52:56 -0300
Subject: [PATCH 063/102] Add functions to test 2D vector intersection

The functions to test 2D vector intersection check if a 2D vector is
inside or outside of a circle or triangle.
---
 CHANGELOG.md | 15 +++++++++--
 mathc.c      | 71 ++++++++++++++++++++++++++++++++++++++++++++--------
 mathc.h      |  9 ++++++-
 test.c       | 52 ++++++++++++++++++++++++++++++++++++++
 4 files changed, 133 insertions(+), 14 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fbcebcf..f7f4e4c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,12 +4,23 @@ All notable changes to this project will be documented in this file, following s
 
 ## Unreleased
 
+## 1.2.0 - 2017-11-21
+
+### Added
+
+- Functions `pvector2_in_circle`/`vector2_in_circle` to check if 2D vector is inside 2D circle.
+- Functions `pvector2_in_triangle`/`vector2_in_triangle` to check if 2D vector is inside 2D triangle.
+
+### Changed
+
+- Quaternion spherical interpolation use `0.95f` as cutoff to switch to linear interpolation.
+
 ## 1.1.0 - 2017-11-18
 
 ### Added
 
-- Function to get quaternion from two vectors.
-- Function to get null quaternion.
+- Functions `pquaternion_from_2_vectors`/`quaternion_from_2_vectors` to get quaternion from two vectors.
+- Functions `pquaternion_null`/`quaternion_null` to get null quaternion.
 
 ### Changed
 
diff --git a/mathc.c b/mathc.c
index 2ea97ee..95ec2d8 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1528,28 +1528,28 @@ void pquaternion_spherical_linear_interpolation(struct vec *a, struct vec *b, fl
 	struct vec tmp_a = *a;
 	struct vec tmp_b = *b;
 	float cos_theta = pquaternion_dot(a, b);
-	float k0;
-	float k1;
+	float p0;
+	float p1;
 	/* Take shortest arc */
 	if (cos_theta < 0.0f) {
 		pquaternion_negative(&tmp_b, &tmp_b);
 		cos_theta = -cos_theta;
 	}
 	/* Check if quaternions are close */
-	if (cos_theta > 0.9999f) {
+	if (cos_theta > 0.95f) {
 		/* Use linear interpolation */
-		k0 = 1.0f - p;
-		k1 = p;
+		p0 = 1.0f - p;
+		p1 = p;
 	} else {
 		float theta = acosf(cos_theta);
 		float sin_theta = sinf(theta);
-		k0 = sinf((1.f - p) * theta) / sin_theta;
-		k1 = sinf(p * theta) / sin_theta;
+		p0 = sinf((1.f - p) * theta) / sin_theta;
+		p1 = sinf(p * theta) / sin_theta;
 	}
-	result->x = tmp_a.x * k0 + tmp_b.x * k1;
-	result->y = tmp_a.y * k0 + tmp_b.y * k1;
-	result->z = tmp_a.z * k0 + tmp_b.z * k1;
-	result->w = tmp_a.w * k0 + tmp_b.w * k1;
+	result->x = tmp_a.x * p0 + tmp_b.x * p1;
+	result->y = tmp_a.y * p0 + tmp_b.y * p1;
+	result->z = tmp_a.z * p0 + tmp_b.z * p1;
+	result->w = tmp_a.w * p0 + tmp_b.w * p1;
 }
 
 MATHC_EXTERN_INLINE struct vec quaternion_spherical_linear_interpolation(struct vec a, struct vec b, float p)
@@ -2251,6 +2251,55 @@ MATHC_EXTERN_INLINE void matrix_to_array(struct mat m, float *result)
 	pmatrix_to_array(&m, result);
 }
 
+/* Intersection */
+bool pvector2_in_circle(struct vec *v, struct vec *circle_position, float radius)
+{
+	bool result = false;
+	float distance = pvector2_distance_to(v, circle_position);
+	if (distance <= radius) {
+		result = true;
+	}
+	return result;
+}
+
+MATHC_EXTERN_INLINE bool vector2_in_circle(struct vec v, struct vec circle_position, float radius)
+{
+	return pvector2_in_circle(&v, &circle_position, radius);
+}
+
+static bool psame_side(struct vec *p1, struct vec *p2, struct vec *a, struct vec *b)
+{
+	bool result = false;
+	struct vec b_minus_a = {0};
+	struct vec p1_minus_a = {0};
+	struct vec p2_minus_a = {0};
+	struct vec cross_p1;
+	struct vec cross_p2;
+	pvector2_subtract(b, a, &b_minus_a);
+	pvector2_subtract(p1, a, &p1_minus_a);
+	pvector2_subtract(p2, a, &p2_minus_a);
+	pvector3_cross(&b_minus_a, &p1_minus_a, &cross_p1);
+	pvector3_cross(&b_minus_a, &p2_minus_a, &cross_p2);
+	if (pvector3_dot(&cross_p1, &cross_p2) >= 0.0f) {
+		result = true;
+	}
+	return result;
+}
+
+bool pvector2_in_triangle(struct vec *v, struct vec *a, struct vec *b, struct vec *c)
+{
+	bool result = false;
+	if (psame_side(v, a, b, c) && psame_side(v, b, a, c) && psame_side(v, c, a, b)) {
+		result = true;
+	}
+	return result;
+}
+
+MATHC_EXTERN_INLINE bool vector2_in_triangle(struct vec v, struct vec a, struct vec b, struct vec c)
+{
+	return pvector2_in_triangle(&v, &a, &b, &c);
+}
+
 /* Easing functions */
 float quadratic_ease_in(float p)
 {
diff --git a/mathc.h b/mathc.h
index 0041540..b5e54c6 100644
--- a/mathc.h
+++ b/mathc.h
@@ -24,7 +24,7 @@ the following restrictions:
 #include <stdbool.h>
 
 #define MATHC_MAJOR_VERSION 1
-#define MATHC_MINOR_VERSION 0
+#define MATHC_MINOR_VERSION 2
 #define MATHC_PATCH_VERSION 0
 #define M_PIF 3.1415926536f
 #define M_PIF_2 1.5707963268f
@@ -314,6 +314,13 @@ struct mat matrix_linear_interpolation(struct mat a, struct mat b, float p);
 void matrix_multiply_f4(struct mat m, float *result);
 void matrix_to_array(struct mat m, float *result);
 
+/* Intersection */
+bool pvector2_in_circle(struct vec *v, struct vec *circle_position, float radius);
+bool pvector2_in_triangle(struct vec *v, struct vec *a, struct vec *b, struct vec *c);
+
+bool vector2_in_circle(struct vec v, struct vec circle_position, float radius);
+bool vector2_in_triangle(struct vec v, struct vec a, struct vec b, struct vec c);
+
 /* Easing functions */
 float quadratic_ease_in(float p);
 float quadratic_ease_out(float p);
diff --git a/test.c b/test.c
index ac2f7b6..fa079fd 100644
--- a/test.c
+++ b/test.c
@@ -34,6 +34,28 @@ struct cerror {
 	int32_t passed_with_e1000;
 };
 
+void printf_bool_test(struct cerror *error, char *msg, bool e, bool r)
+{
+	if (e) {
+		printf("%s:\n\tExpected true\n\t", msg);
+	} else {
+		printf("%s:\n\tExpected false\n\t", msg);
+	}
+	if (r) {
+		printf("  Actual true\t");
+	} else {
+		printf("  Actual false\t");
+	}
+
+	if (e == r) {
+		error->passed = error->passed + 1;
+		printf("~passed~\n\n");
+	} else {
+		error->failed = error->failed + 1;
+		printf("~failed~\n\n");
+	}
+}
+
 void printf_1f_test(struct cerror *error, char *msg, float e1, float r1)
 {
 	bool done = false;
@@ -394,6 +416,35 @@ void matrix_tests(struct cerror *error)
 	r = matrix_multiply_matrix(a, b);
 }
 
+void intersection_tests(struct cerror *error)
+{
+	struct vec a;
+	struct vec b;
+	struct vec c;
+	struct vec d;
+	printf("\n# Making tests with intersection...\n");
+	a = to_vector2(0.0f, 0.0f);
+	b = to_vector2(0.0f, 1.0f);
+	c = to_vector2(1.0f, 0.0f);
+	d = to_vector2(0.5f, 0.5f);
+	printf_bool_test(error, "2D vector in triangle", true, vector2_in_triangle(d, a, b, c));
+	a = to_vector2(0.0f, 0.0f);
+	b = to_vector2(1.0f, 1.0f);
+	c = to_vector2(1.0f, 0.0f);
+	d = to_vector2(0.5f, 0.5f);
+	printf_bool_test(error, "2D vector in triangle", true, vector2_in_triangle(d, a, b, c));
+	a = to_vector2(0.0f, 0.0f);
+	b = to_vector2(1.0f, 1.0f);
+	c = to_vector2(1.0f, 0.0f);
+	d = to_vector2(0.5f, 0.6f);
+	printf_bool_test(error, "2D vector in triangle", false, vector2_in_triangle(d, a, b, c));
+	a = to_vector2(0.0f, 1.0f);
+	b = to_vector2(1.0f, 1.0f);
+	c = to_vector2(1.0f, 0.0f);
+	d = to_vector2(0.5f, 0.4f);
+	printf_bool_test(error, "2D vector in triangle", false, vector2_in_triangle(d, a, b, c));
+}
+
 int main(int argc, char **args)
 {
 	struct cerror error = {0};
@@ -401,6 +452,7 @@ int main(int argc, char **args)
 	vector3_tests(&error);
 	quaternion_tests(&error);
 	matrix_tests(&error);
+	intersection_tests(&error);
 	printf("\nTotal of failed tests: %d\n", error.failed);
 	printf("Total of tests that passed: %d\n", error.passed);
 	printf("Total of tests that passed with epsilon * 10.0: %d\n", error.passed_with_e10);

From 9664a53c49bf97bb8484cda5be2b08218f7ece14 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Tue, 21 Nov 2017 15:31:49 -0300
Subject: [PATCH 064/102] Update REFERENCE.md

---
 REFERENCE.md | 36 ++++++++++++++++++++++++++----------
 1 file changed, 26 insertions(+), 10 deletions(-)

diff --git a/REFERENCE.md b/REFERENCE.md
index a9284af..f8c7379 100644
--- a/REFERENCE.md
+++ b/REFERENCE.md
@@ -20,7 +20,7 @@ int nearly_equal(float a, float b, float epsilon);
 
 Used to compare two `float` variables with an error margin `epsilon`. The standard header `<float.h>` comes with the macro `FLT_EPSILON` that can be used as the error margin. Greater values are also acceptable in most cases, such as `FLT_EPSILON * 10.0f` and `FLT_EPSILON * 100.0f`.
 
-Returns `TRUE` if the values are accepted as equal and `FALSE` otherwise.
+Returns `true` if the values are accepted as equal and `false` otherwise.
 
 ```c
 float to_radians(float degrees);
@@ -80,21 +80,21 @@ int pvector2_is_zero(struct vec *a);
 int vector2_is_zero(struct vec a);
 ```
 
-Test if the 2D vector is zero with `FLT_EPSILON` as error margin. Returns `TRUE` if the values are accepted as equal to zero and `FALSE` otherwise.
+Test if the 2D vector is zero with `FLT_EPSILON` as error margin. Returns `true` if the values are accepted as equal to zero and `false` otherwise.
 
 ```c
 int pvector2_is_near_zero(struct vec *a, float epsilon);
 int vector2_is_near_zero(struct vec a, float epsilon);
 ```
 
-Test if the 2D vector is near zero with `epsilon` as error margin. Returns `TRUE` if the values are accepted as nearly equal to zero and `FALSE` otherwise.
+Test if the 2D vector is near zero with `epsilon` as error margin. Returns `true` if the values are accepted as nearly equal to zero and `false` otherwise.
 
 ```c
 int pvector2_is_equal(struct vec *a, struct vec *b, float epsilon);
 int vector2_is_equal(struct vec a, struct vec b, float epsilon);
 ```
 
-Test if the 2D vector `a` and the 2D vector `b` are equal with `epsilon` as error margin. Returns `TRUE` if the values are accepted as equal and `FALSE` otherwise.
+Test if the 2D vector `a` and the 2D vector `b` are equal with `epsilon` as error margin. Returns `true` if the values are accepted as equal and `false` otherwise.
 
 ```c
 void pvector2_add(struct vec *a, struct vec *b, struct vec *result);
@@ -294,21 +294,21 @@ int pvector3_is_zero(struct vec *a);
 int vector3_is_zero(struct vec a);
 ```
 
-Test if the 3D vector is zero with `FLT_EPSILON` as error margin. Returns `TRUE` if the values are accepted as equal to zero and `FALSE` otherwise.
+Test if the 3D vector is zero with `FLT_EPSILON` as error margin. Returns `true` if the values are accepted as equal to zero and `false` otherwise.
 
 ```c
 int pvector3_is_near_zero(struct vec *a, float epsilon);
 int vector3_is_near_zero(struct vec a, float epsilon);
 ```
 
-Test if the 3D vector is near zero with `epsilon` as error margin. Returns `TRUE` if the values are accepted as nearly equal to zero and `FALSE` otherwise.
+Test if the 3D vector is near zero with `epsilon` as error margin. Returns `true` if the values are accepted as nearly equal to zero and `false` otherwise.
 
 ```c
 int pvector3_is_equal(struct vec *a, struct vec *b, float epsilon);
 int vector3_is_equal(struct vec a, struct vec b, float epsilon);
 ```
 
-Test if the 3D vector `a` and the 3D vector `b` are equal with `epsilon` as error margin. Returns `TRUE` if the values are accepted as equal and `FALSE` otherwise.
+Test if the 3D vector `a` and the 3D vector `b` are equal with `epsilon` as error margin. Returns `true` if the values are accepted as equal and `false` otherwise.
 
 ```c
 void pvector3_add(struct vec *a, struct vec *b, struct vec *result);
@@ -492,21 +492,21 @@ int pquaternion_is_zero(struct vec *a);
 int quaternion_is_zero(struct vec a);
 ```
 
-Test if the quaternion is zero with `FLT_EPSILON` as error margin. Returns `TRUE` if the values are accepted as equal to zero and `FALSE` otherwise.
+Test if the quaternion is zero with `FLT_EPSILON` as error margin. Returns `true` if the values are accepted as equal to zero and `false` otherwise.
 
 ```c
 int pquaternion_is_near_zero(struct vec *a, float epsilon);
 int quaternion_is_near_zero(struct vec a, float epsilon);
 ```
 
-Test if the quaternion is near zero with `epsilon` as error margin. Returns `TRUE` if the values are accepted as nearly equal to zero and `FALSE` otherwise.
+Test if the quaternion is near zero with `epsilon` as error margin. Returns `true` if the values are accepted as nearly equal to zero and `false` otherwise.
 
 ```c
 int pquaternion_is_equal(struct vec *a, struct vec *b, float epsilon);
 int quaternion_is_equal(struct vec a, struct vec b, float epsilon);
 ```
 
-Test if the quaternion `a` and the quaternion `b` are equal with `epsilon` as error margin. Returns `TRUE` if the values are accepted as equal and `FALSE` otherwise.
+Test if the quaternion `a` and the quaternion `b` are equal with `epsilon` as error margin. Returns `true` if the values are accepted as equal and `false` otherwise.
 
 ```c
 void pquaternion_add(struct vec *a, struct vec *b, struct vec *result);
@@ -846,6 +846,22 @@ void matrix_to_array(struct mat m, float *result);
 
 Copy the elements of the matrix `m` to the array `result` with 16 `float` elements.
 
+## Intersection
+
+```c
+bool pvector2_in_circle(struct vec *v, struct vec *circle_position, float radius);
+bool vector2_in_circle(struct vec v, struct vec circle_position, float radius);
+```
+
+Test if the 2D vector `v` is inside the 2D circle at `circle_position` with radius `radius`. Returns `true` if the 2D vector is inside the 2D circle and `false` otherwise.
+
+```c
+bool pvector2_in_triangle(struct vec *v, struct vec *a, struct vec *b, struct vec *c);
+bool vector2_in_triangle(struct vec v, struct vec a, struct vec b, struct vec c);
+```
+
+Test if the 2D vector `v` is inside the 2D triangle with vertices `a`, `b` and `c`. Returns `true` if the 2D vector is inside the 2D triangle and `false` otherwise.
+
 ## Easing Functions
 
 ```c

From 111ee65ce6522b0c6d257c98d9e60efa6242cfc4 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Tue, 19 Dec 2017 11:11:54 -0300
Subject: [PATCH 065/102] Add function to multiply matrix with 3D vector

---
 mathc.c | 17 +++++++++++++++++
 mathc.h |  2 ++
 2 files changed, 19 insertions(+)

diff --git a/mathc.c b/mathc.c
index 95ec2d8..26cbe17 100644
--- a/mathc.c
+++ b/mathc.c
@@ -2226,6 +2226,23 @@ MATHC_EXTERN_INLINE void matrix_multiply_f4(struct mat m, float *result)
 	pmatrix_multiply_f4(&m, result);
 }
 
+void pmatrix_multiply_f3(struct mat *m, float *result)
+{
+	float v0 = result[0];
+	float v1 = result[1];
+	float v2 = result[2];
+	float v3 = 1.0f;
+	result[0] = (m->m11 * v0) + (m->m12 * v1) + (m->m13 * v2) + (m->m14 * v3);
+	result[1] = (m->m21 * v0) + (m->m22 * v1) + (m->m23 * v2) + (m->m24 * v3);
+	result[2] = (m->m31 * v0) + (m->m32 * v1) + (m->m33 * v2) + (m->m34 * v3);
+	result[3] = (m->m41 * v0) + (m->m42 * v1) + (m->m43 * v2) + (m->m44 * v3);
+}
+
+MATHC_EXTERN_INLINE void matrix_multiply_f3(struct mat m, float *result)
+{
+	pmatrix_multiply_f3(&m, result);
+}
+
 void pmatrix_to_array(struct mat *m, float *result)
 {
 	result[0] = m->m11;
diff --git a/mathc.h b/mathc.h
index b5e54c6..6bf0c2d 100644
--- a/mathc.h
+++ b/mathc.h
@@ -286,6 +286,7 @@ void pmatrix_multiply(struct mat *m, float s, struct mat *result);
 void pmatrix_multiply_matrix(struct mat *a, struct mat *b, struct mat *result);
 void pmatrix_linear_interpolation(struct mat *a, struct mat *b, float p, struct mat *result);
 void pmatrix_multiply_f4(struct mat *m, float *result);
+void pmatrix_multiply_f3(struct mat *m, float *result);
 void pmatrix_to_array(struct mat *m, float *result);
 
 struct mat matrix_zero(void);
@@ -312,6 +313,7 @@ struct mat matrix_multiply(struct mat m, float s);
 struct mat matrix_multiply_matrix(struct mat a, struct mat b);
 struct mat matrix_linear_interpolation(struct mat a, struct mat b, float p);
 void matrix_multiply_f4(struct mat m, float *result);
+void matrix_multiply_f3(struct mat m, float *result);
 void matrix_to_array(struct mat m, float *result);
 
 /* Intersection */

From a493072b587b104193838641aad858d9ef359745 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Tue, 19 Dec 2017 11:13:08 -0300
Subject: [PATCH 066/102] Update README.md

---
 README.md | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 7e306bf..eb3e254 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@ MATHC is a simple math library for 2D and 3D game programming. It contains imple
 - Matrices
 - Easing functions
 
-It support C99 standard or later.
+It support C99 standard or later. MATCH was made with focus on simplicity.
 
 ## Release
 
@@ -32,7 +32,7 @@ Check the file `CONTRIBUTING.md` for contribution rules and contributions of int
 
 Every structure and function uses `float`, because it is the most used type on 2D and 3D programming with OpenGL.
 
-**The type `float` loses precision with large numbers, why not use `double`?** Because every `double` value would be converted to `float` before sending to OpenGL, anyway. Which means your physics would run with high precision, but the rendering would still be affected by the `float` imprecision. Instead, *the good practice* to solve the problem with large numbers is to truncate the world position back to `[0.0f, 0.0f, 0.0f]` when the world distance to the center is too large. If the world is too big that even when truncating there are stil large numbers, the correct approach is to divide the world in chunks.
+**The type `float` is less precise with large numbers, why not use `double`?** Because every `double` value would be converted to `float` before sending to OpenGL, anyway. Which means your physics would run with high precision, but the rendering would still be affected by the `float` imprecision. Instead, *the good practice* to solve the problem with large numbers is to truncate the world position back to `[0.0f, 0.0f, 0.0f]` when the world distance to the center is too large. If the world is too big that even when truncating there are stil large numbers, the correct approach is to divide the world in chunks.
 
 ## Passing Arguments as Value or Pointer
 
@@ -93,7 +93,7 @@ You don't need to create your OpenGL buffer (VBO) to take 4 elements. When using
 
 All matrices are 4×4. There are functions for setting up projection matrices, view matrices and model matrices.
 
-Usually, model matrices are used to modify vertices on client-side or GPU-side. If you want to modify on client-side, you can use the functions `matrix_multiply_f4()` or `pmatrix_multiply_f4()` to modify an array with 4 `float` elements. Example:
+Model matrices are used to modify vertices on client-side or GPU-side. If you want to modify on client-side, you can use the functions `matrix_multiply_f4()` or `pmatrix_multiply_f4()` to modify an array with 4 `float` elements. Example:
 
 ```c
 float v[4] = {0.0f, 10.0f, 0.0f, 1.0f}; /* Compoments X, Y, Z and W */
@@ -110,6 +110,10 @@ struct mat view = matrix_look_at(to_vector3(0.0f, 0.0f, 1.0f),
 	to_vector3(0.0f, 0.0f, 0.0f));
 struct mat pv = matrix_multiply_matrix(projection, view);
 matrix_to_array(pv, v);
+/*
+After rotation, the new values of `v` are:
+[-7.071068f, 7.071068f, 0.000000f, 1.000000f]
+*/
 ```
 
 ## Easing Functions

From 8b315d9ff9230864893ef0799d9f9ca8837e3f95 Mon Sep 17 00:00:00 2001
From: Cong <congusbongus@gmail.com>
Date: Thu, 21 Dec 2017 21:54:59 +1100
Subject: [PATCH 067/102] Fix double to float warning

---
 mathc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mathc.c b/mathc.c
index 95ec2d8..1a50f9f 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1744,7 +1744,7 @@ void pmatrix_inverse(struct mat *m, struct mat *result)
 	det = m->m11 * inv.m11 + m->m21 * inv.m12 + m->m31 * inv.m13 + m->m41 * inv.m14;
 	/* Matrix can not be inverted if det == 0 */
 	if (det != 0) {
-		det = 1.0 / det;
+		det = 1.0f / det;
 	}
 	result->m11 = inv.m11 * det;
 	result->m21 = inv.m21 * det;

From 0970ef008d87a0931effeb85a0c3ebe4b7033d86 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 21 Dec 2017 09:34:36 -0300
Subject: [PATCH 068/102] Fix structure initialization

---
 mathc.c | 6 +++---
 test.c  | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/mathc.c b/mathc.c
index 2fddaeb..99ddc97 100644
--- a/mathc.c
+++ b/mathc.c
@@ -2287,9 +2287,9 @@ MATHC_EXTERN_INLINE bool vector2_in_circle(struct vec v, struct vec circle_posit
 static bool psame_side(struct vec *p1, struct vec *p2, struct vec *a, struct vec *b)
 {
 	bool result = false;
-	struct vec b_minus_a = {0};
-	struct vec p1_minus_a = {0};
-	struct vec p2_minus_a = {0};
+	struct vec b_minus_a = {0, 0, 0, 0};
+	struct vec p1_minus_a = {0, 0, 0, 0};
+	struct vec p2_minus_a = {0, 0, 0, 0};
 	struct vec cross_p1;
 	struct vec cross_p2;
 	pvector2_subtract(b, a, &b_minus_a);
diff --git a/test.c b/test.c
index fa079fd..d0891f2 100644
--- a/test.c
+++ b/test.c
@@ -447,7 +447,7 @@ void intersection_tests(struct cerror *error)
 
 int main(int argc, char **args)
 {
-	struct cerror error = {0};
+	struct cerror error = {0, 0, 0, 0, 0};
 	vector2_tests(&error);
 	vector3_tests(&error);
 	quaternion_tests(&error);

From 90e78cfc0efad23934ba9b563f70156d0d8462ad Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Tue, 2 Jan 2018 15:56:40 -0300
Subject: [PATCH 069/102] Update README.md

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index eb3e254..3c29e4a 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,8 @@
 
 [![Build Status](https://travis-ci.org/ferreiradaselva/mathc.svg?branch=master)](https://travis-ci.org/ferreiradaselva/mathc)
 
+Important: MATHC version 2 is currently under development with improvements. You can check out on branch `mathc2`.
+
 MATHC is a simple math library for 2D and 3D game programming. It contains implementations for:
 
 - 2D vectors

From c9228ed67ed18843a6d7e0dcaad79479133adc40 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 2 Aug 2018 23:19:07 -0300
Subject: [PATCH 070/102] Update for newer version

---
 .travis.yml     |    7 -
 CHANGELOG.md    |  102 -
 CONTRIBUTING.md |   14 -
 CONTRIBUTORS.md |   12 -
 LICENSE         |    2 +-
 README.md       |  140 +-
 REFERENCE.md    |  916 ------
 mathc.c         | 7387 ++++++++++++++++++++++++++++++++++++-----------
 mathc.h         | 1535 ++++++++--
 run_tests.sh    |   17 -
 test.c          |  462 ---
 11 files changed, 6925 insertions(+), 3669 deletions(-)
 delete mode 100644 .travis.yml
 delete mode 100644 CHANGELOG.md
 delete mode 100644 CONTRIBUTING.md
 delete mode 100644 CONTRIBUTORS.md
 delete mode 100644 REFERENCE.md
 delete mode 100755 run_tests.sh
 delete mode 100644 test.c

diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 3cf3668..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,7 +0,0 @@
-language: c
-compiler:
-  - clang
-  - gcc
-
-script:
-  - ./run_tests.sh
diff --git a/CHANGELOG.md b/CHANGELOG.md
deleted file mode 100644
index f7f4e4c..0000000
--- a/CHANGELOG.md
+++ /dev/null
@@ -1,102 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file, following semantic versioning.
-
-## Unreleased
-
-## 1.2.0 - 2017-11-21
-
-### Added
-
-- Functions `pvector2_in_circle`/`vector2_in_circle` to check if 2D vector is inside 2D circle.
-- Functions `pvector2_in_triangle`/`vector2_in_triangle` to check if 2D vector is inside 2D triangle.
-
-### Changed
-
-- Quaternion spherical interpolation use `0.95f` as cutoff to switch to linear interpolation.
-
-## 1.1.0 - 2017-11-18
-
-### Added
-
-- Functions `pquaternion_from_2_vectors`/`quaternion_from_2_vectors` to get quaternion from two vectors.
-- Functions `pquaternion_null`/`quaternion_null` to get null quaternion.
-
-### Changed
-
-- Fix missing declaration of function to get zero 3D vector.
-
-## 1.0.4 - 2017-11-18
-
-### Changed
-
-- Fix quaternion inverse function.
-
-## 1.0.3 - 2017-11-18
-
-### Changed
-
-- Fix checking if quaternion is zero.
-
-## 1.0.2 - 2017-11-13
-
-### Changed
-
-- Fix typo.
-
-## 1.0.1 - 2017-11-13
-
-### Changed
-
-- Use standard boolean.
-
-## 1.0.0 - 2017-11-13
-
-### Added
-
-- Version macros.
-
-## 0.3.0 - 2017-11-13
-
-### Added
-
-- Functions `pmatrix_linear_interpolation`/`matrix_linear_interpolation` for matrix linear interpolation.
-- Functions to test vector and quaternion equality:
-  - `pvector2_is_zero`/`vector2_is_zero`
-  - `pvector2_is_near_zero`/`vector2_is_near_zero`
-  - `pvector2_is_equal`/`vector2_is_equal`
-  - `pvector3_is_zero`/`vector3_is_zero`
-  - `pvector3_is_near_zero`/`vector3_is_near_zero`
-  - `pvector3_is_equal`/`vector3_is_equal`
-  - `pquatertion_is_zero`/`quatertion_is_zero`
-  - `pquatertion_is_near_zero`/`quatertion_is_near_zero`
-  - `pquatertion_is_equal`/`quatertion_is_equal`
-
-## 0.2.0 - 2017-11-11
-
-### Notes
-
-If you are using any of the functions to generate an projection matrices, you should update to one of the newer version. The perspective matrices only chaged in name, but the orthographic matrices changed in implementation, fixing the top-down orientation, and requiring a near and far clipping.
-
-### Added
-
-- Link in the `README.md` to this CHANGELOG file.
-- Functions `pmatrix_ortho`/`matrix_ortho` based on the old `pmatrix_ortho_zo`/`matrix_ortho_zo`.
-- Functions `pmatrix_perspective`/`matrix_perspective` based on the old `pmatrix_perspective_zo`/`matrix_perspective_zo`.
-- Functions `pmatrix_perspective_fov`/`matrix_perspective_fov` based on the old `pmatrix_perspective_fov_zo`/`matrix_perspective_fov_zo`.
-
-### Removed
-
-- Functions `pmatrix_ortho_zo`/`matrix_ortho_zo`.
-- Functions `pmatrix_ortho_no`/`matrix_ortho_no`.
-- Old functions `pmatrix_ortho`/`matrix_ortho`.
-- Functions `pmatrix_perspective_zo`/`matrix_perspective_zo`.
-- Functions `pmatrix_perspective_no`/`matrix_perspective_no`.
-- Functions `pmatrix_perspective_fov_zo`/`matrix_perspective_fov_zo`.
-- Functions `pmatrix_perspective_fov_no`/`matrix_perspective_fov_no`.
-
-## 0.1.0 - 2017-11-11
-
-### Added
-
-- This CHANGELOG file.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
deleted file mode 100644
index b31a3e1..0000000
--- a/CONTRIBUTING.md
+++ /dev/null
@@ -1,14 +0,0 @@
-# Contributing
-
-To contribute, open an issue or a pull request describing the feature or fix. Don't leave the explanation of the issue or pull request in blank.
-
-- At least until the version 2.0.0, the structure `vec` will remain as the structure for 2D vectors, 3D vectors and quaternions.
-- At least until the version 2.0.0, there will be only 4x4 matrices.
-- The orientation is right-handed for OpenGL compatibility. Focus on compatibility with other API is not of interest.
-- The library will remain licensed under ZLIB.
-
-## Contributions of interest
-
-- Adding functions useful for 2D or 3D graphics, physics or animation.
-- Deleting functions that prove useless.
-- Fixes.
diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
deleted file mode 100644
index e577312..0000000
--- a/CONTRIBUTORS.md
+++ /dev/null
@@ -1,12 +0,0 @@
-# Contributors
-
-- [@ratchetfreak](https://github.com/ratchetfreak) added `pquaternion_null`/`quaternion_null` and `pquaternion_from_2_vectors`/`quaternion_from_2_vectors`
-- [@ratchetfreak](https://github.com/ratchetfreak) found bug with function for quaternion inverse
-- [@ratchetfreak](https://github.com/ratchetfreak) found bug with function for testing if quaternion is zero
-- [@cxong](https://github.com/cxong) suggested functions to test vectors equality
-- [@cxong](https://github.com/cxong) suggested function to return zeroed vectors
-- [@cxong](https://github.com/cxong) fixed typos in `REFERENCE.md`
-- [@Ankush-p](https://github.com/Ankush-p) added `pmatrix_transpose`/`matrix_transpose` and `pmatrix_inverse`/`matrix_inverse`
-- [@Ankush-p](https://github.com/Ankush-p) fixed `pmatrix_rotation_axis`/`matrix_rotation_axis`
-- [@barrotsteindev](https://github.com/barrotsteindev) added Travis CI integration
-- [@Randy Gaul](https://github.com/RandyGaul) helped giving useful suggestions
diff --git a/LICENSE b/LICENSE
index 459e0f0..0c59f7a 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (C) 2016 Felipe Ferreira da Silva
+Copyright © 2018 Felipe Ferreira da Silva
 
 This software is provided 'as-is', without any express or implied warranty. In
 no event will the authors be held liable for any damages arising from the use of
diff --git a/README.md b/README.md
index 3c29e4a..5395ed3 100644
--- a/README.md
+++ b/README.md
@@ -1,134 +1,66 @@
 # MATHC
 
-[![Build Status](https://travis-ci.org/ferreiradaselva/mathc.svg?branch=master)](https://travis-ci.org/ferreiradaselva/mathc)
+MATHC is a simple math library for 2D and 3D programming.
 
-Important: MATHC version 2 is currently under development with improvements. You can check out on branch `mathc2`.
+## Features
 
-MATHC is a simple math library for 2D and 3D game programming. It contains implementations for:
-
-- 2D vectors
-- 3D vectors
+- Vectors (2D, 3D and 4D) (integer type and floating-point type)
 - Quaternions
-- Matrices
+- Matrices (2×2, 3×3, and 4×4)
 - Easing functions
 
-It support C99 standard or later. MATCH was made with focus on simplicity.
-
-## Release
-
-The CHANGELOG and RELEASE NOTES can be found in [CHANGELOG.md](CHANGELOG.md#020---2017-11-11).
-
-## Reference
-
-The reference is the file `REFERENCE.md`.
-
-There are examples on my other repository using this math library:
-
-[CGDFW examples](https://github.com/ferreiradaselva/cgdfw/tree/master/examples)
-
-## Contributing
-
-Check the file `CONTRIBUTING.md` for contribution rules and contributions of interest.
-
-## Float
-
-Every structure and function uses `float`, because it is the most used type on 2D and 3D programming with OpenGL.
-
-**The type `float` is less precise with large numbers, why not use `double`?** Because every `double` value would be converted to `float` before sending to OpenGL, anyway. Which means your physics would run with high precision, but the rendering would still be affected by the `float` imprecision. Instead, *the good practice* to solve the problem with large numbers is to truncate the world position back to `[0.0f, 0.0f, 0.0f]` when the world distance to the center is too large. If the world is too big that even when truncating there are stil large numbers, the correct approach is to divide the world in chunks.
-
-## Passing Arguments as Value or Pointer
+## Versioning
 
-For every function **that takes a structure**, there are two versions. One that you pass structures as value and other that you pass as pointer. The functions that pass the value by pointer have a prefix `p` before the type name (pvector2, pvector3, pquaternion and pmatrix) and the result is the `*result` argument or a returned `float`.
+Starting on version 2, the development of MATHC uses calendar versioning, with a tag `YYYY.MM.DD.MICRO` for each stable release, representing year, month and day, and `MICRO` for fixes. If a release breaks backward compatibility, then it is mentioned in the release notes.
 
-You can decide which one you want to use.
+## Configuring
 
-Examples:
+MATHC can be configured using these preprocessors:
 
-```c
-/* Pass by value and return a value */
-struct mat projection = matrix_ortho(-100.0f, 100.0f, 100.0f, -100.0f);
-struct mat view = matrix_look_at(to_vector3(0.0f, 0.0f, 1.0f),
-	to_vector3(0.0f, 0.0f, 0.0f));
-struct mat pv = matrix_multiply_matrix(projection, view);
-
-/* Pass by pointer */
-struct vec pos = {0};
-struct vec target = {0};
-struct mat projection = {0};
-struct mat view = {0};
-struct mat multiplied_matrix = {0};
-
-to_pvector3(0.0f, 0.0f, 1.0f, &pos);
-to_pvector3(0.0f, 0.0f, 0.0f, &target);
-to_pvector3(0.0f, 1.0f, 0.0f, &up);
-pmatrix_ortho(-100.0f, 100.0f, 100.0f, -100.0f, &projection);
-pmatrix_look_at(&pos, &target, &view);
-pmatrix_multiply_matrix(&projection, &view, &multiplied_matrix);
-```
+- `MATHC_NO_INT`: disable implementations using `mint_t`.
+- `MATHC_USE_INT8`: define `mint_t` as `int8_t`.
+- `MATHC_USE_INT16`: define `mint_t` as `int16_t`.
+- `MATHC_USE_INT32`: define `mint_t` as `int32_t`. This is the default.
+- `MATHC_USE_INT64`: define `mint_t` as `int64_t`.
+- `MATHC_INT_TYPE`: set a custom type for `mint_t`.
+- `MATHC_NO_FLOATING_POINT`: disable implementations using `mfloat_t`.
+- `MATHC_USE_SINGLE_FLOATING_POINT`: define `mfloat_t` as `float`. This is the default.
+- `MATHC_USE_DOUBLE_FLOATING_POINT`: define `mfloat_t` as `double`.
+- `MATHC_FLOATING_POINT_TYPE`: set a custom type for `mfloat_t`.
+- `MATHC_USE_UNIONS`: define anonymous unions inside structures.
+- `MATHC_NO_POINTER_STRUCT_FUNCTIONS`: don't define the functions that take pointer to structures.
+- `MATHC_NO_STRUCT_FUNCTIONS`: don't define the functions that take structures as value.
+- `MATHC_NO_EASING_FUNCTIONS`: don't define the easing functions.
 
-## Vectors
+You can define these preprocessors them using the compiler's option `-D` or using the compiler's option `-include` to include a configuration header and with the configuration macros defined inside it.
 
-All vectors (2D, 3D and quaternions) use the same structure type `struct vec`. The `z` component is still useful for 2D vectors, as it is used by OpenGL for depth testing. This means the only extra component on 2D and 3D vectors is the `w` component, which is used by quaternions.
-
-Examples:
+Example of a configuration header that makes `mint_t` a `int16_t`, `mfloat_t` a `GLfloat` and uses the standard math functions with double floating-point precision:
 
 ```c
-/* Rotate a 2D vector 90º */
-struct vec direction = to_vector2(0.0f, -1.0f);
-direction = vector2_rotate(90.0f * M_PIF / 180.0f);
-
-/* Get the angle (radians) of a 2D vector */
-float angle = vector2_angle(direction);
+#include <gl.h>
 
-/* Create a 3D vector */
-struct vec position = to_vector3(0.0f, 0.0f, 0.0f);
-
-/* Create a quaternion */
-struct vec quaternion = to_quaternion(0.0f, 0.0f, 0.0f, 1.0f);
-/* Spherical interpolation between two quaternions */
-struct vec interpolated = quaternion_spherical_linear_interpolation(a, b, 0.5f);
+#define MATHC_USE_INT16
+#define MATHC_FLOATING_POINT_TYPE GLfloat
+#define MATHC_USE_DOUBLE_FLOATING_POINT
 ```
 
-You don't need to create your OpenGL buffer (VBO) to take 4 elements. When using `glMapBufferRange()`/`glMapBuffer()` and `glUnmapBuffer()`, you can pass only the used elements to the VBO, that has element count of your choice.
+## Types
 
-## Matrices
+By default, types are can be declared as arrays of `mint_t`, arrays of `mfloat_t`, or structures.
 
-All matrices are 4×4. There are functions for setting up projection matrices, view matrices and model matrices.
+## Functions
 
-Model matrices are used to modify vertices on client-side or GPU-side. If you want to modify on client-side, you can use the functions `matrix_multiply_f4()` or `pmatrix_multiply_f4()` to modify an array with 4 `float` elements. Example:
-
-```c
-float v[4] = {0.0f, 10.0f, 0.0f, 1.0f}; /* Compoments X, Y, Z and W */
-struct mat rotation = matrix_rotation_z(to_radians(45.0f));
-matrix_multiply_f4(rotation, v);
-```
-
-If you want to modify on GPU-side, you can use the functions `matrix_to_array()` or `pmatrix_to_array()` to push the matrix to an array with 16 `float` elements. Example:
-
-```c
-float v[MAT_SIZE]; /* MAT_SIZE is a macro in mathc.h with value 16 */
-struct mat projection = matrix_ortho(-100.0f, 100.0f, -100.0f, 100.0f, 0.0f, 1.0f);
-struct mat view = matrix_look_at(to_vector3(0.0f, 0.0f, 1.0f),
-	to_vector3(0.0f, 0.0f, 0.0f));
-struct mat pv = matrix_multiply_matrix(projection, view);
-matrix_to_array(pv, v);
-/*
-After rotation, the new values of `v` are:
-[-7.071068f, 7.071068f, 0.000000f, 1.000000f]
-*/
-```
+By default, MATHC has functions that take as argument arrays of `mint_t`, arrays of `mfloat_t`, structures as value, or pointer to structures. Functions that take structure as value have a prefix `s`. Functions that take structure pointer have a prefix `ps`.
 
 ## Easing Functions
 
-The easing functions are an implementation of the functions presented in [easings.net](http://easings.net/). They are mainly useful for animations.
-
-Easing functions take a value that range from `0.0f` to `1.0f` and usually will return a value inside that same range. However, in some of the easing functions, the returned value extrapolate that range.
+The easing functions are an implementation of the functions presented in [easings.net](http://easings.net/), useful particularly for animations.
 
-## LICENSE
+Easing functions take a value inside the range `0.0-1.0` and usually will return a value inside that same range.
 
-The source code of this project is licensed under the terms of the ZLIB license:
+## License
 
-Copyright (C) 2016 Felipe Ferreira da Silva
+Copyright © 2018 Felipe Ferreira da Silva
 
 This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
 
diff --git a/REFERENCE.md b/REFERENCE.md
deleted file mode 100644
index f8c7379..0000000
--- a/REFERENCE.md
+++ /dev/null
@@ -1,916 +0,0 @@
-# MathC Reference
-
-## Utils
-
-```c
-#define M_PIF 3.1415926536f
-#define M_PIF_2 1.5707963268f
-#define MAT_SIZE 16
-```
-
-These are "syntactic sugar" macros that might be useful for the user.
-
-The `M_PIF` is the `float` value of Pi, and `M_PIF_2` is the `float` value of Pi divided by `2`. The macros `M_PI` and `M_PI_2` are not part of the C standard, and for that reason they are added here.
-
-The `MAT_SIZE` is more often useful, that allows the user to declare an array with the correct number of elements (`16`) of a 4x4 matrix instead of writing a [magic number](https://en.wikipedia.org/wiki/Magic_number_\(programming\)#Unnamed_numerical_constants) in the code.
-
-```c
-int nearly_equal(float a, float b, float epsilon);
-```
-
-Used to compare two `float` variables with an error margin `epsilon`. The standard header `<float.h>` comes with the macro `FLT_EPSILON` that can be used as the error margin. Greater values are also acceptable in most cases, such as `FLT_EPSILON * 10.0f` and `FLT_EPSILON * 100.0f`.
-
-Returns `true` if the values are accepted as equal and `false` otherwise.
-
-```c
-float to_radians(float degrees);
-```
-
-Return the angle `degrees` in radians.
-
-```c
-float to_degrees(float radians);
-```
-
-Return the angle `radians` in degrees.
-
-## Vector and Quaternion Structure
-
-Vectors (2D and 3D) and quaternions use the same structure `struct vec`.
-
-```c
-struct vec {
-	float x;
-	float y;
-	float z;
-	float w;
-};
-```
-
-## 2D Vector
-
-When using 2D vectors, it is good practice to initialize the variable with `0`, so the value of the `z` component is set to `0.0f`.
-
-Example:
-
-```
-struct vec position = {0};
-```
-
-The only functions that will set the `z` component of a 2D vector to `0.0f` are `to_pvector2()` and `to_vector2()`. The other operation functions will not change the `z` value, since it's useful when you need to modify yourself.
-
-Every function for 2D vectors will set the value of `w` to `1.0f`.
-
-```c
-void to_pvector2(float x, float y, struct vec *result);
-struct vec to_vector2(float x, float y);
-```
-
-The result is a 2D vector for the position `x` and `y`. The value of `z` is set to `0.0f`.
-
-```c
-void pvector2_zero(struct vec *result);
-struct vec vector2_zero(void);
-```
-
-The result is a zeroed 2D vector.
-
-```c
-int pvector2_is_zero(struct vec *a);
-int vector2_is_zero(struct vec a);
-```
-
-Test if the 2D vector is zero with `FLT_EPSILON` as error margin. Returns `true` if the values are accepted as equal to zero and `false` otherwise.
-
-```c
-int pvector2_is_near_zero(struct vec *a, float epsilon);
-int vector2_is_near_zero(struct vec a, float epsilon);
-```
-
-Test if the 2D vector is near zero with `epsilon` as error margin. Returns `true` if the values are accepted as nearly equal to zero and `false` otherwise.
-
-```c
-int pvector2_is_equal(struct vec *a, struct vec *b, float epsilon);
-int vector2_is_equal(struct vec a, struct vec b, float epsilon);
-```
-
-Test if the 2D vector `a` and the 2D vector `b` are equal with `epsilon` as error margin. Returns `true` if the values are accepted as equal and `false` otherwise.
-
-```c
-void pvector2_add(struct vec *a, struct vec *b, struct vec *result);
-struct vec vector2_add(struct vec a, struct vec b);
-```
-
-The result is a 2D vector for the addition of the 2D vector `a` with the 2D vector `b`.
-
-```c
-void pvector2_subtract(struct vec *a, struct vec *b, struct vec *result);
-struct vec vector2_subtract(struct vec a, struct vec b);
-```
-
-The result is a 2D vector for the subtraction of the 2D vector `a` with the 2D vector `b`.
-
-```c
-void pvector2_scale(struct vec *a, float scale, struct vec *result);
-struct vec vector2_scale(struct vec a, float scale);
-```
-
-The result is a 2D vector for the scaling of the 2D vector `a` with the value `scale`.
-
-```c
-void pvector2_multiply(struct vec *a, struct vec *b, struct vec *result);
-struct vec vector2_multiply(struct vec a, struct vec b);
-```
-
-The result is a 2D vector for the multiplication of the 2D vector `a` with the 2D vector `b`.
-
-```c
-void pvector2_divide(struct vec *a, struct vec *b, struct vec *result);
-struct vec vector2_divide(struct vec a, struct vec b);
-```
-
-The result is a 2D vector for the division of the 2D vector `a` with the 2D vector `b`.
-
-```c
-void pvector2_negative(struct vec *a, struct vec *result);
-struct vec vector2_negative(struct vec a);
-```
-
-The result is a 2D vector for the negation of the 2D vector `a`.
-
-```c
-void pvector2_inverse(struct vec *a, struct vec *result);
-struct vec vector2_inverse(struct vec a);
-```
-
-The result is a 2D vector for the inversion of the 2D vector `a`.
-
-```c
-void pvector2_abs(struct vec *a, struct vec *result);
-struct vec vector2_abs(struct vec a);
-```
-
-The result is a 2D vector for the 2D vector `a` with absolute values.
-
-```c
-void pvector2_floor(struct vec *a, struct vec *result);
-struct vec vector2_floor(struct vec a);
-```
-
-The result is a 2D vector for the 2D vector `a` with floored values.
-
-```c
-void pvector2_ceil(struct vec *a, struct vec *result);
-struct vec vector2_ceil(struct vec a);
-```
-
-The result is a 2D vector for the 2D vector `a` with ceiled values.
-
-```c
-void pvector2_round(struct vec *a, struct vec *result);
-struct vec vector2_round(struct vec a);
-```
-
-The result is a 2D vector for the 2D vector `a` with rounded values.
-
-```c
-void pvector2_max(struct vec *a, struct vec *b, struct vec *result);
-struct vec vector2_max(struct vec a, struct vec b);
-```
-
-The result is a 2D vector with the maximum values between the 2D vector `a` and the 2D vector `b`.
-
-```c
-void pvector2_min(struct vec *a, struct vec *b, struct vec *result);
-struct vec vector2_min(struct vec a, struct vec b);
-```
-
-The result is a 2D vector with the minimum values between the 2D vector `a` and the 2D vector `b`.
-
-```c
-float pvector2_dot(struct vec *a, struct vec *b);
-float vector2_dot(struct vec a, struct vec b);
-```
-
-The result is the dot product of the 2D vector `a` with the 2D vector `b`.
-
-```c
-float pvector2_angle(struct vec *a);
-float vector2_angle(struct vec a);
-```
-
-The result is the angle of the 2D vector `a` with the origin.
-
-```c
-float pvector2_length_squared(struct vec *a);
-float vector2_length_squared(struct vec a);
-```
-
-The result is the length squared of the 2D vector `a`.
-
-```c
-float pvector2_length(struct vec *a);
-float vector2_length(struct vec a);
-```
-
-The result is the length of the 2D vector `a`.
-
-```c
-void pvector2_normalize(struct vec *a, struct vec *result);
-struct vec vector2_normalize(struct vec a);
-```
-
-The result is a 2D vector for the normalized 2D vector `a`.
-
-```c
-void pvector2_slide(struct vec *a, struct vec *normal, struct vec *result);
-struct vec vector2_slide(struct vec a, struct vec normal);
-```
-
-The result is a 2D vector for the slided 2D vector `a` against the 2D vector `normal`.
-
-```c
-void pvector2_reflect(struct vec *a, struct vec *normal, struct vec *result);
-struct vec vector2_reflect(struct vec a, struct vec normal);
-```
-
-The result is a 2D vector for the reflected 2D vector `a` against the 2D vector `normal`.
-
-```c
-void pvector2_tangent(struct vec *a, struct vec *result);
-struct vec vector2_tangent(struct vec a);
-```
-
-The result is a 2D vector for the tangent of the 2D vector `a`.
-
-```c
-void pvector2_rotate(struct vec *a, float angle, struct vec *result);
-struct vec vector2_rotate(struct vec a, float angle);
-```
-
-The result is a 2D vector for the rotated 2D vector `a` with the value in radians `angle`.
-
-```c
-float pvector2_distance_to(struct vec *a, struct vec *b);
-float vector2_distance_to(struct vec a, struct vec b);
-```
-
-The result is the distance between the 2D vector `a` and the 2D vector `b`.
-
-```c
-float pvector2_distance_squared_to(struct vec *a, struct vec *b);
-float vector2_distance_squared_to(struct vec a, struct vec b);
-```
-
-The result is the distance squared between the 2D vector `a` and the 2D vector `b`.
-
-```c
-void pvector2_linear_interpolation(struct vec *a, struct vec *b, float, p, struct vec *result);
-struct vec vector2_linear_interpolation(struct vec a, struct vec b, float p);
-```
-
-The result is a 2D vector for the linear interpolation between the 2D vector `a` and the 2D vector `b` with the value `p`.
-
-## 3D Vector
-
-Every function for 3D vectors will set the value of `w` to `1.0f`.
-
-```c
-void to_pvector3(float x, float y, float z, struct vec *result);
-struct vec to_vector2(float x, float y, float z);
-```
-
-The result is a 3D vector for the position `x`, `y` and `z`.
-
-```c
-void pvector3_zero(struct vec *result);
-struct vec vector3_zero(void);
-```
-
-The result is a zeroed 3D vector.
-
-```c
-int pvector3_is_zero(struct vec *a);
-int vector3_is_zero(struct vec a);
-```
-
-Test if the 3D vector is zero with `FLT_EPSILON` as error margin. Returns `true` if the values are accepted as equal to zero and `false` otherwise.
-
-```c
-int pvector3_is_near_zero(struct vec *a, float epsilon);
-int vector3_is_near_zero(struct vec a, float epsilon);
-```
-
-Test if the 3D vector is near zero with `epsilon` as error margin. Returns `true` if the values are accepted as nearly equal to zero and `false` otherwise.
-
-```c
-int pvector3_is_equal(struct vec *a, struct vec *b, float epsilon);
-int vector3_is_equal(struct vec a, struct vec b, float epsilon);
-```
-
-Test if the 3D vector `a` and the 3D vector `b` are equal with `epsilon` as error margin. Returns `true` if the values are accepted as equal and `false` otherwise.
-
-```c
-void pvector3_add(struct vec *a, struct vec *b, struct vec *result);
-struct vec vector3_add(struct vec a, struct vec b);
-```
-
-The result is a 3D vector for the addition of the 3D vector `a` with the 3D vector `b`.
-
-```c
-void pvector3_subtract(struct vec *a, struct vec *b, struct vec *result);
-struct vec vector3_subtract(struct vec a, struct vec b);
-```
-
-The result is a 3D vector for the subtraction of the 3D vector `a` with the 3D vector `b`.
-
-```c
-void pvector3_scale(struct vec *a, float scale, struct vec *result);
-struct vec vector3_scale(struct vec a, float scale);
-```
-
-The result is a 3D vector for the scaling of the 3D vector `a` with the value `scale`.
-
-```c
-void pvector3_multiply(struct vec *a, struct vec *b, struct vec *result);
-struct vec vector3_multiply(struct vec a, struct vec b);
-```
-
-The result is a 3D vector for the multiplication of the 3D vector `a` with the 3D vector `b`.
-
-```c
-void pvector3_divide(struct vec *a, struct vec *b, struct vec *result);
-struct vec vector3_divide(struct vec a, struct vec b);
-```
-
-The result is a 3D vector for the division of the 3D vector `a` with the 3D vector `b`.
-
-```c
-void pvector3_negative(struct vec *a, struct vec *result);
-struct vec vector3_negative(struct vec a);
-```
-
-The result is a 3D vector for the negation of the 3D vector `a`.
-
-```c
-void pvector3_inverse(struct vec *a, struct vec *result);
-struct vec vector3_inverse(struct vec a);
-```
-
-The result is a 3D vector for the inversion of the 3D vector `a`.
-
-```c
-void pvector3_abs(struct vec *a, struct vec *result);
-struct vec vector3_abs(struct vec a);
-```
-
-The result is a 3D vector for the 3D vector `a` with absolute values.
-
-```c
-void pvector3_floor(struct vec *a, struct vec *result);
-struct vec vector3_floor(struct vec a);
-```
-
-The result is a 3D vector for the 3D vector `a` with floored values.
-
-```c
-void pvector3_ceil(struct vec *a, struct vec *result);
-struct vec vector3_ceil(struct vec a);
-```
-
-The result is a 3D vector for the 3D vector `a` with ceiled values.
-
-```c
-void pvector3_round(struct vec *a, struct vec *result);
-struct vec vector3_round(struct vec a);
-```
-
-The result is a 3D vector for the 3D vector `a` with rounded values.
-
-```c
-void pvector3_max(struct vec *a, struct vec *b, struct vec *result);
-struct vec vector3_max(struct vec a, struct vec b);
-```
-
-The result is a 3D vector with the maximum values between the 3D vector `a` and the 3D vector `b`.
-
-```c
-void pvector3_min(struct vec *a, struct vec *b, struct vec *result);
-struct vec vector3_min(struct vec a, struct vec b);
-```
-
-The result is a 3D vector with the minimum values between the 3D vector `a` and the 3D vector `b`.
-
-```c
-float pvector3_dot(struct vec *a, struct vec *b);
-float vector3_dot(struct vec a, struct vec b);
-```
-
-The result is the dot product of the 3D vector `a` with the 3D vector `b`.
-
-```c
-float pvector3_cross(struct vec *a, struct vec *b);
-float vector3_cross(struct vec a, struct vec b);
-```
-
-The result is the cross product of the 3D vector `a` with the 3D vector `b`.
-
-```c
-float pvector3_length_squared(struct vec *a);
-float vector3_length_squared(struct vec a);
-```
-
-The result is the length squared of the 3D vector `a`.
-
-```c
-float pvector3_length(struct vec *a);
-float vector3_length(struct vec a);
-```
-
-The result is the length of the 3D vector `a`.
-
-```c
-void pvector3_normalize(struct vec *a, struct vec *result);
-struct vec vector3_normalize(struct vec a);
-```
-
-The result is a 3D vector for the normalized 3D vector `a`.
-
-```c
-void pvector3_slide(struct vec *a, struct vec *normal, struct vec *result);
-struct vec vector3_slide(struct vec a, struct vec normal);
-```
-
-The result is a 3D vector for the slided 3D vector `a` against the 3D vector `normal`.
-
-```c
-void pvector3_reflect(struct vec *a, struct vec *normal, struct vec *result);
-struct vec vector3_reflect(struct vec a, struct vec normal);
-```
-
-The result is a 3D vector for the reflected 3D vector `a` against the 3D vector `normal`.
-
-```c
-float pvector3_distance_to(struct vec *a, struct vec *b);
-float vector3_distance_to(struct vec a, struct vec b);
-```
-
-The result is the distance between the 3D vector `a` and the 3D vector `b`.
-
-```c
-float pvector3_distance_squared_to(struct vec *a, struct vec *b);
-float vector3_distance_squared_to(struct vec a, struct vec b);
-```
-
-The result is the distance squared between the 3D vector `a` and the 3D vector `b`.
-
-```c
-void pvector3_linear_interpolation(struct vec *a, struct vec *b, float, p, struct vec *result);
-struct vec vector3_linear_interpolation(struct vec a, struct vec b, float p);
-```
-
-The result is a 3D vector for the linear interpolation between the 3D vector `a` and the 3D vector `b` with the value `p`.
-
-## Quaternion
-
-```c
-void to_pquaternion(float x, float y, float z, struct vec *result);
-struct vec to_quaternion(float x, float y, float z);
-```
-
-The result is a quaternion for the position `x`, `y` and `z`.
-
-```c
-void pquaternion_zero(struct vec *result);
-struct vec quaternion_zero();
-```
-
-The result is a zeroed quaternion.
-
-```c
-int pquaternion_is_zero(struct vec *a);
-int quaternion_is_zero(struct vec a);
-```
-
-Test if the quaternion is zero with `FLT_EPSILON` as error margin. Returns `true` if the values are accepted as equal to zero and `false` otherwise.
-
-```c
-int pquaternion_is_near_zero(struct vec *a, float epsilon);
-int quaternion_is_near_zero(struct vec a, float epsilon);
-```
-
-Test if the quaternion is near zero with `epsilon` as error margin. Returns `true` if the values are accepted as nearly equal to zero and `false` otherwise.
-
-```c
-int pquaternion_is_equal(struct vec *a, struct vec *b, float epsilon);
-int quaternion_is_equal(struct vec a, struct vec b, float epsilon);
-```
-
-Test if the quaternion `a` and the quaternion `b` are equal with `epsilon` as error margin. Returns `true` if the values are accepted as equal and `false` otherwise.
-
-```c
-void pquaternion_add(struct vec *a, struct vec *b, struct vec *result);
-struct vec quaternion_add(struct vec a, struct vec b);
-```
-
-The result is a quaternion for the addition of the quaternion `a` with the quaternion `b`.
-
-```c
-void pquaternion_subtract(struct vec *a, struct vec *b, struct vec *result);
-struct vec quaternion_subtract(struct vec a, struct vec b);
-```
-
-The result is a quaternion for the subtraction of the quaternion `a` with the quaternion `b`.
-
-```c
-void pquaternion_scale(struct vec *a, float scale, struct vec *result);
-struct vec quaternion_scale(struct vec a, float scale);
-```
-
-The result is a quaternion for the scaling of the quaternion `a` with the value `scale`.
-
-```c
-void pquaternion_multiply(struct vec *a, struct vec *b, struct vec *result);
-struct vec quaternion_multiply(struct vec a, struct vec b);
-```
-
-The result is a quaternion for the multiplication of the quaternion `a` with the quaternion `b`.
-
-```c
-void pquaternion_divide(struct vec *a, struct vec *b, struct vec *result);
-struct vec quaternion_divide(struct vec a, struct vec b);
-```
-
-The result is a quaternion for the division of the quaternion `a` with the quaternion `b`.
-
-```c
-void pquaternion_negative(struct vec *a, struct vec *result);
-struct vec quaternion_negative(struct vec a);
-```
-
-The result is a quaternion for the negation of the quaternion `a`.
-
-```c
-void pquaternion_conjugate(struct vec *a, struct vec *result);
-struct vec quaternion_conjugate(struct vec a);
-```
-
-The result is a quaternion for the conjugate of the quaternion `a`.
-
-```c
-void pquaternion_inverse(struct vec *a, struct vec *result);
-struct vec quaternion_inverse(struct vec a);
-```
-
-The result is a quaternion for the inversion of the quaternion `a`.
-
-```c
-void pquaternion_abs(struct vec *a, struct vec *result);
-struct vec quaternion_abs(struct vec a);
-```
-
-The result is a quaternion for the quaternion `a` with absolute values.
-
-```c
-void pquaternion_floor(struct vec *a, struct vec *result);
-struct vec quaternion_floor(struct vec a);
-```
-
-The result is a quaternion for the quaternion `a` with floored values.
-
-```c
-void pquaternion_ceil(struct vec *a, struct vec *result);
-struct vec quaternion_ceil(struct vec a);
-```
-
-The result is a quaternion for the quaternion `a` with ceiled values.
-
-```c
-void pquaternion_round(struct vec *a, struct vec *result);
-struct vec quaternion_round(struct vec a);
-```
-
-The result is a quaternion for the quaternion `a` with rounded values.
-
-```c
-void pquaternion_max(struct vec *a, struct vec *b, struct vec *result);
-struct vec quaternion_max(struct vec a, struct vec b);
-```
-
-The result is a quaternion with the maximum values between the quaternion `a` and the quaternion `b`.
-
-```c
-void pquaternion_min(struct vec *a, struct vec *b, struct vec *result);
-struct vec quaternion_min(struct vec a, struct vec b);
-```
-
-The result is a quaternion with the minimum values between the quaternion `a` and the quaternion `b`.
-
-```c
-float pquaternion_dot(struct vec *a, struct vec *b);
-float quaternion_dot(struct vec a, struct vec b);
-```
-
-The result is the dot product of the quaternion `a` with the quaternion `b`.
-
-```c
-float pquaternion_angle(struct vec *a, struct vec *b);
-float quaternion_angle(struct vec a, struct vec b);
-```
-
-The result is the angle between the quaternion `a` and the quaternion `b`.
-
-```c
-float pquaternion_length_squared(struct vec *a);
-float quaternion_length_squared(struct vec a);
-```
-
-The result is the length squared of the quaternion `a`.
-
-```c
-float pquaternion_length(struct vec *a);
-float quaternion_length(struct vec a);
-```
-
-The result is the length of the quaternion `a`.
-
-```c
-void pquaternion_normalize(struct vec *a, struct vec *result);
-struct vec quaternion_normalize(struct vec a);
-```
-
-The result is a quaternion for the normalized quaternion `a`.
-
-```c
-void pquaternion_power(struct vec *a, float exponent, struct vec *result);
-struct vec quaternion_power(struct vec a, float exponent);
-```
-
-The result is a quaternion for the quaternion `a` raised to the exponent `exponent`.
-
-```c
-void pquaternion_from_axis_angle(struct vec *a, float angle, struct vec *result);
-struct vec quaternion_from_axis_angle(struct vec a, float angle);
-```
-
-The result is a quaternion for the 3D vector `a` with the value in radians `angle`.
-
-```c
-void pquaternion_rotation_matrix(struct mat *m, struct vec *result);
-struct vec quaternion_rotation_matrix(struct mat m);
-```
-
-The result is a quaternion for the rotation matrix `m`.
-
-```c
-void pquaternion_yaw_pitch_roll(float yaw, float pitch, float roll, struct vec *result);
-struct vec quaternion_yaw_pitch_roll(float yaw, float pitch, float roll);
-```
-
-The result is a quaternion for the vertical axis `yaw`, the lateral axis `pitch` and the longitudinal axis `roll`.
-
-```c
-void pquaternion_linear_interpolation(struct vec *a, struct vec *b, float, p, struct vec *result);
-struct vec quaternion_linear_interpolation(struct vec a, struct vec b, float p);
-```
-
-The result is a quaternion for the linear interpolation between the quaternion `a` and the quaternion `b` with the value `p`.
-
-```c
-void pquaternion_spherical_linear_interpolation(struct vec *a, struct vec *b, float, p, struct vec *result);
-struct vec quaternion_spherical_linear_interpolation(struct vec a, struct vec b, float p);
-```
-
-The result is a quaternion for the spherical linear interpolation between the quaternion `a` and the quaternion `b` with the value `p`.
-
-## Matrix
-
-```c
-void pmatrix_identity(struct mat *result);
-struct mat matrix_identity(void);
-```
-
-The result is a identity matrix.
-
-```c
-void pmatrix_transpose(struct mat *m, struct mat *result);
-struct mat matrix_transpose(struct mat m);
-```
-
-The result is the transpose of the matrix `m`.
-
-```c
-void pmatrix_inverse(struct mat *m, struct mat *result);
-struct mat matrix_inverse(struct mat m);
-```
-
-The result is the inverse of the matrix `m`.
-
-```c
-void pmatrix_ortho(float l, float r, float b, float t, float n, float f, struct mat *result);
-struct mat matrix_ortho(float l, float r, float b, float t, float n, float f);
-```
-
-The result is a orthographic projection matrix with left `l`, right `r`, bottom `b` top `t`, near clipping `n` and far clipping `f`.
-
-```c
-void pmatrix_perspective(float fov_y, float aspect, float n, float f, struct mat *result);
-struct mat matrix_perspective(float fov_y, float aspect, float n, float f);
-```
-
-The result is a perspective projection matrix with field of view of Y axis `fov_y`, in radians, aspect ratio `aspect`, near clipping `n` and far clipping `f`.
-
-```c
-void pmatrix_perspective_fov(float fov, float w, float h, float n, float f, struct mat *result);
-struct mat matrix_perspective_fov(float fov, float w, float h, float n, float f);
-```
-
-The result is a perspective projection matrix with field of view `fov`, width `w`, height `h`, near clipping `n` and far clipping `f`.
-
-```c
-void pmatrix_perspective_infinite(float fov_y, float aspect, float n, struct mat *result);
-struct mat matrix_perspective_infinite(float fov_y, float aspect, float n);
-```
-
-The result is a perspective projection matrix with field of view of Y axis `fov_y`, aspect ratio `aspct` and near clipping `n`.
-
-```c
-void pmatrix_rotation_x(float angle, struct mat *result);
-struct mat matrix_rotation_x(float angle);
-```
-
-The result is a rotation matrix with radians `angle` on the X axis.
-
-```c
-void pmatrix_rotation_y(float angle, struct mat *result);
-struct mat matrix_rotation_y(float angle);
-```
-
-The result is a rotation matrix with radians `angle` on the Y axis.
-
-```c
-void pmatrix_rotation_z(float angle, struct mat *result);
-struct mat matrix_rotation_z(float angle);
-```
-
-The result is a rotation matrix with radians `angle` on the Z axis.
-
-```c
-void pmatrix_rotation_axis(struct vec *a, float angle, struct mat *result);
-struct mat matrix_rotation_axis(struct vec a, float angle);
-```
-
-The result is a rotation matrix with radians `angle` on the axis of the 3D vector `a`.
-
-```c
-void pmatrix_rotation_quaternion(struct vec *q, struct mat *result);
-struct mat matrix_rotation_quaternion(struct vec q);
-```
-
-The result is a rotation matrix from the quaternion `q`.
-
-```c
-void pmatrix_look_at(struct vec *pos, struct vec *target, struct mat *result);
-struct mat matrix_look_at(struct vec pos, struct vec target);
-```
-
-The result is a view matrix with the position at the 3D vector `pos`, looking at the 3d vector `target`. The up direction is assumed `[0.0f, 1.0f, 0.0f]`.
-
-```c
-void pmatrix_scale(struct vec *v, struct mat *result);
-struct mat matrix_scale(struct vec v);
-```
-
-The result is a scaling matrix for the 3D vector `v`.
-
-```c
-void pmatrix_get_scale(struct mat *m, struct vec *result);
-struct vec matrix_get_scale(struct mat m);
-```
-
-The result is a 3D vector from the scale of the scale matrix `m`.
-
-```c
-void pmatrix_translation(struct vec *v, struct mat *result);
-struct mat matrix_translation(struct vec v);
-```
-
-The result is a translation matrix for the 3D vector `v`.
-
-```c
-void pmatrix_get_translation(struct mat *m, struct vec *result);
-struct vec matrix_get_translation(struct mat m);
-```
-
-The result is a 3D vector from the translation of the translation matrix `m`.
-
-```c
-void pmatrix_negative(struct mat *m, struct mat *result);
-struct mat matrix_negative(struct mat m);
-```
-
-The result is a matrix for the negation of the matrix `m`.
-
-```c
-void pmatrix_multiply(struct mat *m, float s, struct mat *result);
-struct mat matrix_multiply(struct mat m, float s);
-```
-
-The result is a matrix for the multiplication of the matrix `a` with the scale `s`.
-
-```c
-void pmatrix_multiply_matrix(struct mat *a, struct mat *b, struct mat *result);
-struct mat matrix_multiply_matrix(struct mat a, struct mat b);
-```
-
-The result is a matrix for the multiplication of the matrix `a` with the matrix `b`.
-
-```c
-void pmatrix_linear_interpolation(struct mat *a, struct mat *b, float p, struct mat *result);
-struct mat matrix_linear_interpolation(struct mat a, struct mat b, float p);
-```
-
-The result is a matrix for the linear interpolation between the matrix `a` and the matrix `b` with the value `p`.
-
-```c
-void pmatrix_multiply_f4(struct mat *m, float *result);
-void matrix_multiply_f4(struct mat m, float *result);
-```
-
-Multiply the values of the array `result` with 4 `float` elements by the matrix `m`.
-
-```c
-void pmatrix_to_array(struct mat *m, float *result);
-void matrix_to_array(struct mat m, float *result);
-```
-
-Copy the elements of the matrix `m` to the array `result` with 16 `float` elements.
-
-## Intersection
-
-```c
-bool pvector2_in_circle(struct vec *v, struct vec *circle_position, float radius);
-bool vector2_in_circle(struct vec v, struct vec circle_position, float radius);
-```
-
-Test if the 2D vector `v` is inside the 2D circle at `circle_position` with radius `radius`. Returns `true` if the 2D vector is inside the 2D circle and `false` otherwise.
-
-```c
-bool pvector2_in_triangle(struct vec *v, struct vec *a, struct vec *b, struct vec *c);
-bool vector2_in_triangle(struct vec v, struct vec a, struct vec b, struct vec c);
-```
-
-Test if the 2D vector `v` is inside the 2D triangle with vertices `a`, `b` and `c`. Returns `true` if the 2D vector is inside the 2D triangle and `false` otherwise.
-
-## Easing Functions
-
-```c
-float quadratic_ease_in(float p);
-float quadratic_ease_out(float p);
-float quadratic_ease_in_out(float p);
-float cubic_ease_in(float p);
-float cubic_ease_out(float p);
-float cubic_ease_in_out(float p);
-float quartic_ease_in(float p);
-float quartic_ease_out(float p);
-float quartic_ease_in_out(float p);
-float quintic_ease_in(float p);
-float quintic_ease_out(float p);
-float quintic_ease_in_out(float p);
-float sine_ease_in(float p);
-float sine_ease_out(float p);
-float sine_ease_in_out(float p);
-float circular_ease_in(float p);
-float circular_ease_out(float p);
-float circular_ease_in_out(float p);
-float exponential_ease_in(float p);
-float exponential_ease_out(float p);
-float exponential_ease_in_out(float p);
-float elastic_ease_in(float p);
-float elastic_ease_out(float p);
-float elastic_ease_in_out(float p);
-float back_ease_in(float p);
-float back_ease_out(float p);
-float back_ease_in_out(float p);
-float bounce_ease_in(float p);
-float bounce_ease_out(float p);
-float bounce_ease_in_out(float p);
-```
-
-Each easing function will return a rate of change for `p`. The value of `p` must be inside the range `0.0f-1.0f`.
-
-The graphic visualization of the easing functions can be found on [easing.net](http://easings.net/).
-
-# LICENSE
-
-The source code of this project is licensed under the terms of the ZLIB license:
-
-Copyright (C) 2016 Felipe Ferreira da Silva
-
-This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:
-
-1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
-2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
-3. This notice may not be removed or altered from any source distribution.
diff --git a/mathc.c b/mathc.c
index 99ddc97..5174e47 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1,5 +1,5 @@
 /*
-Copyright (C) 2016 Felipe Ferreira da Silva
+Copyright © 2018 Felipe Ferreira da Silva
 
 This software is provided 'as-is', without any express or implied warranty. In
 no event will the authors be held liable for any damages arising from the use of
@@ -18,2535 +18,6490 @@ the following restrictions:
   3. This notice may not be removed or altered from any source distribution.
 */
 
-#include <math.h>
-#include <float.h>
 #include "mathc.h"
 
-/* Check C standard */
-#ifdef __STDC__
-  #define PREDEF_STANDARD_C89
-  #ifdef __STDC_VERSION__
-    #if __STDC_VERSION__ >= 199901L
-      #define PREDEF_STANDARD_C99
-    #endif
-  #endif
+#if defined(MATHC_USE_FLOATING_POINT)
+bool nearly_equal(mfloat_t a, mfloat_t b, mfloat_t epsilon)
+{
+	bool result = false;
+	if (a == b) {
+		result = true;
+	} else if (MFABS(a - b) <= epsilon) {
+		result = true;
+	}
+	return result;
+}
+
+mfloat_t to_radians(mfloat_t degrees)
+{
+	return degrees * MPI / MFLOAT_C(180.0);
+}
+
+mfloat_t to_degrees(mfloat_t radians)
+{
+	return radians * MFLOAT_C(180.0) / MPI;
+}
+#endif
+
+#if defined(MATHC_USE_INT)
+bool vec2i_is_zero(mint_t *vec2i0)
+{
+	return vec2i0[0] == 0 && vec2i0[1] == 0;
+}
+
+bool vec2i_is_equal(mint_t *vec2i0, mint_t *vec2i1)
+{
+	return vec2i0[0] == vec2i1[0] && vec2i0[1] == vec2i1[1];
+}
+
+mint_t *vec2i(mint_t *result, mint_t x, mint_t y)
+{
+	result[0] = x;
+	result[1] = y;
+	return result;
+}
+
+mint_t *vec2i_assign(mint_t *result, mint_t *vec2i0)
+{
+	result[0] = vec2i0[0];
+	result[1] = vec2i0[1];
+	return result;
+}
+
+#if defined(MATHC_USE_FLOATING_POINT)
+mint_t *vec2i_assign_vec2(mint_t *result, mfloat_t *vec20)
+{
+	result[0] = vec20[0];
+	result[1] = vec20[1];
+	return result;
+}
+#endif
+
+mint_t *vec2i_zero(mint_t *result)
+{
+	result[0] = 0;
+	result[1] = 0;
+	return result;
+}
+
+mint_t *vec2i_one(mint_t *result)
+{
+	result[0] = 1;
+	result[1] = 1;
+	return result;
+}
+
+mint_t *vec2i_sign(mint_t *result, mint_t *vec2i0)
+{
+	if (vec2i0[0] > 0) {
+		result[0] = 1;
+	} else if (vec2i0[0] < 0) {
+		result[0] = -1;
+	} else {
+		result[0] = 0;
+	}
+	if (vec2i0[1] > 0) {
+		result[1] = 1;
+	} else if (vec2i0[1] < 0) {
+		result[1] = -1;
+	} else {
+		result[1] = 0;
+	}
+	return result;
+}
+
+mint_t *vec2i_add(mint_t *result, mint_t *vec2i0, mint_t *vec2i1)
+{
+	result[0] = vec2i0[0] + vec2i1[0];
+	result[1] = vec2i0[1] + vec2i1[1];
+	return result;
+}
+
+mint_t *vec2i_add_i(mint_t *result, mint_t *vec2i0, mint_t i)
+{
+	result[0] = vec2i0[0] + i;
+	result[1] = vec2i0[1] + i;
+	return result;
+}
+
+mint_t *vec2i_subtract(mint_t *result, mint_t *vec2i0, mint_t *vec2i1)
+{
+	result[0] = vec2i0[0] - vec2i1[0];
+	result[1] = vec2i0[1] - vec2i1[1];
+	return result;
+}
+
+mint_t *vec2i_subtract_i(mint_t *result, mint_t *vec2i0, mint_t i)
+{
+	result[0] = vec2i0[0] - i;
+	result[1] = vec2i0[1] - i;
+	return result;
+}
+
+mint_t *vec2i_multiply(mint_t *result, mint_t *vec2i0, mint_t *vec2i1)
+{
+	result[0] = vec2i0[0] * vec2i1[0];
+	result[1] = vec2i0[1] * vec2i1[1];
+	return result;
+}
+
+mint_t *vec2i_multiply_i(mint_t *result, mint_t *vec2i0, mint_t i)
+{
+	result[0] = vec2i0[0] * i;
+	result[1] = vec2i0[1] * i;
+	return result;
+}
+
+mint_t *vec2i_divide(mint_t *result, mint_t *vec2i0, mint_t *vec2i1)
+{
+	result[0] = vec2i0[0] / vec2i1[0];
+	result[1] = vec2i0[1] / vec2i1[1];
+	return result;
+}
+
+mint_t *vec2i_divide_i(mint_t *result, mint_t *vec2i0, mint_t i)
+{
+	result[0] = vec2i0[0] / i;
+	result[1] = vec2i0[1] / i;
+	return result;
+}
+
+mint_t *vec2i_snap(mint_t *result, mint_t *vec2i0, mint_t *vec2i1)
+{
+	result[0] = (vec2i0[0] / vec2i1[0]) * vec2i1[0];
+	result[1] = (vec2i0[1] / vec2i1[1]) * vec2i1[1];
+	return result;
+}
+
+mint_t *vec2i_snap_i(mint_t *result, mint_t *vec2i0, mint_t i)
+{
+	result[0] = (vec2i0[0] / i) * i;
+	result[1] = (vec2i0[1] / i) * i;
+	return result;
+}
+
+mint_t *vec2i_negative(mint_t *result, mint_t *vec2i0)
+{
+	result[0] = -vec2i0[0];
+	result[1] = -vec2i0[1];
+	return result;
+}
+
+mint_t *vec2i_abs(mint_t *result, mint_t *vec2i0)
+{
+	result[0] = vec2i0[0];
+	if (result[0] < 0) {
+		result[0] = -result[0];
+	}
+	result[1] = vec2i0[1];
+	if (result[1] < 0) {
+		result[1] = -result[1];
+	}
+	return result;
+}
+
+mint_t *vec2i_max(mint_t *result, mint_t *vec2i0, mint_t *vec2i1)
+{
+	if (vec2i0[0] > vec2i1[0]) {
+		result[0] = vec2i0[0];
+	} else {
+		result[0] = vec2i1[0];
+	}
+	if (vec2i0[1] > vec2i1[1]) {
+		result[1] = vec2i0[1];
+	} else {
+		result[1] = vec2i1[1];
+	}
+	return result;
+}
+
+mint_t *vec2i_min(mint_t *result, mint_t *vec2i0, mint_t *vec2i1)
+{
+	if (vec2i0[0] < vec2i1[0]) {
+		result[0] = vec2i0[0];
+	} else {
+		result[0] = vec2i1[0];
+	}
+	if (vec2i0[1] < vec2i1[1]) {
+		result[1] = vec2i0[1];
+	} else {
+		result[1] = vec2i1[1];
+	}
+	return result;
+}
+
+mint_t *vec2i_clamp(mint_t *result, mint_t *vec2i0, mint_t *vec2i1, mint_t *vec2i2)
+{
+	vec2i_min(result, vec2i0, vec2i1);
+	vec2i_max(result, vec2i0, vec2i2);
+	return result;
+}
+
+mint_t *vec2i_tangent(mint_t *result, mint_t *vec2i0)
+{
+	mint_t a0 = vec2i0[0];
+	mint_t a1 = vec2i0[1];
+	result[0] = a1;
+	result[1] = -a0;
+	return result;
+}
+
+bool vec3i_is_zero(mint_t *vec3i0)
+{
+	return vec3i0[0] == 0 && vec3i0[1] == 0;
+}
+
+bool vec3i_is_equal(mint_t *vec3i0, mint_t *vec3i1)
+{
+	return vec3i0[0] == vec3i1[0] && vec3i0[1] == vec3i1[1] && vec3i0[2] == vec3i1[2];
+}
+
+mint_t *vec3i(mint_t *result, mint_t x, mint_t y, mint_t z)
+{
+	result[0] = x;
+	result[1] = y;
+	result[2] = z;
+	return result;
+}
+
+mint_t *vec3i_assign(mint_t *result, mint_t *vec3i0)
+{
+	result[0] = vec3i0[0];
+	result[1] = vec3i0[1];
+	result[2] = vec3i0[2];
+	return result;
+}
+
+#if defined(MATHC_USE_FLOATING_POINT)
+mint_t *vec3i_assign_vec3(mint_t *result, mfloat_t *vec30)
+{
+	result[0] = vec30[0];
+	result[1] = vec30[1];
+	result[2] = vec30[2];
+	return result;
+}
 #endif
 
-/* Use `extern inline` for C99 or later */
-#ifdef PREDEF_STANDARD_C99
-#define MATHC_EXTERN_INLINE extern inline
-#else
-#define MATHC_EXTERN_INLINE
+mint_t *vec3i_zero(mint_t *result)
+{
+	result[0] = 0;
+	result[1] = 0;
+	result[2] = 0;
+	return result;
+}
+
+mint_t *vec3i_one(mint_t *result)
+{
+	result[0] = 1;
+	result[1] = 1;
+	result[2] = 1;
+	return result;
+}
+
+mint_t *vec3i_sign(mint_t *result, mint_t *vec3i0)
+{
+	if (vec3i0[0] > 0) {
+		result[0] = 1;
+	} else if (vec3i0[0] < 0) {
+		result[0] = -1;
+	} else {
+		result[0] = 0;
+	}
+	if (vec3i0[1] > 0) {
+		result[1] = 1;
+	} else if (vec3i0[1] < 0) {
+		result[1] = -1;
+	} else {
+		result[1] = 0;
+	}
+	if (vec3i0[2] > 0) {
+		result[2] = 1;
+	} else if (vec3i0[2] < 0) {
+		result[2] = -1;
+	} else {
+		result[2] = 0;
+	}
+	return result;
+}
+
+mint_t *vec3i_add(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+{
+	result[0] = vec3i0[0] + vec3i1[0];
+	result[1] = vec3i0[1] + vec3i1[1];
+	result[2] = vec3i0[2] + vec3i1[2];
+	return result;
+}
+
+mint_t *vec3i_add_i(mint_t *result, mint_t *vec3i0, mint_t i)
+{
+	result[0] = vec3i0[0] + i;
+	result[1] = vec3i0[1] + i;
+	result[2] = vec3i0[2] + i;
+	return result;
+}
+
+mint_t *vec3i_subtract(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+{
+	result[0] = vec3i0[0] - vec3i1[0];
+	result[1] = vec3i0[1] - vec3i1[1];
+	result[2] = vec3i0[2] - vec3i1[2];
+	return result;
+}
+
+mint_t *vec3i_subtract_i(mint_t *result, mint_t *vec3i0, mint_t i)
+{
+	result[0] = vec3i0[0] - i;
+	result[1] = vec3i0[1] - i;
+	result[2] = vec3i0[2] - i;
+	return result;
+}
+
+mint_t *vec3i_multiply(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+{
+	result[0] = vec3i0[0] * vec3i1[0];
+	result[1] = vec3i0[1] * vec3i1[1];
+	result[2] = vec3i0[2] * vec3i1[2];
+	return result;
+}
+
+mint_t *vec3i_multiply_i(mint_t *result, mint_t *vec3i0, mint_t i)
+{
+	result[0] = vec3i0[0] * i;
+	result[1] = vec3i0[1] * i;
+	result[2] = vec3i0[2] * i;
+	return result;
+}
+
+mint_t *vec3i_divide(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+{
+	result[0] = vec3i0[0] / vec3i1[0];
+	result[1] = vec3i0[1] / vec3i1[1];
+	result[2] = vec3i0[2] / vec3i1[2];
+	return result;
+}
+
+mint_t *vec3i_divide_i(mint_t *result, mint_t *vec3i0, mint_t i)
+{
+	result[0] = vec3i0[0] / i;
+	result[1] = vec3i0[1] / i;
+	result[2] = vec3i0[2] / i;
+	return result;
+}
+
+mint_t *vec3i_snap(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+{
+	result[0] = (vec3i0[0] / vec3i1[0]) * vec3i1[0];
+	result[1] = (vec3i0[1] / vec3i1[1]) * vec3i1[1];
+	result[2] = (vec3i0[2] / vec3i1[2]) * vec3i1[2];
+	return result;
+}
+
+mint_t *vec3i_snap_i(mint_t *result, mint_t *vec3i0, mint_t i)
+{
+	result[0] = (vec3i0[0] / i) * i;
+	result[1] = (vec3i0[1] / i) * i;
+	result[2] = (vec3i0[2] / i) * i;
+	return result;
+}
+
+mint_t *vec3i_cross(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+{
+	mint_t cross[VEC3_SIZE];
+	cross[0] = vec3i0[1] * vec3i1[2] - vec3i0[2] * vec3i1[1];
+	cross[1] = vec3i0[2] * vec3i1[0] - vec3i0[0] * vec3i1[2];
+	cross[2] = vec3i0[0] * vec3i1[1] - vec3i0[1] * vec3i1[0];
+	result[0] = cross[0];
+	result[1] = cross[1];
+	result[2] = cross[2];
+	return result;
+}
+
+mint_t *vec3i_negative(mint_t *result, mint_t *vec3i0)
+{
+	result[0] = -vec3i0[0];
+	result[1] = -vec3i0[1];
+	result[2] = -vec3i0[2];
+	return result;
+}
+
+mint_t *vec3i_abs(mint_t *result, mint_t *vec3i0)
+{
+	result[0] = vec3i0[0];
+	if (result[0] < 0) {
+		result[0] = -result[0];
+	}
+	result[1] = vec3i0[1];
+	if (result[1] < 0) {
+		result[1] = -result[1];
+	}
+	result[2] = vec3i0[2];
+	if (result[2] < 0) {
+		result[2] = -result[2];
+	}
+	return result;
+}
+
+mint_t *vec3i_max(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+{
+	if (vec3i0[0] > vec3i1[0]) {
+		result[0] = vec3i0[0];
+	} else {
+		result[0] = vec3i1[0];
+	}
+	if (vec3i0[1] > vec3i1[1]) {
+		result[1] = vec3i0[1];
+	} else {
+		result[1] = vec3i1[1];
+	}
+	if (vec3i0[2] > vec3i1[2]) {
+		result[2] = vec3i0[2];
+	} else {
+		result[2] = vec3i1[2];
+	}
+	return result;
+}
+
+mint_t *vec3i_min(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+{
+	if (vec3i0[0] < vec3i1[0]) {
+		result[0] = vec3i0[0];
+	} else {
+		result[0] = vec3i1[0];
+	}
+	if (vec3i0[1] < vec3i1[1]) {
+		result[1] = vec3i0[1];
+	} else {
+		result[1] = vec3i1[1];
+	}
+	if (vec3i0[2] < vec3i1[2]) {
+		result[2] = vec3i0[2];
+	} else {
+		result[2] = vec3i1[2];
+	}
+	return result;
+}
+
+mint_t *vec3i_clamp(mint_t *result, mint_t *vec3i0, mint_t *vec3i1, mint_t *vec3i2)
+{
+	vec3i_min(result, vec3i0, vec3i1);
+	vec3i_max(result, vec3i0, vec3i2);
+	return result;
+}
+
+bool vec4i_is_zero(mint_t *vec4i0)
+{
+	return vec4i0[0] == 0 && vec4i0[1] == 0 && vec4i0[2] == 0 && vec4i0[3] == 0;
+}
+
+bool vec4i_is_equal(mint_t *vec4i0, mint_t *vec4i1)
+{
+	return vec4i0[0] == vec4i1[0] && vec4i0[1] == vec4i1[1] && vec4i0[2] == vec4i1[2] && vec4i0[3] == vec4i1[3];
+}
+
+mint_t *vec4i(mint_t *result, mint_t x, mint_t y, mint_t z, mint_t w)
+{
+	result[0] = x;
+	result[1] = y;
+	result[2] = z;
+	result[3] = w;
+	return result;
+}
+
+mint_t *vec4i_assign(mint_t *result, mint_t *vec4i0)
+{
+	result[0] = vec4i0[0];
+	result[1] = vec4i0[1];
+	result[2] = vec4i0[2];
+	result[3] = vec4i0[3];
+	return result;
+}
+
+#if defined(MATHC_USE_FLOATING_POINT)
+mint_t *vec4i_assign_vec4(mint_t *result, mfloat_t *vec40)
+{
+	result[0] = vec40[0];
+	result[1] = vec40[1];
+	result[2] = vec40[2];
+	result[3] = vec40[3];
+	return result;
+}
 #endif
 
-/* Utils */
-bool nearly_equal(float a, float b, float epsilon)
+mint_t *vec4i_zero(mint_t *result)
+{
+	result[0] = 0;
+	result[1] = 0;
+	result[2] = 0;
+	result[3] = 0;
+	return result;
+}
+
+mint_t *vec4i_one(mint_t *result)
+{
+	result[0] = 1;
+	result[1] = 1;
+	result[2] = 1;
+	result[3] = 1;
+	return result;
+}
+
+mint_t *vec4i_sign(mint_t *result, mint_t *vec4i0)
+{
+	if (vec4i0[0] > 0) {
+		result[0] = 1;
+	} else if (vec4i0[0] < 0) {
+		result[0] = -1;
+	} else {
+		result[0] = 0;
+	}
+	if (vec4i0[1] > 0) {
+		result[1] = 1;
+	} else if (vec4i0[1] < 0) {
+		result[1] = -1;
+	} else {
+		result[1] = 0;
+	}
+	if (vec4i0[2] > 0) {
+		result[2] = 1;
+	} else if (vec4i0[2] < 0) {
+		result[2] = -1;
+	} else {
+		result[2] = 0;
+	}
+	if (vec4i0[3] > 0) {
+		result[3] = 1;
+	} else if (vec4i0[3] < 0) {
+		result[3] = -1;
+	} else {
+		result[3] = 0;
+	}
+	return result;
+}
+
+mint_t *vec4i_add(mint_t *result, mint_t *vec4i0, mint_t *vec4i1)
+{
+	result[0] = vec4i0[0] + vec4i1[0];
+	result[1] = vec4i0[1] + vec4i1[1];
+	result[2] = vec4i0[2] + vec4i1[2];
+	result[3] = vec4i0[3] + vec4i1[3];
+	return result;
+}
+
+mint_t *vec4i_add_i(mint_t *result, mint_t *vec4i0, mint_t i)
+{
+	result[0] = vec4i0[0] + i;
+	result[1] = vec4i0[1] + i;
+	result[2] = vec4i0[2] + i;
+	result[3] = vec4i0[3] + i;
+	return result;
+}
+
+mint_t *vec4i_subtract(mint_t *result, mint_t *vec4i0, mint_t *vec4i1)
+{
+	result[0] = vec4i0[0] - vec4i1[0];
+	result[1] = vec4i0[1] - vec4i1[1];
+	result[2] = vec4i0[2] - vec4i1[2];
+	result[3] = vec4i0[3] - vec4i1[3];
+	return result;
+}
+
+mint_t *vec4i_subtract_i(mint_t *result, mint_t *vec4i0, mint_t i)
+{
+	result[0] = vec4i0[0] - i;
+	result[1] = vec4i0[1] - i;
+	result[2] = vec4i0[2] - i;
+	result[3] = vec4i0[3] - i;
+	return result;
+}
+
+mint_t *vec4i_multiply(mint_t *result, mint_t *vec4i0, mint_t *vec4i1)
+{
+	result[0] = vec4i0[0] * vec4i1[0];
+	result[1] = vec4i0[1] * vec4i1[1];
+	result[2] = vec4i0[2] * vec4i1[2];
+	result[3] = vec4i0[3] * vec4i1[3];
+	return result;
+}
+
+mint_t *vec4i_multiply_i(mint_t *result, mint_t *vec4i0, mint_t i)
+{
+	result[0] = vec4i0[0] * i;
+	result[1] = vec4i0[1] * i;
+	result[2] = vec4i0[2] * i;
+	result[3] = vec4i0[3] * i;
+	return result;
+}
+
+mint_t *vec4i_divide(mint_t *result, mint_t *vec4i0, mint_t *vec4i1)
+{
+	result[0] = vec4i0[0] / vec4i1[0];
+	result[1] = vec4i0[1] / vec4i1[1];
+	result[2] = vec4i0[2] / vec4i1[2];
+	result[3] = vec4i0[3] / vec4i1[3];
+	return result;
+}
+
+mint_t *vec4i_divide_i(mint_t *result, mint_t *vec4i0, mint_t i)
+{
+	result[0] = vec4i0[0] / i;
+	result[1] = vec4i0[1] / i;
+	result[2] = vec4i0[2] / i;
+	result[3] = vec4i0[3] / i;
+	return result;
+}
+
+mint_t *vec4i_snap(mint_t *result, mint_t *vec4i0, mint_t *vec4i1)
+{
+	result[0] = (vec4i0[0] / vec4i1[0]) * vec4i1[0];
+	result[1] = (vec4i0[1] / vec4i1[1]) * vec4i1[1];
+	result[2] = (vec4i0[2] / vec4i1[2]) * vec4i1[2];
+	result[3] = (vec4i0[3] / vec4i1[3]) * vec4i1[3];
+	return result;
+}
+
+mint_t *vec4i_snap_i(mint_t *result, mint_t *vec4i0, mint_t i)
+{
+	result[0] = (vec4i0[0] / i) * i;
+	result[1] = (vec4i0[1] / i) * i;
+	result[2] = (vec4i0[2] / i) * i;
+	result[3] = (vec4i0[3] / i) * i;
+	return result;
+}
+
+mint_t *vec4i_negative(mint_t *result, mint_t *vec4i0)
+{
+	result[0] = -vec4i0[0];
+	result[1] = -vec4i0[1];
+	result[2] = -vec4i0[2];
+	result[3] = -vec4i0[3];
+	return result;
+}
+
+mint_t *vec4i_abs(mint_t *result, mint_t *vec4i0)
+{
+	result[0] = vec4i0[0];
+	if (result[0] < 0) {
+		result[0] = -result[0];
+	}
+	result[1] = vec4i0[1];
+	if (result[1] < 0) {
+		result[1] = -result[1];
+	}
+	result[2] = vec4i0[2];
+	if (result[2] < 0) {
+		result[2] = -result[2];
+	}
+	result[3] = vec4i0[3];
+	if (result[3] < 0) {
+		result[3] = -result[3];
+	}
+	return result;
+}
+
+mint_t *vec4i_max(mint_t *result, mint_t *vec4i0, mint_t *vec4i1)
+{
+	if (vec4i0[0] > vec4i1[0]) {
+		result[0] = vec4i0[0];
+	} else {
+		result[0] = vec4i1[0];
+	}
+	if (vec4i0[1] > vec4i1[1]) {
+		result[1] = vec4i0[1];
+	} else {
+		result[1] = vec4i1[1];
+	}
+	if (vec4i0[2] > vec4i1[2]) {
+		result[2] = vec4i0[2];
+	} else {
+		result[2] = vec4i1[2];
+	}
+	if (vec4i0[3] > vec4i1[3]) {
+		result[3] = vec4i0[3];
+	} else {
+		result[3] = vec4i1[3];
+	}
+	return result;
+}
+
+mint_t *vec4i_min(mint_t *result, mint_t *vec4i0, mint_t *vec4i1)
+{
+	if (vec4i0[0] < vec4i1[0]) {
+		result[0] = vec4i0[0];
+	} else {
+		result[0] = vec4i1[0];
+	}
+	if (vec4i0[1] < vec4i1[1]) {
+		result[1] = vec4i0[1];
+	} else {
+		result[1] = vec4i1[1];
+	}
+	if (vec4i0[2] < vec4i1[2]) {
+		result[2] = vec4i0[2];
+	} else {
+		result[2] = vec4i1[2];
+	}
+	if (vec4i0[3] < vec4i1[3]) {
+		result[3] = vec4i0[3];
+	} else {
+		result[3] = vec4i1[3];
+	}
+	return result;
+}
+
+mint_t *vec4i_clamp(mint_t *result, mint_t *vec4i0, mint_t *vec4i1, mint_t *vec4i2)
+{
+	vec4i_min(result, vec4i0, vec4i1);
+	vec4i_max(result, vec4i0, vec4i2);
+	return result;
+}
+#endif
+
+#if defined(MATHC_USE_FLOATING_POINT)
+bool vec2_is_zero(mfloat_t *vec20)
+{
+	return vec20[0] < MFLT_EPSILON && vec20[1] < MFLT_EPSILON;
+}
+
+bool vec2_is_equal(mfloat_t *vec20, mfloat_t *vec21)
+{
+	return MFABS(vec20[0] - vec21[0]) < MFLT_EPSILON && MFABS(vec20[1] - vec21[1]) < MFLT_EPSILON;
+}
+
+mfloat_t *vec2(mfloat_t *result, mfloat_t x, mfloat_t y)
+{
+	result[0] = x;
+	result[1] = y;
+	return result;
+}
+
+mfloat_t *vec2_assign(mfloat_t *result, mfloat_t *vec20)
+{
+	result[0] = vec20[0];
+	result[1] = vec20[1];
+	return result;
+}
+
+#if defined(MATHC_USE_INT)
+mfloat_t *vec2_assign_vec2i(mfloat_t *result, mint_t *vec2i0)
+{
+	result[0] = vec2i0[0];
+	result[1] = vec2i0[1];
+	return result;
+}
+#endif
+
+mfloat_t *vec2_zero(mfloat_t *result)
+{
+	result[0] = MFLOAT_C(0.0);
+	result[1] = MFLOAT_C(0.0);
+	return result;
+}
+
+mfloat_t *vec2_one(mfloat_t *result)
+{
+	result[0] = MFLOAT_C(1.0);
+	result[1] = MFLOAT_C(1.0);
+	return result;
+}
+
+mfloat_t *vec2_sign(mfloat_t *result, mfloat_t *vec20)
+{
+	if (vec20[0] > MFLOAT_C(0.0)) {
+		result[0] = MFLOAT_C(1.0);
+	} else if (vec20[0] < MFLOAT_C(0.0)) {
+		result[0] = -MFLOAT_C(1.0);
+	} else {
+		result[0] = MFLOAT_C(0.0);
+	}
+	if (vec20[1] > MFLOAT_C(0.0)) {
+		result[1] = MFLOAT_C(1.0);
+	} else if (vec20[1] < MFLOAT_C(0.0)) {
+		result[1] = -MFLOAT_C(1.0);
+	} else {
+		result[1] = MFLOAT_C(0.0);
+	}
+	return result;
+}
+
+mfloat_t *vec2_add(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+{
+	result[0] = vec20[0] + vec21[0];
+	result[1] = vec20[1] + vec21[1];
+	return result;
+}
+
+mfloat_t *vec2_add_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f)
+{
+	result[0] = vec20[0] + f;
+	result[1] = vec20[1] + f;
+	return result;
+}
+
+mfloat_t *vec2_subtract(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+{
+	result[0] = vec20[0] - vec21[0];
+	result[1] = vec20[1] - vec21[1];
+	return result;
+}
+
+mfloat_t *vec2_subtract_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f)
+{
+	result[0] = vec20[0] - f;
+	result[1] = vec20[1] - f;
+	return result;
+}
+
+mfloat_t *vec2_multiply(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+{
+	result[0] = vec20[0] * vec21[0];
+	result[1] = vec20[1] * vec21[1];
+	return result;
+}
+
+mfloat_t *vec2_multiply_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f)
+{
+	result[0] = vec20[0] * f;
+	result[1] = vec20[1] * f;
+	return result;
+}
+
+mfloat_t *vec2_multiply_mat2(mfloat_t *result, mfloat_t *vec20, mfloat_t *mat20)
+{
+	mfloat_t x = vec20[0];
+	mfloat_t y = vec20[1];
+	result[0] = mat20[0] * x + mat20[2] * y;
+	result[1] = mat20[1] * x + mat20[3] * y;
+	return result;
+}
+
+mfloat_t *vec2_divide(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+{
+	result[0] = vec20[0] / vec21[0];
+	result[1] = vec20[1] / vec21[1];
+	return result;
+}
+
+mfloat_t *vec2_divide_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f)
+{
+	result[0] = vec20[0] / f;
+	result[1] = vec20[1] / f;
+	return result;
+}
+
+mfloat_t *vec2_snap(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+{
+	result[0] = MFLOOR(vec20[0] / vec21[0]) * vec21[0];
+	result[1] = MFLOOR(vec20[1] / vec21[1]) * vec21[1];
+	return result;
+}
+
+mfloat_t *vec2_snap_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f)
+{
+	result[0] = MFLOOR(vec20[0] / f) * f;
+	result[1] = MFLOOR(vec20[1] / f) * f;
+	return result;
+}
+
+mfloat_t *vec2_negative(mfloat_t *result, mfloat_t *vec20)
+{
+	result[0] = -vec20[0];
+	result[1] = -vec20[1];
+	return result;
+}
+
+mfloat_t *vec2_abs(mfloat_t *result, mfloat_t *vec20)
+{
+	result[0] = MFABS(vec20[0]);
+	result[1] = MFABS(vec20[1]);
+	return result;
+}
+
+mfloat_t *vec2_floor(mfloat_t *result, mfloat_t *vec20)
+{
+	result[0] = MFLOOR(vec20[0]);
+	result[1] = MFLOOR(vec20[1]);
+	return result;
+}
+
+mfloat_t *vec2_ceil(mfloat_t *result, mfloat_t *vec20)
+{
+	result[0] = MCEIL(vec20[0]);
+	result[1] = MCEIL(vec20[1]);
+	return result;
+}
+
+mfloat_t *vec2_round(mfloat_t *result, mfloat_t *vec20)
+{
+	result[0] = MROUND(vec20[0]);
+	result[1] = MROUND(vec20[1]);
+	return result;
+}
+
+mfloat_t *vec2_max(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+{
+	result[0] = MFMAX(vec20[0], vec21[0]);
+	result[1] = MFMAX(vec20[1], vec21[1]);
+	return result;
+}
+
+mfloat_t *vec2_min(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+{
+	result[0] = MFMIN(vec20[0], vec21[0]);
+	result[1] = MFMIN(vec20[1], vec21[1]);
+	return result;
+}
+
+mfloat_t *vec2_clamp(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t *vec22)
+{
+	vec2_min(result, vec20, vec21);
+	vec2_max(result, vec20, vec22);
+	return result;
+}
+
+mfloat_t *vec2_normalize(mfloat_t *result, mfloat_t *vec20)
+{
+	mfloat_t l = MSQRT(vec20[0] * vec20[0] + vec20[1] * vec20[1]);
+	result[0] = vec20[0] / l;
+	result[1] = vec20[1] / l;
+	return result;
+}
+
+mfloat_t vec2_dot(mfloat_t *vec20, mfloat_t *vec21)
+{
+	return vec20[0] * vec21[0] + vec20[1] * vec21[1];
+}
+
+mfloat_t *vec2_project(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+{
+	mfloat_t d = vec2_dot(vec21, vec21);
+	mfloat_t s = vec2_dot(vec20, vec21) / d;
+	result[0] = vec21[0] * s;
+	result[1] = vec21[1] * s;
+	return result;
+}
+
+mfloat_t *vec2_slide(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+{
+	mfloat_t d = vec2_dot(vec20, vec21);
+	result[0] = vec20[0] - vec21[0] * d;
+	result[1] = vec20[1] - vec21[1] * d;
+	return result;
+}
+
+mfloat_t *vec2_reflect(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+{
+	mfloat_t d = MFLOAT_C(2.0) * vec2_dot(vec20, vec21);
+	result[0] = vec21[0] * d - vec20[0];
+	result[1] = vec21[1] * d - vec20[1];
+	return result;
+}
+
+mfloat_t *vec2_tangent(mfloat_t *result, mfloat_t *vec20)
+{
+	mfloat_t a0 = vec20[0];
+	mfloat_t a1 = vec20[1];
+	result[0] = a1;
+	result[1] = -a0;
+	return result;
+}
+
+mfloat_t *vec2_rotate(mfloat_t *result, mfloat_t *vec20, mfloat_t f)
+{
+	mfloat_t cs = MCOS(f);
+	mfloat_t sn = MSIN(f);
+	mfloat_t x = vec20[0];
+	mfloat_t y = vec20[1];
+	result[0] = x * cs - y * sn;
+	result[1] = x * sn + y * cs;
+	return result;
+}
+
+mfloat_t *vec2_lerp(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t f)
+{
+	result[0] = vec20[0] + (vec21[0] - vec20[0]) * f;
+	result[1] = vec20[1] + (vec21[1] - vec20[1]) * f;
+	return result;
+}
+
+mfloat_t *vec2_bezier3(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t *vec22, mfloat_t f)
+{
+	mfloat_t tmp0[VEC2_SIZE];
+	mfloat_t tmp1[VEC2_SIZE];
+	vec2_lerp(tmp0, vec20, vec21, f);
+	vec2_lerp(tmp1, vec21, vec22, f);
+	vec2_lerp(result, tmp0, tmp1, f);
+	return result;
+}
+
+mfloat_t *vec2_bezier4(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t *vec22, mfloat_t *vec23, mfloat_t f)
+{
+	mfloat_t tmp0[VEC2_SIZE];
+	mfloat_t tmp1[VEC2_SIZE];
+	mfloat_t tmp2[VEC2_SIZE];
+	mfloat_t tmp3[VEC2_SIZE];
+	mfloat_t tmp4[VEC2_SIZE];
+	vec2_lerp(tmp0, vec20, vec21, f);
+	vec2_lerp(tmp1, vec21, vec22, f);
+	vec2_lerp(tmp2, vec22, vec23, f);
+	vec2_lerp(tmp3, tmp0, tmp1, f);
+	vec2_lerp(tmp4, tmp1, tmp2, f);
+	vec2_lerp(result, tmp3, tmp4, f);
+	return result;
+}
+
+mfloat_t vec2_angle(mfloat_t *vec20)
+{
+	return MATAN2(vec20[1], vec20[0]);
+}
+
+mfloat_t vec2_length(mfloat_t *vec20)
+{
+	return MSQRT(vec20[0] * vec20[0] + vec20[1] * vec20[1]);
+}
+
+mfloat_t vec2_length_squared(mfloat_t *vec20)
+{
+	return vec20[0] * vec20[0] + vec20[1] * vec20[1];
+}
+
+mfloat_t vec2_distance(mfloat_t *vec20, mfloat_t *vec21)
+{
+	return MSQRT((vec20[0] - vec21[0]) * (vec20[0] - vec21[0]) + (vec20[1] - vec21[1]) * (vec20[1] - vec21[1]));
+}
+
+mfloat_t vec2_distance_squared(mfloat_t *vec20, mfloat_t *vec21)
+{
+	return (vec20[0] - vec21[0]) * (vec20[0] - vec21[0]) + (vec20[1] - vec21[1]) * (vec20[1] - vec21[1]);
+}
+
+bool vec3_is_zero(mfloat_t *vec30)
+{
+	return vec30[0] < MFLT_EPSILON && vec30[1] < MFLT_EPSILON && vec30[2] < MFLT_EPSILON;
+}
+
+bool vec3_is_equal(mfloat_t *vec30, mfloat_t *vec31)
+{
+	return MFABS(vec30[0] - vec31[0]) < MFLT_EPSILON && MFABS(vec30[1] - vec31[1]) < MFLT_EPSILON && MFABS(vec30[2] - vec31[2]) < MFLT_EPSILON;
+}
+
+mfloat_t *vec3(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z)
+{
+	result[0] = x;
+	result[1] = y;
+	result[2] = z;
+	return result;
+}
+
+mfloat_t *vec3_assign(mfloat_t *result, mfloat_t *vec30)
+{
+	result[0] = vec30[0];
+	result[1] = vec30[1];
+	result[2] = vec30[2];
+	return result;
+}
+
+#if defined(MATHC_USE_INT)
+mfloat_t *vec3_assign_vec3i(mfloat_t *result, mint_t *vec3i0)
+{
+	result[0] = vec3i0[0];
+	result[1] = vec3i0[1];
+	result[2] = vec3i0[2];
+	return result;
+}
+#endif
+
+mfloat_t *vec3_zero(mfloat_t *result)
+{
+	result[0] = MFLOAT_C(0.0);
+	result[1] = MFLOAT_C(0.0);
+	result[2] = MFLOAT_C(0.0);
+	return result;
+}
+
+mfloat_t *vec3_one(mfloat_t *result)
+{
+	result[0] = MFLOAT_C(1.0);
+	result[1] = MFLOAT_C(1.0);
+	result[2] = MFLOAT_C(1.0);
+	return result;
+}
+
+mfloat_t *vec3_sign(mfloat_t *result, mfloat_t *vec30)
+{
+	if (vec30[0] > MFLOAT_C(0.0)) {
+		result[0] = MFLOAT_C(1.0);
+	} else if (vec30[0] < 0) {
+		result[0] = -MFLOAT_C(1.0);
+	} else {
+		result[0] = MFLOAT_C(0.0);
+	}
+	if (vec30[1] > MFLOAT_C(0.0)) {
+		result[1] = MFLOAT_C(1.0);
+	} else if (vec30[1] < 0) {
+		result[1] = -MFLOAT_C(1.0);
+	} else {
+		result[1] = MFLOAT_C(0.0);
+	}
+	if (vec30[2] > MFLOAT_C(0.0)) {
+		result[2] = MFLOAT_C(1.0);
+	} else if (vec30[2] < 0) {
+		result[2] = -MFLOAT_C(1.0);
+	} else {
+		result[2] = MFLOAT_C(0.0);
+	}
+	return result;
+}
+
+mfloat_t *vec3_add(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+{
+	result[0] = vec30[0] + vec31[0];
+	result[1] = vec30[1] + vec31[1];
+	result[2] = vec30[2] + vec31[2];
+	return result;
+}
+
+mfloat_t *vec3_add_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
+{
+	result[0] = vec30[0] + f;
+	result[1] = vec30[1] + f;
+	result[2] = vec30[2] + f;
+	return result;
+}
+
+mfloat_t *vec3_subtract(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+{
+	result[0] = vec30[0] - vec31[0];
+	result[1] = vec30[1] - vec31[1];
+	result[2] = vec30[2] - vec31[2];
+	return result;
+}
+
+mfloat_t *vec3_subtract_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
+{
+	result[0] = vec30[0] - f;
+	result[1] = vec30[1] - f;
+	result[2] = vec30[2] - f;
+	return result;
+}
+
+mfloat_t *vec3_multiply(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+{
+	result[0] = vec30[0] * vec31[0];
+	result[1] = vec30[1] * vec31[1];
+	result[2] = vec30[2] * vec31[2];
+	return result;
+}
+
+mfloat_t *vec3_multiply_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
+{
+	result[0] = vec30[0] * f;
+	result[1] = vec30[1] * f;
+	result[2] = vec30[2] * f;
+	return result;
+}
+
+mfloat_t *vec3_multiply_mat3(mfloat_t *result, mfloat_t *vec30, mfloat_t *mat30)
+{
+	mfloat_t x = vec30[0];
+	mfloat_t y = vec30[1];
+	mfloat_t z = vec30[2];
+	result[0] = mat30[0] * x + mat30[3] * y + mat30[6] * z;
+	result[1] = mat30[1] * x + mat30[4] * y + mat30[7] * z;
+	result[2] = mat30[2] * x + mat30[5] * y + mat30[8] * z;
+	return result;
+}
+
+mfloat_t *vec3_divide(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+{
+	result[0] = vec30[0] / vec31[0];
+	result[1] = vec30[1] / vec31[1];
+	result[2] = vec30[2] / vec31[2];
+	return result;
+}
+
+mfloat_t *vec3_divide_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
+{
+	result[0] = vec30[0] / f;
+	result[1] = vec30[1] / f;
+	result[2] = vec30[2] / f;
+	return result;
+}
+
+mfloat_t *vec3_snap(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+{
+	result[0] = MFLOOR(vec30[0] / vec31[0]) * vec31[0];
+	result[1] = MFLOOR(vec30[1] / vec31[1]) * vec31[1];
+	result[2] = MFLOOR(vec30[2] / vec31[2]) * vec31[2];
+	return result;
+}
+
+mfloat_t *vec3_snap_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
+{
+	result[0] = MFLOOR(vec30[0] / f) * f;
+	result[1] = MFLOOR(vec30[1] / f) * f;
+	result[2] = MFLOOR(vec30[2] / f) * f;
+	return result;
+}
+
+mfloat_t *vec3_negative(mfloat_t *result, mfloat_t *vec30)
+{
+	result[0] = -vec30[0];
+	result[1] = -vec30[1];
+	result[2] = -vec30[2];
+	return result;
+}
+
+mfloat_t *vec3_abs(mfloat_t *result, mfloat_t *vec30)
+{
+	result[0] = MFABS(vec30[0]);
+	result[1] = MFABS(vec30[1]);
+	result[2] = MFABS(vec30[2]);
+	return result;
+}
+
+mfloat_t *vec3_floor(mfloat_t *result, mfloat_t *vec30)
+{
+	result[0] = MFLOOR(vec30[0]);
+	result[1] = MFLOOR(vec30[1]);
+	result[2] = MFLOOR(vec30[2]);
+	return result;
+}
+
+mfloat_t *vec3_ceil(mfloat_t *result, mfloat_t *vec30)
+{
+	result[0] = MCEIL(vec30[0]);
+	result[1] = MCEIL(vec30[1]);
+	result[2] = MCEIL(vec30[2]);
+	return result;
+}
+
+mfloat_t *vec3_round(mfloat_t *result, mfloat_t *vec30)
+{
+	result[0] = MROUND(vec30[0]);
+	result[1] = MROUND(vec30[1]);
+	result[2] = MROUND(vec30[2]);
+	return result;
+}
+
+mfloat_t *vec3_max(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+{
+	result[0] = MFMAX(vec30[0], vec31[0]);
+	result[1] = MFMAX(vec30[1], vec31[1]);
+	result[2] = MFMAX(vec30[2], vec31[2]);
+	return result;
+}
+
+mfloat_t *vec3_min(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+{
+	result[0] = MFMIN(vec30[0], vec31[0]);
+	result[1] = MFMIN(vec30[1], vec31[1]);
+	result[2] = MFMIN(vec30[2], vec31[2]);
+	return result;
+}
+
+mfloat_t *vec3_clamp(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32)
+{
+	vec3_min(result, vec30, vec31);
+	vec3_max(result, vec30, vec32);
+	return result;
+}
+
+mfloat_t *vec3_cross(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+{
+	mfloat_t cross[VEC3_SIZE];
+	cross[0] = vec30[1] * vec31[2] - vec30[2] * vec31[1];
+	cross[1] = vec30[2] * vec31[0] - vec30[0] * vec31[2];
+	cross[2] = vec30[0] * vec31[1] - vec30[1] * vec31[0];
+	result[0] = cross[0];
+	result[1] = cross[1];
+	result[2] = cross[2];
+	return result;
+}
+
+mfloat_t *vec3_normalize(mfloat_t *result, mfloat_t *vec30)
+{
+	mfloat_t l = MSQRT(vec30[0] * vec30[0] + vec30[1] * vec30[1] + vec30[2] * vec30[2]);
+	result[0] = vec30[0] / l;
+	result[1] = vec30[1] / l;
+	result[2] = vec30[2] / l;
+	return result;
+}
+
+mfloat_t vec3_dot(mfloat_t *vec30, mfloat_t *vec31)
+{
+	return vec30[0] * vec31[0] + vec30[1] * vec31[1] + vec30[2] * vec31[2];
+}
+
+mfloat_t *vec3_project(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+{
+	mfloat_t d = vec2_dot(vec31, vec31);
+	mfloat_t s = vec2_dot(vec30, vec31) / d;
+	result[0] = vec31[0] * s;
+	result[1] = vec31[1] * s;
+	result[2] = vec31[2] * s;
+	return result;
+}
+
+mfloat_t *vec3_slide(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+{
+	mfloat_t d = vec3_dot(vec30, vec31);
+	result[0] = vec30[0] - vec31[0] * d;
+	result[1] = vec30[1] - vec31[1] * d;
+	result[2] = vec30[2] - vec31[2] * d;
+	return result;
+}
+
+mfloat_t *vec3_reflect(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+{
+	mfloat_t d = MFLOAT_C(2.0) * vec3_dot(vec30, vec31);
+	result[0] = vec31[0] * d - vec30[0];
+	result[1] = vec31[1] * d - vec30[1];
+	result[2] = vec31[2] * d - vec30[2];
+	return result;
+}
+
+mfloat_t *vec3_lerp(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t f)
+{
+	result[0] = vec30[0] + (vec31[0] - vec30[0]) * f;
+	result[1] = vec30[1] + (vec31[1] - vec30[1]) * f;
+	result[2] = vec30[2] + (vec31[2] - vec30[2]) * f;
+	return result;
+}
+
+mfloat_t *vec3_bezier3(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32, mfloat_t f)
+{
+	mfloat_t tmp0[VEC3_SIZE];
+	mfloat_t tmp1[VEC3_SIZE];
+	vec3_lerp(tmp0, vec30, vec31, f);
+	vec3_lerp(tmp1, vec31, vec32, f);
+	vec3_lerp(result, tmp0, tmp1, f);
+	return result;
+}
+
+mfloat_t *vec3_bezier4(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32, mfloat_t *vec33, mfloat_t f)
+{
+	mfloat_t tmp0[VEC3_SIZE];
+	mfloat_t tmp1[VEC3_SIZE];
+	mfloat_t tmp2[VEC3_SIZE];
+	mfloat_t tmp3[VEC3_SIZE];
+	mfloat_t tmp4[VEC3_SIZE];
+	vec3_lerp(tmp0, vec30, vec31, f);
+	vec3_lerp(tmp1, vec31, vec32, f);
+	vec3_lerp(tmp2, vec32, vec33, f);
+	vec3_lerp(tmp3, tmp0, tmp1, f);
+	vec3_lerp(tmp4, tmp1, tmp2, f);
+	vec3_lerp(result, tmp3, tmp4, f);
+	return result;
+}
+
+mfloat_t vec3_length(mfloat_t *vec30)
+{
+	return MSQRT(vec30[0] * vec30[0] + vec30[1] * vec30[1] + vec30[2] * vec30[2]);
+}
+
+mfloat_t vec3_length_squared(mfloat_t *vec30)
+{
+	return vec30[0] * vec30[0] + vec30[1] * vec30[1] + vec30[2] * vec30[2];
+}
+
+mfloat_t vec3_distance(mfloat_t *vec30, mfloat_t *vec31)
+{
+	return MSQRT((vec30[0] - vec31[0]) * (vec30[0] - vec31[0]) + (vec30[1] - vec31[1]) * (vec30[1] - vec31[1]) + (vec30[2] - vec31[2]) * (vec30[2] - vec31[2]));
+}
+
+mfloat_t vec3_distance_squared(mfloat_t *vec30, mfloat_t *vec31)
+{
+	return (vec30[0] - vec31[0]) * (vec30[0] - vec31[0]) + (vec30[1] - vec31[1]) * (vec30[1] - vec31[1]) + (vec30[2] - vec31[2]) * (vec30[2] - vec31[2]);
+}
+
+bool vec4_is_zero(mfloat_t *vec40)
+{
+	return vec40[0] < MFLT_EPSILON && vec40[1] < MFLT_EPSILON && vec40[2] < MFLT_EPSILON && vec40[3] < MFLT_EPSILON;
+}
+
+bool vec4_is_equal(mfloat_t *vec40, mfloat_t *vec41)
+{
+	return MFABS(vec40[0] - vec41[0]) < MFLT_EPSILON && MFABS(vec40[1] - vec41[1]) < MFLT_EPSILON && MFABS(vec40[2] - vec41[2]) < MFLT_EPSILON && MFABS(vec40[3] - vec41[3]) < MFLT_EPSILON;
+}
+
+mfloat_t *vec4(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
+{
+	result[0] = x;
+	result[1] = y;
+	result[2] = z;
+	result[3] = w;
+	return result;
+}
+
+mfloat_t *vec4_assign(mfloat_t *result, mfloat_t *vec40)
+{
+	result[0] = vec40[0];
+	result[1] = vec40[1];
+	result[2] = vec40[2];
+	result[3] = vec40[3];
+	return result;
+}
+
+#if defined(MATHC_USE_INT)
+mfloat_t *vec4_assign_vec4i(mfloat_t *result, mint_t *vec4i0)
+{
+	result[0] = vec4i0[0];
+	result[1] = vec4i0[1];
+	result[2] = vec4i0[2];
+	result[3] = vec4i0[3];
+	return result;
+}
+#endif
+
+mfloat_t *vec4_zero(mfloat_t *result)
+{
+	result[0] = MFLOAT_C(0.0);
+	result[1] = MFLOAT_C(0.0);
+	result[2] = MFLOAT_C(0.0);
+	result[3] = MFLOAT_C(0.0);
+	return result;
+}
+
+mfloat_t *vec4_one(mfloat_t *result)
+{
+	result[0] = MFLOAT_C(1.0);
+	result[1] = MFLOAT_C(1.0);
+	result[2] = MFLOAT_C(1.0);
+	result[3] = MFLOAT_C(1.0);
+	return result;
+}
+
+mfloat_t *vec4_sign(mfloat_t *result, mfloat_t *vec40)
+{
+	if (vec40[0] > MFLOAT_C(0.0)) {
+		result[0] = MFLOAT_C(1.0);
+	} else if (vec40[0] < 0) {
+		result[0] = -MFLOAT_C(1.0);
+	} else {
+		result[0] = MFLOAT_C(0.0);
+	}
+	if (vec40[1] > MFLOAT_C(0.0)) {
+		result[1] = MFLOAT_C(1.0);
+	} else if (vec40[1] < 0) {
+		result[1] = -MFLOAT_C(1.0);
+	} else {
+		result[1] = MFLOAT_C(0.0);
+	}
+	if (vec40[2] > MFLOAT_C(0.0)) {
+		result[2] = MFLOAT_C(1.0);
+	} else if (vec40[2] < 0) {
+		result[2] = -MFLOAT_C(1.0);
+	} else {
+		result[2] = MFLOAT_C(0.0);
+	}
+	if (vec40[3] > MFLOAT_C(0.0)) {
+		result[3] = MFLOAT_C(1.0);
+	} else if (vec40[3] < 0) {
+		result[3] = -MFLOAT_C(1.0);
+	} else {
+		result[3] = MFLOAT_C(0.0);
+	}
+	return result;
+}
+
+mfloat_t *vec4_add(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41)
+{
+	result[0] = vec40[0] + vec41[0];
+	result[1] = vec40[1] + vec41[1];
+	result[2] = vec40[2] + vec41[2];
+	result[3] = vec40[3] + vec41[3];
+	return result;
+}
+
+mfloat_t *vec4_add_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f)
+{
+	result[0] = vec40[0] + f;
+	result[1] = vec40[1] + f;
+	result[2] = vec40[2] + f;
+	result[3] = vec40[3] + f;
+	return result;
+}
+
+mfloat_t *vec4_subtract(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41)
+{
+	result[0] = vec40[0] - vec41[0];
+	result[1] = vec40[1] - vec41[1];
+	result[2] = vec40[2] - vec41[2];
+	result[3] = vec40[3] - vec41[3];
+	return result;
+}
+
+mfloat_t *vec4_subtract_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f)
+{
+	result[0] = vec40[0] - f;
+	result[1] = vec40[1] - f;
+	result[2] = vec40[2] - f;
+	result[3] = vec40[3] - f;
+	return result;
+}
+
+mfloat_t *vec4_multiply(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41)
+{
+	result[0] = vec40[0] * vec41[0];
+	result[1] = vec40[1] * vec41[1];
+	result[2] = vec40[2] * vec41[2];
+	result[3] = vec40[3] * vec41[3];
+	return result;
+}
+
+mfloat_t *vec4_multiply_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f)
+{
+	result[0] = vec40[0] * f;
+	result[1] = vec40[1] * f;
+	result[2] = vec40[2] * f;
+	result[3] = vec40[3] * f;
+	return result;
+}
+
+mfloat_t *vec4_multiply_mat4(mfloat_t *result, mfloat_t *vec40, mfloat_t *mat40)
+{
+	mfloat_t x = vec40[0];
+	mfloat_t y = vec40[1];
+	mfloat_t z = vec40[2];
+	mfloat_t w = vec40[3];
+	result[0] = mat40[0] * x + mat40[4] * y + mat40[8] * z + mat40[12] * w;
+	result[1] = mat40[1] * x + mat40[5] * y + mat40[9] * z + mat40[13] * w;
+	result[2] = mat40[2] * x + mat40[6] * y + mat40[10] * z + mat40[14] * w;
+	result[3] = mat40[3] * x + mat40[7] * y + mat40[11] * z + mat40[15] * w;
+	return result;
+}
+
+mfloat_t *vec4_divide(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41)
+{
+	result[0] = vec40[0] / vec41[0];
+	result[1] = vec40[1] / vec41[1];
+	result[2] = vec40[2] / vec41[2];
+	result[3] = vec40[3] / vec41[3];
+	return result;
+}
+
+mfloat_t *vec4_divide_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f)
+{
+	result[0] = vec40[0] / f;
+	result[1] = vec40[1] / f;
+	result[2] = vec40[2] / f;
+	result[3] = vec40[3] / f;
+	return result;
+}
+
+mfloat_t *vec4_snap(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41)
+{
+	result[0] = MFLOOR(vec40[0] / vec41[0]) * vec41[0];
+	result[1] = MFLOOR(vec40[1] / vec41[1]) * vec41[1];
+	result[2] = MFLOOR(vec40[2] / vec41[2]) * vec41[2];
+	result[3] = MFLOOR(vec40[3] / vec41[3]) * vec41[3];
+	return result;
+}
+
+mfloat_t *vec4_snap_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f)
+{
+	result[0] = MFLOOR(vec40[0] / f) * f;
+	result[1] = MFLOOR(vec40[1] / f) * f;
+	result[2] = MFLOOR(vec40[2] / f) * f;
+	result[3] = MFLOOR(vec40[3] / f) * f;
+	return result;
+}
+
+mfloat_t *vec4_negative(mfloat_t *result, mfloat_t *vec40)
+{
+	result[0] = -vec40[0];
+	result[1] = -vec40[1];
+	result[2] = -vec40[2];
+	result[3] = -vec40[3];
+	return result;
+}
+
+mfloat_t *vec4_abs(mfloat_t *result, mfloat_t *vec40)
+{
+	result[0] = MFABS(vec40[0]);
+	result[1] = MFABS(vec40[1]);
+	result[2] = MFABS(vec40[2]);
+	result[3] = MFABS(vec40[3]);
+	return result;
+}
+
+mfloat_t *vec4_floor(mfloat_t *result, mfloat_t *vec40)
+{
+	result[0] = MFLOOR(vec40[0]);
+	result[1] = MFLOOR(vec40[1]);
+	result[2] = MFLOOR(vec40[2]);
+	result[3] = MFLOOR(vec40[3]);
+	return result;
+}
+
+mfloat_t *vec4_ceil(mfloat_t *result, mfloat_t *vec40)
+{
+	result[0] = MCEIL(vec40[0]);
+	result[1] = MCEIL(vec40[1]);
+	result[2] = MCEIL(vec40[2]);
+	result[3] = MCEIL(vec40[3]);
+	return result;
+}
+
+mfloat_t *vec4_round(mfloat_t *result, mfloat_t *vec40)
+{
+	result[0] = MROUND(vec40[0]);
+	result[1] = MROUND(vec40[1]);
+	result[2] = MROUND(vec40[2]);
+	result[3] = MROUND(vec40[3]);
+	return result;
+}
+
+mfloat_t *vec4_max(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41)
+{
+	result[0] = MFMAX(vec40[0], vec41[0]);
+	result[1] = MFMAX(vec40[1], vec41[1]);
+	result[2] = MFMAX(vec40[2], vec41[2]);
+	result[3] = MFMAX(vec40[3], vec41[3]);
+	return result;
+}
+
+mfloat_t *vec4_min(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41)
+{
+	result[0] = MFMIN(vec40[0], vec41[0]);
+	result[1] = MFMIN(vec40[1], vec41[1]);
+	result[2] = MFMIN(vec40[2], vec41[2]);
+	result[3] = MFMIN(vec40[3], vec41[3]);
+	return result;
+}
+
+mfloat_t *vec4_clamp(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41, mfloat_t *vec42)
+{
+	vec4_min(result, vec40, vec41);
+	vec4_max(result, vec40, vec42);
+	return result;
+}
+
+mfloat_t *vec4_normalize(mfloat_t *result, mfloat_t *vec40)
+{
+	mfloat_t l = MSQRT(vec40[0] * vec40[0] + vec40[1] * vec40[1] + vec40[2] * vec40[2] + vec40[3] * vec40[3]);
+	result[0] = vec40[0] / l;
+	result[1] = vec40[1] / l;
+	result[2] = vec40[2] / l;
+	result[3] = vec40[3] / l;
+	return result;
+}
+
+mfloat_t *vec4_lerp(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41, mfloat_t f)
+{
+	result[0] = vec40[0] + (vec41[0] - vec40[0]) * f;
+	result[1] = vec40[1] + (vec41[1] - vec40[1]) * f;
+	result[2] = vec40[2] + (vec41[2] - vec40[2]) * f;
+	result[3] = vec40[3] + (vec41[3] - vec40[3]) * f;
+	return result;
+}
+
+bool quat_is_zero(mfloat_t *quat0)
+{
+	return quat0[0] < MFLT_EPSILON && quat0[1] < MFLT_EPSILON && quat0[2] < MFLT_EPSILON && quat0[3] < MFLT_EPSILON;
+}
+
+bool quat_is_equal(mfloat_t *quat0, mfloat_t *quat1)
+{
+	return MFABS(quat0[0] - quat1[0]) < MFLT_EPSILON && MFABS(quat0[1] - quat1[1]) < MFLT_EPSILON && MFABS(quat0[2] - quat1[2]) < MFLT_EPSILON && MFABS(quat0[3] - quat1[3]) < MFLT_EPSILON;
+}
+
+mfloat_t *quat(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
+{
+	result[0] = x;
+	result[1] = y;
+	result[2] = z;
+	result[3] = w;
+	return result;
+}
+
+mfloat_t *quat_assign(mfloat_t *result, mfloat_t *quat0)
+{
+	result[0] = quat0[0];
+	result[1] = quat0[1];
+	result[2] = quat0[2];
+	result[3] = quat0[3];
+	return result;
+}
+
+mfloat_t *quat_zero(mfloat_t *result)
+{
+	result[0] = MFLOAT_C(0.0);
+	result[1] = MFLOAT_C(0.0);
+	result[2] = MFLOAT_C(0.0);
+	result[3] = MFLOAT_C(0.0);
+	return result;
+}
+
+mfloat_t *quat_null(mfloat_t *result)
+{
+	result[0] = MFLOAT_C(0.0);
+	result[1] = MFLOAT_C(0.0);
+	result[2] = MFLOAT_C(0.0);
+	result[3] = MFLOAT_C(1.0);
+	return result;
+}
+
+mfloat_t *quat_multiply(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1)
+{
+	result[0] = quat0[3] * quat1[0] + quat0[0] * quat1[3] + quat0[1] * quat1[2] - quat0[2] * quat1[1];
+	result[1] = quat0[3] * quat1[1] + quat0[1] * quat1[3] + quat0[2] * quat1[0] - quat0[0] * quat1[2];
+	result[2] = quat0[3] * quat1[2] + quat0[2] * quat1[3] + quat0[0] * quat1[1] - quat0[1] * quat1[0];
+	result[3] = quat0[3] * quat1[3] - quat0[0] * quat1[0] - quat0[1] * quat1[1] - quat0[2] * quat1[2];
+	return result;
+}
+
+mfloat_t *quat_multiply_f(mfloat_t *result, mfloat_t *quat0, mfloat_t f)
+{
+	result[0] = quat0[0] * f;
+	result[1] = quat0[1] * f;
+	result[2] = quat0[2] * f;
+	result[3] = quat0[3] * f;
+	return result;
+}
+
+mfloat_t *quat_divide(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1)
+{
+	mfloat_t x = quat0[0];
+	mfloat_t y = quat0[1];
+	mfloat_t z = quat0[2];
+	mfloat_t w = quat0[3];
+	mfloat_t ls = quat1[0] * quat1[0] + quat1[1] * quat1[1] + quat1[8] * quat1[8] + quat1[3] * quat1[3];
+	mfloat_t normalized_x = -quat1[0] / ls;
+	mfloat_t normalized_y = -quat1[1] / ls;
+	mfloat_t normalized_z = -quat1[8] / ls;
+	mfloat_t normalized_w = quat1[3] / ls;
+	result[0] = x * normalized_w + normalized_x * w + (y * normalized_z - z * normalized_y);
+	result[1] = y * normalized_w + normalized_y * w + (z * normalized_x - x * normalized_z);
+	result[2] = z * normalized_w + normalized_z * w + (x * normalized_y - y * normalized_x);
+	result[3] = w * normalized_w - (x * normalized_x + y * normalized_y + z * normalized_z);
+	return result;
+}
+
+mfloat_t *quat_divide_f(mfloat_t *result, mfloat_t *quat0, mfloat_t f)
+{
+	result[0] = quat0[0] / f;
+	result[1] = quat0[1] / f;
+	result[2] = quat0[2] / f;
+	result[3] = quat0[3] / f;
+	return result;
+}
+
+mfloat_t *quat_negative(mfloat_t *result, mfloat_t *quat0)
+{
+	result[0] = -quat0[0];
+	result[1] = -quat0[1];
+	result[2] = -quat0[2];
+	result[3] = -quat0[3];
+	return result;
+}
+
+mfloat_t *quat_conjugate(mfloat_t *result, mfloat_t *quat0)
+{
+	result[0] = -quat0[0];
+	result[1] = -quat0[1];
+	result[2] = -quat0[2];
+	result[3] = quat0[3];
+	return result;
+}
+
+mfloat_t *quat_inverse(mfloat_t *result, mfloat_t *quat0)
+{
+	mfloat_t l = MFLOAT_C(1.0) / (quat0[0] * quat0[0] + quat0[1] * quat0[1] + quat0[2] * quat0[2] + quat0[3] * quat0[3]);
+	result[0] = -quat0[0] * l;
+	result[1] = -quat0[1] * l;
+	result[2] = -quat0[2] * l;
+	result[3] = quat0[3] * l;
+	return result;
+}
+
+mfloat_t *quat_normalize(mfloat_t *result, mfloat_t *quat0)
+{
+	mfloat_t l = MFLOAT_C(1.0) / MSQRT(quat0[0] * quat0[0] + quat0[1] * quat0[1] + quat0[2] * quat0[2] + quat0[3] * quat0[3]);
+	result[0] = quat0[0] * l;
+	result[1] = quat0[1] * l;
+	result[2] = quat0[2] * l;
+	result[3] = quat0[3] * l;
+	return result;
+}
+
+mfloat_t quat_dot(mfloat_t *quat0, mfloat_t *quat1)
+{
+	return quat0[0] * quat1[0] + quat0[1] * quat1[1] + quat0[2] * quat1[2] + quat0[3] * quat1[3];
+}
+
+mfloat_t *quat_power(mfloat_t *result, mfloat_t *quat0, mfloat_t exponent)
+{
+	if (MFABS(quat0[3]) < MFLOAT_C(1.0) - MFLT_EPSILON) {
+		mfloat_t alpha = MACOS(quat0[3]);
+		mfloat_t new_alpha = alpha * exponent;
+		mfloat_t s = MSIN(new_alpha) / MSIN(alpha);
+		result[0] = result[0] * s;
+		result[1] = result[1] * s;
+		result[2] = result[2] * s;
+		result[3] = MCOS(new_alpha);
+	} else {
+		result[0] = quat0[0];
+		result[1] = quat0[1];
+		result[2] = quat0[1];
+		result[3] = quat0[3];
+	}
+	return result;
+}
+
+mfloat_t *quat_from_axis_angle(mfloat_t *result, mfloat_t *vec30, mfloat_t angle)
+{
+	mfloat_t half = angle * MFLOAT_C(0.5);
+	mfloat_t s = MSIN(half);
+	result[0] = vec30[0] * s;
+	result[1] = vec30[1] * s;
+	result[2] = vec30[2] * s;
+	result[3] = MCOS(half);
+	return result;
+}
+
+mfloat_t *quat_from_vec3(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+{
+	mfloat_t cross[VEC3_SIZE];
+	mfloat_t d = vec3_dot(vec30, vec31);
+	mfloat_t a_ls = vec3_length_squared(vec30);
+	mfloat_t b_ls = vec3_length_squared(vec30);
+	vec3_cross(cross, vec30, vec31);
+	quat(result, cross[0], cross[1], cross[1], d + MSQRT(a_ls * b_ls));
+	quat_normalize(result, result);
+	return result;
+}
+
+mfloat_t *quat_from_mat4(mfloat_t *result, mfloat_t *mat40)
+{
+	mfloat_t scale = mat40[0] + mat40[5] + mat40[10];
+	if (scale > MFLOAT_C(0.0)) {
+		mfloat_t sr = MSQRT(scale + MFLOAT_C(1.0));
+		result[3] = sr * MFLOAT_C(0.5);
+		sr = MFLOAT_C(0.5) / sr;
+		result[0] = (mat40[9] - mat40[6]) * sr;
+		result[1] = (mat40[2] - mat40[8]) * sr;
+		result[2] = (mat40[4] - mat40[1]) * sr;
+	} else if ((mat40[0] >= mat40[5]) && (mat40[0] >= mat40[10])) {
+		mfloat_t sr = MSQRT(MFLOAT_C(1.0) + mat40[0] - mat40[5] - mat40[10]);
+		mfloat_t half = MFLOAT_C(0.5) / sr;
+		result[0] = MFLOAT_C(0.5) * sr;
+		result[1] = (mat40[4] + mat40[1]) * half;
+		result[2] = (mat40[8] + mat40[2]) * half;
+		result[3] = (mat40[9] - mat40[6]) * half;
+	} else if (mat40[5] > mat40[10]) {
+		mfloat_t sr = MSQRT(MFLOAT_C(1.0) + mat40[5] - mat40[0] - mat40[10]);
+		mfloat_t half = MFLOAT_C(0.5) / sr;
+		result[0] = (mat40[1] + mat40[4]) * half;
+		result[1] = MFLOAT_C(0.5) * sr;
+		result[2] = (mat40[6] + mat40[9]) * half;
+		result[3] = (mat40[2] - mat40[8]) * half;
+	} else {
+		mfloat_t sr = MSQRT(MFLOAT_C(1.0) + mat40[10] - mat40[0] - mat40[5]);
+		mfloat_t half = MFLOAT_C(0.5) / sr;
+		result[0] = (mat40[2] + mat40[8]) * half;
+		result[1] = (mat40[6] + mat40[9]) * half;
+		result[2] = MFLOAT_C(0.5) * sr;
+		result[3] = (mat40[4] - mat40[1]) * half;
+	}
+	return result;
+}
+
+mfloat_t *quat_lerp(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1, mfloat_t f)
+{
+	result[0] = quat0[0] + (quat1[0] - quat0[0]) * f;
+	result[1] = quat0[1] + (quat1[1] - quat0[1]) * f;
+	result[2] = quat0[2] + (quat1[2] - quat0[2]) * f;
+	result[3] = quat0[3] + (quat1[3] - quat0[3]) * f;
+	return result;
+}
+
+mfloat_t *quat_slerp(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1, mfloat_t f)
+{
+	mfloat_t tmp1[QUAT_SIZE];
+	mfloat_t d = quat_dot(quat0, quat1);
+	mfloat_t f0;
+	mfloat_t f1;
+	quat_assign(tmp1, quat1);
+	if (d < MFLOAT_C(0.0)) {
+		quat_negative(tmp1, tmp1);
+		d = -d;
+	}
+	if (d > MFLOAT_C(0.9995)) {
+		f0 = MFLOAT_C(1.0) - f;
+		f1 = f;
+	} else {
+		mfloat_t theta = MACOS(d);
+		mfloat_t sin_theta = MSIN(theta);
+		f0 = MSIN((MFLOAT_C(1.0) - f) * theta) / sin_theta;
+		f1 = MSIN(f * theta) / sin_theta;
+	}
+	result[0] = quat0[0] * f0 + tmp1[0] * f1;
+	result[1] = quat0[1] * f0 + tmp1[1] * f1;
+	result[2] = quat0[2] * f0 + tmp1[2] * f1;
+	result[3] = quat0[3] * f0 + tmp1[3] * f1;
+	return result;
+}
+
+mfloat_t quat_length(mfloat_t *quat0)
+{
+	return MSQRT(quat0[0] * quat0[0] + quat0[1] * quat0[1] + quat0[2] * quat0[2] + quat0[3] * quat0[3]);
+}
+
+mfloat_t quat_length_squared(mfloat_t *quat0)
+{
+	return quat0[0] * quat0[0] + quat0[1] * quat0[1] + quat0[2] * quat0[2] + quat0[3] * quat0[3];
+}
+
+mfloat_t quat_angle(mfloat_t *quat0, mfloat_t *quat1)
+{
+	mfloat_t s = MSQRT(quat_length_squared(quat0) * quat_length_squared(quat1));
+	s = MFLOAT_C(1.0) / s;
+	return MACOS(quat_dot(quat0, quat1) * s);
+}
+
+mfloat_t *mat2(mfloat_t *result, mfloat_t m11, mfloat_t m12, mfloat_t m21, mfloat_t m22)
+{
+	result[0] = m11;
+	result[1] = m21;
+	result[2] = m12;
+	result[3] = m22;
+	return result;
+}
+
+mfloat_t *mat2_zero(mfloat_t *result)
+{
+	result[0] = MFLOAT_C(0.0);
+	result[1] = MFLOAT_C(0.0);
+	result[2] = MFLOAT_C(0.0);
+	result[3] = MFLOAT_C(0.0);
+	return result;
+}
+
+mfloat_t *mat2_identity(mfloat_t *result)
+{
+	result[0] = MFLOAT_C(1.0);
+	result[1] = MFLOAT_C(0.0);
+	result[2] = MFLOAT_C(0.0);
+	result[3] = MFLOAT_C(1.0);
+	return result;
+}
+
+mfloat_t mat2_determinant(mfloat_t *mat20)
+{
+	return mat20[0] * mat20[3] - mat20[2] * mat20[1];
+}
+
+mfloat_t *mat2_assign(mfloat_t *result, mfloat_t *mat20)
+{
+	result[0] = mat20[0];
+	result[1] = mat20[1];
+	result[2] = mat20[2];
+	result[3] = mat20[3];
+	return result;
+}
+
+mfloat_t *mat2_negative(mfloat_t *result, mfloat_t *mat20)
+{
+	result[0] = -mat20[0];
+	result[1] = -mat20[1];
+	result[2] = -mat20[2];
+	result[3] = -mat20[3];
+	return result;
+}
+
+mfloat_t *mat2_transpose(mfloat_t *result, mfloat_t *mat20)
+{
+	mfloat_t transposed[MAT2_SIZE];
+	transposed[0] = mat20[0];
+	transposed[1] = mat20[2];
+	transposed[2] = mat20[1];
+	transposed[3] = mat20[3];
+	result[0] = transposed[0];
+	result[1] = transposed[1];
+	result[2] = transposed[2];
+	result[3] = transposed[3];
+	return result;
+}
+
+mfloat_t *mat2_cofactor(mfloat_t *result, mfloat_t *mat20)
+{
+	mfloat_t cofactor[MAT2_SIZE];
+	cofactor[0] = mat20[3];
+	cofactor[1] = -mat20[2];
+	cofactor[2] = -mat20[1];
+	cofactor[3] = mat20[0];
+	result[0] = cofactor[0];
+	result[1] = cofactor[1];
+	result[2] = cofactor[2];
+	result[3] = cofactor[3];
+	return result;
+}
+
+mfloat_t *mat2_adjugate(mfloat_t *result, mfloat_t *mat20)
+{
+	mfloat_t adjugate[MAT2_SIZE];
+	adjugate[0] = mat20[3];
+	adjugate[1] = -mat20[1];
+	adjugate[2] = -mat20[2];
+	adjugate[3] = mat20[0];
+	result[0] = adjugate[0];
+	result[1] = adjugate[1];
+	result[2] = adjugate[2];
+	result[3] = adjugate[3];
+	return result;
+}
+
+mfloat_t *mat2_multiply(mfloat_t *result, mfloat_t *mat20, mfloat_t *mat21)
+{
+	mfloat_t multiplied[MAT3_SIZE];
+	multiplied[0] = mat20[0] * mat21[0] + mat20[2] * mat21[1];
+	multiplied[1] = mat20[1] * mat21[0] + mat20[3] * mat21[1];
+	multiplied[2] = mat20[0] * mat21[2] + mat20[2] * mat21[3];
+	multiplied[3] = mat20[1] * mat21[2] + mat20[3] * mat21[3];
+	result[0] = multiplied[0];
+	result[1] = multiplied[1];
+	result[2] = multiplied[2];
+	result[3] = multiplied[3];
+	return result;
+}
+
+mfloat_t *mat2_multiply_f(mfloat_t *result, mfloat_t *mat20, mfloat_t f)
+{
+	result[0] = mat20[0] * f;
+	result[1] = mat20[1] * f;
+	result[2] = mat20[2] * f;
+	result[3] = mat20[3] * f;
+	return result;
+}
+
+mfloat_t *mat2_inverse(mfloat_t *result, mfloat_t *mat20)
+{
+	mfloat_t inverse[MAT2_SIZE];
+	mfloat_t det = mat2_determinant(mat20);
+	mat2_cofactor(inverse, mat20);
+	mat2_multiply_f(inverse, inverse, MFLOAT_C(1.0) / det);
+	result[0] = inverse[0];
+	result[1] = inverse[1];
+	result[2] = inverse[2];
+	result[3] = inverse[3];
+	return result;
+}
+
+mfloat_t *mat2_scaling(mfloat_t *result, mfloat_t *vec20)
+{
+	result[0] = vec20[0];
+	result[3] = vec20[1];
+	return result;
+}
+
+mfloat_t *mat2_scale(mfloat_t *result, mfloat_t *mat20, mfloat_t *vec20)
+{
+	result[0] = mat20[0] * vec20[0];
+	result[3] = mat20[3] * vec20[1];
+	return result;
+}
+
+mfloat_t *mat2_rotation_z(mfloat_t *result, mfloat_t f)
+{
+	mfloat_t c = MCOS(f);
+	mfloat_t s = MSIN(f);
+	result[0] = c;
+	result[1] = s;
+	result[2] = -s;
+	result[3] = c;
+	return result;
+}
+
+mfloat_t *mat2_lerp(mfloat_t *result, mfloat_t *mat20, mfloat_t *mat21, mfloat_t f)
+{
+	result[0] = mat20[0] + (mat21[0] - mat20[0]) * f;
+	result[1] = mat20[1] + (mat21[1] - mat20[1]) * f;
+	result[2] = mat20[2] + (mat21[2] - mat20[2]) * f;
+	result[3] = mat20[3] + (mat21[3] - mat20[3]) * f;
+	return result;
+}
+
+mfloat_t *mat3(mfloat_t *result, mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m31, mfloat_t m32, mfloat_t m33)
+{
+	result[0] = m11;
+	result[1] = m21;
+	result[2] = m31;
+	result[3] = m12;
+	result[4] = m22;
+	result[5] = m32;
+	result[6] = m13;
+	result[7] = m23;
+	result[8] = m33;
+	return result;
+}
+
+mfloat_t *mat3_zero(mfloat_t *result)
+{
+	result[0] = MFLOAT_C(0.0);
+	result[1] = MFLOAT_C(0.0);
+	result[2] = MFLOAT_C(0.0);
+	result[3] = MFLOAT_C(0.0);
+	result[4] = MFLOAT_C(0.0);
+	result[5] = MFLOAT_C(0.0);
+	result[6] = MFLOAT_C(0.0);
+	result[7] = MFLOAT_C(0.0);
+	result[8] = MFLOAT_C(0.0);
+	return result;
+}
+
+mfloat_t *mat3_identity(mfloat_t *result)
+{
+	result[0] = MFLOAT_C(1.0);
+	result[1] = MFLOAT_C(0.0);
+	result[2] = MFLOAT_C(0.0);
+	result[3] = MFLOAT_C(0.0);
+	result[4] = MFLOAT_C(1.0);
+	result[5] = MFLOAT_C(0.0);
+	result[6] = MFLOAT_C(0.0);
+	result[7] = MFLOAT_C(0.0);
+	result[8] = MFLOAT_C(8.0);
+	return result;
+}
+
+mfloat_t mat3_determinant(mfloat_t *mat30)
+{
+	mfloat_t m11 = mat30[0];
+	mfloat_t m21 = mat30[1];
+	mfloat_t m31 = mat30[2];
+	mfloat_t m12 = mat30[3];
+	mfloat_t m22 = mat30[4];
+	mfloat_t m32 = mat30[5];
+	mfloat_t m13 = mat30[6];
+	mfloat_t m23 = mat30[7];
+	mfloat_t m33 = mat30[8];
+	mfloat_t determinant = m11 * m22 * m33
+		+ m12 * m23 * m31
+		+ m13 * m21 * m32
+		- m11 * m23 * m32
+		- m12 * m21 * m33
+		- m13 * m22 * m31;
+	return determinant;
+}
+
+mfloat_t *mat3_assign(mfloat_t *result, mfloat_t *mat30)
+{
+	result[0] = mat30[0];
+	result[1] = mat30[1];
+	result[2] = mat30[2];
+	result[3] = mat30[3];
+	result[4] = mat30[4];
+	result[5] = mat30[5];
+	result[6] = mat30[6];
+	result[7] = mat30[7];
+	result[8] = mat30[8];
+	return result;
+}
+
+mfloat_t *mat3_negative(mfloat_t *result, mfloat_t *mat30)
+{
+	result[0] = -mat30[0];
+	result[1] = -mat30[1];
+	result[2] = -mat30[2];
+	result[3] = -mat30[3];
+	result[4] = -mat30[4];
+	result[5] = -mat30[5];
+	result[6] = -mat30[6];
+	result[7] = -mat30[7];
+	result[8] = -mat30[8];
+	return result;
+}
+
+mfloat_t *mat3_transpose(mfloat_t *result, mfloat_t *mat30)
+{
+	mfloat_t transposed[MAT4_SIZE];
+	transposed[0] = mat30[0];
+	transposed[1] = mat30[3];
+	transposed[2] = mat30[6];
+	transposed[3] = mat30[1];
+	transposed[4] = mat30[4];
+	transposed[5] = mat30[7];
+	transposed[6] = mat30[2];
+	transposed[7] = mat30[5];
+	transposed[8] = mat30[8];
+	result[0] = transposed[0];
+	result[1] = transposed[1];
+	result[2] = transposed[2];
+	result[3] = transposed[3];
+	result[4] = transposed[4];
+	result[5] = transposed[5];
+	result[6] = transposed[6];
+	result[7] = transposed[7];
+	result[8] = transposed[8];
+	return result;
+}
+
+mfloat_t *mat3_cofactor(mfloat_t *result, mfloat_t *mat30)
+{
+	mfloat_t cofactor[MAT3_SIZE];
+	mfloat_t minor[MAT2_SIZE];
+	minor[0] = mat30[4];
+	minor[1] = mat30[5];
+	minor[2] = mat30[7];
+	minor[3] = mat30[8];
+	cofactor[0] = mat2_determinant(minor);
+	minor[0] = mat30[3];
+	minor[1] = mat30[5];
+	minor[2] = mat30[6];
+	minor[3] = mat30[8];
+	cofactor[1] = -mat2_determinant(minor);
+	minor[0] = mat30[3];
+	minor[1] = mat30[4];
+	minor[2] = mat30[6];
+	minor[3] = mat30[7];
+	cofactor[2] = mat2_determinant(minor);
+	minor[0] = mat30[1];
+	minor[1] = mat30[2];
+	minor[2] = mat30[7];
+	minor[3] = mat30[8];
+	cofactor[3] = -mat2_determinant(minor);
+	minor[0] = mat30[0];
+	minor[1] = mat30[2];
+	minor[2] = mat30[6];
+	minor[3] = mat30[8];
+	cofactor[4] = mat2_determinant(minor);
+	minor[0] = mat30[0];
+	minor[1] = mat30[1];
+	minor[2] = mat30[6];
+	minor[3] = mat30[7];
+	cofactor[5] = -mat2_determinant(minor);
+	minor[0] = mat30[1];
+	minor[1] = mat30[2];
+	minor[2] = mat30[4];
+	minor[3] = mat30[5];
+	cofactor[6] = mat2_determinant(minor);
+	minor[0] = mat30[0];
+	minor[1] = mat30[2];
+	minor[2] = mat30[3];
+	minor[3] = mat30[5];
+	cofactor[7] = -mat2_determinant(minor);
+	minor[0] = mat30[0];
+	minor[1] = mat30[1];
+	minor[2] = mat30[3];
+	minor[3] = mat30[4];
+	cofactor[8] = mat2_determinant(minor);
+	result[0] = cofactor[0];
+	result[1] = cofactor[1];
+	result[2] = cofactor[2];
+	result[3] = cofactor[3];
+	result[4] = cofactor[4];
+	result[5] = cofactor[5];
+	result[6] = cofactor[6];
+	result[7] = cofactor[7];
+	result[8] = cofactor[8];
+	return result;
+}
+
+mfloat_t *mat3_multiply(mfloat_t *result, mfloat_t *mat30, mfloat_t *mat31)
+{
+	mfloat_t multiplied[MAT3_SIZE];
+	multiplied[0] = mat30[0] * mat31[0] + mat30[3] * mat31[1] + mat30[6] * mat31[2];
+	multiplied[1] = mat30[1] * mat31[0] + mat30[4] * mat31[1] + mat30[7] * mat31[2];
+	multiplied[2] = mat30[2] * mat31[0] + mat30[5] * mat31[1] + mat30[8] * mat31[2];
+	multiplied[3] = mat30[0] * mat31[3] + mat30[3] * mat31[4] + mat30[6] * mat31[5];
+	multiplied[4] = mat30[1] * mat31[3] + mat30[4] * mat31[4] + mat30[7] * mat31[5];
+	multiplied[5] = mat30[2] * mat31[3] + mat30[5] * mat31[4] + mat30[8] * mat31[5];
+	multiplied[6] = mat30[0] * mat31[6] + mat30[3] * mat31[7] + mat30[6] * mat31[8];
+	multiplied[7] = mat30[1] * mat31[6] + mat30[4] * mat31[7] + mat30[7] * mat31[8];
+	multiplied[8] = mat30[2] * mat31[6] + mat30[5] * mat31[7] + mat30[8] * mat31[8];
+	result[0] = multiplied[0];
+	result[1] = multiplied[1];
+	result[2] = multiplied[2];
+	result[3] = multiplied[3];
+	result[4] = multiplied[4];
+	result[5] = multiplied[5];
+	result[6] = multiplied[6];
+	result[7] = multiplied[7];
+	result[8] = multiplied[8];
+	return result;
+}
+
+mfloat_t *mat3_multiply_f(mfloat_t *result, mfloat_t *mat30, mfloat_t f)
+{
+	result[0] = mat30[0] * f;
+	result[1] = mat30[1] * f;
+	result[2] = mat30[2] * f;
+	result[3] = mat30[3] * f;
+	result[4] = mat30[4] * f;
+	result[5] = mat30[5] * f;
+	result[6] = mat30[6] * f;
+	result[7] = mat30[7] * f;
+	result[8] = mat30[8] * f;
+	return result;
+}
+
+mfloat_t *mat3_inverse(mfloat_t *result, mfloat_t *mat30)
+{
+	result = mat30;
+	return result;
+}
+
+mfloat_t *mat3_scaling(mfloat_t *result, mfloat_t *vec30)
+{
+	result[0] = vec30[0];
+	result[4] = vec30[1];
+	result[8] = vec30[2];
+	return result;
+}
+
+mfloat_t *mat3_scale(mfloat_t *result, mfloat_t *mat30, mfloat_t *vec30)
+{
+	result[0] = mat30[0] * vec30[0];
+	result[4] = mat30[4] * vec30[1];
+	result[8] = mat30[8] * vec30[2];
+	return result;
+}
+
+mfloat_t *mat3_rotation_x(mfloat_t *result, mfloat_t f)
+{
+	mfloat_t c = MCOS(f);
+	mfloat_t s = MSIN(f);
+	result[4] = c;
+	result[5] = s;
+	result[7] = -s;
+	result[8] = -c;
+	return result;
+}
+
+mfloat_t *mat3_rotation_y(mfloat_t *result, mfloat_t f)
+{
+	mfloat_t c = MCOS(f);
+	mfloat_t s = MSIN(f);
+	result[0] = c;
+	result[2] = -s;
+	result[6] = s;
+	result[8] = c;
+	return result;
+}
+
+mfloat_t *mat3_rotation_z(mfloat_t *result, mfloat_t f)
+{
+	mfloat_t c = MCOS(f);
+	mfloat_t s = MSIN(f);
+	result[0] = c;
+	result[1] = s;
+	result[3] = -s;
+	result[4] = c;
+	return result;
+}
+
+mfloat_t *mat3_rotation_axis(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
+{
+	mfloat_t c = MCOS(f);
+	mfloat_t s = MSIN(f);
+	mfloat_t one_c = MFLOAT_C(1.0) - c;
+	mfloat_t x = vec30[0];
+	mfloat_t y = vec30[4];
+	mfloat_t z = vec30[8];
+	mfloat_t xx = x * x;
+	mfloat_t xy = x * y;
+	mfloat_t xz = x * z;
+	mfloat_t yy = y * y;
+	mfloat_t yz = y * z;
+	mfloat_t zz = z * z;
+	mfloat_t l = xx + yy + zz;
+	mfloat_t sqrt_l = MSQRT(l);
+	result[0] = (xx + (yy + zz) * c) / l;
+	result[1] = (xy * one_c + vec30[2] * sqrt_l * s) / l;
+	result[2] = (xz * one_c - vec30[1] * sqrt_l * s) / l;
+	result[3] = (xy * one_c - vec30[2] * sqrt_l * s) / l;
+	result[4] = (yy + (xx + zz) * c) / l;
+	result[5] = (yz * one_c + vec30[0] * sqrt_l * s) / l;
+	result[6] = (xz * one_c + vec30[1] * sqrt_l * s) / l;
+	result[7] = (yz * one_c - vec30[0] * sqrt_l * s) / l;
+	result[8] = (zz + (xx + yy) * c) / l;
+	return result;
+}
+
+mfloat_t *mat3_rotation_quat(mfloat_t *result, mfloat_t *quat0)
+{
+	mfloat_t xx = quat0[0] * quat0[0];
+	mfloat_t yy = quat0[1] * quat0[1];
+	mfloat_t zz = quat0[2] * quat0[2];
+	mfloat_t xy = quat0[0] * quat0[1];
+	mfloat_t zw = quat0[2] * quat0[3];
+	mfloat_t xz = quat0[8] * quat0[0];
+	mfloat_t yw = quat0[1] * quat0[3];
+	mfloat_t yz = quat0[1] * quat0[2];
+	mfloat_t xw = quat0[0] * quat0[3];
+	result[0] = MFLOAT_C(1.0) - MFLOAT_C(2.0) * (yy - zz);
+	result[1] = MFLOAT_C(2.0) * (xy + zw);
+	result[2] = MFLOAT_C(2.0) * (xz - yw);
+	result[3] = MFLOAT_C(2.0) * (xy - zw);
+	result[4] = MFLOAT_C(1.0) - MFLOAT_C(2.0) * (xx - zz);
+	result[5] = MFLOAT_C(2.0) * (yz + xw);
+	result[6] = MFLOAT_C(2.0) * (xz + yw);
+	result[7] = MFLOAT_C(2.0) * (yz - xw);
+	result[8] = MFLOAT_C(1.0) - MFLOAT_C(2.0) * (xx - yy);
+	return result;
+}
+
+mfloat_t *mat3_lerp(mfloat_t *result, mfloat_t *mat30, mfloat_t *mat31, mfloat_t f)
+{
+	result[0] = mat30[0] + (mat31[0] - mat30[0]) * f;
+	result[1] = mat30[1] + (mat31[1] - mat30[1]) * f;
+	result[2] = mat30[2] + (mat31[2] - mat30[2]) * f;
+	result[3] = mat30[3] + (mat31[3] - mat30[3]) * f;
+	result[4] = mat30[4] + (mat31[4] - mat30[4]) * f;
+	result[5] = mat30[5] + (mat31[5] - mat30[5]) * f;
+	result[6] = mat30[6] + (mat31[6] - mat30[6]) * f;
+	result[7] = mat30[7] + (mat31[7] - mat30[7]) * f;
+	result[8] = mat30[8] + (mat31[8] - mat30[8]) * f;
+	return result;
+}
+
+mfloat_t *mat4(mfloat_t *result, mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m14, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m24, mfloat_t m31, mfloat_t m32, mfloat_t m33, mfloat_t m34, mfloat_t m41, mfloat_t m42, mfloat_t m43, mfloat_t m44)
+{
+	result[0] = m11;
+	result[1] = m21;
+	result[2] = m31;
+	result[3] = m41;
+	result[4] = m12;
+	result[5] = m22;
+	result[6] = m32;
+	result[7] = m42;
+	result[8] = m13;
+	result[9] = m23;
+	result[10] = m33;
+	result[11] = m43;
+	result[12] = m14;
+	result[13] = m24;
+	result[14] = m34;
+	result[15] = m44;
+	return result;
+}
+
+mfloat_t *mat4_zero(mfloat_t *result)
+{
+	result[0] = MFLOAT_C(0.0);
+	result[1] = MFLOAT_C(0.0);
+	result[2] = MFLOAT_C(0.0);
+	result[3] = MFLOAT_C(0.0);
+	result[4] = MFLOAT_C(0.0);
+	result[5] = MFLOAT_C(0.0);
+	result[6] = MFLOAT_C(0.0);
+	result[7] = MFLOAT_C(0.0);
+	result[8] = MFLOAT_C(0.0);
+	result[9] = MFLOAT_C(0.0);
+	result[10] = MFLOAT_C(0.0);
+	result[11] = MFLOAT_C(0.0);
+	result[12] = MFLOAT_C(0.0);
+	result[13] = MFLOAT_C(0.0);
+	result[14] = MFLOAT_C(0.0);
+	result[15] = MFLOAT_C(0.0);
+	return result;
+}
+
+mfloat_t *mat4_identity(mfloat_t *result)
+{
+	result[0] = MFLOAT_C(1.0);
+	result[1] = MFLOAT_C(0.0);
+	result[2] = MFLOAT_C(0.0);
+	result[3] = MFLOAT_C(0.0);
+	result[4] = MFLOAT_C(0.0);
+	result[5] = MFLOAT_C(1.0);
+	result[6] = MFLOAT_C(0.0);
+	result[7] = MFLOAT_C(0.0);
+	result[8] = MFLOAT_C(0.0);
+	result[9] = MFLOAT_C(0.0);
+	result[10] = MFLOAT_C(1.0);
+	result[11] = MFLOAT_C(0.0);
+	result[12] = MFLOAT_C(0.0);
+	result[13] = MFLOAT_C(0.0);
+	result[14] = MFLOAT_C(0.0);
+	result[15] = MFLOAT_C(1.0);
+	return result;
+}
+
+mfloat_t mat4_determinant(mfloat_t *mat40)
+{
+	mfloat_t m11 = mat40[0];
+	mfloat_t m21 = mat40[1];
+	mfloat_t m31 = mat40[2];
+	mfloat_t m41 = mat40[3];
+	mfloat_t m12 = mat40[4];
+	mfloat_t m22 = mat40[5];
+	mfloat_t m32 = mat40[6];
+	mfloat_t m42 = mat40[7];
+	mfloat_t m13 = mat40[8];
+	mfloat_t m23 = mat40[9];
+	mfloat_t m33 = mat40[10];
+	mfloat_t m43 = mat40[11];
+	mfloat_t m14 = mat40[12];
+	mfloat_t m24 = mat40[13];
+	mfloat_t m34 = mat40[14];
+	mfloat_t m44 = mat40[15];
+	mfloat_t determinant = m14 * m23 * m32 * m41 - m13 * m24 * m32 * m41
+		- m14 * m22 * m33 * m41 + m12 * m24 * m33 * m41
+		+ m13 * m22 * m34 * m41 - m12 * m23 * m34 * m41
+		- m14 * m23 * m31 * m42 + m13 * m24 * m31 * m42
+		+ m14 * m21 * m33 * m42 - m11 * m24 * m33 * m42
+		- m13 * m21 * m34 * m42 + m11 * m23 * m34 * m42
+		+ m14 * m22 * m31 * m43 - m12 * m24 * m31 * m43
+		- m14 * m21 * m32 * m43 + m11 * m24 * m32 * m43
+		+ m12 * m21 * m34 * m43 - m11 * m22 * m34 * m43
+		- m13 * m22 * m31 * m44 + m12 * m23 * m31 * m44
+		+ m13 * m21 * m32 * m44 - m11 * m23 * m32 * m44
+		- m12 * m21 * m33 * m44 + m11 * m22 * m33 * m44;
+	return determinant;
+}
+
+mfloat_t *mat4_assign(mfloat_t *result, mfloat_t *mat40)
+{
+	result[0] = mat40[0];
+	result[1] = mat40[1];
+	result[2] = mat40[2];
+	result[3] = mat40[3];
+	result[4] = mat40[4];
+	result[5] = mat40[5];
+	result[6] = mat40[6];
+	result[7] = mat40[7];
+	result[8] = mat40[8];
+	result[9] = mat40[9];
+	result[10] = mat40[10];
+	result[11] = mat40[11];
+	result[12] = mat40[12];
+	result[13] = mat40[13];
+	result[14] = mat40[14];
+	result[15] = mat40[15];
+	return result;
+}
+
+mfloat_t *mat4_negative(mfloat_t *result, mfloat_t *mat40)
+{
+	result[0] = -mat40[0];
+	result[1] = -mat40[1];
+	result[2] = -mat40[2];
+	result[3] = -mat40[3];
+	result[4] = -mat40[4];
+	result[5] = -mat40[5];
+	result[6] = -mat40[6];
+	result[7] = -mat40[7];
+	result[8] = -mat40[8];
+	result[9] = -mat40[9];
+	result[10] = -mat40[10];
+	result[11] = -mat40[11];
+	result[12] = -mat40[12];
+	result[13] = -mat40[13];
+	result[14] = -mat40[14];
+	result[15] = -mat40[15];
+	return result;
+}
+
+mfloat_t *mat4_transpose(mfloat_t *result, mfloat_t *mat40)
+{
+	mfloat_t transposed[MAT4_SIZE];
+	transposed[0] = mat40[0];
+	transposed[1] = mat40[4];
+	transposed[2] = mat40[8];
+	transposed[3] = mat40[12];
+	transposed[4] = mat40[1];
+	transposed[5] = mat40[5];
+	transposed[6] = mat40[9];
+	transposed[7] = mat40[13];
+	transposed[8] = mat40[2];
+	transposed[9] = mat40[6];
+	transposed[10] = mat40[10];
+	transposed[11] = mat40[14];
+	transposed[12] = mat40[3];
+	transposed[13] = mat40[7];
+	transposed[14] = mat40[11];
+	transposed[15] = mat40[15];
+	result[0] = transposed[0];
+	result[1] = transposed[1];
+	result[2] = transposed[2];
+	result[3] = transposed[3];
+	result[4] = transposed[4];
+	result[5] = transposed[5];
+	result[6] = transposed[6];
+	result[7] = transposed[7];
+	result[8] = transposed[8];
+	result[9] = transposed[9];
+	result[10] = transposed[10];
+	result[11] = transposed[11];
+	result[12] = transposed[12];
+	result[13] = transposed[13];
+	result[14] = transposed[14];
+	result[15] = transposed[15];
+	return result;
+}
+
+mfloat_t *mat4_cofactor(mfloat_t *result, mfloat_t *mat40)
+{
+	mfloat_t cofactor[MAT4_SIZE];
+	mfloat_t minor[MAT3_SIZE];
+	minor[0] = mat40[5];
+	minor[1] = mat40[6];
+	minor[2] = mat40[7];
+	minor[3] = mat40[9];
+	minor[4] = mat40[10];
+	minor[5] = mat40[11];
+	minor[6] = mat40[13];
+	minor[7] = mat40[14];
+	minor[8] = mat40[15];
+	cofactor[0] = mat3_determinant(minor);
+	minor[0] = mat40[4];
+	minor[1] = mat40[6];
+	minor[2] = mat40[7];
+	minor[3] = mat40[8];
+	minor[4] = mat40[10];
+	minor[5] = mat40[11];
+	minor[6] = mat40[12];
+	minor[7] = mat40[14];
+	minor[8] = mat40[15];
+	cofactor[1] = -mat3_determinant(minor);
+	minor[0] = mat40[4];
+	minor[1] = mat40[5];
+	minor[2] = mat40[7];
+	minor[3] = mat40[8];
+	minor[4] = mat40[9];
+	minor[5] = mat40[11];
+	minor[6] = mat40[12];
+	minor[7] = mat40[13];
+	minor[8] = mat40[15];
+	cofactor[2] = mat3_determinant(minor);
+	minor[0] = mat40[4];
+	minor[1] = mat40[5];
+	minor[2] = mat40[6];
+	minor[3] = mat40[8];
+	minor[4] = mat40[9];
+	minor[5] = mat40[10];
+	minor[6] = mat40[12];
+	minor[7] = mat40[13];
+	minor[8] = mat40[14];
+	cofactor[3] = -mat3_determinant(minor);
+	minor[0] = mat40[1];
+	minor[1] = mat40[2];
+	minor[2] = mat40[3];
+	minor[3] = mat40[9];
+	minor[4] = mat40[10];
+	minor[5] = mat40[11];
+	minor[6] = mat40[13];
+	minor[7] = mat40[14];
+	minor[8] = mat40[15];
+	cofactor[4] = -mat3_determinant(minor);
+	minor[0] = mat40[0];
+	minor[1] = mat40[2];
+	minor[2] = mat40[3];
+	minor[3] = mat40[8];
+	minor[4] = mat40[10];
+	minor[5] = mat40[11];
+	minor[6] = mat40[12];
+	minor[7] = mat40[14];
+	minor[8] = mat40[15];
+	cofactor[5] = mat3_determinant(minor);
+	minor[0] = mat40[0];
+	minor[1] = mat40[1];
+	minor[2] = mat40[3];
+	minor[3] = mat40[8];
+	minor[4] = mat40[9];
+	minor[5] = mat40[11];
+	minor[6] = mat40[12];
+	minor[7] = mat40[13];
+	minor[8] = mat40[15];
+	cofactor[6] = -mat3_determinant(minor);
+	minor[0] = mat40[0];
+	minor[1] = mat40[1];
+	minor[2] = mat40[2];
+	minor[3] = mat40[8];
+	minor[4] = mat40[9];
+	minor[5] = mat40[10];
+	minor[6] = mat40[12];
+	minor[7] = mat40[13];
+	minor[8] = mat40[14];
+	cofactor[7] = mat3_determinant(minor);
+	minor[0] = mat40[1];
+	minor[1] = mat40[2];
+	minor[2] = mat40[3];
+	minor[3] = mat40[5];
+	minor[4] = mat40[6];
+	minor[5] = mat40[7];
+	minor[6] = mat40[13];
+	minor[7] = mat40[14];
+	minor[8] = mat40[15];
+	cofactor[8] = mat3_determinant(minor);
+	minor[0] = mat40[0];
+	minor[1] = mat40[2];
+	minor[2] = mat40[3];
+	minor[3] = mat40[4];
+	minor[4] = mat40[6];
+	minor[5] = mat40[7];
+	minor[6] = mat40[12];
+	minor[7] = mat40[14];
+	minor[8] = mat40[15];
+	cofactor[9] = -mat3_determinant(minor);
+	minor[0] = mat40[0];
+	minor[1] = mat40[1];
+	minor[2] = mat40[3];
+	minor[3] = mat40[4];
+	minor[4] = mat40[5];
+	minor[5] = mat40[7];
+	minor[6] = mat40[12];
+	minor[7] = mat40[13];
+	minor[8] = mat40[15];
+	cofactor[10] = mat3_determinant(minor);
+	minor[0] = mat40[0];
+	minor[1] = mat40[1];
+	minor[2] = mat40[2];
+	minor[3] = mat40[4];
+	minor[4] = mat40[5];
+	minor[5] = mat40[6];
+	minor[6] = mat40[12];
+	minor[7] = mat40[13];
+	minor[8] = mat40[14];
+	cofactor[11] = -mat3_determinant(minor);
+	minor[0] = mat40[1];
+	minor[1] = mat40[2];
+	minor[2] = mat40[3];
+	minor[3] = mat40[5];
+	minor[4] = mat40[6];
+	minor[5] = mat40[7];
+	minor[6] = mat40[9];
+	minor[7] = mat40[10];
+	minor[8] = mat40[11];
+	cofactor[12] = -mat3_determinant(minor);
+	minor[0] = mat40[0];
+	minor[1] = mat40[2];
+	minor[2] = mat40[3];
+	minor[3] = mat40[4];
+	minor[4] = mat40[6];
+	minor[5] = mat40[7];
+	minor[6] = mat40[8];
+	minor[7] = mat40[10];
+	minor[8] = mat40[11];
+	cofactor[13] = mat3_determinant(minor);
+	minor[0] = mat40[0];
+	minor[1] = mat40[1];
+	minor[2] = mat40[3];
+	minor[3] = mat40[4];
+	minor[4] = mat40[5];
+	minor[5] = mat40[7];
+	minor[6] = mat40[8];
+	minor[7] = mat40[9];
+	minor[8] = mat40[11];
+	cofactor[14] = -mat3_determinant(minor);
+	minor[0] = mat40[0];
+	minor[1] = mat40[1];
+	minor[2] = mat40[2];
+	minor[3] = mat40[4];
+	minor[4] = mat40[5];
+	minor[5] = mat40[6];
+	minor[6] = mat40[8];
+	minor[7] = mat40[9];
+	minor[8] = mat40[10];
+	cofactor[15] = mat3_determinant(minor);
+	result[0] = cofactor[0];
+	result[1] = cofactor[1];
+	result[2] = cofactor[2];
+	result[3] = cofactor[3];
+	result[4] = cofactor[4];
+	result[5] = cofactor[5];
+	result[6] = cofactor[6];
+	result[7] = cofactor[7];
+	result[8] = cofactor[8];
+	result[9] = cofactor[9];
+	result[10] = cofactor[10];
+	result[11] = cofactor[11];
+	result[12] = cofactor[12];
+	result[13] = cofactor[13];
+	result[14] = cofactor[14];
+	result[15] = cofactor[15];
+	return result;
+}
+
+mfloat_t *mat4_rotation_x(mfloat_t *result, mfloat_t f)
+{
+	mfloat_t c = MCOS(f);
+	mfloat_t s = MSIN(f);
+	result[5] = c;
+	result[6] = s;
+	result[9] = -s;
+	result[10] = c;
+	return result;
+}
+
+mfloat_t *mat4_rotation_y(mfloat_t *result, mfloat_t f)
+{
+	mfloat_t c = MCOS(f);
+	mfloat_t s = MSIN(f);
+	result[0] = c;
+	result[2] = -s;
+	result[8] = s;
+	result[10] = c;
+	return result;
+}
+
+mfloat_t *mat4_rotation_z(mfloat_t *result, mfloat_t f)
+{
+	mfloat_t c = MCOS(f);
+	mfloat_t s = MSIN(f);
+	result[0] = c;
+	result[1] = s;
+	result[4] = -s;
+	result[5] = c;
+	return result;
+}
+
+mfloat_t *mat4_rotation_axis(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
+{
+	mfloat_t c = MCOS(f);
+	mfloat_t s = MSIN(f);
+	mfloat_t one_c = MFLOAT_C(1.0) - c;
+	mfloat_t x = vec30[0];
+	mfloat_t y = vec30[4];
+	mfloat_t z = vec30[8];
+	mfloat_t xx = x * x;
+	mfloat_t xy = x * y;
+	mfloat_t xz = x * z;
+	mfloat_t yy = y * y;
+	mfloat_t yz = y * z;
+	mfloat_t zz = z * z;
+	mfloat_t l = xx + yy + zz;
+	mfloat_t sqrt_l = MSQRT(l);
+	result[0] = (xx + (yy + zz) * c) / l;
+	result[1] = (xy * one_c + vec30[2] * sqrt_l * s) / l;
+	result[2] = (xz * one_c - vec30[1] * sqrt_l * s) / l;
+	result[3] = MFLOAT_C(0.0);
+	result[4] = (xy * one_c - vec30[2] * sqrt_l * s) / l;
+	result[5] = (yy + (xx + zz) * c) / l;
+	result[6] = (yz * one_c + vec30[0] * sqrt_l * s) / l;
+	result[7] = MFLOAT_C(0.0);
+	result[8] = (xz * one_c + vec30[1] * sqrt_l * s) / l;
+	result[9] = (yz * one_c - vec30[0] * sqrt_l * s) / l;
+	result[10] = (zz + (xx + yy) * c) / l;
+	result[11] = MFLOAT_C(0.0);
+	result[12] = MFLOAT_C(0.0);
+	result[13] = MFLOAT_C(0.0);
+	result[14] = MFLOAT_C(0.0);
+	result[15] = MFLOAT_C(1.0);
+	return result;
+}
+
+mfloat_t *mat4_rotation_quat(mfloat_t *result, mfloat_t *quat0)
+{
+	mfloat_t xx = quat0[0] * quat0[0];
+	mfloat_t yy = quat0[1] * quat0[1];
+	mfloat_t zz = quat0[2] * quat0[2];
+	mfloat_t xy = quat0[0] * quat0[1];
+	mfloat_t zw = quat0[2] * quat0[3];
+	mfloat_t xz = quat0[8] * quat0[0];
+	mfloat_t yw = quat0[1] * quat0[3];
+	mfloat_t yz = quat0[1] * quat0[2];
+	mfloat_t xw = quat0[0] * quat0[3];
+	result[0] = MFLOAT_C(1.0) - MFLOAT_C(2.0) * (yy - zz);
+	result[1] = MFLOAT_C(2.0) * (xy + zw);
+	result[2] = MFLOAT_C(2.0) * (xz - yw);
+	result[3] = MFLOAT_C(0.0);
+	result[4] = MFLOAT_C(2.0) * (xy - zw);
+	result[5] = MFLOAT_C(1.0) - MFLOAT_C(2.0) * (xx - zz);
+	result[6] = MFLOAT_C(2.0) * (yz + xw);
+	result[7] = MFLOAT_C(0.0);
+	result[8] = MFLOAT_C(2.0) * (xz + yw);
+	result[9] = MFLOAT_C(2.0) * (yz - xw);
+	result[10] = MFLOAT_C(1.0) - MFLOAT_C(2.0) * (xx - yy);
+	result[11] = MFLOAT_C(0.0);
+	result[12] = MFLOAT_C(0.0);
+	result[13] = MFLOAT_C(0.0);
+	result[14] = MFLOAT_C(0.0);
+	result[15] = MFLOAT_C(1.0);
+	return result;
+}
+
+mfloat_t *mat4_translation(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30)
+{
+	result[0] = mat40[0];
+	result[1] = mat40[1];
+	result[2] = mat40[2];
+	result[3] = mat40[3];
+	result[4] = mat40[4];
+	result[5] = mat40[5];
+	result[6] = mat40[6];
+	result[7] = mat40[7];
+	result[8] = mat40[8];
+	result[9] = mat40[9];
+	result[10] = mat40[10];
+	result[11] = mat40[11];
+	result[12] = vec30[0];
+	result[13] = vec30[1];
+	result[14] = vec30[2];
+	result[15] = mat40[15];
+	return result;
+}
+
+mfloat_t *mat4_translate(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30)
+{
+	result[0] = mat40[0];
+	result[1] = mat40[1];
+	result[2] = mat40[2];
+	result[3] = mat40[3];
+	result[4] = mat40[4];
+	result[5] = mat40[5];
+	result[6] = mat40[6];
+	result[7] = mat40[7];
+	result[8] = mat40[8];
+	result[9] = mat40[9];
+	result[10] = mat40[10];
+	result[11] = mat40[11];
+	result[12] = mat40[12] + vec30[0];
+	result[13] = mat40[13] + vec30[1];
+	result[14] = mat40[14] + vec30[2];
+	result[15] = mat40[15];
+	return result;
+}
+
+mfloat_t *mat4_scaling(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30)
+{
+	result[0] = vec30[0];
+	result[1] = mat40[1];
+	result[2] = mat40[2];
+	result[3] = mat40[3];
+	result[4] = mat40[4];
+	result[5] = vec30[1];
+	result[6] = mat40[6];
+	result[7] = mat40[7];
+	result[8] = mat40[8];
+	result[9] = mat40[9];
+	result[10] = vec30[2];
+	result[11] = mat40[11];
+	result[12] = mat40[12];
+	result[13] = mat40[13];
+	result[14] = mat40[14];
+	result[15] = mat40[15];
+	return result;
+}
+
+mfloat_t *mat4_scale(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30)
+{
+	result[0] = mat40[0] * vec30[0];
+	result[1] = mat40[1];
+	result[2] = mat40[2];
+	result[3] = mat40[3];
+	result[4] = mat40[4];
+	result[5] = mat40[5] * vec30[1];
+	result[6] = mat40[6];
+	result[7] = mat40[7];
+	result[8] = mat40[8];
+	result[9] = mat40[9];
+	result[10] = mat40[10] * vec30[2];
+	result[11] = mat40[11];
+	result[12] = mat40[12];
+	result[13] = mat40[13];
+	result[14] = mat40[14];
+	result[15] = mat40[15];
+	return result;
+}
+
+mfloat_t *mat4_multiply(mfloat_t *result, mfloat_t *mat40, mfloat_t *mat41)
+{
+	mfloat_t multiplied[MAT4_SIZE];
+	multiplied[0] = mat40[0] * mat41[0] + mat40[4] * mat41[1] + mat40[8] * mat41[2] + mat40[12] * mat41[3];
+	multiplied[1] = mat40[1] * mat41[0] + mat40[5] * mat41[1] + mat40[9] * mat41[2] + mat40[13] * mat41[3];
+	multiplied[2] = mat40[2] * mat41[0] + mat40[6] * mat41[1] + mat40[10] * mat41[2] + mat40[14] * mat41[3];
+	multiplied[3] = mat40[3] * mat41[0] + mat40[7] * mat41[1] + mat40[11] * mat41[2] + mat40[15] * mat41[3];
+	multiplied[4] = mat40[0] * mat41[4] + mat40[4] * mat41[5] + mat40[8] * mat41[6] + mat40[12] * mat41[7];
+	multiplied[5] = mat40[1] * mat41[4] + mat40[5] * mat41[5] + mat40[9] * mat41[6] + mat40[13] * mat41[7];
+	multiplied[6] = mat40[2] * mat41[4] + mat40[6] * mat41[5] + mat40[10] * mat41[6] + mat40[14] * mat41[7];
+	multiplied[7] = mat40[3] * mat41[4] + mat40[7] * mat41[5] + mat40[11] * mat41[6] + mat40[15] * mat41[7];
+	multiplied[8] = mat40[0] * mat41[8] + mat40[4] * mat41[9] + mat40[8] * mat41[10] + mat40[12] * mat41[11];
+	multiplied[9] = mat40[1] * mat41[8] + mat40[5] * mat41[9] + mat40[9] * mat41[10] + mat40[13] * mat41[11];
+	multiplied[10] = mat40[2] * mat41[8] + mat40[6] * mat41[9] + mat40[10] * mat41[10] + mat40[14] * mat41[11];
+	multiplied[11] = mat40[3] * mat41[8] + mat40[7] * mat41[9] + mat40[11] * mat41[10] + mat40[15] * mat41[11];
+	multiplied[12] = mat40[0] * mat41[12] + mat40[4] * mat41[13] + mat40[8] * mat41[14] + mat40[12] * mat41[15];
+	multiplied[13] = mat40[1] * mat41[12] + mat40[5] * mat41[13] + mat40[9] * mat41[14] + mat40[13] * mat41[15];
+	multiplied[14] = mat40[2] * mat41[12] + mat40[6] * mat41[13] + mat40[10] * mat41[14] + mat40[14] * mat41[15];
+	multiplied[15] = mat40[3] * mat41[12] + mat40[7] * mat41[13] + mat40[11] * mat41[14] + mat40[15] * mat41[15];
+	result[0] = multiplied[0];
+	result[1] = multiplied[1];
+	result[2] = multiplied[2];
+	result[3] = multiplied[3];
+	result[4] = multiplied[4];
+	result[5] = multiplied[5];
+	result[6] = multiplied[6];
+	result[7] = multiplied[7];
+	result[8] = multiplied[8];
+	result[9] = multiplied[9];
+	result[10] = multiplied[10];
+	result[11] = multiplied[11];
+	result[12] = multiplied[12];
+	result[13] = multiplied[13];
+	result[14] = multiplied[14];
+	result[15] = multiplied[15];
+	return result;
+}
+
+mfloat_t *mat4_multiply_f(mfloat_t *result, mfloat_t *mat40, mfloat_t f)
+{
+	result[0] = mat40[0] * f;
+	result[1] = mat40[1] * f;
+	result[2] = mat40[2] * f;
+	result[3] = mat40[3] * f;
+	result[4] = mat40[4] * f;
+	result[5] = mat40[5] * f;
+	result[6] = mat40[6] * f;
+	result[7] = mat40[7] * f;
+	result[8] = mat40[8] * f;
+	result[9] = mat40[9] * f;
+	result[10] = mat40[10] * f;
+	result[11] = mat40[11] * f;
+	result[12] = mat40[12] * f;
+	result[13] = mat40[13] * f;
+	result[14] = mat40[14] * f;
+	result[15] = mat40[15] * f;
+	return result;
+}
+
+mfloat_t *mat4_inverse(mfloat_t *result, mfloat_t *mat40)
+{
+	mfloat_t inverse[MAT4_SIZE];
+	mfloat_t inverted_determinant;
+	mfloat_t m11 = mat40[0];
+	mfloat_t m21 = mat40[1];
+	mfloat_t m31 = mat40[2];
+	mfloat_t m41 = mat40[3];
+	mfloat_t m12 = mat40[4];
+	mfloat_t m22 = mat40[5];
+	mfloat_t m32 = mat40[6];
+	mfloat_t m42 = mat40[7];
+	mfloat_t m13 = mat40[8];
+	mfloat_t m23 = mat40[9];
+	mfloat_t m33 = mat40[10];
+	mfloat_t m43 = mat40[11];
+	mfloat_t m14 = mat40[12];
+	mfloat_t m24 = mat40[13];
+	mfloat_t m34 = mat40[14];
+	mfloat_t m44 = mat40[15];
+	inverse[0] = m22 * m33 * m44
+		- m22 * m43 * m34
+		- m23 * m32 * m44
+		+ m23 * m42 * m34
+		+ m24 * m32 * m43
+		- m24 * m42 * m33;
+	inverse[4] = -m12 * m33 * m44
+		+ m12 * m43 * m34
+		+ m13 * m32 * m44
+		- m13 * m42 * m34
+		- m14 * m32 * m43
+		+ m14 * m42 * m33;
+	inverse[8] = m12 * m23 * m44
+		- m12 * m43 * m24
+		- m13 * m22 * m44
+		+ m13 * m42 * m24
+		+ m14 * m22 * m43
+		- m14 * m42 * m23;
+	inverse[12] = -m12 * m23 * m34
+		+ m12 * m33 * m24
+		+ m13 * m22 * m34
+		- m13 * m32 * m24
+		- m14 * m22 * m33
+		+ m14 * m32 * m23;
+	inverse[1] = -m21 * m33 * m44
+		+ m21 * m43 * m34
+		+ m23 * m31 * m44
+		- m23 * m41 * m34
+		- m24 * m31 * m43
+		+ m24 * m41 * m33;
+	inverse[5] =m11 * m33 * m44
+		-m11 * m43 * m34
+		- m13 * m31 * m44
+		+ m13 * m41 * m34
+		+ m14 * m31 * m43
+		- m14 * m41 * m33;
+	inverse[9] = -m11 * m23 * m44
+		+m11 * m43 * m24
+		+ m13 * m21 * m44
+		- m13 * m41 * m24
+		- m14 * m21 * m43
+		+ m14 * m41 * m23;
+	inverse[13] =m11 * m23 * m34
+		-m11 * m33 * m24
+		- m13 * m21 * m34
+		+ m13 * m31 * m24
+		+ m14 * m21 * m33
+		- m14 * m31 * m23;
+	inverse[2] = m21 * m32 * m44
+		- m21 * m42 * m34
+		- m22 * m31 * m44
+		+ m22 * m41 * m34
+		+ m24 * m31 * m42
+		- m24 * m41 * m32;
+	inverse[6] = -m11 * m32 * m44
+		+m11 * m42 * m34
+		+ m12 * m31 * m44
+		- m12 * m41 * m34
+		- m14 * m31 * m42
+		+ m14 * m41 * m32;
+	inverse[10] =m11 * m22 * m44
+		-m11 * m42 * m24
+		- m12 * m21 * m44
+		+ m12 * m41 * m24
+		+ m14 * m21 * m42
+		- m14 * m41 * m22;
+	inverse[14] = -m11 * m22 * m34
+		+m11 * m32 * m24
+		+ m12 * m21 * m34
+		- m12 * m31 * m24
+		- m14 * m21 * m32
+		+ m14 * m31 * m22;
+	inverse[3] = -m21 * m32 * m43
+		+ m21 * m42 * m33
+		+ m22 * m31 * m43
+		- m22 * m41 * m33
+		- m23 * m31 * m42
+		+ m23 * m41 * m32;
+	inverse[7] =m11 * m32 * m43
+		-m11 * m42 * m33
+		- m12 * m31 * m43
+		+ m12 * m41 * m33
+		+ m13 * m31 * m42
+		- m13 * m41 * m32;
+	inverse[11] = -m11 * m22 * m43
+		+m11 * m42 * m23
+		+ m12 * m21 * m43
+		- m12 * m41 * m23
+		- m13 * m21 * m42
+		+ m13 * m41 * m22;
+	inverse[15] =m11 * m22 * m33
+		-m11 * m32 * m23
+		- m12 * m21 * m33
+		+ m12 * m31 * m23
+		+ m13 * m21 * m32
+		- m13 * m31 * m22;
+	inverted_determinant = MFLOAT_C(1.0) / (m11 * inverse[0] + m21 * inverse[4] + m31 * inverse[8] + m41 * inverse[12]);
+	result[0] = inverse[0] * inverted_determinant;
+	result[1] = inverse[1] * inverted_determinant;
+	result[2] = inverse[2] * inverted_determinant;
+	result[3] = inverse[3] * inverted_determinant;
+	result[4] = inverse[4] * inverted_determinant;
+	result[5] = inverse[5] * inverted_determinant;
+	result[6] = inverse[6] * inverted_determinant;
+	result[7] = inverse[7] * inverted_determinant;
+	result[8] = inverse[8] * inverted_determinant;
+	result[9] = inverse[9] * inverted_determinant;
+	result[10] = inverse[10] * inverted_determinant;
+	result[11] = inverse[11] * inverted_determinant;
+	result[12] = inverse[12] * inverted_determinant;
+	result[13] = inverse[13] * inverted_determinant;
+	result[14] = inverse[14] * inverted_determinant;
+	result[15] = inverse[15] * inverted_determinant;
+	return result;
+}
+
+mfloat_t *mat4_lerp(mfloat_t *result, mfloat_t *mat40, mfloat_t *mat41, mfloat_t f)
+{
+	result[0] = mat40[0] + (mat41[0] - mat40[0]) * f;
+	result[1] = mat40[1] + (mat41[1] - mat40[1]) * f;
+	result[2] = mat40[2] + (mat41[2] - mat40[2]) * f;
+	result[3] = mat40[3] + (mat41[3] - mat40[3]) * f;
+	result[4] = mat40[4] + (mat41[4] - mat40[4]) * f;
+	result[5] = mat40[5] + (mat41[5] - mat40[5]) * f;
+	result[6] = mat40[6] + (mat41[6] - mat40[6]) * f;
+	result[7] = mat40[7] + (mat41[7] - mat40[7]) * f;
+	result[8] = mat40[8] + (mat41[8] - mat40[8]) * f;
+	result[9] = mat40[9] + (mat41[9] - mat40[9]) * f;
+	result[10] = mat40[10] + (mat41[10] - mat40[10]) * f;
+	result[11] = mat40[11] + (mat41[11] - mat40[11]) * f;
+	result[12] = mat40[12] + (mat41[12] - mat40[12]) * f;
+	result[13] = mat40[13] + (mat41[13] - mat40[13]) * f;
+	result[14] = mat40[14] + (mat41[14] - mat40[14]) * f;
+	result[15] = mat40[15] + (mat41[15] - mat40[15]) * f;
+	return result;
+}
+
+mfloat_t *mat4_look_at(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32)
+{
+	mfloat_t forward[VEC3_SIZE];
+	mfloat_t side[VEC3_SIZE];
+	mfloat_t up[VEC3_SIZE];
+	vec3_subtract(forward, vec31, vec30);
+	vec3_normalize(forward, forward);
+	vec3_cross(side, forward, vec32);
+	vec3_normalize(side, side);
+	vec3_cross(up, side, forward);
+	result[0] = side[0];
+	result[1] = side[1];
+	result[2] = side[2];
+	result[3] = vec3_dot(side, vec30);
+	result[4] = up[0];
+	result[5] = up[1];
+	result[6] = up[2];
+	result[7] = vec3_dot(up, vec30);
+	result[8] = forward[0];
+	result[9] = forward[1];
+	result[10] = forward[2];
+	result[11] = vec3_dot(forward, vec30);
+	return result;
+}
+
+mfloat_t *mat4_ortho(mfloat_t *result, mfloat_t l, mfloat_t r, mfloat_t b, mfloat_t t, mfloat_t n, mfloat_t f)
+{
+	result[0] = MFLOAT_C(2.0) / (r - l);
+	result[1] = MFLOAT_C(0.0);
+	result[2] = MFLOAT_C(0.0);
+	result[3] = MFLOAT_C(0.0);
+	result[4] = MFLOAT_C(0.0);
+	result[5] = MFLOAT_C(2.0) / (t - b);
+	result[6] = MFLOAT_C(0.0);
+	result[7] = MFLOAT_C(0.0);
+	result[8] = MFLOAT_C(0.0);
+	result[9] = MFLOAT_C(0.0);
+	result[10] = -MFLOAT_C(2.0) / (f - n);
+	result[11] = MFLOAT_C(0.0);
+	result[12] = -((r + l) / (r - l));
+	result[13] = -((t + b) / (t - b));
+	result[14] = -((f + n) / (f - n));
+	result[15] = MFLOAT_C(1.0);
+	return result;
+}
+
+mfloat_t *mat4_perspective(mfloat_t *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n, mfloat_t f)
+{
+	mfloat_t tan_half_fov_y = MFLOAT_C(1.0) / MTAN(fov_y * MFLOAT_C(0.5));
+	result[0] = MFLOAT_C(1.0) / aspect * tan_half_fov_y;
+	result[1] = MFLOAT_C(0.0);
+	result[2] = MFLOAT_C(0.0);
+	result[3] = MFLOAT_C(0.0);
+	result[4] = MFLOAT_C(0.0);
+	result[5] = MFLOAT_C(1.0) / tan_half_fov_y;
+	result[6] = MFLOAT_C(0.0);
+	result[7] = MFLOAT_C(0.0);
+	result[8] = MFLOAT_C(0.0);
+	result[9] = MFLOAT_C(0.0);
+	result[10] = f / (n - f);
+	result[11] = -MFLOAT_C(1.0);
+	result[12] = MFLOAT_C(0.0);
+	result[13] = MFLOAT_C(0.0);
+	result[14] = -(f * n) / (f - n);
+	result[15] = MFLOAT_C(0.0);
+	return result;
+}
+
+mfloat_t *mat4_perspective_fov(mfloat_t *result, mfloat_t fov, mfloat_t w, mfloat_t h, mfloat_t n, mfloat_t f)
+{
+	mfloat_t h2 = MCOS(fov * MFLOAT_C(0.5)) / MSIN(fov * MFLOAT_C(0.5));
+	mfloat_t w2 = h2 * h / w;
+	result[0] = w2;
+	result[1] = MFLOAT_C(0.0);
+	result[2] = MFLOAT_C(0.0);
+	result[3] = MFLOAT_C(0.0);
+	result[4] = MFLOAT_C(0.0);
+	result[5] = h2;
+	result[6] = MFLOAT_C(0.0);
+	result[7] = MFLOAT_C(0.0);
+	result[8] = MFLOAT_C(0.0);
+	result[9] = MFLOAT_C(0.0);
+	result[10] = f / (n - f);
+	result[11] = -MFLOAT_C(1.0);
+	result[12] = MFLOAT_C(0.0);
+	result[13] = MFLOAT_C(0.0);
+	result[14] = -(f * n) / (f - n);
+	result[15] = MFLOAT_C(0.0);
+	return result;
+}
+
+mfloat_t *mat4_perspective_infinite(mfloat_t *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n)
+{
+	mfloat_t range = MTAN(fov_y * MFLOAT_C(0.5)) * n;
+	mfloat_t left = -range * aspect;
+	mfloat_t right = range * aspect;
+	mfloat_t top = range;
+	mfloat_t bottom = -range;
+	result[0] = MFLOAT_C(2.0) * n / (right - left);
+	result[1] = MFLOAT_C(0.0);
+	result[2] = MFLOAT_C(0.0);
+	result[3] = MFLOAT_C(0.0);
+	result[4] = MFLOAT_C(0.0);
+	result[5] = MFLOAT_C(2.0) * n / (top - bottom);
+	result[6] = MFLOAT_C(0.0);
+	result[7] = MFLOAT_C(0.0);
+	result[8] = MFLOAT_C(0.0);
+	result[9] = MFLOAT_C(0.0);
+	result[10] = -MFLOAT_C(1.0);
+	result[11] = -MFLOAT_C(1.0);
+	result[12] = MFLOAT_C(0.0);
+	result[13] = MFLOAT_C(0.0);
+	result[14] = -MFLOAT_C(2.0) * n;
+	result[15] = MFLOAT_C(0.0);
+	return result;
+}
+#endif
+
+#if defined(MATHC_USE_STRUCT_FUNCTIONS)
+#if defined(MATHC_USE_INT)
+bool svec2i_is_zero(struct vec2i vec2i0)
+{
+	return vec2i_is_zero((mint_t *)&vec2i0);
+}
+
+bool svec2i_is_equal(struct vec2i vec2i0, struct vec2i vec2i1)
+{
+	return vec2i_is_equal((mint_t *)&vec2i0, (mint_t *)&vec2i1);
+}
+
+struct vec2i svec2i(mint_t x, mint_t y)
+{
+	struct vec2i result;
+	vec2i((mint_t *)&result, x, y);
+	return result;
+}
+
+struct vec2i svec2i_assign(struct vec2i vec2i0)
+{
+	struct vec2i result;
+	vec2i_assign((mint_t *)&result, (mint_t *)&vec2i0);
+	return result;
+}
+
+#if defined(MATHC_USE_FLOATING_POINT)
+struct vec2i svec2i_assign_vec2(struct vec2 vec20)
+{
+	struct vec2i result;
+	vec2i_assign_vec2((mint_t *)&result, (mfloat_t *)&vec20);
+	return result;
+}
+#endif
+
+struct vec2i svec2i_zero(void)
+{
+	struct vec2i result;
+	vec2i_zero((mint_t *)&result);
+	return result;
+}
+
+struct vec2i svec2i_one(void)
+{
+	struct vec2i result;
+	vec2i_one((mint_t *)&result);
+	return result;
+}
+
+struct vec2i svec2i_sign(struct vec2i vec2i0)
+{
+	struct vec2i result;
+	vec2i_sign((mint_t *)&result, (mint_t *)&vec2i0);
+	return result;
+}
+
+struct vec2i svec2i_add(struct vec2i vec2i0, struct vec2i vec2i1)
+{
+	struct vec2i result;
+	vec2i_add((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	return result;
+}
+
+struct vec2i svec2i_add_i(struct vec2i vec2i0, mint_t i)
+{
+	struct vec2i result;
+	vec2i_add_i((mint_t *)&result, (mint_t *)&vec2i0, i);
+	return result;
+}
+
+struct vec2i svec2i_subtract(struct vec2i vec2i0, struct vec2i vec2i1)
+{
+	struct vec2i result;
+	vec2i_subtract((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	return result;
+}
+
+struct vec2i svec2i_subtract_i(struct vec2i vec2i0, mint_t i)
+{
+	struct vec2i result;
+	vec2i_subtract_i((mint_t *)&result, (mint_t *)&vec2i0, i);
+	return result;
+}
+
+struct vec2i svec2i_multiply(struct vec2i vec2i0, struct vec2i vec2i1)
+{
+	struct vec2i result;
+	vec2i_multiply((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	return result;
+}
+
+struct vec2i svec2i_multiply_i(struct vec2i vec2i0, mint_t i)
+{
+	struct vec2i result;
+	vec2i_multiply_i((mint_t *)&result, (mint_t *)&vec2i0, i);
+	return result;
+}
+
+struct vec2i svec2i_divide(struct vec2i vec2i0, struct vec2i vec2i1)
+{
+	struct vec2i result;
+	vec2i_divide((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	return result;
+}
+
+struct vec2i svec2i_divide_i(struct vec2i vec2i0, mint_t i)
+{
+	struct vec2i result;
+	vec2i_divide_i((mint_t *)&result, (mint_t *)&vec2i0, i);
+	return result;
+}
+
+struct vec2i svec2i_snap(struct vec2i vec2i0, struct vec2i vec2i1)
+{
+	struct vec2i result;
+	vec2i_snap((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	return result;
+}
+
+struct vec2i svec2i_snap_i(struct vec2i vec2i0, mint_t i)
+{
+	struct vec2i result;
+	vec2i_snap_i((mint_t *)&result, (mint_t *)&vec2i0, i);
+	return result;
+}
+
+struct vec2i svec2i_negative(struct vec2i vec2i0)
+{
+	struct vec2i result;
+	vec2i_negative((mint_t *)&result, (mint_t *)&vec2i0);
+	return result;
+}
+
+struct vec2i svec2i_abs(struct vec2i vec2i0)
+{
+	struct vec2i result;
+	vec2i_abs((mint_t *)&result, (mint_t *)&vec2i0);
+	return result;
+}
+
+struct vec2i svec2i_max(struct vec2i vec2i0, struct vec2i vec2i1)
+{
+	struct vec2i result;
+	vec2i_max((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	return result;
+}
+
+struct vec2i svec2i_min(struct vec2i vec2i0, struct vec2i vec2i1)
+{
+	struct vec2i result;
+	vec2i_min((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	return result;
+}
+
+struct vec2i svec2i_clamp(struct vec2i vec2i0, struct vec2i vec2i1, struct vec2i vec2i2)
+{
+	struct vec2i result;
+	vec2i_clamp((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1, (mint_t *)&vec2i2);
+	return result;
+}
+
+struct vec2i svec2i_tangent(struct vec2i vec2i0)
+{
+	struct vec2i result;
+	vec2i_tangent((mint_t *)&result, (mint_t *)&vec2i0);
+	return result;
+}
+
+bool svec3i_is_zero(struct vec3i vec3i0)
+{
+	return vec3i_is_zero((mint_t *)&vec3i0);
+}
+
+bool svec3i_is_equal(struct vec3i vec3i0, struct vec3i vec3i1)
+{
+	return vec3i_is_equal((mint_t *)&vec3i0, (mint_t *)&vec3i1);
+}
+
+struct vec3i svec3i(mint_t x, mint_t y, mint_t z)
+{
+	struct vec3i result;
+	vec3i((mint_t *)&result, x, y, z);
+	return result;
+}
+
+struct vec3i svec3i_assign(struct vec3i vec3i0)
+{
+	struct vec3i result;
+	vec3i_assign((mint_t *)&result, (mint_t *)&vec3i0);
+	return result;
+}
+
+#if defined(MATHC_USE_FLOATING_POINT)
+struct vec3i svec3i_assign_vec3(struct vec3 vec30)
+{
+	struct vec3i result;
+	vec3i_assign_vec3((mint_t *)&result, (mfloat_t *)&vec30);
+	return result;
+}
+#endif
+
+struct vec3i svec3i_zero(void)
+{
+	struct vec3i result;
+	vec3i_zero((mint_t *)&result);
+	return result;
+}
+
+struct vec3i svec3i_one(void)
+{
+	struct vec3i result;
+	vec3i_one((mint_t *)&result);
+	return result;
+}
+
+struct vec3i svec3i_sign(struct vec3i vec3i0)
+{
+	struct vec3i result;
+	vec3i_sign((mint_t *)&result, (mint_t *)&vec3i0);
+	return result;
+}
+
+struct vec3i svec3i_add(struct vec3i vec3i0, struct vec3i vec3i1)
+{
+	struct vec3i result;
+	vec3i_add((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	return result;
+}
+
+struct vec3i svec3i_add_i(struct vec3i vec3i0, mint_t i)
+{
+	struct vec3i result;
+	vec3i_add_i((mint_t *)&result, (mint_t *)&vec3i0, i);
+	return result;
+}
+
+struct vec3i svec3i_subtract(struct vec3i vec3i0, struct vec3i vec3i1)
+{
+	struct vec3i result;
+	vec3i_subtract((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	return result;
+}
+
+struct vec3i svec3i_subtract_i(struct vec3i vec3i0, mint_t i)
+{
+	struct vec3i result;
+	vec3i_subtract_i((mint_t *)&result, (mint_t *)&vec3i0, i);
+	return result;
+}
+
+struct vec3i svec3i_multiply(struct vec3i vec3i0, struct vec3i vec3i1)
+{
+	struct vec3i result;
+	vec3i_multiply((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	return result;
+}
+
+struct vec3i svec3i_multiply_i(struct vec3i vec3i0, mint_t i)
+{
+	struct vec3i result;
+	vec3i_multiply_i((mint_t *)&result, (mint_t *)&vec3i0, i);
+	return result;
+}
+
+struct vec3i svec3i_divide(struct vec3i vec3i0, struct vec3i vec3i1)
+{
+	struct vec3i result;
+	vec3i_divide((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	return result;
+}
+
+struct vec3i svec3i_divide_i(struct vec3i vec3i0, mint_t i)
+{
+	struct vec3i result;
+	vec3i_divide_i((mint_t *)&result, (mint_t *)&vec3i0, i);
+	return result;
+}
+
+struct vec3i svec3i_snap(struct vec3i vec3i0, struct vec3i vec3i1)
+{
+	struct vec3i result;
+	vec3i_snap((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	return result;
+}
+
+struct vec3i svec3i_snap_i(struct vec3i vec3i0, mint_t i)
+{
+	struct vec3i result;
+	vec3i_snap_i((mint_t *)&result, (mint_t *)&vec3i0, i);
+	return result;
+}
+
+struct vec3i svec3i_cross(struct vec3i vec3i0, struct vec3i vec3i1)
+{
+	struct vec3i result;
+	vec3i_cross((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	return result;
+}
+
+struct vec3i svec3i_negative(struct vec3i vec3i0)
+{
+	struct vec3i result;
+	vec3i_negative((mint_t *)&result, (mint_t *)&vec3i0);
+	return result;
+}
+
+struct vec3i svec3i_abs(struct vec3i vec3i0)
+{
+	struct vec3i result;
+	vec3i_abs((mint_t *)&result, (mint_t *)&vec3i0);
+	return result;
+}
+
+struct vec3i svec3i_max(struct vec3i vec3i0, struct vec3i vec3i1)
+{
+	struct vec3i result;
+	vec3i_max((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	return result;
+}
+
+struct vec3i svec3i_min(struct vec3i vec3i0, struct vec3i vec3i1)
+{
+	struct vec3i result;
+	vec3i_min((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	return result;
+}
+
+struct vec3i svec3i_clamp(struct vec3i vec3i0, struct vec3i vec3i1, struct vec3i vec3i2)
+{
+	struct vec3i result;
+	vec3i_clamp((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1, (mint_t *)&vec3i2);
+	return result;
+}
+
+bool svec4i_is_zero(struct vec4i vec4i0)
+{
+	return vec4i_is_zero((mint_t *)&vec4i0);
+}
+
+bool svec4i_is_equal(struct vec4i vec4i0, struct vec4i vec4i1)
+{
+	return vec4i_is_equal((mint_t *)&vec4i0, (mint_t *)&vec4i1);
+}
+
+struct vec4i svec4i(mint_t x, mint_t y, mint_t z, mint_t w)
+{
+	struct vec4i result;
+	vec4i((mint_t *)&result, x, y, z, w);
+	return result;
+}
+
+struct vec4i svec4i_assign(struct vec4i vec4i0)
+{
+	struct vec4i result;
+	vec4i_assign((mint_t *)&result, (mint_t *)&vec4i0);
+	return result;
+}
+
+#if defined(MATHC_USE_FLOATING_POINT)
+struct vec4i svec4i_assign_vec4(struct vec4 vec40)
+{
+	struct vec4i result;
+	vec4i_assign_vec4((mint_t *)&result, (mfloat_t *)&vec40);
+	return result;
+}
+#endif
+
+struct vec4i svec4i_zero(void)
+{
+	struct vec4i result;
+	vec4i_zero((mint_t *)&result);
+	return result;
+}
+
+struct vec4i svec4i_one(void)
+{
+	struct vec4i result;
+	vec4i_one((mint_t *)&result);
+	return result;
+}
+
+struct vec4i svec4i_sign(struct vec4i vec4i0)
+{
+	struct vec4i result;
+	vec4i_sign((mint_t *)&result, (mint_t *)&vec4i0);
+	return result;
+}
+
+struct vec4i svec4i_add(struct vec4i vec4i0, struct vec4i vec4i1)
+{
+	struct vec4i result;
+	vec4i_add((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	return result;
+}
+
+struct vec4i svec4i_add_i(struct vec4i vec4i0, mint_t i)
+{
+	struct vec4i result;
+	vec4i_add_i((mint_t *)&result, (mint_t *)&vec4i0, i);
+	return result;
+}
+
+struct vec4i svec4i_subtract(struct vec4i vec4i0, struct vec4i vec4i1)
+{
+	struct vec4i result;
+	vec4i_subtract((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	return result;
+}
+
+struct vec4i svec4i_subtract_i(struct vec4i vec4i0, mint_t i)
+{
+	struct vec4i result;
+	vec4i_subtract_i((mint_t *)&result, (mint_t *)&vec4i0, i);
+	return result;
+}
+
+struct vec4i svec4i_multiply(struct vec4i vec4i0, struct vec4i vec4i1)
+{
+	struct vec4i result;
+	vec4i_multiply((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	return result;
+}
+
+struct vec4i svec4i_multiply_i(struct vec4i vec4i0, mint_t i)
+{
+	struct vec4i result;
+	vec4i_multiply_i((mint_t *)&result, (mint_t *)&vec4i0, i);
+	return result;
+}
+
+struct vec4i svec4i_divide(struct vec4i vec4i0, struct vec4i vec4i1)
+{
+	struct vec4i result;
+	vec4i_divide((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	return result;
+}
+
+struct vec4i svec4i_divide_i(struct vec4i vec4i0, mint_t i)
+{
+	struct vec4i result;
+	vec4i_divide_i((mint_t *)&result, (mint_t *)&vec4i0, i);
+	return result;
+}
+
+struct vec4i svec4i_snap(struct vec4i vec4i0, struct vec4i vec4i1)
+{
+	struct vec4i result;
+	vec4i_snap((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	return result;
+}
+
+struct vec4i svec4i_snap_i(struct vec4i vec4i0, mint_t i)
+{
+	struct vec4i result;
+	vec4i_snap_i((mint_t *)&result, (mint_t *)&vec4i0, i);
+	return result;
+}
+
+struct vec4i svec4i_negative(struct vec4i vec4i0)
+{
+	struct vec4i result;
+	vec4i_negative((mint_t *)&result, (mint_t *)&vec4i0);
+	return result;
+}
+
+struct vec4i svec4i_abs(struct vec4i vec4i0)
+{
+	struct vec4i result;
+	vec4i_abs((mint_t *)&result, (mint_t *)&vec4i0);
+	return result;
+}
+
+struct vec4i svec4i_max(struct vec4i vec4i0, struct vec4i vec4i1)
+{
+	struct vec4i result;
+	vec4i_max((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	return result;
+}
+
+struct vec4i svec4i_min(struct vec4i vec4i0, struct vec4i vec4i1)
+{
+	struct vec4i result;
+	vec4i_min((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	return result;
+}
+
+struct vec4i svec4i_clamp(struct vec4i vec4i0, struct vec4i vec4i1, struct vec4i vec4i2)
+{
+	struct vec4i result;
+	vec4i_clamp((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1, (mint_t *)&vec4i2);
+	return result;
+}
+#endif
+
+#if defined(MATHC_USE_FLOATING_POINT)
+bool svec2_is_zero(struct vec2 vec20)
+{
+	return vec2_is_zero((mfloat_t *)&vec20);
+}
+
+bool svec2_is_equal(struct vec2 vec20, struct vec2 vec21)
+{
+	return vec2_is_equal((mfloat_t *)&vec20, (mfloat_t *)&vec21);
+}
+
+struct vec2 svec2(mfloat_t x, mfloat_t y)
+{
+	struct vec2 result;
+	vec2((mfloat_t *)&result, x, y);
+	return result;
+}
+
+struct vec2 svec2_assign(struct vec2 vec20)
+{
+	struct vec2 result;
+	vec2_assign((mfloat_t *)&result, (mfloat_t *)&vec20);
+	return result;
+}
+
+#if defined(MATHC_USE_INT)
+struct vec2 svec2_assign_vec2i(struct vec2i vec2i0)
+{
+	struct vec2 result;
+	vec2_assign_vec2i((mfloat_t *)&result, (mint_t *)&vec2i0);
+	return result;
+}
+#endif
+
+struct vec2 svec2_zero(void)
+{
+	struct vec2 result;
+	vec2_zero((mfloat_t *)&result);
+	return result;
+}
+
+struct vec2 svec2_one(void)
+{
+	struct vec2 result;
+	vec2_one((mfloat_t *)&result);
+	return result;
+}
+
+struct vec2 svec2_sign(struct vec2 vec20)
+{
+	struct vec2 result;
+	vec2_sign((mfloat_t *)&result, (mfloat_t *)&vec20);
+	return result;
+}
+
+struct vec2 svec2_add(struct vec2 vec20, struct vec2 vec21)
+{
+	struct vec2 result;
+	vec2_add((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	return result;
+}
+
+struct vec2 svec2_add_f(struct vec2 vec20, mfloat_t f)
+{
+	struct vec2 result;
+	vec2_add_f((mfloat_t *)&result, (mfloat_t *)&vec20, f);
+	return result;
+}
+
+struct vec2 svec2_subtract(struct vec2 vec20, struct vec2 vec21)
+{
+	struct vec2 result;
+	vec2_subtract((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	return result;
+}
+
+struct vec2 svec2_subtract_f(struct vec2 vec20, mfloat_t f)
+{
+	struct vec2 result;
+	vec2_subtract_f((mfloat_t *)&result, (mfloat_t *)&vec20, f);
+	return result;
+}
+
+struct vec2 svec2_multiply(struct vec2 vec20, struct vec2 vec21)
+{
+	struct vec2 result;
+	vec2_multiply((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	return result;
+}
+
+struct vec2 svec2_multiply_f(struct vec2 vec20, mfloat_t f)
+{
+	struct vec2 result;
+	vec2_multiply_f((mfloat_t *)&result, (mfloat_t *)&vec20, f);
+	return result;
+}
+
+struct vec2 svec2_multiply_mat2(struct vec2 vec20, struct mat2 mat20)
+{
+	struct vec2 result;
+	vec2_multiply_mat2((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&mat20);
+	return result;
+}
+
+struct vec2 svec2_divide(struct vec2 vec20, struct vec2 vec21)
+{
+	struct vec2 result;
+	vec2_divide((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	return result;
+}
+
+struct vec2 svec2_divide_f(struct vec2 vec20, mfloat_t f)
+{
+	struct vec2 result;
+	vec2_divide_f((mfloat_t *)&result, (mfloat_t *)&vec20, f);
+	return result;
+}
+
+struct vec2 svec2_snap(struct vec2 vec20, struct vec2 vec21)
+{
+	struct vec2 result;
+	vec2_snap((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	return result;
+}
+
+struct vec2 svec2_snap_f(struct vec2 vec20, mfloat_t f)
+{
+	struct vec2 result;
+	vec2_snap_f((mfloat_t *)&result, (mfloat_t *)&vec20, f);
+	return result;
+}
+
+struct vec2 svec2_negative(struct vec2 vec20)
+{
+	struct vec2 result;
+	vec2_negative((mfloat_t *)&result, (mfloat_t *)&vec20);
+	return result;
+}
+
+struct vec2 svec2_abs(struct vec2 vec20)
+{
+	struct vec2 result;
+	vec2_abs((mfloat_t *)&result, (mfloat_t *)&vec20);
+	return result;
+}
+
+struct vec2 svec2_floor(struct vec2 vec20)
+{
+	struct vec2 result;
+	vec2_floor((mfloat_t *)&result, (mfloat_t *)&vec20);
+	return result;
+}
+
+struct vec2 svec2_ceil(struct vec2 vec20)
+{
+	struct vec2 result;
+	vec2_ceil((mfloat_t *)&result, (mfloat_t *)&vec20);
+	return result;
+}
+
+struct vec2 svec2_round(struct vec2 vec20)
+{
+	struct vec2 result;
+	vec2_round((mfloat_t *)&result, (mfloat_t *)&vec20);
+	return result;
+}
+
+struct vec2 svec2_max(struct vec2 vec20, struct vec2 vec21)
+{
+	struct vec2 result;
+	vec2_max((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	return result;
+}
+
+struct vec2 svec2_min(struct vec2 vec20, struct vec2 vec21)
+{
+	struct vec2 result;
+	vec2_min((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	return result;
+}
+
+struct vec2 svec2_clamp(struct vec2 vec20, struct vec2 vec21, struct vec2 vec22)
+{
+	struct vec2 result;
+	vec2_clamp((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21, (mfloat_t *)&vec22);
+	return result;
+}
+
+struct vec2 svec2_normalize(struct vec2 vec20)
+{
+	struct vec2 result;
+	vec2_normalize((mfloat_t *)&result, (mfloat_t *)&vec20);
+	return result;
+}
+
+mfloat_t svec2_dot(struct vec2 vec20, struct vec2 vec21)
+{
+	return vec2_dot((mfloat_t *)&vec20, (mfloat_t *)&vec21);
+}
+
+struct vec2 svec2_project(struct vec2 vec20, struct vec2 vec21)
+{
+	struct vec2 result;
+	vec2_project((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	return result;
+}
+
+struct vec2 svec2_slide(struct vec2 vec20, struct vec2 vec21)
+{
+	struct vec2 result;
+	vec2_slide((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	return result;
+}
+
+struct vec2 svec2_reflect(struct vec2 vec20, struct vec2 vec21)
+{
+	struct vec2 result;
+	vec2_reflect((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	return result;
+}
+
+struct vec2 svec2_tangent(struct vec2 vec20)
+{
+	struct vec2 result;
+	vec2_tangent((mfloat_t *)&result, (mfloat_t *)&vec20);
+	return result;
+}
+
+struct vec2 svec2_rotate(struct vec2 vec20, mfloat_t f)
+{
+	struct vec2 result;
+	vec2_rotate((mfloat_t *)&result, (mfloat_t *)&vec20, f);
+	return result;
+}
+
+struct vec2 svec2_lerp(struct vec2 vec20, struct vec2 vec21, mfloat_t f)
+{
+	struct vec2 result;
+	vec2_lerp((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21, f);
+	return result;
+}
+
+struct vec2 svec2_bezier3(struct vec2 vec20, struct vec2 vec21, struct vec2 vec22, mfloat_t f)
+{
+	struct vec2 result;
+	vec2_bezier3((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21, (mfloat_t *)&vec22, f);
+	return result;
+}
+
+struct vec2 svec2_bezier4(struct vec2 vec20, struct vec2 vec21, struct vec2 vec22, struct vec2 vec23, mfloat_t f)
+{
+	struct vec2 result;
+	vec2_bezier4((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21, (mfloat_t *)&vec22, (mfloat_t *)&vec23, f);
+	return result;
+}
+
+mfloat_t svec2_angle(struct vec2 vec20)
+{
+	return vec2_angle((mfloat_t *)&vec20);
+}
+
+mfloat_t svec2_length(struct vec2 vec20)
+{
+	return vec2_length((mfloat_t *)&vec20);
+}
+
+mfloat_t svec2_length_squared(struct vec2 vec20)
+{
+	return vec2_length_squared((mfloat_t *)&vec20);
+}
+
+mfloat_t svec2_distance(struct vec2 vec20, struct vec2 vec21)
+{
+	return vec2_distance((mfloat_t *)&vec20, (mfloat_t *)&vec21);
+}
+
+mfloat_t svec2_distance_squared(struct vec2 vec20, struct vec2 vec21)
+{
+	return vec2_distance_squared((mfloat_t *)&vec20, (mfloat_t *)&vec21);
+}
+
+bool svec3_is_zero(struct vec3 vec30)
+{
+	return vec3_is_zero((mfloat_t *)&vec30);
+}
+
+bool svec3_is_equal(struct vec3 vec30, struct vec3 vec31)
+{
+	return vec3_is_equal((mfloat_t *)&vec30, (mfloat_t *)&vec31);
+}
+
+struct vec3 svec3(mfloat_t x, mfloat_t y, mfloat_t z)
+{
+	struct vec3 result;
+	vec3((mfloat_t *)&result, x, y, z);
+	return result;
+}
+
+struct vec3 svec3_assign(struct vec3 vec30)
+{
+	struct vec3 result;
+	vec3_assign((mfloat_t *)&result, (mfloat_t *)&vec30);
+	return result;
+}
+
+#if defined(MATHC_USE_INT)
+struct vec3 svec3_assign_vec3i(struct vec3i vec3i0)
+{
+	struct vec3 result;
+	vec3_assign_vec3i((mfloat_t *)&result, (mint_t *)&vec3i0);
+	return result;
+}
+#endif
+
+struct vec3 svec3_zero(void)
+{
+	struct vec3 result;
+	vec3_zero((mfloat_t *)&result);
+	return result;
+}
+
+struct vec3 svec3_one(void)
+{
+	struct vec3 result;
+	vec3_one((mfloat_t *)&result);
+	return result;
+}
+
+struct vec3 svec3_sign(struct vec3 vec30)
+{
+	struct vec3 result;
+	vec3_sign((mfloat_t *)&result, (mfloat_t *)&vec30);
+	return result;
+}
+
+struct vec3 svec3_add(struct vec3 vec30, struct vec3 vec31)
+{
+	struct vec3 result;
+	vec3_add((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return result;
+}
+
+struct vec3 svec3_add_f(struct vec3 vec30, mfloat_t f)
+{
+	struct vec3 result;
+	vec3_add_f((mfloat_t *)&result, (mfloat_t *)&vec30, f);
+	return result;
+}
+
+struct vec3 svec3_subtract(struct vec3 vec30, struct vec3 vec31)
+{
+	struct vec3 result;
+	vec3_subtract((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return result;
+}
+
+struct vec3 svec3_subtract_f(struct vec3 vec30, mfloat_t f)
+{
+	struct vec3 result;
+	vec3_subtract_f((mfloat_t *)&result, (mfloat_t *)&vec30, f);
+	return result;
+}
+
+struct vec3 svec3_multiply(struct vec3 vec30, struct vec3 vec31)
+{
+	struct vec3 result;
+	vec3_multiply((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return result;
+}
+
+struct vec3 svec3_multiply_f(struct vec3 vec30, mfloat_t f)
+{
+	struct vec3 result;
+	vec3_multiply_f((mfloat_t *)&result, (mfloat_t *)&vec30, f);
+	return result;
+}
+
+struct vec3 svec3_multiply_mat3(struct vec3 vec30, struct mat3 mat30)
+{
+	struct vec3 result;
+	vec3_multiply_mat3((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&mat30);
+	return result;
+}
+
+struct vec3 svec3_divide(struct vec3 vec30, struct vec3 vec31)
+{
+	struct vec3 result;
+	vec3_divide((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return result;
+}
+
+struct vec3 svec3_divide_f(struct vec3 vec30, mfloat_t f)
+{
+	struct vec3 result;
+	vec3_divide_f((mfloat_t *)&result, (mfloat_t *)&vec30, f);
+	return result;
+}
+
+struct vec3 svec3_snap(struct vec3 vec30, struct vec3 vec31)
+{
+	struct vec3 result;
+	vec3_snap((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return result;
+}
+
+struct vec3 svec3_snap_f(struct vec3 vec30, mfloat_t f)
+{
+	struct vec3 result;
+	vec3_snap_f((mfloat_t *)&result, (mfloat_t *)&vec30, f);
+	return result;
+}
+
+struct vec3 svec3_negative(struct vec3 vec30)
+{
+	struct vec3 result;
+	vec3_negative((mfloat_t *)&result, (mfloat_t *)&vec30);
+	return result;
+}
+
+struct vec3 svec3_abs(struct vec3 vec30)
+{
+	struct vec3 result;
+	vec3_abs((mfloat_t *)&result, (mfloat_t *)&vec30);
+	return result;
+}
+
+struct vec3 svec3_floor(struct vec3 vec30)
+{
+	struct vec3 result;
+	vec3_floor((mfloat_t *)&result, (mfloat_t *)&vec30);
+	return result;
+}
+
+struct vec3 svec3_ceil(struct vec3 vec30)
+{
+	struct vec3 result;
+	vec3_ceil((mfloat_t *)&result, (mfloat_t *)&vec30);
+	return result;
+}
+
+struct vec3 svec3_round(struct vec3 vec30)
+{
+	struct vec3 result;
+	vec3_round((mfloat_t *)&result, (mfloat_t *)&vec30);
+	return result;
+}
+
+struct vec3 svec3_max(struct vec3 vec30, struct vec3 vec31)
+{
+	struct vec3 result;
+	vec3_max((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return result;
+}
+
+struct vec3 svec3_min(struct vec3 vec30, struct vec3 vec31)
+{
+	struct vec3 result;
+	vec3_min((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return result;
+}
+
+struct vec3 svec3_clamp(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32)
+{
+	struct vec3 result;
+	vec3_clamp((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31, (mfloat_t *)&vec32);
+	return result;
+}
+
+struct vec3 svec3_cross(struct vec3 vec30, struct vec3 vec31)
+{
+	struct vec3 result;
+	vec3_cross((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return result;
+}
+
+struct vec3 svec3_normalize(struct vec3 vec30)
+{
+	struct vec3 result;
+	vec3_normalize((mfloat_t *)&result, (mfloat_t *)&vec30);
+	return result;
+}
+
+mfloat_t svec3_dot(struct vec3 vec30, struct vec3 vec31)
+{
+	return vec3_dot((mfloat_t *)&vec30, (mfloat_t *)&vec31);
+}
+
+struct vec3 svec3_project(struct vec3 vec30, struct vec3 vec31)
+{
+	struct vec3 result;
+	vec3_project((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return result;
+}
+
+struct vec3 svec3_slide(struct vec3 vec30, struct vec3 vec31)
+{
+	struct vec3 result;
+	vec3_slide((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return result;
+}
+
+struct vec3 svec3_reflect(struct vec3 vec30, struct vec3 vec31)
+{
+	struct vec3 result;
+	vec3_reflect((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return result;
+}
+
+struct vec3 svec3_lerp(struct vec3 vec30, struct vec3 vec31, mfloat_t f)
+{
+	struct vec3 result;
+	vec3_lerp((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31, f);
+	return result;
+}
+
+struct vec3 svec3_bezier3(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32, mfloat_t f)
+{
+	struct vec3 result;
+	vec3_bezier3((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31, (mfloat_t *)&vec32, f);
+	return result;
+}
+
+struct vec3 svec3_bezier4(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32, struct vec3 vec33, mfloat_t f)
+{
+	struct vec3 result;
+	vec3_bezier4((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31, (mfloat_t *)&vec32, (mfloat_t *)&vec33, f);
+	return result;
+}
+
+mfloat_t svec3_length(struct vec3 vec30)
+{
+	return vec3_length((mfloat_t *)&vec30);
+}
+
+mfloat_t svec3_length_squared(struct vec3 vec30)
+{
+	return vec3_length_squared((mfloat_t *)&vec30);
+}
+
+mfloat_t svec3_distance(struct vec3 vec30, struct vec3 vec31)
+{
+	return vec3_distance((mfloat_t *)&vec30, (mfloat_t *)&vec31);
+}
+
+mfloat_t svec3_distance_squared(struct vec3 vec30, struct vec3 vec31)
+{
+	return vec3_distance_squared((mfloat_t *)&vec30, (mfloat_t *)&vec31);
+}
+
+bool svec4_is_zero(struct vec4 vec40)
+{
+	return vec4_is_zero((mfloat_t *)&vec40);
+}
+
+bool svec4_is_equal(struct vec4 vec40, struct vec4 vec41)
+{
+	return vec4_is_equal((mfloat_t *)&vec40, (mfloat_t *)&vec41);
+}
+
+struct vec4 svec4(mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
+{
+	struct vec4 result;
+	vec4((mfloat_t *)&result, x, y, z, w);
+	return result;
+}
+
+struct vec4 svec4_assign(struct vec4 vec40)
+{
+	struct vec4 result;
+	vec4_assign((mfloat_t *)&result, (mfloat_t *)&vec40);
+	return result;
+}
+
+#if defined(MATHC_USE_INT)
+struct vec4 svec4_assign_vec4i(struct vec4i vec4i0)
+{
+	struct vec4 result;
+	vec4_assign_vec4i((mfloat_t *)&result, (mint_t *)&vec4i0);
+	return result;
+}
+#endif
+
+struct vec4 svec4_zero(void)
+{
+	struct vec4 result;
+	vec4_zero((mfloat_t *)&result);
+	return result;
+}
+
+struct vec4 svec4_one(void)
+{
+	struct vec4 result;
+	vec4_one((mfloat_t *)&result);
+	return result;
+}
+
+struct vec4 svec4_sign(struct vec4 vec40)
+{
+	struct vec4 result;
+	vec4_sign((mfloat_t *)&result, (mfloat_t *)&vec40);
+	return result;
+}
+
+struct vec4 svec4_add(struct vec4 vec40, struct vec4 vec41)
+{
+	struct vec4 result;
+	vec4_add((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	return result;
+}
+
+struct vec4 svec4_add_f(struct vec4 vec40, mfloat_t f)
+{
+	struct vec4 result;
+	vec4_add_f((mfloat_t *)&result, (mfloat_t *)&vec40, f);
+	return result;
+}
+
+struct vec4 svec4_subtract(struct vec4 vec40, struct vec4 vec41)
+{
+	struct vec4 result;
+	vec4_subtract((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	return result;
+}
+
+struct vec4 svec4_subtract_f(struct vec4 vec40, mfloat_t f)
+{
+	struct vec4 result;
+	vec4_subtract_f((mfloat_t *)&result, (mfloat_t *)&vec40, f);
+	return result;
+}
+
+struct vec4 svec4_multiply(struct vec4 vec40, struct vec4 vec41)
+{
+	struct vec4 result;
+	vec4_multiply((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	return result;
+}
+
+struct vec4 svec4_multiply_f(struct vec4 vec40, mfloat_t f)
+{
+	struct vec4 result;
+	vec4_multiply_f((mfloat_t *)&result, (mfloat_t *)&vec40, f);
+	return result;
+}
+
+struct vec4 svec4_multiply_mat4(struct vec4 vec40, struct mat4 mat40)
+{
+	struct vec4 result;
+	vec4_multiply_mat4((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&mat40);
+	return result;
+}
+
+struct vec4 svec4_divide(struct vec4 vec40, struct vec4 vec41)
+{
+	struct vec4 result;
+	vec4_divide((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	return result;
+}
+
+struct vec4 svec4_divide_f(struct vec4 vec40, mfloat_t f)
+{
+	struct vec4 result;
+	vec4_divide_f((mfloat_t *)&result, (mfloat_t *)&vec40, f);
+	return result;
+}
+
+struct vec4 svec4_snap(struct vec4 vec40, struct vec4 vec41)
+{
+	struct vec4 result;
+	vec4_snap((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	return result;
+}
+
+struct vec4 svec4_snap_f(struct vec4 vec40, mfloat_t f)
+{
+	struct vec4 result;
+	vec4_snap_f((mfloat_t *)&result, (mfloat_t *)&vec40, f);
+	return result;
+}
+
+struct vec4 svec4_negative(struct vec4 vec40)
+{
+	struct vec4 result;
+	vec4_negative((mfloat_t *)&result, (mfloat_t *)&vec40);
+	return result;
+}
+
+struct vec4 svec4_abs(struct vec4 vec40)
+{
+	struct vec4 result;
+	vec4_abs((mfloat_t *)&result, (mfloat_t *)&vec40);
+	return result;
+}
+
+struct vec4 svec4_floor(struct vec4 vec40)
+{
+	struct vec4 result;
+	vec4_floor((mfloat_t *)&result, (mfloat_t *)&vec40);
+	return result;
+}
+
+struct vec4 svec4_ceil(struct vec4 vec40)
+{
+	struct vec4 result;
+	vec4_ceil((mfloat_t *)&result, (mfloat_t *)&vec40);
+	return result;
+}
+
+struct vec4 svec4_round(struct vec4 vec40)
+{
+	struct vec4 result;
+	vec4_round((mfloat_t *)&result, (mfloat_t *)&vec40);
+	return result;
+}
+
+struct vec4 svec4_max(struct vec4 vec40, struct vec4 vec41)
+{
+	struct vec4 result;
+	vec4_max((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	return result;
+}
+
+struct vec4 svec4_min(struct vec4 vec40, struct vec4 vec41)
+{
+	struct vec4 result;
+	vec4_min((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	return result;
+}
+
+struct vec4 svec4_clamp(struct vec4 vec40, struct vec4 vec41, struct vec4 vec42)
+{
+	struct vec4 result;
+	vec4_clamp((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41, (mfloat_t *)&vec42);
+	return result;
+}
+
+struct vec4 svec4_normalize(struct vec4 vec40)
+{
+	struct vec4 result;
+	vec4_normalize((mfloat_t *)&result, (mfloat_t *)&vec40);
+	return result;
+}
+
+struct vec4 svec4_lerp(struct vec4 vec40, struct vec4 vec41, mfloat_t f)
+{
+	struct vec4 result;
+	vec4_lerp((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41, f);
+	return result;
+}
+
+bool squat_is_zero(struct quat quat0)
+{
+	return quat_is_zero((mfloat_t *)&quat0);
+}
+
+bool squat_is_equal(struct quat quat0, struct quat quat1)
+{
+	return quat_is_equal((mfloat_t *)&quat0, (mfloat_t *)&quat1);
+}
+
+struct quat squat(mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
+{
+	struct quat result;
+	quat((mfloat_t *)&result, x, y, z, w);
+	return result;
+}
+
+struct quat squat_assign(struct quat quat0)
+{
+	struct quat result;
+	quat_assign((mfloat_t *)&result, (mfloat_t *)&quat0);
+	return result;
+}
+
+struct quat squat_zero(void)
+{
+	struct quat result;
+	quat_zero((mfloat_t *)&result);
+	return result;
+}
+
+struct quat squat_null(void)
+{
+	struct quat result;
+	quat_null((mfloat_t *)&result);
+	return result;
+}
+
+struct quat squat_multiply(struct quat quat0, struct quat quat1)
+{
+	struct quat result;
+	quat_multiply((mfloat_t *)&result, (mfloat_t *)&quat0, (mfloat_t *)&quat1);
+	return result;
+}
+
+struct quat squat_multiply_f(struct quat quat0, mfloat_t f)
+{
+	struct quat result;
+	quat_multiply_f((mfloat_t *)&result, (mfloat_t *)&quat0, f);
+	return result;
+}
+
+struct quat squat_divide(struct quat quat0, struct quat quat1)
+{
+	struct quat result;
+	quat_divide((mfloat_t *)&result, (mfloat_t *)&quat0, (mfloat_t *)&quat1);
+	return result;
+}
+
+struct quat squat_divide_f(struct quat quat0, mfloat_t f)
+{
+	struct quat result;
+	quat_divide_f((mfloat_t *)&result, (mfloat_t *)&quat0, f);
+	return result;
+}
+
+struct quat squat_negative(struct quat quat0)
+{
+	struct quat result;
+	quat_negative((mfloat_t *)&result, (mfloat_t *)&quat0);
+	return result;
+}
+
+struct quat squat_conjugate(struct quat quat0)
+{
+	struct quat result;
+	quat_conjugate((mfloat_t *)&result, (mfloat_t *)&quat0);
+	return result;
+}
+
+struct quat squat_inverse(struct quat quat0)
+{
+	struct quat result;
+	quat_inverse((mfloat_t *)&result, (mfloat_t *)&quat0);
+	return result;
+}
+
+struct quat squat_normalize(struct quat quat0)
+{
+	struct quat result;
+	quat_normalize((mfloat_t *)&result, (mfloat_t *)&quat0);
+	return result;
+}
+
+mfloat_t squat_dot(struct quat quat0, struct quat quat1)
+{
+	return quat_dot((mfloat_t *)&quat0, (mfloat_t *)&quat1);
+}
+
+struct quat squat_power(struct quat quat0, mfloat_t exponent)
+{
+	struct quat result;
+	quat_power((mfloat_t *)&result, (mfloat_t *)&quat0, exponent);
+	return result;
+}
+
+struct quat squat_from_axis_angle(struct vec3 vec30, mfloat_t angle)
+{
+	struct quat result;
+	quat_from_axis_angle((mfloat_t *)&result, (mfloat_t *)&vec30, angle);
+	return result;
+}
+
+struct quat squat_from_vec3(struct vec3 vec30, struct vec3 vec31)
+{
+	struct quat result;
+	quat_from_vec3((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return result;
+}
+
+struct quat squat_from_mat4(struct mat4 mat40)
+{
+	struct quat result;
+	quat_from_mat4((mfloat_t *)&result, (mfloat_t *)&mat40);
+	return result;
+}
+
+struct quat squat_lerp(struct quat quat0, struct quat quat1, mfloat_t f)
+{
+	struct quat result;
+	quat_lerp((mfloat_t *)&result, (mfloat_t *)&quat0, (mfloat_t *)&quat1, f);
+	return result;
+}
+
+struct quat squat_slerp(struct quat quat0, struct quat quat1, mfloat_t f)
+{
+	struct quat result;
+	quat_slerp((mfloat_t *)&result, (mfloat_t *)&quat0, (mfloat_t *)&quat1, f);
+	return result;
+}
+
+mfloat_t squat_length(struct quat quat0)
+{
+	return quat_length((mfloat_t *)&quat0);
+}
+
+mfloat_t squat_length_squared(struct quat quat0)
+{
+	return quat_length_squared((mfloat_t *)&quat0);
+}
+
+mfloat_t squat_angle(struct quat quat0, struct quat quat1)
+{
+	return quat_angle((mfloat_t *)&quat0, (mfloat_t *)&quat1);
+}
+
+struct mat2 smat2(mfloat_t m11, mfloat_t m12, mfloat_t m21, mfloat_t m22)
+{
+	struct mat2 result;
+	mat2((mfloat_t *)&result, m11, m12, m21, m22);
+	return result;
+}
+
+struct mat2 smat2_zero(void)
+{
+	struct mat2 result;
+	mat2_zero((mfloat_t *)&result);
+	return result;
+}
+
+struct mat2 smat2_identity(void)
+{
+	struct mat2 result;
+	mat2_identity((mfloat_t *)&result);
+	return result;
+}
+
+mfloat_t smat2_determinant(struct mat2 mat20)
+{
+	return mat2_determinant((mfloat_t *)&mat20);
+}
+
+struct mat2 smat2_assign(struct mat2 mat20)
+{
+	struct mat2 result;
+	mat2_assign((mfloat_t *)&result, (mfloat_t *)&mat20);
+	return result;
+}
+
+struct mat2 smat2_negative(struct mat2 mat20)
+{
+	struct mat2 result;
+	mat2_negative((mfloat_t *)&result, (mfloat_t *)&mat20);
+	return result;
+}
+
+struct mat2 smat2_transpose(struct mat2 mat20)
+{
+	struct mat2 result;
+	mat2_transpose((mfloat_t *)&result, (mfloat_t *)&mat20);
+	return result;
+}
+
+struct mat2 smat2_cofactor(struct mat2 mat20)
+{
+	struct mat2 result;
+	mat2_cofactor((mfloat_t *)&result, (mfloat_t *)&mat20);
+	return result;
+}
+
+struct mat2 smat2_adjugate(struct mat2 mat20)
+{
+	struct mat2 result;
+	mat2_adjugate((mfloat_t *)&result, (mfloat_t *)&mat20);
+	return result;
+}
+
+struct mat2 smat2_multiply(struct mat2 mat20, struct mat2 mat21)
+{
+	struct mat2 result;
+	mat2_multiply((mfloat_t *)&result, (mfloat_t *)&mat20, (mfloat_t *)&mat21);
+	return result;
+}
+
+struct mat2 smat2_multiply_f(struct mat2 mat20, mfloat_t f)
+{
+	struct mat2 result;
+	mat2_multiply_f((mfloat_t *)&result, (mfloat_t *)&mat20, f);
+	return result;
+}
+
+struct mat2 smat2_inverse(struct mat2 mat20)
+{
+	struct mat2 result;
+	mat2_inverse((mfloat_t *)&result, (mfloat_t *)&mat20);
+	return result;
+}
+
+struct mat2 smat2_scaling(struct vec2 vec20)
+{
+	struct mat2 result;
+	mat2_scaling((mfloat_t *)&result, (mfloat_t *)&vec20);
+	return result;
+}
+
+struct mat2 smat2_scale(struct mat2 mat20, struct vec2 vec20)
+{
+	struct mat2 result;
+	mat2_scale((mfloat_t *)&result, (mfloat_t *)&mat20, (mfloat_t *)&vec20);
+	return result;
+}
+
+struct mat2 smat2_rotation_z(mfloat_t f)
+{
+	struct mat2 result;
+	mat2_rotation_z((mfloat_t *)&result, f);
+	return result;
+}
+
+struct mat2 smat2_lerp(struct mat2 mat20, struct mat2 mat21, mfloat_t f)
+{
+	struct mat2 result;
+	mat2_lerp((mfloat_t *)&result, (mfloat_t *)&mat20, (mfloat_t *)&mat21, f);
+	return result;
+}
+
+struct mat3 smat3(mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m31, mfloat_t m32, mfloat_t m33)
+{
+	struct mat3 result;
+	mat3((mfloat_t *)&result, m11, m12, m13, m21, m22, m23, m31, m32, m33);
+	return result;
+}
+
+struct mat3 smat3_zero(void)
+{
+	struct mat3 result;
+	mat3_zero((mfloat_t *)&result);
+	return result;
+}
+
+struct mat3 smat3_identity(void)
+{
+	struct mat3 result;
+	mat3_identity((mfloat_t *)&result);
+	return result;
+}
+
+mfloat_t smat3_determinant(struct mat3 mat30)
+{
+	return mat3_determinant((mfloat_t *)&mat30);
+}
+
+struct mat3 smat3_assign(struct mat3 mat30)
+{
+	struct mat3 result;
+	mat3_assign((mfloat_t *)&result, (mfloat_t *)&mat30);
+	return result;
+}
+
+struct mat3 smat3_negative(struct mat3 mat30)
+{
+	struct mat3 result;
+	mat3_negative((mfloat_t *)&result, (mfloat_t *)&mat30);
+	return result;
+}
+
+struct mat3 smat3_transpose(struct mat3 mat30)
+{
+	struct mat3 result;
+	mat3_transpose((mfloat_t *)&result, (mfloat_t *)&mat30);
+	return result;
+}
+
+struct mat3 smat3_cofactor(struct mat3 mat30)
+{
+	struct mat3 result;
+	mat3_cofactor((mfloat_t *)&result, (mfloat_t *)&mat30);
+	return result;
+}
+
+struct mat3 smat3_multiply(struct mat3 mat30, struct mat3 mat31)
+{
+	struct mat3 result;
+	mat3_multiply((mfloat_t *)&result, (mfloat_t *)&mat30, (mfloat_t *)&mat31);
+	return result;
+}
+
+struct mat3 smat3_multiply_f(struct mat3 mat30, mfloat_t f)
+{
+	struct mat3 result;
+	mat3_multiply_f((mfloat_t *)&result, (mfloat_t *)&mat30, f);
+	return result;
+}
+
+struct mat3 smat3_inverse(struct mat3 mat30)
+{
+	struct mat3 result;
+	mat3_inverse((mfloat_t *)&result, (mfloat_t *)&mat30);
+	return result;
+}
+
+struct mat3 smat3_scaling(struct vec3 vec30)
+{
+	struct mat3 result;
+	mat3_scaling((mfloat_t *)&result, (mfloat_t *)&vec30);
+	return result;
+}
+
+struct mat3 smat3_scale(struct mat3 mat30, struct vec3 vec30)
+{
+	struct mat3 result;
+	mat3_scale((mfloat_t *)&result, (mfloat_t *)&mat30, (mfloat_t *)&vec30);
+	return result;
+}
+
+struct mat3 smat3_rotation_x(mfloat_t f)
+{
+	struct mat3 result;
+	mat3_rotation_x((mfloat_t *)&result, f);
+	return result;
+}
+
+struct mat3 smat3_rotation_y(mfloat_t f)
+{
+	struct mat3 result;
+	mat3_rotation_y((mfloat_t *)&result, f);
+	return result;
+}
+
+struct mat3 smat3_rotation_z(mfloat_t f)
+{
+	struct mat3 result;
+	mat3_rotation_z((mfloat_t *)&result, f);
+	return result;
+}
+
+struct mat3 smat3_rotation_axis(struct vec3 vec30, mfloat_t f)
+{
+	struct mat3 result;
+	mat3_rotation_axis((mfloat_t *)&result, (mfloat_t *)&vec30, f);
+	return result;
+}
+
+struct mat3 smat3_rotation_quat(struct quat quat0)
+{
+	struct mat3 result;
+	mat3_rotation_quat((mfloat_t *)&result, (mfloat_t *)&quat0);
+	return result;
+}
+
+struct mat3 smat3_lerp(struct mat3 mat30, struct mat3 mat31, mfloat_t f)
+{
+	struct mat3 result;
+	mat3_lerp((mfloat_t *)&result, (mfloat_t *)&mat30, (mfloat_t *)&mat31, f);
+	return result;
+}
+
+struct mat4 smat4(mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m14, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m24, mfloat_t m31, mfloat_t m32, mfloat_t m33, mfloat_t m34, mfloat_t m41, mfloat_t m42, mfloat_t m43, mfloat_t m44)
+{
+	struct mat4 result;
+	mat4((mfloat_t *)&result, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
+	return result;
+}
+
+struct mat4 smat4_zero(void)
+{
+	struct mat4 result;
+	mat4_zero((mfloat_t *)&result);
+	return result;
+}
+
+struct mat4 smat4_identity(void)
 {
-	bool result = false;
-	float abs_a = fabsf(a);
-	float abs_b = fabsf(b);
-	float diff = fabsf(a - b);
-	if (a == b) {
-		result = true;
-	} else if (a == 0.0f || b == 0.0f || diff < FLT_EPSILON) {
-		result = diff < epsilon;
-	} else {
-		result = diff / fminf(abs_a + abs_b, FLT_MAX) < epsilon;
-	}
+	struct mat4 result;
+	mat4_identity((mfloat_t *)&result);
 	return result;
 }
 
-float to_radians(float degrees)
+mfloat_t smat4_determinant(struct mat4 mat40)
 {
-	return degrees * M_PIF / 180.0f;
+	return mat4_determinant((mfloat_t *)&mat40);
 }
 
-float to_degrees(float radians)
+struct mat4 smat4_assign(struct mat4 mat40)
 {
-	return radians * 180.0f / M_PIF;
+	struct mat4 result;
+	mat4_assign((mfloat_t *)&result, (mfloat_t *)&mat40);
+	return result;
 }
 
-/* Vector 2D */
-void to_pvector2(float x, float y, struct vec *result)
+struct mat4 smat4_negative(struct mat4 mat40)
 {
-	result->x = x;
-	result->y = y;
-	result->z = 0.0f;
-	result->w = 1.0f;
+	struct mat4 result;
+	mat4_negative((mfloat_t *)&result, (mfloat_t *)&mat40);
+	return result;
 }
 
-MATHC_EXTERN_INLINE struct vec to_vector2(float x, float y)
+struct mat4 smat4_transpose(struct mat4 mat40)
 {
-	struct vec result;
-	to_pvector2(x, y, &result);
+	struct mat4 result;
+	mat4_transpose((mfloat_t *)&result, (mfloat_t *)&mat40);
 	return result;
 }
 
-void pvector2_zero(struct vec *result)
+struct mat4 smat4_cofactor(struct mat4 mat40)
 {
-	result->x = 0.0f;
-	result->y = 0.0f;
-	result->z = 0.0f;
-	result->w = 0.0f;
+	struct mat4 result;
+	mat4_cofactor((mfloat_t *)&result, (mfloat_t *)&mat40);
+	return result;
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_zero(void)
+struct mat4 smat4_rotation_x(mfloat_t f)
 {
-	struct vec result;
-	pvector2_zero(&result);
+	struct mat4 result;
+	mat4_rotation_x((mfloat_t *)&result, f);
 	return result;
 }
 
-bool pvector2_is_zero(struct vec *a)
+struct mat4 smat4_rotation_y(mfloat_t f)
 {
-	bool is_zero = false;
-	if (fabs(a->x) < FLT_EPSILON && fabs(a->y) < FLT_EPSILON) {
-		is_zero = true;
-	}
-	return is_zero;
+	struct mat4 result;
+	mat4_rotation_y((mfloat_t *)&result, f);
+	return result;
 }
 
-MATHC_EXTERN_INLINE bool vector2_is_zero(struct vec a)
+struct mat4 smat4_rotation_z(mfloat_t f)
 {
-	return pvector2_is_zero(&a);
+	struct mat4 result;
+	mat4_rotation_z((mfloat_t *)&result, f);
+	return result;
 }
 
-bool pvector2_is_near_zero(struct vec *a, float epsilon)
+struct mat4 smat4_rotation_axis(struct vec3 vec30, mfloat_t f)
 {
-	bool is_near_zero = false;
-	if (fabs(a->x) < epsilon && fabs(a->y) < epsilon) {
-		is_near_zero = true;
-	}
-	return is_near_zero;
+	struct mat4 result;
+	mat4_rotation_axis((mfloat_t *)&result, (mfloat_t *)&vec30, f);
+	return result;
 }
 
-MATHC_EXTERN_INLINE bool vector2_is_near_zero(struct vec a, float epsilon)
+struct mat4 smat4_rotation_quat(struct quat quat0)
 {
-	return pvector2_is_near_zero(&a, epsilon);
+	struct mat4 result;
+	mat4_rotation_quat((mfloat_t *)&result, (mfloat_t *)&quat0);
+	return result;
 }
 
-bool pvector2_is_equal(struct vec *a, struct vec *b, float epsilon)
+struct mat4 smat4_translation(struct mat4 mat40, struct vec3 vec30)
 {
-	bool is_equal = false;
-	if (fabs(a->x - b->x) < epsilon && fabs(a->y - b->y) < FLT_EPSILON) {
-		is_equal = true;
-	}
-	return is_equal;
+	struct mat4 result;
+	mat4_translation((mfloat_t *)&result, (mfloat_t *)&mat40, (mfloat_t *)&vec30);
+	return result;
 }
 
-MATHC_EXTERN_INLINE bool vector2_is_equal(struct vec a, struct vec b, float epsilon)
+struct mat4 smat4_translate(struct mat4 mat40, struct vec3 vec30)
 {
-	return pvector2_is_equal(&a, &b, epsilon);
+	struct mat4 result;
+	mat4_translate((mfloat_t *)&result, (mfloat_t *)&mat40, (mfloat_t *)&vec30);
+	return result;
 }
 
-void pvector2_add(struct vec *a, struct vec *b, struct vec *result)
+struct mat4 smat4_scaling(struct mat4 mat40, struct vec3 vec30)
 {
-	result->x = a->x + b->x;
-	result->y = a->y + b->y;
-	result->w = 1.0f;
+	struct mat4 result;
+	mat4_scaling((mfloat_t *)&result, (mfloat_t *)&mat40, (mfloat_t *)&vec30);
+	return result;
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_add(struct vec a, struct vec b)
+struct mat4 smat4_scale(struct mat4 mat40, struct vec3 vec30)
 {
-	struct vec result;
-	pvector2_add(&a, &b, &result);
+	struct mat4 result;
+	mat4_scale((mfloat_t *)&result, (mfloat_t *)&mat40, (mfloat_t *)&vec30);
 	return result;
 }
 
-void pvector2_subtract(struct vec *a, struct vec *b, struct vec *result)
+struct mat4 smat4_multiply(struct mat4 mat40, struct mat4 mat41)
 {
-	result->x = a->x - b->x;
-	result->y = a->y - b->y;
-	result->w = 1.0f;
+	struct mat4 result;
+	mat4_multiply((mfloat_t *)&result, (mfloat_t *)&mat40, (mfloat_t *)&mat41);
+	return result;
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_subtract(struct vec a, struct vec b)
+struct mat4 smat4_multiply_f(struct mat4 mat40, mfloat_t f)
 {
-	struct vec result;
-	pvector2_subtract(&a, &b, &result);
+	struct mat4 result;
+	mat4_multiply_f((mfloat_t *)&result, (mfloat_t *)&mat40, f);
 	return result;
 }
 
-void pvector2_scale(struct vec *a, float scale, struct vec *result)
+struct mat4 smat4_inverse(struct mat4 mat40)
 {
-	result->x = a->x * scale;
-	result->y = a->y * scale;
-	result->w = 1.0f;
+	struct mat4 result;
+	mat4_inverse((mfloat_t *)&result, (mfloat_t *)&mat40);
+	return result;
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_scale(struct vec a, float scale)
+struct mat4 smat4_lerp(struct mat4 mat40, struct mat4 mat41, mfloat_t f)
 {
-	struct vec result;
-	pvector2_scale(&a, scale, &result);
+	struct mat4 result;
+	mat4_lerp((mfloat_t *)&result, (mfloat_t *)&mat40, (mfloat_t *)&mat41, f);
 	return result;
 }
 
-void pvector2_multiply(struct vec *a, struct vec *b, struct vec *result)
+struct mat4 smat4_look_at(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32)
 {
-	result->x = a->x * b->x;
-	result->y = a->y * b->y;
-	result->w = 1.0f;
+	struct mat4 result;
+	mat4_look_at((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31, (mfloat_t *)&vec32);
+	return result;
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_multiply(struct vec a, struct vec b)
+struct mat4 smat4_ortho(mfloat_t l, mfloat_t r, mfloat_t b, mfloat_t t, mfloat_t n, mfloat_t f)
 {
-	struct vec result;
-	pvector2_multiply(&a, &b, &result);
+	struct mat4 result;
+	mat4_ortho((mfloat_t *)&result, l, r, b, t, n, f);
 	return result;
 }
 
-void pvector2_divide(struct vec *a, struct vec *b, struct vec *result)
+struct mat4 smat4_perspective(mfloat_t fov_y, mfloat_t aspect, mfloat_t n, mfloat_t f)
 {
-	result->x = a->x / b->x;
-	result->y = a->y / b->y;
-	result->w = 1.0f;
+	struct mat4 result;
+	mat4_perspective((mfloat_t *)&result, fov_y, aspect, n, f);
+	return result;
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_divide(struct vec a, struct vec b)
+struct mat4 smat4_perspective_fov(mfloat_t fov, mfloat_t w, mfloat_t h, mfloat_t n, mfloat_t f)
 {
-	struct vec result;
-	pvector2_divide(&a, &b, &result);
+	struct mat4 result;
+	mat4_perspective_fov((mfloat_t *)&result, fov, w, h, n, f);
 	return result;
 }
 
-void pvector2_negative(struct vec *a, struct vec *result)
+struct mat4 smat4_perspective_infinite(mfloat_t fov_y, mfloat_t aspect, mfloat_t n)
 {
-	result->x = -a->x;
-	result->y = -a->y;
-	result->w = 1.0f;
+	struct mat4 result;
+	mat4_perspective_infinite((mfloat_t *)&result, fov_y, aspect, n);
+	return result;
 }
+#endif
+#endif
 
-MATHC_EXTERN_INLINE struct vec vector2_negative(struct vec a)
+#if defined(MATHC_USE_POINTER_STRUCT_FUNCTIONS)
+#if defined(MATHC_USE_INT)
+bool psvec2i_is_zero(struct vec2i *vec2i0)
 {
-	struct vec result;
-	pvector2_negative(&a, &result);
-	return result;
+	return vec2i_is_zero((mint_t *)vec2i0);
 }
 
-void pvector2_inverse(struct vec *a, struct vec *result)
+bool psvec2i_is_equal(struct vec2i *vec2i0, struct vec2i *vec2i1)
 {
-	if (a->x != 0.0f) {
-		result->x = 1.0f / a->x;
-	} else {
-		result->x = 0.0f;
-	}
-	if (a->y != 0.0f) {
-		result->y = 1.0f / a->y;
-	} else {
-		result->y = 0.0f;
-	}
-	result->w = 1.0f;
+	return vec2i_is_equal((mint_t *)vec2i0, (mint_t *)vec2i1);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_inverse(struct vec a)
+struct vec2i *psvec2i(struct vec2i *result, mint_t x, mint_t y)
 {
-	struct vec result;
-	pvector2_inverse(&a, &result);
-	return result;
+	return (struct vec2i *)vec2i((mint_t *)result, x, y);
 }
 
-void pvector2_abs(struct vec *a, struct vec *result)
+struct vec2i *psvec2i_assign(struct vec2i *result, struct vec2i *vec2i0)
 {
-	result->x = fabsf(a->x);
-	result->y = fabsf(a->y);
-	result->w = 1.0f;
+	return (struct vec2i *)vec2i_assign((mint_t *)result, (mint_t *)vec2i0);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_abs(struct vec a)
+#if defined(MATHC_USE_FLOATING_POINT)
+struct vec2i *psvec2i_assign_vec2(struct vec2i *result, struct vec2 *vec20)
 {
-	struct vec result;
-	pvector2_abs(&a, &result);
-	return result;
+	return (struct vec2i *)vec2i_assign_vec2((mint_t *)result, (mfloat_t *)vec20);
 }
+#endif
 
-void pvector2_floor(struct vec *a, struct vec *result)
+struct vec2i *psvec2i_zero(struct vec2i *result)
 {
-	result->x = floorf(a->x);
-	result->y = floorf(a->y);
-	result->w = 1.0f;
+	return (struct vec2i *)vec2i_zero((mint_t *)result);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_floor(struct vec a)
+struct vec2i *psvec2i_one(struct vec2i *result)
 {
-	struct vec result;
-	pvector2_floor(&a, &result);
-	return result;
+	return (struct vec2i *)vec2i_one((mint_t *)result);
 }
 
-void pvector2_ceil(struct vec *a, struct vec *result)
+struct vec2i *psvec2i_sign(struct vec2i *result, struct vec2i *vec2i0)
 {
-	result->x = ceilf(a->x);
-	result->y = ceilf(a->y);
-	result->w = 1.0f;
+	return (struct vec2i *)vec2i_sign((mint_t *)result, (mint_t *)vec2i0);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_ceil(struct vec a)
+struct vec2i *psvec2i_add(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1)
 {
-	struct vec result;
-	pvector2_ceil(&a, &result);
-	return result;
+	return (struct vec2i *)vec2i_add((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1);
 }
 
-void pvector2_round(struct vec *a, struct vec *result)
+struct vec2i *psvec2i_add_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i)
 {
-	result->x = roundf(a->x);
-	result->y = roundf(a->y);
-	result->w = 1.0f;
+	return (struct vec2i *)vec2i_add_i((mint_t *)result, (mint_t *)vec2i0, i);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_round(struct vec a)
+struct vec2i *psvec2i_subtract(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1)
 {
-	struct vec result;
-	pvector2_round(&a, &result);
-	return result;
+	return (struct vec2i *)vec2i_subtract((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1);
 }
 
-void pvector2_max(struct vec *a, struct vec *b, struct vec *result)
+struct vec2i *psvec2i_subtract_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i)
 {
-	result->x = fmaxf(a->x, b->x);
-	result->y = fmaxf(a->y, b->y);
-	result->w = 1.0f;
+	return (struct vec2i *)vec2i_subtract_i((mint_t *)result, (mint_t *)vec2i0, i);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_max(struct vec a, struct vec b)
+struct vec2i *psvec2i_multiply(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1)
 {
-	struct vec result;
-	pvector2_max(&a, &b, &result);
-	return result;
+	return (struct vec2i *)vec2i_multiply((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1);
 }
 
-void pvector2_min(struct vec *a, struct vec *b, struct vec *result)
+struct vec2i *psvec2i_multiply_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i)
 {
-	result->x = fminf(a->x, b->x);
-	result->y = fminf(a->y, b->y);
-	result->w = 1.0f;
+	return (struct vec2i *)vec2i_multiply_i((mint_t *)result, (mint_t *)vec2i0, i);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_min(struct vec a, struct vec b)
+struct vec2i *psvec2i_divide(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1)
 {
-	struct vec result;
-	pvector2_min(&a, &b, &result);
-	return result;
+	return (struct vec2i *)vec2i_divide((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1);
 }
 
-float pvector2_dot(struct vec *a, struct vec *b)
+struct vec2i *psvec2i_divide_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i)
 {
-	return a->x * b->x + a->y * b->y;
+	return (struct vec2i *)vec2i_divide_i((mint_t *)result, (mint_t *)vec2i0, i);
 }
 
-MATHC_EXTERN_INLINE float vector2_dot(struct vec a, struct vec b)
+struct vec2i *psvec2i_snap(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1)
 {
-	return pvector2_dot(&a, &b);
+	return (struct vec2i *)vec2i_snap((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1);
 }
 
-float pvector2_angle(struct vec *a)
+struct vec2i *psvec2i_snap_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i)
 {
-	return atan2f(a->y, a->x);
+	return (struct vec2i *)vec2i_snap_i((mint_t *)result, (mint_t *)vec2i0, i);
 }
 
-MATHC_EXTERN_INLINE float vector2_angle(struct vec a)
+struct vec2i *psvec2i_negative(struct vec2i *result, struct vec2i *vec2i0)
 {
-	return pvector2_angle(&a);
+	return (struct vec2i *)vec2i_negative((mint_t *)result, (mint_t *)vec2i0);
 }
 
-float pvector2_length_squared(struct vec *a)
+struct vec2i *psvec2i_abs(struct vec2i *result, struct vec2i *vec2i0)
 {
-	return a->x * a->x + a->y * a->y;
+	return (struct vec2i *)vec2i_abs((mint_t *)result, (mint_t *)vec2i0);
 }
 
-MATHC_EXTERN_INLINE float vector2_length_squared(struct vec a)
+struct vec2i *psvec2i_max(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1)
 {
-	return pvector2_length_squared(&a);
+	return (struct vec2i *)vec2i_max((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1);
 }
 
-float pvector2_length(struct vec *a)
+struct vec2i *psvec2i_min(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1)
 {
-	return sqrtf(a->x * a->x + a->y * a->y);
+	return (struct vec2i *)vec2i_min((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1);
 }
 
-MATHC_EXTERN_INLINE float vector2_length(struct vec a)
+struct vec2i *psvec2i_clamp(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1, struct vec2i *vec2i2)
 {
-	return pvector2_length(&a);
+	return (struct vec2i *)vec2i_clamp((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1, (mint_t *)vec2i2);
 }
 
-void pvector2_normalize(struct vec *a, struct vec *result)
+struct vec2i *psvec2i_tangent(struct vec2i *result, struct vec2i *vec2i0)
 {
-	float length = sqrtf(a->x * a->x + a->y * a->y);
-	if (length > FLT_EPSILON) {
-		length = 1.0f / length;
-		result->x = a->x * length;
-		result->y = a->y * length;
-	} else {
-		result->x = 0.0f;
-		result->y = 0.0f;
-	}
-	result->w = 1.0f;
+	return (struct vec2i *)vec2i_tangent((mint_t *)result, (mint_t *)vec2i0);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_normalize(struct vec a)
+bool psvec3i_is_zero(struct vec3i *vec3i0)
 {
-	struct vec result;
-	pvector2_normalize(&a, &result);
-	return result;
+	return vec3i_is_zero((mint_t *)vec3i0);
 }
 
-void pvector2_slide(struct vec *a, struct vec *normal, struct vec *result)
+bool psvec3i_is_equal(struct vec3i *vec3i0, struct vec3i *vec3i1)
 {
-	float d = pvector2_dot(a, normal);
-	result->x = a->x - normal->x * d;
-	result->y = a->y - normal->y * d;
-	result->w = 1.0f;
+	return vec3i_is_equal((mint_t *)vec3i0, (mint_t *)vec3i1);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_slide(struct vec a, struct vec normal)
+struct vec3i *psvec3i(struct vec3i *result, mint_t x, mint_t y, mint_t z)
 {
-	struct vec result;
-	pvector2_slide(&a, &normal, &result);
-	return result;
+	return (struct vec3i *)vec3i((mint_t *)result, x, y, z);
 }
 
-void pvector2_reflect(struct vec *a, struct vec *normal, struct vec *result)
+struct vec3i *psvec3i_assign(struct vec3i *result, struct vec3i *vec3i0)
 {
-	float d = 2.0f * pvector2_dot(a, normal);
-	result->x = a->x - normal->x * d;
-	result->y = a->y - normal->y * d;
-	result->w = 1.0f;
+	return (struct vec3i *)vec3i_assign((mint_t *)result, (mint_t *)vec3i0);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_reflect(struct vec a, struct vec normal)
+#if defined(MATHC_USE_FLOATING_POINT)
+struct vec3i *psvec3i_assign_vec3(struct vec3i *result, struct vec3 *vec30)
 {
-	struct vec result;
-	pvector2_reflect(&a, &normal, &result);
-	return result;
+	return (struct vec3i *)vec3i_assign_vec3((mint_t *)result, (mfloat_t *)vec30);
 }
+#endif
 
-void pvector2_tangent(struct vec *a, struct vec *result)
+struct vec3i *psvec3i_zero(struct vec3i *result)
 {
-	result->x = a->y;
-	result->y = -a->x;
-	result->w = 1.0f;
+	return (struct vec3i *)vec3i_zero((mint_t *)result);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_tangent(struct vec a)
+struct vec3i *psvec3i_one(struct vec3i *result)
 {
-	struct vec result;
-	pvector2_tangent(&a, &result);
-	return result;
+	return (struct vec3i *)vec3i_one((mint_t *)result);
 }
 
-void pvector2_rotate(struct vec *a, float angle, struct vec *result)
+struct vec3i *psvec3i_sign(struct vec3i *result, struct vec3i *vec3i0)
 {
-	float cs = cosf(angle);
-	float sn = sinf(angle);
-	float x = a->x;
-	float y = a->y;
-	result->x = x * cs - y * sn;
-	result->y = x * sn + y * cs;
-	result->w = 1.0f;
+	return (struct vec3i *)vec3i_sign((mint_t *)result, (mint_t *)vec3i0);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_rotate(struct vec a, float angle)
+struct vec3i *psvec3i_add(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
 {
-	struct vec result;
-	pvector2_rotate(&a, angle, &result);
-	return result;
+	return (struct vec3i *)vec3i_add((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
 }
 
-float pvector2_distance_to(struct vec *a, struct vec *b)
+struct vec3i *psvec3i_add_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i)
 {
-	return sqrtf((a->x - b->x) * (a->x - b->x) + (a->y - b->y) * (a->y - b->y));
+	return (struct vec3i *)vec3i_add_i((mint_t *)result, (mint_t *)vec3i0, i);
 }
 
-MATHC_EXTERN_INLINE float vector2_distance_to(struct vec a, struct vec b)
+struct vec3i *psvec3i_subtract(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
 {
-	return pvector2_distance_to(&a, &b);
+	return (struct vec3i *)vec3i_subtract((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
 }
 
-float pvector2_distance_squared_to(struct vec *a, struct vec *b)
+struct vec3i *psvec3i_subtract_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i)
 {
-	return (a->x - b->x) * (a->x - b->x) + (a->y - b->y) * (a->y - b->y);
+	return (struct vec3i *)vec3i_subtract_i((mint_t *)result, (mint_t *)vec3i0, i);
 }
 
-MATHC_EXTERN_INLINE float vector2_distance_squared_to(struct vec a, struct vec b)
+struct vec3i *psvec3i_multiply(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
 {
-	return pvector2_distance_squared_to(&a, &b);
+	return (struct vec3i *)vec3i_multiply((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
 }
 
-void pvector2_linear_interpolation(struct vec *a, struct vec *b, float p, struct vec *result)
+struct vec3i *psvec3i_multiply_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i)
 {
-	result->x = a->x + (b->x - a->x) * p;
-	result->y = a->y + (b->y - a->y) * p;
-	result->w = 1.0f;
+	return (struct vec3i *)vec3i_multiply_i((mint_t *)result, (mint_t *)vec3i0, i);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_linear_interpolation(struct vec a, struct vec b, float p)
+struct vec3i *psvec3i_divide(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
 {
-	struct vec result;
-	pvector2_linear_interpolation(&a, &b, p, &result);
-	return result;
+	return (struct vec3i *)vec3i_divide((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
 }
 
-void pvector2_bezier3(struct vec *a, struct vec *b, struct vec *c, float p, struct vec *result)
+struct vec3i *psvec3i_divide_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i)
 {
-	struct vec tmp_a;
-	struct vec tmp_b;
-	pvector2_linear_interpolation(a, b, p, &tmp_a);
-	pvector2_linear_interpolation(b, c, p, &tmp_b);
-	pvector2_linear_interpolation(&tmp_a, &tmp_b, p, result);
+	return (struct vec3i *)vec3i_divide_i((mint_t *)result, (mint_t *)vec3i0, i);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_bezier3(struct vec a, struct vec b, struct vec c, float p)
+struct vec3i *psvec3i_snap(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
 {
-	struct vec result;
-	pvector2_bezier3(&a, &b, &c, p, &result);
-	return result;
+	return (struct vec3i *)vec3i_snap((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
 }
 
-void pvector2_bezier4(struct vec *a, struct vec *b, struct vec *c, struct vec *d, float p, struct vec *result)
+struct vec3i *psvec3i_snap_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i)
 {
-	struct vec tmp_a;
-	struct vec tmp_b;
-	struct vec tmp_c;
-	struct vec tmp_d;
-	struct vec tmp_e;
-	pvector2_linear_interpolation(a, b, p, &tmp_a);
-	pvector2_linear_interpolation(b, c, p, &tmp_b);
-	pvector2_linear_interpolation(c, d, p, &tmp_c);
-	pvector2_linear_interpolation(&tmp_a, &tmp_b, p, &tmp_d);
-	pvector2_linear_interpolation(&tmp_b, &tmp_c, p, &tmp_e);
-	pvector2_linear_interpolation(&tmp_d, &tmp_e, p, result);
+	return (struct vec3i *)vec3i_snap_i((mint_t *)result, (mint_t *)vec3i0, i);
 }
 
-MATHC_EXTERN_INLINE struct vec vector2_bezier4(struct vec a, struct vec b, struct vec c, struct vec d, float p)
+struct vec3i *psvec3i_cross(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
 {
-	struct vec result;
-	pvector2_bezier4(&a, &b, &c, &d, p, &result);
-	return result;
+	return (struct vec3i *)vec3i_cross((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
 }
 
-/* Vector 3D */
-void to_pvector3(float x, float y, float z, struct vec *result)
+struct vec3i *psvec3i_negative(struct vec3i *result, struct vec3i *vec3i0)
 {
-	result->x = x;
-	result->y = y;
-	result->z = z;
-	result->w = 1.0f;
+	return (struct vec3i *)vec3i_negative((mint_t *)result, (mint_t *)vec3i0);
 }
 
-MATHC_EXTERN_INLINE struct vec to_vector3(float x, float y, float z)
+struct vec3i *psvec3i_abs(struct vec3i *result, struct vec3i *vec3i0)
 {
-	struct vec result;
-	to_pvector3(x, y, z, &result);
-	return result;
+	return (struct vec3i *)vec3i_abs((mint_t *)result, (mint_t *)vec3i0);
 }
 
-void pvector3_zero(struct vec *result)
+struct vec3i *psvec3i_max(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
 {
-	result->x = 0.0f;
-	result->y = 0.0f;
-	result->z = 0.0f;
-	result->w = 0.0f;
+	return (struct vec3i *)vec3i_max((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_zero(void)
+struct vec3i *psvec3i_min(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
 {
-	struct vec result;
-	pvector3_zero(&result);
-	return result;
+	return (struct vec3i *)vec3i_min((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
 }
 
-bool pvector3_is_zero(struct vec *a)
+struct vec3i *psvec3i_clamp(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1, struct vec3i *vec3i2)
 {
-	bool is_zero = false;
-	if (fabs(a->x) < FLT_EPSILON && fabs(a->y) < FLT_EPSILON && fabs(a->z) < FLT_EPSILON) {
-		is_zero = true;
-	}
-	return is_zero;
+	return (struct vec3i *)vec3i_clamp((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1, (mint_t *)vec3i2);
 }
 
-MATHC_EXTERN_INLINE bool vector3_is_zero(struct vec a)
+bool psvec4i_is_zero(struct vec4i *vec4i0)
 {
-	return pvector3_is_zero(&a);
+	return vec4i_is_zero((mint_t *)vec4i0);
 }
 
-bool pvector3_is_near_zero(struct vec *a, float epsilon)
+bool psvec4i_is_equal(struct vec4i *vec4i0, struct vec4i *vec4i1)
 {
-	bool is_near_zero = false;
-	if (fabs(a->x) < epsilon && fabs(a->y) < epsilon && fabs(a->z) < epsilon) {
-		is_near_zero = true;
-	}
-	return is_near_zero;
+	return vec4i_is_equal((mint_t *)vec4i0, (mint_t *)vec4i1);
 }
 
-MATHC_EXTERN_INLINE bool vector3_is_near_zero(struct vec a, float epsilon)
+struct vec4i *psvec4i(struct vec4i *result, mint_t x, mint_t y, mint_t z, mint_t w)
 {
-	return pvector3_is_near_zero(&a, epsilon);
+	return (struct vec4i *)vec4i((mint_t *)result, x, y, z, w);
 }
 
-bool pvector3_is_equal(struct vec *a, struct vec *b, float epsilon)
+struct vec4i *psvec4i_assign(struct vec4i *result, struct vec4i *vec4i0)
 {
-	bool is_equal = false;
-	if (fabs(a->x - b->x) < epsilon && fabs(a->y - b->y) < FLT_EPSILON && fabs(a->z - b->z) < FLT_EPSILON) {
-		is_equal = true;
-	}
-	return is_equal;
+	return (struct vec4i *)vec4i_assign((mint_t *)result, (mint_t *)vec4i0);
 }
 
-MATHC_EXTERN_INLINE bool vector3_is_equal(struct vec a, struct vec b, float epsilon)
+#if defined(MATHC_USE_FLOATING_POINT)
+struct vec4i *psvec4i_assign_vec4(struct vec4i *result, struct vec4 *vec40)
 {
-	return pvector3_is_equal(&a, &b, epsilon);
+	return (struct vec4i *)vec4i_assign_vec4((mint_t *)result, (mfloat_t *)vec40);
 }
+#endif
 
-void pvector3_add(struct vec *a, struct vec *b, struct vec *result)
+struct vec4i *psvec4i_zero(struct vec4i *result)
 {
-	result->x = a->x + b->x;
-	result->y = a->y + b->y;
-	result->z = a->z + b->z;
-	result->w = 1.0f;
+	return (struct vec4i *)vec4i_zero((mint_t *)result);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_add(struct vec a, struct vec b)
+struct vec4i *psvec4i_one(struct vec4i *result)
 {
-	struct vec result;
-	pvector3_add(&a, &b, &result);
-	return result;
+	return (struct vec4i *)vec4i_one((mint_t *)result);
 }
 
-void pvector3_subtract(struct vec *a, struct vec *b, struct vec *result)
+struct vec4i *psvec4i_sign(struct vec4i *result, struct vec4i *vec4i0)
 {
-	result->x = a->x - b->x;
-	result->y = a->y - b->y;
-	result->z = a->z - b->z;
-	result->w = 1.0f;
+	return (struct vec4i *)vec4i_sign((mint_t *)result, (mint_t *)vec4i0);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_subtract(struct vec a, struct vec b)
+struct vec4i *psvec4i_add(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1)
 {
-	struct vec result;
-	pvector3_subtract(&a, &b, &result);
-	return result;
+	return (struct vec4i *)vec4i_add((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1);
 }
 
-void pvector3_scale(struct vec *a, float scale, struct vec *result)
+struct vec4i *psvec4i_add_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i)
 {
-	result->x = a->x * scale;
-	result->y = a->y * scale;
-	result->z = a->z * scale;
-	result->w = 1.0f;
+	return (struct vec4i *)vec4i_add_i((mint_t *)result, (mint_t *)vec4i0, i);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_scale(struct vec a, float scale)
+struct vec4i *psvec4i_subtract(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1)
 {
-	struct vec result;
-	pvector3_scale(&a, scale, &result);
-	return result;
+	return (struct vec4i *)vec4i_subtract((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1);
 }
 
-void pvector3_multiply(struct vec *a, struct vec *b, struct vec *result)
+struct vec4i *psvec4i_subtract_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i)
 {
-	result->x = a->x * b->x;
-	result->y = a->y * b->y;
-	result->z = a->z * b->z;
-	result->w = 1.0f;
+	return (struct vec4i *)vec4i_subtract_i((mint_t *)result, (mint_t *)vec4i0, i);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_multiply(struct vec a, struct vec b)
+struct vec4i *psvec4i_multiply(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1)
 {
-	struct vec result;
-	pvector3_multiply(&a, &b, &result);
-	return result;
+	return (struct vec4i *)vec4i_multiply((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1);
 }
 
-void pvector3_divide(struct vec *a, struct vec *b, struct vec *result)
+struct vec4i *psvec4i_multiply_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i)
 {
-	result->x = a->x / b->x;
-	result->y = a->y / b->y;
-	result->z = a->z / b->z;
-	result->w = 1.0f;
+	return (struct vec4i *)vec4i_multiply_i((mint_t *)result, (mint_t *)vec4i0, i);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_divide(struct vec a, struct vec b)
+struct vec4i *psvec4i_divide(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1)
 {
-	struct vec result;
-	pvector3_divide(&a, &b, &result);
-	return result;
+	return (struct vec4i *)vec4i_divide((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1);
 }
 
-void pvector3_negative(struct vec *a, struct vec *result)
+struct vec4i *psvec4i_divide_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i)
 {
-	result->x = -a->x;
-	result->y = -a->y;
-	result->z = -a->z;
-	result->w = 1.0f;
+	return (struct vec4i *)vec4i_divide_i((mint_t *)result, (mint_t *)vec4i0, i);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_negative(struct vec a)
+struct vec4i *psvec4i_snap(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1)
 {
-	struct vec result;
-	pvector3_negative(&a, &result);
-	return result;
+	return (struct vec4i *)vec4i_snap((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1);
 }
 
-void pvector3_inverse(struct vec *a, struct vec *result)
+struct vec4i *psvec4i_snap_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i)
 {
-	if (a->x != 0.0f) {
-		result->x = 1.0f / a->x;
-	} else {
-		result->x = 0.0f;
-	}
-	if (a->y != 0.0f) {
-		result->y = 1.0f / a->y;
-	} else {
-		result->y = 0.0f;
-	}
-	if (a->z != 0.0f) {
-		result->z = 1.0f / a->z;
-	} else {
-		result->z = 0.0f;
-	}
-	result->w = 1.0f;
+	return (struct vec4i *)vec4i_snap_i((mint_t *)result, (mint_t *)vec4i0, i);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_inverse(struct vec a)
+struct vec4i *psvec4i_negative(struct vec4i *result, struct vec4i *vec4i0)
 {
-	struct vec result;
-	pvector3_inverse(&a, &result);
-	return result;
+	return (struct vec4i *)vec4i_negative((mint_t *)result, (mint_t *)vec4i0);
 }
 
-void pvector3_abs(struct vec *a, struct vec *result)
+struct vec4i *psvec4i_abs(struct vec4i *result, struct vec4i *vec4i0)
 {
-	result->x = fabsf(a->x);
-	result->y = fabsf(a->y);
-	result->z = fabsf(a->z);
-	result->w = 1.0f;
+	return (struct vec4i *)vec4i_abs((mint_t *)result, (mint_t *)vec4i0);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_abs(struct vec a)
+struct vec4i *psvec4i_max(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1)
 {
-	struct vec result;
-	pvector3_abs(&a, &result);
-	return result;
+	return (struct vec4i *)vec4i_max((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1);
 }
 
-void pvector3_floor(struct vec *a, struct vec *result)
+struct vec4i *psvec4i_min(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1)
 {
-	result->x = floorf(a->x);
-	result->y = floorf(a->y);
-	result->z = floorf(a->z);
-	result->w = 1.0f;
+	return (struct vec4i *)vec4i_min((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_floor(struct vec a)
+struct vec4i *psvec4i_clamp(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1, struct vec4i *vec4i2)
 {
-	struct vec result;
-	pvector3_floor(&a, &result);
-	return result;
+	return (struct vec4i *)vec4i_clamp((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1, (mint_t *)vec4i2);
 }
+#endif
 
-void pvector3_ceil(struct vec *a, struct vec *result)
+#if defined(MATHC_USE_FLOATING_POINT)
+bool psvec2_is_zero(struct vec2 *vec20)
 {
-	result->x = ceilf(a->x);
-	result->y = ceilf(a->y);
-	result->z = ceilf(a->z);
-	result->w = 1.0f;
+	return vec2_is_zero((mfloat_t *)vec20);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_ceil(struct vec a)
+bool psvec2_is_equal(struct vec2 *vec20, struct vec2 *vec21)
 {
-	struct vec result;
-	pvector3_ceil(&a, &result);
-	return result;
+	return vec2_is_equal((mfloat_t *)vec20, (mfloat_t *)vec21);
 }
 
-void pvector3_round(struct vec *a, struct vec *result)
+struct vec2 *psvec2(struct vec2 *result, mfloat_t x, mfloat_t y)
 {
-	result->x = roundf(a->x);
-	result->y = roundf(a->y);
-	result->z = roundf(a->z);
-	result->w = 1.0f;
+	return (struct vec2 *)vec2((mfloat_t *)result, x, y);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_round(struct vec a)
+struct vec2 *psvec2_assign(struct vec2 *result, struct vec2 *vec20)
 {
-	struct vec result;
-	pvector3_round(&a, &result);
-	return result;
+	return (struct vec2 *)vec2_assign((mfloat_t *)result, (mfloat_t *)vec20);
 }
 
-void pvector3_max(struct vec *a, struct vec *b, struct vec *result)
+#if defined(MATHC_USE_INT)
+struct vec2 *psvec2_assign_vec2i(struct vec2 *result, struct vec2i *vec2i0)
 {
-	result->x = fmaxf(a->x, b->x);
-	result->y = fmaxf(a->y, b->y);
-	result->z = fmaxf(a->z, b->z);
-	result->w = 1.0f;
+	return (struct vec2 *)vec2_assign_vec2i((mfloat_t *)result, (mint_t *)vec2i0);
 }
+#endif
 
-MATHC_EXTERN_INLINE struct vec vector3_max(struct vec a, struct vec b)
+struct vec2 *psvec2_zero(struct vec2 *result)
 {
-	struct vec result;
-	pvector3_max(&a, &b, &result);
-	return result;
+	return (struct vec2 *)vec2_zero((mfloat_t *)result);
 }
 
-void pvector3_min(struct vec *a, struct vec *b, struct vec *result)
+struct vec2 *psvec2_one(struct vec2 *result)
 {
-	result->x = fminf(a->x, b->x);
-	result->y = fminf(a->y, b->y);
-	result->z = fminf(a->z, b->z);
-	result->w = 1.0f;
+	return (struct vec2 *)vec2_one((mfloat_t *)result);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_min(struct vec a, struct vec b)
+struct vec2 *psvec2_sign(struct vec2 *result, struct vec2 *vec20)
 {
-	struct vec result;
-	pvector3_min(&a, &b, &result);
-	return result;
+	return (struct vec2 *)vec2_sign((mfloat_t *)result, (mfloat_t *)vec20);
 }
 
-float pvector3_dot(struct vec *a, struct vec *b)
+struct vec2 *psvec2_add(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
 {
-	return a->x * b->x + a->y * b->y + a->z * b->z;
+	return (struct vec2 *)vec2_add((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
 }
 
-MATHC_EXTERN_INLINE float vector3_dot(struct vec a, struct vec b)
+struct vec2 *psvec2_add_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f)
 {
-	return pvector3_dot(&a, &b);
+	return (struct vec2 *)vec2_add_f((mfloat_t *)result, (mfloat_t *)vec20, f);
 }
 
-void pvector3_cross(struct vec *a, struct vec *b, struct vec *result)
+struct vec2 *psvec2_subtract(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
 {
-	result->x = a->y * b->z - a->z * b->y;
-	result->y = a->z * b->x - a->x * b->z;
-	result->z = a->x * b->y - a->y * b->x;
-	result->w = 1.0f;
+	return (struct vec2 *)vec2_subtract((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_cross(struct vec a, struct vec b)
+struct vec2 *psvec2_subtract_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f)
 {
-	struct vec result;
-	pvector3_cross(&a, &b, &result);
-	return result;
+	return (struct vec2 *)vec2_subtract_f((mfloat_t *)result, (mfloat_t *)vec20, f);
 }
 
-float pvector3_length_squared(struct vec *a)
+struct vec2 *psvec2_multiply(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
 {
-	return a->x * a->x + a->y * a->y + a->z * a->z;
+	return (struct vec2 *)vec2_multiply((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
 }
 
-MATHC_EXTERN_INLINE float vector3_length_squared(struct vec a)
+struct vec2 *psvec2_multiply_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f)
 {
-	return pvector3_length_squared(&a);
+	return (struct vec2 *)vec2_multiply_f((mfloat_t *)result, (mfloat_t *)vec20, f);
 }
 
-float pvector3_length(struct vec *a)
+struct vec2 *psvec2_multiply_mat2(struct vec2 *result, struct vec2 *vec20, struct mat2 *mat20)
 {
-	return sqrtf(a->x * a->x + a->y * a->y + a->z * a->z);
+	return (struct vec2 *)vec2_multiply_mat2((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)mat20);
 }
 
-MATHC_EXTERN_INLINE float vector3_length(struct vec a)
+struct vec2 *psvec2_divide(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
 {
-	return pvector3_length(&a);
+	return (struct vec2 *)vec2_divide((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
 }
 
-void pvector3_normalize(struct vec *a, struct vec *result)
+struct vec2 *psvec2_divide_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f)
 {
-	float length = sqrtf(a->x * a->x + a->y * a->y + a->z * a->z);
-	if (length > FLT_EPSILON) {
-		length = 1.0f / length;
-		result->x = a->x * length;
-		result->y = a->y * length;
-		result->z = a->z * length;
-	} else {
-		result->x = 0.0f;
-		result->y = 0.0f;
-		result->z = 0.0f;
-	}
-	result->w = 1.0f;
+	return (struct vec2 *)vec2_divide_f((mfloat_t *)result, (mfloat_t *)vec20, f);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_normalize(struct vec a)
+struct vec2 *psvec2_snap(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
 {
-	struct vec result;
-	pvector3_normalize(&a, &result);
-	return result;
+	return (struct vec2 *)vec2_snap((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
 }
 
-void pvector3_slide(struct vec *a, struct vec *normal, struct vec *result)
+struct vec2 *psvec2_snap_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f)
 {
-	float d = pvector3_dot(a, normal);
-	result->x = a->x - normal->x * d;
-	result->y = a->y - normal->y * d;
-	result->y = a->z - normal->z * d;
-	result->w = 1.0f;
+	return (struct vec2 *)vec2_snap_f((mfloat_t *)result, (mfloat_t *)vec20, f);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_slide(struct vec a, struct vec normal)
+struct vec2 *psvec2_negative(struct vec2 *result, struct vec2 *vec20)
 {
-	struct vec result;
-	pvector3_slide(&a, &normal, &result);
-	return result;
+	return (struct vec2 *)vec2_negative((mfloat_t *)result, (mfloat_t *)vec20);
 }
 
-void pvector3_reflect(struct vec *a, struct vec *normal, struct vec *result)
+struct vec2 *psvec2_abs(struct vec2 *result, struct vec2 *vec20)
 {
-	float d = 2.0f * pvector3_dot(a, normal);
-	result->x = a->x - normal->x * d;
-	result->y = a->y - normal->y * d;
-	result->z = a->z - normal->z * d;
-	result->w = 1.0f;
+	return (struct vec2 *)vec2_abs((mfloat_t *)result, (mfloat_t *)vec20);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_reflect(struct vec a, struct vec normal)
+struct vec2 *psvec2_floor(struct vec2 *result, struct vec2 *vec20)
 {
-	struct vec result;
-	pvector3_reflect(&a, &normal, &result);
-	return result;
+	return (struct vec2 *)vec2_floor((mfloat_t *)result, (mfloat_t *)vec20);
 }
 
-float pvector3_distance_to(struct vec *a, struct vec *b)
+struct vec2 *psvec2_ceil(struct vec2 *result, struct vec2 *vec20)
 {
-	return sqrtf((a->x - b->x) * (a->x - b->x) + (a->y - b->y) * (a->y - b->y) + (a->z - b->z) * (a->z - b->z));
+	return (struct vec2 *)vec2_ceil((mfloat_t *)result, (mfloat_t *)vec20);
 }
 
-MATHC_EXTERN_INLINE float vector3_distance_to(struct vec a, struct vec b)
+struct vec2 *psvec2_round(struct vec2 *result, struct vec2 *vec20)
 {
-	return pvector3_distance_to(&a, &b);
+	return (struct vec2 *)vec2_round((mfloat_t *)result, (mfloat_t *)vec20);
 }
 
-float pvector3_distance_squared_to(struct vec *a, struct vec *b)
+struct vec2 *psvec2_max(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
 {
-	return (a->x - b->x) * (a->x - b->x) + (a->y - b->y) * (a->y - b->y) + (a->z - b->z) * (a->z - b->z);
+	return (struct vec2 *)vec2_max((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
 }
 
-MATHC_EXTERN_INLINE float vector3_distance_squared_to(struct vec a, struct vec b)
+struct vec2 *psvec2_min(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
 {
-	return pvector3_distance_squared_to(&a, &b);
+	return (struct vec2 *)vec2_min((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
 }
 
-void pvector3_linear_interpolation(struct vec *a, struct vec *b, float p, struct vec *result)
+struct vec2 *psvec2_clamp(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, struct vec2 *vec22)
 {
-	result->x = a->x + (b->x - a->x) * p;
-	result->y = a->y + (b->y - a->y) * p;
-	result->z = a->z + (b->z - a->z) * p;
-	result->w = 1.0f;
+	return (struct vec2 *)vec2_clamp((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21, (mfloat_t *)vec22);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_linear_interpolation(struct vec a, struct vec b, float p)
+struct vec2 *psvec2_normalize(struct vec2 *result, struct vec2 *vec20)
 {
-	struct vec result;
-	pvector3_linear_interpolation(&a, &b, p, &result);
-	return result;
+	return (struct vec2 *)vec2_normalize((mfloat_t *)result, (mfloat_t *)vec20);
 }
 
-void pvector3_bezier3(struct vec *a, struct vec *b, struct vec *c, float p, struct vec *result)
+mfloat_t psvec2_dot(struct vec2 *vec20, struct vec2 *vec21)
 {
-	struct vec tmp_a;
-	struct vec tmp_b;
-	pvector3_linear_interpolation(a, b, p, &tmp_a);
-	pvector3_linear_interpolation(b, c, p, &tmp_b);
-	pvector3_linear_interpolation(&tmp_a, &tmp_b, p, result);
+	return vec2_dot((mfloat_t *)vec20, (mfloat_t *)vec21);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_bezier3(struct vec a, struct vec b, struct vec c, float p)
+struct vec2 *psvec2_project(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
 {
-	struct vec result;
-	pvector3_bezier3(&a, &b, &c, p, &result);
-	return result;
+	return (struct vec2 *)vec2_project((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
 }
 
-void pvector3_bezier4(struct vec *a, struct vec *b, struct vec *c, struct vec *d, float p, struct vec *result)
+struct vec2 *psvec2_slide(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
 {
-	struct vec tmp_a;
-	struct vec tmp_b;
-	struct vec tmp_c;
-	struct vec tmp_d;
-	struct vec tmp_e;
-	pvector3_linear_interpolation(a, b, p, &tmp_a);
-	pvector3_linear_interpolation(b, c, p, &tmp_b);
-	pvector3_linear_interpolation(c, d, p, &tmp_c);
-	pvector3_linear_interpolation(&tmp_a, &tmp_b, p, &tmp_d);
-	pvector3_linear_interpolation(&tmp_b, &tmp_c, p, &tmp_e);
-	pvector3_linear_interpolation(&tmp_d, &tmp_e, p, result);
+	return (struct vec2 *)vec2_slide((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
 }
 
-MATHC_EXTERN_INLINE struct vec vector3_bezier4(struct vec a, struct vec b, struct vec c, struct vec d, float p)
+struct vec2 *psvec2_reflect(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
 {
-	struct vec result;
-	pvector3_bezier4(&a, &b, &c, &d, p, &result);
-	return result;
+	return (struct vec2 *)vec2_reflect((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
 }
 
-/* Quaternion */
-void to_pquaternion(float x, float y, float z, float w, struct vec *result)
+struct vec2 *psvec2_tangent(struct vec2 *result, struct vec2 *vec20)
 {
-	result->x = x;
-	result->y = y;
-	result->z = z;
-	result->w = w;
+	return (struct vec2 *)vec2_tangent((mfloat_t *)result, (mfloat_t *)vec20);
 }
 
-struct vec to_quaternion(float x, float y, float z, float w)
+struct vec2 *psvec2_rotate(struct vec2 *result, struct vec2 *vec20, mfloat_t f)
 {
-	struct vec result;
-	to_pquaternion(x, y, z, w, &result);
-	return result;
+	return (struct vec2 *)vec2_rotate((mfloat_t *)result, (mfloat_t *)vec20, f);
 }
 
-void pquaternion_zero(struct vec *result)
+struct vec2 *psvec2_lerp(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, mfloat_t f)
 {
-	result->x = 0.0f;
-	result->y = 0.0f;
-	result->z = 0.0f;
-	result->w = 0.0f;
+	return (struct vec2 *)vec2_lerp((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21, f);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_zero(void)
+struct vec2 *psvec2_bezier3(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, struct vec2 *vec22, mfloat_t f)
 {
-	struct vec result;
-	pquaternion_zero(&result);
-	return result;
+	return (struct vec2 *)vec2_bezier3((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21, (mfloat_t *)vec22, f);
 }
 
-void pquaternion_null(struct vec *result)
+struct vec2 *psvec2_bezier4(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, struct vec2 *vec22, struct vec2 *vec23, mfloat_t f)
 {
-	result->x = 0.0f;
-	result->y = 0.0f;
-	result->z = 0.0f;
-	result->w = 1.0f;
+	return (struct vec2 *)vec2_bezier4((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21, (mfloat_t *)vec22, (mfloat_t *)vec23, f);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_null(void)
+mfloat_t psvec2_angle(struct vec2 *vec20)
 {
-	struct vec result;
-	pquaternion_null(&result);
-	return result;
+	return vec2_angle((mfloat_t *)vec20);
 }
 
-bool pquaternion_is_zero(struct vec *a)
+mfloat_t psvec2_length(struct vec2 *vec20)
 {
-	bool is_zero = false;
-	if (fabs(a->x) < FLT_EPSILON && fabs(a->y) < FLT_EPSILON && fabs(a->z) < FLT_EPSILON && fabs(a->w) < FLT_EPSILON) {
-		is_zero = true;
-	}
-	return is_zero;
+	return vec2_length((mfloat_t *)vec20);
 }
 
-MATHC_EXTERN_INLINE bool quaternion_is_zero(struct vec a)
+mfloat_t psvec2_length_squared(struct vec2 *vec20)
 {
-	return pquaternion_is_zero(&a);
+	return vec2_length_squared((mfloat_t *)vec20);
 }
 
-bool pquaternion_is_near_zero(struct vec *a, float epsilon)
+mfloat_t psvec2_distance(struct vec2 *vec20, struct vec2 *vec21)
 {
-	bool is_near_zero = false;
-	if (fabs(a->x) < epsilon && fabs(a->y) < epsilon && fabs(a->z) < epsilon && fabs(a->w) < epsilon) {
-		is_near_zero = true;
-	}
-	return is_near_zero;
+	return vec2_distance((mfloat_t *)vec20, (mfloat_t *)vec21);
 }
 
-MATHC_EXTERN_INLINE bool quaternion_is_near_zero(struct vec a, float epsilon)
+mfloat_t psvec2_distance_squared(struct vec2 *vec20, struct vec2 *vec21)
 {
-	return pquaternion_is_near_zero(&a, epsilon);
+	return vec2_distance_squared((mfloat_t *)vec20, (mfloat_t *)vec21);
 }
 
-bool pquaternion_is_equal(struct vec *a, struct vec *b, float epsilon)
+bool psvec3_is_zero(struct vec3 *vec30)
 {
-	bool is_equal = false;
-	if (fabs(a->x - b->x) < epsilon && fabs(a->y - b->y) < FLT_EPSILON && fabs(a->z - b->z) < FLT_EPSILON) {
-		is_equal = true;
-	}
-	return is_equal;
+	return vec3_is_zero((mfloat_t *)vec30);
 }
 
-MATHC_EXTERN_INLINE bool quaternion_is_equal(struct vec a, struct vec b, float epsilon)
+bool psvec3_is_equal(struct vec3 *vec30, struct vec3 *vec31)
 {
-	return pquaternion_is_equal(&a, &b, epsilon);
+	return vec3_is_equal((mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-void pquaternion_add(struct vec *a, struct vec *b, struct vec *result)
+struct vec3 *psvec3(struct vec3 *result, mfloat_t x, mfloat_t y, mfloat_t z)
 {
-	result->x = a->x + b->x;
-	result->y = a->y + b->y;
-	result->z = a->z + b->z;
-	result->w = a->w + b->w;
+	return (struct vec3 *)vec3((mfloat_t *)result, x, y, z);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_add(struct vec a, struct vec b)
+struct vec3 *psvec3_assign(struct vec3 *result, struct vec3 *vec30)
 {
-	struct vec result;
-	pquaternion_add(&a, &b, &result);
-	return result;
+	return (struct vec3 *)vec3_assign((mfloat_t *)result, (mfloat_t *)vec30);
 }
 
-void pquaternion_subtract(struct vec *a, struct vec *b, struct vec *result)
+#if defined(MATHC_USE_INT)
+struct vec3 *psvec3_assign_vec3i(struct vec3 *result, struct vec3i *vec3i0)
 {
-	result->x = a->x - b->x;
-	result->y = a->y - b->y;
-	result->y = a->z - b->z;
-	result->w = a->w - b->w;
+	return (struct vec3 *)vec3_assign_vec3i((mfloat_t *)result, (mint_t *)vec3i0);
 }
+#endif
 
-MATHC_EXTERN_INLINE struct vec quaternion_subtract(struct vec a, struct vec b)
+struct vec3 *psvec3_zero(struct vec3 *result)
 {
-	struct vec result;
-	pquaternion_subtract(&a, &b, &result);
-	return result;
+	return (struct vec3 *)vec3_zero((mfloat_t *)result);
 }
 
-void pquaternion_scale(struct vec *a, float scale, struct vec *result)
+struct vec3 *psvec3_one(struct vec3 *result)
 {
-	result->x = a->x * scale;
-	result->y = a->y * scale;
-	result->z = a->z * scale;
-	result->w = a->w * scale;
+	return (struct vec3 *)vec3_one((mfloat_t *)result);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_scale(struct vec a, float scale)
+struct vec3 *psvec3_sign(struct vec3 *result, struct vec3 *vec30)
 {
-	struct vec result;
-	pquaternion_scale(&a, scale, &result);
-	return result;
+	return (struct vec3 *)vec3_sign((mfloat_t *)result, (mfloat_t *)vec30);
 }
 
-void pquaternion_multiply(struct vec *a, struct vec *b, struct vec *result)
+struct vec3 *psvec3_add(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
 {
-	result->x = a->w * b->x + a->x * b->w + a->y * b->z - a->z * b->y;
-	result->y = a->w * b->y + a->y * b->w + a->z * b->x - a->x * b->z;
-	result->z = a->w * b->z + a->z * b->w + a->x * b->y - a->y * b->x;
-	result->w = a->w * b->w - a->x * b->x - a->y * b->y - a->z * b->z;
+	return (struct vec3 *)vec3_add((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_multiply(struct vec a, struct vec b)
+struct vec3 *psvec3_add_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f)
 {
-	struct vec result;
-	pquaternion_multiply(&a, &b, &result);
-	return result;
+	return (struct vec3 *)vec3_add_f((mfloat_t *)result, (mfloat_t *)vec30, f);
 }
 
-void pquaternion_divide(struct vec *a, struct vec *b, struct vec *result)
+struct vec3 *psvec3_subtract(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
 {
-	float x = a->x;
-	float y = a->y;
-	float z = a->z;
-	float w = a->w;
-	float length_squared = 1.0f / (b->x * b->x + b->y * b->y + b->z * b->z + b->w * b->w);
-	float normalized_x = -b->x * length_squared;
-	float normalized_y = -b->y * length_squared;
-	float normalized_z = -b->z * length_squared;
-	float normalized_w = b->w * length_squared;
-	result->x = x * normalized_w + normalized_x * w + (y * normalized_z - z * normalized_y);
-	result->y = y * normalized_w + normalized_y * w + (z * normalized_x - x * normalized_z);
-	result->z = z * normalized_w + normalized_z * w + (x * normalized_y - y * normalized_x);
-	result->w = w * normalized_w - (x * normalized_x + y * normalized_y + z * normalized_z);
+	return (struct vec3 *)vec3_subtract((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_divide(struct vec a, struct vec b)
+struct vec3 *psvec3_subtract_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f)
 {
-	struct vec result;
-	pquaternion_divide(&a, &b, &result);
-	return result;
+	return (struct vec3 *)vec3_subtract_f((mfloat_t *)result, (mfloat_t *)vec30, f);
 }
 
-void pquaternion_negative(struct vec *a, struct vec *result)
+struct vec3 *psvec3_multiply(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
 {
-	result->x = -a->x;
-	result->y = -a->y;
-	result->z = -a->z;
-	result->w = -a->w;
+	return (struct vec3 *)vec3_multiply((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_negative(struct vec a)
+struct vec3 *psvec3_multiply_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f)
 {
-	struct vec result;
-	pquaternion_negative(&a, &result);
-	return result;
+	return (struct vec3 *)vec3_multiply_f((mfloat_t *)result, (mfloat_t *)vec30, f);
 }
 
-void pquaternion_conjugate(struct vec *a, struct vec *result)
+struct vec3 *psvec3_multiply_mat3(struct vec3 *result, struct vec3 *vec30, struct mat3 *mat30)
 {
-	result->x = -a->x;
-	result->y = -a->y;
-	result->z = -a->z;
-	result->w = a->w;
+	return (struct vec3 *)vec3_multiply_mat3((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)mat30);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_conjugate(struct vec a)
+struct vec3 *psvec3_divide(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
 {
-	struct vec result;
-	pquaternion_conjugate(&a, &result);
-	return result;
+	return (struct vec3 *)vec3_divide((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-void pquaternion_inverse(struct vec *a, struct vec *result)
+struct vec3 *psvec3_divide_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f)
 {
-	float length = a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w;
-	if (fabs(length) > FLT_EPSILON) {
-		length = 1.0f / length;
-	} else {
-		length = 0.0f;
-	}
-	result->x = -a->x * length;
-	result->y = -a->y * length;
-	result->z = -a->z * length;
-	result->w = a->w * length;
+	return (struct vec3 *)vec3_divide_f((mfloat_t *)result, (mfloat_t *)vec30, f);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_inverse(struct vec a)
+struct vec3 *psvec3_snap(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
 {
-	struct vec result;
-	pquaternion_inverse(&a, &result);
-	return result;
+	return (struct vec3 *)vec3_snap((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-void pquaternion_abs(struct vec *a, struct vec *result)
+struct vec3 *psvec3_snap_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f)
 {
-	result->x = fabsf(a->x);
-	result->y = fabsf(a->y);
-	result->z = fabsf(a->z);
-	result->w = fabsf(a->w);
+	return (struct vec3 *)vec3_snap_f((mfloat_t *)result, (mfloat_t *)vec30, f);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_abs(struct vec a)
+struct vec3 *psvec3_negative(struct vec3 *result, struct vec3 *vec30)
 {
-	struct vec result;
-	pquaternion_abs(&a, &result);
-	return result;
+	return (struct vec3 *)vec3_negative((mfloat_t *)result, (mfloat_t *)vec30);
 }
 
-void pquaternion_floor(struct vec *a, struct vec *result)
+struct vec3 *psvec3_abs(struct vec3 *result, struct vec3 *vec30)
 {
-	result->x = floorf(a->x);
-	result->y = floorf(a->y);
-	result->z = floorf(a->z);
-	result->w = floorf(a->w);
+	return (struct vec3 *)vec3_abs((mfloat_t *)result, (mfloat_t *)vec30);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_floor(struct vec a)
+struct vec3 *psvec3_floor(struct vec3 *result, struct vec3 *vec30)
 {
-	struct vec result;
-	pquaternion_floor(&a, &result);
-	return result;
+	return (struct vec3 *)vec3_floor((mfloat_t *)result, (mfloat_t *)vec30);
 }
 
-void pquaternion_ceil(struct vec *a, struct vec *result)
+struct vec3 *psvec3_ceil(struct vec3 *result, struct vec3 *vec30)
 {
-	result->x = ceilf(a->x);
-	result->y = ceilf(a->y);
-	result->z = ceilf(a->z);
-	result->w = ceilf(a->w);
+	return (struct vec3 *)vec3_ceil((mfloat_t *)result, (mfloat_t *)vec30);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_ceil(struct vec a)
+struct vec3 *psvec3_round(struct vec3 *result, struct vec3 *vec30)
 {
-	struct vec result;
-	pquaternion_ceil(&a, &result);
-	return result;
+	return (struct vec3 *)vec3_round((mfloat_t *)result, (mfloat_t *)vec30);
 }
 
-void pquaternion_round(struct vec *a, struct vec *result)
+struct vec3 *psvec3_max(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
 {
-	result->x = roundf(a->x);
-	result->y = roundf(a->y);
-	result->z = roundf(a->z);
-	result->w = roundf(a->w);
+	return (struct vec3 *)vec3_max((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_round(struct vec a)
+struct vec3 *psvec3_min(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
 {
-	struct vec result;
-	pquaternion_round(&a, &result);
-	return result;
+	return (struct vec3 *)vec3_min((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-void pquaternion_max(struct vec *a, struct vec *b, struct vec *result)
+struct vec3 *psvec3_clamp(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32)
 {
-	result->x = fmaxf(a->x, b->x);
-	result->y = fmaxf(a->y, b->y);
-	result->z = fmaxf(a->z, b->z);
-	result->w = fmaxf(a->w, b->w);
+	return (struct vec3 *)vec3_clamp((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31, (mfloat_t *)vec32);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_max(struct vec a, struct vec b)
+struct vec3 *psvec3_cross(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
 {
-	struct vec result;
-	pquaternion_max(&a, &b, &result);
-	return result;
+	return (struct vec3 *)vec3_cross((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-void pquaternion_min(struct vec *a, struct vec *b, struct vec *result)
+struct vec3 *psvec3_normalize(struct vec3 *result, struct vec3 *vec30)
 {
-	result->x = fminf(a->x, b->x);
-	result->y = fminf(a->y, b->y);
-	result->z = fminf(a->z, b->z);
-	result->w = fminf(a->w, b->w);
+	return (struct vec3 *)vec3_normalize((mfloat_t *)result, (mfloat_t *)vec30);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_min(struct vec a, struct vec b)
+mfloat_t psvec3_dot(struct vec3 *vec30, struct vec3 *vec31)
 {
-	struct vec result;
-	pquaternion_min(&a, &b, &result);
-	return result;
+	return vec3_dot((mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-float pquaternion_dot(struct vec *a, struct vec *b)
+struct vec3 *psvec3_project(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
 {
-	return a->x * b->x + a->y * b->y + a->z * b->z + a->w * b->w;
+	return (struct vec3 *)vec3_project((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-MATHC_EXTERN_INLINE float quaternion_dot(struct vec a, struct vec b)
+struct vec3 *psvec3_slide(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
 {
-	return pquaternion_dot(&a, &b);
+	return (struct vec3 *)vec3_slide((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-float pquaternion_angle(struct vec *a, struct vec *b)
+struct vec3 *psvec3_reflect(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
 {
-	float s = sqrtf(pquaternion_length_squared(a) * pquaternion_length_squared(b));
-	if (fabs(s) > FLT_EPSILON) {
-		s = 1.0f / s;
-	} else {
-		s = 0.0f;
-	}
-	return acosf(pquaternion_dot(a, b) * s);
+	return (struct vec3 *)vec3_reflect((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-MATHC_EXTERN_INLINE float quaternion_angle(struct vec a, struct vec b)
+struct vec3 *psvec3_lerp(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, mfloat_t f)
 {
-	return pquaternion_angle(&a, &b);
+	return (struct vec3 *)vec3_lerp((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31, f);
 }
 
-float pquaternion_length_squared(struct vec *a)
+struct vec3 *psvec3_bezier3(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32, mfloat_t f)
 {
-	return a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w;
+	return (struct vec3 *)vec3_bezier3((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31, (mfloat_t *)vec32, f);
 }
 
-MATHC_EXTERN_INLINE float quaternion_length_squared(struct vec a)
+struct vec3 *psvec3_bezier4(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32, struct vec3 *vec33, mfloat_t f)
 {
-	return pquaternion_length_squared(&a);
+	return (struct vec3 *)vec3_bezier4((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31, (mfloat_t *)vec32, (mfloat_t *)vec33, f);
 }
 
-float pquaternion_length(struct vec *a)
+mfloat_t psvec3_length(struct vec3 *vec30)
 {
-	return sqrtf(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
+	return vec3_length((mfloat_t *)vec30);
 }
 
-MATHC_EXTERN_INLINE float quaternion_length(struct vec a)
+mfloat_t psvec3_length_squared(struct vec3 *vec30)
 {
-	return pquaternion_length(&a);
+	return vec3_length_squared((mfloat_t *)vec30);
 }
 
-void pquaternion_normalize(struct vec *a, struct vec *result)
+mfloat_t psvec3_distance(struct vec3 *vec30, struct vec3 *vec31)
 {
-	float length = 1.0f / sqrtf(a->x * a->x + a->y * a->y + a->z * a->z + a->w * a->w);
-	if (length > FLT_EPSILON) {
-		result->x = a->x * length;
-		result->y = a->y * length;
-		result->z = a->z * length;
-		result->w = a->w * length;
-	} else {
-		result->x = 0.0f;
-		result->y = 0.0f;
-		result->z = 0.0f;
-		result->w = 1.0f;
-	}
+	return vec3_distance((mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_normalize(struct vec a)
+mfloat_t psvec3_distance_squared(struct vec3 *vec30, struct vec3 *vec31)
 {
-	struct vec result;
-	pquaternion_normalize(&a, &result);
-	return result;
+	return vec3_distance_squared((mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-void pquaternion_power(struct vec *a, float exponent, struct vec *result)
+bool psvec4_is_zero(struct vec4 *vec40)
 {
-	if (fabsf(a->w) < 0.9999f) {
-		float alpha = acosf(a->w);
-		float new_alpha = alpha * exponent;
-		float s = sinf(new_alpha) / sinf(alpha);
-		result->x = result->x * s;
-		result->y = result->y * s;
-		result->z = result->z * s;
-		result->w = cosf(new_alpha);
-	} else {
-		result->x = a->x;
-		result->y = a->y;
-		result->z = a->z;
-		result->w = a->w;
-	}
+	return vec4_is_zero((mfloat_t *)vec40);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_power(struct vec a, float exponent)
+bool psvec4_is_equal(struct vec4 *vec40, struct vec4 *vec41)
 {
-	struct vec result;
-	pquaternion_power(&a, exponent, &result);
-	return result;
+	return vec4_is_equal((mfloat_t *)vec40, (mfloat_t *)vec41);
 }
 
-void pquaternion_from_axis_angle(struct vec *a, float angle, struct vec *result)
+struct vec4 *psvec4(struct vec4 *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
 {
-	float half = angle * 0.5f;
-	float s = sinf(half);
-	result->x = a->x * s;
-	result->y = a->y * s;
-	result->z = a->z * s;
-	result->w = cosf(half);
-	pquaternion_normalize(result, result);
+	return (struct vec4 *)vec4((mfloat_t *)result, x, y, z, w);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_from_axis_angle(struct vec a, float angle)
+struct vec4 *psvec4_assign(struct vec4 *result, struct vec4 *vec40)
 {
-	struct vec result;
-	pquaternion_from_axis_angle(&a, angle, &result);
-	return result;
+	return (struct vec4 *)vec4_assign((mfloat_t *)result, (mfloat_t *)vec40);
 }
 
-void pquaternion_to_axis_angle(struct vec *a, struct vec *result)
+#if defined(MATHC_USE_INT)
+struct vec4 *psvec4_assign_vec4i(struct vec4 *result, struct vec4i *vec4i0)
 {
-	float sa;
-	struct vec tmp;
-	pquaternion_normalize(a, &tmp);
-	sa = sqrtf(1.0f - tmp.w * tmp.w);
-	if (fabsf(sa) <= FLT_EPSILON) {
-		sa = 1.0f;
-	}
-	result->x = tmp.x / sa;
-	result->y = tmp.y / sa;
-	result->z = tmp.z / sa;
-	result->w = acosf(tmp.w) * 2.0f;
-}
-
-MATHC_EXTERN_INLINE struct vec quaternion_to_axis_angle(struct vec a)
-{
-	struct vec result;
-	pquaternion_to_axis_angle(&a, &result);
-	return result;
-}
-
-void pquaternion_from_2_vectors(struct vec *a, struct vec *b, struct vec *result){
-	struct vec cross;
-	float dot = pvector3_dot(a, b);
-	float a_length_sq = pvector3_length_squared(a);
-	float b_length_sq = pvector3_length_squared(a);
-	pvector3_cross(a, b, &cross);
-	to_pquaternion(cross.x, cross.y, cross.z, dot + sqrtf(a_length_sq * b_length_sq), result);
-	pquaternion_normalize(result, result);
-}
-
-MATHC_EXTERN_INLINE struct vec quaternion_from_2_vectors(struct vec a, struct vec b)
-{
-	struct vec result;
-	pquaternion_from_2_vectors(&a, &b, &result);
-	return result;
-}
-
-void pquaternion_rotation_matrix(struct mat *m, struct vec *result)
-{
-	float sr;
-	float half;
-	float scale = m->m11 + m->m22 + m->m33;
-	if (scale > 0.0f) {
-		sr = sqrtf(scale + 1.0f);
-		result->w = sr * 0.5f;
-		sr = 0.5f / sr;
-		result->x = (m->m23 - m->m32) * sr;
-		result->y = (m->m31 - m->m13) * sr;
-		result->z = (m->m12 - m->m21) * sr;
-	} else if ((m->m11 >= m->m22) && (m->m11 >= m->m33)) {
-		sr = sqrtf(1.0f + m->m11 - m->m22 - m->m33);
-		half = 0.5f / sr;
-		result->x = 0.5f * sr;
-		result->y = (m->m12 + m->m21) * half;
-		result->z = (m->m13 + m->m31) * half;
-		result->w = (m->m23 - m->m32) * half;
-	} else if (m->m22 > m->m33) {
-		sr = sqrtf(1.0f + m->m22 - m->m11 - m->m33);
-		half = 0.5f / sr;
-		result->x = (m->m21 + m->m12) * half;
-		result->y = 0.5f * sr;
-		result->z = (m->m32 + m->m23) * half;
-		result->w = (m->m31 - m->m13) * half;
-	} else {
-		sr = sqrtf(1.0f + m->m33 - m->m11 - m->m22);
-		half = 0.5f / sr;
-		result->x = (m->m31 + m->m13) * half;
-		result->y = (m->m32 + m->m23) * half;
-		result->z = 0.5f * sr;
-		result->w = (m->m12 - m->m21) * half;
-	}
+	return (struct vec4 *)vec4_assign_vec4i((mfloat_t *)result, (mint_t *)vec4i0);
 }
+#endif
 
-MATHC_EXTERN_INLINE struct vec quaternion_rotation_matrix(struct mat m)
+struct vec4 *psvec4_zero(struct vec4 *result)
 {
-	struct vec result;
-	pquaternion_rotation_matrix(&m, &result);
-	return result;
+	return (struct vec4 *)vec4_zero((mfloat_t *)result);
 }
 
-void pquaternion_yaw_pitch_roll(float yaw, float pitch, float roll, struct vec *result)
+struct vec4 *psvec4_one(struct vec4 *result)
 {
-	float half_roll = roll * 0.5f;
-	float half_pitch = pitch * 0.5f;
-	float half_yaw = yaw * 0.5f;
-	float sin_roll = sinf(half_roll);
-	float cos_roll = cosf(half_roll);
-	float sin_pitch = sinf(half_pitch);
-	float cos_pitch = cosf(half_pitch);
-	float sin_yaw = sinf(half_yaw);
-	float cos_yaw = cosf(half_yaw);
-	result->x = cos_yaw * sin_pitch * cos_roll + sin_yaw * cos_pitch * sin_roll;
-	result->y = sin_yaw * cos_pitch * cos_roll - cos_yaw * sin_pitch * sin_roll;
-	result->z = cos_yaw * cos_pitch * sin_roll - sin_yaw * sin_pitch * cos_roll;
-	result->w = cos_yaw * cos_pitch * cos_roll + sin_yaw * sin_pitch * sin_roll;
+	return (struct vec4 *)vec4_one((mfloat_t *)result);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_yaw_pitch_roll(float yaw, float pitch, float roll)
+struct vec4 *psvec4_sign(struct vec4 *result, struct vec4 *vec40)
 {
-	struct vec result;
-	pquaternion_yaw_pitch_roll(yaw, pitch, roll, &result);
-	return result;
+	return (struct vec4 *)vec4_sign((mfloat_t *)result, (mfloat_t *)vec40);
 }
 
-void pquaternion_linear_interpolation(struct vec *a, struct vec *b, float p, struct vec *result)
+struct vec4 *psvec4_add(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41)
 {
-	result->x = a->x + (b->x - a->x) * p;
-	result->y = a->y + (b->y - a->y) * p;
-	result->z = a->z + (b->z - a->z) * p;
-	result->w = a->w + (b->w - a->w) * p;
+	return (struct vec4 *)vec4_add((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_linear_interpolation(struct vec a, struct vec b, float p)
+struct vec4 *psvec4_add_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f)
 {
-	struct vec result;
-	pquaternion_linear_interpolation(&a, &b, p, &result);
-	return result;
+	return (struct vec4 *)vec4_add_f((mfloat_t *)result, (mfloat_t *)vec40, f);
 }
 
-void pquaternion_spherical_linear_interpolation(struct vec *a, struct vec *b, float p, struct vec *result)
+struct vec4 *psvec4_subtract(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41)
 {
-	struct vec tmp_a = *a;
-	struct vec tmp_b = *b;
-	float cos_theta = pquaternion_dot(a, b);
-	float p0;
-	float p1;
-	/* Take shortest arc */
-	if (cos_theta < 0.0f) {
-		pquaternion_negative(&tmp_b, &tmp_b);
-		cos_theta = -cos_theta;
-	}
-	/* Check if quaternions are close */
-	if (cos_theta > 0.95f) {
-		/* Use linear interpolation */
-		p0 = 1.0f - p;
-		p1 = p;
-	} else {
-		float theta = acosf(cos_theta);
-		float sin_theta = sinf(theta);
-		p0 = sinf((1.f - p) * theta) / sin_theta;
-		p1 = sinf(p * theta) / sin_theta;
-	}
-	result->x = tmp_a.x * p0 + tmp_b.x * p1;
-	result->y = tmp_a.y * p0 + tmp_b.y * p1;
-	result->z = tmp_a.z * p0 + tmp_b.z * p1;
-	result->w = tmp_a.w * p0 + tmp_b.w * p1;
+	return (struct vec4 *)vec4_subtract((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41);
 }
 
-MATHC_EXTERN_INLINE struct vec quaternion_spherical_linear_interpolation(struct vec a, struct vec b, float p)
+struct vec4 *psvec4_subtract_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f)
 {
-	struct vec result;
-	pquaternion_spherical_linear_interpolation(&a, &b, p, &result);
-	return result;
+	return (struct vec4 *)vec4_subtract_f((mfloat_t *)result, (mfloat_t *)vec40, f);
 }
 
-/* Matrix */
-void pmatrix_zero(struct mat *result)
-{
-	result->m11 = 0.0f;
-	result->m12 = 0.0f;
-	result->m13 = 0.0f;
-	result->m14 = 0.0f;
-	result->m21 = 0.0f;
-	result->m22 = 0.0f;
-	result->m23 = 0.0f;
-	result->m24 = 0.0f;
-	result->m31 = 0.0f;
-	result->m32 = 0.0f;
-	result->m33 = 0.0f;
-	result->m34 = 0.0f;
-	result->m41 = 0.0f;
-	result->m42 = 0.0f;
-	result->m43 = 0.0f;
-	result->m44 = 0.0f;
-}
-
-MATHC_EXTERN_INLINE struct mat matrix_zero(void)
-{
-	struct mat result;
-	pmatrix_zero(&result);
-	return result;
-}
-
-void pmatrix_identity(struct mat *result)
-{
-	result->m11 = 1.0f;
-	result->m12 = 0.0f;
-	result->m13 = 0.0f;
-	result->m14 = 0.0f;
-	result->m21 = 0.0f;
-	result->m22 = 1.0f;
-	result->m23 = 0.0f;
-	result->m24 = 0.0f;
-	result->m31 = 0.0f;
-	result->m32 = 0.0f;
-	result->m33 = 1.0f;
-	result->m34 = 0.0f;
-	result->m41 = 0.0f;
-	result->m42 = 0.0f;
-	result->m43 = 0.0f;
-	result->m44 = 1.0f;
-}
-
-MATHC_EXTERN_INLINE struct mat matrix_identity(void)
-{
-	struct mat result;
-	pmatrix_identity(&result);
-	return result;
-}
-
-void pmatrix_transpose(struct mat *m, struct mat *result)
-{
-	result->m11 = m->m11;
-	result->m21 = m->m12;
-	result->m31 = m->m13;
-	result->m41 = m->m14;
-	result->m12 = m->m21;
-	result->m22 = m->m22;
-	result->m32 = m->m23;
-	result->m42 = m->m24;
-	result->m13 = m->m31;
-	result->m23 = m->m32;
-	result->m33 = m->m33;
-	result->m43 = m->m34;
-	result->m14 = m->m41;
-	result->m24 = m->m42;
-	result->m34 = m->m43;
-	result->m44 = m->m44;
-}
-
-struct mat matrix_transpose(struct mat m)
-{
-	struct mat result;
-	pmatrix_transpose(&m, &result);
-	return result;
-}
-
-void pmatrix_inverse(struct mat *m, struct mat *result)
-{
-	struct mat inv;
-	float det;
-	inv.m11 = m->m22 * m->m33 * m->m44 -
-		m->m22 * m->m43 * m->m34 -
-		m->m23 * m->m32 * m->m44 +
-		m->m23 * m->m42 * m->m34 +
-		m->m24 * m->m32 * m->m43 -
-		m->m24 * m->m42 * m->m33;
-	inv.m12 = -m->m12 * m->m33 * m->m44 +
-		m->m12 * m->m43 * m->m34 +
-		m->m13 * m->m32 * m->m44 -
-		m->m13 * m->m42 * m->m34 -
-		m->m14 * m->m32 * m->m43 +
-		m->m14 * m->m42 * m->m33;
-	inv.m13 = m->m12 * m->m23 * m->m44 -
-		m->m12 * m->m43 * m->m24 -
-		m->m13 * m->m22 * m->m44 +
-		m->m13 * m->m42 * m->m24 +
-		m->m14 * m->m22 * m->m43 -
-		m->m14 * m->m42 * m->m23;
-	inv.m14 = -m->m12 * m->m23 * m->m34 +
-		m->m12 * m->m33 * m->m24 +
-		m->m13 * m->m22 * m->m34 -
-		m->m13 * m->m32 * m->m24 -
-		m->m14 * m->m22 * m->m33 +
-		m->m14 * m->m32 * m->m23;
-	inv.m21 = -m->m21 * m->m33 * m->m44 +
-		m->m21 * m->m43 * m->m34 +
-		m->m23 * m->m31 * m->m44 -
-		m->m23 * m->m41 * m->m34 -
-		m->m24 * m->m31 * m->m43 +
-		m->m24 * m->m41 * m->m33;
-	inv.m22 = m->m11 * m->m33 * m->m44 -
-		m->m11 * m->m43 * m->m34 -
-		m->m13 * m->m31 * m->m44 +
-		m->m13 * m->m41 * m->m34 +
-		m->m14 * m->m31 * m->m43 -
-		m->m14 * m->m41 * m->m33;
-	inv.m23 = -m->m11 * m->m23 * m->m44 +
-		m->m11 * m->m43 * m->m24 +
-		m->m13 * m->m21 * m->m44 -
-		m->m13 * m->m41 * m->m24 -
-		m->m14 * m->m21 * m->m43 +
-		m->m14 * m->m41 * m->m23;
-	inv.m24 = m->m11 * m->m23 * m->m34 -
-		m->m11 * m->m33 * m->m24 -
-		m->m13 * m->m21 * m->m34 +
-		m->m13 * m->m31 * m->m24 +
-		m->m14 * m->m21 * m->m33 -
-		m->m14 * m->m31 * m->m23;
-	inv.m31 = m->m21 * m->m32 * m->m44 -
-		m->m21 * m->m42 * m->m34 -
-		m->m22 * m->m31 * m->m44 +
-		m->m22 * m->m41 * m->m34 +
-		m->m24 * m->m31 * m->m42 -
-		m->m24 * m->m41 * m->m32;
-	inv.m32 = -m->m11 * m->m32 * m->m44 +
-		m->m11 * m->m42 * m->m34 +
-		m->m12 * m->m31 * m->m44 -
-		m->m12 * m->m41 * m->m34 -
-		m->m14 * m->m31 * m->m42 +
-		m->m14 * m->m41 * m->m32;
-	inv.m33 = m->m11 * m->m22 * m->m44 -
-		m->m11 * m->m42 * m->m24 -
-		m->m12 * m->m21 * m->m44 +
-		m->m12 * m->m41 * m->m24 +
-		m->m14 * m->m21 * m->m42 -
-		m->m14 * m->m41 * m->m22;
-	inv.m34 = -m->m11 * m->m22 * m->m34 +
-		m->m11 * m->m32 * m->m24 +
-		m->m12 * m->m21 * m->m34 -
-		m->m12 * m->m31 * m->m24 -
-		m->m14 * m->m21 * m->m32 +
-		m->m14 * m->m31 * m->m22;
-	inv.m41 = -m->m21 * m->m32 * m->m43 +
-		m->m21 * m->m42 * m->m33 +
-		m->m22 * m->m31 * m->m43 -
-		m->m22 * m->m41 * m->m33 -
-		m->m23 * m->m31 * m->m42 +
-		m->m23 * m->m41 * m->m32;
-	inv.m42 = m->m11 * m->m32 * m->m43 -
-		m->m11 * m->m42 * m->m33 -
-		m->m12 * m->m31 * m->m43 +
-		m->m12 * m->m41 * m->m33 +
-		m->m13 * m->m31 * m->m42 -
-		m->m13 * m->m41 * m->m32;
-	inv.m43 = -m->m11 * m->m22 * m->m43 +
-		m->m11 * m->m42 * m->m23 +
-		m->m12 * m->m21 * m->m43 -
-		m->m12 * m->m41 * m->m23 -
-		m->m13 * m->m21 * m->m42 +
-		m->m13 * m->m41 * m->m22;
-	inv.m44 = m->m11 * m->m22 * m->m33 -
-		m->m11 * m->m32 * m->m23 -
-		m->m12 * m->m21 * m->m33 +
-		m->m12 * m->m31 * m->m23 +
-		m->m13 * m->m21 * m->m32 -
-		m->m13 * m->m31 * m->m22;
-	det = m->m11 * inv.m11 + m->m21 * inv.m12 + m->m31 * inv.m13 + m->m41 * inv.m14;
-	/* Matrix can not be inverted if det == 0 */
-	if (det != 0) {
-		det = 1.0f / det;
-	}
-	result->m11 = inv.m11 * det;
-	result->m21 = inv.m21 * det;
-	result->m31 = inv.m31 * det;
-	result->m41 = inv.m41 * det;
-	result->m12 = inv.m12 * det;
-	result->m22 = inv.m22 * det;
-	result->m32 = inv.m32 * det;
-	result->m42 = inv.m42 * det;
-	result->m13 = inv.m13 * det;
-	result->m23 = inv.m23 * det;
-	result->m33 = inv.m33 * det;
-	result->m43 = inv.m43 * det;
-	result->m14 = inv.m14 * det;
-	result->m24 = inv.m24 * det;
-	result->m34 = inv.m34 * det;
-	result->m44 = inv.m44 * det;
+struct vec4 *psvec4_multiply(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41)
+{
+	return (struct vec4 *)vec4_multiply((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41);
 }
 
-struct mat matrix_inverse(struct mat m)
+struct vec4 *psvec4_multiply_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f)
 {
-	struct mat result;
-	pmatrix_inverse(&m, &result);
-	return result;
+	return (struct vec4 *)vec4_multiply_f((mfloat_t *)result, (mfloat_t *)vec40, f);
 }
 
-#include <stdio.h>
+struct vec4 *psvec4_multiply_mat4(struct vec4 *result, struct vec4 *vec40, struct mat4 *mat40)
+{
+	return (struct vec4 *)vec4_multiply_mat4((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)mat40);
+}
 
-void pmatrix_ortho(float l, float r, float b, float t, float n, float f, struct mat *result)
+struct vec4 *psvec4_divide(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41)
 {
-	pmatrix_identity(result);
-	result->m11 = 2.0f / (r - l);
-	result->m22 = 2.0f / (t - b);
-	result->m33 = -2.0f / (f - n);
-	result->m14 = -((r + l) / (r - l));
-	result->m24 = -((t + b) / (t - b));
-	result->m34 = -((f + n) / (f - n));
+	return (struct vec4 *)vec4_divide((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_ortho(float l, float r, float b, float t, float n, float f)
+struct vec4 *psvec4_divide_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f)
 {
-	struct mat result;
-	pmatrix_ortho(l, r, b, t, n, f, &result);
-	return result;
+	return (struct vec4 *)vec4_divide_f((mfloat_t *)result, (mfloat_t *)vec40, f);
 }
 
-void pmatrix_perspective(float fov_y, float aspect, float n, float f, struct mat *result)
+struct vec4 *psvec4_snap(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41)
 {
-	const float tan_half_fov_y = 1.0f / tanf(fov_y * 0.5f);
-	pmatrix_zero(result);
-	result->m11 = 1.0f / aspect * tan_half_fov_y;
-	result->m22 = 1.0f / tan_half_fov_y;
-	result->m33 = f / (n - f);
-	result->m43 = -1.0f;
-	result->m34 = -(f * n) / (f - n);
+	return (struct vec4 *)vec4_snap((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_perspective(float fov_y, float aspect, float n, float f)
+struct vec4 *psvec4_snap_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f)
 {
-	struct mat result;
-	pmatrix_perspective(fov_y, aspect, n, f, &result);
-	return result;
+	return (struct vec4 *)vec4_snap_f((mfloat_t *)result, (mfloat_t *)vec40, f);
 }
 
-void pmatrix_perspective_fov(float fov, float w, float h, float n, float f, struct mat *result)
+struct vec4 *psvec4_negative(struct vec4 *result, struct vec4 *vec40)
 {
-	const float h2 = cosf(fov * 0.5f) / sinf(fov * 0.5f);
-	const float w2 = h2 * h / w;
-	pmatrix_zero(result);
-	result->m11 = w2;
-	result->m22 = h2;
-	result->m33 = f / (n - f);
-	result->m43 = -1.0f;
-	result->m34 = -(f * n) / (f - n);
+	return (struct vec4 *)vec4_negative((mfloat_t *)result, (mfloat_t *)vec40);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_perspective_fov(float fov, float w, float h, float n, float f)
+struct vec4 *psvec4_abs(struct vec4 *result, struct vec4 *vec40)
 {
-	struct mat result;
-	pmatrix_perspective_fov(fov, w, h, n, f, &result);
-	return result;
+	return (struct vec4 *)vec4_abs((mfloat_t *)result, (mfloat_t *)vec40);
 }
 
-void pmatrix_perspective_infinite(float fov_y, float aspect, float n, struct mat *result)
+struct vec4 *psvec4_floor(struct vec4 *result, struct vec4 *vec40)
 {
-	const float range = tanf(fov_y * 0.5f) * n;
-	const float left = -range * aspect;
-	const float right = range * aspect;
-	const float top = range;
-	const float bottom = -range;
-	pmatrix_zero(result);
-	result->m11 = 2.0f * n / (right - left);
-	result->m22 = 2.0f * n / (top - bottom);
-	result->m33 = -1.0f;
-	result->m43 = -1.0f;
-	result->m34 = -2.0f * n;
+	return (struct vec4 *)vec4_floor((mfloat_t *)result, (mfloat_t *)vec40);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_perspective_infinite(float fov_y, float aspect, float n)
+struct vec4 *psvec4_ceil(struct vec4 *result, struct vec4 *vec40)
 {
-	struct mat result;
-	pmatrix_perspective_infinite(fov_y, aspect, n, &result);
-	return result;
+	return (struct vec4 *)vec4_ceil((mfloat_t *)result, (mfloat_t *)vec40);
 }
 
-void pmatrix_rotation_x(float angle, struct mat *result)
+struct vec4 *psvec4_round(struct vec4 *result, struct vec4 *vec40)
 {
-	pmatrix_identity(result);
-	float c = cosf(angle);
-	float s = sinf(angle);
-	result->m22 = c;
-	result->m23 = -s;
-	result->m32 = s;
-	result->m33 = c;
+	return (struct vec4 *)vec4_round((mfloat_t *)result, (mfloat_t *)vec40);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_rotation_x(float angle)
+struct vec4 *psvec4_max(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41)
 {
-	struct mat result;
-	pmatrix_rotation_x(angle, &result);
-	return result;
+	return (struct vec4 *)vec4_max((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41);
 }
 
-void pmatrix_rotation_y(float angle, struct mat *result)
+struct vec4 *psvec4_min(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41)
 {
-	pmatrix_identity(result);
-	float c = cosf(angle);
-	float s = sinf(angle);
-	result->m11 = c;
-	result->m13 = s;
-	result->m31 = -s;
-	result->m33 = c;
+	return (struct vec4 *)vec4_min((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_rotation_y(float angle)
+struct vec4 *psvec4_clamp(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41, struct vec4 *vec42)
 {
-	struct mat result;
-	pmatrix_rotation_y(angle, &result);
-	return result;
+	return (struct vec4 *)vec4_clamp((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41, (mfloat_t *)vec42);
 }
 
-void pmatrix_rotation_z(float angle, struct mat *result)
+struct vec4 *psvec4_normalize(struct vec4 *result, struct vec4 *vec40)
 {
-	pmatrix_identity(result);
-	float c = cosf(angle);
-	float s = sinf(angle);
-	result->m11 = c;
-	result->m12 = -s;
-	result->m21 = s;
-	result->m22 = c;
+	return (struct vec4 *)vec4_normalize((mfloat_t *)result, (mfloat_t *)vec40);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_rotation_z(float angle)
+struct vec4 *psvec4_lerp(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41, mfloat_t f)
 {
-	struct mat result;
-	pmatrix_rotation_z(angle, &result);
-	return result;
+	return (struct vec4 *)vec4_lerp((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41, f);
 }
 
-void pmatrix_rotation_axis(struct vec *a, float angle, struct mat *result)
+bool psquat_is_zero(struct quat *quat0)
 {
-	pmatrix_identity(result);
-	float c = cosf(angle);
-	float s = sinf(angle);
-	float one_c = 1.0f - c;
-	float x = a->x;
-	float y = a->y;
-	float z = a->z;
-	float xx = x * x;
-	float xy = x * y;
-	float xz = x * z;
-	float yy = y * y;
-	float yz = y * z;
-	float zz = z * z;
-	float l = xx + yy + zz;
-	float sqrt_l = sqrtf(l);
-	pmatrix_identity(result);
-	result->m11 = (xx + (yy + zz) * c) / l;
-	result->m12 = (xy * one_c - a->z * sqrt_l * s) / l;
-	result->m13 = (xz * one_c + a->y * sqrt_l * s) / l;
-	result->m21 = (xy * one_c + a->z * sqrt_l * s) / l;
-	result->m22 = (yy + (xx + zz) * c) / l;
-	result->m23 = (yz * one_c - a->x * sqrt_l * s) / l;
-	result->m31 = (xz * one_c - a->y * sqrt_l * s) / l;
-	result->m32 = (yz * one_c + a->x * sqrt_l * s) / l;
-	result->m33 = (zz + (xx + yy) * c) / l;
+	return quat_is_zero((mfloat_t *)quat0);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_rotation_axis(struct vec a, float angle)
+bool psquat_is_equal(struct quat *quat0, struct quat *quat1)
 {
-	struct mat result;
-	pmatrix_rotation_axis(&a, angle, &result);
-	return result;
+	return quat_is_equal((mfloat_t *)quat0, (mfloat_t *)quat1);
 }
 
-void pmatrix_rotation_quaternion(struct vec *q, struct mat *result)
+struct quat *psquat(struct quat *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
 {
-	pmatrix_identity(result);
-	float xx = q->x * q->x;
-	float yy = q->y * q->y;
-	float zz = q->z * q->z;
-	float xy = q->x * q->y;
-	float zw = q->z * q->w;
-	float xz = q->z * q->x;
-	float yw = q->y * q->w;
-	float yz = q->y * q->z;
-	float xw = q->x * q->w;
-	result->m11 = 1.0f - 2.0f * (yy - zz);
-	result->m12 = 2.0f * (xy - zw);
-	result->m13 = 2.0f * (xz + yw);
-	result->m21 = 2.0f * (xy + zw);
-	result->m22 = 1.0f - 2.0f * (xx - zz);
-	result->m23 = 2.0f * (yz - xw);
-	result->m31 = 2.0f * (xz - yw);
-	result->m32 = 2.0f * (yz + xw);
-	result->m33 = 1.0f - 2.0f * (xx - yy);
+	return (struct quat *)quat((mfloat_t *)result, x, y, z, w);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_rotation_quaternion(struct vec q)
+struct quat *psquat_assign(struct quat *result, struct quat *quat0)
 {
-	struct mat result;
-	pmatrix_rotation_quaternion(&q, &result);
-	return result;
+	return (struct quat *)quat_assign((mfloat_t *)result, (mfloat_t *)quat0);
 }
 
-void pmatrix_look_at_up(struct vec *position, struct vec *target, struct vec *up_axis, struct mat *result)
+struct quat *psquat_zero(struct quat *result)
 {
-	struct vec forward_axis;
-	struct vec side_axis;
-	pvector3_subtract(target, position, &forward_axis);
-	pvector3_normalize(&forward_axis, &forward_axis);
-	pvector3_cross(&forward_axis, up_axis, &side_axis);
-	pvector3_normalize(&side_axis, &side_axis);
-	pvector3_cross(&side_axis, &forward_axis, up_axis);
-	pmatrix_identity(result);
-	result->m11 = side_axis.x;
-	result->m12 = side_axis.y;
-	result->m13 = side_axis.z;
-	result->m21 = up_axis->x;
-	result->m22 = up_axis->y;
-	result->m23 = up_axis->z;
-	result->m31 = -forward_axis.x;
-	result->m32 = -forward_axis.y;
-	result->m33 = -forward_axis.z;
-	result->m14 = -pvector3_dot(&side_axis, position);
-	result->m24 = -pvector3_dot(up_axis, position);
-	result->m34 = pvector3_dot(&forward_axis, position);
-}
-
-MATHC_EXTERN_INLINE struct mat matrix_look_at_up(struct vec pos, struct vec target, struct vec up_axis)
-{
-	struct mat result;
-	pmatrix_look_at_up(&pos, &target, &up_axis, &result);
-	return result;
-}
-
-void pmatrix_look_at(struct vec *position, struct vec *target, struct mat *result)
-{
-	struct vec forward_axis;
-	struct vec side_axis;
-	struct vec up_axis;
-	pvector3_subtract(target, position, &forward_axis);
-	pvector3_normalize(&forward_axis, &forward_axis);
-	if (fabsf(forward_axis.x) < FLT_EPSILON && fabsf(forward_axis.z) < FLT_EPSILON) {
-		if (forward_axis.y > 0.0f) {
-			to_pvector3(0.0f, 0.0f, -1.0f, &up_axis);
-		} else {
-			to_pvector3(0.0f, 0.0f, 1.0f, &up_axis);
-		}
-	} else {
-		to_pvector3(0.0f, 1.0f, 0.0f, &up_axis);
-	}
-	pvector3_cross(&forward_axis, &up_axis, &side_axis);
-	pvector3_normalize(&side_axis, &side_axis);
-	pvector3_cross(&side_axis, &forward_axis, &up_axis);
-	pmatrix_identity(result);
-	result->m11 = side_axis.x;
-	result->m12 = side_axis.y;
-	result->m13 = side_axis.z;
-	result->m21 = up_axis.x;
-	result->m22 = up_axis.y;
-	result->m23 = up_axis.z;
-	result->m31 = -forward_axis.x;
-	result->m32 = -forward_axis.y;
-	result->m33 = -forward_axis.z;
-	result->m14 = -pvector3_dot(&side_axis, position);
-	result->m24 = -pvector3_dot(&up_axis, position);
-	result->m34 = pvector3_dot(&forward_axis, position);
+	return (struct quat *)quat_zero((mfloat_t *)result);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_look_at(struct vec pos, struct vec target)
+struct quat *psquat_null(struct quat *result)
 {
-	struct mat result;
-	pmatrix_look_at(&pos, &target, &result);
-	return result;
+	return (struct quat *)quat_null((mfloat_t *)result);
 }
 
-void pmatrix_scale(struct vec *v, struct mat *result)
+struct quat *psquat_multiply(struct quat *result, struct quat *quat0, struct quat *quat1)
 {
-	pmatrix_identity(result);
-	result->m11 = v->x;
-	result->m22 = v->y;
-	result->m33 = v->z;
+	return (struct quat *)quat_multiply((mfloat_t *)result, (mfloat_t *)quat0, (mfloat_t *)quat1);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_scale(struct vec v)
+struct quat *psquat_multiply_f(struct quat *result, struct quat *quat0, mfloat_t f)
 {
-	struct mat result;
-	pmatrix_scale(&v, &result);
-	return result;
+	return (struct quat *)quat_multiply_f((mfloat_t *)result, (mfloat_t *)quat0, f);
 }
 
-void pmatrix_get_scale(struct mat *m, struct vec *result)
+struct quat *psquat_divide(struct quat *result, struct quat *quat0, struct quat *quat1)
 {
-	result->x = m->m11;
-	result->y = m->m22;
-	result->z = m->m33;
+	return (struct quat *)quat_divide((mfloat_t *)result, (mfloat_t *)quat0, (mfloat_t *)quat1);
 }
 
-MATHC_EXTERN_INLINE struct vec matrix_get_scale(struct mat m)
+struct quat *psquat_divide_f(struct quat *result, struct quat *quat0, mfloat_t f)
 {
-	struct vec result;
-	pmatrix_get_scale(&m, &result);
-	return result;
+	return (struct quat *)quat_divide_f((mfloat_t *)result, (mfloat_t *)quat0, f);
 }
 
-void pmatrix_translation(struct vec *v, struct mat *result)
+struct quat *psquat_negative(struct quat *result, struct quat *quat0)
 {
-	pmatrix_identity(result);
-	result->m14 = v->x;
-	result->m24 = v->y;
-	result->m34 = v->z;
+	return (struct quat *)quat_negative((mfloat_t *)result, (mfloat_t *)quat0);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_translation(struct vec v)
+struct quat *psquat_conjugate(struct quat *result, struct quat *quat0)
 {
-	struct mat result;
-	pmatrix_translation(&v, &result);
-	return result;
+	return (struct quat *)quat_conjugate((mfloat_t *)result, (mfloat_t *)quat0);
 }
 
-void pmatrix_get_translation(struct mat *m, struct vec *result)
+struct quat *psquat_inverse(struct quat *result, struct quat *quat0)
 {
-	result->x = m->m14;
-	result->y = m->m24;
-	result->z = m->m34;
-	result->w = 1.0f;
+	return (struct quat *)quat_inverse((mfloat_t *)result, (mfloat_t *)quat0);
 }
 
-MATHC_EXTERN_INLINE struct vec matrix_get_translation(struct mat m)
+struct quat *psquat_normalize(struct quat *result, struct quat *quat0)
 {
-	struct vec result;
-	pmatrix_get_translation(&m, &result);
-	return result;
+	return (struct quat *)quat_normalize((mfloat_t *)result, (mfloat_t *)quat0);
 }
 
-void pmatrix_negative(struct mat *m, struct mat *result)
+mfloat_t psquat_dot(struct quat *quat0, struct quat *quat1)
 {
-	result->m11 = -m->m11;
-	result->m12 = -m->m12;
-	result->m13 = -m->m13;
-	result->m14 = -m->m14;
-	result->m21 = -m->m21;
-	result->m22 = -m->m22;
-	result->m23 = -m->m23;
-	result->m24 = -m->m24;
-	result->m31 = -m->m31;
-	result->m32 = -m->m32;
-	result->m33 = -m->m33;
-	result->m34 = -m->m34;
-	result->m41 = -m->m41;
-	result->m42 = -m->m42;
-	result->m43 = -m->m43;
-	result->m44 = -m->m44;
+	return quat_dot((mfloat_t *)quat0, (mfloat_t *)quat1);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_negative(struct mat m)
+struct quat *psquat_power(struct quat *result, struct quat *quat0, mfloat_t exponent)
 {
-	struct mat result;
-	pmatrix_negative(&m, &result);
-	return result;
+	return (struct quat *)quat_power((mfloat_t *)result, (mfloat_t *)quat0, exponent);
 }
 
-void pmatrix_multiply(struct mat *m, float s, struct mat *result)
+struct quat *psquat_from_axis_angle(struct quat *result, struct vec3 *vec30, mfloat_t angle)
 {
-	result->m11 = m->m11 * s;
-	result->m12 = m->m12 * s;
-	result->m13 = m->m13 * s;
-	result->m14 = m->m14 * s;
-	result->m21 = m->m21 * s;
-	result->m22 = m->m22 * s;
-	result->m23 = m->m23 * s;
-	result->m24 = m->m24 * s;
-	result->m31 = m->m31 * s;
-	result->m32 = m->m32 * s;
-	result->m33 = m->m33 * s;
-	result->m34 = m->m34 * s;
-	result->m41 = m->m41 * s;
-	result->m42 = m->m42 * s;
-	result->m43 = m->m43 * s;
-	result->m44 = m->m44 * s;
+	return (struct quat *)quat_from_axis_angle((mfloat_t *)result, (mfloat_t *)vec30, angle);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_multiply(struct mat m, float s)
+struct quat *psquat_from_vec3(struct quat *result, struct vec3 *vec30, struct vec3 *vec31)
 {
-	struct mat result;
-	pmatrix_multiply(&m, s, &result);
-	return result;
+	return (struct quat *)quat_from_vec3((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
 }
 
-void pmatrix_multiply_matrix(struct mat *a, struct mat *b, struct mat *result)
+struct quat *psquat_from_mat4(struct quat *result, struct mat4 *mat40)
 {
-	result->m11 = a->m11 * b->m11 + a->m12 * b->m21 + a->m13 * b->m31 + a->m14 * b->m41;
-	result->m12 = a->m11 * b->m12 + a->m12 * b->m22 + a->m13 * b->m32 + a->m14 * b->m42;
-	result->m13 = a->m11 * b->m13 + a->m12 * b->m23 + a->m13 * b->m33 + a->m14 * b->m43;
-	result->m14 = a->m11 * b->m14 + a->m12 * b->m24 + a->m13 * b->m34 + a->m14 * b->m44;
-	result->m21 = a->m21 * b->m11 + a->m22 * b->m21 + a->m23 * b->m31 + a->m24 * b->m41;
-	result->m22 = a->m21 * b->m12 + a->m22 * b->m22 + a->m23 * b->m32 + a->m24 * b->m42;
-	result->m23 = a->m21 * b->m13 + a->m22 * b->m23 + a->m23 * b->m33 + a->m24 * b->m43;
-	result->m24 = a->m21 * b->m14 + a->m22 * b->m24 + a->m23 * b->m34 + a->m24 * b->m44;
-	result->m31 = a->m31 * b->m11 + a->m32 * b->m21 + a->m33 * b->m31 + a->m34 * b->m41;
-	result->m32 = a->m31 * b->m12 + a->m32 * b->m22 + a->m33 * b->m32 + a->m34 * b->m42;
-	result->m33 = a->m31 * b->m13 + a->m32 * b->m23 + a->m33 * b->m33 + a->m34 * b->m43;
-	result->m34 = a->m31 * b->m14 + a->m32 * b->m24 + a->m33 * b->m34 + a->m34 * b->m44;
-	result->m41 = a->m41 * b->m11 + a->m42 * b->m21 + a->m43 * b->m31 + a->m44 * b->m41;
-	result->m42 = a->m41 * b->m12 + a->m42 * b->m22 + a->m43 * b->m32 + a->m44 * b->m42;
-	result->m43 = a->m41 * b->m13 + a->m42 * b->m23 + a->m43 * b->m33 + a->m44 * b->m43;
-	result->m44 = a->m41 * b->m14 + a->m42 * b->m24 + a->m43 * b->m34 + a->m44 * b->m44;
+	return (struct quat *)quat_from_mat4((mfloat_t *)result, (mfloat_t *)mat40);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_multiply_matrix(struct mat a, struct mat b)
+struct quat *psquat_lerp(struct quat *result, struct quat *quat0, struct quat *quat1, mfloat_t f)
 {
-	struct mat result;
-	pmatrix_multiply_matrix(&a, &b, &result);
-	return result;
+	return (struct quat *)quat_lerp((mfloat_t *)result, (mfloat_t *)quat0, (mfloat_t *)quat1, f);
 }
 
-void pmatrix_linear_interpolation(struct mat *a, struct mat *b, float p, struct mat *result)
+struct quat *psquat_slerp(struct quat *result, struct quat *quat0, struct quat *quat1, mfloat_t f)
 {
-	result->m11 = a->m11 + (b->m11 - a->m11) * p;
-	result->m12 = a->m12 + (b->m12 - a->m12) * p;
-	result->m13 = a->m13 + (b->m13 - a->m13) * p;
-	result->m14 = a->m14 + (b->m14 - a->m14) * p;
-	result->m21 = a->m21 + (b->m21 - a->m21) * p;
-	result->m22 = a->m22 + (b->m22 - a->m22) * p;
-	result->m23 = a->m23 + (b->m23 - a->m23) * p;
-	result->m24 = a->m24 + (b->m24 - a->m24) * p;
-	result->m31 = a->m31 + (b->m31 - a->m31) * p;
-	result->m32 = a->m32 + (b->m32 - a->m32) * p;
-	result->m33 = a->m33 + (b->m33 - a->m33) * p;
-	result->m34 = a->m34 + (b->m34 - a->m34) * p;
-	result->m41 = a->m41 + (b->m41 - a->m41) * p;
-	result->m42 = a->m42 + (b->m42 - a->m42) * p;
-	result->m43 = a->m43 + (b->m43 - a->m43) * p;
-	result->m44 = a->m44 + (b->m44 - a->m44) * p;
+	return (struct quat *)quat_slerp((mfloat_t *)result, (mfloat_t *)quat0, (mfloat_t *)quat1, f);
 }
 
-MATHC_EXTERN_INLINE struct mat matrix_linear_interpolation(struct mat a, struct mat b, float p)
+mfloat_t psquat_length(struct quat *quat0)
 {
-	struct mat result;
-	pmatrix_linear_interpolation(&a, &b, p, &result);
-	return result;
+	return quat_length((mfloat_t *)quat0);
 }
 
-void pmatrix_multiply_f4(struct mat *m, float *result)
+mfloat_t psquat_length_squared(struct quat *quat0)
 {
-	float v0 = result[0];
-	float v1 = result[1];
-	float v2 = result[2];
-	float v3 = result[3];
-	result[0] = (m->m11 * v0) + (m->m12 * v1) + (m->m13 * v2) + (m->m14 * v3);
-	result[1] = (m->m21 * v0) + (m->m22 * v1) + (m->m23 * v2) + (m->m24 * v3);
-	result[2] = (m->m31 * v0) + (m->m32 * v1) + (m->m33 * v2) + (m->m34 * v3);
-	result[3] = (m->m41 * v0) + (m->m42 * v1) + (m->m43 * v2) + (m->m44 * v3);
+	return quat_length_squared((mfloat_t *)quat0);
 }
 
-MATHC_EXTERN_INLINE void matrix_multiply_f4(struct mat m, float *result)
+mfloat_t psquat_angle(struct quat *quat0, struct quat *quat1)
 {
-	pmatrix_multiply_f4(&m, result);
+	return quat_angle((mfloat_t *)quat0, (mfloat_t *)quat1);
 }
 
-void pmatrix_multiply_f3(struct mat *m, float *result)
+struct mat2 *psmat2(struct mat2 *result, mfloat_t m11, mfloat_t m12, mfloat_t m21, mfloat_t m22)
 {
-	float v0 = result[0];
-	float v1 = result[1];
-	float v2 = result[2];
-	float v3 = 1.0f;
-	result[0] = (m->m11 * v0) + (m->m12 * v1) + (m->m13 * v2) + (m->m14 * v3);
-	result[1] = (m->m21 * v0) + (m->m22 * v1) + (m->m23 * v2) + (m->m24 * v3);
-	result[2] = (m->m31 * v0) + (m->m32 * v1) + (m->m33 * v2) + (m->m34 * v3);
-	result[3] = (m->m41 * v0) + (m->m42 * v1) + (m->m43 * v2) + (m->m44 * v3);
+	return (struct mat2 *)mat2((mfloat_t *)result, m11, m12, m21, m22);
 }
 
-MATHC_EXTERN_INLINE void matrix_multiply_f3(struct mat m, float *result)
+struct mat2 *psmat2_zero(struct mat2 *result)
 {
-	pmatrix_multiply_f3(&m, result);
+	return (struct mat2 *)mat2_zero((mfloat_t *)result);
 }
 
-void pmatrix_to_array(struct mat *m, float *result)
+struct mat2 *psmat2_identity(struct mat2 *result)
 {
-	result[0] = m->m11;
-	result[1] = m->m21;
-	result[2] = m->m31;
-	result[3] = m->m41;
-	result[4] = m->m12;
-	result[5] = m->m22;
-	result[6] = m->m32;
-	result[7] = m->m42;
-	result[8] = m->m13;
-	result[9] = m->m23;
-	result[10] = m->m33;
-	result[11] = m->m43;
-	result[12] = m->m14;
-	result[13] = m->m24;
-	result[14] = m->m34;
-	result[15] = m->m44;
+	return (struct mat2 *)mat2_identity((mfloat_t *)result);
 }
 
-MATHC_EXTERN_INLINE void matrix_to_array(struct mat m, float *result)
+mfloat_t psmat2_determinant(struct mat2 *mat20)
 {
-	pmatrix_to_array(&m, result);
+	return mat2_determinant((mfloat_t *)mat20);
 }
 
-/* Intersection */
-bool pvector2_in_circle(struct vec *v, struct vec *circle_position, float radius)
+struct mat2 *psmat2_assign(struct mat2 *result, struct mat2 *mat20)
 {
-	bool result = false;
-	float distance = pvector2_distance_to(v, circle_position);
-	if (distance <= radius) {
-		result = true;
-	}
-	return result;
+	return (struct mat2 *)mat2_assign((mfloat_t *)result, (mfloat_t *)mat20);
 }
 
-MATHC_EXTERN_INLINE bool vector2_in_circle(struct vec v, struct vec circle_position, float radius)
+struct mat2 *psmat2_negative(struct mat2 *result, struct mat2 *mat20)
 {
-	return pvector2_in_circle(&v, &circle_position, radius);
+	return (struct mat2 *)mat2_negative((mfloat_t *)result, (mfloat_t *)mat20);
 }
 
-static bool psame_side(struct vec *p1, struct vec *p2, struct vec *a, struct vec *b)
+struct mat2 *psmat2_transpose(struct mat2 *result, struct mat2 *mat20)
 {
-	bool result = false;
-	struct vec b_minus_a = {0, 0, 0, 0};
-	struct vec p1_minus_a = {0, 0, 0, 0};
-	struct vec p2_minus_a = {0, 0, 0, 0};
-	struct vec cross_p1;
-	struct vec cross_p2;
-	pvector2_subtract(b, a, &b_minus_a);
-	pvector2_subtract(p1, a, &p1_minus_a);
-	pvector2_subtract(p2, a, &p2_minus_a);
-	pvector3_cross(&b_minus_a, &p1_minus_a, &cross_p1);
-	pvector3_cross(&b_minus_a, &p2_minus_a, &cross_p2);
-	if (pvector3_dot(&cross_p1, &cross_p2) >= 0.0f) {
-		result = true;
-	}
-	return result;
+	return (struct mat2 *)mat2_transpose((mfloat_t *)result, (mfloat_t *)mat20);
 }
 
-bool pvector2_in_triangle(struct vec *v, struct vec *a, struct vec *b, struct vec *c)
+struct mat2 *psmat2_cofactor(struct mat2 *result, struct mat2 *mat20)
 {
-	bool result = false;
-	if (psame_side(v, a, b, c) && psame_side(v, b, a, c) && psame_side(v, c, a, b)) {
-		result = true;
-	}
-	return result;
+	return (struct mat2 *)mat2_cofactor((mfloat_t *)result, (mfloat_t *)mat20);
 }
 
-MATHC_EXTERN_INLINE bool vector2_in_triangle(struct vec v, struct vec a, struct vec b, struct vec c)
+struct mat2 *psmat2_adjugate(struct mat2 *result, struct mat2 *mat20)
 {
-	return pvector2_in_triangle(&v, &a, &b, &c);
+	return (struct mat2 *)mat2_adjugate((mfloat_t *)result, (mfloat_t *)mat20);
 }
 
-/* Easing functions */
-float quadratic_ease_in(float p)
+struct mat2 *psmat2_multiply(struct mat2 *result, struct mat2 *mat20, struct mat2 *mat21)
 {
-	return p * p;
+	return (struct mat2 *)mat2_multiply((mfloat_t *)result, (mfloat_t *)mat20, (mfloat_t *)mat21);
 }
 
-float quadratic_ease_out(float p)
+struct mat2 *psmat2_multiply_f(struct mat2 *result, struct mat2 *mat20, mfloat_t f)
 {
-	return -(p * (p - 2.0f));
+	return (struct mat2 *)mat2_multiply_f((mfloat_t *)result, (mfloat_t *)mat20, f);
 }
 
-float quadratic_ease_in_out(float p)
+struct mat2 *psmat2_inverse(struct mat2 *result, struct mat2 *mat20)
 {
-	float f = 0.0f;
-	if (p < 0.5f) {
-		f = 2.0f * p * p;
-	} else {
-		f = (-2.0f * p * p) + (4.0f * p) - 1.0f;
-	}
-	return f;
+	return (struct mat2 *)mat2_inverse((mfloat_t *)result, (mfloat_t *)mat20);
 }
 
-float cubic_ease_in(float p)
+struct mat2 *psmat2_scaling(struct mat2 *result, struct vec2 *vec20)
 {
-	return p * p * p;
+	return (struct mat2 *)mat2_scaling((mfloat_t *)result, (mfloat_t *)vec20);
 }
 
-float cubic_ease_out(float p)
+struct mat2 *psmat2_scale(struct mat2 *result, struct mat2 *mat20, struct vec2 *vec20)
 {
-	float f = (p - 1.0f);
-	return f * f * f + 1.0f;
+	return (struct mat2 *)mat2_scale((mfloat_t *)result, (mfloat_t *)mat20, (mfloat_t *)vec20);
 }
 
-float cubic_ease_in_out(float p)
+struct mat2 *psmat2_rotation_z(struct mat2 *result, mfloat_t f)
 {
-	float f = 0.0f;
-	if (p < 0.5f) {
-		f = 4.0f * p * p * p;
-	} else {
-		f = ((2.0f * p) - 2.0f);
-		f = 0.5f * f * f * f + 1.0f;
-	}
-	return f;
+	return (struct mat2 *)mat2_rotation_z((mfloat_t *)result, f);
 }
 
-float quartic_ease_in(float p)
+struct mat2 *psmat2_lerp(struct mat2 *result, struct mat2 *mat20, struct mat2 *mat21, mfloat_t f)
 {
-	return p * p * p * p;
+	return (struct mat2 *)mat2_lerp((mfloat_t *)result, (mfloat_t *)mat20, (mfloat_t *)mat21, f);
 }
 
-float quartic_ease_out(float p)
+struct mat3 *psmat3(struct mat3 *result, mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m31, mfloat_t m32, mfloat_t m33)
 {
-	float f = (p - 1.0f);
-	return f * f * f * (1.0f - p) + 1.0f;
+	return (struct mat3 *)mat3((mfloat_t *)result, m11, m12, m13, m21, m22, m23, m31, m32, m33);
 }
 
-float quartic_ease_in_out(float p)
+struct mat3 *psmat3_zero(struct mat3 *result)
 {
-	float f = 0.0f;
-	if (p < 0.5f) {
-		f = 8.0f * p * p * p * p;
-	} else {
-		f = (p - 1.0f);
-		f = -8.0f * f * f * f * f + 1.0f;
-	}
-	return f;
+	return (struct mat3 *)mat3_zero((mfloat_t *)result);
 }
 
-float quintic_ease_in(float p)
+struct mat3 *psmat3_identity(struct mat3 *result)
 {
-	return p * p * p * p * p;
+	return (struct mat3 *)mat3_identity((mfloat_t *)result);
 }
 
-float quintic_ease_out(float p)
+mfloat_t psmat3_determinant(struct mat3 *mat30)
 {
-	float f = (p - 1.0f);
-	return f * f * f * f * f + 1.0f;
+	return mat3_determinant((mfloat_t *)mat30);
 }
 
-float quintic_ease_in_out(float p)
+struct mat3 *psmat3_assign(struct mat3 *result, struct mat3 *mat30)
 {
-	float f = 0.0f;
-	if (p < 0.5f) {
-		f = 16.0f * p * p * p * p * p;
-	} else {
-		f = ((2.0f * p) - 2.0f);
-		f = 0.5f * f * f * f * f * f + 1.0f;
-	}
-	return f;
+	return (struct mat3 *)mat3_assign((mfloat_t *)result, (mfloat_t *)mat30);
 }
 
-float sine_ease_in(float p)
+struct mat3 *psmat3_negative(struct mat3 *result, struct mat3 *mat30)
 {
-	return sinf((p - 1.0f) * M_PIF_2) + 1.0f;
+	return (struct mat3 *)mat3_negative((mfloat_t *)result, (mfloat_t *)mat30);
 }
 
-float sine_ease_out(float p)
+struct mat3 *psmat3_transpose(struct mat3 *result, struct mat3 *mat30)
 {
-	return sinf(p * M_PIF_2);
+	return (struct mat3 *)mat3_transpose((mfloat_t *)result, (mfloat_t *)mat30);
 }
 
-float sine_ease_in_out(float p)
+struct mat3 *psmat3_cofactor(struct mat3 *result, struct mat3 *mat30)
 {
-	return 0.5f * (1.0f - cosf(p * M_PIF));
+	return (struct mat3 *)mat3_cofactor((mfloat_t *)result, (mfloat_t *)mat30);
 }
 
-float circular_ease_in(float p)
+struct mat3 *psmat3_multiply(struct mat3 *result, struct mat3 *mat30, struct mat3 *mat31)
 {
-	return 1.0f - sqrtf(1.0f - (p * p));
+	return (struct mat3 *)mat3_multiply((mfloat_t *)result, (mfloat_t *)mat30, (mfloat_t *)mat31);
 }
 
-float circular_ease_out(float p)
+struct mat3 *psmat3_multiply_f(struct mat3 *result, struct mat3 *mat30, mfloat_t f)
 {
-	return sqrtf((2.0f - p) * p);
+	return (struct mat3 *)mat3_multiply_f((mfloat_t *)result, (mfloat_t *)mat30, f);
 }
 
-float circular_ease_in_out(float p)
+struct mat3 *psmat3_inverse(struct mat3 *result, struct mat3 *mat30)
 {
-	float f = 0.0f;
-	if (p < 0.5f) {
-		f = 0.5f * (1.0f - sqrtf(1.0f - 4.0f * (p * p)));
-	} else {
-		f = 0.5f * (sqrtf(-((2.0f * p) - 3.0f) * ((2.0f * p) - 1.0f)) + 1.0f);
-	}
-	return f;
+	return (struct mat3 *)mat3_inverse((mfloat_t *)result, (mfloat_t *)mat30);
 }
 
-float exponential_ease_in(float p)
+struct mat3 *psmat3_scaling(struct mat3 *result, struct vec3 *vec30)
 {
-	float f = p;
-	if (p != 0.0f) {
-		f = powf(2.0f, 10.0f * (p - 1.0f));
-	}
-	return f;
+	return (struct mat3 *)mat3_scaling((mfloat_t *)result, (mfloat_t *)vec30);
 }
 
-float exponential_ease_out(float p)
+struct mat3 *psmat3_scale(struct mat3 *result, struct mat3 *mat30, struct vec3 *vec30)
 {
-	float f = p;
-	if (p != 1.0f) {
-		f = 1 - powf(2.0f, -10.0f * p);
-	}
-	return f;
+	return (struct mat3 *)mat3_scale((mfloat_t *)result, (mfloat_t *)mat30, (mfloat_t *)vec30);
 }
 
-float exponential_ease_in_out(float p)
+struct mat3 *psmat3_rotation_x(struct mat3 *result, mfloat_t f)
 {
-	float f = p;
-	if (p == 0.0f || p == 1.0f) {
-		f = p;
-	} else if (p < 0.5f) {
-		f = 0.5f * powf(2.0f, (20.0f * p) - 10.0f);
-	} else {
-		f = -0.5f * powf(2.0f, (-20.0f * p) + 10.0f) + 1.0f;
-	}
-	return f;
+	return (struct mat3 *)mat3_rotation_x((mfloat_t *)result, f);
 }
 
-float elastic_ease_in(float p)
+struct mat3 *psmat3_rotation_y(struct mat3 *result, mfloat_t f)
 {
-	return sinf(13.0f * M_PIF_2 * p) * powf(2.0f, 10.0f * (p - 1.0f));
+	return (struct mat3 *)mat3_rotation_y((mfloat_t *)result, f);
 }
 
-float elastic_ease_out(float p)
+struct mat3 *psmat3_rotation_z(struct mat3 *result, mfloat_t f)
 {
-	return sinf(-13.0f * M_PIF_2 * (p + 1.0f)) * powf(2.0f, -10.0f * p) + 1.0f;
+	return (struct mat3 *)mat3_rotation_z((mfloat_t *)result, f);
 }
 
-float elastic_ease_in_out(float p)
+struct mat3 *psmat3_rotation_axis(struct mat3 *result, struct vec3 *vec30, mfloat_t f)
 {
-	float f = 0.0f;
-	if (p < 0.5f) {
-		f = 0.5f * sinf(13.0f * M_PIF_2 * (2.0f * p)) * powf(2.0f, 10.0f * ((2.0f * p) - 1.0f));
-	} else {
-		f = 0.5f * (sinf(-13.0f * M_PIF_2 * ((2.0f * p - 1.0f) + 1.0f)) * powf(2.0f, -10.0f * (2.0f * p - 1.0f)) + 2.0f);
-	}
-	return f;
+	return (struct mat3 *)mat3_rotation_axis((mfloat_t *)result, (mfloat_t *)vec30, f);
 }
 
-float back_ease_in(float p)
+struct mat3 *psmat3_rotation_quat(struct mat3 *result, struct quat *quat0)
 {
-	return p * p * p - p * sinf(p * M_PIF);
+	return (struct mat3 *)mat3_rotation_quat((mfloat_t *)result, (mfloat_t *)quat0);
 }
 
-float back_ease_out(float p)
+struct mat3 *psmat3_lerp(struct mat3 *result, struct mat3 *mat30, struct mat3 *mat31, mfloat_t f)
 {
-	float f = (1.0f - p);
-	return 1.0f - (f * f * f - f * sinf(f * M_PIF));
+	return (struct mat3 *)mat3_lerp((mfloat_t *)result, (mfloat_t *)mat30, (mfloat_t *)mat31, f);
 }
 
-float back_ease_in_out(float p)
+struct mat4 *psmat4(struct mat4 *result, mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m14, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m24, mfloat_t m31, mfloat_t m32, mfloat_t m33, mfloat_t m34, mfloat_t m41, mfloat_t m42, mfloat_t m43, mfloat_t m44)
 {
-	float f = 0.0f;
-	if (p < 0.5f) {
-		f = 2.0f * p;
-		f = 0.5f * (f * f * f - f * sinf(f * M_PIF));
-	} else {
-		f = (1.0f - (2.0f * p - 1.0f));
-		f = 0.5f * (1.0f - (f * f * f - f * sinf(f * M_PIF))) + 0.5f;
-	}
-	return f;
+	return (struct mat4 *)mat4((mfloat_t *)result, m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44);
 }
 
-float bounce_ease_in(float p)
+struct mat4 *psmat4_zero(struct mat4 *result)
 {
-	return 1.0f - bounce_ease_out(1.0f - p);
+	return (struct mat4 *)mat4_zero((mfloat_t *)result);
 }
 
-float bounce_ease_out(float p)
+struct mat4 *psmat4_identity(struct mat4 *result)
 {
-	float f = 0.0f;
-	if (p < 4.0f / 11.0f) {
-		f = (121.0f * p * p) / 16.0f;
-	} else if (p < 8.0f / 11.0f) {
-		f = (363.0f / 40.0f * p * p) - (99.0f / 10.0f * p) + 17.0f / 5.0f;
-	} else if (p < 9.0f / 10.0f) {
-		f = (4356.0f / 361.0f * p * p) - (35442.0f / 1805.0f * p) + 16061 / 1805.0f;
-	} else {
-		f = (54.0f / 5.0f * p * p) - (513.0f / 25.0f * p) + 268.0f / 25.0f;
-	}
-	return f;
+	return (struct mat4 *)mat4_identity((mfloat_t *)result);
 }
 
-float bounce_ease_in_out(float p)
+mfloat_t psmat4_determinant(struct mat4 *mat40)
 {
-	float f = 0.0f;
-	if (p < 0.5f) {
-		f = 0.5f * bounce_ease_in(p * 2.0f);
-	} else {
-		f = 0.5f * bounce_ease_out(p * 2.0f - 1.0f) + 0.5f;
-	}
-	return f;
+	return mat4_determinant((mfloat_t *)mat40);
+}
+
+struct mat4 *psmat4_assign(struct mat4 *result, struct mat4 *mat40)
+{
+	return (struct mat4 *)mat4_assign((mfloat_t *)result, (mfloat_t *)mat40);
+}
+
+struct mat4 *psmat4_negative(struct mat4 *result, struct mat4 *mat40)
+{
+	return (struct mat4 *)mat4_negative((mfloat_t *)result, (mfloat_t *)mat40);
+}
+
+struct mat4 *psmat4_transpose(struct mat4 *result, struct mat4 *mat40)
+{
+	return (struct mat4 *)mat4_transpose((mfloat_t *)result, (mfloat_t *)mat40);
+}
+
+struct mat4 *psmat4_cofactor(struct mat4 *result, struct mat4 *mat40)
+{
+	return (struct mat4 *)mat4_cofactor((mfloat_t *)result, (mfloat_t *)mat40);
+}
+
+struct mat4 *psmat4_rotation_x(struct mat4 *result, mfloat_t f)
+{
+	return (struct mat4 *)mat4_rotation_x((mfloat_t *)result, f);
+}
+
+struct mat4 *psmat4_rotation_y(struct mat4 *result, mfloat_t f)
+{
+	return (struct mat4 *)mat4_rotation_y((mfloat_t *)result, f);
+}
+
+struct mat4 *psmat4_rotation_z(struct mat4 *result, mfloat_t f)
+{
+	return (struct mat4 *)mat4_rotation_z((mfloat_t *)result, f);
+}
+
+struct mat4 *psmat4_rotation_axis(struct mat4 *result, struct vec3 *vec30, mfloat_t f)
+{
+	return (struct mat4 *)mat4_rotation_axis((mfloat_t *)result, (mfloat_t *)vec30, f);
+}
+
+struct mat4 *psmat4_rotation_quat(struct mat4 *result, struct quat *quat0)
+{
+	return (struct mat4 *)mat4_rotation_quat((mfloat_t *)result, (mfloat_t *)quat0);
+}
+
+struct mat4 *psmat4_translation(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30)
+{
+	return (struct mat4 *)mat4_translation((mfloat_t *)result, (mfloat_t *)mat40, (mfloat_t *)vec30);
+}
+
+struct mat4 *psmat4_translate(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30)
+{
+	return (struct mat4 *)mat4_translate((mfloat_t *)result, (mfloat_t *)mat40, (mfloat_t *)vec30);
+}
+
+struct mat4 *psmat4_scaling(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30)
+{
+	return (struct mat4 *)mat4_scaling((mfloat_t *)result, (mfloat_t *)mat40, (mfloat_t *)vec30);
 }
+
+struct mat4 *psmat4_scale(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30)
+{
+	return (struct mat4 *)mat4_scale((mfloat_t *)result, (mfloat_t *)mat40, (mfloat_t *)vec30);
+}
+
+struct mat4 *psmat4_multiply(struct mat4 *result, struct mat4 *mat40, struct mat4 *mat41)
+{
+	return (struct mat4 *)mat4_multiply((mfloat_t *)result, (mfloat_t *)mat40, (mfloat_t *)mat41);
+}
+
+struct mat4 *psmat4_multiply_f(struct mat4 *result, struct mat4 *mat40, mfloat_t f)
+{
+	return (struct mat4 *)mat4_multiply_f((mfloat_t *)result, (mfloat_t *)mat40, f);
+}
+
+struct mat4 *psmat4_inverse(struct mat4 *result, struct mat4 *mat40)
+{
+	return (struct mat4 *)mat4_inverse((mfloat_t *)result, (mfloat_t *)mat40);
+}
+
+struct mat4 *psmat4_lerp(struct mat4 *result, struct mat4 *mat40, struct mat4 *mat41, mfloat_t f)
+{
+	return (struct mat4 *)mat4_lerp((mfloat_t *)result, (mfloat_t *)mat40, (mfloat_t *)mat41, f);
+}
+
+struct mat4 *psmat4_look_at(struct mat4 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32)
+{
+	return (struct mat4 *)mat4_look_at((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31, (mfloat_t *)vec32);
+}
+
+struct mat4 *psmat4_ortho(struct mat4 *result, mfloat_t l, mfloat_t r, mfloat_t b, mfloat_t t, mfloat_t n, mfloat_t f)
+{
+	return (struct mat4 *)mat4_ortho((mfloat_t *)result, l, r, b, t, n, f);
+}
+
+struct mat4 *psmat4_perspective(struct mat4 *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n, mfloat_t f)
+{
+	return (struct mat4 *)mat4_perspective((mfloat_t *)result, fov_y, aspect, n, f);
+}
+
+struct mat4 *psmat4_perspective_fov(struct mat4 *result, mfloat_t fov, mfloat_t w, mfloat_t h, mfloat_t n, mfloat_t f)
+{
+	return (struct mat4 *)mat4_perspective_fov((mfloat_t *)result, fov, w, h, n, f);
+}
+
+struct mat4 *psmat4_perspective_infinite(struct mat4 *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n)
+{
+	return (struct mat4 *)mat4_perspective_infinite((mfloat_t *)result, fov_y, aspect, n);
+}
+#endif
+#endif
diff --git a/mathc.h b/mathc.h
index 6bf0c2d..6b8e96c 100644
--- a/mathc.h
+++ b/mathc.h
@@ -1,5 +1,5 @@
 /*
-Copyright (C) 2016 Felipe Ferreira da Silva
+Copyright © 2018 Felipe Ferreira da Silva
 
 This software is provided 'as-is', without any express or implied warranty. In
 no event will the authors be held liable for any damages arising from the use of
@@ -22,337 +22,1236 @@ the following restrictions:
 #define MATHC_H
 
 #include <stdbool.h>
+#include <math.h>
 
-#define MATHC_MAJOR_VERSION 1
-#define MATHC_MINOR_VERSION 2
-#define MATHC_PATCH_VERSION 0
-#define M_PIF 3.1415926536f
-#define M_PIF_2 1.5707963268f
-#define MAT_SIZE 16
+#define MATHC_VERSION_YYYY 2018
+#define MATHC_VERSION_MM 08
+#define MATHC_VERSION_DD 02
+#define MATHC_VERSION_MICRO 0
 
-struct vec {
-	float x;
-	float y;
-	float z;
-	float w;
-};
+#if !defined(MATHC_NO_INT)
+#define MATHC_USE_INT
+#endif
+#if !defined(MATHC_NO_FLOATING_POINT)
+#define MATHC_USE_FLOATING_POINT
+#endif
+#if !defined(MATHC_NO_POINTER_STRUCT_FUNCTIONS)
+#define MATHC_USE_POINTER_STRUCT_FUNCTIONS
+#endif
+#if !defined(MATHC_NO_STRUCT_FUNCTIONS)
+#define MATHC_USE_STRUCT_FUNCTIONS
+#endif
+#if !defined(MATHC_NO_EASING_FUNCTIONS)
+#define MATHC_USE_EASING_FUNCTIONS
+#endif
 
-struct mat {
-	/* Row x Column */
-	float m11;
-	float m21;
-	float m31;
-	float m41;
-	float m12;
-	float m22;
-	float m32;
-	float m42;
-	float m13;
-	float m23;
-	float m33;
-	float m43;
-	float m14;
-	float m24;
-	float m34;
-	float m44;
-};
+#if defined(MATHC_USE_INT)
+#include <stdint.h>
+#endif
+#if defined(MATHC_USE_FLOATING_POINT)
+#include <float.h>
+#endif
 
-/* Utils */
-bool nearly_equal(float a, float b, float epsilon);
-float to_radians(float degrees);
-float to_degrees(float radians);
+#define VEC2_SIZE 2
+#define VEC3_SIZE 3
+#define VEC4_SIZE 4
+#define EULER_SIZE 3
+#define QUAT_SIZE 4
+#define MAT2_SIZE 4
+#define MAT3_SIZE 9
+#define MAT4_SIZE 16
 
-/* Vector 2D */
-void to_pvector2(float x, float y, struct vec *result);
-void pvector2_zero(struct vec *result);
-bool pvector2_is_zero(struct vec *a);
-bool pvector2_is_near_zero(struct vec *a, float epsilon);
-bool pvector2_is_equal(struct vec *a, struct vec *b, float epsilon);
-void pvector2_add(struct vec *a, struct vec *b, struct vec *result);
-void pvector2_subtract(struct vec *a, struct vec *b, struct vec *result);
-void pvector2_scale(struct vec *a, float scale, struct vec *result);
-void pvector2_multiply(struct vec *a, struct vec *b, struct vec *result);
-void pvector2_divide(struct vec *a, struct vec *b, struct vec *result);
-void pvector2_negative(struct vec *a, struct vec *result);
-void pvector2_inverse(struct vec *a, struct vec *result);
-void pvector2_abs(struct vec *a, struct vec *result);
-void pvector2_floor(struct vec *a, struct vec *result);
-void pvector2_ceil(struct vec *a, struct vec *result);
-void pvector2_round(struct vec *a, struct vec *result);
-void pvector2_max(struct vec *a, struct vec *b, struct vec *result);
-void pvector2_min(struct vec *a, struct vec *b, struct vec *result);
-float pvector2_dot(struct vec *a, struct vec *b);
-float pvector2_angle(struct vec *a);
-float pvector2_length_squared(struct vec *a);
-float pvector2_length(struct vec *a);
-void pvector2_normalize(struct vec *a, struct vec *result);
-void pvector2_slide(struct vec *a, struct vec *b, struct vec *result);
-void pvector2_reflect(struct vec *a, struct vec *b, struct vec *result);
-void pvector2_tangent(struct vec *a, struct vec *result);
-void pvector2_rotate(struct vec *a, float angle, struct vec *result);
-float pvector2_distance_to(struct vec *a, struct vec *b);
-float pvector2_distance_squared_to(struct vec *a, struct vec *b);
-void pvector2_linear_interpolation(struct vec *a, struct vec *b, float p, struct vec *result);
-void pvector2_bezier3(struct vec *a, struct vec *b, struct vec *c, float p, struct vec *result);
-void pvector2_bezier4(struct vec *a, struct vec *b, struct vec *c, struct vec *d, float p, struct vec *result);
+#if defined(MATHC_USE_INT)
+#if defined(MATHC_INT_TYPE)
+typedef MATHC_INT_TYPE mint_t;
+#endif
+#if !defined(MATHC_USE_INT8) && !defined(MATHC_USE_INT16) && !defined(MATHC_USE_INT32) && !defined(MATHC_USE_INT64)
+#define MATHC_USE_INT32
+#endif
+#if defined(MATHC_USE_INT8)
+#if !defined(MATHC_INT_TYPE)
+typedef int8_t mint_t;
+#endif
+#define MINT_MAX INT8_MAX
+#define MINT_MIN INT8_MIN
+#endif
+#if defined(MATHC_USE_INT16)
+#if !defined(MATHC_INT_TYPE)
+typedef int16_t mint_t;
+#endif
+#define MINT_MAX INT16_MAX
+#define MINT_MIN INT16_MIN
+#endif
+#if defined(MATHC_USE_INT32)
+#if !defined(MATHC_INT_TYPE)
+typedef int32_t mint_t;
+#endif
+#define MINT_MAX INT32_MAX
+#define MINT_MIN INT32_MIN
+#endif
+#if defined(MATHC_USE_INT64)
+#if !defined(MATHC_INT_TYPE)
+typedef int64_t mint_t;
+#endif
+#define MINT_MAX INT64_MAX
+#define MINT_MIN INT64_MIN
+#endif
+#endif
 
-struct vec to_vector2(float x, float y);
-struct vec vector2_zero(void);
-bool vector2_is_zero(struct vec a);
-bool vector2_is_near_zero(struct vec a, float epsilon);
-bool vector2_is_equal(struct vec a, struct vec b, float epsilon);
-struct vec vector2_add(struct vec a, struct vec b);
-struct vec vector2_subtract(struct vec a, struct vec b);
-struct vec vector2_scale(struct vec a, float scale);
-struct vec vector2_multiply(struct vec a, struct vec b);
-struct vec vector2_divide(struct vec a, struct vec b);
-struct vec vector2_negative(struct vec a);
-struct vec vector2_inverse(struct vec a);
-struct vec vector2_abs(struct vec a);
-struct vec vector2_floor(struct vec a);
-struct vec vector2_ceil(struct vec a);
-struct vec vector2_round(struct vec a);
-struct vec vector2_max(struct vec a, struct vec b);
-struct vec vector2_min(struct vec a, struct vec b);
-float vector2_dot(struct vec a, struct vec b);
-float vector2_angle(struct vec a);
-float vector2_length_squared(struct vec a);
-float vector2_length(struct vec a);
-struct vec vector2_normalize(struct vec a);
-struct vec vector2_slide(struct vec a, struct vec normal);
-struct vec vector2_reflect(struct vec a, struct vec normal);
-struct vec vector2_tangent(struct vec a);
-struct vec vector2_rotate(struct vec a, float angle);
-float vector2_distance_to(struct vec a, struct vec b);
-float vector2_distance_squared_to(struct vec a, struct vec b);
-struct vec vector2_linear_interpolation(struct vec a, struct vec b, float p);
-struct vec vector2_bezier3(struct vec a, struct vec b, struct vec c, float p);
-struct vec vector2_bezier4(struct vec a, struct vec b, struct vec c, struct vec d, float p);
+#if defined(MATHC_USE_FLOATING_POINT)
+#if defined(MATHC_FLOATING_POINT_TYPE)
+typedef MATHC_FLOATING_POINT_TYPE mint_t;
+#endif
+#if !defined(MATHC_USE_SINGLE_FLOATING_POINT) && !defined(MATHC_USE_DOUBLE_FLOATING_POINT)
+#define MATHC_USE_SINGLE_FLOATING_POINT
+#endif
+#if defined(MATHC_USE_SINGLE_FLOATING_POINT)
+#if !defined(MATHC_FLOATING_POINT_TYPE)
+typedef float mfloat_t;
+#endif
+#define MPI 3.1415926536f
+#define MPI_2 1.5707963268f
+#define MPI_4 0.7853981634f
+#define MFLT_EPSILON FLT_EPSILON
+#define MFABS fabsf
+#define MFMIN fminf
+#define MFMAX fmaxf
+#define MSQRT sqrtf
+#define MSIN sinf
+#define MCOS cosf
+#define MACOS acosf
+#define MASIN asinf
+#define MTAN tanf
+#define MATAN2 atan2f
+#define MPOW powf
+#define MFLOOR floorf
+#define MCEIL ceilf
+#define MROUND roundf
+#define MFLOAT_C(c) c ## f
+#endif
+#if defined(MATHC_USE_DOUBLE_FLOATING_POINT)
+#if !defined(MATHC_FLOATING_POINT_TYPE)
+typedef double mfloat_t;
+#endif
+#define MPI 3.14159265358979323846
+#define MPI_2 1.57079632679489661923
+#define MPI_4 0.78539816339744830962
+#define MFLT_EPSILON DBL_EPSILON
+#define MFABS fabs
+#define MFMIN fmin
+#define MFMAX fmax
+#define MSQRT sqrt
+#define MSIN sin
+#define MCOS cos
+#define MACOS acos
+#define MASIN asin
+#define MTAN tan
+#define MATAN2 atan2
+#define MPOW pow
+#define MFLOOR floor
+#define MCEIL ceil
+#define MROUND round
+#define MFLOAT_C(c) c
+#endif
+#endif
 
-/* Vector 3D */
-void to_pvector3(float x, float y, float z, struct vec *result);
-void pvector3_zero(struct vec *result);
-bool pvector3_is_zero(struct vec *a);
-bool pvector3_is_near_zero(struct vec *a, float epsilon);
-bool pvector3_is_equal(struct vec *a, struct vec *b, float epsilon);
-void pvector3_add(struct vec *a, struct vec *b, struct vec *result);
-void pvector3_subtract(struct vec *a, struct vec *b, struct vec *result);
-void pvector3_scale(struct vec *a, float scale, struct vec *result);
-void pvector3_multiply(struct vec *a, struct vec *b, struct vec *result);
-void pvector3_divide(struct vec *a, struct vec *b, struct vec *result);
-void pvector3_negative(struct vec *a, struct vec *result);
-void pvector3_inverse(struct vec *a, struct vec *result);
-void pvector3_abs(struct vec *a, struct vec *result);
-void pvector3_floor(struct vec *a, struct vec *result);
-void pvector3_ceil(struct vec *a, struct vec *result);
-void pvector3_round(struct vec *a, struct vec *result);
-void pvector3_max(struct vec *a, struct vec *b, struct vec *result);
-void pvector3_min(struct vec *a, struct vec *b, struct vec *result);
-float pvector3_dot(struct vec *a, struct vec *b);
-void pvector3_cross(struct vec *a, struct vec *b, struct vec *result);
-float pvector3_length_squared(struct vec *a);
-float pvector3_length(struct vec *a);
-void pvector3_normalize(struct vec *a, struct vec *result);
-void pvector3_slide(struct vec *a, struct vec *b, struct vec *result);
-void pvector3_reflect(struct vec *a, struct vec *normal, struct vec *result);
-float pvector3_distance_to(struct vec *a, struct vec *b);
-float pvector3_distance_squared_to(struct vec *a, struct vec *b);
-void pvector3_linear_interpolation(struct vec *a, struct vec *b, float p, struct vec *result);
-void pvector3_bezier3(struct vec *a, struct vec *b, struct vec *c, float p, struct vec *result);
-void pvector3_bezier4(struct vec *a, struct vec *b, struct vec *c, struct vec *d, float p, struct vec *result);
+#if defined(MATHC_USE_FLOATING_POINT)
+#define MRADIANS(degrees) (degrees * MPI / MFLOAT_C(180.0))
+#define MDEGREES(radians) (radians * MFLOAT_C(180.0) / MPI)
+#endif
 
-struct vec to_vector3(float x, float y, float z);
-struct vec vector3_zero(void);
-struct vec vector3_add(struct vec a, struct vec b);
-bool vector3_is_zero(struct vec a);
-bool vector3_is_near_zero(struct vec a, float epsilon);
-bool vector3_is_equal(struct vec a, struct vec b, float epsilon);
-struct vec vector3_subtract(struct vec a, struct vec b);
-struct vec vector3_scale(struct vec a, float scale);
-struct vec vector3_multiply(struct vec a, struct vec b);
-struct vec vector3_divide(struct vec a, struct vec b);
-struct vec vector3_negative(struct vec a);
-struct vec vector3_inverse(struct vec a);
-struct vec vector3_abs(struct vec a);
-struct vec vector3_floor(struct vec a);
-struct vec vector3_ceil(struct vec a);
-struct vec vector3_round(struct vec a);
-struct vec vector3_max(struct vec a, struct vec b);
-struct vec vector3_min(struct vec a, struct vec b);
-float vector3_dot(struct vec a, struct vec b);
-struct vec vector3_cross(struct vec a, struct vec b);
-float vector3_length_squared(struct vec a);
-float vector3_length(struct vec a);
-struct vec vector3_normalize(struct vec a);
-struct vec vector3_slide(struct vec a, struct vec b);
-struct vec vector3_reflect(struct vec a, struct vec normal);
-float vector3_distance_to(struct vec a, struct vec b);
-float vector3_distance_squared_to(struct vec a, struct vec b);
-struct vec vector3_linear_interpolation(struct vec a, struct vec b, float p);
-struct vec vector3_bezier3(struct vec a, struct vec b, struct vec c, float p);
-struct vec vector3_bezier4(struct vec a, struct vec b, struct vec c, struct vec d, float p);
+#if defined(MATHC_USE_STRUCT_FUNCTIONS) || defined(MATHC_USE_POINTER_STRUCT_FUNCTIONS)
+#if defined(MATHC_USE_INT)
+struct vec2i {
+#if defined(MATHC_USE_UNIONS)
+	union {
+		struct {
+			mint_t x;
+			mint_t y;
+		};
+		mint_t v[VEC2_SIZE];
+	};
+#else
+	mint_t x;
+	mint_t y;
+#endif
+};
 
-/* Quaternion */
-void to_pquaternion(float x, float y, float z, float w, struct vec *result);
-void pquaternion_zero(struct vec *result);
-void pquaternion_null(struct vec *result);
-bool pquaternion_is_zero(struct vec *a);
-bool pquaternion_is_near_zero(struct vec *a, float epsilon);
-bool pquaternion_is_equal(struct vec *a, struct vec *b, float epsilon);
-void pquaternion_add(struct vec *a, struct vec *b, struct vec *result);
-void pquaternion_subtract(struct vec *a, struct vec *b, struct vec *result);
-void pquaternion_scale(struct vec *a, float scale, struct vec *result);
-void pquaternion_multiply(struct vec *a, struct vec *b, struct vec *result);
-void pquaternion_divide(struct vec *a, struct vec *b, struct vec *result);
-void pquaternion_negative(struct vec *a, struct vec *result);
-void pquaternion_conjugate(struct vec *a, struct vec *result);
-void pquaternion_inverse(struct vec *a, struct vec *result);
-void pquaternion_abs(struct vec *a, struct vec *result);
-void pquaternion_floor(struct vec *a, struct vec *result);
-void pquaternion_ceil(struct vec *a, struct vec *result);
-void pquaternion_round(struct vec *a, struct vec *result);
-void pquaternion_max(struct vec *a, struct vec *b, struct vec *result);
-void pquaternion_min(struct vec *a, struct vec *b, struct vec *result);
-float pquaternion_dot(struct vec *a, struct vec *b);
-float pquaternion_angle(struct vec *a, struct vec *b);
-float pquaternion_length_squared(struct vec *a);
-float pquaternion_length(struct vec *a);
-void pquaternion_normalize(struct vec *a, struct vec *result);
-void pquaternion_power(struct vec *a, float exponent, struct vec *result);
-void pquaternion_from_axis_angle(struct vec *a, float angle, struct vec *result);
-void pquaternion_to_axis_angle(struct vec *a, struct vec *result);
-void pquaternion_from_2_vectors(struct vec *a, struct vec *b, struct vec *result);
-void pquaternion_rotation_matrix(struct mat *m, struct vec *result);
-void pquaternion_yaw_pitch_roll(float yaw, float pitch, float roll, struct vec *result);
-void pquaternion_linear_interpolation(struct vec *a, struct vec *b, float p, struct vec *result);
-void pquaternion_spherical_linear_interpolation(struct vec *a, struct vec *b, float p, struct vec *result);
+struct vec3i {
+#if defined(MATHC_USE_UNIONS)
+	union {
+		struct {
+			mint_t x;
+			mint_t y;
+			mint_t z;
+		};
+		mint_t v[VEC3_SIZE];
+	};
+#else
+	mint_t x;
+	mint_t y;
+	mint_t z;
+#endif
+};
 
-struct vec to_quaternion(float x, float y, float z, float w);
-struct vec quaternion_zero(void);
-struct vec quaternion_null(void);
-bool quaternion_is_zero(struct vec a);
-bool quaternion_is_near_zero(struct vec a, float epsilon);
-bool quaternion_is_equal(struct vec a, struct vec b, float epsilon);
-struct vec quaternion_add(struct vec a, struct vec b);
-struct vec quaternion_subtract(struct vec a, struct vec b);
-struct vec quaternion_scale(struct vec a, float scale);
-struct vec quaternion_multiply(struct vec a, struct vec b);
-struct vec quaternion_divide(struct vec a, struct vec b);
-struct vec quaternion_negative(struct vec a);
-struct vec quaternion_conjugate(struct vec a);
-struct vec quaternion_inverse(struct vec a);
-struct vec quaternion_abs(struct vec a);
-struct vec quaternion_floor(struct vec a);
-struct vec quaternion_ceil(struct vec a);
-struct vec quaternion_round(struct vec a);
-struct vec quaternion_max(struct vec a, struct vec b);
-struct vec quaternion_min(struct vec a, struct vec b);
-float quaternion_dot(struct vec a, struct vec b);
-float quaternion_angle(struct vec a, struct vec b);
-float quaternion_length_squared(struct vec a);
-float quaternion_length(struct vec a);
-struct vec quaternion_normalize(struct vec a);
-struct vec quaternion_power(struct vec a, float exponent);
-struct vec quaternion_from_axis_angle(struct vec a, float angle);
-struct vec quaternion_to_axis_angle(struct vec a);
-struct vec quaternion_from_2_vectors(struct vec a, struct vec b);
-struct vec quaternion_rotation_matrix(struct mat m);
-struct vec quaternion_yaw_pitch_roll(float yaw, float pitch, float roll);
-struct vec quaternion_linear_interpolation(struct vec a, struct vec b, float p);
-struct vec quaternion_spherical_linear_interpolation(struct vec a, struct vec b, float p);
+struct vec4i {
+#if defined(MATHC_USE_UNIONS)
+	union {
+		struct {
+			mint_t x;
+			mint_t y;
+			mint_t z;
+			mint_t w;
+		};
+		mint_t v[VEC4_SIZE];
+	};
+#else
+	mint_t x;
+	mint_t y;
+	mint_t z;
+	mint_t w;
+#endif
+};
+#endif
+
+#if defined(MATHC_USE_FLOATING_POINT)
+struct vec2 {
+#if defined(MATHC_USE_UNIONS)
+	union {
+		struct {
+			mfloat_t x;
+			mfloat_t y;
+		};
+		mfloat_t v[VEC2_SIZE];
+	};
+#else
+	mfloat_t x;
+	mfloat_t y;
+#endif
+};
 
-/* Matrix */
-void pmatrix_zero(struct mat *result);
-void pmatrix_identity(struct mat *result);
-void pmatrix_transpose(struct mat *m, struct mat *result);
-void pmatrix_inverse(struct mat *m, struct mat *result);
-void pmatrix_ortho(float l, float r, float b, float t, float n, float f, struct mat *result);
-void pmatrix_perspective(float fov_y, float aspect, float n, float f, struct mat *result);
-void pmatrix_perspective_fov(float fov, float w, float h, float n, float f, struct mat *result);
-void pmatrix_perspective_infinite(float fov_y, float aspect, float n, struct mat *result);
-void pmatrix_rotation_x(float angle, struct mat *result);
-void pmatrix_rotation_y(float angle, struct mat *result);
-void pmatrix_rotation_z(float angle, struct mat *result);
-void pmatrix_rotation_axis(struct vec *a, float angle, struct mat *result);
-void pmatrix_rotation_quaternion(struct vec *q, struct mat *result);
-void pmatrix_look_at_up(struct vec *pos, struct vec *target, struct vec *up_axis, struct mat *result);
-void pmatrix_look_at(struct vec *pos, struct vec *target, struct mat *result);
-void pmatrix_scale(struct vec *v, struct mat *result);
-void pmatrix_get_scale(struct mat *m, struct vec *result);
-void pmatrix_translation(struct vec *v, struct mat *result);
-void pmatrix_get_translation(struct mat *m, struct vec *result);
-void pmatrix_negative(struct mat *m, struct mat *result);
-void pmatrix_multiply(struct mat *m, float s, struct mat *result);
-void pmatrix_multiply_matrix(struct mat *a, struct mat *b, struct mat *result);
-void pmatrix_linear_interpolation(struct mat *a, struct mat *b, float p, struct mat *result);
-void pmatrix_multiply_f4(struct mat *m, float *result);
-void pmatrix_multiply_f3(struct mat *m, float *result);
-void pmatrix_to_array(struct mat *m, float *result);
+struct vec3 {
+#if defined(MATHC_USE_UNIONS)
+	union {
+		struct {
+			mfloat_t x;
+			mfloat_t y;
+			mfloat_t z;
+		};
+		mfloat_t v[VEC3_SIZE];
+	};
+#else
+	mfloat_t x;
+	mfloat_t y;
+	mfloat_t z;
+#endif
+};
+
+struct vec4 {
+#if defined(MATHC_USE_UNIONS)
+	union {
+		struct {
+			mfloat_t x;
+			mfloat_t y;
+			mfloat_t z;
+			mfloat_t w;
+		};
+		mfloat_t v[VEC4_SIZE];
+	};
+#else
+	mfloat_t x;
+	mfloat_t y;
+	mfloat_t z;
+	mfloat_t w;
+#endif
+};
 
-struct mat matrix_zero(void);
-struct mat matrix_identity(void);
-struct mat matrix_transpose(struct mat m);
-struct mat matrix_inverse(struct mat m);
-struct mat matrix_ortho(float l, float r, float b, float t, float n, float f);
-struct mat matrix_perspective(float fov_y, float aspect, float n, float f);
-struct mat matrix_perspective_fov(float fov, float w, float h, float n, float f);
-struct mat matrix_perspective_infinite(float fov_y, float aspect, float n);
-struct mat matrix_rotation_x(float angle);
-struct mat matrix_rotation_y(float angle);
-struct mat matrix_rotation_z(float angle);
-struct mat matrix_rotation_axis(struct vec a, float angle);
-struct mat matrix_rotation_quaternion(struct vec q);
-struct mat matrix_look_at_up(struct vec pos, struct vec target, struct vec up_axis);
-struct mat matrix_look_at(struct vec pos, struct vec target);
-struct mat matrix_scale(struct vec v);
-struct vec matrix_get_scale(struct mat m);
-struct mat matrix_translation(struct vec v);
-struct vec matrix_get_translation(struct mat m);
-struct mat matrix_negative(struct mat m);
-struct mat matrix_multiply(struct mat m, float s);
-struct mat matrix_multiply_matrix(struct mat a, struct mat b);
-struct mat matrix_linear_interpolation(struct mat a, struct mat b, float p);
-void matrix_multiply_f4(struct mat m, float *result);
-void matrix_multiply_f3(struct mat m, float *result);
-void matrix_to_array(struct mat m, float *result);
+struct quat {
+#if defined(MATHC_USE_UNIONS)
+	union {
+		struct {
+			mfloat_t x;
+			mfloat_t y;
+			mfloat_t z;
+			mfloat_t w;
+		};
+		mfloat_t v[QUAT_SIZE];
+	};
+#else
+	mfloat_t x;
+	mfloat_t y;
+	mfloat_t z;
+	mfloat_t w;
+#endif
+};
 
-/* Intersection */
-bool pvector2_in_circle(struct vec *v, struct vec *circle_position, float radius);
-bool pvector2_in_triangle(struct vec *v, struct vec *a, struct vec *b, struct vec *c);
+/*
+Matrix 2×2 representation:
+0/m11 2/m12
+1/m21 3/m22
+*/
+struct mat2 {
+#if defined(MATHC_USE_UNIONS)
+	union {
+		struct {
+			mfloat_t m11;
+			mfloat_t m21;
+			mfloat_t m12;
+			mfloat_t m22;
+		};
+		mfloat_t v[MAT2_SIZE];
+	};
+#else
+	mfloat_t m11;
+	mfloat_t m21;
+	mfloat_t m12;
+	mfloat_t m22;
+#endif
+};
 
-bool vector2_in_circle(struct vec v, struct vec circle_position, float radius);
-bool vector2_in_triangle(struct vec v, struct vec a, struct vec b, struct vec c);
+/*
+Matrix 3×3 representation:
+0/m11 3/m12 6/m13
+1/m21 4/m22 7/m23
+2/m31 5/m32 8/m33
+*/
+struct mat3 {
+#if defined(MATHC_USE_UNIONS)
+	union {
+		struct {
+			mfloat_t m11;
+			mfloat_t m21;
+			mfloat_t m31;
+			mfloat_t m12;
+			mfloat_t m22;
+			mfloat_t m32;
+			mfloat_t m13;
+			mfloat_t m23;
+			mfloat_t m33;
+		};
+		mfloat_t v[MAT3_SIZE];
+	};
+#else
+	mfloat_t m11;
+	mfloat_t m21;
+	mfloat_t m31;
+	mfloat_t m12;
+	mfloat_t m22;
+	mfloat_t m32;
+	mfloat_t m13;
+	mfloat_t m23;
+	mfloat_t m33;
+#endif
+};
 
-/* Easing functions */
-float quadratic_ease_in(float p);
-float quadratic_ease_out(float p);
-float quadratic_ease_in_out(float p);
-float cubic_ease_in(float p);
-float cubic_ease_out(float p);
-float cubic_ease_in_out(float p);
-float quartic_ease_in(float p);
-float quartic_ease_out(float p);
-float quartic_ease_in_out(float p);
-float quintic_ease_in(float p);
-float quintic_ease_out(float p);
-float quintic_ease_in_out(float p);
-float sine_ease_in(float p);
-float sine_ease_out(float p);
-float sine_ease_in_out(float p);
-float circular_ease_in(float p);
-float circular_ease_out(float p);
-float circular_ease_in_out(float p);
-float exponential_ease_in(float p);
-float exponential_ease_out(float p);
-float exponential_ease_in_out(float p);
-float elastic_ease_in(float p);
-float elastic_ease_out(float p);
-float elastic_ease_in_out(float p);
-float back_ease_in(float p);
-float back_ease_out(float p);
-float back_ease_in_out(float p);
-float bounce_ease_in(float p);
-float bounce_ease_out(float p);
-float bounce_ease_in_out(float p);
+/*
+Matrix 4×4 representation:
+0/m11 4/m12  8/m13 12/m14
+1/m21 5/m22  9/m23 13/m24
+2/m31 6/m32 10/m33 14/m34
+3/m41 7/m42 11/m43 15/m44
+*/
+struct mat4 {
+#if defined(MATHC_USE_UNIONS)
+	union {
+		struct {
+			mfloat_t m11;
+			mfloat_t m21;
+			mfloat_t m31;
+			mfloat_t m41;
+			mfloat_t m12;
+			mfloat_t m22;
+			mfloat_t m32;
+			mfloat_t m42;
+			mfloat_t m13;
+			mfloat_t m23;
+			mfloat_t m33;
+			mfloat_t m43;
+			mfloat_t m14;
+			mfloat_t m24;
+			mfloat_t m34;
+			mfloat_t m44;
+		};
+		mfloat_t v[MAT4_SIZE];
+	};
+#else
+	mfloat_t m11;
+	mfloat_t m21;
+	mfloat_t m31;
+	mfloat_t m41;
+	mfloat_t m12;
+	mfloat_t m22;
+	mfloat_t m32;
+	mfloat_t m42;
+	mfloat_t m13;
+	mfloat_t m23;
+	mfloat_t m33;
+	mfloat_t m43;
+	mfloat_t m14;
+	mfloat_t m24;
+	mfloat_t m34;
+	mfloat_t m44;
+#endif
+};
+#endif
+#endif
 
+#if defined(MATHC_USE_FLOATING_POINT)
+bool nearly_equal(mfloat_t a, mfloat_t b, mfloat_t epsilon);
+mfloat_t to_radians(mfloat_t degrees);
+mfloat_t to_degrees(mfloat_t radians);
+#endif
+#if defined(MATHC_USE_INT)
+bool vec2i_is_zero(mint_t *vec2i0);
+bool vec2i_is_equal(mint_t *vec2i0, mint_t *vec2i1);
+mint_t *vec2i(mint_t *result, mint_t x, mint_t y);
+mint_t *vec2i_assign(mint_t *result, mint_t *vec2i0);
+#if defined(MATHC_USE_FLOATING_POINT)
+mint_t *vec2i_assign_vec2(mint_t *result, mfloat_t *vec20);
+#endif
+mint_t *vec2i_zero(mint_t *result);
+mint_t *vec2i_one(mint_t *result);
+mint_t *vec2i_sign(mint_t *result, mint_t *vec2i0);
+mint_t *vec2i_add(mint_t *result, mint_t *vec2i0, mint_t *vec2i1);
+mint_t *vec2i_add_i(mint_t *result, mint_t *vec2i0, mint_t i);
+mint_t *vec2i_subtract(mint_t *result, mint_t *vec2i0, mint_t *vec2i1);
+mint_t *vec2i_subtract_i(mint_t *result, mint_t *vec2i0, mint_t i);
+mint_t *vec2i_multiply(mint_t *result, mint_t *vec2i0, mint_t *vec2i1);
+mint_t *vec2i_multiply_i(mint_t *result, mint_t *vec2i0, mint_t i);
+mint_t *vec2i_divide(mint_t *result, mint_t *vec2i0, mint_t *vec2i1);
+mint_t *vec2i_divide_i(mint_t *result, mint_t *vec2i0, mint_t i);
+mint_t *vec2i_snap(mint_t *result, mint_t *vec2i0, mint_t *vec2i1);
+mint_t *vec2i_snap_i(mint_t *result, mint_t *vec2i0, mint_t i);
+mint_t *vec2i_negative(mint_t *result, mint_t *vec2i0);
+mint_t *vec2i_abs(mint_t *result, mint_t *vec2i0);
+mint_t *vec2i_max(mint_t *result, mint_t *vec2i0, mint_t *vec2i1);
+mint_t *vec2i_min(mint_t *result, mint_t *vec2i0, mint_t *vec2i1);
+mint_t *vec2i_clamp(mint_t *result, mint_t *vec2i0, mint_t *vec2i1, mint_t *vec2i2);
+mint_t *vec2i_tangent(mint_t *result, mint_t *vec2i0);
+bool vec3i_is_zero(mint_t *vec3i0);
+bool vec3i_is_equal(mint_t *vec3i0, mint_t *vec3i1);
+mint_t *vec3i(mint_t *result, mint_t x, mint_t y, mint_t z);
+mint_t *vec3i_assign(mint_t *result, mint_t *vec3i0);
+#if defined(MATHC_USE_FLOATING_POINT)
+mint_t *vec3i_assign_vec3(mint_t *result, mfloat_t *vec30);
+#endif
+mint_t *vec3i_zero(mint_t *result);
+mint_t *vec3i_one(mint_t *result);
+mint_t *vec3i_sign(mint_t *result, mint_t *vec3i0);
+mint_t *vec3i_add(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
+mint_t *vec3i_add_i(mint_t *result, mint_t *vec3i0, mint_t i);
+mint_t *vec3i_subtract(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
+mint_t *vec3i_subtract_i(mint_t *result, mint_t *vec3i0, mint_t i);
+mint_t *vec3i_multiply(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
+mint_t *vec3i_multiply_i(mint_t *result, mint_t *vec3i0, mint_t i);
+mint_t *vec3i_divide(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
+mint_t *vec3i_divide_i(mint_t *result, mint_t *vec3i0, mint_t i);
+mint_t *vec3i_snap(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
+mint_t *vec3i_snap_i(mint_t *result, mint_t *vec3i0, mint_t i);
+mint_t *vec3i_cross(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
+mint_t *vec3i_negative(mint_t *result, mint_t *vec3i0);
+mint_t *vec3i_abs(mint_t *result, mint_t *vec3i0);
+mint_t *vec3i_max(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
+mint_t *vec3i_min(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
+mint_t *vec3i_clamp(mint_t *result, mint_t *vec3i0, mint_t *vec3i1, mint_t *vec3i2);
+bool vec4i_is_zero(mint_t *vec4i0);
+bool vec4i_is_equal(mint_t *vec4i0, mint_t *vec4i1);
+mint_t *vec4i(mint_t *result, mint_t x, mint_t y, mint_t z, mint_t w);
+mint_t *vec4i_assign(mint_t *result, mint_t *vec4i0);
+#if defined(MATHC_USE_FLOATING_POINT)
+mint_t *vec4i_assign_vec4(mint_t *result, mfloat_t *vec40);
+#endif
+mint_t *vec4i_zero(mint_t *result);
+mint_t *vec4i_one(mint_t *result);
+mint_t *vec4i_sign(mint_t *result, mint_t *vec4i0);
+mint_t *vec4i_add(mint_t *result, mint_t *vec4i0, mint_t *vec4i1);
+mint_t *vec4i_add_i(mint_t *result, mint_t *vec4i0, mint_t i);
+mint_t *vec4i_subtract(mint_t *result, mint_t *vec4i0, mint_t *vec4i1);
+mint_t *vec4i_subtract_i(mint_t *result, mint_t *vec4i0, mint_t i);
+mint_t *vec4i_multiply(mint_t *result, mint_t *vec4i0, mint_t *vec4i1);
+mint_t *vec4i_multiply_i(mint_t *result, mint_t *vec4i0, mint_t i);
+mint_t *vec4i_divide(mint_t *result, mint_t *vec4i0, mint_t *vec4i1);
+mint_t *vec4i_divide_i(mint_t *result, mint_t *vec4i0, mint_t i);
+mint_t *vec4i_snap(mint_t *result, mint_t *vec4i0, mint_t *vec4i1);
+mint_t *vec4i_snap_i(mint_t *result, mint_t *vec4i0, mint_t i);
+mint_t *vec4i_negative(mint_t *result, mint_t *vec4i0);
+mint_t *vec4i_abs(mint_t *result, mint_t *vec4i0);
+mint_t *vec4i_max(mint_t *result, mint_t *vec4i0, mint_t *vec4i1);
+mint_t *vec4i_min(mint_t *result, mint_t *vec4i0, mint_t *vec4i1);
+mint_t *vec4i_clamp(mint_t *result, mint_t *vec4i0, mint_t *vec4i1, mint_t *vec4i2);
+#endif
+#if defined(MATHC_USE_FLOATING_POINT)
+bool vec2_is_zero(mfloat_t *vec20);
+bool vec2_is_equal(mfloat_t *vec20, mfloat_t *vec21);
+mfloat_t *vec2(mfloat_t *result, mfloat_t x, mfloat_t y);
+mfloat_t *vec2_assign(mfloat_t *result, mfloat_t *vec20);
+#if defined(MATHC_USE_INT)
+mfloat_t *vec2_assign_vec2i(mfloat_t *result, mint_t *vec2i0);
+#endif
+mfloat_t *vec2_zero(mfloat_t *result);
+mfloat_t *vec2_one(mfloat_t *result);
+mfloat_t *vec2_sign(mfloat_t *result, mfloat_t *vec20);
+mfloat_t *vec2_add(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
+mfloat_t *vec2_add_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f);
+mfloat_t *vec2_subtract(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
+mfloat_t *vec2_subtract_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f);
+mfloat_t *vec2_multiply(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
+mfloat_t *vec2_multiply_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f);
+mfloat_t *vec2_multiply_mat2(mfloat_t *result, mfloat_t *vec20, mfloat_t *mat20);
+mfloat_t *vec2_divide(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
+mfloat_t *vec2_divide_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f);
+mfloat_t *vec2_snap(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
+mfloat_t *vec2_snap_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f);
+mfloat_t *vec2_negative(mfloat_t *result, mfloat_t *vec20);
+mfloat_t *vec2_abs(mfloat_t *result, mfloat_t *vec20);
+mfloat_t *vec2_floor(mfloat_t *result, mfloat_t *vec20);
+mfloat_t *vec2_ceil(mfloat_t *result, mfloat_t *vec20);
+mfloat_t *vec2_round(mfloat_t *result, mfloat_t *vec20);
+mfloat_t *vec2_max(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
+mfloat_t *vec2_min(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
+mfloat_t *vec2_clamp(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t *vec22);
+mfloat_t *vec2_normalize(mfloat_t *result, mfloat_t *vec20);
+mfloat_t vec2_dot(mfloat_t *vec20, mfloat_t *vec21);
+mfloat_t *vec2_project(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
+mfloat_t *vec2_slide(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
+mfloat_t *vec2_reflect(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
+mfloat_t *vec2_tangent(mfloat_t *result, mfloat_t *vec20);
+mfloat_t *vec2_rotate(mfloat_t *result, mfloat_t *vec20, mfloat_t f);
+mfloat_t *vec2_lerp(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t f);
+mfloat_t *vec2_bezier3(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t *vec22, mfloat_t f);
+mfloat_t *vec2_bezier4(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t *vec22, mfloat_t *vec23, mfloat_t f);
+mfloat_t vec2_angle(mfloat_t *vec20);
+mfloat_t vec2_length(mfloat_t *vec20);
+mfloat_t vec2_length_squared(mfloat_t *vec20);
+mfloat_t vec2_distance(mfloat_t *vec20, mfloat_t *vec21);
+mfloat_t vec2_distance_squared(mfloat_t *vec20, mfloat_t *vec21);
+bool vec3_is_zero(mfloat_t *vec30);
+bool vec3_is_equal(mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *vec3(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z);
+mfloat_t *vec3_assign(mfloat_t *result, mfloat_t *vec30);
+#if defined(MATHC_USE_INT)
+mfloat_t *vec3_assign_vec3i(mfloat_t *result, mint_t *vec3i0);
+#endif
+mfloat_t *vec3_zero(mfloat_t *result);
+mfloat_t *vec3_one(mfloat_t *result);
+mfloat_t *vec3_sign(mfloat_t *result, mfloat_t *vec30);
+mfloat_t *vec3_add(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *vec3_add_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f);
+mfloat_t *vec3_subtract(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *vec3_subtract_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f);
+mfloat_t *vec3_multiply(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *vec3_multiply_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f);
+mfloat_t *vec3_multiply_mat3(mfloat_t *result, mfloat_t *vec30, mfloat_t *mat30);
+mfloat_t *vec3_divide(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *vec3_divide_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f);
+mfloat_t *vec3_snap(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *vec3_snap_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f);
+mfloat_t *vec3_negative(mfloat_t *result, mfloat_t *vec30);
+mfloat_t *vec3_abs(mfloat_t *result, mfloat_t *vec30);
+mfloat_t *vec3_floor(mfloat_t *result, mfloat_t *vec30);
+mfloat_t *vec3_ceil(mfloat_t *result, mfloat_t *vec30);
+mfloat_t *vec3_round(mfloat_t *result, mfloat_t *vec30);
+mfloat_t *vec3_max(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *vec3_min(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *vec3_clamp(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32);
+mfloat_t *vec3_cross(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *vec3_normalize(mfloat_t *result, mfloat_t *vec30);
+mfloat_t vec3_dot(mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *vec3_project(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *vec3_slide(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *vec3_reflect(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *vec3_lerp(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t f);
+mfloat_t *vec3_bezier3(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32, mfloat_t f);
+mfloat_t *vec3_bezier4(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32, mfloat_t *vec33, mfloat_t f);
+mfloat_t vec3_length(mfloat_t *vec30);
+mfloat_t vec3_length_squared(mfloat_t *vec30);
+mfloat_t vec3_distance(mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t vec3_distance_squared(mfloat_t *vec30, mfloat_t *vec31);
+bool vec4_is_zero(mfloat_t *vec40);
+bool vec4_is_equal(mfloat_t *vec40, mfloat_t *vec41);
+mfloat_t *vec4(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);
+mfloat_t *vec4_assign(mfloat_t *result, mfloat_t *vec40);
+#if defined(MATHC_USE_INT)
+mfloat_t *vec4_assign_vec4i(mfloat_t *result, mint_t *vec4i0);
+#endif
+mfloat_t *vec4_zero(mfloat_t *result);
+mfloat_t *vec4_one(mfloat_t *result);
+mfloat_t *vec4_sign(mfloat_t *result, mfloat_t *vec40);
+mfloat_t *vec4_add(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41);
+mfloat_t *vec4_add_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f);
+mfloat_t *vec4_subtract(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41);
+mfloat_t *vec4_subtract_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f);
+mfloat_t *vec4_multiply(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41);
+mfloat_t *vec4_multiply_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f);
+mfloat_t *vec4_multiply_mat4(mfloat_t *result, mfloat_t *vec40, mfloat_t *mat40);
+mfloat_t *vec4_divide(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41);
+mfloat_t *vec4_divide_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f);
+mfloat_t *vec4_snap(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41);
+mfloat_t *vec4_snap_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f);
+mfloat_t *vec4_negative(mfloat_t *result, mfloat_t *vec40);
+mfloat_t *vec4_abs(mfloat_t *result, mfloat_t *vec40);
+mfloat_t *vec4_floor(mfloat_t *result, mfloat_t *vec40);
+mfloat_t *vec4_ceil(mfloat_t *result, mfloat_t *vec40);
+mfloat_t *vec4_round(mfloat_t *result, mfloat_t *vec40);
+mfloat_t *vec4_max(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41);
+mfloat_t *vec4_min(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41);
+mfloat_t *vec4_clamp(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41, mfloat_t *vec42);
+mfloat_t *vec4_normalize(mfloat_t *result, mfloat_t *vec40);
+mfloat_t *vec4_lerp(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41, mfloat_t f);
+bool quat_is_zero(mfloat_t *quat0);
+bool quat_is_equal(mfloat_t *quat0, mfloat_t *quat1);
+mfloat_t *quat(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);
+mfloat_t *quat_assign(mfloat_t *result, mfloat_t *quat0);
+mfloat_t *quat_zero(mfloat_t *result);
+mfloat_t *quat_null(mfloat_t *result);
+mfloat_t *quat_multiply(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1);
+mfloat_t *quat_multiply_f(mfloat_t *result, mfloat_t *quat0, mfloat_t f);
+mfloat_t *quat_divide(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1);
+mfloat_t *quat_divide_f(mfloat_t *result, mfloat_t *quat0, mfloat_t f);
+mfloat_t *quat_negative(mfloat_t *result, mfloat_t *quat0);
+mfloat_t *quat_conjugate(mfloat_t *result, mfloat_t *quat0);
+mfloat_t *quat_inverse(mfloat_t *result, mfloat_t *quat0);
+mfloat_t *quat_normalize(mfloat_t *result, mfloat_t *quat0);
+mfloat_t quat_dot(mfloat_t *quat0, mfloat_t *quat1);
+mfloat_t *quat_power(mfloat_t *result, mfloat_t *quat0, mfloat_t exponent);
+mfloat_t *quat_from_axis_angle(mfloat_t *result, mfloat_t *vec30, mfloat_t angle);
+mfloat_t *quat_from_vec3(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *quat_from_mat4(mfloat_t *result, mfloat_t *mat40);
+mfloat_t *quat_lerp(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1, mfloat_t f);
+mfloat_t *quat_slerp(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1, mfloat_t f);
+mfloat_t quat_length(mfloat_t *quat0);
+mfloat_t quat_length_squared(mfloat_t *quat0);
+mfloat_t quat_angle(mfloat_t *quat0, mfloat_t *quat1);
+mfloat_t *mat2(mfloat_t *result, mfloat_t m11, mfloat_t m12, mfloat_t m21, mfloat_t m22);
+mfloat_t *mat2_zero(mfloat_t *result);
+mfloat_t *mat2_identity(mfloat_t *result);
+mfloat_t mat2_determinant(mfloat_t *mat20);
+mfloat_t *mat2_assign(mfloat_t *result, mfloat_t *mat20);
+mfloat_t *mat2_negative(mfloat_t *result, mfloat_t *mat20);
+mfloat_t *mat2_transpose(mfloat_t *result, mfloat_t *mat20);
+mfloat_t *mat2_cofactor(mfloat_t *result, mfloat_t *mat20);
+mfloat_t *mat2_adjugate(mfloat_t *result, mfloat_t *mat20);
+mfloat_t *mat2_multiply(mfloat_t *result, mfloat_t *mat20, mfloat_t *mat21);
+mfloat_t *mat2_multiply_f(mfloat_t *result, mfloat_t *mat20, mfloat_t f);
+mfloat_t *mat2_inverse(mfloat_t *result, mfloat_t *mat20);
+mfloat_t *mat2_scaling(mfloat_t *result, mfloat_t *vec20);
+mfloat_t *mat2_scale(mfloat_t *result, mfloat_t *mat20, mfloat_t *vec20);
+mfloat_t *mat2_rotation_z(mfloat_t *result, mfloat_t f);
+mfloat_t *mat2_lerp(mfloat_t *result, mfloat_t *mat20, mfloat_t *mat21, mfloat_t f);
+mfloat_t *mat3(mfloat_t *result, mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m31, mfloat_t m32, mfloat_t m33);
+mfloat_t *mat3_zero(mfloat_t *result);
+mfloat_t *mat3_identity(mfloat_t *result);
+mfloat_t mat3_determinant(mfloat_t *mat30);
+mfloat_t *mat3_assign(mfloat_t *result, mfloat_t *mat30);
+mfloat_t *mat3_negative(mfloat_t *result, mfloat_t *mat30);
+mfloat_t *mat3_transpose(mfloat_t *result, mfloat_t *mat30);
+mfloat_t *mat3_cofactor(mfloat_t *result, mfloat_t *mat30);
+mfloat_t *mat3_multiply(mfloat_t *result, mfloat_t *mat30, mfloat_t *mat31);
+mfloat_t *mat3_multiply_f(mfloat_t *result, mfloat_t *mat30, mfloat_t f);
+mfloat_t *mat3_inverse(mfloat_t *result, mfloat_t *mat30);
+mfloat_t *mat3_scaling(mfloat_t *result, mfloat_t *vec30);
+mfloat_t *mat3_scale(mfloat_t *result, mfloat_t *mat30, mfloat_t *vec30);
+mfloat_t *mat3_rotation_x(mfloat_t *result, mfloat_t f);
+mfloat_t *mat3_rotation_y(mfloat_t *result, mfloat_t f);
+mfloat_t *mat3_rotation_z(mfloat_t *result, mfloat_t f);
+mfloat_t *mat3_rotation_axis(mfloat_t *result, mfloat_t *vec30, mfloat_t f);
+mfloat_t *mat3_rotation_quat(mfloat_t *result, mfloat_t *quat0);
+mfloat_t *mat3_lerp(mfloat_t *result, mfloat_t *mat30, mfloat_t *mat31, mfloat_t f);
+mfloat_t *mat4(mfloat_t *result, mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m14, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m24, mfloat_t m31, mfloat_t m32, mfloat_t m33, mfloat_t m34, mfloat_t m41, mfloat_t m42, mfloat_t m43, mfloat_t m44);
+mfloat_t *mat4_zero(mfloat_t *result);
+mfloat_t *mat4_identity(mfloat_t *result);
+mfloat_t mat4_determinant(mfloat_t *mat40);
+mfloat_t *mat4_assign(mfloat_t *result, mfloat_t *mat40);
+mfloat_t *mat4_negative(mfloat_t *result, mfloat_t *mat40);
+mfloat_t *mat4_transpose(mfloat_t *result, mfloat_t *mat40);
+mfloat_t *mat4_cofactor(mfloat_t *result, mfloat_t *mat40);
+mfloat_t *mat4_rotation_x(mfloat_t *result, mfloat_t f);
+mfloat_t *mat4_rotation_y(mfloat_t *result, mfloat_t f);
+mfloat_t *mat4_rotation_z(mfloat_t *result, mfloat_t f);
+mfloat_t *mat4_rotation_axis(mfloat_t *result, mfloat_t *vec30, mfloat_t f);
+mfloat_t *mat4_rotation_quat(mfloat_t *result, mfloat_t *quat0);
+mfloat_t *mat4_translation(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30);
+mfloat_t *mat4_translate(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30);
+mfloat_t *mat4_scaling(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30);
+mfloat_t *mat4_scale(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30);
+mfloat_t *mat4_multiply(mfloat_t *result, mfloat_t *mat40, mfloat_t *mat41);
+mfloat_t *mat4_multiply_f(mfloat_t *result, mfloat_t *mat40, mfloat_t f);
+mfloat_t *mat4_inverse(mfloat_t *result, mfloat_t *mat40);
+mfloat_t *mat4_lerp(mfloat_t *result, mfloat_t *mat40, mfloat_t *mat41, mfloat_t f);
+mfloat_t *mat4_look_at(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32);
+mfloat_t *mat4_ortho(mfloat_t *result, mfloat_t l, mfloat_t r, mfloat_t b, mfloat_t t, mfloat_t n, mfloat_t f);
+mfloat_t *mat4_perspective(mfloat_t *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n, mfloat_t f);
+mfloat_t *mat4_perspective_fov(mfloat_t *result, mfloat_t fov, mfloat_t w, mfloat_t h, mfloat_t n, mfloat_t f);
+mfloat_t *mat4_perspective_infinite(mfloat_t *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n);
+#endif
+#if defined(MATHC_USE_STRUCT_FUNCTIONS)
+#if defined(MATHC_USE_INT)
+bool svec2i_is_zero(struct vec2i vec2i0);
+bool svec2i_is_equal(struct vec2i vec2i0, struct vec2i vec2i1);
+struct vec2i svec2i(mint_t x, mint_t y);
+struct vec2i svec2i_assign(struct vec2i vec2i0);
+#if defined(MATHC_USE_FLOATING_POINT)
+struct vec2i svec2i_assign_vec2(struct vec2 vec20);
+#endif
+struct vec2i svec2i_zero(void);
+struct vec2i svec2i_one(void);
+struct vec2i svec2i_sign(struct vec2i vec2i0);
+struct vec2i svec2i_add(struct vec2i vec2i0, struct vec2i vec2i1);
+struct vec2i svec2i_add_i(struct vec2i vec2i0, mint_t i);
+struct vec2i svec2i_subtract(struct vec2i vec2i0, struct vec2i vec2i1);
+struct vec2i svec2i_subtract_i(struct vec2i vec2i0, mint_t i);
+struct vec2i svec2i_multiply(struct vec2i vec2i0, struct vec2i vec2i1);
+struct vec2i svec2i_multiply_i(struct vec2i vec2i0, mint_t i);
+struct vec2i svec2i_divide(struct vec2i vec2i0, struct vec2i vec2i1);
+struct vec2i svec2i_divide_i(struct vec2i vec2i0, mint_t i);
+struct vec2i svec2i_snap(struct vec2i vec2i0, struct vec2i vec2i1);
+struct vec2i svec2i_snap_i(struct vec2i vec2i0, mint_t i);
+struct vec2i svec2i_negative(struct vec2i vec2i0);
+struct vec2i svec2i_abs(struct vec2i vec2i0);
+struct vec2i svec2i_max(struct vec2i vec2i0, struct vec2i vec2i1);
+struct vec2i svec2i_min(struct vec2i vec2i0, struct vec2i vec2i1);
+struct vec2i svec2i_clamp(struct vec2i vec2i0, struct vec2i vec2i1, struct vec2i vec2i2);
+struct vec2i svec2i_tangent(struct vec2i vec2i0);
+bool svec3i_is_zero(struct vec3i vec3i0);
+bool svec3i_is_equal(struct vec3i vec3i0, struct vec3i vec3i1);
+struct vec3i svec3i(mint_t x, mint_t y, mint_t z);
+struct vec3i svec3i_assign(struct vec3i vec3i0);
+#if defined(MATHC_USE_FLOATING_POINT)
+struct vec3i svec3i_assign_vec3(struct vec3 vec30);
+#endif
+struct vec3i svec3i_zero(void);
+struct vec3i svec3i_one(void);
+struct vec3i svec3i_sign(struct vec3i vec3i0);
+struct vec3i svec3i_add(struct vec3i vec3i0, struct vec3i vec3i1);
+struct vec3i svec3i_add_i(struct vec3i vec3i0, mint_t i);
+struct vec3i svec3i_subtract(struct vec3i vec3i0, struct vec3i vec3i1);
+struct vec3i svec3i_subtract_i(struct vec3i vec3i0, mint_t i);
+struct vec3i svec3i_multiply(struct vec3i vec3i0, struct vec3i vec3i1);
+struct vec3i svec3i_multiply_i(struct vec3i vec3i0, mint_t i);
+struct vec3i svec3i_divide(struct vec3i vec3i0, struct vec3i vec3i1);
+struct vec3i svec3i_divide_i(struct vec3i vec3i0, mint_t i);
+struct vec3i svec3i_snap(struct vec3i vec3i0, struct vec3i vec3i1);
+struct vec3i svec3i_snap_i(struct vec3i vec3i0, mint_t i);
+struct vec3i svec3i_cross(struct vec3i vec3i0, struct vec3i vec3i1);
+struct vec3i svec3i_negative(struct vec3i vec3i0);
+struct vec3i svec3i_abs(struct vec3i vec3i0);
+struct vec3i svec3i_max(struct vec3i vec3i0, struct vec3i vec3i1);
+struct vec3i svec3i_min(struct vec3i vec3i0, struct vec3i vec3i1);
+struct vec3i svec3i_clamp(struct vec3i vec3i0, struct vec3i vec3i1, struct vec3i vec3i2);
+bool svec4i_is_zero(struct vec4i vec4i0);
+bool svec4i_is_equal(struct vec4i vec4i0, struct vec4i vec4i1);
+struct vec4i svec4i(mint_t x, mint_t y, mint_t z, mint_t w);
+struct vec4i svec4i_assign(struct vec4i vec4i0);
+#if defined(MATHC_USE_FLOATING_POINT)
+struct vec4i svec4i_assign_vec4(struct vec4 vec40);
+#endif
+struct vec4i svec4i_zero(void);
+struct vec4i svec4i_one(void);
+struct vec4i svec4i_sign(struct vec4i vec4i0);
+struct vec4i svec4i_add(struct vec4i vec4i0, struct vec4i vec4i1);
+struct vec4i svec4i_add_i(struct vec4i vec4i0, mint_t i);
+struct vec4i svec4i_subtract(struct vec4i vec4i0, struct vec4i vec4i1);
+struct vec4i svec4i_subtract_i(struct vec4i vec4i0, mint_t i);
+struct vec4i svec4i_multiply(struct vec4i vec4i0, struct vec4i vec4i1);
+struct vec4i svec4i_multiply_i(struct vec4i vec4i0, mint_t i);
+struct vec4i svec4i_divide(struct vec4i vec4i0, struct vec4i vec4i1);
+struct vec4i svec4i_divide_i(struct vec4i vec4i0, mint_t i);
+struct vec4i svec4i_snap(struct vec4i vec4i0, struct vec4i vec4i1);
+struct vec4i svec4i_snap_i(struct vec4i vec4i0, mint_t i);
+struct vec4i svec4i_negative(struct vec4i vec4i0);
+struct vec4i svec4i_abs(struct vec4i vec4i0);
+struct vec4i svec4i_max(struct vec4i vec4i0, struct vec4i vec4i1);
+struct vec4i svec4i_min(struct vec4i vec4i0, struct vec4i vec4i1);
+struct vec4i svec4i_clamp(struct vec4i vec4i0, struct vec4i vec4i1, struct vec4i vec4i2);
+#endif
+#if defined(MATHC_USE_FLOATING_POINT)
+bool svec2_is_zero(struct vec2 vec20);
+bool svec2_is_equal(struct vec2 vec20, struct vec2 vec21);
+struct vec2 svec2(mfloat_t x, mfloat_t y);
+struct vec2 svec2_assign(struct vec2 vec20);
+#if defined(MATHC_USE_INT)
+struct vec2 svec2_assign_vec2i(struct vec2i vec2i0);
+#endif
+struct vec2 svec2_zero(void);
+struct vec2 svec2_one(void);
+struct vec2 svec2_sign(struct vec2 vec20);
+struct vec2 svec2_add(struct vec2 vec20, struct vec2 vec21);
+struct vec2 svec2_add_f(struct vec2 vec20, mfloat_t f);
+struct vec2 svec2_subtract(struct vec2 vec20, struct vec2 vec21);
+struct vec2 svec2_subtract_f(struct vec2 vec20, mfloat_t f);
+struct vec2 svec2_multiply(struct vec2 vec20, struct vec2 vec21);
+struct vec2 svec2_multiply_f(struct vec2 vec20, mfloat_t f);
+struct vec2 svec2_multiply_mat2(struct vec2 vec20, struct mat2 mat20);
+struct vec2 svec2_divide(struct vec2 vec20, struct vec2 vec21);
+struct vec2 svec2_divide_f(struct vec2 vec20, mfloat_t f);
+struct vec2 svec2_snap(struct vec2 vec20, struct vec2 vec21);
+struct vec2 svec2_snap_f(struct vec2 vec20, mfloat_t f);
+struct vec2 svec2_negative(struct vec2 vec20);
+struct vec2 svec2_abs(struct vec2 vec20);
+struct vec2 svec2_floor(struct vec2 vec20);
+struct vec2 svec2_ceil(struct vec2 vec20);
+struct vec2 svec2_round(struct vec2 vec20);
+struct vec2 svec2_max(struct vec2 vec20, struct vec2 vec21);
+struct vec2 svec2_min(struct vec2 vec20, struct vec2 vec21);
+struct vec2 svec2_clamp(struct vec2 vec20, struct vec2 vec21, struct vec2 vec22);
+struct vec2 svec2_normalize(struct vec2 vec20);
+mfloat_t svec2_dot(struct vec2 vec20, struct vec2 vec21);
+struct vec2 svec2_project(struct vec2 vec20, struct vec2 vec21);
+struct vec2 svec2_slide(struct vec2 vec20, struct vec2 vec21);
+struct vec2 svec2_reflect(struct vec2 vec20, struct vec2 vec21);
+struct vec2 svec2_tangent(struct vec2 vec20);
+struct vec2 svec2_rotate(struct vec2 vec20, mfloat_t f);
+struct vec2 svec2_lerp(struct vec2 vec20, struct vec2 vec21, mfloat_t f);
+struct vec2 svec2_bezier3(struct vec2 vec20, struct vec2 vec21, struct vec2 vec22, mfloat_t f);
+struct vec2 svec2_bezier4(struct vec2 vec20, struct vec2 vec21, struct vec2 vec22, struct vec2 vec23, mfloat_t f);
+mfloat_t svec2_angle(struct vec2 vec20);
+mfloat_t svec2_length(struct vec2 vec20);
+mfloat_t svec2_length_squared(struct vec2 vec20);
+mfloat_t svec2_distance(struct vec2 vec20, struct vec2 vec21);
+mfloat_t svec2_distance_squared(struct vec2 vec20, struct vec2 vec21);
+bool svec3_is_zero(struct vec3 vec30);
+bool svec3_is_equal(struct vec3 vec30, struct vec3 vec31);
+struct vec3 svec3(mfloat_t x, mfloat_t y, mfloat_t z);
+struct vec3 svec3_assign(struct vec3 vec30);
+#if defined(MATHC_USE_INT)
+struct vec3 svec3_assign_vec3i(struct vec3i vec3i0);
+#endif
+struct vec3 svec3_zero(void);
+struct vec3 svec3_one(void);
+struct vec3 svec3_sign(struct vec3 vec30);
+struct vec3 svec3_add(struct vec3 vec30, struct vec3 vec31);
+struct vec3 svec3_add_f(struct vec3 vec30, mfloat_t f);
+struct vec3 svec3_subtract(struct vec3 vec30, struct vec3 vec31);
+struct vec3 svec3_subtract_f(struct vec3 vec30, mfloat_t f);
+struct vec3 svec3_multiply(struct vec3 vec30, struct vec3 vec31);
+struct vec3 svec3_multiply_f(struct vec3 vec30, mfloat_t f);
+struct vec3 svec3_multiply_mat3(struct vec3 vec30, struct mat3 mat30);
+struct vec3 svec3_divide(struct vec3 vec30, struct vec3 vec31);
+struct vec3 svec3_divide_f(struct vec3 vec30, mfloat_t f);
+struct vec3 svec3_snap(struct vec3 vec30, struct vec3 vec31);
+struct vec3 svec3_snap_f(struct vec3 vec30, mfloat_t f);
+struct vec3 svec3_negative(struct vec3 vec30);
+struct vec3 svec3_abs(struct vec3 vec30);
+struct vec3 svec3_floor(struct vec3 vec30);
+struct vec3 svec3_ceil(struct vec3 vec30);
+struct vec3 svec3_round(struct vec3 vec30);
+struct vec3 svec3_max(struct vec3 vec30, struct vec3 vec31);
+struct vec3 svec3_min(struct vec3 vec30, struct vec3 vec31);
+struct vec3 svec3_clamp(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32);
+struct vec3 svec3_cross(struct vec3 vec30, struct vec3 vec31);
+struct vec3 svec3_normalize(struct vec3 vec30);
+mfloat_t svec3_dot(struct vec3 vec30, struct vec3 vec31);
+struct vec3 svec3_project(struct vec3 vec30, struct vec3 vec31);
+struct vec3 svec3_slide(struct vec3 vec30, struct vec3 vec31);
+struct vec3 svec3_reflect(struct vec3 vec30, struct vec3 vec31);
+struct vec3 svec3_lerp(struct vec3 vec30, struct vec3 vec31, mfloat_t f);
+struct vec3 svec3_bezier3(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32, mfloat_t f);
+struct vec3 svec3_bezier4(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32, struct vec3 vec33, mfloat_t f);
+mfloat_t svec3_length(struct vec3 vec30);
+mfloat_t svec3_length_squared(struct vec3 vec30);
+mfloat_t svec3_distance(struct vec3 vec30, struct vec3 vec31);
+mfloat_t svec3_distance_squared(struct vec3 vec30, struct vec3 vec31);
+bool svec4_is_zero(struct vec4 vec40);
+bool svec4_is_equal(struct vec4 vec40, struct vec4 vec41);
+struct vec4 svec4(mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);
+struct vec4 svec4_assign(struct vec4 vec40);
+#if defined(MATHC_USE_INT)
+struct vec4 svec4_assign_vec4i(struct vec4i vec4i0);
+#endif
+struct vec4 svec4_zero(void);
+struct vec4 svec4_one(void);
+struct vec4 svec4_sign(struct vec4 vec40);
+struct vec4 svec4_add(struct vec4 vec40, struct vec4 vec41);
+struct vec4 svec4_add_f(struct vec4 vec40, mfloat_t f);
+struct vec4 svec4_subtract(struct vec4 vec40, struct vec4 vec41);
+struct vec4 svec4_subtract_f(struct vec4 vec40, mfloat_t f);
+struct vec4 svec4_multiply(struct vec4 vec40, struct vec4 vec41);
+struct vec4 svec4_multiply_f(struct vec4 vec40, mfloat_t f);
+struct vec4 svec4_multiply_mat4(struct vec4 vec40, struct mat4 mat40);
+struct vec4 svec4_divide(struct vec4 vec40, struct vec4 vec41);
+struct vec4 svec4_divide_f(struct vec4 vec40, mfloat_t f);
+struct vec4 svec4_snap(struct vec4 vec40, struct vec4 vec41);
+struct vec4 svec4_snap_f(struct vec4 vec40, mfloat_t f);
+struct vec4 svec4_negative(struct vec4 vec40);
+struct vec4 svec4_abs(struct vec4 vec40);
+struct vec4 svec4_floor(struct vec4 vec40);
+struct vec4 svec4_ceil(struct vec4 vec40);
+struct vec4 svec4_round(struct vec4 vec40);
+struct vec4 svec4_max(struct vec4 vec40, struct vec4 vec41);
+struct vec4 svec4_min(struct vec4 vec40, struct vec4 vec41);
+struct vec4 svec4_clamp(struct vec4 vec40, struct vec4 vec41, struct vec4 vec42);
+struct vec4 svec4_normalize(struct vec4 vec40);
+struct vec4 svec4_lerp(struct vec4 vec40, struct vec4 vec41, mfloat_t f);
+bool squat_is_zero(struct quat quat0);
+bool squat_is_equal(struct quat quat0, struct quat quat1);
+struct quat squat(mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);
+struct quat squat_assign(struct quat quat0);
+struct quat squat_zero(void);
+struct quat squat_null(void);
+struct quat squat_multiply(struct quat quat0, struct quat quat1);
+struct quat squat_multiply_f(struct quat quat0, mfloat_t f);
+struct quat squat_divide(struct quat quat0, struct quat quat1);
+struct quat squat_divide_f(struct quat quat0, mfloat_t f);
+struct quat squat_negative(struct quat quat0);
+struct quat squat_conjugate(struct quat quat0);
+struct quat squat_inverse(struct quat quat0);
+struct quat squat_normalize(struct quat quat0);
+mfloat_t squat_dot(struct quat quat0, struct quat quat1);
+struct quat squat_power(struct quat quat0, mfloat_t exponent);
+struct quat squat_from_axis_angle(struct vec3 vec30, mfloat_t angle);
+struct quat squat_from_vec3(struct vec3 vec30, struct vec3 vec31);
+struct quat squat_from_mat4(struct mat4 mat40);
+struct quat squat_lerp(struct quat quat0, struct quat quat1, mfloat_t f);
+struct quat squat_slerp(struct quat quat0, struct quat quat1, mfloat_t f);
+mfloat_t squat_length(struct quat quat0);
+mfloat_t squat_length_squared(struct quat quat0);
+mfloat_t squat_angle(struct quat quat0, struct quat quat1);
+struct mat2 smat2(mfloat_t m11, mfloat_t m12, mfloat_t m21, mfloat_t m22);
+struct mat2 smat2_zero(void);
+struct mat2 smat2_identity(void);
+mfloat_t smat2_determinant(struct mat2 mat20);
+struct mat2 smat2_assign(struct mat2 mat20);
+struct mat2 smat2_negative(struct mat2 mat20);
+struct mat2 smat2_transpose(struct mat2 mat20);
+struct mat2 smat2_cofactor(struct mat2 mat20);
+struct mat2 smat2_adjugate(struct mat2 mat20);
+struct mat2 smat2_multiply(struct mat2 mat20, struct mat2 mat21);
+struct mat2 smat2_multiply_f(struct mat2 mat20, mfloat_t f);
+struct mat2 smat2_inverse(struct mat2 mat20);
+struct mat2 smat2_scaling(struct vec2 vec20);
+struct mat2 smat2_scale(struct mat2 mat20, struct vec2 vec20);
+struct mat2 smat2_rotation_z(mfloat_t f);
+struct mat2 smat2_lerp(struct mat2 mat20, struct mat2 mat21, mfloat_t f);
+struct mat3 smat3(mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m31, mfloat_t m32, mfloat_t m33);
+struct mat3 smat3_zero(void);
+struct mat3 smat3_identity(void);
+mfloat_t smat3_determinant(struct mat3 mat30);
+struct mat3 smat3_assign(struct mat3 mat30);
+struct mat3 smat3_negative(struct mat3 mat30);
+struct mat3 smat3_transpose(struct mat3 mat30);
+struct mat3 smat3_cofactor(struct mat3 mat30);
+struct mat3 smat3_multiply(struct mat3 mat30, struct mat3 mat31);
+struct mat3 smat3_multiply_f(struct mat3 mat30, mfloat_t f);
+struct mat3 smat3_inverse(struct mat3 mat30);
+struct mat3 smat3_scaling(struct vec3 vec30);
+struct mat3 smat3_scale(struct mat3 mat30, struct vec3 vec30);
+struct mat3 smat3_rotation_x(mfloat_t f);
+struct mat3 smat3_rotation_y(mfloat_t f);
+struct mat3 smat3_rotation_z(mfloat_t f);
+struct mat3 smat3_rotation_axis(struct vec3 vec30, mfloat_t f);
+struct mat3 smat3_rotation_quat(struct quat quat0);
+struct mat3 smat3_lerp(struct mat3 mat30, struct mat3 mat31, mfloat_t f);
+struct mat4 smat4(mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m14, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m24, mfloat_t m31, mfloat_t m32, mfloat_t m33, mfloat_t m34, mfloat_t m41, mfloat_t m42, mfloat_t m43, mfloat_t m44);
+struct mat4 smat4_zero(void);
+struct mat4 smat4_identity(void);
+mfloat_t smat4_determinant(struct mat4 mat40);
+struct mat4 smat4_assign(struct mat4 mat40);
+struct mat4 smat4_negative(struct mat4 mat40);
+struct mat4 smat4_transpose(struct mat4 mat40);
+struct mat4 smat4_cofactor(struct mat4 mat40);
+struct mat4 smat4_rotation_x(mfloat_t f);
+struct mat4 smat4_rotation_y(mfloat_t f);
+struct mat4 smat4_rotation_z(mfloat_t f);
+struct mat4 smat4_rotation_axis(struct vec3 vec30, mfloat_t f);
+struct mat4 smat4_rotation_quat(struct quat quat0);
+struct mat4 smat4_translation(struct mat4 mat40, struct vec3 vec30);
+struct mat4 smat4_translate(struct mat4 mat40, struct vec3 vec30);
+struct mat4 smat4_scaling(struct mat4 mat40, struct vec3 vec30);
+struct mat4 smat4_scale(struct mat4 mat40, struct vec3 vec30);
+struct mat4 smat4_multiply(struct mat4 mat40, struct mat4 mat41);
+struct mat4 smat4_multiply_f(struct mat4 mat40, mfloat_t f);
+struct mat4 smat4_inverse(struct mat4 mat40);
+struct mat4 smat4_lerp(struct mat4 mat40, struct mat4 mat41, mfloat_t f);
+struct mat4 smat4_look_at(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32);
+struct mat4 smat4_ortho(mfloat_t l, mfloat_t r, mfloat_t b, mfloat_t t, mfloat_t n, mfloat_t f);
+struct mat4 smat4_perspective(mfloat_t fov_y, mfloat_t aspect, mfloat_t n, mfloat_t f);
+struct mat4 smat4_perspective_fov(mfloat_t fov, mfloat_t w, mfloat_t h, mfloat_t n, mfloat_t f);
+struct mat4 smat4_perspective_infinite(mfloat_t fov_y, mfloat_t aspect, mfloat_t n);
+#endif
+#endif
+#if defined(MATHC_USE_POINTER_STRUCT_FUNCTIONS)
+#if defined(MATHC_USE_INT)
+bool psvec2i_is_zero(struct vec2i *vec2i0);
+bool psvec2i_is_equal(struct vec2i *vec2i0, struct vec2i *vec2i1);
+struct vec2i *psvec2i(struct vec2i *result, mint_t x, mint_t y);
+struct vec2i *psvec2i_assign(struct vec2i *result, struct vec2i *vec2i0);
+#if defined(MATHC_USE_FLOATING_POINT)
+struct vec2i *psvec2i_assign_vec2(struct vec2i *result, struct vec2 *vec20);
+#endif
+struct vec2i *psvec2i_zero(struct vec2i *result);
+struct vec2i *psvec2i_one(struct vec2i *result);
+struct vec2i *psvec2i_sign(struct vec2i *result, struct vec2i *vec2i0);
+struct vec2i *psvec2i_add(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1);
+struct vec2i *psvec2i_add_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i);
+struct vec2i *psvec2i_subtract(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1);
+struct vec2i *psvec2i_subtract_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i);
+struct vec2i *psvec2i_multiply(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1);
+struct vec2i *psvec2i_multiply_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i);
+struct vec2i *psvec2i_divide(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1);
+struct vec2i *psvec2i_divide_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i);
+struct vec2i *psvec2i_snap(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1);
+struct vec2i *psvec2i_snap_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i);
+struct vec2i *psvec2i_negative(struct vec2i *result, struct vec2i *vec2i0);
+struct vec2i *psvec2i_abs(struct vec2i *result, struct vec2i *vec2i0);
+struct vec2i *psvec2i_max(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1);
+struct vec2i *psvec2i_min(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1);
+struct vec2i *psvec2i_clamp(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1, struct vec2i *vec2i2);
+struct vec2i *psvec2i_tangent(struct vec2i *result, struct vec2i *vec2i0);
+bool psvec3i_is_zero(struct vec3i *vec3i0);
+bool psvec3i_is_equal(struct vec3i *vec3i0, struct vec3i *vec3i1);
+struct vec3i *psvec3i(struct vec3i *result, mint_t x, mint_t y, mint_t z);
+struct vec3i *psvec3i_assign(struct vec3i *result, struct vec3i *vec3i0);
+#if defined(MATHC_USE_FLOATING_POINT)
+struct vec3i *psvec3i_assign_vec3(struct vec3i *result, struct vec3 *vec30);
+#endif
+struct vec3i *psvec3i_zero(struct vec3i *result);
+struct vec3i *psvec3i_one(struct vec3i *result);
+struct vec3i *psvec3i_sign(struct vec3i *result, struct vec3i *vec3i0);
+struct vec3i *psvec3i_add(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
+struct vec3i *psvec3i_add_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i);
+struct vec3i *psvec3i_subtract(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
+struct vec3i *psvec3i_subtract_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i);
+struct vec3i *psvec3i_multiply(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
+struct vec3i *psvec3i_multiply_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i);
+struct vec3i *psvec3i_divide(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
+struct vec3i *psvec3i_divide_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i);
+struct vec3i *psvec3i_snap(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
+struct vec3i *psvec3i_snap_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i);
+struct vec3i *psvec3i_cross(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
+struct vec3i *psvec3i_negative(struct vec3i *result, struct vec3i *vec3i0);
+struct vec3i *psvec3i_abs(struct vec3i *result, struct vec3i *vec3i0);
+struct vec3i *psvec3i_max(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
+struct vec3i *psvec3i_min(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
+struct vec3i *psvec3i_clamp(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1, struct vec3i *vec3i2);
+bool psvec4i_is_zero(struct vec4i *vec4i0);
+bool psvec4i_is_equal(struct vec4i *vec4i0, struct vec4i *vec4i1);
+struct vec4i *psvec4i(struct vec4i *result, mint_t x, mint_t y, mint_t z, mint_t w);
+struct vec4i *psvec4i_assign(struct vec4i *result, struct vec4i *vec4i0);
+#if defined(MATHC_USE_FLOATING_POINT)
+struct vec4i *psvec4i_assign_vec4(struct vec4i *result, struct vec4 *vec40);
+#endif
+struct vec4i *psvec4i_zero(struct vec4i *result);
+struct vec4i *psvec4i_one(struct vec4i *result);
+struct vec4i *psvec4i_sign(struct vec4i *result, struct vec4i *vec4i0);
+struct vec4i *psvec4i_add(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1);
+struct vec4i *psvec4i_add_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i);
+struct vec4i *psvec4i_subtract(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1);
+struct vec4i *psvec4i_subtract_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i);
+struct vec4i *psvec4i_multiply(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1);
+struct vec4i *psvec4i_multiply_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i);
+struct vec4i *psvec4i_divide(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1);
+struct vec4i *psvec4i_divide_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i);
+struct vec4i *psvec4i_snap(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1);
+struct vec4i *psvec4i_snap_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i);
+struct vec4i *psvec4i_negative(struct vec4i *result, struct vec4i *vec4i0);
+struct vec4i *psvec4i_abs(struct vec4i *result, struct vec4i *vec4i0);
+struct vec4i *psvec4i_max(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1);
+struct vec4i *psvec4i_min(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1);
+struct vec4i *psvec4i_clamp(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1, struct vec4i *vec4i2);
+#endif
+#if defined(MATHC_USE_FLOATING_POINT)
+bool psvec2_is_zero(struct vec2 *vec20);
+bool psvec2_is_equal(struct vec2 *vec20, struct vec2 *vec21);
+struct vec2 *psvec2(struct vec2 *result, mfloat_t x, mfloat_t y);
+struct vec2 *psvec2_assign(struct vec2 *result, struct vec2 *vec20);
+#if defined(MATHC_USE_INT)
+struct vec2 *psvec2_assign_vec2i(struct vec2 *result, struct vec2i *vec2i0);
+#endif
+struct vec2 *psvec2_zero(struct vec2 *result);
+struct vec2 *psvec2_one(struct vec2 *result);
+struct vec2 *psvec2_sign(struct vec2 *result, struct vec2 *vec20);
+struct vec2 *psvec2_add(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
+struct vec2 *psvec2_add_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f);
+struct vec2 *psvec2_subtract(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
+struct vec2 *psvec2_subtract_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f);
+struct vec2 *psvec2_multiply(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
+struct vec2 *psvec2_multiply_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f);
+struct vec2 *psvec2_multiply_mat2(struct vec2 *result, struct vec2 *vec20, struct mat2 *mat20);
+struct vec2 *psvec2_divide(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
+struct vec2 *psvec2_divide_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f);
+struct vec2 *psvec2_snap(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
+struct vec2 *psvec2_snap_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f);
+struct vec2 *psvec2_negative(struct vec2 *result, struct vec2 *vec20);
+struct vec2 *psvec2_abs(struct vec2 *result, struct vec2 *vec20);
+struct vec2 *psvec2_floor(struct vec2 *result, struct vec2 *vec20);
+struct vec2 *psvec2_ceil(struct vec2 *result, struct vec2 *vec20);
+struct vec2 *psvec2_round(struct vec2 *result, struct vec2 *vec20);
+struct vec2 *psvec2_max(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
+struct vec2 *psvec2_min(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
+struct vec2 *psvec2_clamp(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, struct vec2 *vec22);
+struct vec2 *psvec2_normalize(struct vec2 *result, struct vec2 *vec20);
+mfloat_t psvec2_dot(struct vec2 *vec20, struct vec2 *vec21);
+struct vec2 *psvec2_project(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
+struct vec2 *psvec2_slide(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
+struct vec2 *psvec2_reflect(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
+struct vec2 *psvec2_tangent(struct vec2 *result, struct vec2 *vec20);
+struct vec2 *psvec2_rotate(struct vec2 *result, struct vec2 *vec20, mfloat_t f);
+struct vec2 *psvec2_lerp(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, mfloat_t f);
+struct vec2 *psvec2_bezier3(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, struct vec2 *vec22, mfloat_t f);
+struct vec2 *psvec2_bezier4(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, struct vec2 *vec22, struct vec2 *vec23, mfloat_t f);
+mfloat_t psvec2_angle(struct vec2 *vec20);
+mfloat_t psvec2_length(struct vec2 *vec20);
+mfloat_t psvec2_length_squared(struct vec2 *vec20);
+mfloat_t psvec2_distance(struct vec2 *vec20, struct vec2 *vec21);
+mfloat_t psvec2_distance_squared(struct vec2 *vec20, struct vec2 *vec21);
+bool psvec3_is_zero(struct vec3 *vec30);
+bool psvec3_is_equal(struct vec3 *vec30, struct vec3 *vec31);
+struct vec3 *psvec3(struct vec3 *result, mfloat_t x, mfloat_t y, mfloat_t z);
+struct vec3 *psvec3_assign(struct vec3 *result, struct vec3 *vec30);
+#if defined(MATHC_USE_INT)
+struct vec3 *psvec3_assign_vec3i(struct vec3 *result, struct vec3i *vec3i0);
+#endif
+struct vec3 *psvec3_zero(struct vec3 *result);
+struct vec3 *psvec3_one(struct vec3 *result);
+struct vec3 *psvec3_sign(struct vec3 *result, struct vec3 *vec30);
+struct vec3 *psvec3_add(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
+struct vec3 *psvec3_add_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f);
+struct vec3 *psvec3_subtract(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
+struct vec3 *psvec3_subtract_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f);
+struct vec3 *psvec3_multiply(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
+struct vec3 *psvec3_multiply_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f);
+struct vec3 *psvec3_multiply_mat3(struct vec3 *result, struct vec3 *vec30, struct mat3 *mat30);
+struct vec3 *psvec3_divide(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
+struct vec3 *psvec3_divide_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f);
+struct vec3 *psvec3_snap(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
+struct vec3 *psvec3_snap_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f);
+struct vec3 *psvec3_negative(struct vec3 *result, struct vec3 *vec30);
+struct vec3 *psvec3_abs(struct vec3 *result, struct vec3 *vec30);
+struct vec3 *psvec3_floor(struct vec3 *result, struct vec3 *vec30);
+struct vec3 *psvec3_ceil(struct vec3 *result, struct vec3 *vec30);
+struct vec3 *psvec3_round(struct vec3 *result, struct vec3 *vec30);
+struct vec3 *psvec3_max(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
+struct vec3 *psvec3_min(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
+struct vec3 *psvec3_clamp(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32);
+struct vec3 *psvec3_cross(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
+struct vec3 *psvec3_normalize(struct vec3 *result, struct vec3 *vec30);
+mfloat_t psvec3_dot(struct vec3 *vec30, struct vec3 *vec31);
+struct vec3 *psvec3_project(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
+struct vec3 *psvec3_slide(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
+struct vec3 *psvec3_reflect(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
+struct vec3 *psvec3_lerp(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, mfloat_t f);
+struct vec3 *psvec3_bezier3(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32, mfloat_t f);
+struct vec3 *psvec3_bezier4(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32, struct vec3 *vec33, mfloat_t f);
+mfloat_t psvec3_length(struct vec3 *vec30);
+mfloat_t psvec3_length_squared(struct vec3 *vec30);
+mfloat_t psvec3_distance(struct vec3 *vec30, struct vec3 *vec31);
+mfloat_t psvec3_distance_squared(struct vec3 *vec30, struct vec3 *vec31);
+bool psvec4_is_zero(struct vec4 *vec40);
+bool psvec4_is_equal(struct vec4 *vec40, struct vec4 *vec41);
+struct vec4 *psvec4(struct vec4 *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);
+struct vec4 *psvec4_assign(struct vec4 *result, struct vec4 *vec40);
+#if defined(MATHC_USE_INT)
+struct vec4 *psvec4_assign_vec4i(struct vec4 *result, struct vec4i *vec4i0);
+#endif
+struct vec4 *psvec4_zero(struct vec4 *result);
+struct vec4 *psvec4_one(struct vec4 *result);
+struct vec4 *psvec4_sign(struct vec4 *result, struct vec4 *vec40);
+struct vec4 *psvec4_add(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41);
+struct vec4 *psvec4_add_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f);
+struct vec4 *psvec4_subtract(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41);
+struct vec4 *psvec4_subtract_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f);
+struct vec4 *psvec4_multiply(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41);
+struct vec4 *psvec4_multiply_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f);
+struct vec4 *psvec4_multiply_mat4(struct vec4 *result, struct vec4 *vec40, struct mat4 *mat40);
+struct vec4 *psvec4_divide(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41);
+struct vec4 *psvec4_divide_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f);
+struct vec4 *psvec4_snap(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41);
+struct vec4 *psvec4_snap_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f);
+struct vec4 *psvec4_negative(struct vec4 *result, struct vec4 *vec40);
+struct vec4 *psvec4_abs(struct vec4 *result, struct vec4 *vec40);
+struct vec4 *psvec4_floor(struct vec4 *result, struct vec4 *vec40);
+struct vec4 *psvec4_ceil(struct vec4 *result, struct vec4 *vec40);
+struct vec4 *psvec4_round(struct vec4 *result, struct vec4 *vec40);
+struct vec4 *psvec4_max(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41);
+struct vec4 *psvec4_min(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41);
+struct vec4 *psvec4_clamp(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41, struct vec4 *vec42);
+struct vec4 *psvec4_normalize(struct vec4 *result, struct vec4 *vec40);
+struct vec4 *psvec4_lerp(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41, mfloat_t f);
+bool psquat_is_zero(struct quat *quat0);
+bool psquat_is_equal(struct quat *quat0, struct quat *quat1);
+struct quat *psquat(struct quat *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);
+struct quat *psquat_assign(struct quat *result, struct quat *quat0);
+struct quat *psquat_zero(struct quat *result);
+struct quat *psquat_null(struct quat *result);
+struct quat *psquat_multiply(struct quat *result, struct quat *quat0, struct quat *quat1);
+struct quat *psquat_multiply_f(struct quat *result, struct quat *quat0, mfloat_t f);
+struct quat *psquat_divide(struct quat *result, struct quat *quat0, struct quat *quat1);
+struct quat *psquat_divide_f(struct quat *result, struct quat *quat0, mfloat_t f);
+struct quat *psquat_negative(struct quat *result, struct quat *quat0);
+struct quat *psquat_conjugate(struct quat *result, struct quat *quat0);
+struct quat *psquat_inverse(struct quat *result, struct quat *quat0);
+struct quat *psquat_normalize(struct quat *result, struct quat *quat0);
+mfloat_t psquat_dot(struct quat *quat0, struct quat *quat1);
+struct quat *psquat_power(struct quat *result, struct quat *quat0, mfloat_t exponent);
+struct quat *psquat_from_axis_angle(struct quat *result, struct vec3 *vec30, mfloat_t angle);
+struct quat *psquat_from_vec3(struct quat *result, struct vec3 *vec30, struct vec3 *vec31);
+struct quat *psquat_from_mat4(struct quat *result, struct mat4 *mat40);
+struct quat *psquat_lerp(struct quat *result, struct quat *quat0, struct quat *quat1, mfloat_t f);
+struct quat *psquat_slerp(struct quat *result, struct quat *quat0, struct quat *quat1, mfloat_t f);
+mfloat_t psquat_length(struct quat *quat0);
+mfloat_t psquat_length_squared(struct quat *quat0);
+mfloat_t psquat_angle(struct quat *quat0, struct quat *quat1);
+struct mat2 *psmat2(struct mat2 *result, mfloat_t m11, mfloat_t m12, mfloat_t m21, mfloat_t m22);
+struct mat2 *psmat2_zero(struct mat2 *result);
+struct mat2 *psmat2_identity(struct mat2 *result);
+mfloat_t psmat2_determinant(struct mat2 *mat20);
+struct mat2 *psmat2_assign(struct mat2 *result, struct mat2 *mat20);
+struct mat2 *psmat2_negative(struct mat2 *result, struct mat2 *mat20);
+struct mat2 *psmat2_transpose(struct mat2 *result, struct mat2 *mat20);
+struct mat2 *psmat2_cofactor(struct mat2 *result, struct mat2 *mat20);
+struct mat2 *psmat2_adjugate(struct mat2 *result, struct mat2 *mat20);
+struct mat2 *psmat2_multiply(struct mat2 *result, struct mat2 *mat20, struct mat2 *mat21);
+struct mat2 *psmat2_multiply_f(struct mat2 *result, struct mat2 *mat20, mfloat_t f);
+struct mat2 *psmat2_inverse(struct mat2 *result, struct mat2 *mat20);
+struct mat2 *psmat2_scaling(struct mat2 *result, struct vec2 *vec20);
+struct mat2 *psmat2_scale(struct mat2 *result, struct mat2 *mat20, struct vec2 *vec20);
+struct mat2 *psmat2_rotation_z(struct mat2 *result, mfloat_t f);
+struct mat2 *psmat2_lerp(struct mat2 *result, struct mat2 *mat20, struct mat2 *mat21, mfloat_t f);
+struct mat3 *psmat3(struct mat3 *result, mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m31, mfloat_t m32, mfloat_t m33);
+struct mat3 *psmat3_zero(struct mat3 *result);
+struct mat3 *psmat3_identity(struct mat3 *result);
+mfloat_t psmat3_determinant(struct mat3 *mat30);
+struct mat3 *psmat3_assign(struct mat3 *result, struct mat3 *mat30);
+struct mat3 *psmat3_negative(struct mat3 *result, struct mat3 *mat30);
+struct mat3 *psmat3_transpose(struct mat3 *result, struct mat3 *mat30);
+struct mat3 *psmat3_cofactor(struct mat3 *result, struct mat3 *mat30);
+struct mat3 *psmat3_multiply(struct mat3 *result, struct mat3 *mat30, struct mat3 *mat31);
+struct mat3 *psmat3_multiply_f(struct mat3 *result, struct mat3 *mat30, mfloat_t f);
+struct mat3 *psmat3_inverse(struct mat3 *result, struct mat3 *mat30);
+struct mat3 *psmat3_scaling(struct mat3 *result, struct vec3 *vec30);
+struct mat3 *psmat3_scale(struct mat3 *result, struct mat3 *mat30, struct vec3 *vec30);
+struct mat3 *psmat3_rotation_x(struct mat3 *result, mfloat_t f);
+struct mat3 *psmat3_rotation_y(struct mat3 *result, mfloat_t f);
+struct mat3 *psmat3_rotation_z(struct mat3 *result, mfloat_t f);
+struct mat3 *psmat3_rotation_axis(struct mat3 *result, struct vec3 *vec30, mfloat_t f);
+struct mat3 *psmat3_rotation_quat(struct mat3 *result, struct quat *quat0);
+struct mat3 *psmat3_lerp(struct mat3 *result, struct mat3 *mat30, struct mat3 *mat31, mfloat_t f);
+struct mat4 *psmat4(struct mat4 *result, mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m14, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m24, mfloat_t m31, mfloat_t m32, mfloat_t m33, mfloat_t m34, mfloat_t m41, mfloat_t m42, mfloat_t m43, mfloat_t m44);
+struct mat4 *psmat4_zero(struct mat4 *result);
+struct mat4 *psmat4_identity(struct mat4 *result);
+mfloat_t psmat4_determinant(struct mat4 *mat40);
+struct mat4 *psmat4_assign(struct mat4 *result, struct mat4 *mat40);
+struct mat4 *psmat4_negative(struct mat4 *result, struct mat4 *mat40);
+struct mat4 *psmat4_transpose(struct mat4 *result, struct mat4 *mat40);
+struct mat4 *psmat4_cofactor(struct mat4 *result, struct mat4 *mat40);
+struct mat4 *psmat4_rotation_x(struct mat4 *result, mfloat_t f);
+struct mat4 *psmat4_rotation_y(struct mat4 *result, mfloat_t f);
+struct mat4 *psmat4_rotation_z(struct mat4 *result, mfloat_t f);
+struct mat4 *psmat4_rotation_axis(struct mat4 *result, struct vec3 *vec30, mfloat_t f);
+struct mat4 *psmat4_rotation_quat(struct mat4 *result, struct quat *quat0);
+struct mat4 *psmat4_translation(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30);
+struct mat4 *psmat4_translate(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30);
+struct mat4 *psmat4_scaling(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30);
+struct mat4 *psmat4_scale(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30);
+struct mat4 *psmat4_multiply(struct mat4 *result, struct mat4 *mat40, struct mat4 *mat41);
+struct mat4 *psmat4_multiply_f(struct mat4 *result, struct mat4 *mat40, mfloat_t f);
+struct mat4 *psmat4_inverse(struct mat4 *result, struct mat4 *mat40);
+struct mat4 *psmat4_lerp(struct mat4 *result, struct mat4 *mat40, struct mat4 *mat41, mfloat_t f);
+struct mat4 *psmat4_look_at(struct mat4 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32);
+struct mat4 *psmat4_ortho(struct mat4 *result, mfloat_t l, mfloat_t r, mfloat_t b, mfloat_t t, mfloat_t n, mfloat_t f);
+struct mat4 *psmat4_perspective(struct mat4 *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n, mfloat_t f);
+struct mat4 *psmat4_perspective_fov(struct mat4 *result, mfloat_t fov, mfloat_t w, mfloat_t h, mfloat_t n, mfloat_t f);
+struct mat4 *psmat4_perspective_infinite(struct mat4 *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n);
+#endif
+#endif
 #endif
diff --git a/run_tests.sh b/run_tests.sh
deleted file mode 100755
index 6be4c21..0000000
--- a/run_tests.sh
+++ /dev/null
@@ -1,17 +0,0 @@
-if [ -n $CC ]
-then
-  if [ $CC=clang ]
-  then
-    clang test.c -include mathc.h -c mathc.c && clang -o test_clang test.o mathc.o -lm && chmod +x test_clang
-    ./test_clang
-  elif [ $CC=gcc ]
-  then
-    gcc -o test_gcc test.c mathc.c -I. -lm && chmod +x test_gcc
-    ./test_gcc
-  else
-    echo -e "unrecognized compiler"
-    exit
-  fi
-else
-  echo -e "CC is not defined, compiler cannot be identified"
-fi
diff --git a/test.c b/test.c
deleted file mode 100644
index d0891f2..0000000
--- a/test.c
+++ /dev/null
@@ -1,462 +0,0 @@
-/*
-Copyright (C) 2016 Felipe Ferreira da Silva
-
-This software is provided 'as-is', without any express or implied warranty. In
-no event will the authors be held liable for any damages arising from the use of
-this software.
-
-Permission is granted to anyone to use this software for any purpose, including
-commercial applications, and to alter it and redistribute it freely, subject to
-the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not claim
-     that you wrote the original software. If you use this software in a
-     product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-*/
-
-#include <stdio.h>
-#include <float.h>
-#include <stdbool.h>
-#include <stdint.h>
-#include "mathc.h"
-
-const float epsilon = FLT_EPSILON;
-
-struct cerror {
-	int32_t failed;
-	int32_t passed;
-	int32_t passed_with_e10;
-	int32_t passed_with_e100;
-	int32_t passed_with_e1000;
-};
-
-void printf_bool_test(struct cerror *error, char *msg, bool e, bool r)
-{
-	if (e) {
-		printf("%s:\n\tExpected true\n\t", msg);
-	} else {
-		printf("%s:\n\tExpected false\n\t", msg);
-	}
-	if (r) {
-		printf("  Actual true\t");
-	} else {
-		printf("  Actual false\t");
-	}
-
-	if (e == r) {
-		error->passed = error->passed + 1;
-		printf("~passed~\n\n");
-	} else {
-		error->failed = error->failed + 1;
-		printf("~failed~\n\n");
-	}
-}
-
-void printf_1f_test(struct cerror *error, char *msg, float e1, float r1)
-{
-	bool done = false;
-	printf("%s:\n\tExpected % .4f\n\t  Actual  % .4f\t", msg, e1, r1);
-	if (nearly_equal(e1, r1, epsilon)) {
-		error->passed = error->passed + 1;
-		done = true;
-		printf("~passed~\n\n");
-	}
-	if (!done && nearly_equal(e1, r1, epsilon * 10.0f)) {
-		error->passed_with_e10 = error->passed_with_e10 + 1;
-		done = true;
-		printf("~passed with epsilon * 10.0~\n\n");
-	}
-	if (!done && nearly_equal(e1, r1, epsilon * 100.0f)) {
-		error->passed_with_e100 = error->passed_with_e100 + 1;
-		done = true;
-		printf("~passed with epsilon * 100.0~\n\n");
-	}
-	if (!done && nearly_equal(e1, r1, epsilon * 1000.0f)) {
-		error->passed_with_e1000 = error->passed_with_e1000 + 1;
-		done = true;
-		printf("~passed with epsilon * 1000.0~\n\n");
-	}
-	if (!done) {
-		error->failed = error->failed + 1;
-		printf("~failed~\n\n");
-	}
-}
-
-void printf_2f_test(struct cerror *error, char *msg, float e1, float e2, float r1, float r2)
-{
-	bool done = false;
-	printf("%s:\n\tExpected % .4f, % .4f\n\t  Actual % .4f, % .4f\t", msg, e1, e2, r1, r2);
-	if (nearly_equal(e1, r1, epsilon) && nearly_equal(e2, r2, epsilon)) {
-		error->passed = error->passed + 1;
-		done = true;
-		printf("~passed~\n\n");
-	}
-	if (!done && nearly_equal(e1, r1, epsilon * 10.0f) && nearly_equal(e2, r2, epsilon * 10.0f)) {
-		error->passed_with_e10 = error->passed_with_e10 + 1;
-		done = true;
-		printf("~passed with epsilon * 10.0~\n\n");
-	}
-	if (!done && nearly_equal(e1, r1, epsilon * 100.0f) && nearly_equal(e2, r2, epsilon * 100.0f)) {
-		error->passed_with_e100 = error->passed_with_e100 + 1;
-		done = true;
-		printf("~passed with epsilon * 100.0~\n\n");
-	}
-	if (!done && nearly_equal(e1, r1, epsilon * 1000.0f) && nearly_equal(e2, r2, epsilon * 1000.0f)) {
-		error->passed_with_e1000 = error->passed_with_e1000 + 1;
-		done = true;
-		printf("~passed with epsilon * 1000.0~\n\n");
-	}
-	if (!done) {
-		error->failed = error->failed + 1;
-		printf("~failed~\n\n");
-	}
-}
-
-void printf_3f_test(struct cerror *error, char *msg, float e1, float e2, float e3, float r1, float r2, float r3)
-{
-	bool done = false;
-	printf("%s:\n\tExpected % .4f, % .4f, % .4f\n\t  Actual % .4f, % .4f, % .4f\t", msg, e1, e2, e3, r1, r2, r3);
-	if (nearly_equal(e1, r1, epsilon) && nearly_equal(e2, r2, epsilon) && nearly_equal(e3, r3, epsilon)) {
-		error->passed = error->passed + 1;
-		done = true;
-		printf("~passed~\n\n");
-	}
-	if (!done && nearly_equal(e1, r1, epsilon * 10.0f) && nearly_equal(e2, r2, epsilon * 10.0f) && nearly_equal(e3, r3, epsilon * 10.0f)) {
-		error->passed_with_e10 = error->passed_with_e10 + 1;
-		done = true;
-		printf("~passed with epsilon * 10.0~\n\n");
-	}
-	if (!done && nearly_equal(e1, r1, epsilon * 100.0f) && nearly_equal(e2, r2, epsilon * 100.0f) && nearly_equal(e2, r2, epsilon * 100.0f)) {
-		error->passed_with_e100 = error->passed_with_e100 + 1;
-		done = true;
-		printf("~passed with epsilon * 100.0~\n\n");
-	}
-	if (!done && nearly_equal(e1, r1, epsilon * 1000.0f) && nearly_equal(e2, r2, epsilon * 1000.0f) && nearly_equal(e2, r2, epsilon * 1000.0f)) {
-		error->passed_with_e1000 = error->passed_with_e1000 + 1;
-		done = true;
-		printf("~passed with epsilon * 1000.0~\n\n");
-	}
-	if (!done) {
-		error->failed = error->failed + 1;
-		printf("~failed~\n\n");
-	}
-}
-
-void printf_4f_test(struct cerror *error, char *msg, float e1, float e2, float e3, float e4, float r1, float r2, float r3, float r4)
-{
-	bool done = false;
-	printf("%s:\n\tExpected % .9f, % .9f, % .9f, % .9f\n\t  Actual % .9f, % .9f, % .9f, % .9f\t", msg, e1, e2, e3, e4, r1, r2, r3, r4);
-	if (nearly_equal(e1, r1, epsilon) && nearly_equal(e2, r2, epsilon) && nearly_equal(e3, r3, epsilon) && nearly_equal(e3, r3, epsilon)) {
-		error->passed = error->passed + 1;
-		done = true;
-		printf("~passed~\n\n");
-	}
-	if (!done && nearly_equal(e1, r1, epsilon * 10.0f) && nearly_equal(e2, r2, epsilon * 10.0f) && nearly_equal(e3, r3, epsilon * 10.0f) && nearly_equal(e3, r3, epsilon * 10.0f)) {
-		error->passed_with_e10 = error->passed_with_e10 + 1;
-		done = true;
-		printf("~passed with epsilon * 10.0~\n\n");
-	}
-	if (!done && nearly_equal(e1, r1, epsilon * 100.0f) && nearly_equal(e2, r2, epsilon * 100.0f) && nearly_equal(e3, r3, epsilon * 100.0f) && nearly_equal(e4, r4, epsilon * 100.0f)) {
-		error->passed_with_e100 = error->passed_with_e100 + 1;
-		done = true;
-		printf("~passed with epsilon * 100.0~\n\n");
-	}
-	if (!done && nearly_equal(e1, r1, epsilon * 1000.0f) && nearly_equal(e2, r2, epsilon * 1000.0f) && nearly_equal(e3, r3, epsilon * 1000.0f) && nearly_equal(e4, r4, epsilon * 1000.0f)) {
-		error->passed_with_e1000 = error->passed_with_e1000 + 1;
-		done = true;
-		printf("~passed with epsilon * 1000.0~\n\n");
-	}
-	if (!done) {
-		error->failed = error->failed + 1;
-		printf("~failed~\n\n");
-	}
-}
-
-void vector2_tests(struct cerror *error)
-{
-	struct vec a;
-	struct vec b;
-	struct vec r;
-	float p;
-	printf("\n# Making tests with 2D vectors...\n");
-	a = to_vector2(1.11f, 2.5f);
-	b = to_vector2(0.9f, 1.3f);
-	r = vector2_add(a, b);
-	printf_2f_test(error, "Add two vectors", 2.01f, 3.8f, r.x, r.y);
-	a = to_vector2(1.11f, 2.5f);
-	b = to_vector2(0.9f, 1.3f);
-	r = vector2_subtract(a, b);
-	printf_2f_test(error, "Subtract two vectors", 0.21f, 1.2f, r.x, r.y);
-	a = to_vector2(1.11f, 2.5f);
-	r = vector2_scale(a, 3.3f);
-	printf_2f_test(error, "Scale vector", 3.663f, 8.25f, r.x, r.y);
-	a = to_vector2(1.11f, 2.5f);
-	b = to_vector2(0.9f, 1.3f);
-	r = vector2_multiply(a, b);
-	printf_2f_test(error, "Multiply two vectors", 0.999f, 3.25f, r.x, r.y);
-	a = to_vector2(1.11f, 2.5f);
-	b = to_vector2(0.9f, 1.3f);
-	r = vector2_divide(a, b);
-	printf_2f_test(error, "Divide two vectors", 1.2333333333f, 1.9230769231f, r.x, r.y);
-	a = to_vector2(1.11f, 2.5f);
-	r = vector2_negative(a);
-	printf_2f_test(error, "Negative vector", -1.11f, -2.5f, r.x, r.y);
-	a = to_vector2(1.11f, 2.5f);
-	r = vector2_inverse(a);
-	printf_2f_test(error, "Inverse vector", 0.9009009009f, 0.4f, r.x, r.y);
-	a = to_vector2(-3.33f, 1.1f);
-	r = vector2_abs(a);
-	printf_2f_test(error, "Absolute vector", 3.33f, 1.1f, r.x, r.y);
-	a = to_vector2(1.11f, -2.5f);
-	r = vector2_floor(a);
-	printf_2f_test(error, "Floor vector", 1.0f, -3.0f, r.x, r.y);
-	a = to_vector2(-0.00011f, 3.999999f);
-	r = vector2_floor(a);
-	printf_2f_test(error, "Floor vector", -1.0f, 3.0f, r.x, r.y);
-	a = to_vector2(1.11f, -2.5f);
-	r = vector2_ceil(a);
-	printf_2f_test(error, "Ceil vector", 2.0f, -2.0f, r.x, r.y);
-	a = to_vector2(-0.00011f, 3.999999f);
-	r = vector2_ceil(a);
-	printf_2f_test(error, "Ceil vector", 0.0f, 4.0f, r.x, r.y);
-	a = to_vector2(1.11f, -2.55f);
-	r = vector2_round(a);
-	printf_2f_test(error, "Round vector", 1.0f, -3.0f, r.x, r.y);
-	a = to_vector2(4.31f, -6.65f);
-	b = to_vector2(-3.41f, 2.7f);
-	r = vector2_max(a, b);
-	printf_2f_test(error, "Maximum of vectors", 4.31f, 2.7f, r.x, r.y);
-	a = to_vector2(4.31f, -6.65f);
-	b = to_vector2(-3.41f, 2.7f);
-	r = vector2_min(a, b);
-	printf_2f_test(error, "Minimum of vectors", -3.41f, -6.65f, r.x, r.y);
-	a = to_vector2(4.31f, -6.65f);
-	b = to_vector2(-3.41f, 2.7f);
-	p = vector2_dot(a, b);
-	printf_1f_test(error, "Dot value of vectors", -32.6521f, p);
-	a = to_vector2(2.0f, 2.0f);
-	p = vector2_angle(a);
-	printf_1f_test(error, "Angle (radians) of vector", 0.78539816339745f, p);
-	a = to_vector2(4.31f, -6.65f);
-	p = vector2_angle(a);
-	printf_1f_test(error, "Angle (radians) of vector", -0.99574364682817f, p);
-	a = to_vector2(-5.31f, -7.33f);
-	p = vector2_angle(a);
-	printf_1f_test(error, "Angle (radians) of vector", -2.1977243674756f, p);
-	a = to_vector2(3.33f, 2.0f);
-	p = vector2_length_squared(a);
-	printf_1f_test(error, "Length squared of vector", 15.0889f, p);
-	a = to_vector2(3.33f, 2.0f);
-	p = vector2_length(a);
-	printf_1f_test(error, "Length of vector", 3.8844433321f, p);
-	a = to_vector2(3.33f, 2.0f);
-	r = vector2_normalize(a);
-	printf_2f_test(error, "Normalize vector", 0.8572664271f, 0.514874731f, r.x, r.y);
-	a = to_vector2(1.0f, -1.0f);
-	b = to_vector2(0.0f, 1.0f);
-	r = vector2_slide(a, b);
-	printf_2f_test(error, "Slide vector by normal", 1.0f, 0.0f, r.x, r.y);
-	a = to_vector2(-2.0f, 0.0f);
-	b = vector2_normalize(to_vector2(1.0f, 1.0f));
-	r = vector2_slide(a, b);
-	printf_2f_test(error, "Slide vector by normal", -1.0f, 1.0f, r.x, r.y);
-	a = to_vector2(1.0f, -1.0f);
-	b = to_vector2(-1.0f, 0.0f);
-	r = vector2_reflect(a, b);
-	printf_2f_test(error, "Reflect vector by another", -1.0f, -1.0f, r.x, r.y);
-	a = to_vector2(1.0f, 1.0f);
-	b = to_vector2(0.0f, -1.0f);
-	r = vector2_reflect(a, b);
-	printf_2f_test(error, "Reflect vector by another", 1.0f, -1.0f, r.x, r.y);
-	a = to_vector2(2.0f, 1.0f);
-	r = vector2_tangent(a);
-	printf_2f_test(error, "Vector tangent", 1.0f, -2.0f, r.x, r.y);
-	a = to_vector2(1.0f, 0.0f);
-	r = vector2_rotate(a, 90.0f * M_PIF / 180.0f);
-	printf_2f_test(error, "Rotate vector", 0.0f, 1.0f, r.x, r.y);
-	a = to_vector2(1.0f, 0.0f);
-	r = vector2_rotate(a, 45.0f * M_PIF / 180.0f);
-	printf_2f_test(error, "Rotate vector", 0.707106781f,0.707106781f, r.x, r.y);
-	a = to_vector2(1.0f, 0.0f);
-	r = vector2_rotate(a, 130.0f * M_PIF / 180.0f);
-	printf_2f_test(error, "Rotate vector", -0.64278761f,0.766044443f, r.x, r.y);
-	a = to_vector2(-7.0f, -4.0f);
-	b = to_vector2(17.0f, 6.5f);
-	p = vector2_distance_to(a, b);
-	printf_1f_test(error, "Distance between vector", 26.196374f, p);
-	a = to_vector2(-7.0f, -4.0f);
-	b = to_vector2(17.0f, 6.5f);
-	p = vector2_distance_squared_to(a, b);
-	printf_1f_test(error, "Distance squared between vector", 686.2500107479f, p);
-	a = to_vector2(-7.0f, -4.0f);
-	b = to_vector2(17.0f, 6.5f);
-	r = vector2_linear_interpolation(a, b, 0.33f);
-	printf_2f_test(error, "Linear interpolation between vectors", 0.92f, -0.535f, r.x, r.y);
-}
-
-void vector3_tests(struct cerror *error)
-{
-	struct vec a;
-	struct vec b;
-	struct vec r;
-	float p;
-	printf("\n# Making tests with 3D vectors...\n");
-	a = to_vector3(1.11f, 2.5f, 0.0003f);
-	b = to_vector3(0.9f, 1.3f, 3.999999f);
-	r = vector3_add(a, b);
-	printf_3f_test(error, "Add two vectors", 2.01f, 3.8f, 4.000299f, r.x, r.y, r.z);
-	a = to_vector3(1.11f, 2.5f, 0.0003f);
-	b = to_vector3(0.9f, 1.3f, 3.999999f);
-	r = vector3_subtract(a, b);
-	printf_3f_test(error, "Subtract vectors", 0.21f, 1.2f, -3.999699f, r.x, r.y, r.z);
-	a = to_vector3(1.11f, 2.5f, 0.0003f);
-	r = vector3_scale(a, 3.3f);
-	printf_3f_test(error, "Scale vector", 3.663f, 8.25f, 0.000990f, r.x, r.y, r.z);
-	a = to_vector3(1.11f, 2.5f, 0.0003f);
-	b = to_vector3(0.9f, 1.3f, 3.999999f);
-	r = vector3_multiply(a, b);
-	printf_3f_test(error, "Multiply vectors", 0.999f, 3.25f, 0.001200f, r.x, r.y, r.z);
-	a = to_vector3(1.11f, 2.5f, 0.0003f);
-	b = to_vector3(0.9f, 1.3f, 3.999999f);
-	r = vector3_divide(a, b);
-	printf_3f_test(error, "Divide vectors", 1.2333333333f, 1.9230769231f, 0.000075f, r.x, r.y, r.z);
-	a = to_vector3(1.11f, 2.5f, 0.0003f);
-	r = vector3_negative(a);
-	printf_3f_test(error, "Negative vector", -1.11f, -2.5f, -0.0003f, r.x, r.y, r.z);
-	a = to_vector3(1.11f, 2.5f, 0.0003f);
-	r = vector3_inverse(a);
-	printf_3f_test(error, "Inverse vector", 0.9009009009f, 0.4f, 3333.3333333333f, r.x, r.y, r.z);
-	a = to_vector3(-3.33f, 1.1f, -0.00001f);
-	r = vector3_abs(a);
-	printf_3f_test(error, "Absolute vector", 3.33f, 1.1f, 0.00001f, r.x, r.y, r.z);
-	a = to_vector3(1.11f, -2.5f, 0.0003f);
-	r = vector3_floor(a);
-	printf_3f_test(error, "Floor vector", 1.0f, -3.0f, 0.0f, r.x, r.y, r.z);
-	a = to_vector3(-0.00011f, 3.999999f, -0.99999f);
-	r = vector3_floor(a);
-	printf_3f_test(error, "Floor vector", -1.0f, 3.0f, -1.0f, r.x, r.y, r.z);
-	a = to_vector3(1.11f, -2.5f, 9.99999f);
-	r = vector3_ceil(a);
-	printf_3f_test(error, "Ceil vector", 2.0f, -2.0f, 10.0f, r.x, r.y, r.z);
-	a = to_vector3(-0.00011f, 3.999999f, 0.0000001f);
-	r = vector3_ceil(a);
-	printf_3f_test(error, "Ceil vector", 0.0f, 4.0f, 1.0f, r.x, r.y, r.z);
-	a = to_vector3(1.11f, -2.55f, 3.50000001f);
-	r = vector3_round(a);
-	printf_3f_test(error, "Round vector", 1.0f, -3.0f, 4.0f, r.x, r.y, r.z);
-	a = to_vector3(544.00001f, -233333.51f, 7999.50000001f);
-	r = vector3_round(a);
-	printf_3f_test(error, "Round vector", 544.0f, -233334.0f, 8000.0f, r.x, r.y, r.z);
-	a = to_vector3(4.31f, -6.65f, 4.5f);
-	b = to_vector3(-3.41f, 2.7f, -5.0f);
-	r = vector3_max(a, b);
-	printf_3f_test(error, "Maximum between vectors", 4.31f, 2.7f, 4.5f, r.x, r.y, r.z);
-	a = to_vector3(4.31f, -6.65f, 4.5f);
-	b = to_vector3(-3.41f, 2.7f, -5.0f);
-	r = vector3_min(a, b);
-	printf_3f_test(error, "Minimum between vectors", -3.41f, -6.65f, -5.0f, r.x, r.y, r.z);
-	a = to_vector3(4.31f, -6.65f, 1.0f);
-	b = to_vector3(-3.41f, 2.7f, 2.0f);
-	p = vector3_dot(a, b);
-	printf_1f_test(error, "Dot value of vectors", -30.652100f, p);
-	a = to_vector3(3.33f, 2.0f, 3.0f);
-	p = vector3_length_squared(a);
-	printf_1f_test(error, "Length squared of vector", 24.088900f, p);
-	a = to_vector3(3.33f, 2.0f, 3.0f);
-	p = vector3_length(a);
-	printf_1f_test(error, "Length of vector", 4.908044f, p);
-	a = to_vector3(3.33f, 2.0f, 5.0f);
-	r = vector3_normalize(a);
-	printf_3f_test(error, "Normalize vector", 0.525935f, 0.315877f, 0.789692f, r.x, r.y, r.z);
-	a = to_vector3(-7.0f, -4.0f, 99.9f);
-	b = to_vector3(17.0f, 6.5f, 103.33f);
-	p = vector3_distance_to(a, b);
-	printf_1f_test(error, "Distance between vectors", 26.419971f, p);
-	a = to_vector3(-7.0f, -4.0f, 99.9f);
-	b = to_vector3(17.0f, 6.5f, 103.33f);
-	p = vector3_distance_squared_to(a, b);
-	printf_1f_test(error, "Distance squared between vectors", 698.014893f, p);
-	a = to_vector3(-7.0f, -4.0f, 99.9f);
-	b = to_vector3(17.0f, 6.5f, 103.33f);
-	r = vector3_linear_interpolation(a, b, 0.33f);
-	printf_3f_test(error, "Linear interpolation between vectors", 0.92f, -0.535f, 101.031898f, r.x, r.y, r.z);
-}
-
-void quaternion_tests(struct cerror *error)
-{
-	struct vec a;
-	struct vec b;
-	struct vec r;
-	float p;
-	printf("\n# Making tests with quaternions...\n");
-	a = to_quaternion(0.0f, 1.0f, 0.0f, 1.0f);
-	r = quaternion_normalize(a);
-	printf_4f_test(error, "Normalize quaternion", 0.7071067812f, 0.0, 0.7071067812f, 0.0f, r.w, r.x, r.y, r.z);
-	a = to_vector3(1.0f, 0.0f, 0.0f);
-	r = quaternion_from_axis_angle(a, M_PIF_2);
-	printf_4f_test(error, "Quaternion from axis-angle", 0.707099974f, 0.707099974f, 0.0f, 0.0f, r.w, r.x, r.y, r.z);
-	a = to_quaternion(0.7071067812f, 0.0f, 0.0f, 0.7071067812f);
-	r = quaternion_to_axis_angle(a);
-	printf_4f_test(error, "Quaternion to axis-angle", 1.0f, 0.0f, 0.0f, 1.570796371f, r.x, r.y, r.z, r.w);
-}
-
-void matrix_tests(struct cerror *error)
-{
-	struct mat a;
-	struct mat b;
-	struct mat r;
-	float p;
-	printf("\n# Making tests with matrices...\n");
-	a = matrix_identity();
-	b = matrix_identity();
-	r = matrix_multiply_matrix(a, b);
-}
-
-void intersection_tests(struct cerror *error)
-{
-	struct vec a;
-	struct vec b;
-	struct vec c;
-	struct vec d;
-	printf("\n# Making tests with intersection...\n");
-	a = to_vector2(0.0f, 0.0f);
-	b = to_vector2(0.0f, 1.0f);
-	c = to_vector2(1.0f, 0.0f);
-	d = to_vector2(0.5f, 0.5f);
-	printf_bool_test(error, "2D vector in triangle", true, vector2_in_triangle(d, a, b, c));
-	a = to_vector2(0.0f, 0.0f);
-	b = to_vector2(1.0f, 1.0f);
-	c = to_vector2(1.0f, 0.0f);
-	d = to_vector2(0.5f, 0.5f);
-	printf_bool_test(error, "2D vector in triangle", true, vector2_in_triangle(d, a, b, c));
-	a = to_vector2(0.0f, 0.0f);
-	b = to_vector2(1.0f, 1.0f);
-	c = to_vector2(1.0f, 0.0f);
-	d = to_vector2(0.5f, 0.6f);
-	printf_bool_test(error, "2D vector in triangle", false, vector2_in_triangle(d, a, b, c));
-	a = to_vector2(0.0f, 1.0f);
-	b = to_vector2(1.0f, 1.0f);
-	c = to_vector2(1.0f, 0.0f);
-	d = to_vector2(0.5f, 0.4f);
-	printf_bool_test(error, "2D vector in triangle", false, vector2_in_triangle(d, a, b, c));
-}
-
-int main(int argc, char **args)
-{
-	struct cerror error = {0, 0, 0, 0, 0};
-	vector2_tests(&error);
-	vector3_tests(&error);
-	quaternion_tests(&error);
-	matrix_tests(&error);
-	intersection_tests(&error);
-	printf("\nTotal of failed tests: %d\n", error.failed);
-	printf("Total of tests that passed: %d\n", error.passed);
-	printf("Total of tests that passed with epsilon * 10.0: %d\n", error.passed_with_e10);
-	printf("Total of tests that passed with epsilon * 100.0: %d\n", error.passed_with_e100);
-	printf("Total of tests that passed with epsilon * 1000.0: %d\n", error.passed_with_e1000);
-	return error.failed;
-}

From 3b7d3c3d722fddec5dd40642b55f374209ea731f Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 2 Aug 2018 23:32:30 -0300
Subject: [PATCH 071/102] Remove unneeded macro

---
 mathc.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/mathc.h b/mathc.h
index 6b8e96c..0c3ef44 100644
--- a/mathc.h
+++ b/mathc.h
@@ -55,7 +55,6 @@ the following restrictions:
 #define VEC2_SIZE 2
 #define VEC3_SIZE 3
 #define VEC4_SIZE 4
-#define EULER_SIZE 3
 #define QUAT_SIZE 4
 #define MAT2_SIZE 4
 #define MAT3_SIZE 9

From 98105f28366ae007dd8225575ff9b969db331af1 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 2 Aug 2018 23:38:48 -0300
Subject: [PATCH 072/102] Move radians-degrees conversion macros

---
 mathc.c | 4 ++--
 mathc.h | 7 ++-----
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/mathc.c b/mathc.c
index 5174e47..1c755e3 100644
--- a/mathc.c
+++ b/mathc.c
@@ -34,12 +34,12 @@ bool nearly_equal(mfloat_t a, mfloat_t b, mfloat_t epsilon)
 
 mfloat_t to_radians(mfloat_t degrees)
 {
-	return degrees * MPI / MFLOAT_C(180.0);
+	return MRADIANS(degrees);
 }
 
 mfloat_t to_degrees(mfloat_t radians)
 {
-	return radians * MFLOAT_C(180.0) / MPI;
+	return MDEGREES(radians);
 }
 #endif
 
diff --git a/mathc.h b/mathc.h
index 0c3ef44..3ad584b 100644
--- a/mathc.h
+++ b/mathc.h
@@ -154,11 +154,6 @@ typedef double mfloat_t;
 #endif
 #endif
 
-#if defined(MATHC_USE_FLOATING_POINT)
-#define MRADIANS(degrees) (degrees * MPI / MFLOAT_C(180.0))
-#define MDEGREES(radians) (radians * MFLOAT_C(180.0) / MPI)
-#endif
-
 #if defined(MATHC_USE_STRUCT_FUNCTIONS) || defined(MATHC_USE_POINTER_STRUCT_FUNCTIONS)
 #if defined(MATHC_USE_INT)
 struct vec2i {
@@ -396,6 +391,8 @@ struct mat4 {
 #endif
 
 #if defined(MATHC_USE_FLOATING_POINT)
+#define MRADIANS(degrees) (degrees * MPI / MFLOAT_C(180.0))
+#define MDEGREES(radians) (radians * MFLOAT_C(180.0) / MPI)
 bool nearly_equal(mfloat_t a, mfloat_t b, mfloat_t epsilon);
 mfloat_t to_radians(mfloat_t degrees);
 mfloat_t to_degrees(mfloat_t radians);

From 8bf806067a6fd8b20769e000e5baf33713a29b2d Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Fri, 3 Aug 2018 00:41:27 -0300
Subject: [PATCH 073/102] Update README.md

---
 README.md | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/README.md b/README.md
index 5395ed3..c1db8d2 100644
--- a/README.md
+++ b/README.md
@@ -58,6 +58,60 @@ The easing functions are an implementation of the functions presented in [easing
 
 Easing functions take a value inside the range `0.0-1.0` and usually will return a value inside that same range.
 
+## Usage
+
+Creating a "look at" view matrix, useful for 3D programming:
+
+```c
+mfloat_t position[VEC3_SIZE];
+mfloat_t target[VEC3_SIZE];
+mfloat_t up[VEC3_SIZE];
+mfloat_t view[MAT4_SIZE];
+
+mat4_look_at(view,
+	vec3(position, 0.0, 0.0, 10.0),
+	vec3(target, 0.0, 0.0, 0.0),
+	vec3(up, 0.0, 1.0, 0.0));
+```
+
+Creating a perspective projection matrix:
+
+```c
+mfloat_t perspective[MAT4_SIZE];
+
+mat4_perspective(perspective, to_radians(60.0), 1.0, 0.1, 100.0);
+```
+
+Creating a model matrix:
+
+```c
+mfloat_t position[VEC3_SIZE];
+mfloat_t scaling[VEC3_SIZE];
+struct {
+	mfloat_t position[MAT4_SIZE];
+	mfloat_t rotation[MAT4_SIZE];
+	mfloat_t scaling[MAT4_SIZE];
+	mfloat_t model[MAT4_SIZE];
+} matrices;
+
+/* Position */
+mat4_identity(matrices.position);
+mat4_translation(matrices.position,
+	vec3(position, 0.0, 0.0, 0.0));
+/* Rotation */
+mat4_identity(matrices.rotation);
+mat4_rotation_x(matrices.rotation, to_radians(30.0));
+
+/* Scaling */
+mat4_identity(matrices.scaling);
+mat4_translation(matrices.scaling,
+	vec3(scaling, 1.0, 1.0, 1.0));
+
+/* Model matrix */
+mat4_multiply(matrices.model, matrices.scaling, matrices.rotation);
+mat4_multiply(matrices.model, matrices.position, matrices.model);
+```
+
 ## License
 
 Copyright © 2018 Felipe Ferreira da Silva

From 853c7029ef4c53fc413935d5022b97106946c753 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Fri, 3 Aug 2018 00:44:10 -0300
Subject: [PATCH 074/102] Update README.md

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index c1db8d2..9afd7f4 100644
--- a/README.md
+++ b/README.md
@@ -98,6 +98,7 @@ struct {
 mat4_identity(matrices.position);
 mat4_translation(matrices.position,
 	vec3(position, 0.0, 0.0, 0.0));
+
 /* Rotation */
 mat4_identity(matrices.rotation);
 mat4_rotation_x(matrices.rotation, to_radians(30.0));

From 6f913d8d516583219f9566f80b801bf1ddcfd5a2 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Fri, 3 Aug 2018 20:05:44 -0300
Subject: [PATCH 075/102] Rename parameters

---
 mathc.c | 4546 ++++++++++++++++++++++++++++---------------------------
 mathc.h | 1359 ++++++++---------
 2 files changed, 2956 insertions(+), 2949 deletions(-)

diff --git a/mathc.c b/mathc.c
index 1c755e3..246330b 100644
--- a/mathc.c
+++ b/mathc.c
@@ -44,14 +44,14 @@ mfloat_t to_degrees(mfloat_t radians)
 #endif
 
 #if defined(MATHC_USE_INT)
-bool vec2i_is_zero(mint_t *vec2i0)
+bool vec2i_is_zero(mint_t *v0)
 {
-	return vec2i0[0] == 0 && vec2i0[1] == 0;
+	return v0[0] == 0 && v0[1] == 0;
 }
 
-bool vec2i_is_equal(mint_t *vec2i0, mint_t *vec2i1)
+bool vec2i_is_equal(mint_t *v0, mint_t *v1)
 {
-	return vec2i0[0] == vec2i1[0] && vec2i0[1] == vec2i1[1];
+	return v0[0] == v1[0] && v0[1] == v1[1];
 }
 
 mint_t *vec2i(mint_t *result, mint_t x, mint_t y)
@@ -61,18 +61,18 @@ mint_t *vec2i(mint_t *result, mint_t x, mint_t y)
 	return result;
 }
 
-mint_t *vec2i_assign(mint_t *result, mint_t *vec2i0)
+mint_t *vec2i_assign(mint_t *result, mint_t *v0)
 {
-	result[0] = vec2i0[0];
-	result[1] = vec2i0[1];
+	result[0] = v0[0];
+	result[1] = v0[1];
 	return result;
 }
 
 #if defined(MATHC_USE_FLOATING_POINT)
-mint_t *vec2i_assign_vec2(mint_t *result, mfloat_t *vec20)
+mint_t *vec2i_assign_vec2(mint_t *result, mfloat_t *v0)
 {
-	result[0] = vec20[0];
-	result[1] = vec20[1];
+	result[0] = v0[0];
+	result[1] = v0[1];
 	return result;
 }
 #endif
@@ -91,18 +91,18 @@ mint_t *vec2i_one(mint_t *result)
 	return result;
 }
 
-mint_t *vec2i_sign(mint_t *result, mint_t *vec2i0)
+mint_t *vec2i_sign(mint_t *result, mint_t *v0)
 {
-	if (vec2i0[0] > 0) {
+	if (v0[0] > 0) {
 		result[0] = 1;
-	} else if (vec2i0[0] < 0) {
+	} else if (v0[0] < 0) {
 		result[0] = -1;
 	} else {
 		result[0] = 0;
 	}
-	if (vec2i0[1] > 0) {
+	if (v0[1] > 0) {
 		result[1] = 1;
-	} else if (vec2i0[1] < 0) {
+	} else if (v0[1] < 0) {
 		result[1] = -1;
 	} else {
 		result[1] = 0;
@@ -110,150 +110,150 @@ mint_t *vec2i_sign(mint_t *result, mint_t *vec2i0)
 	return result;
 }
 
-mint_t *vec2i_add(mint_t *result, mint_t *vec2i0, mint_t *vec2i1)
+mint_t *vec2i_add(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = vec2i0[0] + vec2i1[0];
-	result[1] = vec2i0[1] + vec2i1[1];
+	result[0] = v0[0] + v1[0];
+	result[1] = v0[1] + v1[1];
 	return result;
 }
 
-mint_t *vec2i_add_i(mint_t *result, mint_t *vec2i0, mint_t i)
+mint_t *vec2i_add_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = vec2i0[0] + i;
-	result[1] = vec2i0[1] + i;
+	result[0] = v0[0] + i;
+	result[1] = v0[1] + i;
 	return result;
 }
 
-mint_t *vec2i_subtract(mint_t *result, mint_t *vec2i0, mint_t *vec2i1)
+mint_t *vec2i_subtract(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = vec2i0[0] - vec2i1[0];
-	result[1] = vec2i0[1] - vec2i1[1];
+	result[0] = v0[0] - v1[0];
+	result[1] = v0[1] - v1[1];
 	return result;
 }
 
-mint_t *vec2i_subtract_i(mint_t *result, mint_t *vec2i0, mint_t i)
+mint_t *vec2i_subtract_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = vec2i0[0] - i;
-	result[1] = vec2i0[1] - i;
+	result[0] = v0[0] - i;
+	result[1] = v0[1] - i;
 	return result;
 }
 
-mint_t *vec2i_multiply(mint_t *result, mint_t *vec2i0, mint_t *vec2i1)
+mint_t *vec2i_multiply(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = vec2i0[0] * vec2i1[0];
-	result[1] = vec2i0[1] * vec2i1[1];
+	result[0] = v0[0] * v1[0];
+	result[1] = v0[1] * v1[1];
 	return result;
 }
 
-mint_t *vec2i_multiply_i(mint_t *result, mint_t *vec2i0, mint_t i)
+mint_t *vec2i_multiply_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = vec2i0[0] * i;
-	result[1] = vec2i0[1] * i;
+	result[0] = v0[0] * i;
+	result[1] = v0[1] * i;
 	return result;
 }
 
-mint_t *vec2i_divide(mint_t *result, mint_t *vec2i0, mint_t *vec2i1)
+mint_t *vec2i_divide(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = vec2i0[0] / vec2i1[0];
-	result[1] = vec2i0[1] / vec2i1[1];
+	result[0] = v0[0] / v1[0];
+	result[1] = v0[1] / v1[1];
 	return result;
 }
 
-mint_t *vec2i_divide_i(mint_t *result, mint_t *vec2i0, mint_t i)
+mint_t *vec2i_divide_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = vec2i0[0] / i;
-	result[1] = vec2i0[1] / i;
+	result[0] = v0[0] / i;
+	result[1] = v0[1] / i;
 	return result;
 }
 
-mint_t *vec2i_snap(mint_t *result, mint_t *vec2i0, mint_t *vec2i1)
+mint_t *vec2i_snap(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = (vec2i0[0] / vec2i1[0]) * vec2i1[0];
-	result[1] = (vec2i0[1] / vec2i1[1]) * vec2i1[1];
+	result[0] = (v0[0] / v1[0]) * v1[0];
+	result[1] = (v0[1] / v1[1]) * v1[1];
 	return result;
 }
 
-mint_t *vec2i_snap_i(mint_t *result, mint_t *vec2i0, mint_t i)
+mint_t *vec2i_snap_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = (vec2i0[0] / i) * i;
-	result[1] = (vec2i0[1] / i) * i;
+	result[0] = (v0[0] / i) * i;
+	result[1] = (v0[1] / i) * i;
 	return result;
 }
 
-mint_t *vec2i_negative(mint_t *result, mint_t *vec2i0)
+mint_t *vec2i_negative(mint_t *result, mint_t *v0)
 {
-	result[0] = -vec2i0[0];
-	result[1] = -vec2i0[1];
+	result[0] = -v0[0];
+	result[1] = -v0[1];
 	return result;
 }
 
-mint_t *vec2i_abs(mint_t *result, mint_t *vec2i0)
+mint_t *vec2i_abs(mint_t *result, mint_t *v0)
 {
-	result[0] = vec2i0[0];
+	result[0] = v0[0];
 	if (result[0] < 0) {
 		result[0] = -result[0];
 	}
-	result[1] = vec2i0[1];
+	result[1] = v0[1];
 	if (result[1] < 0) {
 		result[1] = -result[1];
 	}
 	return result;
 }
 
-mint_t *vec2i_max(mint_t *result, mint_t *vec2i0, mint_t *vec2i1)
+mint_t *vec2i_max(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	if (vec2i0[0] > vec2i1[0]) {
-		result[0] = vec2i0[0];
+	if (v0[0] > v1[0]) {
+		result[0] = v0[0];
 	} else {
-		result[0] = vec2i1[0];
+		result[0] = v1[0];
 	}
-	if (vec2i0[1] > vec2i1[1]) {
-		result[1] = vec2i0[1];
+	if (v0[1] > v1[1]) {
+		result[1] = v0[1];
 	} else {
-		result[1] = vec2i1[1];
+		result[1] = v1[1];
 	}
 	return result;
 }
 
-mint_t *vec2i_min(mint_t *result, mint_t *vec2i0, mint_t *vec2i1)
+mint_t *vec2i_min(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	if (vec2i0[0] < vec2i1[0]) {
-		result[0] = vec2i0[0];
+	if (v0[0] < v1[0]) {
+		result[0] = v0[0];
 	} else {
-		result[0] = vec2i1[0];
+		result[0] = v1[0];
 	}
-	if (vec2i0[1] < vec2i1[1]) {
-		result[1] = vec2i0[1];
+	if (v0[1] < v1[1]) {
+		result[1] = v0[1];
 	} else {
-		result[1] = vec2i1[1];
+		result[1] = v1[1];
 	}
 	return result;
 }
 
-mint_t *vec2i_clamp(mint_t *result, mint_t *vec2i0, mint_t *vec2i1, mint_t *vec2i2)
+mint_t *vec2i_clamp(mint_t *result, mint_t *v0, mint_t *v1, mint_t *v2)
 {
-	vec2i_min(result, vec2i0, vec2i1);
-	vec2i_max(result, vec2i0, vec2i2);
+	vec2i_min(result, v0, v1);
+	vec2i_max(result, v0, v2);
 	return result;
 }
 
-mint_t *vec2i_tangent(mint_t *result, mint_t *vec2i0)
+mint_t *vec2i_tangent(mint_t *result, mint_t *v0)
 {
-	mint_t a0 = vec2i0[0];
-	mint_t a1 = vec2i0[1];
+	mint_t a0 = v0[0];
+	mint_t a1 = v0[1];
 	result[0] = a1;
 	result[1] = -a0;
 	return result;
 }
 
-bool vec3i_is_zero(mint_t *vec3i0)
+bool vec3i_is_zero(mint_t *v0)
 {
-	return vec3i0[0] == 0 && vec3i0[1] == 0;
+	return v0[0] == 0 && v0[1] == 0;
 }
 
-bool vec3i_is_equal(mint_t *vec3i0, mint_t *vec3i1)
+bool vec3i_is_equal(mint_t *v0, mint_t *v1)
 {
-	return vec3i0[0] == vec3i1[0] && vec3i0[1] == vec3i1[1] && vec3i0[2] == vec3i1[2];
+	return v0[0] == v1[0] && v0[1] == v1[1] && v0[2] == v1[2];
 }
 
 mint_t *vec3i(mint_t *result, mint_t x, mint_t y, mint_t z)
@@ -264,20 +264,20 @@ mint_t *vec3i(mint_t *result, mint_t x, mint_t y, mint_t z)
 	return result;
 }
 
-mint_t *vec3i_assign(mint_t *result, mint_t *vec3i0)
+mint_t *vec3i_assign(mint_t *result, mint_t *v0)
 {
-	result[0] = vec3i0[0];
-	result[1] = vec3i0[1];
-	result[2] = vec3i0[2];
+	result[0] = v0[0];
+	result[1] = v0[1];
+	result[2] = v0[2];
 	return result;
 }
 
 #if defined(MATHC_USE_FLOATING_POINT)
-mint_t *vec3i_assign_vec3(mint_t *result, mfloat_t *vec30)
+mint_t *vec3i_assign_vec3(mint_t *result, mfloat_t *v0)
 {
-	result[0] = vec30[0];
-	result[1] = vec30[1];
-	result[2] = vec30[2];
+	result[0] = v0[0];
+	result[1] = v0[1];
+	result[2] = v0[2];
 	return result;
 }
 #endif
@@ -298,25 +298,25 @@ mint_t *vec3i_one(mint_t *result)
 	return result;
 }
 
-mint_t *vec3i_sign(mint_t *result, mint_t *vec3i0)
+mint_t *vec3i_sign(mint_t *result, mint_t *v0)
 {
-	if (vec3i0[0] > 0) {
+	if (v0[0] > 0) {
 		result[0] = 1;
-	} else if (vec3i0[0] < 0) {
+	} else if (v0[0] < 0) {
 		result[0] = -1;
 	} else {
 		result[0] = 0;
 	}
-	if (vec3i0[1] > 0) {
+	if (v0[1] > 0) {
 		result[1] = 1;
-	} else if (vec3i0[1] < 0) {
+	} else if (v0[1] < 0) {
 		result[1] = -1;
 	} else {
 		result[1] = 0;
 	}
-	if (vec3i0[2] > 0) {
+	if (v0[2] > 0) {
 		result[2] = 1;
-	} else if (vec3i0[2] < 0) {
+	} else if (v0[2] < 0) {
 		result[2] = -1;
 	} else {
 		result[2] = 0;
@@ -324,178 +324,178 @@ mint_t *vec3i_sign(mint_t *result, mint_t *vec3i0)
 	return result;
 }
 
-mint_t *vec3i_add(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+mint_t *vec3i_add(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = vec3i0[0] + vec3i1[0];
-	result[1] = vec3i0[1] + vec3i1[1];
-	result[2] = vec3i0[2] + vec3i1[2];
+	result[0] = v0[0] + v1[0];
+	result[1] = v0[1] + v1[1];
+	result[2] = v0[2] + v1[2];
 	return result;
 }
 
-mint_t *vec3i_add_i(mint_t *result, mint_t *vec3i0, mint_t i)
+mint_t *vec3i_add_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = vec3i0[0] + i;
-	result[1] = vec3i0[1] + i;
-	result[2] = vec3i0[2] + i;
+	result[0] = v0[0] + i;
+	result[1] = v0[1] + i;
+	result[2] = v0[2] + i;
 	return result;
 }
 
-mint_t *vec3i_subtract(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+mint_t *vec3i_subtract(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = vec3i0[0] - vec3i1[0];
-	result[1] = vec3i0[1] - vec3i1[1];
-	result[2] = vec3i0[2] - vec3i1[2];
+	result[0] = v0[0] - v1[0];
+	result[1] = v0[1] - v1[1];
+	result[2] = v0[2] - v1[2];
 	return result;
 }
 
-mint_t *vec3i_subtract_i(mint_t *result, mint_t *vec3i0, mint_t i)
+mint_t *vec3i_subtract_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = vec3i0[0] - i;
-	result[1] = vec3i0[1] - i;
-	result[2] = vec3i0[2] - i;
+	result[0] = v0[0] - i;
+	result[1] = v0[1] - i;
+	result[2] = v0[2] - i;
 	return result;
 }
 
-mint_t *vec3i_multiply(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+mint_t *vec3i_multiply(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = vec3i0[0] * vec3i1[0];
-	result[1] = vec3i0[1] * vec3i1[1];
-	result[2] = vec3i0[2] * vec3i1[2];
+	result[0] = v0[0] * v1[0];
+	result[1] = v0[1] * v1[1];
+	result[2] = v0[2] * v1[2];
 	return result;
 }
 
-mint_t *vec3i_multiply_i(mint_t *result, mint_t *vec3i0, mint_t i)
+mint_t *vec3i_multiply_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = vec3i0[0] * i;
-	result[1] = vec3i0[1] * i;
-	result[2] = vec3i0[2] * i;
+	result[0] = v0[0] * i;
+	result[1] = v0[1] * i;
+	result[2] = v0[2] * i;
 	return result;
 }
 
-mint_t *vec3i_divide(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+mint_t *vec3i_divide(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = vec3i0[0] / vec3i1[0];
-	result[1] = vec3i0[1] / vec3i1[1];
-	result[2] = vec3i0[2] / vec3i1[2];
+	result[0] = v0[0] / v1[0];
+	result[1] = v0[1] / v1[1];
+	result[2] = v0[2] / v1[2];
 	return result;
 }
 
-mint_t *vec3i_divide_i(mint_t *result, mint_t *vec3i0, mint_t i)
+mint_t *vec3i_divide_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = vec3i0[0] / i;
-	result[1] = vec3i0[1] / i;
-	result[2] = vec3i0[2] / i;
+	result[0] = v0[0] / i;
+	result[1] = v0[1] / i;
+	result[2] = v0[2] / i;
 	return result;
 }
 
-mint_t *vec3i_snap(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+mint_t *vec3i_snap(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = (vec3i0[0] / vec3i1[0]) * vec3i1[0];
-	result[1] = (vec3i0[1] / vec3i1[1]) * vec3i1[1];
-	result[2] = (vec3i0[2] / vec3i1[2]) * vec3i1[2];
+	result[0] = (v0[0] / v1[0]) * v1[0];
+	result[1] = (v0[1] / v1[1]) * v1[1];
+	result[2] = (v0[2] / v1[2]) * v1[2];
 	return result;
 }
 
-mint_t *vec3i_snap_i(mint_t *result, mint_t *vec3i0, mint_t i)
+mint_t *vec3i_snap_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = (vec3i0[0] / i) * i;
-	result[1] = (vec3i0[1] / i) * i;
-	result[2] = (vec3i0[2] / i) * i;
+	result[0] = (v0[0] / i) * i;
+	result[1] = (v0[1] / i) * i;
+	result[2] = (v0[2] / i) * i;
 	return result;
 }
 
-mint_t *vec3i_cross(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+mint_t *vec3i_cross(mint_t *result, mint_t *v0, mint_t *v1)
 {
 	mint_t cross[VEC3_SIZE];
-	cross[0] = vec3i0[1] * vec3i1[2] - vec3i0[2] * vec3i1[1];
-	cross[1] = vec3i0[2] * vec3i1[0] - vec3i0[0] * vec3i1[2];
-	cross[2] = vec3i0[0] * vec3i1[1] - vec3i0[1] * vec3i1[0];
+	cross[0] = v0[1] * v1[2] - v0[2] * v1[1];
+	cross[1] = v0[2] * v1[0] - v0[0] * v1[2];
+	cross[2] = v0[0] * v1[1] - v0[1] * v1[0];
 	result[0] = cross[0];
 	result[1] = cross[1];
 	result[2] = cross[2];
 	return result;
 }
 
-mint_t *vec3i_negative(mint_t *result, mint_t *vec3i0)
+mint_t *vec3i_negative(mint_t *result, mint_t *v0)
 {
-	result[0] = -vec3i0[0];
-	result[1] = -vec3i0[1];
-	result[2] = -vec3i0[2];
+	result[0] = -v0[0];
+	result[1] = -v0[1];
+	result[2] = -v0[2];
 	return result;
 }
 
-mint_t *vec3i_abs(mint_t *result, mint_t *vec3i0)
+mint_t *vec3i_abs(mint_t *result, mint_t *v0)
 {
-	result[0] = vec3i0[0];
+	result[0] = v0[0];
 	if (result[0] < 0) {
 		result[0] = -result[0];
 	}
-	result[1] = vec3i0[1];
+	result[1] = v0[1];
 	if (result[1] < 0) {
 		result[1] = -result[1];
 	}
-	result[2] = vec3i0[2];
+	result[2] = v0[2];
 	if (result[2] < 0) {
 		result[2] = -result[2];
 	}
 	return result;
 }
 
-mint_t *vec3i_max(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+mint_t *vec3i_max(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	if (vec3i0[0] > vec3i1[0]) {
-		result[0] = vec3i0[0];
+	if (v0[0] > v1[0]) {
+		result[0] = v0[0];
 	} else {
-		result[0] = vec3i1[0];
+		result[0] = v1[0];
 	}
-	if (vec3i0[1] > vec3i1[1]) {
-		result[1] = vec3i0[1];
+	if (v0[1] > v1[1]) {
+		result[1] = v0[1];
 	} else {
-		result[1] = vec3i1[1];
+		result[1] = v1[1];
 	}
-	if (vec3i0[2] > vec3i1[2]) {
-		result[2] = vec3i0[2];
+	if (v0[2] > v1[2]) {
+		result[2] = v0[2];
 	} else {
-		result[2] = vec3i1[2];
+		result[2] = v1[2];
 	}
 	return result;
 }
 
-mint_t *vec3i_min(mint_t *result, mint_t *vec3i0, mint_t *vec3i1)
+mint_t *vec3i_min(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	if (vec3i0[0] < vec3i1[0]) {
-		result[0] = vec3i0[0];
+	if (v0[0] < v1[0]) {
+		result[0] = v0[0];
 	} else {
-		result[0] = vec3i1[0];
+		result[0] = v1[0];
 	}
-	if (vec3i0[1] < vec3i1[1]) {
-		result[1] = vec3i0[1];
+	if (v0[1] < v1[1]) {
+		result[1] = v0[1];
 	} else {
-		result[1] = vec3i1[1];
+		result[1] = v1[1];
 	}
-	if (vec3i0[2] < vec3i1[2]) {
-		result[2] = vec3i0[2];
+	if (v0[2] < v1[2]) {
+		result[2] = v0[2];
 	} else {
-		result[2] = vec3i1[2];
+		result[2] = v1[2];
 	}
 	return result;
 }
 
-mint_t *vec3i_clamp(mint_t *result, mint_t *vec3i0, mint_t *vec3i1, mint_t *vec3i2)
+mint_t *vec3i_clamp(mint_t *result, mint_t *v0, mint_t *v1, mint_t *v2)
 {
-	vec3i_min(result, vec3i0, vec3i1);
-	vec3i_max(result, vec3i0, vec3i2);
+	vec3i_min(result, v0, v1);
+	vec3i_max(result, v0, v2);
 	return result;
 }
 
-bool vec4i_is_zero(mint_t *vec4i0)
+bool vec4i_is_zero(mint_t *v0)
 {
-	return vec4i0[0] == 0 && vec4i0[1] == 0 && vec4i0[2] == 0 && vec4i0[3] == 0;
+	return v0[0] == 0 && v0[1] == 0 && v0[2] == 0 && v0[3] == 0;
 }
 
-bool vec4i_is_equal(mint_t *vec4i0, mint_t *vec4i1)
+bool vec4i_is_equal(mint_t *v0, mint_t *v1)
 {
-	return vec4i0[0] == vec4i1[0] && vec4i0[1] == vec4i1[1] && vec4i0[2] == vec4i1[2] && vec4i0[3] == vec4i1[3];
+	return v0[0] == v1[0] && v0[1] == v1[1] && v0[2] == v1[2] && v0[3] == v1[3];
 }
 
 mint_t *vec4i(mint_t *result, mint_t x, mint_t y, mint_t z, mint_t w)
@@ -507,22 +507,22 @@ mint_t *vec4i(mint_t *result, mint_t x, mint_t y, mint_t z, mint_t w)
 	return result;
 }
 
-mint_t *vec4i_assign(mint_t *result, mint_t *vec4i0)
+mint_t *vec4i_assign(mint_t *result, mint_t *v0)
 {
-	result[0] = vec4i0[0];
-	result[1] = vec4i0[1];
-	result[2] = vec4i0[2];
-	result[3] = vec4i0[3];
+	result[0] = v0[0];
+	result[1] = v0[1];
+	result[2] = v0[2];
+	result[3] = v0[3];
 	return result;
 }
 
 #if defined(MATHC_USE_FLOATING_POINT)
-mint_t *vec4i_assign_vec4(mint_t *result, mfloat_t *vec40)
+mint_t *vec4i_assign_vec4(mint_t *result, mfloat_t *v0)
 {
-	result[0] = vec40[0];
-	result[1] = vec40[1];
-	result[2] = vec40[2];
-	result[3] = vec40[3];
+	result[0] = v0[0];
+	result[1] = v0[1];
+	result[2] = v0[2];
+	result[3] = v0[3];
 	return result;
 }
 #endif
@@ -545,32 +545,32 @@ mint_t *vec4i_one(mint_t *result)
 	return result;
 }
 
-mint_t *vec4i_sign(mint_t *result, mint_t *vec4i0)
+mint_t *vec4i_sign(mint_t *result, mint_t *v0)
 {
-	if (vec4i0[0] > 0) {
+	if (v0[0] > 0) {
 		result[0] = 1;
-	} else if (vec4i0[0] < 0) {
+	} else if (v0[0] < 0) {
 		result[0] = -1;
 	} else {
 		result[0] = 0;
 	}
-	if (vec4i0[1] > 0) {
+	if (v0[1] > 0) {
 		result[1] = 1;
-	} else if (vec4i0[1] < 0) {
+	} else if (v0[1] < 0) {
 		result[1] = -1;
 	} else {
 		result[1] = 0;
 	}
-	if (vec4i0[2] > 0) {
+	if (v0[2] > 0) {
 		result[2] = 1;
-	} else if (vec4i0[2] < 0) {
+	} else if (v0[2] < 0) {
 		result[2] = -1;
 	} else {
 		result[2] = 0;
 	}
-	if (vec4i0[3] > 0) {
+	if (v0[3] > 0) {
 		result[3] = 1;
-	} else if (vec4i0[3] < 0) {
+	} else if (v0[3] < 0) {
 		result[3] = -1;
 	} else {
 		result[3] = 0;
@@ -578,193 +578,193 @@ mint_t *vec4i_sign(mint_t *result, mint_t *vec4i0)
 	return result;
 }
 
-mint_t *vec4i_add(mint_t *result, mint_t *vec4i0, mint_t *vec4i1)
+mint_t *vec4i_add(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = vec4i0[0] + vec4i1[0];
-	result[1] = vec4i0[1] + vec4i1[1];
-	result[2] = vec4i0[2] + vec4i1[2];
-	result[3] = vec4i0[3] + vec4i1[3];
+	result[0] = v0[0] + v1[0];
+	result[1] = v0[1] + v1[1];
+	result[2] = v0[2] + v1[2];
+	result[3] = v0[3] + v1[3];
 	return result;
 }
 
-mint_t *vec4i_add_i(mint_t *result, mint_t *vec4i0, mint_t i)
+mint_t *vec4i_add_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = vec4i0[0] + i;
-	result[1] = vec4i0[1] + i;
-	result[2] = vec4i0[2] + i;
-	result[3] = vec4i0[3] + i;
+	result[0] = v0[0] + i;
+	result[1] = v0[1] + i;
+	result[2] = v0[2] + i;
+	result[3] = v0[3] + i;
 	return result;
 }
 
-mint_t *vec4i_subtract(mint_t *result, mint_t *vec4i0, mint_t *vec4i1)
+mint_t *vec4i_subtract(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = vec4i0[0] - vec4i1[0];
-	result[1] = vec4i0[1] - vec4i1[1];
-	result[2] = vec4i0[2] - vec4i1[2];
-	result[3] = vec4i0[3] - vec4i1[3];
+	result[0] = v0[0] - v1[0];
+	result[1] = v0[1] - v1[1];
+	result[2] = v0[2] - v1[2];
+	result[3] = v0[3] - v1[3];
 	return result;
 }
 
-mint_t *vec4i_subtract_i(mint_t *result, mint_t *vec4i0, mint_t i)
+mint_t *vec4i_subtract_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = vec4i0[0] - i;
-	result[1] = vec4i0[1] - i;
-	result[2] = vec4i0[2] - i;
-	result[3] = vec4i0[3] - i;
+	result[0] = v0[0] - i;
+	result[1] = v0[1] - i;
+	result[2] = v0[2] - i;
+	result[3] = v0[3] - i;
 	return result;
 }
 
-mint_t *vec4i_multiply(mint_t *result, mint_t *vec4i0, mint_t *vec4i1)
+mint_t *vec4i_multiply(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = vec4i0[0] * vec4i1[0];
-	result[1] = vec4i0[1] * vec4i1[1];
-	result[2] = vec4i0[2] * vec4i1[2];
-	result[3] = vec4i0[3] * vec4i1[3];
+	result[0] = v0[0] * v1[0];
+	result[1] = v0[1] * v1[1];
+	result[2] = v0[2] * v1[2];
+	result[3] = v0[3] * v1[3];
 	return result;
 }
 
-mint_t *vec4i_multiply_i(mint_t *result, mint_t *vec4i0, mint_t i)
+mint_t *vec4i_multiply_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = vec4i0[0] * i;
-	result[1] = vec4i0[1] * i;
-	result[2] = vec4i0[2] * i;
-	result[3] = vec4i0[3] * i;
+	result[0] = v0[0] * i;
+	result[1] = v0[1] * i;
+	result[2] = v0[2] * i;
+	result[3] = v0[3] * i;
 	return result;
 }
 
-mint_t *vec4i_divide(mint_t *result, mint_t *vec4i0, mint_t *vec4i1)
+mint_t *vec4i_divide(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = vec4i0[0] / vec4i1[0];
-	result[1] = vec4i0[1] / vec4i1[1];
-	result[2] = vec4i0[2] / vec4i1[2];
-	result[3] = vec4i0[3] / vec4i1[3];
+	result[0] = v0[0] / v1[0];
+	result[1] = v0[1] / v1[1];
+	result[2] = v0[2] / v1[2];
+	result[3] = v0[3] / v1[3];
 	return result;
 }
 
-mint_t *vec4i_divide_i(mint_t *result, mint_t *vec4i0, mint_t i)
+mint_t *vec4i_divide_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = vec4i0[0] / i;
-	result[1] = vec4i0[1] / i;
-	result[2] = vec4i0[2] / i;
-	result[3] = vec4i0[3] / i;
+	result[0] = v0[0] / i;
+	result[1] = v0[1] / i;
+	result[2] = v0[2] / i;
+	result[3] = v0[3] / i;
 	return result;
 }
 
-mint_t *vec4i_snap(mint_t *result, mint_t *vec4i0, mint_t *vec4i1)
+mint_t *vec4i_snap(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	result[0] = (vec4i0[0] / vec4i1[0]) * vec4i1[0];
-	result[1] = (vec4i0[1] / vec4i1[1]) * vec4i1[1];
-	result[2] = (vec4i0[2] / vec4i1[2]) * vec4i1[2];
-	result[3] = (vec4i0[3] / vec4i1[3]) * vec4i1[3];
+	result[0] = (v0[0] / v1[0]) * v1[0];
+	result[1] = (v0[1] / v1[1]) * v1[1];
+	result[2] = (v0[2] / v1[2]) * v1[2];
+	result[3] = (v0[3] / v1[3]) * v1[3];
 	return result;
 }
 
-mint_t *vec4i_snap_i(mint_t *result, mint_t *vec4i0, mint_t i)
+mint_t *vec4i_snap_i(mint_t *result, mint_t *v0, mint_t i)
 {
-	result[0] = (vec4i0[0] / i) * i;
-	result[1] = (vec4i0[1] / i) * i;
-	result[2] = (vec4i0[2] / i) * i;
-	result[3] = (vec4i0[3] / i) * i;
+	result[0] = (v0[0] / i) * i;
+	result[1] = (v0[1] / i) * i;
+	result[2] = (v0[2] / i) * i;
+	result[3] = (v0[3] / i) * i;
 	return result;
 }
 
-mint_t *vec4i_negative(mint_t *result, mint_t *vec4i0)
+mint_t *vec4i_negative(mint_t *result, mint_t *v0)
 {
-	result[0] = -vec4i0[0];
-	result[1] = -vec4i0[1];
-	result[2] = -vec4i0[2];
-	result[3] = -vec4i0[3];
+	result[0] = -v0[0];
+	result[1] = -v0[1];
+	result[2] = -v0[2];
+	result[3] = -v0[3];
 	return result;
 }
 
-mint_t *vec4i_abs(mint_t *result, mint_t *vec4i0)
+mint_t *vec4i_abs(mint_t *result, mint_t *v0)
 {
-	result[0] = vec4i0[0];
+	result[0] = v0[0];
 	if (result[0] < 0) {
 		result[0] = -result[0];
 	}
-	result[1] = vec4i0[1];
+	result[1] = v0[1];
 	if (result[1] < 0) {
 		result[1] = -result[1];
 	}
-	result[2] = vec4i0[2];
+	result[2] = v0[2];
 	if (result[2] < 0) {
 		result[2] = -result[2];
 	}
-	result[3] = vec4i0[3];
+	result[3] = v0[3];
 	if (result[3] < 0) {
 		result[3] = -result[3];
 	}
 	return result;
 }
 
-mint_t *vec4i_max(mint_t *result, mint_t *vec4i0, mint_t *vec4i1)
+mint_t *vec4i_max(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	if (vec4i0[0] > vec4i1[0]) {
-		result[0] = vec4i0[0];
+	if (v0[0] > v1[0]) {
+		result[0] = v0[0];
 	} else {
-		result[0] = vec4i1[0];
+		result[0] = v1[0];
 	}
-	if (vec4i0[1] > vec4i1[1]) {
-		result[1] = vec4i0[1];
+	if (v0[1] > v1[1]) {
+		result[1] = v0[1];
 	} else {
-		result[1] = vec4i1[1];
+		result[1] = v1[1];
 	}
-	if (vec4i0[2] > vec4i1[2]) {
-		result[2] = vec4i0[2];
+	if (v0[2] > v1[2]) {
+		result[2] = v0[2];
 	} else {
-		result[2] = vec4i1[2];
+		result[2] = v1[2];
 	}
-	if (vec4i0[3] > vec4i1[3]) {
-		result[3] = vec4i0[3];
+	if (v0[3] > v1[3]) {
+		result[3] = v0[3];
 	} else {
-		result[3] = vec4i1[3];
+		result[3] = v1[3];
 	}
 	return result;
 }
 
-mint_t *vec4i_min(mint_t *result, mint_t *vec4i0, mint_t *vec4i1)
+mint_t *vec4i_min(mint_t *result, mint_t *v0, mint_t *v1)
 {
-	if (vec4i0[0] < vec4i1[0]) {
-		result[0] = vec4i0[0];
+	if (v0[0] < v1[0]) {
+		result[0] = v0[0];
 	} else {
-		result[0] = vec4i1[0];
+		result[0] = v1[0];
 	}
-	if (vec4i0[1] < vec4i1[1]) {
-		result[1] = vec4i0[1];
+	if (v0[1] < v1[1]) {
+		result[1] = v0[1];
 	} else {
-		result[1] = vec4i1[1];
+		result[1] = v1[1];
 	}
-	if (vec4i0[2] < vec4i1[2]) {
-		result[2] = vec4i0[2];
+	if (v0[2] < v1[2]) {
+		result[2] = v0[2];
 	} else {
-		result[2] = vec4i1[2];
+		result[2] = v1[2];
 	}
-	if (vec4i0[3] < vec4i1[3]) {
-		result[3] = vec4i0[3];
+	if (v0[3] < v1[3]) {
+		result[3] = v0[3];
 	} else {
-		result[3] = vec4i1[3];
+		result[3] = v1[3];
 	}
 	return result;
 }
 
-mint_t *vec4i_clamp(mint_t *result, mint_t *vec4i0, mint_t *vec4i1, mint_t *vec4i2)
+mint_t *vec4i_clamp(mint_t *result, mint_t *v0, mint_t *v1, mint_t *v2)
 {
-	vec4i_min(result, vec4i0, vec4i1);
-	vec4i_max(result, vec4i0, vec4i2);
+	vec4i_min(result, v0, v1);
+	vec4i_max(result, v0, v2);
 	return result;
 }
 #endif
 
 #if defined(MATHC_USE_FLOATING_POINT)
-bool vec2_is_zero(mfloat_t *vec20)
+bool vec2_is_zero(mfloat_t *v0)
 {
-	return vec20[0] < MFLT_EPSILON && vec20[1] < MFLT_EPSILON;
+	return v0[0] < MFLT_EPSILON && v0[1] < MFLT_EPSILON;
 }
 
-bool vec2_is_equal(mfloat_t *vec20, mfloat_t *vec21)
+bool vec2_is_equal(mfloat_t *v0, mfloat_t *v1)
 {
-	return MFABS(vec20[0] - vec21[0]) < MFLT_EPSILON && MFABS(vec20[1] - vec21[1]) < MFLT_EPSILON;
+	return MFABS(v0[0] - v1[0]) < MFLT_EPSILON && MFABS(v0[1] - v1[1]) < MFLT_EPSILON;
 }
 
 mfloat_t *vec2(mfloat_t *result, mfloat_t x, mfloat_t y)
@@ -774,18 +774,18 @@ mfloat_t *vec2(mfloat_t *result, mfloat_t x, mfloat_t y)
 	return result;
 }
 
-mfloat_t *vec2_assign(mfloat_t *result, mfloat_t *vec20)
+mfloat_t *vec2_assign(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = vec20[0];
-	result[1] = vec20[1];
+	result[0] = v0[0];
+	result[1] = v0[1];
 	return result;
 }
 
 #if defined(MATHC_USE_INT)
-mfloat_t *vec2_assign_vec2i(mfloat_t *result, mint_t *vec2i0)
+mfloat_t *vec2_assign_vec2i(mfloat_t *result, mint_t *v0)
 {
-	result[0] = vec2i0[0];
-	result[1] = vec2i0[1];
+	result[0] = v0[0];
+	result[1] = v0[1];
 	return result;
 }
 #endif
@@ -804,18 +804,18 @@ mfloat_t *vec2_one(mfloat_t *result)
 	return result;
 }
 
-mfloat_t *vec2_sign(mfloat_t *result, mfloat_t *vec20)
+mfloat_t *vec2_sign(mfloat_t *result, mfloat_t *v0)
 {
-	if (vec20[0] > MFLOAT_C(0.0)) {
+	if (v0[0] > MFLOAT_C(0.0)) {
 		result[0] = MFLOAT_C(1.0);
-	} else if (vec20[0] < MFLOAT_C(0.0)) {
+	} else if (v0[0] < MFLOAT_C(0.0)) {
 		result[0] = -MFLOAT_C(1.0);
 	} else {
 		result[0] = MFLOAT_C(0.0);
 	}
-	if (vec20[1] > MFLOAT_C(0.0)) {
+	if (v0[1] > MFLOAT_C(0.0)) {
 		result[1] = MFLOAT_C(1.0);
-	} else if (vec20[1] < MFLOAT_C(0.0)) {
+	} else if (v0[1] < MFLOAT_C(0.0)) {
 		result[1] = -MFLOAT_C(1.0);
 	} else {
 		result[1] = MFLOAT_C(0.0);
@@ -823,265 +823,265 @@ mfloat_t *vec2_sign(mfloat_t *result, mfloat_t *vec20)
 	return result;
 }
 
-mfloat_t *vec2_add(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+mfloat_t *vec2_add(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = vec20[0] + vec21[0];
-	result[1] = vec20[1] + vec21[1];
+	result[0] = v0[0] + v1[0];
+	result[1] = v0[1] + v1[1];
 	return result;
 }
 
-mfloat_t *vec2_add_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f)
+mfloat_t *vec2_add_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = vec20[0] + f;
-	result[1] = vec20[1] + f;
+	result[0] = v0[0] + f;
+	result[1] = v0[1] + f;
 	return result;
 }
 
-mfloat_t *vec2_subtract(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+mfloat_t *vec2_subtract(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = vec20[0] - vec21[0];
-	result[1] = vec20[1] - vec21[1];
+	result[0] = v0[0] - v1[0];
+	result[1] = v0[1] - v1[1];
 	return result;
 }
 
-mfloat_t *vec2_subtract_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f)
+mfloat_t *vec2_subtract_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = vec20[0] - f;
-	result[1] = vec20[1] - f;
+	result[0] = v0[0] - f;
+	result[1] = v0[1] - f;
 	return result;
 }
 
-mfloat_t *vec2_multiply(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+mfloat_t *vec2_multiply(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = vec20[0] * vec21[0];
-	result[1] = vec20[1] * vec21[1];
+	result[0] = v0[0] * v1[0];
+	result[1] = v0[1] * v1[1];
 	return result;
 }
 
-mfloat_t *vec2_multiply_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f)
+mfloat_t *vec2_multiply_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = vec20[0] * f;
-	result[1] = vec20[1] * f;
+	result[0] = v0[0] * f;
+	result[1] = v0[1] * f;
 	return result;
 }
 
-mfloat_t *vec2_multiply_mat2(mfloat_t *result, mfloat_t *vec20, mfloat_t *mat20)
+mfloat_t *vec2_multiply_mat2(mfloat_t *result, mfloat_t *v0, mfloat_t *m0)
 {
-	mfloat_t x = vec20[0];
-	mfloat_t y = vec20[1];
-	result[0] = mat20[0] * x + mat20[2] * y;
-	result[1] = mat20[1] * x + mat20[3] * y;
+	mfloat_t x = v0[0];
+	mfloat_t y = v0[1];
+	result[0] = m0[0] * x + m0[2] * y;
+	result[1] = m0[1] * x + m0[3] * y;
 	return result;
 }
 
-mfloat_t *vec2_divide(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+mfloat_t *vec2_divide(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = vec20[0] / vec21[0];
-	result[1] = vec20[1] / vec21[1];
+	result[0] = v0[0] / v1[0];
+	result[1] = v0[1] / v1[1];
 	return result;
 }
 
-mfloat_t *vec2_divide_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f)
+mfloat_t *vec2_divide_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = vec20[0] / f;
-	result[1] = vec20[1] / f;
+	result[0] = v0[0] / f;
+	result[1] = v0[1] / f;
 	return result;
 }
 
-mfloat_t *vec2_snap(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+mfloat_t *vec2_snap(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = MFLOOR(vec20[0] / vec21[0]) * vec21[0];
-	result[1] = MFLOOR(vec20[1] / vec21[1]) * vec21[1];
+	result[0] = MFLOOR(v0[0] / v1[0]) * v1[0];
+	result[1] = MFLOOR(v0[1] / v1[1]) * v1[1];
 	return result;
 }
 
-mfloat_t *vec2_snap_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f)
+mfloat_t *vec2_snap_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = MFLOOR(vec20[0] / f) * f;
-	result[1] = MFLOOR(vec20[1] / f) * f;
+	result[0] = MFLOOR(v0[0] / f) * f;
+	result[1] = MFLOOR(v0[1] / f) * f;
 	return result;
 }
 
-mfloat_t *vec2_negative(mfloat_t *result, mfloat_t *vec20)
+mfloat_t *vec2_negative(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = -vec20[0];
-	result[1] = -vec20[1];
+	result[0] = -v0[0];
+	result[1] = -v0[1];
 	return result;
 }
 
-mfloat_t *vec2_abs(mfloat_t *result, mfloat_t *vec20)
+mfloat_t *vec2_abs(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = MFABS(vec20[0]);
-	result[1] = MFABS(vec20[1]);
+	result[0] = MFABS(v0[0]);
+	result[1] = MFABS(v0[1]);
 	return result;
 }
 
-mfloat_t *vec2_floor(mfloat_t *result, mfloat_t *vec20)
+mfloat_t *vec2_floor(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = MFLOOR(vec20[0]);
-	result[1] = MFLOOR(vec20[1]);
+	result[0] = MFLOOR(v0[0]);
+	result[1] = MFLOOR(v0[1]);
 	return result;
 }
 
-mfloat_t *vec2_ceil(mfloat_t *result, mfloat_t *vec20)
+mfloat_t *vec2_ceil(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = MCEIL(vec20[0]);
-	result[1] = MCEIL(vec20[1]);
+	result[0] = MCEIL(v0[0]);
+	result[1] = MCEIL(v0[1]);
 	return result;
 }
 
-mfloat_t *vec2_round(mfloat_t *result, mfloat_t *vec20)
+mfloat_t *vec2_round(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = MROUND(vec20[0]);
-	result[1] = MROUND(vec20[1]);
+	result[0] = MROUND(v0[0]);
+	result[1] = MROUND(v0[1]);
 	return result;
 }
 
-mfloat_t *vec2_max(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+mfloat_t *vec2_max(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = MFMAX(vec20[0], vec21[0]);
-	result[1] = MFMAX(vec20[1], vec21[1]);
+	result[0] = MFMAX(v0[0], v1[0]);
+	result[1] = MFMAX(v0[1], v1[1]);
 	return result;
 }
 
-mfloat_t *vec2_min(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+mfloat_t *vec2_min(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = MFMIN(vec20[0], vec21[0]);
-	result[1] = MFMIN(vec20[1], vec21[1]);
+	result[0] = MFMIN(v0[0], v1[0]);
+	result[1] = MFMIN(v0[1], v1[1]);
 	return result;
 }
 
-mfloat_t *vec2_clamp(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t *vec22)
+mfloat_t *vec2_clamp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2)
 {
-	vec2_min(result, vec20, vec21);
-	vec2_max(result, vec20, vec22);
+	vec2_min(result, v0, v1);
+	vec2_max(result, v0, v2);
 	return result;
 }
 
-mfloat_t *vec2_normalize(mfloat_t *result, mfloat_t *vec20)
+mfloat_t *vec2_normalize(mfloat_t *result, mfloat_t *v0)
 {
-	mfloat_t l = MSQRT(vec20[0] * vec20[0] + vec20[1] * vec20[1]);
-	result[0] = vec20[0] / l;
-	result[1] = vec20[1] / l;
+	mfloat_t l = MSQRT(v0[0] * v0[0] + v0[1] * v0[1]);
+	result[0] = v0[0] / l;
+	result[1] = v0[1] / l;
 	return result;
 }
 
-mfloat_t vec2_dot(mfloat_t *vec20, mfloat_t *vec21)
+mfloat_t vec2_dot(mfloat_t *v0, mfloat_t *v1)
 {
-	return vec20[0] * vec21[0] + vec20[1] * vec21[1];
+	return v0[0] * v1[0] + v0[1] * v1[1];
 }
 
-mfloat_t *vec2_project(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+mfloat_t *vec2_project(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	mfloat_t d = vec2_dot(vec21, vec21);
-	mfloat_t s = vec2_dot(vec20, vec21) / d;
-	result[0] = vec21[0] * s;
-	result[1] = vec21[1] * s;
+	mfloat_t d = vec2_dot(v1, v1);
+	mfloat_t s = vec2_dot(v0, v1) / d;
+	result[0] = v1[0] * s;
+	result[1] = v1[1] * s;
 	return result;
 }
 
-mfloat_t *vec2_slide(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+mfloat_t *vec2_slide(mfloat_t *result, mfloat_t *v0, mfloat_t *normal)
 {
-	mfloat_t d = vec2_dot(vec20, vec21);
-	result[0] = vec20[0] - vec21[0] * d;
-	result[1] = vec20[1] - vec21[1] * d;
+	mfloat_t d = vec2_dot(v0, normal);
+	result[0] = v0[0] - normal[0] * d;
+	result[1] = v0[1] - normal[1] * d;
 	return result;
 }
 
-mfloat_t *vec2_reflect(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21)
+mfloat_t *vec2_reflect(mfloat_t *result, mfloat_t *v0, mfloat_t *normal)
 {
-	mfloat_t d = MFLOAT_C(2.0) * vec2_dot(vec20, vec21);
-	result[0] = vec21[0] * d - vec20[0];
-	result[1] = vec21[1] * d - vec20[1];
+	mfloat_t d = MFLOAT_C(2.0) * vec2_dot(v0, normal);
+	result[0] = normal[0] * d - v0[0];
+	result[1] = normal[1] * d - v0[1];
 	return result;
 }
 
-mfloat_t *vec2_tangent(mfloat_t *result, mfloat_t *vec20)
+mfloat_t *vec2_tangent(mfloat_t *result, mfloat_t *v0)
 {
-	mfloat_t a0 = vec20[0];
-	mfloat_t a1 = vec20[1];
+	mfloat_t a0 = v0[0];
+	mfloat_t a1 = v0[1];
 	result[0] = a1;
 	result[1] = -a0;
 	return result;
 }
 
-mfloat_t *vec2_rotate(mfloat_t *result, mfloat_t *vec20, mfloat_t f)
+mfloat_t *vec2_rotate(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
 	mfloat_t cs = MCOS(f);
 	mfloat_t sn = MSIN(f);
-	mfloat_t x = vec20[0];
-	mfloat_t y = vec20[1];
+	mfloat_t x = v0[0];
+	mfloat_t y = v0[1];
 	result[0] = x * cs - y * sn;
 	result[1] = x * sn + y * cs;
 	return result;
 }
 
-mfloat_t *vec2_lerp(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t f)
+mfloat_t *vec2_lerp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t f)
 {
-	result[0] = vec20[0] + (vec21[0] - vec20[0]) * f;
-	result[1] = vec20[1] + (vec21[1] - vec20[1]) * f;
+	result[0] = v0[0] + (v1[0] - v0[0]) * f;
+	result[1] = v0[1] + (v1[1] - v0[1]) * f;
 	return result;
 }
 
-mfloat_t *vec2_bezier3(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t *vec22, mfloat_t f)
+mfloat_t *vec2_bezier3(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2, mfloat_t f)
 {
 	mfloat_t tmp0[VEC2_SIZE];
 	mfloat_t tmp1[VEC2_SIZE];
-	vec2_lerp(tmp0, vec20, vec21, f);
-	vec2_lerp(tmp1, vec21, vec22, f);
+	vec2_lerp(tmp0, v0, v1, f);
+	vec2_lerp(tmp1, v1, v2, f);
 	vec2_lerp(result, tmp0, tmp1, f);
 	return result;
 }
 
-mfloat_t *vec2_bezier4(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t *vec22, mfloat_t *vec23, mfloat_t f)
+mfloat_t *vec2_bezier4(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2, mfloat_t *v3, mfloat_t f)
 {
 	mfloat_t tmp0[VEC2_SIZE];
 	mfloat_t tmp1[VEC2_SIZE];
 	mfloat_t tmp2[VEC2_SIZE];
 	mfloat_t tmp3[VEC2_SIZE];
 	mfloat_t tmp4[VEC2_SIZE];
-	vec2_lerp(tmp0, vec20, vec21, f);
-	vec2_lerp(tmp1, vec21, vec22, f);
-	vec2_lerp(tmp2, vec22, vec23, f);
+	vec2_lerp(tmp0, v0, v1, f);
+	vec2_lerp(tmp1, v1, v2, f);
+	vec2_lerp(tmp2, v2, v3, f);
 	vec2_lerp(tmp3, tmp0, tmp1, f);
 	vec2_lerp(tmp4, tmp1, tmp2, f);
 	vec2_lerp(result, tmp3, tmp4, f);
 	return result;
 }
 
-mfloat_t vec2_angle(mfloat_t *vec20)
+mfloat_t vec2_angle(mfloat_t *v0)
 {
-	return MATAN2(vec20[1], vec20[0]);
+	return MATAN2(v0[1], v0[0]);
 }
 
-mfloat_t vec2_length(mfloat_t *vec20)
+mfloat_t vec2_length(mfloat_t *v0)
 {
-	return MSQRT(vec20[0] * vec20[0] + vec20[1] * vec20[1]);
+	return MSQRT(v0[0] * v0[0] + v0[1] * v0[1]);
 }
 
-mfloat_t vec2_length_squared(mfloat_t *vec20)
+mfloat_t vec2_length_squared(mfloat_t *v0)
 {
-	return vec20[0] * vec20[0] + vec20[1] * vec20[1];
+	return v0[0] * v0[0] + v0[1] * v0[1];
 }
 
-mfloat_t vec2_distance(mfloat_t *vec20, mfloat_t *vec21)
+mfloat_t vec2_distance(mfloat_t *v0, mfloat_t *v1)
 {
-	return MSQRT((vec20[0] - vec21[0]) * (vec20[0] - vec21[0]) + (vec20[1] - vec21[1]) * (vec20[1] - vec21[1]));
+	return MSQRT((v0[0] - v1[0]) * (v0[0] - v1[0]) + (v0[1] - v1[1]) * (v0[1] - v1[1]));
 }
 
-mfloat_t vec2_distance_squared(mfloat_t *vec20, mfloat_t *vec21)
+mfloat_t vec2_distance_squared(mfloat_t *v0, mfloat_t *v1)
 {
-	return (vec20[0] - vec21[0]) * (vec20[0] - vec21[0]) + (vec20[1] - vec21[1]) * (vec20[1] - vec21[1]);
+	return (v0[0] - v1[0]) * (v0[0] - v1[0]) + (v0[1] - v1[1]) * (v0[1] - v1[1]);
 }
 
-bool vec3_is_zero(mfloat_t *vec30)
+bool vec3_is_zero(mfloat_t *v0)
 {
-	return vec30[0] < MFLT_EPSILON && vec30[1] < MFLT_EPSILON && vec30[2] < MFLT_EPSILON;
+	return v0[0] < MFLT_EPSILON && v0[1] < MFLT_EPSILON && v0[2] < MFLT_EPSILON;
 }
 
-bool vec3_is_equal(mfloat_t *vec30, mfloat_t *vec31)
+bool vec3_is_equal(mfloat_t *v0, mfloat_t *v1)
 {
-	return MFABS(vec30[0] - vec31[0]) < MFLT_EPSILON && MFABS(vec30[1] - vec31[1]) < MFLT_EPSILON && MFABS(vec30[2] - vec31[2]) < MFLT_EPSILON;
+	return MFABS(v0[0] - v1[0]) < MFLT_EPSILON && MFABS(v0[1] - v1[1]) < MFLT_EPSILON && MFABS(v0[2] - v1[2]) < MFLT_EPSILON;
 }
 
 mfloat_t *vec3(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z)
@@ -1092,20 +1092,20 @@ mfloat_t *vec3(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z)
 	return result;
 }
 
-mfloat_t *vec3_assign(mfloat_t *result, mfloat_t *vec30)
+mfloat_t *vec3_assign(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = vec30[0];
-	result[1] = vec30[1];
-	result[2] = vec30[2];
+	result[0] = v0[0];
+	result[1] = v0[1];
+	result[2] = v0[2];
 	return result;
 }
 
 #if defined(MATHC_USE_INT)
-mfloat_t *vec3_assign_vec3i(mfloat_t *result, mint_t *vec3i0)
+mfloat_t *vec3_assign_vec3i(mfloat_t *result, mint_t *v0)
 {
-	result[0] = vec3i0[0];
-	result[1] = vec3i0[1];
-	result[2] = vec3i0[2];
+	result[0] = v0[0];
+	result[1] = v0[1];
+	result[2] = v0[2];
 	return result;
 }
 #endif
@@ -1126,25 +1126,25 @@ mfloat_t *vec3_one(mfloat_t *result)
 	return result;
 }
 
-mfloat_t *vec3_sign(mfloat_t *result, mfloat_t *vec30)
+mfloat_t *vec3_sign(mfloat_t *result, mfloat_t *v0)
 {
-	if (vec30[0] > MFLOAT_C(0.0)) {
+	if (v0[0] > MFLOAT_C(0.0)) {
 		result[0] = MFLOAT_C(1.0);
-	} else if (vec30[0] < 0) {
+	} else if (v0[0] < 0) {
 		result[0] = -MFLOAT_C(1.0);
 	} else {
 		result[0] = MFLOAT_C(0.0);
 	}
-	if (vec30[1] > MFLOAT_C(0.0)) {
+	if (v0[1] > MFLOAT_C(0.0)) {
 		result[1] = MFLOAT_C(1.0);
-	} else if (vec30[1] < 0) {
+	} else if (v0[1] < 0) {
 		result[1] = -MFLOAT_C(1.0);
 	} else {
 		result[1] = MFLOAT_C(0.0);
 	}
-	if (vec30[2] > MFLOAT_C(0.0)) {
+	if (v0[2] > MFLOAT_C(0.0)) {
 		result[2] = MFLOAT_C(1.0);
-	} else if (vec30[2] < 0) {
+	} else if (v0[2] < 0) {
 		result[2] = -MFLOAT_C(1.0);
 	} else {
 		result[2] = MFLOAT_C(0.0);
@@ -1152,276 +1152,276 @@ mfloat_t *vec3_sign(mfloat_t *result, mfloat_t *vec30)
 	return result;
 }
 
-mfloat_t *vec3_add(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t *vec3_add(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = vec30[0] + vec31[0];
-	result[1] = vec30[1] + vec31[1];
-	result[2] = vec30[2] + vec31[2];
+	result[0] = v0[0] + v1[0];
+	result[1] = v0[1] + v1[1];
+	result[2] = v0[2] + v1[2];
 	return result;
 }
 
-mfloat_t *vec3_add_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
+mfloat_t *vec3_add_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = vec30[0] + f;
-	result[1] = vec30[1] + f;
-	result[2] = vec30[2] + f;
+	result[0] = v0[0] + f;
+	result[1] = v0[1] + f;
+	result[2] = v0[2] + f;
 	return result;
 }
 
-mfloat_t *vec3_subtract(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t *vec3_subtract(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = vec30[0] - vec31[0];
-	result[1] = vec30[1] - vec31[1];
-	result[2] = vec30[2] - vec31[2];
+	result[0] = v0[0] - v1[0];
+	result[1] = v0[1] - v1[1];
+	result[2] = v0[2] - v1[2];
 	return result;
 }
 
-mfloat_t *vec3_subtract_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
+mfloat_t *vec3_subtract_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = vec30[0] - f;
-	result[1] = vec30[1] - f;
-	result[2] = vec30[2] - f;
+	result[0] = v0[0] - f;
+	result[1] = v0[1] - f;
+	result[2] = v0[2] - f;
 	return result;
 }
 
-mfloat_t *vec3_multiply(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t *vec3_multiply(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = vec30[0] * vec31[0];
-	result[1] = vec30[1] * vec31[1];
-	result[2] = vec30[2] * vec31[2];
+	result[0] = v0[0] * v1[0];
+	result[1] = v0[1] * v1[1];
+	result[2] = v0[2] * v1[2];
 	return result;
 }
 
-mfloat_t *vec3_multiply_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
+mfloat_t *vec3_multiply_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = vec30[0] * f;
-	result[1] = vec30[1] * f;
-	result[2] = vec30[2] * f;
+	result[0] = v0[0] * f;
+	result[1] = v0[1] * f;
+	result[2] = v0[2] * f;
 	return result;
 }
 
-mfloat_t *vec3_multiply_mat3(mfloat_t *result, mfloat_t *vec30, mfloat_t *mat30)
+mfloat_t *vec3_multiply_mat3(mfloat_t *result, mfloat_t *v0, mfloat_t *m0)
 {
-	mfloat_t x = vec30[0];
-	mfloat_t y = vec30[1];
-	mfloat_t z = vec30[2];
-	result[0] = mat30[0] * x + mat30[3] * y + mat30[6] * z;
-	result[1] = mat30[1] * x + mat30[4] * y + mat30[7] * z;
-	result[2] = mat30[2] * x + mat30[5] * y + mat30[8] * z;
+	mfloat_t x = v0[0];
+	mfloat_t y = v0[1];
+	mfloat_t z = v0[2];
+	result[0] = m0[0] * x + m0[3] * y + m0[6] * z;
+	result[1] = m0[1] * x + m0[4] * y + m0[7] * z;
+	result[2] = m0[2] * x + m0[5] * y + m0[8] * z;
 	return result;
 }
 
-mfloat_t *vec3_divide(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t *vec3_divide(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = vec30[0] / vec31[0];
-	result[1] = vec30[1] / vec31[1];
-	result[2] = vec30[2] / vec31[2];
+	result[0] = v0[0] / v1[0];
+	result[1] = v0[1] / v1[1];
+	result[2] = v0[2] / v1[2];
 	return result;
 }
 
-mfloat_t *vec3_divide_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
+mfloat_t *vec3_divide_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = vec30[0] / f;
-	result[1] = vec30[1] / f;
-	result[2] = vec30[2] / f;
+	result[0] = v0[0] / f;
+	result[1] = v0[1] / f;
+	result[2] = v0[2] / f;
 	return result;
 }
 
-mfloat_t *vec3_snap(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t *vec3_snap(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = MFLOOR(vec30[0] / vec31[0]) * vec31[0];
-	result[1] = MFLOOR(vec30[1] / vec31[1]) * vec31[1];
-	result[2] = MFLOOR(vec30[2] / vec31[2]) * vec31[2];
+	result[0] = MFLOOR(v0[0] / v1[0]) * v1[0];
+	result[1] = MFLOOR(v0[1] / v1[1]) * v1[1];
+	result[2] = MFLOOR(v0[2] / v1[2]) * v1[2];
 	return result;
 }
 
-mfloat_t *vec3_snap_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
+mfloat_t *vec3_snap_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = MFLOOR(vec30[0] / f) * f;
-	result[1] = MFLOOR(vec30[1] / f) * f;
-	result[2] = MFLOOR(vec30[2] / f) * f;
+	result[0] = MFLOOR(v0[0] / f) * f;
+	result[1] = MFLOOR(v0[1] / f) * f;
+	result[2] = MFLOOR(v0[2] / f) * f;
 	return result;
 }
 
-mfloat_t *vec3_negative(mfloat_t *result, mfloat_t *vec30)
+mfloat_t *vec3_negative(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = -vec30[0];
-	result[1] = -vec30[1];
-	result[2] = -vec30[2];
+	result[0] = -v0[0];
+	result[1] = -v0[1];
+	result[2] = -v0[2];
 	return result;
 }
 
-mfloat_t *vec3_abs(mfloat_t *result, mfloat_t *vec30)
+mfloat_t *vec3_abs(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = MFABS(vec30[0]);
-	result[1] = MFABS(vec30[1]);
-	result[2] = MFABS(vec30[2]);
+	result[0] = MFABS(v0[0]);
+	result[1] = MFABS(v0[1]);
+	result[2] = MFABS(v0[2]);
 	return result;
 }
 
-mfloat_t *vec3_floor(mfloat_t *result, mfloat_t *vec30)
+mfloat_t *vec3_floor(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = MFLOOR(vec30[0]);
-	result[1] = MFLOOR(vec30[1]);
-	result[2] = MFLOOR(vec30[2]);
+	result[0] = MFLOOR(v0[0]);
+	result[1] = MFLOOR(v0[1]);
+	result[2] = MFLOOR(v0[2]);
 	return result;
 }
 
-mfloat_t *vec3_ceil(mfloat_t *result, mfloat_t *vec30)
+mfloat_t *vec3_ceil(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = MCEIL(vec30[0]);
-	result[1] = MCEIL(vec30[1]);
-	result[2] = MCEIL(vec30[2]);
+	result[0] = MCEIL(v0[0]);
+	result[1] = MCEIL(v0[1]);
+	result[2] = MCEIL(v0[2]);
 	return result;
 }
 
-mfloat_t *vec3_round(mfloat_t *result, mfloat_t *vec30)
+mfloat_t *vec3_round(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = MROUND(vec30[0]);
-	result[1] = MROUND(vec30[1]);
-	result[2] = MROUND(vec30[2]);
+	result[0] = MROUND(v0[0]);
+	result[1] = MROUND(v0[1]);
+	result[2] = MROUND(v0[2]);
 	return result;
 }
 
-mfloat_t *vec3_max(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t *vec3_max(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = MFMAX(vec30[0], vec31[0]);
-	result[1] = MFMAX(vec30[1], vec31[1]);
-	result[2] = MFMAX(vec30[2], vec31[2]);
+	result[0] = MFMAX(v0[0], v1[0]);
+	result[1] = MFMAX(v0[1], v1[1]);
+	result[2] = MFMAX(v0[2], v1[2]);
 	return result;
 }
 
-mfloat_t *vec3_min(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t *vec3_min(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = MFMIN(vec30[0], vec31[0]);
-	result[1] = MFMIN(vec30[1], vec31[1]);
-	result[2] = MFMIN(vec30[2], vec31[2]);
+	result[0] = MFMIN(v0[0], v1[0]);
+	result[1] = MFMIN(v0[1], v1[1]);
+	result[2] = MFMIN(v0[2], v1[2]);
 	return result;
 }
 
-mfloat_t *vec3_clamp(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32)
+mfloat_t *vec3_clamp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2)
 {
-	vec3_min(result, vec30, vec31);
-	vec3_max(result, vec30, vec32);
+	vec3_min(result, v0, v1);
+	vec3_max(result, v0, v2);
 	return result;
 }
 
-mfloat_t *vec3_cross(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t *vec3_cross(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
 	mfloat_t cross[VEC3_SIZE];
-	cross[0] = vec30[1] * vec31[2] - vec30[2] * vec31[1];
-	cross[1] = vec30[2] * vec31[0] - vec30[0] * vec31[2];
-	cross[2] = vec30[0] * vec31[1] - vec30[1] * vec31[0];
+	cross[0] = v0[1] * v1[2] - v0[2] * v1[1];
+	cross[1] = v0[2] * v1[0] - v0[0] * v1[2];
+	cross[2] = v0[0] * v1[1] - v0[1] * v1[0];
 	result[0] = cross[0];
 	result[1] = cross[1];
 	result[2] = cross[2];
 	return result;
 }
 
-mfloat_t *vec3_normalize(mfloat_t *result, mfloat_t *vec30)
+mfloat_t *vec3_normalize(mfloat_t *result, mfloat_t *v0)
 {
-	mfloat_t l = MSQRT(vec30[0] * vec30[0] + vec30[1] * vec30[1] + vec30[2] * vec30[2]);
-	result[0] = vec30[0] / l;
-	result[1] = vec30[1] / l;
-	result[2] = vec30[2] / l;
+	mfloat_t l = MSQRT(v0[0] * v0[0] + v0[1] * v0[1] + v0[2] * v0[2]);
+	result[0] = v0[0] / l;
+	result[1] = v0[1] / l;
+	result[2] = v0[2] / l;
 	return result;
 }
 
-mfloat_t vec3_dot(mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t vec3_dot(mfloat_t *v0, mfloat_t *v1)
 {
-	return vec30[0] * vec31[0] + vec30[1] * vec31[1] + vec30[2] * vec31[2];
+	return v0[0] * v1[0] + v0[1] * v1[1] + v0[2] * v1[2];
 }
 
-mfloat_t *vec3_project(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t *vec3_project(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	mfloat_t d = vec2_dot(vec31, vec31);
-	mfloat_t s = vec2_dot(vec30, vec31) / d;
-	result[0] = vec31[0] * s;
-	result[1] = vec31[1] * s;
-	result[2] = vec31[2] * s;
+	mfloat_t d = vec2_dot(v1, v1);
+	mfloat_t s = vec2_dot(v0, v1) / d;
+	result[0] = v1[0] * s;
+	result[1] = v1[1] * s;
+	result[2] = v1[2] * s;
 	return result;
 }
 
-mfloat_t *vec3_slide(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t *vec3_slide(mfloat_t *result, mfloat_t *v0, mfloat_t *normal)
 {
-	mfloat_t d = vec3_dot(vec30, vec31);
-	result[0] = vec30[0] - vec31[0] * d;
-	result[1] = vec30[1] - vec31[1] * d;
-	result[2] = vec30[2] - vec31[2] * d;
+	mfloat_t d = vec3_dot(v0, normal);
+	result[0] = v0[0] - normal[0] * d;
+	result[1] = v0[1] - normal[1] * d;
+	result[2] = v0[2] - normal[2] * d;
 	return result;
 }
 
-mfloat_t *vec3_reflect(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t *vec3_reflect(mfloat_t *result, mfloat_t *v0, mfloat_t *normal)
 {
-	mfloat_t d = MFLOAT_C(2.0) * vec3_dot(vec30, vec31);
-	result[0] = vec31[0] * d - vec30[0];
-	result[1] = vec31[1] * d - vec30[1];
-	result[2] = vec31[2] * d - vec30[2];
+	mfloat_t d = MFLOAT_C(2.0) * vec3_dot(v0, normal);
+	result[0] = normal[0] * d - v0[0];
+	result[1] = normal[1] * d - v0[1];
+	result[2] = normal[2] * d - v0[2];
 	return result;
 }
 
-mfloat_t *vec3_lerp(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t f)
+mfloat_t *vec3_lerp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t f)
 {
-	result[0] = vec30[0] + (vec31[0] - vec30[0]) * f;
-	result[1] = vec30[1] + (vec31[1] - vec30[1]) * f;
-	result[2] = vec30[2] + (vec31[2] - vec30[2]) * f;
+	result[0] = v0[0] + (v1[0] - v0[0]) * f;
+	result[1] = v0[1] + (v1[1] - v0[1]) * f;
+	result[2] = v0[2] + (v1[2] - v0[2]) * f;
 	return result;
 }
 
-mfloat_t *vec3_bezier3(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32, mfloat_t f)
+mfloat_t *vec3_bezier3(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2, mfloat_t f)
 {
 	mfloat_t tmp0[VEC3_SIZE];
 	mfloat_t tmp1[VEC3_SIZE];
-	vec3_lerp(tmp0, vec30, vec31, f);
-	vec3_lerp(tmp1, vec31, vec32, f);
+	vec3_lerp(tmp0, v0, v1, f);
+	vec3_lerp(tmp1, v1, v2, f);
 	vec3_lerp(result, tmp0, tmp1, f);
 	return result;
 }
 
-mfloat_t *vec3_bezier4(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32, mfloat_t *vec33, mfloat_t f)
+mfloat_t *vec3_bezier4(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2, mfloat_t *v3, mfloat_t f)
 {
 	mfloat_t tmp0[VEC3_SIZE];
 	mfloat_t tmp1[VEC3_SIZE];
 	mfloat_t tmp2[VEC3_SIZE];
 	mfloat_t tmp3[VEC3_SIZE];
 	mfloat_t tmp4[VEC3_SIZE];
-	vec3_lerp(tmp0, vec30, vec31, f);
-	vec3_lerp(tmp1, vec31, vec32, f);
-	vec3_lerp(tmp2, vec32, vec33, f);
+	vec3_lerp(tmp0, v0, v1, f);
+	vec3_lerp(tmp1, v1, v2, f);
+	vec3_lerp(tmp2, v2, v3, f);
 	vec3_lerp(tmp3, tmp0, tmp1, f);
 	vec3_lerp(tmp4, tmp1, tmp2, f);
 	vec3_lerp(result, tmp3, tmp4, f);
 	return result;
 }
 
-mfloat_t vec3_length(mfloat_t *vec30)
+mfloat_t vec3_length(mfloat_t *v0)
 {
-	return MSQRT(vec30[0] * vec30[0] + vec30[1] * vec30[1] + vec30[2] * vec30[2]);
+	return MSQRT(v0[0] * v0[0] + v0[1] * v0[1] + v0[2] * v0[2]);
 }
 
-mfloat_t vec3_length_squared(mfloat_t *vec30)
+mfloat_t vec3_length_squared(mfloat_t *v0)
 {
-	return vec30[0] * vec30[0] + vec30[1] * vec30[1] + vec30[2] * vec30[2];
+	return v0[0] * v0[0] + v0[1] * v0[1] + v0[2] * v0[2];
 }
 
-mfloat_t vec3_distance(mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t vec3_distance(mfloat_t *v0, mfloat_t *v1)
 {
-	return MSQRT((vec30[0] - vec31[0]) * (vec30[0] - vec31[0]) + (vec30[1] - vec31[1]) * (vec30[1] - vec31[1]) + (vec30[2] - vec31[2]) * (vec30[2] - vec31[2]));
+	return MSQRT((v0[0] - v1[0]) * (v0[0] - v1[0]) + (v0[1] - v1[1]) * (v0[1] - v1[1]) + (v0[2] - v1[2]) * (v0[2] - v1[2]));
 }
 
-mfloat_t vec3_distance_squared(mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t vec3_distance_squared(mfloat_t *v0, mfloat_t *v1)
 {
-	return (vec30[0] - vec31[0]) * (vec30[0] - vec31[0]) + (vec30[1] - vec31[1]) * (vec30[1] - vec31[1]) + (vec30[2] - vec31[2]) * (vec30[2] - vec31[2]);
+	return (v0[0] - v1[0]) * (v0[0] - v1[0]) + (v0[1] - v1[1]) * (v0[1] - v1[1]) + (v0[2] - v1[2]) * (v0[2] - v1[2]);
 }
 
-bool vec4_is_zero(mfloat_t *vec40)
+bool vec4_is_zero(mfloat_t *v0)
 {
-	return vec40[0] < MFLT_EPSILON && vec40[1] < MFLT_EPSILON && vec40[2] < MFLT_EPSILON && vec40[3] < MFLT_EPSILON;
+	return v0[0] < MFLT_EPSILON && v0[1] < MFLT_EPSILON && v0[2] < MFLT_EPSILON && v0[3] < MFLT_EPSILON;
 }
 
-bool vec4_is_equal(mfloat_t *vec40, mfloat_t *vec41)
+bool vec4_is_equal(mfloat_t *v0, mfloat_t *v1)
 {
-	return MFABS(vec40[0] - vec41[0]) < MFLT_EPSILON && MFABS(vec40[1] - vec41[1]) < MFLT_EPSILON && MFABS(vec40[2] - vec41[2]) < MFLT_EPSILON && MFABS(vec40[3] - vec41[3]) < MFLT_EPSILON;
+	return MFABS(v0[0] - v1[0]) < MFLT_EPSILON && MFABS(v0[1] - v1[1]) < MFLT_EPSILON && MFABS(v0[2] - v1[2]) < MFLT_EPSILON && MFABS(v0[3] - v1[3]) < MFLT_EPSILON;
 }
 
 mfloat_t *vec4(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
@@ -1433,22 +1433,22 @@ mfloat_t *vec4(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
 	return result;
 }
 
-mfloat_t *vec4_assign(mfloat_t *result, mfloat_t *vec40)
+mfloat_t *vec4_assign(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = vec40[0];
-	result[1] = vec40[1];
-	result[2] = vec40[2];
-	result[3] = vec40[3];
+	result[0] = v0[0];
+	result[1] = v0[1];
+	result[2] = v0[2];
+	result[3] = v0[3];
 	return result;
 }
 
 #if defined(MATHC_USE_INT)
-mfloat_t *vec4_assign_vec4i(mfloat_t *result, mint_t *vec4i0)
+mfloat_t *vec4_assign_vec4i(mfloat_t *result, mint_t *v0)
 {
-	result[0] = vec4i0[0];
-	result[1] = vec4i0[1];
-	result[2] = vec4i0[2];
-	result[3] = vec4i0[3];
+	result[0] = v0[0];
+	result[1] = v0[1];
+	result[2] = v0[2];
+	result[3] = v0[3];
 	return result;
 }
 #endif
@@ -1471,32 +1471,32 @@ mfloat_t *vec4_one(mfloat_t *result)
 	return result;
 }
 
-mfloat_t *vec4_sign(mfloat_t *result, mfloat_t *vec40)
+mfloat_t *vec4_sign(mfloat_t *result, mfloat_t *v0)
 {
-	if (vec40[0] > MFLOAT_C(0.0)) {
+	if (v0[0] > MFLOAT_C(0.0)) {
 		result[0] = MFLOAT_C(1.0);
-	} else if (vec40[0] < 0) {
+	} else if (v0[0] < 0) {
 		result[0] = -MFLOAT_C(1.0);
 	} else {
 		result[0] = MFLOAT_C(0.0);
 	}
-	if (vec40[1] > MFLOAT_C(0.0)) {
+	if (v0[1] > MFLOAT_C(0.0)) {
 		result[1] = MFLOAT_C(1.0);
-	} else if (vec40[1] < 0) {
+	} else if (v0[1] < 0) {
 		result[1] = -MFLOAT_C(1.0);
 	} else {
 		result[1] = MFLOAT_C(0.0);
 	}
-	if (vec40[2] > MFLOAT_C(0.0)) {
+	if (v0[2] > MFLOAT_C(0.0)) {
 		result[2] = MFLOAT_C(1.0);
-	} else if (vec40[2] < 0) {
+	} else if (v0[2] < 0) {
 		result[2] = -MFLOAT_C(1.0);
 	} else {
 		result[2] = MFLOAT_C(0.0);
 	}
-	if (vec40[3] > MFLOAT_C(0.0)) {
+	if (v0[3] > MFLOAT_C(0.0)) {
 		result[3] = MFLOAT_C(1.0);
-	} else if (vec40[3] < 0) {
+	} else if (v0[3] < 0) {
 		result[3] = -MFLOAT_C(1.0);
 	} else {
 		result[3] = MFLOAT_C(0.0);
@@ -1504,206 +1504,206 @@ mfloat_t *vec4_sign(mfloat_t *result, mfloat_t *vec40)
 	return result;
 }
 
-mfloat_t *vec4_add(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41)
+mfloat_t *vec4_add(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = vec40[0] + vec41[0];
-	result[1] = vec40[1] + vec41[1];
-	result[2] = vec40[2] + vec41[2];
-	result[3] = vec40[3] + vec41[3];
+	result[0] = v0[0] + v1[0];
+	result[1] = v0[1] + v1[1];
+	result[2] = v0[2] + v1[2];
+	result[3] = v0[3] + v1[3];
 	return result;
 }
 
-mfloat_t *vec4_add_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f)
+mfloat_t *vec4_add_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = vec40[0] + f;
-	result[1] = vec40[1] + f;
-	result[2] = vec40[2] + f;
-	result[3] = vec40[3] + f;
+	result[0] = v0[0] + f;
+	result[1] = v0[1] + f;
+	result[2] = v0[2] + f;
+	result[3] = v0[3] + f;
 	return result;
 }
 
-mfloat_t *vec4_subtract(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41)
+mfloat_t *vec4_subtract(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = vec40[0] - vec41[0];
-	result[1] = vec40[1] - vec41[1];
-	result[2] = vec40[2] - vec41[2];
-	result[3] = vec40[3] - vec41[3];
+	result[0] = v0[0] - v1[0];
+	result[1] = v0[1] - v1[1];
+	result[2] = v0[2] - v1[2];
+	result[3] = v0[3] - v1[3];
 	return result;
 }
 
-mfloat_t *vec4_subtract_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f)
+mfloat_t *vec4_subtract_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = vec40[0] - f;
-	result[1] = vec40[1] - f;
-	result[2] = vec40[2] - f;
-	result[3] = vec40[3] - f;
+	result[0] = v0[0] - f;
+	result[1] = v0[1] - f;
+	result[2] = v0[2] - f;
+	result[3] = v0[3] - f;
 	return result;
 }
 
-mfloat_t *vec4_multiply(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41)
+mfloat_t *vec4_multiply(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = vec40[0] * vec41[0];
-	result[1] = vec40[1] * vec41[1];
-	result[2] = vec40[2] * vec41[2];
-	result[3] = vec40[3] * vec41[3];
+	result[0] = v0[0] * v1[0];
+	result[1] = v0[1] * v1[1];
+	result[2] = v0[2] * v1[2];
+	result[3] = v0[3] * v1[3];
 	return result;
 }
 
-mfloat_t *vec4_multiply_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f)
+mfloat_t *vec4_multiply_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = vec40[0] * f;
-	result[1] = vec40[1] * f;
-	result[2] = vec40[2] * f;
-	result[3] = vec40[3] * f;
+	result[0] = v0[0] * f;
+	result[1] = v0[1] * f;
+	result[2] = v0[2] * f;
+	result[3] = v0[3] * f;
 	return result;
 }
 
-mfloat_t *vec4_multiply_mat4(mfloat_t *result, mfloat_t *vec40, mfloat_t *mat40)
+mfloat_t *vec4_multiply_mat4(mfloat_t *result, mfloat_t *v0, mfloat_t *m0)
 {
-	mfloat_t x = vec40[0];
-	mfloat_t y = vec40[1];
-	mfloat_t z = vec40[2];
-	mfloat_t w = vec40[3];
-	result[0] = mat40[0] * x + mat40[4] * y + mat40[8] * z + mat40[12] * w;
-	result[1] = mat40[1] * x + mat40[5] * y + mat40[9] * z + mat40[13] * w;
-	result[2] = mat40[2] * x + mat40[6] * y + mat40[10] * z + mat40[14] * w;
-	result[3] = mat40[3] * x + mat40[7] * y + mat40[11] * z + mat40[15] * w;
+	mfloat_t x = v0[0];
+	mfloat_t y = v0[1];
+	mfloat_t z = v0[2];
+	mfloat_t w = v0[3];
+	result[0] = m0[0] * x + m0[4] * y + m0[8] * z + m0[12] * w;
+	result[1] = m0[1] * x + m0[5] * y + m0[9] * z + m0[13] * w;
+	result[2] = m0[2] * x + m0[6] * y + m0[10] * z + m0[14] * w;
+	result[3] = m0[3] * x + m0[7] * y + m0[11] * z + m0[15] * w;
 	return result;
 }
 
-mfloat_t *vec4_divide(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41)
+mfloat_t *vec4_divide(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = vec40[0] / vec41[0];
-	result[1] = vec40[1] / vec41[1];
-	result[2] = vec40[2] / vec41[2];
-	result[3] = vec40[3] / vec41[3];
+	result[0] = v0[0] / v1[0];
+	result[1] = v0[1] / v1[1];
+	result[2] = v0[2] / v1[2];
+	result[3] = v0[3] / v1[3];
 	return result;
 }
 
-mfloat_t *vec4_divide_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f)
+mfloat_t *vec4_divide_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = vec40[0] / f;
-	result[1] = vec40[1] / f;
-	result[2] = vec40[2] / f;
-	result[3] = vec40[3] / f;
+	result[0] = v0[0] / f;
+	result[1] = v0[1] / f;
+	result[2] = v0[2] / f;
+	result[3] = v0[3] / f;
 	return result;
 }
 
-mfloat_t *vec4_snap(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41)
+mfloat_t *vec4_snap(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = MFLOOR(vec40[0] / vec41[0]) * vec41[0];
-	result[1] = MFLOOR(vec40[1] / vec41[1]) * vec41[1];
-	result[2] = MFLOOR(vec40[2] / vec41[2]) * vec41[2];
-	result[3] = MFLOOR(vec40[3] / vec41[3]) * vec41[3];
+	result[0] = MFLOOR(v0[0] / v1[0]) * v1[0];
+	result[1] = MFLOOR(v0[1] / v1[1]) * v1[1];
+	result[2] = MFLOOR(v0[2] / v1[2]) * v1[2];
+	result[3] = MFLOOR(v0[3] / v1[3]) * v1[3];
 	return result;
 }
 
-mfloat_t *vec4_snap_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f)
+mfloat_t *vec4_snap_f(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
-	result[0] = MFLOOR(vec40[0] / f) * f;
-	result[1] = MFLOOR(vec40[1] / f) * f;
-	result[2] = MFLOOR(vec40[2] / f) * f;
-	result[3] = MFLOOR(vec40[3] / f) * f;
+	result[0] = MFLOOR(v0[0] / f) * f;
+	result[1] = MFLOOR(v0[1] / f) * f;
+	result[2] = MFLOOR(v0[2] / f) * f;
+	result[3] = MFLOOR(v0[3] / f) * f;
 	return result;
 }
 
-mfloat_t *vec4_negative(mfloat_t *result, mfloat_t *vec40)
+mfloat_t *vec4_negative(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = -vec40[0];
-	result[1] = -vec40[1];
-	result[2] = -vec40[2];
-	result[3] = -vec40[3];
+	result[0] = -v0[0];
+	result[1] = -v0[1];
+	result[2] = -v0[2];
+	result[3] = -v0[3];
 	return result;
 }
 
-mfloat_t *vec4_abs(mfloat_t *result, mfloat_t *vec40)
+mfloat_t *vec4_abs(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = MFABS(vec40[0]);
-	result[1] = MFABS(vec40[1]);
-	result[2] = MFABS(vec40[2]);
-	result[3] = MFABS(vec40[3]);
+	result[0] = MFABS(v0[0]);
+	result[1] = MFABS(v0[1]);
+	result[2] = MFABS(v0[2]);
+	result[3] = MFABS(v0[3]);
 	return result;
 }
 
-mfloat_t *vec4_floor(mfloat_t *result, mfloat_t *vec40)
+mfloat_t *vec4_floor(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = MFLOOR(vec40[0]);
-	result[1] = MFLOOR(vec40[1]);
-	result[2] = MFLOOR(vec40[2]);
-	result[3] = MFLOOR(vec40[3]);
+	result[0] = MFLOOR(v0[0]);
+	result[1] = MFLOOR(v0[1]);
+	result[2] = MFLOOR(v0[2]);
+	result[3] = MFLOOR(v0[3]);
 	return result;
 }
 
-mfloat_t *vec4_ceil(mfloat_t *result, mfloat_t *vec40)
+mfloat_t *vec4_ceil(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = MCEIL(vec40[0]);
-	result[1] = MCEIL(vec40[1]);
-	result[2] = MCEIL(vec40[2]);
-	result[3] = MCEIL(vec40[3]);
+	result[0] = MCEIL(v0[0]);
+	result[1] = MCEIL(v0[1]);
+	result[2] = MCEIL(v0[2]);
+	result[3] = MCEIL(v0[3]);
 	return result;
 }
 
-mfloat_t *vec4_round(mfloat_t *result, mfloat_t *vec40)
+mfloat_t *vec4_round(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = MROUND(vec40[0]);
-	result[1] = MROUND(vec40[1]);
-	result[2] = MROUND(vec40[2]);
-	result[3] = MROUND(vec40[3]);
+	result[0] = MROUND(v0[0]);
+	result[1] = MROUND(v0[1]);
+	result[2] = MROUND(v0[2]);
+	result[3] = MROUND(v0[3]);
 	return result;
 }
 
-mfloat_t *vec4_max(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41)
+mfloat_t *vec4_max(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = MFMAX(vec40[0], vec41[0]);
-	result[1] = MFMAX(vec40[1], vec41[1]);
-	result[2] = MFMAX(vec40[2], vec41[2]);
-	result[3] = MFMAX(vec40[3], vec41[3]);
+	result[0] = MFMAX(v0[0], v1[0]);
+	result[1] = MFMAX(v0[1], v1[1]);
+	result[2] = MFMAX(v0[2], v1[2]);
+	result[3] = MFMAX(v0[3], v1[3]);
 	return result;
 }
 
-mfloat_t *vec4_min(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41)
+mfloat_t *vec4_min(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	result[0] = MFMIN(vec40[0], vec41[0]);
-	result[1] = MFMIN(vec40[1], vec41[1]);
-	result[2] = MFMIN(vec40[2], vec41[2]);
-	result[3] = MFMIN(vec40[3], vec41[3]);
+	result[0] = MFMIN(v0[0], v1[0]);
+	result[1] = MFMIN(v0[1], v1[1]);
+	result[2] = MFMIN(v0[2], v1[2]);
+	result[3] = MFMIN(v0[3], v1[3]);
 	return result;
 }
 
-mfloat_t *vec4_clamp(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41, mfloat_t *vec42)
+mfloat_t *vec4_clamp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2)
 {
-	vec4_min(result, vec40, vec41);
-	vec4_max(result, vec40, vec42);
+	vec4_min(result, v0, v1);
+	vec4_max(result, v0, v2);
 	return result;
 }
 
-mfloat_t *vec4_normalize(mfloat_t *result, mfloat_t *vec40)
+mfloat_t *vec4_normalize(mfloat_t *result, mfloat_t *v0)
 {
-	mfloat_t l = MSQRT(vec40[0] * vec40[0] + vec40[1] * vec40[1] + vec40[2] * vec40[2] + vec40[3] * vec40[3]);
-	result[0] = vec40[0] / l;
-	result[1] = vec40[1] / l;
-	result[2] = vec40[2] / l;
-	result[3] = vec40[3] / l;
+	mfloat_t l = MSQRT(v0[0] * v0[0] + v0[1] * v0[1] + v0[2] * v0[2] + v0[3] * v0[3]);
+	result[0] = v0[0] / l;
+	result[1] = v0[1] / l;
+	result[2] = v0[2] / l;
+	result[3] = v0[3] / l;
 	return result;
 }
 
-mfloat_t *vec4_lerp(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41, mfloat_t f)
+mfloat_t *vec4_lerp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t f)
 {
-	result[0] = vec40[0] + (vec41[0] - vec40[0]) * f;
-	result[1] = vec40[1] + (vec41[1] - vec40[1]) * f;
-	result[2] = vec40[2] + (vec41[2] - vec40[2]) * f;
-	result[3] = vec40[3] + (vec41[3] - vec40[3]) * f;
+	result[0] = v0[0] + (v1[0] - v0[0]) * f;
+	result[1] = v0[1] + (v1[1] - v0[1]) * f;
+	result[2] = v0[2] + (v1[2] - v0[2]) * f;
+	result[3] = v0[3] + (v1[3] - v0[3]) * f;
 	return result;
 }
 
-bool quat_is_zero(mfloat_t *quat0)
+bool quat_is_zero(mfloat_t *q0)
 {
-	return quat0[0] < MFLT_EPSILON && quat0[1] < MFLT_EPSILON && quat0[2] < MFLT_EPSILON && quat0[3] < MFLT_EPSILON;
+	return q0[0] < MFLT_EPSILON && q0[1] < MFLT_EPSILON && q0[2] < MFLT_EPSILON && q0[3] < MFLT_EPSILON;
 }
 
-bool quat_is_equal(mfloat_t *quat0, mfloat_t *quat1)
+bool quat_is_equal(mfloat_t *q0, mfloat_t *q1)
 {
-	return MFABS(quat0[0] - quat1[0]) < MFLT_EPSILON && MFABS(quat0[1] - quat1[1]) < MFLT_EPSILON && MFABS(quat0[2] - quat1[2]) < MFLT_EPSILON && MFABS(quat0[3] - quat1[3]) < MFLT_EPSILON;
+	return MFABS(q0[0] - q1[0]) < MFLT_EPSILON && MFABS(q0[1] - q1[1]) < MFLT_EPSILON && MFABS(q0[2] - q1[2]) < MFLT_EPSILON && MFABS(q0[3] - q1[3]) < MFLT_EPSILON;
 }
 
 mfloat_t *quat(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
@@ -1715,12 +1715,12 @@ mfloat_t *quat(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
 	return result;
 }
 
-mfloat_t *quat_assign(mfloat_t *result, mfloat_t *quat0)
+mfloat_t *quat_assign(mfloat_t *result, mfloat_t *q0)
 {
-	result[0] = quat0[0];
-	result[1] = quat0[1];
-	result[2] = quat0[2];
-	result[3] = quat0[3];
+	result[0] = q0[0];
+	result[1] = q0[1];
+	result[2] = q0[2];
+	result[3] = q0[3];
 	return result;
 }
 
@@ -1742,35 +1742,35 @@ mfloat_t *quat_null(mfloat_t *result)
 	return result;
 }
 
-mfloat_t *quat_multiply(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1)
+mfloat_t *quat_multiply(mfloat_t *result, mfloat_t *q0, mfloat_t *q1)
 {
-	result[0] = quat0[3] * quat1[0] + quat0[0] * quat1[3] + quat0[1] * quat1[2] - quat0[2] * quat1[1];
-	result[1] = quat0[3] * quat1[1] + quat0[1] * quat1[3] + quat0[2] * quat1[0] - quat0[0] * quat1[2];
-	result[2] = quat0[3] * quat1[2] + quat0[2] * quat1[3] + quat0[0] * quat1[1] - quat0[1] * quat1[0];
-	result[3] = quat0[3] * quat1[3] - quat0[0] * quat1[0] - quat0[1] * quat1[1] - quat0[2] * quat1[2];
+	result[0] = q0[3] * q1[0] + q0[0] * q1[3] + q0[1] * q1[2] - q0[2] * q1[1];
+	result[1] = q0[3] * q1[1] + q0[1] * q1[3] + q0[2] * q1[0] - q0[0] * q1[2];
+	result[2] = q0[3] * q1[2] + q0[2] * q1[3] + q0[0] * q1[1] - q0[1] * q1[0];
+	result[3] = q0[3] * q1[3] - q0[0] * q1[0] - q0[1] * q1[1] - q0[2] * q1[2];
 	return result;
 }
 
-mfloat_t *quat_multiply_f(mfloat_t *result, mfloat_t *quat0, mfloat_t f)
+mfloat_t *quat_multiply_f(mfloat_t *result, mfloat_t *q0, mfloat_t f)
 {
-	result[0] = quat0[0] * f;
-	result[1] = quat0[1] * f;
-	result[2] = quat0[2] * f;
-	result[3] = quat0[3] * f;
+	result[0] = q0[0] * f;
+	result[1] = q0[1] * f;
+	result[2] = q0[2] * f;
+	result[3] = q0[3] * f;
 	return result;
 }
 
-mfloat_t *quat_divide(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1)
+mfloat_t *quat_divide(mfloat_t *result, mfloat_t *q0, mfloat_t *q1)
 {
-	mfloat_t x = quat0[0];
-	mfloat_t y = quat0[1];
-	mfloat_t z = quat0[2];
-	mfloat_t w = quat0[3];
-	mfloat_t ls = quat1[0] * quat1[0] + quat1[1] * quat1[1] + quat1[8] * quat1[8] + quat1[3] * quat1[3];
-	mfloat_t normalized_x = -quat1[0] / ls;
-	mfloat_t normalized_y = -quat1[1] / ls;
-	mfloat_t normalized_z = -quat1[8] / ls;
-	mfloat_t normalized_w = quat1[3] / ls;
+	mfloat_t x = q0[0];
+	mfloat_t y = q0[1];
+	mfloat_t z = q0[2];
+	mfloat_t w = q0[3];
+	mfloat_t ls = q1[0] * q1[0] + q1[1] * q1[1] + q1[8] * q1[8] + q1[3] * q1[3];
+	mfloat_t normalized_x = -q1[0] / ls;
+	mfloat_t normalized_y = -q1[1] / ls;
+	mfloat_t normalized_z = -q1[8] / ls;
+	mfloat_t normalized_w = q1[3] / ls;
 	result[0] = x * normalized_w + normalized_x * w + (y * normalized_z - z * normalized_y);
 	result[1] = y * normalized_w + normalized_y * w + (z * normalized_x - x * normalized_z);
 	result[2] = z * normalized_w + normalized_z * w + (x * normalized_y - y * normalized_x);
@@ -1778,62 +1778,62 @@ mfloat_t *quat_divide(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1)
 	return result;
 }
 
-mfloat_t *quat_divide_f(mfloat_t *result, mfloat_t *quat0, mfloat_t f)
+mfloat_t *quat_divide_f(mfloat_t *result, mfloat_t *q0, mfloat_t f)
 {
-	result[0] = quat0[0] / f;
-	result[1] = quat0[1] / f;
-	result[2] = quat0[2] / f;
-	result[3] = quat0[3] / f;
+	result[0] = q0[0] / f;
+	result[1] = q0[1] / f;
+	result[2] = q0[2] / f;
+	result[3] = q0[3] / f;
 	return result;
 }
 
-mfloat_t *quat_negative(mfloat_t *result, mfloat_t *quat0)
+mfloat_t *quat_negative(mfloat_t *result, mfloat_t *q0)
 {
-	result[0] = -quat0[0];
-	result[1] = -quat0[1];
-	result[2] = -quat0[2];
-	result[3] = -quat0[3];
+	result[0] = -q0[0];
+	result[1] = -q0[1];
+	result[2] = -q0[2];
+	result[3] = -q0[3];
 	return result;
 }
 
-mfloat_t *quat_conjugate(mfloat_t *result, mfloat_t *quat0)
+mfloat_t *quat_conjugate(mfloat_t *result, mfloat_t *q0)
 {
-	result[0] = -quat0[0];
-	result[1] = -quat0[1];
-	result[2] = -quat0[2];
-	result[3] = quat0[3];
+	result[0] = -q0[0];
+	result[1] = -q0[1];
+	result[2] = -q0[2];
+	result[3] = q0[3];
 	return result;
 }
 
-mfloat_t *quat_inverse(mfloat_t *result, mfloat_t *quat0)
+mfloat_t *quat_inverse(mfloat_t *result, mfloat_t *q0)
 {
-	mfloat_t l = MFLOAT_C(1.0) / (quat0[0] * quat0[0] + quat0[1] * quat0[1] + quat0[2] * quat0[2] + quat0[3] * quat0[3]);
-	result[0] = -quat0[0] * l;
-	result[1] = -quat0[1] * l;
-	result[2] = -quat0[2] * l;
-	result[3] = quat0[3] * l;
+	mfloat_t l = MFLOAT_C(1.0) / (q0[0] * q0[0] + q0[1] * q0[1] + q0[2] * q0[2] + q0[3] * q0[3]);
+	result[0] = -q0[0] * l;
+	result[1] = -q0[1] * l;
+	result[2] = -q0[2] * l;
+	result[3] = q0[3] * l;
 	return result;
 }
 
-mfloat_t *quat_normalize(mfloat_t *result, mfloat_t *quat0)
+mfloat_t *quat_normalize(mfloat_t *result, mfloat_t *q0)
 {
-	mfloat_t l = MFLOAT_C(1.0) / MSQRT(quat0[0] * quat0[0] + quat0[1] * quat0[1] + quat0[2] * quat0[2] + quat0[3] * quat0[3]);
-	result[0] = quat0[0] * l;
-	result[1] = quat0[1] * l;
-	result[2] = quat0[2] * l;
-	result[3] = quat0[3] * l;
+	mfloat_t l = MFLOAT_C(1.0) / MSQRT(q0[0] * q0[0] + q0[1] * q0[1] + q0[2] * q0[2] + q0[3] * q0[3]);
+	result[0] = q0[0] * l;
+	result[1] = q0[1] * l;
+	result[2] = q0[2] * l;
+	result[3] = q0[3] * l;
 	return result;
 }
 
-mfloat_t quat_dot(mfloat_t *quat0, mfloat_t *quat1)
+mfloat_t quat_dot(mfloat_t *q0, mfloat_t *q1)
 {
-	return quat0[0] * quat1[0] + quat0[1] * quat1[1] + quat0[2] * quat1[2] + quat0[3] * quat1[3];
+	return q0[0] * q1[0] + q0[1] * q1[1] + q0[2] * q1[2] + q0[3] * q1[3];
 }
 
-mfloat_t *quat_power(mfloat_t *result, mfloat_t *quat0, mfloat_t exponent)
+mfloat_t *quat_power(mfloat_t *result, mfloat_t *q0, mfloat_t exponent)
 {
-	if (MFABS(quat0[3]) < MFLOAT_C(1.0) - MFLT_EPSILON) {
-		mfloat_t alpha = MACOS(quat0[3]);
+	if (MFABS(q0[3]) < MFLOAT_C(1.0) - MFLT_EPSILON) {
+		mfloat_t alpha = MACOS(q0[3]);
 		mfloat_t new_alpha = alpha * exponent;
 		mfloat_t s = MSIN(new_alpha) / MSIN(alpha);
 		result[0] = result[0] * s;
@@ -1841,88 +1841,88 @@ mfloat_t *quat_power(mfloat_t *result, mfloat_t *quat0, mfloat_t exponent)
 		result[2] = result[2] * s;
 		result[3] = MCOS(new_alpha);
 	} else {
-		result[0] = quat0[0];
-		result[1] = quat0[1];
-		result[2] = quat0[1];
-		result[3] = quat0[3];
+		result[0] = q0[0];
+		result[1] = q0[1];
+		result[2] = q0[1];
+		result[3] = q0[3];
 	}
 	return result;
 }
 
-mfloat_t *quat_from_axis_angle(mfloat_t *result, mfloat_t *vec30, mfloat_t angle)
+mfloat_t *quat_from_axis_angle(mfloat_t *result, mfloat_t *v0, mfloat_t angle)
 {
 	mfloat_t half = angle * MFLOAT_C(0.5);
 	mfloat_t s = MSIN(half);
-	result[0] = vec30[0] * s;
-	result[1] = vec30[1] * s;
-	result[2] = vec30[2] * s;
+	result[0] = v0[0] * s;
+	result[1] = v0[1] * s;
+	result[2] = v0[2] * s;
 	result[3] = MCOS(half);
 	return result;
 }
 
-mfloat_t *quat_from_vec3(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31)
+mfloat_t *quat_from_vec3(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
 	mfloat_t cross[VEC3_SIZE];
-	mfloat_t d = vec3_dot(vec30, vec31);
-	mfloat_t a_ls = vec3_length_squared(vec30);
-	mfloat_t b_ls = vec3_length_squared(vec30);
-	vec3_cross(cross, vec30, vec31);
+	mfloat_t d = vec3_dot(v0, v1);
+	mfloat_t a_ls = vec3_length_squared(v0);
+	mfloat_t b_ls = vec3_length_squared(v0);
+	vec3_cross(cross, v0, v1);
 	quat(result, cross[0], cross[1], cross[1], d + MSQRT(a_ls * b_ls));
 	quat_normalize(result, result);
 	return result;
 }
 
-mfloat_t *quat_from_mat4(mfloat_t *result, mfloat_t *mat40)
+mfloat_t *quat_from_mat4(mfloat_t *result, mfloat_t *m0)
 {
-	mfloat_t scale = mat40[0] + mat40[5] + mat40[10];
+	mfloat_t scale = m0[0] + m0[5] + m0[10];
 	if (scale > MFLOAT_C(0.0)) {
 		mfloat_t sr = MSQRT(scale + MFLOAT_C(1.0));
 		result[3] = sr * MFLOAT_C(0.5);
 		sr = MFLOAT_C(0.5) / sr;
-		result[0] = (mat40[9] - mat40[6]) * sr;
-		result[1] = (mat40[2] - mat40[8]) * sr;
-		result[2] = (mat40[4] - mat40[1]) * sr;
-	} else if ((mat40[0] >= mat40[5]) && (mat40[0] >= mat40[10])) {
-		mfloat_t sr = MSQRT(MFLOAT_C(1.0) + mat40[0] - mat40[5] - mat40[10]);
+		result[0] = (m0[9] - m0[6]) * sr;
+		result[1] = (m0[2] - m0[8]) * sr;
+		result[2] = (m0[4] - m0[1]) * sr;
+	} else if ((m0[0] >= m0[5]) && (m0[0] >= m0[10])) {
+		mfloat_t sr = MSQRT(MFLOAT_C(1.0) + m0[0] - m0[5] - m0[10]);
 		mfloat_t half = MFLOAT_C(0.5) / sr;
 		result[0] = MFLOAT_C(0.5) * sr;
-		result[1] = (mat40[4] + mat40[1]) * half;
-		result[2] = (mat40[8] + mat40[2]) * half;
-		result[3] = (mat40[9] - mat40[6]) * half;
-	} else if (mat40[5] > mat40[10]) {
-		mfloat_t sr = MSQRT(MFLOAT_C(1.0) + mat40[5] - mat40[0] - mat40[10]);
+		result[1] = (m0[4] + m0[1]) * half;
+		result[2] = (m0[8] + m0[2]) * half;
+		result[3] = (m0[9] - m0[6]) * half;
+	} else if (m0[5] > m0[10]) {
+		mfloat_t sr = MSQRT(MFLOAT_C(1.0) + m0[5] - m0[0] - m0[10]);
 		mfloat_t half = MFLOAT_C(0.5) / sr;
-		result[0] = (mat40[1] + mat40[4]) * half;
+		result[0] = (m0[1] + m0[4]) * half;
 		result[1] = MFLOAT_C(0.5) * sr;
-		result[2] = (mat40[6] + mat40[9]) * half;
-		result[3] = (mat40[2] - mat40[8]) * half;
+		result[2] = (m0[6] + m0[9]) * half;
+		result[3] = (m0[2] - m0[8]) * half;
 	} else {
-		mfloat_t sr = MSQRT(MFLOAT_C(1.0) + mat40[10] - mat40[0] - mat40[5]);
+		mfloat_t sr = MSQRT(MFLOAT_C(1.0) + m0[10] - m0[0] - m0[5]);
 		mfloat_t half = MFLOAT_C(0.5) / sr;
-		result[0] = (mat40[2] + mat40[8]) * half;
-		result[1] = (mat40[6] + mat40[9]) * half;
+		result[0] = (m0[2] + m0[8]) * half;
+		result[1] = (m0[6] + m0[9]) * half;
 		result[2] = MFLOAT_C(0.5) * sr;
-		result[3] = (mat40[4] - mat40[1]) * half;
+		result[3] = (m0[4] - m0[1]) * half;
 	}
 	return result;
 }
 
-mfloat_t *quat_lerp(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1, mfloat_t f)
+mfloat_t *quat_lerp(mfloat_t *result, mfloat_t *q0, mfloat_t *q1, mfloat_t f)
 {
-	result[0] = quat0[0] + (quat1[0] - quat0[0]) * f;
-	result[1] = quat0[1] + (quat1[1] - quat0[1]) * f;
-	result[2] = quat0[2] + (quat1[2] - quat0[2]) * f;
-	result[3] = quat0[3] + (quat1[3] - quat0[3]) * f;
+	result[0] = q0[0] + (q1[0] - q0[0]) * f;
+	result[1] = q0[1] + (q1[1] - q0[1]) * f;
+	result[2] = q0[2] + (q1[2] - q0[2]) * f;
+	result[3] = q0[3] + (q1[3] - q0[3]) * f;
 	return result;
 }
 
-mfloat_t *quat_slerp(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1, mfloat_t f)
+mfloat_t *quat_slerp(mfloat_t *result, mfloat_t *q0, mfloat_t *q1, mfloat_t f)
 {
 	mfloat_t tmp1[QUAT_SIZE];
-	mfloat_t d = quat_dot(quat0, quat1);
+	mfloat_t d = quat_dot(q0, q1);
 	mfloat_t f0;
 	mfloat_t f1;
-	quat_assign(tmp1, quat1);
+	quat_assign(tmp1, q1);
 	if (d < MFLOAT_C(0.0)) {
 		quat_negative(tmp1, tmp1);
 		d = -d;
@@ -1936,28 +1936,28 @@ mfloat_t *quat_slerp(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1, mfloat_
 		f0 = MSIN((MFLOAT_C(1.0) - f) * theta) / sin_theta;
 		f1 = MSIN(f * theta) / sin_theta;
 	}
-	result[0] = quat0[0] * f0 + tmp1[0] * f1;
-	result[1] = quat0[1] * f0 + tmp1[1] * f1;
-	result[2] = quat0[2] * f0 + tmp1[2] * f1;
-	result[3] = quat0[3] * f0 + tmp1[3] * f1;
+	result[0] = q0[0] * f0 + tmp1[0] * f1;
+	result[1] = q0[1] * f0 + tmp1[1] * f1;
+	result[2] = q0[2] * f0 + tmp1[2] * f1;
+	result[3] = q0[3] * f0 + tmp1[3] * f1;
 	return result;
 }
 
-mfloat_t quat_length(mfloat_t *quat0)
+mfloat_t quat_length(mfloat_t *q0)
 {
-	return MSQRT(quat0[0] * quat0[0] + quat0[1] * quat0[1] + quat0[2] * quat0[2] + quat0[3] * quat0[3]);
+	return MSQRT(q0[0] * q0[0] + q0[1] * q0[1] + q0[2] * q0[2] + q0[3] * q0[3]);
 }
 
-mfloat_t quat_length_squared(mfloat_t *quat0)
+mfloat_t quat_length_squared(mfloat_t *q0)
 {
-	return quat0[0] * quat0[0] + quat0[1] * quat0[1] + quat0[2] * quat0[2] + quat0[3] * quat0[3];
+	return q0[0] * q0[0] + q0[1] * q0[1] + q0[2] * q0[2] + q0[3] * q0[3];
 }
 
-mfloat_t quat_angle(mfloat_t *quat0, mfloat_t *quat1)
+mfloat_t quat_angle(mfloat_t *q0, mfloat_t *q1)
 {
-	mfloat_t s = MSQRT(quat_length_squared(quat0) * quat_length_squared(quat1));
+	mfloat_t s = MSQRT(quat_length_squared(q0) * quat_length_squared(q1));
 	s = MFLOAT_C(1.0) / s;
-	return MACOS(quat_dot(quat0, quat1) * s);
+	return MACOS(quat_dot(q0, q1) * s);
 }
 
 mfloat_t *mat2(mfloat_t *result, mfloat_t m11, mfloat_t m12, mfloat_t m21, mfloat_t m22)
@@ -1987,36 +1987,36 @@ mfloat_t *mat2_identity(mfloat_t *result)
 	return result;
 }
 
-mfloat_t mat2_determinant(mfloat_t *mat20)
+mfloat_t mat2_determinant(mfloat_t *m0)
 {
-	return mat20[0] * mat20[3] - mat20[2] * mat20[1];
+	return m0[0] * m0[3] - m0[2] * m0[1];
 }
 
-mfloat_t *mat2_assign(mfloat_t *result, mfloat_t *mat20)
+mfloat_t *mat2_assign(mfloat_t *result, mfloat_t *m0)
 {
-	result[0] = mat20[0];
-	result[1] = mat20[1];
-	result[2] = mat20[2];
-	result[3] = mat20[3];
+	result[0] = m0[0];
+	result[1] = m0[1];
+	result[2] = m0[2];
+	result[3] = m0[3];
 	return result;
 }
 
-mfloat_t *mat2_negative(mfloat_t *result, mfloat_t *mat20)
+mfloat_t *mat2_negative(mfloat_t *result, mfloat_t *m0)
 {
-	result[0] = -mat20[0];
-	result[1] = -mat20[1];
-	result[2] = -mat20[2];
-	result[3] = -mat20[3];
+	result[0] = -m0[0];
+	result[1] = -m0[1];
+	result[2] = -m0[2];
+	result[3] = -m0[3];
 	return result;
 }
 
-mfloat_t *mat2_transpose(mfloat_t *result, mfloat_t *mat20)
+mfloat_t *mat2_transpose(mfloat_t *result, mfloat_t *m0)
 {
 	mfloat_t transposed[MAT2_SIZE];
-	transposed[0] = mat20[0];
-	transposed[1] = mat20[2];
-	transposed[2] = mat20[1];
-	transposed[3] = mat20[3];
+	transposed[0] = m0[0];
+	transposed[1] = m0[2];
+	transposed[2] = m0[1];
+	transposed[3] = m0[3];
 	result[0] = transposed[0];
 	result[1] = transposed[1];
 	result[2] = transposed[2];
@@ -2024,13 +2024,13 @@ mfloat_t *mat2_transpose(mfloat_t *result, mfloat_t *mat20)
 	return result;
 }
 
-mfloat_t *mat2_cofactor(mfloat_t *result, mfloat_t *mat20)
+mfloat_t *mat2_cofactor(mfloat_t *result, mfloat_t *m0)
 {
 	mfloat_t cofactor[MAT2_SIZE];
-	cofactor[0] = mat20[3];
-	cofactor[1] = -mat20[2];
-	cofactor[2] = -mat20[1];
-	cofactor[3] = mat20[0];
+	cofactor[0] = m0[3];
+	cofactor[1] = -m0[2];
+	cofactor[2] = -m0[1];
+	cofactor[3] = m0[0];
 	result[0] = cofactor[0];
 	result[1] = cofactor[1];
 	result[2] = cofactor[2];
@@ -2038,13 +2038,13 @@ mfloat_t *mat2_cofactor(mfloat_t *result, mfloat_t *mat20)
 	return result;
 }
 
-mfloat_t *mat2_adjugate(mfloat_t *result, mfloat_t *mat20)
+mfloat_t *mat2_adjugate(mfloat_t *result, mfloat_t *m0)
 {
 	mfloat_t adjugate[MAT2_SIZE];
-	adjugate[0] = mat20[3];
-	adjugate[1] = -mat20[1];
-	adjugate[2] = -mat20[2];
-	adjugate[3] = mat20[0];
+	adjugate[0] = m0[3];
+	adjugate[1] = -m0[1];
+	adjugate[2] = -m0[2];
+	adjugate[3] = m0[0];
 	result[0] = adjugate[0];
 	result[1] = adjugate[1];
 	result[2] = adjugate[2];
@@ -2052,13 +2052,13 @@ mfloat_t *mat2_adjugate(mfloat_t *result, mfloat_t *mat20)
 	return result;
 }
 
-mfloat_t *mat2_multiply(mfloat_t *result, mfloat_t *mat20, mfloat_t *mat21)
+mfloat_t *mat2_multiply(mfloat_t *result, mfloat_t *m0, mfloat_t *m1)
 {
 	mfloat_t multiplied[MAT3_SIZE];
-	multiplied[0] = mat20[0] * mat21[0] + mat20[2] * mat21[1];
-	multiplied[1] = mat20[1] * mat21[0] + mat20[3] * mat21[1];
-	multiplied[2] = mat20[0] * mat21[2] + mat20[2] * mat21[3];
-	multiplied[3] = mat20[1] * mat21[2] + mat20[3] * mat21[3];
+	multiplied[0] = m0[0] * m1[0] + m0[2] * m1[1];
+	multiplied[1] = m0[1] * m1[0] + m0[3] * m1[1];
+	multiplied[2] = m0[0] * m1[2] + m0[2] * m1[3];
+	multiplied[3] = m0[1] * m1[2] + m0[3] * m1[3];
 	result[0] = multiplied[0];
 	result[1] = multiplied[1];
 	result[2] = multiplied[2];
@@ -2066,20 +2066,20 @@ mfloat_t *mat2_multiply(mfloat_t *result, mfloat_t *mat20, mfloat_t *mat21)
 	return result;
 }
 
-mfloat_t *mat2_multiply_f(mfloat_t *result, mfloat_t *mat20, mfloat_t f)
+mfloat_t *mat2_multiply_f(mfloat_t *result, mfloat_t *m0, mfloat_t f)
 {
-	result[0] = mat20[0] * f;
-	result[1] = mat20[1] * f;
-	result[2] = mat20[2] * f;
-	result[3] = mat20[3] * f;
+	result[0] = m0[0] * f;
+	result[1] = m0[1] * f;
+	result[2] = m0[2] * f;
+	result[3] = m0[3] * f;
 	return result;
 }
 
-mfloat_t *mat2_inverse(mfloat_t *result, mfloat_t *mat20)
+mfloat_t *mat2_inverse(mfloat_t *result, mfloat_t *m0)
 {
 	mfloat_t inverse[MAT2_SIZE];
-	mfloat_t det = mat2_determinant(mat20);
-	mat2_cofactor(inverse, mat20);
+	mfloat_t det = mat2_determinant(m0);
+	mat2_cofactor(inverse, m0);
 	mat2_multiply_f(inverse, inverse, MFLOAT_C(1.0) / det);
 	result[0] = inverse[0];
 	result[1] = inverse[1];
@@ -2088,17 +2088,17 @@ mfloat_t *mat2_inverse(mfloat_t *result, mfloat_t *mat20)
 	return result;
 }
 
-mfloat_t *mat2_scaling(mfloat_t *result, mfloat_t *vec20)
+mfloat_t *mat2_scaling(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = vec20[0];
-	result[3] = vec20[1];
+	result[0] = v0[0];
+	result[3] = v0[1];
 	return result;
 }
 
-mfloat_t *mat2_scale(mfloat_t *result, mfloat_t *mat20, mfloat_t *vec20)
+mfloat_t *mat2_scale(mfloat_t *result, mfloat_t *m0, mfloat_t *v0)
 {
-	result[0] = mat20[0] * vec20[0];
-	result[3] = mat20[3] * vec20[1];
+	result[0] = m0[0] * v0[0];
+	result[3] = m0[3] * v0[1];
 	return result;
 }
 
@@ -2113,12 +2113,12 @@ mfloat_t *mat2_rotation_z(mfloat_t *result, mfloat_t f)
 	return result;
 }
 
-mfloat_t *mat2_lerp(mfloat_t *result, mfloat_t *mat20, mfloat_t *mat21, mfloat_t f)
+mfloat_t *mat2_lerp(mfloat_t *result, mfloat_t *m0, mfloat_t *m1, mfloat_t f)
 {
-	result[0] = mat20[0] + (mat21[0] - mat20[0]) * f;
-	result[1] = mat20[1] + (mat21[1] - mat20[1]) * f;
-	result[2] = mat20[2] + (mat21[2] - mat20[2]) * f;
-	result[3] = mat20[3] + (mat21[3] - mat20[3]) * f;
+	result[0] = m0[0] + (m1[0] - m0[0]) * f;
+	result[1] = m0[1] + (m1[1] - m0[1]) * f;
+	result[2] = m0[2] + (m1[2] - m0[2]) * f;
+	result[3] = m0[3] + (m1[3] - m0[3]) * f;
 	return result;
 }
 
@@ -2164,17 +2164,17 @@ mfloat_t *mat3_identity(mfloat_t *result)
 	return result;
 }
 
-mfloat_t mat3_determinant(mfloat_t *mat30)
+mfloat_t mat3_determinant(mfloat_t *m0)
 {
-	mfloat_t m11 = mat30[0];
-	mfloat_t m21 = mat30[1];
-	mfloat_t m31 = mat30[2];
-	mfloat_t m12 = mat30[3];
-	mfloat_t m22 = mat30[4];
-	mfloat_t m32 = mat30[5];
-	mfloat_t m13 = mat30[6];
-	mfloat_t m23 = mat30[7];
-	mfloat_t m33 = mat30[8];
+	mfloat_t m11 = m0[0];
+	mfloat_t m21 = m0[1];
+	mfloat_t m31 = m0[2];
+	mfloat_t m12 = m0[3];
+	mfloat_t m22 = m0[4];
+	mfloat_t m32 = m0[5];
+	mfloat_t m13 = m0[6];
+	mfloat_t m23 = m0[7];
+	mfloat_t m33 = m0[8];
 	mfloat_t determinant = m11 * m22 * m33
 		+ m12 * m23 * m31
 		+ m13 * m21 * m32
@@ -2184,46 +2184,46 @@ mfloat_t mat3_determinant(mfloat_t *mat30)
 	return determinant;
 }
 
-mfloat_t *mat3_assign(mfloat_t *result, mfloat_t *mat30)
+mfloat_t *mat3_assign(mfloat_t *result, mfloat_t *m0)
 {
-	result[0] = mat30[0];
-	result[1] = mat30[1];
-	result[2] = mat30[2];
-	result[3] = mat30[3];
-	result[4] = mat30[4];
-	result[5] = mat30[5];
-	result[6] = mat30[6];
-	result[7] = mat30[7];
-	result[8] = mat30[8];
+	result[0] = m0[0];
+	result[1] = m0[1];
+	result[2] = m0[2];
+	result[3] = m0[3];
+	result[4] = m0[4];
+	result[5] = m0[5];
+	result[6] = m0[6];
+	result[7] = m0[7];
+	result[8] = m0[8];
 	return result;
 }
 
-mfloat_t *mat3_negative(mfloat_t *result, mfloat_t *mat30)
+mfloat_t *mat3_negative(mfloat_t *result, mfloat_t *m0)
 {
-	result[0] = -mat30[0];
-	result[1] = -mat30[1];
-	result[2] = -mat30[2];
-	result[3] = -mat30[3];
-	result[4] = -mat30[4];
-	result[5] = -mat30[5];
-	result[6] = -mat30[6];
-	result[7] = -mat30[7];
-	result[8] = -mat30[8];
+	result[0] = -m0[0];
+	result[1] = -m0[1];
+	result[2] = -m0[2];
+	result[3] = -m0[3];
+	result[4] = -m0[4];
+	result[5] = -m0[5];
+	result[6] = -m0[6];
+	result[7] = -m0[7];
+	result[8] = -m0[8];
 	return result;
 }
 
-mfloat_t *mat3_transpose(mfloat_t *result, mfloat_t *mat30)
+mfloat_t *mat3_transpose(mfloat_t *result, mfloat_t *m0)
 {
 	mfloat_t transposed[MAT4_SIZE];
-	transposed[0] = mat30[0];
-	transposed[1] = mat30[3];
-	transposed[2] = mat30[6];
-	transposed[3] = mat30[1];
-	transposed[4] = mat30[4];
-	transposed[5] = mat30[7];
-	transposed[6] = mat30[2];
-	transposed[7] = mat30[5];
-	transposed[8] = mat30[8];
+	transposed[0] = m0[0];
+	transposed[1] = m0[3];
+	transposed[2] = m0[6];
+	transposed[3] = m0[1];
+	transposed[4] = m0[4];
+	transposed[5] = m0[7];
+	transposed[6] = m0[2];
+	transposed[7] = m0[5];
+	transposed[8] = m0[8];
 	result[0] = transposed[0];
 	result[1] = transposed[1];
 	result[2] = transposed[2];
@@ -2236,54 +2236,54 @@ mfloat_t *mat3_transpose(mfloat_t *result, mfloat_t *mat30)
 	return result;
 }
 
-mfloat_t *mat3_cofactor(mfloat_t *result, mfloat_t *mat30)
+mfloat_t *mat3_cofactor(mfloat_t *result, mfloat_t *m0)
 {
 	mfloat_t cofactor[MAT3_SIZE];
 	mfloat_t minor[MAT2_SIZE];
-	minor[0] = mat30[4];
-	minor[1] = mat30[5];
-	minor[2] = mat30[7];
-	minor[3] = mat30[8];
+	minor[0] = m0[4];
+	minor[1] = m0[5];
+	minor[2] = m0[7];
+	minor[3] = m0[8];
 	cofactor[0] = mat2_determinant(minor);
-	minor[0] = mat30[3];
-	minor[1] = mat30[5];
-	minor[2] = mat30[6];
-	minor[3] = mat30[8];
+	minor[0] = m0[3];
+	minor[1] = m0[5];
+	minor[2] = m0[6];
+	minor[3] = m0[8];
 	cofactor[1] = -mat2_determinant(minor);
-	minor[0] = mat30[3];
-	minor[1] = mat30[4];
-	minor[2] = mat30[6];
-	minor[3] = mat30[7];
+	minor[0] = m0[3];
+	minor[1] = m0[4];
+	minor[2] = m0[6];
+	minor[3] = m0[7];
 	cofactor[2] = mat2_determinant(minor);
-	minor[0] = mat30[1];
-	minor[1] = mat30[2];
-	minor[2] = mat30[7];
-	minor[3] = mat30[8];
+	minor[0] = m0[1];
+	minor[1] = m0[2];
+	minor[2] = m0[7];
+	minor[3] = m0[8];
 	cofactor[3] = -mat2_determinant(minor);
-	minor[0] = mat30[0];
-	minor[1] = mat30[2];
-	minor[2] = mat30[6];
-	minor[3] = mat30[8];
+	minor[0] = m0[0];
+	minor[1] = m0[2];
+	minor[2] = m0[6];
+	minor[3] = m0[8];
 	cofactor[4] = mat2_determinant(minor);
-	minor[0] = mat30[0];
-	minor[1] = mat30[1];
-	minor[2] = mat30[6];
-	minor[3] = mat30[7];
+	minor[0] = m0[0];
+	minor[1] = m0[1];
+	minor[2] = m0[6];
+	minor[3] = m0[7];
 	cofactor[5] = -mat2_determinant(minor);
-	minor[0] = mat30[1];
-	minor[1] = mat30[2];
-	minor[2] = mat30[4];
-	minor[3] = mat30[5];
+	minor[0] = m0[1];
+	minor[1] = m0[2];
+	minor[2] = m0[4];
+	minor[3] = m0[5];
 	cofactor[6] = mat2_determinant(minor);
-	minor[0] = mat30[0];
-	minor[1] = mat30[2];
-	minor[2] = mat30[3];
-	minor[3] = mat30[5];
+	minor[0] = m0[0];
+	minor[1] = m0[2];
+	minor[2] = m0[3];
+	minor[3] = m0[5];
 	cofactor[7] = -mat2_determinant(minor);
-	minor[0] = mat30[0];
-	minor[1] = mat30[1];
-	minor[2] = mat30[3];
-	minor[3] = mat30[4];
+	minor[0] = m0[0];
+	minor[1] = m0[1];
+	minor[2] = m0[3];
+	minor[3] = m0[4];
 	cofactor[8] = mat2_determinant(minor);
 	result[0] = cofactor[0];
 	result[1] = cofactor[1];
@@ -2297,18 +2297,18 @@ mfloat_t *mat3_cofactor(mfloat_t *result, mfloat_t *mat30)
 	return result;
 }
 
-mfloat_t *mat3_multiply(mfloat_t *result, mfloat_t *mat30, mfloat_t *mat31)
+mfloat_t *mat3_multiply(mfloat_t *result, mfloat_t *m0, mfloat_t *m1)
 {
 	mfloat_t multiplied[MAT3_SIZE];
-	multiplied[0] = mat30[0] * mat31[0] + mat30[3] * mat31[1] + mat30[6] * mat31[2];
-	multiplied[1] = mat30[1] * mat31[0] + mat30[4] * mat31[1] + mat30[7] * mat31[2];
-	multiplied[2] = mat30[2] * mat31[0] + mat30[5] * mat31[1] + mat30[8] * mat31[2];
-	multiplied[3] = mat30[0] * mat31[3] + mat30[3] * mat31[4] + mat30[6] * mat31[5];
-	multiplied[4] = mat30[1] * mat31[3] + mat30[4] * mat31[4] + mat30[7] * mat31[5];
-	multiplied[5] = mat30[2] * mat31[3] + mat30[5] * mat31[4] + mat30[8] * mat31[5];
-	multiplied[6] = mat30[0] * mat31[6] + mat30[3] * mat31[7] + mat30[6] * mat31[8];
-	multiplied[7] = mat30[1] * mat31[6] + mat30[4] * mat31[7] + mat30[7] * mat31[8];
-	multiplied[8] = mat30[2] * mat31[6] + mat30[5] * mat31[7] + mat30[8] * mat31[8];
+	multiplied[0] = m0[0] * m1[0] + m0[3] * m1[1] + m0[6] * m1[2];
+	multiplied[1] = m0[1] * m1[0] + m0[4] * m1[1] + m0[7] * m1[2];
+	multiplied[2] = m0[2] * m1[0] + m0[5] * m1[1] + m0[8] * m1[2];
+	multiplied[3] = m0[0] * m1[3] + m0[3] * m1[4] + m0[6] * m1[5];
+	multiplied[4] = m0[1] * m1[3] + m0[4] * m1[4] + m0[7] * m1[5];
+	multiplied[5] = m0[2] * m1[3] + m0[5] * m1[4] + m0[8] * m1[5];
+	multiplied[6] = m0[0] * m1[6] + m0[3] * m1[7] + m0[6] * m1[8];
+	multiplied[7] = m0[1] * m1[6] + m0[4] * m1[7] + m0[7] * m1[8];
+	multiplied[8] = m0[2] * m1[6] + m0[5] * m1[7] + m0[8] * m1[8];
 	result[0] = multiplied[0];
 	result[1] = multiplied[1];
 	result[2] = multiplied[2];
@@ -2321,39 +2321,39 @@ mfloat_t *mat3_multiply(mfloat_t *result, mfloat_t *mat30, mfloat_t *mat31)
 	return result;
 }
 
-mfloat_t *mat3_multiply_f(mfloat_t *result, mfloat_t *mat30, mfloat_t f)
+mfloat_t *mat3_multiply_f(mfloat_t *result, mfloat_t *m0, mfloat_t f)
 {
-	result[0] = mat30[0] * f;
-	result[1] = mat30[1] * f;
-	result[2] = mat30[2] * f;
-	result[3] = mat30[3] * f;
-	result[4] = mat30[4] * f;
-	result[5] = mat30[5] * f;
-	result[6] = mat30[6] * f;
-	result[7] = mat30[7] * f;
-	result[8] = mat30[8] * f;
+	result[0] = m0[0] * f;
+	result[1] = m0[1] * f;
+	result[2] = m0[2] * f;
+	result[3] = m0[3] * f;
+	result[4] = m0[4] * f;
+	result[5] = m0[5] * f;
+	result[6] = m0[6] * f;
+	result[7] = m0[7] * f;
+	result[8] = m0[8] * f;
 	return result;
 }
 
-mfloat_t *mat3_inverse(mfloat_t *result, mfloat_t *mat30)
+mfloat_t *mat3_inverse(mfloat_t *result, mfloat_t *m0)
 {
-	result = mat30;
+	result = m0;
 	return result;
 }
 
-mfloat_t *mat3_scaling(mfloat_t *result, mfloat_t *vec30)
+mfloat_t *mat3_scaling(mfloat_t *result, mfloat_t *v0)
 {
-	result[0] = vec30[0];
-	result[4] = vec30[1];
-	result[8] = vec30[2];
+	result[0] = v0[0];
+	result[4] = v0[1];
+	result[8] = v0[2];
 	return result;
 }
 
-mfloat_t *mat3_scale(mfloat_t *result, mfloat_t *mat30, mfloat_t *vec30)
+mfloat_t *mat3_scale(mfloat_t *result, mfloat_t *m0, mfloat_t *v0)
 {
-	result[0] = mat30[0] * vec30[0];
-	result[4] = mat30[4] * vec30[1];
-	result[8] = mat30[8] * vec30[2];
+	result[0] = m0[0] * v0[0];
+	result[4] = m0[4] * v0[1];
+	result[8] = m0[8] * v0[2];
 	return result;
 }
 
@@ -2390,14 +2390,14 @@ mfloat_t *mat3_rotation_z(mfloat_t *result, mfloat_t f)
 	return result;
 }
 
-mfloat_t *mat3_rotation_axis(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
+mfloat_t *mat3_rotation_axis(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
 	mfloat_t c = MCOS(f);
 	mfloat_t s = MSIN(f);
 	mfloat_t one_c = MFLOAT_C(1.0) - c;
-	mfloat_t x = vec30[0];
-	mfloat_t y = vec30[4];
-	mfloat_t z = vec30[8];
+	mfloat_t x = v0[0];
+	mfloat_t y = v0[4];
+	mfloat_t z = v0[8];
 	mfloat_t xx = x * x;
 	mfloat_t xy = x * y;
 	mfloat_t xz = x * z;
@@ -2407,28 +2407,28 @@ mfloat_t *mat3_rotation_axis(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
 	mfloat_t l = xx + yy + zz;
 	mfloat_t sqrt_l = MSQRT(l);
 	result[0] = (xx + (yy + zz) * c) / l;
-	result[1] = (xy * one_c + vec30[2] * sqrt_l * s) / l;
-	result[2] = (xz * one_c - vec30[1] * sqrt_l * s) / l;
-	result[3] = (xy * one_c - vec30[2] * sqrt_l * s) / l;
+	result[1] = (xy * one_c + v0[2] * sqrt_l * s) / l;
+	result[2] = (xz * one_c - v0[1] * sqrt_l * s) / l;
+	result[3] = (xy * one_c - v0[2] * sqrt_l * s) / l;
 	result[4] = (yy + (xx + zz) * c) / l;
-	result[5] = (yz * one_c + vec30[0] * sqrt_l * s) / l;
-	result[6] = (xz * one_c + vec30[1] * sqrt_l * s) / l;
-	result[7] = (yz * one_c - vec30[0] * sqrt_l * s) / l;
+	result[5] = (yz * one_c + v0[0] * sqrt_l * s) / l;
+	result[6] = (xz * one_c + v0[1] * sqrt_l * s) / l;
+	result[7] = (yz * one_c - v0[0] * sqrt_l * s) / l;
 	result[8] = (zz + (xx + yy) * c) / l;
 	return result;
 }
 
-mfloat_t *mat3_rotation_quat(mfloat_t *result, mfloat_t *quat0)
+mfloat_t *mat3_rotation_quat(mfloat_t *result, mfloat_t *q0)
 {
-	mfloat_t xx = quat0[0] * quat0[0];
-	mfloat_t yy = quat0[1] * quat0[1];
-	mfloat_t zz = quat0[2] * quat0[2];
-	mfloat_t xy = quat0[0] * quat0[1];
-	mfloat_t zw = quat0[2] * quat0[3];
-	mfloat_t xz = quat0[8] * quat0[0];
-	mfloat_t yw = quat0[1] * quat0[3];
-	mfloat_t yz = quat0[1] * quat0[2];
-	mfloat_t xw = quat0[0] * quat0[3];
+	mfloat_t xx = q0[0] * q0[0];
+	mfloat_t yy = q0[1] * q0[1];
+	mfloat_t zz = q0[2] * q0[2];
+	mfloat_t xy = q0[0] * q0[1];
+	mfloat_t zw = q0[2] * q0[3];
+	mfloat_t xz = q0[8] * q0[0];
+	mfloat_t yw = q0[1] * q0[3];
+	mfloat_t yz = q0[1] * q0[2];
+	mfloat_t xw = q0[0] * q0[3];
 	result[0] = MFLOAT_C(1.0) - MFLOAT_C(2.0) * (yy - zz);
 	result[1] = MFLOAT_C(2.0) * (xy + zw);
 	result[2] = MFLOAT_C(2.0) * (xz - yw);
@@ -2441,17 +2441,17 @@ mfloat_t *mat3_rotation_quat(mfloat_t *result, mfloat_t *quat0)
 	return result;
 }
 
-mfloat_t *mat3_lerp(mfloat_t *result, mfloat_t *mat30, mfloat_t *mat31, mfloat_t f)
+mfloat_t *mat3_lerp(mfloat_t *result, mfloat_t *m0, mfloat_t *m1, mfloat_t f)
 {
-	result[0] = mat30[0] + (mat31[0] - mat30[0]) * f;
-	result[1] = mat30[1] + (mat31[1] - mat30[1]) * f;
-	result[2] = mat30[2] + (mat31[2] - mat30[2]) * f;
-	result[3] = mat30[3] + (mat31[3] - mat30[3]) * f;
-	result[4] = mat30[4] + (mat31[4] - mat30[4]) * f;
-	result[5] = mat30[5] + (mat31[5] - mat30[5]) * f;
-	result[6] = mat30[6] + (mat31[6] - mat30[6]) * f;
-	result[7] = mat30[7] + (mat31[7] - mat30[7]) * f;
-	result[8] = mat30[8] + (mat31[8] - mat30[8]) * f;
+	result[0] = m0[0] + (m1[0] - m0[0]) * f;
+	result[1] = m0[1] + (m1[1] - m0[1]) * f;
+	result[2] = m0[2] + (m1[2] - m0[2]) * f;
+	result[3] = m0[3] + (m1[3] - m0[3]) * f;
+	result[4] = m0[4] + (m1[4] - m0[4]) * f;
+	result[5] = m0[5] + (m1[5] - m0[5]) * f;
+	result[6] = m0[6] + (m1[6] - m0[6]) * f;
+	result[7] = m0[7] + (m1[7] - m0[7]) * f;
+	result[8] = m0[8] + (m1[8] - m0[8]) * f;
 	return result;
 }
 
@@ -2518,24 +2518,24 @@ mfloat_t *mat4_identity(mfloat_t *result)
 	return result;
 }
 
-mfloat_t mat4_determinant(mfloat_t *mat40)
-{
-	mfloat_t m11 = mat40[0];
-	mfloat_t m21 = mat40[1];
-	mfloat_t m31 = mat40[2];
-	mfloat_t m41 = mat40[3];
-	mfloat_t m12 = mat40[4];
-	mfloat_t m22 = mat40[5];
-	mfloat_t m32 = mat40[6];
-	mfloat_t m42 = mat40[7];
-	mfloat_t m13 = mat40[8];
-	mfloat_t m23 = mat40[9];
-	mfloat_t m33 = mat40[10];
-	mfloat_t m43 = mat40[11];
-	mfloat_t m14 = mat40[12];
-	mfloat_t m24 = mat40[13];
-	mfloat_t m34 = mat40[14];
-	mfloat_t m44 = mat40[15];
+mfloat_t mat4_determinant(mfloat_t *m0)
+{
+	mfloat_t m11 = m0[0];
+	mfloat_t m21 = m0[1];
+	mfloat_t m31 = m0[2];
+	mfloat_t m41 = m0[3];
+	mfloat_t m12 = m0[4];
+	mfloat_t m22 = m0[5];
+	mfloat_t m32 = m0[6];
+	mfloat_t m42 = m0[7];
+	mfloat_t m13 = m0[8];
+	mfloat_t m23 = m0[9];
+	mfloat_t m33 = m0[10];
+	mfloat_t m43 = m0[11];
+	mfloat_t m14 = m0[12];
+	mfloat_t m24 = m0[13];
+	mfloat_t m34 = m0[14];
+	mfloat_t m44 = m0[15];
 	mfloat_t determinant = m14 * m23 * m32 * m41 - m13 * m24 * m32 * m41
 		- m14 * m22 * m33 * m41 + m12 * m24 * m33 * m41
 		+ m13 * m22 * m34 * m41 - m12 * m23 * m34 * m41
@@ -2551,67 +2551,67 @@ mfloat_t mat4_determinant(mfloat_t *mat40)
 	return determinant;
 }
 
-mfloat_t *mat4_assign(mfloat_t *result, mfloat_t *mat40)
+mfloat_t *mat4_assign(mfloat_t *result, mfloat_t *m0)
 {
-	result[0] = mat40[0];
-	result[1] = mat40[1];
-	result[2] = mat40[2];
-	result[3] = mat40[3];
-	result[4] = mat40[4];
-	result[5] = mat40[5];
-	result[6] = mat40[6];
-	result[7] = mat40[7];
-	result[8] = mat40[8];
-	result[9] = mat40[9];
-	result[10] = mat40[10];
-	result[11] = mat40[11];
-	result[12] = mat40[12];
-	result[13] = mat40[13];
-	result[14] = mat40[14];
-	result[15] = mat40[15];
+	result[0] = m0[0];
+	result[1] = m0[1];
+	result[2] = m0[2];
+	result[3] = m0[3];
+	result[4] = m0[4];
+	result[5] = m0[5];
+	result[6] = m0[6];
+	result[7] = m0[7];
+	result[8] = m0[8];
+	result[9] = m0[9];
+	result[10] = m0[10];
+	result[11] = m0[11];
+	result[12] = m0[12];
+	result[13] = m0[13];
+	result[14] = m0[14];
+	result[15] = m0[15];
 	return result;
 }
 
-mfloat_t *mat4_negative(mfloat_t *result, mfloat_t *mat40)
+mfloat_t *mat4_negative(mfloat_t *result, mfloat_t *m0)
 {
-	result[0] = -mat40[0];
-	result[1] = -mat40[1];
-	result[2] = -mat40[2];
-	result[3] = -mat40[3];
-	result[4] = -mat40[4];
-	result[5] = -mat40[5];
-	result[6] = -mat40[6];
-	result[7] = -mat40[7];
-	result[8] = -mat40[8];
-	result[9] = -mat40[9];
-	result[10] = -mat40[10];
-	result[11] = -mat40[11];
-	result[12] = -mat40[12];
-	result[13] = -mat40[13];
-	result[14] = -mat40[14];
-	result[15] = -mat40[15];
+	result[0] = -m0[0];
+	result[1] = -m0[1];
+	result[2] = -m0[2];
+	result[3] = -m0[3];
+	result[4] = -m0[4];
+	result[5] = -m0[5];
+	result[6] = -m0[6];
+	result[7] = -m0[7];
+	result[8] = -m0[8];
+	result[9] = -m0[9];
+	result[10] = -m0[10];
+	result[11] = -m0[11];
+	result[12] = -m0[12];
+	result[13] = -m0[13];
+	result[14] = -m0[14];
+	result[15] = -m0[15];
 	return result;
 }
 
-mfloat_t *mat4_transpose(mfloat_t *result, mfloat_t *mat40)
+mfloat_t *mat4_transpose(mfloat_t *result, mfloat_t *m0)
 {
 	mfloat_t transposed[MAT4_SIZE];
-	transposed[0] = mat40[0];
-	transposed[1] = mat40[4];
-	transposed[2] = mat40[8];
-	transposed[3] = mat40[12];
-	transposed[4] = mat40[1];
-	transposed[5] = mat40[5];
-	transposed[6] = mat40[9];
-	transposed[7] = mat40[13];
-	transposed[8] = mat40[2];
-	transposed[9] = mat40[6];
-	transposed[10] = mat40[10];
-	transposed[11] = mat40[14];
-	transposed[12] = mat40[3];
-	transposed[13] = mat40[7];
-	transposed[14] = mat40[11];
-	transposed[15] = mat40[15];
+	transposed[0] = m0[0];
+	transposed[1] = m0[4];
+	transposed[2] = m0[8];
+	transposed[3] = m0[12];
+	transposed[4] = m0[1];
+	transposed[5] = m0[5];
+	transposed[6] = m0[9];
+	transposed[7] = m0[13];
+	transposed[8] = m0[2];
+	transposed[9] = m0[6];
+	transposed[10] = m0[10];
+	transposed[11] = m0[14];
+	transposed[12] = m0[3];
+	transposed[13] = m0[7];
+	transposed[14] = m0[11];
+	transposed[15] = m0[15];
 	result[0] = transposed[0];
 	result[1] = transposed[1];
 	result[2] = transposed[2];
@@ -2631,169 +2631,169 @@ mfloat_t *mat4_transpose(mfloat_t *result, mfloat_t *mat40)
 	return result;
 }
 
-mfloat_t *mat4_cofactor(mfloat_t *result, mfloat_t *mat40)
+mfloat_t *mat4_cofactor(mfloat_t *result, mfloat_t *m0)
 {
 	mfloat_t cofactor[MAT4_SIZE];
 	mfloat_t minor[MAT3_SIZE];
-	minor[0] = mat40[5];
-	minor[1] = mat40[6];
-	minor[2] = mat40[7];
-	minor[3] = mat40[9];
-	minor[4] = mat40[10];
-	minor[5] = mat40[11];
-	minor[6] = mat40[13];
-	minor[7] = mat40[14];
-	minor[8] = mat40[15];
+	minor[0] = m0[5];
+	minor[1] = m0[6];
+	minor[2] = m0[7];
+	minor[3] = m0[9];
+	minor[4] = m0[10];
+	minor[5] = m0[11];
+	minor[6] = m0[13];
+	minor[7] = m0[14];
+	minor[8] = m0[15];
 	cofactor[0] = mat3_determinant(minor);
-	minor[0] = mat40[4];
-	minor[1] = mat40[6];
-	minor[2] = mat40[7];
-	minor[3] = mat40[8];
-	minor[4] = mat40[10];
-	minor[5] = mat40[11];
-	minor[6] = mat40[12];
-	minor[7] = mat40[14];
-	minor[8] = mat40[15];
+	minor[0] = m0[4];
+	minor[1] = m0[6];
+	minor[2] = m0[7];
+	minor[3] = m0[8];
+	minor[4] = m0[10];
+	minor[5] = m0[11];
+	minor[6] = m0[12];
+	minor[7] = m0[14];
+	minor[8] = m0[15];
 	cofactor[1] = -mat3_determinant(minor);
-	minor[0] = mat40[4];
-	minor[1] = mat40[5];
-	minor[2] = mat40[7];
-	minor[3] = mat40[8];
-	minor[4] = mat40[9];
-	minor[5] = mat40[11];
-	minor[6] = mat40[12];
-	minor[7] = mat40[13];
-	minor[8] = mat40[15];
+	minor[0] = m0[4];
+	minor[1] = m0[5];
+	minor[2] = m0[7];
+	minor[3] = m0[8];
+	minor[4] = m0[9];
+	minor[5] = m0[11];
+	minor[6] = m0[12];
+	minor[7] = m0[13];
+	minor[8] = m0[15];
 	cofactor[2] = mat3_determinant(minor);
-	minor[0] = mat40[4];
-	minor[1] = mat40[5];
-	minor[2] = mat40[6];
-	minor[3] = mat40[8];
-	minor[4] = mat40[9];
-	minor[5] = mat40[10];
-	minor[6] = mat40[12];
-	minor[7] = mat40[13];
-	minor[8] = mat40[14];
+	minor[0] = m0[4];
+	minor[1] = m0[5];
+	minor[2] = m0[6];
+	minor[3] = m0[8];
+	minor[4] = m0[9];
+	minor[5] = m0[10];
+	minor[6] = m0[12];
+	minor[7] = m0[13];
+	minor[8] = m0[14];
 	cofactor[3] = -mat3_determinant(minor);
-	minor[0] = mat40[1];
-	minor[1] = mat40[2];
-	minor[2] = mat40[3];
-	minor[3] = mat40[9];
-	minor[4] = mat40[10];
-	minor[5] = mat40[11];
-	minor[6] = mat40[13];
-	minor[7] = mat40[14];
-	minor[8] = mat40[15];
+	minor[0] = m0[1];
+	minor[1] = m0[2];
+	minor[2] = m0[3];
+	minor[3] = m0[9];
+	minor[4] = m0[10];
+	minor[5] = m0[11];
+	minor[6] = m0[13];
+	minor[7] = m0[14];
+	minor[8] = m0[15];
 	cofactor[4] = -mat3_determinant(minor);
-	minor[0] = mat40[0];
-	minor[1] = mat40[2];
-	minor[2] = mat40[3];
-	minor[3] = mat40[8];
-	minor[4] = mat40[10];
-	minor[5] = mat40[11];
-	minor[6] = mat40[12];
-	minor[7] = mat40[14];
-	minor[8] = mat40[15];
+	minor[0] = m0[0];
+	minor[1] = m0[2];
+	minor[2] = m0[3];
+	minor[3] = m0[8];
+	minor[4] = m0[10];
+	minor[5] = m0[11];
+	minor[6] = m0[12];
+	minor[7] = m0[14];
+	minor[8] = m0[15];
 	cofactor[5] = mat3_determinant(minor);
-	minor[0] = mat40[0];
-	minor[1] = mat40[1];
-	minor[2] = mat40[3];
-	minor[3] = mat40[8];
-	minor[4] = mat40[9];
-	minor[5] = mat40[11];
-	minor[6] = mat40[12];
-	minor[7] = mat40[13];
-	minor[8] = mat40[15];
+	minor[0] = m0[0];
+	minor[1] = m0[1];
+	minor[2] = m0[3];
+	minor[3] = m0[8];
+	minor[4] = m0[9];
+	minor[5] = m0[11];
+	minor[6] = m0[12];
+	minor[7] = m0[13];
+	minor[8] = m0[15];
 	cofactor[6] = -mat3_determinant(minor);
-	minor[0] = mat40[0];
-	minor[1] = mat40[1];
-	minor[2] = mat40[2];
-	minor[3] = mat40[8];
-	minor[4] = mat40[9];
-	minor[5] = mat40[10];
-	minor[6] = mat40[12];
-	minor[7] = mat40[13];
-	minor[8] = mat40[14];
+	minor[0] = m0[0];
+	minor[1] = m0[1];
+	minor[2] = m0[2];
+	minor[3] = m0[8];
+	minor[4] = m0[9];
+	minor[5] = m0[10];
+	minor[6] = m0[12];
+	minor[7] = m0[13];
+	minor[8] = m0[14];
 	cofactor[7] = mat3_determinant(minor);
-	minor[0] = mat40[1];
-	minor[1] = mat40[2];
-	minor[2] = mat40[3];
-	minor[3] = mat40[5];
-	minor[4] = mat40[6];
-	minor[5] = mat40[7];
-	minor[6] = mat40[13];
-	minor[7] = mat40[14];
-	minor[8] = mat40[15];
+	minor[0] = m0[1];
+	minor[1] = m0[2];
+	minor[2] = m0[3];
+	minor[3] = m0[5];
+	minor[4] = m0[6];
+	minor[5] = m0[7];
+	minor[6] = m0[13];
+	minor[7] = m0[14];
+	minor[8] = m0[15];
 	cofactor[8] = mat3_determinant(minor);
-	minor[0] = mat40[0];
-	minor[1] = mat40[2];
-	minor[2] = mat40[3];
-	minor[3] = mat40[4];
-	minor[4] = mat40[6];
-	minor[5] = mat40[7];
-	minor[6] = mat40[12];
-	minor[7] = mat40[14];
-	minor[8] = mat40[15];
+	minor[0] = m0[0];
+	minor[1] = m0[2];
+	minor[2] = m0[3];
+	minor[3] = m0[4];
+	minor[4] = m0[6];
+	minor[5] = m0[7];
+	minor[6] = m0[12];
+	minor[7] = m0[14];
+	minor[8] = m0[15];
 	cofactor[9] = -mat3_determinant(minor);
-	minor[0] = mat40[0];
-	minor[1] = mat40[1];
-	minor[2] = mat40[3];
-	minor[3] = mat40[4];
-	minor[4] = mat40[5];
-	minor[5] = mat40[7];
-	minor[6] = mat40[12];
-	minor[7] = mat40[13];
-	minor[8] = mat40[15];
+	minor[0] = m0[0];
+	minor[1] = m0[1];
+	minor[2] = m0[3];
+	minor[3] = m0[4];
+	minor[4] = m0[5];
+	minor[5] = m0[7];
+	minor[6] = m0[12];
+	minor[7] = m0[13];
+	minor[8] = m0[15];
 	cofactor[10] = mat3_determinant(minor);
-	minor[0] = mat40[0];
-	minor[1] = mat40[1];
-	minor[2] = mat40[2];
-	minor[3] = mat40[4];
-	minor[4] = mat40[5];
-	minor[5] = mat40[6];
-	minor[6] = mat40[12];
-	minor[7] = mat40[13];
-	minor[8] = mat40[14];
+	minor[0] = m0[0];
+	minor[1] = m0[1];
+	minor[2] = m0[2];
+	minor[3] = m0[4];
+	minor[4] = m0[5];
+	minor[5] = m0[6];
+	minor[6] = m0[12];
+	minor[7] = m0[13];
+	minor[8] = m0[14];
 	cofactor[11] = -mat3_determinant(minor);
-	minor[0] = mat40[1];
-	minor[1] = mat40[2];
-	minor[2] = mat40[3];
-	minor[3] = mat40[5];
-	minor[4] = mat40[6];
-	minor[5] = mat40[7];
-	minor[6] = mat40[9];
-	minor[7] = mat40[10];
-	minor[8] = mat40[11];
+	minor[0] = m0[1];
+	minor[1] = m0[2];
+	minor[2] = m0[3];
+	minor[3] = m0[5];
+	minor[4] = m0[6];
+	minor[5] = m0[7];
+	minor[6] = m0[9];
+	minor[7] = m0[10];
+	minor[8] = m0[11];
 	cofactor[12] = -mat3_determinant(minor);
-	minor[0] = mat40[0];
-	minor[1] = mat40[2];
-	minor[2] = mat40[3];
-	minor[3] = mat40[4];
-	minor[4] = mat40[6];
-	minor[5] = mat40[7];
-	minor[6] = mat40[8];
-	minor[7] = mat40[10];
-	minor[8] = mat40[11];
+	minor[0] = m0[0];
+	minor[1] = m0[2];
+	minor[2] = m0[3];
+	minor[3] = m0[4];
+	minor[4] = m0[6];
+	minor[5] = m0[7];
+	minor[6] = m0[8];
+	minor[7] = m0[10];
+	minor[8] = m0[11];
 	cofactor[13] = mat3_determinant(minor);
-	minor[0] = mat40[0];
-	minor[1] = mat40[1];
-	minor[2] = mat40[3];
-	minor[3] = mat40[4];
-	minor[4] = mat40[5];
-	minor[5] = mat40[7];
-	minor[6] = mat40[8];
-	minor[7] = mat40[9];
-	minor[8] = mat40[11];
+	minor[0] = m0[0];
+	minor[1] = m0[1];
+	minor[2] = m0[3];
+	minor[3] = m0[4];
+	minor[4] = m0[5];
+	minor[5] = m0[7];
+	minor[6] = m0[8];
+	minor[7] = m0[9];
+	minor[8] = m0[11];
 	cofactor[14] = -mat3_determinant(minor);
-	minor[0] = mat40[0];
-	minor[1] = mat40[1];
-	minor[2] = mat40[2];
-	minor[3] = mat40[4];
-	minor[4] = mat40[5];
-	minor[5] = mat40[6];
-	minor[6] = mat40[8];
-	minor[7] = mat40[9];
-	minor[8] = mat40[10];
+	minor[0] = m0[0];
+	minor[1] = m0[1];
+	minor[2] = m0[2];
+	minor[3] = m0[4];
+	minor[4] = m0[5];
+	minor[5] = m0[6];
+	minor[6] = m0[8];
+	minor[7] = m0[9];
+	minor[8] = m0[10];
 	cofactor[15] = mat3_determinant(minor);
 	result[0] = cofactor[0];
 	result[1] = cofactor[1];
@@ -2847,14 +2847,14 @@ mfloat_t *mat4_rotation_z(mfloat_t *result, mfloat_t f)
 	return result;
 }
 
-mfloat_t *mat4_rotation_axis(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
+mfloat_t *mat4_rotation_axis(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 {
 	mfloat_t c = MCOS(f);
 	mfloat_t s = MSIN(f);
 	mfloat_t one_c = MFLOAT_C(1.0) - c;
-	mfloat_t x = vec30[0];
-	mfloat_t y = vec30[4];
-	mfloat_t z = vec30[8];
+	mfloat_t x = v0[0];
+	mfloat_t y = v0[4];
+	mfloat_t z = v0[8];
 	mfloat_t xx = x * x;
 	mfloat_t xy = x * y;
 	mfloat_t xz = x * z;
@@ -2864,15 +2864,15 @@ mfloat_t *mat4_rotation_axis(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
 	mfloat_t l = xx + yy + zz;
 	mfloat_t sqrt_l = MSQRT(l);
 	result[0] = (xx + (yy + zz) * c) / l;
-	result[1] = (xy * one_c + vec30[2] * sqrt_l * s) / l;
-	result[2] = (xz * one_c - vec30[1] * sqrt_l * s) / l;
+	result[1] = (xy * one_c + v0[2] * sqrt_l * s) / l;
+	result[2] = (xz * one_c - v0[1] * sqrt_l * s) / l;
 	result[3] = MFLOAT_C(0.0);
-	result[4] = (xy * one_c - vec30[2] * sqrt_l * s) / l;
+	result[4] = (xy * one_c - v0[2] * sqrt_l * s) / l;
 	result[5] = (yy + (xx + zz) * c) / l;
-	result[6] = (yz * one_c + vec30[0] * sqrt_l * s) / l;
+	result[6] = (yz * one_c + v0[0] * sqrt_l * s) / l;
 	result[7] = MFLOAT_C(0.0);
-	result[8] = (xz * one_c + vec30[1] * sqrt_l * s) / l;
-	result[9] = (yz * one_c - vec30[0] * sqrt_l * s) / l;
+	result[8] = (xz * one_c + v0[1] * sqrt_l * s) / l;
+	result[9] = (yz * one_c - v0[0] * sqrt_l * s) / l;
 	result[10] = (zz + (xx + yy) * c) / l;
 	result[11] = MFLOAT_C(0.0);
 	result[12] = MFLOAT_C(0.0);
@@ -2882,17 +2882,17 @@ mfloat_t *mat4_rotation_axis(mfloat_t *result, mfloat_t *vec30, mfloat_t f)
 	return result;
 }
 
-mfloat_t *mat4_rotation_quat(mfloat_t *result, mfloat_t *quat0)
+mfloat_t *mat4_rotation_quat(mfloat_t *result, mfloat_t *q0)
 {
-	mfloat_t xx = quat0[0] * quat0[0];
-	mfloat_t yy = quat0[1] * quat0[1];
-	mfloat_t zz = quat0[2] * quat0[2];
-	mfloat_t xy = quat0[0] * quat0[1];
-	mfloat_t zw = quat0[2] * quat0[3];
-	mfloat_t xz = quat0[8] * quat0[0];
-	mfloat_t yw = quat0[1] * quat0[3];
-	mfloat_t yz = quat0[1] * quat0[2];
-	mfloat_t xw = quat0[0] * quat0[3];
+	mfloat_t xx = q0[0] * q0[0];
+	mfloat_t yy = q0[1] * q0[1];
+	mfloat_t zz = q0[2] * q0[2];
+	mfloat_t xy = q0[0] * q0[1];
+	mfloat_t zw = q0[2] * q0[3];
+	mfloat_t xz = q0[8] * q0[0];
+	mfloat_t yw = q0[1] * q0[3];
+	mfloat_t yz = q0[1] * q0[2];
+	mfloat_t xw = q0[0] * q0[3];
 	result[0] = MFLOAT_C(1.0) - MFLOAT_C(2.0) * (yy - zz);
 	result[1] = MFLOAT_C(2.0) * (xy + zw);
 	result[2] = MFLOAT_C(2.0) * (xz - yw);
@@ -2912,109 +2912,109 @@ mfloat_t *mat4_rotation_quat(mfloat_t *result, mfloat_t *quat0)
 	return result;
 }
 
-mfloat_t *mat4_translation(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30)
-{
-	result[0] = mat40[0];
-	result[1] = mat40[1];
-	result[2] = mat40[2];
-	result[3] = mat40[3];
-	result[4] = mat40[4];
-	result[5] = mat40[5];
-	result[6] = mat40[6];
-	result[7] = mat40[7];
-	result[8] = mat40[8];
-	result[9] = mat40[9];
-	result[10] = mat40[10];
-	result[11] = mat40[11];
-	result[12] = vec30[0];
-	result[13] = vec30[1];
-	result[14] = vec30[2];
-	result[15] = mat40[15];
-	return result;
-}
-
-mfloat_t *mat4_translate(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30)
-{
-	result[0] = mat40[0];
-	result[1] = mat40[1];
-	result[2] = mat40[2];
-	result[3] = mat40[3];
-	result[4] = mat40[4];
-	result[5] = mat40[5];
-	result[6] = mat40[6];
-	result[7] = mat40[7];
-	result[8] = mat40[8];
-	result[9] = mat40[9];
-	result[10] = mat40[10];
-	result[11] = mat40[11];
-	result[12] = mat40[12] + vec30[0];
-	result[13] = mat40[13] + vec30[1];
-	result[14] = mat40[14] + vec30[2];
-	result[15] = mat40[15];
-	return result;
-}
-
-mfloat_t *mat4_scaling(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30)
-{
-	result[0] = vec30[0];
-	result[1] = mat40[1];
-	result[2] = mat40[2];
-	result[3] = mat40[3];
-	result[4] = mat40[4];
-	result[5] = vec30[1];
-	result[6] = mat40[6];
-	result[7] = mat40[7];
-	result[8] = mat40[8];
-	result[9] = mat40[9];
-	result[10] = vec30[2];
-	result[11] = mat40[11];
-	result[12] = mat40[12];
-	result[13] = mat40[13];
-	result[14] = mat40[14];
-	result[15] = mat40[15];
-	return result;
-}
-
-mfloat_t *mat4_scale(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30)
-{
-	result[0] = mat40[0] * vec30[0];
-	result[1] = mat40[1];
-	result[2] = mat40[2];
-	result[3] = mat40[3];
-	result[4] = mat40[4];
-	result[5] = mat40[5] * vec30[1];
-	result[6] = mat40[6];
-	result[7] = mat40[7];
-	result[8] = mat40[8];
-	result[9] = mat40[9];
-	result[10] = mat40[10] * vec30[2];
-	result[11] = mat40[11];
-	result[12] = mat40[12];
-	result[13] = mat40[13];
-	result[14] = mat40[14];
-	result[15] = mat40[15];
-	return result;
-}
-
-mfloat_t *mat4_multiply(mfloat_t *result, mfloat_t *mat40, mfloat_t *mat41)
+mfloat_t *mat4_translation(mfloat_t *result, mfloat_t *m0, mfloat_t *v0)
+{
+	result[0] = m0[0];
+	result[1] = m0[1];
+	result[2] = m0[2];
+	result[3] = m0[3];
+	result[4] = m0[4];
+	result[5] = m0[5];
+	result[6] = m0[6];
+	result[7] = m0[7];
+	result[8] = m0[8];
+	result[9] = m0[9];
+	result[10] = m0[10];
+	result[11] = m0[11];
+	result[12] = v0[0];
+	result[13] = v0[1];
+	result[14] = v0[2];
+	result[15] = m0[15];
+	return result;
+}
+
+mfloat_t *mat4_translate(mfloat_t *result, mfloat_t *m0, mfloat_t *v0)
+{
+	result[0] = m0[0];
+	result[1] = m0[1];
+	result[2] = m0[2];
+	result[3] = m0[3];
+	result[4] = m0[4];
+	result[5] = m0[5];
+	result[6] = m0[6];
+	result[7] = m0[7];
+	result[8] = m0[8];
+	result[9] = m0[9];
+	result[10] = m0[10];
+	result[11] = m0[11];
+	result[12] = m0[12] + v0[0];
+	result[13] = m0[13] + v0[1];
+	result[14] = m0[14] + v0[2];
+	result[15] = m0[15];
+	return result;
+}
+
+mfloat_t *mat4_scaling(mfloat_t *result, mfloat_t *m0, mfloat_t *v0)
+{
+	result[0] = v0[0];
+	result[1] = m0[1];
+	result[2] = m0[2];
+	result[3] = m0[3];
+	result[4] = m0[4];
+	result[5] = v0[1];
+	result[6] = m0[6];
+	result[7] = m0[7];
+	result[8] = m0[8];
+	result[9] = m0[9];
+	result[10] = v0[2];
+	result[11] = m0[11];
+	result[12] = m0[12];
+	result[13] = m0[13];
+	result[14] = m0[14];
+	result[15] = m0[15];
+	return result;
+}
+
+mfloat_t *mat4_scale(mfloat_t *result, mfloat_t *m0, mfloat_t *v0)
+{
+	result[0] = m0[0] * v0[0];
+	result[1] = m0[1];
+	result[2] = m0[2];
+	result[3] = m0[3];
+	result[4] = m0[4];
+	result[5] = m0[5] * v0[1];
+	result[6] = m0[6];
+	result[7] = m0[7];
+	result[8] = m0[8];
+	result[9] = m0[9];
+	result[10] = m0[10] * v0[2];
+	result[11] = m0[11];
+	result[12] = m0[12];
+	result[13] = m0[13];
+	result[14] = m0[14];
+	result[15] = m0[15];
+	return result;
+}
+
+mfloat_t *mat4_multiply(mfloat_t *result, mfloat_t *m0, mfloat_t *m1)
 {
 	mfloat_t multiplied[MAT4_SIZE];
-	multiplied[0] = mat40[0] * mat41[0] + mat40[4] * mat41[1] + mat40[8] * mat41[2] + mat40[12] * mat41[3];
-	multiplied[1] = mat40[1] * mat41[0] + mat40[5] * mat41[1] + mat40[9] * mat41[2] + mat40[13] * mat41[3];
-	multiplied[2] = mat40[2] * mat41[0] + mat40[6] * mat41[1] + mat40[10] * mat41[2] + mat40[14] * mat41[3];
-	multiplied[3] = mat40[3] * mat41[0] + mat40[7] * mat41[1] + mat40[11] * mat41[2] + mat40[15] * mat41[3];
-	multiplied[4] = mat40[0] * mat41[4] + mat40[4] * mat41[5] + mat40[8] * mat41[6] + mat40[12] * mat41[7];
-	multiplied[5] = mat40[1] * mat41[4] + mat40[5] * mat41[5] + mat40[9] * mat41[6] + mat40[13] * mat41[7];
-	multiplied[6] = mat40[2] * mat41[4] + mat40[6] * mat41[5] + mat40[10] * mat41[6] + mat40[14] * mat41[7];
-	multiplied[7] = mat40[3] * mat41[4] + mat40[7] * mat41[5] + mat40[11] * mat41[6] + mat40[15] * mat41[7];
-	multiplied[8] = mat40[0] * mat41[8] + mat40[4] * mat41[9] + mat40[8] * mat41[10] + mat40[12] * mat41[11];
-	multiplied[9] = mat40[1] * mat41[8] + mat40[5] * mat41[9] + mat40[9] * mat41[10] + mat40[13] * mat41[11];
-	multiplied[10] = mat40[2] * mat41[8] + mat40[6] * mat41[9] + mat40[10] * mat41[10] + mat40[14] * mat41[11];
-	multiplied[11] = mat40[3] * mat41[8] + mat40[7] * mat41[9] + mat40[11] * mat41[10] + mat40[15] * mat41[11];
-	multiplied[12] = mat40[0] * mat41[12] + mat40[4] * mat41[13] + mat40[8] * mat41[14] + mat40[12] * mat41[15];
-	multiplied[13] = mat40[1] * mat41[12] + mat40[5] * mat41[13] + mat40[9] * mat41[14] + mat40[13] * mat41[15];
-	multiplied[14] = mat40[2] * mat41[12] + mat40[6] * mat41[13] + mat40[10] * mat41[14] + mat40[14] * mat41[15];
-	multiplied[15] = mat40[3] * mat41[12] + mat40[7] * mat41[13] + mat40[11] * mat41[14] + mat40[15] * mat41[15];
+	multiplied[0] = m0[0] * m1[0] + m0[4] * m1[1] + m0[8] * m1[2] + m0[12] * m1[3];
+	multiplied[1] = m0[1] * m1[0] + m0[5] * m1[1] + m0[9] * m1[2] + m0[13] * m1[3];
+	multiplied[2] = m0[2] * m1[0] + m0[6] * m1[1] + m0[10] * m1[2] + m0[14] * m1[3];
+	multiplied[3] = m0[3] * m1[0] + m0[7] * m1[1] + m0[11] * m1[2] + m0[15] * m1[3];
+	multiplied[4] = m0[0] * m1[4] + m0[4] * m1[5] + m0[8] * m1[6] + m0[12] * m1[7];
+	multiplied[5] = m0[1] * m1[4] + m0[5] * m1[5] + m0[9] * m1[6] + m0[13] * m1[7];
+	multiplied[6] = m0[2] * m1[4] + m0[6] * m1[5] + m0[10] * m1[6] + m0[14] * m1[7];
+	multiplied[7] = m0[3] * m1[4] + m0[7] * m1[5] + m0[11] * m1[6] + m0[15] * m1[7];
+	multiplied[8] = m0[0] * m1[8] + m0[4] * m1[9] + m0[8] * m1[10] + m0[12] * m1[11];
+	multiplied[9] = m0[1] * m1[8] + m0[5] * m1[9] + m0[9] * m1[10] + m0[13] * m1[11];
+	multiplied[10] = m0[2] * m1[8] + m0[6] * m1[9] + m0[10] * m1[10] + m0[14] * m1[11];
+	multiplied[11] = m0[3] * m1[8] + m0[7] * m1[9] + m0[11] * m1[10] + m0[15] * m1[11];
+	multiplied[12] = m0[0] * m1[12] + m0[4] * m1[13] + m0[8] * m1[14] + m0[12] * m1[15];
+	multiplied[13] = m0[1] * m1[12] + m0[5] * m1[13] + m0[9] * m1[14] + m0[13] * m1[15];
+	multiplied[14] = m0[2] * m1[12] + m0[6] * m1[13] + m0[10] * m1[14] + m0[14] * m1[15];
+	multiplied[15] = m0[3] * m1[12] + m0[7] * m1[13] + m0[11] * m1[14] + m0[15] * m1[15];
 	result[0] = multiplied[0];
 	result[1] = multiplied[1];
 	result[2] = multiplied[2];
@@ -3034,47 +3034,47 @@ mfloat_t *mat4_multiply(mfloat_t *result, mfloat_t *mat40, mfloat_t *mat41)
 	return result;
 }
 
-mfloat_t *mat4_multiply_f(mfloat_t *result, mfloat_t *mat40, mfloat_t f)
+mfloat_t *mat4_multiply_f(mfloat_t *result, mfloat_t *m0, mfloat_t f)
 {
-	result[0] = mat40[0] * f;
-	result[1] = mat40[1] * f;
-	result[2] = mat40[2] * f;
-	result[3] = mat40[3] * f;
-	result[4] = mat40[4] * f;
-	result[5] = mat40[5] * f;
-	result[6] = mat40[6] * f;
-	result[7] = mat40[7] * f;
-	result[8] = mat40[8] * f;
-	result[9] = mat40[9] * f;
-	result[10] = mat40[10] * f;
-	result[11] = mat40[11] * f;
-	result[12] = mat40[12] * f;
-	result[13] = mat40[13] * f;
-	result[14] = mat40[14] * f;
-	result[15] = mat40[15] * f;
+	result[0] = m0[0] * f;
+	result[1] = m0[1] * f;
+	result[2] = m0[2] * f;
+	result[3] = m0[3] * f;
+	result[4] = m0[4] * f;
+	result[5] = m0[5] * f;
+	result[6] = m0[6] * f;
+	result[7] = m0[7] * f;
+	result[8] = m0[8] * f;
+	result[9] = m0[9] * f;
+	result[10] = m0[10] * f;
+	result[11] = m0[11] * f;
+	result[12] = m0[12] * f;
+	result[13] = m0[13] * f;
+	result[14] = m0[14] * f;
+	result[15] = m0[15] * f;
 	return result;
 }
 
-mfloat_t *mat4_inverse(mfloat_t *result, mfloat_t *mat40)
+mfloat_t *mat4_inverse(mfloat_t *result, mfloat_t *m0)
 {
 	mfloat_t inverse[MAT4_SIZE];
 	mfloat_t inverted_determinant;
-	mfloat_t m11 = mat40[0];
-	mfloat_t m21 = mat40[1];
-	mfloat_t m31 = mat40[2];
-	mfloat_t m41 = mat40[3];
-	mfloat_t m12 = mat40[4];
-	mfloat_t m22 = mat40[5];
-	mfloat_t m32 = mat40[6];
-	mfloat_t m42 = mat40[7];
-	mfloat_t m13 = mat40[8];
-	mfloat_t m23 = mat40[9];
-	mfloat_t m33 = mat40[10];
-	mfloat_t m43 = mat40[11];
-	mfloat_t m14 = mat40[12];
-	mfloat_t m24 = mat40[13];
-	mfloat_t m34 = mat40[14];
-	mfloat_t m44 = mat40[15];
+	mfloat_t m11 = m0[0];
+	mfloat_t m21 = m0[1];
+	mfloat_t m31 = m0[2];
+	mfloat_t m41 = m0[3];
+	mfloat_t m12 = m0[4];
+	mfloat_t m22 = m0[5];
+	mfloat_t m32 = m0[6];
+	mfloat_t m42 = m0[7];
+	mfloat_t m13 = m0[8];
+	mfloat_t m23 = m0[9];
+	mfloat_t m33 = m0[10];
+	mfloat_t m43 = m0[11];
+	mfloat_t m14 = m0[12];
+	mfloat_t m24 = m0[13];
+	mfloat_t m34 = m0[14];
+	mfloat_t m44 = m0[15];
 	inverse[0] = m22 * m33 * m44
 		- m22 * m43 * m34
 		- m23 * m32 * m44
@@ -3191,49 +3191,53 @@ mfloat_t *mat4_inverse(mfloat_t *result, mfloat_t *mat40)
 	return result;
 }
 
-mfloat_t *mat4_lerp(mfloat_t *result, mfloat_t *mat40, mfloat_t *mat41, mfloat_t f)
+mfloat_t *mat4_lerp(mfloat_t *result, mfloat_t *m0, mfloat_t *m1, mfloat_t f)
 {
-	result[0] = mat40[0] + (mat41[0] - mat40[0]) * f;
-	result[1] = mat40[1] + (mat41[1] - mat40[1]) * f;
-	result[2] = mat40[2] + (mat41[2] - mat40[2]) * f;
-	result[3] = mat40[3] + (mat41[3] - mat40[3]) * f;
-	result[4] = mat40[4] + (mat41[4] - mat40[4]) * f;
-	result[5] = mat40[5] + (mat41[5] - mat40[5]) * f;
-	result[6] = mat40[6] + (mat41[6] - mat40[6]) * f;
-	result[7] = mat40[7] + (mat41[7] - mat40[7]) * f;
-	result[8] = mat40[8] + (mat41[8] - mat40[8]) * f;
-	result[9] = mat40[9] + (mat41[9] - mat40[9]) * f;
-	result[10] = mat40[10] + (mat41[10] - mat40[10]) * f;
-	result[11] = mat40[11] + (mat41[11] - mat40[11]) * f;
-	result[12] = mat40[12] + (mat41[12] - mat40[12]) * f;
-	result[13] = mat40[13] + (mat41[13] - mat40[13]) * f;
-	result[14] = mat40[14] + (mat41[14] - mat40[14]) * f;
-	result[15] = mat40[15] + (mat41[15] - mat40[15]) * f;
+	result[0] = m0[0] + (m1[0] - m0[0]) * f;
+	result[1] = m0[1] + (m1[1] - m0[1]) * f;
+	result[2] = m0[2] + (m1[2] - m0[2]) * f;
+	result[3] = m0[3] + (m1[3] - m0[3]) * f;
+	result[4] = m0[4] + (m1[4] - m0[4]) * f;
+	result[5] = m0[5] + (m1[5] - m0[5]) * f;
+	result[6] = m0[6] + (m1[6] - m0[6]) * f;
+	result[7] = m0[7] + (m1[7] - m0[7]) * f;
+	result[8] = m0[8] + (m1[8] - m0[8]) * f;
+	result[9] = m0[9] + (m1[9] - m0[9]) * f;
+	result[10] = m0[10] + (m1[10] - m0[10]) * f;
+	result[11] = m0[11] + (m1[11] - m0[11]) * f;
+	result[12] = m0[12] + (m1[12] - m0[12]) * f;
+	result[13] = m0[13] + (m1[13] - m0[13]) * f;
+	result[14] = m0[14] + (m1[14] - m0[14]) * f;
+	result[15] = m0[15] + (m1[15] - m0[15]) * f;
 	return result;
 }
 
-mfloat_t *mat4_look_at(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32)
+mfloat_t *mat4_look_at(mfloat_t *result, mfloat_t *position, mfloat_t *target, mfloat_t *up)
 {
 	mfloat_t forward[VEC3_SIZE];
 	mfloat_t side[VEC3_SIZE];
-	mfloat_t up[VEC3_SIZE];
-	vec3_subtract(forward, vec31, vec30);
+	mfloat_t tmp_up[VEC3_SIZE];
+	vec3_subtract(forward, target, position);
 	vec3_normalize(forward, forward);
-	vec3_cross(side, forward, vec32);
+	vec3_cross(side, forward, up);
 	vec3_normalize(side, side);
-	vec3_cross(up, side, forward);
+	vec3_cross(tmp_up, side, forward);
 	result[0] = side[0];
 	result[1] = side[1];
 	result[2] = side[2];
-	result[3] = vec3_dot(side, vec30);
-	result[4] = up[0];
-	result[5] = up[1];
-	result[6] = up[2];
-	result[7] = vec3_dot(up, vec30);
+	result[3] = -vec3_dot(side, position);
+	result[4] = tmp_up[0];
+	result[5] = tmp_up[1];
+	result[6] = tmp_up[2];
+	result[7] = -vec3_dot(tmp_up, position);
 	result[8] = forward[0];
 	result[9] = forward[1];
 	result[10] = forward[2];
-	result[11] = vec3_dot(forward, vec30);
+	result[11] = -vec3_dot(forward, position);
+	result[12] = MFLOAT_C(0.0);
+	result[13] = MFLOAT_C(0.0);
+	result[14] = MFLOAT_C(0.0);
+	result[15] = MFLOAT_C(1.0);
 	return result;
 }
 
@@ -3332,14 +3336,14 @@ mfloat_t *mat4_perspective_infinite(mfloat_t *result, mfloat_t fov_y, mfloat_t a
 
 #if defined(MATHC_USE_STRUCT_FUNCTIONS)
 #if defined(MATHC_USE_INT)
-bool svec2i_is_zero(struct vec2i vec2i0)
+bool svec2i_is_zero(struct vec2i v0)
 {
-	return vec2i_is_zero((mint_t *)&vec2i0);
+	return vec2i_is_zero((mint_t *)&v0);
 }
 
-bool svec2i_is_equal(struct vec2i vec2i0, struct vec2i vec2i1)
+bool svec2i_is_equal(struct vec2i v0, struct vec2i v1)
 {
-	return vec2i_is_equal((mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	return vec2i_is_equal((mint_t *)&v0, (mint_t *)&v1);
 }
 
 struct vec2i svec2i(mint_t x, mint_t y)
@@ -3349,18 +3353,18 @@ struct vec2i svec2i(mint_t x, mint_t y)
 	return result;
 }
 
-struct vec2i svec2i_assign(struct vec2i vec2i0)
+struct vec2i svec2i_assign(struct vec2i v0)
 {
 	struct vec2i result;
-	vec2i_assign((mint_t *)&result, (mint_t *)&vec2i0);
+	vec2i_assign((mint_t *)&result, (mint_t *)&v0);
 	return result;
 }
 
 #if defined(MATHC_USE_FLOATING_POINT)
-struct vec2i svec2i_assign_vec2(struct vec2 vec20)
+struct vec2i svec2i_assign_vec2(struct vec2 v0)
 {
 	struct vec2i result;
-	vec2i_assign_vec2((mint_t *)&result, (mfloat_t *)&vec20);
+	vec2i_assign_vec2((mint_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 #endif
@@ -3379,133 +3383,133 @@ struct vec2i svec2i_one(void)
 	return result;
 }
 
-struct vec2i svec2i_sign(struct vec2i vec2i0)
+struct vec2i svec2i_sign(struct vec2i v0)
 {
 	struct vec2i result;
-	vec2i_sign((mint_t *)&result, (mint_t *)&vec2i0);
+	vec2i_sign((mint_t *)&result, (mint_t *)&v0);
 	return result;
 }
 
-struct vec2i svec2i_add(struct vec2i vec2i0, struct vec2i vec2i1)
+struct vec2i svec2i_add(struct vec2i v0, struct vec2i v1)
 {
 	struct vec2i result;
-	vec2i_add((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	vec2i_add((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec2i svec2i_add_i(struct vec2i vec2i0, mint_t i)
+struct vec2i svec2i_add_i(struct vec2i v0, mint_t i)
 {
 	struct vec2i result;
-	vec2i_add_i((mint_t *)&result, (mint_t *)&vec2i0, i);
+	vec2i_add_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec2i svec2i_subtract(struct vec2i vec2i0, struct vec2i vec2i1)
+struct vec2i svec2i_subtract(struct vec2i v0, struct vec2i v1)
 {
 	struct vec2i result;
-	vec2i_subtract((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	vec2i_subtract((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec2i svec2i_subtract_i(struct vec2i vec2i0, mint_t i)
+struct vec2i svec2i_subtract_i(struct vec2i v0, mint_t i)
 {
 	struct vec2i result;
-	vec2i_subtract_i((mint_t *)&result, (mint_t *)&vec2i0, i);
+	vec2i_subtract_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec2i svec2i_multiply(struct vec2i vec2i0, struct vec2i vec2i1)
+struct vec2i svec2i_multiply(struct vec2i v0, struct vec2i v1)
 {
 	struct vec2i result;
-	vec2i_multiply((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	vec2i_multiply((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec2i svec2i_multiply_i(struct vec2i vec2i0, mint_t i)
+struct vec2i svec2i_multiply_i(struct vec2i v0, mint_t i)
 {
 	struct vec2i result;
-	vec2i_multiply_i((mint_t *)&result, (mint_t *)&vec2i0, i);
+	vec2i_multiply_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec2i svec2i_divide(struct vec2i vec2i0, struct vec2i vec2i1)
+struct vec2i svec2i_divide(struct vec2i v0, struct vec2i v1)
 {
 	struct vec2i result;
-	vec2i_divide((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	vec2i_divide((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec2i svec2i_divide_i(struct vec2i vec2i0, mint_t i)
+struct vec2i svec2i_divide_i(struct vec2i v0, mint_t i)
 {
 	struct vec2i result;
-	vec2i_divide_i((mint_t *)&result, (mint_t *)&vec2i0, i);
+	vec2i_divide_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec2i svec2i_snap(struct vec2i vec2i0, struct vec2i vec2i1)
+struct vec2i svec2i_snap(struct vec2i v0, struct vec2i v1)
 {
 	struct vec2i result;
-	vec2i_snap((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	vec2i_snap((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec2i svec2i_snap_i(struct vec2i vec2i0, mint_t i)
+struct vec2i svec2i_snap_i(struct vec2i v0, mint_t i)
 {
 	struct vec2i result;
-	vec2i_snap_i((mint_t *)&result, (mint_t *)&vec2i0, i);
+	vec2i_snap_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec2i svec2i_negative(struct vec2i vec2i0)
+struct vec2i svec2i_negative(struct vec2i v0)
 {
 	struct vec2i result;
-	vec2i_negative((mint_t *)&result, (mint_t *)&vec2i0);
+	vec2i_negative((mint_t *)&result, (mint_t *)&v0);
 	return result;
 }
 
-struct vec2i svec2i_abs(struct vec2i vec2i0)
+struct vec2i svec2i_abs(struct vec2i v0)
 {
 	struct vec2i result;
-	vec2i_abs((mint_t *)&result, (mint_t *)&vec2i0);
+	vec2i_abs((mint_t *)&result, (mint_t *)&v0);
 	return result;
 }
 
-struct vec2i svec2i_max(struct vec2i vec2i0, struct vec2i vec2i1)
+struct vec2i svec2i_max(struct vec2i v0, struct vec2i v1)
 {
 	struct vec2i result;
-	vec2i_max((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	vec2i_max((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec2i svec2i_min(struct vec2i vec2i0, struct vec2i vec2i1)
+struct vec2i svec2i_min(struct vec2i v0, struct vec2i v1)
 {
 	struct vec2i result;
-	vec2i_min((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1);
+	vec2i_min((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec2i svec2i_clamp(struct vec2i vec2i0, struct vec2i vec2i1, struct vec2i vec2i2)
+struct vec2i svec2i_clamp(struct vec2i v0, struct vec2i v1, struct vec2i v2)
 {
 	struct vec2i result;
-	vec2i_clamp((mint_t *)&result, (mint_t *)&vec2i0, (mint_t *)&vec2i1, (mint_t *)&vec2i2);
+	vec2i_clamp((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1, (mint_t *)&v2);
 	return result;
 }
 
-struct vec2i svec2i_tangent(struct vec2i vec2i0)
+struct vec2i svec2i_tangent(struct vec2i v0)
 {
 	struct vec2i result;
-	vec2i_tangent((mint_t *)&result, (mint_t *)&vec2i0);
+	vec2i_tangent((mint_t *)&result, (mint_t *)&v0);
 	return result;
 }
 
-bool svec3i_is_zero(struct vec3i vec3i0)
+bool svec3i_is_zero(struct vec3i v0)
 {
-	return vec3i_is_zero((mint_t *)&vec3i0);
+	return vec3i_is_zero((mint_t *)&v0);
 }
 
-bool svec3i_is_equal(struct vec3i vec3i0, struct vec3i vec3i1)
+bool svec3i_is_equal(struct vec3i v0, struct vec3i v1)
 {
-	return vec3i_is_equal((mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	return vec3i_is_equal((mint_t *)&v0, (mint_t *)&v1);
 }
 
 struct vec3i svec3i(mint_t x, mint_t y, mint_t z)
@@ -3515,18 +3519,18 @@ struct vec3i svec3i(mint_t x, mint_t y, mint_t z)
 	return result;
 }
 
-struct vec3i svec3i_assign(struct vec3i vec3i0)
+struct vec3i svec3i_assign(struct vec3i v0)
 {
 	struct vec3i result;
-	vec3i_assign((mint_t *)&result, (mint_t *)&vec3i0);
+	vec3i_assign((mint_t *)&result, (mint_t *)&v0);
 	return result;
 }
 
 #if defined(MATHC_USE_FLOATING_POINT)
-struct vec3i svec3i_assign_vec3(struct vec3 vec30)
+struct vec3i svec3i_assign_vec3(struct vec3 v0)
 {
 	struct vec3i result;
-	vec3i_assign_vec3((mint_t *)&result, (mfloat_t *)&vec30);
+	vec3i_assign_vec3((mint_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 #endif
@@ -3545,133 +3549,133 @@ struct vec3i svec3i_one(void)
 	return result;
 }
 
-struct vec3i svec3i_sign(struct vec3i vec3i0)
+struct vec3i svec3i_sign(struct vec3i v0)
 {
 	struct vec3i result;
-	vec3i_sign((mint_t *)&result, (mint_t *)&vec3i0);
+	vec3i_sign((mint_t *)&result, (mint_t *)&v0);
 	return result;
 }
 
-struct vec3i svec3i_add(struct vec3i vec3i0, struct vec3i vec3i1)
+struct vec3i svec3i_add(struct vec3i v0, struct vec3i v1)
 {
 	struct vec3i result;
-	vec3i_add((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	vec3i_add((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec3i svec3i_add_i(struct vec3i vec3i0, mint_t i)
+struct vec3i svec3i_add_i(struct vec3i v0, mint_t i)
 {
 	struct vec3i result;
-	vec3i_add_i((mint_t *)&result, (mint_t *)&vec3i0, i);
+	vec3i_add_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec3i svec3i_subtract(struct vec3i vec3i0, struct vec3i vec3i1)
+struct vec3i svec3i_subtract(struct vec3i v0, struct vec3i v1)
 {
 	struct vec3i result;
-	vec3i_subtract((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	vec3i_subtract((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec3i svec3i_subtract_i(struct vec3i vec3i0, mint_t i)
+struct vec3i svec3i_subtract_i(struct vec3i v0, mint_t i)
 {
 	struct vec3i result;
-	vec3i_subtract_i((mint_t *)&result, (mint_t *)&vec3i0, i);
+	vec3i_subtract_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec3i svec3i_multiply(struct vec3i vec3i0, struct vec3i vec3i1)
+struct vec3i svec3i_multiply(struct vec3i v0, struct vec3i v1)
 {
 	struct vec3i result;
-	vec3i_multiply((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	vec3i_multiply((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec3i svec3i_multiply_i(struct vec3i vec3i0, mint_t i)
+struct vec3i svec3i_multiply_i(struct vec3i v0, mint_t i)
 {
 	struct vec3i result;
-	vec3i_multiply_i((mint_t *)&result, (mint_t *)&vec3i0, i);
+	vec3i_multiply_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec3i svec3i_divide(struct vec3i vec3i0, struct vec3i vec3i1)
+struct vec3i svec3i_divide(struct vec3i v0, struct vec3i v1)
 {
 	struct vec3i result;
-	vec3i_divide((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	vec3i_divide((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec3i svec3i_divide_i(struct vec3i vec3i0, mint_t i)
+struct vec3i svec3i_divide_i(struct vec3i v0, mint_t i)
 {
 	struct vec3i result;
-	vec3i_divide_i((mint_t *)&result, (mint_t *)&vec3i0, i);
+	vec3i_divide_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec3i svec3i_snap(struct vec3i vec3i0, struct vec3i vec3i1)
+struct vec3i svec3i_snap(struct vec3i v0, struct vec3i v1)
 {
 	struct vec3i result;
-	vec3i_snap((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	vec3i_snap((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec3i svec3i_snap_i(struct vec3i vec3i0, mint_t i)
+struct vec3i svec3i_snap_i(struct vec3i v0, mint_t i)
 {
 	struct vec3i result;
-	vec3i_snap_i((mint_t *)&result, (mint_t *)&vec3i0, i);
+	vec3i_snap_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec3i svec3i_cross(struct vec3i vec3i0, struct vec3i vec3i1)
+struct vec3i svec3i_cross(struct vec3i v0, struct vec3i v1)
 {
 	struct vec3i result;
-	vec3i_cross((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	vec3i_cross((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec3i svec3i_negative(struct vec3i vec3i0)
+struct vec3i svec3i_negative(struct vec3i v0)
 {
 	struct vec3i result;
-	vec3i_negative((mint_t *)&result, (mint_t *)&vec3i0);
+	vec3i_negative((mint_t *)&result, (mint_t *)&v0);
 	return result;
 }
 
-struct vec3i svec3i_abs(struct vec3i vec3i0)
+struct vec3i svec3i_abs(struct vec3i v0)
 {
 	struct vec3i result;
-	vec3i_abs((mint_t *)&result, (mint_t *)&vec3i0);
+	vec3i_abs((mint_t *)&result, (mint_t *)&v0);
 	return result;
 }
 
-struct vec3i svec3i_max(struct vec3i vec3i0, struct vec3i vec3i1)
+struct vec3i svec3i_max(struct vec3i v0, struct vec3i v1)
 {
 	struct vec3i result;
-	vec3i_max((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	vec3i_max((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec3i svec3i_min(struct vec3i vec3i0, struct vec3i vec3i1)
+struct vec3i svec3i_min(struct vec3i v0, struct vec3i v1)
 {
 	struct vec3i result;
-	vec3i_min((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1);
+	vec3i_min((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec3i svec3i_clamp(struct vec3i vec3i0, struct vec3i vec3i1, struct vec3i vec3i2)
+struct vec3i svec3i_clamp(struct vec3i v0, struct vec3i v1, struct vec3i v2)
 {
 	struct vec3i result;
-	vec3i_clamp((mint_t *)&result, (mint_t *)&vec3i0, (mint_t *)&vec3i1, (mint_t *)&vec3i2);
+	vec3i_clamp((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1, (mint_t *)&v2);
 	return result;
 }
 
-bool svec4i_is_zero(struct vec4i vec4i0)
+bool svec4i_is_zero(struct vec4i v0)
 {
-	return vec4i_is_zero((mint_t *)&vec4i0);
+	return vec4i_is_zero((mint_t *)&v0);
 }
 
-bool svec4i_is_equal(struct vec4i vec4i0, struct vec4i vec4i1)
+bool svec4i_is_equal(struct vec4i v0, struct vec4i v1)
 {
-	return vec4i_is_equal((mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	return vec4i_is_equal((mint_t *)&v0, (mint_t *)&v1);
 }
 
 struct vec4i svec4i(mint_t x, mint_t y, mint_t z, mint_t w)
@@ -3681,18 +3685,18 @@ struct vec4i svec4i(mint_t x, mint_t y, mint_t z, mint_t w)
 	return result;
 }
 
-struct vec4i svec4i_assign(struct vec4i vec4i0)
+struct vec4i svec4i_assign(struct vec4i v0)
 {
 	struct vec4i result;
-	vec4i_assign((mint_t *)&result, (mint_t *)&vec4i0);
+	vec4i_assign((mint_t *)&result, (mint_t *)&v0);
 	return result;
 }
 
 #if defined(MATHC_USE_FLOATING_POINT)
-struct vec4i svec4i_assign_vec4(struct vec4 vec40)
+struct vec4i svec4i_assign_vec4(struct vec4 v0)
 {
 	struct vec4i result;
-	vec4i_assign_vec4((mint_t *)&result, (mfloat_t *)&vec40);
+	vec4i_assign_vec4((mint_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 #endif
@@ -3711,128 +3715,128 @@ struct vec4i svec4i_one(void)
 	return result;
 }
 
-struct vec4i svec4i_sign(struct vec4i vec4i0)
+struct vec4i svec4i_sign(struct vec4i v0)
 {
 	struct vec4i result;
-	vec4i_sign((mint_t *)&result, (mint_t *)&vec4i0);
+	vec4i_sign((mint_t *)&result, (mint_t *)&v0);
 	return result;
 }
 
-struct vec4i svec4i_add(struct vec4i vec4i0, struct vec4i vec4i1)
+struct vec4i svec4i_add(struct vec4i v0, struct vec4i v1)
 {
 	struct vec4i result;
-	vec4i_add((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	vec4i_add((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec4i svec4i_add_i(struct vec4i vec4i0, mint_t i)
+struct vec4i svec4i_add_i(struct vec4i v0, mint_t i)
 {
 	struct vec4i result;
-	vec4i_add_i((mint_t *)&result, (mint_t *)&vec4i0, i);
+	vec4i_add_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec4i svec4i_subtract(struct vec4i vec4i0, struct vec4i vec4i1)
+struct vec4i svec4i_subtract(struct vec4i v0, struct vec4i v1)
 {
 	struct vec4i result;
-	vec4i_subtract((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	vec4i_subtract((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec4i svec4i_subtract_i(struct vec4i vec4i0, mint_t i)
+struct vec4i svec4i_subtract_i(struct vec4i v0, mint_t i)
 {
 	struct vec4i result;
-	vec4i_subtract_i((mint_t *)&result, (mint_t *)&vec4i0, i);
+	vec4i_subtract_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec4i svec4i_multiply(struct vec4i vec4i0, struct vec4i vec4i1)
+struct vec4i svec4i_multiply(struct vec4i v0, struct vec4i v1)
 {
 	struct vec4i result;
-	vec4i_multiply((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	vec4i_multiply((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec4i svec4i_multiply_i(struct vec4i vec4i0, mint_t i)
+struct vec4i svec4i_multiply_i(struct vec4i v0, mint_t i)
 {
 	struct vec4i result;
-	vec4i_multiply_i((mint_t *)&result, (mint_t *)&vec4i0, i);
+	vec4i_multiply_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec4i svec4i_divide(struct vec4i vec4i0, struct vec4i vec4i1)
+struct vec4i svec4i_divide(struct vec4i v0, struct vec4i v1)
 {
 	struct vec4i result;
-	vec4i_divide((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	vec4i_divide((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec4i svec4i_divide_i(struct vec4i vec4i0, mint_t i)
+struct vec4i svec4i_divide_i(struct vec4i v0, mint_t i)
 {
 	struct vec4i result;
-	vec4i_divide_i((mint_t *)&result, (mint_t *)&vec4i0, i);
+	vec4i_divide_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec4i svec4i_snap(struct vec4i vec4i0, struct vec4i vec4i1)
+struct vec4i svec4i_snap(struct vec4i v0, struct vec4i v1)
 {
 	struct vec4i result;
-	vec4i_snap((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	vec4i_snap((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec4i svec4i_snap_i(struct vec4i vec4i0, mint_t i)
+struct vec4i svec4i_snap_i(struct vec4i v0, mint_t i)
 {
 	struct vec4i result;
-	vec4i_snap_i((mint_t *)&result, (mint_t *)&vec4i0, i);
+	vec4i_snap_i((mint_t *)&result, (mint_t *)&v0, i);
 	return result;
 }
 
-struct vec4i svec4i_negative(struct vec4i vec4i0)
+struct vec4i svec4i_negative(struct vec4i v0)
 {
 	struct vec4i result;
-	vec4i_negative((mint_t *)&result, (mint_t *)&vec4i0);
+	vec4i_negative((mint_t *)&result, (mint_t *)&v0);
 	return result;
 }
 
-struct vec4i svec4i_abs(struct vec4i vec4i0)
+struct vec4i svec4i_abs(struct vec4i v0)
 {
 	struct vec4i result;
-	vec4i_abs((mint_t *)&result, (mint_t *)&vec4i0);
+	vec4i_abs((mint_t *)&result, (mint_t *)&v0);
 	return result;
 }
 
-struct vec4i svec4i_max(struct vec4i vec4i0, struct vec4i vec4i1)
+struct vec4i svec4i_max(struct vec4i v0, struct vec4i v1)
 {
 	struct vec4i result;
-	vec4i_max((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	vec4i_max((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec4i svec4i_min(struct vec4i vec4i0, struct vec4i vec4i1)
+struct vec4i svec4i_min(struct vec4i v0, struct vec4i v1)
 {
 	struct vec4i result;
-	vec4i_min((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1);
+	vec4i_min((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1);
 	return result;
 }
 
-struct vec4i svec4i_clamp(struct vec4i vec4i0, struct vec4i vec4i1, struct vec4i vec4i2)
+struct vec4i svec4i_clamp(struct vec4i v0, struct vec4i v1, struct vec4i v2)
 {
 	struct vec4i result;
-	vec4i_clamp((mint_t *)&result, (mint_t *)&vec4i0, (mint_t *)&vec4i1, (mint_t *)&vec4i2);
+	vec4i_clamp((mint_t *)&result, (mint_t *)&v0, (mint_t *)&v1, (mint_t *)&v2);
 	return result;
 }
 #endif
 
 #if defined(MATHC_USE_FLOATING_POINT)
-bool svec2_is_zero(struct vec2 vec20)
+bool svec2_is_zero(struct vec2 v0)
 {
-	return vec2_is_zero((mfloat_t *)&vec20);
+	return vec2_is_zero((mfloat_t *)&v0);
 }
 
-bool svec2_is_equal(struct vec2 vec20, struct vec2 vec21)
+bool svec2_is_equal(struct vec2 v0, struct vec2 v1)
 {
-	return vec2_is_equal((mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	return vec2_is_equal((mfloat_t *)&v0, (mfloat_t *)&v1);
 }
 
 struct vec2 svec2(mfloat_t x, mfloat_t y)
@@ -3842,18 +3846,18 @@ struct vec2 svec2(mfloat_t x, mfloat_t y)
 	return result;
 }
 
-struct vec2 svec2_assign(struct vec2 vec20)
+struct vec2 svec2_assign(struct vec2 v0)
 {
 	struct vec2 result;
-	vec2_assign((mfloat_t *)&result, (mfloat_t *)&vec20);
+	vec2_assign((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
 #if defined(MATHC_USE_INT)
-struct vec2 svec2_assign_vec2i(struct vec2i vec2i0)
+struct vec2 svec2_assign_vec2i(struct vec2i v0)
 {
 	struct vec2 result;
-	vec2_assign_vec2i((mfloat_t *)&result, (mint_t *)&vec2i0);
+	vec2_assign_vec2i((mfloat_t *)&result, (mint_t *)&v0);
 	return result;
 }
 #endif
@@ -3872,247 +3876,247 @@ struct vec2 svec2_one(void)
 	return result;
 }
 
-struct vec2 svec2_sign(struct vec2 vec20)
+struct vec2 svec2_sign(struct vec2 v0)
 {
 	struct vec2 result;
-	vec2_sign((mfloat_t *)&result, (mfloat_t *)&vec20);
+	vec2_sign((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec2 svec2_add(struct vec2 vec20, struct vec2 vec21)
+struct vec2 svec2_add(struct vec2 v0, struct vec2 v1)
 {
 	struct vec2 result;
-	vec2_add((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	vec2_add((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec2 svec2_add_f(struct vec2 vec20, mfloat_t f)
+struct vec2 svec2_add_f(struct vec2 v0, mfloat_t f)
 {
 	struct vec2 result;
-	vec2_add_f((mfloat_t *)&result, (mfloat_t *)&vec20, f);
+	vec2_add_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec2 svec2_subtract(struct vec2 vec20, struct vec2 vec21)
+struct vec2 svec2_subtract(struct vec2 v0, struct vec2 v1)
 {
 	struct vec2 result;
-	vec2_subtract((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	vec2_subtract((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec2 svec2_subtract_f(struct vec2 vec20, mfloat_t f)
+struct vec2 svec2_subtract_f(struct vec2 v0, mfloat_t f)
 {
 	struct vec2 result;
-	vec2_subtract_f((mfloat_t *)&result, (mfloat_t *)&vec20, f);
+	vec2_subtract_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec2 svec2_multiply(struct vec2 vec20, struct vec2 vec21)
+struct vec2 svec2_multiply(struct vec2 v0, struct vec2 v1)
 {
 	struct vec2 result;
-	vec2_multiply((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	vec2_multiply((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec2 svec2_multiply_f(struct vec2 vec20, mfloat_t f)
+struct vec2 svec2_multiply_f(struct vec2 v0, mfloat_t f)
 {
 	struct vec2 result;
-	vec2_multiply_f((mfloat_t *)&result, (mfloat_t *)&vec20, f);
+	vec2_multiply_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec2 svec2_multiply_mat2(struct vec2 vec20, struct mat2 mat20)
+struct vec2 svec2_multiply_mat2(struct vec2 v0, struct mat2 m0)
 {
 	struct vec2 result;
-	vec2_multiply_mat2((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&mat20);
+	vec2_multiply_mat2((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&m0);
 	return result;
 }
 
-struct vec2 svec2_divide(struct vec2 vec20, struct vec2 vec21)
+struct vec2 svec2_divide(struct vec2 v0, struct vec2 v1)
 {
 	struct vec2 result;
-	vec2_divide((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	vec2_divide((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec2 svec2_divide_f(struct vec2 vec20, mfloat_t f)
+struct vec2 svec2_divide_f(struct vec2 v0, mfloat_t f)
 {
 	struct vec2 result;
-	vec2_divide_f((mfloat_t *)&result, (mfloat_t *)&vec20, f);
+	vec2_divide_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec2 svec2_snap(struct vec2 vec20, struct vec2 vec21)
+struct vec2 svec2_snap(struct vec2 v0, struct vec2 v1)
 {
 	struct vec2 result;
-	vec2_snap((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	vec2_snap((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec2 svec2_snap_f(struct vec2 vec20, mfloat_t f)
+struct vec2 svec2_snap_f(struct vec2 v0, mfloat_t f)
 {
 	struct vec2 result;
-	vec2_snap_f((mfloat_t *)&result, (mfloat_t *)&vec20, f);
+	vec2_snap_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec2 svec2_negative(struct vec2 vec20)
+struct vec2 svec2_negative(struct vec2 v0)
 {
 	struct vec2 result;
-	vec2_negative((mfloat_t *)&result, (mfloat_t *)&vec20);
+	vec2_negative((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec2 svec2_abs(struct vec2 vec20)
+struct vec2 svec2_abs(struct vec2 v0)
 {
 	struct vec2 result;
-	vec2_abs((mfloat_t *)&result, (mfloat_t *)&vec20);
+	vec2_abs((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec2 svec2_floor(struct vec2 vec20)
+struct vec2 svec2_floor(struct vec2 v0)
 {
 	struct vec2 result;
-	vec2_floor((mfloat_t *)&result, (mfloat_t *)&vec20);
+	vec2_floor((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec2 svec2_ceil(struct vec2 vec20)
+struct vec2 svec2_ceil(struct vec2 v0)
 {
 	struct vec2 result;
-	vec2_ceil((mfloat_t *)&result, (mfloat_t *)&vec20);
+	vec2_ceil((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec2 svec2_round(struct vec2 vec20)
+struct vec2 svec2_round(struct vec2 v0)
 {
 	struct vec2 result;
-	vec2_round((mfloat_t *)&result, (mfloat_t *)&vec20);
+	vec2_round((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec2 svec2_max(struct vec2 vec20, struct vec2 vec21)
+struct vec2 svec2_max(struct vec2 v0, struct vec2 v1)
 {
 	struct vec2 result;
-	vec2_max((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	vec2_max((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec2 svec2_min(struct vec2 vec20, struct vec2 vec21)
+struct vec2 svec2_min(struct vec2 v0, struct vec2 v1)
 {
 	struct vec2 result;
-	vec2_min((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	vec2_min((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec2 svec2_clamp(struct vec2 vec20, struct vec2 vec21, struct vec2 vec22)
+struct vec2 svec2_clamp(struct vec2 v0, struct vec2 v1, struct vec2 v2)
 {
 	struct vec2 result;
-	vec2_clamp((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21, (mfloat_t *)&vec22);
+	vec2_clamp((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1, (mfloat_t *)&v2);
 	return result;
 }
 
-struct vec2 svec2_normalize(struct vec2 vec20)
+struct vec2 svec2_normalize(struct vec2 v0)
 {
 	struct vec2 result;
-	vec2_normalize((mfloat_t *)&result, (mfloat_t *)&vec20);
+	vec2_normalize((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-mfloat_t svec2_dot(struct vec2 vec20, struct vec2 vec21)
+mfloat_t svec2_dot(struct vec2 v0, struct vec2 v1)
 {
-	return vec2_dot((mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	return vec2_dot((mfloat_t *)&v0, (mfloat_t *)&v1);
 }
 
-struct vec2 svec2_project(struct vec2 vec20, struct vec2 vec21)
+struct vec2 svec2_project(struct vec2 v0, struct vec2 v1)
 {
 	struct vec2 result;
-	vec2_project((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	vec2_project((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec2 svec2_slide(struct vec2 vec20, struct vec2 vec21)
+struct vec2 svec2_slide(struct vec2 v0, struct vec2 normal)
 {
 	struct vec2 result;
-	vec2_slide((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	vec2_slide((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&normal);
 	return result;
 }
 
-struct vec2 svec2_reflect(struct vec2 vec20, struct vec2 vec21)
+struct vec2 svec2_reflect(struct vec2 v0, struct vec2 normal)
 {
 	struct vec2 result;
-	vec2_reflect((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	vec2_reflect((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&normal);
 	return result;
 }
 
-struct vec2 svec2_tangent(struct vec2 vec20)
+struct vec2 svec2_tangent(struct vec2 v0)
 {
 	struct vec2 result;
-	vec2_tangent((mfloat_t *)&result, (mfloat_t *)&vec20);
+	vec2_tangent((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec2 svec2_rotate(struct vec2 vec20, mfloat_t f)
+struct vec2 svec2_rotate(struct vec2 v0, mfloat_t f)
 {
 	struct vec2 result;
-	vec2_rotate((mfloat_t *)&result, (mfloat_t *)&vec20, f);
+	vec2_rotate((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec2 svec2_lerp(struct vec2 vec20, struct vec2 vec21, mfloat_t f)
+struct vec2 svec2_lerp(struct vec2 v0, struct vec2 v1, mfloat_t f)
 {
 	struct vec2 result;
-	vec2_lerp((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21, f);
+	vec2_lerp((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1, f);
 	return result;
 }
 
-struct vec2 svec2_bezier3(struct vec2 vec20, struct vec2 vec21, struct vec2 vec22, mfloat_t f)
+struct vec2 svec2_bezier3(struct vec2 v0, struct vec2 v1, struct vec2 v2, mfloat_t f)
 {
 	struct vec2 result;
-	vec2_bezier3((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21, (mfloat_t *)&vec22, f);
+	vec2_bezier3((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1, (mfloat_t *)&v2, f);
 	return result;
 }
 
-struct vec2 svec2_bezier4(struct vec2 vec20, struct vec2 vec21, struct vec2 vec22, struct vec2 vec23, mfloat_t f)
+struct vec2 svec2_bezier4(struct vec2 v0, struct vec2 v1, struct vec2 v2, struct vec2 v3, mfloat_t f)
 {
 	struct vec2 result;
-	vec2_bezier4((mfloat_t *)&result, (mfloat_t *)&vec20, (mfloat_t *)&vec21, (mfloat_t *)&vec22, (mfloat_t *)&vec23, f);
+	vec2_bezier4((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1, (mfloat_t *)&v2, (mfloat_t *)&v3, f);
 	return result;
 }
 
-mfloat_t svec2_angle(struct vec2 vec20)
+mfloat_t svec2_angle(struct vec2 v0)
 {
-	return vec2_angle((mfloat_t *)&vec20);
+	return vec2_angle((mfloat_t *)&v0);
 }
 
-mfloat_t svec2_length(struct vec2 vec20)
+mfloat_t svec2_length(struct vec2 v0)
 {
-	return vec2_length((mfloat_t *)&vec20);
+	return vec2_length((mfloat_t *)&v0);
 }
 
-mfloat_t svec2_length_squared(struct vec2 vec20)
+mfloat_t svec2_length_squared(struct vec2 v0)
 {
-	return vec2_length_squared((mfloat_t *)&vec20);
+	return vec2_length_squared((mfloat_t *)&v0);
 }
 
-mfloat_t svec2_distance(struct vec2 vec20, struct vec2 vec21)
+mfloat_t svec2_distance(struct vec2 v0, struct vec2 v1)
 {
-	return vec2_distance((mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	return vec2_distance((mfloat_t *)&v0, (mfloat_t *)&v1);
 }
 
-mfloat_t svec2_distance_squared(struct vec2 vec20, struct vec2 vec21)
+mfloat_t svec2_distance_squared(struct vec2 v0, struct vec2 v1)
 {
-	return vec2_distance_squared((mfloat_t *)&vec20, (mfloat_t *)&vec21);
+	return vec2_distance_squared((mfloat_t *)&v0, (mfloat_t *)&v1);
 }
 
-bool svec3_is_zero(struct vec3 vec30)
+bool svec3_is_zero(struct vec3 v0)
 {
-	return vec3_is_zero((mfloat_t *)&vec30);
+	return vec3_is_zero((mfloat_t *)&v0);
 }
 
-bool svec3_is_equal(struct vec3 vec30, struct vec3 vec31)
+bool svec3_is_equal(struct vec3 v0, struct vec3 v1)
 {
-	return vec3_is_equal((mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return vec3_is_equal((mfloat_t *)&v0, (mfloat_t *)&v1);
 }
 
 struct vec3 svec3(mfloat_t x, mfloat_t y, mfloat_t z)
@@ -4122,18 +4126,18 @@ struct vec3 svec3(mfloat_t x, mfloat_t y, mfloat_t z)
 	return result;
 }
 
-struct vec3 svec3_assign(struct vec3 vec30)
+struct vec3 svec3_assign(struct vec3 v0)
 {
 	struct vec3 result;
-	vec3_assign((mfloat_t *)&result, (mfloat_t *)&vec30);
+	vec3_assign((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
 #if defined(MATHC_USE_INT)
-struct vec3 svec3_assign_vec3i(struct vec3i vec3i0)
+struct vec3 svec3_assign_vec3i(struct vec3i v0)
 {
 	struct vec3 result;
-	vec3_assign_vec3i((mfloat_t *)&result, (mint_t *)&vec3i0);
+	vec3_assign_vec3i((mfloat_t *)&result, (mint_t *)&v0);
 	return result;
 }
 #endif
@@ -4152,235 +4156,235 @@ struct vec3 svec3_one(void)
 	return result;
 }
 
-struct vec3 svec3_sign(struct vec3 vec30)
+struct vec3 svec3_sign(struct vec3 v0)
 {
 	struct vec3 result;
-	vec3_sign((mfloat_t *)&result, (mfloat_t *)&vec30);
+	vec3_sign((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec3 svec3_add(struct vec3 vec30, struct vec3 vec31)
+struct vec3 svec3_add(struct vec3 v0, struct vec3 v1)
 {
 	struct vec3 result;
-	vec3_add((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	vec3_add((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec3 svec3_add_f(struct vec3 vec30, mfloat_t f)
+struct vec3 svec3_add_f(struct vec3 v0, mfloat_t f)
 {
 	struct vec3 result;
-	vec3_add_f((mfloat_t *)&result, (mfloat_t *)&vec30, f);
+	vec3_add_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec3 svec3_subtract(struct vec3 vec30, struct vec3 vec31)
+struct vec3 svec3_subtract(struct vec3 v0, struct vec3 v1)
 {
 	struct vec3 result;
-	vec3_subtract((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	vec3_subtract((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec3 svec3_subtract_f(struct vec3 vec30, mfloat_t f)
+struct vec3 svec3_subtract_f(struct vec3 v0, mfloat_t f)
 {
 	struct vec3 result;
-	vec3_subtract_f((mfloat_t *)&result, (mfloat_t *)&vec30, f);
+	vec3_subtract_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec3 svec3_multiply(struct vec3 vec30, struct vec3 vec31)
+struct vec3 svec3_multiply(struct vec3 v0, struct vec3 v1)
 {
 	struct vec3 result;
-	vec3_multiply((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	vec3_multiply((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec3 svec3_multiply_f(struct vec3 vec30, mfloat_t f)
+struct vec3 svec3_multiply_f(struct vec3 v0, mfloat_t f)
 {
 	struct vec3 result;
-	vec3_multiply_f((mfloat_t *)&result, (mfloat_t *)&vec30, f);
+	vec3_multiply_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec3 svec3_multiply_mat3(struct vec3 vec30, struct mat3 mat30)
+struct vec3 svec3_multiply_mat3(struct vec3 v0, struct mat3 m0)
 {
 	struct vec3 result;
-	vec3_multiply_mat3((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&mat30);
+	vec3_multiply_mat3((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&m0);
 	return result;
 }
 
-struct vec3 svec3_divide(struct vec3 vec30, struct vec3 vec31)
+struct vec3 svec3_divide(struct vec3 v0, struct vec3 v1)
 {
 	struct vec3 result;
-	vec3_divide((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	vec3_divide((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec3 svec3_divide_f(struct vec3 vec30, mfloat_t f)
+struct vec3 svec3_divide_f(struct vec3 v0, mfloat_t f)
 {
 	struct vec3 result;
-	vec3_divide_f((mfloat_t *)&result, (mfloat_t *)&vec30, f);
+	vec3_divide_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec3 svec3_snap(struct vec3 vec30, struct vec3 vec31)
+struct vec3 svec3_snap(struct vec3 v0, struct vec3 v1)
 {
 	struct vec3 result;
-	vec3_snap((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	vec3_snap((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec3 svec3_snap_f(struct vec3 vec30, mfloat_t f)
+struct vec3 svec3_snap_f(struct vec3 v0, mfloat_t f)
 {
 	struct vec3 result;
-	vec3_snap_f((mfloat_t *)&result, (mfloat_t *)&vec30, f);
+	vec3_snap_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec3 svec3_negative(struct vec3 vec30)
+struct vec3 svec3_negative(struct vec3 v0)
 {
 	struct vec3 result;
-	vec3_negative((mfloat_t *)&result, (mfloat_t *)&vec30);
+	vec3_negative((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec3 svec3_abs(struct vec3 vec30)
+struct vec3 svec3_abs(struct vec3 v0)
 {
 	struct vec3 result;
-	vec3_abs((mfloat_t *)&result, (mfloat_t *)&vec30);
+	vec3_abs((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec3 svec3_floor(struct vec3 vec30)
+struct vec3 svec3_floor(struct vec3 v0)
 {
 	struct vec3 result;
-	vec3_floor((mfloat_t *)&result, (mfloat_t *)&vec30);
+	vec3_floor((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec3 svec3_ceil(struct vec3 vec30)
+struct vec3 svec3_ceil(struct vec3 v0)
 {
 	struct vec3 result;
-	vec3_ceil((mfloat_t *)&result, (mfloat_t *)&vec30);
+	vec3_ceil((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec3 svec3_round(struct vec3 vec30)
+struct vec3 svec3_round(struct vec3 v0)
 {
 	struct vec3 result;
-	vec3_round((mfloat_t *)&result, (mfloat_t *)&vec30);
+	vec3_round((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec3 svec3_max(struct vec3 vec30, struct vec3 vec31)
+struct vec3 svec3_max(struct vec3 v0, struct vec3 v1)
 {
 	struct vec3 result;
-	vec3_max((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	vec3_max((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec3 svec3_min(struct vec3 vec30, struct vec3 vec31)
+struct vec3 svec3_min(struct vec3 v0, struct vec3 v1)
 {
 	struct vec3 result;
-	vec3_min((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	vec3_min((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec3 svec3_clamp(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32)
+struct vec3 svec3_clamp(struct vec3 v0, struct vec3 v1, struct vec3 v2)
 {
 	struct vec3 result;
-	vec3_clamp((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31, (mfloat_t *)&vec32);
+	vec3_clamp((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1, (mfloat_t *)&v2);
 	return result;
 }
 
-struct vec3 svec3_cross(struct vec3 vec30, struct vec3 vec31)
+struct vec3 svec3_cross(struct vec3 v0, struct vec3 v1)
 {
 	struct vec3 result;
-	vec3_cross((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	vec3_cross((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec3 svec3_normalize(struct vec3 vec30)
+struct vec3 svec3_normalize(struct vec3 v0)
 {
 	struct vec3 result;
-	vec3_normalize((mfloat_t *)&result, (mfloat_t *)&vec30);
+	vec3_normalize((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-mfloat_t svec3_dot(struct vec3 vec30, struct vec3 vec31)
+mfloat_t svec3_dot(struct vec3 v0, struct vec3 v1)
 {
-	return vec3_dot((mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return vec3_dot((mfloat_t *)&v0, (mfloat_t *)&v1);
 }
 
-struct vec3 svec3_project(struct vec3 vec30, struct vec3 vec31)
+struct vec3 svec3_project(struct vec3 v0, struct vec3 v1)
 {
 	struct vec3 result;
-	vec3_project((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	vec3_project((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec3 svec3_slide(struct vec3 vec30, struct vec3 vec31)
+struct vec3 svec3_slide(struct vec3 v0, struct vec3 normal)
 {
 	struct vec3 result;
-	vec3_slide((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	vec3_slide((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&normal);
 	return result;
 }
 
-struct vec3 svec3_reflect(struct vec3 vec30, struct vec3 vec31)
+struct vec3 svec3_reflect(struct vec3 v0, struct vec3 normal)
 {
 	struct vec3 result;
-	vec3_reflect((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	vec3_reflect((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&normal);
 	return result;
 }
 
-struct vec3 svec3_lerp(struct vec3 vec30, struct vec3 vec31, mfloat_t f)
+struct vec3 svec3_lerp(struct vec3 v0, struct vec3 v1, mfloat_t f)
 {
 	struct vec3 result;
-	vec3_lerp((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31, f);
+	vec3_lerp((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1, f);
 	return result;
 }
 
-struct vec3 svec3_bezier3(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32, mfloat_t f)
+struct vec3 svec3_bezier3(struct vec3 v0, struct vec3 v1, struct vec3 v2, mfloat_t f)
 {
 	struct vec3 result;
-	vec3_bezier3((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31, (mfloat_t *)&vec32, f);
+	vec3_bezier3((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1, (mfloat_t *)&v2, f);
 	return result;
 }
 
-struct vec3 svec3_bezier4(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32, struct vec3 vec33, mfloat_t f)
+struct vec3 svec3_bezier4(struct vec3 v0, struct vec3 v1, struct vec3 v2, struct vec3 v3, mfloat_t f)
 {
 	struct vec3 result;
-	vec3_bezier4((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31, (mfloat_t *)&vec32, (mfloat_t *)&vec33, f);
+	vec3_bezier4((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1, (mfloat_t *)&v2, (mfloat_t *)&v3, f);
 	return result;
 }
 
-mfloat_t svec3_length(struct vec3 vec30)
+mfloat_t svec3_length(struct vec3 v0)
 {
-	return vec3_length((mfloat_t *)&vec30);
+	return vec3_length((mfloat_t *)&v0);
 }
 
-mfloat_t svec3_length_squared(struct vec3 vec30)
+mfloat_t svec3_length_squared(struct vec3 v0)
 {
-	return vec3_length_squared((mfloat_t *)&vec30);
+	return vec3_length_squared((mfloat_t *)&v0);
 }
 
-mfloat_t svec3_distance(struct vec3 vec30, struct vec3 vec31)
+mfloat_t svec3_distance(struct vec3 v0, struct vec3 v1)
 {
-	return vec3_distance((mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return vec3_distance((mfloat_t *)&v0, (mfloat_t *)&v1);
 }
 
-mfloat_t svec3_distance_squared(struct vec3 vec30, struct vec3 vec31)
+mfloat_t svec3_distance_squared(struct vec3 v0, struct vec3 v1)
 {
-	return vec3_distance_squared((mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	return vec3_distance_squared((mfloat_t *)&v0, (mfloat_t *)&v1);
 }
 
-bool svec4_is_zero(struct vec4 vec40)
+bool svec4_is_zero(struct vec4 v0)
 {
-	return vec4_is_zero((mfloat_t *)&vec40);
+	return vec4_is_zero((mfloat_t *)&v0);
 }
 
-bool svec4_is_equal(struct vec4 vec40, struct vec4 vec41)
+bool svec4_is_equal(struct vec4 v0, struct vec4 v1)
 {
-	return vec4_is_equal((mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	return vec4_is_equal((mfloat_t *)&v0, (mfloat_t *)&v1);
 }
 
 struct vec4 svec4(mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
@@ -4390,18 +4394,18 @@ struct vec4 svec4(mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
 	return result;
 }
 
-struct vec4 svec4_assign(struct vec4 vec40)
+struct vec4 svec4_assign(struct vec4 v0)
 {
 	struct vec4 result;
-	vec4_assign((mfloat_t *)&result, (mfloat_t *)&vec40);
+	vec4_assign((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
 #if defined(MATHC_USE_INT)
-struct vec4 svec4_assign_vec4i(struct vec4i vec4i0)
+struct vec4 svec4_assign_vec4i(struct vec4i v0)
 {
 	struct vec4 result;
-	vec4_assign_vec4i((mfloat_t *)&result, (mint_t *)&vec4i0);
+	vec4_assign_vec4i((mfloat_t *)&result, (mint_t *)&v0);
 	return result;
 }
 #endif
@@ -4420,168 +4424,168 @@ struct vec4 svec4_one(void)
 	return result;
 }
 
-struct vec4 svec4_sign(struct vec4 vec40)
+struct vec4 svec4_sign(struct vec4 v0)
 {
 	struct vec4 result;
-	vec4_sign((mfloat_t *)&result, (mfloat_t *)&vec40);
+	vec4_sign((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec4 svec4_add(struct vec4 vec40, struct vec4 vec41)
+struct vec4 svec4_add(struct vec4 v0, struct vec4 v1)
 {
 	struct vec4 result;
-	vec4_add((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	vec4_add((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec4 svec4_add_f(struct vec4 vec40, mfloat_t f)
+struct vec4 svec4_add_f(struct vec4 v0, mfloat_t f)
 {
 	struct vec4 result;
-	vec4_add_f((mfloat_t *)&result, (mfloat_t *)&vec40, f);
+	vec4_add_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec4 svec4_subtract(struct vec4 vec40, struct vec4 vec41)
+struct vec4 svec4_subtract(struct vec4 v0, struct vec4 v1)
 {
 	struct vec4 result;
-	vec4_subtract((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	vec4_subtract((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec4 svec4_subtract_f(struct vec4 vec40, mfloat_t f)
+struct vec4 svec4_subtract_f(struct vec4 v0, mfloat_t f)
 {
 	struct vec4 result;
-	vec4_subtract_f((mfloat_t *)&result, (mfloat_t *)&vec40, f);
+	vec4_subtract_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec4 svec4_multiply(struct vec4 vec40, struct vec4 vec41)
+struct vec4 svec4_multiply(struct vec4 v0, struct vec4 v1)
 {
 	struct vec4 result;
-	vec4_multiply((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	vec4_multiply((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec4 svec4_multiply_f(struct vec4 vec40, mfloat_t f)
+struct vec4 svec4_multiply_f(struct vec4 v0, mfloat_t f)
 {
 	struct vec4 result;
-	vec4_multiply_f((mfloat_t *)&result, (mfloat_t *)&vec40, f);
+	vec4_multiply_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec4 svec4_multiply_mat4(struct vec4 vec40, struct mat4 mat40)
+struct vec4 svec4_multiply_mat4(struct vec4 v0, struct mat4 m0)
 {
 	struct vec4 result;
-	vec4_multiply_mat4((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&mat40);
+	vec4_multiply_mat4((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&m0);
 	return result;
 }
 
-struct vec4 svec4_divide(struct vec4 vec40, struct vec4 vec41)
+struct vec4 svec4_divide(struct vec4 v0, struct vec4 v1)
 {
 	struct vec4 result;
-	vec4_divide((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	vec4_divide((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec4 svec4_divide_f(struct vec4 vec40, mfloat_t f)
+struct vec4 svec4_divide_f(struct vec4 v0, mfloat_t f)
 {
 	struct vec4 result;
-	vec4_divide_f((mfloat_t *)&result, (mfloat_t *)&vec40, f);
+	vec4_divide_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec4 svec4_snap(struct vec4 vec40, struct vec4 vec41)
+struct vec4 svec4_snap(struct vec4 v0, struct vec4 v1)
 {
 	struct vec4 result;
-	vec4_snap((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	vec4_snap((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec4 svec4_snap_f(struct vec4 vec40, mfloat_t f)
+struct vec4 svec4_snap_f(struct vec4 v0, mfloat_t f)
 {
 	struct vec4 result;
-	vec4_snap_f((mfloat_t *)&result, (mfloat_t *)&vec40, f);
+	vec4_snap_f((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct vec4 svec4_negative(struct vec4 vec40)
+struct vec4 svec4_negative(struct vec4 v0)
 {
 	struct vec4 result;
-	vec4_negative((mfloat_t *)&result, (mfloat_t *)&vec40);
+	vec4_negative((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec4 svec4_abs(struct vec4 vec40)
+struct vec4 svec4_abs(struct vec4 v0)
 {
 	struct vec4 result;
-	vec4_abs((mfloat_t *)&result, (mfloat_t *)&vec40);
+	vec4_abs((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec4 svec4_floor(struct vec4 vec40)
+struct vec4 svec4_floor(struct vec4 v0)
 {
 	struct vec4 result;
-	vec4_floor((mfloat_t *)&result, (mfloat_t *)&vec40);
+	vec4_floor((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec4 svec4_ceil(struct vec4 vec40)
+struct vec4 svec4_ceil(struct vec4 v0)
 {
 	struct vec4 result;
-	vec4_ceil((mfloat_t *)&result, (mfloat_t *)&vec40);
+	vec4_ceil((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec4 svec4_round(struct vec4 vec40)
+struct vec4 svec4_round(struct vec4 v0)
 {
 	struct vec4 result;
-	vec4_round((mfloat_t *)&result, (mfloat_t *)&vec40);
+	vec4_round((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec4 svec4_max(struct vec4 vec40, struct vec4 vec41)
+struct vec4 svec4_max(struct vec4 v0, struct vec4 v1)
 {
 	struct vec4 result;
-	vec4_max((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	vec4_max((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec4 svec4_min(struct vec4 vec40, struct vec4 vec41)
+struct vec4 svec4_min(struct vec4 v0, struct vec4 v1)
 {
 	struct vec4 result;
-	vec4_min((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41);
+	vec4_min((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct vec4 svec4_clamp(struct vec4 vec40, struct vec4 vec41, struct vec4 vec42)
+struct vec4 svec4_clamp(struct vec4 v0, struct vec4 v1, struct vec4 v2)
 {
 	struct vec4 result;
-	vec4_clamp((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41, (mfloat_t *)&vec42);
+	vec4_clamp((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1, (mfloat_t *)&v2);
 	return result;
 }
 
-struct vec4 svec4_normalize(struct vec4 vec40)
+struct vec4 svec4_normalize(struct vec4 v0)
 {
 	struct vec4 result;
-	vec4_normalize((mfloat_t *)&result, (mfloat_t *)&vec40);
+	vec4_normalize((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct vec4 svec4_lerp(struct vec4 vec40, struct vec4 vec41, mfloat_t f)
+struct vec4 svec4_lerp(struct vec4 v0, struct vec4 v1, mfloat_t f)
 {
 	struct vec4 result;
-	vec4_lerp((mfloat_t *)&result, (mfloat_t *)&vec40, (mfloat_t *)&vec41, f);
+	vec4_lerp((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1, f);
 	return result;
 }
 
-bool squat_is_zero(struct quat quat0)
+bool squat_is_zero(struct quat q0)
 {
-	return quat_is_zero((mfloat_t *)&quat0);
+	return quat_is_zero((mfloat_t *)&q0);
 }
 
-bool squat_is_equal(struct quat quat0, struct quat quat1)
+bool squat_is_equal(struct quat q0, struct quat q1)
 {
-	return quat_is_equal((mfloat_t *)&quat0, (mfloat_t *)&quat1);
+	return quat_is_equal((mfloat_t *)&q0, (mfloat_t *)&q1);
 }
 
 struct quat squat(mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
@@ -4591,10 +4595,10 @@ struct quat squat(mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
 	return result;
 }
 
-struct quat squat_assign(struct quat quat0)
+struct quat squat_assign(struct quat q0)
 {
 	struct quat result;
-	quat_assign((mfloat_t *)&result, (mfloat_t *)&quat0);
+	quat_assign((mfloat_t *)&result, (mfloat_t *)&q0);
 	return result;
 }
 
@@ -4612,122 +4616,122 @@ struct quat squat_null(void)
 	return result;
 }
 
-struct quat squat_multiply(struct quat quat0, struct quat quat1)
+struct quat squat_multiply(struct quat q0, struct quat q1)
 {
 	struct quat result;
-	quat_multiply((mfloat_t *)&result, (mfloat_t *)&quat0, (mfloat_t *)&quat1);
+	quat_multiply((mfloat_t *)&result, (mfloat_t *)&q0, (mfloat_t *)&q1);
 	return result;
 }
 
-struct quat squat_multiply_f(struct quat quat0, mfloat_t f)
+struct quat squat_multiply_f(struct quat q0, mfloat_t f)
 {
 	struct quat result;
-	quat_multiply_f((mfloat_t *)&result, (mfloat_t *)&quat0, f);
+	quat_multiply_f((mfloat_t *)&result, (mfloat_t *)&q0, f);
 	return result;
 }
 
-struct quat squat_divide(struct quat quat0, struct quat quat1)
+struct quat squat_divide(struct quat q0, struct quat q1)
 {
 	struct quat result;
-	quat_divide((mfloat_t *)&result, (mfloat_t *)&quat0, (mfloat_t *)&quat1);
+	quat_divide((mfloat_t *)&result, (mfloat_t *)&q0, (mfloat_t *)&q1);
 	return result;
 }
 
-struct quat squat_divide_f(struct quat quat0, mfloat_t f)
+struct quat squat_divide_f(struct quat q0, mfloat_t f)
 {
 	struct quat result;
-	quat_divide_f((mfloat_t *)&result, (mfloat_t *)&quat0, f);
+	quat_divide_f((mfloat_t *)&result, (mfloat_t *)&q0, f);
 	return result;
 }
 
-struct quat squat_negative(struct quat quat0)
+struct quat squat_negative(struct quat q0)
 {
 	struct quat result;
-	quat_negative((mfloat_t *)&result, (mfloat_t *)&quat0);
+	quat_negative((mfloat_t *)&result, (mfloat_t *)&q0);
 	return result;
 }
 
-struct quat squat_conjugate(struct quat quat0)
+struct quat squat_conjugate(struct quat q0)
 {
 	struct quat result;
-	quat_conjugate((mfloat_t *)&result, (mfloat_t *)&quat0);
+	quat_conjugate((mfloat_t *)&result, (mfloat_t *)&q0);
 	return result;
 }
 
-struct quat squat_inverse(struct quat quat0)
+struct quat squat_inverse(struct quat q0)
 {
 	struct quat result;
-	quat_inverse((mfloat_t *)&result, (mfloat_t *)&quat0);
+	quat_inverse((mfloat_t *)&result, (mfloat_t *)&q0);
 	return result;
 }
 
-struct quat squat_normalize(struct quat quat0)
+struct quat squat_normalize(struct quat q0)
 {
 	struct quat result;
-	quat_normalize((mfloat_t *)&result, (mfloat_t *)&quat0);
+	quat_normalize((mfloat_t *)&result, (mfloat_t *)&q0);
 	return result;
 }
 
-mfloat_t squat_dot(struct quat quat0, struct quat quat1)
+mfloat_t squat_dot(struct quat q0, struct quat q1)
 {
-	return quat_dot((mfloat_t *)&quat0, (mfloat_t *)&quat1);
+	return quat_dot((mfloat_t *)&q0, (mfloat_t *)&q1);
 }
 
-struct quat squat_power(struct quat quat0, mfloat_t exponent)
+struct quat squat_power(struct quat q0, mfloat_t exponent)
 {
 	struct quat result;
-	quat_power((mfloat_t *)&result, (mfloat_t *)&quat0, exponent);
+	quat_power((mfloat_t *)&result, (mfloat_t *)&q0, exponent);
 	return result;
 }
 
-struct quat squat_from_axis_angle(struct vec3 vec30, mfloat_t angle)
+struct quat squat_from_axis_angle(struct vec3 v0, mfloat_t angle)
 {
 	struct quat result;
-	quat_from_axis_angle((mfloat_t *)&result, (mfloat_t *)&vec30, angle);
+	quat_from_axis_angle((mfloat_t *)&result, (mfloat_t *)&v0, angle);
 	return result;
 }
 
-struct quat squat_from_vec3(struct vec3 vec30, struct vec3 vec31)
+struct quat squat_from_vec3(struct vec3 v0, struct vec3 v1)
 {
 	struct quat result;
-	quat_from_vec3((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31);
+	quat_from_vec3((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&v1);
 	return result;
 }
 
-struct quat squat_from_mat4(struct mat4 mat40)
+struct quat squat_from_mat4(struct mat4 m0)
 {
 	struct quat result;
-	quat_from_mat4((mfloat_t *)&result, (mfloat_t *)&mat40);
+	quat_from_mat4((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct quat squat_lerp(struct quat quat0, struct quat quat1, mfloat_t f)
+struct quat squat_lerp(struct quat q0, struct quat q1, mfloat_t f)
 {
 	struct quat result;
-	quat_lerp((mfloat_t *)&result, (mfloat_t *)&quat0, (mfloat_t *)&quat1, f);
+	quat_lerp((mfloat_t *)&result, (mfloat_t *)&q0, (mfloat_t *)&q1, f);
 	return result;
 }
 
-struct quat squat_slerp(struct quat quat0, struct quat quat1, mfloat_t f)
+struct quat squat_slerp(struct quat q0, struct quat q1, mfloat_t f)
 {
 	struct quat result;
-	quat_slerp((mfloat_t *)&result, (mfloat_t *)&quat0, (mfloat_t *)&quat1, f);
+	quat_slerp((mfloat_t *)&result, (mfloat_t *)&q0, (mfloat_t *)&q1, f);
 	return result;
 }
 
-mfloat_t squat_length(struct quat quat0)
+mfloat_t squat_length(struct quat q0)
 {
-	return quat_length((mfloat_t *)&quat0);
+	return quat_length((mfloat_t *)&q0);
 }
 
-mfloat_t squat_length_squared(struct quat quat0)
+mfloat_t squat_length_squared(struct quat q0)
 {
-	return quat_length_squared((mfloat_t *)&quat0);
+	return quat_length_squared((mfloat_t *)&q0);
 }
 
-mfloat_t squat_angle(struct quat quat0, struct quat quat1)
+mfloat_t squat_angle(struct quat q0, struct quat q1)
 {
-	return quat_angle((mfloat_t *)&quat0, (mfloat_t *)&quat1);
+	return quat_angle((mfloat_t *)&q0, (mfloat_t *)&q1);
 }
 
 struct mat2 smat2(mfloat_t m11, mfloat_t m12, mfloat_t m21, mfloat_t m22)
@@ -4751,78 +4755,78 @@ struct mat2 smat2_identity(void)
 	return result;
 }
 
-mfloat_t smat2_determinant(struct mat2 mat20)
+mfloat_t smat2_determinant(struct mat2 m0)
 {
-	return mat2_determinant((mfloat_t *)&mat20);
+	return mat2_determinant((mfloat_t *)&m0);
 }
 
-struct mat2 smat2_assign(struct mat2 mat20)
+struct mat2 smat2_assign(struct mat2 m0)
 {
 	struct mat2 result;
-	mat2_assign((mfloat_t *)&result, (mfloat_t *)&mat20);
+	mat2_assign((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat2 smat2_negative(struct mat2 mat20)
+struct mat2 smat2_negative(struct mat2 m0)
 {
 	struct mat2 result;
-	mat2_negative((mfloat_t *)&result, (mfloat_t *)&mat20);
+	mat2_negative((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat2 smat2_transpose(struct mat2 mat20)
+struct mat2 smat2_transpose(struct mat2 m0)
 {
 	struct mat2 result;
-	mat2_transpose((mfloat_t *)&result, (mfloat_t *)&mat20);
+	mat2_transpose((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat2 smat2_cofactor(struct mat2 mat20)
+struct mat2 smat2_cofactor(struct mat2 m0)
 {
 	struct mat2 result;
-	mat2_cofactor((mfloat_t *)&result, (mfloat_t *)&mat20);
+	mat2_cofactor((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat2 smat2_adjugate(struct mat2 mat20)
+struct mat2 smat2_adjugate(struct mat2 m0)
 {
 	struct mat2 result;
-	mat2_adjugate((mfloat_t *)&result, (mfloat_t *)&mat20);
+	mat2_adjugate((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat2 smat2_multiply(struct mat2 mat20, struct mat2 mat21)
+struct mat2 smat2_multiply(struct mat2 m0, struct mat2 m1)
 {
 	struct mat2 result;
-	mat2_multiply((mfloat_t *)&result, (mfloat_t *)&mat20, (mfloat_t *)&mat21);
+	mat2_multiply((mfloat_t *)&result, (mfloat_t *)&m0, (mfloat_t *)&m1);
 	return result;
 }
 
-struct mat2 smat2_multiply_f(struct mat2 mat20, mfloat_t f)
+struct mat2 smat2_multiply_f(struct mat2 m0, mfloat_t f)
 {
 	struct mat2 result;
-	mat2_multiply_f((mfloat_t *)&result, (mfloat_t *)&mat20, f);
+	mat2_multiply_f((mfloat_t *)&result, (mfloat_t *)&m0, f);
 	return result;
 }
 
-struct mat2 smat2_inverse(struct mat2 mat20)
+struct mat2 smat2_inverse(struct mat2 m0)
 {
 	struct mat2 result;
-	mat2_inverse((mfloat_t *)&result, (mfloat_t *)&mat20);
+	mat2_inverse((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat2 smat2_scaling(struct vec2 vec20)
+struct mat2 smat2_scaling(struct vec2 v0)
 {
 	struct mat2 result;
-	mat2_scaling((mfloat_t *)&result, (mfloat_t *)&vec20);
+	mat2_scaling((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct mat2 smat2_scale(struct mat2 mat20, struct vec2 vec20)
+struct mat2 smat2_scale(struct mat2 m0, struct vec2 v0)
 {
 	struct mat2 result;
-	mat2_scale((mfloat_t *)&result, (mfloat_t *)&mat20, (mfloat_t *)&vec20);
+	mat2_scale((mfloat_t *)&result, (mfloat_t *)&m0, (mfloat_t *)&v0);
 	return result;
 }
 
@@ -4833,10 +4837,10 @@ struct mat2 smat2_rotation_z(mfloat_t f)
 	return result;
 }
 
-struct mat2 smat2_lerp(struct mat2 mat20, struct mat2 mat21, mfloat_t f)
+struct mat2 smat2_lerp(struct mat2 m0, struct mat2 m1, mfloat_t f)
 {
 	struct mat2 result;
-	mat2_lerp((mfloat_t *)&result, (mfloat_t *)&mat20, (mfloat_t *)&mat21, f);
+	mat2_lerp((mfloat_t *)&result, (mfloat_t *)&m0, (mfloat_t *)&m1, f);
 	return result;
 }
 
@@ -4861,71 +4865,71 @@ struct mat3 smat3_identity(void)
 	return result;
 }
 
-mfloat_t smat3_determinant(struct mat3 mat30)
+mfloat_t smat3_determinant(struct mat3 m0)
 {
-	return mat3_determinant((mfloat_t *)&mat30);
+	return mat3_determinant((mfloat_t *)&m0);
 }
 
-struct mat3 smat3_assign(struct mat3 mat30)
+struct mat3 smat3_assign(struct mat3 m0)
 {
 	struct mat3 result;
-	mat3_assign((mfloat_t *)&result, (mfloat_t *)&mat30);
+	mat3_assign((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat3 smat3_negative(struct mat3 mat30)
+struct mat3 smat3_negative(struct mat3 m0)
 {
 	struct mat3 result;
-	mat3_negative((mfloat_t *)&result, (mfloat_t *)&mat30);
+	mat3_negative((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat3 smat3_transpose(struct mat3 mat30)
+struct mat3 smat3_transpose(struct mat3 m0)
 {
 	struct mat3 result;
-	mat3_transpose((mfloat_t *)&result, (mfloat_t *)&mat30);
+	mat3_transpose((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat3 smat3_cofactor(struct mat3 mat30)
+struct mat3 smat3_cofactor(struct mat3 m0)
 {
 	struct mat3 result;
-	mat3_cofactor((mfloat_t *)&result, (mfloat_t *)&mat30);
+	mat3_cofactor((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat3 smat3_multiply(struct mat3 mat30, struct mat3 mat31)
+struct mat3 smat3_multiply(struct mat3 m0, struct mat3 m1)
 {
 	struct mat3 result;
-	mat3_multiply((mfloat_t *)&result, (mfloat_t *)&mat30, (mfloat_t *)&mat31);
+	mat3_multiply((mfloat_t *)&result, (mfloat_t *)&m0, (mfloat_t *)&m1);
 	return result;
 }
 
-struct mat3 smat3_multiply_f(struct mat3 mat30, mfloat_t f)
+struct mat3 smat3_multiply_f(struct mat3 m0, mfloat_t f)
 {
 	struct mat3 result;
-	mat3_multiply_f((mfloat_t *)&result, (mfloat_t *)&mat30, f);
+	mat3_multiply_f((mfloat_t *)&result, (mfloat_t *)&m0, f);
 	return result;
 }
 
-struct mat3 smat3_inverse(struct mat3 mat30)
+struct mat3 smat3_inverse(struct mat3 m0)
 {
 	struct mat3 result;
-	mat3_inverse((mfloat_t *)&result, (mfloat_t *)&mat30);
+	mat3_inverse((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat3 smat3_scaling(struct vec3 vec30)
+struct mat3 smat3_scaling(struct vec3 v0)
 {
 	struct mat3 result;
-	mat3_scaling((mfloat_t *)&result, (mfloat_t *)&vec30);
+	mat3_scaling((mfloat_t *)&result, (mfloat_t *)&v0);
 	return result;
 }
 
-struct mat3 smat3_scale(struct mat3 mat30, struct vec3 vec30)
+struct mat3 smat3_scale(struct mat3 m0, struct vec3 v0)
 {
 	struct mat3 result;
-	mat3_scale((mfloat_t *)&result, (mfloat_t *)&mat30, (mfloat_t *)&vec30);
+	mat3_scale((mfloat_t *)&result, (mfloat_t *)&m0, (mfloat_t *)&v0);
 	return result;
 }
 
@@ -4950,24 +4954,24 @@ struct mat3 smat3_rotation_z(mfloat_t f)
 	return result;
 }
 
-struct mat3 smat3_rotation_axis(struct vec3 vec30, mfloat_t f)
+struct mat3 smat3_rotation_axis(struct vec3 v0, mfloat_t f)
 {
 	struct mat3 result;
-	mat3_rotation_axis((mfloat_t *)&result, (mfloat_t *)&vec30, f);
+	mat3_rotation_axis((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct mat3 smat3_rotation_quat(struct quat quat0)
+struct mat3 smat3_rotation_quat(struct quat q0)
 {
 	struct mat3 result;
-	mat3_rotation_quat((mfloat_t *)&result, (mfloat_t *)&quat0);
+	mat3_rotation_quat((mfloat_t *)&result, (mfloat_t *)&q0);
 	return result;
 }
 
-struct mat3 smat3_lerp(struct mat3 mat30, struct mat3 mat31, mfloat_t f)
+struct mat3 smat3_lerp(struct mat3 m0, struct mat3 m1, mfloat_t f)
 {
 	struct mat3 result;
-	mat3_lerp((mfloat_t *)&result, (mfloat_t *)&mat30, (mfloat_t *)&mat31, f);
+	mat3_lerp((mfloat_t *)&result, (mfloat_t *)&m0, (mfloat_t *)&m1, f);
 	return result;
 }
 
@@ -4992,36 +4996,36 @@ struct mat4 smat4_identity(void)
 	return result;
 }
 
-mfloat_t smat4_determinant(struct mat4 mat40)
+mfloat_t smat4_determinant(struct mat4 m0)
 {
-	return mat4_determinant((mfloat_t *)&mat40);
+	return mat4_determinant((mfloat_t *)&m0);
 }
 
-struct mat4 smat4_assign(struct mat4 mat40)
+struct mat4 smat4_assign(struct mat4 m0)
 {
 	struct mat4 result;
-	mat4_assign((mfloat_t *)&result, (mfloat_t *)&mat40);
+	mat4_assign((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat4 smat4_negative(struct mat4 mat40)
+struct mat4 smat4_negative(struct mat4 m0)
 {
 	struct mat4 result;
-	mat4_negative((mfloat_t *)&result, (mfloat_t *)&mat40);
+	mat4_negative((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat4 smat4_transpose(struct mat4 mat40)
+struct mat4 smat4_transpose(struct mat4 m0)
 {
 	struct mat4 result;
-	mat4_transpose((mfloat_t *)&result, (mfloat_t *)&mat40);
+	mat4_transpose((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat4 smat4_cofactor(struct mat4 mat40)
+struct mat4 smat4_cofactor(struct mat4 m0)
 {
 	struct mat4 result;
-	mat4_cofactor((mfloat_t *)&result, (mfloat_t *)&mat40);
+	mat4_cofactor((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
@@ -5046,80 +5050,80 @@ struct mat4 smat4_rotation_z(mfloat_t f)
 	return result;
 }
 
-struct mat4 smat4_rotation_axis(struct vec3 vec30, mfloat_t f)
+struct mat4 smat4_rotation_axis(struct vec3 v0, mfloat_t f)
 {
 	struct mat4 result;
-	mat4_rotation_axis((mfloat_t *)&result, (mfloat_t *)&vec30, f);
+	mat4_rotation_axis((mfloat_t *)&result, (mfloat_t *)&v0, f);
 	return result;
 }
 
-struct mat4 smat4_rotation_quat(struct quat quat0)
+struct mat4 smat4_rotation_quat(struct quat q0)
 {
 	struct mat4 result;
-	mat4_rotation_quat((mfloat_t *)&result, (mfloat_t *)&quat0);
+	mat4_rotation_quat((mfloat_t *)&result, (mfloat_t *)&q0);
 	return result;
 }
 
-struct mat4 smat4_translation(struct mat4 mat40, struct vec3 vec30)
+struct mat4 smat4_translation(struct mat4 m0, struct vec3 v0)
 {
 	struct mat4 result;
-	mat4_translation((mfloat_t *)&result, (mfloat_t *)&mat40, (mfloat_t *)&vec30);
+	mat4_translation((mfloat_t *)&result, (mfloat_t *)&m0, (mfloat_t *)&v0);
 	return result;
 }
 
-struct mat4 smat4_translate(struct mat4 mat40, struct vec3 vec30)
+struct mat4 smat4_translate(struct mat4 m0, struct vec3 v0)
 {
 	struct mat4 result;
-	mat4_translate((mfloat_t *)&result, (mfloat_t *)&mat40, (mfloat_t *)&vec30);
+	mat4_translate((mfloat_t *)&result, (mfloat_t *)&m0, (mfloat_t *)&v0);
 	return result;
 }
 
-struct mat4 smat4_scaling(struct mat4 mat40, struct vec3 vec30)
+struct mat4 smat4_scaling(struct mat4 m0, struct vec3 v0)
 {
 	struct mat4 result;
-	mat4_scaling((mfloat_t *)&result, (mfloat_t *)&mat40, (mfloat_t *)&vec30);
+	mat4_scaling((mfloat_t *)&result, (mfloat_t *)&m0, (mfloat_t *)&v0);
 	return result;
 }
 
-struct mat4 smat4_scale(struct mat4 mat40, struct vec3 vec30)
+struct mat4 smat4_scale(struct mat4 m0, struct vec3 v0)
 {
 	struct mat4 result;
-	mat4_scale((mfloat_t *)&result, (mfloat_t *)&mat40, (mfloat_t *)&vec30);
+	mat4_scale((mfloat_t *)&result, (mfloat_t *)&m0, (mfloat_t *)&v0);
 	return result;
 }
 
-struct mat4 smat4_multiply(struct mat4 mat40, struct mat4 mat41)
+struct mat4 smat4_multiply(struct mat4 m0, struct mat4 m1)
 {
 	struct mat4 result;
-	mat4_multiply((mfloat_t *)&result, (mfloat_t *)&mat40, (mfloat_t *)&mat41);
+	mat4_multiply((mfloat_t *)&result, (mfloat_t *)&m0, (mfloat_t *)&m1);
 	return result;
 }
 
-struct mat4 smat4_multiply_f(struct mat4 mat40, mfloat_t f)
+struct mat4 smat4_multiply_f(struct mat4 m0, mfloat_t f)
 {
 	struct mat4 result;
-	mat4_multiply_f((mfloat_t *)&result, (mfloat_t *)&mat40, f);
+	mat4_multiply_f((mfloat_t *)&result, (mfloat_t *)&m0, f);
 	return result;
 }
 
-struct mat4 smat4_inverse(struct mat4 mat40)
+struct mat4 smat4_inverse(struct mat4 m0)
 {
 	struct mat4 result;
-	mat4_inverse((mfloat_t *)&result, (mfloat_t *)&mat40);
+	mat4_inverse((mfloat_t *)&result, (mfloat_t *)&m0);
 	return result;
 }
 
-struct mat4 smat4_lerp(struct mat4 mat40, struct mat4 mat41, mfloat_t f)
+struct mat4 smat4_lerp(struct mat4 m0, struct mat4 m1, mfloat_t f)
 {
 	struct mat4 result;
-	mat4_lerp((mfloat_t *)&result, (mfloat_t *)&mat40, (mfloat_t *)&mat41, f);
+	mat4_lerp((mfloat_t *)&result, (mfloat_t *)&m0, (mfloat_t *)&m1, f);
 	return result;
 }
 
-struct mat4 smat4_look_at(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32)
+struct mat4 smat4_g(struct vec3 position, struct vec3 target, struct vec3 up)
 {
 	struct mat4 result;
-	mat4_look_at((mfloat_t *)&result, (mfloat_t *)&vec30, (mfloat_t *)&vec31, (mfloat_t *)&vec32);
+	mat4_look_at((mfloat_t *)&result, (mfloat_t *)&position, (mfloat_t *)&target, (mfloat_t *)&up);
 	return result;
 }
 
@@ -5155,14 +5159,14 @@ struct mat4 smat4_perspective_infinite(mfloat_t fov_y, mfloat_t aspect, mfloat_t
 
 #if defined(MATHC_USE_POINTER_STRUCT_FUNCTIONS)
 #if defined(MATHC_USE_INT)
-bool psvec2i_is_zero(struct vec2i *vec2i0)
+bool psvec2i_is_zero(struct vec2i *v0)
 {
-	return vec2i_is_zero((mint_t *)vec2i0);
+	return vec2i_is_zero((mint_t *)v0);
 }
 
-bool psvec2i_is_equal(struct vec2i *vec2i0, struct vec2i *vec2i1)
+bool psvec2i_is_equal(struct vec2i *v0, struct vec2i *v1)
 {
-	return vec2i_is_equal((mint_t *)vec2i0, (mint_t *)vec2i1);
+	return vec2i_is_equal((mint_t *)v0, (mint_t *)v1);
 }
 
 struct vec2i *psvec2i(struct vec2i *result, mint_t x, mint_t y)
@@ -5170,15 +5174,15 @@ struct vec2i *psvec2i(struct vec2i *result, mint_t x, mint_t y)
 	return (struct vec2i *)vec2i((mint_t *)result, x, y);
 }
 
-struct vec2i *psvec2i_assign(struct vec2i *result, struct vec2i *vec2i0)
+struct vec2i *psvec2i_assign(struct vec2i *result, struct vec2i *v0)
 {
-	return (struct vec2i *)vec2i_assign((mint_t *)result, (mint_t *)vec2i0);
+	return (struct vec2i *)vec2i_assign((mint_t *)result, (mint_t *)v0);
 }
 
 #if defined(MATHC_USE_FLOATING_POINT)
-struct vec2i *psvec2i_assign_vec2(struct vec2i *result, struct vec2 *vec20)
+struct vec2i *psvec2i_assign_vec2(struct vec2i *result, struct vec2 *v0)
 {
-	return (struct vec2i *)vec2i_assign_vec2((mint_t *)result, (mfloat_t *)vec20);
+	return (struct vec2i *)vec2i_assign_vec2((mint_t *)result, (mfloat_t *)v0);
 }
 #endif
 
@@ -5192,99 +5196,99 @@ struct vec2i *psvec2i_one(struct vec2i *result)
 	return (struct vec2i *)vec2i_one((mint_t *)result);
 }
 
-struct vec2i *psvec2i_sign(struct vec2i *result, struct vec2i *vec2i0)
+struct vec2i *psvec2i_sign(struct vec2i *result, struct vec2i *v0)
 {
-	return (struct vec2i *)vec2i_sign((mint_t *)result, (mint_t *)vec2i0);
+	return (struct vec2i *)vec2i_sign((mint_t *)result, (mint_t *)v0);
 }
 
-struct vec2i *psvec2i_add(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1)
+struct vec2i *psvec2i_add(struct vec2i *result, struct vec2i *v0, struct vec2i *v1)
 {
-	return (struct vec2i *)vec2i_add((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1);
+	return (struct vec2i *)vec2i_add((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec2i *psvec2i_add_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i)
+struct vec2i *psvec2i_add_i(struct vec2i *result, struct vec2i *v0, mint_t i)
 {
-	return (struct vec2i *)vec2i_add_i((mint_t *)result, (mint_t *)vec2i0, i);
+	return (struct vec2i *)vec2i_add_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec2i *psvec2i_subtract(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1)
+struct vec2i *psvec2i_subtract(struct vec2i *result, struct vec2i *v0, struct vec2i *v1)
 {
-	return (struct vec2i *)vec2i_subtract((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1);
+	return (struct vec2i *)vec2i_subtract((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec2i *psvec2i_subtract_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i)
+struct vec2i *psvec2i_subtract_i(struct vec2i *result, struct vec2i *v0, mint_t i)
 {
-	return (struct vec2i *)vec2i_subtract_i((mint_t *)result, (mint_t *)vec2i0, i);
+	return (struct vec2i *)vec2i_subtract_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec2i *psvec2i_multiply(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1)
+struct vec2i *psvec2i_multiply(struct vec2i *result, struct vec2i *v0, struct vec2i *v1)
 {
-	return (struct vec2i *)vec2i_multiply((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1);
+	return (struct vec2i *)vec2i_multiply((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec2i *psvec2i_multiply_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i)
+struct vec2i *psvec2i_multiply_i(struct vec2i *result, struct vec2i *v0, mint_t i)
 {
-	return (struct vec2i *)vec2i_multiply_i((mint_t *)result, (mint_t *)vec2i0, i);
+	return (struct vec2i *)vec2i_multiply_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec2i *psvec2i_divide(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1)
+struct vec2i *psvec2i_divide(struct vec2i *result, struct vec2i *v0, struct vec2i *v1)
 {
-	return (struct vec2i *)vec2i_divide((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1);
+	return (struct vec2i *)vec2i_divide((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec2i *psvec2i_divide_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i)
+struct vec2i *psvec2i_divide_i(struct vec2i *result, struct vec2i *v0, mint_t i)
 {
-	return (struct vec2i *)vec2i_divide_i((mint_t *)result, (mint_t *)vec2i0, i);
+	return (struct vec2i *)vec2i_divide_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec2i *psvec2i_snap(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1)
+struct vec2i *psvec2i_snap(struct vec2i *result, struct vec2i *v0, struct vec2i *v1)
 {
-	return (struct vec2i *)vec2i_snap((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1);
+	return (struct vec2i *)vec2i_snap((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec2i *psvec2i_snap_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i)
+struct vec2i *psvec2i_snap_i(struct vec2i *result, struct vec2i *v0, mint_t i)
 {
-	return (struct vec2i *)vec2i_snap_i((mint_t *)result, (mint_t *)vec2i0, i);
+	return (struct vec2i *)vec2i_snap_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec2i *psvec2i_negative(struct vec2i *result, struct vec2i *vec2i0)
+struct vec2i *psvec2i_negative(struct vec2i *result, struct vec2i *v0)
 {
-	return (struct vec2i *)vec2i_negative((mint_t *)result, (mint_t *)vec2i0);
+	return (struct vec2i *)vec2i_negative((mint_t *)result, (mint_t *)v0);
 }
 
-struct vec2i *psvec2i_abs(struct vec2i *result, struct vec2i *vec2i0)
+struct vec2i *psvec2i_abs(struct vec2i *result, struct vec2i *v0)
 {
-	return (struct vec2i *)vec2i_abs((mint_t *)result, (mint_t *)vec2i0);
+	return (struct vec2i *)vec2i_abs((mint_t *)result, (mint_t *)v0);
 }
 
-struct vec2i *psvec2i_max(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1)
+struct vec2i *psvec2i_max(struct vec2i *result, struct vec2i *v0, struct vec2i *v1)
 {
-	return (struct vec2i *)vec2i_max((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1);
+	return (struct vec2i *)vec2i_max((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec2i *psvec2i_min(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1)
+struct vec2i *psvec2i_min(struct vec2i *result, struct vec2i *v0, struct vec2i *v1)
 {
-	return (struct vec2i *)vec2i_min((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1);
+	return (struct vec2i *)vec2i_min((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec2i *psvec2i_clamp(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1, struct vec2i *vec2i2)
+struct vec2i *psvec2i_clamp(struct vec2i *result, struct vec2i *v0, struct vec2i *v1, struct vec2i *v2)
 {
-	return (struct vec2i *)vec2i_clamp((mint_t *)result, (mint_t *)vec2i0, (mint_t *)vec2i1, (mint_t *)vec2i2);
+	return (struct vec2i *)vec2i_clamp((mint_t *)result, (mint_t *)v0, (mint_t *)v1, (mint_t *)v2);
 }
 
-struct vec2i *psvec2i_tangent(struct vec2i *result, struct vec2i *vec2i0)
+struct vec2i *psvec2i_tangent(struct vec2i *result, struct vec2i *v0)
 {
-	return (struct vec2i *)vec2i_tangent((mint_t *)result, (mint_t *)vec2i0);
+	return (struct vec2i *)vec2i_tangent((mint_t *)result, (mint_t *)v0);
 }
 
-bool psvec3i_is_zero(struct vec3i *vec3i0)
+bool psvec3i_is_zero(struct vec3i *v0)
 {
-	return vec3i_is_zero((mint_t *)vec3i0);
+	return vec3i_is_zero((mint_t *)v0);
 }
 
-bool psvec3i_is_equal(struct vec3i *vec3i0, struct vec3i *vec3i1)
+bool psvec3i_is_equal(struct vec3i *v0, struct vec3i *v1)
 {
-	return vec3i_is_equal((mint_t *)vec3i0, (mint_t *)vec3i1);
+	return vec3i_is_equal((mint_t *)v0, (mint_t *)v1);
 }
 
 struct vec3i *psvec3i(struct vec3i *result, mint_t x, mint_t y, mint_t z)
@@ -5292,15 +5296,15 @@ struct vec3i *psvec3i(struct vec3i *result, mint_t x, mint_t y, mint_t z)
 	return (struct vec3i *)vec3i((mint_t *)result, x, y, z);
 }
 
-struct vec3i *psvec3i_assign(struct vec3i *result, struct vec3i *vec3i0)
+struct vec3i *psvec3i_assign(struct vec3i *result, struct vec3i *v0)
 {
-	return (struct vec3i *)vec3i_assign((mint_t *)result, (mint_t *)vec3i0);
+	return (struct vec3i *)vec3i_assign((mint_t *)result, (mint_t *)v0);
 }
 
 #if defined(MATHC_USE_FLOATING_POINT)
-struct vec3i *psvec3i_assign_vec3(struct vec3i *result, struct vec3 *vec30)
+struct vec3i *psvec3i_assign_vec3(struct vec3i *result, struct vec3 *v0)
 {
-	return (struct vec3i *)vec3i_assign_vec3((mint_t *)result, (mfloat_t *)vec30);
+	return (struct vec3i *)vec3i_assign_vec3((mint_t *)result, (mfloat_t *)v0);
 }
 #endif
 
@@ -5314,99 +5318,99 @@ struct vec3i *psvec3i_one(struct vec3i *result)
 	return (struct vec3i *)vec3i_one((mint_t *)result);
 }
 
-struct vec3i *psvec3i_sign(struct vec3i *result, struct vec3i *vec3i0)
+struct vec3i *psvec3i_sign(struct vec3i *result, struct vec3i *v0)
 {
-	return (struct vec3i *)vec3i_sign((mint_t *)result, (mint_t *)vec3i0);
+	return (struct vec3i *)vec3i_sign((mint_t *)result, (mint_t *)v0);
 }
 
-struct vec3i *psvec3i_add(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
+struct vec3i *psvec3i_add(struct vec3i *result, struct vec3i *v0, struct vec3i *v1)
 {
-	return (struct vec3i *)vec3i_add((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
+	return (struct vec3i *)vec3i_add((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec3i *psvec3i_add_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i)
+struct vec3i *psvec3i_add_i(struct vec3i *result, struct vec3i *v0, mint_t i)
 {
-	return (struct vec3i *)vec3i_add_i((mint_t *)result, (mint_t *)vec3i0, i);
+	return (struct vec3i *)vec3i_add_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec3i *psvec3i_subtract(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
+struct vec3i *psvec3i_subtract(struct vec3i *result, struct vec3i *v0, struct vec3i *v1)
 {
-	return (struct vec3i *)vec3i_subtract((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
+	return (struct vec3i *)vec3i_subtract((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec3i *psvec3i_subtract_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i)
+struct vec3i *psvec3i_subtract_i(struct vec3i *result, struct vec3i *v0, mint_t i)
 {
-	return (struct vec3i *)vec3i_subtract_i((mint_t *)result, (mint_t *)vec3i0, i);
+	return (struct vec3i *)vec3i_subtract_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec3i *psvec3i_multiply(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
+struct vec3i *psvec3i_multiply(struct vec3i *result, struct vec3i *v0, struct vec3i *v1)
 {
-	return (struct vec3i *)vec3i_multiply((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
+	return (struct vec3i *)vec3i_multiply((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec3i *psvec3i_multiply_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i)
+struct vec3i *psvec3i_multiply_i(struct vec3i *result, struct vec3i *v0, mint_t i)
 {
-	return (struct vec3i *)vec3i_multiply_i((mint_t *)result, (mint_t *)vec3i0, i);
+	return (struct vec3i *)vec3i_multiply_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec3i *psvec3i_divide(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
+struct vec3i *psvec3i_divide(struct vec3i *result, struct vec3i *v0, struct vec3i *v1)
 {
-	return (struct vec3i *)vec3i_divide((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
+	return (struct vec3i *)vec3i_divide((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec3i *psvec3i_divide_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i)
+struct vec3i *psvec3i_divide_i(struct vec3i *result, struct vec3i *v0, mint_t i)
 {
-	return (struct vec3i *)vec3i_divide_i((mint_t *)result, (mint_t *)vec3i0, i);
+	return (struct vec3i *)vec3i_divide_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec3i *psvec3i_snap(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
+struct vec3i *psvec3i_snap(struct vec3i *result, struct vec3i *v0, struct vec3i *v1)
 {
-	return (struct vec3i *)vec3i_snap((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
+	return (struct vec3i *)vec3i_snap((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec3i *psvec3i_snap_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i)
+struct vec3i *psvec3i_snap_i(struct vec3i *result, struct vec3i *v0, mint_t i)
 {
-	return (struct vec3i *)vec3i_snap_i((mint_t *)result, (mint_t *)vec3i0, i);
+	return (struct vec3i *)vec3i_snap_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec3i *psvec3i_cross(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
+struct vec3i *psvec3i_cross(struct vec3i *result, struct vec3i *v0, struct vec3i *v1)
 {
-	return (struct vec3i *)vec3i_cross((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
+	return (struct vec3i *)vec3i_cross((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec3i *psvec3i_negative(struct vec3i *result, struct vec3i *vec3i0)
+struct vec3i *psvec3i_negative(struct vec3i *result, struct vec3i *v0)
 {
-	return (struct vec3i *)vec3i_negative((mint_t *)result, (mint_t *)vec3i0);
+	return (struct vec3i *)vec3i_negative((mint_t *)result, (mint_t *)v0);
 }
 
-struct vec3i *psvec3i_abs(struct vec3i *result, struct vec3i *vec3i0)
+struct vec3i *psvec3i_abs(struct vec3i *result, struct vec3i *v0)
 {
-	return (struct vec3i *)vec3i_abs((mint_t *)result, (mint_t *)vec3i0);
+	return (struct vec3i *)vec3i_abs((mint_t *)result, (mint_t *)v0);
 }
 
-struct vec3i *psvec3i_max(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
+struct vec3i *psvec3i_max(struct vec3i *result, struct vec3i *v0, struct vec3i *v1)
 {
-	return (struct vec3i *)vec3i_max((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
+	return (struct vec3i *)vec3i_max((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec3i *psvec3i_min(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1)
+struct vec3i *psvec3i_min(struct vec3i *result, struct vec3i *v0, struct vec3i *v1)
 {
-	return (struct vec3i *)vec3i_min((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1);
+	return (struct vec3i *)vec3i_min((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec3i *psvec3i_clamp(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1, struct vec3i *vec3i2)
+struct vec3i *psvec3i_clamp(struct vec3i *result, struct vec3i *v0, struct vec3i *v1, struct vec3i *v2)
 {
-	return (struct vec3i *)vec3i_clamp((mint_t *)result, (mint_t *)vec3i0, (mint_t *)vec3i1, (mint_t *)vec3i2);
+	return (struct vec3i *)vec3i_clamp((mint_t *)result, (mint_t *)v0, (mint_t *)v1, (mint_t *)v2);
 }
 
-bool psvec4i_is_zero(struct vec4i *vec4i0)
+bool psvec4i_is_zero(struct vec4i *v0)
 {
-	return vec4i_is_zero((mint_t *)vec4i0);
+	return vec4i_is_zero((mint_t *)v0);
 }
 
-bool psvec4i_is_equal(struct vec4i *vec4i0, struct vec4i *vec4i1)
+bool psvec4i_is_equal(struct vec4i *v0, struct vec4i *v1)
 {
-	return vec4i_is_equal((mint_t *)vec4i0, (mint_t *)vec4i1);
+	return vec4i_is_equal((mint_t *)v0, (mint_t *)v1);
 }
 
 struct vec4i *psvec4i(struct vec4i *result, mint_t x, mint_t y, mint_t z, mint_t w)
@@ -5414,15 +5418,15 @@ struct vec4i *psvec4i(struct vec4i *result, mint_t x, mint_t y, mint_t z, mint_t
 	return (struct vec4i *)vec4i((mint_t *)result, x, y, z, w);
 }
 
-struct vec4i *psvec4i_assign(struct vec4i *result, struct vec4i *vec4i0)
+struct vec4i *psvec4i_assign(struct vec4i *result, struct vec4i *v0)
 {
-	return (struct vec4i *)vec4i_assign((mint_t *)result, (mint_t *)vec4i0);
+	return (struct vec4i *)vec4i_assign((mint_t *)result, (mint_t *)v0);
 }
 
 #if defined(MATHC_USE_FLOATING_POINT)
-struct vec4i *psvec4i_assign_vec4(struct vec4i *result, struct vec4 *vec40)
+struct vec4i *psvec4i_assign_vec4(struct vec4i *result, struct vec4 *v0)
 {
-	return (struct vec4i *)vec4i_assign_vec4((mint_t *)result, (mfloat_t *)vec40);
+	return (struct vec4i *)vec4i_assign_vec4((mint_t *)result, (mfloat_t *)v0);
 }
 #endif
 
@@ -5436,96 +5440,96 @@ struct vec4i *psvec4i_one(struct vec4i *result)
 	return (struct vec4i *)vec4i_one((mint_t *)result);
 }
 
-struct vec4i *psvec4i_sign(struct vec4i *result, struct vec4i *vec4i0)
+struct vec4i *psvec4i_sign(struct vec4i *result, struct vec4i *v0)
 {
-	return (struct vec4i *)vec4i_sign((mint_t *)result, (mint_t *)vec4i0);
+	return (struct vec4i *)vec4i_sign((mint_t *)result, (mint_t *)v0);
 }
 
-struct vec4i *psvec4i_add(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1)
+struct vec4i *psvec4i_add(struct vec4i *result, struct vec4i *v0, struct vec4i *v1)
 {
-	return (struct vec4i *)vec4i_add((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1);
+	return (struct vec4i *)vec4i_add((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec4i *psvec4i_add_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i)
+struct vec4i *psvec4i_add_i(struct vec4i *result, struct vec4i *v0, mint_t i)
 {
-	return (struct vec4i *)vec4i_add_i((mint_t *)result, (mint_t *)vec4i0, i);
+	return (struct vec4i *)vec4i_add_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec4i *psvec4i_subtract(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1)
+struct vec4i *psvec4i_subtract(struct vec4i *result, struct vec4i *v0, struct vec4i *v1)
 {
-	return (struct vec4i *)vec4i_subtract((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1);
+	return (struct vec4i *)vec4i_subtract((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec4i *psvec4i_subtract_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i)
+struct vec4i *psvec4i_subtract_i(struct vec4i *result, struct vec4i *v0, mint_t i)
 {
-	return (struct vec4i *)vec4i_subtract_i((mint_t *)result, (mint_t *)vec4i0, i);
+	return (struct vec4i *)vec4i_subtract_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec4i *psvec4i_multiply(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1)
+struct vec4i *psvec4i_multiply(struct vec4i *result, struct vec4i *v0, struct vec4i *v1)
 {
-	return (struct vec4i *)vec4i_multiply((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1);
+	return (struct vec4i *)vec4i_multiply((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec4i *psvec4i_multiply_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i)
+struct vec4i *psvec4i_multiply_i(struct vec4i *result, struct vec4i *v0, mint_t i)
 {
-	return (struct vec4i *)vec4i_multiply_i((mint_t *)result, (mint_t *)vec4i0, i);
+	return (struct vec4i *)vec4i_multiply_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec4i *psvec4i_divide(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1)
+struct vec4i *psvec4i_divide(struct vec4i *result, struct vec4i *v0, struct vec4i *v1)
 {
-	return (struct vec4i *)vec4i_divide((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1);
+	return (struct vec4i *)vec4i_divide((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec4i *psvec4i_divide_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i)
+struct vec4i *psvec4i_divide_i(struct vec4i *result, struct vec4i *v0, mint_t i)
 {
-	return (struct vec4i *)vec4i_divide_i((mint_t *)result, (mint_t *)vec4i0, i);
+	return (struct vec4i *)vec4i_divide_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec4i *psvec4i_snap(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1)
+struct vec4i *psvec4i_snap(struct vec4i *result, struct vec4i *v0, struct vec4i *v1)
 {
-	return (struct vec4i *)vec4i_snap((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1);
+	return (struct vec4i *)vec4i_snap((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec4i *psvec4i_snap_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i)
+struct vec4i *psvec4i_snap_i(struct vec4i *result, struct vec4i *v0, mint_t i)
 {
-	return (struct vec4i *)vec4i_snap_i((mint_t *)result, (mint_t *)vec4i0, i);
+	return (struct vec4i *)vec4i_snap_i((mint_t *)result, (mint_t *)v0, i);
 }
 
-struct vec4i *psvec4i_negative(struct vec4i *result, struct vec4i *vec4i0)
+struct vec4i *psvec4i_negative(struct vec4i *result, struct vec4i *v0)
 {
-	return (struct vec4i *)vec4i_negative((mint_t *)result, (mint_t *)vec4i0);
+	return (struct vec4i *)vec4i_negative((mint_t *)result, (mint_t *)v0);
 }
 
-struct vec4i *psvec4i_abs(struct vec4i *result, struct vec4i *vec4i0)
+struct vec4i *psvec4i_abs(struct vec4i *result, struct vec4i *v0)
 {
-	return (struct vec4i *)vec4i_abs((mint_t *)result, (mint_t *)vec4i0);
+	return (struct vec4i *)vec4i_abs((mint_t *)result, (mint_t *)v0);
 }
 
-struct vec4i *psvec4i_max(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1)
+struct vec4i *psvec4i_max(struct vec4i *result, struct vec4i *v0, struct vec4i *v1)
 {
-	return (struct vec4i *)vec4i_max((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1);
+	return (struct vec4i *)vec4i_max((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec4i *psvec4i_min(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1)
+struct vec4i *psvec4i_min(struct vec4i *result, struct vec4i *v0, struct vec4i *v1)
 {
-	return (struct vec4i *)vec4i_min((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1);
+	return (struct vec4i *)vec4i_min((mint_t *)result, (mint_t *)v0, (mint_t *)v1);
 }
 
-struct vec4i *psvec4i_clamp(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1, struct vec4i *vec4i2)
+struct vec4i *psvec4i_clamp(struct vec4i *result, struct vec4i *v0, struct vec4i *v1, struct vec4i *v2)
 {
-	return (struct vec4i *)vec4i_clamp((mint_t *)result, (mint_t *)vec4i0, (mint_t *)vec4i1, (mint_t *)vec4i2);
+	return (struct vec4i *)vec4i_clamp((mint_t *)result, (mint_t *)v0, (mint_t *)v1, (mint_t *)v2);
 }
 #endif
 
 #if defined(MATHC_USE_FLOATING_POINT)
-bool psvec2_is_zero(struct vec2 *vec20)
+bool psvec2_is_zero(struct vec2 *v0)
 {
-	return vec2_is_zero((mfloat_t *)vec20);
+	return vec2_is_zero((mfloat_t *)v0);
 }
 
-bool psvec2_is_equal(struct vec2 *vec20, struct vec2 *vec21)
+bool psvec2_is_equal(struct vec2 *v0, struct vec2 *v1)
 {
-	return vec2_is_equal((mfloat_t *)vec20, (mfloat_t *)vec21);
+	return vec2_is_equal((mfloat_t *)v0, (mfloat_t *)v1);
 }
 
 struct vec2 *psvec2(struct vec2 *result, mfloat_t x, mfloat_t y)
@@ -5533,15 +5537,15 @@ struct vec2 *psvec2(struct vec2 *result, mfloat_t x, mfloat_t y)
 	return (struct vec2 *)vec2((mfloat_t *)result, x, y);
 }
 
-struct vec2 *psvec2_assign(struct vec2 *result, struct vec2 *vec20)
+struct vec2 *psvec2_assign(struct vec2 *result, struct vec2 *v0)
 {
-	return (struct vec2 *)vec2_assign((mfloat_t *)result, (mfloat_t *)vec20);
+	return (struct vec2 *)vec2_assign((mfloat_t *)result, (mfloat_t *)v0);
 }
 
 #if defined(MATHC_USE_INT)
-struct vec2 *psvec2_assign_vec2i(struct vec2 *result, struct vec2i *vec2i0)
+struct vec2 *psvec2_assign_vec2i(struct vec2 *result, struct vec2i *v0)
 {
-	return (struct vec2 *)vec2_assign_vec2i((mfloat_t *)result, (mint_t *)vec2i0);
+	return (struct vec2 *)vec2_assign_vec2i((mfloat_t *)result, (mint_t *)v0);
 }
 #endif
 
@@ -5555,189 +5559,189 @@ struct vec2 *psvec2_one(struct vec2 *result)
 	return (struct vec2 *)vec2_one((mfloat_t *)result);
 }
 
-struct vec2 *psvec2_sign(struct vec2 *result, struct vec2 *vec20)
+struct vec2 *psvec2_sign(struct vec2 *result, struct vec2 *v0)
 {
-	return (struct vec2 *)vec2_sign((mfloat_t *)result, (mfloat_t *)vec20);
+	return (struct vec2 *)vec2_sign((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec2 *psvec2_add(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
+struct vec2 *psvec2_add(struct vec2 *result, struct vec2 *v0, struct vec2 *v1)
 {
-	return (struct vec2 *)vec2_add((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
+	return (struct vec2 *)vec2_add((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec2 *psvec2_add_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f)
+struct vec2 *psvec2_add_f(struct vec2 *result, struct vec2 *v0, mfloat_t f)
 {
-	return (struct vec2 *)vec2_add_f((mfloat_t *)result, (mfloat_t *)vec20, f);
+	return (struct vec2 *)vec2_add_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec2 *psvec2_subtract(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
+struct vec2 *psvec2_subtract(struct vec2 *result, struct vec2 *v0, struct vec2 *v1)
 {
-	return (struct vec2 *)vec2_subtract((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
+	return (struct vec2 *)vec2_subtract((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec2 *psvec2_subtract_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f)
+struct vec2 *psvec2_subtract_f(struct vec2 *result, struct vec2 *v0, mfloat_t f)
 {
-	return (struct vec2 *)vec2_subtract_f((mfloat_t *)result, (mfloat_t *)vec20, f);
+	return (struct vec2 *)vec2_subtract_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec2 *psvec2_multiply(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
+struct vec2 *psvec2_multiply(struct vec2 *result, struct vec2 *v0, struct vec2 *v1)
 {
-	return (struct vec2 *)vec2_multiply((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
+	return (struct vec2 *)vec2_multiply((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec2 *psvec2_multiply_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f)
+struct vec2 *psvec2_multiply_f(struct vec2 *result, struct vec2 *v0, mfloat_t f)
 {
-	return (struct vec2 *)vec2_multiply_f((mfloat_t *)result, (mfloat_t *)vec20, f);
+	return (struct vec2 *)vec2_multiply_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec2 *psvec2_multiply_mat2(struct vec2 *result, struct vec2 *vec20, struct mat2 *mat20)
+struct vec2 *psvec2_multiply_mat2(struct vec2 *result, struct vec2 *v0, struct mat2 *m0)
 {
-	return (struct vec2 *)vec2_multiply_mat2((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)mat20);
+	return (struct vec2 *)vec2_multiply_mat2((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)m0);
 }
 
-struct vec2 *psvec2_divide(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
+struct vec2 *psvec2_divide(struct vec2 *result, struct vec2 *v0, struct vec2 *v1)
 {
-	return (struct vec2 *)vec2_divide((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
+	return (struct vec2 *)vec2_divide((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec2 *psvec2_divide_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f)
+struct vec2 *psvec2_divide_f(struct vec2 *result, struct vec2 *v0, mfloat_t f)
 {
-	return (struct vec2 *)vec2_divide_f((mfloat_t *)result, (mfloat_t *)vec20, f);
+	return (struct vec2 *)vec2_divide_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec2 *psvec2_snap(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
+struct vec2 *psvec2_snap(struct vec2 *result, struct vec2 *v0, struct vec2 *v1)
 {
-	return (struct vec2 *)vec2_snap((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
+	return (struct vec2 *)vec2_snap((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec2 *psvec2_snap_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f)
+struct vec2 *psvec2_snap_f(struct vec2 *result, struct vec2 *v0, mfloat_t f)
 {
-	return (struct vec2 *)vec2_snap_f((mfloat_t *)result, (mfloat_t *)vec20, f);
+	return (struct vec2 *)vec2_snap_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec2 *psvec2_negative(struct vec2 *result, struct vec2 *vec20)
+struct vec2 *psvec2_negative(struct vec2 *result, struct vec2 *v0)
 {
-	return (struct vec2 *)vec2_negative((mfloat_t *)result, (mfloat_t *)vec20);
+	return (struct vec2 *)vec2_negative((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec2 *psvec2_abs(struct vec2 *result, struct vec2 *vec20)
+struct vec2 *psvec2_abs(struct vec2 *result, struct vec2 *v0)
 {
-	return (struct vec2 *)vec2_abs((mfloat_t *)result, (mfloat_t *)vec20);
+	return (struct vec2 *)vec2_abs((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec2 *psvec2_floor(struct vec2 *result, struct vec2 *vec20)
+struct vec2 *psvec2_floor(struct vec2 *result, struct vec2 *v0)
 {
-	return (struct vec2 *)vec2_floor((mfloat_t *)result, (mfloat_t *)vec20);
+	return (struct vec2 *)vec2_floor((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec2 *psvec2_ceil(struct vec2 *result, struct vec2 *vec20)
+struct vec2 *psvec2_ceil(struct vec2 *result, struct vec2 *v0)
 {
-	return (struct vec2 *)vec2_ceil((mfloat_t *)result, (mfloat_t *)vec20);
+	return (struct vec2 *)vec2_ceil((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec2 *psvec2_round(struct vec2 *result, struct vec2 *vec20)
+struct vec2 *psvec2_round(struct vec2 *result, struct vec2 *v0)
 {
-	return (struct vec2 *)vec2_round((mfloat_t *)result, (mfloat_t *)vec20);
+	return (struct vec2 *)vec2_round((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec2 *psvec2_max(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
+struct vec2 *psvec2_max(struct vec2 *result, struct vec2 *v0, struct vec2 *v1)
 {
-	return (struct vec2 *)vec2_max((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
+	return (struct vec2 *)vec2_max((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec2 *psvec2_min(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
+struct vec2 *psvec2_min(struct vec2 *result, struct vec2 *v0, struct vec2 *v1)
 {
-	return (struct vec2 *)vec2_min((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
+	return (struct vec2 *)vec2_min((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec2 *psvec2_clamp(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, struct vec2 *vec22)
+struct vec2 *psvec2_clamp(struct vec2 *result, struct vec2 *v0, struct vec2 *v1, struct vec2 *v2)
 {
-	return (struct vec2 *)vec2_clamp((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21, (mfloat_t *)vec22);
+	return (struct vec2 *)vec2_clamp((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1, (mfloat_t *)v2);
 }
 
-struct vec2 *psvec2_normalize(struct vec2 *result, struct vec2 *vec20)
+struct vec2 *psvec2_normalize(struct vec2 *result, struct vec2 *v0)
 {
-	return (struct vec2 *)vec2_normalize((mfloat_t *)result, (mfloat_t *)vec20);
+	return (struct vec2 *)vec2_normalize((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-mfloat_t psvec2_dot(struct vec2 *vec20, struct vec2 *vec21)
+mfloat_t psvec2_dot(struct vec2 *v0, struct vec2 *v1)
 {
-	return vec2_dot((mfloat_t *)vec20, (mfloat_t *)vec21);
+	return vec2_dot((mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec2 *psvec2_project(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
+struct vec2 *psvec2_project(struct vec2 *result, struct vec2 *v0, struct vec2 *v1)
 {
-	return (struct vec2 *)vec2_project((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
+	return (struct vec2 *)vec2_project((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec2 *psvec2_slide(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
+struct vec2 *psvec2_slide(struct vec2 *result, struct vec2 *v0, struct vec2 *normal)
 {
-	return (struct vec2 *)vec2_slide((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
+	return (struct vec2 *)vec2_slide((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)normal);
 }
 
-struct vec2 *psvec2_reflect(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21)
+struct vec2 *psvec2_reflect(struct vec2 *result, struct vec2 *v0, struct vec2 *normal)
 {
-	return (struct vec2 *)vec2_reflect((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21);
+	return (struct vec2 *)vec2_reflect((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)normal);
 }
 
-struct vec2 *psvec2_tangent(struct vec2 *result, struct vec2 *vec20)
+struct vec2 *psvec2_tangent(struct vec2 *result, struct vec2 *v0)
 {
-	return (struct vec2 *)vec2_tangent((mfloat_t *)result, (mfloat_t *)vec20);
+	return (struct vec2 *)vec2_tangent((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec2 *psvec2_rotate(struct vec2 *result, struct vec2 *vec20, mfloat_t f)
+struct vec2 *psvec2_rotate(struct vec2 *result, struct vec2 *v0, mfloat_t f)
 {
-	return (struct vec2 *)vec2_rotate((mfloat_t *)result, (mfloat_t *)vec20, f);
+	return (struct vec2 *)vec2_rotate((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec2 *psvec2_lerp(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, mfloat_t f)
+struct vec2 *psvec2_lerp(struct vec2 *result, struct vec2 *v0, struct vec2 *v1, mfloat_t f)
 {
-	return (struct vec2 *)vec2_lerp((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21, f);
+	return (struct vec2 *)vec2_lerp((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1, f);
 }
 
-struct vec2 *psvec2_bezier3(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, struct vec2 *vec22, mfloat_t f)
+struct vec2 *psvec2_bezier3(struct vec2 *result, struct vec2 *v0, struct vec2 *v1, struct vec2 *v2, mfloat_t f)
 {
-	return (struct vec2 *)vec2_bezier3((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21, (mfloat_t *)vec22, f);
+	return (struct vec2 *)vec2_bezier3((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1, (mfloat_t *)v2, f);
 }
 
-struct vec2 *psvec2_bezier4(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, struct vec2 *vec22, struct vec2 *vec23, mfloat_t f)
+struct vec2 *psvec2_bezier4(struct vec2 *result, struct vec2 *v0, struct vec2 *v1, struct vec2 *v2, struct vec2 *v3, mfloat_t f)
 {
-	return (struct vec2 *)vec2_bezier4((mfloat_t *)result, (mfloat_t *)vec20, (mfloat_t *)vec21, (mfloat_t *)vec22, (mfloat_t *)vec23, f);
+	return (struct vec2 *)vec2_bezier4((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1, (mfloat_t *)v2, (mfloat_t *)v3, f);
 }
 
-mfloat_t psvec2_angle(struct vec2 *vec20)
+mfloat_t psvec2_angle(struct vec2 *v0)
 {
-	return vec2_angle((mfloat_t *)vec20);
+	return vec2_angle((mfloat_t *)v0);
 }
 
-mfloat_t psvec2_length(struct vec2 *vec20)
+mfloat_t psvec2_length(struct vec2 *v0)
 {
-	return vec2_length((mfloat_t *)vec20);
+	return vec2_length((mfloat_t *)v0);
 }
 
-mfloat_t psvec2_length_squared(struct vec2 *vec20)
+mfloat_t psvec2_length_squared(struct vec2 *v0)
 {
-	return vec2_length_squared((mfloat_t *)vec20);
+	return vec2_length_squared((mfloat_t *)v0);
 }
 
-mfloat_t psvec2_distance(struct vec2 *vec20, struct vec2 *vec21)
+mfloat_t psvec2_distance(struct vec2 *v0, struct vec2 *v1)
 {
-	return vec2_distance((mfloat_t *)vec20, (mfloat_t *)vec21);
+	return vec2_distance((mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-mfloat_t psvec2_distance_squared(struct vec2 *vec20, struct vec2 *vec21)
+mfloat_t psvec2_distance_squared(struct vec2 *v0, struct vec2 *v1)
 {
-	return vec2_distance_squared((mfloat_t *)vec20, (mfloat_t *)vec21);
+	return vec2_distance_squared((mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-bool psvec3_is_zero(struct vec3 *vec30)
+bool psvec3_is_zero(struct vec3 *v0)
 {
-	return vec3_is_zero((mfloat_t *)vec30);
+	return vec3_is_zero((mfloat_t *)v0);
 }
 
-bool psvec3_is_equal(struct vec3 *vec30, struct vec3 *vec31)
+bool psvec3_is_equal(struct vec3 *v0, struct vec3 *v1)
 {
-	return vec3_is_equal((mfloat_t *)vec30, (mfloat_t *)vec31);
+	return vec3_is_equal((mfloat_t *)v0, (mfloat_t *)v1);
 }
 
 struct vec3 *psvec3(struct vec3 *result, mfloat_t x, mfloat_t y, mfloat_t z)
@@ -5745,15 +5749,15 @@ struct vec3 *psvec3(struct vec3 *result, mfloat_t x, mfloat_t y, mfloat_t z)
 	return (struct vec3 *)vec3((mfloat_t *)result, x, y, z);
 }
 
-struct vec3 *psvec3_assign(struct vec3 *result, struct vec3 *vec30)
+struct vec3 *psvec3_assign(struct vec3 *result, struct vec3 *v0)
 {
-	return (struct vec3 *)vec3_assign((mfloat_t *)result, (mfloat_t *)vec30);
+	return (struct vec3 *)vec3_assign((mfloat_t *)result, (mfloat_t *)v0);
 }
 
 #if defined(MATHC_USE_INT)
-struct vec3 *psvec3_assign_vec3i(struct vec3 *result, struct vec3i *vec3i0)
+struct vec3 *psvec3_assign_vec3i(struct vec3 *result, struct vec3i *v0)
 {
-	return (struct vec3 *)vec3_assign_vec3i((mfloat_t *)result, (mint_t *)vec3i0);
+	return (struct vec3 *)vec3_assign_vec3i((mfloat_t *)result, (mint_t *)v0);
 }
 #endif
 
@@ -5767,179 +5771,179 @@ struct vec3 *psvec3_one(struct vec3 *result)
 	return (struct vec3 *)vec3_one((mfloat_t *)result);
 }
 
-struct vec3 *psvec3_sign(struct vec3 *result, struct vec3 *vec30)
+struct vec3 *psvec3_sign(struct vec3 *result, struct vec3 *v0)
 {
-	return (struct vec3 *)vec3_sign((mfloat_t *)result, (mfloat_t *)vec30);
+	return (struct vec3 *)vec3_sign((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec3 *psvec3_add(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
+struct vec3 *psvec3_add(struct vec3 *result, struct vec3 *v0, struct vec3 *v1)
 {
-	return (struct vec3 *)vec3_add((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
+	return (struct vec3 *)vec3_add((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec3 *psvec3_add_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f)
+struct vec3 *psvec3_add_f(struct vec3 *result, struct vec3 *v0, mfloat_t f)
 {
-	return (struct vec3 *)vec3_add_f((mfloat_t *)result, (mfloat_t *)vec30, f);
+	return (struct vec3 *)vec3_add_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec3 *psvec3_subtract(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
+struct vec3 *psvec3_subtract(struct vec3 *result, struct vec3 *v0, struct vec3 *v1)
 {
-	return (struct vec3 *)vec3_subtract((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
+	return (struct vec3 *)vec3_subtract((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec3 *psvec3_subtract_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f)
+struct vec3 *psvec3_subtract_f(struct vec3 *result, struct vec3 *v0, mfloat_t f)
 {
-	return (struct vec3 *)vec3_subtract_f((mfloat_t *)result, (mfloat_t *)vec30, f);
+	return (struct vec3 *)vec3_subtract_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec3 *psvec3_multiply(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
+struct vec3 *psvec3_multiply(struct vec3 *result, struct vec3 *v0, struct vec3 *v1)
 {
-	return (struct vec3 *)vec3_multiply((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
+	return (struct vec3 *)vec3_multiply((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec3 *psvec3_multiply_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f)
+struct vec3 *psvec3_multiply_f(struct vec3 *result, struct vec3 *v0, mfloat_t f)
 {
-	return (struct vec3 *)vec3_multiply_f((mfloat_t *)result, (mfloat_t *)vec30, f);
+	return (struct vec3 *)vec3_multiply_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec3 *psvec3_multiply_mat3(struct vec3 *result, struct vec3 *vec30, struct mat3 *mat30)
+struct vec3 *psvec3_multiply_mat3(struct vec3 *result, struct vec3 *v0, struct mat3 *m0)
 {
-	return (struct vec3 *)vec3_multiply_mat3((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)mat30);
+	return (struct vec3 *)vec3_multiply_mat3((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)m0);
 }
 
-struct vec3 *psvec3_divide(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
+struct vec3 *psvec3_divide(struct vec3 *result, struct vec3 *v0, struct vec3 *v1)
 {
-	return (struct vec3 *)vec3_divide((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
+	return (struct vec3 *)vec3_divide((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec3 *psvec3_divide_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f)
+struct vec3 *psvec3_divide_f(struct vec3 *result, struct vec3 *v0, mfloat_t f)
 {
-	return (struct vec3 *)vec3_divide_f((mfloat_t *)result, (mfloat_t *)vec30, f);
+	return (struct vec3 *)vec3_divide_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec3 *psvec3_snap(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
+struct vec3 *psvec3_snap(struct vec3 *result, struct vec3 *v0, struct vec3 *v1)
 {
-	return (struct vec3 *)vec3_snap((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
+	return (struct vec3 *)vec3_snap((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec3 *psvec3_snap_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f)
+struct vec3 *psvec3_snap_f(struct vec3 *result, struct vec3 *v0, mfloat_t f)
 {
-	return (struct vec3 *)vec3_snap_f((mfloat_t *)result, (mfloat_t *)vec30, f);
+	return (struct vec3 *)vec3_snap_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec3 *psvec3_negative(struct vec3 *result, struct vec3 *vec30)
+struct vec3 *psvec3_negative(struct vec3 *result, struct vec3 *v0)
 {
-	return (struct vec3 *)vec3_negative((mfloat_t *)result, (mfloat_t *)vec30);
+	return (struct vec3 *)vec3_negative((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec3 *psvec3_abs(struct vec3 *result, struct vec3 *vec30)
+struct vec3 *psvec3_abs(struct vec3 *result, struct vec3 *v0)
 {
-	return (struct vec3 *)vec3_abs((mfloat_t *)result, (mfloat_t *)vec30);
+	return (struct vec3 *)vec3_abs((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec3 *psvec3_floor(struct vec3 *result, struct vec3 *vec30)
+struct vec3 *psvec3_floor(struct vec3 *result, struct vec3 *v0)
 {
-	return (struct vec3 *)vec3_floor((mfloat_t *)result, (mfloat_t *)vec30);
+	return (struct vec3 *)vec3_floor((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec3 *psvec3_ceil(struct vec3 *result, struct vec3 *vec30)
+struct vec3 *psvec3_ceil(struct vec3 *result, struct vec3 *v0)
 {
-	return (struct vec3 *)vec3_ceil((mfloat_t *)result, (mfloat_t *)vec30);
+	return (struct vec3 *)vec3_ceil((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec3 *psvec3_round(struct vec3 *result, struct vec3 *vec30)
+struct vec3 *psvec3_round(struct vec3 *result, struct vec3 *v0)
 {
-	return (struct vec3 *)vec3_round((mfloat_t *)result, (mfloat_t *)vec30);
+	return (struct vec3 *)vec3_round((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec3 *psvec3_max(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
+struct vec3 *psvec3_max(struct vec3 *result, struct vec3 *v0, struct vec3 *v1)
 {
-	return (struct vec3 *)vec3_max((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
+	return (struct vec3 *)vec3_max((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec3 *psvec3_min(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
+struct vec3 *psvec3_min(struct vec3 *result, struct vec3 *v0, struct vec3 *v1)
 {
-	return (struct vec3 *)vec3_min((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
+	return (struct vec3 *)vec3_min((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec3 *psvec3_clamp(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32)
+struct vec3 *psvec3_clamp(struct vec3 *result, struct vec3 *v0, struct vec3 *v1, struct vec3 *v2)
 {
-	return (struct vec3 *)vec3_clamp((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31, (mfloat_t *)vec32);
+	return (struct vec3 *)vec3_clamp((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1, (mfloat_t *)v2);
 }
 
-struct vec3 *psvec3_cross(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
+struct vec3 *psvec3_cross(struct vec3 *result, struct vec3 *v0, struct vec3 *v1)
 {
-	return (struct vec3 *)vec3_cross((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
+	return (struct vec3 *)vec3_cross((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec3 *psvec3_normalize(struct vec3 *result, struct vec3 *vec30)
+struct vec3 *psvec3_normalize(struct vec3 *result, struct vec3 *v0)
 {
-	return (struct vec3 *)vec3_normalize((mfloat_t *)result, (mfloat_t *)vec30);
+	return (struct vec3 *)vec3_normalize((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-mfloat_t psvec3_dot(struct vec3 *vec30, struct vec3 *vec31)
+mfloat_t psvec3_dot(struct vec3 *v0, struct vec3 *v1)
 {
-	return vec3_dot((mfloat_t *)vec30, (mfloat_t *)vec31);
+	return vec3_dot((mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec3 *psvec3_project(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
+struct vec3 *psvec3_project(struct vec3 *result, struct vec3 *v0, struct vec3 *v1)
 {
-	return (struct vec3 *)vec3_project((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
+	return (struct vec3 *)vec3_project((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec3 *psvec3_slide(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
+struct vec3 *psvec3_slide(struct vec3 *result, struct vec3 *v0, struct vec3 *normal)
 {
-	return (struct vec3 *)vec3_slide((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
+	return (struct vec3 *)vec3_slide((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)normal);
 }
 
-struct vec3 *psvec3_reflect(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31)
+struct vec3 *psvec3_reflect(struct vec3 *result, struct vec3 *v0, struct vec3 *normal)
 {
-	return (struct vec3 *)vec3_reflect((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
+	return (struct vec3 *)vec3_reflect((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)normal);
 }
 
-struct vec3 *psvec3_lerp(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, mfloat_t f)
+struct vec3 *psvec3_lerp(struct vec3 *result, struct vec3 *v0, struct vec3 *v1, mfloat_t f)
 {
-	return (struct vec3 *)vec3_lerp((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31, f);
+	return (struct vec3 *)vec3_lerp((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1, f);
 }
 
-struct vec3 *psvec3_bezier3(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32, mfloat_t f)
+struct vec3 *psvec3_bezier3(struct vec3 *result, struct vec3 *v0, struct vec3 *v1, struct vec3 *v2, mfloat_t f)
 {
-	return (struct vec3 *)vec3_bezier3((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31, (mfloat_t *)vec32, f);
+	return (struct vec3 *)vec3_bezier3((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1, (mfloat_t *)v2, f);
 }
 
-struct vec3 *psvec3_bezier4(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32, struct vec3 *vec33, mfloat_t f)
+struct vec3 *psvec3_bezier4(struct vec3 *result, struct vec3 *v0, struct vec3 *v1, struct vec3 *v2, struct vec3 *v3, mfloat_t f)
 {
-	return (struct vec3 *)vec3_bezier4((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31, (mfloat_t *)vec32, (mfloat_t *)vec33, f);
+	return (struct vec3 *)vec3_bezier4((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1, (mfloat_t *)v2, (mfloat_t *)v3, f);
 }
 
-mfloat_t psvec3_length(struct vec3 *vec30)
+mfloat_t psvec3_length(struct vec3 *v0)
 {
-	return vec3_length((mfloat_t *)vec30);
+	return vec3_length((mfloat_t *)v0);
 }
 
-mfloat_t psvec3_length_squared(struct vec3 *vec30)
+mfloat_t psvec3_length_squared(struct vec3 *v0)
 {
-	return vec3_length_squared((mfloat_t *)vec30);
+	return vec3_length_squared((mfloat_t *)v0);
 }
 
-mfloat_t psvec3_distance(struct vec3 *vec30, struct vec3 *vec31)
+mfloat_t psvec3_distance(struct vec3 *v0, struct vec3 *v1)
 {
-	return vec3_distance((mfloat_t *)vec30, (mfloat_t *)vec31);
+	return vec3_distance((mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-mfloat_t psvec3_distance_squared(struct vec3 *vec30, struct vec3 *vec31)
+mfloat_t psvec3_distance_squared(struct vec3 *v0, struct vec3 *v1)
 {
-	return vec3_distance_squared((mfloat_t *)vec30, (mfloat_t *)vec31);
+	return vec3_distance_squared((mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-bool psvec4_is_zero(struct vec4 *vec40)
+bool psvec4_is_zero(struct vec4 *v0)
 {
-	return vec4_is_zero((mfloat_t *)vec40);
+	return vec4_is_zero((mfloat_t *)v0);
 }
 
-bool psvec4_is_equal(struct vec4 *vec40, struct vec4 *vec41)
+bool psvec4_is_equal(struct vec4 *v0, struct vec4 *v1)
 {
-	return vec4_is_equal((mfloat_t *)vec40, (mfloat_t *)vec41);
+	return vec4_is_equal((mfloat_t *)v0, (mfloat_t *)v1);
 }
 
 struct vec4 *psvec4(struct vec4 *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
@@ -5947,15 +5951,15 @@ struct vec4 *psvec4(struct vec4 *result, mfloat_t x, mfloat_t y, mfloat_t z, mfl
 	return (struct vec4 *)vec4((mfloat_t *)result, x, y, z, w);
 }
 
-struct vec4 *psvec4_assign(struct vec4 *result, struct vec4 *vec40)
+struct vec4 *psvec4_assign(struct vec4 *result, struct vec4 *v0)
 {
-	return (struct vec4 *)vec4_assign((mfloat_t *)result, (mfloat_t *)vec40);
+	return (struct vec4 *)vec4_assign((mfloat_t *)result, (mfloat_t *)v0);
 }
 
 #if defined(MATHC_USE_INT)
-struct vec4 *psvec4_assign_vec4i(struct vec4 *result, struct vec4i *vec4i0)
+struct vec4 *psvec4_assign_vec4i(struct vec4 *result, struct vec4i *v0)
 {
-	return (struct vec4 *)vec4_assign_vec4i((mfloat_t *)result, (mint_t *)vec4i0);
+	return (struct vec4 *)vec4_assign_vec4i((mfloat_t *)result, (mint_t *)v0);
 }
 #endif
 
@@ -5969,124 +5973,124 @@ struct vec4 *psvec4_one(struct vec4 *result)
 	return (struct vec4 *)vec4_one((mfloat_t *)result);
 }
 
-struct vec4 *psvec4_sign(struct vec4 *result, struct vec4 *vec40)
+struct vec4 *psvec4_sign(struct vec4 *result, struct vec4 *v0)
 {
-	return (struct vec4 *)vec4_sign((mfloat_t *)result, (mfloat_t *)vec40);
+	return (struct vec4 *)vec4_sign((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec4 *psvec4_add(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41)
+struct vec4 *psvec4_add(struct vec4 *result, struct vec4 *v0, struct vec4 *v1)
 {
-	return (struct vec4 *)vec4_add((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41);
+	return (struct vec4 *)vec4_add((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec4 *psvec4_add_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f)
+struct vec4 *psvec4_add_f(struct vec4 *result, struct vec4 *v0, mfloat_t f)
 {
-	return (struct vec4 *)vec4_add_f((mfloat_t *)result, (mfloat_t *)vec40, f);
+	return (struct vec4 *)vec4_add_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec4 *psvec4_subtract(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41)
+struct vec4 *psvec4_subtract(struct vec4 *result, struct vec4 *v0, struct vec4 *v1)
 {
-	return (struct vec4 *)vec4_subtract((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41);
+	return (struct vec4 *)vec4_subtract((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec4 *psvec4_subtract_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f)
+struct vec4 *psvec4_subtract_f(struct vec4 *result, struct vec4 *v0, mfloat_t f)
 {
-	return (struct vec4 *)vec4_subtract_f((mfloat_t *)result, (mfloat_t *)vec40, f);
+	return (struct vec4 *)vec4_subtract_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec4 *psvec4_multiply(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41)
+struct vec4 *psvec4_multiply(struct vec4 *result, struct vec4 *v0, struct vec4 *v1)
 {
-	return (struct vec4 *)vec4_multiply((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41);
+	return (struct vec4 *)vec4_multiply((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec4 *psvec4_multiply_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f)
+struct vec4 *psvec4_multiply_f(struct vec4 *result, struct vec4 *v0, mfloat_t f)
 {
-	return (struct vec4 *)vec4_multiply_f((mfloat_t *)result, (mfloat_t *)vec40, f);
+	return (struct vec4 *)vec4_multiply_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec4 *psvec4_multiply_mat4(struct vec4 *result, struct vec4 *vec40, struct mat4 *mat40)
+struct vec4 *psvec4_multiply_mat4(struct vec4 *result, struct vec4 *v0, struct mat4 *m0)
 {
-	return (struct vec4 *)vec4_multiply_mat4((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)mat40);
+	return (struct vec4 *)vec4_multiply_mat4((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)m0);
 }
 
-struct vec4 *psvec4_divide(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41)
+struct vec4 *psvec4_divide(struct vec4 *result, struct vec4 *v0, struct vec4 *v1)
 {
-	return (struct vec4 *)vec4_divide((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41);
+	return (struct vec4 *)vec4_divide((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec4 *psvec4_divide_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f)
+struct vec4 *psvec4_divide_f(struct vec4 *result, struct vec4 *v0, mfloat_t f)
 {
-	return (struct vec4 *)vec4_divide_f((mfloat_t *)result, (mfloat_t *)vec40, f);
+	return (struct vec4 *)vec4_divide_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec4 *psvec4_snap(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41)
+struct vec4 *psvec4_snap(struct vec4 *result, struct vec4 *v0, struct vec4 *v1)
 {
-	return (struct vec4 *)vec4_snap((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41);
+	return (struct vec4 *)vec4_snap((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec4 *psvec4_snap_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f)
+struct vec4 *psvec4_snap_f(struct vec4 *result, struct vec4 *v0, mfloat_t f)
 {
-	return (struct vec4 *)vec4_snap_f((mfloat_t *)result, (mfloat_t *)vec40, f);
+	return (struct vec4 *)vec4_snap_f((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct vec4 *psvec4_negative(struct vec4 *result, struct vec4 *vec40)
+struct vec4 *psvec4_negative(struct vec4 *result, struct vec4 *v0)
 {
-	return (struct vec4 *)vec4_negative((mfloat_t *)result, (mfloat_t *)vec40);
+	return (struct vec4 *)vec4_negative((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec4 *psvec4_abs(struct vec4 *result, struct vec4 *vec40)
+struct vec4 *psvec4_abs(struct vec4 *result, struct vec4 *v0)
 {
-	return (struct vec4 *)vec4_abs((mfloat_t *)result, (mfloat_t *)vec40);
+	return (struct vec4 *)vec4_abs((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec4 *psvec4_floor(struct vec4 *result, struct vec4 *vec40)
+struct vec4 *psvec4_floor(struct vec4 *result, struct vec4 *v0)
 {
-	return (struct vec4 *)vec4_floor((mfloat_t *)result, (mfloat_t *)vec40);
+	return (struct vec4 *)vec4_floor((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec4 *psvec4_ceil(struct vec4 *result, struct vec4 *vec40)
+struct vec4 *psvec4_ceil(struct vec4 *result, struct vec4 *v0)
 {
-	return (struct vec4 *)vec4_ceil((mfloat_t *)result, (mfloat_t *)vec40);
+	return (struct vec4 *)vec4_ceil((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec4 *psvec4_round(struct vec4 *result, struct vec4 *vec40)
+struct vec4 *psvec4_round(struct vec4 *result, struct vec4 *v0)
 {
-	return (struct vec4 *)vec4_round((mfloat_t *)result, (mfloat_t *)vec40);
+	return (struct vec4 *)vec4_round((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec4 *psvec4_max(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41)
+struct vec4 *psvec4_max(struct vec4 *result, struct vec4 *v0, struct vec4 *v1)
 {
-	return (struct vec4 *)vec4_max((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41);
+	return (struct vec4 *)vec4_max((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec4 *psvec4_min(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41)
+struct vec4 *psvec4_min(struct vec4 *result, struct vec4 *v0, struct vec4 *v1)
 {
-	return (struct vec4 *)vec4_min((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41);
+	return (struct vec4 *)vec4_min((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct vec4 *psvec4_clamp(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41, struct vec4 *vec42)
+struct vec4 *psvec4_clamp(struct vec4 *result, struct vec4 *v0, struct vec4 *v1, struct vec4 *v2)
 {
-	return (struct vec4 *)vec4_clamp((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41, (mfloat_t *)vec42);
+	return (struct vec4 *)vec4_clamp((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1, (mfloat_t *)v2);
 }
 
-struct vec4 *psvec4_normalize(struct vec4 *result, struct vec4 *vec40)
+struct vec4 *psvec4_normalize(struct vec4 *result, struct vec4 *v0)
 {
-	return (struct vec4 *)vec4_normalize((mfloat_t *)result, (mfloat_t *)vec40);
+	return (struct vec4 *)vec4_normalize((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct vec4 *psvec4_lerp(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41, mfloat_t f)
+struct vec4 *psvec4_lerp(struct vec4 *result, struct vec4 *v0, struct vec4 *v1, mfloat_t f)
 {
-	return (struct vec4 *)vec4_lerp((mfloat_t *)result, (mfloat_t *)vec40, (mfloat_t *)vec41, f);
+	return (struct vec4 *)vec4_lerp((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1, f);
 }
 
-bool psquat_is_zero(struct quat *quat0)
+bool psquat_is_zero(struct quat *q0)
 {
-	return quat_is_zero((mfloat_t *)quat0);
+	return quat_is_zero((mfloat_t *)q0);
 }
 
-bool psquat_is_equal(struct quat *quat0, struct quat *quat1)
+bool psquat_is_equal(struct quat *q0, struct quat *q1)
 {
-	return quat_is_equal((mfloat_t *)quat0, (mfloat_t *)quat1);
+	return quat_is_equal((mfloat_t *)q0, (mfloat_t *)q1);
 }
 
 struct quat *psquat(struct quat *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w)
@@ -6094,9 +6098,9 @@ struct quat *psquat(struct quat *result, mfloat_t x, mfloat_t y, mfloat_t z, mfl
 	return (struct quat *)quat((mfloat_t *)result, x, y, z, w);
 }
 
-struct quat *psquat_assign(struct quat *result, struct quat *quat0)
+struct quat *psquat_assign(struct quat *result, struct quat *q0)
 {
-	return (struct quat *)quat_assign((mfloat_t *)result, (mfloat_t *)quat0);
+	return (struct quat *)quat_assign((mfloat_t *)result, (mfloat_t *)q0);
 }
 
 struct quat *psquat_zero(struct quat *result)
@@ -6109,94 +6113,94 @@ struct quat *psquat_null(struct quat *result)
 	return (struct quat *)quat_null((mfloat_t *)result);
 }
 
-struct quat *psquat_multiply(struct quat *result, struct quat *quat0, struct quat *quat1)
+struct quat *psquat_multiply(struct quat *result, struct quat *q0, struct quat *q1)
 {
-	return (struct quat *)quat_multiply((mfloat_t *)result, (mfloat_t *)quat0, (mfloat_t *)quat1);
+	return (struct quat *)quat_multiply((mfloat_t *)result, (mfloat_t *)q0, (mfloat_t *)q1);
 }
 
-struct quat *psquat_multiply_f(struct quat *result, struct quat *quat0, mfloat_t f)
+struct quat *psquat_multiply_f(struct quat *result, struct quat *q0, mfloat_t f)
 {
-	return (struct quat *)quat_multiply_f((mfloat_t *)result, (mfloat_t *)quat0, f);
+	return (struct quat *)quat_multiply_f((mfloat_t *)result, (mfloat_t *)q0, f);
 }
 
-struct quat *psquat_divide(struct quat *result, struct quat *quat0, struct quat *quat1)
+struct quat *psquat_divide(struct quat *result, struct quat *q0, struct quat *q1)
 {
-	return (struct quat *)quat_divide((mfloat_t *)result, (mfloat_t *)quat0, (mfloat_t *)quat1);
+	return (struct quat *)quat_divide((mfloat_t *)result, (mfloat_t *)q0, (mfloat_t *)q1);
 }
 
-struct quat *psquat_divide_f(struct quat *result, struct quat *quat0, mfloat_t f)
+struct quat *psquat_divide_f(struct quat *result, struct quat *q0, mfloat_t f)
 {
-	return (struct quat *)quat_divide_f((mfloat_t *)result, (mfloat_t *)quat0, f);
+	return (struct quat *)quat_divide_f((mfloat_t *)result, (mfloat_t *)q0, f);
 }
 
-struct quat *psquat_negative(struct quat *result, struct quat *quat0)
+struct quat *psquat_negative(struct quat *result, struct quat *q0)
 {
-	return (struct quat *)quat_negative((mfloat_t *)result, (mfloat_t *)quat0);
+	return (struct quat *)quat_negative((mfloat_t *)result, (mfloat_t *)q0);
 }
 
-struct quat *psquat_conjugate(struct quat *result, struct quat *quat0)
+struct quat *psquat_conjugate(struct quat *result, struct quat *q0)
 {
-	return (struct quat *)quat_conjugate((mfloat_t *)result, (mfloat_t *)quat0);
+	return (struct quat *)quat_conjugate((mfloat_t *)result, (mfloat_t *)q0);
 }
 
-struct quat *psquat_inverse(struct quat *result, struct quat *quat0)
+struct quat *psquat_inverse(struct quat *result, struct quat *q0)
 {
-	return (struct quat *)quat_inverse((mfloat_t *)result, (mfloat_t *)quat0);
+	return (struct quat *)quat_inverse((mfloat_t *)result, (mfloat_t *)q0);
 }
 
-struct quat *psquat_normalize(struct quat *result, struct quat *quat0)
+struct quat *psquat_normalize(struct quat *result, struct quat *q0)
 {
-	return (struct quat *)quat_normalize((mfloat_t *)result, (mfloat_t *)quat0);
+	return (struct quat *)quat_normalize((mfloat_t *)result, (mfloat_t *)q0);
 }
 
-mfloat_t psquat_dot(struct quat *quat0, struct quat *quat1)
+mfloat_t psquat_dot(struct quat *q0, struct quat *q1)
 {
-	return quat_dot((mfloat_t *)quat0, (mfloat_t *)quat1);
+	return quat_dot((mfloat_t *)q0, (mfloat_t *)q1);
 }
 
-struct quat *psquat_power(struct quat *result, struct quat *quat0, mfloat_t exponent)
+struct quat *psquat_power(struct quat *result, struct quat *q0, mfloat_t exponent)
 {
-	return (struct quat *)quat_power((mfloat_t *)result, (mfloat_t *)quat0, exponent);
+	return (struct quat *)quat_power((mfloat_t *)result, (mfloat_t *)q0, exponent);
 }
 
-struct quat *psquat_from_axis_angle(struct quat *result, struct vec3 *vec30, mfloat_t angle)
+struct quat *psquat_from_axis_angle(struct quat *result, struct vec3 *v0, mfloat_t angle)
 {
-	return (struct quat *)quat_from_axis_angle((mfloat_t *)result, (mfloat_t *)vec30, angle);
+	return (struct quat *)quat_from_axis_angle((mfloat_t *)result, (mfloat_t *)v0, angle);
 }
 
-struct quat *psquat_from_vec3(struct quat *result, struct vec3 *vec30, struct vec3 *vec31)
+struct quat *psquat_from_vec3(struct quat *result, struct vec3 *v0, struct vec3 *v1)
 {
-	return (struct quat *)quat_from_vec3((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31);
+	return (struct quat *)quat_from_vec3((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1);
 }
 
-struct quat *psquat_from_mat4(struct quat *result, struct mat4 *mat40)
+struct quat *psquat_from_mat4(struct quat *result, struct mat4 *m0)
 {
-	return (struct quat *)quat_from_mat4((mfloat_t *)result, (mfloat_t *)mat40);
+	return (struct quat *)quat_from_mat4((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct quat *psquat_lerp(struct quat *result, struct quat *quat0, struct quat *quat1, mfloat_t f)
+struct quat *psquat_lerp(struct quat *result, struct quat *q0, struct quat *q1, mfloat_t f)
 {
-	return (struct quat *)quat_lerp((mfloat_t *)result, (mfloat_t *)quat0, (mfloat_t *)quat1, f);
+	return (struct quat *)quat_lerp((mfloat_t *)result, (mfloat_t *)q0, (mfloat_t *)q1, f);
 }
 
-struct quat *psquat_slerp(struct quat *result, struct quat *quat0, struct quat *quat1, mfloat_t f)
+struct quat *psquat_slerp(struct quat *result, struct quat *q0, struct quat *q1, mfloat_t f)
 {
-	return (struct quat *)quat_slerp((mfloat_t *)result, (mfloat_t *)quat0, (mfloat_t *)quat1, f);
+	return (struct quat *)quat_slerp((mfloat_t *)result, (mfloat_t *)q0, (mfloat_t *)q1, f);
 }
 
-mfloat_t psquat_length(struct quat *quat0)
+mfloat_t psquat_length(struct quat *q0)
 {
-	return quat_length((mfloat_t *)quat0);
+	return quat_length((mfloat_t *)q0);
 }
 
-mfloat_t psquat_length_squared(struct quat *quat0)
+mfloat_t psquat_length_squared(struct quat *q0)
 {
-	return quat_length_squared((mfloat_t *)quat0);
+	return quat_length_squared((mfloat_t *)q0);
 }
 
-mfloat_t psquat_angle(struct quat *quat0, struct quat *quat1)
+mfloat_t psquat_angle(struct quat *q0, struct quat *q1)
 {
-	return quat_angle((mfloat_t *)quat0, (mfloat_t *)quat1);
+	return quat_angle((mfloat_t *)q0, (mfloat_t *)q1);
 }
 
 struct mat2 *psmat2(struct mat2 *result, mfloat_t m11, mfloat_t m12, mfloat_t m21, mfloat_t m22)
@@ -6214,59 +6218,59 @@ struct mat2 *psmat2_identity(struct mat2 *result)
 	return (struct mat2 *)mat2_identity((mfloat_t *)result);
 }
 
-mfloat_t psmat2_determinant(struct mat2 *mat20)
+mfloat_t psmat2_determinant(struct mat2 *m0)
 {
-	return mat2_determinant((mfloat_t *)mat20);
+	return mat2_determinant((mfloat_t *)m0);
 }
 
-struct mat2 *psmat2_assign(struct mat2 *result, struct mat2 *mat20)
+struct mat2 *psmat2_assign(struct mat2 *result, struct mat2 *m0)
 {
-	return (struct mat2 *)mat2_assign((mfloat_t *)result, (mfloat_t *)mat20);
+	return (struct mat2 *)mat2_assign((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat2 *psmat2_negative(struct mat2 *result, struct mat2 *mat20)
+struct mat2 *psmat2_negative(struct mat2 *result, struct mat2 *m0)
 {
-	return (struct mat2 *)mat2_negative((mfloat_t *)result, (mfloat_t *)mat20);
+	return (struct mat2 *)mat2_negative((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat2 *psmat2_transpose(struct mat2 *result, struct mat2 *mat20)
+struct mat2 *psmat2_transpose(struct mat2 *result, struct mat2 *m0)
 {
-	return (struct mat2 *)mat2_transpose((mfloat_t *)result, (mfloat_t *)mat20);
+	return (struct mat2 *)mat2_transpose((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat2 *psmat2_cofactor(struct mat2 *result, struct mat2 *mat20)
+struct mat2 *psmat2_cofactor(struct mat2 *result, struct mat2 *m0)
 {
-	return (struct mat2 *)mat2_cofactor((mfloat_t *)result, (mfloat_t *)mat20);
+	return (struct mat2 *)mat2_cofactor((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat2 *psmat2_adjugate(struct mat2 *result, struct mat2 *mat20)
+struct mat2 *psmat2_adjugate(struct mat2 *result, struct mat2 *m0)
 {
-	return (struct mat2 *)mat2_adjugate((mfloat_t *)result, (mfloat_t *)mat20);
+	return (struct mat2 *)mat2_adjugate((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat2 *psmat2_multiply(struct mat2 *result, struct mat2 *mat20, struct mat2 *mat21)
+struct mat2 *psmat2_multiply(struct mat2 *result, struct mat2 *m0, struct mat2 *m1)
 {
-	return (struct mat2 *)mat2_multiply((mfloat_t *)result, (mfloat_t *)mat20, (mfloat_t *)mat21);
+	return (struct mat2 *)mat2_multiply((mfloat_t *)result, (mfloat_t *)m0, (mfloat_t *)m1);
 }
 
-struct mat2 *psmat2_multiply_f(struct mat2 *result, struct mat2 *mat20, mfloat_t f)
+struct mat2 *psmat2_multiply_f(struct mat2 *result, struct mat2 *m0, mfloat_t f)
 {
-	return (struct mat2 *)mat2_multiply_f((mfloat_t *)result, (mfloat_t *)mat20, f);
+	return (struct mat2 *)mat2_multiply_f((mfloat_t *)result, (mfloat_t *)m0, f);
 }
 
-struct mat2 *psmat2_inverse(struct mat2 *result, struct mat2 *mat20)
+struct mat2 *psmat2_inverse(struct mat2 *result, struct mat2 *m0)
 {
-	return (struct mat2 *)mat2_inverse((mfloat_t *)result, (mfloat_t *)mat20);
+	return (struct mat2 *)mat2_inverse((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat2 *psmat2_scaling(struct mat2 *result, struct vec2 *vec20)
+struct mat2 *psmat2_scaling(struct mat2 *result, struct vec2 *v0)
 {
-	return (struct mat2 *)mat2_scaling((mfloat_t *)result, (mfloat_t *)vec20);
+	return (struct mat2 *)mat2_scaling((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct mat2 *psmat2_scale(struct mat2 *result, struct mat2 *mat20, struct vec2 *vec20)
+struct mat2 *psmat2_scale(struct mat2 *result, struct mat2 *m0, struct vec2 *v0)
 {
-	return (struct mat2 *)mat2_scale((mfloat_t *)result, (mfloat_t *)mat20, (mfloat_t *)vec20);
+	return (struct mat2 *)mat2_scale((mfloat_t *)result, (mfloat_t *)m0, (mfloat_t *)v0);
 }
 
 struct mat2 *psmat2_rotation_z(struct mat2 *result, mfloat_t f)
@@ -6274,9 +6278,9 @@ struct mat2 *psmat2_rotation_z(struct mat2 *result, mfloat_t f)
 	return (struct mat2 *)mat2_rotation_z((mfloat_t *)result, f);
 }
 
-struct mat2 *psmat2_lerp(struct mat2 *result, struct mat2 *mat20, struct mat2 *mat21, mfloat_t f)
+struct mat2 *psmat2_lerp(struct mat2 *result, struct mat2 *m0, struct mat2 *m1, mfloat_t f)
 {
-	return (struct mat2 *)mat2_lerp((mfloat_t *)result, (mfloat_t *)mat20, (mfloat_t *)mat21, f);
+	return (struct mat2 *)mat2_lerp((mfloat_t *)result, (mfloat_t *)m0, (mfloat_t *)m1, f);
 }
 
 struct mat3 *psmat3(struct mat3 *result, mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m31, mfloat_t m32, mfloat_t m33)
@@ -6294,54 +6298,54 @@ struct mat3 *psmat3_identity(struct mat3 *result)
 	return (struct mat3 *)mat3_identity((mfloat_t *)result);
 }
 
-mfloat_t psmat3_determinant(struct mat3 *mat30)
+mfloat_t psmat3_determinant(struct mat3 *m0)
 {
-	return mat3_determinant((mfloat_t *)mat30);
+	return mat3_determinant((mfloat_t *)m0);
 }
 
-struct mat3 *psmat3_assign(struct mat3 *result, struct mat3 *mat30)
+struct mat3 *psmat3_assign(struct mat3 *result, struct mat3 *m0)
 {
-	return (struct mat3 *)mat3_assign((mfloat_t *)result, (mfloat_t *)mat30);
+	return (struct mat3 *)mat3_assign((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat3 *psmat3_negative(struct mat3 *result, struct mat3 *mat30)
+struct mat3 *psmat3_negative(struct mat3 *result, struct mat3 *m0)
 {
-	return (struct mat3 *)mat3_negative((mfloat_t *)result, (mfloat_t *)mat30);
+	return (struct mat3 *)mat3_negative((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat3 *psmat3_transpose(struct mat3 *result, struct mat3 *mat30)
+struct mat3 *psmat3_transpose(struct mat3 *result, struct mat3 *m0)
 {
-	return (struct mat3 *)mat3_transpose((mfloat_t *)result, (mfloat_t *)mat30);
+	return (struct mat3 *)mat3_transpose((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat3 *psmat3_cofactor(struct mat3 *result, struct mat3 *mat30)
+struct mat3 *psmat3_cofactor(struct mat3 *result, struct mat3 *m0)
 {
-	return (struct mat3 *)mat3_cofactor((mfloat_t *)result, (mfloat_t *)mat30);
+	return (struct mat3 *)mat3_cofactor((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat3 *psmat3_multiply(struct mat3 *result, struct mat3 *mat30, struct mat3 *mat31)
+struct mat3 *psmat3_multiply(struct mat3 *result, struct mat3 *m0, struct mat3 *m1)
 {
-	return (struct mat3 *)mat3_multiply((mfloat_t *)result, (mfloat_t *)mat30, (mfloat_t *)mat31);
+	return (struct mat3 *)mat3_multiply((mfloat_t *)result, (mfloat_t *)m0, (mfloat_t *)m1);
 }
 
-struct mat3 *psmat3_multiply_f(struct mat3 *result, struct mat3 *mat30, mfloat_t f)
+struct mat3 *psmat3_multiply_f(struct mat3 *result, struct mat3 *m0, mfloat_t f)
 {
-	return (struct mat3 *)mat3_multiply_f((mfloat_t *)result, (mfloat_t *)mat30, f);
+	return (struct mat3 *)mat3_multiply_f((mfloat_t *)result, (mfloat_t *)m0, f);
 }
 
-struct mat3 *psmat3_inverse(struct mat3 *result, struct mat3 *mat30)
+struct mat3 *psmat3_inverse(struct mat3 *result, struct mat3 *m0)
 {
-	return (struct mat3 *)mat3_inverse((mfloat_t *)result, (mfloat_t *)mat30);
+	return (struct mat3 *)mat3_inverse((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat3 *psmat3_scaling(struct mat3 *result, struct vec3 *vec30)
+struct mat3 *psmat3_scaling(struct mat3 *result, struct vec3 *v0)
 {
-	return (struct mat3 *)mat3_scaling((mfloat_t *)result, (mfloat_t *)vec30);
+	return (struct mat3 *)mat3_scaling((mfloat_t *)result, (mfloat_t *)v0);
 }
 
-struct mat3 *psmat3_scale(struct mat3 *result, struct mat3 *mat30, struct vec3 *vec30)
+struct mat3 *psmat3_scale(struct mat3 *result, struct mat3 *m0, struct vec3 *v0)
 {
-	return (struct mat3 *)mat3_scale((mfloat_t *)result, (mfloat_t *)mat30, (mfloat_t *)vec30);
+	return (struct mat3 *)mat3_scale((mfloat_t *)result, (mfloat_t *)m0, (mfloat_t *)v0);
 }
 
 struct mat3 *psmat3_rotation_x(struct mat3 *result, mfloat_t f)
@@ -6359,19 +6363,19 @@ struct mat3 *psmat3_rotation_z(struct mat3 *result, mfloat_t f)
 	return (struct mat3 *)mat3_rotation_z((mfloat_t *)result, f);
 }
 
-struct mat3 *psmat3_rotation_axis(struct mat3 *result, struct vec3 *vec30, mfloat_t f)
+struct mat3 *psmat3_rotation_axis(struct mat3 *result, struct vec3 *v0, mfloat_t f)
 {
-	return (struct mat3 *)mat3_rotation_axis((mfloat_t *)result, (mfloat_t *)vec30, f);
+	return (struct mat3 *)mat3_rotation_axis((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct mat3 *psmat3_rotation_quat(struct mat3 *result, struct quat *quat0)
+struct mat3 *psmat3_rotation_quat(struct mat3 *result, struct quat *q0)
 {
-	return (struct mat3 *)mat3_rotation_quat((mfloat_t *)result, (mfloat_t *)quat0);
+	return (struct mat3 *)mat3_rotation_quat((mfloat_t *)result, (mfloat_t *)q0);
 }
 
-struct mat3 *psmat3_lerp(struct mat3 *result, struct mat3 *mat30, struct mat3 *mat31, mfloat_t f)
+struct mat3 *psmat3_lerp(struct mat3 *result, struct mat3 *m0, struct mat3 *m1, mfloat_t f)
 {
-	return (struct mat3 *)mat3_lerp((mfloat_t *)result, (mfloat_t *)mat30, (mfloat_t *)mat31, f);
+	return (struct mat3 *)mat3_lerp((mfloat_t *)result, (mfloat_t *)m0, (mfloat_t *)m1, f);
 }
 
 struct mat4 *psmat4(struct mat4 *result, mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m14, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m24, mfloat_t m31, mfloat_t m32, mfloat_t m33, mfloat_t m34, mfloat_t m41, mfloat_t m42, mfloat_t m43, mfloat_t m44)
@@ -6389,29 +6393,29 @@ struct mat4 *psmat4_identity(struct mat4 *result)
 	return (struct mat4 *)mat4_identity((mfloat_t *)result);
 }
 
-mfloat_t psmat4_determinant(struct mat4 *mat40)
+mfloat_t psmat4_determinant(struct mat4 *m0)
 {
-	return mat4_determinant((mfloat_t *)mat40);
+	return mat4_determinant((mfloat_t *)m0);
 }
 
-struct mat4 *psmat4_assign(struct mat4 *result, struct mat4 *mat40)
+struct mat4 *psmat4_assign(struct mat4 *result, struct mat4 *m0)
 {
-	return (struct mat4 *)mat4_assign((mfloat_t *)result, (mfloat_t *)mat40);
+	return (struct mat4 *)mat4_assign((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat4 *psmat4_negative(struct mat4 *result, struct mat4 *mat40)
+struct mat4 *psmat4_negative(struct mat4 *result, struct mat4 *m0)
 {
-	return (struct mat4 *)mat4_negative((mfloat_t *)result, (mfloat_t *)mat40);
+	return (struct mat4 *)mat4_negative((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat4 *psmat4_transpose(struct mat4 *result, struct mat4 *mat40)
+struct mat4 *psmat4_transpose(struct mat4 *result, struct mat4 *m0)
 {
-	return (struct mat4 *)mat4_transpose((mfloat_t *)result, (mfloat_t *)mat40);
+	return (struct mat4 *)mat4_transpose((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat4 *psmat4_cofactor(struct mat4 *result, struct mat4 *mat40)
+struct mat4 *psmat4_cofactor(struct mat4 *result, struct mat4 *m0)
 {
-	return (struct mat4 *)mat4_cofactor((mfloat_t *)result, (mfloat_t *)mat40);
+	return (struct mat4 *)mat4_cofactor((mfloat_t *)result, (mfloat_t *)m0);
 }
 
 struct mat4 *psmat4_rotation_x(struct mat4 *result, mfloat_t f)
@@ -6429,59 +6433,59 @@ struct mat4 *psmat4_rotation_z(struct mat4 *result, mfloat_t f)
 	return (struct mat4 *)mat4_rotation_z((mfloat_t *)result, f);
 }
 
-struct mat4 *psmat4_rotation_axis(struct mat4 *result, struct vec3 *vec30, mfloat_t f)
+struct mat4 *psmat4_rotation_axis(struct mat4 *result, struct vec3 *v0, mfloat_t f)
 {
-	return (struct mat4 *)mat4_rotation_axis((mfloat_t *)result, (mfloat_t *)vec30, f);
+	return (struct mat4 *)mat4_rotation_axis((mfloat_t *)result, (mfloat_t *)v0, f);
 }
 
-struct mat4 *psmat4_rotation_quat(struct mat4 *result, struct quat *quat0)
+struct mat4 *psmat4_rotation_quat(struct mat4 *result, struct quat *q0)
 {
-	return (struct mat4 *)mat4_rotation_quat((mfloat_t *)result, (mfloat_t *)quat0);
+	return (struct mat4 *)mat4_rotation_quat((mfloat_t *)result, (mfloat_t *)q0);
 }
 
-struct mat4 *psmat4_translation(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30)
+struct mat4 *psmat4_translation(struct mat4 *result, struct mat4 *m0, struct vec3 *v0)
 {
-	return (struct mat4 *)mat4_translation((mfloat_t *)result, (mfloat_t *)mat40, (mfloat_t *)vec30);
+	return (struct mat4 *)mat4_translation((mfloat_t *)result, (mfloat_t *)m0, (mfloat_t *)v0);
 }
 
-struct mat4 *psmat4_translate(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30)
+struct mat4 *psmat4_translate(struct mat4 *result, struct mat4 *m0, struct vec3 *v0)
 {
-	return (struct mat4 *)mat4_translate((mfloat_t *)result, (mfloat_t *)mat40, (mfloat_t *)vec30);
+	return (struct mat4 *)mat4_translate((mfloat_t *)result, (mfloat_t *)m0, (mfloat_t *)v0);
 }
 
-struct mat4 *psmat4_scaling(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30)
+struct mat4 *psmat4_scaling(struct mat4 *result, struct mat4 *m0, struct vec3 *v0)
 {
-	return (struct mat4 *)mat4_scaling((mfloat_t *)result, (mfloat_t *)mat40, (mfloat_t *)vec30);
+	return (struct mat4 *)mat4_scaling((mfloat_t *)result, (mfloat_t *)m0, (mfloat_t *)v0);
 }
 
-struct mat4 *psmat4_scale(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30)
+struct mat4 *psmat4_scale(struct mat4 *result, struct mat4 *m0, struct vec3 *v0)
 {
-	return (struct mat4 *)mat4_scale((mfloat_t *)result, (mfloat_t *)mat40, (mfloat_t *)vec30);
+	return (struct mat4 *)mat4_scale((mfloat_t *)result, (mfloat_t *)m0, (mfloat_t *)v0);
 }
 
-struct mat4 *psmat4_multiply(struct mat4 *result, struct mat4 *mat40, struct mat4 *mat41)
+struct mat4 *psmat4_multiply(struct mat4 *result, struct mat4 *m0, struct mat4 *m1)
 {
-	return (struct mat4 *)mat4_multiply((mfloat_t *)result, (mfloat_t *)mat40, (mfloat_t *)mat41);
+	return (struct mat4 *)mat4_multiply((mfloat_t *)result, (mfloat_t *)m0, (mfloat_t *)m1);
 }
 
-struct mat4 *psmat4_multiply_f(struct mat4 *result, struct mat4 *mat40, mfloat_t f)
+struct mat4 *psmat4_multiply_f(struct mat4 *result, struct mat4 *m0, mfloat_t f)
 {
-	return (struct mat4 *)mat4_multiply_f((mfloat_t *)result, (mfloat_t *)mat40, f);
+	return (struct mat4 *)mat4_multiply_f((mfloat_t *)result, (mfloat_t *)m0, f);
 }
 
-struct mat4 *psmat4_inverse(struct mat4 *result, struct mat4 *mat40)
+struct mat4 *psmat4_inverse(struct mat4 *result, struct mat4 *m0)
 {
-	return (struct mat4 *)mat4_inverse((mfloat_t *)result, (mfloat_t *)mat40);
+	return (struct mat4 *)mat4_inverse((mfloat_t *)result, (mfloat_t *)m0);
 }
 
-struct mat4 *psmat4_lerp(struct mat4 *result, struct mat4 *mat40, struct mat4 *mat41, mfloat_t f)
+struct mat4 *psmat4_lerp(struct mat4 *result, struct mat4 *m0, struct mat4 *m1, mfloat_t f)
 {
-	return (struct mat4 *)mat4_lerp((mfloat_t *)result, (mfloat_t *)mat40, (mfloat_t *)mat41, f);
+	return (struct mat4 *)mat4_lerp((mfloat_t *)result, (mfloat_t *)m0, (mfloat_t *)m1, f);
 }
 
-struct mat4 *psmat4_look_at(struct mat4 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32)
+struct mat4 *psmat4_look_at(struct mat4 *result, struct vec3 *position, struct vec3 *target, struct vec3 *up)
 {
-	return (struct mat4 *)mat4_look_at((mfloat_t *)result, (mfloat_t *)vec30, (mfloat_t *)vec31, (mfloat_t *)vec32);
+	return (struct mat4 *)mat4_look_at((mfloat_t *)result, (mfloat_t *)position, (mfloat_t *)target, (mfloat_t *)up);
 }
 
 struct mat4 *psmat4_ortho(struct mat4 *result, mfloat_t l, mfloat_t r, mfloat_t b, mfloat_t t, mfloat_t n, mfloat_t f)
diff --git a/mathc.h b/mathc.h
index 3ad584b..ad3588b 100644
--- a/mathc.h
+++ b/mathc.h
@@ -398,856 +398,859 @@ mfloat_t to_radians(mfloat_t degrees);
 mfloat_t to_degrees(mfloat_t radians);
 #endif
 #if defined(MATHC_USE_INT)
-bool vec2i_is_zero(mint_t *vec2i0);
-bool vec2i_is_equal(mint_t *vec2i0, mint_t *vec2i1);
+bool vec2i_is_zero(mint_t *v0);
+bool vec2i_is_equal(mint_t *v0, mint_t *v1);
 mint_t *vec2i(mint_t *result, mint_t x, mint_t y);
-mint_t *vec2i_assign(mint_t *result, mint_t *vec2i0);
+mint_t *vec2i_assign(mint_t *result, mint_t *v0);
 #if defined(MATHC_USE_FLOATING_POINT)
-mint_t *vec2i_assign_vec2(mint_t *result, mfloat_t *vec20);
+mint_t *vec2i_assign_vec2(mint_t *result, mfloat_t *v0);
 #endif
 mint_t *vec2i_zero(mint_t *result);
 mint_t *vec2i_one(mint_t *result);
-mint_t *vec2i_sign(mint_t *result, mint_t *vec2i0);
-mint_t *vec2i_add(mint_t *result, mint_t *vec2i0, mint_t *vec2i1);
-mint_t *vec2i_add_i(mint_t *result, mint_t *vec2i0, mint_t i);
-mint_t *vec2i_subtract(mint_t *result, mint_t *vec2i0, mint_t *vec2i1);
-mint_t *vec2i_subtract_i(mint_t *result, mint_t *vec2i0, mint_t i);
-mint_t *vec2i_multiply(mint_t *result, mint_t *vec2i0, mint_t *vec2i1);
-mint_t *vec2i_multiply_i(mint_t *result, mint_t *vec2i0, mint_t i);
-mint_t *vec2i_divide(mint_t *result, mint_t *vec2i0, mint_t *vec2i1);
-mint_t *vec2i_divide_i(mint_t *result, mint_t *vec2i0, mint_t i);
-mint_t *vec2i_snap(mint_t *result, mint_t *vec2i0, mint_t *vec2i1);
-mint_t *vec2i_snap_i(mint_t *result, mint_t *vec2i0, mint_t i);
-mint_t *vec2i_negative(mint_t *result, mint_t *vec2i0);
-mint_t *vec2i_abs(mint_t *result, mint_t *vec2i0);
-mint_t *vec2i_max(mint_t *result, mint_t *vec2i0, mint_t *vec2i1);
-mint_t *vec2i_min(mint_t *result, mint_t *vec2i0, mint_t *vec2i1);
-mint_t *vec2i_clamp(mint_t *result, mint_t *vec2i0, mint_t *vec2i1, mint_t *vec2i2);
-mint_t *vec2i_tangent(mint_t *result, mint_t *vec2i0);
-bool vec3i_is_zero(mint_t *vec3i0);
-bool vec3i_is_equal(mint_t *vec3i0, mint_t *vec3i1);
+mint_t *vec2i_sign(mint_t *result, mint_t *v0);
+mint_t *vec2i_add(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec2i_add_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec2i_subtract(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec2i_subtract_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec2i_multiply(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec2i_multiply_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec2i_divide(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec2i_divide_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec2i_snap(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec2i_snap_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec2i_negative(mint_t *result, mint_t *v0);
+mint_t *vec2i_abs(mint_t *result, mint_t *v0);
+mint_t *vec2i_max(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec2i_min(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec2i_clamp(mint_t *result, mint_t *v0, mint_t *v1, mint_t *v2);
+mint_t *vec2i_tangent(mint_t *result, mint_t *v0);
+bool vec3i_is_zero(mint_t *v0);
+bool vec3i_is_equal(mint_t *v0, mint_t *v1);
 mint_t *vec3i(mint_t *result, mint_t x, mint_t y, mint_t z);
-mint_t *vec3i_assign(mint_t *result, mint_t *vec3i0);
+mint_t *vec3i_assign(mint_t *result, mint_t *v0);
 #if defined(MATHC_USE_FLOATING_POINT)
-mint_t *vec3i_assign_vec3(mint_t *result, mfloat_t *vec30);
+mint_t *vec3i_assign_vec3(mint_t *result, mfloat_t *v0);
 #endif
 mint_t *vec3i_zero(mint_t *result);
 mint_t *vec3i_one(mint_t *result);
-mint_t *vec3i_sign(mint_t *result, mint_t *vec3i0);
-mint_t *vec3i_add(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
-mint_t *vec3i_add_i(mint_t *result, mint_t *vec3i0, mint_t i);
-mint_t *vec3i_subtract(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
-mint_t *vec3i_subtract_i(mint_t *result, mint_t *vec3i0, mint_t i);
-mint_t *vec3i_multiply(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
-mint_t *vec3i_multiply_i(mint_t *result, mint_t *vec3i0, mint_t i);
-mint_t *vec3i_divide(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
-mint_t *vec3i_divide_i(mint_t *result, mint_t *vec3i0, mint_t i);
-mint_t *vec3i_snap(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
-mint_t *vec3i_snap_i(mint_t *result, mint_t *vec3i0, mint_t i);
-mint_t *vec3i_cross(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
-mint_t *vec3i_negative(mint_t *result, mint_t *vec3i0);
-mint_t *vec3i_abs(mint_t *result, mint_t *vec3i0);
-mint_t *vec3i_max(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
-mint_t *vec3i_min(mint_t *result, mint_t *vec3i0, mint_t *vec3i1);
-mint_t *vec3i_clamp(mint_t *result, mint_t *vec3i0, mint_t *vec3i1, mint_t *vec3i2);
-bool vec4i_is_zero(mint_t *vec4i0);
-bool vec4i_is_equal(mint_t *vec4i0, mint_t *vec4i1);
+mint_t *vec3i_sign(mint_t *result, mint_t *v0);
+mint_t *vec3i_add(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec3i_add_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec3i_subtract(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec3i_subtract_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec3i_multiply(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec3i_multiply_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec3i_divide(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec3i_divide_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec3i_snap(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec3i_snap_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec3i_cross(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec3i_negative(mint_t *result, mint_t *v0);
+mint_t *vec3i_abs(mint_t *result, mint_t *v0);
+mint_t *vec3i_max(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec3i_min(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec3i_clamp(mint_t *result, mint_t *v0, mint_t *v1, mint_t *v2);
+bool vec4i_is_zero(mint_t *v0);
+bool vec4i_is_equal(mint_t *v0, mint_t *v1);
 mint_t *vec4i(mint_t *result, mint_t x, mint_t y, mint_t z, mint_t w);
-mint_t *vec4i_assign(mint_t *result, mint_t *vec4i0);
+mint_t *vec4i_assign(mint_t *result, mint_t *v0);
 #if defined(MATHC_USE_FLOATING_POINT)
-mint_t *vec4i_assign_vec4(mint_t *result, mfloat_t *vec40);
+mint_t *vec4i_assign_vec4(mint_t *result, mfloat_t *v0);
 #endif
 mint_t *vec4i_zero(mint_t *result);
 mint_t *vec4i_one(mint_t *result);
-mint_t *vec4i_sign(mint_t *result, mint_t *vec4i0);
-mint_t *vec4i_add(mint_t *result, mint_t *vec4i0, mint_t *vec4i1);
-mint_t *vec4i_add_i(mint_t *result, mint_t *vec4i0, mint_t i);
-mint_t *vec4i_subtract(mint_t *result, mint_t *vec4i0, mint_t *vec4i1);
-mint_t *vec4i_subtract_i(mint_t *result, mint_t *vec4i0, mint_t i);
-mint_t *vec4i_multiply(mint_t *result, mint_t *vec4i0, mint_t *vec4i1);
-mint_t *vec4i_multiply_i(mint_t *result, mint_t *vec4i0, mint_t i);
-mint_t *vec4i_divide(mint_t *result, mint_t *vec4i0, mint_t *vec4i1);
-mint_t *vec4i_divide_i(mint_t *result, mint_t *vec4i0, mint_t i);
-mint_t *vec4i_snap(mint_t *result, mint_t *vec4i0, mint_t *vec4i1);
-mint_t *vec4i_snap_i(mint_t *result, mint_t *vec4i0, mint_t i);
-mint_t *vec4i_negative(mint_t *result, mint_t *vec4i0);
-mint_t *vec4i_abs(mint_t *result, mint_t *vec4i0);
-mint_t *vec4i_max(mint_t *result, mint_t *vec4i0, mint_t *vec4i1);
-mint_t *vec4i_min(mint_t *result, mint_t *vec4i0, mint_t *vec4i1);
-mint_t *vec4i_clamp(mint_t *result, mint_t *vec4i0, mint_t *vec4i1, mint_t *vec4i2);
+mint_t *vec4i_sign(mint_t *result, mint_t *v0);
+mint_t *vec4i_add(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec4i_add_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec4i_subtract(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec4i_subtract_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec4i_multiply(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec4i_multiply_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec4i_divide(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec4i_divide_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec4i_snap(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec4i_snap_i(mint_t *result, mint_t *v0, mint_t i);
+mint_t *vec4i_negative(mint_t *result, mint_t *v0);
+mint_t *vec4i_abs(mint_t *result, mint_t *v0);
+mint_t *vec4i_max(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec4i_min(mint_t *result, mint_t *v0, mint_t *v1);
+mint_t *vec4i_clamp(mint_t *result, mint_t *v0, mint_t *v1, mint_t *v2);
 #endif
 #if defined(MATHC_USE_FLOATING_POINT)
-bool vec2_is_zero(mfloat_t *vec20);
-bool vec2_is_equal(mfloat_t *vec20, mfloat_t *vec21);
+bool vec2_is_zero(mfloat_t *v0);
+bool vec2_is_equal(mfloat_t *v0, mfloat_t *v1);
 mfloat_t *vec2(mfloat_t *result, mfloat_t x, mfloat_t y);
-mfloat_t *vec2_assign(mfloat_t *result, mfloat_t *vec20);
+mfloat_t *vec2_assign(mfloat_t *result, mfloat_t *v0);
 #if defined(MATHC_USE_INT)
-mfloat_t *vec2_assign_vec2i(mfloat_t *result, mint_t *vec2i0);
+mfloat_t *vec2_assign_vec2i(mfloat_t *result, mint_t *v0);
 #endif
 mfloat_t *vec2_zero(mfloat_t *result);
 mfloat_t *vec2_one(mfloat_t *result);
-mfloat_t *vec2_sign(mfloat_t *result, mfloat_t *vec20);
-mfloat_t *vec2_add(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
-mfloat_t *vec2_add_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f);
-mfloat_t *vec2_subtract(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
-mfloat_t *vec2_subtract_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f);
-mfloat_t *vec2_multiply(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
-mfloat_t *vec2_multiply_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f);
-mfloat_t *vec2_multiply_mat2(mfloat_t *result, mfloat_t *vec20, mfloat_t *mat20);
-mfloat_t *vec2_divide(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
-mfloat_t *vec2_divide_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f);
-mfloat_t *vec2_snap(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
-mfloat_t *vec2_snap_f(mfloat_t *result, mfloat_t *vec20, mfloat_t f);
-mfloat_t *vec2_negative(mfloat_t *result, mfloat_t *vec20);
-mfloat_t *vec2_abs(mfloat_t *result, mfloat_t *vec20);
-mfloat_t *vec2_floor(mfloat_t *result, mfloat_t *vec20);
-mfloat_t *vec2_ceil(mfloat_t *result, mfloat_t *vec20);
-mfloat_t *vec2_round(mfloat_t *result, mfloat_t *vec20);
-mfloat_t *vec2_max(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
-mfloat_t *vec2_min(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
-mfloat_t *vec2_clamp(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t *vec22);
-mfloat_t *vec2_normalize(mfloat_t *result, mfloat_t *vec20);
-mfloat_t vec2_dot(mfloat_t *vec20, mfloat_t *vec21);
-mfloat_t *vec2_project(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
-mfloat_t *vec2_slide(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
-mfloat_t *vec2_reflect(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21);
-mfloat_t *vec2_tangent(mfloat_t *result, mfloat_t *vec20);
-mfloat_t *vec2_rotate(mfloat_t *result, mfloat_t *vec20, mfloat_t f);
-mfloat_t *vec2_lerp(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t f);
-mfloat_t *vec2_bezier3(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t *vec22, mfloat_t f);
-mfloat_t *vec2_bezier4(mfloat_t *result, mfloat_t *vec20, mfloat_t *vec21, mfloat_t *vec22, mfloat_t *vec23, mfloat_t f);
-mfloat_t vec2_angle(mfloat_t *vec20);
-mfloat_t vec2_length(mfloat_t *vec20);
-mfloat_t vec2_length_squared(mfloat_t *vec20);
-mfloat_t vec2_distance(mfloat_t *vec20, mfloat_t *vec21);
-mfloat_t vec2_distance_squared(mfloat_t *vec20, mfloat_t *vec21);
-bool vec3_is_zero(mfloat_t *vec30);
-bool vec3_is_equal(mfloat_t *vec30, mfloat_t *vec31);
+mfloat_t *vec2_sign(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec2_add(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec2_add_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec2_subtract(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec2_subtract_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec2_multiply(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec2_multiply_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec2_multiply_mat2(mfloat_t *result, mfloat_t *v0, mfloat_t *m0);
+mfloat_t *vec2_divide(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec2_divide_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec2_snap(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec2_snap_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec2_negative(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec2_abs(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec2_floor(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec2_ceil(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec2_round(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec2_max(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec2_min(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec2_clamp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2);
+mfloat_t *vec2_normalize(mfloat_t *result, mfloat_t *v0);
+mfloat_t vec2_dot(mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec2_project(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec2_slide(mfloat_t *result, mfloat_t *v0, mfloat_t *normal);
+mfloat_t *vec2_reflect(mfloat_t *result, mfloat_t *v0, mfloat_t *normal);
+mfloat_t *vec2_tangent(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec2_rotate(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec2_lerp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t f);
+mfloat_t *vec2_bezier3(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2, mfloat_t f);
+mfloat_t *vec2_bezier4(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2, mfloat_t *v3, mfloat_t f);
+mfloat_t vec2_angle(mfloat_t *v0);
+mfloat_t vec2_length(mfloat_t *v0);
+mfloat_t vec2_length_squared(mfloat_t *v0);
+mfloat_t vec2_distance(mfloat_t *v0, mfloat_t *v1);
+mfloat_t vec2_distance_squared(mfloat_t *v0, mfloat_t *v1);
+bool vec3_is_zero(mfloat_t *v0);
+bool vec3_is_equal(mfloat_t *v0, mfloat_t *v1);
 mfloat_t *vec3(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z);
-mfloat_t *vec3_assign(mfloat_t *result, mfloat_t *vec30);
+mfloat_t *vec3_assign(mfloat_t *result, mfloat_t *v0);
 #if defined(MATHC_USE_INT)
-mfloat_t *vec3_assign_vec3i(mfloat_t *result, mint_t *vec3i0);
+mfloat_t *vec3_assign_vec3i(mfloat_t *result, mint_t *v0);
 #endif
 mfloat_t *vec3_zero(mfloat_t *result);
 mfloat_t *vec3_one(mfloat_t *result);
-mfloat_t *vec3_sign(mfloat_t *result, mfloat_t *vec30);
-mfloat_t *vec3_add(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
-mfloat_t *vec3_add_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f);
-mfloat_t *vec3_subtract(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
-mfloat_t *vec3_subtract_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f);
-mfloat_t *vec3_multiply(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
-mfloat_t *vec3_multiply_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f);
-mfloat_t *vec3_multiply_mat3(mfloat_t *result, mfloat_t *vec30, mfloat_t *mat30);
-mfloat_t *vec3_divide(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
-mfloat_t *vec3_divide_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f);
-mfloat_t *vec3_snap(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
-mfloat_t *vec3_snap_f(mfloat_t *result, mfloat_t *vec30, mfloat_t f);
-mfloat_t *vec3_negative(mfloat_t *result, mfloat_t *vec30);
-mfloat_t *vec3_abs(mfloat_t *result, mfloat_t *vec30);
-mfloat_t *vec3_floor(mfloat_t *result, mfloat_t *vec30);
-mfloat_t *vec3_ceil(mfloat_t *result, mfloat_t *vec30);
-mfloat_t *vec3_round(mfloat_t *result, mfloat_t *vec30);
-mfloat_t *vec3_max(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
-mfloat_t *vec3_min(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
-mfloat_t *vec3_clamp(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32);
-mfloat_t *vec3_cross(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
-mfloat_t *vec3_normalize(mfloat_t *result, mfloat_t *vec30);
-mfloat_t vec3_dot(mfloat_t *vec30, mfloat_t *vec31);
-mfloat_t *vec3_project(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
-mfloat_t *vec3_slide(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
-mfloat_t *vec3_reflect(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
-mfloat_t *vec3_lerp(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t f);
-mfloat_t *vec3_bezier3(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32, mfloat_t f);
-mfloat_t *vec3_bezier4(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32, mfloat_t *vec33, mfloat_t f);
-mfloat_t vec3_length(mfloat_t *vec30);
-mfloat_t vec3_length_squared(mfloat_t *vec30);
-mfloat_t vec3_distance(mfloat_t *vec30, mfloat_t *vec31);
-mfloat_t vec3_distance_squared(mfloat_t *vec30, mfloat_t *vec31);
-bool vec4_is_zero(mfloat_t *vec40);
-bool vec4_is_equal(mfloat_t *vec40, mfloat_t *vec41);
+mfloat_t *vec3_sign(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec3_add(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec3_add_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec3_subtract(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec3_subtract_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec3_multiply(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec3_multiply_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec3_multiply_mat3(mfloat_t *result, mfloat_t *v0, mfloat_t *m0);
+mfloat_t *vec3_divide(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec3_divide_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec3_snap(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec3_snap_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec3_negative(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec3_abs(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec3_floor(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec3_ceil(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec3_round(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec3_max(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec3_min(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec3_clamp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2);
+mfloat_t *vec3_cross(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec3_normalize(mfloat_t *result, mfloat_t *v0);
+mfloat_t vec3_dot(mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec3_project(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec3_slide(mfloat_t *result, mfloat_t *v0, mfloat_t *normal);
+mfloat_t *vec3_reflect(mfloat_t *result, mfloat_t *v0, mfloat_t *normal);
+mfloat_t *vec3_lerp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t f);
+mfloat_t *vec3_bezier3(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2, mfloat_t f);
+mfloat_t *vec3_bezier4(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2, mfloat_t *v3, mfloat_t f);
+mfloat_t vec3_length(mfloat_t *v0);
+mfloat_t vec3_length_squared(mfloat_t *v0);
+mfloat_t vec3_distance(mfloat_t *v0, mfloat_t *v1);
+mfloat_t vec3_distance_squared(mfloat_t *v0, mfloat_t *v1);
+bool vec4_is_zero(mfloat_t *v0);
+bool vec4_is_equal(mfloat_t *v0, mfloat_t *v1);
 mfloat_t *vec4(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);
-mfloat_t *vec4_assign(mfloat_t *result, mfloat_t *vec40);
+mfloat_t *vec4_assign(mfloat_t *result, mfloat_t *v0);
 #if defined(MATHC_USE_INT)
-mfloat_t *vec4_assign_vec4i(mfloat_t *result, mint_t *vec4i0);
+mfloat_t *vec4_assign_vec4i(mfloat_t *result, mint_t *v0);
 #endif
 mfloat_t *vec4_zero(mfloat_t *result);
 mfloat_t *vec4_one(mfloat_t *result);
-mfloat_t *vec4_sign(mfloat_t *result, mfloat_t *vec40);
-mfloat_t *vec4_add(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41);
-mfloat_t *vec4_add_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f);
-mfloat_t *vec4_subtract(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41);
-mfloat_t *vec4_subtract_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f);
-mfloat_t *vec4_multiply(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41);
-mfloat_t *vec4_multiply_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f);
-mfloat_t *vec4_multiply_mat4(mfloat_t *result, mfloat_t *vec40, mfloat_t *mat40);
-mfloat_t *vec4_divide(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41);
-mfloat_t *vec4_divide_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f);
-mfloat_t *vec4_snap(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41);
-mfloat_t *vec4_snap_f(mfloat_t *result, mfloat_t *vec40, mfloat_t f);
-mfloat_t *vec4_negative(mfloat_t *result, mfloat_t *vec40);
-mfloat_t *vec4_abs(mfloat_t *result, mfloat_t *vec40);
-mfloat_t *vec4_floor(mfloat_t *result, mfloat_t *vec40);
-mfloat_t *vec4_ceil(mfloat_t *result, mfloat_t *vec40);
-mfloat_t *vec4_round(mfloat_t *result, mfloat_t *vec40);
-mfloat_t *vec4_max(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41);
-mfloat_t *vec4_min(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41);
-mfloat_t *vec4_clamp(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41, mfloat_t *vec42);
-mfloat_t *vec4_normalize(mfloat_t *result, mfloat_t *vec40);
-mfloat_t *vec4_lerp(mfloat_t *result, mfloat_t *vec40, mfloat_t *vec41, mfloat_t f);
-bool quat_is_zero(mfloat_t *quat0);
-bool quat_is_equal(mfloat_t *quat0, mfloat_t *quat1);
+mfloat_t *vec4_sign(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec4_add(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec4_add_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec4_subtract(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec4_subtract_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec4_multiply(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec4_multiply_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec4_multiply_mat4(mfloat_t *result, mfloat_t *v0, mfloat_t *m0);
+mfloat_t *vec4_divide(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec4_divide_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec4_snap(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec4_snap_f(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *vec4_negative(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec4_abs(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec4_floor(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec4_ceil(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec4_round(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec4_max(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec4_min(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *vec4_clamp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2);
+mfloat_t *vec4_normalize(mfloat_t *result, mfloat_t *v0);
+mfloat_t *vec4_lerp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t f);
+bool quat_is_zero(mfloat_t *q0);
+bool quat_is_equal(mfloat_t *q0, mfloat_t *q1);
 mfloat_t *quat(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);
-mfloat_t *quat_assign(mfloat_t *result, mfloat_t *quat0);
+mfloat_t *quat_assign(mfloat_t *result, mfloat_t *q0);
 mfloat_t *quat_zero(mfloat_t *result);
 mfloat_t *quat_null(mfloat_t *result);
-mfloat_t *quat_multiply(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1);
-mfloat_t *quat_multiply_f(mfloat_t *result, mfloat_t *quat0, mfloat_t f);
-mfloat_t *quat_divide(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1);
-mfloat_t *quat_divide_f(mfloat_t *result, mfloat_t *quat0, mfloat_t f);
-mfloat_t *quat_negative(mfloat_t *result, mfloat_t *quat0);
-mfloat_t *quat_conjugate(mfloat_t *result, mfloat_t *quat0);
-mfloat_t *quat_inverse(mfloat_t *result, mfloat_t *quat0);
-mfloat_t *quat_normalize(mfloat_t *result, mfloat_t *quat0);
-mfloat_t quat_dot(mfloat_t *quat0, mfloat_t *quat1);
-mfloat_t *quat_power(mfloat_t *result, mfloat_t *quat0, mfloat_t exponent);
-mfloat_t *quat_from_axis_angle(mfloat_t *result, mfloat_t *vec30, mfloat_t angle);
-mfloat_t *quat_from_vec3(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31);
-mfloat_t *quat_from_mat4(mfloat_t *result, mfloat_t *mat40);
-mfloat_t *quat_lerp(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1, mfloat_t f);
-mfloat_t *quat_slerp(mfloat_t *result, mfloat_t *quat0, mfloat_t *quat1, mfloat_t f);
-mfloat_t quat_length(mfloat_t *quat0);
-mfloat_t quat_length_squared(mfloat_t *quat0);
-mfloat_t quat_angle(mfloat_t *quat0, mfloat_t *quat1);
+mfloat_t *quat_multiply(mfloat_t *result, mfloat_t *q0, mfloat_t *q1);
+mfloat_t *quat_multiply_f(mfloat_t *result, mfloat_t *q0, mfloat_t f);
+mfloat_t *quat_divide(mfloat_t *result, mfloat_t *q0, mfloat_t *q1);
+mfloat_t *quat_divide_f(mfloat_t *result, mfloat_t *q0, mfloat_t f);
+mfloat_t *quat_negative(mfloat_t *result, mfloat_t *q0);
+mfloat_t *quat_conjugate(mfloat_t *result, mfloat_t *q0);
+mfloat_t *quat_inverse(mfloat_t *result, mfloat_t *q0);
+mfloat_t *quat_normalize(mfloat_t *result, mfloat_t *q0);
+mfloat_t quat_dot(mfloat_t *q0, mfloat_t *q1);
+mfloat_t *quat_power(mfloat_t *result, mfloat_t *q0, mfloat_t exponent);
+mfloat_t *quat_from_axis_angle(mfloat_t *result, mfloat_t *v0, mfloat_t angle);
+mfloat_t *quat_from_vec3(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
+mfloat_t *quat_from_mat4(mfloat_t *result, mfloat_t *m0);
+mfloat_t *quat_lerp(mfloat_t *result, mfloat_t *q0, mfloat_t *q1, mfloat_t f);
+mfloat_t *quat_slerp(mfloat_t *result, mfloat_t *q0, mfloat_t *q1, mfloat_t f);
+mfloat_t quat_length(mfloat_t *q0);
+mfloat_t quat_length_squared(mfloat_t *q0);
+mfloat_t quat_angle(mfloat_t *q0, mfloat_t *q1);
 mfloat_t *mat2(mfloat_t *result, mfloat_t m11, mfloat_t m12, mfloat_t m21, mfloat_t m22);
 mfloat_t *mat2_zero(mfloat_t *result);
 mfloat_t *mat2_identity(mfloat_t *result);
-mfloat_t mat2_determinant(mfloat_t *mat20);
-mfloat_t *mat2_assign(mfloat_t *result, mfloat_t *mat20);
-mfloat_t *mat2_negative(mfloat_t *result, mfloat_t *mat20);
-mfloat_t *mat2_transpose(mfloat_t *result, mfloat_t *mat20);
-mfloat_t *mat2_cofactor(mfloat_t *result, mfloat_t *mat20);
-mfloat_t *mat2_adjugate(mfloat_t *result, mfloat_t *mat20);
-mfloat_t *mat2_multiply(mfloat_t *result, mfloat_t *mat20, mfloat_t *mat21);
-mfloat_t *mat2_multiply_f(mfloat_t *result, mfloat_t *mat20, mfloat_t f);
-mfloat_t *mat2_inverse(mfloat_t *result, mfloat_t *mat20);
-mfloat_t *mat2_scaling(mfloat_t *result, mfloat_t *vec20);
-mfloat_t *mat2_scale(mfloat_t *result, mfloat_t *mat20, mfloat_t *vec20);
+mfloat_t mat2_determinant(mfloat_t *m0);
+mfloat_t *mat2_assign(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat2_negative(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat2_transpose(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat2_cofactor(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat2_adjugate(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat2_multiply(mfloat_t *result, mfloat_t *m0, mfloat_t *m1);
+mfloat_t *mat2_multiply_f(mfloat_t *result, mfloat_t *m0, mfloat_t f);
+mfloat_t *mat2_inverse(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat2_scaling(mfloat_t *result, mfloat_t *v0);
+mfloat_t *mat2_scale(mfloat_t *result, mfloat_t *m0, mfloat_t *v0);
 mfloat_t *mat2_rotation_z(mfloat_t *result, mfloat_t f);
-mfloat_t *mat2_lerp(mfloat_t *result, mfloat_t *mat20, mfloat_t *mat21, mfloat_t f);
+mfloat_t *mat2_lerp(mfloat_t *result, mfloat_t *m0, mfloat_t *m1, mfloat_t f);
 mfloat_t *mat3(mfloat_t *result, mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m31, mfloat_t m32, mfloat_t m33);
 mfloat_t *mat3_zero(mfloat_t *result);
 mfloat_t *mat3_identity(mfloat_t *result);
-mfloat_t mat3_determinant(mfloat_t *mat30);
-mfloat_t *mat3_assign(mfloat_t *result, mfloat_t *mat30);
-mfloat_t *mat3_negative(mfloat_t *result, mfloat_t *mat30);
-mfloat_t *mat3_transpose(mfloat_t *result, mfloat_t *mat30);
-mfloat_t *mat3_cofactor(mfloat_t *result, mfloat_t *mat30);
-mfloat_t *mat3_multiply(mfloat_t *result, mfloat_t *mat30, mfloat_t *mat31);
-mfloat_t *mat3_multiply_f(mfloat_t *result, mfloat_t *mat30, mfloat_t f);
-mfloat_t *mat3_inverse(mfloat_t *result, mfloat_t *mat30);
-mfloat_t *mat3_scaling(mfloat_t *result, mfloat_t *vec30);
-mfloat_t *mat3_scale(mfloat_t *result, mfloat_t *mat30, mfloat_t *vec30);
+mfloat_t mat3_determinant(mfloat_t *m0);
+mfloat_t *mat3_assign(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat3_negative(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat3_transpose(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat3_cofactor(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat3_multiply(mfloat_t *result, mfloat_t *m0, mfloat_t *m1);
+mfloat_t *mat3_multiply_f(mfloat_t *result, mfloat_t *m0, mfloat_t f);
+mfloat_t *mat3_inverse(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat3_scaling(mfloat_t *result, mfloat_t *v0);
+mfloat_t *mat3_scale(mfloat_t *result, mfloat_t *m0, mfloat_t *v0);
 mfloat_t *mat3_rotation_x(mfloat_t *result, mfloat_t f);
 mfloat_t *mat3_rotation_y(mfloat_t *result, mfloat_t f);
 mfloat_t *mat3_rotation_z(mfloat_t *result, mfloat_t f);
-mfloat_t *mat3_rotation_axis(mfloat_t *result, mfloat_t *vec30, mfloat_t f);
-mfloat_t *mat3_rotation_quat(mfloat_t *result, mfloat_t *quat0);
-mfloat_t *mat3_lerp(mfloat_t *result, mfloat_t *mat30, mfloat_t *mat31, mfloat_t f);
+mfloat_t *mat3_rotation_axis(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *mat3_rotation_quat(mfloat_t *result, mfloat_t *q0);
+mfloat_t *mat3_lerp(mfloat_t *result, mfloat_t *m0, mfloat_t *m1, mfloat_t f);
 mfloat_t *mat4(mfloat_t *result, mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m14, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m24, mfloat_t m31, mfloat_t m32, mfloat_t m33, mfloat_t m34, mfloat_t m41, mfloat_t m42, mfloat_t m43, mfloat_t m44);
 mfloat_t *mat4_zero(mfloat_t *result);
 mfloat_t *mat4_identity(mfloat_t *result);
-mfloat_t mat4_determinant(mfloat_t *mat40);
-mfloat_t *mat4_assign(mfloat_t *result, mfloat_t *mat40);
-mfloat_t *mat4_negative(mfloat_t *result, mfloat_t *mat40);
-mfloat_t *mat4_transpose(mfloat_t *result, mfloat_t *mat40);
-mfloat_t *mat4_cofactor(mfloat_t *result, mfloat_t *mat40);
+mfloat_t mat4_determinant(mfloat_t *m0);
+mfloat_t *mat4_assign(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat4_negative(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat4_transpose(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat4_cofactor(mfloat_t *result, mfloat_t *m0);
 mfloat_t *mat4_rotation_x(mfloat_t *result, mfloat_t f);
 mfloat_t *mat4_rotation_y(mfloat_t *result, mfloat_t f);
 mfloat_t *mat4_rotation_z(mfloat_t *result, mfloat_t f);
-mfloat_t *mat4_rotation_axis(mfloat_t *result, mfloat_t *vec30, mfloat_t f);
-mfloat_t *mat4_rotation_quat(mfloat_t *result, mfloat_t *quat0);
-mfloat_t *mat4_translation(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30);
-mfloat_t *mat4_translate(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30);
-mfloat_t *mat4_scaling(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30);
-mfloat_t *mat4_scale(mfloat_t *result, mfloat_t *mat40, mfloat_t *vec30);
-mfloat_t *mat4_multiply(mfloat_t *result, mfloat_t *mat40, mfloat_t *mat41);
-mfloat_t *mat4_multiply_f(mfloat_t *result, mfloat_t *mat40, mfloat_t f);
-mfloat_t *mat4_inverse(mfloat_t *result, mfloat_t *mat40);
-mfloat_t *mat4_lerp(mfloat_t *result, mfloat_t *mat40, mfloat_t *mat41, mfloat_t f);
-mfloat_t *mat4_look_at(mfloat_t *result, mfloat_t *vec30, mfloat_t *vec31, mfloat_t *vec32);
+mfloat_t *mat4_rotation_axis(mfloat_t *result, mfloat_t *v0, mfloat_t f);
+mfloat_t *mat4_rotation_quat(mfloat_t *result, mfloat_t *q0);
+mfloat_t *mat4_translation(mfloat_t *result, mfloat_t *m0, mfloat_t *v0);
+mfloat_t *mat4_translate(mfloat_t *result, mfloat_t *m0, mfloat_t *v0);
+mfloat_t *mat4_scaling(mfloat_t *result, mfloat_t *m0, mfloat_t *v0);
+mfloat_t *mat4_scale(mfloat_t *result, mfloat_t *m0, mfloat_t *v0);
+mfloat_t *mat4_multiply(mfloat_t *result, mfloat_t *m0, mfloat_t *m1);
+mfloat_t *mat4_multiply_f(mfloat_t *result, mfloat_t *m0, mfloat_t f);
+mfloat_t *mat4_inverse(mfloat_t *result, mfloat_t *m0);
+mfloat_t *mat4_lerp(mfloat_t *result, mfloat_t *m0, mfloat_t *m1, mfloat_t f);
+mfloat_t *mat4_look_at(mfloat_t *result, mfloat_t *position, mfloat_t *target, mfloat_t *up);
 mfloat_t *mat4_ortho(mfloat_t *result, mfloat_t l, mfloat_t r, mfloat_t b, mfloat_t t, mfloat_t n, mfloat_t f);
 mfloat_t *mat4_perspective(mfloat_t *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n, mfloat_t f);
 mfloat_t *mat4_perspective_fov(mfloat_t *result, mfloat_t fov, mfloat_t w, mfloat_t h, mfloat_t n, mfloat_t f);
 mfloat_t *mat4_perspective_infinite(mfloat_t *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n);
 #endif
+
 #if defined(MATHC_USE_STRUCT_FUNCTIONS)
 #if defined(MATHC_USE_INT)
-bool svec2i_is_zero(struct vec2i vec2i0);
-bool svec2i_is_equal(struct vec2i vec2i0, struct vec2i vec2i1);
+bool svec2i_is_zero(struct vec2i v0);
+bool svec2i_is_equal(struct vec2i v0, struct vec2i v1);
 struct vec2i svec2i(mint_t x, mint_t y);
-struct vec2i svec2i_assign(struct vec2i vec2i0);
+struct vec2i svec2i_assign(struct vec2i v0);
 #if defined(MATHC_USE_FLOATING_POINT)
-struct vec2i svec2i_assign_vec2(struct vec2 vec20);
+struct vec2i svec2i_assign_vec2(struct vec2 v0);
 #endif
 struct vec2i svec2i_zero(void);
 struct vec2i svec2i_one(void);
-struct vec2i svec2i_sign(struct vec2i vec2i0);
-struct vec2i svec2i_add(struct vec2i vec2i0, struct vec2i vec2i1);
-struct vec2i svec2i_add_i(struct vec2i vec2i0, mint_t i);
-struct vec2i svec2i_subtract(struct vec2i vec2i0, struct vec2i vec2i1);
-struct vec2i svec2i_subtract_i(struct vec2i vec2i0, mint_t i);
-struct vec2i svec2i_multiply(struct vec2i vec2i0, struct vec2i vec2i1);
-struct vec2i svec2i_multiply_i(struct vec2i vec2i0, mint_t i);
-struct vec2i svec2i_divide(struct vec2i vec2i0, struct vec2i vec2i1);
-struct vec2i svec2i_divide_i(struct vec2i vec2i0, mint_t i);
-struct vec2i svec2i_snap(struct vec2i vec2i0, struct vec2i vec2i1);
-struct vec2i svec2i_snap_i(struct vec2i vec2i0, mint_t i);
-struct vec2i svec2i_negative(struct vec2i vec2i0);
-struct vec2i svec2i_abs(struct vec2i vec2i0);
-struct vec2i svec2i_max(struct vec2i vec2i0, struct vec2i vec2i1);
-struct vec2i svec2i_min(struct vec2i vec2i0, struct vec2i vec2i1);
-struct vec2i svec2i_clamp(struct vec2i vec2i0, struct vec2i vec2i1, struct vec2i vec2i2);
-struct vec2i svec2i_tangent(struct vec2i vec2i0);
-bool svec3i_is_zero(struct vec3i vec3i0);
-bool svec3i_is_equal(struct vec3i vec3i0, struct vec3i vec3i1);
+struct vec2i svec2i_sign(struct vec2i v0);
+struct vec2i svec2i_add(struct vec2i v0, struct vec2i v1);
+struct vec2i svec2i_add_i(struct vec2i v0, mint_t i);
+struct vec2i svec2i_subtract(struct vec2i v0, struct vec2i v1);
+struct vec2i svec2i_subtract_i(struct vec2i v0, mint_t i);
+struct vec2i svec2i_multiply(struct vec2i v0, struct vec2i v1);
+struct vec2i svec2i_multiply_i(struct vec2i v0, mint_t i);
+struct vec2i svec2i_divide(struct vec2i v0, struct vec2i v1);
+struct vec2i svec2i_divide_i(struct vec2i v0, mint_t i);
+struct vec2i svec2i_snap(struct vec2i v0, struct vec2i v1);
+struct vec2i svec2i_snap_i(struct vec2i v0, mint_t i);
+struct vec2i svec2i_negative(struct vec2i v0);
+struct vec2i svec2i_abs(struct vec2i v0);
+struct vec2i svec2i_max(struct vec2i v0, struct vec2i v1);
+struct vec2i svec2i_min(struct vec2i v0, struct vec2i v1);
+struct vec2i svec2i_clamp(struct vec2i v0, struct vec2i v1, struct vec2i v2);
+struct vec2i svec2i_tangent(struct vec2i v0);
+bool svec3i_is_zero(struct vec3i v0);
+bool svec3i_is_equal(struct vec3i v0, struct vec3i v1);
 struct vec3i svec3i(mint_t x, mint_t y, mint_t z);
-struct vec3i svec3i_assign(struct vec3i vec3i0);
+struct vec3i svec3i_assign(struct vec3i v0);
 #if defined(MATHC_USE_FLOATING_POINT)
-struct vec3i svec3i_assign_vec3(struct vec3 vec30);
+struct vec3i svec3i_assign_vec3(struct vec3 v0);
 #endif
 struct vec3i svec3i_zero(void);
 struct vec3i svec3i_one(void);
-struct vec3i svec3i_sign(struct vec3i vec3i0);
-struct vec3i svec3i_add(struct vec3i vec3i0, struct vec3i vec3i1);
-struct vec3i svec3i_add_i(struct vec3i vec3i0, mint_t i);
-struct vec3i svec3i_subtract(struct vec3i vec3i0, struct vec3i vec3i1);
-struct vec3i svec3i_subtract_i(struct vec3i vec3i0, mint_t i);
-struct vec3i svec3i_multiply(struct vec3i vec3i0, struct vec3i vec3i1);
-struct vec3i svec3i_multiply_i(struct vec3i vec3i0, mint_t i);
-struct vec3i svec3i_divide(struct vec3i vec3i0, struct vec3i vec3i1);
-struct vec3i svec3i_divide_i(struct vec3i vec3i0, mint_t i);
-struct vec3i svec3i_snap(struct vec3i vec3i0, struct vec3i vec3i1);
-struct vec3i svec3i_snap_i(struct vec3i vec3i0, mint_t i);
-struct vec3i svec3i_cross(struct vec3i vec3i0, struct vec3i vec3i1);
-struct vec3i svec3i_negative(struct vec3i vec3i0);
-struct vec3i svec3i_abs(struct vec3i vec3i0);
-struct vec3i svec3i_max(struct vec3i vec3i0, struct vec3i vec3i1);
-struct vec3i svec3i_min(struct vec3i vec3i0, struct vec3i vec3i1);
-struct vec3i svec3i_clamp(struct vec3i vec3i0, struct vec3i vec3i1, struct vec3i vec3i2);
-bool svec4i_is_zero(struct vec4i vec4i0);
-bool svec4i_is_equal(struct vec4i vec4i0, struct vec4i vec4i1);
+struct vec3i svec3i_sign(struct vec3i v0);
+struct vec3i svec3i_add(struct vec3i v0, struct vec3i v1);
+struct vec3i svec3i_add_i(struct vec3i v0, mint_t i);
+struct vec3i svec3i_subtract(struct vec3i v0, struct vec3i v1);
+struct vec3i svec3i_subtract_i(struct vec3i v0, mint_t i);
+struct vec3i svec3i_multiply(struct vec3i v0, struct vec3i v1);
+struct vec3i svec3i_multiply_i(struct vec3i v0, mint_t i);
+struct vec3i svec3i_divide(struct vec3i v0, struct vec3i v1);
+struct vec3i svec3i_divide_i(struct vec3i v0, mint_t i);
+struct vec3i svec3i_snap(struct vec3i v0, struct vec3i v1);
+struct vec3i svec3i_snap_i(struct vec3i v0, mint_t i);
+struct vec3i svec3i_cross(struct vec3i v0, struct vec3i v1);
+struct vec3i svec3i_negative(struct vec3i v0);
+struct vec3i svec3i_abs(struct vec3i v0);
+struct vec3i svec3i_max(struct vec3i v0, struct vec3i v1);
+struct vec3i svec3i_min(struct vec3i v0, struct vec3i v1);
+struct vec3i svec3i_clamp(struct vec3i v0, struct vec3i v1, struct vec3i v2);
+bool svec4i_is_zero(struct vec4i v0);
+bool svec4i_is_equal(struct vec4i v0, struct vec4i v1);
 struct vec4i svec4i(mint_t x, mint_t y, mint_t z, mint_t w);
-struct vec4i svec4i_assign(struct vec4i vec4i0);
+struct vec4i svec4i_assign(struct vec4i v0);
 #if defined(MATHC_USE_FLOATING_POINT)
-struct vec4i svec4i_assign_vec4(struct vec4 vec40);
+struct vec4i svec4i_assign_vec4(struct vec4 v0);
 #endif
 struct vec4i svec4i_zero(void);
 struct vec4i svec4i_one(void);
-struct vec4i svec4i_sign(struct vec4i vec4i0);
-struct vec4i svec4i_add(struct vec4i vec4i0, struct vec4i vec4i1);
-struct vec4i svec4i_add_i(struct vec4i vec4i0, mint_t i);
-struct vec4i svec4i_subtract(struct vec4i vec4i0, struct vec4i vec4i1);
-struct vec4i svec4i_subtract_i(struct vec4i vec4i0, mint_t i);
-struct vec4i svec4i_multiply(struct vec4i vec4i0, struct vec4i vec4i1);
-struct vec4i svec4i_multiply_i(struct vec4i vec4i0, mint_t i);
-struct vec4i svec4i_divide(struct vec4i vec4i0, struct vec4i vec4i1);
-struct vec4i svec4i_divide_i(struct vec4i vec4i0, mint_t i);
-struct vec4i svec4i_snap(struct vec4i vec4i0, struct vec4i vec4i1);
-struct vec4i svec4i_snap_i(struct vec4i vec4i0, mint_t i);
-struct vec4i svec4i_negative(struct vec4i vec4i0);
-struct vec4i svec4i_abs(struct vec4i vec4i0);
-struct vec4i svec4i_max(struct vec4i vec4i0, struct vec4i vec4i1);
-struct vec4i svec4i_min(struct vec4i vec4i0, struct vec4i vec4i1);
-struct vec4i svec4i_clamp(struct vec4i vec4i0, struct vec4i vec4i1, struct vec4i vec4i2);
+struct vec4i svec4i_sign(struct vec4i v0);
+struct vec4i svec4i_add(struct vec4i v0, struct vec4i v1);
+struct vec4i svec4i_add_i(struct vec4i v0, mint_t i);
+struct vec4i svec4i_subtract(struct vec4i v0, struct vec4i v1);
+struct vec4i svec4i_subtract_i(struct vec4i v0, mint_t i);
+struct vec4i svec4i_multiply(struct vec4i v0, struct vec4i v1);
+struct vec4i svec4i_multiply_i(struct vec4i v0, mint_t i);
+struct vec4i svec4i_divide(struct vec4i v0, struct vec4i v1);
+struct vec4i svec4i_divide_i(struct vec4i v0, mint_t i);
+struct vec4i svec4i_snap(struct vec4i v0, struct vec4i v1);
+struct vec4i svec4i_snap_i(struct vec4i v0, mint_t i);
+struct vec4i svec4i_negative(struct vec4i v0);
+struct vec4i svec4i_abs(struct vec4i v0);
+struct vec4i svec4i_max(struct vec4i v0, struct vec4i v1);
+struct vec4i svec4i_min(struct vec4i v0, struct vec4i v1);
+struct vec4i svec4i_clamp(struct vec4i v0, struct vec4i v1, struct vec4i v2);
 #endif
 #if defined(MATHC_USE_FLOATING_POINT)
-bool svec2_is_zero(struct vec2 vec20);
-bool svec2_is_equal(struct vec2 vec20, struct vec2 vec21);
+bool svec2_is_zero(struct vec2 v0);
+bool svec2_is_equal(struct vec2 v0, struct vec2 v1);
 struct vec2 svec2(mfloat_t x, mfloat_t y);
-struct vec2 svec2_assign(struct vec2 vec20);
+struct vec2 svec2_assign(struct vec2 v0);
 #if defined(MATHC_USE_INT)
-struct vec2 svec2_assign_vec2i(struct vec2i vec2i0);
+struct vec2 svec2_assign_vec2i(struct vec2i v0);
 #endif
 struct vec2 svec2_zero(void);
 struct vec2 svec2_one(void);
-struct vec2 svec2_sign(struct vec2 vec20);
-struct vec2 svec2_add(struct vec2 vec20, struct vec2 vec21);
-struct vec2 svec2_add_f(struct vec2 vec20, mfloat_t f);
-struct vec2 svec2_subtract(struct vec2 vec20, struct vec2 vec21);
-struct vec2 svec2_subtract_f(struct vec2 vec20, mfloat_t f);
-struct vec2 svec2_multiply(struct vec2 vec20, struct vec2 vec21);
-struct vec2 svec2_multiply_f(struct vec2 vec20, mfloat_t f);
-struct vec2 svec2_multiply_mat2(struct vec2 vec20, struct mat2 mat20);
-struct vec2 svec2_divide(struct vec2 vec20, struct vec2 vec21);
-struct vec2 svec2_divide_f(struct vec2 vec20, mfloat_t f);
-struct vec2 svec2_snap(struct vec2 vec20, struct vec2 vec21);
-struct vec2 svec2_snap_f(struct vec2 vec20, mfloat_t f);
-struct vec2 svec2_negative(struct vec2 vec20);
-struct vec2 svec2_abs(struct vec2 vec20);
-struct vec2 svec2_floor(struct vec2 vec20);
-struct vec2 svec2_ceil(struct vec2 vec20);
-struct vec2 svec2_round(struct vec2 vec20);
-struct vec2 svec2_max(struct vec2 vec20, struct vec2 vec21);
-struct vec2 svec2_min(struct vec2 vec20, struct vec2 vec21);
-struct vec2 svec2_clamp(struct vec2 vec20, struct vec2 vec21, struct vec2 vec22);
-struct vec2 svec2_normalize(struct vec2 vec20);
-mfloat_t svec2_dot(struct vec2 vec20, struct vec2 vec21);
-struct vec2 svec2_project(struct vec2 vec20, struct vec2 vec21);
-struct vec2 svec2_slide(struct vec2 vec20, struct vec2 vec21);
-struct vec2 svec2_reflect(struct vec2 vec20, struct vec2 vec21);
-struct vec2 svec2_tangent(struct vec2 vec20);
-struct vec2 svec2_rotate(struct vec2 vec20, mfloat_t f);
-struct vec2 svec2_lerp(struct vec2 vec20, struct vec2 vec21, mfloat_t f);
-struct vec2 svec2_bezier3(struct vec2 vec20, struct vec2 vec21, struct vec2 vec22, mfloat_t f);
-struct vec2 svec2_bezier4(struct vec2 vec20, struct vec2 vec21, struct vec2 vec22, struct vec2 vec23, mfloat_t f);
-mfloat_t svec2_angle(struct vec2 vec20);
-mfloat_t svec2_length(struct vec2 vec20);
-mfloat_t svec2_length_squared(struct vec2 vec20);
-mfloat_t svec2_distance(struct vec2 vec20, struct vec2 vec21);
-mfloat_t svec2_distance_squared(struct vec2 vec20, struct vec2 vec21);
-bool svec3_is_zero(struct vec3 vec30);
-bool svec3_is_equal(struct vec3 vec30, struct vec3 vec31);
+struct vec2 svec2_sign(struct vec2 v0);
+struct vec2 svec2_add(struct vec2 v0, struct vec2 v1);
+struct vec2 svec2_add_f(struct vec2 v0, mfloat_t f);
+struct vec2 svec2_subtract(struct vec2 v0, struct vec2 v1);
+struct vec2 svec2_subtract_f(struct vec2 v0, mfloat_t f);
+struct vec2 svec2_multiply(struct vec2 v0, struct vec2 v1);
+struct vec2 svec2_multiply_f(struct vec2 v0, mfloat_t f);
+struct vec2 svec2_multiply_mat2(struct vec2 v0, struct mat2 m0);
+struct vec2 svec2_divide(struct vec2 v0, struct vec2 v1);
+struct vec2 svec2_divide_f(struct vec2 v0, mfloat_t f);
+struct vec2 svec2_snap(struct vec2 v0, struct vec2 v1);
+struct vec2 svec2_snap_f(struct vec2 v0, mfloat_t f);
+struct vec2 svec2_negative(struct vec2 v0);
+struct vec2 svec2_abs(struct vec2 v0);
+struct vec2 svec2_floor(struct vec2 v0);
+struct vec2 svec2_ceil(struct vec2 v0);
+struct vec2 svec2_round(struct vec2 v0);
+struct vec2 svec2_max(struct vec2 v0, struct vec2 v1);
+struct vec2 svec2_min(struct vec2 v0, struct vec2 v1);
+struct vec2 svec2_clamp(struct vec2 v0, struct vec2 v1, struct vec2 v2);
+struct vec2 svec2_normalize(struct vec2 v0);
+mfloat_t svec2_dot(struct vec2 v0, struct vec2 v1);
+struct vec2 svec2_project(struct vec2 v0, struct vec2 v1);
+struct vec2 svec2_slide(struct vec2 v0, struct vec2 normal);
+struct vec2 svec2_reflect(struct vec2 v0, struct vec2 normal);
+struct vec2 svec2_tangent(struct vec2 v0);
+struct vec2 svec2_rotate(struct vec2 v0, mfloat_t f);
+struct vec2 svec2_lerp(struct vec2 v0, struct vec2 v1, mfloat_t f);
+struct vec2 svec2_bezier3(struct vec2 v0, struct vec2 v1, struct vec2 v2, mfloat_t f);
+struct vec2 svec2_bezier4(struct vec2 v0, struct vec2 v1, struct vec2 v2, struct vec2 v3, mfloat_t f);
+mfloat_t svec2_angle(struct vec2 v0);
+mfloat_t svec2_length(struct vec2 v0);
+mfloat_t svec2_length_squared(struct vec2 v0);
+mfloat_t svec2_distance(struct vec2 v0, struct vec2 v1);
+mfloat_t svec2_distance_squared(struct vec2 v0, struct vec2 v1);
+bool svec3_is_zero(struct vec3 v0);
+bool svec3_is_equal(struct vec3 v0, struct vec3 v1);
 struct vec3 svec3(mfloat_t x, mfloat_t y, mfloat_t z);
-struct vec3 svec3_assign(struct vec3 vec30);
+struct vec3 svec3_assign(struct vec3 v0);
 #if defined(MATHC_USE_INT)
-struct vec3 svec3_assign_vec3i(struct vec3i vec3i0);
+struct vec3 svec3_assign_vec3i(struct vec3i v0);
 #endif
 struct vec3 svec3_zero(void);
 struct vec3 svec3_one(void);
-struct vec3 svec3_sign(struct vec3 vec30);
-struct vec3 svec3_add(struct vec3 vec30, struct vec3 vec31);
-struct vec3 svec3_add_f(struct vec3 vec30, mfloat_t f);
-struct vec3 svec3_subtract(struct vec3 vec30, struct vec3 vec31);
-struct vec3 svec3_subtract_f(struct vec3 vec30, mfloat_t f);
-struct vec3 svec3_multiply(struct vec3 vec30, struct vec3 vec31);
-struct vec3 svec3_multiply_f(struct vec3 vec30, mfloat_t f);
-struct vec3 svec3_multiply_mat3(struct vec3 vec30, struct mat3 mat30);
-struct vec3 svec3_divide(struct vec3 vec30, struct vec3 vec31);
-struct vec3 svec3_divide_f(struct vec3 vec30, mfloat_t f);
-struct vec3 svec3_snap(struct vec3 vec30, struct vec3 vec31);
-struct vec3 svec3_snap_f(struct vec3 vec30, mfloat_t f);
-struct vec3 svec3_negative(struct vec3 vec30);
-struct vec3 svec3_abs(struct vec3 vec30);
-struct vec3 svec3_floor(struct vec3 vec30);
-struct vec3 svec3_ceil(struct vec3 vec30);
-struct vec3 svec3_round(struct vec3 vec30);
-struct vec3 svec3_max(struct vec3 vec30, struct vec3 vec31);
-struct vec3 svec3_min(struct vec3 vec30, struct vec3 vec31);
-struct vec3 svec3_clamp(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32);
-struct vec3 svec3_cross(struct vec3 vec30, struct vec3 vec31);
-struct vec3 svec3_normalize(struct vec3 vec30);
-mfloat_t svec3_dot(struct vec3 vec30, struct vec3 vec31);
-struct vec3 svec3_project(struct vec3 vec30, struct vec3 vec31);
-struct vec3 svec3_slide(struct vec3 vec30, struct vec3 vec31);
-struct vec3 svec3_reflect(struct vec3 vec30, struct vec3 vec31);
-struct vec3 svec3_lerp(struct vec3 vec30, struct vec3 vec31, mfloat_t f);
-struct vec3 svec3_bezier3(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32, mfloat_t f);
-struct vec3 svec3_bezier4(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32, struct vec3 vec33, mfloat_t f);
-mfloat_t svec3_length(struct vec3 vec30);
-mfloat_t svec3_length_squared(struct vec3 vec30);
-mfloat_t svec3_distance(struct vec3 vec30, struct vec3 vec31);
-mfloat_t svec3_distance_squared(struct vec3 vec30, struct vec3 vec31);
-bool svec4_is_zero(struct vec4 vec40);
-bool svec4_is_equal(struct vec4 vec40, struct vec4 vec41);
+struct vec3 svec3_sign(struct vec3 v0);
+struct vec3 svec3_add(struct vec3 v0, struct vec3 v1);
+struct vec3 svec3_add_f(struct vec3 v0, mfloat_t f);
+struct vec3 svec3_subtract(struct vec3 v0, struct vec3 v1);
+struct vec3 svec3_subtract_f(struct vec3 v0, mfloat_t f);
+struct vec3 svec3_multiply(struct vec3 v0, struct vec3 v1);
+struct vec3 svec3_multiply_f(struct vec3 v0, mfloat_t f);
+struct vec3 svec3_multiply_mat3(struct vec3 v0, struct mat3 m0);
+struct vec3 svec3_divide(struct vec3 v0, struct vec3 v1);
+struct vec3 svec3_divide_f(struct vec3 v0, mfloat_t f);
+struct vec3 svec3_snap(struct vec3 v0, struct vec3 v1);
+struct vec3 svec3_snap_f(struct vec3 v0, mfloat_t f);
+struct vec3 svec3_negative(struct vec3 v0);
+struct vec3 svec3_abs(struct vec3 v0);
+struct vec3 svec3_floor(struct vec3 v0);
+struct vec3 svec3_ceil(struct vec3 v0);
+struct vec3 svec3_round(struct vec3 v0);
+struct vec3 svec3_max(struct vec3 v0, struct vec3 v1);
+struct vec3 svec3_min(struct vec3 v0, struct vec3 v1);
+struct vec3 svec3_clamp(struct vec3 v0, struct vec3 v1, struct vec3 v2);
+struct vec3 svec3_cross(struct vec3 v0, struct vec3 v1);
+struct vec3 svec3_normalize(struct vec3 v0);
+mfloat_t svec3_dot(struct vec3 v0, struct vec3 v1);
+struct vec3 svec3_project(struct vec3 v0, struct vec3 v1);
+struct vec3 svec3_slide(struct vec3 v0, struct vec3 normal);
+struct vec3 svec3_reflect(struct vec3 v0, struct vec3 normal);
+struct vec3 svec3_lerp(struct vec3 v0, struct vec3 v1, mfloat_t f);
+struct vec3 svec3_bezier3(struct vec3 v0, struct vec3 v1, struct vec3 v2, mfloat_t f);
+struct vec3 svec3_bezier4(struct vec3 v0, struct vec3 v1, struct vec3 v2, struct vec3 v3, mfloat_t f);
+mfloat_t svec3_length(struct vec3 v0);
+mfloat_t svec3_length_squared(struct vec3 v0);
+mfloat_t svec3_distance(struct vec3 v0, struct vec3 v1);
+mfloat_t svec3_distance_squared(struct vec3 v0, struct vec3 v1);
+bool svec4_is_zero(struct vec4 v0);
+bool svec4_is_equal(struct vec4 v0, struct vec4 v1);
 struct vec4 svec4(mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);
-struct vec4 svec4_assign(struct vec4 vec40);
+struct vec4 svec4_assign(struct vec4 v0);
 #if defined(MATHC_USE_INT)
-struct vec4 svec4_assign_vec4i(struct vec4i vec4i0);
+struct vec4 svec4_assign_vec4i(struct vec4i v0);
 #endif
 struct vec4 svec4_zero(void);
 struct vec4 svec4_one(void);
-struct vec4 svec4_sign(struct vec4 vec40);
-struct vec4 svec4_add(struct vec4 vec40, struct vec4 vec41);
-struct vec4 svec4_add_f(struct vec4 vec40, mfloat_t f);
-struct vec4 svec4_subtract(struct vec4 vec40, struct vec4 vec41);
-struct vec4 svec4_subtract_f(struct vec4 vec40, mfloat_t f);
-struct vec4 svec4_multiply(struct vec4 vec40, struct vec4 vec41);
-struct vec4 svec4_multiply_f(struct vec4 vec40, mfloat_t f);
-struct vec4 svec4_multiply_mat4(struct vec4 vec40, struct mat4 mat40);
-struct vec4 svec4_divide(struct vec4 vec40, struct vec4 vec41);
-struct vec4 svec4_divide_f(struct vec4 vec40, mfloat_t f);
-struct vec4 svec4_snap(struct vec4 vec40, struct vec4 vec41);
-struct vec4 svec4_snap_f(struct vec4 vec40, mfloat_t f);
-struct vec4 svec4_negative(struct vec4 vec40);
-struct vec4 svec4_abs(struct vec4 vec40);
-struct vec4 svec4_floor(struct vec4 vec40);
-struct vec4 svec4_ceil(struct vec4 vec40);
-struct vec4 svec4_round(struct vec4 vec40);
-struct vec4 svec4_max(struct vec4 vec40, struct vec4 vec41);
-struct vec4 svec4_min(struct vec4 vec40, struct vec4 vec41);
-struct vec4 svec4_clamp(struct vec4 vec40, struct vec4 vec41, struct vec4 vec42);
-struct vec4 svec4_normalize(struct vec4 vec40);
-struct vec4 svec4_lerp(struct vec4 vec40, struct vec4 vec41, mfloat_t f);
-bool squat_is_zero(struct quat quat0);
-bool squat_is_equal(struct quat quat0, struct quat quat1);
+struct vec4 svec4_sign(struct vec4 v0);
+struct vec4 svec4_add(struct vec4 v0, struct vec4 v1);
+struct vec4 svec4_add_f(struct vec4 v0, mfloat_t f);
+struct vec4 svec4_subtract(struct vec4 v0, struct vec4 v1);
+struct vec4 svec4_subtract_f(struct vec4 v0, mfloat_t f);
+struct vec4 svec4_multiply(struct vec4 v0, struct vec4 v1);
+struct vec4 svec4_multiply_f(struct vec4 v0, mfloat_t f);
+struct vec4 svec4_multiply_mat4(struct vec4 v0, struct mat4 m0);
+struct vec4 svec4_divide(struct vec4 v0, struct vec4 v1);
+struct vec4 svec4_divide_f(struct vec4 v0, mfloat_t f);
+struct vec4 svec4_snap(struct vec4 v0, struct vec4 v1);
+struct vec4 svec4_snap_f(struct vec4 v0, mfloat_t f);
+struct vec4 svec4_negative(struct vec4 v0);
+struct vec4 svec4_abs(struct vec4 v0);
+struct vec4 svec4_floor(struct vec4 v0);
+struct vec4 svec4_ceil(struct vec4 v0);
+struct vec4 svec4_round(struct vec4 v0);
+struct vec4 svec4_max(struct vec4 v0, struct vec4 v1);
+struct vec4 svec4_min(struct vec4 v0, struct vec4 v1);
+struct vec4 svec4_clamp(struct vec4 v0, struct vec4 v1, struct vec4 v2);
+struct vec4 svec4_normalize(struct vec4 v0);
+struct vec4 svec4_lerp(struct vec4 v0, struct vec4 v1, mfloat_t f);
+bool squat_is_zero(struct quat q0);
+bool squat_is_equal(struct quat q0, struct quat q1);
 struct quat squat(mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);
-struct quat squat_assign(struct quat quat0);
+struct quat squat_assign(struct quat q0);
 struct quat squat_zero(void);
 struct quat squat_null(void);
-struct quat squat_multiply(struct quat quat0, struct quat quat1);
-struct quat squat_multiply_f(struct quat quat0, mfloat_t f);
-struct quat squat_divide(struct quat quat0, struct quat quat1);
-struct quat squat_divide_f(struct quat quat0, mfloat_t f);
-struct quat squat_negative(struct quat quat0);
-struct quat squat_conjugate(struct quat quat0);
-struct quat squat_inverse(struct quat quat0);
-struct quat squat_normalize(struct quat quat0);
-mfloat_t squat_dot(struct quat quat0, struct quat quat1);
-struct quat squat_power(struct quat quat0, mfloat_t exponent);
-struct quat squat_from_axis_angle(struct vec3 vec30, mfloat_t angle);
-struct quat squat_from_vec3(struct vec3 vec30, struct vec3 vec31);
-struct quat squat_from_mat4(struct mat4 mat40);
-struct quat squat_lerp(struct quat quat0, struct quat quat1, mfloat_t f);
-struct quat squat_slerp(struct quat quat0, struct quat quat1, mfloat_t f);
-mfloat_t squat_length(struct quat quat0);
-mfloat_t squat_length_squared(struct quat quat0);
-mfloat_t squat_angle(struct quat quat0, struct quat quat1);
+struct quat squat_multiply(struct quat q0, struct quat q1);
+struct quat squat_multiply_f(struct quat q0, mfloat_t f);
+struct quat squat_divide(struct quat q0, struct quat q1);
+struct quat squat_divide_f(struct quat q0, mfloat_t f);
+struct quat squat_negative(struct quat q0);
+struct quat squat_conjugate(struct quat q0);
+struct quat squat_inverse(struct quat q0);
+struct quat squat_normalize(struct quat q0);
+mfloat_t squat_dot(struct quat q0, struct quat q1);
+struct quat squat_power(struct quat q0, mfloat_t exponent);
+struct quat squat_from_axis_angle(struct vec3 v0, mfloat_t angle);
+struct quat squat_from_vec3(struct vec3 v0, struct vec3 v1);
+struct quat squat_from_mat4(struct mat4 m0);
+struct quat squat_lerp(struct quat q0, struct quat q1, mfloat_t f);
+struct quat squat_slerp(struct quat q0, struct quat q1, mfloat_t f);
+mfloat_t squat_length(struct quat q0);
+mfloat_t squat_length_squared(struct quat q0);
+mfloat_t squat_angle(struct quat q0, struct quat q1);
 struct mat2 smat2(mfloat_t m11, mfloat_t m12, mfloat_t m21, mfloat_t m22);
 struct mat2 smat2_zero(void);
 struct mat2 smat2_identity(void);
-mfloat_t smat2_determinant(struct mat2 mat20);
-struct mat2 smat2_assign(struct mat2 mat20);
-struct mat2 smat2_negative(struct mat2 mat20);
-struct mat2 smat2_transpose(struct mat2 mat20);
-struct mat2 smat2_cofactor(struct mat2 mat20);
-struct mat2 smat2_adjugate(struct mat2 mat20);
-struct mat2 smat2_multiply(struct mat2 mat20, struct mat2 mat21);
-struct mat2 smat2_multiply_f(struct mat2 mat20, mfloat_t f);
-struct mat2 smat2_inverse(struct mat2 mat20);
-struct mat2 smat2_scaling(struct vec2 vec20);
-struct mat2 smat2_scale(struct mat2 mat20, struct vec2 vec20);
+mfloat_t smat2_determinant(struct mat2 m0);
+struct mat2 smat2_assign(struct mat2 m0);
+struct mat2 smat2_negative(struct mat2 m0);
+struct mat2 smat2_transpose(struct mat2 m0);
+struct mat2 smat2_cofactor(struct mat2 m0);
+struct mat2 smat2_adjugate(struct mat2 m0);
+struct mat2 smat2_multiply(struct mat2 m0, struct mat2 m1);
+struct mat2 smat2_multiply_f(struct mat2 m0, mfloat_t f);
+struct mat2 smat2_inverse(struct mat2 m0);
+struct mat2 smat2_scaling(struct vec2 v0);
+struct mat2 smat2_scale(struct mat2 m0, struct vec2 v0);
 struct mat2 smat2_rotation_z(mfloat_t f);
-struct mat2 smat2_lerp(struct mat2 mat20, struct mat2 mat21, mfloat_t f);
+struct mat2 smat2_lerp(struct mat2 m0, struct mat2 m1, mfloat_t f);
 struct mat3 smat3(mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m31, mfloat_t m32, mfloat_t m33);
 struct mat3 smat3_zero(void);
 struct mat3 smat3_identity(void);
-mfloat_t smat3_determinant(struct mat3 mat30);
-struct mat3 smat3_assign(struct mat3 mat30);
-struct mat3 smat3_negative(struct mat3 mat30);
-struct mat3 smat3_transpose(struct mat3 mat30);
-struct mat3 smat3_cofactor(struct mat3 mat30);
-struct mat3 smat3_multiply(struct mat3 mat30, struct mat3 mat31);
-struct mat3 smat3_multiply_f(struct mat3 mat30, mfloat_t f);
-struct mat3 smat3_inverse(struct mat3 mat30);
-struct mat3 smat3_scaling(struct vec3 vec30);
-struct mat3 smat3_scale(struct mat3 mat30, struct vec3 vec30);
+mfloat_t smat3_determinant(struct mat3 m0);
+struct mat3 smat3_assign(struct mat3 m0);
+struct mat3 smat3_negative(struct mat3 m0);
+struct mat3 smat3_transpose(struct mat3 m0);
+struct mat3 smat3_cofactor(struct mat3 m0);
+struct mat3 smat3_multiply(struct mat3 m0, struct mat3 m1);
+struct mat3 smat3_multiply_f(struct mat3 m0, mfloat_t f);
+struct mat3 smat3_inverse(struct mat3 m0);
+struct mat3 smat3_scaling(struct vec3 v0);
+struct mat3 smat3_scale(struct mat3 m0, struct vec3 v0);
 struct mat3 smat3_rotation_x(mfloat_t f);
 struct mat3 smat3_rotation_y(mfloat_t f);
 struct mat3 smat3_rotation_z(mfloat_t f);
-struct mat3 smat3_rotation_axis(struct vec3 vec30, mfloat_t f);
-struct mat3 smat3_rotation_quat(struct quat quat0);
-struct mat3 smat3_lerp(struct mat3 mat30, struct mat3 mat31, mfloat_t f);
+struct mat3 smat3_rotation_axis(struct vec3 v0, mfloat_t f);
+struct mat3 smat3_rotation_quat(struct quat q0);
+struct mat3 smat3_lerp(struct mat3 m0, struct mat3 m1, mfloat_t f);
 struct mat4 smat4(mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m14, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m24, mfloat_t m31, mfloat_t m32, mfloat_t m33, mfloat_t m34, mfloat_t m41, mfloat_t m42, mfloat_t m43, mfloat_t m44);
 struct mat4 smat4_zero(void);
 struct mat4 smat4_identity(void);
-mfloat_t smat4_determinant(struct mat4 mat40);
-struct mat4 smat4_assign(struct mat4 mat40);
-struct mat4 smat4_negative(struct mat4 mat40);
-struct mat4 smat4_transpose(struct mat4 mat40);
-struct mat4 smat4_cofactor(struct mat4 mat40);
+mfloat_t smat4_determinant(struct mat4 m0);
+struct mat4 smat4_assign(struct mat4 m0);
+struct mat4 smat4_negative(struct mat4 m0);
+struct mat4 smat4_transpose(struct mat4 m0);
+struct mat4 smat4_cofactor(struct mat4 m0);
 struct mat4 smat4_rotation_x(mfloat_t f);
 struct mat4 smat4_rotation_y(mfloat_t f);
 struct mat4 smat4_rotation_z(mfloat_t f);
-struct mat4 smat4_rotation_axis(struct vec3 vec30, mfloat_t f);
-struct mat4 smat4_rotation_quat(struct quat quat0);
-struct mat4 smat4_translation(struct mat4 mat40, struct vec3 vec30);
-struct mat4 smat4_translate(struct mat4 mat40, struct vec3 vec30);
-struct mat4 smat4_scaling(struct mat4 mat40, struct vec3 vec30);
-struct mat4 smat4_scale(struct mat4 mat40, struct vec3 vec30);
-struct mat4 smat4_multiply(struct mat4 mat40, struct mat4 mat41);
-struct mat4 smat4_multiply_f(struct mat4 mat40, mfloat_t f);
-struct mat4 smat4_inverse(struct mat4 mat40);
-struct mat4 smat4_lerp(struct mat4 mat40, struct mat4 mat41, mfloat_t f);
-struct mat4 smat4_look_at(struct vec3 vec30, struct vec3 vec31, struct vec3 vec32);
+struct mat4 smat4_rotation_axis(struct vec3 v0, mfloat_t f);
+struct mat4 smat4_rotation_quat(struct quat q0);
+struct mat4 smat4_translation(struct mat4 m0, struct vec3 v0);
+struct mat4 smat4_translate(struct mat4 m0, struct vec3 v0);
+struct mat4 smat4_scaling(struct mat4 m0, struct vec3 v0);
+struct mat4 smat4_scale(struct mat4 m0, struct vec3 v0);
+struct mat4 smat4_multiply(struct mat4 m0, struct mat4 m1);
+struct mat4 smat4_multiply_f(struct mat4 m0, mfloat_t f);
+struct mat4 smat4_inverse(struct mat4 m0);
+struct mat4 smat4_lerp(struct mat4 m0, struct mat4 m1, mfloat_t f);
+struct mat4 smat4_look_at(struct vec3 position, struct vec3 target, struct vec3 up);
 struct mat4 smat4_ortho(mfloat_t l, mfloat_t r, mfloat_t b, mfloat_t t, mfloat_t n, mfloat_t f);
 struct mat4 smat4_perspective(mfloat_t fov_y, mfloat_t aspect, mfloat_t n, mfloat_t f);
 struct mat4 smat4_perspective_fov(mfloat_t fov, mfloat_t w, mfloat_t h, mfloat_t n, mfloat_t f);
 struct mat4 smat4_perspective_infinite(mfloat_t fov_y, mfloat_t aspect, mfloat_t n);
 #endif
 #endif
+
 #if defined(MATHC_USE_POINTER_STRUCT_FUNCTIONS)
 #if defined(MATHC_USE_INT)
-bool psvec2i_is_zero(struct vec2i *vec2i0);
-bool psvec2i_is_equal(struct vec2i *vec2i0, struct vec2i *vec2i1);
+bool psvec2i_is_zero(struct vec2i *v0);
+bool psvec2i_is_equal(struct vec2i *v0, struct vec2i *v1);
 struct vec2i *psvec2i(struct vec2i *result, mint_t x, mint_t y);
-struct vec2i *psvec2i_assign(struct vec2i *result, struct vec2i *vec2i0);
+struct vec2i *psvec2i_assign(struct vec2i *result, struct vec2i *v0);
 #if defined(MATHC_USE_FLOATING_POINT)
-struct vec2i *psvec2i_assign_vec2(struct vec2i *result, struct vec2 *vec20);
+struct vec2i *psvec2i_assign_vec2(struct vec2i *result, struct vec2 *v0);
 #endif
 struct vec2i *psvec2i_zero(struct vec2i *result);
 struct vec2i *psvec2i_one(struct vec2i *result);
-struct vec2i *psvec2i_sign(struct vec2i *result, struct vec2i *vec2i0);
-struct vec2i *psvec2i_add(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1);
-struct vec2i *psvec2i_add_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i);
-struct vec2i *psvec2i_subtract(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1);
-struct vec2i *psvec2i_subtract_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i);
-struct vec2i *psvec2i_multiply(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1);
-struct vec2i *psvec2i_multiply_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i);
-struct vec2i *psvec2i_divide(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1);
-struct vec2i *psvec2i_divide_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i);
-struct vec2i *psvec2i_snap(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1);
-struct vec2i *psvec2i_snap_i(struct vec2i *result, struct vec2i *vec2i0, mint_t i);
-struct vec2i *psvec2i_negative(struct vec2i *result, struct vec2i *vec2i0);
-struct vec2i *psvec2i_abs(struct vec2i *result, struct vec2i *vec2i0);
-struct vec2i *psvec2i_max(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1);
-struct vec2i *psvec2i_min(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1);
-struct vec2i *psvec2i_clamp(struct vec2i *result, struct vec2i *vec2i0, struct vec2i *vec2i1, struct vec2i *vec2i2);
-struct vec2i *psvec2i_tangent(struct vec2i *result, struct vec2i *vec2i0);
-bool psvec3i_is_zero(struct vec3i *vec3i0);
-bool psvec3i_is_equal(struct vec3i *vec3i0, struct vec3i *vec3i1);
+struct vec2i *psvec2i_sign(struct vec2i *result, struct vec2i *v0);
+struct vec2i *psvec2i_add(struct vec2i *result, struct vec2i *v0, struct vec2i *v1);
+struct vec2i *psvec2i_add_i(struct vec2i *result, struct vec2i *v0, mint_t i);
+struct vec2i *psvec2i_subtract(struct vec2i *result, struct vec2i *v0, struct vec2i *v1);
+struct vec2i *psvec2i_subtract_i(struct vec2i *result, struct vec2i *v0, mint_t i);
+struct vec2i *psvec2i_multiply(struct vec2i *result, struct vec2i *v0, struct vec2i *v1);
+struct vec2i *psvec2i_multiply_i(struct vec2i *result, struct vec2i *v0, mint_t i);
+struct vec2i *psvec2i_divide(struct vec2i *result, struct vec2i *v0, struct vec2i *v1);
+struct vec2i *psvec2i_divide_i(struct vec2i *result, struct vec2i *v0, mint_t i);
+struct vec2i *psvec2i_snap(struct vec2i *result, struct vec2i *v0, struct vec2i *v1);
+struct vec2i *psvec2i_snap_i(struct vec2i *result, struct vec2i *v0, mint_t i);
+struct vec2i *psvec2i_negative(struct vec2i *result, struct vec2i *v0);
+struct vec2i *psvec2i_abs(struct vec2i *result, struct vec2i *v0);
+struct vec2i *psvec2i_max(struct vec2i *result, struct vec2i *v0, struct vec2i *v1);
+struct vec2i *psvec2i_min(struct vec2i *result, struct vec2i *v0, struct vec2i *v1);
+struct vec2i *psvec2i_clamp(struct vec2i *result, struct vec2i *v0, struct vec2i *v1, struct vec2i *v2);
+struct vec2i *psvec2i_tangent(struct vec2i *result, struct vec2i *v0);
+bool psvec3i_is_zero(struct vec3i *v0);
+bool psvec3i_is_equal(struct vec3i *v0, struct vec3i *v1);
 struct vec3i *psvec3i(struct vec3i *result, mint_t x, mint_t y, mint_t z);
-struct vec3i *psvec3i_assign(struct vec3i *result, struct vec3i *vec3i0);
+struct vec3i *psvec3i_assign(struct vec3i *result, struct vec3i *v0);
 #if defined(MATHC_USE_FLOATING_POINT)
-struct vec3i *psvec3i_assign_vec3(struct vec3i *result, struct vec3 *vec30);
+struct vec3i *psvec3i_assign_vec3(struct vec3i *result, struct vec3 *v0);
 #endif
 struct vec3i *psvec3i_zero(struct vec3i *result);
 struct vec3i *psvec3i_one(struct vec3i *result);
-struct vec3i *psvec3i_sign(struct vec3i *result, struct vec3i *vec3i0);
-struct vec3i *psvec3i_add(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
-struct vec3i *psvec3i_add_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i);
-struct vec3i *psvec3i_subtract(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
-struct vec3i *psvec3i_subtract_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i);
-struct vec3i *psvec3i_multiply(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
-struct vec3i *psvec3i_multiply_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i);
-struct vec3i *psvec3i_divide(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
-struct vec3i *psvec3i_divide_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i);
-struct vec3i *psvec3i_snap(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
-struct vec3i *psvec3i_snap_i(struct vec3i *result, struct vec3i *vec3i0, mint_t i);
-struct vec3i *psvec3i_cross(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
-struct vec3i *psvec3i_negative(struct vec3i *result, struct vec3i *vec3i0);
-struct vec3i *psvec3i_abs(struct vec3i *result, struct vec3i *vec3i0);
-struct vec3i *psvec3i_max(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
-struct vec3i *psvec3i_min(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1);
-struct vec3i *psvec3i_clamp(struct vec3i *result, struct vec3i *vec3i0, struct vec3i *vec3i1, struct vec3i *vec3i2);
-bool psvec4i_is_zero(struct vec4i *vec4i0);
-bool psvec4i_is_equal(struct vec4i *vec4i0, struct vec4i *vec4i1);
+struct vec3i *psvec3i_sign(struct vec3i *result, struct vec3i *v0);
+struct vec3i *psvec3i_add(struct vec3i *result, struct vec3i *v0, struct vec3i *v1);
+struct vec3i *psvec3i_add_i(struct vec3i *result, struct vec3i *v0, mint_t i);
+struct vec3i *psvec3i_subtract(struct vec3i *result, struct vec3i *v0, struct vec3i *v1);
+struct vec3i *psvec3i_subtract_i(struct vec3i *result, struct vec3i *v0, mint_t i);
+struct vec3i *psvec3i_multiply(struct vec3i *result, struct vec3i *v0, struct vec3i *v1);
+struct vec3i *psvec3i_multiply_i(struct vec3i *result, struct vec3i *v0, mint_t i);
+struct vec3i *psvec3i_divide(struct vec3i *result, struct vec3i *v0, struct vec3i *v1);
+struct vec3i *psvec3i_divide_i(struct vec3i *result, struct vec3i *v0, mint_t i);
+struct vec3i *psvec3i_snap(struct vec3i *result, struct vec3i *v0, struct vec3i *v1);
+struct vec3i *psvec3i_snap_i(struct vec3i *result, struct vec3i *v0, mint_t i);
+struct vec3i *psvec3i_cross(struct vec3i *result, struct vec3i *v0, struct vec3i *v1);
+struct vec3i *psvec3i_negative(struct vec3i *result, struct vec3i *v0);
+struct vec3i *psvec3i_abs(struct vec3i *result, struct vec3i *v0);
+struct vec3i *psvec3i_max(struct vec3i *result, struct vec3i *v0, struct vec3i *v1);
+struct vec3i *psvec3i_min(struct vec3i *result, struct vec3i *v0, struct vec3i *v1);
+struct vec3i *psvec3i_clamp(struct vec3i *result, struct vec3i *v0, struct vec3i *v1, struct vec3i *v2);
+bool psvec4i_is_zero(struct vec4i *v0);
+bool psvec4i_is_equal(struct vec4i *v0, struct vec4i *v1);
 struct vec4i *psvec4i(struct vec4i *result, mint_t x, mint_t y, mint_t z, mint_t w);
-struct vec4i *psvec4i_assign(struct vec4i *result, struct vec4i *vec4i0);
+struct vec4i *psvec4i_assign(struct vec4i *result, struct vec4i *v0);
 #if defined(MATHC_USE_FLOATING_POINT)
-struct vec4i *psvec4i_assign_vec4(struct vec4i *result, struct vec4 *vec40);
+struct vec4i *psvec4i_assign_vec4(struct vec4i *result, struct vec4 *v0);
 #endif
 struct vec4i *psvec4i_zero(struct vec4i *result);
 struct vec4i *psvec4i_one(struct vec4i *result);
-struct vec4i *psvec4i_sign(struct vec4i *result, struct vec4i *vec4i0);
-struct vec4i *psvec4i_add(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1);
-struct vec4i *psvec4i_add_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i);
-struct vec4i *psvec4i_subtract(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1);
-struct vec4i *psvec4i_subtract_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i);
-struct vec4i *psvec4i_multiply(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1);
-struct vec4i *psvec4i_multiply_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i);
-struct vec4i *psvec4i_divide(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1);
-struct vec4i *psvec4i_divide_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i);
-struct vec4i *psvec4i_snap(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1);
-struct vec4i *psvec4i_snap_i(struct vec4i *result, struct vec4i *vec4i0, mint_t i);
-struct vec4i *psvec4i_negative(struct vec4i *result, struct vec4i *vec4i0);
-struct vec4i *psvec4i_abs(struct vec4i *result, struct vec4i *vec4i0);
-struct vec4i *psvec4i_max(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1);
-struct vec4i *psvec4i_min(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1);
-struct vec4i *psvec4i_clamp(struct vec4i *result, struct vec4i *vec4i0, struct vec4i *vec4i1, struct vec4i *vec4i2);
+struct vec4i *psvec4i_sign(struct vec4i *result, struct vec4i *v0);
+struct vec4i *psvec4i_add(struct vec4i *result, struct vec4i *v0, struct vec4i *v1);
+struct vec4i *psvec4i_add_i(struct vec4i *result, struct vec4i *v0, mint_t i);
+struct vec4i *psvec4i_subtract(struct vec4i *result, struct vec4i *v0, struct vec4i *v1);
+struct vec4i *psvec4i_subtract_i(struct vec4i *result, struct vec4i *v0, mint_t i);
+struct vec4i *psvec4i_multiply(struct vec4i *result, struct vec4i *v0, struct vec4i *v1);
+struct vec4i *psvec4i_multiply_i(struct vec4i *result, struct vec4i *v0, mint_t i);
+struct vec4i *psvec4i_divide(struct vec4i *result, struct vec4i *v0, struct vec4i *v1);
+struct vec4i *psvec4i_divide_i(struct vec4i *result, struct vec4i *v0, mint_t i);
+struct vec4i *psvec4i_snap(struct vec4i *result, struct vec4i *v0, struct vec4i *v1);
+struct vec4i *psvec4i_snap_i(struct vec4i *result, struct vec4i *v0, mint_t i);
+struct vec4i *psvec4i_negative(struct vec4i *result, struct vec4i *v0);
+struct vec4i *psvec4i_abs(struct vec4i *result, struct vec4i *v0);
+struct vec4i *psvec4i_max(struct vec4i *result, struct vec4i *v0, struct vec4i *v1);
+struct vec4i *psvec4i_min(struct vec4i *result, struct vec4i *v0, struct vec4i *v1);
+struct vec4i *psvec4i_clamp(struct vec4i *result, struct vec4i *v0, struct vec4i *v1, struct vec4i *v2);
 #endif
 #if defined(MATHC_USE_FLOATING_POINT)
-bool psvec2_is_zero(struct vec2 *vec20);
-bool psvec2_is_equal(struct vec2 *vec20, struct vec2 *vec21);
+bool psvec2_is_zero(struct vec2 *v0);
+bool psvec2_is_equal(struct vec2 *v0, struct vec2 *v1);
 struct vec2 *psvec2(struct vec2 *result, mfloat_t x, mfloat_t y);
-struct vec2 *psvec2_assign(struct vec2 *result, struct vec2 *vec20);
+struct vec2 *psvec2_assign(struct vec2 *result, struct vec2 *v0);
 #if defined(MATHC_USE_INT)
-struct vec2 *psvec2_assign_vec2i(struct vec2 *result, struct vec2i *vec2i0);
+struct vec2 *psvec2_assign_vec2i(struct vec2 *result, struct vec2i *v0);
 #endif
 struct vec2 *psvec2_zero(struct vec2 *result);
 struct vec2 *psvec2_one(struct vec2 *result);
-struct vec2 *psvec2_sign(struct vec2 *result, struct vec2 *vec20);
-struct vec2 *psvec2_add(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
-struct vec2 *psvec2_add_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f);
-struct vec2 *psvec2_subtract(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
-struct vec2 *psvec2_subtract_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f);
-struct vec2 *psvec2_multiply(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
-struct vec2 *psvec2_multiply_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f);
-struct vec2 *psvec2_multiply_mat2(struct vec2 *result, struct vec2 *vec20, struct mat2 *mat20);
-struct vec2 *psvec2_divide(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
-struct vec2 *psvec2_divide_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f);
-struct vec2 *psvec2_snap(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
-struct vec2 *psvec2_snap_f(struct vec2 *result, struct vec2 *vec20, mfloat_t f);
-struct vec2 *psvec2_negative(struct vec2 *result, struct vec2 *vec20);
-struct vec2 *psvec2_abs(struct vec2 *result, struct vec2 *vec20);
-struct vec2 *psvec2_floor(struct vec2 *result, struct vec2 *vec20);
-struct vec2 *psvec2_ceil(struct vec2 *result, struct vec2 *vec20);
-struct vec2 *psvec2_round(struct vec2 *result, struct vec2 *vec20);
-struct vec2 *psvec2_max(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
-struct vec2 *psvec2_min(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
-struct vec2 *psvec2_clamp(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, struct vec2 *vec22);
-struct vec2 *psvec2_normalize(struct vec2 *result, struct vec2 *vec20);
-mfloat_t psvec2_dot(struct vec2 *vec20, struct vec2 *vec21);
-struct vec2 *psvec2_project(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
-struct vec2 *psvec2_slide(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
-struct vec2 *psvec2_reflect(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21);
-struct vec2 *psvec2_tangent(struct vec2 *result, struct vec2 *vec20);
-struct vec2 *psvec2_rotate(struct vec2 *result, struct vec2 *vec20, mfloat_t f);
-struct vec2 *psvec2_lerp(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, mfloat_t f);
-struct vec2 *psvec2_bezier3(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, struct vec2 *vec22, mfloat_t f);
-struct vec2 *psvec2_bezier4(struct vec2 *result, struct vec2 *vec20, struct vec2 *vec21, struct vec2 *vec22, struct vec2 *vec23, mfloat_t f);
-mfloat_t psvec2_angle(struct vec2 *vec20);
-mfloat_t psvec2_length(struct vec2 *vec20);
-mfloat_t psvec2_length_squared(struct vec2 *vec20);
-mfloat_t psvec2_distance(struct vec2 *vec20, struct vec2 *vec21);
-mfloat_t psvec2_distance_squared(struct vec2 *vec20, struct vec2 *vec21);
-bool psvec3_is_zero(struct vec3 *vec30);
-bool psvec3_is_equal(struct vec3 *vec30, struct vec3 *vec31);
+struct vec2 *psvec2_sign(struct vec2 *result, struct vec2 *v0);
+struct vec2 *psvec2_add(struct vec2 *result, struct vec2 *v0, struct vec2 *v1);
+struct vec2 *psvec2_add_f(struct vec2 *result, struct vec2 *v0, mfloat_t f);
+struct vec2 *psvec2_subtract(struct vec2 *result, struct vec2 *v0, struct vec2 *v1);
+struct vec2 *psvec2_subtract_f(struct vec2 *result, struct vec2 *v0, mfloat_t f);
+struct vec2 *psvec2_multiply(struct vec2 *result, struct vec2 *v0, struct vec2 *v1);
+struct vec2 *psvec2_multiply_f(struct vec2 *result, struct vec2 *v0, mfloat_t f);
+struct vec2 *psvec2_multiply_mat2(struct vec2 *result, struct vec2 *v0, struct mat2 *m0);
+struct vec2 *psvec2_divide(struct vec2 *result, struct vec2 *v0, struct vec2 *v1);
+struct vec2 *psvec2_divide_f(struct vec2 *result, struct vec2 *v0, mfloat_t f);
+struct vec2 *psvec2_snap(struct vec2 *result, struct vec2 *v0, struct vec2 *v1);
+struct vec2 *psvec2_snap_f(struct vec2 *result, struct vec2 *v0, mfloat_t f);
+struct vec2 *psvec2_negative(struct vec2 *result, struct vec2 *v0);
+struct vec2 *psvec2_abs(struct vec2 *result, struct vec2 *v0);
+struct vec2 *psvec2_floor(struct vec2 *result, struct vec2 *v0);
+struct vec2 *psvec2_ceil(struct vec2 *result, struct vec2 *v0);
+struct vec2 *psvec2_round(struct vec2 *result, struct vec2 *v0);
+struct vec2 *psvec2_max(struct vec2 *result, struct vec2 *v0, struct vec2 *v1);
+struct vec2 *psvec2_min(struct vec2 *result, struct vec2 *v0, struct vec2 *v1);
+struct vec2 *psvec2_clamp(struct vec2 *result, struct vec2 *v0, struct vec2 *v1, struct vec2 *v2);
+struct vec2 *psvec2_normalize(struct vec2 *result, struct vec2 *v0);
+mfloat_t psvec2_dot(struct vec2 *v0, struct vec2 *v1);
+struct vec2 *psvec2_project(struct vec2 *result, struct vec2 *v0, struct vec2 *v1);
+struct vec2 *psvec2_slide(struct vec2 *result, struct vec2 *v0, struct vec2 *normal);
+struct vec2 *psvec2_reflect(struct vec2 *result, struct vec2 *v0, struct vec2 *normal);
+struct vec2 *psvec2_tangent(struct vec2 *result, struct vec2 *v0);
+struct vec2 *psvec2_rotate(struct vec2 *result, struct vec2 *v0, mfloat_t f);
+struct vec2 *psvec2_lerp(struct vec2 *result, struct vec2 *v0, struct vec2 *v1, mfloat_t f);
+struct vec2 *psvec2_bezier3(struct vec2 *result, struct vec2 *v0, struct vec2 *v1, struct vec2 *v2, mfloat_t f);
+struct vec2 *psvec2_bezier4(struct vec2 *result, struct vec2 *v0, struct vec2 *v1, struct vec2 *v2, struct vec2 *v3, mfloat_t f);
+mfloat_t psvec2_angle(struct vec2 *v0);
+mfloat_t psvec2_length(struct vec2 *v0);
+mfloat_t psvec2_length_squared(struct vec2 *v0);
+mfloat_t psvec2_distance(struct vec2 *v0, struct vec2 *v1);
+mfloat_t psvec2_distance_squared(struct vec2 *v0, struct vec2 *v1);
+bool psvec3_is_zero(struct vec3 *v0);
+bool psvec3_is_equal(struct vec3 *v0, struct vec3 *v1);
 struct vec3 *psvec3(struct vec3 *result, mfloat_t x, mfloat_t y, mfloat_t z);
-struct vec3 *psvec3_assign(struct vec3 *result, struct vec3 *vec30);
+struct vec3 *psvec3_assign(struct vec3 *result, struct vec3 *v0);
 #if defined(MATHC_USE_INT)
-struct vec3 *psvec3_assign_vec3i(struct vec3 *result, struct vec3i *vec3i0);
+struct vec3 *psvec3_assign_vec3i(struct vec3 *result, struct vec3i *v0);
 #endif
 struct vec3 *psvec3_zero(struct vec3 *result);
 struct vec3 *psvec3_one(struct vec3 *result);
-struct vec3 *psvec3_sign(struct vec3 *result, struct vec3 *vec30);
-struct vec3 *psvec3_add(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
-struct vec3 *psvec3_add_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f);
-struct vec3 *psvec3_subtract(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
-struct vec3 *psvec3_subtract_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f);
-struct vec3 *psvec3_multiply(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
-struct vec3 *psvec3_multiply_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f);
-struct vec3 *psvec3_multiply_mat3(struct vec3 *result, struct vec3 *vec30, struct mat3 *mat30);
-struct vec3 *psvec3_divide(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
-struct vec3 *psvec3_divide_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f);
-struct vec3 *psvec3_snap(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
-struct vec3 *psvec3_snap_f(struct vec3 *result, struct vec3 *vec30, mfloat_t f);
-struct vec3 *psvec3_negative(struct vec3 *result, struct vec3 *vec30);
-struct vec3 *psvec3_abs(struct vec3 *result, struct vec3 *vec30);
-struct vec3 *psvec3_floor(struct vec3 *result, struct vec3 *vec30);
-struct vec3 *psvec3_ceil(struct vec3 *result, struct vec3 *vec30);
-struct vec3 *psvec3_round(struct vec3 *result, struct vec3 *vec30);
-struct vec3 *psvec3_max(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
-struct vec3 *psvec3_min(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
-struct vec3 *psvec3_clamp(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32);
-struct vec3 *psvec3_cross(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
-struct vec3 *psvec3_normalize(struct vec3 *result, struct vec3 *vec30);
-mfloat_t psvec3_dot(struct vec3 *vec30, struct vec3 *vec31);
-struct vec3 *psvec3_project(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
-struct vec3 *psvec3_slide(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
-struct vec3 *psvec3_reflect(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31);
-struct vec3 *psvec3_lerp(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, mfloat_t f);
-struct vec3 *psvec3_bezier3(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32, mfloat_t f);
-struct vec3 *psvec3_bezier4(struct vec3 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32, struct vec3 *vec33, mfloat_t f);
-mfloat_t psvec3_length(struct vec3 *vec30);
-mfloat_t psvec3_length_squared(struct vec3 *vec30);
-mfloat_t psvec3_distance(struct vec3 *vec30, struct vec3 *vec31);
-mfloat_t psvec3_distance_squared(struct vec3 *vec30, struct vec3 *vec31);
-bool psvec4_is_zero(struct vec4 *vec40);
-bool psvec4_is_equal(struct vec4 *vec40, struct vec4 *vec41);
+struct vec3 *psvec3_sign(struct vec3 *result, struct vec3 *v0);
+struct vec3 *psvec3_add(struct vec3 *result, struct vec3 *v0, struct vec3 *v1);
+struct vec3 *psvec3_add_f(struct vec3 *result, struct vec3 *v0, mfloat_t f);
+struct vec3 *psvec3_subtract(struct vec3 *result, struct vec3 *v0, struct vec3 *v1);
+struct vec3 *psvec3_subtract_f(struct vec3 *result, struct vec3 *v0, mfloat_t f);
+struct vec3 *psvec3_multiply(struct vec3 *result, struct vec3 *v0, struct vec3 *v1);
+struct vec3 *psvec3_multiply_f(struct vec3 *result, struct vec3 *v0, mfloat_t f);
+struct vec3 *psvec3_multiply_mat3(struct vec3 *result, struct vec3 *v0, struct mat3 *m0);
+struct vec3 *psvec3_divide(struct vec3 *result, struct vec3 *v0, struct vec3 *v1);
+struct vec3 *psvec3_divide_f(struct vec3 *result, struct vec3 *v0, mfloat_t f);
+struct vec3 *psvec3_snap(struct vec3 *result, struct vec3 *v0, struct vec3 *v1);
+struct vec3 *psvec3_snap_f(struct vec3 *result, struct vec3 *v0, mfloat_t f);
+struct vec3 *psvec3_negative(struct vec3 *result, struct vec3 *v0);
+struct vec3 *psvec3_abs(struct vec3 *result, struct vec3 *v0);
+struct vec3 *psvec3_floor(struct vec3 *result, struct vec3 *v0);
+struct vec3 *psvec3_ceil(struct vec3 *result, struct vec3 *v0);
+struct vec3 *psvec3_round(struct vec3 *result, struct vec3 *v0);
+struct vec3 *psvec3_max(struct vec3 *result, struct vec3 *v0, struct vec3 *v1);
+struct vec3 *psvec3_min(struct vec3 *result, struct vec3 *v0, struct vec3 *v1);
+struct vec3 *psvec3_clamp(struct vec3 *result, struct vec3 *v0, struct vec3 *v1, struct vec3 *v2);
+struct vec3 *psvec3_cross(struct vec3 *result, struct vec3 *v0, struct vec3 *v1);
+struct vec3 *psvec3_normalize(struct vec3 *result, struct vec3 *v0);
+mfloat_t psvec3_dot(struct vec3 *v0, struct vec3 *v1);
+struct vec3 *psvec3_project(struct vec3 *result, struct vec3 *v0, struct vec3 *v1);
+struct vec3 *psvec3_slide(struct vec3 *result, struct vec3 *v0, struct vec3 *normal);
+struct vec3 *psvec3_reflect(struct vec3 *result, struct vec3 *v0, struct vec3 *normal);
+struct vec3 *psvec3_lerp(struct vec3 *result, struct vec3 *v0, struct vec3 *v1, mfloat_t f);
+struct vec3 *psvec3_bezier3(struct vec3 *result, struct vec3 *v0, struct vec3 *v1, struct vec3 *v2, mfloat_t f);
+struct vec3 *psvec3_bezier4(struct vec3 *result, struct vec3 *v0, struct vec3 *v1, struct vec3 *v2, struct vec3 *v3, mfloat_t f);
+mfloat_t psvec3_length(struct vec3 *v0);
+mfloat_t psvec3_length_squared(struct vec3 *v0);
+mfloat_t psvec3_distance(struct vec3 *v0, struct vec3 *v1);
+mfloat_t psvec3_distance_squared(struct vec3 *v0, struct vec3 *v1);
+bool psvec4_is_zero(struct vec4 *v0);
+bool psvec4_is_equal(struct vec4 *v0, struct vec4 *v1);
 struct vec4 *psvec4(struct vec4 *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);
-struct vec4 *psvec4_assign(struct vec4 *result, struct vec4 *vec40);
+struct vec4 *psvec4_assign(struct vec4 *result, struct vec4 *v0);
 #if defined(MATHC_USE_INT)
-struct vec4 *psvec4_assign_vec4i(struct vec4 *result, struct vec4i *vec4i0);
+struct vec4 *psvec4_assign_vec4i(struct vec4 *result, struct vec4i *v0);
 #endif
 struct vec4 *psvec4_zero(struct vec4 *result);
 struct vec4 *psvec4_one(struct vec4 *result);
-struct vec4 *psvec4_sign(struct vec4 *result, struct vec4 *vec40);
-struct vec4 *psvec4_add(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41);
-struct vec4 *psvec4_add_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f);
-struct vec4 *psvec4_subtract(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41);
-struct vec4 *psvec4_subtract_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f);
-struct vec4 *psvec4_multiply(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41);
-struct vec4 *psvec4_multiply_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f);
-struct vec4 *psvec4_multiply_mat4(struct vec4 *result, struct vec4 *vec40, struct mat4 *mat40);
-struct vec4 *psvec4_divide(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41);
-struct vec4 *psvec4_divide_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f);
-struct vec4 *psvec4_snap(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41);
-struct vec4 *psvec4_snap_f(struct vec4 *result, struct vec4 *vec40, mfloat_t f);
-struct vec4 *psvec4_negative(struct vec4 *result, struct vec4 *vec40);
-struct vec4 *psvec4_abs(struct vec4 *result, struct vec4 *vec40);
-struct vec4 *psvec4_floor(struct vec4 *result, struct vec4 *vec40);
-struct vec4 *psvec4_ceil(struct vec4 *result, struct vec4 *vec40);
-struct vec4 *psvec4_round(struct vec4 *result, struct vec4 *vec40);
-struct vec4 *psvec4_max(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41);
-struct vec4 *psvec4_min(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41);
-struct vec4 *psvec4_clamp(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41, struct vec4 *vec42);
-struct vec4 *psvec4_normalize(struct vec4 *result, struct vec4 *vec40);
-struct vec4 *psvec4_lerp(struct vec4 *result, struct vec4 *vec40, struct vec4 *vec41, mfloat_t f);
-bool psquat_is_zero(struct quat *quat0);
-bool psquat_is_equal(struct quat *quat0, struct quat *quat1);
+struct vec4 *psvec4_sign(struct vec4 *result, struct vec4 *v0);
+struct vec4 *psvec4_add(struct vec4 *result, struct vec4 *v0, struct vec4 *v1);
+struct vec4 *psvec4_add_f(struct vec4 *result, struct vec4 *v0, mfloat_t f);
+struct vec4 *psvec4_subtract(struct vec4 *result, struct vec4 *v0, struct vec4 *v1);
+struct vec4 *psvec4_subtract_f(struct vec4 *result, struct vec4 *v0, mfloat_t f);
+struct vec4 *psvec4_multiply(struct vec4 *result, struct vec4 *v0, struct vec4 *v1);
+struct vec4 *psvec4_multiply_f(struct vec4 *result, struct vec4 *v0, mfloat_t f);
+struct vec4 *psvec4_multiply_mat4(struct vec4 *result, struct vec4 *v0, struct mat4 *m0);
+struct vec4 *psvec4_divide(struct vec4 *result, struct vec4 *v0, struct vec4 *v1);
+struct vec4 *psvec4_divide_f(struct vec4 *result, struct vec4 *v0, mfloat_t f);
+struct vec4 *psvec4_snap(struct vec4 *result, struct vec4 *v0, struct vec4 *v1);
+struct vec4 *psvec4_snap_f(struct vec4 *result, struct vec4 *v0, mfloat_t f);
+struct vec4 *psvec4_negative(struct vec4 *result, struct vec4 *v0);
+struct vec4 *psvec4_abs(struct vec4 *result, struct vec4 *v0);
+struct vec4 *psvec4_floor(struct vec4 *result, struct vec4 *v0);
+struct vec4 *psvec4_ceil(struct vec4 *result, struct vec4 *v0);
+struct vec4 *psvec4_round(struct vec4 *result, struct vec4 *v0);
+struct vec4 *psvec4_max(struct vec4 *result, struct vec4 *v0, struct vec4 *v1);
+struct vec4 *psvec4_min(struct vec4 *result, struct vec4 *v0, struct vec4 *v1);
+struct vec4 *psvec4_clamp(struct vec4 *result, struct vec4 *v0, struct vec4 *v1, struct vec4 *v2);
+struct vec4 *psvec4_normalize(struct vec4 *result, struct vec4 *v0);
+struct vec4 *psvec4_lerp(struct vec4 *result, struct vec4 *v0, struct vec4 *v1, mfloat_t f);
+bool psquat_is_zero(struct quat *q0);
+bool psquat_is_equal(struct quat *q0, struct quat *q1);
 struct quat *psquat(struct quat *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);
-struct quat *psquat_assign(struct quat *result, struct quat *quat0);
+struct quat *psquat_assign(struct quat *result, struct quat *q0);
 struct quat *psquat_zero(struct quat *result);
 struct quat *psquat_null(struct quat *result);
-struct quat *psquat_multiply(struct quat *result, struct quat *quat0, struct quat *quat1);
-struct quat *psquat_multiply_f(struct quat *result, struct quat *quat0, mfloat_t f);
-struct quat *psquat_divide(struct quat *result, struct quat *quat0, struct quat *quat1);
-struct quat *psquat_divide_f(struct quat *result, struct quat *quat0, mfloat_t f);
-struct quat *psquat_negative(struct quat *result, struct quat *quat0);
-struct quat *psquat_conjugate(struct quat *result, struct quat *quat0);
-struct quat *psquat_inverse(struct quat *result, struct quat *quat0);
-struct quat *psquat_normalize(struct quat *result, struct quat *quat0);
-mfloat_t psquat_dot(struct quat *quat0, struct quat *quat1);
-struct quat *psquat_power(struct quat *result, struct quat *quat0, mfloat_t exponent);
-struct quat *psquat_from_axis_angle(struct quat *result, struct vec3 *vec30, mfloat_t angle);
-struct quat *psquat_from_vec3(struct quat *result, struct vec3 *vec30, struct vec3 *vec31);
-struct quat *psquat_from_mat4(struct quat *result, struct mat4 *mat40);
-struct quat *psquat_lerp(struct quat *result, struct quat *quat0, struct quat *quat1, mfloat_t f);
-struct quat *psquat_slerp(struct quat *result, struct quat *quat0, struct quat *quat1, mfloat_t f);
-mfloat_t psquat_length(struct quat *quat0);
-mfloat_t psquat_length_squared(struct quat *quat0);
-mfloat_t psquat_angle(struct quat *quat0, struct quat *quat1);
+struct quat *psquat_multiply(struct quat *result, struct quat *q0, struct quat *q1);
+struct quat *psquat_multiply_f(struct quat *result, struct quat *q0, mfloat_t f);
+struct quat *psquat_divide(struct quat *result, struct quat *q0, struct quat *q1);
+struct quat *psquat_divide_f(struct quat *result, struct quat *q0, mfloat_t f);
+struct quat *psquat_negative(struct quat *result, struct quat *q0);
+struct quat *psquat_conjugate(struct quat *result, struct quat *q0);
+struct quat *psquat_inverse(struct quat *result, struct quat *q0);
+struct quat *psquat_normalize(struct quat *result, struct quat *q0);
+mfloat_t psquat_dot(struct quat *q0, struct quat *q1);
+struct quat *psquat_power(struct quat *result, struct quat *q0, mfloat_t exponent);
+struct quat *psquat_from_axis_angle(struct quat *result, struct vec3 *v0, mfloat_t angle);
+struct quat *psquat_from_vec3(struct quat *result, struct vec3 *v0, struct vec3 *v1);
+struct quat *psquat_from_mat4(struct quat *result, struct mat4 *m0);
+struct quat *psquat_lerp(struct quat *result, struct quat *q0, struct quat *q1, mfloat_t f);
+struct quat *psquat_slerp(struct quat *result, struct quat *q0, struct quat *q1, mfloat_t f);
+mfloat_t psquat_length(struct quat *q0);
+mfloat_t psquat_length_squared(struct quat *q0);
+mfloat_t psquat_angle(struct quat *q0, struct quat *q1);
 struct mat2 *psmat2(struct mat2 *result, mfloat_t m11, mfloat_t m12, mfloat_t m21, mfloat_t m22);
 struct mat2 *psmat2_zero(struct mat2 *result);
 struct mat2 *psmat2_identity(struct mat2 *result);
-mfloat_t psmat2_determinant(struct mat2 *mat20);
-struct mat2 *psmat2_assign(struct mat2 *result, struct mat2 *mat20);
-struct mat2 *psmat2_negative(struct mat2 *result, struct mat2 *mat20);
-struct mat2 *psmat2_transpose(struct mat2 *result, struct mat2 *mat20);
-struct mat2 *psmat2_cofactor(struct mat2 *result, struct mat2 *mat20);
-struct mat2 *psmat2_adjugate(struct mat2 *result, struct mat2 *mat20);
-struct mat2 *psmat2_multiply(struct mat2 *result, struct mat2 *mat20, struct mat2 *mat21);
-struct mat2 *psmat2_multiply_f(struct mat2 *result, struct mat2 *mat20, mfloat_t f);
-struct mat2 *psmat2_inverse(struct mat2 *result, struct mat2 *mat20);
-struct mat2 *psmat2_scaling(struct mat2 *result, struct vec2 *vec20);
-struct mat2 *psmat2_scale(struct mat2 *result, struct mat2 *mat20, struct vec2 *vec20);
+mfloat_t psmat2_determinant(struct mat2 *m0);
+struct mat2 *psmat2_assign(struct mat2 *result, struct mat2 *m0);
+struct mat2 *psmat2_negative(struct mat2 *result, struct mat2 *m0);
+struct mat2 *psmat2_transpose(struct mat2 *result, struct mat2 *m0);
+struct mat2 *psmat2_cofactor(struct mat2 *result, struct mat2 *m0);
+struct mat2 *psmat2_adjugate(struct mat2 *result, struct mat2 *m0);
+struct mat2 *psmat2_multiply(struct mat2 *result, struct mat2 *m0, struct mat2 *m1);
+struct mat2 *psmat2_multiply_f(struct mat2 *result, struct mat2 *m0, mfloat_t f);
+struct mat2 *psmat2_inverse(struct mat2 *result, struct mat2 *m0);
+struct mat2 *psmat2_scaling(struct mat2 *result, struct vec2 *v0);
+struct mat2 *psmat2_scale(struct mat2 *result, struct mat2 *m0, struct vec2 *v0);
 struct mat2 *psmat2_rotation_z(struct mat2 *result, mfloat_t f);
-struct mat2 *psmat2_lerp(struct mat2 *result, struct mat2 *mat20, struct mat2 *mat21, mfloat_t f);
+struct mat2 *psmat2_lerp(struct mat2 *result, struct mat2 *m0, struct mat2 *m1, mfloat_t f);
 struct mat3 *psmat3(struct mat3 *result, mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m31, mfloat_t m32, mfloat_t m33);
 struct mat3 *psmat3_zero(struct mat3 *result);
 struct mat3 *psmat3_identity(struct mat3 *result);
-mfloat_t psmat3_determinant(struct mat3 *mat30);
-struct mat3 *psmat3_assign(struct mat3 *result, struct mat3 *mat30);
-struct mat3 *psmat3_negative(struct mat3 *result, struct mat3 *mat30);
-struct mat3 *psmat3_transpose(struct mat3 *result, struct mat3 *mat30);
-struct mat3 *psmat3_cofactor(struct mat3 *result, struct mat3 *mat30);
-struct mat3 *psmat3_multiply(struct mat3 *result, struct mat3 *mat30, struct mat3 *mat31);
-struct mat3 *psmat3_multiply_f(struct mat3 *result, struct mat3 *mat30, mfloat_t f);
-struct mat3 *psmat3_inverse(struct mat3 *result, struct mat3 *mat30);
-struct mat3 *psmat3_scaling(struct mat3 *result, struct vec3 *vec30);
-struct mat3 *psmat3_scale(struct mat3 *result, struct mat3 *mat30, struct vec3 *vec30);
+mfloat_t psmat3_determinant(struct mat3 *m0);
+struct mat3 *psmat3_assign(struct mat3 *result, struct mat3 *m0);
+struct mat3 *psmat3_negative(struct mat3 *result, struct mat3 *m0);
+struct mat3 *psmat3_transpose(struct mat3 *result, struct mat3 *m0);
+struct mat3 *psmat3_cofactor(struct mat3 *result, struct mat3 *m0);
+struct mat3 *psmat3_multiply(struct mat3 *result, struct mat3 *m0, struct mat3 *m1);
+struct mat3 *psmat3_multiply_f(struct mat3 *result, struct mat3 *m0, mfloat_t f);
+struct mat3 *psmat3_inverse(struct mat3 *result, struct mat3 *m0);
+struct mat3 *psmat3_scaling(struct mat3 *result, struct vec3 *v0);
+struct mat3 *psmat3_scale(struct mat3 *result, struct mat3 *m0, struct vec3 *v0);
 struct mat3 *psmat3_rotation_x(struct mat3 *result, mfloat_t f);
 struct mat3 *psmat3_rotation_y(struct mat3 *result, mfloat_t f);
 struct mat3 *psmat3_rotation_z(struct mat3 *result, mfloat_t f);
-struct mat3 *psmat3_rotation_axis(struct mat3 *result, struct vec3 *vec30, mfloat_t f);
-struct mat3 *psmat3_rotation_quat(struct mat3 *result, struct quat *quat0);
-struct mat3 *psmat3_lerp(struct mat3 *result, struct mat3 *mat30, struct mat3 *mat31, mfloat_t f);
+struct mat3 *psmat3_rotation_axis(struct mat3 *result, struct vec3 *v0, mfloat_t f);
+struct mat3 *psmat3_rotation_quat(struct mat3 *result, struct quat *q0);
+struct mat3 *psmat3_lerp(struct mat3 *result, struct mat3 *m0, struct mat3 *m1, mfloat_t f);
 struct mat4 *psmat4(struct mat4 *result, mfloat_t m11, mfloat_t m12, mfloat_t m13, mfloat_t m14, mfloat_t m21, mfloat_t m22, mfloat_t m23, mfloat_t m24, mfloat_t m31, mfloat_t m32, mfloat_t m33, mfloat_t m34, mfloat_t m41, mfloat_t m42, mfloat_t m43, mfloat_t m44);
 struct mat4 *psmat4_zero(struct mat4 *result);
 struct mat4 *psmat4_identity(struct mat4 *result);
-mfloat_t psmat4_determinant(struct mat4 *mat40);
-struct mat4 *psmat4_assign(struct mat4 *result, struct mat4 *mat40);
-struct mat4 *psmat4_negative(struct mat4 *result, struct mat4 *mat40);
-struct mat4 *psmat4_transpose(struct mat4 *result, struct mat4 *mat40);
-struct mat4 *psmat4_cofactor(struct mat4 *result, struct mat4 *mat40);
+mfloat_t psmat4_determinant(struct mat4 *m0);
+struct mat4 *psmat4_assign(struct mat4 *result, struct mat4 *m0);
+struct mat4 *psmat4_negative(struct mat4 *result, struct mat4 *m0);
+struct mat4 *psmat4_transpose(struct mat4 *result, struct mat4 *m0);
+struct mat4 *psmat4_cofactor(struct mat4 *result, struct mat4 *m0);
 struct mat4 *psmat4_rotation_x(struct mat4 *result, mfloat_t f);
 struct mat4 *psmat4_rotation_y(struct mat4 *result, mfloat_t f);
 struct mat4 *psmat4_rotation_z(struct mat4 *result, mfloat_t f);
-struct mat4 *psmat4_rotation_axis(struct mat4 *result, struct vec3 *vec30, mfloat_t f);
-struct mat4 *psmat4_rotation_quat(struct mat4 *result, struct quat *quat0);
-struct mat4 *psmat4_translation(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30);
-struct mat4 *psmat4_translate(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30);
-struct mat4 *psmat4_scaling(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30);
-struct mat4 *psmat4_scale(struct mat4 *result, struct mat4 *mat40, struct vec3 *vec30);
-struct mat4 *psmat4_multiply(struct mat4 *result, struct mat4 *mat40, struct mat4 *mat41);
-struct mat4 *psmat4_multiply_f(struct mat4 *result, struct mat4 *mat40, mfloat_t f);
-struct mat4 *psmat4_inverse(struct mat4 *result, struct mat4 *mat40);
-struct mat4 *psmat4_lerp(struct mat4 *result, struct mat4 *mat40, struct mat4 *mat41, mfloat_t f);
-struct mat4 *psmat4_look_at(struct mat4 *result, struct vec3 *vec30, struct vec3 *vec31, struct vec3 *vec32);
+struct mat4 *psmat4_rotation_axis(struct mat4 *result, struct vec3 *v0, mfloat_t f);
+struct mat4 *psmat4_rotation_quat(struct mat4 *result, struct quat *q0);
+struct mat4 *psmat4_translation(struct mat4 *result, struct mat4 *m0, struct vec3 *v0);
+struct mat4 *psmat4_translate(struct mat4 *result, struct mat4 *m0, struct vec3 *v0);
+struct mat4 *psmat4_scaling(struct mat4 *result, struct mat4 *m0, struct vec3 *v0);
+struct mat4 *psmat4_scale(struct mat4 *result, struct mat4 *m0, struct vec3 *v0);
+struct mat4 *psmat4_multiply(struct mat4 *result, struct mat4 *m0, struct mat4 *m1);
+struct mat4 *psmat4_multiply_f(struct mat4 *result, struct mat4 *m0, mfloat_t f);
+struct mat4 *psmat4_inverse(struct mat4 *result, struct mat4 *m0);
+struct mat4 *psmat4_lerp(struct mat4 *result, struct mat4 *m0, struct mat4 *m1, mfloat_t f);
+struct mat4 *psmat4_look_at(struct mat4 *result, struct vec3 *position, struct vec3 *target, struct vec3 *up);
 struct mat4 *psmat4_ortho(struct mat4 *result, mfloat_t l, mfloat_t r, mfloat_t b, mfloat_t t, mfloat_t n, mfloat_t f);
 struct mat4 *psmat4_perspective(struct mat4 *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n, mfloat_t f);
 struct mat4 *psmat4_perspective_fov(struct mat4 *result, mfloat_t fov, mfloat_t w, mfloat_t h, mfloat_t n, mfloat_t f);
 struct mat4 *psmat4_perspective_infinite(struct mat4 *result, mfloat_t fov_y, mfloat_t aspect, mfloat_t n);
 #endif
 #endif
+
 #endif

From 810d1e525743b0b8ce2c21d5c2a43034db7643e9 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Fri, 3 Aug 2018 20:08:42 -0300
Subject: [PATCH 076/102] Add easing functions

---
 mathc.c | 233 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 mathc.h |  33 ++++++++
 2 files changed, 266 insertions(+)

diff --git a/mathc.c b/mathc.c
index 246330b..a5014ac 100644
--- a/mathc.c
+++ b/mathc.c
@@ -6509,3 +6509,236 @@ struct mat4 *psmat4_perspective_infinite(struct mat4 *result, mfloat_t fov_y, mf
 }
 #endif
 #endif
+
+#if defined(MATHC_USE_FLOATING_POINT) && defined(MATHC_USE_EASING_FUNCTIONS)
+mfloat_t quadratic_ease_out(mfloat_t f)
+{
+	return -f * (f - MFLOAT_C(2.0));
+}
+
+mfloat_t quadratic_ease_in(mfloat_t f)
+{
+	return f * f;
+}
+
+mfloat_t quadratic_ease_in_out(mfloat_t f)
+{
+	mfloat_t a = MFLOAT_C(0.0);
+	if (f < MFLOAT_C(0.5)) {
+		a = MFLOAT_C(2.0) * f * f;
+	} else {
+		a = -MFLOAT_C(2.0) * f * f + MFLOAT_C(4.0) * f - MFLOAT_C(1.0);
+	}
+	return a;
+}
+
+mfloat_t cubic_ease_out(mfloat_t f)
+{
+	mfloat_t a = f - MFLOAT_C(1.0);
+	return a * a * a + MFLOAT_C(1.0);
+}
+
+mfloat_t cubic_ease_in(mfloat_t f)
+{
+	return f * f * f;
+}
+
+mfloat_t cubic_ease_in_out(mfloat_t f)
+{
+	mfloat_t a = MFLOAT_C(0.0);
+	if (f < MFLOAT_C(0.5)) {
+		a = MFLOAT_C(4.0) * f * f * f;
+	} else {
+		a = MFLOAT_C(2.0) * f - MFLOAT_C(2.0);
+		a = MFLOAT_C(0.5) * a * a * a + MFLOAT_C(1.0);
+	}
+	return a;
+}
+
+mfloat_t quartic_ease_out(mfloat_t f)
+{
+	mfloat_t a = f - MFLOAT_C(1.0);
+	return a * a * a * (MFLOAT_C(1.0) - f) + MFLOAT_C(1.0);
+}
+
+mfloat_t quartic_ease_in(mfloat_t f)
+{
+	return f * f * f * f;
+}
+
+mfloat_t quartic_ease_in_out(mfloat_t f)
+{
+	mfloat_t a = MFLOAT_C(0.0);
+	if (f < MFLOAT_C(0.5)) {
+		a = MFLOAT_C(8.0) * f * f * f * f;
+	} else {
+		a = f - MFLOAT_C(1.0);
+		a = -MFLOAT_C(8.0) * a * a * a * a + MFLOAT_C(1.0);
+	}
+	return a;
+}
+
+mfloat_t quintic_ease_out(mfloat_t f)
+{
+	mfloat_t a = f - MFLOAT_C(1.0);
+	return a * a * a * a * a + MFLOAT_C(1.0);
+}
+
+mfloat_t quintic_ease_in(mfloat_t f)
+{
+	return f * f * f * f * f;
+}
+
+mfloat_t quintic_ease_in_out(mfloat_t f)
+{
+	mfloat_t a = MFLOAT_C(0.0);
+	if (f < MFLOAT_C(0.5)) {
+		a = MFLOAT_C(16.0) * f * f * f * f * f;
+	} else {
+		a = MFLOAT_C(2.0) * f - MFLOAT_C(2.0);
+		a = MFLOAT_C(0.5) * a * a * a * a * a + MFLOAT_C(1.0);
+	}
+	return a;
+}
+
+mfloat_t sine_ease_out(mfloat_t f)
+{
+	return MSIN(f * MPI_2);
+}
+
+mfloat_t sine_ease_in(mfloat_t f)
+{
+	return MSIN((f - MFLOAT_C(1.0)) * MPI_2) + MFLOAT_C(1.0);
+}
+
+mfloat_t sine_ease_in_out(mfloat_t f)
+{
+	return MFLOAT_C(0.5) * (MFLOAT_C(1.0) - MCOS(f * MPI));
+}
+
+mfloat_t circular_ease_out(mfloat_t f)
+{
+	return MSQRT((MFLOAT_C(2.0) - f) * f);
+}
+
+mfloat_t circular_ease_in(mfloat_t f)
+{
+	return MFLOAT_C(1.0) - MSQRT(MFLOAT_C(1.0) - (f * f));
+}
+
+mfloat_t circular_ease_in_out(mfloat_t f)
+{
+	mfloat_t a = MFLOAT_C(0.0);
+	if (f < MFLOAT_C(0.5)) {
+		a = MFLOAT_C(0.5) * (MFLOAT_C(1.0) - MSQRT(MFLOAT_C(1.0) - MFLOAT_C(4.0) * f * f));
+	} else {
+		a = MFLOAT_C(0.5) * (MSQRT(-(MFLOAT_C(2.0) * f - MFLOAT_C(3.0)) * (MFLOAT_C(2.0) * f - MFLOAT_C(1.0))) + MFLOAT_C(1.0));
+	}
+	return a;
+}
+
+mfloat_t exponential_ease_out(mfloat_t f)
+{
+	mfloat_t a = f;
+	if (MFABS(a) > MFLT_EPSILON) {
+		a = MFLOAT_C(1.0) - MPOW(MFLOAT_C(2.0), -MFLOAT_C(10.0) * f);
+	}
+	return a;
+}
+
+mfloat_t exponential_ease_in(mfloat_t f)
+{
+	mfloat_t a = f;
+	if (MFABS(a) > MFLT_EPSILON) {
+		a = MPOW(MFLOAT_C(2.0), MFLOAT_C(10.0) * (f - MFLOAT_C(1.0)));
+	}
+	return a;
+}
+
+mfloat_t exponential_ease_in_out(mfloat_t f)
+{
+	mfloat_t a = f;
+	if (f < MFLOAT_C(0.5)) {
+		a = MFLOAT_C(0.5) * MPOW(MFLOAT_C(2.0), (MFLOAT_C(20.0) * f) - MFLOAT_C(10.0));
+	} else {
+		a = -MFLOAT_C(0.5) * MPOW(MFLOAT_C(2.0), -MFLOAT_C(20.0) * f + MFLOAT_C(10.0)) + MFLOAT_C(1.0);
+	}
+	return a;
+}
+
+mfloat_t elastic_ease_out(mfloat_t f)
+{
+	return MSIN(-MFLOAT_C(13.0) * MPI_2 * (f + MFLOAT_C(1.0))) * MPOW(MFLOAT_C(2.0), -MFLOAT_C(10.0) * f) + MFLOAT_C(1.0);
+}
+
+mfloat_t elastic_ease_in(mfloat_t f)
+{
+	return MSIN(MFLOAT_C(13.0) * MPI_2 * f) * MPOW(MFLOAT_C(2.0), MFLOAT_C(10.0) * (f - MFLOAT_C(1.0)));
+}
+
+mfloat_t elastic_ease_in_out(mfloat_t f)
+{
+	mfloat_t a = MFLOAT_C(0.0);
+	if (f < MFLOAT_C(0.5)) {
+		a = MFLOAT_C(0.5) * MSIN(MFLOAT_C(13.0) * MPI_2 * (MFLOAT_C(2.0) * f)) * MPOW(MFLOAT_C(2.0), MFLOAT_C(10.0) * ((MFLOAT_C(2.0) * f) - MFLOAT_C(1.0)));
+	} else {
+		a = MFLOAT_C(0.5) * (MSIN(-MFLOAT_C(13.0) * MPI_2 * ((MFLOAT_C(2.0) * f - MFLOAT_C(1.0)) + MFLOAT_C(1.0))) * MPOW(MFLOAT_C(2.0), -MFLOAT_C(10.0) * (MFLOAT_C(2.0) * f - MFLOAT_C(1.0))) + MFLOAT_C(2.0));
+	}
+	return a;
+}
+
+mfloat_t back_ease_out(mfloat_t f)
+{
+	mfloat_t a = MFLOAT_C(1.0) - f;
+	return MFLOAT_C(1.0) - (a * a * a - a * MSIN(a * MPI));
+}
+
+mfloat_t back_ease_in(mfloat_t f)
+{
+	return f * f * f - f * MSIN(f * MPI);
+}
+
+mfloat_t back_ease_in_out(mfloat_t f)
+{
+	mfloat_t a = MFLOAT_C(0.0);
+	if (f < MFLOAT_C(0.5)) {
+		a = MFLOAT_C(2.0) * f;
+		a = MFLOAT_C(0.5) * (a * a * a - a * MSIN(a * MPI));
+	} else {
+		a = (MFLOAT_C(1.0) - (MFLOAT_C(2.0) * f - MFLOAT_C(1.0)));
+		a = MFLOAT_C(0.5) * (MFLOAT_C(1.0) - (a * a * a - a * MSIN(f * MPI))) + MFLOAT_C(0.5);
+	}
+	return a;
+}
+
+mfloat_t bounce_ease_out(mfloat_t f)
+{
+	mfloat_t a = MFLOAT_C(0.0);
+	if (f < MFLOAT_C(4.0) / MFLOAT_C(11.0)) {
+		a = (MFLOAT_C(121.0) * f * f) / MFLOAT_C(16.0);
+	} else if (f < MFLOAT_C(8.0) / MFLOAT_C(11.0)) {
+		a = (MFLOAT_C(363.0) / MFLOAT_C(40.0) * f * f) - (MFLOAT_C(99.0) / MFLOAT_C(10.0) * f) + MFLOAT_C(17.0) / MFLOAT_C(5.0);
+	} else if (f < MFLOAT_C(9.0) / MFLOAT_C(10.0)) {
+		a = (MFLOAT_C(4356.0) / MFLOAT_C(361.0) * f * f) - (MFLOAT_C(35442.0) / MFLOAT_C(1805.0) * f) + MFLOAT_C(16061.0) / MFLOAT_C(1805.0);
+	} else {
+		a = (MFLOAT_C(54.0) / MFLOAT_C(5.0) * f * f) - (MFLOAT_C(513.0) / MFLOAT_C(25.0) * f) + MFLOAT_C(268.0) / MFLOAT_C(25.0);
+	}
+	return a;
+}
+
+mfloat_t bounce_ease_in(mfloat_t f)
+{
+	return MFLOAT_C(1.0) - bounce_ease_out(MFLOAT_C(1.0) - f);
+}
+
+mfloat_t bounce_ease_in_out(mfloat_t f)
+{
+	mfloat_t a = MFLOAT_C(0.0);
+	if (f < MFLOAT_C(0.5)) {
+		a = MFLOAT_C(0.5) * bounce_ease_in(f * MFLOAT_C(2.0));
+	} else {
+		a = MFLOAT_C(0.5) * bounce_ease_out(f * MFLOAT_C(2.0) - MFLOAT_C(1.0)) + MFLOAT_C(0.5);
+	}
+	return a;
+}
+#endif
diff --git a/mathc.h b/mathc.h
index ad3588b..47a4d2b 100644
--- a/mathc.h
+++ b/mathc.h
@@ -1253,4 +1253,37 @@ struct mat4 *psmat4_perspective_infinite(struct mat4 *result, mfloat_t fov_y, mf
 #endif
 #endif
 
+#if defined(MATHC_USE_FLOATING_POINT) && defined(MATHC_USE_EASING_FUNCTIONS)
+mfloat_t quadratic_ease_out(mfloat_t f);
+mfloat_t quadratic_ease_in(mfloat_t f);
+mfloat_t quadratic_ease_in_out(mfloat_t f);
+mfloat_t cubic_ease_out(mfloat_t f);
+mfloat_t cubic_ease_in(mfloat_t f);
+mfloat_t cubic_ease_in_out(mfloat_t f);
+mfloat_t quartic_ease_out(mfloat_t f);
+mfloat_t quartic_ease_in(mfloat_t f);
+mfloat_t quartic_ease_in_out(mfloat_t f);
+mfloat_t quintic_ease_out(mfloat_t f);
+mfloat_t quintic_ease_in(mfloat_t f);
+mfloat_t quintic_ease_in_out(mfloat_t f);
+mfloat_t sine_ease_out(mfloat_t f);
+mfloat_t sine_ease_in(mfloat_t f);
+mfloat_t sine_ease_in_out(mfloat_t f);
+mfloat_t circular_ease_out(mfloat_t f);
+mfloat_t circular_ease_in(mfloat_t f);
+mfloat_t circular_ease_in_out(mfloat_t f);
+mfloat_t exponential_ease_out(mfloat_t f);
+mfloat_t exponential_ease_in(mfloat_t f);
+mfloat_t exponential_ease_in_out(mfloat_t f);
+mfloat_t elastic_ease_out(mfloat_t f);
+mfloat_t elastic_ease_in(mfloat_t f);
+mfloat_t elastic_ease_in_out(mfloat_t f);
+mfloat_t back_ease_out(mfloat_t f);
+mfloat_t back_ease_in(mfloat_t f);
+mfloat_t back_ease_in_out(mfloat_t f);
+mfloat_t bounce_ease_out(mfloat_t f);
+mfloat_t bounce_ease_in(mfloat_t f);
+mfloat_t bounce_ease_in_out(mfloat_t f);
+#endif
+
 #endif

From 7c2edccea3aa7405b51d9d337ce4473019b1b363 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Fri, 3 Aug 2018 20:10:26 -0300
Subject: [PATCH 077/102] Fix formatting

---
 mathc.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mathc.h b/mathc.h
index 47a4d2b..c2a5128 100644
--- a/mathc.h
+++ b/mathc.h
@@ -397,6 +397,7 @@ bool nearly_equal(mfloat_t a, mfloat_t b, mfloat_t epsilon);
 mfloat_t to_radians(mfloat_t degrees);
 mfloat_t to_degrees(mfloat_t radians);
 #endif
+
 #if defined(MATHC_USE_INT)
 bool vec2i_is_zero(mint_t *v0);
 bool vec2i_is_equal(mint_t *v0, mint_t *v1);

From 64785a9d63ebf70bd36eddbdcf72842a966d75fd Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 4 Aug 2018 12:14:19 -0300
Subject: [PATCH 078/102] Fix customization of floating-point type

---
 mathc.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mathc.h b/mathc.h
index c2a5128..7a6a779 100644
--- a/mathc.h
+++ b/mathc.h
@@ -99,7 +99,7 @@ typedef int64_t mint_t;
 
 #if defined(MATHC_USE_FLOATING_POINT)
 #if defined(MATHC_FLOATING_POINT_TYPE)
-typedef MATHC_FLOATING_POINT_TYPE mint_t;
+typedef MATHC_FLOATING_POINT_TYPE mfloat_t;
 #endif
 #if !defined(MATHC_USE_SINGLE_FLOATING_POINT) && !defined(MATHC_USE_DOUBLE_FLOATING_POINT)
 #define MATHC_USE_SINGLE_FLOATING_POINT

From 76b8814f61fd961e43bab3cf9fdbd613bf897957 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 4 Aug 2018 12:15:51 -0300
Subject: [PATCH 079/102] Discard micro from versioning

---
 README.md | 2 +-
 mathc.h   | 3 +--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 9afd7f4..88573d9 100644
--- a/README.md
+++ b/README.md
@@ -11,7 +11,7 @@ MATHC is a simple math library for 2D and 3D programming.
 
 ## Versioning
 
-Starting on version 2, the development of MATHC uses calendar versioning, with a tag `YYYY.MM.DD.MICRO` for each stable release, representing year, month and day, and `MICRO` for fixes. If a release breaks backward compatibility, then it is mentioned in the release notes.
+Starting on version 2, the development of MATHC uses calendar versioning, with a tag `YYYY.MM.DD` for each stable release, representing year, month and day. If a release breaks backward compatibility, then it is mentioned in the release notes.
 
 ## Configuring
 
diff --git a/mathc.h b/mathc.h
index 7a6a779..fcf051a 100644
--- a/mathc.h
+++ b/mathc.h
@@ -26,8 +26,7 @@ the following restrictions:
 
 #define MATHC_VERSION_YYYY 2018
 #define MATHC_VERSION_MM 08
-#define MATHC_VERSION_DD 02
-#define MATHC_VERSION_MICRO 0
+#define MATHC_VERSION_DD 04
 
 #if !defined(MATHC_NO_INT)
 #define MATHC_USE_INT

From ab96ae9ec91adf1011d8ed82b4032203bd356043 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 4 Aug 2018 12:31:19 -0300
Subject: [PATCH 080/102] Fix mat4 look at

---
 mathc.c | 42 +++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/mathc.c b/mathc.c
index a5014ac..b394fe0 100644
--- a/mathc.c
+++ b/mathc.c
@@ -3214,29 +3214,29 @@ mfloat_t *mat4_lerp(mfloat_t *result, mfloat_t *m0, mfloat_t *m1, mfloat_t f)
 
 mfloat_t *mat4_look_at(mfloat_t *result, mfloat_t *position, mfloat_t *target, mfloat_t *up)
 {
-	mfloat_t forward[VEC3_SIZE];
-	mfloat_t side[VEC3_SIZE];
+	mfloat_t tmp_forward[VEC3_SIZE];
+	mfloat_t tmp_side[VEC3_SIZE];
 	mfloat_t tmp_up[VEC3_SIZE];
-	vec3_subtract(forward, target, position);
-	vec3_normalize(forward, forward);
-	vec3_cross(side, forward, up);
-	vec3_normalize(side, side);
-	vec3_cross(tmp_up, side, forward);
-	result[0] = side[0];
-	result[1] = side[1];
-	result[2] = side[2];
-	result[3] = -vec3_dot(side, position);
-	result[4] = tmp_up[0];
+	vec3_subtract(tmp_forward, target, position);
+	vec3_normalize(tmp_forward, tmp_forward);
+	vec3_cross(tmp_side, tmp_forward, up);
+	vec3_normalize(tmp_side, tmp_side);
+	vec3_cross(tmp_up, tmp_side, tmp_forward);
+	result[0] = tmp_side[0];
+	result[1] = tmp_up[0];
+	result[2] = -tmp_forward[0];
+	result[3] = MFLOAT_C(0.0);
+	result[4] = tmp_side[1];
 	result[5] = tmp_up[1];
-	result[6] = tmp_up[2];
-	result[7] = -vec3_dot(tmp_up, position);
-	result[8] = forward[0];
-	result[9] = forward[1];
-	result[10] = forward[2];
-	result[11] = -vec3_dot(forward, position);
-	result[12] = MFLOAT_C(0.0);
-	result[13] = MFLOAT_C(0.0);
-	result[14] = MFLOAT_C(0.0);
+	result[6] = -tmp_forward[1];
+	result[7] = MFLOAT_C(0.0);
+	result[8] = tmp_side[2];
+	result[9] = tmp_up[2];
+	result[10] = -tmp_forward[2];
+	result[11] = MFLOAT_C(0.0);
+	result[12] = -vec3_dot(tmp_side, position);
+	result[13] = -vec3_dot(tmp_up, position);
+	result[14] = vec3_dot(tmp_forward, position);
 	result[15] = MFLOAT_C(1.0);
 	return result;
 }

From 8a332f8d049e39cd80e9a02b6e625594982e9a47 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 4 Aug 2018 12:37:57 -0300
Subject: [PATCH 081/102] Bump version

---
 mathc.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/mathc.h b/mathc.h
index fcf051a..f5b3b93 100644
--- a/mathc.h
+++ b/mathc.h
@@ -27,6 +27,7 @@ the following restrictions:
 #define MATHC_VERSION_YYYY 2018
 #define MATHC_VERSION_MM 08
 #define MATHC_VERSION_DD 04
+#define MATHC_VERSION_MICRO 1
 
 #if !defined(MATHC_NO_INT)
 #define MATHC_USE_INT

From 8c6c7e5c2f172578612deeb1e5597ef034e89fa8 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 4 Aug 2018 13:16:59 -0300
Subject: [PATCH 082/102] Update README.md

---
 README.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/README.md b/README.md
index 88573d9..f607a81 100644
--- a/README.md
+++ b/README.md
@@ -9,6 +9,12 @@ MATHC is a simple math library for 2D and 3D programming.
 - Matrices (2×2, 3×3, and 4×4)
 - Easing functions
 
+## Contributions And Donations
+
+You can help with the development of MATHC testing the library, sending in-scope math functions, reporting errors and giving feedback.
+
+Donations can be sent to `ferreiradaselva@protonmail.com` via Paypal.
+
 ## Versioning
 
 Starting on version 2, the development of MATHC uses calendar versioning, with a tag `YYYY.MM.DD` for each stable release, representing year, month and day. If a release breaks backward compatibility, then it is mentioned in the release notes.

From 3bfcdf136164b31505bdfb9ff7c11400332891ab Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 4 Aug 2018 13:20:58 -0300
Subject: [PATCH 083/102] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index f607a81..6d4e22c 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@ MATHC is a simple math library for 2D and 3D programming.
 
 You can help with the development of MATHC testing the library, sending in-scope math functions, reporting errors and giving feedback.
 
-Donations can be sent to `ferreiradaselva@protonmail.com` via Paypal.
+Donations can be sent to `ferreiradaselva@protonmail.com` via PayPal.
 
 ## Versioning
 

From fc7ad44956506773b4a152ac759c4b94fa110bf0 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 4 Aug 2018 13:21:48 -0300
Subject: [PATCH 084/102] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 6d4e22c..e947442 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@ Donations can be sent to `ferreiradaselva@protonmail.com` via PayPal.
 
 ## Versioning
 
-Starting on version 2, the development of MATHC uses calendar versioning, with a tag `YYYY.MM.DD` for each stable release, representing year, month and day. If a release breaks backward compatibility, then it is mentioned in the release notes.
+Starting on version 2, the development of MATHC uses calendar versioning, with a tag `YYYY.MM.DD.MICRO` for each stable release. If a release breaks backward compatibility, then it is mentioned in the release notes.
 
 ## Configuring
 

From b0b74329a1ed682fa2ba5096bde9af052ef9252c Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 4 Aug 2018 13:26:13 -0300
Subject: [PATCH 085/102] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index e947442..0b3b420 100644
--- a/README.md
+++ b/README.md
@@ -52,7 +52,7 @@ Example of a configuration header that makes `mint_t` a `int16_t`, `mfloat_t` a
 
 ## Types
 
-By default, types are can be declared as arrays of `mint_t`, arrays of `mfloat_t`, or structures.
+By default, vectors and matrices can be declared as arrays of `mint_t`, arrays of `mfloat_t`, or structures.
 
 ## Functions
 

From 795a6fe2a3f9b3a89e7e19aff1cf37b4fdc6cb6d Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Sat, 4 Aug 2018 13:28:48 -0300
Subject: [PATCH 086/102] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 0b3b420..18128be 100644
--- a/README.md
+++ b/README.md
@@ -52,7 +52,7 @@ Example of a configuration header that makes `mint_t` a `int16_t`, `mfloat_t` a
 
 ## Types
 
-By default, vectors and matrices can be declared as arrays of `mint_t`, arrays of `mfloat_t`, or structures.
+By default, vectors, quaternions and matrices can be declared as arrays of `mint_t`, arrays of `mfloat_t`, or structures.
 
 ## Functions
 

From 8f5b3e304121f9db2e8b5ae16f1e409c98809865 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <ferreiradaselva@protonmail.com>
Date: Thu, 9 Aug 2018 22:13:36 -0300
Subject: [PATCH 087/102] Fix vector and quaternion comparison functions

---
 mathc.c | 10 +++++-----
 mathc.h |  4 ++--
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/mathc.c b/mathc.c
index b394fe0..18ed505 100644
--- a/mathc.c
+++ b/mathc.c
@@ -248,7 +248,7 @@ mint_t *vec2i_tangent(mint_t *result, mint_t *v0)
 
 bool vec3i_is_zero(mint_t *v0)
 {
-	return v0[0] == 0 && v0[1] == 0;
+	return v0[0] == 0 && v0[1] == 0 && v0[2] == 0;
 }
 
 bool vec3i_is_equal(mint_t *v0, mint_t *v1)
@@ -759,7 +759,7 @@ mint_t *vec4i_clamp(mint_t *result, mint_t *v0, mint_t *v1, mint_t *v2)
 #if defined(MATHC_USE_FLOATING_POINT)
 bool vec2_is_zero(mfloat_t *v0)
 {
-	return v0[0] < MFLT_EPSILON && v0[1] < MFLT_EPSILON;
+	return MFABS(v0[0]) < MFLT_EPSILON && MFABS(v0[1]) < MFLT_EPSILON;
 }
 
 bool vec2_is_equal(mfloat_t *v0, mfloat_t *v1)
@@ -1076,7 +1076,7 @@ mfloat_t vec2_distance_squared(mfloat_t *v0, mfloat_t *v1)
 
 bool vec3_is_zero(mfloat_t *v0)
 {
-	return v0[0] < MFLT_EPSILON && v0[1] < MFLT_EPSILON && v0[2] < MFLT_EPSILON;
+	return MFABS(v0[0]) < MFLT_EPSILON && MFABS(v0[1]) < MFLT_EPSILON && MFABS(v0[2]) < MFLT_EPSILON;
 }
 
 bool vec3_is_equal(mfloat_t *v0, mfloat_t *v1)
@@ -1416,7 +1416,7 @@ mfloat_t vec3_distance_squared(mfloat_t *v0, mfloat_t *v1)
 
 bool vec4_is_zero(mfloat_t *v0)
 {
-	return v0[0] < MFLT_EPSILON && v0[1] < MFLT_EPSILON && v0[2] < MFLT_EPSILON && v0[3] < MFLT_EPSILON;
+	return MFABS(v0[0]) < MFLT_EPSILON && MFABS(v0[1]) < MFLT_EPSILON && MFABS(v0[2]) < MFLT_EPSILON && MFABS(v0[3]) < MFLT_EPSILON;
 }
 
 bool vec4_is_equal(mfloat_t *v0, mfloat_t *v1)
@@ -1698,7 +1698,7 @@ mfloat_t *vec4_lerp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t f)
 
 bool quat_is_zero(mfloat_t *q0)
 {
-	return q0[0] < MFLT_EPSILON && q0[1] < MFLT_EPSILON && q0[2] < MFLT_EPSILON && q0[3] < MFLT_EPSILON;
+	return MFABS(q0[0]) < MFLT_EPSILON && MFABS(q0[1]) < MFLT_EPSILON && MFABS(q0[2]) < MFLT_EPSILON && MFABS(q0[3]) < MFLT_EPSILON;
 }
 
 bool quat_is_equal(mfloat_t *q0, mfloat_t *q1)
diff --git a/mathc.h b/mathc.h
index f5b3b93..02ff4f1 100644
--- a/mathc.h
+++ b/mathc.h
@@ -26,8 +26,8 @@ the following restrictions:
 
 #define MATHC_VERSION_YYYY 2018
 #define MATHC_VERSION_MM 08
-#define MATHC_VERSION_DD 04
-#define MATHC_VERSION_MICRO 1
+#define MATHC_VERSION_DD 09
+#define MATHC_VERSION_MICRO 0
 
 #if !defined(MATHC_NO_INT)
 #define MATHC_USE_INT

From e418cac75494cd8dec45451ede1f10237669ee4c Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <felselva@gmail.com>
Date: Tue, 2 Oct 2018 15:35:36 -0300
Subject: [PATCH 088/102] Update README.md

---
 README.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/README.md b/README.md
index 18128be..f2d734a 100644
--- a/README.md
+++ b/README.md
@@ -13,8 +13,6 @@ MATHC is a simple math library for 2D and 3D programming.
 
 You can help with the development of MATHC testing the library, sending in-scope math functions, reporting errors and giving feedback.
 
-Donations can be sent to `ferreiradaselva@protonmail.com` via PayPal.
-
 ## Versioning
 
 Starting on version 2, the development of MATHC uses calendar versioning, with a tag `YYYY.MM.DD.MICRO` for each stable release. If a release breaks backward compatibility, then it is mentioned in the release notes.

From fa3d513ec9e8b0481432db379274e98186b68731 Mon Sep 17 00:00:00 2001
From: Ariel D'Alessandro <ariel@vanguardiasur.com.ar>
Date: Fri, 19 Oct 2018 19:56:58 -0300
Subject: [PATCH 089/102] mathc: Fix bad sign in mat3_rotation_x()

Signed-off-by: Ariel D'Alessandro <ariel@vanguardiasur.com.ar>
---
 mathc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mathc.c b/mathc.c
index 18ed505..d4caba5 100644
--- a/mathc.c
+++ b/mathc.c
@@ -2364,7 +2364,7 @@ mfloat_t *mat3_rotation_x(mfloat_t *result, mfloat_t f)
 	result[4] = c;
 	result[5] = s;
 	result[7] = -s;
-	result[8] = -c;
+	result[8] = c;
 	return result;
 }
 

From 67bd064db8ab96119b7806fe2e1b63a5830c7b2b Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <felselva@gmail.com>
Date: Thu, 25 Oct 2018 20:15:29 -0300
Subject: [PATCH 090/102] Update README.md

---
 README.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index f2d734a..ec8fe84 100644
--- a/README.md
+++ b/README.md
@@ -9,10 +9,12 @@ MATHC is a simple math library for 2D and 3D programming.
 - Matrices (2×2, 3×3, and 4×4)
 - Easing functions
 
-## Contributions And Donations
+## Contributions and Development
 
 You can help with the development of MATHC testing the library, sending in-scope math functions, reporting errors and giving feedback.
 
+I work little on the library nowadays, but I am always open to suggestions and contributions.
+
 ## Versioning
 
 Starting on version 2, the development of MATHC uses calendar versioning, with a tag `YYYY.MM.DD.MICRO` for each stable release. If a release breaks backward compatibility, then it is mentioned in the release notes.
@@ -36,7 +38,7 @@ MATHC can be configured using these preprocessors:
 - `MATHC_NO_STRUCT_FUNCTIONS`: don't define the functions that take structures as value.
 - `MATHC_NO_EASING_FUNCTIONS`: don't define the easing functions.
 
-You can define these preprocessors them using the compiler's option `-D` or using the compiler's option `-include` to include a configuration header and with the configuration macros defined inside it.
+You can define these preprocessors using the compiler's option `-D` or using the compiler's option `-include` to include a configuration header with the configuration preprocessors inside it.
 
 Example of a configuration header that makes `mint_t` a `int16_t`, `mfloat_t` a `GLfloat` and uses the standard math functions with double floating-point precision:
 

From c55d20891ca9802602b196afa039c500a3f33189 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <felselva@protonmail.com>
Date: Tue, 29 Jan 2019 00:53:47 -0300
Subject: [PATCH 091/102] Fix name of mat4 look at

---
 mathc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mathc.c b/mathc.c
index d4caba5..b1f1947 100644
--- a/mathc.c
+++ b/mathc.c
@@ -5120,7 +5120,7 @@ struct mat4 smat4_lerp(struct mat4 m0, struct mat4 m1, mfloat_t f)
 	return result;
 }
 
-struct mat4 smat4_g(struct vec3 position, struct vec3 target, struct vec3 up)
+struct mat4 smat4_look_at(struct vec3 position, struct vec3 target, struct vec3 up)
 {
 	struct mat4 result;
 	mat4_look_at((mfloat_t *)&result, (mfloat_t *)&position, (mfloat_t *)&target, (mfloat_t *)&up);

From e492bf9f00d17c14aca93a5876c660d6cd437f0d Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <felselva@protonmail.com>
Date: Tue, 29 Jan 2019 12:18:03 -0300
Subject: [PATCH 092/102] Bump version

---
 mathc.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/mathc.h b/mathc.h
index 02ff4f1..920dc7a 100644
--- a/mathc.h
+++ b/mathc.h
@@ -24,9 +24,9 @@ the following restrictions:
 #include <stdbool.h>
 #include <math.h>
 
-#define MATHC_VERSION_YYYY 2018
-#define MATHC_VERSION_MM 08
-#define MATHC_VERSION_DD 09
+#define MATHC_VERSION_YYYY 2019
+#define MATHC_VERSION_MM 01
+#define MATHC_VERSION_DD 29
 #define MATHC_VERSION_MICRO 0
 
 #if !defined(MATHC_NO_INT)

From 9f0ee0c86b127fc0bd3a56e63af44e98d0b7c5e8 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <felselva@protonmail.com>
Date: Fri, 1 Feb 2019 22:55:30 -0300
Subject: [PATCH 093/102] Add functions clampi and clampf

---
 mathc.c | 22 ++++++++++++++++++++++
 mathc.h |  5 +++++
 2 files changed, 27 insertions(+)

diff --git a/mathc.c b/mathc.c
index b1f1947..b72e2ae 100644
--- a/mathc.c
+++ b/mathc.c
@@ -20,6 +20,18 @@ the following restrictions:
 
 #include "mathc.h"
 
+#if defined(MATHC_USE_INT)
+mint_t clampi(mint_t value, mint_t min, mint_t max)
+{
+	if (value < min) {
+		value = min;
+	} else if (value > max) {
+		value = max;
+	}
+	return value;
+}
+#endif
+
 #if defined(MATHC_USE_FLOATING_POINT)
 bool nearly_equal(mfloat_t a, mfloat_t b, mfloat_t epsilon)
 {
@@ -41,6 +53,16 @@ mfloat_t to_degrees(mfloat_t radians)
 {
 	return MDEGREES(radians);
 }
+
+mfloat_t clampf(mfloat_t value, mfloat_t min, mfloat_t max)
+{
+	if (value < min) {
+		value = min;
+	} else if (value > max) {
+		value = max;
+	}
+	return value;
+}
 #endif
 
 #if defined(MATHC_USE_INT)
diff --git a/mathc.h b/mathc.h
index 920dc7a..2f64cac 100644
--- a/mathc.h
+++ b/mathc.h
@@ -390,12 +390,17 @@ struct mat4 {
 #endif
 #endif
 
+#if defined(MATHC_USE_INT)
+mint_t clampi(mint_t value, mint_t min, mint_t max);
+#endif
+
 #if defined(MATHC_USE_FLOATING_POINT)
 #define MRADIANS(degrees) (degrees * MPI / MFLOAT_C(180.0))
 #define MDEGREES(radians) (radians * MFLOAT_C(180.0) / MPI)
 bool nearly_equal(mfloat_t a, mfloat_t b, mfloat_t epsilon);
 mfloat_t to_radians(mfloat_t degrees);
 mfloat_t to_degrees(mfloat_t radians);
+mfloat_t clampf(mfloat_t value, mfloat_t min, mfloat_t max);
 #endif
 
 #if defined(MATHC_USE_INT)

From d13cf8fd1925fd37763f560c19044ffbc537b9cf Mon Sep 17 00:00:00 2001
From: Eleftheria Chatziargyriou <ele.hatzy@gmail.com>
Date: Wed, 13 Feb 2019 23:45:04 +0200
Subject: [PATCH 094/102] Add vec3 rotation

---
 mathc.c | 17 +++++++++++++++++
 mathc.h |  1 +
 2 files changed, 18 insertions(+)

diff --git a/mathc.c b/mathc.c
index b72e2ae..4855f25 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1382,6 +1382,23 @@ mfloat_t *vec3_reflect(mfloat_t *result, mfloat_t *v0, mfloat_t *normal)
 	return result;
 }
 
+mfloat_t *vec3_rotate(mfloat_t *result, mfloat_t *v0, mfloat_t *ra, mfloat_t f)
+{
+	mfloat_t cs = MCOS(f);
+	mfloat_t sn = MSIN(f);
+	mfloat_t x = v0[0];
+	mfloat_t y = v0[1];
+	mfloat_t z = v0[2];
+	vec3_normalize(ra, ra);
+	mfloat_t rx = ra[0];
+	mfloat_t ry = ra[1];
+	mfloat_t rz = ra[2];
+	result[0] = x * (cs + rx * rx*(1 - cs)) + y * (rx*ry*(1 - cs) - rz * sn) + z * (rx*rz*(1 - cs) + ry * sn);
+	result[1] = x * (ry*rx*(1 - cs) + rz * sn) + y * (cs + ry * ry*(1 - cs)) + z * (ry*rz*(1 - cs) - rx * sn);
+	result[2] = x * (rz*rx*(1 - cs) - ry * sn) + y * (rz*ry*(1 - cs) + rx * sn) + z * (cs + rz * rz*(1 - cs));
+	return result;
+}
+
 mfloat_t *vec3_lerp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t f)
 {
 	result[0] = v0[0] + (v1[0] - v0[0]) * f;
diff --git a/mathc.h b/mathc.h
index 2f64cac..6a674ff 100644
--- a/mathc.h
+++ b/mathc.h
@@ -562,6 +562,7 @@ mfloat_t vec3_dot(mfloat_t *v0, mfloat_t *v1);
 mfloat_t *vec3_project(mfloat_t *result, mfloat_t *v0, mfloat_t *v1);
 mfloat_t *vec3_slide(mfloat_t *result, mfloat_t *v0, mfloat_t *normal);
 mfloat_t *vec3_reflect(mfloat_t *result, mfloat_t *v0, mfloat_t *normal);
+mfloat_t *vec3_rotate(mfloat_t *result, mfloat_t *v0, mfloat_t *ra, mfloat_t f);
 mfloat_t *vec3_lerp(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t f);
 mfloat_t *vec3_bezier3(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2, mfloat_t f);
 mfloat_t *vec3_bezier4(mfloat_t *result, mfloat_t *v0, mfloat_t *v1, mfloat_t *v2, mfloat_t *v3, mfloat_t f);

From 10254aa74a69a97bcca3037fbcb9f39f5e1e2113 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <felselva@protonmail.com>
Date: Sat, 16 Feb 2019 11:24:11 -0300
Subject: [PATCH 095/102] Fix style and add wrapper functions

---
 mathc.c | 42 +++++++++++++++++++++++++++++++-----------
 mathc.h |  2 ++
 2 files changed, 33 insertions(+), 11 deletions(-)

diff --git a/mathc.c b/mathc.c
index 4855f25..ee0cb04 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1384,18 +1384,26 @@ mfloat_t *vec3_reflect(mfloat_t *result, mfloat_t *v0, mfloat_t *normal)
 
 mfloat_t *vec3_rotate(mfloat_t *result, mfloat_t *v0, mfloat_t *ra, mfloat_t f)
 {
-	mfloat_t cs = MCOS(f);
-	mfloat_t sn = MSIN(f);
-	mfloat_t x = v0[0];
-	mfloat_t y = v0[1];
-	mfloat_t z = v0[2];
+	mfloat_t cs;
+	mfloat_t sn;
+	mfloat_t x;
+	mfloat_t y;
+	mfloat_t z;
+	mfloat_t rx;
+	mfloat_t ry;
+	mfloat_t rz;
+	cs = MCOS(f);
+	sn = MSIN(f);
+	x = v0[0];
+	y = v0[1];
+	z = v0[2];
 	vec3_normalize(ra, ra);
-	mfloat_t rx = ra[0];
-	mfloat_t ry = ra[1];
-	mfloat_t rz = ra[2];
-	result[0] = x * (cs + rx * rx*(1 - cs)) + y * (rx*ry*(1 - cs) - rz * sn) + z * (rx*rz*(1 - cs) + ry * sn);
-	result[1] = x * (ry*rx*(1 - cs) + rz * sn) + y * (cs + ry * ry*(1 - cs)) + z * (ry*rz*(1 - cs) - rx * sn);
-	result[2] = x * (rz*rx*(1 - cs) - ry * sn) + y * (rz*ry*(1 - cs) + rx * sn) + z * (cs + rz * rz*(1 - cs));
+	rx = ra[0];
+	ry = ra[1];
+	rz = ra[2];
+	result[0] = x * (cs + rx * rx * (1 - cs)) + y * (rx * ry * (1 - cs) - rz * sn) + z * (rx * rz * (1 - cs) + ry * sn);
+	result[1] = x * (ry * rx * (1 - cs) + rz * sn) + y * (cs + ry * ry * (1 - cs)) + z * (ry * rz * (1 - cs) - rx * sn);
+	result[2] = x * (rz * rx * (1 - cs) - ry * sn) + y * (rz * ry * (1 - cs) + rx * sn) + z * (cs + rz * rz * (1 - cs));
 	return result;
 }
 
@@ -4375,6 +4383,13 @@ struct vec3 svec3_reflect(struct vec3 v0, struct vec3 normal)
 	return result;
 }
 
+struct vec3 svec3_rotate(struct vec3 v0, struct vec3 ra, mfloat_t f);
+{
+	struct vec3 result;
+	vec3_lerp((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&ra, f);
+	return result;
+}
+
 struct vec3 svec3_lerp(struct vec3 v0, struct vec3 v1, mfloat_t f)
 {
 	struct vec3 result;
@@ -5940,6 +5955,11 @@ struct vec3 *psvec3_reflect(struct vec3 *result, struct vec3 *v0, struct vec3 *n
 	return (struct vec3 *)vec3_reflect((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)normal);
 }
 
+struct vec3 *psvec3_rotate(struct vec3 *result, struct vec3 *v0, struct vec3 *ra, mfloat_t f);
+{
+	return (struct vec3 *)vec3_lerp((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)ra, f);
+}
+
 struct vec3 *psvec3_lerp(struct vec3 *result, struct vec3 *v0, struct vec3 *v1, mfloat_t f)
 {
 	return (struct vec3 *)vec3_lerp((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)v1, f);
diff --git a/mathc.h b/mathc.h
index 6a674ff..3c55ce2 100644
--- a/mathc.h
+++ b/mathc.h
@@ -848,6 +848,7 @@ mfloat_t svec3_dot(struct vec3 v0, struct vec3 v1);
 struct vec3 svec3_project(struct vec3 v0, struct vec3 v1);
 struct vec3 svec3_slide(struct vec3 v0, struct vec3 normal);
 struct vec3 svec3_reflect(struct vec3 v0, struct vec3 normal);
+struct vec3 svec3_rotate(struct vec3 v0, struct vec3 ra, mfloat_t f);
 struct vec3 svec3_lerp(struct vec3 v0, struct vec3 v1, mfloat_t f);
 struct vec3 svec3_bezier3(struct vec3 v0, struct vec3 v1, struct vec3 v2, mfloat_t f);
 struct vec3 svec3_bezier4(struct vec3 v0, struct vec3 v1, struct vec3 v2, struct vec3 v3, mfloat_t f);
@@ -1134,6 +1135,7 @@ mfloat_t psvec3_dot(struct vec3 *v0, struct vec3 *v1);
 struct vec3 *psvec3_project(struct vec3 *result, struct vec3 *v0, struct vec3 *v1);
 struct vec3 *psvec3_slide(struct vec3 *result, struct vec3 *v0, struct vec3 *normal);
 struct vec3 *psvec3_reflect(struct vec3 *result, struct vec3 *v0, struct vec3 *normal);
+struct vec3 *psvec3_rotate(struct vec3 *result, struct vec3 *v0, struct vec3 *ra, mfloat_t f);
 struct vec3 *psvec3_lerp(struct vec3 *result, struct vec3 *v0, struct vec3 *v1, mfloat_t f);
 struct vec3 *psvec3_bezier3(struct vec3 *result, struct vec3 *v0, struct vec3 *v1, struct vec3 *v2, mfloat_t f);
 struct vec3 *psvec3_bezier4(struct vec3 *result, struct vec3 *v0, struct vec3 *v1, struct vec3 *v2, struct vec3 *v3, mfloat_t f);

From 9ed911218b511d2593850edfae6a939ed03b281f Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <felselva@protonmail.com>
Date: Sat, 16 Feb 2019 11:26:17 -0300
Subject: [PATCH 096/102] Fix syntax error

---
 mathc.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/mathc.c b/mathc.c
index ee0cb04..a55a164 100644
--- a/mathc.c
+++ b/mathc.c
@@ -4383,7 +4383,7 @@ struct vec3 svec3_reflect(struct vec3 v0, struct vec3 normal)
 	return result;
 }
 
-struct vec3 svec3_rotate(struct vec3 v0, struct vec3 ra, mfloat_t f);
+struct vec3 svec3_rotate(struct vec3 v0, struct vec3 ra, mfloat_t f)
 {
 	struct vec3 result;
 	vec3_lerp((mfloat_t *)&result, (mfloat_t *)&v0, (mfloat_t *)&ra, f);
@@ -5955,7 +5955,7 @@ struct vec3 *psvec3_reflect(struct vec3 *result, struct vec3 *v0, struct vec3 *n
 	return (struct vec3 *)vec3_reflect((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)normal);
 }
 
-struct vec3 *psvec3_rotate(struct vec3 *result, struct vec3 *v0, struct vec3 *ra, mfloat_t f);
+struct vec3 *psvec3_rotate(struct vec3 *result, struct vec3 *v0, struct vec3 *ra, mfloat_t f)
 {
 	return (struct vec3 *)vec3_lerp((mfloat_t *)result, (mfloat_t *)v0, (mfloat_t *)ra, f);
 }

From 436fbbbafbe6e77f5f76ae28a4a52b3a87283472 Mon Sep 17 00:00:00 2001
From: Felipe Ferreira da Silva <felselva@protonmail.com>
Date: Sat, 16 Feb 2019 11:27:14 -0300
Subject: [PATCH 097/102] Bump version

---
 mathc.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/mathc.h b/mathc.h
index 3c55ce2..a9d7a5f 100644
--- a/mathc.h
+++ b/mathc.h
@@ -25,8 +25,8 @@ the following restrictions:
 #include <math.h>
 
 #define MATHC_VERSION_YYYY 2019
-#define MATHC_VERSION_MM 01
-#define MATHC_VERSION_DD 29
+#define MATHC_VERSION_MM 02
+#define MATHC_VERSION_DD 16
 #define MATHC_VERSION_MICRO 0
 
 #if !defined(MATHC_NO_INT)

From 14bee92cde8c4065065ee34ee5fa43f527a99c8a Mon Sep 17 00:00:00 2001
From: Eleftheria Chatziargyriou <ele.hatzy@gmail.com>
Date: Mon, 18 Feb 2019 23:05:27 +0200
Subject: [PATCH 098/102] Add 2D vector Orthonormalization (Gram-Schmidt
 process)

---
 mathc.c | 38 ++++++++++++++++++++++++++++++++++++++
 mathc.h |  2 ++
 2 files changed, 40 insertions(+)

diff --git a/mathc.c b/mathc.c
index a55a164..5e3e4da 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1096,6 +1096,44 @@ mfloat_t vec2_distance_squared(mfloat_t *v0, mfloat_t *v1)
 	return (v0[0] - v1[0]) * (v0[0] - v1[0]) + (v0[1] - v1[1]) * (v0[1] - v1[1]);
 }
 
+bool vec2_linear_independent(mfloat_t *v0, mfloat_t *v1)
+{
+	return (v0[0] * v1[1] - v1[0] * v0[1]) != 0;
+}
+
+mfloat_t** vec2_orthonormalization(mfloat_t result[2][2], mfloat_t basis[2][2])
+{
+	int N = sizeof(result[0]);
+	mfloat_t *v0 = malloc(N);
+	mfloat_t *v1 = malloc(N);
+	memcpy(v0, result[0], N);
+	memcpy(v1, result[1], N);
+
+	if (!vec2_linear_independent(v0, v1))
+	{
+		free(v0);
+		free(v1);
+		return result;
+	}
+
+	mfloat_t proju1[2];
+	mfloat_t *u0 = malloc(v0);
+	mfloat_t *u1 = malloc(N);
+	memcpy(u0, v0, N);
+
+	vec2_project(proju1, v1, v0);
+	vec2_subtract(u1, v1, proju1);
+	vec2_normalize(result[0], u0);
+	vec2_normalize(result[1], u1);
+
+	free(v0);
+	free(v1);
+	free(u0);
+	free(u1);
+
+	return result;
+}
+
 bool vec3_is_zero(mfloat_t *v0)
 {
 	return MFABS(v0[0]) < MFLT_EPSILON && MFABS(v0[1]) < MFLT_EPSILON && MFABS(v0[2]) < MFLT_EPSILON;
diff --git a/mathc.h b/mathc.h
index a9d7a5f..ba37ba4 100644
--- a/mathc.h
+++ b/mathc.h
@@ -527,6 +527,8 @@ mfloat_t vec2_length(mfloat_t *v0);
 mfloat_t vec2_length_squared(mfloat_t *v0);
 mfloat_t vec2_distance(mfloat_t *v0, mfloat_t *v1);
 mfloat_t vec2_distance_squared(mfloat_t *v0, mfloat_t *v1);
+bool vec2_linear_independent(mfloat_t *v0, mfloat_t *v1);
+mfloat_t** vec2_orthonormalization(mfloat_t result[2][2], mfloat_t basis[2][2]);
 bool vec3_is_zero(mfloat_t *v0);
 bool vec3_is_equal(mfloat_t *v0, mfloat_t *v1);
 mfloat_t *vec3(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z);

From c015a80fa1351474df078461b8dc22b336a46474 Mon Sep 17 00:00:00 2001
From: Eleftheria Chatziargyriou <ele.hatzy@gmail.com>
Date: Tue, 19 Feb 2019 00:46:53 +0200
Subject: [PATCH 099/102] Add 3D vector Orthonormalization (Gram-Schmidt
 process)

---
 mathc.c | 64 +++++++++++++++++++++++++++++++++++++++++++++++++++------
 mathc.h |  2 ++
 2 files changed, 60 insertions(+), 6 deletions(-)

diff --git a/mathc.c b/mathc.c
index 5e3e4da..aff7834 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1103,11 +1103,11 @@ bool vec2_linear_independent(mfloat_t *v0, mfloat_t *v1)
 
 mfloat_t** vec2_orthonormalization(mfloat_t result[2][2], mfloat_t basis[2][2])
 {
-	int N = sizeof(result[0]);
+	int N = sizeof(basis[0]);
 	mfloat_t *v0 = malloc(N);
 	mfloat_t *v1 = malloc(N);
-	memcpy(v0, result[0], N);
-	memcpy(v1, result[1], N);
+	memcpy(v0, basis[0], N);
+	memcpy(v1, basis[1], N);
 
 	if (!vec2_linear_independent(v0, v1))
 	{
@@ -1117,7 +1117,7 @@ mfloat_t** vec2_orthonormalization(mfloat_t result[2][2], mfloat_t basis[2][2])
 	}
 
 	mfloat_t proju1[2];
-	mfloat_t *u0 = malloc(v0);
+	mfloat_t *u0 = malloc(N);
 	mfloat_t *u1 = malloc(N);
 	memcpy(u0, v0, N);
 
@@ -1394,8 +1394,8 @@ mfloat_t vec3_dot(mfloat_t *v0, mfloat_t *v1)
 
 mfloat_t *vec3_project(mfloat_t *result, mfloat_t *v0, mfloat_t *v1)
 {
-	mfloat_t d = vec2_dot(v1, v1);
-	mfloat_t s = vec2_dot(v0, v1) / d;
+	mfloat_t d = vec3_dot(v1, v1);
+	mfloat_t s = vec3_dot(v0, v1) / d;
 	result[0] = v1[0] * s;
 	result[1] = v1[1] * s;
 	result[2] = v1[2] * s;
@@ -1499,6 +1499,58 @@ mfloat_t vec3_distance_squared(mfloat_t *v0, mfloat_t *v1)
 	return (v0[0] - v1[0]) * (v0[0] - v1[0]) + (v0[1] - v1[1]) * (v0[1] - v1[1]) + (v0[2] - v1[2]) * (v0[2] - v1[2]);
 }
 
+bool vec3_linear_independent(mfloat_t *v0, mfloat_t *v1, mfloat_t *v2)
+{
+	return v0[0] * v1[1] * v2[2] + v0[1] * v1[2] * v2[0] + v0[2] * v1[0] * v2[1]
+		- v0[2] * v1[1] * v2[0] - v0[1] * v1[0] * v2[2] - v0[0] * v1[2] * v2[1];
+}
+
+mfloat_t** vec3_orthonormalization(mfloat_t result[3][3], mfloat_t basis[3][3])
+{
+	int N = sizeof(basis[0]);
+	mfloat_t *v0 = malloc(N);
+	mfloat_t *v1 = malloc(N);
+	mfloat_t *v2 = malloc(N);
+
+	memcpy(v0, basis[0], N);
+	memcpy(v1, basis[1], N);
+	memcpy(v2, basis[2], N);
+
+	if (!vec3_linear_independent(v0, v1, v2))
+	{
+		free(v0);
+		free(v1);
+		free(v2);
+		return result;
+	}
+
+	mfloat_t proj[3];
+	mfloat_t *u0 = malloc(N);
+	mfloat_t *u1 = malloc(N);
+	mfloat_t *u2 = malloc(N);
+	memcpy(u0, v0, N);
+	vec3_project(proj, v1, u0);
+	vec3_subtract(u1, v1, proj);
+
+	vec3_project(proj, v2, u0);
+	vec3_subtract(u2, v2, proj);
+	vec3_project(proj, v2, u1);
+	vec3_subtract(u2, u2, proj);
+
+	vec3_normalize(result[0], u0);
+	vec3_normalize(result[1], u1);
+	vec3_normalize(result[2], u2);
+
+	free(v0);
+	free(v1);
+	free(v2);
+	free(u0);
+	free(u1);
+	free(u2);
+
+	return result;
+}
+
 bool vec4_is_zero(mfloat_t *v0)
 {
 	return MFABS(v0[0]) < MFLT_EPSILON && MFABS(v0[1]) < MFLT_EPSILON && MFABS(v0[2]) < MFLT_EPSILON && MFABS(v0[3]) < MFLT_EPSILON;
diff --git a/mathc.h b/mathc.h
index ba37ba4..4f9f5e1 100644
--- a/mathc.h
+++ b/mathc.h
@@ -572,6 +572,8 @@ mfloat_t vec3_length(mfloat_t *v0);
 mfloat_t vec3_length_squared(mfloat_t *v0);
 mfloat_t vec3_distance(mfloat_t *v0, mfloat_t *v1);
 mfloat_t vec3_distance_squared(mfloat_t *v0, mfloat_t *v1);
+bool vec3_linear_independent(mfloat_t *v0, mfloat_t *v1, mfloat_t *v2);
+mfloat_t** vec3_orthonormalization(mfloat_t result[3][3], mfloat_t basis[3][3]);
 bool vec4_is_zero(mfloat_t *v0);
 bool vec4_is_equal(mfloat_t *v0, mfloat_t *v1);
 mfloat_t *vec4(mfloat_t *result, mfloat_t x, mfloat_t y, mfloat_t z, mfloat_t w);

From 20e4dd587eed09dc00e6e332757a709bc63d7ce8 Mon Sep 17 00:00:00 2001
From: Maarten Meijer <MaartenMJR@users.noreply.github.com>
Date: Fri, 22 Mar 2019 09:11:14 +0100
Subject: [PATCH 100/102] Fix error in the last element of the identity matrix

---
 mathc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mathc.c b/mathc.c
index aff7834..afbd307 100644
--- a/mathc.c
+++ b/mathc.c
@@ -2297,7 +2297,7 @@ mfloat_t *mat3_identity(mfloat_t *result)
 	result[5] = MFLOAT_C(0.0);
 	result[6] = MFLOAT_C(0.0);
 	result[7] = MFLOAT_C(0.0);
-	result[8] = MFLOAT_C(8.0);
+	result[8] = MFLOAT_C(1.0);
 	return result;
 }
 

From 4e4e0eec61d6e7f3493d5ff442bdc13edff92d7c Mon Sep 17 00:00:00 2001
From: fabiopolimeni <fabio.polimeni@outlook.com>
Date: Sun, 5 May 2019 11:27:01 +0200
Subject: [PATCH 101/102] Remove malloc and memcpy from orthonormalization
 functions

---
 mathc.c | 85 ++++++++++++++++++++++++++-------------------------------
 1 file changed, 38 insertions(+), 47 deletions(-)

diff --git a/mathc.c b/mathc.c
index afbd307..ed17d71 100644
--- a/mathc.c
+++ b/mathc.c
@@ -1103,35 +1103,32 @@ bool vec2_linear_independent(mfloat_t *v0, mfloat_t *v1)
 
 mfloat_t** vec2_orthonormalization(mfloat_t result[2][2], mfloat_t basis[2][2])
 {
-	int N = sizeof(basis[0]);
-	mfloat_t *v0 = malloc(N);
-	mfloat_t *v1 = malloc(N);
-	memcpy(v0, basis[0], N);
-	memcpy(v1, basis[1], N);
-
-	if (!vec2_linear_independent(v0, v1))
-	{
-		free(v0);
-		free(v1);
-		return result;
+	mfloat_t v0[2];
+	mfloat_t v1[2];
+
+	for(int32_t i = 0; i < 2; ++i) {
+		v0[i] = basis[0][i];
+		v1[i] = basis[1][i];
+	}
+
+	if (!vec2_linear_independent(v0, v1)) {
+		return (mfloat_t**)result;
 	}
 
 	mfloat_t proju1[2];
-	mfloat_t *u0 = malloc(N);
-	mfloat_t *u1 = malloc(N);
-	memcpy(u0, v0, N);
+	mfloat_t u0[2];
+	mfloat_t u1[2];
+
+	for(int32_t i = 0; i < 2; ++i) {
+		u0[i] = v0[i];
+	}
 
 	vec2_project(proju1, v1, v0);
 	vec2_subtract(u1, v1, proju1);
 	vec2_normalize(result[0], u0);
 	vec2_normalize(result[1], u1);
 
-	free(v0);
-	free(v1);
-	free(u0);
-	free(u1);
-
-	return result;
+	return (mfloat_t**)result;
 }
 
 bool vec3_is_zero(mfloat_t *v0)
@@ -1507,28 +1504,29 @@ bool vec3_linear_independent(mfloat_t *v0, mfloat_t *v1, mfloat_t *v2)
 
 mfloat_t** vec3_orthonormalization(mfloat_t result[3][3], mfloat_t basis[3][3])
 {
-	int N = sizeof(basis[0]);
-	mfloat_t *v0 = malloc(N);
-	mfloat_t *v1 = malloc(N);
-	mfloat_t *v2 = malloc(N);
-
-	memcpy(v0, basis[0], N);
-	memcpy(v1, basis[1], N);
-	memcpy(v2, basis[2], N);
-
-	if (!vec3_linear_independent(v0, v1, v2))
-	{
-		free(v0);
-		free(v1);
-		free(v2);
-		return result;
+	mfloat_t v0[3];
+	mfloat_t v1[3];
+	mfloat_t v2[3];
+	
+	for(int32_t i = 0; i < 3; ++i) {
+		v0[i] = basis[0][i];
+		v1[i] = basis[1][i];
+		v2[i] = basis[2][i];
+	}
+
+	if (!vec3_linear_independent(v0, v1, v2)) {
+		return (mfloat_t**)result;
 	}
 
 	mfloat_t proj[3];
-	mfloat_t *u0 = malloc(N);
-	mfloat_t *u1 = malloc(N);
-	mfloat_t *u2 = malloc(N);
-	memcpy(u0, v0, N);
+	mfloat_t u0[3];
+	mfloat_t u1[3];
+	mfloat_t u2[3];
+
+	for(int32_t i = 0; i < 3; ++i) {
+		u0[i] = v0[i];
+	}
+
 	vec3_project(proj, v1, u0);
 	vec3_subtract(u1, v1, proj);
 
@@ -1541,14 +1539,7 @@ mfloat_t** vec3_orthonormalization(mfloat_t result[3][3], mfloat_t basis[3][3])
 	vec3_normalize(result[1], u1);
 	vec3_normalize(result[2], u2);
 
-	free(v0);
-	free(v1);
-	free(v2);
-	free(u0);
-	free(u1);
-	free(u2);
-
-	return result;
+	return (mfloat_t**)result;
 }
 
 bool vec4_is_zero(mfloat_t *v0)

From d672725203fc80f6f79fba64533b87d51c32d714 Mon Sep 17 00:00:00 2001
From: fabiopolimeni <fabio.polimeni@outlook.com>
Date: Thu, 16 May 2019 22:50:52 +0200
Subject: [PATCH 102/102] fix mat4_axis_angle and quat_to_mat4 bugs

---
 mathc.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/mathc.c b/mathc.c
index ed17d71..888d9f3 100644
--- a/mathc.c
+++ b/mathc.c
@@ -2981,8 +2981,8 @@ mfloat_t *mat4_rotation_axis(mfloat_t *result, mfloat_t *v0, mfloat_t f)
 	mfloat_t s = MSIN(f);
 	mfloat_t one_c = MFLOAT_C(1.0) - c;
 	mfloat_t x = v0[0];
-	mfloat_t y = v0[4];
-	mfloat_t z = v0[8];
+	mfloat_t y = v0[1];
+	mfloat_t z = v0[2];
 	mfloat_t xx = x * x;
 	mfloat_t xy = x * y;
 	mfloat_t xz = x * z;
@@ -3017,21 +3017,21 @@ mfloat_t *mat4_rotation_quat(mfloat_t *result, mfloat_t *q0)
 	mfloat_t zz = q0[2] * q0[2];
 	mfloat_t xy = q0[0] * q0[1];
 	mfloat_t zw = q0[2] * q0[3];
-	mfloat_t xz = q0[8] * q0[0];
+	mfloat_t xz = q0[0] * q0[2];
 	mfloat_t yw = q0[1] * q0[3];
 	mfloat_t yz = q0[1] * q0[2];
 	mfloat_t xw = q0[0] * q0[3];
-	result[0] = MFLOAT_C(1.0) - MFLOAT_C(2.0) * (yy - zz);
+	result[0] = MFLOAT_C(1.0) - MFLOAT_C(2.0) * (yy + zz);
 	result[1] = MFLOAT_C(2.0) * (xy + zw);
 	result[2] = MFLOAT_C(2.0) * (xz - yw);
 	result[3] = MFLOAT_C(0.0);
 	result[4] = MFLOAT_C(2.0) * (xy - zw);
-	result[5] = MFLOAT_C(1.0) - MFLOAT_C(2.0) * (xx - zz);
+	result[5] = MFLOAT_C(1.0) - MFLOAT_C(2.0) * (xx + zz);
 	result[6] = MFLOAT_C(2.0) * (yz + xw);
 	result[7] = MFLOAT_C(0.0);
 	result[8] = MFLOAT_C(2.0) * (xz + yw);
 	result[9] = MFLOAT_C(2.0) * (yz - xw);
-	result[10] = MFLOAT_C(1.0) - MFLOAT_C(2.0) * (xx - yy);
+	result[10] = MFLOAT_C(1.0) - MFLOAT_C(2.0) * (xx + yy);
 	result[11] = MFLOAT_C(0.0);
 	result[12] = MFLOAT_C(0.0);
 	result[13] = MFLOAT_C(0.0);