From 74ce99e0d758753f255c36d1df564e88347dd712 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Mon, 22 May 2023 12:05:56 +0100 Subject: [PATCH] Add `@(require_results)` `core:math/linalg` procedures --- core/math/linalg/extended.odin | 71 ++++++- core/math/linalg/general.odin | 74 +++++-- core/math/linalg/specific.odin | 185 ++++++++++++++++++ .../linalg/specific_euler_angles_f16.odin | 100 ++++++++++ .../linalg/specific_euler_angles_f32.odin | 100 ++++++++++ .../linalg/specific_euler_angles_f64.odin | 100 ++++++++++ core/math/linalg/swizzle.odin | 32 +++ 7 files changed, 638 insertions(+), 24 deletions(-) diff --git a/core/math/linalg/extended.odin b/core/math/linalg/extended.odin index 22368b70c..f0be35aa1 100644 --- a/core/math/linalg/extended.odin +++ b/core/math/linalg/extended.odin @@ -3,6 +3,7 @@ package linalg import "core:builtin" import "core:math" +@(require_results) to_radians :: proc(degrees: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { return } +@(require_results) to_degrees :: proc(radians: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { return } +@(require_results) min_double :: proc(a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { return } +@(require_results) min_single :: proc(a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { N :: len(T) @@ -56,12 +60,14 @@ min_single :: proc(a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) return } +@(require_results) min_triple :: proc(a, b, c: $T) -> T where IS_NUMERIC(ELEM_TYPE(T)) { return min_double(a, min_double(b, c)) } min :: proc{min_single, min_double, min_triple} +@(require_results) max_double :: proc(a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { return } +@(require_results) max_single :: proc(a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { N :: len(T) @@ -95,12 +102,14 @@ max_single :: proc(a: $T) -> (out: ELEM_TYPE(T)) where IS_NUMERIC(ELEM_TYPE(T)) return } +@(require_results) max_triple :: proc(a, b, c: $T) -> T where IS_NUMERIC(ELEM_TYPE(T)) { return max_double(a, max_double(b, c)) } max :: proc{max_single, max_double, max_triple} +@(require_results) abs :: proc(a: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { return } +@(require_results) sign :: proc(a: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { return } +@(require_results) clamp :: proc(x, a, b: $T) -> (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_NUMERIC(ELEM_TYPE(T)) { } +@(require_results) saturate :: proc(x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { return clamp(x, 0.0, 1.0) } +@(require_results) lerp :: proc(a, b, t: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } return } +@(require_results) mix :: proc(a, b, t: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) unlerp :: proc(a, b, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { return (x - a) / (b - a) } +@(require_results) step :: proc(e, x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) smoothstep :: proc(e0, e1, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { t := saturate(unlerp(e0, e1, x)) return t * t * (3.0 - 2.0 * t) } +@(require_results) smootherstep :: proc(e0, e1, x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { t := saturate(unlerp(e0, e1, x)) return t * t * t * (t * (6*t - 15) + 10) } +@(require_results) sqrt :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) inverse_sqrt :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) cos :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) sin :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) tan :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) acos :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) asin :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) atan :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } return } +@(require_results) atan2 :: proc(y, x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } +@(require_results) ln :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) log2 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) log10 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) log :: proc(x, b: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) exp :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) exp2 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) exp10 :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) pow :: proc(x, e: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { } +@(require_results) ceil :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) floor :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) round :: proc(x: $T) -> (out: T) where IS_FLOAT(ELEM_TYPE(T)) { when IS_ARRAY(T) { for i in 0.. (out: T) where IS_FLOAT(ELEM_TYPE(T)) { return } +@(require_results) fract :: proc(x: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { f := #force_inline floor(x) return x - f } +@(require_results) mod :: proc(x, m: $T) -> T where IS_FLOAT(ELEM_TYPE(T)) { f := #force_inline floor(x / m) return x - f * m } +@(require_results) face_forward :: proc(N, I, N_ref: $T) -> (out: T) where IS_ARRAY(T), IS_FLOAT(ELEM_TYPE(T)) { return dot(N_ref, I) < 0 ? N : -N } +@(require_results) distance :: proc(p0, p1: $V/[$N]$E) -> E where IS_NUMERIC(E) { return length(p1 - p0) } +@(require_results) reflect :: proc(I, N: $T) -> (out: T) where IS_ARRAY(T), IS_FLOAT(ELEM_TYPE(T)) { b := N * (2 * dot(N, I)) return I - b } +@(require_results) refract :: proc(I, Normal: $V/[$N]$E, eta: E) -> (out: V) where IS_ARRAY(V), IS_FLOAT(ELEM_TYPE(V)) { dv := dot(Normal, I) k := 1 - eta*eta * (1 - dv*dv) @@ -441,10 +485,12 @@ refract :: proc(I, Normal: $V/[$N]$E, eta: E) -> (out: V) where IS_ARRAY(V), IS_ +@(require_results) is_nan_single :: proc(x: $T) -> bool where IS_FLOAT(T) { return #force_inline math.is_nan(x) } +@(require_results) is_nan_array :: proc(x: $A/[$N]$T) -> (out: [N]bool) where IS_FLOAT(T) { for i in 0.. (out: [N]bool) where IS_FLOAT(T) { return } +@(require_results) is_inf_single :: proc(x: $T) -> bool where IS_FLOAT(T) { return #force_inline math.is_inf(x) } +@(require_results) is_inf_array :: proc(x: $A/[$N]$T) -> (out: [N]bool) where IS_FLOAT(T) { for i in 0.. (out: [N]bool) where IS_FLOAT(T) { return } +@(require_results) classify_single :: proc(x: $T) -> math.Float_Class where IS_FLOAT(T) { return #force_inline math.classify(x) } +@(require_results) classify_array :: proc(x: $A/[$N]$T) -> (out: [N]math.Float_Class) where IS_FLOAT(T) { for i in 0.. (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x < y } -less_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x <= y } -greater_than_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x > y } -greater_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x >= y } -equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x == y } -not_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x != y } +@(require_results) less_than_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x < y } +@(require_results) less_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x <= y } +@(require_results) greater_than_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x > y } +@(require_results) greater_than_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x >= y } +@(require_results) equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x == y } +@(require_results) not_equal_single :: proc(x, y: $T) -> (out: bool) where !IS_ARRAY(T), IS_FLOAT(T) { return x != y } +@(require_results) less_than_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. y[i] } return } +@(require_results) greater_than_equal_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0..= y[i] } return } +@(require_results) equal_array :: proc(x, y: $A/[$N]$T) -> (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. (out: [N]bool) where IS_ARRAY(A), IS_FLOAT(ELEM_TYPE(A)) { for i in 0.. (out: bool) { for e in x { if e { @@ -538,6 +595,7 @@ any :: proc(x: $A/[$N]bool) -> (out: bool) { } return false } +@(require_results) all :: proc(x: $A/[$N]bool) -> (out: bool) { for e in x { if !e { @@ -546,6 +604,7 @@ all :: proc(x: $A/[$N]bool) -> (out: bool) { } return true } +@(require_results) not :: proc(x: $A/[$N]bool) -> (out: A) { for e, i in x { out[i] = !e diff --git a/core/math/linalg/general.odin b/core/math/linalg/general.odin index c11151b25..dca3cf5d5 100644 --- a/core/math/linalg/general.odin +++ b/core/math/linalg/general.odin @@ -38,22 +38,27 @@ DEG_PER_RAD :: 360.0/TAU @private ELEM_TYPE :: intrinsics.type_elem_type +@(require_results) scalar_dot :: proc(a, b: $T) -> T where IS_FLOAT(T), !IS_ARRAY(T) { return a * b } +@(require_results) vector_dot :: proc(a, b: $T/[$N]$E) -> (c: E) where IS_NUMERIC(E) #no_bounds_check { for i in 0.. (c: f16) { return a.w*a.w + a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) quaternion128_dot :: proc(a, b: $T/quaternion128) -> (c: f32) { return a.w*a.w + a.x*b.x + a.y*b.y + a.z*b.z } +@(require_results) quaternion256_dot :: proc(a, b: $T/quaternion256) -> (c: f64) { return a.w*a.w + a.x*b.x + a.y*b.y + a.z*b.z } @@ -63,19 +68,23 @@ dot :: proc{scalar_dot, vector_dot, quaternion64_dot, quaternion128_dot, quatern inner_product :: dot outer_product :: builtin.outer_product +@(require_results) quaternion_inverse :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { return conj(q) * quaternion(1.0/dot(q, q), 0, 0, 0) } +@(require_results) scalar_cross :: proc(a, b: $T) -> T where IS_FLOAT(T), !IS_ARRAY(T) { return a * b } +@(require_results) vector_cross2 :: proc(a, b: $T/[2]$E) -> E where IS_NUMERIC(E) { return a[0]*b[1] - b[0]*a[1] } +@(require_results) vector_cross3 :: proc(a, b: $T/[3]$E) -> (c: T) where IS_NUMERIC(E) { c[0] = a[1]*b[2] - b[1]*a[2] c[1] = a[2]*b[0] - b[2]*a[0] @@ -83,6 +92,7 @@ vector_cross3 :: proc(a, b: $T/[3]$E) -> (c: T) where IS_NUMERIC(E) { return } +@(require_results) quaternion_cross :: proc(q1, q2: $Q) -> (q3: Q) where IS_QUATERNION(Q) { q3.x = q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y q3.y = q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z @@ -94,18 +104,22 @@ quaternion_cross :: proc(q1, q2: $Q) -> (q3: Q) where IS_QUATERNION(Q) { vector_cross :: proc{scalar_cross, vector_cross2, vector_cross3} cross :: proc{scalar_cross, vector_cross2, vector_cross3, quaternion_cross} +@(require_results) vector_normalize :: proc(v: $T/[$N]$E) -> T where IS_FLOAT(E) { return v / length(v) } +@(require_results) quaternion_normalize :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { return q/abs(q) } normalize :: proc{vector_normalize, quaternion_normalize} +@(require_results) vector_normalize0 :: proc(v: $T/[$N]$E) -> T where IS_FLOAT(E) { m := length(v) return 0 if m == 0 else v/m } +@(require_results) quaternion_normalize0 :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { m := abs(q) return 0 if m == 0 else q/m @@ -113,22 +127,27 @@ quaternion_normalize0 :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { normalize0 :: proc{vector_normalize0, quaternion_normalize0} +@(require_results) vector_length :: proc(v: $T/[$N]$E) -> E where IS_FLOAT(E) { return math.sqrt(dot(v, v)) } +@(require_results) vector_length2 :: proc(v: $T/[$N]$E) -> E where IS_NUMERIC(E) { return dot(v, v) } +@(require_results) quaternion_length :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { return abs(q) } +@(require_results) quaternion_length2 :: proc(q: $Q) -> Q where IS_QUATERNION(Q) { return dot(q, q) } +@(require_results) scalar_triple_product :: proc(a, b, c: $T/[$N]$E) -> E where IS_NUMERIC(E) { // a . (b x c) // b . (c x a) @@ -136,6 +155,7 @@ scalar_triple_product :: proc(a, b, c: $T/[$N]$E) -> E where IS_NUMERIC(E) { return dot(a, cross(b, c)) } +@(require_results) vector_triple_product :: proc(a, b, c: $T/[$N]$E) -> T where IS_NUMERIC(E) { // a x (b x c) // (a . c)b - (a . b)c @@ -146,10 +166,12 @@ vector_triple_product :: proc(a, b, c: $T/[$N]$E) -> T where IS_NUMERIC(E) { length :: proc{vector_length, quaternion_length} length2 :: proc{vector_length2, quaternion_length2} +@(require_results) projection :: proc(x, normal: $T/[$N]$E) -> T where IS_NUMERIC(E) { return dot(x, normal) / dot(normal, normal) * normal } +@(require_results) identity :: proc($T: typeid/[$N][N]$E) -> (m: T) #no_bounds_check { for i in 0.. (m: T) #no_bounds_check { trace :: builtin.matrix_trace transpose :: builtin.transpose +@(require_results) matrix_mul :: proc(a, b: $M/matrix[$N, N]$E) -> (c: M) where !IS_ARRAY(E), IS_NUMERIC(E) #no_bounds_check { return a * b } +@(require_results) matrix_comp_mul :: proc(a, b: $M/matrix[$I, $J]$E) -> (c: M) where !IS_ARRAY(E), IS_NUMERIC(E) #no_bounds_check { return hadamard_product(a, b) } +@(require_results) matrix_mul_differ :: proc(a: $A/matrix[$I, $J]$E, b: $B/matrix[J, $K]E) -> (c: matrix[I, K]E) where !IS_ARRAY(E), IS_NUMERIC(E), I != K #no_bounds_check { return a * b } +@(require_results) matrix_mul_vector :: proc(a: $A/matrix[$I, $J]$E, b: $B/[J]E) -> (c: B) where !IS_ARRAY(E), IS_NUMERIC(E) #no_bounds_check { return a * b } +@(require_results) quaternion_mul_quaternion :: proc(q1, q2: $Q) -> Q where IS_QUATERNION(Q) { return q1 * q2 } +@(require_results) quaternion64_mul_vector3 :: proc(q: $Q/quaternion64, v: $V/[3]$F/f16) -> V { Raw_Quaternion :: struct {xyz: [3]f16, r: f16} @@ -194,6 +222,7 @@ quaternion64_mul_vector3 :: proc(q: $Q/quaternion64, v: $V/[3]$F/f16) -> V { t := cross(2*q.xyz, v) return V(v + q.r*t + cross(q.xyz, t)) } +@(require_results) quaternion128_mul_vector3 :: proc(q: $Q/quaternion128, v: $V/[3]$F/f32) -> V { Raw_Quaternion :: struct {xyz: [3]f32, r: f32} @@ -203,6 +232,7 @@ quaternion128_mul_vector3 :: proc(q: $Q/quaternion128, v: $V/[3]$F/f32) -> V { t := cross(2*q.xyz, v) return V(v + q.r*t + cross(q.xyz, t)) } +@(require_results) quaternion256_mul_vector3 :: proc(q: $Q/quaternion256, v: $V/[3]$F/f64) -> V { Raw_Quaternion :: struct {xyz: [3]f64, r: f64} @@ -224,9 +254,11 @@ mul :: proc{ quaternion_mul_quaternion, } +@(require_results) vector_to_ptr :: proc(v: ^$V/[$N]$E) -> ^E where IS_NUMERIC(E), N > 0 #no_bounds_check { return &v[0] } +@(require_results) matrix_to_ptr :: proc(m: ^$A/matrix[$I, $J]$E) -> ^E where IS_NUMERIC(E), I > 0, J > 0 #no_bounds_check { return &m[0, 0] } @@ -239,6 +271,7 @@ to_ptr :: proc{vector_to_ptr, matrix_to_ptr} // Splines +@(require_results) vector_slerp :: proc(x, y: $T/[$N]$E, a: E) -> T { cos_alpha := dot(x, y) alpha := math.acos(cos_alpha) @@ -250,6 +283,7 @@ vector_slerp :: proc(x, y: $T/[$N]$E, a: E) -> T { return x * t1 + y * t2 } +@(require_results) catmull_rom :: proc(v1, v2, v3, v4: $T/[$N]$E, s: E) -> T { s2 := s*s s3 := s2*s @@ -262,6 +296,7 @@ catmull_rom :: proc(v1, v2, v3, v4: $T/[$N]$E, s: E) -> T { return (f1 * v1 + f2 * v2 + f3 * v3 + f4 * v4) * 0.5 } +@(require_results) hermite :: proc(v1, t1, v2, t2: $T/[$N]$E, s: E) -> T { s2 := s*s s3 := s2*s @@ -274,12 +309,14 @@ hermite :: proc(v1, t1, v2, t2: $T/[$N]$E, s: E) -> T { return f1 * v1 + f2 * v2 + f3 * t1 + f4 * t2 } +@(require_results) cubic :: proc(v1, v2, v3, v4: $T/[$N]$E, s: E) -> T { return ((v1 * s + v2) * s + v3) * s + v4 } +@(require_results) array_cast :: proc(v: $A/[$N]$T, $Elem_Type: typeid) -> (w: [N]Elem_Type) #no_bounds_check { for i in 0.. (w: [N]Elem_Type) #no_bo return } +@(require_results) matrix_cast :: proc(v: $A/matrix[$M, $N]$T, $Elem_Type: typeid) -> (w: matrix[M, N]Elem_Type) #no_bounds_check { for j in 0.. (w: matrix[M, return } -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) } +@(require_results) to_f32 :: #force_inline proc(v: $A/[$N]$T) -> [N]f32 { return array_cast(v, f32) } +@(require_results) 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) } +@(require_results) to_i8 :: #force_inline proc(v: $A/[$N]$T) -> [N]i8 { return array_cast(v, i8) } +@(require_results) to_i16 :: #force_inline proc(v: $A/[$N]$T) -> [N]i16 { return array_cast(v, i16) } +@(require_results) to_i32 :: #force_inline proc(v: $A/[$N]$T) -> [N]i32 { return array_cast(v, i32) } +@(require_results) to_i64 :: #force_inline proc(v: $A/[$N]$T) -> [N]i64 { return array_cast(v, i64) } +@(require_results) 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) } +@(require_results) to_u8 :: #force_inline proc(v: $A/[$N]$T) -> [N]u8 { return array_cast(v, u8) } +@(require_results) to_u16 :: #force_inline proc(v: $A/[$N]$T) -> [N]u16 { return array_cast(v, u16) } +@(require_results) to_u32 :: #force_inline proc(v: $A/[$N]$T) -> [N]u32 { return array_cast(v, u32) } +@(require_results) to_u64 :: #force_inline proc(v: $A/[$N]$T) -> [N]u64 { return array_cast(v, u64) } +@(require_results) to_uint :: #force_inline proc(v: $A/[$N]$T) -> [N]uint { return array_cast(v, uint) } -to_complex32 :: #force_inline proc(v: $A/[$N]$T) -> [N]complex32 { return array_cast(v, complex32) } -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_quaternion64 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion64 { return array_cast(v, quaternion64) } -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) } +@(require_results) to_complex32 :: #force_inline proc(v: $A/[$N]$T) -> [N]complex32 { return array_cast(v, complex32) } +@(require_results) to_complex64 :: #force_inline proc(v: $A/[$N]$T) -> [N]complex64 { return array_cast(v, complex64) } +@(require_results) to_complex128 :: #force_inline proc(v: $A/[$N]$T) -> [N]complex128 { return array_cast(v, complex128) } +@(require_results) to_quaternion64 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion64 { return array_cast(v, quaternion64) } +@(require_results) to_quaternion128 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion128 { return array_cast(v, quaternion128) } +@(require_results) to_quaternion256 :: #force_inline proc(v: $A/[$N]$T) -> [N]quaternion256 { return array_cast(v, quaternion256) } diff --git a/core/math/linalg/specific.odin b/core/math/linalg/specific.odin index c4ecb194f..e4ebe76da 100644 --- a/core/math/linalg/specific.odin +++ b/core/math/linalg/specific.odin @@ -130,10 +130,12 @@ VECTOR3F64_Y_AXIS :: Vector3f64{0, 1, 0} VECTOR3F64_Z_AXIS :: Vector3f64{0, 0, 1} +@(require_results) vector2_orthogonal :: proc(v: $V/[2]$E) -> V where !IS_ARRAY(E), IS_FLOAT(E) { return {-v.y, v.x} } +@(require_results) vector3_orthogonal :: proc(v: $V/[3]$E) -> V where !IS_ARRAY(E), IS_FLOAT(E) { x := abs(v.x) y := abs(v.y) @@ -160,6 +162,7 @@ orthogonal :: proc{vector2_orthogonal, vector3_orthogonal} +@(require_results) vector4_srgb_to_linear_f16 :: proc(col: Vector4f16) -> Vector4f16 { r := math.pow(col.x, 2.2) g := math.pow(col.y, 2.2) @@ -167,6 +170,7 @@ vector4_srgb_to_linear_f16 :: proc(col: Vector4f16) -> Vector4f16 { a := col.w return {r, g, b, a} } +@(require_results) vector4_srgb_to_linear_f32 :: proc(col: Vector4f32) -> Vector4f32 { r := math.pow(col.x, 2.2) g := math.pow(col.y, 2.2) @@ -174,6 +178,7 @@ vector4_srgb_to_linear_f32 :: proc(col: Vector4f32) -> Vector4f32 { a := col.w return {r, g, b, a} } +@(require_results) vector4_srgb_to_linear_f64 :: proc(col: Vector4f64) -> Vector4f64 { r := math.pow(col.x, 2.2) g := math.pow(col.y, 2.2) @@ -188,6 +193,7 @@ vector4_srgb_to_linear :: proc{ } +@(require_results) vector4_linear_to_srgb_f16 :: proc(col: Vector4f16) -> Vector4f16 { a :: 2.51 b :: 0.03 @@ -209,6 +215,7 @@ vector4_linear_to_srgb_f16 :: proc(col: Vector4f16) -> Vector4f16 { return {x, y, z, col.w} } +@(require_results) vector4_linear_to_srgb_f32 :: proc(col: Vector4f32) -> Vector4f32 { a :: 2.51 b :: 0.03 @@ -230,6 +237,7 @@ vector4_linear_to_srgb_f32 :: proc(col: Vector4f32) -> Vector4f32 { return {x, y, z, col.w} } +@(require_results) vector4_linear_to_srgb_f64 :: proc(col: Vector4f64) -> Vector4f64 { a :: 2.51 b :: 0.03 @@ -258,7 +266,9 @@ vector4_linear_to_srgb :: proc{ } +@(require_results) vector4_hsl_to_rgb_f16 :: proc(h, s, l: f16, a: f16 = 1) -> Vector4f16 { + @(require_results) hue_to_rgb :: proc(p, q, t: f16) -> f16 { t := t if t < 0 { t += 1 } @@ -285,7 +295,9 @@ vector4_hsl_to_rgb_f16 :: proc(h, s, l: f16, a: f16 = 1) -> Vector4f16 { } return {r, g, b, a} } +@(require_results) vector4_hsl_to_rgb_f32 :: proc(h, s, l: f32, a: f32 = 1) -> Vector4f32 { + @(require_results) hue_to_rgb :: proc(p, q, t: f32) -> f32 { t := t if t < 0 { t += 1 } @@ -312,7 +324,9 @@ vector4_hsl_to_rgb_f32 :: proc(h, s, l: f32, a: f32 = 1) -> Vector4f32 { } return {r, g, b, a} } +@(require_results) vector4_hsl_to_rgb_f64 :: proc(h, s, l: f64, a: f64 = 1) -> Vector4f64 { + @(require_results) hue_to_rgb :: proc(p, q, t: f64) -> f64 { t := t if t < 0 { t += 1 } @@ -346,6 +360,7 @@ vector4_hsl_to_rgb :: proc{ } +@(require_results) vector4_rgb_to_hsl_f16 :: proc(col: Vector4f16) -> Vector4f16 { r := col.x g := col.y @@ -375,6 +390,7 @@ vector4_rgb_to_hsl_f16 :: proc(col: Vector4f16) -> Vector4f16 { return {h, s, l, a} } +@(require_results) vector4_rgb_to_hsl_f32 :: proc(col: Vector4f32) -> Vector4f32 { r := col.x g := col.y @@ -404,6 +420,7 @@ vector4_rgb_to_hsl_f32 :: proc(col: Vector4f32) -> Vector4f32 { return {h, s, l, a} } +@(require_results) vector4_rgb_to_hsl_f64 :: proc(col: Vector4f64) -> Vector4f64 { r := col.x g := col.y @@ -441,6 +458,7 @@ vector4_rgb_to_hsl :: proc{ +@(require_results) quaternion_angle_axis_f16 :: proc(angle_radians: f16, axis: Vector3f16) -> (q: Quaternionf16) { t := angle_radians*0.5 v := normalize(axis) * math.sin(t) @@ -450,6 +468,7 @@ quaternion_angle_axis_f16 :: proc(angle_radians: f16, axis: Vector3f16) -> (q: Q q.w = math.cos(t) return } +@(require_results) quaternion_angle_axis_f32 :: proc(angle_radians: f32, axis: Vector3f32) -> (q: Quaternionf32) { t := angle_radians*0.5 v := normalize(axis) * math.sin(t) @@ -459,6 +478,7 @@ quaternion_angle_axis_f32 :: proc(angle_radians: f32, axis: Vector3f32) -> (q: Q q.w = math.cos(t) return } +@(require_results) quaternion_angle_axis_f64 :: proc(angle_radians: f64, axis: Vector3f64) -> (q: Quaternionf64) { t := angle_radians*0.5 v := normalize(axis) * math.sin(t) @@ -474,6 +494,7 @@ quaternion_angle_axis :: proc{ quaternion_angle_axis_f64, } +@(require_results) angle_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { if abs(q.w) > math.SQRT_THREE*0.5 { return math.asin(math.sqrt(q.x*q.x + q.y*q.y + q.z*q.z)) * 2 @@ -481,6 +502,7 @@ angle_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { return math.acos(q.w) * 2 } +@(require_results) angle_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { if abs(q.w) > math.SQRT_THREE*0.5 { return math.asin(math.sqrt(q.x*q.x + q.y*q.y + q.z*q.z)) * 2 @@ -488,6 +510,7 @@ angle_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { return math.acos(q.w) * 2 } +@(require_results) angle_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 { if abs(q.w) > math.SQRT_THREE*0.5 { return math.asin(math.sqrt(q.x*q.x + q.y*q.y + q.z*q.z)) * 2 @@ -501,6 +524,7 @@ angle_from_quaternion :: proc{ angle_from_quaternion_f64, } +@(require_results) axis_from_quaternion_f16 :: proc(q: Quaternionf16) -> Vector3f16 { t1 := 1 - q.w*q.w if t1 < 0 { @@ -509,6 +533,7 @@ axis_from_quaternion_f16 :: proc(q: Quaternionf16) -> Vector3f16 { t2 := 1.0 / math.sqrt(t1) return {q.x*t2, q.y*t2, q.z*t2} } +@(require_results) axis_from_quaternion_f32 :: proc(q: Quaternionf32) -> Vector3f32 { t1 := 1 - q.w*q.w if t1 < 0 { @@ -517,6 +542,7 @@ axis_from_quaternion_f32 :: proc(q: Quaternionf32) -> Vector3f32 { t2 := 1.0 / math.sqrt(t1) return {q.x*t2, q.y*t2, q.z*t2} } +@(require_results) axis_from_quaternion_f64 :: proc(q: Quaternionf64) -> Vector3f64 { t1 := 1 - q.w*q.w if t1 < 0 { @@ -532,16 +558,19 @@ axis_from_quaternion :: proc{ } +@(require_results) angle_axis_from_quaternion_f16 :: proc(q: Quaternionf16) -> (angle: f16, axis: Vector3f16) { angle = angle_from_quaternion(q) axis = axis_from_quaternion(q) return } +@(require_results) angle_axis_from_quaternion_f32 :: proc(q: Quaternionf32) -> (angle: f32, axis: Vector3f32) { angle = angle_from_quaternion(q) axis = axis_from_quaternion(q) return } +@(require_results) angle_axis_from_quaternion_f64 :: proc(q: Quaternionf64) -> (angle: f64, axis: Vector3f64) { angle = angle_from_quaternion(q) axis = axis_from_quaternion(q) @@ -554,6 +583,7 @@ angle_axis_from_quaternion :: proc { } +@(require_results) quaternion_from_forward_and_up_f16 :: proc(forward, up: Vector3f16) -> Quaternionf16 { f := normalize(forward) s := normalize(cross(f, up)) @@ -597,6 +627,7 @@ quaternion_from_forward_and_up_f16 :: proc(forward, up: Vector3f16) -> Quaternio return normalize(q) } +@(require_results) quaternion_from_forward_and_up_f32 :: proc(forward, up: Vector3f32) -> Quaternionf32 { f := normalize(forward) s := normalize(cross(f, up)) @@ -640,6 +671,7 @@ quaternion_from_forward_and_up_f32 :: proc(forward, up: Vector3f32) -> Quaternio return normalize(q) } +@(require_results) quaternion_from_forward_and_up_f64 :: proc(forward, up: Vector3f64) -> Quaternionf64 { f := normalize(forward) s := normalize(cross(f, up)) @@ -689,12 +721,15 @@ quaternion_from_forward_and_up :: proc{ quaternion_from_forward_and_up_f64, } +@(require_results) quaternion_look_at_f16 :: proc(eye, centre: Vector3f16, up: Vector3f16) -> Quaternionf16 { return quaternion_from_matrix3(matrix3_look_at(eye, centre, up)) } +@(require_results) quaternion_look_at_f32 :: proc(eye, centre: Vector3f32, up: Vector3f32) -> Quaternionf32 { return quaternion_from_matrix3(matrix3_look_at(eye, centre, up)) } +@(require_results) quaternion_look_at_f64 :: proc(eye, centre: Vector3f64, up: Vector3f64) -> Quaternionf64 { return quaternion_from_matrix3(matrix3_look_at(eye, centre, up)) } @@ -706,6 +741,7 @@ quaternion_look_at :: proc{ +@(require_results) quaternion_nlerp_f16 :: proc(a, b: Quaternionf16, t: f16) -> (c: Quaternionf16) { c.x = a.x + (b.x-a.x)*t c.y = a.y + (b.y-a.y)*t @@ -713,6 +749,7 @@ quaternion_nlerp_f16 :: proc(a, b: Quaternionf16, t: f16) -> (c: Quaternionf16) c.w = a.w + (b.w-a.w)*t return normalize(c) } +@(require_results) quaternion_nlerp_f32 :: proc(a, b: Quaternionf32, t: f32) -> (c: Quaternionf32) { c.x = a.x + (b.x-a.x)*t c.y = a.y + (b.y-a.y)*t @@ -720,6 +757,7 @@ quaternion_nlerp_f32 :: proc(a, b: Quaternionf32, t: f32) -> (c: Quaternionf32) c.w = a.w + (b.w-a.w)*t return normalize(c) } +@(require_results) quaternion_nlerp_f64 :: proc(a, b: Quaternionf64, t: f64) -> (c: Quaternionf64) { c.x = a.x + (b.x-a.x)*t c.y = a.y + (b.y-a.y)*t @@ -734,6 +772,7 @@ quaternion_nlerp :: proc{ } +@(require_results) quaternion_slerp_f16 :: proc(x, y: Quaternionf16, t: f16) -> (q: Quaternionf16) { a, b := x, y cos_angle := dot(a, b) @@ -761,6 +800,7 @@ quaternion_slerp_f16 :: proc(x, y: Quaternionf16, t: f16) -> (q: Quaternionf16) q.w = factor_a * a.w + factor_b * b.w return } +@(require_results) quaternion_slerp_f32 :: proc(x, y: Quaternionf32, t: f32) -> (q: Quaternionf32) { a, b := x, y cos_angle := dot(a, b) @@ -788,6 +828,7 @@ quaternion_slerp_f32 :: proc(x, y: Quaternionf32, t: f32) -> (q: Quaternionf32) q.w = factor_a * a.w + factor_b * b.w return } +@(require_results) quaternion_slerp_f64 :: proc(x, y: Quaternionf64, t: f64) -> (q: Quaternionf64) { a, b := x, y cos_angle := dot(a, b) @@ -822,14 +863,17 @@ quaternion_slerp :: proc{ } +@(require_results) quaternion_squad_f16 :: proc(q1, q2, s1, s2: Quaternionf16, h: f16) -> Quaternionf16 { slerp :: quaternion_slerp return slerp(slerp(q1, q2, h), slerp(s1, s2, h), 2 * (1 - h) * h) } +@(require_results) quaternion_squad_f32 :: proc(q1, q2, s1, s2: Quaternionf32, h: f32) -> Quaternionf32 { slerp :: quaternion_slerp return slerp(slerp(q1, q2, h), slerp(s1, s2, h), 2 * (1 - h) * h) } +@(require_results) quaternion_squad_f64 :: proc(q1, q2, s1, s2: Quaternionf64, h: f64) -> Quaternionf64 { slerp :: quaternion_slerp return slerp(slerp(q1, q2, h), slerp(s1, s2, h), 2 * (1 - h) * h) @@ -841,6 +885,7 @@ quaternion_squad :: proc{ } +@(require_results) quaternion_from_matrix4_f16 :: proc(m: Matrix4f16) -> (q: Quaternionf16) { m3: Matrix3f16 = --- m3[0, 0], m3[1, 0], m3[2, 0] = m[0, 0], m[1, 0], m[2, 0] @@ -848,6 +893,7 @@ quaternion_from_matrix4_f16 :: proc(m: Matrix4f16) -> (q: Quaternionf16) { m3[0, 2], m3[1, 2], m3[2, 2] = m[0, 2], m[1, 2], m[2, 2] return quaternion_from_matrix3(m3) } +@(require_results) quaternion_from_matrix4_f32 :: proc(m: Matrix4f32) -> (q: Quaternionf32) { m3: Matrix3f32 = --- m3[0, 0], m3[1, 0], m3[2, 0] = m[0, 0], m[1, 0], m[2, 0] @@ -855,6 +901,7 @@ quaternion_from_matrix4_f32 :: proc(m: Matrix4f32) -> (q: Quaternionf32) { m3[0, 2], m3[1, 2], m3[2, 2] = m[0, 2], m[1, 2], m[2, 2] return quaternion_from_matrix3(m3) } +@(require_results) quaternion_from_matrix4_f64 :: proc(m: Matrix4f64) -> (q: Quaternionf64) { m3: Matrix3f64 = --- m3[0, 0], m3[1, 0], m3[2, 0] = m[0, 0], m[1, 0], m[2, 0] @@ -869,6 +916,7 @@ quaternion_from_matrix4 :: proc{ } +@(require_results) quaternion_from_matrix3_f16 :: proc(m: Matrix3f16) -> (q: Quaternionf16) { four_x_squared_minus_1 := m[0, 0] - m[1, 1] - m[2, 2] four_y_squared_minus_1 := m[1, 1] - m[0, 0] - m[2, 2] @@ -918,6 +966,7 @@ quaternion_from_matrix3_f16 :: proc(m: Matrix3f16) -> (q: Quaternionf16) { } return } +@(require_results) quaternion_from_matrix3_f32 :: proc(m: Matrix3f32) -> (q: Quaternionf32) { four_x_squared_minus_1 := m[0, 0] - m[1, 1] - m[2, 2] four_y_squared_minus_1 := m[1, 1] - m[0, 0] - m[2, 2] @@ -967,6 +1016,7 @@ quaternion_from_matrix3_f32 :: proc(m: Matrix3f32) -> (q: Quaternionf32) { } return } +@(require_results) quaternion_from_matrix3_f64 :: proc(m: Matrix3f64) -> (q: Quaternionf64) { four_x_squared_minus_1 := m[0, 0] - m[1, 1] - m[2, 2] four_y_squared_minus_1 := m[1, 1] - m[0, 0] - m[2, 2] @@ -1023,6 +1073,7 @@ quaternion_from_matrix3 :: proc{ } +@(require_results) quaternion_between_two_vector3_f16 :: proc(from, to: Vector3f16) -> (q: Quaternionf16) { x := normalize(from) y := normalize(to) @@ -1044,6 +1095,7 @@ quaternion_between_two_vector3_f16 :: proc(from, to: Vector3f16) -> (q: Quaterni q.z = v.z return normalize(q) } +@(require_results) quaternion_between_two_vector3_f32 :: proc(from, to: Vector3f32) -> (q: Quaternionf32) { x := normalize(from) y := normalize(to) @@ -1065,6 +1117,7 @@ quaternion_between_two_vector3_f32 :: proc(from, to: Vector3f32) -> (q: Quaterni q.z = v.z return normalize(q) } +@(require_results) quaternion_between_two_vector3_f64 :: proc(from, to: Vector3f64) -> (q: Quaternionf64) { x := normalize(from) y := normalize(to) @@ -1093,6 +1146,7 @@ quaternion_between_two_vector3 :: proc{ } +@(require_results) matrix2_inverse_transpose_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d @@ -1102,6 +1156,7 @@ matrix2_inverse_transpose_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { c[1, 1] = +m[0, 0] * id return c } +@(require_results) matrix2_inverse_transpose_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d @@ -1111,6 +1166,7 @@ matrix2_inverse_transpose_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { c[1, 1] = +m[0, 0] * id return c } +@(require_results) matrix2_inverse_transpose_f64 :: proc(m: Matrix2f64) -> (c: Matrix2f64) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d @@ -1127,12 +1183,15 @@ matrix2_inverse_transpose :: proc{ } +@(require_results) matrix2_determinant_f16 :: proc(m: Matrix2f16) -> f16 { return m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] } +@(require_results) matrix2_determinant_f32 :: proc(m: Matrix2f32) -> f32 { return m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] } +@(require_results) matrix2_determinant_f64 :: proc(m: Matrix2f64) -> f64 { return m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] } @@ -1143,6 +1202,7 @@ matrix2_determinant :: proc{ } +@(require_results) matrix2_inverse_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d @@ -1152,6 +1212,7 @@ matrix2_inverse_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { c[1, 1] = +m[0, 0] * id return c } +@(require_results) matrix2_inverse_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d @@ -1161,6 +1222,7 @@ matrix2_inverse_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { c[1, 1] = +m[0, 0] * id return c } +@(require_results) matrix2_inverse_f64 :: proc(m: Matrix2f64) -> (c: Matrix2f64) { d := m[0, 0]*m[1, 1] - m[0, 1]*m[1, 0] id := 1.0/d @@ -1177,6 +1239,7 @@ matrix2_inverse :: proc{ } +@(require_results) matrix2_adjoint_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { c[0, 0] = +m[1, 1] c[1, 0] = -m[0, 1] @@ -1184,6 +1247,7 @@ matrix2_adjoint_f16 :: proc(m: Matrix2f16) -> (c: Matrix2f16) { c[1, 1] = +m[0, 0] return c } +@(require_results) matrix2_adjoint_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { c[0, 0] = +m[1, 1] c[1, 0] = -m[0, 1] @@ -1191,6 +1255,7 @@ matrix2_adjoint_f32 :: proc(m: Matrix2f32) -> (c: Matrix2f32) { c[1, 1] = +m[0, 0] return c } +@(require_results) matrix2_adjoint_f64 :: proc(m: Matrix2f64) -> (c: Matrix2f64) { c[0, 0] = +m[1, 1] c[1, 0] = -m[0, 1] @@ -1205,6 +1270,7 @@ matrix2_adjoint :: proc{ } +@(require_results) matrix3_from_quaternion_f16 :: proc(q: Quaternionf16) -> (m: Matrix3f16) { qxx := q.x * q.x qyy := q.y * q.y @@ -1229,6 +1295,7 @@ matrix3_from_quaternion_f16 :: proc(q: Quaternionf16) -> (m: Matrix3f16) { m[2, 2] = 1 - 2 * (qxx + qyy) return m } +@(require_results) matrix3_from_quaternion_f32 :: proc(q: Quaternionf32) -> (m: Matrix3f32) { qxx := q.x * q.x qyy := q.y * q.y @@ -1253,6 +1320,7 @@ matrix3_from_quaternion_f32 :: proc(q: Quaternionf32) -> (m: Matrix3f32) { m[2, 2] = 1 - 2 * (qxx + qyy) return m } +@(require_results) matrix3_from_quaternion_f64 :: proc(q: Quaternionf64) -> (m: Matrix3f64) { qxx := q.x * q.x qyy := q.y * q.y @@ -1284,12 +1352,15 @@ matrix3_from_quaternion :: proc{ } +@(require_results) matrix3_inverse_f16 :: proc(m: Matrix3f16) -> Matrix3f16 { return transpose(matrix3_inverse_transpose(m)) } +@(require_results) matrix3_inverse_f32 :: proc(m: Matrix3f32) -> Matrix3f32 { return transpose(matrix3_inverse_transpose(m)) } +@(require_results) matrix3_inverse_f64 :: proc(m: Matrix3f64) -> Matrix3f64 { return transpose(matrix3_inverse_transpose(m)) } @@ -1300,18 +1371,21 @@ matrix3_inverse :: proc{ } +@(require_results) matrix3_determinant_f16 :: proc(m: Matrix3f16) -> f16 { a := +m[0, 0] * (m[1, 1] * m[2, 2] - m[1, 2] * m[2, 1]) b := -m[0, 1] * (m[1, 0] * m[2, 2] - m[1, 2] * m[2, 0]) c := +m[0, 2] * (m[1, 0] * m[2, 1] - m[1, 1] * m[2, 0]) return a + b + c } +@(require_results) matrix3_determinant_f32 :: proc(m: Matrix3f32) -> f32 { a := +m[0, 0] * (m[1, 1] * m[2, 2] - m[1, 2] * m[2, 1]) b := -m[0, 1] * (m[1, 0] * m[2, 2] - m[1, 2] * m[2, 0]) c := +m[0, 2] * (m[1, 0] * m[2, 1] - m[1, 1] * m[2, 0]) return a + b + c } +@(require_results) matrix3_determinant_f64 :: proc(m: Matrix3f64) -> f64 { a := +m[0, 0] * (m[1, 1] * m[2, 2] - m[1, 2] * m[2, 1]) b := -m[0, 1] * (m[1, 0] * m[2, 2] - m[1, 2] * m[2, 0]) @@ -1325,6 +1399,7 @@ matrix3_determinant :: proc{ } +@(require_results) matrix3_adjoint_f16 :: proc(m: Matrix3f16) -> (adjoint: Matrix3f16) { adjoint[0, 0] = +(m[1, 1] * m[2, 2] - m[2, 1] * m[1, 2]) adjoint[0, 1] = -(m[1, 0] * m[2, 2] - m[2, 0] * m[1, 2]) @@ -1337,6 +1412,7 @@ matrix3_adjoint_f16 :: proc(m: Matrix3f16) -> (adjoint: Matrix3f16) { adjoint[2, 2] = +(m[0, 0] * m[1, 1] - m[1, 0] * m[0, 1]) return adjoint } +@(require_results) matrix3_adjoint_f32 :: proc(m: Matrix3f32) -> (adjoint: Matrix3f32) { adjoint[0, 0] = +(m[1, 1] * m[2, 2] - m[2, 1] * m[1, 2]) adjoint[0, 1] = -(m[1, 0] * m[2, 2] - m[2, 0] * m[1, 2]) @@ -1349,6 +1425,7 @@ matrix3_adjoint_f32 :: proc(m: Matrix3f32) -> (adjoint: Matrix3f32) { adjoint[2, 2] = +(m[0, 0] * m[1, 1] - m[1, 0] * m[0, 1]) return adjoint } +@(require_results) matrix3_adjoint_f64 :: proc(m: Matrix3f64) -> (adjoint: Matrix3f64) { adjoint[0, 0] = +(m[1, 1] * m[2, 2] - m[2, 1] * m[1, 2]) adjoint[0, 1] = -(m[1, 0] * m[2, 2] - m[2, 0] * m[1, 2]) @@ -1369,12 +1446,15 @@ matrix3_adjoint :: proc{ +@(require_results) matrix3_inverse_transpose_f16 :: proc(m: Matrix3f16) -> (inverse_transpose: Matrix3f16) { return builtin.inverse_transpose(m) } +@(require_results) matrix3_inverse_transpose_f32 :: proc(m: Matrix3f32) -> (inverse_transpose: Matrix3f32) { return builtin.inverse_transpose(m) } +@(require_results) matrix3_inverse_transpose_f64 :: proc(m: Matrix3f64) -> (inverse_transpose: Matrix3f64) { return builtin.inverse_transpose(m) } @@ -1385,18 +1465,21 @@ matrix3_inverse_transpose :: proc{ } +@(require_results) matrix3_scale_f16 :: proc(s: Vector3f16) -> (m: Matrix3f16) { m[0, 0] = s[0] m[1, 1] = s[1] m[2, 2] = s[2] return m } +@(require_results) matrix3_scale_f32 :: proc(s: Vector3f32) -> (m: Matrix3f32) { m[0, 0] = s[0] m[1, 1] = s[1] m[2, 2] = s[2] return m } +@(require_results) matrix3_scale_f64 :: proc(s: Vector3f64) -> (m: Matrix3f64) { m[0, 0] = s[0] m[1, 1] = s[1] @@ -1410,6 +1493,7 @@ matrix3_scale :: proc{ } +@(require_results) matrix3_rotate_f16 :: proc(angle_radians: f16, v: Vector3f16) -> (rot: Matrix3f16) { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1431,6 +1515,7 @@ matrix3_rotate_f16 :: proc(angle_radians: f16, v: Vector3f16) -> (rot: Matrix3f1 return rot } +@(require_results) matrix3_rotate_f32 :: proc(angle_radians: f32, v: Vector3f32) -> (rot: Matrix3f32) { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1452,6 +1537,7 @@ matrix3_rotate_f32 :: proc(angle_radians: f32, v: Vector3f32) -> (rot: Matrix3f3 return rot } +@(require_results) matrix3_rotate_f64 :: proc(angle_radians: f64, v: Vector3f64) -> (rot: Matrix3f64) { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1480,6 +1566,7 @@ matrix3_rotate :: proc{ } +@(require_results) matrix3_look_at_f16 :: proc(eye, centre, up: Vector3f16) -> Matrix3f16 { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -1490,6 +1577,7 @@ matrix3_look_at_f16 :: proc(eye, centre, up: Vector3f16) -> Matrix3f16 { -f.x, -f.y, -f.z, } } +@(require_results) matrix3_look_at_f32 :: proc(eye, centre, up: Vector3f32) -> Matrix3f32 { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -1500,6 +1588,7 @@ matrix3_look_at_f32 :: proc(eye, centre, up: Vector3f32) -> Matrix3f32 { -f.x, -f.y, -f.z, } } +@(require_results) matrix3_look_at_f64 :: proc(eye, centre, up: Vector3f64) -> Matrix3f64 { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -1517,6 +1606,7 @@ matrix3_look_at :: proc{ } +@(require_results) matrix4_from_quaternion_f16 :: proc(q: Quaternionf16) -> (m: Matrix4f16) { qxx := q.x * q.x qyy := q.y * q.y @@ -1544,6 +1634,7 @@ matrix4_from_quaternion_f16 :: proc(q: Quaternionf16) -> (m: Matrix4f16) { return m } +@(require_results) matrix4_from_quaternion_f32 :: proc(q: Quaternionf32) -> (m: Matrix4f32) { qxx := q.x * q.x qyy := q.y * q.y @@ -1571,6 +1662,7 @@ matrix4_from_quaternion_f32 :: proc(q: Quaternionf32) -> (m: Matrix4f32) { return m } +@(require_results) matrix4_from_quaternion_f64 :: proc(q: Quaternionf64) -> (m: Matrix4f64) { qxx := q.x * q.x qyy := q.y * q.y @@ -1605,18 +1697,21 @@ matrix4_from_quaternion :: proc{ } +@(require_results) matrix4_from_trs_f16 :: proc(t: Vector3f16, r: Quaternionf16, s: Vector3f16) -> Matrix4f16 { translation := matrix4_translate(t) rotation := matrix4_from_quaternion(r) scale := matrix4_scale(s) return mul(translation, mul(rotation, scale)) } +@(require_results) matrix4_from_trs_f32 :: proc(t: Vector3f32, r: Quaternionf32, s: Vector3f32) -> Matrix4f32 { translation := matrix4_translate(t) rotation := matrix4_from_quaternion(r) scale := matrix4_scale(s) return mul(translation, mul(rotation, scale)) } +@(require_results) matrix4_from_trs_f64 :: proc(t: Vector3f64, r: Quaternionf64, s: Vector3f64) -> Matrix4f64 { translation := matrix4_translate(t) rotation := matrix4_from_quaternion(r) @@ -1631,12 +1726,15 @@ matrix4_from_trs :: proc{ +@(require_results) matrix4_inverse_f16 :: proc(m: Matrix4f16) -> Matrix4f16 { return transpose(matrix4_inverse_transpose(m)) } +@(require_results) matrix4_inverse_f32 :: proc(m: Matrix4f32) -> Matrix4f32 { return transpose(matrix4_inverse_transpose(m)) } +@(require_results) matrix4_inverse_f64 :: proc(m: Matrix4f64) -> Matrix4f64 { return transpose(matrix4_inverse_transpose(m)) } @@ -1647,6 +1745,7 @@ matrix4_inverse :: proc{ } +@(require_results) matrix4_minor_f16 :: proc(m: Matrix4f16, c, r: int) -> f16 { cut_down: Matrix3f16 for i in 0..<3 { @@ -1658,6 +1757,7 @@ matrix4_minor_f16 :: proc(m: Matrix4f16, c, r: int) -> f16 { } return matrix3_determinant(cut_down) } +@(require_results) matrix4_minor_f32 :: proc(m: Matrix4f32, c, r: int) -> f32 { cut_down: Matrix3f32 for i in 0..<3 { @@ -1669,6 +1769,7 @@ matrix4_minor_f32 :: proc(m: Matrix4f32, c, r: int) -> f32 { } return matrix3_determinant(cut_down) } +@(require_results) matrix4_minor_f64 :: proc(m: Matrix4f64, c, r: int) -> f64 { cut_down: Matrix3f64 for i in 0..<3 { @@ -1687,18 +1788,21 @@ matrix4_minor :: proc{ } +@(require_results) matrix4_cofactor_f16 :: proc(m: Matrix4f16, c, r: int) -> f16 { sign, minor: f16 sign = 1 if (c + r) % 2 == 0 else -1 minor = matrix4_minor(m, c, r) return sign * minor } +@(require_results) matrix4_cofactor_f32 :: proc(m: Matrix4f32, c, r: int) -> f32 { sign, minor: f32 sign = 1 if (c + r) % 2 == 0 else -1 minor = matrix4_minor(m, c, r) return sign * minor } +@(require_results) matrix4_cofactor_f64 :: proc(m: Matrix4f64, c, r: int) -> f64 { sign, minor: f64 sign = 1 if (c + r) % 2 == 0 else -1 @@ -1712,6 +1816,7 @@ matrix4_cofactor :: proc{ } +@(require_results) matrix4_adjoint_f16 :: proc(m: Matrix4f16) -> (adjoint: Matrix4f16) { for i in 0..<4 { for j in 0..<4 { @@ -1720,6 +1825,7 @@ matrix4_adjoint_f16 :: proc(m: Matrix4f16) -> (adjoint: Matrix4f16) { } return } +@(require_results) matrix4_adjoint_f32 :: proc(m: Matrix4f32) -> (adjoint: Matrix4f32) { for i in 0..<4 { for j in 0..<4 { @@ -1728,6 +1834,7 @@ matrix4_adjoint_f32 :: proc(m: Matrix4f32) -> (adjoint: Matrix4f32) { } return } +@(require_results) matrix4_adjoint_f64 :: proc(m: Matrix4f64) -> (adjoint: Matrix4f64) { for i in 0..<4 { for j in 0..<4 { @@ -1743,6 +1850,7 @@ matrix4_adjoint :: proc{ } +@(require_results) matrix4_determinant_f16 :: proc(m: Matrix4f16) -> (determinant: f16) { adjoint := matrix4_adjoint(m) for i in 0..<4 { @@ -1750,6 +1858,7 @@ matrix4_determinant_f16 :: proc(m: Matrix4f16) -> (determinant: f16) { } return } +@(require_results) matrix4_determinant_f32 :: proc(m: Matrix4f32) -> (determinant: f32) { adjoint := matrix4_adjoint(m) for i in 0..<4 { @@ -1757,6 +1866,7 @@ matrix4_determinant_f32 :: proc(m: Matrix4f32) -> (determinant: f32) { } return } +@(require_results) matrix4_determinant_f64 :: proc(m: Matrix4f64) -> (determinant: f64) { adjoint := matrix4_adjoint(m) for i in 0..<4 { @@ -1771,6 +1881,7 @@ matrix4_determinant :: proc{ } +@(require_results) matrix4_inverse_transpose_f16 :: proc(m: Matrix4f16) -> (inverse_transpose: Matrix4f16) { adjoint := matrix4_adjoint(m) determinant: f16 = 0 @@ -1785,6 +1896,7 @@ matrix4_inverse_transpose_f16 :: proc(m: Matrix4f16) -> (inverse_transpose: Matr } return } +@(require_results) matrix4_inverse_transpose_f32 :: proc(m: Matrix4f32) -> (inverse_transpose: Matrix4f32) { adjoint := matrix4_adjoint(m) determinant: f32 = 0 @@ -1799,6 +1911,7 @@ matrix4_inverse_transpose_f32 :: proc(m: Matrix4f32) -> (inverse_transpose: Matr } return } +@(require_results) matrix4_inverse_transpose_f64 :: proc(m: Matrix4f64) -> (inverse_transpose: Matrix4f64) { adjoint := matrix4_adjoint(m) determinant: f64 = 0 @@ -1820,6 +1933,7 @@ matrix4_inverse_transpose :: proc{ } +@(require_results) matrix4_translate_f16 :: proc(v: Vector3f16) -> Matrix4f16 { m := MATRIX4F16_IDENTITY m[3][0] = v[0] @@ -1827,6 +1941,7 @@ matrix4_translate_f16 :: proc(v: Vector3f16) -> Matrix4f16 { m[3][2] = v[2] return m } +@(require_results) matrix4_translate_f32 :: proc(v: Vector3f32) -> Matrix4f32 { m := MATRIX4F32_IDENTITY m[3][0] = v[0] @@ -1834,6 +1949,7 @@ matrix4_translate_f32 :: proc(v: Vector3f32) -> Matrix4f32 { m[3][2] = v[2] return m } +@(require_results) matrix4_translate_f64 :: proc(v: Vector3f64) -> Matrix4f64 { m := MATRIX4F64_IDENTITY m[3][0] = v[0] @@ -1848,6 +1964,7 @@ matrix4_translate :: proc{ } +@(require_results) matrix4_rotate_f16 :: proc(angle_radians: f16, v: Vector3f16) -> Matrix4f16 { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1874,6 +1991,7 @@ matrix4_rotate_f16 :: proc(angle_radians: f16, v: Vector3f16) -> Matrix4f16 { return rot } +@(require_results) matrix4_rotate_f32 :: proc(angle_radians: f32, v: Vector3f32) -> Matrix4f32 { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1900,6 +2018,7 @@ matrix4_rotate_f32 :: proc(angle_radians: f32, v: Vector3f32) -> Matrix4f32 { return rot } +@(require_results) matrix4_rotate_f64 :: proc(angle_radians: f64, v: Vector3f64) -> Matrix4f64 { c := math.cos(angle_radians) s := math.sin(angle_radians) @@ -1933,6 +2052,7 @@ matrix4_rotate :: proc{ } +@(require_results) matrix4_scale_f16 :: proc(v: Vector3f16) -> (m: Matrix4f16) { m[0][0] = v[0] m[1][1] = v[1] @@ -1940,6 +2060,7 @@ matrix4_scale_f16 :: proc(v: Vector3f16) -> (m: Matrix4f16) { m[3][3] = 1 return } +@(require_results) matrix4_scale_f32 :: proc(v: Vector3f32) -> (m: Matrix4f32) { m[0][0] = v[0] m[1][1] = v[1] @@ -1947,6 +2068,7 @@ matrix4_scale_f32 :: proc(v: Vector3f32) -> (m: Matrix4f32) { m[3][3] = 1 return } +@(require_results) matrix4_scale_f64 :: proc(v: Vector3f64) -> (m: Matrix4f64) { m[0][0] = v[0] m[1][1] = v[1] @@ -1961,6 +2083,7 @@ matrix4_scale :: proc{ } +@(require_results) matrix4_look_at_f16 :: proc(eye, centre, up: Vector3f16, flip_z_axis := true) -> (m: Matrix4f16) { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -1975,6 +2098,7 @@ matrix4_look_at_f16 :: proc(eye, centre, up: Vector3f16, flip_z_axis := true) -> 0, 0, 0, 1, } } +@(require_results) matrix4_look_at_f32 :: proc(eye, centre, up: Vector3f32, flip_z_axis := true) -> (m: Matrix4f32) { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -1989,6 +2113,7 @@ matrix4_look_at_f32 :: proc(eye, centre, up: Vector3f32, flip_z_axis := true) -> 0, 0, 0, 1, } } +@(require_results) matrix4_look_at_f64 :: proc(eye, centre, up: Vector3f64, flip_z_axis := true) -> (m: Matrix4f64) { f := normalize(centre - eye) s := normalize(cross(f, up)) @@ -2010,6 +2135,7 @@ matrix4_look_at :: proc{ } +@(require_results) matrix4_look_at_from_fru_f16 :: proc(eye, f, r, u: Vector3f16, flip_z_axis := true) -> (m: Matrix4f16) { f, s, u := f, r, u f = normalize(f) @@ -2024,6 +2150,7 @@ matrix4_look_at_from_fru_f16 :: proc(eye, f, r, u: Vector3f16, flip_z_axis := tr 0, 0, 0, 1, } } +@(require_results) matrix4_look_at_from_fru_f32 :: proc(eye, f, r, u: Vector3f32, flip_z_axis := true) -> (m: Matrix4f32) { f, s, u := f, r, u f = normalize(f) @@ -2038,6 +2165,7 @@ matrix4_look_at_from_fru_f32 :: proc(eye, f, r, u: Vector3f32, flip_z_axis := tr 0, 0, 0, 1, } } +@(require_results) matrix4_look_at_from_fru_f64 :: proc(eye, f, r, u: Vector3f64, flip_z_axis := true) -> (m: Matrix4f64) { f, s, u := f, r, u f = normalize(f) @@ -2059,6 +2187,7 @@ matrix4_look_at_from_fru :: proc{ } +@(require_results) matrix4_perspective_f16 :: proc(fovy, aspect, near, far: f16, flip_z_axis := true) -> (m: Matrix4f16) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -2073,6 +2202,7 @@ matrix4_perspective_f16 :: proc(fovy, aspect, near, far: f16, flip_z_axis := tru return } +@(require_results) matrix4_perspective_f32 :: proc(fovy, aspect, near, far: f32, flip_z_axis := true) -> (m: Matrix4f32) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -2087,6 +2217,7 @@ matrix4_perspective_f32 :: proc(fovy, aspect, near, far: f32, flip_z_axis := tru return } +@(require_results) matrix4_perspective_f64 :: proc(fovy, aspect, near, far: f64, flip_z_axis := true) -> (m: Matrix4f64) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -2109,6 +2240,7 @@ matrix4_perspective :: proc{ +@(require_results) matrix_ortho3d_f16 :: proc(left, right, bottom, top, near, far: f16, flip_z_axis := true) -> (m: Matrix4f16) { m[0, 0] = +2 / (right - left) m[1, 1] = +2 / (top - bottom) @@ -2124,6 +2256,7 @@ matrix_ortho3d_f16 :: proc(left, right, bottom, top, near, far: f16, flip_z_axis return } +@(require_results) matrix_ortho3d_f32 :: proc(left, right, bottom, top, near, far: f32, flip_z_axis := true) -> (m: Matrix4f32) { m[0, 0] = +2 / (right - left) m[1, 1] = +2 / (top - bottom) @@ -2139,6 +2272,7 @@ matrix_ortho3d_f32 :: proc(left, right, bottom, top, near, far: f32, flip_z_axis return } +@(require_results) matrix_ortho3d_f64 :: proc(left, right, bottom, top, near, far: f64, flip_z_axis := true) -> (m: Matrix4f64) { m[0, 0] = +2 / (right - left) m[1, 1] = +2 / (top - bottom) @@ -2162,6 +2296,7 @@ matrix_ortho3d :: proc{ +@(require_results) matrix4_infinite_perspective_f16 :: proc(fovy, aspect, near: f16, flip_z_axis := true) -> (m: Matrix4f16) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -2176,6 +2311,7 @@ matrix4_infinite_perspective_f16 :: proc(fovy, aspect, near: f16, flip_z_axis := return } +@(require_results) matrix4_infinite_perspective_f32 :: proc(fovy, aspect, near: f32, flip_z_axis := true) -> (m: Matrix4f32) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -2190,6 +2326,7 @@ matrix4_infinite_perspective_f32 :: proc(fovy, aspect, near: f32, flip_z_axis := return } +@(require_results) matrix4_infinite_perspective_f64 :: proc(fovy, aspect, near: f64, flip_z_axis := true) -> (m: Matrix4f64) { tan_half_fovy := math.tan(0.5 * fovy) m[0, 0] = 1 / (aspect*tan_half_fovy) @@ -2212,16 +2349,19 @@ matrix4_infinite_perspective :: proc{ +@(require_results) matrix2_from_scalar_f16 :: proc(f: f16) -> (m: Matrix2f16) { m[0, 0], m[1, 0] = f, 0 m[0, 1], m[1, 1] = 0, f return } +@(require_results) matrix2_from_scalar_f32 :: proc(f: f32) -> (m: Matrix2f32) { m[0, 0], m[1, 0] = f, 0 m[0, 1], m[1, 1] = 0, f return } +@(require_results) matrix2_from_scalar_f64 :: proc(f: f64) -> (m: Matrix2f64) { m[0, 0], m[1, 0] = f, 0 m[0, 1], m[1, 1] = 0, f @@ -2234,18 +2374,21 @@ matrix2_from_scalar :: proc{ } +@(require_results) matrix3_from_scalar_f16 :: proc(f: f16) -> (m: Matrix3f16) { m[0, 0], m[1, 0], m[2, 0] = f, 0, 0 m[0, 1], m[1, 1], m[2, 1] = 0, f, 0 m[0, 2], m[1, 2], m[2, 2] = 0, 0, f return } +@(require_results) matrix3_from_scalar_f32 :: proc(f: f32) -> (m: Matrix3f32) { m[0, 0], m[1, 0], m[2, 0] = f, 0, 0 m[0, 1], m[1, 1], m[2, 1] = 0, f, 0 m[0, 2], m[1, 2], m[2, 2] = 0, 0, f return } +@(require_results) matrix3_from_scalar_f64 :: proc(f: f64) -> (m: Matrix3f64) { m[0, 0], m[1, 0], m[2, 0] = f, 0, 0 m[0, 1], m[1, 1], m[2, 1] = 0, f, 0 @@ -2259,6 +2402,7 @@ matrix3_from_scalar :: proc{ } +@(require_results) matrix4_from_scalar_f16 :: proc(f: f16) -> (m: Matrix4f16) { m[0, 0], m[1, 0], m[2, 0], m[3, 0] = f, 0, 0, 0 m[0, 1], m[1, 1], m[2, 1], m[3, 1] = 0, f, 0, 0 @@ -2266,6 +2410,7 @@ matrix4_from_scalar_f16 :: proc(f: f16) -> (m: Matrix4f16) { m[0, 3], m[1, 3], m[2, 3], m[3, 3] = 0, 0, 0, f return } +@(require_results) matrix4_from_scalar_f32 :: proc(f: f32) -> (m: Matrix4f32) { m[0, 0], m[1, 0], m[2, 0], m[3, 0] = f, 0, 0, 0 m[0, 1], m[1, 1], m[2, 1], m[3, 1] = 0, f, 0, 0 @@ -2273,6 +2418,7 @@ matrix4_from_scalar_f32 :: proc(f: f32) -> (m: Matrix4f32) { m[0, 3], m[1, 3], m[2, 3], m[3, 3] = 0, 0, 0, f return } +@(require_results) matrix4_from_scalar_f64 :: proc(f: f64) -> (m: Matrix4f64) { m[0, 0], m[1, 0], m[2, 0], m[3, 0] = f, 0, 0, 0 m[0, 1], m[1, 1], m[2, 1], m[3, 1] = 0, f, 0, 0 @@ -2287,16 +2433,19 @@ matrix4_from_scalar :: proc{ } +@(require_results) matrix2_from_matrix3_f16 :: proc(m: Matrix3f16) -> (r: Matrix2f16) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] return } +@(require_results) matrix2_from_matrix3_f32 :: proc(m: Matrix3f32) -> (r: Matrix2f32) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] return } +@(require_results) matrix2_from_matrix3_f64 :: proc(m: Matrix3f64) -> (r: Matrix2f64) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] @@ -2309,16 +2458,19 @@ matrix2_from_matrix3 :: proc{ } +@(require_results) matrix2_from_matrix4_f16 :: proc(m: Matrix4f16) -> (r: Matrix2f16) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] return } +@(require_results) matrix2_from_matrix4_f32 :: proc(m: Matrix4f32) -> (r: Matrix2f32) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] return } +@(require_results) matrix2_from_matrix4_f64 :: proc(m: Matrix4f64) -> (r: Matrix2f64) { r[0, 0], r[1, 0] = m[0, 0], m[1, 0] r[0, 1], r[1, 1] = m[0, 1], m[1, 1] @@ -2331,18 +2483,21 @@ matrix2_from_matrix4 :: proc{ } +@(require_results) matrix3_from_matrix2_f16 :: proc(m: Matrix2f16) -> (r: Matrix3f16) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], 0 r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], 0 r[0, 2], r[1, 2], r[2, 2] = 0, 0, 1 return } +@(require_results) matrix3_from_matrix2_f32 :: proc(m: Matrix2f32) -> (r: Matrix3f32) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], 0 r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], 0 r[0, 2], r[1, 2], r[2, 2] = 0, 0, 1 return } +@(require_results) matrix3_from_matrix2_f64 :: proc(m: Matrix2f64) -> (r: Matrix3f64) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], 0 r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], 0 @@ -2356,18 +2511,21 @@ matrix3_from_matrix2 :: proc{ } +@(require_results) matrix3_from_matrix4_f16 :: proc(m: Matrix4f16) -> (r: Matrix3f16) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], m[2, 0] r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], m[2, 1] r[0, 2], r[1, 2], r[2, 2] = m[0, 2], m[1, 2], m[2, 2] return } +@(require_results) matrix3_from_matrix4_f32 :: proc(m: Matrix4f32) -> (r: Matrix3f32) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], m[2, 0] r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], m[2, 1] r[0, 2], r[1, 2], r[2, 2] = m[0, 2], m[1, 2], m[2, 2] return } +@(require_results) matrix3_from_matrix4_f64 :: proc(m: Matrix4f64) -> (r: Matrix3f64) { r[0, 0], r[1, 0], r[2, 0] = m[0, 0], m[1, 0], m[2, 0] r[0, 1], r[1, 1], r[2, 1] = m[0, 1], m[1, 1], m[2, 1] @@ -2381,6 +2539,7 @@ matrix3_from_matrix4 :: proc{ } +@(require_results) matrix4_from_matrix2_f16 :: proc(m: Matrix2f16) -> (r: Matrix4f16) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], 0, 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], 0, 0 @@ -2388,6 +2547,7 @@ matrix4_from_matrix2_f16 :: proc(m: Matrix2f16) -> (r: Matrix4f16) { r[0, 3], r[1, 3], r[2, 3], r[3, 3] = 0, 0, 0, 1 return } +@(require_results) matrix4_from_matrix2_f32 :: proc(m: Matrix2f32) -> (r: Matrix4f32) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], 0, 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], 0, 0 @@ -2395,6 +2555,7 @@ matrix4_from_matrix2_f32 :: proc(m: Matrix2f32) -> (r: Matrix4f32) { r[0, 3], r[1, 3], r[2, 3], r[3, 3] = 0, 0, 0, 1 return } +@(require_results) matrix4_from_matrix2_f64 :: proc(m: Matrix2f64) -> (r: Matrix4f64) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], 0, 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], 0, 0 @@ -2409,6 +2570,7 @@ matrix4_from_matrix2 :: proc{ } +@(require_results) matrix4_from_matrix3_f16 :: proc(m: Matrix3f16) -> (r: Matrix4f16) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], m[2, 0], 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], m[2, 1], 0 @@ -2416,6 +2578,7 @@ matrix4_from_matrix3_f16 :: proc(m: Matrix3f16) -> (r: Matrix4f16) { r[0, 3], r[1, 3], r[2, 3], r[3, 3] = 0, 0, 0, 1 return } +@(require_results) matrix4_from_matrix3_f32 :: proc(m: Matrix3f32) -> (r: Matrix4f32) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], m[2, 0], 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], m[2, 1], 0 @@ -2423,6 +2586,7 @@ matrix4_from_matrix3_f32 :: proc(m: Matrix3f32) -> (r: Matrix4f32) { r[0, 3], r[1, 3], r[2, 3], r[3, 3] = 0, 0, 0, 1 return } +@(require_results) matrix4_from_matrix3_f64 :: proc(m: Matrix3f64) -> (r: Matrix4f64) { r[0, 0], r[1, 0], r[2, 0], r[3, 0] = m[0, 0], m[1, 0], m[2, 0], 0 r[0, 1], r[1, 1], r[2, 1], r[3, 1] = m[0, 1], m[1, 1], m[2, 1], 0 @@ -2437,14 +2601,17 @@ matrix4_from_matrix3 :: proc{ } +@(require_results) quaternion_from_scalar_f16 :: proc(f: f16) -> (q: Quaternionf16) { q.w = f return } +@(require_results) quaternion_from_scalar_f32 :: proc(f: f32) -> (q: Quaternionf32) { q.w = f return } +@(require_results) quaternion_from_scalar_f64 :: proc(f: f64) -> (q: Quaternionf64) { q.w = f return @@ -2505,6 +2672,7 @@ to_quaternion :: proc{ +@(require_results) matrix2_orthonormalize_f16 :: proc(m: Matrix2f16) -> (r: Matrix2f16) { r[0] = normalize(m[0]) @@ -2514,6 +2682,7 @@ matrix2_orthonormalize_f16 :: proc(m: Matrix2f16) -> (r: Matrix2f16) { return } +@(require_results) matrix2_orthonormalize_f32 :: proc(m: Matrix2f32) -> (r: Matrix2f32) { r[0] = normalize(m[0]) @@ -2523,6 +2692,7 @@ matrix2_orthonormalize_f32 :: proc(m: Matrix2f32) -> (r: Matrix2f32) { return } +@(require_results) matrix2_orthonormalize_f64 :: proc(m: Matrix2f64) -> (r: Matrix2f64) { r[0] = normalize(m[0]) @@ -2539,6 +2709,7 @@ matrix2_orthonormalize :: proc{ } +@(require_results) matrix3_orthonormalize_f16 :: proc(m: Matrix3f16) -> (r: Matrix3f16) { r[0] = normalize(m[0]) @@ -2553,6 +2724,7 @@ matrix3_orthonormalize_f16 :: proc(m: Matrix3f16) -> (r: Matrix3f16) { return } +@(require_results) matrix3_orthonormalize_f32 :: proc(m: Matrix3f32) -> (r: Matrix3f32) { r[0] = normalize(m[0]) @@ -2567,6 +2739,7 @@ matrix3_orthonormalize_f32 :: proc(m: Matrix3f32) -> (r: Matrix3f32) { return } +@(require_results) matrix3_orthonormalize_f64 :: proc(m: Matrix3f64) -> (r: Matrix3f64) { r[0] = normalize(m[0]) @@ -2588,12 +2761,15 @@ matrix3_orthonormalize :: proc{ } +@(require_results) vector3_orthonormalize_f16 :: proc(x, y: Vector3f16) -> (z: Vector3f16) { return normalize(x - y * dot(y, x)) } +@(require_results) vector3_orthonormalize_f32 :: proc(x, y: Vector3f32) -> (z: Vector3f32) { return normalize(x - y * dot(y, x)) } +@(require_results) vector3_orthonormalize_f64 :: proc(x, y: Vector3f64) -> (z: Vector3f64) { return normalize(x - y * dot(y, x)) } @@ -2611,6 +2787,7 @@ orthonormalize :: proc{ } +@(require_results) matrix4_orientation_f16 :: proc(normal, up: Vector3f16) -> Matrix4f16 { if all(equal(normal, up)) { return MATRIX4F16_IDENTITY @@ -2621,6 +2798,7 @@ matrix4_orientation_f16 :: proc(normal, up: Vector3f16) -> Matrix4f16 { return matrix4_rotate(angle, rotation_axis) } +@(require_results) matrix4_orientation_f32 :: proc(normal, up: Vector3f32) -> Matrix4f32 { if all(equal(normal, up)) { return MATRIX4F32_IDENTITY @@ -2631,6 +2809,7 @@ matrix4_orientation_f32 :: proc(normal, up: Vector3f32) -> Matrix4f32 { return matrix4_rotate(angle, rotation_axis) } +@(require_results) matrix4_orientation_f64 :: proc(normal, up: Vector3f64) -> Matrix4f64 { if all(equal(normal, up)) { return MATRIX4F64_IDENTITY @@ -2648,6 +2827,7 @@ matrix4_orientation :: proc{ } +@(require_results) euclidean_from_polar_f16 :: proc(polar: Vector2f16) -> Vector3f16 { latitude, longitude := polar.x, polar.y cx, sx := math.cos(latitude), math.sin(latitude) @@ -2659,6 +2839,7 @@ euclidean_from_polar_f16 :: proc(polar: Vector2f16) -> Vector3f16 { cx*cy, } } +@(require_results) euclidean_from_polar_f32 :: proc(polar: Vector2f32) -> Vector3f32 { latitude, longitude := polar.x, polar.y cx, sx := math.cos(latitude), math.sin(latitude) @@ -2670,6 +2851,7 @@ euclidean_from_polar_f32 :: proc(polar: Vector2f32) -> Vector3f32 { cx*cy, } } +@(require_results) euclidean_from_polar_f64 :: proc(polar: Vector2f64) -> Vector3f64 { latitude, longitude := polar.x, polar.y cx, sx := math.cos(latitude), math.sin(latitude) @@ -2688,6 +2870,7 @@ euclidean_from_polar :: proc{ } +@(require_results) polar_from_euclidean_f16 :: proc(euclidean: Vector3f16) -> Vector3f16 { n := length(euclidean) tmp := euclidean / n @@ -2700,6 +2883,7 @@ polar_from_euclidean_f16 :: proc(euclidean: Vector3f16) -> Vector3f16 { xz_dist, } } +@(require_results) polar_from_euclidean_f32 :: proc(euclidean: Vector3f32) -> Vector3f32 { n := length(euclidean) tmp := euclidean / n @@ -2712,6 +2896,7 @@ polar_from_euclidean_f32 :: proc(euclidean: Vector3f32) -> Vector3f32 { xz_dist, } } +@(require_results) polar_from_euclidean_f64 :: proc(euclidean: Vector3f64) -> Vector3f64 { n := length(euclidean) tmp := euclidean / n diff --git a/core/math/linalg/specific_euler_angles_f16.odin b/core/math/linalg/specific_euler_angles_f16.odin index 9e21c7f97..e26860882 100644 --- a/core/math/linalg/specific_euler_angles_f16.odin +++ b/core/math/linalg/specific_euler_angles_f16.odin @@ -2,6 +2,7 @@ package linalg import "core:math" +@(require_results) euler_angles_from_matrix3_f16 :: proc(m: Matrix3f16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix3(m) @@ -19,6 +20,7 @@ euler_angles_from_matrix3_f16 :: proc(m: Matrix3f16, order: Euler_Angle_Order) - } return } +@(require_results) euler_angles_from_matrix4_f16 :: proc(m: Matrix4f16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix4(m) @@ -36,6 +38,7 @@ euler_angles_from_matrix4_f16 :: proc(m: Matrix4f16, order: Euler_Angle_Order) - } return } +@(require_results) euler_angles_from_quaternion_f16 :: proc(m: Quaternionf16, order: Euler_Angle_Order) -> (t1, t2, t3: f16) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_quaternion(m) @@ -54,6 +57,7 @@ euler_angles_from_quaternion_f16 :: proc(m: Quaternionf16, order: Euler_Angle_Or return } +@(require_results) matrix3_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) -> (m: Matrix3f16) { switch order { case .XYZ: return matrix3_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); @@ -71,6 +75,7 @@ matrix3_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) } return } +@(require_results) matrix4_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) -> (m: Matrix4f16) { switch order { case .XYZ: return matrix4_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); @@ -89,6 +94,7 @@ matrix4_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) return } +@(require_results) quaternion_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Order) -> Quaternionf16 { X :: quaternion_from_euler_angle_x Y :: quaternion_from_euler_angle_y @@ -117,16 +123,20 @@ quaternion_from_euler_angles_f16 :: proc(t1, t2, t3: f16, order: Euler_Angle_Ord // Quaternionf16s +@(require_results) quaternion_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (q: Quaternionf16) { return quaternion_angle_axis_f16(angle_x, {1, 0, 0}) } +@(require_results) quaternion_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (q: Quaternionf16) { return quaternion_angle_axis_f16(angle_y, {0, 1, 0}) } +@(require_results) quaternion_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (q: Quaternionf16) { return quaternion_angle_axis_f16(angle_z, {0, 0, 1}) } +@(require_results) quaternion_from_pitch_yaw_roll_f16 :: proc(pitch, yaw, roll: f16) -> Quaternionf16 { a, b, c := pitch, yaw, roll @@ -142,10 +152,12 @@ quaternion_from_pitch_yaw_roll_f16 :: proc(pitch, yaw, roll: f16) -> Quaternionf return q } +@(require_results) roll_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { 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) } +@(require_results) pitch_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { 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 @@ -157,11 +169,13 @@ pitch_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { return math.atan2(y, x) } +@(require_results) yaw_from_quaternion_f16 :: proc(q: Quaternionf16) -> f16 { return math.asin(clamp(-2 * (q.x*q.z - q.w*q.y), -1, 1)) } +@(require_results) pitch_yaw_roll_from_quaternion_f16 :: proc(q: Quaternionf16) -> (pitch, yaw, roll: f16) { pitch = pitch_from_quaternion(q) yaw = yaw_from_quaternion(q) @@ -169,39 +183,51 @@ pitch_yaw_roll_from_quaternion_f16 :: proc(q: Quaternionf16) -> (pitch, yaw, rol return } +@(require_results) euler_angles_xyz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_xyz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yxz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_yxz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xzx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_xzx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xyx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_xyx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yxy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_yxy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yzy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_yzy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zyz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_zyz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zxz_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_zxz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xzy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_xzy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yzx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_yzx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zyx_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_zyx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zxy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f16) { return euler_angles_zxy_from_matrix4(matrix4_from_quaternion(q)) } @@ -210,6 +236,7 @@ euler_angles_zxy_from_quaternion_f16 :: proc(q: Quaternionf16) -> (t1, t2, t3: f // Matrix3 +@(require_results) matrix3_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (m: Matrix3f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 @@ -219,6 +246,7 @@ matrix3_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (m: Matrix3f16) { m[2, 2] = +cos_x return } +@(require_results) matrix3_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (m: Matrix3f16) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y @@ -228,6 +256,7 @@ matrix3_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (m: Matrix3f16) { m[2, 2] = +cos_y return } +@(require_results) matrix3_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (m: Matrix3f16) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z @@ -239,6 +268,7 @@ matrix3_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (m: Matrix3f16) { } +@(require_results) matrix3_from_derived_euler_angle_x_f16 :: proc(angle_x: f16, angular_velocity_x: f16) -> (m: Matrix3f16) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x @@ -249,6 +279,7 @@ matrix3_from_derived_euler_angle_x_f16 :: proc(angle_x: f16, angular_velocity_x: m[2, 2] = +cos_x return } +@(require_results) matrix3_from_derived_euler_angle_y_f16 :: proc(angle_y: f16, angular_velocity_y: f16) -> (m: Matrix3f16) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y @@ -259,6 +290,7 @@ matrix3_from_derived_euler_angle_y_f16 :: proc(angle_y: f16, angular_velocity_y: m[2, 2] = +cos_y return } +@(require_results) matrix3_from_derived_euler_angle_z_f16 :: proc(angle_z: f16, angular_velocity_z: f16) -> (m: Matrix3f16) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z @@ -271,6 +303,7 @@ matrix3_from_derived_euler_angle_z_f16 :: proc(angle_z: f16, angular_velocity_z: } +@(require_results) matrix3_from_euler_angles_xy_f16 :: proc(angle_x, angle_y: f16) -> (m: Matrix3f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -286,6 +319,7 @@ matrix3_from_euler_angles_xy_f16 :: proc(angle_x, angle_y: f16) -> (m: Matrix3f1 } +@(require_results) matrix3_from_euler_angles_yx_f16 :: proc(angle_y, angle_x: f16) -> (m: Matrix3f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -300,20 +334,25 @@ matrix3_from_euler_angles_yx_f16 :: proc(angle_y, angle_x: f16) -> (m: Matrix3f1 return } +@(require_results) matrix3_from_euler_angles_xz_f16 :: proc(angle_x, angle_z: f16) -> (m: Matrix3f16) { return mul(matrix3_from_euler_angle_x(angle_x), matrix3_from_euler_angle_z(angle_z)) } +@(require_results) matrix3_from_euler_angles_zx_f16 :: proc(angle_z, angle_x: f16) -> (m: Matrix3f16) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_x(angle_x)) } +@(require_results) matrix3_from_euler_angles_yz_f16 :: proc(angle_y, angle_z: f16) -> (m: Matrix3f16) { return mul(matrix3_from_euler_angle_y(angle_y), matrix3_from_euler_angle_z(angle_z)) } +@(require_results) matrix3_from_euler_angles_zy_f16 :: proc(angle_z, angle_y: f16) -> (m: Matrix3f16) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_y(angle_y)) } +@(require_results) matrix3_from_euler_angles_xyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(-t1) c2 := math.cos(-t2) @@ -334,6 +373,7 @@ matrix3_from_euler_angles_xyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_yxz_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix3f16) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -354,6 +394,7 @@ matrix3_from_euler_angles_yxz_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix3f return } +@(require_results) matrix3_from_euler_angles_xzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -374,6 +415,7 @@ matrix3_from_euler_angles_xzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_xyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -394,6 +436,7 @@ matrix3_from_euler_angles_xyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_yxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -414,6 +457,7 @@ matrix3_from_euler_angles_yxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_yzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -434,6 +478,7 @@ matrix3_from_euler_angles_yzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_zyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -454,6 +499,7 @@ matrix3_from_euler_angles_zyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_zxz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -475,6 +521,7 @@ matrix3_from_euler_angles_zxz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { } +@(require_results) matrix3_from_euler_angles_xzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -495,6 +542,7 @@ matrix3_from_euler_angles_xzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_yzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -515,6 +563,7 @@ matrix3_from_euler_angles_yzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_zyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -535,6 +584,7 @@ matrix3_from_euler_angles_zyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { return } +@(require_results) matrix3_from_euler_angles_zxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -556,6 +606,7 @@ matrix3_from_euler_angles_zxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix3f16) { } +@(require_results) matrix3_from_yaw_pitch_roll_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix3f16) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -576,6 +627,7 @@ matrix3_from_yaw_pitch_roll_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix3f16 return m } +@(require_results) euler_angles_xyz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) @@ -589,6 +641,7 @@ euler_angles_xyz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yxz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) @@ -602,6 +655,7 @@ euler_angles_yxz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_xzx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -615,6 +669,7 @@ euler_angles_xzx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_xyx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -628,6 +683,7 @@ euler_angles_xyx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yxy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -641,6 +697,7 @@ euler_angles_yxy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yzy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -653,6 +710,7 @@ euler_angles_yzy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { t3 = T3 return } +@(require_results) euler_angles_zyz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -666,6 +724,7 @@ euler_angles_zyz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_zxz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -679,6 +738,7 @@ euler_angles_zxz_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_xzy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) @@ -692,6 +752,7 @@ euler_angles_xzy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yzx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) @@ -705,6 +766,7 @@ euler_angles_yzx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_zyx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) @@ -718,6 +780,7 @@ euler_angles_zyx_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_zxy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) @@ -735,6 +798,7 @@ euler_angles_zxy_from_matrix3_f16 :: proc(m: Matrix3f16) -> (t1, t2, t3: f16) { // Matrix4 +@(require_results) matrix4_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (m: Matrix4f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 @@ -745,6 +809,7 @@ matrix4_from_euler_angle_x_f16 :: proc(angle_x: f16) -> (m: Matrix4f16) { m[3, 3] = 1 return } +@(require_results) matrix4_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (m: Matrix4f16) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y @@ -755,6 +820,7 @@ matrix4_from_euler_angle_y_f16 :: proc(angle_y: f16) -> (m: Matrix4f16) { m[3, 3] = 1 return } +@(require_results) matrix4_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (m: Matrix4f16) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z @@ -767,6 +833,7 @@ matrix4_from_euler_angle_z_f16 :: proc(angle_z: f16) -> (m: Matrix4f16) { } +@(require_results) matrix4_from_derived_euler_angle_x_f16 :: proc(angle_x: f16, angular_velocity_x: f16) -> (m: Matrix4f16) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x @@ -778,6 +845,7 @@ matrix4_from_derived_euler_angle_x_f16 :: proc(angle_x: f16, angular_velocity_x: m[3, 3] = 1 return } +@(require_results) matrix4_from_derived_euler_angle_y_f16 :: proc(angle_y: f16, angular_velocity_y: f16) -> (m: Matrix4f16) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y @@ -789,6 +857,7 @@ matrix4_from_derived_euler_angle_y_f16 :: proc(angle_y: f16, angular_velocity_y: m[3, 3] = 1 return } +@(require_results) matrix4_from_derived_euler_angle_z_f16 :: proc(angle_z: f16, angular_velocity_z: f16) -> (m: Matrix4f16) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z @@ -802,6 +871,7 @@ matrix4_from_derived_euler_angle_z_f16 :: proc(angle_z: f16, angular_velocity_z: } +@(require_results) matrix4_from_euler_angles_xy_f16 :: proc(angle_x, angle_y: f16) -> (m: Matrix4f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -818,6 +888,7 @@ matrix4_from_euler_angles_xy_f16 :: proc(angle_x, angle_y: f16) -> (m: Matrix4f1 } +@(require_results) matrix4_from_euler_angles_yx_f16 :: proc(angle_y, angle_x: f16) -> (m: Matrix4f16) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -833,20 +904,25 @@ matrix4_from_euler_angles_yx_f16 :: proc(angle_y, angle_x: f16) -> (m: Matrix4f1 return } +@(require_results) matrix4_from_euler_angles_xz_f16 :: proc(angle_x, angle_z: f16) -> (m: Matrix4f16) { return mul(matrix4_from_euler_angle_x(angle_x), matrix4_from_euler_angle_z(angle_z)) } +@(require_results) matrix4_from_euler_angles_zx_f16 :: proc(angle_z, angle_x: f16) -> (m: Matrix4f16) { return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_x(angle_x)) } +@(require_results) matrix4_from_euler_angles_yz_f16 :: proc(angle_y, angle_z: f16) -> (m: Matrix4f16) { return mul(matrix4_from_euler_angle_y(angle_y), matrix4_from_euler_angle_z(angle_z)) } +@(require_results) matrix4_from_euler_angles_zy_f16 :: proc(angle_z, angle_y: f16) -> (m: Matrix4f16) { return mul(matrix4_from_euler_angle_z(angle_z), matrix4_from_euler_angle_y(angle_y)) } +@(require_results) matrix4_from_euler_angles_xyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(-t1) c2 := math.cos(-t2) @@ -874,6 +950,7 @@ matrix4_from_euler_angles_xyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_yxz_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix4f16) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -901,6 +978,7 @@ matrix4_from_euler_angles_yxz_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix4f return } +@(require_results) matrix4_from_euler_angles_xzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -928,6 +1006,7 @@ matrix4_from_euler_angles_xzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_xyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -955,6 +1034,7 @@ matrix4_from_euler_angles_xyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_yxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -982,6 +1062,7 @@ matrix4_from_euler_angles_yxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_yzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1009,6 +1090,7 @@ matrix4_from_euler_angles_yzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_zyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1036,6 +1118,7 @@ matrix4_from_euler_angles_zyz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_zxz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1064,6 +1147,7 @@ matrix4_from_euler_angles_zxz_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { } +@(require_results) matrix4_from_euler_angles_xzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1091,6 +1175,7 @@ matrix4_from_euler_angles_xzy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_yzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1118,6 +1203,7 @@ matrix4_from_euler_angles_yzx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_zyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1145,6 +1231,7 @@ matrix4_from_euler_angles_zyx_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { return } +@(require_results) matrix4_from_euler_angles_zxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1173,6 +1260,7 @@ matrix4_from_euler_angles_zxy_f16 :: proc(t1, t2, t3: f16) -> (m: Matrix4f16) { } +@(require_results) matrix4_from_yaw_pitch_roll_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix4f16) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -1200,6 +1288,7 @@ matrix4_from_yaw_pitch_roll_f16 :: proc(yaw, pitch, roll: f16) -> (m: Matrix4f16 return m } +@(require_results) euler_angles_xyz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) @@ -1213,6 +1302,7 @@ euler_angles_xyz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yxz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) @@ -1226,6 +1316,7 @@ euler_angles_yxz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_xzx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -1239,6 +1330,7 @@ euler_angles_xzx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_xyx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -1252,6 +1344,7 @@ euler_angles_xyx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yxy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -1265,6 +1358,7 @@ euler_angles_yxy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yzy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -1277,6 +1371,7 @@ euler_angles_yzy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { t3 = T3 return } +@(require_results) euler_angles_zyz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -1290,6 +1385,7 @@ euler_angles_zyz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_zxz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -1303,6 +1399,7 @@ euler_angles_zxz_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_xzy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) @@ -1316,6 +1413,7 @@ euler_angles_xzy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_yzx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) @@ -1329,6 +1427,7 @@ euler_angles_yzx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_zyx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) @@ -1342,6 +1441,7 @@ euler_angles_zyx_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { return } +@(require_results) euler_angles_zxy_from_matrix4_f16 :: proc(m: Matrix4f16) -> (t1, t2, t3: f16) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) diff --git a/core/math/linalg/specific_euler_angles_f32.odin b/core/math/linalg/specific_euler_angles_f32.odin index 80e19ce85..3cd076f0b 100644 --- a/core/math/linalg/specific_euler_angles_f32.odin +++ b/core/math/linalg/specific_euler_angles_f32.odin @@ -2,6 +2,7 @@ package linalg import "core:math" +@(require_results) euler_angles_from_matrix3_f32 :: proc(m: Matrix3f32, order: Euler_Angle_Order) -> (t1, t2, t3: f32) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix3(m) @@ -19,6 +20,7 @@ euler_angles_from_matrix3_f32 :: proc(m: Matrix3f32, order: Euler_Angle_Order) - } return } +@(require_results) 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(m) @@ -36,6 +38,7 @@ euler_angles_from_matrix4_f32 :: proc(m: Matrix4f32, order: Euler_Angle_Order) - } return } +@(require_results) 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(m) @@ -54,6 +57,7 @@ euler_angles_from_quaternion_f32 :: proc(m: Quaternionf32, order: Euler_Angle_Or return } +@(require_results) matrix3_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) -> (m: Matrix3f32) { switch order { case .XYZ: return matrix3_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); @@ -71,6 +75,7 @@ matrix3_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) } return } +@(require_results) 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(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); @@ -89,6 +94,7 @@ matrix4_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Order) return } +@(require_results) 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 @@ -117,16 +123,20 @@ quaternion_from_euler_angles_f32 :: proc(t1, t2, t3: f32, order: Euler_Angle_Ord // Quaternionf32s +@(require_results) quaternion_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (q: Quaternionf32) { return quaternion_angle_axis_f32(angle_x, {1, 0, 0}) } +@(require_results) quaternion_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (q: Quaternionf32) { return quaternion_angle_axis_f32(angle_y, {0, 1, 0}) } +@(require_results) quaternion_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (q: Quaternionf32) { return quaternion_angle_axis_f32(angle_z, {0, 0, 1}) } +@(require_results) quaternion_from_pitch_yaw_roll_f32 :: proc(pitch, yaw, roll: f32) -> Quaternionf32 { a, b, c := pitch, yaw, roll @@ -142,10 +152,12 @@ quaternion_from_pitch_yaw_roll_f32 :: proc(pitch, yaw, roll: f32) -> Quaternionf return q } +@(require_results) 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) } +@(require_results) 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 @@ -157,11 +169,13 @@ pitch_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { return math.atan2(y, x) } +@(require_results) yaw_from_quaternion_f32 :: proc(q: Quaternionf32) -> f32 { return math.asin(clamp(-2 * (q.x*q.z - q.w*q.y), -1, 1)) } +@(require_results) pitch_yaw_roll_from_quaternion_f32 :: proc(q: Quaternionf32) -> (pitch, yaw, roll: f32) { pitch = pitch_from_quaternion(q) yaw = yaw_from_quaternion(q) @@ -169,39 +183,51 @@ pitch_yaw_roll_from_quaternion_f32 :: proc(q: Quaternionf32) -> (pitch, yaw, rol return } +@(require_results) euler_angles_xyz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_xyz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yxz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_yxz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xzx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_xzx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xyx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_xyx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yxy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_yxy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yzy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_yzy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zyz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_zyz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zxz_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_zxz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xzy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_xzy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yzx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_yzx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zyx_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_zyx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zxy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f32) { return euler_angles_zxy_from_matrix4(matrix4_from_quaternion(q)) } @@ -210,6 +236,7 @@ euler_angles_zxy_from_quaternion_f32 :: proc(q: Quaternionf32) -> (t1, t2, t3: f // Matrix3 +@(require_results) matrix3_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (m: Matrix3f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 @@ -219,6 +246,7 @@ matrix3_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (m: Matrix3f32) { m[2, 2] = +cos_x return } +@(require_results) matrix3_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (m: Matrix3f32) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y @@ -228,6 +256,7 @@ matrix3_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (m: Matrix3f32) { m[2, 2] = +cos_y return } +@(require_results) matrix3_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (m: Matrix3f32) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z @@ -239,6 +268,7 @@ matrix3_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (m: Matrix3f32) { } +@(require_results) matrix3_from_derived_euler_angle_x_f32 :: proc(angle_x: f32, angular_velocity_x: f32) -> (m: Matrix3f32) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x @@ -249,6 +279,7 @@ matrix3_from_derived_euler_angle_x_f32 :: proc(angle_x: f32, angular_velocity_x: m[2, 2] = +cos_x return } +@(require_results) matrix3_from_derived_euler_angle_y_f32 :: proc(angle_y: f32, angular_velocity_y: f32) -> (m: Matrix3f32) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y @@ -259,6 +290,7 @@ matrix3_from_derived_euler_angle_y_f32 :: proc(angle_y: f32, angular_velocity_y: m[2, 2] = +cos_y return } +@(require_results) matrix3_from_derived_euler_angle_z_f32 :: proc(angle_z: f32, angular_velocity_z: f32) -> (m: Matrix3f32) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z @@ -271,6 +303,7 @@ matrix3_from_derived_euler_angle_z_f32 :: proc(angle_z: f32, angular_velocity_z: } +@(require_results) matrix3_from_euler_angles_xy_f32 :: proc(angle_x, angle_y: f32) -> (m: Matrix3f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -286,6 +319,7 @@ matrix3_from_euler_angles_xy_f32 :: proc(angle_x, angle_y: f32) -> (m: Matrix3f3 } +@(require_results) matrix3_from_euler_angles_yx_f32 :: proc(angle_y, angle_x: f32) -> (m: Matrix3f32) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -300,20 +334,25 @@ matrix3_from_euler_angles_yx_f32 :: proc(angle_y, angle_x: f32) -> (m: Matrix3f3 return } +@(require_results) matrix3_from_euler_angles_xz_f32 :: proc(angle_x, angle_z: f32) -> (m: Matrix3f32) { return mul(matrix3_from_euler_angle_x(angle_x), matrix3_from_euler_angle_z(angle_z)) } +@(require_results) matrix3_from_euler_angles_zx_f32 :: proc(angle_z, angle_x: f32) -> (m: Matrix3f32) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_x(angle_x)) } +@(require_results) matrix3_from_euler_angles_yz_f32 :: proc(angle_y, angle_z: f32) -> (m: Matrix3f32) { return mul(matrix3_from_euler_angle_y(angle_y), matrix3_from_euler_angle_z(angle_z)) } +@(require_results) matrix3_from_euler_angles_zy_f32 :: proc(angle_z, angle_y: f32) -> (m: Matrix3f32) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_y(angle_y)) } +@(require_results) matrix3_from_euler_angles_xyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(-t1) c2 := math.cos(-t2) @@ -334,6 +373,7 @@ matrix3_from_euler_angles_xyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_yxz_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix3f32) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -354,6 +394,7 @@ matrix3_from_euler_angles_yxz_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix3f return } +@(require_results) matrix3_from_euler_angles_xzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -374,6 +415,7 @@ matrix3_from_euler_angles_xzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_xyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -394,6 +436,7 @@ matrix3_from_euler_angles_xyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_yxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -414,6 +457,7 @@ matrix3_from_euler_angles_yxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_yzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -434,6 +478,7 @@ matrix3_from_euler_angles_yzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_zyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -454,6 +499,7 @@ matrix3_from_euler_angles_zyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_zxz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -475,6 +521,7 @@ matrix3_from_euler_angles_zxz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { } +@(require_results) matrix3_from_euler_angles_xzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -495,6 +542,7 @@ matrix3_from_euler_angles_xzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_yzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -515,6 +563,7 @@ matrix3_from_euler_angles_yzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_zyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -535,6 +584,7 @@ matrix3_from_euler_angles_zyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { return } +@(require_results) matrix3_from_euler_angles_zxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -556,6 +606,7 @@ matrix3_from_euler_angles_zxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix3f32) { } +@(require_results) matrix3_from_yaw_pitch_roll_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix3f32) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -576,6 +627,7 @@ matrix3_from_yaw_pitch_roll_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix3f32 return m } +@(require_results) euler_angles_xyz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) @@ -589,6 +641,7 @@ euler_angles_xyz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yxz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) @@ -602,6 +655,7 @@ euler_angles_yxz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_xzx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -615,6 +669,7 @@ euler_angles_xzx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_xyx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -628,6 +683,7 @@ euler_angles_xyx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yxy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -641,6 +697,7 @@ euler_angles_yxy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yzy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -653,6 +710,7 @@ euler_angles_yzy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { t3 = T3 return } +@(require_results) euler_angles_zyz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -666,6 +724,7 @@ euler_angles_zyz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_zxz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -679,6 +738,7 @@ euler_angles_zxz_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_xzy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) @@ -692,6 +752,7 @@ euler_angles_xzy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yzx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) @@ -705,6 +766,7 @@ euler_angles_yzx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_zyx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) @@ -718,6 +780,7 @@ euler_angles_zyx_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_zxy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) @@ -735,6 +798,7 @@ euler_angles_zxy_from_matrix3_f32 :: proc(m: Matrix3f32) -> (t1, t2, t3: f32) { // Matrix4 +@(require_results) 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 @@ -745,6 +809,7 @@ matrix4_from_euler_angle_x_f32 :: proc(angle_x: f32) -> (m: Matrix4f32) { m[3, 3] = 1 return } +@(require_results) 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 @@ -755,6 +820,7 @@ matrix4_from_euler_angle_y_f32 :: proc(angle_y: f32) -> (m: Matrix4f32) { m[3, 3] = 1 return } +@(require_results) 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 @@ -767,6 +833,7 @@ matrix4_from_euler_angle_z_f32 :: proc(angle_z: f32) -> (m: Matrix4f32) { } +@(require_results) 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 @@ -778,6 +845,7 @@ matrix4_from_derived_euler_angle_x_f32 :: proc(angle_x: f32, angular_velocity_x: m[3, 3] = 1 return } +@(require_results) 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 @@ -789,6 +857,7 @@ matrix4_from_derived_euler_angle_y_f32 :: proc(angle_y: f32, angular_velocity_y: m[3, 3] = 1 return } +@(require_results) 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 @@ -802,6 +871,7 @@ matrix4_from_derived_euler_angle_z_f32 :: proc(angle_z: f32, angular_velocity_z: } +@(require_results) 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) @@ -818,6 +888,7 @@ matrix4_from_euler_angles_xy_f32 :: proc(angle_x, angle_y: f32) -> (m: Matrix4f3 } +@(require_results) 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) @@ -833,20 +904,25 @@ matrix4_from_euler_angles_yx_f32 :: proc(angle_y, angle_x: f32) -> (m: Matrix4f3 return } +@(require_results) 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)) } +@(require_results) 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)) } +@(require_results) 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)) } +@(require_results) 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)) } +@(require_results) matrix4_from_euler_angles_xyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(-t1) c2 := math.cos(-t2) @@ -874,6 +950,7 @@ matrix4_from_euler_angles_xyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_yxz_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix4f32) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -901,6 +978,7 @@ matrix4_from_euler_angles_yxz_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix4f return } +@(require_results) matrix4_from_euler_angles_xzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -928,6 +1006,7 @@ matrix4_from_euler_angles_xzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_xyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -955,6 +1034,7 @@ matrix4_from_euler_angles_xyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_yxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -982,6 +1062,7 @@ matrix4_from_euler_angles_yxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_yzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1009,6 +1090,7 @@ matrix4_from_euler_angles_yzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_zyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1036,6 +1118,7 @@ matrix4_from_euler_angles_zyz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_zxz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1064,6 +1147,7 @@ matrix4_from_euler_angles_zxz_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { } +@(require_results) matrix4_from_euler_angles_xzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1091,6 +1175,7 @@ matrix4_from_euler_angles_xzy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_yzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1118,6 +1203,7 @@ matrix4_from_euler_angles_yzx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_zyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1145,6 +1231,7 @@ matrix4_from_euler_angles_zyx_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { return } +@(require_results) matrix4_from_euler_angles_zxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1173,6 +1260,7 @@ matrix4_from_euler_angles_zxy_f32 :: proc(t1, t2, t3: f32) -> (m: Matrix4f32) { } +@(require_results) matrix4_from_yaw_pitch_roll_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix4f32) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -1200,6 +1288,7 @@ matrix4_from_yaw_pitch_roll_f32 :: proc(yaw, pitch, roll: f32) -> (m: Matrix4f32 return m } +@(require_results) euler_angles_xyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) @@ -1213,6 +1302,7 @@ euler_angles_xyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) @@ -1226,6 +1316,7 @@ euler_angles_yxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_xzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -1239,6 +1330,7 @@ euler_angles_xzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_xyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -1252,6 +1344,7 @@ euler_angles_xyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yxy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -1265,6 +1358,7 @@ euler_angles_yxy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -1277,6 +1371,7 @@ euler_angles_yzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { t3 = T3 return } +@(require_results) euler_angles_zyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -1290,6 +1385,7 @@ euler_angles_zyz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_zxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -1303,6 +1399,7 @@ euler_angles_zxz_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_xzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) @@ -1316,6 +1413,7 @@ euler_angles_xzy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_yzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) @@ -1329,6 +1427,7 @@ euler_angles_yzx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_zyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) @@ -1342,6 +1441,7 @@ euler_angles_zyx_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { return } +@(require_results) euler_angles_zxy_from_matrix4_f32 :: proc(m: Matrix4f32) -> (t1, t2, t3: f32) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) diff --git a/core/math/linalg/specific_euler_angles_f64.odin b/core/math/linalg/specific_euler_angles_f64.odin index 2f8f758b0..a97f1757d 100644 --- a/core/math/linalg/specific_euler_angles_f64.odin +++ b/core/math/linalg/specific_euler_angles_f64.odin @@ -2,6 +2,7 @@ package linalg import "core:math" +@(require_results) euler_angles_from_matrix3_f64 :: proc(m: Matrix3f64, order: Euler_Angle_Order) -> (t1, t2, t3: f64) { switch order { case .XYZ: t1, t2, t3 = euler_angles_xyz_from_matrix3(m) @@ -19,6 +20,7 @@ euler_angles_from_matrix3_f64 :: proc(m: Matrix3f64, order: Euler_Angle_Order) - } return } +@(require_results) 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) @@ -36,6 +38,7 @@ euler_angles_from_matrix4_f64 :: proc(m: Matrix4f64, order: Euler_Angle_Order) - } return } +@(require_results) 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) @@ -54,6 +57,7 @@ euler_angles_from_quaternion_f64 :: proc(m: Quaternionf64, order: Euler_Angle_Or return } +@(require_results) matrix3_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) -> (m: Matrix3f64) { switch order { case .XYZ: return matrix3_from_euler_angles_xyz(t1, t2, t3) // m1, m2, m3 = X(t1), Y(t2), Z(t3); @@ -71,6 +75,7 @@ matrix3_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) } return } +@(require_results) 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); @@ -89,6 +94,7 @@ matrix4_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Order) return } +@(require_results) 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 @@ -117,16 +123,20 @@ quaternion_from_euler_angles_f64 :: proc(t1, t2, t3: f64, order: Euler_Angle_Ord // Quaternionf64s +@(require_results) quaternion_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (q: Quaternionf64) { return quaternion_angle_axis_f64(angle_x, {1, 0, 0}) } +@(require_results) quaternion_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (q: Quaternionf64) { return quaternion_angle_axis_f64(angle_y, {0, 1, 0}) } +@(require_results) quaternion_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (q: Quaternionf64) { return quaternion_angle_axis_f64(angle_z, {0, 0, 1}) } +@(require_results) quaternion_from_pitch_yaw_roll_f64 :: proc(pitch, yaw, roll: f64) -> Quaternionf64 { a, b, c := pitch, yaw, roll @@ -142,10 +152,12 @@ quaternion_from_pitch_yaw_roll_f64 :: proc(pitch, yaw, roll: f64) -> Quaternionf return q } +@(require_results) 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) } +@(require_results) 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 @@ -157,11 +169,13 @@ pitch_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 { return math.atan2(y, x) } +@(require_results) yaw_from_quaternion_f64 :: proc(q: Quaternionf64) -> f64 { return math.asin(clamp(-2 * (q.x*q.z - q.w*q.y), -1, 1)) } +@(require_results) pitch_yaw_roll_from_quaternion_f64 :: proc(q: Quaternionf64) -> (pitch, yaw, roll: f64) { pitch = pitch_from_quaternion(q) yaw = yaw_from_quaternion(q) @@ -169,39 +183,51 @@ pitch_yaw_roll_from_quaternion_f64 :: proc(q: Quaternionf64) -> (pitch, yaw, rol return } +@(require_results) euler_angles_xyz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_xyz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yxz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_yxz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xzx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_xzx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xyx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_xyx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yxy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_yxy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yzy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_yzy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zyz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_zyz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zxz_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_zxz_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_xzy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_xzy_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_yzx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_yzx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zyx_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_zyx_from_matrix4(matrix4_from_quaternion(q)) } +@(require_results) euler_angles_zxy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f64) { return euler_angles_zxy_from_matrix4(matrix4_from_quaternion(q)) } @@ -210,6 +236,7 @@ euler_angles_zxy_from_quaternion_f64 :: proc(q: Quaternionf64) -> (t1, t2, t3: f // Matrix3 +@(require_results) matrix3_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (m: Matrix3f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) m[0, 0] = 1 @@ -219,6 +246,7 @@ matrix3_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (m: Matrix3f64) { m[2, 2] = +cos_x return } +@(require_results) matrix3_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (m: Matrix3f64) { cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) m[0, 0] = +cos_y @@ -228,6 +256,7 @@ matrix3_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (m: Matrix3f64) { m[2, 2] = +cos_y return } +@(require_results) matrix3_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (m: Matrix3f64) { cos_z, sin_z := math.cos(angle_z), math.sin(angle_z) m[0, 0] = +cos_z @@ -239,6 +268,7 @@ matrix3_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (m: Matrix3f64) { } +@(require_results) matrix3_from_derived_euler_angle_x_f64 :: proc(angle_x: f64, angular_velocity_x: f64) -> (m: Matrix3f64) { cos_x := math.cos(angle_x) * angular_velocity_x sin_x := math.sin(angle_x) * angular_velocity_x @@ -249,6 +279,7 @@ matrix3_from_derived_euler_angle_x_f64 :: proc(angle_x: f64, angular_velocity_x: m[2, 2] = +cos_x return } +@(require_results) matrix3_from_derived_euler_angle_y_f64 :: proc(angle_y: f64, angular_velocity_y: f64) -> (m: Matrix3f64) { cos_y := math.cos(angle_y) * angular_velocity_y sin_y := math.sin(angle_y) * angular_velocity_y @@ -259,6 +290,7 @@ matrix3_from_derived_euler_angle_y_f64 :: proc(angle_y: f64, angular_velocity_y: m[2, 2] = +cos_y return } +@(require_results) matrix3_from_derived_euler_angle_z_f64 :: proc(angle_z: f64, angular_velocity_z: f64) -> (m: Matrix3f64) { cos_z := math.cos(angle_z) * angular_velocity_z sin_z := math.sin(angle_z) * angular_velocity_z @@ -271,6 +303,7 @@ matrix3_from_derived_euler_angle_z_f64 :: proc(angle_z: f64, angular_velocity_z: } +@(require_results) matrix3_from_euler_angles_xy_f64 :: proc(angle_x, angle_y: f64) -> (m: Matrix3f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -286,6 +319,7 @@ matrix3_from_euler_angles_xy_f64 :: proc(angle_x, angle_y: f64) -> (m: Matrix3f6 } +@(require_results) matrix3_from_euler_angles_yx_f64 :: proc(angle_y, angle_x: f64) -> (m: Matrix3f64) { cos_x, sin_x := math.cos(angle_x), math.sin(angle_x) cos_y, sin_y := math.cos(angle_y), math.sin(angle_y) @@ -300,20 +334,25 @@ matrix3_from_euler_angles_yx_f64 :: proc(angle_y, angle_x: f64) -> (m: Matrix3f6 return } +@(require_results) matrix3_from_euler_angles_xz_f64 :: proc(angle_x, angle_z: f64) -> (m: Matrix3f64) { return mul(matrix3_from_euler_angle_x(angle_x), matrix3_from_euler_angle_z(angle_z)) } +@(require_results) matrix3_from_euler_angles_zx_f64 :: proc(angle_z, angle_x: f64) -> (m: Matrix3f64) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_x(angle_x)) } +@(require_results) matrix3_from_euler_angles_yz_f64 :: proc(angle_y, angle_z: f64) -> (m: Matrix3f64) { return mul(matrix3_from_euler_angle_y(angle_y), matrix3_from_euler_angle_z(angle_z)) } +@(require_results) matrix3_from_euler_angles_zy_f64 :: proc(angle_z, angle_y: f64) -> (m: Matrix3f64) { return mul(matrix3_from_euler_angle_z(angle_z), matrix3_from_euler_angle_y(angle_y)) } +@(require_results) matrix3_from_euler_angles_xyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(-t1) c2 := math.cos(-t2) @@ -334,6 +373,7 @@ matrix3_from_euler_angles_xyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_yxz_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix3f64) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -354,6 +394,7 @@ matrix3_from_euler_angles_yxz_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix3f return } +@(require_results) matrix3_from_euler_angles_xzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -374,6 +415,7 @@ matrix3_from_euler_angles_xzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_xyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -394,6 +436,7 @@ matrix3_from_euler_angles_xyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_yxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -414,6 +457,7 @@ matrix3_from_euler_angles_yxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_yzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -434,6 +478,7 @@ matrix3_from_euler_angles_yzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_zyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -454,6 +499,7 @@ matrix3_from_euler_angles_zyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_zxz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -475,6 +521,7 @@ matrix3_from_euler_angles_zxz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { } +@(require_results) matrix3_from_euler_angles_xzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -495,6 +542,7 @@ matrix3_from_euler_angles_xzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_yzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -515,6 +563,7 @@ matrix3_from_euler_angles_yzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_zyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -535,6 +584,7 @@ matrix3_from_euler_angles_zyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { return } +@(require_results) matrix3_from_euler_angles_zxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -556,6 +606,7 @@ matrix3_from_euler_angles_zxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix3f64) { } +@(require_results) matrix3_from_yaw_pitch_roll_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix3f64) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -576,6 +627,7 @@ matrix3_from_yaw_pitch_roll_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix3f64 return m } +@(require_results) euler_angles_xyz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) @@ -589,6 +641,7 @@ euler_angles_xyz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yxz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) @@ -602,6 +655,7 @@ euler_angles_yxz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_xzx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -615,6 +669,7 @@ euler_angles_xzx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_xyx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -628,6 +683,7 @@ euler_angles_xyx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yxy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -641,6 +697,7 @@ euler_angles_yxy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yzy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -653,6 +710,7 @@ euler_angles_yzy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { t3 = T3 return } +@(require_results) euler_angles_zyz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -666,6 +724,7 @@ euler_angles_zyz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_zxz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -679,6 +738,7 @@ euler_angles_zxz_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_xzy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) @@ -692,6 +752,7 @@ euler_angles_xzy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yzx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) @@ -705,6 +766,7 @@ euler_angles_yzx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_zyx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) @@ -718,6 +780,7 @@ euler_angles_zyx_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_zxy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) @@ -735,6 +798,7 @@ euler_angles_zxy_from_matrix3_f64 :: proc(m: Matrix3f64) -> (t1, t2, t3: f64) { // Matrix4 +@(require_results) 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 @@ -745,6 +809,7 @@ matrix4_from_euler_angle_x_f64 :: proc(angle_x: f64) -> (m: Matrix4f64) { m[3, 3] = 1 return } +@(require_results) 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 @@ -755,6 +820,7 @@ matrix4_from_euler_angle_y_f64 :: proc(angle_y: f64) -> (m: Matrix4f64) { m[3, 3] = 1 return } +@(require_results) 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 @@ -767,6 +833,7 @@ matrix4_from_euler_angle_z_f64 :: proc(angle_z: f64) -> (m: Matrix4f64) { } +@(require_results) 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 @@ -778,6 +845,7 @@ matrix4_from_derived_euler_angle_x_f64 :: proc(angle_x: f64, angular_velocity_x: m[3, 3] = 1 return } +@(require_results) 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 @@ -789,6 +857,7 @@ matrix4_from_derived_euler_angle_y_f64 :: proc(angle_y: f64, angular_velocity_y: m[3, 3] = 1 return } +@(require_results) 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 @@ -802,6 +871,7 @@ matrix4_from_derived_euler_angle_z_f64 :: proc(angle_z: f64, angular_velocity_z: } +@(require_results) 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) @@ -818,6 +888,7 @@ matrix4_from_euler_angles_xy_f64 :: proc(angle_x, angle_y: f64) -> (m: Matrix4f6 } +@(require_results) 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) @@ -833,20 +904,25 @@ matrix4_from_euler_angles_yx_f64 :: proc(angle_y, angle_x: f64) -> (m: Matrix4f6 return } +@(require_results) 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)) } +@(require_results) 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)) } +@(require_results) 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)) } +@(require_results) 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)) } +@(require_results) matrix4_from_euler_angles_xyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(-t1) c2 := math.cos(-t2) @@ -874,6 +950,7 @@ matrix4_from_euler_angles_xyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_yxz_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix4f64) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -901,6 +978,7 @@ matrix4_from_euler_angles_yxz_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix4f return } +@(require_results) matrix4_from_euler_angles_xzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -928,6 +1006,7 @@ matrix4_from_euler_angles_xzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_xyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -955,6 +1034,7 @@ matrix4_from_euler_angles_xyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_yxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -982,6 +1062,7 @@ matrix4_from_euler_angles_yxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_yzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1009,6 +1090,7 @@ matrix4_from_euler_angles_yzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_zyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1036,6 +1118,7 @@ matrix4_from_euler_angles_zyz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_zxz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1064,6 +1147,7 @@ matrix4_from_euler_angles_zxz_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { } +@(require_results) matrix4_from_euler_angles_xzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1091,6 +1175,7 @@ matrix4_from_euler_angles_xzy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_yzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1118,6 +1203,7 @@ matrix4_from_euler_angles_yzx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_zyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1145,6 +1231,7 @@ matrix4_from_euler_angles_zyx_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { return } +@(require_results) matrix4_from_euler_angles_zxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { c1 := math.cos(t1) s1 := math.sin(t1) @@ -1173,6 +1260,7 @@ matrix4_from_euler_angles_zxy_f64 :: proc(t1, t2, t3: f64) -> (m: Matrix4f64) { } +@(require_results) matrix4_from_yaw_pitch_roll_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix4f64) { ch := math.cos(yaw) sh := math.sin(yaw) @@ -1200,6 +1288,7 @@ matrix4_from_yaw_pitch_roll_f64 :: proc(yaw, pitch, roll: f64) -> (m: Matrix4f64 return m } +@(require_results) euler_angles_xyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 2], m[2, 2]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 1]*m[0, 1]) @@ -1213,6 +1302,7 @@ euler_angles_xyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 2], m[2, 2]) C2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 1]*m[1, 1]) @@ -1226,6 +1316,7 @@ euler_angles_yxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_xzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 0], m[1, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -1239,6 +1330,7 @@ euler_angles_xzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_xyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 0], -m[2, 0]) S2 := math.sqrt(m[0, 1]*m[0, 1] + m[0, 2]*m[0, 2]) @@ -1252,6 +1344,7 @@ euler_angles_xyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yxy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 1], m[2, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -1265,6 +1358,7 @@ euler_angles_yxy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 1], -m[0, 1]) S2 := math.sqrt(m[1, 0]*m[1, 0] + m[1, 2]*m[1, 2]) @@ -1277,6 +1371,7 @@ euler_angles_yzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { t3 = T3 return } +@(require_results) euler_angles_zyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 2], m[0, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -1290,6 +1385,7 @@ euler_angles_zyz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_zxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[0, 2], -m[1, 2]) S2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 1]*m[2, 1]) @@ -1303,6 +1399,7 @@ euler_angles_zxz_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_xzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[2, 1], m[1, 1]) C2 := math.sqrt(m[0, 0]*m[0, 0] + m[0, 2]*m[0, 2]) @@ -1316,6 +1413,7 @@ euler_angles_xzy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_yzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(-m[2, 0], m[0, 0]) C2 := math.sqrt(m[1, 1]*m[1, 1] + m[1, 2]*m[1, 2]) @@ -1329,6 +1427,7 @@ euler_angles_yzx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_zyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(m[1, 0], m[0, 0]) C2 := math.sqrt(m[2, 1]*m[2, 1] + m[2, 2]*m[2, 2]) @@ -1342,6 +1441,7 @@ euler_angles_zyx_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { return } +@(require_results) euler_angles_zxy_from_matrix4_f64 :: proc(m: Matrix4f64) -> (t1, t2, t3: f64) { T1 := math.atan2(-m[0, 1], m[1, 1]) C2 := math.sqrt(m[2, 0]*m[2, 0] + m[2, 2]*m[2, 2]) diff --git a/core/math/linalg/swizzle.odin b/core/math/linalg/swizzle.odin index ada4aebcf..8c2072193 100644 --- a/core/math/linalg/swizzle.odin +++ b/core/math/linalg/swizzle.odin @@ -37,109 +37,141 @@ Vector4_Components :: enum u8 { a = 3, } +@(require_results) scalar_f32_swizzle1 :: proc(f: f32, c0: Scalar_Components) -> f32 { return f } +@(require_results) scalar_f32_swizzle2 :: proc(f: f32, c0, c1: Scalar_Components) -> Vector2f32 { return {f, f} } +@(require_results) scalar_f32_swizzle3 :: proc(f: f32, c0, c1, c2: Scalar_Components) -> Vector3f32 { return {f, f, f} } +@(require_results) scalar_f32_swizzle4 :: proc(f: f32, c0, c1, c2, c3: Scalar_Components) -> Vector4f32 { return {f, f, f, f} } +@(require_results) vector2f32_swizzle1 :: proc(v: Vector2f32, c0: Vector2_Components) -> f32 { return v[c0] } +@(require_results) vector2f32_swizzle2 :: proc(v: Vector2f32, c0, c1: Vector2_Components) -> Vector2f32 { return {v[c0], v[c1]} } +@(require_results) vector2f32_swizzle3 :: proc(v: Vector2f32, c0, c1, c2: Vector2_Components) -> Vector3f32 { return {v[c0], v[c1], v[c2]} } +@(require_results) vector2f32_swizzle4 :: proc(v: Vector2f32, c0, c1, c2, c3: Vector2_Components) -> Vector4f32 { return {v[c0], v[c1], v[c2], v[c3]} } +@(require_results) vector3f32_swizzle1 :: proc(v: Vector3f32, c0: Vector3_Components) -> f32 { return v[c0] } +@(require_results) vector3f32_swizzle2 :: proc(v: Vector3f32, c0, c1: Vector3_Components) -> Vector2f32 { return {v[c0], v[c1]} } +@(require_results) vector3f32_swizzle3 :: proc(v: Vector3f32, c0, c1, c2: Vector3_Components) -> Vector3f32 { return {v[c0], v[c1], v[c2]} } +@(require_results) vector3f32_swizzle4 :: proc(v: Vector3f32, c0, c1, c2, c3: Vector3_Components) -> Vector4f32 { return {v[c0], v[c1], v[c2], v[c3]} } +@(require_results) vector4f32_swizzle1 :: proc(v: Vector4f32, c0: Vector4_Components) -> f32 { return v[c0] } +@(require_results) vector4f32_swizzle2 :: proc(v: Vector4f32, c0, c1: Vector4_Components) -> Vector2f32 { return {v[c0], v[c1]} } +@(require_results) vector4f32_swizzle3 :: proc(v: Vector4f32, c0, c1, c2: Vector4_Components) -> Vector3f32 { return {v[c0], v[c1], v[c2]} } +@(require_results) vector4f32_swizzle4 :: proc(v: Vector4f32, c0, c1, c2, c3: Vector4_Components) -> Vector4f32 { return {v[c0], v[c1], v[c2], v[c3]} } +@(require_results) scalar_f64_swizzle1 :: proc(f: f64, c0: Scalar_Components) -> f64 { return f } +@(require_results) scalar_f64_swizzle2 :: proc(f: f64, c0, c1: Scalar_Components) -> Vector2f64 { return {f, f} } +@(require_results) scalar_f64_swizzle3 :: proc(f: f64, c0, c1, c2: Scalar_Components) -> Vector3f64 { return {f, f, f} } +@(require_results) scalar_f64_swizzle4 :: proc(f: f64, c0, c1, c2, c3: Scalar_Components) -> Vector4f64 { return {f, f, f, f} } +@(require_results) vector2f64_swizzle1 :: proc(v: Vector2f64, c0: Vector2_Components) -> f64 { return v[c0] } +@(require_results) vector2f64_swizzle2 :: proc(v: Vector2f64, c0, c1: Vector2_Components) -> Vector2f64 { return {v[c0], v[c1]} } +@(require_results) vector2f64_swizzle3 :: proc(v: Vector2f64, c0, c1, c2: Vector2_Components) -> Vector3f64 { return {v[c0], v[c1], v[c2]} } +@(require_results) vector2f64_swizzle4 :: proc(v: Vector2f64, c0, c1, c2, c3: Vector2_Components) -> Vector4f64 { return {v[c0], v[c1], v[c2], v[c3]} } +@(require_results) vector3f64_swizzle1 :: proc(v: Vector3f64, c0: Vector3_Components) -> f64 { return v[c0] } +@(require_results) vector3f64_swizzle2 :: proc(v: Vector3f64, c0, c1: Vector3_Components) -> Vector2f64 { return {v[c0], v[c1]} } +@(require_results) vector3f64_swizzle3 :: proc(v: Vector3f64, c0, c1, c2: Vector3_Components) -> Vector3f64 { return {v[c0], v[c1], v[c2]} } +@(require_results) vector3f64_swizzle4 :: proc(v: Vector3f64, c0, c1, c2, c3: Vector3_Components) -> Vector4f64 { return {v[c0], v[c1], v[c2], v[c3]} } +@(require_results) vector4f64_swizzle1 :: proc(v: Vector4f64, c0: Vector4_Components) -> f64 { return v[c0] } +@(require_results) vector4f64_swizzle2 :: proc(v: Vector4f64, c0, c1: Vector4_Components) -> Vector2f64 { return {v[c0], v[c1]} } +@(require_results) vector4f64_swizzle3 :: proc(v: Vector4f64, c0, c1, c2: Vector4_Components) -> Vector3f64 { return {v[c0], v[c1], v[c2]} } +@(require_results) vector4f64_swizzle4 :: proc(v: Vector4f64, c0, c1, c2, c3: Vector4_Components) -> Vector4f64 { return {v[c0], v[c1], v[c2], v[c3]} }