Improve math/linalg to support both f32 and f64 basic procedures for the specific*.odin files

core/math/linalg/general.odin

@@ -313,3 +313,31 @@ hermite :: proc(v1, t1, v2, t2: $T/[$N]$E, s: E) -> T {
 cubic :: proc(v1, v2, v3, v4: $T/[$N]$E, s: E) -> T {
 	return ((v1 * s + v2) * s + v3) * s + v3;
 }
+
+
+
+array_cast :: proc(v: $A/[$N]$T, $U: typeid) -> [N]U {
+	w: [N]U;
+	for _, i in v do w[i] = U(v[i]);
+	return w;
+}
+
+to_f32  :: #force_inline proc(v: $A/[$N]$T) -> [N]f32  { return array_cast(v, f32);  }
+to_f64  :: #force_inline proc(v: $A/[$N]$T) -> [N]f64  { return array_cast(v, f64);  }
+
+to_i8   :: #force_inline proc(v: $A/[$N]$T) -> [N]i8   { return array_cast(v, i8);   }
+to_i16  :: #force_inline proc(v: $A/[$N]$T) -> [N]i16  { return array_cast(v, i16);  }
+to_i32  :: #force_inline proc(v: $A/[$N]$T) -> [N]i32  { return array_cast(v, i32);  }
+to_i64  :: #force_inline proc(v: $A/[$N]$T) -> [N]i64  { return array_cast(v, i64);  }
+to_int  :: #force_inline proc(v: $A/[$N]$T) -> [N]int  { return array_cast(v, int);  }
+
+to_u8   :: #force_inline proc(v: $A/[$N]$T) -> [N]u8   { return array_cast(v, u8);   }
+to_u16  :: #force_inline proc(v: $A/[$N]$T) -> [N]u16  { return array_cast(v, u16);  }
+to_u32  :: #force_inline proc(v: $A/[$N]$T) -> [N]u32  { return array_cast(v, u32);  }
+to_u64  :: #force_inline proc(v: $A/[$N]$T) -> [N]u64  { return array_cast(v, u64);  }
+to_uint :: #force_inline proc(v: $A/[$N]$T) -> [N]uint { return array_cast(v, uint); }
+
+to_complex64     :: #force_inline proc(v: $A/[$N]$T) -> [N]complex64     { return array_cast(v, complex64);     }
+to_complex128    :: #force_inline proc(v: $A/[$N]$T) -> [N]complex128    { return array_cast(v, complex128);    }
+to_quaternion128 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion128 { return array_cast(v, quaternion128); }
+to_quaternion256 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion256 { return array_cast(v, quaternion256); }

core/math/linalg/specific_euler_angles.odin

@@ -1,7 +1,5 @@
 package linalg
 
-import "core:math"
-
 Euler_Angle_Order :: enum {
 	// Tait-Bryan
 	XYZ,
@@ -20,796 +18,64 @@ Euler_Angle_Order :: enum {
 	ZYZ,
 }
 
-euler_angles_from_matrix4 :: proc(m: Matrix4, order: Euler_Angle_Order) -> (t1, t2, t3: Float) {
-	switch order {
-	case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix4(m);
-	case .XZY: t1, t2, t3 = euler_angles_xzy_from_matrix4(m);
-	case .YXZ: t1, t2, t3 = euler_angles_yxz_from_matrix4(m);
-	case .YZX: t1, t2, t3 = euler_angles_yzx_from_matrix4(m);
-	case .ZXY: t1, t2, t3 = euler_angles_zxy_from_matrix4(m);
-	case .ZYX: t1, t2, t3 = euler_angles_zyx_from_matrix4(m);
-	case .XYX: t1, t2, t3 = euler_angles_xyx_from_matrix4(m);
-	case .XZX: t1, t2, t3 = euler_angles_xzx_from_matrix4(m);
-	case .YXY: t1, t2, t3 = euler_angles_yxy_from_matrix4(m);
-	case .YZY: t1, t2, t3 = euler_angles_yzy_from_matrix4(m);
-	case .ZXZ: t1, t2, t3 = euler_angles_zxz_from_matrix4(m);
-	case .ZYZ: t1, t2, t3 = euler_angles_zyz_from_matrix4(m);
-	}
-	return;
-}
-euler_angles_from_quaternion :: proc(m: Quaternion, order: Euler_Angle_Order) -> (t1, t2, t3: Float) {
-	switch order {
-	case .XYZ: t1, t2, t3 = euler_angles_xyz_from_quaternion(m);
-	case .XZY: t1, t2, t3 = euler_angles_xzy_from_quaternion(m);
-	case .YXZ: t1, t2, t3 = euler_angles_yxz_from_quaternion(m);
-	case .YZX: t1, t2, t3 = euler_angles_yzx_from_quaternion(m);
-	case .ZXY: t1, t2, t3 = euler_angles_zxy_from_quaternion(m);
-	case .ZYX: t1, t2, t3 = euler_angles_zyx_from_quaternion(m);
-	case .XYX: t1, t2, t3 = euler_angles_xyx_from_quaternion(m);
-	case .XZX: t1, t2, t3 = euler_angles_xzx_from_quaternion(m);
-	case .YXY: t1, t2, t3 = euler_angles_yxy_from_quaternion(m);
-	case .YZY: t1, t2, t3 = euler_angles_yzy_from_quaternion(m);
-	case .ZXZ: t1, t2, t3 = euler_angles_zxz_from_quaternion(m);
-	case .ZYZ: t1, t2, t3 = euler_angles_zyz_from_quaternion(m);
-	}
-	return;
-}
-
-matrix4_from_euler_angles :: proc(t1, t2, t3: Float, order: Euler_Angle_Order) -> (m: Matrix4) {
-	switch order {
-	case .XYZ: return matrix4_from_euler_angles_xyz(t1, t2, t3); // m1, m2, m3 = X(t1), Y(t2), Z(t3);
-	case .XZY: return matrix4_from_euler_angles_xzy(t1, t2, t3); // m1, m2, m3 = X(t1), Z(t2), Y(t3);
-	case .YXZ: return matrix4_from_euler_angles_yxz(t1, t2, t3); // m1, m2, m3 = Y(t1), X(t2), Z(t3);
-	case .YZX: return matrix4_from_euler_angles_yzx(t1, t2, t3); // m1, m2, m3 = Y(t1), Z(t2), X(t3);
-	case .ZXY: return matrix4_from_euler_angles_zxy(t1, t2, t3); // m1, m2, m3 = Z(t1), X(t2), Y(t3);
-	case .ZYX: return matrix4_from_euler_angles_zyx(t1, t2, t3); // m1, m2, m3 = Z(t1), Y(t2), X(t3);
-	case .XYX: return matrix4_from_euler_angles_xyx(t1, t2, t3); // m1, m2, m3 = X(t1), Y(t2), X(t3);
-	case .XZX: return matrix4_from_euler_angles_xzx(t1, t2, t3); // m1, m2, m3 = X(t1), Z(t2), X(t3);
-	case .YXY: return matrix4_from_euler_angles_yxy(t1, t2, t3); // m1, m2, m3 = Y(t1), X(t2), Y(t3);
-	case .YZY: return matrix4_from_euler_angles_yzy(t1, t2, t3); // m1, m2, m3 = Y(t1), Z(t2), Y(t3);
-	case .ZXZ: return matrix4_from_euler_angles_zxz(t1, t2, t3); // m1, m2, m3 = Z(t1), X(t2), Z(t3);
-	case .ZYZ: return matrix4_from_euler_angles_zyz(t1, t2, t3); // m1, m2, m3 = Z(t1), Y(t2), Z(t3);
-	}
-	return;
-}
-
-quaternion_from_euler_angles :: proc(t1, t2, t3: Float, order: Euler_Angle_Order) -> Quaternion {
-	X :: quaternion_from_euler_angle_x;
-	Y :: quaternion_from_euler_angle_y;
-	Z :: quaternion_from_euler_angle_z;
-
-	q1, q2, q3: Quaternion;
-
-	switch order {
-	case .XYZ: q1, q2, q3 = X(t1), Y(t2), Z(t3);
-	case .XZY: q1, q2, q3 = X(t1), Z(t2), Y(t3);
-	case .YXZ: q1, q2, q3 = Y(t1), X(t2), Z(t3);
-	case .YZX: q1, q2, q3 = Y(t1), Z(t2), X(t3);
-	case .ZXY: q1, q2, q3 = Z(t1), X(t2), Y(t3);
-	case .ZYX: q1, q2, q3 = Z(t1), Y(t2), X(t3);
-	case .XYX: q1, q2, q3 = X(t1), Y(t2), X(t3);
-	case .XZX: q1, q2, q3 = X(t1), Z(t2), X(t3);
-	case .YXY: q1, q2, q3 = Y(t1), X(t2), Y(t3);
-	case .YZY: q1, q2, q3 = Y(t1), Z(t2), Y(t3);
-	case .ZXZ: q1, q2, q3 = Z(t1), X(t2), Z(t3);
-	case .ZYZ: q1, q2, q3 = Z(t1), Y(t2), Z(t3);
-	}
-
-	return q1 * (q2 * q3);
-}
-
-
-// Quaternions
-
-quaternion_from_euler_angle_x :: proc(angle_x: Float) -> (q: Quaternion) {
-	return quaternion_angle_axis(angle_x, Vector3{1, 0, 0});
-}
-quaternion_from_euler_angle_y :: proc(angle_y: Float) -> (q: Quaternion) {
-	return quaternion_angle_axis(angle_y, Vector3{0, 1, 0});
-}
-quaternion_from_euler_angle_z :: proc(angle_z: Float) -> (q: Quaternion) {
-	return quaternion_angle_axis(angle_z, Vector3{0, 0, 1});
-}
-
-quaternion_from_pitch_yaw_roll :: proc(pitch, yaw, roll: Float) -> Quaternion {
-	a, b, c := pitch, yaw, roll;
-
-	ca, sa := math.cos(a*0.5), math.sin(a*0.5);
-	cb, sb := math.cos(b*0.5), math.sin(b*0.5);
-	cc, sc := math.cos(c*0.5), math.sin(c*0.5);
-
-	q: Quaternion;
-	q.x = sa*cb*cc - ca*sb*sc;
-	q.y = ca*sb*cc + sa*cb*sc;
-	q.z = ca*cb*sc - sa*sb*cc;
-	q.w = ca*cb*cc + sa*sb*sc;
-	return q;
-}
-
-roll_from_quaternion :: proc(q: Quaternion) -> Float {
-	return math.atan2(2 * q.x*q.y + q.w*q.z, q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z);
-}
-
-pitch_from_quaternion :: proc(q: Quaternion) -> Float {
-	y := 2 * (q.y*q.z + q.w*q.w);
-	x := q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z;
-
-	if abs(x) <= FLOAT_EPSILON && abs(y) <= FLOAT_EPSILON {
-		return 2 * math.atan2(q.x, q.w);
-	}
-
-	return math.atan2(y, x);
-}
-
-yaw_from_quaternion :: proc(q: Quaternion) -> Float {
-	return math.asin(clamp(-2 * (q.x*q.z - q.w*q.y), -1, 1));
-}
-
-
-pitch_yaw_roll_from_quaternion :: proc(q: Quaternion) -> (pitch, yaw, roll: Float) {
-	pitch = pitch_from_quaternion(q);
-	yaw = yaw_from_quaternion(q);
-	roll = roll_from_quaternion(q);
-	return;
-}
-
-euler_angles_xyz_from_quaternion :: proc(q: Quaternion) -> (t1, t2, t3: Float) {
-	return euler_angles_xyz_from_matrix4(matrix4_from_quaternion(q));
-}
-euler_angles_yxz_from_quaternion :: proc(q: Quaternion) -> (t1, t2, t3: Float) {
-	return euler_angles_yxz_from_matrix4(matrix4_from_quaternion(q));
-}
-euler_angles_xzx_from_quaternion :: proc(q: Quaternion) -> (t1, t2, t3: Float) {
-	return euler_angles_xzx_from_matrix4(matrix4_from_quaternion(q));
-}
-euler_angles_xyx_from_quaternion :: proc(q: Quaternion) -> (t1, t2, t3: Float) {
-	return euler_angles_xyx_from_matrix4(matrix4_from_quaternion(q));
-}
-euler_angles_yxy_from_quaternion :: proc(q: Quaternion) -> (t1, t2, t3: Float) {
-	return euler_angles_yxy_from_matrix4(matrix4_from_quaternion(q));
-}
-euler_angles_yzy_from_quaternion :: proc(q: Quaternion) -> (t1, t2, t3: Float) {
-	return euler_angles_yzy_from_matrix4(matrix4_from_quaternion(q));
-}
-euler_angles_zyz_from_quaternion :: proc(q: Quaternion) -> (t1, t2, t3: Float) {
-	return euler_angles_zyz_from_matrix4(matrix4_from_quaternion(q));
-}
-euler_angles_zxz_from_quaternion :: proc(q: Quaternion) -> (t1, t2, t3: Float) {
-	return euler_angles_zxz_from_matrix4(matrix4_from_quaternion(q));
-}
-euler_angles_xzy_from_quaternion :: proc(q: Quaternion) -> (t1, t2, t3: Float) {
-	return euler_angles_xzy_from_matrix4(matrix4_from_quaternion(q));
-}
-euler_angles_yzx_from_quaternion :: proc(q: Quaternion) -> (t1, t2, t3: Float) {
-	return euler_angles_yzx_from_matrix4(matrix4_from_quaternion(q));
-}
-euler_angles_zyx_from_quaternion :: proc(q: Quaternion) -> (t1, t2, t3: Float) {
-	return euler_angles_zyx_from_matrix4(matrix4_from_quaternion(q));
-}
-euler_angles_zxy_from_quaternion :: proc(q: Quaternion) -> (t1, t2, t3: Float) {
-	return euler_angles_zxy_from_matrix4(matrix4_from_quaternion(q));
-}
-
-
-// Matrices
-
-
-matrix4_from_euler_angle_x :: proc(angle_x: Float) -> (m: Matrix4) {
-	cos_x, sin_x := math.cos(angle_x), math.sin(angle_x);
-	m[0][0] = 1;
-	m[1][1] = +cos_x;
-	m[2][1] = +sin_x;
-	m[1][2] = -sin_x;
-	m[2][2] = +cos_x;
-	m[3][3] = 1;
-	return;
-}
-matrix4_from_euler_angle_y :: proc(angle_y: Float) -> (m: Matrix4) {
-	cos_y, sin_y := math.cos(angle_y), math.sin(angle_y);
-	m[0][0] = +cos_y;
-	m[2][0] = -sin_y;
-	m[1][1] = 1;
-	m[0][2] = +sin_y;
-	m[2][2] = +cos_y;
-	m[3][3] = 1;
-	return;
-}
-matrix4_from_euler_angle_z :: proc(angle_z: Float) -> (m: Matrix4) {
-	cos_z, sin_z := math.cos(angle_z), math.sin(angle_z);
-	m[0][0] = +cos_z;
-	m[1][0] = +sin_z;
-	m[1][1] = +cos_z;
-	m[0][1] = -sin_z;
-	m[2][2] = 1;
-	m[3][3] = 1;
-	return;
-}
-
-
-matrix4_from_derived_euler_angle_x :: proc(angle_x: Float, angular_velocity_x: Float) -> (m: Matrix4) {
-	cos_x := math.cos(angle_x) * angular_velocity_x;
-	sin_x := math.sin(angle_x) * angular_velocity_x;
-	m[0][0] = 1;
-	m[1][1] = +cos_x;
-	m[2][1] = +sin_x;
-	m[1][2] = -sin_x;
-	m[2][2] = +cos_x;
-	m[3][3] = 1;
-	return;
-}
-matrix4_from_derived_euler_angle_y :: proc(angle_y: Float, angular_velocity_y: Float) -> (m: Matrix4) {
-	cos_y := math.cos(angle_y) * angular_velocity_y;
-	sin_y := math.sin(angle_y) * angular_velocity_y;
-	m[0][0] = +cos_y;
-	m[2][0] = -sin_y;
-	m[1][1] = 1;
-	m[0][2] = +sin_y;
-	m[2][2] = +cos_y;
-	m[3][3] = 1;
-	return;
-}
-matrix4_from_derived_euler_angle_z :: proc(angle_z: Float, angular_velocity_z: Float) -> (m: Matrix4) {
-	cos_z := math.cos(angle_z) * angular_velocity_z;
-	sin_z := math.sin(angle_z) * angular_velocity_z;
-	m[0][0] = +cos_z;
-	m[1][0] = +sin_z;
-	m[1][1] = +cos_z;
-	m[0][1] = -sin_z;
-	m[2][2] = 1;
-	m[3][3] = 1;
-	return;
-}
-
-
-matrix4_from_euler_angles_xy :: proc(angle_x, angle_y: Float) -> (m: Matrix4) {
-	cos_x, sin_x := math.cos(angle_x), math.sin(angle_x);
-	cos_y, sin_y := math.cos(angle_y), math.sin(angle_y);
-	m[0][0] = cos_y;
-	m[1][0] = -sin_x * - sin_y;
-	m[2][0] = -cos_x * - sin_y;
-	m[1][1] = cos_x;
-	m[2][1] = sin_x;
-	m[0][2] = sin_y;
-	m[1][2] = -sin_x * cos_y;
-	m[2][2] = cos_x * cos_y;
-	m[3][3] = 1;
-	return;
-}
-
-
-matrix4_from_euler_angles_yx :: proc(angle_y, angle_x: Float) -> (m: Matrix4) {
-	cos_x, sin_x := math.cos(angle_x), math.sin(angle_x);
-	cos_y, sin_y := math.cos(angle_y), math.sin(angle_y);
-	m[0][0] = cos_y;
-	m[2][0] = -sin_y;
-	m[0][1] = sin_y*sin_x;
-	m[1][1] = cos_x;
-	m[2][1] = cos_y*sin_x;
-	m[0][2] = sin_y*cos_x;
-	m[1][2] = -sin_x;
-	m[2][2] = cos_y*cos_x;
-	m[3][3] = 1;
-	return;
-}
-
-matrix4_from_euler_angles_xz :: proc(angle_x, angle_z: Float) -> (m: Matrix4) {
-	return mul(matrix4_from_euler_angle_x(angle_x), matrix4_from_euler_angle_z(angle_z));
-}
-matrix4_from_euler_angles_zx :: proc(angle_z, angle_x: Float) -> (m: Matrix4) {
-	return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_x(angle_x));
-}
-matrix4_from_euler_angles_yz :: proc(angle_y, angle_z: Float) -> (m: Matrix4) {
-	return mul(matrix4_from_euler_angle_y(angle_y), matrix4_from_euler_angle_z(angle_z));
-}
-matrix4_from_euler_angles_zy :: proc(angle_z, angle_y: Float) -> (m: Matrix4) {
-	return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_y(angle_y));
-}
-
-
-matrix4_from_euler_angles_xyz :: proc(t1, t2, t3: Float) -> (m: Matrix4) {
-	c1 := math.cos(-t1);
-	c2 := math.cos(-t2);
-	c3 := math.cos(-t3);
-	s1 := math.sin(-t1);
-	s2 := math.sin(-t2);
-	s3 := math.sin(-t3);
-
-	m[0][0] = c2 * c3;
-	m[0][1] =-c1 * s3 + s1 * s2 * c3;
-	m[0][2] = s1 * s3 + c1 * s2 * c3;
-	m[0][3] = 0;
-	m[1][0] = c2 * s3;
-	m[1][1] = c1 * c3 + s1 * s2 * s3;
-	m[1][2] =-s1 * c3 + c1 * s2 * s3;
-	m[1][3] = 0;
-	m[2][0] =-s2;
-	m[2][1] = s1 * c2;
-	m[2][2] = c1 * c2;
-	m[2][3] = 0;
-	m[3][0] = 0;
-	m[3][1] = 0;
-	m[3][2] = 0;
-	m[3][3] = 1;
-	return;
-}
-
-matrix4_from_euler_angles_yxz :: proc(yaw, pitch, roll: Float) -> (m: Matrix4) {
-	ch := math.cos(yaw);
-	sh := math.sin(yaw);
-	cp := math.cos(pitch);
-	sp := math.sin(pitch);
-	cb := math.cos(roll);
-	sb := math.sin(roll);
-
-	m[0][0] = ch * cb + sh * sp * sb;
-	m[0][1] = sb * cp;
-	m[0][2] = -sh * cb + ch * sp * sb;
-	m[0][3] = 0;
-	m[1][0] = -ch * sb + sh * sp * cb;
-	m[1][1] = cb * cp;
-	m[1][2] = sb * sh + ch * sp * cb;
-	m[1][3] = 0;
-	m[2][0] = sh * cp;
-	m[2][1] = -sp;
-	m[2][2] = ch * cp;
-	m[2][3] = 0;
-	m[3][0] = 0;
-	m[3][1] = 0;
-	m[3][2] = 0;
-	m[3][3] = 1;
-	return;
-}
-
-matrix4_from_euler_angles_xzx :: proc(t1, t2, t3: Float) -> (m: Matrix4) {
-	c1 := math.cos(t1);
-	s1 := math.sin(t1);
-	c2 := math.cos(t2);
-	s2 := math.sin(t2);
-	c3 := math.cos(t3);
-	s3 := math.sin(t3);
-
-	m[0][0] = c2;
-	m[0][1] = c1 * s2;
-	m[0][2] = s1 * s2;
-	m[0][3] = 0;
-	m[1][0] =-c3 * s2;
-	m[1][1] = c1 * c2 * c3 - s1 * s3;
-	m[1][2] = c1 * s3 + c2 * c3 * s1;
-	m[1][3] = 0;
-	m[2][0] = s2 * s3;
-	m[2][1] =-c3 * s1 - c1 * c2 * s3;
-	m[2][2] = c1 * c3 - c2 * s1 * s3;
-	m[2][3] = 0;
-	m[3][0] = 0;
-	m[3][1] = 0;
-	m[3][2] = 0;
-	m[3][3] = 1;
-	return;
-}
-
-matrix4_from_euler_angles_xyx :: proc(t1, t2, t3: Float) -> (m: Matrix4) {
-	c1 := math.cos(t1);
-	s1 := math.sin(t1);
-	c2 := math.cos(t2);
-	s2 := math.sin(t2);
-	c3 := math.cos(t3);
-	s3 := math.sin(t3);
-
-	m[0][0] = c2;
-	m[0][1] = s1 * s2;
-	m[0][2] =-c1 * s2;
-	m[0][3] = 0;
-	m[1][0] = s2 * s3;
-	m[1][1] = c1 * c3 - c2 * s1 * s3;
-	m[1][2] = c3 * s1 + c1 * c2 * s3;
-	m[1][3] = 0;
-	m[2][0] = c3 * s2;
-	m[2][1] =-c1 * s3 - c2 * c3 * s1;
-	m[2][2] = c1 * c2 * c3 - s1 * s3;
-	m[2][3] = 0;
-	m[3][0] = 0;
-	m[3][1] = 0;
-	m[3][2] = 0;
-	m[3][3] = 1;
-	return;
-}
-
-matrix4_from_euler_angles_yxy :: proc(t1, t2, t3: Float) -> (m: Matrix4) {
-	c1 := math.cos(t1);
-	s1 := math.sin(t1);
-	c2 := math.cos(t2);
-	s2 := math.sin(t2);
-	c3 := math.cos(t3);
-	s3 := math.sin(t3);
-
-	m[0][0] = c1 * c3 - c2 * s1 * s3;
-	m[0][1] = s2* s3;
-	m[0][2] =-c3 * s1 - c1 * c2 * s3;
-	m[0][3] = 0;
-	m[1][0] = s1 * s2;
-	m[1][1] = c2;
-	m[1][2] = c1 * s2;
-	m[1][3] = 0;
-	m[2][0] = c1 * s3 + c2 * c3 * s1;
-	m[2][1] =-c3 * s2;
-	m[2][2] = c1 * c2 * c3 - s1 * s3;
-	m[2][3] = 0;
-	m[3][0] = 0;
-	m[3][1] = 0;
-	m[3][2] = 0;
-	m[3][3] = 1;
-	return;
-}
-
-matrix4_from_euler_angles_yzy :: proc(t1, t2, t3: Float) -> (m: Matrix4) {
-	c1 := math.cos(t1);
-	s1 := math.sin(t1);
-	c2 := math.cos(t2);
-	s2 := math.sin(t2);
-	c3 := math.cos(t3);
-	s3 := math.sin(t3);
-
-	m[0][0] = c1 * c2 * c3 - s1 * s3;
-	m[0][1] = c3 * s2;
-	m[0][2] =-c1 * s3 - c2 * c3 * s1;
-	m[0][3] = 0;
-	m[1][0] =-c1 * s2;
-	m[1][1] = c2;
-	m[1][2] = s1 * s2;
-	m[1][3] = 0;
-	m[2][0] = c3 * s1 + c1 * c2 * s3;
-	m[2][1] = s2 * s3;
-	m[2][2] = c1 * c3 - c2 * s1 * s3;
-	m[2][3] = 0;
-	m[3][0] = 0;
-	m[3][1] = 0;
-	m[3][2] = 0;
-	m[3][3] = 1;
-	return;
-}
-
-matrix4_from_euler_angles_zyz :: proc(t1, t2, t3: Float) -> (m: Matrix4) {
-	c1 := math.cos(t1);
-	s1 := math.sin(t1);
-	c2 := math.cos(t2);
-	s2 := math.sin(t2);
-	c3 := math.cos(t3);
-	s3 := math.sin(t3);
-
-	m[0][0] = c1 * c2 * c3 - s1 * s3;
-	m[0][1] = c1 * s3 + c2 * c3 * s1;
-	m[0][2] =-c3 * s2;
-	m[0][3] = 0;
-	m[1][0] =-c3 * s1 - c1 * c2 * s3;
-	m[1][1] = c1 * c3 - c2 * s1 * s3;
-	m[1][2] = s2 * s3;
-	m[1][3] = 0;
-	m[2][0] = c1 * s2;
-	m[2][1] = s1 * s2;
-	m[2][2] = c2;
-	m[2][3] = 0;
-	m[3][0] = 0;
-	m[3][1] = 0;
-	m[3][2] = 0;
-	m[3][3] = 1;
-	return;
-}
-
-matrix4_from_euler_angles_zxz :: proc(t1, t2, t3: Float) -> (m: Matrix4) {
-	c1 := math.cos(t1);
-	s1 := math.sin(t1);
-	c2 := math.cos(t2);
-	s2 := math.sin(t2);
-	c3 := math.cos(t3);
-	s3 := math.sin(t3);
-
-	m[0][0] = c1 * c3 - c2 * s1 * s3;
-	m[0][1] = c3 * s1 + c1 * c2 * s3;
-	m[0][2] = s2 *s3;
-	m[0][3] = 0;
-	m[1][0] =-c1 * s3 - c2 * c3 * s1;
-	m[1][1] = c1 * c2 * c3 - s1 * s3;
-	m[1][2] = c3 * s2;
-	m[1][3] = 0;
-	m[2][0] = s1 * s2;
-	m[2][1] =-c1 * s2;
-	m[2][2] = c2;
-	m[2][3] = 0;
-	m[3][0] = 0;
-	m[3][1] = 0;
-	m[3][2] = 0;
-	m[3][3] = 1;
-	return;
-}
-
-
-matrix4_from_euler_angles_xzy :: proc(t1, t2, t3: Float) -> (m: Matrix4) {
-	c1 := math.cos(t1);
-	s1 := math.sin(t1);
-	c2 := math.cos(t2);
-	s2 := math.sin(t2);
-	c3 := math.cos(t3);
-	s3 := math.sin(t3);
-
-	m[0][0] = c2 * c3;
-	m[0][1] = s1 * s3 + c1 * c3 * s2;
-	m[0][2] = c3 * s1 * s2 - c1 * s3;
-	m[0][3] = 0;
-	m[1][0] =-s2;
-	m[1][1] = c1 * c2;
-	m[1][2] = c2 * s1;
-	m[1][3] = 0;
-	m[2][0] = c2 * s3;
-	m[2][1] = c1 * s2 * s3 - c3 * s1;
-	m[2][2] = c1 * c3 + s1 * s2 *s3;
-	m[2][3] = 0;
-	m[3][0] = 0;
-	m[3][1] = 0;
-	m[3][2] = 0;
-	m[3][3] = 1;
-	return;
-}
-
-matrix4_from_euler_angles_yzx :: proc(t1, t2, t3: Float) -> (m: Matrix4) {
-	c1 := math.cos(t1);
-	s1 := math.sin(t1);
-	c2 := math.cos(t2);
-	s2 := math.sin(t2);
-	c3 := math.cos(t3);
-	s3 := math.sin(t3);
-
-	m[0][0] = c1 * c2;
-	m[0][1] = s2;
-	m[0][2] =-c2 * s1;
-	m[0][3] = 0;
-	m[1][0] = s1 * s3 - c1 * c3 * s2;
-	m[1][1] = c2 * c3;
-	m[1][2] = c1 * s3 + c3 * s1 * s2;
-	m[1][3] = 0;
-	m[2][0] = c3 * s1 + c1 * s2 * s3;
-	m[2][1] =-c2 * s3;
-	m[2][2] = c1 * c3 - s1 * s2 * s3;
-	m[2][3] = 0;
-	m[3][0] = 0;
-	m[3][1] = 0;
-	m[3][2] = 0;
-	m[3][3] = 1;
-	return;
-}
-
-matrix4_from_euler_angles_zyx :: proc(t1, t2, t3: Float) -> (m: Matrix4) {
-	c1 := math.cos(t1);
-	s1 := math.sin(t1);
-	c2 := math.cos(t2);
-	s2 := math.sin(t2);
-	c3 := math.cos(t3);
-	s3 := math.sin(t3);
-
-	m[0][0] = c1 * c2;
-	m[0][1] = c2 * s1;
-	m[0][2] =-s2;
-	m[0][3] = 0;
-	m[1][0] = c1 * s2 * s3 - c3 * s1;
-	m[1][1] = c1 * c3 + s1 * s2 * s3;
-	m[1][2] = c2 * s3;
-	m[1][3] = 0;
-	m[2][0] = s1 * s3 + c1 * c3 * s2;
-	m[2][1] = c3 * s1 * s2 - c1 * s3;
-	m[2][2] = c2 * c3;
-	m[2][3] = 0;
-	m[3][0] = 0;
-	m[3][1] = 0;
-	m[3][2] = 0;
-	m[3][3] = 1;
-	return;
-}
-
-matrix4_from_euler_angles_zxy :: proc(t1, t2, t3: Float) -> (m: Matrix4) {
-	c1 := math.cos(t1);
-	s1 := math.sin(t1);
-	c2 := math.cos(t2);
-	s2 := math.sin(t2);
-	c3 := math.cos(t3);
-	s3 := math.sin(t3);
-
-	m[0][0] = c1 * c3 - s1 * s2 * s3;
-	m[0][1] = c3 * s1 + c1 * s2 * s3;
-	m[0][2] =-c2 * s3;
-	m[0][3] = 0;
-	m[1][0] =-c2 * s1;
-	m[1][1] = c1 * c2;
-	m[1][2] = s2;
-	m[1][3] = 0;
-	m[2][0] = c1 * s3 + c3 * s1 * s2;
-	m[2][1] = s1 * s3 - c1 * c3 * s2;
-	m[2][2] = c2 * c3;
-	m[2][3] = 0;
-	m[3][0] = 0;
-	m[3][1] = 0;
-	m[3][2] = 0;
-	m[3][3] = 1;
-	return;
-}
-
-
-matrix4_from_yaw_pitch_roll :: proc(yaw, pitch, roll: Float) -> (m: Matrix4) {
-	ch := math.cos(yaw);
-	sh := math.sin(yaw);
-	cp := math.cos(pitch);
-	sp := math.sin(pitch);
-	cb := math.cos(roll);
-	sb := math.sin(roll);
-
-	m[0][0] = ch * cb + sh * sp * sb;
-	m[0][1] = sb * cp;
-	m[0][2] = -sh * cb + ch * sp * sb;
-	m[0][3] = 0;
-	m[1][0] = -ch * sb + sh * sp * cb;
-	m[1][1] = cb * cp;
-	m[1][2] = sb * sh + ch * sp * cb;
-	m[1][3] = 0;
-	m[2][0] = sh * cp;
-	m[2][1] = -sp;
-	m[2][2] = ch * cp;
-	m[2][3] = 0;
-	m[3][0] = 0;
-	m[3][1] = 0;
-	m[3][2] = 0;
-	m[3][3] = 1;
-	return m;
-}
-
-euler_angles_xyz_from_matrix4 :: proc(m: Matrix4) -> (t1, t2, t3: Float) {
-	T1 := math.atan2(m[2][1], m[2][2]);
-	C2 := math.sqrt(m[0][0]*m[0][0] + m[1][0]*m[1][0]);
-	T2 := math.atan2(-m[2][0], C2);
-	S1 := math.sin(T1);
-	C1 := math.cos(T1);
-	T3 := math.atan2(S1*m[0][2] - C1*m[0][1], C1*m[1][1] - S1*m[1][2]);
-	t1 = -T1;
-	t2 = -T2;
-	t3 = -T3;
-	return;
-}
-
-euler_angles_yxz_from_matrix4 :: proc(m: Matrix4) -> (t1, t2, t3: Float) {
-	T1 := math.atan2(m[2][0], m[2][2]);
-	C2 := math.sqrt(m[0][1]*m[0][1] + m[1][1]*m[1][1]);
-	T2 := math.atan2(-m[2][1], C2);
-	S1 := math.sin(T1);
-	C1 := math.cos(T1);
-	T3 := math.atan2(S1*m[1][2] - C1*m[1][0], C1*m[0][0] - S1*m[0][2]);
-	t1 = T1;
-	t2 = T2;
-	t3 = T3;
-	return;
-}
-
-euler_angles_xzx_from_matrix4 :: proc(m: Matrix4) -> (t1, t2, t3: Float) {
-	T1 := math.atan2(m[0][2], m[0][1]);
-	S2 := math.sqrt(m[1][0]*m[1][0] + m[2][0]*m[2][0]);
-	T2 := math.atan2(S2, m[0][0]);
-	S1 := math.sin(T1);
-	C1 := math.cos(T1);
-	T3 := math.atan2(C1*m[1][2] - S1*m[1][1], C1*m[2][2] - S1*m[2][1]);
-	t1 = T1;
-	t2 = T2;
-	t3 = T3;
-	return;
-}
-
-euler_angles_xyx_from_matrix4 :: proc(m: Matrix4) -> (t1, t2, t3: Float) {
-	T1 := math.atan2(m[0][1], -m[0][2]);
-	S2 := math.sqrt(m[1][0]*m[1][0] + m[2][0]*m[2][0]);
-	T2 := math.atan2(S2, m[0][0]);
-	S1 := math.sin(T1);
-	C1 := math.cos(T1);
-	T3 := math.atan2(-C1*m[2][1] - S1*m[2][2], C1*m[1][1] + S1*m[1][2]);
-	t1 = T1;
-	t2 = T2;
-	t3 = T3;
-	return;
-}
-
-euler_angles_yxy_from_matrix4 :: proc(m: Matrix4) -> (t1, t2, t3: Float) {
-	T1 := math.atan2(m[1][0], m[1][2]);
-	S2 := math.sqrt(m[0][1]*m[0][1] + m[2][1]*m[2][1]);
-	T2 := math.atan2(S2, m[1][1]);
-	S1 := math.sin(T1);
-	C1 := math.cos(T1);
-	T3 := math.atan2(C1*m[2][0] - S1*m[2][2], C1*m[0][0] - S1*m[0][2]);
-	t1 = T1;
-	t2 = T2;
-	t3 = T3;
-	return;
-}
-
-euler_angles_yzy_from_matrix4 :: proc(m: Matrix4) -> (t1, t2, t3: Float) {
-	T1 := math.atan2(m[1][2], -m[1][0]);
-	S2 := math.sqrt(m[0][1]*m[0][1] + m[2][1]*m[2][1]);
-	T2 := math.atan2(S2, m[1][1]);
-	S1 := math.sin(T1);
-	C1 := math.cos(T1);
-	T3 := math.atan2(-S1*m[0][0] - C1*m[0][2], S1*m[2][0] + C1*m[2][2]);
-	t1 = T1;
-	t2 = T2;
-	t3 = T3;
-	return;
-}
-euler_angles_zyz_from_matrix4 :: proc(m: Matrix4) -> (t1, t2, t3: Float) {
-	T1 := math.atan2(m[2][1], m[2][0]);
-	S2 := math.sqrt(m[0][2]*m[0][2] + m[1][2]*m[1][2]);
-	T2 := math.atan2(S2, m[2][2]);
-	S1 := math.sin(T1);
-	C1 := math.cos(T1);
-	T3 := math.atan2(C1*m[0][1] - S1*m[0][0], C1*m[1][1] - S1*m[1][0]);
-	t1 = T1;
-	t2 = T2;
-	t3 = T3;
-	return;
-}
-
-euler_angles_zxz_from_matrix4 :: proc(m: Matrix4) -> (t1, t2, t3: Float) {
-	T1 := math.atan2(m[2][0], -m[2][1]);
-	S2 := math.sqrt(m[0][2]*m[0][2] + m[1][2]*m[1][2]);
-	T2 := math.atan2(S2, m[2][2]);
-	S1 := math.sin(T1);
-	C1 := math.cos(T1);
-	T3 := math.atan2(-C1*m[1][0] - S1*m[1][1], C1*m[0][0] + S1*m[0][1]);
-	t1 = T1;
-	t2 = T2;
-	t3 = T3;
-	return;
-}
-
-euler_angles_xzy_from_matrix4 :: proc(m: Matrix4) -> (t1, t2, t3: Float) {
-	T1 := math.atan2(m[1][2], m[1][1]);
-	C2 := math.sqrt(m[0][0]*m[0][0] + m[2][0]*m[2][0]);
-	T2 := math.atan2(-m[1][0], C2);
-	S1 := math.sin(T1);
-	C1 := math.cos(T1);
-	T3 := math.atan2(S1*m[0][1] - C1*m[0][2], C1*m[2][2] - S1*m[2][1]);
-	t1 = T1;
-	t2 = T2;
-	t3 = T3;
-	return;
-}
-
-euler_angles_yzx_from_matrix4 :: proc(m: Matrix4) -> (t1, t2, t3: Float) {
-	T1 := math.atan2(-m[0][2], m[0][0]);
-	C2 := math.sqrt(m[1][1]*m[1][1] + m[2][1]*m[2][1]);
-	T2 := math.atan2(m[0][1], C2);
-	S1 := math.sin(T1);
-	C1 := math.cos(T1);
-	T3 := math.atan2(S1*m[1][0] + C1*m[1][2], S1*m[2][0] + C1*m[2][2]);
-	t1 = T1;
-	t2 = T2;
-	t3 = T3;
-	return;
-}
-
-euler_angles_zyx_from_matrix4 :: proc(m: Matrix4) -> (t1, t2, t3: Float) {
-	T1 := math.atan2(m[0][1], m[0][0]);
-	C2 := math.sqrt(m[1][2]*m[1][2] + m[2][2]*m[2][2]);
-	T2 := math.atan2(-m[0][2], C2);
-	S1 := math.sin(T1);
-	C1 := math.cos(T1);
-	T3 := math.atan2(S1*m[2][0] - C1*m[2][1], C1*m[1][1] - S1*m[1][0]);
-	t1 = T1;
-	t2 = T2;
-	t3 = T3;
-	return;
-}
-
-euler_angles_zxy_from_matrix4 :: proc(m: Matrix4) -> (t1, t2, t3: Float) {
-	T1 := math.atan2(-m[1][0], m[1][1]);
-	C2 := math.sqrt(m[0][2]*m[0][2] + m[2][2]*m[2][2]);
-	T2 := math.atan2(m[1][2], C2);
-	S1 := math.sin(T1);
-	C1 := math.cos(T1);
-	T3 := math.atan2(C1*m[2][0] + S1*m[2][1], C1*m[0][0] + S1*m[0][1]);
-	t1 = T1;
-	t2 = T2;
-	t3 = T3;
-	return;
-}
+euler_angles_from_matrix4          :: proc{euler_angles_from_matrix4_f32, euler_angles_from_matrix4_f64};
+euler_angles_from_quaternion       :: proc{euler_angles_from_quaternion_f32, euler_angles_from_quaternion_f64};
+matrix4_from_euler_angles          :: proc{matrix4_from_euler_angles_f32, matrix4_from_euler_angles_f64};
+quaternion_from_euler_angles       :: proc{quaternion_from_euler_angles_f32, quaternion_from_euler_angles_f64};
+quaternion_from_euler_angle_x      :: proc{quaternion_from_euler_angle_x_f32, quaternion_from_euler_angle_x_f64};
+quaternion_from_euler_angle_y      :: proc{quaternion_from_euler_angle_y_f32, quaternion_from_euler_angle_y_f64};
+quaternion_from_euler_angle_z      :: proc{quaternion_from_euler_angle_z_f32, quaternion_from_euler_angle_z_f64};
+quaternion_from_pitch_yaw_roll     :: proc{quaternion_from_pitch_yaw_roll_f32, quaternion_from_pitch_yaw_roll_f64};
+roll_from_quaternion               :: proc{roll_from_quaternion_f32, roll_from_quaternion_f64};
+pitch_from_quaternion              :: proc{pitch_from_quaternion_f32, pitch_from_quaternion_f64};
+yaw_from_quaternion                :: proc{yaw_from_quaternion_f32, yaw_from_quaternion_f64};
+pitch_yaw_roll_from_quaternion     :: proc{pitch_yaw_roll_from_quaternion_f32, pitch_yaw_roll_from_quaternion_f64};
+euler_angles_xyz_from_quaternion   :: proc{euler_angles_xyz_from_quaternion_f32, euler_angles_xyz_from_quaternion_f64};
+euler_angles_yxz_from_quaternion   :: proc{euler_angles_yxz_from_quaternion_f32, euler_angles_yxz_from_quaternion_f64};
+euler_angles_xzx_from_quaternion   :: proc{euler_angles_xzx_from_quaternion_f32, euler_angles_xzx_from_quaternion_f64};
+euler_angles_xyx_from_quaternion   :: proc{euler_angles_xyx_from_quaternion_f32, euler_angles_xyx_from_quaternion_f64};
+euler_angles_yxy_from_quaternion   :: proc{euler_angles_yxy_from_quaternion_f32, euler_angles_yxy_from_quaternion_f64};
+euler_angles_yzy_from_quaternion   :: proc{euler_angles_yzy_from_quaternion_f32, euler_angles_yzy_from_quaternion_f64};
+euler_angles_zyz_from_quaternion   :: proc{euler_angles_zyz_from_quaternion_f32, euler_angles_zyz_from_quaternion_f64};
+euler_angles_zxz_from_quaternion   :: proc{euler_angles_zxz_from_quaternion_f32, euler_angles_zxz_from_quaternion_f64};
+euler_angles_xzy_from_quaternion   :: proc{euler_angles_xzy_from_quaternion_f32, euler_angles_xzy_from_quaternion_f64};
+euler_angles_yzx_from_quaternion   :: proc{euler_angles_yzx_from_quaternion_f32, euler_angles_yzx_from_quaternion_f64};
+euler_angles_zyx_from_quaternion   :: proc{euler_angles_zyx_from_quaternion_f32, euler_angles_zyx_from_quaternion_f64};
+euler_angles_zxy_from_quaternion   :: proc{euler_angles_zxy_from_quaternion_f32, euler_angles_zxy_from_quaternion_f64};
+matrix4_from_euler_angle_x         :: proc{matrix4_from_euler_angle_x_f32, matrix4_from_euler_angle_x_f64};
+matrix4_from_euler_angle_y         :: proc{matrix4_from_euler_angle_y_f32, matrix4_from_euler_angle_y_f64};
+matrix4_from_euler_angle_z         :: proc{matrix4_from_euler_angle_z_f32, matrix4_from_euler_angle_z_f64};
+matrix4_from_derived_euler_angle_x :: proc{matrix4_from_derived_euler_angle_x_f32, matrix4_from_derived_euler_angle_x_f64};
+matrix4_from_derived_euler_angle_y :: proc{matrix4_from_derived_euler_angle_y_f32, matrix4_from_derived_euler_angle_y_f64};
+matrix4_from_derived_euler_angle_z :: proc{matrix4_from_derived_euler_angle_z_f32, matrix4_from_derived_euler_angle_z_f64};
+matrix4_from_euler_angles_xy       :: proc{matrix4_from_euler_angles_xy_f32, matrix4_from_euler_angles_xy_f64};
+matrix4_from_euler_angles_yx       :: proc{matrix4_from_euler_angles_yx_f32, matrix4_from_euler_angles_yx_f64};
+matrix4_from_euler_angles_xz       :: proc{matrix4_from_euler_angles_xz_f32, matrix4_from_euler_angles_xz_f64};
+matrix4_from_euler_angles_zx       :: proc{matrix4_from_euler_angles_zx_f32, matrix4_from_euler_angles_zx_f64};
+matrix4_from_euler_angles_yz       :: proc{matrix4_from_euler_angles_yz_f32, matrix4_from_euler_angles_yz_f64};
+matrix4_from_euler_angles_zy       :: proc{matrix4_from_euler_angles_zy_f32, matrix4_from_euler_angles_zy_f64};
+matrix4_from_euler_angles_xyz      :: proc{matrix4_from_euler_angles_xyz_f32, matrix4_from_euler_angles_xyz_f64};
+matrix4_from_euler_angles_yxz      :: proc{matrix4_from_euler_angles_yxz_f32, matrix4_from_euler_angles_yxz_f64};
+matrix4_from_euler_angles_xzx      :: proc{matrix4_from_euler_angles_xzx_f32, matrix4_from_euler_angles_xzx_f64};
+matrix4_from_euler_angles_xyx      :: proc{matrix4_from_euler_angles_xyx_f32, matrix4_from_euler_angles_xyx_f64};
+matrix4_from_euler_angles_yxy      :: proc{matrix4_from_euler_angles_yxy_f32, matrix4_from_euler_angles_yxy_f64};
+matrix4_from_euler_angles_yzy      :: proc{matrix4_from_euler_angles_yzy_f32, matrix4_from_euler_angles_yzy_f64};
+matrix4_from_euler_angles_zyz      :: proc{matrix4_from_euler_angles_zyz_f32, matrix4_from_euler_angles_zyz_f64};
+matrix4_from_euler_angles_zxz      :: proc{matrix4_from_euler_angles_zxz_f32, matrix4_from_euler_angles_zxz_f64};
+matrix4_from_euler_angles_xzy      :: proc{matrix4_from_euler_angles_xzy_f32, matrix4_from_euler_angles_xzy_f64};
+matrix4_from_euler_angles_yzx      :: proc{matrix4_from_euler_angles_yzx_f32, matrix4_from_euler_angles_yzx_f64};
+matrix4_from_euler_angles_zyx      :: proc{matrix4_from_euler_angles_zyx_f32, matrix4_from_euler_angles_zyx_f64};
+matrix4_from_euler_angles_zxy      :: proc{matrix4_from_euler_angles_zxy_f32, matrix4_from_euler_angles_zxy_f64};
+matrix4_from_yaw_pitch_roll        :: proc{matrix4_from_yaw_pitch_roll_f32, matrix4_from_yaw_pitch_roll_f64};
+euler_angles_xyz_from_matrix4      :: proc{euler_angles_xyz_from_matrix4_f32, euler_angles_xyz_from_matrix4_f64};
+euler_angles_yxz_from_matrix4      :: proc{euler_angles_yxz_from_matrix4_f32, euler_angles_yxz_from_matrix4_f64};
+euler_angles_xzx_from_matrix4      :: proc{euler_angles_xzx_from_matrix4_f32, euler_angles_xzx_from_matrix4_f64};
+euler_angles_xyx_from_matrix4      :: proc{euler_angles_xyx_from_matrix4_f32, euler_angles_xyx_from_matrix4_f64};
+euler_angles_yxy_from_matrix4      :: proc{euler_angles_yxy_from_matrix4_f32, euler_angles_yxy_from_matrix4_f64};
+euler_angles_yzy_from_matrix4      :: proc{euler_angles_yzy_from_matrix4_f32, euler_angles_yzy_from_matrix4_f64};
+euler_angles_zyz_from_matrix4      :: proc{euler_angles_zyz_from_matrix4_f32, euler_angles_zyz_from_matrix4_f64};
+euler_angles_zxz_from_matrix4      :: proc{euler_angles_zxz_from_matrix4_f32, euler_angles_zxz_from_matrix4_f64};
+euler_angles_xzy_from_matrix4      :: proc{euler_angles_xzy_from_matrix4_f32, euler_angles_xzy_from_matrix4_f64};
+euler_angles_yzx_from_matrix4      :: proc{euler_angles_yzx_from_matrix4_f32, euler_angles_yzx_from_matrix4_f64};
+euler_angles_zyx_from_matrix4      :: proc{euler_angles_zyx_from_matrix4_f32, euler_angles_zyx_from_matrix4_f64};
+euler_angles_zxy_from_matrix4      :: proc{euler_angles_zxy_from_matrix4_f32, euler_angles_zxy_from_matrix4_f64};

