Blender V5.3
mathutils_Euler.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <algorithm>
10
11#include <Python.h>
12
13#include "mathutils.hh"
14
16#include "BLI_math_matrix_c.hh"
18#include "BLI_math_vector_c.hh"
19#include "BLI_utildefines.hh"
20
21#ifndef MATH_STANDALONE
22# include "BLI_dynstr.hh"
23#endif
24
25namespace blender {
26
27#define EULER_SIZE 3
28
29/* -------------------------------------------------------------------- */
32
34static const char *euler_order_str(EulerObject *self)
35{
36 static const char order[][4] = {"XYZ", "XZY", "YXZ", "YZX", "ZXY", "ZYX"};
37 return order[self->order - EULER_ORDER_XYZ];
38}
39
40short euler_order_from_string(const char *str, const char *error_prefix)
41{
42 if (str[0] && str[1] && str[2] && str[3] == '\0') {
43
44/* NOTE: this is endianness-sensitive. */
45#define MAKE_ID3(a, b, c) ((a) | ((b) << 8) | ((c) << 16))
46
47 switch (*(reinterpret_cast<const int32_t *>(str))) {
48 case MAKE_ID3('X', 'Y', 'Z'): {
49 return EULER_ORDER_XYZ;
50 }
51 case MAKE_ID3('X', 'Z', 'Y'): {
52 return EULER_ORDER_XZY;
53 }
54 case MAKE_ID3('Y', 'X', 'Z'): {
55 return EULER_ORDER_YXZ;
56 }
57 case MAKE_ID3('Y', 'Z', 'X'): {
58 return EULER_ORDER_YZX;
59 }
60 case MAKE_ID3('Z', 'X', 'Y'): {
61 return EULER_ORDER_ZXY;
62 }
63 case MAKE_ID3('Z', 'Y', 'X'): {
64 return EULER_ORDER_ZYX;
65 }
66 }
67
68#undef MAKE_ID3
69 }
70
71 PyErr_Format(PyExc_ValueError, "%s: invalid euler order '%s'", error_prefix, str);
72 return -1;
73}
74
78static PyObject *Euler_to_tuple_ex(EulerObject *self, int ndigits)
79{
80 PyObject *ret;
81 int i;
82
83 ret = PyTuple_New(EULER_SIZE);
84
85 if (ndigits >= 0) {
86 for (i = 0; i < EULER_SIZE; i++) {
87 PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(double_round(double(self->eul[i]), ndigits)));
88 }
89 }
90 else {
91 for (i = 0; i < EULER_SIZE; i++) {
92 PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(self->eul[i]));
93 }
94 }
95
96 return ret;
97}
98
100
101/* -------------------------------------------------------------------- */
104
105static PyObject *Euler_vectorcall(PyObject *type,
106 PyObject *const *args,
107 const size_t nargsf,
108 PyObject *kwnames)
109{
110 if (kwnames && PyTuple_GET_SIZE(kwnames)) [[unlikely]] {
111 PyErr_SetString(PyExc_TypeError,
112 "mathutils.Euler(): "
113 "takes no keyword args");
114 return nullptr;
115 }
116
117 float eul[EULER_SIZE] = {0.0f, 0.0f, 0.0f};
118 short order = EULER_ORDER_XYZ;
119
120 const size_t nargs = PyVectorcall_NARGS(nargsf);
121 switch (nargs) {
122 case 0: {
123 break;
124 }
125 case 2: {
126 const char *order_str;
127
128 if (((order_str = PyUnicode_AsUTF8(args[1])) == nullptr) ||
129 ((order = euler_order_from_string(order_str, "mathutils.Euler()")) == -1))
130 {
131 return nullptr;
132 }
134 }
135 case 1: {
136 if (mathutils_array_parse(eul, EULER_SIZE, EULER_SIZE, args[0], "mathutils.Euler()") == -1) {
137 return nullptr;
138 }
139 break;
140 }
141 default: {
142 PyErr_Format(PyExc_TypeError,
143 "mathutils.Euler(): "
144 "takes at most 2 arguments (%zd given)",
145 nargs);
146 return nullptr;
147 }
148 }
149 return Euler_CreatePyObject(eul, order, reinterpret_cast<PyTypeObject *>(type));
150}
151
152static PyObject *Euler_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
153{
154 /* Only called on sub-classes. */
155 if (kwds && PyDict_GET_SIZE(kwds)) [[unlikely]] {
156 PyErr_SetString(PyExc_TypeError,
157 "mathutils.Euler(): "
158 "takes no keyword args");
159 return nullptr;
160 }
161 PyObject *const *args_array = &PyTuple_GET_ITEM(args, 0);
162 const size_t args_array_num = PyTuple_GET_SIZE(args);
163 return Euler_vectorcall(reinterpret_cast<PyObject *>(type), args_array, args_array_num, nullptr);
164}
165
167
168/* -------------------------------------------------------------------- */
171
173 /* Wrap. */
174 Euler_to_quaternion_doc,
175 ".. method:: to_quaternion()\n"
176 "\n"
177 " Return a quaternion representation of the euler.\n"
178 "\n"
179 " :return: Quaternion representation of the euler.\n"
180 " :rtype: :class:`Quaternion`\n");
181static PyObject *Euler_to_quaternion(EulerObject *self)
182{
183 float quat[4];
184
185 if (BaseMath_ReadCallback(self) == -1) {
186 return nullptr;
187 }
188
189 eulO_to_quat(quat, self->eul, self->order);
190
191 return Quaternion_CreatePyObject(quat, nullptr);
192}
193
195 /* Wrap. */
196 Euler_to_matrix_doc,
197 ".. method:: to_matrix()\n"
198 "\n"
199 " Return a matrix representation of the euler.\n"
200 "\n"
201 " :return: A 3x3 rotation matrix representation of the euler.\n"
202 " :rtype: :class:`Matrix`\n");
203static PyObject *Euler_to_matrix(EulerObject *self)
204{
205 float mat[9];
206
207 if (BaseMath_ReadCallback(self) == -1) {
208 return nullptr;
209 }
210
211 eulO_to_mat3(reinterpret_cast<float (*)[3]>(mat), self->eul, self->order);
212
213 return Matrix_CreatePyObject(mat, 3, 3, nullptr);
214}
215
217 /* Wrap. */
218 Euler_zero_doc,
219 ".. method:: zero()\n"
220 "\n"
221 " Set all values to zero.\n");
222static PyObject *Euler_zero(EulerObject *self)
223{
224 if (BaseMath_Prepare_ForWrite(self) == -1) {
225 return nullptr;
226 }
227
228 zero_v3(self->eul);
229
230 if (BaseMath_WriteCallback(self) == -1) {
231 return nullptr;
232 }
233
234 Py_RETURN_NONE;
235}
236
238 /* Wrap. */
239 Euler_rotate_axis_doc,
240 ".. method:: rotate_axis(axis, angle, /)\n"
241 "\n"
242 " Rotates the euler a certain amount, wrapping the result to produce\n"
243 " a unique euler rotation (no 720 degree pitches).\n"
244 "\n"
245 " :param axis: An axis string.\n"
246 " :type axis: Literal['X', 'Y', 'Z']\n"
247 " :param angle: angle in radians.\n"
248 " :type angle: float\n");
249static PyObject *Euler_rotate_axis(EulerObject *self, PyObject *args)
250{
251 float angle = 0.0f;
252 int axis; /* actually a character */
253
254 if (!PyArg_ParseTuple(args,
255 "C" /* `axis` */
256 "f" /* `angle` */
257 ":rotate_axis",
258 &axis,
259 &angle))
260 {
261 PyErr_SetString(PyExc_TypeError,
262 "Euler.rotate_axis(): "
263 "expected an axis 'X', 'Y', 'Z' and an angle (float)");
264 return nullptr;
265 }
266
267 if (!ELEM(axis, 'X', 'Y', 'Z')) {
268 PyErr_SetString(PyExc_ValueError,
269 "Euler.rotate_axis(): "
270 "expected axis to be 'X', 'Y' or 'Z'");
271 return nullptr;
272 }
273
274 if (BaseMath_ReadCallback_ForWrite(self) == -1) {
275 return nullptr;
276 }
277
278 rotate_eulO(self->eul, self->order, char(axis), angle);
279
280 (void)BaseMath_WriteCallback(self);
281
282 Py_RETURN_NONE;
283}
284
286 /* Wrap. */
287 Euler_rotate_doc,
288 ".. method:: rotate(other, /)\n"
289 "\n"
290 " Rotates the euler by another mathutils value.\n"
291 "\n"
292 " :param other: rotation component of mathutils value\n"
293 " :type other: :class:`Euler` | :class:`Quaternion` | :class:`Matrix`\n");
294static PyObject *Euler_rotate(EulerObject *self, PyObject *value)
295{
296 float self_rmat[3][3], other_rmat[3][3], rmat[3][3];
297
298 if (BaseMath_ReadCallback_ForWrite(self) == -1) {
299 return nullptr;
300 }
301
302 if (mathutils_any_to_rotmat(other_rmat, value, "euler.rotate(value)") == -1) {
303 return nullptr;
304 }
305
306 eulO_to_mat3(self_rmat, self->eul, self->order);
307 mul_m3_m3m3(rmat, other_rmat, self_rmat);
308
309 mat3_to_compatible_eulO(self->eul, self->eul, self->order, rmat);
310
311 (void)BaseMath_WriteCallback(self);
312 Py_RETURN_NONE;
313}
314
316 /* Wrap. */
317 Euler_make_compatible_doc,
318 ".. method:: make_compatible(other, /)\n"
319 "\n"
320 " Make this euler compatible with another,\n"
321 " so interpolating between them works as intended.\n"
322 "\n"
323 " :param other: Other euler rotation.\n"
324 " :type other: :class:`Euler`\n"
325 "\n"
326 " .. note:: the rotation order is not taken into account for this function.\n");
327static PyObject *Euler_make_compatible(EulerObject *self, PyObject *value)
328{
329 float teul[EULER_SIZE];
330
331 if (BaseMath_ReadCallback_ForWrite(self) == -1) {
332 return nullptr;
333 }
334
335 if (mathutils_array_parse(teul,
338 value,
339 "euler.make_compatible(other), invalid 'other' arg") == -1)
340 {
341 return nullptr;
342 }
343
344 compatible_eul(self->eul, teul);
345
346 (void)BaseMath_WriteCallback(self);
347
348 Py_RETURN_NONE;
349}
350
352 /* Wrap. */
353 Euler_copy_doc,
354 ".. method:: copy()\n"
355 "\n"
356 " Returns a copy of this euler.\n"
357 "\n"
358 " :return: A copy of the euler.\n"
359 " :rtype: :class:`Euler`\n"
360 "\n"
361 " .. note:: use this to get a copy of a wrapped euler with\n"
362 " no reference to the original data.\n");
363static PyObject *Euler_copy(EulerObject *self)
364{
365 if (BaseMath_ReadCallback(self) == -1) {
366 return nullptr;
367 }
368
369 return Euler_CreatePyObject(self->eul, self->order, Py_TYPE(self));
370}
371static PyObject *Euler_deepcopy(EulerObject *self, PyObject *args)
372{
373 if (!PyC_CheckArgs_DeepCopy(args)) {
374 return nullptr;
375 }
376 return Euler_copy(self);
377}
378
380
381/* -------------------------------------------------------------------- */
384
385static PyObject *Euler_repr(EulerObject *self)
386{
387 PyObject *ret, *tuple;
388
389 if (BaseMath_ReadCallback(self) == -1) {
390 return nullptr;
391 }
392
393 tuple = Euler_to_tuple_ex(self, -1);
394
395 ret = PyUnicode_FromFormat("Euler(%R, '%s')", tuple, euler_order_str(self));
396
397 Py_DECREF(tuple);
398 return ret;
399}
400
401#ifndef MATH_STANDALONE
402static PyObject *Euler_str(EulerObject *self)
403{
404 DynStr *ds;
405
406 if (BaseMath_ReadCallback(self) == -1) {
407 return nullptr;
408 }
409
410 ds = BLI_dynstr_new();
411
413 "<Euler (x=%.4f, y=%.4f, z=%.4f), order='%s'>",
414 self->eul[0],
415 self->eul[1],
416 self->eul[2],
417 euler_order_str(self));
418
419 return mathutils_dynstr_to_py(ds); /* frees ds */
420}
421#endif
422
424
425/* -------------------------------------------------------------------- */
428
429static int Euler_getbuffer(PyObject *obj, Py_buffer *view, int flags)
430{
431 EulerObject *self = reinterpret_cast<EulerObject *>(obj);
432 if (BaseMath_Prepare_ForBufferAccess(self, view, flags) == -1) [[unlikely]] {
433 return -1;
434 }
435 if (BaseMath_ReadCallback(self) == -1) [[unlikely]] {
436 return -1;
437 }
438
439 memset(view, 0, sizeof(*view));
440
441 view->obj = reinterpret_cast<PyObject *>(self);
442 view->buf = static_cast<void *>(self->eul);
443 view->len = Py_ssize_t(EULER_SIZE * sizeof(float));
444 view->itemsize = sizeof(float);
445 view->ndim = 1;
446 if ((flags & PyBUF_WRITABLE) == 0) {
447 view->readonly = 1;
448 }
449 if (flags & PyBUF_FORMAT) {
450 view->format = const_cast<char *>("f");
451 }
452
453 self->flag |= BASE_MATH_FLAG_HAS_BUFFER_VIEW;
454
455 Py_INCREF(self);
456 return 0;
457}
458
459static void Euler_releasebuffer(PyObject * /*exporter*/, Py_buffer *view)
460{
461 EulerObject *self = reinterpret_cast<EulerObject *>(view->obj);
463
464 if (view->readonly == 0) {
465 if (BaseMath_WriteCallback(self) == -1) [[unlikely]] {
466 PyErr_Print();
467 }
468 }
469}
470
471static PyBufferProcs Euler_as_buffer = {
472 static_cast<getbufferproc>(Euler_getbuffer),
473 static_cast<releasebufferproc>(Euler_releasebuffer),
474};
475
477
478/* -------------------------------------------------------------------- */
481
482static PyObject *Euler_richcmpr(PyObject *a, PyObject *b, int op)
483{
484 PyObject *res;
485 int ok = -1; /* zero is true */
486
488 EulerObject *eulA = reinterpret_cast<EulerObject *>(a);
489 EulerObject *eulB = reinterpret_cast<EulerObject *>(b);
490
491 if (BaseMath_ReadCallback(eulA) == -1 || BaseMath_ReadCallback(eulB) == -1) {
492 return nullptr;
493 }
494
495 ok = ((eulA->order == eulB->order) &&
496 EXPP_VectorsAreEqual(eulA->eul, eulB->eul, EULER_SIZE, 1)) ?
497 0 :
498 -1;
499 }
500
501 switch (op) {
502 case Py_NE: {
503 ok = !ok;
505 }
506 case Py_EQ: {
507 res = ok ? Py_False : Py_True;
508 break;
509 }
510 case Py_LT:
511 case Py_LE:
512 case Py_GT:
513 case Py_GE: {
514 res = Py_NotImplemented;
515 break;
516 }
517 default: {
518 PyErr_BadArgument();
519 return nullptr;
520 }
521 }
522
523 return Py_NewRef(res);
524}
525
527
528/* -------------------------------------------------------------------- */
531
532static Py_hash_t Euler_hash(EulerObject *self)
533{
534 if (BaseMath_ReadCallback(self) == -1) {
535 return -1;
536 }
537
538 if (BaseMathObject_Prepare_ForHash(self) == -1) {
539 return -1;
540 }
541
542 return mathutils_array_hash(self->eul, EULER_SIZE);
543}
544
546
547/* -------------------------------------------------------------------- */
550
552static Py_ssize_t Euler_len(EulerObject * /*self*/)
553{
554 return EULER_SIZE;
555}
556
558static PyObject *Euler_item(EulerObject *self, Py_ssize_t i)
559{
560 if (i < 0 || i >= EULER_SIZE) {
561 PyErr_SetString(PyExc_IndexError,
562 "euler[attribute]: "
563 "array index out of range");
564 return nullptr;
565 }
566
567 if (BaseMath_ReadIndexCallback(self, i) == -1) {
568 return nullptr;
569 }
570
571 return PyFloat_FromDouble(self->eul[i]);
572}
573
575static int Euler_ass_item(EulerObject *self, Py_ssize_t i, PyObject *value)
576{
577 float f;
578
579 if (BaseMath_Prepare_ForWrite(self) == -1) {
580 return -1;
581 }
582
583 f = PyFloat_AsDouble(value);
584 if (f == -1 && PyErr_Occurred()) { /* parsed item not a number */
585 PyErr_SetString(PyExc_TypeError,
586 "euler[attribute] = x: "
587 "assigned value not a number");
588 return -1;
589 }
590
591 if (i < 0 || i >= EULER_SIZE) {
592 PyErr_SetString(PyExc_IndexError,
593 "euler[attribute] = x: "
594 "array assignment index out of range");
595 return -1;
596 }
597
598 self->eul[i] = f;
599
600 if (BaseMath_WriteIndexCallback(self, i) == -1) {
601 return -1;
602 }
603
604 return 0;
605}
606
608static PyObject *Euler_slice(EulerObject *self,
609 Py_ssize_t start,
610 Py_ssize_t step,
611 Py_ssize_t slice_length)
612{
613 if (BaseMath_ReadCallback(self) == -1) {
614 return nullptr;
615 }
616
617 PyObject *tuple = PyTuple_New(slice_length);
618 Py_ssize_t index = start;
619 for (Py_ssize_t i = 0; i < slice_length; i++, index += step) {
620 BLI_assert(index >= 0 && index < EULER_SIZE);
621 PyTuple_SET_ITEM(tuple, i, PyFloat_FromDouble(self->eul[index]));
622 }
623 return tuple;
624}
625
632 EulerObject *self, Py_ssize_t start, Py_ssize_t step, Py_ssize_t slice_length, PyObject *seq)
633{
634 float eul[EULER_SIZE];
635
636 /* Subset writes merge into existing values, so sync the source first. */
637 if (mathutils_slice_is_subset(start, step, slice_length, EULER_SIZE)) {
638 if (BaseMath_ReadCallback_ForWrite(self) == -1) {
639 return -1;
640 }
641 }
642 else {
643 if (BaseMath_Prepare_ForWrite(self) == -1) {
644 return -1;
645 }
646 }
647
649 eul, slice_length, slice_length, seq, "mathutils.Euler[slice] = seq") == -1)
650 {
651 return -1;
652 }
653
654 Py_ssize_t index = start;
655 for (Py_ssize_t i = 0; i < slice_length; i++, index += step) {
656 BLI_assert(index >= 0 && index < EULER_SIZE);
657 self->eul[index] = eul[i];
658 }
659
660 (void)BaseMath_WriteCallback(self);
661 return 0;
662}
663
665static PyObject *Euler_subscript(EulerObject *self, PyObject *item)
666{
667 if (PyIndex_Check(item)) {
668 Py_ssize_t i;
669 i = PyNumber_AsSsize_t(item, PyExc_IndexError);
670 if (i == -1 && PyErr_Occurred()) {
671 return nullptr;
672 }
673 if (i < 0) {
674 i += EULER_SIZE;
675 }
676 return Euler_item(self, i);
677 }
678 if (PySlice_Check(item)) {
679 Py_ssize_t start, stop, step, slice_length;
680
681 if (PySlice_GetIndicesEx(item, EULER_SIZE, &start, &stop, &step, &slice_length) < 0) {
682 return nullptr;
683 }
684
685 return Euler_slice(self, start, step, slice_length);
686 }
687
688 PyErr_Format(
689 PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
690 return nullptr;
691}
692
694static int Euler_ass_subscript(EulerObject *self, PyObject *item, PyObject *value)
695{
696 if (PyIndex_Check(item)) {
697 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
698 if (i == -1 && PyErr_Occurred()) {
699 return -1;
700 }
701 if (i < 0) {
702 i += EULER_SIZE;
703 }
704 return Euler_ass_item(self, i, value);
705 }
706 if (PySlice_Check(item)) {
707 Py_ssize_t start, stop, step, slice_length;
708
709 if (PySlice_GetIndicesEx(item, EULER_SIZE, &start, &stop, &step, &slice_length) < 0) {
710 return -1;
711 }
712
713 return Euler_ass_slice(self, start, step, slice_length, value);
714 }
715
716 PyErr_Format(
717 PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
718 return -1;
719}
720
722
723/* -------------------------------------------------------------------- */
726
727static PySequenceMethods Euler_SeqMethods = {
728 /*sq_length*/ reinterpret_cast<lenfunc>(Euler_len),
729 /*sq_concat*/ nullptr,
730 /*sq_repeat*/ nullptr,
731 /*sq_item*/ reinterpret_cast<ssizeargfunc>(Euler_item),
732 /*was_sq_slice*/ nullptr, /* DEPRECATED. */
733 /*sq_ass_item*/ reinterpret_cast<ssizeobjargproc>(Euler_ass_item),
734 /*was_sq_ass_slice*/ nullptr, /* DEPRECATED. */
735 /*sq_contains*/ nullptr,
736 /*sq_inplace_concat*/ nullptr,
737 /*sq_inplace_repeat*/ nullptr,
738};
739
740static PyMappingMethods Euler_AsMapping = {
741 /*mp_length*/ reinterpret_cast<lenfunc>(Euler_len),
742 /*mp_subscript*/ reinterpret_cast<binaryfunc>(Euler_subscript),
743 /*mp_ass_subscript*/ reinterpret_cast<objobjargproc>(Euler_ass_subscript),
744};
745
747
748/* -------------------------------------------------------------------- */
751
752/* Euler axis: `euler.x/y/z`. */
753
755 /* Wrap. */
756 Euler_axis_doc,
757 "Euler axis angle in radians.\n"
758 "\n"
759 ":type: float\n");
760static PyObject *Euler_axis_get(EulerObject *self, void *type)
761{
762 return Euler_item(self, POINTER_AS_INT(type));
763}
764
765static int Euler_axis_set(EulerObject *self, PyObject *value, void *type)
766{
767 return Euler_ass_item(self, POINTER_AS_INT(type), value);
768}
769
770/* Euler rotation order: `euler.order`. */
771
773 /* Wrap. */
774 Euler_order_doc,
775 "Euler rotation order.\n"
776 "\n"
777 ":type: Literal['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX']\n");
778static PyObject *Euler_order_get(EulerObject *self, void * /*closure*/)
779{
780 if (BaseMath_ReadCallback(self) == -1) {
781 /* can read order too */
782 return nullptr;
783 }
784
785 return PyUnicode_FromString(euler_order_str(self));
786}
787
788static int Euler_order_set(EulerObject *self, PyObject *value, void * /*closure*/)
789{
790 const char *order_str;
791 short order;
792
793 if (BaseMath_Prepare_ForWrite(self) == -1) {
794 return -1;
795 }
796
797 if (((order_str = PyUnicode_AsUTF8(value)) == nullptr) ||
798 ((order = euler_order_from_string(order_str, "euler.order")) == -1))
799 {
800 return -1;
801 }
802
803 self->order = order;
804 (void)BaseMath_WriteCallback(self); /* order can be written back */
805 return 0;
806}
807
809
810/* -------------------------------------------------------------------- */
813
814static PyGetSetDef Euler_getseters[] = {
815 {"x",
816 reinterpret_cast<getter>(Euler_axis_get),
817 reinterpret_cast<setter>(Euler_axis_set),
818 Euler_axis_doc,
820 {"y",
821 reinterpret_cast<getter>(Euler_axis_get),
822 reinterpret_cast<setter>(Euler_axis_set),
823 Euler_axis_doc,
825 {"z",
826 reinterpret_cast<getter>(Euler_axis_get),
827 reinterpret_cast<setter>(Euler_axis_set),
828 Euler_axis_doc,
830 {"order",
831 reinterpret_cast<getter>(Euler_order_get),
832 reinterpret_cast<setter>(Euler_order_set),
833 Euler_order_doc,
834 nullptr},
835
836 {"is_wrapped",
837 reinterpret_cast<getter>(BaseMathObject_is_wrapped_get),
838 static_cast<setter>(nullptr),
840 nullptr},
841 {"is_frozen",
842 reinterpret_cast<getter>(BaseMathObject_is_frozen_get),
843 static_cast<setter>(nullptr),
845 nullptr},
846 {"is_valid",
847 reinterpret_cast<getter>(BaseMathObject_is_valid_get),
848 static_cast<setter>(nullptr),
850 nullptr},
851 {"owner",
852 reinterpret_cast<getter>(BaseMathObject_owner_get),
853 static_cast<setter>(nullptr),
855 nullptr},
856 {nullptr, nullptr, nullptr, nullptr, nullptr} /* Sentinel */};
857
859
860/* -------------------------------------------------------------------- */
863
864#ifdef __GNUC__
865# ifdef __clang__
866# pragma clang diagnostic push
867# pragma clang diagnostic ignored "-Wcast-function-type"
868# else
869# pragma GCC diagnostic push
870# pragma GCC diagnostic ignored "-Wcast-function-type"
871# endif
872#endif
873
874static PyMethodDef Euler_methods[] = {
875 {"zero", reinterpret_cast<PyCFunction>(Euler_zero), METH_NOARGS, Euler_zero_doc},
876 {"to_matrix",
877 reinterpret_cast<PyCFunction>(Euler_to_matrix),
878 METH_NOARGS,
879 Euler_to_matrix_doc},
880 {"to_quaternion",
881 reinterpret_cast<PyCFunction>(Euler_to_quaternion),
882 METH_NOARGS,
883 Euler_to_quaternion_doc},
884 {"rotate_axis",
885 reinterpret_cast<PyCFunction>(Euler_rotate_axis),
886 METH_VARARGS,
887 Euler_rotate_axis_doc},
888 {"rotate", reinterpret_cast<PyCFunction>(Euler_rotate), METH_O, Euler_rotate_doc},
889 {"make_compatible",
890 reinterpret_cast<PyCFunction>(Euler_make_compatible),
891 METH_O,
892 Euler_make_compatible_doc},
893 {"copy", reinterpret_cast<PyCFunction>(Euler_copy), METH_NOARGS, Euler_copy_doc},
894 {"__copy__", reinterpret_cast<PyCFunction>(Euler_copy), METH_NOARGS, Euler_copy_doc},
895 {"__deepcopy__", reinterpret_cast<PyCFunction>(Euler_deepcopy), METH_VARARGS, Euler_copy_doc},
896
897 /* base-math methods */
898 {"freeze",
899 reinterpret_cast<PyCFunction>(BaseMathObject_freeze),
900 METH_NOARGS,
902 {nullptr, nullptr, 0, nullptr},
903};
904
905#ifdef __GNUC__
906# ifdef __clang__
907# pragma clang diagnostic pop
908# else
909# pragma GCC diagnostic pop
910# endif
911#endif
912
914
915/* -------------------------------------------------------------------- */
918
919#ifdef MATH_STANDALONE
920# define Euler_str nullptr
921#endif
922
924 /* Wrap. */
925 euler_doc,
926 ".. class:: Euler(angles=(0.0, 0.0, 0.0), order='XYZ', /)\n"
927 "\n"
928 " This object gives access to Eulers in Blender.\n"
929 "\n"
930 " .. seealso:: `Euler angles <https://en.wikipedia.org/wiki/Euler_angles>`__ on "
931 "Wikipedia.\n"
932 "\n"
933 " :param angles: (X, Y, Z) angles in radians.\n"
934 " :type angles: Sequence[float]\n"
935 " :param order: Euler rotation order.\n"
936 " :type order: Literal['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX']\n");
937PyTypeObject euler_Type = {
938 /*ob_base*/ PyVarObject_HEAD_INIT(nullptr, 0)
939 /*tp_name*/ "Euler",
940 /*tp_basicsize*/ sizeof(EulerObject),
941 /*tp_itemsize*/ 0,
942 /*tp_dealloc*/ reinterpret_cast<destructor>(BaseMathObject_dealloc),
943 /*tp_vectorcall_offset*/ 0,
944 /*tp_getattr*/ nullptr,
945 /*tp_setattr*/ nullptr,
946 /*tp_as_async*/ nullptr,
947 /*tp_repr*/ reinterpret_cast<reprfunc>(Euler_repr),
948 /*tp_as_number*/ nullptr,
949 /*tp_as_sequence*/ &Euler_SeqMethods,
950 /*tp_as_mapping*/ &Euler_AsMapping,
951 /*tp_hash*/ reinterpret_cast<hashfunc>(Euler_hash),
952 /*tp_call*/ nullptr,
953 /*tp_str*/ reinterpret_cast<reprfunc>(Euler_str),
954 /*tp_getattro*/ nullptr,
955 /*tp_setattro*/ nullptr,
956 /*tp_as_buffer*/ &Euler_as_buffer,
957 /*tp_flags*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
958 /*tp_doc*/ euler_doc,
959 /*tp_traverse*/ reinterpret_cast<traverseproc>(BaseMathObject_traverse),
960 /*tp_clear*/ reinterpret_cast<inquiry>(BaseMathObject_clear),
961 /*tp_richcompare*/ static_cast<richcmpfunc>(Euler_richcmpr),
962 /*tp_weaklistoffset*/ 0,
963 /*tp_iter*/ nullptr,
964 /*tp_iternext*/ nullptr,
965 /*tp_methods*/ Euler_methods,
966 /*tp_members*/ nullptr,
967 /*tp_getset*/ Euler_getseters,
968 /*tp_base*/ nullptr,
969 /*tp_dict*/ nullptr,
970 /*tp_descr_get*/ nullptr,
971 /*tp_descr_set*/ nullptr,
972 /*tp_dictoffset*/ 0,
973 /*tp_init*/ nullptr,
974 /*tp_alloc*/ nullptr,
975 /*tp_new*/ Euler_new,
976 /*tp_free*/ nullptr,
977 /*tp_is_gc*/ reinterpret_cast<inquiry>(BaseMathObject_is_gc),
978 /*tp_bases*/ nullptr,
979 /*tp_mro*/ nullptr,
980 /*tp_cache*/ nullptr,
981 /*tp_subclasses*/ nullptr,
982 /*tp_weaklist*/ nullptr,
983 /*tp_del*/ nullptr,
984 /*tp_version_tag*/ 0,
985 /*tp_finalize*/ nullptr,
986 /*tp_vectorcall*/ Euler_vectorcall,
987};
988
989#ifdef MATH_STANDALONE
990# undef Euler_str
991#endif
992
994
995/* -------------------------------------------------------------------- */
998
999PyObject *Euler_CreatePyObject(const float eul[3], const short order, PyTypeObject *base_type)
1000{
1001 EulerObject *self;
1002 float *eul_alloc;
1003
1004 eul_alloc = static_cast<float *>(PyMem_Malloc(EULER_SIZE * sizeof(float)));
1005 if (eul_alloc == nullptr) [[unlikely]] {
1006 PyErr_SetString(PyExc_MemoryError,
1007 "Euler(): "
1008 "problem allocating data");
1009 return nullptr;
1010 }
1011
1012 self = BASE_MATH_NEW(EulerObject, euler_Type, base_type);
1013 if (self) {
1014 self->eul = eul_alloc;
1015
1016 /* init callbacks as nullptr */
1017 self->cb_user = nullptr;
1018 self->cb_type = self->cb_subtype = 0;
1019
1020 if (eul) {
1021 copy_v3_v3(self->eul, eul);
1022 }
1023 else {
1024 zero_v3(self->eul);
1025 }
1026
1027 self->flag = BASE_MATH_FLAG_DEFAULT;
1028 self->order = order;
1029 }
1030 else {
1031 PyMem_Free(eul_alloc);
1032 }
1033
1034 return reinterpret_cast<PyObject *>(self);
1035}
1036
1037PyObject *Euler_CreatePyObject_wrap(float eul[3], const short order, PyTypeObject *base_type)
1038{
1039 EulerObject *self;
1040
1041 self = BASE_MATH_NEW(EulerObject, euler_Type, base_type);
1042 if (self) {
1043 /* init callbacks as nullptr */
1044 self->cb_user = nullptr;
1045 self->cb_type = self->cb_subtype = 0;
1046
1047 self->eul = eul;
1049
1050 self->order = order;
1051 }
1052
1053 return reinterpret_cast<PyObject *>(self);
1054}
1055
1056PyObject *Euler_CreatePyObject_cb(PyObject *cb_user,
1057 const short order,
1058 uchar cb_type,
1059 uchar cb_subtype)
1060{
1061 EulerObject *self = reinterpret_cast<EulerObject *>(
1062 Euler_CreatePyObject(nullptr, order, nullptr));
1063 if (self) {
1064 Py_INCREF(cb_user);
1065 self->cb_user = cb_user;
1066 self->cb_type = cb_type;
1067 self->cb_subtype = cb_subtype;
1068 BLI_assert(!PyObject_GC_IsTracked((PyObject *)self));
1069 PyObject_GC_Track(self);
1070 }
1071
1072 return reinterpret_cast<PyObject *>(self);
1073}
1074
1076
1077} // namespace blender
#define ATTR_FALLTHROUGH
A dynamically sized string ADT.
#define POINTER_FROM_INT(i)
#define POINTER_AS_INT(i)
#define ELEM(...)
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
Definition btVector3.h:356
#define str(s)
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
#define BaseMath_ReadCallback_ForWrite(_self)
Definition mathutils.hh:157
#define BaseMath_Prepare_ForBufferAccess(_self, _view, _flags)
Definition mathutils.hh:189
#define BaseMath_ReadIndexCallback(_self, _index)
Definition mathutils.hh:151
#define BaseMath_WriteCallback(_self)
Definition mathutils.hh:149
#define BASE_MATH_NEW(struct_name, root_type, base_type)
Definition mathutils.hh:29
#define BaseMathObject_Prepare_ForHash(_self)
Definition mathutils.hh:172
#define BASE_MATH_FLAG_DEFAULT
Definition mathutils.hh:54
#define BaseMath_Prepare_ForWrite(_self)
Definition mathutils.hh:167
#define BaseMath_ReadCallback(_self)
Definition mathutils.hh:147
#define BaseMath_WriteIndexCallback(_self, _index)
Definition mathutils.hh:153
#define MAKE_ID3(a, b, c)
#define EULER_SIZE
#define EulerObject_Check(v)
BMesh Iterators.
char BaseMathObject_owner_doc[]
Definition mathutils.cc:686
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
char BaseMathObject_freeze_doc[]
Definition mathutils.cc:716
int EXPP_VectorsAreEqual(const float *vecA, const float *vecB, int size, int floatSteps)
Definition mathutils.cc:511
void BLI_dynstr_appendf(DynStr *__restrict ds, const char *__restrict format,...) ATTR_PRINTF_FORMAT(2
static PyObject * Euler_to_tuple_ex(EulerObject *self, int ndigits)
bool mathutils_slice_is_subset(Py_ssize_t start, Py_ssize_t step, Py_ssize_t slice_length, Py_ssize_t array_num)
Definition mathutils.hh:241
void BaseMathObject_dealloc(BaseMathObject *self)
Definition mathutils.cc:766
MINLINE void copy_v3_v3(float r[3], const float a[3])
int PyC_CheckArgs_DeepCopy(PyObject *args)
static void Euler_releasebuffer(PyObject *, Py_buffer *view)
static int Euler_axis_set(EulerObject *self, PyObject *value, void *type)
Py_hash_t mathutils_array_hash(const float *array, size_t array_len)
Definition mathutils.cc:69
PyObject * mathutils_dynstr_to_py(DynStr *ds)
Definition mathutils.cc:523
static PyBufferProcs Euler_as_buffer
PyDoc_STRVAR(bpy_bm_new_doc, ".. function:: new(*, use_operators=True)\n" "\n" " :param use_operators: Support calling operators in :mod:`bmesh.ops` (uses some " "extra memory per vert/edge/face).\n" " :type use_operators: bool\n" " :return: Return a new, empty BMesh.\n" " :rtype: :class:`bmesh.types.BMesh`\n")
static PyObject * Euler_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
PyObject * BaseMathObject_owner_get(BaseMathObject *self, void *)
Definition mathutils.cc:690
static PyObject * Euler_slice(EulerObject *self, Py_ssize_t start, Py_ssize_t step, Py_ssize_t slice_length)
PyObject * Euler_CreatePyObject(const float eul[3], const short order, PyTypeObject *base_type)
static int Euler_ass_item(EulerObject *self, Py_ssize_t i, PyObject *value)
PyTypeObject euler_Type
void mat3_to_compatible_eulO(float eul[3], const float oldrot[3], short order, const float mat[3][3])
double double_round(double x, int ndigits)
Definition math_base.cc:30
int BaseMathObject_clear(BaseMathObject *self)
Definition mathutils.cc:748
PyObject * BaseMathObject_freeze(BaseMathObject *self)
Definition mathutils.cc:725
static const char * euler_order_str(EulerObject *self)
int BaseMathObject_is_gc(BaseMathObject *self)
Definition mathutils.cc:788
void eulO_to_mat3(float M[3][3], const float e[3], short order)
PyObject * BaseMathObject_is_frozen_get(BaseMathObject *self, void *)
Definition mathutils.cc:705
static PyMappingMethods Euler_AsMapping
PyObject * BaseMathObject_is_valid_get(BaseMathObject *self, void *)
Definition mathutils.cc:711
static PyGetSetDef Euler_getseters[]
unsigned char uchar
Definition BKE_text.h:58
PyObject * Matrix_CreatePyObject(const float *mat, const ushort col_num, const ushort row_num, PyTypeObject *base_type)
PyObject * Quaternion_CreatePyObject(const float quat[4], PyTypeObject *base_type)
static int Euler_ass_subscript(EulerObject *self, PyObject *item, PyObject *value)
@ BASE_MATH_FLAG_IS_WRAP
Definition mathutils.hh:39
@ BASE_MATH_FLAG_HAS_BUFFER_VIEW
Definition mathutils.hh:52
static int Euler_order_set(EulerObject *self, PyObject *value, void *)
static PyMethodDef Euler_methods[]
int mathutils_array_parse(float *array, int array_num_min, int array_num_max, PyObject *value, const char *error_prefix)
Definition mathutils.cc:97
static PySequenceMethods Euler_SeqMethods
static PyObject * Euler_rotate(EulerObject *self, PyObject *value)
static PyObject * Euler_vectorcall(PyObject *type, PyObject *const *args, const size_t nargsf, PyObject *kwnames)
static PyObject * Euler_richcmpr(PyObject *a, PyObject *b, int op)
MINLINE void zero_v3(float r[3])
short euler_order_from_string(const char *str, const char *error_prefix)
static PyObject * Euler_repr(EulerObject *self)
static int Euler_getbuffer(PyObject *obj, Py_buffer *view, int flags)
static PyObject * Euler_to_quaternion(EulerObject *self)
static PyObject * Euler_axis_get(EulerObject *self, void *type)
static PyObject * Euler_item(EulerObject *self, Py_ssize_t i)
static int Euler_ass_slice(EulerObject *self, Py_ssize_t start, Py_ssize_t step, Py_ssize_t slice_length, PyObject *seq)
PyObject * BaseMathObject_is_wrapped_get(BaseMathObject *self, void *)
Definition mathutils.cc:698
char BaseMathObject_is_valid_doc[]
Definition mathutils.cc:710
int BaseMathObject_traverse(BaseMathObject *self, visitproc visit, void *arg)
Definition mathutils.cc:742
void eulO_to_quat(float q[4], const float e[3], short order)
static PyObject * Euler_make_compatible(EulerObject *self, PyObject *value)
int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error_prefix)
Definition mathutils.cc:426
static Py_hash_t Euler_hash(EulerObject *self)
static Py_ssize_t Euler_len(EulerObject *)
signed int int32_t
Definition BKE_text.h:78
static PyObject * Euler_copy(EulerObject *self)
static PyObject * Euler_order_get(EulerObject *self, void *)
static PyObject * Euler_str(EulerObject *self)
char BaseMathObject_is_frozen_doc[]
Definition mathutils.cc:703
PyObject * Euler_CreatePyObject_wrap(float eul[3], const short order, PyTypeObject *base_type)
void mul_m3_m3m3(float R[3][3], const float A[3][3], const float B[3][3])
void compatible_eul(float eul[3], const float oldrot[3])
static PyObject * Euler_subscript(EulerObject *self, PyObject *item)
static PyObject * Euler_to_matrix(EulerObject *self)
static PyObject * Euler_deepcopy(EulerObject *self, PyObject *args)
DynStr * BLI_dynstr_new() ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
Definition BLI_dynstr.cc:39
static PyObject * Euler_rotate_axis(EulerObject *self, PyObject *args)
PyObject * Euler_CreatePyObject_cb(PyObject *cb_user, const short order, uchar cb_type, uchar cb_subtype)
char BaseMathObject_is_wrapped_doc[]
Definition mathutils.cc:696
static PyObject * Euler_zero(EulerObject *self)
void rotate_eulO(float beul[3], short order, char axis, float angle)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float