Blender V5.3
BLI_math_euler_types.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#pragma once
6
28
29#include <ostream>
30
32#include "BLI_math_base.hh"
34
35namespace blender::math {
36
37/* WARNING: must match the #eRotationModes in `DNA_action_types.h`
38 * order matters - types are saved to file. */
47
48std::ostream &operator<<(std::ostream &stream, EulerOrder order);
49
50/* -------------------------------------------------------------------- */
53
54template<typename T> struct EulerBase {
56
57 protected:
63
64 EulerBase() = default;
65
66 EulerBase(const AngleT &x, const AngleT &y, const AngleT &z) : xyz_(x, y, z) {};
67
68 EulerBase(const VecBase<AngleT, 3> &vec) : xyz_(vec) {};
69
70 EulerBase(const VecBase<T, 3> &vec) : xyz_(vec.x, vec.y, vec.z) {};
71
72 public:
74
76
77 explicit operator VecBase<AngleT, 3>() const
78 {
79 return this->xyz_;
80 }
81
82 explicit operator VecBase<T, 3>() const
83 {
84 return {T(x()), T(y()), T(z())};
85 }
86
88
90 {
91 return this->xyz_;
92 }
93 const VecBase<AngleT, 3> &xyz() const
94 {
95 return this->xyz_;
96 }
97
98 const AngleT &x() const
99 {
100 return this->xyz_.x;
101 }
102
103 const AngleT &y() const
104 {
105 return this->xyz_.y;
106 }
107
108 const AngleT &z() const
109 {
110 return this->xyz_.z;
111 }
112
114 {
115 return this->xyz_.x;
116 }
117
119 {
120 return this->xyz_.y;
121 }
122
124 {
125 return this->xyz_.z;
126 }
127};
128
130
131/* -------------------------------------------------------------------- */
134
135template<typename T> struct EulerXYZBase : public EulerBase<T> {
137
138 public:
139 EulerXYZBase() = default;
140
144 template<typename AngleU> EulerXYZBase(const VecBase<AngleU, 3> &vec) : EulerBase<T>(vec) {};
145
146 EulerXYZBase(const AngleT &x, const AngleT &y, const AngleT &z) : EulerBase<T>(x, y, z) {};
147
152 EulerXYZBase(const Axis axis, const AngleT &angle)
153 {
154 *this = identity();
155 this->xyz_[axis] = angle;
156 }
157
159
166
168
173
180 EulerXYZBase wrapped_around(const EulerXYZBase &reference) const;
181
183
185 {
186 return {-a.xyz_.x, -a.xyz_.y, -a.xyz_.z};
187 }
188
189 friend bool operator==(const EulerXYZBase &a, const EulerXYZBase &b) = default;
190
191 friend std::ostream &operator<<(std::ostream &stream, const EulerXYZBase &rot)
192 {
193 return stream << "EulerXYZ" << static_cast<VecBase<T, 3>>(rot);
194 }
195};
196
198
199/* -------------------------------------------------------------------- */
202
203template<typename T> struct Euler3Base : public EulerBase<T> {
205
206 private:
208 EulerOrder order_;
209
213 class Swizzle {
214 private:
215 Euler3Base &eul_;
216
217 public:
218 explicit Swizzle(Euler3Base &eul) : eul_(eul) {};
219
221 {
222 eul_.xyz_.x = angles[eul_.i_index()];
223 eul_.xyz_.y = angles[eul_.j_index()];
224 eul_.xyz_.z = angles[eul_.k_index()];
225 return eul_;
226 }
227
228 operator VecBase<AngleT, 3>() const
229 {
230 return {eul_.i(), eul_.j(), eul_.k()};
231 }
232
233 explicit operator VecBase<T, 3>() const
234 {
235 return {T(eul_.i()), T(eul_.j()), T(eul_.k())};
236 }
237 };
238
239 public:
240 Euler3Base() = delete;
241
247 template<typename AngleU>
249 : EulerBase<T>(angles_xyz), order_(order) {};
250
251 Euler3Base(const AngleT &x, const AngleT &y, const AngleT &z, EulerOrder order)
252 : EulerBase<T>(x, y, z), order_(order) {};
253
258 {
259 this->xyz_[axis] = angle;
260 }
261
267
269
270 const EulerOrder &order() const
271 {
272 return order_;
273 }
274
279 Swizzle ijk()
280 {
281 return Swizzle{*this};
282 }
284 {
285 return {i(), j(), k()};
286 }
287
292 const AngleT &i() const
293 {
294 return this->xyz_[i_index()];
295 }
296 const AngleT &j() const
297 {
298 return this->xyz_[j_index()];
299 }
300 const AngleT &k() const
301 {
302 return this->xyz_[k_index()];
303 }
305 {
306 return this->xyz_[i_index()];
307 }
309 {
310 return this->xyz_[j_index()];
311 }
313 {
314 return this->xyz_[k_index()];
315 }
316
323 Euler3Base wrapped_around(const Euler3Base &reference) const
324 {
325 return {VecBase<AngleT, 3>(EulerXYZBase<T>(this->xyz_).wrapped_around(reference.xyz_)),
326 order_};
327 }
328
330
332 {
333 return {-a.xyz_, a.order_};
334 }
335
336 friend bool operator==(const Euler3Base &a, const Euler3Base &b) = default;
337
338 friend std::ostream &operator<<(std::ostream &stream, const Euler3Base &rot)
339 {
340 return stream << "Euler3_" << rot.order_ << rot.xyz_;
341 }
342
343 /* Utilities for conversions and functions operating on Euler3.
344 * This should be private in theory. */
345
351 bool parity() const
352 {
353 switch (order_) {
354 default:
356 return false;
357 case XYZ:
358 case ZXY:
359 case YZX:
360 return false;
361 case XZY:
362 case YXZ:
363 case ZYX:
364 return true;
365 }
366 }
367
371 int i_index() const
372 {
373 switch (order_) {
374 default:
376 return 0;
377 case XYZ:
378 case XZY:
379 return 0;
380 case YXZ:
381 case YZX:
382 return 1;
383 case ZXY:
384 case ZYX:
385 return 2;
386 }
387 }
388
392 int j_index() const
393 {
394 switch (order_) {
395 default:
397 return 0;
398 case YXZ:
399 case ZXY:
400 return 0;
401 case XYZ:
402 case ZYX:
403 return 1;
404 case XZY:
405 case YZX:
406 return 2;
407 }
408 }
409
413 int k_index() const
414 {
415 switch (order_) {
416 default:
418 return 0;
419 case YZX:
420 case ZYX:
421 return 0;
422 case XZY:
423 case ZXY:
424 return 1;
425 case XYZ:
426 case YXZ:
427 return 2;
428 }
429 }
430};
431
433
436
437} // namespace blender::math
#define BLI_assert_unreachable()
btGeneric6DofConstraint & operator=(btGeneric6DofConstraint &other)
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
Definition btVector3.h:356
#define rot(x, k)
#define T
std::ostream & operator<<(std::ostream &stream, const AssetCatalogPath &path_to_append)
EulerXYZBase< float > EulerXYZ
Euler3Base< float > Euler3
VecBase()=default
static AngleRadianBase identity()
Euler3Base(const AngleT &x, const AngleT &y, const AngleT &z, EulerOrder order)
Euler3Base wrapped_around(const Euler3Base &reference) const
friend bool operator==(const Euler3Base &a, const Euler3Base &b)=default
Euler3Base(const Axis axis, AngleT angle, EulerOrder order)
friend std::ostream & operator<<(std::ostream &stream, const Euler3Base &rot)
friend Euler3Base operator-(const Euler3Base &a)
Euler3Base(const VecBase< AngleU, 3 > &angles_xyz, EulerOrder order)
VecBase< AngleT, 3 > ijk() const
VecBase< AngleT, 3 > & xyz()
const VecBase< AngleT, 3 > & xyz() const
EulerBase(const VecBase< T, 3 > &vec)
EulerBase(const VecBase< AngleT, 3 > &vec)
EulerBase(const AngleT &x, const AngleT &y, const AngleT &z)
EulerXYZBase wrapped() const
EulerXYZBase(const AngleT &x, const AngleT &y, const AngleT &z)
EulerXYZBase wrapped_around(const EulerXYZBase &reference) const
EulerXYZBase(const Axis axis, const AngleT &angle)
friend std::ostream & operator<<(std::ostream &stream, const EulerXYZBase &rot)
friend EulerXYZBase operator-(const EulerXYZBase &a)
EulerXYZBase(const VecBase< AngleU, 3 > &vec)
friend bool operator==(const EulerXYZBase &a, const EulerXYZBase &b)=default