core/math/linalg/specific_euler_angles_f32.odin

@@ -0,0 +1,797 @@
+package linalg
+
+import "core:math"
+
+euler_angles_from_matrix4_f32 :: proc(m: Matrix4f32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) {
+	switch order {
+	case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix4_f32(m);
+	case .XZY: t1, t2, t3 = euler_angles_xzy_from_matrix4_f32(m);
+	case .YXZ: t1, t2, t3 = euler_angles_yxz_from_matrix4_f32(m);
+	case .YZX: t1, t2, t3 = euler_angles_yzx_from_matrix4_f32(m);
+	case .ZXY: t1, t2, t3 = euler_angles_zxy_from_matrix4_f32(m);
+	case .ZYX: t1, t2, t3 = euler_angles_zyx_from_matrix4_f32(m);
+	case .XYX: t1, t2, t3 = euler_angles_xyx_from_matrix4_f32(m);
+	case .XZX: t1, t2, t3 = euler_angles_xzx_from_matrix4_f32(m);
+	case .YXY: t1, t2, t3 = euler_angles_yxy_from_matrix4_f32(m);
+	case .YZY: t1, t2, t3 = euler_angles_yzy_from_matrix4_f32(m);
+	case .ZXZ: t1, t2, t3 = euler_angles_zxz_from_matrix4_f32(m);
+	case .ZYZ: t1, t2, t3 = euler_angles_zyz_from_matrix4_f32(m);
+	}
+	return;
+}
+euler_angles_from_quaternion_f32 :: proc(m: Quaternionf32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) {
+	switch order {
+	case .XYZ: t1, t2, t3 = euler_angles_xyz_from_quaternion_f32(m);
+	case .XZY: t1, t2, t3 = euler_angles_xzy_from_quaternion_f32(m);
+	case .YXZ: t1, t2, t3 = euler_angles_yxz_from_quaternion_f32(m);
+	case .YZX: t1, t2, t3 = euler_angles_yzx_from_quaternion_f32(m);
+	case .ZXY: t1, t2, t3 = euler_angles_zxy_from_quaternion_f32(m);
+	case .ZYX: t1, t2, t3 = euler_angles_zyx_from_quaternion_f32(m);
+	case .XYX: t1, t2, t3 = euler_angles_xyx_from_quaternion_f32(m);
+	case .XZX: t1, t2, t3 = euler_angles_xzx_from_quaternion_f32(m);
+	case .YXY: t1, t2, t3 = euler_angles_yxy_from_quaternion_f32(m);
+	case .YZY: t1, t2, t3 = euler_angles_yzy_from_quaternion_f32(m);
+	case .ZXZ: t1, t2, t3 = euler_angles_zxz_from_quaternion_f32(m);
+	case .ZYZ: t1, t2, t3 = euler_angles_zyz_from_quaternion_f32(m);
+	}
+	return;
+}
+
+matrix4_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) -> (m: Matrix4f32) {
+	switch order {
+	case .XYZ: return matrix4_from_euler_angles_xyz_f32(t1, t2, t3); // m1, m2, m3 = X(t1), Y(t2), Z(t3);
+	case .XZY: return matrix4_from_euler_angles_xzy_f32(t1, t2, t3); // m1, m2, m3 = X(t1), Z(t2), Y(t3);
+	case .YXZ: return matrix4_from_euler_angles_yxz_f32(t1, t2, t3); // m1, m2, m3 = Y(t1), X(t2), Z(t3);
+	case .YZX: return matrix4_from_euler_angles_yzx_f32(t1, t2, t3); // m1, m2, m3 = Y(t1), Z(t2), X(t3);
+	case .ZXY: return matrix4_from_euler_angles_zxy_f32(t1, t2, t3); // m1, m2, m3 = Z(t1), X(t2), Y(t3);
+	case .ZYX: return matrix4_from_euler_angles_zyx_f32(t1, t2, t3); // m1, m2, m3 = Z(t1), Y(t2), X(t3);
+	case .XYX: return matrix4_from_euler_angles_xyx_f32(t1, t2, t3); // m1, m2, m3 = X(t1), Y(t2), X(t3);
+	case .XZX: return matrix4_from_euler_angles_xzx_f32(t1, t2, t3); // m1, m2, m3 = X(t1), Z(t2), X(t3);
+	case .YXY: return matrix4_from_euler_angles_yxy_f32(t1, t2, t3); // m1, m2, m3 = Y(t1), X(t2), Y(t3);
+	case .YZY: return matrix4_from_euler_angles_yzy_f32(t1, t2, t3); // m1, m2, m3 = Y(t1), Z(t2), Y(t3);
+	case .ZXZ: return matrix4_from_euler_angles_zxz_f32(t1, t2, t3); // m1, m2, m3 = Z(t1), X(t2), Z(t3);
+	case .ZYZ: return matrix4_from_euler_angles_zyz_f32(t1, t2, t3); // m1, m2, m3 = Z(t1), Y(t2), Z(t3);
+	}
+	return;
+}
+
+quaternion_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) -> Quaternionf32 {
+	X :: quaternion_from_euler_angle_x;
+	Y :: quaternion_from_euler_angle_y;
+	Z :: quaternion_from_euler_angle_z;
+
+	q1, q2, q3: Quaternionf32;
+
+	switch order {
+	case .XYZ: q1, q2, q3 = X(t1), Y(t2), Z(t3);
+	case .XZY: q1, q2, q3 = X(t1), Z(t2), Y(t3);
+	case .YXZ: q1, q2, q3 = Y(t1), X(t2), Z(t3);
+	case .YZX: q1, q2, q3 = Y(t1), Z(t2), X(t3);
+	case .ZXY: q1, q2, q3 = Z(t1), X(t2), Y(t3);
+	case .ZYX: q1, q2, q3 = Z(t1), Y(t2), X(t3);
+	case .XYX: q1, q2, q3 = X(t1), Y(t2), X(t3);
+	case .XZX: q1, q2, q3 = X(t1), Z(t2), X(t3);
+	case .YXY: q1, q2, q3 = Y(t1), X(t2), Y(t3);
+	case .YZY: q1, q2, q3 = Y(t1), Z(t2), Y(t3);
+	case .ZXZ: q1, q2, q3 = Z(t1), X(t2), Z(t3);
+	case .ZYZ: q1, q2, q3 = Z(t1), Y(t2), Z(t3);
+	}
+
+	return q1 * (q2 * q3);
+}
+
+
+// Quaternionf32s
+
+quaternion_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (q: Quaternionf32) {
+	return quaternion_angle_axis_f32(angle_x, {1, 0, 0});
+}
+quaternion_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (q: Quaternionf32) {
+	return quaternion_angle_axis_f32(angle_y, {0, 1, 0});
+}
+quaternion_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (q: Quaternionf32) {
+	return quaternion_angle_axis_f32(angle_z, {0, 0, 1});
+}
+
+quaternion_from_pitch_yaw_roll_f32 :: proc(pitch, yaw, roll: f32) -> Quaternionf32 {
+	a, b, c := pitch, yaw, roll;
+
+	ca, sa := math.cos(a*0.5), math.sin(a*0.5);
+	cb, sb := math.cos(b*0.5), math.sin(b*0.5);
+	cc, sc := math.cos(c*0.5), math.sin(c*0.5);
+
+	q: Quaternionf32;
+	q.x = sa*cb*cc - ca*sb*sc;
+	q.y = ca*sb*cc + sa*cb*sc;
+	q.z = ca*cb*sc - sa*sb*cc;
+	q.w = ca*cb*cc + sa*sb*sc;
+	return q;
+}
+
+roll_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 {
+	return math.atan2(2 * q.x*q.y + q.w*q.z, q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z);
+}
+
+pitch_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 {
+	y := 2 * (q.y*q.z + q.w*q.w);
+	x := q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z;
+
+	if abs(x) <= F32_EPSILON && abs(y) <= F32_EPSILON {
+		return 2 * math.atan2(q.x, q.w);
+	}
+
+	return math.atan2(y, x);
+}
+
+yaw_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 {
+	return math.asin(clamp(-2 * (q.x*q.z - q.w*q.y), -1, 1));
+}
+
+
+pitch_yaw_roll_from_quaternion_f32 :: proc(q: Quaternionf32) -> (pitch, yaw, roll: f32) {
+	pitch = pitch_from_quaternion(q);
+	yaw = yaw_from_quaternion(q);
+	roll = roll_from_quaternion(q);
+	return;
+}
+
+euler_angles_xyz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) {
+	return euler_angles_xyz_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_yxz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) {
+	return euler_angles_yxz_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_xzx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) {
+	return euler_angles_xzx_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_xyx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) {
+	return euler_angles_xyx_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_yxy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) {
+	return euler_angles_yxy_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_yzy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) {
+	return euler_angles_yzy_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_zyz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) {
+	return euler_angles_zyz_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_zxz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) {
+	return euler_angles_zxz_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_xzy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) {
+	return euler_angles_xzy_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_yzx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) {
+	return euler_angles_yzx_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_zyx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) {
+	return euler_angles_zyx_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_zxy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) {
+	return euler_angles_zxy_from_matrix4(matrix4_from_quaternion(q));
+}
+
+
+// Matrices
+
+
+matrix4_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (m: Matrix4f32) {
+	cos_x, sin_x := math.cos(angle_x), math.sin(angle_x);
+	m[0][0] = 1;
+	m[1][1] = +cos_x;
+	m[2][1] = +sin_x;
+	m[1][2] = -sin_x;
+	m[2][2] = +cos_x;
+	m[3][3] = 1;
+	return;
+}
+matrix4_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (m: Matrix4f32) {
+	cos_y, sin_y := math.cos(angle_y), math.sin(angle_y);
+	m[0][0] = +cos_y;
+	m[2][0] = -sin_y;
+	m[1][1] = 1;
+	m[0][2] = +sin_y;
+	m[2][2] = +cos_y;
+	m[3][3] = 1;
+	return;
+}
+matrix4_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (m: Matrix4f32) {
+	cos_z, sin_z := math.cos(angle_z), math.sin(angle_z);
+	m[0][0] = +cos_z;
+	m[1][0] = +sin_z;
+	m[1][1] = +cos_z;
+	m[0][1] = -sin_z;
+	m[2][2] = 1;
+	m[3][3] = 1;
+	return;
+}
+
+
+matrix4_from_derived_euler_angle_x_f32 :: proc(angle_x: f32, angular_velocity_x: f32) -> (m: Matrix4f32) {
+	cos_x := math.cos(angle_x) * angular_velocity_x;
+	sin_x := math.sin(angle_x) * angular_velocity_x;
+	m[0][0] = 1;
+	m[1][1] = +cos_x;
+	m[2][1] = +sin_x;
+	m[1][2] = -sin_x;
+	m[2][2] = +cos_x;
+	m[3][3] = 1;
+	return;
+}
+matrix4_from_derived_euler_angle_y_f32 :: proc(angle_y: f32, angular_velocity_y: f32) -> (m: Matrix4f32) {
+	cos_y := math.cos(angle_y) * angular_velocity_y;
+	sin_y := math.sin(angle_y) * angular_velocity_y;
+	m[0][0] = +cos_y;
+	m[2][0] = -sin_y;
+	m[1][1] = 1;
+	m[0][2] = +sin_y;
+	m[2][2] = +cos_y;
+	m[3][3] = 1;
+	return;
+}
+matrix4_from_derived_euler_angle_z_f32 :: proc(angle_z: f32, angular_velocity_z: f32) -> (m: Matrix4f32) {
+	cos_z := math.cos(angle_z) * angular_velocity_z;
+	sin_z := math.sin(angle_z) * angular_velocity_z;
+	m[0][0] = +cos_z;
+	m[1][0] = +sin_z;
+	m[1][1] = +cos_z;
+	m[0][1] = -sin_z;
+	m[2][2] = 1;
+	m[3][3] = 1;
+	return;
+}
+
+
+matrix4_from_euler_angles_xy_f32 :: proc(angle_x, angle_y: f32) -> (m: Matrix4f32) {
+	cos_x, sin_x := math.cos(angle_x), math.sin(angle_x);
+	cos_y, sin_y := math.cos(angle_y), math.sin(angle_y);
+	m[0][0] = cos_y;
+	m[1][0] = -sin_x * - sin_y;
+	m[2][0] = -cos_x * - sin_y;
+	m[1][1] = cos_x;
+	m[2][1] = sin_x;
+	m[0][2] = sin_y;
+	m[1][2] = -sin_x * cos_y;
+	m[2][2] = cos_x * cos_y;
+	m[3][3] = 1;
+	return;
+}
+
+
+matrix4_from_euler_angles_yx_f32 :: proc(angle_y, angle_x: f32) -> (m: Matrix4f32) {
+	cos_x, sin_x := math.cos(angle_x), math.sin(angle_x);
+	cos_y, sin_y := math.cos(angle_y), math.sin(angle_y);
+	m[0][0] = cos_y;
+	m[2][0] = -sin_y;
+	m[0][1] = sin_y*sin_x;
+	m[1][1] = cos_x;
+	m[2][1] = cos_y*sin_x;
+	m[0][2] = sin_y*cos_x;
+	m[1][2] = -sin_x;
+	m[2][2] = cos_y*cos_x;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_xz_f32 :: proc(angle_x, angle_z: f32) -> (m: Matrix4f32) {
+	return mul(matrix4_from_euler_angle_x(angle_x), matrix4_from_euler_angle_z(angle_z));
+}
+matrix4_from_euler_angles_zx_f32 :: proc(angle_z, angle_x: f32) -> (m: Matrix4f32) {
+	return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_x(angle_x));
+}
+matrix4_from_euler_angles_yz_f32 :: proc(angle_y, angle_z: f32) -> (m: Matrix4f32) {
+	return mul(matrix4_from_euler_angle_y(angle_y), matrix4_from_euler_angle_z(angle_z));
+}
+matrix4_from_euler_angles_zy_f32 :: proc(angle_z, angle_y: f32) -> (m: Matrix4f32) {
+	return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_y(angle_y));
+}
+
+
+matrix4_from_euler_angles_xyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) {
+	c1 := math.cos(-t1);
+	c2 := math.cos(-t2);
+	c3 := math.cos(-t3);
+	s1 := math.sin(-t1);
+	s2 := math.sin(-t2);
+	s3 := math.sin(-t3);
+
+	m[0][0] = c2 * c3;
+	m[0][1] =-c1 * s3 + s1 * s2 * c3;
+	m[0][2] = s1 * s3 + c1 * s2 * c3;
+	m[0][3] = 0;
+	m[1][0] = c2 * s3;
+	m[1][1] = c1 * c3 + s1 * s2 * s3;
+	m[1][2] =-s1 * c3 + c1 * s2 * s3;
+	m[1][3] = 0;
+	m[2][0] =-s2;
+	m[2][1] = s1 * c2;
+	m[2][2] = c1 * c2;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_yxz_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix4f32) {
+	ch := math.cos(yaw);
+	sh := math.sin(yaw);
+	cp := math.cos(pitch);
+	sp := math.sin(pitch);
+	cb := math.cos(roll);
+	sb := math.sin(roll);
+
+	m[0][0] = ch * cb + sh * sp * sb;
+	m[0][1] = sb * cp;
+	m[0][2] = -sh * cb + ch * sp * sb;
+	m[0][3] = 0;
+	m[1][0] = -ch * sb + sh * sp * cb;
+	m[1][1] = cb * cp;
+	m[1][2] = sb * sh + ch * sp * cb;
+	m[1][3] = 0;
+	m[2][0] = sh * cp;
+	m[2][1] = -sp;
+	m[2][2] = ch * cp;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_xzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c2;
+	m[0][1] = c1 * s2;
+	m[0][2] = s1 * s2;
+	m[0][3] = 0;
+	m[1][0] =-c3 * s2;
+	m[1][1] = c1 * c2 * c3 - s1 * s3;
+	m[1][2] = c1 * s3 + c2 * c3 * s1;
+	m[1][3] = 0;
+	m[2][0] = s2 * s3;
+	m[2][1] =-c3 * s1 - c1 * c2 * s3;
+	m[2][2] = c1 * c3 - c2 * s1 * s3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_xyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c2;
+	m[0][1] = s1 * s2;
+	m[0][2] =-c1 * s2;
+	m[0][3] = 0;
+	m[1][0] = s2 * s3;
+	m[1][1] = c1 * c3 - c2 * s1 * s3;
+	m[1][2] = c3 * s1 + c1 * c2 * s3;
+	m[1][3] = 0;
+	m[2][0] = c3 * s2;
+	m[2][1] =-c1 * s3 - c2 * c3 * s1;
+	m[2][2] = c1 * c2 * c3 - s1 * s3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_yxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c1 * c3 - c2 * s1 * s3;
+	m[0][1] = s2* s3;
+	m[0][2] =-c3 * s1 - c1 * c2 * s3;
+	m[0][3] = 0;
+	m[1][0] = s1 * s2;
+	m[1][1] = c2;
+	m[1][2] = c1 * s2;
+	m[1][3] = 0;
+	m[2][0] = c1 * s3 + c2 * c3 * s1;
+	m[2][1] =-c3 * s2;
+	m[2][2] = c1 * c2 * c3 - s1 * s3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_yzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c1 * c2 * c3 - s1 * s3;
+	m[0][1] = c3 * s2;
+	m[0][2] =-c1 * s3 - c2 * c3 * s1;
+	m[0][3] = 0;
+	m[1][0] =-c1 * s2;
+	m[1][1] = c2;
+	m[1][2] = s1 * s2;
+	m[1][3] = 0;
+	m[2][0] = c3 * s1 + c1 * c2 * s3;
+	m[2][1] = s2 * s3;
+	m[2][2] = c1 * c3 - c2 * s1 * s3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_zyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c1 * c2 * c3 - s1 * s3;
+	m[0][1] = c1 * s3 + c2 * c3 * s1;
+	m[0][2] =-c3 * s2;
+	m[0][3] = 0;
+	m[1][0] =-c3 * s1 - c1 * c2 * s3;
+	m[1][1] = c1 * c3 - c2 * s1 * s3;
+	m[1][2] = s2 * s3;
+	m[1][3] = 0;
+	m[2][0] = c1 * s2;
+	m[2][1] = s1 * s2;
+	m[2][2] = c2;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_zxz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c1 * c3 - c2 * s1 * s3;
+	m[0][1] = c3 * s1 + c1 * c2 * s3;
+	m[0][2] = s2 *s3;
+	m[0][3] = 0;
+	m[1][0] =-c1 * s3 - c2 * c3 * s1;
+	m[1][1] = c1 * c2 * c3 - s1 * s3;
+	m[1][2] = c3 * s2;
+	m[1][3] = 0;
+	m[2][0] = s1 * s2;
+	m[2][1] =-c1 * s2;
+	m[2][2] = c2;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+
+matrix4_from_euler_angles_xzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c2 * c3;
+	m[0][1] = s1 * s3 + c1 * c3 * s2;
+	m[0][2] = c3 * s1 * s2 - c1 * s3;
+	m[0][3] = 0;
+	m[1][0] =-s2;
+	m[1][1] = c1 * c2;
+	m[1][2] = c2 * s1;
+	m[1][3] = 0;
+	m[2][0] = c2 * s3;
+	m[2][1] = c1 * s2 * s3 - c3 * s1;
+	m[2][2] = c1 * c3 + s1 * s2 *s3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_yzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c1 * c2;
+	m[0][1] = s2;
+	m[0][2] =-c2 * s1;
+	m[0][3] = 0;
+	m[1][0] = s1 * s3 - c1 * c3 * s2;
+	m[1][1] = c2 * c3;
+	m[1][2] = c1 * s3 + c3 * s1 * s2;
+	m[1][3] = 0;
+	m[2][0] = c3 * s1 + c1 * s2 * s3;
+	m[2][1] =-c2 * s3;
+	m[2][2] = c1 * c3 - s1 * s2 * s3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_zyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c1 * c2;
+	m[0][1] = c2 * s1;
+	m[0][2] =-s2;
+	m[0][3] = 0;
+	m[1][0] = c1 * s2 * s3 - c3 * s1;
+	m[1][1] = c1 * c3 + s1 * s2 * s3;
+	m[1][2] = c2 * s3;
+	m[1][3] = 0;
+	m[2][0] = s1 * s3 + c1 * c3 * s2;
+	m[2][1] = c3 * s1 * s2 - c1 * s3;
+	m[2][2] = c2 * c3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_zxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c1 * c3 - s1 * s2 * s3;
+	m[0][1] = c3 * s1 + c1 * s2 * s3;
+	m[0][2] =-c2 * s3;
+	m[0][3] = 0;
+	m[1][0] =-c2 * s1;
+	m[1][1] = c1 * c2;
+	m[1][2] = s2;
+	m[1][3] = 0;
+	m[2][0] = c1 * s3 + c3 * s1 * s2;
+	m[2][1] = s1 * s3 - c1 * c3 * s2;
+	m[2][2] = c2 * c3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+
+matrix4_from_yaw_pitch_roll_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix4f32) {
+	ch := math.cos(yaw);
+	sh := math.sin(yaw);
+	cp := math.cos(pitch);
+	sp := math.sin(pitch);
+	cb := math.cos(roll);
+	sb := math.sin(roll);
+
+	m[0][0] = ch * cb + sh * sp * sb;
+	m[0][1] = sb * cp;
+	m[0][2] = -sh * cb + ch * sp * sb;
+	m[0][3] = 0;
+	m[1][0] = -ch * sb + sh * sp * cb;
+	m[1][1] = cb * cp;
+	m[1][2] = sb * sh + ch * sp * cb;
+	m[1][3] = 0;
+	m[2][0] = sh * cp;
+	m[2][1] = -sp;
+	m[2][2] = ch * cp;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return m;
+}
+
+euler_angles_xyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) {
+	T1 := math.atan2(m[2][1], m[2][2]);
+	C2 := math.sqrt(m[0][0]*m[0][0] + m[1][0]*m[1][0]);
+	T2 := math.atan2(-m[2][0], C2);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(S1*m[0][2] - C1*m[0][1], C1*m[1][1] - S1*m[1][2]);
+	t1 = -T1;
+	t2 = -T2;
+	t3 = -T3;
+	return;
+}
+
+euler_angles_yxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) {
+	T1 := math.atan2(m[2][0], m[2][2]);
+	C2 := math.sqrt(m[0][1]*m[0][1] + m[1][1]*m[1][1]);
+	T2 := math.atan2(-m[2][1], C2);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(S1*m[1][2] - C1*m[1][0], C1*m[0][0] - S1*m[0][2]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_xzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) {
+	T1 := math.atan2(m[0][2], m[0][1]);
+	S2 := math.sqrt(m[1][0]*m[1][0] + m[2][0]*m[2][0]);
+	T2 := math.atan2(S2, m[0][0]);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(C1*m[1][2] - S1*m[1][1], C1*m[2][2] - S1*m[2][1]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_xyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) {
+	T1 := math.atan2(m[0][1], -m[0][2]);
+	S2 := math.sqrt(m[1][0]*m[1][0] + m[2][0]*m[2][0]);
+	T2 := math.atan2(S2, m[0][0]);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(-C1*m[2][1] - S1*m[2][2], C1*m[1][1] + S1*m[1][2]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_yxy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) {
+	T1 := math.atan2(m[1][0], m[1][2]);
+	S2 := math.sqrt(m[0][1]*m[0][1] + m[2][1]*m[2][1]);
+	T2 := math.atan2(S2, m[1][1]);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(C1*m[2][0] - S1*m[2][2], C1*m[0][0] - S1*m[0][2]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_yzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) {
+	T1 := math.atan2(m[1][2], -m[1][0]);
+	S2 := math.sqrt(m[0][1]*m[0][1] + m[2][1]*m[2][1]);
+	T2 := math.atan2(S2, m[1][1]);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(-S1*m[0][0] - C1*m[0][2], S1*m[2][0] + C1*m[2][2]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+euler_angles_zyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) {
+	T1 := math.atan2(m[2][1], m[2][0]);
+	S2 := math.sqrt(m[0][2]*m[0][2] + m[1][2]*m[1][2]);
+	T2 := math.atan2(S2, m[2][2]);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(C1*m[0][1] - S1*m[0][0], C1*m[1][1] - S1*m[1][0]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_zxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) {
+	T1 := math.atan2(m[2][0], -m[2][1]);
+	S2 := math.sqrt(m[0][2]*m[0][2] + m[1][2]*m[1][2]);
+	T2 := math.atan2(S2, m[2][2]);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(-C1*m[1][0] - S1*m[1][1], C1*m[0][0] + S1*m[0][1]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_xzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) {
+	T1 := math.atan2(m[1][2], m[1][1]);
+	C2 := math.sqrt(m[0][0]*m[0][0] + m[2][0]*m[2][0]);
+	T2 := math.atan2(-m[1][0], C2);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(S1*m[0][1] - C1*m[0][2], C1*m[2][2] - S1*m[2][1]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_yzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) {
+	T1 := math.atan2(-m[0][2], m[0][0]);
+	C2 := math.sqrt(m[1][1]*m[1][1] + m[2][1]*m[2][1]);
+	T2 := math.atan2(m[0][1], C2);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(S1*m[1][0] + C1*m[1][2], S1*m[2][0] + C1*m[2][2]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_zyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) {
+	T1 := math.atan2(m[0][1], m[0][0]);
+	C2 := math.sqrt(m[1][2]*m[1][2] + m[2][2]*m[2][2]);
+	T2 := math.atan2(-m[0][2], C2);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(S1*m[2][0] - C1*m[2][1], C1*m[1][1] - S1*m[1][0]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_zxy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) {
+	T1 := math.atan2(-m[1][0], m[1][1]);
+	C2 := math.sqrt(m[0][2]*m[0][2] + m[2][2]*m[2][2]);
+	T2 := math.atan2(m[1][2], C2);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(C1*m[2][0] + S1*m[2][1], C1*m[0][0] + S1*m[0][1]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}

core/math/linalg/specific_euler_angles_f64.odin

@@ -0,0 +1,797 @@
+package linalg
+
+import "core:math"
+
+euler_angles_from_matrix4_f64 :: proc(m: Matrix4f64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) {
+	switch order {
+	case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix4(m);
+	case .XZY: t1, t2, t3 = euler_angles_xzy_from_matrix4(m);
+	case .YXZ: t1, t2, t3 = euler_angles_yxz_from_matrix4(m);
+	case .YZX: t1, t2, t3 = euler_angles_yzx_from_matrix4(m);
+	case .ZXY: t1, t2, t3 = euler_angles_zxy_from_matrix4(m);
+	case .ZYX: t1, t2, t3 = euler_angles_zyx_from_matrix4(m);
+	case .XYX: t1, t2, t3 = euler_angles_xyx_from_matrix4(m);
+	case .XZX: t1, t2, t3 = euler_angles_xzx_from_matrix4(m);
+	case .YXY: t1, t2, t3 = euler_angles_yxy_from_matrix4(m);
+	case .YZY: t1, t2, t3 = euler_angles_yzy_from_matrix4(m);
+	case .ZXZ: t1, t2, t3 = euler_angles_zxz_from_matrix4(m);
+	case .ZYZ: t1, t2, t3 = euler_angles_zyz_from_matrix4(m);
+	}
+	return;
+}
+euler_angles_from_quaternion_f64 :: proc(m: Quaternionf64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) {
+	switch order {
+	case .XYZ: t1, t2, t3 = euler_angles_xyz_from_quaternion(m);
+	case .XZY: t1, t2, t3 = euler_angles_xzy_from_quaternion(m);
+	case .YXZ: t1, t2, t3 = euler_angles_yxz_from_quaternion(m);
+	case .YZX: t1, t2, t3 = euler_angles_yzx_from_quaternion(m);
+	case .ZXY: t1, t2, t3 = euler_angles_zxy_from_quaternion(m);
+	case .ZYX: t1, t2, t3 = euler_angles_zyx_from_quaternion(m);
+	case .XYX: t1, t2, t3 = euler_angles_xyx_from_quaternion(m);
+	case .XZX: t1, t2, t3 = euler_angles_xzx_from_quaternion(m);
+	case .YXY: t1, t2, t3 = euler_angles_yxy_from_quaternion(m);
+	case .YZY: t1, t2, t3 = euler_angles_yzy_from_quaternion(m);
+	case .ZXZ: t1, t2, t3 = euler_angles_zxz_from_quaternion(m);
+	case .ZYZ: t1, t2, t3 = euler_angles_zyz_from_quaternion(m);
+	}
+	return;
+}
+
+matrix4_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) -> (m: Matrix4f64) {
+	switch order {
+	case .XYZ: return matrix4_from_euler_angles_xyz(t1, t2, t3); // m1, m2, m3 = X(t1), Y(t2), Z(t3);
+	case .XZY: return matrix4_from_euler_angles_xzy(t1, t2, t3); // m1, m2, m3 = X(t1), Z(t2), Y(t3);
+	case .YXZ: return matrix4_from_euler_angles_yxz(t1, t2, t3); // m1, m2, m3 = Y(t1), X(t2), Z(t3);
+	case .YZX: return matrix4_from_euler_angles_yzx(t1, t2, t3); // m1, m2, m3 = Y(t1), Z(t2), X(t3);
+	case .ZXY: return matrix4_from_euler_angles_zxy(t1, t2, t3); // m1, m2, m3 = Z(t1), X(t2), Y(t3);
+	case .ZYX: return matrix4_from_euler_angles_zyx(t1, t2, t3); // m1, m2, m3 = Z(t1), Y(t2), X(t3);
+	case .XYX: return matrix4_from_euler_angles_xyx(t1, t2, t3); // m1, m2, m3 = X(t1), Y(t2), X(t3);
+	case .XZX: return matrix4_from_euler_angles_xzx(t1, t2, t3); // m1, m2, m3 = X(t1), Z(t2), X(t3);
+	case .YXY: return matrix4_from_euler_angles_yxy(t1, t2, t3); // m1, m2, m3 = Y(t1), X(t2), Y(t3);
+	case .YZY: return matrix4_from_euler_angles_yzy(t1, t2, t3); // m1, m2, m3 = Y(t1), Z(t2), Y(t3);
+	case .ZXZ: return matrix4_from_euler_angles_zxz(t1, t2, t3); // m1, m2, m3 = Z(t1), X(t2), Z(t3);
+	case .ZYZ: return matrix4_from_euler_angles_zyz(t1, t2, t3); // m1, m2, m3 = Z(t1), Y(t2), Z(t3);
+	}
+	return;
+}
+
+quaternion_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) -> Quaternionf64 {
+	X :: quaternion_from_euler_angle_x;
+	Y :: quaternion_from_euler_angle_y;
+	Z :: quaternion_from_euler_angle_z;
+
+	q1, q2, q3: Quaternionf64;
+
+	switch order {
+	case .XYZ: q1, q2, q3 = X(t1), Y(t2), Z(t3);
+	case .XZY: q1, q2, q3 = X(t1), Z(t2), Y(t3);
+	case .YXZ: q1, q2, q3 = Y(t1), X(t2), Z(t3);
+	case .YZX: q1, q2, q3 = Y(t1), Z(t2), X(t3);
+	case .ZXY: q1, q2, q3 = Z(t1), X(t2), Y(t3);
+	case .ZYX: q1, q2, q3 = Z(t1), Y(t2), X(t3);
+	case .XYX: q1, q2, q3 = X(t1), Y(t2), X(t3);
+	case .XZX: q1, q2, q3 = X(t1), Z(t2), X(t3);
+	case .YXY: q1, q2, q3 = Y(t1), X(t2), Y(t3);
+	case .YZY: q1, q2, q3 = Y(t1), Z(t2), Y(t3);
+	case .ZXZ: q1, q2, q3 = Z(t1), X(t2), Z(t3);
+	case .ZYZ: q1, q2, q3 = Z(t1), Y(t2), Z(t3);
+	}
+
+	return q1 * (q2 * q3);
+}
+
+
+// Quaternionf64s
+
+quaternion_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (q: Quaternionf64) {
+	return quaternion_angle_axis_f64(angle_x, {1, 0, 0});
+}
+quaternion_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (q: Quaternionf64) {
+	return quaternion_angle_axis_f64(angle_y, {0, 1, 0});
+}
+quaternion_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (q: Quaternionf64) {
+	return quaternion_angle_axis_f64(angle_z, {0, 0, 1});
+}
+
+quaternion_from_pitch_yaw_roll_f64 :: proc(pitch, yaw, roll: f64) -> Quaternionf64 {
+	a, b, c := pitch, yaw, roll;
+
+	ca, sa := math.cos(a*0.5), math.sin(a*0.5);
+	cb, sb := math.cos(b*0.5), math.sin(b*0.5);
+	cc, sc := math.cos(c*0.5), math.sin(c*0.5);
+
+	q: Quaternionf64;
+	q.x = sa*cb*cc - ca*sb*sc;
+	q.y = ca*sb*cc + sa*cb*sc;
+	q.z = ca*cb*sc - sa*sb*cc;
+	q.w = ca*cb*cc + sa*sb*sc;
+	return q;
+}
+
+roll_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 {
+	return math.atan2(2 * q.x*q.y + q.w*q.z, q.w*q.w + q.x*q.x - q.y*q.y - q.z*q.z);
+}
+
+pitch_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 {
+	y := 2 * (q.y*q.z + q.w*q.w);
+	x := q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z;
+
+	if abs(x) <= F64_EPSILON && abs(y) <= F64_EPSILON {
+		return 2 * math.atan2(q.x, q.w);
+	}
+
+	return math.atan2(y, x);
+}
+
+yaw_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 {
+	return math.asin(clamp(-2 * (q.x*q.z - q.w*q.y), -1, 1));
+}
+
+
+pitch_yaw_roll_from_quaternion_f64 :: proc(q: Quaternionf64) -> (pitch, yaw, roll: f64) {
+	pitch = pitch_from_quaternion(q);
+	yaw = yaw_from_quaternion(q);
+	roll = roll_from_quaternion(q);
+	return;
+}
+
+euler_angles_xyz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) {
+	return euler_angles_xyz_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_yxz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) {
+	return euler_angles_yxz_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_xzx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) {
+	return euler_angles_xzx_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_xyx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) {
+	return euler_angles_xyx_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_yxy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) {
+	return euler_angles_yxy_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_yzy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) {
+	return euler_angles_yzy_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_zyz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) {
+	return euler_angles_zyz_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_zxz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) {
+	return euler_angles_zxz_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_xzy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) {
+	return euler_angles_xzy_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_yzx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) {
+	return euler_angles_yzx_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_zyx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) {
+	return euler_angles_zyx_from_matrix4(matrix4_from_quaternion(q));
+}
+euler_angles_zxy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) {
+	return euler_angles_zxy_from_matrix4(matrix4_from_quaternion(q));
+}
+
+
+// Matrices
+
+
+matrix4_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (m: Matrix4f64) {
+	cos_x, sin_x := math.cos(angle_x), math.sin(angle_x);
+	m[0][0] = 1;
+	m[1][1] = +cos_x;
+	m[2][1] = +sin_x;
+	m[1][2] = -sin_x;
+	m[2][2] = +cos_x;
+	m[3][3] = 1;
+	return;
+}
+matrix4_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (m: Matrix4f64) {
+	cos_y, sin_y := math.cos(angle_y), math.sin(angle_y);
+	m[0][0] = +cos_y;
+	m[2][0] = -sin_y;
+	m[1][1] = 1;
+	m[0][2] = +sin_y;
+	m[2][2] = +cos_y;
+	m[3][3] = 1;
+	return;
+}
+matrix4_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (m: Matrix4f64) {
+	cos_z, sin_z := math.cos(angle_z), math.sin(angle_z);
+	m[0][0] = +cos_z;
+	m[1][0] = +sin_z;
+	m[1][1] = +cos_z;
+	m[0][1] = -sin_z;
+	m[2][2] = 1;
+	m[3][3] = 1;
+	return;
+}
+
+
+matrix4_from_derived_euler_angle_x_f64 :: proc(angle_x: f64, angular_velocity_x: f64) -> (m: Matrix4f64) {
+	cos_x := math.cos(angle_x) * angular_velocity_x;
+	sin_x := math.sin(angle_x) * angular_velocity_x;
+	m[0][0] = 1;
+	m[1][1] = +cos_x;
+	m[2][1] = +sin_x;
+	m[1][2] = -sin_x;
+	m[2][2] = +cos_x;
+	m[3][3] = 1;
+	return;
+}
+matrix4_from_derived_euler_angle_y_f64 :: proc(angle_y: f64, angular_velocity_y: f64) -> (m: Matrix4f64) {
+	cos_y := math.cos(angle_y) * angular_velocity_y;
+	sin_y := math.sin(angle_y) * angular_velocity_y;
+	m[0][0] = +cos_y;
+	m[2][0] = -sin_y;
+	m[1][1] = 1;
+	m[0][2] = +sin_y;
+	m[2][2] = +cos_y;
+	m[3][3] = 1;
+	return;
+}
+matrix4_from_derived_euler_angle_z_f64 :: proc(angle_z: f64, angular_velocity_z: f64) -> (m: Matrix4f64) {
+	cos_z := math.cos(angle_z) * angular_velocity_z;
+	sin_z := math.sin(angle_z) * angular_velocity_z;
+	m[0][0] = +cos_z;
+	m[1][0] = +sin_z;
+	m[1][1] = +cos_z;
+	m[0][1] = -sin_z;
+	m[2][2] = 1;
+	m[3][3] = 1;
+	return;
+}
+
+
+matrix4_from_euler_angles_xy_f64 :: proc(angle_x, angle_y: f64) -> (m: Matrix4f64) {
+	cos_x, sin_x := math.cos(angle_x), math.sin(angle_x);
+	cos_y, sin_y := math.cos(angle_y), math.sin(angle_y);
+	m[0][0] = cos_y;
+	m[1][0] = -sin_x * - sin_y;
+	m[2][0] = -cos_x * - sin_y;
+	m[1][1] = cos_x;
+	m[2][1] = sin_x;
+	m[0][2] = sin_y;
+	m[1][2] = -sin_x * cos_y;
+	m[2][2] = cos_x * cos_y;
+	m[3][3] = 1;
+	return;
+}
+
+
+matrix4_from_euler_angles_yx_f64 :: proc(angle_y, angle_x: f64) -> (m: Matrix4f64) {
+	cos_x, sin_x := math.cos(angle_x), math.sin(angle_x);
+	cos_y, sin_y := math.cos(angle_y), math.sin(angle_y);
+	m[0][0] = cos_y;
+	m[2][0] = -sin_y;
+	m[0][1] = sin_y*sin_x;
+	m[1][1] = cos_x;
+	m[2][1] = cos_y*sin_x;
+	m[0][2] = sin_y*cos_x;
+	m[1][2] = -sin_x;
+	m[2][2] = cos_y*cos_x;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_xz_f64 :: proc(angle_x, angle_z: f64) -> (m: Matrix4f64) {
+	return mul(matrix4_from_euler_angle_x(angle_x), matrix4_from_euler_angle_z(angle_z));
+}
+matrix4_from_euler_angles_zx_f64 :: proc(angle_z, angle_x: f64) -> (m: Matrix4f64) {
+	return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_x(angle_x));
+}
+matrix4_from_euler_angles_yz_f64 :: proc(angle_y, angle_z: f64) -> (m: Matrix4f64) {
+	return mul(matrix4_from_euler_angle_y(angle_y), matrix4_from_euler_angle_z(angle_z));
+}
+matrix4_from_euler_angles_zy_f64 :: proc(angle_z, angle_y: f64) -> (m: Matrix4f64) {
+	return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_y(angle_y));
+}
+
+
+matrix4_from_euler_angles_xyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) {
+	c1 := math.cos(-t1);
+	c2 := math.cos(-t2);
+	c3 := math.cos(-t3);
+	s1 := math.sin(-t1);
+	s2 := math.sin(-t2);
+	s3 := math.sin(-t3);
+
+	m[0][0] = c2 * c3;
+	m[0][1] =-c1 * s3 + s1 * s2 * c3;
+	m[0][2] = s1 * s3 + c1 * s2 * c3;
+	m[0][3] = 0;
+	m[1][0] = c2 * s3;
+	m[1][1] = c1 * c3 + s1 * s2 * s3;
+	m[1][2] =-s1 * c3 + c1 * s2 * s3;
+	m[1][3] = 0;
+	m[2][0] =-s2;
+	m[2][1] = s1 * c2;
+	m[2][2] = c1 * c2;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_yxz_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix4f64) {
+	ch := math.cos(yaw);
+	sh := math.sin(yaw);
+	cp := math.cos(pitch);
+	sp := math.sin(pitch);
+	cb := math.cos(roll);
+	sb := math.sin(roll);
+
+	m[0][0] = ch * cb + sh * sp * sb;
+	m[0][1] = sb * cp;
+	m[0][2] = -sh * cb + ch * sp * sb;
+	m[0][3] = 0;
+	m[1][0] = -ch * sb + sh * sp * cb;
+	m[1][1] = cb * cp;
+	m[1][2] = sb * sh + ch * sp * cb;
+	m[1][3] = 0;
+	m[2][0] = sh * cp;
+	m[2][1] = -sp;
+	m[2][2] = ch * cp;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_xzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c2;
+	m[0][1] = c1 * s2;
+	m[0][2] = s1 * s2;
+	m[0][3] = 0;
+	m[1][0] =-c3 * s2;
+	m[1][1] = c1 * c2 * c3 - s1 * s3;
+	m[1][2] = c1 * s3 + c2 * c3 * s1;
+	m[1][3] = 0;
+	m[2][0] = s2 * s3;
+	m[2][1] =-c3 * s1 - c1 * c2 * s3;
+	m[2][2] = c1 * c3 - c2 * s1 * s3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_xyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c2;
+	m[0][1] = s1 * s2;
+	m[0][2] =-c1 * s2;
+	m[0][3] = 0;
+	m[1][0] = s2 * s3;
+	m[1][1] = c1 * c3 - c2 * s1 * s3;
+	m[1][2] = c3 * s1 + c1 * c2 * s3;
+	m[1][3] = 0;
+	m[2][0] = c3 * s2;
+	m[2][1] =-c1 * s3 - c2 * c3 * s1;
+	m[2][2] = c1 * c2 * c3 - s1 * s3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_yxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c1 * c3 - c2 * s1 * s3;
+	m[0][1] = s2* s3;
+	m[0][2] =-c3 * s1 - c1 * c2 * s3;
+	m[0][3] = 0;
+	m[1][0] = s1 * s2;
+	m[1][1] = c2;
+	m[1][2] = c1 * s2;
+	m[1][3] = 0;
+	m[2][0] = c1 * s3 + c2 * c3 * s1;
+	m[2][1] =-c3 * s2;
+	m[2][2] = c1 * c2 * c3 - s1 * s3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_yzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c1 * c2 * c3 - s1 * s3;
+	m[0][1] = c3 * s2;
+	m[0][2] =-c1 * s3 - c2 * c3 * s1;
+	m[0][3] = 0;
+	m[1][0] =-c1 * s2;
+	m[1][1] = c2;
+	m[1][2] = s1 * s2;
+	m[1][3] = 0;
+	m[2][0] = c3 * s1 + c1 * c2 * s3;
+	m[2][1] = s2 * s3;
+	m[2][2] = c1 * c3 - c2 * s1 * s3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_zyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c1 * c2 * c3 - s1 * s3;
+	m[0][1] = c1 * s3 + c2 * c3 * s1;
+	m[0][2] =-c3 * s2;
+	m[0][3] = 0;
+	m[1][0] =-c3 * s1 - c1 * c2 * s3;
+	m[1][1] = c1 * c3 - c2 * s1 * s3;
+	m[1][2] = s2 * s3;
+	m[1][3] = 0;
+	m[2][0] = c1 * s2;
+	m[2][1] = s1 * s2;
+	m[2][2] = c2;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_zxz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c1 * c3 - c2 * s1 * s3;
+	m[0][1] = c3 * s1 + c1 * c2 * s3;
+	m[0][2] = s2 *s3;
+	m[0][3] = 0;
+	m[1][0] =-c1 * s3 - c2 * c3 * s1;
+	m[1][1] = c1 * c2 * c3 - s1 * s3;
+	m[1][2] = c3 * s2;
+	m[1][3] = 0;
+	m[2][0] = s1 * s2;
+	m[2][1] =-c1 * s2;
+	m[2][2] = c2;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+
+matrix4_from_euler_angles_xzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c2 * c3;
+	m[0][1] = s1 * s3 + c1 * c3 * s2;
+	m[0][2] = c3 * s1 * s2 - c1 * s3;
+	m[0][3] = 0;
+	m[1][0] =-s2;
+	m[1][1] = c1 * c2;
+	m[1][2] = c2 * s1;
+	m[1][3] = 0;
+	m[2][0] = c2 * s3;
+	m[2][1] = c1 * s2 * s3 - c3 * s1;
+	m[2][2] = c1 * c3 + s1 * s2 *s3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_yzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c1 * c2;
+	m[0][1] = s2;
+	m[0][2] =-c2 * s1;
+	m[0][3] = 0;
+	m[1][0] = s1 * s3 - c1 * c3 * s2;
+	m[1][1] = c2 * c3;
+	m[1][2] = c1 * s3 + c3 * s1 * s2;
+	m[1][3] = 0;
+	m[2][0] = c3 * s1 + c1 * s2 * s3;
+	m[2][1] =-c2 * s3;
+	m[2][2] = c1 * c3 - s1 * s2 * s3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_zyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c1 * c2;
+	m[0][1] = c2 * s1;
+	m[0][2] =-s2;
+	m[0][3] = 0;
+	m[1][0] = c1 * s2 * s3 - c3 * s1;
+	m[1][1] = c1 * c3 + s1 * s2 * s3;
+	m[1][2] = c2 * s3;
+	m[1][3] = 0;
+	m[2][0] = s1 * s3 + c1 * c3 * s2;
+	m[2][1] = c3 * s1 * s2 - c1 * s3;
+	m[2][2] = c2 * c3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+matrix4_from_euler_angles_zxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) {
+	c1 := math.cos(t1);
+	s1 := math.sin(t1);
+	c2 := math.cos(t2);
+	s2 := math.sin(t2);
+	c3 := math.cos(t3);
+	s3 := math.sin(t3);
+
+	m[0][0] = c1 * c3 - s1 * s2 * s3;
+	m[0][1] = c3 * s1 + c1 * s2 * s3;
+	m[0][2] =-c2 * s3;
+	m[0][3] = 0;
+	m[1][0] =-c2 * s1;
+	m[1][1] = c1 * c2;
+	m[1][2] = s2;
+	m[1][3] = 0;
+	m[2][0] = c1 * s3 + c3 * s1 * s2;
+	m[2][1] = s1 * s3 - c1 * c3 * s2;
+	m[2][2] = c2 * c3;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return;
+}
+
+
+matrix4_from_yaw_pitch_roll_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix4f64) {
+	ch := math.cos(yaw);
+	sh := math.sin(yaw);
+	cp := math.cos(pitch);
+	sp := math.sin(pitch);
+	cb := math.cos(roll);
+	sb := math.sin(roll);
+
+	m[0][0] = ch * cb + sh * sp * sb;
+	m[0][1] = sb * cp;
+	m[0][2] = -sh * cb + ch * sp * sb;
+	m[0][3] = 0;
+	m[1][0] = -ch * sb + sh * sp * cb;
+	m[1][1] = cb * cp;
+	m[1][2] = sb * sh + ch * sp * cb;
+	m[1][3] = 0;
+	m[2][0] = sh * cp;
+	m[2][1] = -sp;
+	m[2][2] = ch * cp;
+	m[2][3] = 0;
+	m[3][0] = 0;
+	m[3][1] = 0;
+	m[3][2] = 0;
+	m[3][3] = 1;
+	return m;
+}
+
+euler_angles_xyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) {
+	T1 := math.atan2(m[2][1], m[2][2]);
+	C2 := math.sqrt(m[0][0]*m[0][0] + m[1][0]*m[1][0]);
+	T2 := math.atan2(-m[2][0], C2);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(S1*m[0][2] - C1*m[0][1], C1*m[1][1] - S1*m[1][2]);
+	t1 = -T1;
+	t2 = -T2;
+	t3 = -T3;
+	return;
+}
+
+euler_angles_yxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) {
+	T1 := math.atan2(m[2][0], m[2][2]);
+	C2 := math.sqrt(m[0][1]*m[0][1] + m[1][1]*m[1][1]);
+	T2 := math.atan2(-m[2][1], C2);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(S1*m[1][2] - C1*m[1][0], C1*m[0][0] - S1*m[0][2]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_xzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) {
+	T1 := math.atan2(m[0][2], m[0][1]);
+	S2 := math.sqrt(m[1][0]*m[1][0] + m[2][0]*m[2][0]);
+	T2 := math.atan2(S2, m[0][0]);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(C1*m[1][2] - S1*m[1][1], C1*m[2][2] - S1*m[2][1]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_xyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) {
+	T1 := math.atan2(m[0][1], -m[0][2]);
+	S2 := math.sqrt(m[1][0]*m[1][0] + m[2][0]*m[2][0]);
+	T2 := math.atan2(S2, m[0][0]);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(-C1*m[2][1] - S1*m[2][2], C1*m[1][1] + S1*m[1][2]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_yxy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) {
+	T1 := math.atan2(m[1][0], m[1][2]);
+	S2 := math.sqrt(m[0][1]*m[0][1] + m[2][1]*m[2][1]);
+	T2 := math.atan2(S2, m[1][1]);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(C1*m[2][0] - S1*m[2][2], C1*m[0][0] - S1*m[0][2]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_yzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) {
+	T1 := math.atan2(m[1][2], -m[1][0]);
+	S2 := math.sqrt(m[0][1]*m[0][1] + m[2][1]*m[2][1]);
+	T2 := math.atan2(S2, m[1][1]);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(-S1*m[0][0] - C1*m[0][2], S1*m[2][0] + C1*m[2][2]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+euler_angles_zyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) {
+	T1 := math.atan2(m[2][1], m[2][0]);
+	S2 := math.sqrt(m[0][2]*m[0][2] + m[1][2]*m[1][2]);
+	T2 := math.atan2(S2, m[2][2]);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(C1*m[0][1] - S1*m[0][0], C1*m[1][1] - S1*m[1][0]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_zxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) {
+	T1 := math.atan2(m[2][0], -m[2][1]);
+	S2 := math.sqrt(m[0][2]*m[0][2] + m[1][2]*m[1][2]);
+	T2 := math.atan2(S2, m[2][2]);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(-C1*m[1][0] - S1*m[1][1], C1*m[0][0] + S1*m[0][1]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_xzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) {
+	T1 := math.atan2(m[1][2], m[1][1]);
+	C2 := math.sqrt(m[0][0]*m[0][0] + m[2][0]*m[2][0]);
+	T2 := math.atan2(-m[1][0], C2);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(S1*m[0][1] - C1*m[0][2], C1*m[2][2] - S1*m[2][1]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_yzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) {
+	T1 := math.atan2(-m[0][2], m[0][0]);
+	C2 := math.sqrt(m[1][1]*m[1][1] + m[2][1]*m[2][1]);
+	T2 := math.atan2(m[0][1], C2);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(S1*m[1][0] + C1*m[1][2], S1*m[2][0] + C1*m[2][2]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_zyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) {
+	T1 := math.atan2(m[0][1], m[0][0]);
+	C2 := math.sqrt(m[1][2]*m[1][2] + m[2][2]*m[2][2]);
+	T2 := math.atan2(-m[0][2], C2);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(S1*m[2][0] - C1*m[2][1], C1*m[1][1] - S1*m[1][0]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}
+
+euler_angles_zxy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) {
+	T1 := math.atan2(-m[1][0], m[1][1]);
+	C2 := math.sqrt(m[0][2]*m[0][2] + m[2][2]*m[2][2]);
+	T2 := math.atan2(m[1][2], C2);
+	S1 := math.sin(T1);
+	C1 := math.cos(T1);
+	T3 := math.atan2(C1*m[2][0] + S1*m[2][1], C1*m[0][0] + S1*m[0][1]);
+	t1 = T1;
+	t2 = T2;
+	t3 = T3;
+	return;
+}

core/math/linalg/swizzle.odin

@@ -0,0 +1,222 @@
+package linalg
+
+Scalar_Components :: enum u8 {
+	x = 0,
+	r = 0,
+}
+
+Vector2_Components :: enum u8 {
+	x = 0,
+	y = 1,
+	r = 0,
+	g = 1,
+}
+
+Vector3_Components :: enum u8 {
+	x = 0,
+	y = 1,
+	z = 2,
+	r = 0,
+	g = 1,
+	b = 2,
+}
+
+Vector4_Components :: enum u8 {
+	x = 0,
+	y = 1,
+	z = 2,
+	w = 3,
+	r = 0,
+	g = 1,
+	b = 2,
+	a = 3,
+}
+
+scalar_f32_swizzle1 :: proc(f: f32, c0: Scalar_Components) -> f32 {
+	return f;
+}
+scalar_f32_swizzle2 :: proc(f: f32, c0, c1: Scalar_Components) -> Vector2f32 {
+	return {f, f};
+}
+scalar_f32_swizzle3 :: proc(f: f32, c0, c1, c2: Scalar_Components) -> Vector3f32 {
+	return {f, f, f};
+}
+scalar_f32_swizzle4 :: proc(f: f32, c0, c1, c2, c3: Scalar_Components) -> Vector4f32 {
+	return {f, f, f, f};
+}
+
+vector2f32_swizzle1 :: proc(v: Vector2f32, c0: Vector2_Components) -> f32 {
+	return v[c0];
+}
+vector2f32_swizzle2 :: proc(v: Vector2f32, c0, c1: Vector2_Components) -> Vector2f32 {
+	return {v[c0], v[c1]};
+}
+vector2f32_swizzle3 :: proc(v: Vector2f32, c0, c1, c2: Vector2_Components) -> Vector3f32 {
+	return {v[c0], v[c1], v[c2]};
+}
+vector2f32_swizzle4 :: proc(v: Vector2f32, c0, c1, c2, c3: Vector2_Components) -> Vector4f32 {
+	return {v[c0], v[c1], v[c2], v[c3]};
+}
+
+
+vector3f32_swizzle1 :: proc(v: Vector3f32, c0: Vector3_Components) -> f32 {
+	return v[c0];
+}
+vector3f32_swizzle2 :: proc(v: Vector3f32, c0, c1: Vector3_Components) -> Vector2f32 {
+	return {v[c0], v[c1]};
+}
+vector3f32_swizzle3 :: proc(v: Vector3f32, c0, c1, c2: Vector3_Components) -> Vector3f32 {
+	return {v[c0], v[c1], v[c2]};
+}
+vector3f32_swizzle4 :: proc(v: Vector3f32, c0, c1, c2, c3: Vector3_Components) -> Vector4f32 {
+	return {v[c0], v[c1], v[c2], v[c3]};
+}
+
+vector4f32_swizzle1 :: proc(v: Vector4f32, c0: Vector4_Components) -> f32 {
+	return v[c0];
+}
+vector4f32_swizzle2 :: proc(v: Vector4f32, c0, c1: Vector4_Components) -> Vector2f32 {
+	return {v[c0], v[c1]};
+}
+vector4f32_swizzle3 :: proc(v: Vector4f32, c0, c1, c2: Vector4_Components) -> Vector3f32 {
+	return {v[c0], v[c1], v[c2]};
+}
+vector4f32_swizzle4 :: proc(v: Vector4f32, c0, c1, c2, c3: Vector4_Components) -> Vector4f32 {
+	return {v[c0], v[c1], v[c2], v[c3]};
+}
+
+
+scalar_f64_swizzle1 :: proc(f: f64, c0: Scalar_Components) -> f64 {
+	return f;
+}
+scalar_f64_swizzle2 :: proc(f: f64, c0, c1: Scalar_Components) -> Vector2f64 {
+	return {f, f};
+}
+scalar_f64_swizzle3 :: proc(f: f64, c0, c1, c2: Scalar_Components) -> Vector3f64 {
+	return {f, f, f};
+}
+scalar_f64_swizzle4 :: proc(f: f64, c0, c1, c2, c3: Scalar_Components) -> Vector4f64 {
+	return {f, f, f, f};
+}
+
+vector2f64_swizzle1 :: proc(v: Vector2f64, c0: Vector2_Components) -> f64 {
+	return v[c0];
+}
+vector2f64_swizzle2 :: proc(v: Vector2f64, c0, c1: Vector2_Components) -> Vector2f64 {
+	return {v[c0], v[c1]};
+}
+vector2f64_swizzle3 :: proc(v: Vector2f64, c0, c1, c2: Vector2_Components) -> Vector3f64 {
+	return {v[c0], v[c1], v[c2]};
+}
+vector2f64_swizzle4 :: proc(v: Vector2f64, c0, c1, c2, c3: Vector2_Components) -> Vector4f64 {
+	return {v[c0], v[c1], v[c2], v[c3]};
+}
+
+
+vector3f64_swizzle1 :: proc(v: Vector3f64, c0: Vector3_Components) -> f64 {
+	return v[c0];
+}
+vector3f64_swizzle2 :: proc(v: Vector3f64, c0, c1: Vector3_Components) -> Vector2f64 {
+	return {v[c0], v[c1]};
+}
+vector3f64_swizzle3 :: proc(v: Vector3f64, c0, c1, c2: Vector3_Components) -> Vector3f64 {
+	return {v[c0], v[c1], v[c2]};
+}
+vector3f64_swizzle4 :: proc(v: Vector3f64, c0, c1, c2, c3: Vector3_Components) -> Vector4f64 {
+	return {v[c0], v[c1], v[c2], v[c3]};
+}
+
+vector4f64_swizzle1 :: proc(v: Vector4f64, c0: Vector4_Components) -> f64 {
+	return v[c0];
+}
+vector4f64_swizzle2 :: proc(v: Vector4f64, c0, c1: Vector4_Components) -> Vector2f64 {
+	return {v[c0], v[c1]};
+}
+vector4f64_swizzle3 :: proc(v: Vector4f64, c0, c1, c2: Vector4_Components) -> Vector3f64 {
+	return {v[c0], v[c1], v[c2]};
+}
+vector4f64_swizzle4 :: proc(v: Vector4f64, c0, c1, c2, c3: Vector4_Components) -> Vector4f64 {
+	return {v[c0], v[c1], v[c2], v[c3]};
+}
+
+
+
+
+scalar_swizzle :: proc{
+	scalar_f32_swizzle1,
+	scalar_f32_swizzle2,
+	scalar_f32_swizzle3,
+	scalar_f32_swizzle4,
+	scalar_f64_swizzle1,
+	scalar_f64_swizzle2,
+	scalar_f64_swizzle3,
+	scalar_f64_swizzle4,
+};
+
+vector2_swizzle :: proc{
+	vector2f32_swizzle1,
+	vector2f32_swizzle2,
+	vector2f32_swizzle3,
+	vector2f32_swizzle4,
+	vector2f64_swizzle1,
+	vector2f64_swizzle2,
+	vector2f64_swizzle3,
+	vector2f64_swizzle4,
+};
+
+vector3_swizzle :: proc{
+	vector3f32_swizzle1,
+	vector3f32_swizzle2,
+	vector3f32_swizzle3,
+	vector3f32_swizzle4,
+	vector3f64_swizzle1,
+	vector3f64_swizzle2,
+	vector3f64_swizzle3,
+	vector3f64_swizzle4,
+};
+
+vector4_swizzle :: proc{
+	vector4f32_swizzle1,
+	vector4f32_swizzle2,
+	vector4f32_swizzle3,
+	vector4f32_swizzle4,
+	vector4f64_swizzle1,
+	vector4f64_swizzle2,
+	vector4f64_swizzle3,
+	vector4f64_swizzle4,
+};
+
+swizzle :: proc{
+	scalar_f32_swizzle1,
+	scalar_f32_swizzle2,
+	scalar_f32_swizzle3,
+	scalar_f32_swizzle4,
+	scalar_f64_swizzle1,
+	scalar_f64_swizzle2,
+	scalar_f64_swizzle3,
+	scalar_f64_swizzle4,
+	vector2f32_swizzle1,
+	vector2f32_swizzle2,
+	vector2f32_swizzle3,
+	vector2f32_swizzle4,
+	vector2f64_swizzle1,
+	vector2f64_swizzle2,
+	vector2f64_swizzle3,
+	vector2f64_swizzle4,
+	vector3f32_swizzle1,
+	vector3f32_swizzle2,
+	vector3f32_swizzle3,
+	vector3f32_swizzle4,
+	vector3f64_swizzle1,
+	vector3f64_swizzle2,
+	vector3f64_swizzle3,
+	vector3f64_swizzle4,
+	vector4f32_swizzle1,
+	vector4f32_swizzle2,
+	vector4f32_swizzle3,
+	vector4f32_swizzle4,
+	vector4f64_swizzle1,
+	vector4f64_swizzle2,
+	vector4f64_swizzle3,
+	vector4f64_swizzle4,
+};