1use super::math_utils::clamp;
10use super::{Matrix4, Quaternion, Vector3};
11
12#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
18pub enum EulerOrder {
19 #[default]
21 XYZ,
22 YXZ,
24 ZXY,
26 ZYX,
28 YZX,
30 XZY,
32}
33
34#[derive(Clone, Copy, Debug, Default, PartialEq)]
38pub struct Euler {
39 pub x: f64,
41 pub y: f64,
43 pub z: f64,
45 pub order: EulerOrder,
47}
48
49impl Euler {
50 pub fn new(x: f64, y: f64, z: f64) -> Self {
52 Self {
53 x,
54 y,
55 z,
56 order: EulerOrder::XYZ,
57 }
58 }
59
60 pub fn new_with_order(x: f64, y: f64, z: f64, order: EulerOrder) -> Self {
62 Self { x, y, z, order }
63 }
64
65 pub fn set(&mut self, x: f64, y: f64, z: f64) -> &mut Self {
67 self.x = x;
68 self.y = y;
69 self.z = z;
70 self
71 }
72
73 pub fn set_with_order(&mut self, x: f64, y: f64, z: f64, order: EulerOrder) -> &mut Self {
75 self.x = x;
76 self.y = y;
77 self.z = z;
78 self.order = order;
79 self
80 }
81
82 pub fn copy(&mut self, euler: &Self) -> &mut Self {
84 *self = *euler;
85 self
86 }
87
88 pub fn set_from_rotation_matrix(&mut self, m: &Matrix4, order: EulerOrder) -> &mut Self {
91 let te = &m.elements;
92 let (m11, m12, m13) = (te[0], te[4], te[8]);
93 let (m21, m22, m23) = (te[1], te[5], te[9]);
94 let (m31, m32, m33) = (te[2], te[6], te[10]);
95
96 match order {
97 EulerOrder::XYZ => {
98 self.y = clamp(m13, -1.0, 1.0).asin();
99
100 if m13.abs() < 0.9999999 {
101 self.x = (-m23).atan2(m33);
102 self.z = (-m12).atan2(m11);
103 } else {
104 self.x = m32.atan2(m22);
105 self.z = 0.0;
106 }
107 }
108 EulerOrder::YXZ => {
109 self.x = (-clamp(m23, -1.0, 1.0)).asin();
110
111 if m23.abs() < 0.9999999 {
112 self.y = m13.atan2(m33);
113 self.z = m21.atan2(m22);
114 } else {
115 self.y = (-m31).atan2(m11);
116 self.z = 0.0;
117 }
118 }
119 EulerOrder::ZXY => {
120 self.x = clamp(m32, -1.0, 1.0).asin();
121
122 if m32.abs() < 0.9999999 {
123 self.y = (-m31).atan2(m33);
124 self.z = (-m12).atan2(m22);
125 } else {
126 self.y = 0.0;
127 self.z = m21.atan2(m11);
128 }
129 }
130 EulerOrder::ZYX => {
131 self.y = (-clamp(m31, -1.0, 1.0)).asin();
132
133 if m31.abs() < 0.9999999 {
134 self.x = m32.atan2(m33);
135 self.z = m21.atan2(m11);
136 } else {
137 self.x = 0.0;
138 self.z = (-m12).atan2(m22);
139 }
140 }
141 EulerOrder::YZX => {
142 self.z = clamp(m21, -1.0, 1.0).asin();
143
144 if m21.abs() < 0.9999999 {
145 self.x = (-m23).atan2(m22);
146 self.y = (-m31).atan2(m11);
147 } else {
148 self.x = 0.0;
149 self.y = m13.atan2(m33);
150 }
151 }
152 EulerOrder::XZY => {
153 self.z = (-clamp(m12, -1.0, 1.0)).asin();
154
155 if m12.abs() < 0.9999999 {
156 self.x = m32.atan2(m22);
157 self.y = m13.atan2(m11);
158 } else {
159 self.x = (-m23).atan2(m33);
160 self.y = 0.0;
161 }
162 }
163 }
164
165 self.order = order;
166
167 self
168 }
169
170 pub fn set_from_quaternion(&mut self, q: &Quaternion, order: EulerOrder) -> &mut Self {
172 let mut matrix = Matrix4::identity();
173 matrix.make_rotation_from_quaternion(q);
174 self.set_from_rotation_matrix(&matrix, order)
175 }
176
177 pub fn set_from_vector3(&mut self, v: &Vector3) -> &mut Self {
179 self.set(v.x, v.y, v.z)
180 }
181
182 pub fn reorder(&mut self, new_order: EulerOrder) -> &mut Self {
185 let mut q = Quaternion::default();
186 q.set_from_euler(self);
187 self.set_from_quaternion(&q, new_order)
188 }
189
190 pub fn equals(&self, euler: &Self) -> bool {
192 euler.x == self.x && euler.y == self.y && euler.z == self.z && euler.order == self.order
193 }
194
195 pub fn from_array(&mut self, array: &[f64]) -> &mut Self {
198 self.x = array[0];
199 self.y = array[1];
200 self.z = array[2];
201 self
202 }
203
204 pub fn to_array(&self) -> [f64; 3] {
206 [self.x, self.y, self.z]
207 }
208}