Blender V5.3
mathutils_Quaternion.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
15#include "BLI_math_base_safe.hh"
16#include "BLI_math_matrix_c.hh"
18#include "BLI_math_vector_c.hh"
19#include "BLI_utildefines.hh"
20
23
24#ifndef MATH_STANDALONE
25# include "BLI_dynstr.hh"
26#endif
27
28namespace blender {
29
30#define QUAT_SIZE 4
31
32static PyObject *quat__apply_to_copy(PyObject *(*quat_func)(QuaternionObject *),
33 QuaternionObject *self);
34static void quat__axis_angle_sanitize(float axis[3], float *angle);
35static PyObject *Quaternion_copy(QuaternionObject *self);
36static PyObject *Quaternion_deepcopy(QuaternionObject *self, PyObject *args);
37
38/* -------------------------------------------------------------------- */
41
42static PyObject *quat__apply_to_copy(PyObject *(*quat_func)(QuaternionObject *),
43 QuaternionObject *self)
44{
45 PyObject *ret = Quaternion_copy(self);
46 PyObject *ret_dummy = quat_func(reinterpret_cast<QuaternionObject *>(ret));
47 if (ret_dummy) {
48 Py_DECREF(ret_dummy);
49 return ret;
50 }
51 /* error */
52 Py_DECREF(ret);
53 return nullptr;
54}
55
57static void quat__axis_angle_sanitize(float axis[3], float *angle)
58{
59 if (axis) {
60 if (is_zero_v3(axis) || !isfinite(axis[0]) || !isfinite(axis[1]) || !isfinite(axis[2])) {
61 axis[0] = 1.0f;
62 axis[1] = 0.0f;
63 axis[2] = 0.0f;
64 }
65 else if (EXPP_FloatsAreEqual(axis[0], 0.0f, 10) && EXPP_FloatsAreEqual(axis[1], 0.0f, 10) &&
66 EXPP_FloatsAreEqual(axis[2], 0.0f, 10))
67 {
68 axis[0] = 1.0f;
69 }
70 }
71
72 if (angle) {
73 if (!isfinite(*angle)) {
74 *angle = 0.0f;
75 }
76 }
77}
78
82static PyObject *Quaternion_to_tuple_ext(QuaternionObject *self, int ndigits)
83{
84 PyObject *ret;
85 int i;
86
87 ret = PyTuple_New(QUAT_SIZE);
88
89 if (ndigits >= 0) {
90 for (i = 0; i < QUAT_SIZE; i++) {
91 PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(double_round(double(self->quat[i]), ndigits)));
92 }
93 }
94 else {
95 for (i = 0; i < QUAT_SIZE; i++) {
96 PyTuple_SET_ITEM(ret, i, PyFloat_FromDouble(self->quat[i]));
97 }
98 }
99
100 return ret;
101}
102
104
105/* -------------------------------------------------------------------- */
108
109static PyObject *Quaternion_vectorcall(PyObject *type,
110 PyObject *const *args,
111 const size_t nargsf,
112 PyObject *kwnames)
113{
114 if (kwnames && PyTuple_GET_SIZE(kwnames)) [[unlikely]] {
115 PyErr_SetString(PyExc_TypeError,
116 "mathutils.Quaternion(): "
117 "takes no keyword args");
118 return nullptr;
119 }
120
121 double angle = 0.0f;
122 float quat[QUAT_SIZE];
123 unit_qt(quat);
124
125 const size_t nargs = PyVectorcall_NARGS(nargsf);
126 switch (nargs) {
127 case 0: {
128 break;
129 }
130 case 1: {
131 const int size = mathutils_array_parse(
132 quat, 3, QUAT_SIZE, args[0], "mathutils.Quaternion()");
133
134 if (size == -1) [[unlikely]] {
135 return nullptr;
136 }
137
138 if (size == 4) {
139 /* 4d: Quaternion (common case) */
140 }
141 else {
142 /* 3d: Interpret as exponential map */
143 BLI_assert(size == 3);
144 expmap_to_quat(quat, quat);
145 }
146
147 break;
148 }
149 case 2: {
150 float axis[3];
151 if (mathutils_array_parse(axis, 3, 3, args[0], "mathutils.Quaternion()") == -1) {
152 return nullptr;
153 }
154 angle = PyFloat_AsDouble(args[1]);
155 if (angle == -1.0 && PyErr_Occurred()) [[unlikely]] {
156 PyErr_Format(PyExc_TypeError,
157 "mathutils.Quaternion(): "
158 "angle must be a real number, not '%.200s'",
159 Py_TYPE(args[1])->tp_name);
160 return nullptr;
161 }
162 angle = angle_wrap_rad(angle); /* clamp because of precision issues */
163 axis_angle_to_quat(quat, axis, angle);
164 break;
165 }
166 default: {
167 PyErr_Format(PyExc_TypeError,
168 "mathutils.Quaternion() "
169 "takes at most 2 arguments (%zd given)",
170 nargs);
171 return nullptr;
172 }
173 }
174 return Quaternion_CreatePyObject(quat, reinterpret_cast<PyTypeObject *>(type));
175}
176
177static PyObject *Quaternion_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
178{
179 /* Only called on sub-classes. */
180 if (kwds && PyDict_GET_SIZE(kwds)) [[unlikely]] {
181 PyErr_SetString(PyExc_TypeError,
182 "mathutils.Quaternion(): "
183 "takes no keyword args");
184 return nullptr;
185 }
186 PyObject *const *args_array = &PyTuple_GET_ITEM(args, 0);
187 const size_t args_array_num = PyTuple_GET_SIZE(args);
189 reinterpret_cast<PyObject *>(type), args_array, args_array_num, nullptr);
190}
191
193
194/* -------------------------------------------------------------------- */
197
199 /* Wrap. */
200 Quaternion_to_euler_doc,
201 ".. method:: to_euler(order='XYZ', euler_compat=None, /)\n"
202 "\n"
203 " Return Euler representation of the quaternion.\n"
204 "\n"
205 " :param order: Rotation order.\n"
206 " :type order: Literal['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX']\n"
207 " :param euler_compat: Optional euler argument the new euler will be made\n"
208 " compatible with (no axis flipping between them).\n"
209 " Useful for converting a series of quaternions to animation curves.\n"
210 " :type euler_compat: :class:`Euler` | None\n"
211 " :return: Euler representation of the quaternion.\n"
212 " :rtype: :class:`Euler`\n");
213static PyObject *Quaternion_to_euler(QuaternionObject *self, PyObject *args)
214{
215 float tquat[4];
216 float eul[3];
217 const char *order_str = nullptr;
218 short order = EULER_ORDER_XYZ;
219 EulerObject *eul_compat = nullptr;
220 PyC_TypeOrNone eul_compat_or_none = PyC_TYPE_OR_NONE_INIT(&euler_Type, &eul_compat);
221
222 static const char *_keywords[] = {"", "", nullptr};
223 static _PyArg_Parser _parser = {
224 "|" /* Optional arguments. */
225 "s" /* `order` */
226 "O&" /* `euler_compat` */
227 ":to_euler",
228 _keywords,
229 nullptr,
230 };
231 if (!_PyArg_ParseTupleAndKeywordsFast(
232 args, nullptr, &_parser, &order_str, PyC_ParseTypeOrNone, &eul_compat_or_none))
233 {
234 return nullptr;
235 }
236
237 if (BaseMath_ReadCallback(self) == -1) {
238 return nullptr;
239 }
240
241 if (order_str) {
242 order = euler_order_from_string(order_str, "Quaternion.to_euler()");
243
244 if (order == -1) {
245 return nullptr;
246 }
247 }
248
249 normalize_qt_qt(tquat, self->quat);
250
251 if (eul_compat) {
252 if (BaseMath_ReadCallback(eul_compat) == -1) {
253 return nullptr;
254 }
255
256 if (order == EULER_ORDER_XYZ) {
257 quat_to_compatible_eul(eul, eul_compat->eul, tquat);
258 }
259 else {
260 quat_to_compatible_eulO(eul, eul_compat->eul, order, tquat);
261 }
262 }
263 else {
264 if (order == EULER_ORDER_XYZ) {
265 quat_to_eul(eul, tquat);
266 }
267 else {
268 quat_to_eulO(eul, order, tquat);
269 }
270 }
271
272 return Euler_CreatePyObject(eul, order, nullptr);
273}
274
276
277/* -------------------------------------------------------------------- */
280
282 /* Wrap. */
283 Quaternion_to_matrix_doc,
284 ".. method:: to_matrix()\n"
285 "\n"
286 " Return a matrix representation of the quaternion.\n"
287 "\n"
288 " :return: A 3x3 rotation matrix representation of the quaternion.\n"
289 " :rtype: :class:`Matrix`\n");
291{
292 float mat[9]; /* all values are set */
293
294 if (BaseMath_ReadCallback(self) == -1) {
295 return nullptr;
296 }
297
298 quat_to_mat3(reinterpret_cast<float (*)[3]>(mat), self->quat);
299 return Matrix_CreatePyObject(mat, 3, 3, nullptr);
300}
301
303
304/* -------------------------------------------------------------------- */
307
309 /* Wrap. */
310 Quaternion_to_axis_angle_doc,
311 ".. method:: to_axis_angle()\n"
312 "\n"
313 " Return the axis, angle representation of the quaternion.\n"
314 "\n"
315 " :return: Axis, angle.\n"
316 " :rtype: tuple[:class:`Vector`, float]\n");
318{
319 PyObject *ret;
320
321 float tquat[4];
322
323 float axis[3];
324 float angle;
325
326 if (BaseMath_ReadCallback(self) == -1) {
327 return nullptr;
328 }
329
330 normalize_qt_qt(tquat, self->quat);
331 quat_to_axis_angle(axis, &angle, tquat);
332
334
335 ret = PyTuple_New(2);
336 PyTuple_SET_ITEMS(ret, Vector_CreatePyObject(axis, 3, nullptr), PyFloat_FromDouble(angle));
337 return ret;
338}
339
341
342/* -------------------------------------------------------------------- */
345
347 /* Wrap. */
348 Quaternion_to_swing_twist_doc,
349 ".. method:: to_swing_twist(axis, /)\n"
350 "\n"
351 " Split the rotation into a swing quaternion with the specified\n"
352 " axis fixed at zero, and the remaining twist rotation angle.\n"
353 "\n"
354 " :param axis: Twist axis as a string.\n"
355 " :type axis: Literal['X', 'Y', 'Z']\n"
356 " :return: Swing, twist angle.\n"
357 " :rtype: tuple[:class:`Quaternion`, float]\n");
358static PyObject *Quaternion_to_swing_twist(QuaternionObject *self, PyObject *axis_arg)
359{
360 PyObject *ret;
361
362 const char *axis_str = nullptr;
363 float swing[4], twist;
364 int axis;
365
366 if (axis_arg && PyUnicode_Check(axis_arg)) {
367 axis_str = PyUnicode_AsUTF8(axis_arg);
368 }
369
370 if (axis_str && axis_str[0] >= 'X' && axis_str[0] <= 'Z' && axis_str[1] == 0) {
371 axis = axis_str[0] - 'X';
372 }
373 else {
374 PyErr_SetString(PyExc_ValueError,
375 "Quaternion.to_swing_twist(): "
376 "the axis argument must be "
377 "a string in 'X', 'Y', 'Z'");
378 return nullptr;
379 }
380
381 if (BaseMath_ReadCallback(self) == -1) {
382 return nullptr;
383 }
384
385 twist = quat_split_swing_and_twist(self->quat, axis, swing, nullptr);
386
387 ret = PyTuple_New(2);
389 ret, Quaternion_CreatePyObject(swing, Py_TYPE(self)), PyFloat_FromDouble(twist));
390 return ret;
391}
392
394
395/* -------------------------------------------------------------------- */
398
400 /* Wrap. */
401 Quaternion_to_exponential_map_doc,
402 ".. method:: to_exponential_map()\n"
403 "\n"
404 " Return the exponential map representation of the quaternion.\n"
405 "\n"
406 " This representation consists of the rotation axis multiplied by the rotation angle.\n"
407 " Such a representation is useful for interpolation between multiple orientations.\n"
408 "\n"
409 " :return: 3D exponential map.\n"
410 " :rtype: :class:`Vector`\n"
411 "\n"
412 " To convert back to a quaternion, pass it to the :class:`Quaternion` constructor.\n");
414{
415 float expmap[3];
416
417 if (BaseMath_ReadCallback(self) == -1) {
418 return nullptr;
419 }
420
421 quat_to_expmap(expmap, self->quat);
422 return Vector_CreatePyObject(expmap, 3, nullptr);
423}
424
426
427/* -------------------------------------------------------------------- */
430
432 /* Wrap. */
433 Quaternion_cross_doc,
434 ".. method:: cross(other, /)\n"
435 "\n"
436 " Return the cross product of this quaternion and another.\n"
437 "\n"
438 " :param other: The other quaternion to perform the cross product with.\n"
439 " :type other: :class:`Quaternion`\n"
440 " :return: The cross product.\n"
441 " :rtype: :class:`Quaternion`\n");
442static PyObject *Quaternion_cross(QuaternionObject *self, PyObject *value)
443{
444 float quat[QUAT_SIZE], tquat[QUAT_SIZE];
445
446 if (BaseMath_ReadCallback(self) == -1) {
447 return nullptr;
448 }
449
451 tquat, QUAT_SIZE, QUAT_SIZE, value, "Quaternion.cross(other), invalid 'other' arg") ==
452 -1)
453 {
454 return nullptr;
455 }
456
457 mul_qt_qtqt(quat, self->quat, tquat);
458 return Quaternion_CreatePyObject(quat, Py_TYPE(self));
459}
460
462
463/* -------------------------------------------------------------------- */
466
468 /* Wrap. */
469 Quaternion_dot_doc,
470 ".. method:: dot(other, /)\n"
471 "\n"
472 " Return the dot product of this quaternion and another.\n"
473 "\n"
474 " :param other: The other quaternion to perform the dot product with.\n"
475 " :type other: :class:`Quaternion`\n"
476 " :return: The dot product.\n"
477 " :rtype: float\n");
478static PyObject *Quaternion_dot(QuaternionObject *self, PyObject *value)
479{
480 float tquat[QUAT_SIZE];
481
482 if (BaseMath_ReadCallback(self) == -1) {
483 return nullptr;
484 }
485
487 tquat, QUAT_SIZE, QUAT_SIZE, value, "Quaternion.dot(other), invalid 'other' arg") == -1)
488 {
489 return nullptr;
490 }
491
492 return PyFloat_FromDouble(dot_qtqt(self->quat, tquat));
493}
494
496
497/* -------------------------------------------------------------------- */
500
502 /* Wrap. */
503 Quaternion_rotation_difference_doc,
504 ".. method:: rotation_difference(other, /)\n"
505 "\n"
506 " Returns a quaternion representing the rotational difference.\n"
507 "\n"
508 " :param other: second quaternion.\n"
509 " :type other: :class:`Quaternion`\n"
510 " :return: the rotational difference between the two quat rotations.\n"
511 " :rtype: :class:`Quaternion`\n");
512static PyObject *Quaternion_rotation_difference(QuaternionObject *self, PyObject *value)
513{
514 float tquat[QUAT_SIZE], quat[QUAT_SIZE];
515
516 if (BaseMath_ReadCallback(self) == -1) {
517 return nullptr;
518 }
519
520 if (mathutils_array_parse(tquat,
521 QUAT_SIZE,
522 QUAT_SIZE,
523 value,
524 "Quaternion.rotation_difference(other), invalid 'other' arg") == -1)
525 {
526 return nullptr;
527 }
528
529 rotation_between_quats_to_quat(quat, self->quat, tquat);
530
531 return Quaternion_CreatePyObject(quat, Py_TYPE(self));
532}
533
535
536/* -------------------------------------------------------------------- */
539
541 /* Wrap. */
542 Quaternion_slerp_doc,
543 ".. method:: slerp(other, factor, /)\n"
544 "\n"
545 " Returns the interpolation of two quaternions.\n"
546 "\n"
547 " :param other: value to interpolate with.\n"
548 " :type other: :class:`Quaternion`\n"
549 " :param factor: The interpolation value in [0.0, 1.0].\n"
550 " :type factor: float\n"
551 " :return: The interpolated rotation.\n"
552 " :rtype: :class:`Quaternion`\n");
553static PyObject *Quaternion_slerp(QuaternionObject *self, PyObject *args)
554{
555 PyObject *value;
556 float tquat[QUAT_SIZE], quat[QUAT_SIZE], fac;
557
558 if (!PyArg_ParseTuple(args,
559 "O" /* `other` */
560 "f" /* `factor` */
561 ":slerp",
562 &value,
563 &fac))
564 {
565 PyErr_SetString(PyExc_TypeError,
566 "quat.slerp(): "
567 "expected Quaternion types and float");
568 return nullptr;
569 }
570
571 if (BaseMath_ReadCallback(self) == -1) {
572 return nullptr;
573 }
574
576 tquat, QUAT_SIZE, QUAT_SIZE, value, "Quaternion.slerp(other), invalid 'other' arg") ==
577 -1)
578 {
579 return nullptr;
580 }
581
582 if (fac > 1.0f || fac < 0.0f) {
583 PyErr_SetString(PyExc_ValueError,
584 "quat.slerp(): "
585 "interpolation factor must be between 0.0 and 1.0");
586 return nullptr;
587 }
588
589 interp_qt_qtqt(quat, self->quat, tquat, fac);
590
591 return Quaternion_CreatePyObject(quat, Py_TYPE(self));
592}
593
595
596/* -------------------------------------------------------------------- */
599
601 /* Wrap. */
602 Quaternion_rotate_doc,
603 ".. method:: rotate(other, /)\n"
604 "\n"
605 " Rotates the quaternion by another mathutils value.\n"
606 "\n"
607 " :param other: rotation component of mathutils value\n"
608 " :type other: :class:`Euler` | :class:`Quaternion` | :class:`Matrix`\n");
609static PyObject *Quaternion_rotate(QuaternionObject *self, PyObject *value)
610{
611 float self_rmat[3][3], other_rmat[3][3], rmat[3][3];
612 float tquat[4], length;
613
614 if (BaseMath_ReadCallback_ForWrite(self) == -1) {
615 return nullptr;
616 }
617
618 if (mathutils_any_to_rotmat(other_rmat, value, "Quaternion.rotate(value)") == -1) {
619 return nullptr;
620 }
621
622 length = normalize_qt_qt(tquat, self->quat);
623 quat_to_mat3(self_rmat, tquat);
624 mul_m3_m3m3(rmat, other_rmat, self_rmat);
625 mat3_to_quat(self->quat, rmat);
626 mul_qt_fl(self->quat, length); /* maintain length after rotating */
627
628 (void)BaseMath_WriteCallback(self);
629 Py_RETURN_NONE;
630}
631
633 /* Wrap. */
634 Quaternion_make_compatible_doc,
635 ".. method:: make_compatible(other, /)\n"
636 "\n"
637 " Make this quaternion compatible with another,\n"
638 " so interpolating between them works as intended.\n"
639 "\n"
640 " :param other: The reference quaternion to make this one compatible with.\n"
641 " :type other: :class:`Quaternion`\n");
642static PyObject *Quaternion_make_compatible(QuaternionObject *self, PyObject *value)
643{
644 float quat[QUAT_SIZE];
645 float tquat[QUAT_SIZE];
646
647 if (BaseMath_ReadCallback_ForWrite(self) == -1) {
648 return nullptr;
649 }
650
651 if (mathutils_array_parse(tquat,
652 QUAT_SIZE,
653 QUAT_SIZE,
654 value,
655 "Quaternion.make_compatible(other), invalid 'other' arg") == -1)
656 {
657 return nullptr;
658 }
659
660 /* Can only operate on unit length quaternions. */
661 const float quat_len = normalize_qt_qt(quat, self->quat);
662 quat_to_compatible_quat(self->quat, quat, tquat);
663 mul_qt_fl(self->quat, quat_len);
664
665 (void)BaseMath_WriteCallback(self);
666
667 Py_RETURN_NONE;
668}
669
671
672/* -------------------------------------------------------------------- */
678
680 /* Wrap. */
681 Quaternion_normalize_doc,
682 ".. method:: normalize()\n"
683 "\n"
684 " Normalize the quaternion.\n");
686{
687 if (BaseMath_ReadCallback_ForWrite(self) == -1) {
688 return nullptr;
689 }
690
691 normalize_qt(self->quat);
692
693 (void)BaseMath_WriteCallback(self);
694 Py_RETURN_NONE;
695}
697 /* Wrap. */
698 Quaternion_normalized_doc,
699 ".. method:: normalized()\n"
700 "\n"
701 " Return a new normalized quaternion.\n"
702 "\n"
703 " :return: a normalized copy.\n"
704 " :rtype: :class:`Quaternion`\n");
706{
708}
709
711
712/* -------------------------------------------------------------------- */
717
719 /* Wrap. */
720 Quaternion_invert_doc,
721 ".. method:: invert()\n"
722 "\n"
723 " Set the quaternion to its inverse.\n");
724static PyObject *Quaternion_invert(QuaternionObject *self)
725{
726 if (BaseMath_ReadCallback_ForWrite(self) == -1) {
727 return nullptr;
728 }
729
730 invert_qt(self->quat);
731
732 (void)BaseMath_WriteCallback(self);
733 Py_RETURN_NONE;
734}
736 /* Wrap. */
737 Quaternion_inverted_doc,
738 ".. method:: inverted()\n"
739 "\n"
740 " Return a new, inverted quaternion.\n"
741 "\n"
742 " :return: the inverted value.\n"
743 " :rtype: :class:`Quaternion`\n");
745{
747}
748
750
751/* -------------------------------------------------------------------- */
754
756 /* Wrap. */
757 Quaternion_identity_doc,
758 ".. method:: identity()\n"
759 "\n"
760 " Set the quaternion to an identity quaternion.\n");
762{
763 if (BaseMath_ReadCallback_ForWrite(self) == -1) {
764 return nullptr;
765 }
766
767 unit_qt(self->quat);
768
769 (void)BaseMath_WriteCallback(self);
770 Py_RETURN_NONE;
771}
772
774
775/* -------------------------------------------------------------------- */
778
780 /* Wrap. */
781 Quaternion_negate_doc,
782 ".. method:: negate()\n"
783 "\n"
784 " Set the quaternion to its negative.\n");
785static PyObject *Quaternion_negate(QuaternionObject *self)
786{
787 if (BaseMath_ReadCallback_ForWrite(self) == -1) {
788 return nullptr;
789 }
790
791 mul_qt_fl(self->quat, -1.0f);
792
793 (void)BaseMath_WriteCallback(self);
794 Py_RETURN_NONE;
795}
796
798
799/* -------------------------------------------------------------------- */
802
804 /* Wrap. */
805 Quaternion_conjugate_doc,
806 ".. method:: conjugate()\n"
807 "\n"
808 " Set the quaternion to its conjugate (negate x, y, z).\n");
810{
811 if (BaseMath_ReadCallback_ForWrite(self) == -1) {
812 return nullptr;
813 }
814
815 conjugate_qt(self->quat);
816
817 (void)BaseMath_WriteCallback(self);
818 Py_RETURN_NONE;
819}
821 /* Wrap. */
822 Quaternion_conjugated_doc,
823 ".. method:: conjugated()\n"
824 "\n"
825 " Return a new conjugated quaternion.\n"
826 "\n"
827 " :return: a new quaternion.\n"
828 " :rtype: :class:`Quaternion`\n");
830{
832}
833
835
836/* -------------------------------------------------------------------- */
839
841 /* Wrap. */
842 Quaternion_copy_doc,
843 ".. method:: copy()\n"
844 "\n"
845 " Returns a copy of this quaternion.\n"
846 "\n"
847 " :return: A copy of the quaternion.\n"
848 " :rtype: :class:`Quaternion`\n"
849 "\n"
850 " .. note:: use this to get a copy of a wrapped quaternion with\n"
851 " no reference to the original data.\n");
852static PyObject *Quaternion_copy(QuaternionObject *self)
853{
854 if (BaseMath_ReadCallback(self) == -1) {
855 return nullptr;
856 }
857
858 return Quaternion_CreatePyObject(self->quat, Py_TYPE(self));
859}
860static PyObject *Quaternion_deepcopy(QuaternionObject *self, PyObject *args)
861{
862 if (!PyC_CheckArgs_DeepCopy(args)) {
863 return nullptr;
864 }
865 return Quaternion_copy(self);
866}
867
869
870/* -------------------------------------------------------------------- */
873
874static PyObject *Quaternion_repr(QuaternionObject *self)
875{
876 PyObject *ret, *tuple;
877
878 if (BaseMath_ReadCallback(self) == -1) {
879 return nullptr;
880 }
881
882 tuple = Quaternion_to_tuple_ext(self, -1);
883
884 ret = PyUnicode_FromFormat("Quaternion(%R)", tuple);
885
886 Py_DECREF(tuple);
887 return ret;
888}
889
890#ifndef MATH_STANDALONE
891static PyObject *Quaternion_str(QuaternionObject *self)
892{
893 DynStr *ds;
894
895 if (BaseMath_ReadCallback(self) == -1) {
896 return nullptr;
897 }
898
899 ds = BLI_dynstr_new();
900
902 "<Quaternion (w=%.4f, x=%.4f, y=%.4f, z=%.4f)>",
903 self->quat[0],
904 self->quat[1],
905 self->quat[2],
906 self->quat[3]);
907
908 return mathutils_dynstr_to_py(ds); /* frees ds */
909}
910#endif
911
913
914/* -------------------------------------------------------------------- */
917
918static int Quaternion_getbuffer(PyObject *obj, Py_buffer *view, int flags)
919{
920 QuaternionObject *self = reinterpret_cast<QuaternionObject *>(obj);
921 if (BaseMath_Prepare_ForBufferAccess(self, view, flags) == -1) [[unlikely]] {
922 return -1;
923 }
924 if (BaseMath_ReadCallback(self) == -1) [[unlikely]] {
925 return -1;
926 }
927
928 memset(view, 0, sizeof(*view));
929
930 view->obj = reinterpret_cast<PyObject *>(self);
931 view->buf = static_cast<void *>(self->quat);
932 view->len = Py_ssize_t(QUAT_SIZE * sizeof(float));
933 view->itemsize = sizeof(float);
934 view->ndim = 1;
935 if ((flags & PyBUF_WRITABLE) == 0) {
936 view->readonly = 1;
937 }
938 if (flags & PyBUF_FORMAT) {
939 view->format = const_cast<char *>("f");
940 }
941
942 self->flag |= BASE_MATH_FLAG_HAS_BUFFER_VIEW;
943
944 Py_INCREF(self);
945 return 0;
946}
947
948static void Quaternion_releasebuffer(PyObject * /*exporter*/, Py_buffer *view)
949{
950 QuaternionObject *self = reinterpret_cast<QuaternionObject *>(view->obj);
952
953 if (view->readonly == 0) {
954 if (BaseMath_WriteCallback(self) == -1) [[unlikely]] {
955 PyErr_Print();
956 }
957 }
958}
959
960static PyBufferProcs Quaternion_as_buffer = {
961 static_cast<getbufferproc>(Quaternion_getbuffer),
962 static_cast<releasebufferproc>(Quaternion_releasebuffer),
963};
964
966
967/* -------------------------------------------------------------------- */
970
971static PyObject *Quaternion_richcmpr(PyObject *a, PyObject *b, int op)
972{
973 PyObject *res;
974 int ok = -1; /* zero is true */
975
977 QuaternionObject *quatA = reinterpret_cast<QuaternionObject *>(a);
978 QuaternionObject *quatB = reinterpret_cast<QuaternionObject *>(b);
979
980 if (BaseMath_ReadCallback(quatA) == -1 || BaseMath_ReadCallback(quatB) == -1) {
981 return nullptr;
982 }
983
984 ok = EXPP_VectorsAreEqual(quatA->quat, quatB->quat, QUAT_SIZE, 1) ? 0 : -1;
985 }
986
987 switch (op) {
988 case Py_NE: {
989 ok = !ok;
991 }
992 case Py_EQ: {
993 res = ok ? Py_False : Py_True;
994 break;
995 }
996 case Py_LT:
997 case Py_LE:
998 case Py_GT:
999 case Py_GE: {
1000 res = Py_NotImplemented;
1001 break;
1002 }
1003 default: {
1004 PyErr_BadArgument();
1005 return nullptr;
1006 }
1007 }
1008
1009 return Py_NewRef(res);
1010}
1011
1013
1014/* -------------------------------------------------------------------- */
1017
1018static Py_hash_t Quaternion_hash(QuaternionObject *self)
1019{
1020 if (BaseMath_ReadCallback(self) == -1) {
1021 return -1;
1022 }
1023
1024 if (BaseMathObject_Prepare_ForHash(self) == -1) {
1025 return -1;
1026 }
1027
1028 return mathutils_array_hash(self->quat, QUAT_SIZE);
1029}
1030
1032
1033/* -------------------------------------------------------------------- */
1036
1038static Py_ssize_t Quaternion_len(QuaternionObject * /*self*/)
1039{
1040 return QUAT_SIZE;
1041}
1042
1044static PyObject *Quaternion_item(QuaternionObject *self, Py_ssize_t i)
1045{
1046 if (i < 0 || i >= QUAT_SIZE) {
1047 PyErr_SetString(PyExc_IndexError,
1048 "quaternion[attribute]: "
1049 "array index out of range");
1050 return nullptr;
1051 }
1052
1053 if (BaseMath_ReadIndexCallback(self, i) == -1) {
1054 return nullptr;
1055 }
1056
1057 return PyFloat_FromDouble(self->quat[i]);
1058}
1059
1061static int Quaternion_ass_item(QuaternionObject *self, Py_ssize_t i, PyObject *ob)
1062{
1063 float f;
1064
1065 if (BaseMath_Prepare_ForWrite(self) == -1) {
1066 return -1;
1067 }
1068
1069 f = float(PyFloat_AsDouble(ob));
1070
1071 if (f == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
1072 PyErr_SetString(PyExc_TypeError,
1073 "quaternion[index] = x: "
1074 "assigned value not a number");
1075 return -1;
1076 }
1077
1078 if (i < 0 || i >= QUAT_SIZE) {
1079 PyErr_SetString(PyExc_IndexError,
1080 "quaternion[attribute] = x: "
1081 "array assignment index out of range");
1082 return -1;
1083 }
1084 self->quat[i] = f;
1085
1086 if (BaseMath_WriteIndexCallback(self, i) == -1) {
1087 return -1;
1088 }
1089
1090 return 0;
1091}
1092
1094static PyObject *Quaternion_slice(QuaternionObject *self,
1095 Py_ssize_t start,
1096 Py_ssize_t step,
1097 Py_ssize_t slice_length)
1098{
1099 if (BaseMath_ReadCallback(self) == -1) {
1100 return nullptr;
1101 }
1102
1103 PyObject *tuple = PyTuple_New(slice_length);
1104 Py_ssize_t index = start;
1105 for (Py_ssize_t i = 0; i < slice_length; i++, index += step) {
1106 BLI_assert(index >= 0 && index < QUAT_SIZE);
1107 PyTuple_SET_ITEM(tuple, i, PyFloat_FromDouble(self->quat[index]));
1108 }
1109 return tuple;
1110}
1111
1118 Py_ssize_t start,
1119 Py_ssize_t step,
1120 Py_ssize_t slice_length,
1121 PyObject *seq)
1122{
1123 float quat[QUAT_SIZE];
1124
1125 /* Subset writes merge into existing values, so sync the source first. */
1126 if (mathutils_slice_is_subset(start, step, slice_length, QUAT_SIZE)) {
1127 if (BaseMath_ReadCallback_ForWrite(self) == -1) {
1128 return -1;
1129 }
1130 }
1131 else {
1132 if (BaseMath_Prepare_ForWrite(self) == -1) {
1133 return -1;
1134 }
1135 }
1136
1138 quat, slice_length, slice_length, seq, "mathutils.Quaternion[slice] = seq") == -1)
1139 {
1140 return -1;
1141 }
1142
1143 Py_ssize_t index = start;
1144 for (Py_ssize_t i = 0; i < slice_length; i++, index += step) {
1145 BLI_assert(index >= 0 && index < QUAT_SIZE);
1146 self->quat[index] = quat[i];
1147 }
1148
1149 (void)BaseMath_WriteCallback(self);
1150 return 0;
1151}
1152
1154static PyObject *Quaternion_subscript(QuaternionObject *self, PyObject *item)
1155{
1156 if (PyIndex_Check(item)) {
1157 Py_ssize_t i;
1158 i = PyNumber_AsSsize_t(item, PyExc_IndexError);
1159 if (i == -1 && PyErr_Occurred()) {
1160 return nullptr;
1161 }
1162 if (i < 0) {
1163 i += QUAT_SIZE;
1164 }
1165 return Quaternion_item(self, i);
1166 }
1167 if (PySlice_Check(item)) {
1168 Py_ssize_t start, stop, step, slice_length;
1169
1170 if (PySlice_GetIndicesEx(item, QUAT_SIZE, &start, &stop, &step, &slice_length) < 0) {
1171 return nullptr;
1172 }
1173
1174 return Quaternion_slice(self, start, step, slice_length);
1175 }
1176
1177 PyErr_Format(
1178 PyExc_TypeError, "quaternion indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
1179 return nullptr;
1180}
1181
1183static int Quaternion_ass_subscript(QuaternionObject *self, PyObject *item, PyObject *value)
1184{
1185 if (PyIndex_Check(item)) {
1186 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
1187 if (i == -1 && PyErr_Occurred()) {
1188 return -1;
1189 }
1190 if (i < 0) {
1191 i += QUAT_SIZE;
1192 }
1193 return Quaternion_ass_item(self, i, value);
1194 }
1195 if (PySlice_Check(item)) {
1196 Py_ssize_t start, stop, step, slice_length;
1197
1198 if (PySlice_GetIndicesEx(item, QUAT_SIZE, &start, &stop, &step, &slice_length) < 0) {
1199 return -1;
1200 }
1201
1202 return Quaternion_ass_slice(self, start, step, slice_length, value);
1203 }
1204
1205 PyErr_Format(
1206 PyExc_TypeError, "quaternion indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
1207 return -1;
1208}
1209
1211
1212/* -------------------------------------------------------------------- */
1215
1217static PyObject *Quaternion_add(PyObject *q1, PyObject *q2)
1218{
1219 float quat[QUAT_SIZE];
1220 QuaternionObject *quat1 = nullptr, *quat2 = nullptr;
1221
1223 PyErr_Format(PyExc_TypeError,
1224 "Quaternion addition: (%s + %s) "
1225 "invalid type for this operation",
1226 Py_TYPE(q1)->tp_name,
1227 Py_TYPE(q2)->tp_name);
1228 return nullptr;
1229 }
1230 quat1 = reinterpret_cast<QuaternionObject *>(q1);
1231 quat2 = reinterpret_cast<QuaternionObject *>(q2);
1232
1233 if (BaseMath_ReadCallback(quat1) == -1 || BaseMath_ReadCallback(quat2) == -1) {
1234 return nullptr;
1235 }
1236
1237 add_qt_qtqt(quat, quat1->quat, quat2->quat, 1.0f);
1238 return Quaternion_CreatePyObject(quat, Py_TYPE(q1));
1239}
1240
1242static PyObject *Quaternion_sub(PyObject *q1, PyObject *q2)
1243{
1244 int x;
1245 float quat[QUAT_SIZE];
1246 QuaternionObject *quat1 = nullptr, *quat2 = nullptr;
1247
1249 PyErr_Format(PyExc_TypeError,
1250 "Quaternion subtraction: (%s - %s) "
1251 "invalid type for this operation",
1252 Py_TYPE(q1)->tp_name,
1253 Py_TYPE(q2)->tp_name);
1254 return nullptr;
1255 }
1256
1257 quat1 = reinterpret_cast<QuaternionObject *>(q1);
1258 quat2 = reinterpret_cast<QuaternionObject *>(q2);
1259
1260 if (BaseMath_ReadCallback(quat1) == -1 || BaseMath_ReadCallback(quat2) == -1) {
1261 return nullptr;
1262 }
1263
1264 for (x = 0; x < QUAT_SIZE; x++) {
1265 quat[x] = quat1->quat[x] - quat2->quat[x];
1266 }
1267
1268 return Quaternion_CreatePyObject(quat, Py_TYPE(q1));
1269}
1270
1271static PyObject *quat_mul_float(QuaternionObject *quat, const float scalar)
1272{
1273 float tquat[4];
1274 copy_qt_qt(tquat, quat->quat);
1275 mul_qt_fl(tquat, scalar);
1276 return Quaternion_CreatePyObject(tquat, Py_TYPE(quat));
1277}
1278
1280static PyObject *Quaternion_mul(PyObject *q1, PyObject *q2)
1281{
1282 float scalar;
1283 QuaternionObject *quat1 = nullptr, *quat2 = nullptr;
1284
1285 if (QuaternionObject_Check(q1)) {
1286 quat1 = reinterpret_cast<QuaternionObject *>(q1);
1287 if (BaseMath_ReadCallback(quat1) == -1) {
1288 return nullptr;
1289 }
1290 }
1291 if (QuaternionObject_Check(q2)) {
1292 quat2 = reinterpret_cast<QuaternionObject *>(q2);
1293 if (BaseMath_ReadCallback(quat2) == -1) {
1294 return nullptr;
1295 }
1296 }
1297
1298 if (quat1 && quat2) { /* QUAT * QUAT (element-wise product) */
1299 float quat[QUAT_SIZE];
1300 mul_vn_vnvn(quat, quat1->quat, quat2->quat, QUAT_SIZE);
1301 return Quaternion_CreatePyObject(quat, Py_TYPE(q1));
1302 }
1303 /* the only case this can happen (for a supported type is "FLOAT * QUAT") */
1304 if (quat2) { /* FLOAT * QUAT */
1305 if (((scalar = PyFloat_AsDouble(q1)) == -1.0f && PyErr_Occurred()) == 0) {
1306 return quat_mul_float(quat2, scalar);
1307 }
1308 }
1309 else if (quat1) { /* QUAT * FLOAT */
1310 if (((scalar = PyFloat_AsDouble(q2)) == -1.0f && PyErr_Occurred()) == 0) {
1311 return quat_mul_float(quat1, scalar);
1312 }
1313 }
1314
1315 PyErr_Format(PyExc_TypeError,
1316 "Element-wise multiplication: "
1317 "not supported between '%.200s' and '%.200s' types",
1318 Py_TYPE(q1)->tp_name,
1319 Py_TYPE(q2)->tp_name);
1320 return nullptr;
1321}
1322
1324static PyObject *Quaternion_imul(PyObject *q1, PyObject *q2)
1325{
1326 float scalar;
1327 QuaternionObject *quat1 = nullptr, *quat2 = nullptr;
1328
1329 if (QuaternionObject_Check(q1)) {
1330 quat1 = reinterpret_cast<QuaternionObject *>(q1);
1331 if (BaseMath_ReadCallback(quat1) == -1) {
1332 return nullptr;
1333 }
1334 }
1335 if (QuaternionObject_Check(q2)) {
1336 quat2 = reinterpret_cast<QuaternionObject *>(q2);
1337 if (BaseMath_ReadCallback(quat2) == -1) {
1338 return nullptr;
1339 }
1340 }
1341
1342 if (quat1 && quat2) { /* QUAT *= QUAT (in-place element-wise product). */
1343 mul_vn_vn(quat1->quat, quat2->quat, QUAT_SIZE);
1344 }
1345 else if (quat1 && (((scalar = PyFloat_AsDouble(q2)) == -1.0f && PyErr_Occurred()) == 0)) {
1346 /* QUAT *= FLOAT */
1347 mul_qt_fl(quat1->quat, scalar);
1348 }
1349 else {
1350 PyErr_Format(PyExc_TypeError,
1351 "Element-wise multiplication: "
1352 "not supported between '%.200s' and '%.200s' types",
1353 Py_TYPE(q1)->tp_name,
1354 Py_TYPE(q2)->tp_name);
1355 return nullptr;
1356 }
1357
1358 (void)BaseMath_WriteCallback(quat1);
1359 Py_INCREF(q1);
1360 return q1;
1361}
1362
1364static PyObject *Quaternion_matmul(PyObject *q1, PyObject *q2)
1365{
1366 float quat[QUAT_SIZE];
1367 QuaternionObject *quat1 = nullptr, *quat2 = nullptr;
1368
1369 if (QuaternionObject_Check(q1)) {
1370 quat1 = reinterpret_cast<QuaternionObject *>(q1);
1371 if (BaseMath_ReadCallback(quat1) == -1) {
1372 return nullptr;
1373 }
1374 }
1375 if (QuaternionObject_Check(q2)) {
1376 quat2 = reinterpret_cast<QuaternionObject *>(q2);
1377 if (BaseMath_ReadCallback(quat2) == -1) {
1378 return nullptr;
1379 }
1380 }
1381
1382 if (quat1 && quat2) { /* QUAT @ QUAT (cross product) */
1383 mul_qt_qtqt(quat, quat1->quat, quat2->quat);
1384 return Quaternion_CreatePyObject(quat, Py_TYPE(q1));
1385 }
1386 if (quat1) {
1387 /* QUAT @ VEC */
1388 if (VectorObject_Check(q2)) {
1389 VectorObject *vec2 = reinterpret_cast<VectorObject *>(q2);
1390 float tvec[3];
1391
1392 if (vec2->vec_num != 3) {
1393 PyErr_SetString(PyExc_ValueError,
1394 "Vector multiplication: "
1395 "only 3D vector rotations (with quats) "
1396 "currently supported");
1397 return nullptr;
1398 }
1399 if (BaseMath_ReadCallback(vec2) == -1) {
1400 return nullptr;
1401 }
1402
1403 copy_v3_v3(tvec, vec2->vec);
1404 mul_qt_v3(quat1->quat, tvec);
1405
1406 return Vector_CreatePyObject(tvec, 3, Py_TYPE(vec2));
1407 }
1408 }
1409
1410 PyErr_Format(PyExc_TypeError,
1411 "Quaternion multiplication: "
1412 "not supported between '%.200s' and '%.200s' types",
1413 Py_TYPE(q1)->tp_name,
1414 Py_TYPE(q2)->tp_name);
1415 return nullptr;
1416}
1417
1419static PyObject *Quaternion_imatmul(PyObject *q1, PyObject *q2)
1420{
1421 float quat[QUAT_SIZE];
1422 QuaternionObject *quat1 = nullptr, *quat2 = nullptr;
1423
1424 if (QuaternionObject_Check(q1)) {
1425 quat1 = reinterpret_cast<QuaternionObject *>(q1);
1426 if (BaseMath_ReadCallback(quat1) == -1) {
1427 return nullptr;
1428 }
1429 }
1430 if (QuaternionObject_Check(q2)) {
1431 quat2 = reinterpret_cast<QuaternionObject *>(q2);
1432 if (BaseMath_ReadCallback(quat2) == -1) {
1433 return nullptr;
1434 }
1435 }
1436
1437 if (quat1 && quat2) { /* QUAT @ QUAT (cross product) */
1438 mul_qt_qtqt(quat, quat1->quat, quat2->quat);
1439 copy_qt_qt(quat1->quat, quat);
1440 }
1441 else {
1442 PyErr_Format(PyExc_TypeError,
1443 "In place quaternion multiplication: "
1444 "not supported between '%.200s' and '%.200s' types",
1445 Py_TYPE(q1)->tp_name,
1446 Py_TYPE(q2)->tp_name);
1447 return nullptr;
1448 }
1449
1450 (void)BaseMath_WriteCallback(quat1);
1451 Py_INCREF(q1);
1452 return q1;
1453}
1454
1456static PyObject *Quaternion_neg(QuaternionObject *self)
1457{
1458 float tquat[QUAT_SIZE];
1459
1460 if (BaseMath_ReadCallback(self) == -1) {
1461 return nullptr;
1462 }
1463
1464 negate_v4_v4(tquat, self->quat);
1465 return Quaternion_CreatePyObject(tquat, Py_TYPE(self));
1466}
1467
1469
1470/* -------------------------------------------------------------------- */
1473
1474static PySequenceMethods Quaternion_SeqMethods = {
1475 /*sq_length*/ reinterpret_cast<lenfunc>(Quaternion_len),
1476 /*sq_concat*/ nullptr,
1477 /*sq_repeat*/ nullptr,
1478 /*sq_item*/ reinterpret_cast<ssizeargfunc>(Quaternion_item),
1479 /*was_sq_slice*/ nullptr, /* DEPRECATED. */
1480 /*sq_ass_item*/ reinterpret_cast<ssizeobjargproc>(Quaternion_ass_item),
1481 /*was_sq_ass_slice*/ nullptr, /* DEPRECATED. */
1482 /*sq_contains*/ nullptr,
1483 /*sq_inplace_concat*/ nullptr,
1484 /*sq_inplace_repeat*/ nullptr,
1485};
1486
1487static PyMappingMethods Quaternion_AsMapping = {
1488 /*mp_length*/ reinterpret_cast<lenfunc>(Quaternion_len),
1489 /*mp_subscript*/ reinterpret_cast<binaryfunc>(Quaternion_subscript),
1490 /*mp_ass_subscript*/ reinterpret_cast<objobjargproc>(Quaternion_ass_subscript),
1491};
1492
1493static PyNumberMethods Quaternion_NumMethods = {
1494 /*nb_add*/ static_cast<binaryfunc>(Quaternion_add),
1495 /*nb_subtract*/ static_cast<binaryfunc>(Quaternion_sub),
1496 /*nb_multiply*/ static_cast<binaryfunc>(Quaternion_mul),
1497 /*nb_remainder*/ nullptr,
1498 /*nb_divmod*/ nullptr,
1499 /*nb_power*/ nullptr,
1500 /*nb_negative*/ reinterpret_cast<unaryfunc>(Quaternion_neg),
1501 /*nb_positive*/ reinterpret_cast<unaryfunc>(Quaternion_copy),
1502 /*nb_absolute*/ nullptr,
1503 /*nb_bool*/ nullptr,
1504 /*nb_invert*/ nullptr,
1505 /*nb_lshift*/ nullptr,
1506 /*nb_rshift*/ nullptr,
1507 /*nb_and*/ nullptr,
1508 /*nb_xor*/ nullptr,
1509 /*nb_or*/ nullptr,
1510 /*nb_int*/ nullptr,
1511 /*nb_reserved*/ nullptr,
1512 /*nb_float*/ nullptr,
1513 /*nb_inplace_add*/ nullptr,
1514 /*nb_inplace_subtract*/ nullptr,
1515 /*nb_inplace_multiply*/ static_cast<binaryfunc>(Quaternion_imul),
1516 /*nb_inplace_remainder*/ nullptr,
1517 /*nb_inplace_power*/ nullptr,
1518 /*nb_inplace_lshift*/ nullptr,
1519 /*nb_inplace_rshift*/ nullptr,
1520 /*nb_inplace_and*/ nullptr,
1521 /*nb_inplace_xor*/ nullptr,
1522 /*nb_inplace_or*/ nullptr,
1523 /*nb_floor_divide*/ nullptr,
1524 /*nb_true_divide*/ nullptr,
1525 /*nb_inplace_floor_divide*/ nullptr,
1526 /*nb_inplace_true_divide*/ nullptr,
1527 /*nb_index*/ nullptr,
1528 /*nb_matrix_multiply*/ static_cast<binaryfunc>(Quaternion_matmul),
1529 /*nb_inplace_matrix_multiply*/ static_cast<binaryfunc>(Quaternion_imatmul),
1530};
1531
1533
1534/* -------------------------------------------------------------------- */
1537
1539 /* Wrap. */
1540 Quaternion_axis_doc,
1541 "Quaternion component value.\n"
1542 "\n"
1543 ":type: float\n");
1544static PyObject *Quaternion_axis_get(QuaternionObject *self, void *type)
1545{
1546 return Quaternion_item(self, POINTER_AS_INT(type));
1547}
1548
1549static int Quaternion_axis_set(QuaternionObject *self, PyObject *value, void *type)
1550{
1551 return Quaternion_ass_item(self, POINTER_AS_INT(type), value);
1552}
1553
1555 /* Wrap. */
1556 Quaternion_magnitude_doc,
1557 "Size of the quaternion (read-only).\n"
1558 "\n"
1559 ":type: float\n");
1560static PyObject *Quaternion_magnitude_get(QuaternionObject *self, void * /*closure*/)
1561{
1562 if (BaseMath_ReadCallback(self) == -1) {
1563 return nullptr;
1564 }
1565
1566 return PyFloat_FromDouble(sqrtf(dot_qtqt(self->quat, self->quat)));
1567}
1568
1570 /* Wrap. */
1571 Quaternion_angle_doc,
1572 "Angle of the quaternion.\n"
1573 "\n"
1574 ":type: float\n");
1575static PyObject *Quaternion_angle_get(QuaternionObject *self, void * /*closure*/)
1576{
1577 float tquat[4];
1578 float angle;
1579
1580 if (BaseMath_ReadCallback(self) == -1) {
1581 return nullptr;
1582 }
1583
1584 normalize_qt_qt(tquat, self->quat);
1585
1586 angle = 2.0f * safe_acosf(tquat[0]);
1587
1589
1590 return PyFloat_FromDouble(angle);
1591}
1592
1593static int Quaternion_angle_set(QuaternionObject *self, PyObject *value, void * /*closure*/)
1594{
1595 float tquat[4];
1596 float len;
1597
1598 float axis[3], angle_dummy;
1599 float angle;
1600
1601 if (BaseMath_ReadCallback_ForWrite(self) == -1) {
1602 return -1;
1603 }
1604
1605 len = normalize_qt_qt(tquat, self->quat);
1606 quat_to_axis_angle(axis, &angle_dummy, tquat);
1607
1608 angle = PyFloat_AsDouble(value);
1609
1610 if (angle == -1.0f && PyErr_Occurred()) { /* parsed item not a number */
1611 PyErr_SetString(PyExc_TypeError, "Quaternion.angle = value: float expected");
1612 return -1;
1613 }
1614
1616
1618
1619 axis_angle_to_quat(self->quat, axis, angle);
1620 mul_qt_fl(self->quat, len);
1621
1622 if (BaseMath_WriteCallback(self) == -1) {
1623 return -1;
1624 }
1625
1626 return 0;
1627}
1628
1630 /* Wrap. */
1631 Quaternion_axis_vector_doc,
1632 "Quaternion axis as a vector.\n"
1633 "\n"
1634 ":type: :class:`Vector`\n");
1635static PyObject *Quaternion_axis_vector_get(QuaternionObject *self, void * /*closure*/)
1636{
1637 float tquat[4];
1638
1639 float axis[3];
1640 float angle_dummy;
1641
1642 if (BaseMath_ReadCallback(self) == -1) {
1643 return nullptr;
1644 }
1645
1646 normalize_qt_qt(tquat, self->quat);
1647 quat_to_axis_angle(axis, &angle_dummy, tquat);
1648
1649 quat__axis_angle_sanitize(axis, nullptr);
1650
1651 return Vector_CreatePyObject(axis, 3, nullptr);
1652}
1653
1654static int Quaternion_axis_vector_set(QuaternionObject *self, PyObject *value, void * /*closure*/)
1655{
1656 float tquat[4];
1657 float len;
1658
1659 float axis[3];
1660 float angle;
1661
1662 if (BaseMath_ReadCallback_ForWrite(self) == -1) {
1663 return -1;
1664 }
1665
1666 len = normalize_qt_qt(tquat, self->quat);
1667 quat_to_axis_angle(axis, &angle, tquat); /* axis value is unused */
1668
1669 if (mathutils_array_parse(axis, 3, 3, value, "quat.axis = other") == -1) {
1670 return -1;
1671 }
1672
1674
1675 axis_angle_to_quat(self->quat, axis, angle);
1676 mul_qt_fl(self->quat, len);
1677
1678 if (BaseMath_WriteCallback(self) == -1) {
1679 return -1;
1680 }
1681
1682 return 0;
1683}
1684
1686
1687/* -------------------------------------------------------------------- */
1690
1691static PyGetSetDef Quaternion_getseters[] = {
1692 {"w",
1693 reinterpret_cast<getter>(Quaternion_axis_get),
1694 reinterpret_cast<setter>(Quaternion_axis_set),
1695 Quaternion_axis_doc,
1696 POINTER_FROM_INT(0)},
1697 {"x",
1698 reinterpret_cast<getter>(Quaternion_axis_get),
1699 reinterpret_cast<setter>(Quaternion_axis_set),
1700 Quaternion_axis_doc,
1701 POINTER_FROM_INT(1)},
1702 {"y",
1703 reinterpret_cast<getter>(Quaternion_axis_get),
1704 reinterpret_cast<setter>(Quaternion_axis_set),
1705 Quaternion_axis_doc,
1706 POINTER_FROM_INT(2)},
1707 {"z",
1708 reinterpret_cast<getter>(Quaternion_axis_get),
1709 reinterpret_cast<setter>(Quaternion_axis_set),
1710 Quaternion_axis_doc,
1711 POINTER_FROM_INT(3)},
1712 {"magnitude",
1713 reinterpret_cast<getter>(Quaternion_magnitude_get),
1714 static_cast<setter>(nullptr),
1715 Quaternion_magnitude_doc,
1716 nullptr},
1717 {"angle",
1718 reinterpret_cast<getter>(Quaternion_angle_get),
1719 reinterpret_cast<setter>(Quaternion_angle_set),
1720 Quaternion_angle_doc,
1721 nullptr},
1722 {"axis",
1723 reinterpret_cast<getter>(Quaternion_axis_vector_get),
1724 reinterpret_cast<setter>(Quaternion_axis_vector_set),
1725 Quaternion_axis_vector_doc,
1726 nullptr},
1727 {"is_wrapped",
1728 reinterpret_cast<getter>(BaseMathObject_is_wrapped_get),
1729 static_cast<setter>(nullptr),
1731 nullptr},
1732 {"is_frozen",
1733 reinterpret_cast<getter>(BaseMathObject_is_frozen_get),
1734 static_cast<setter>(nullptr),
1736 nullptr},
1737 {"is_valid",
1738 reinterpret_cast<getter>(BaseMathObject_is_valid_get),
1739 static_cast<setter>(nullptr),
1741 nullptr},
1742 {"owner",
1743 reinterpret_cast<getter>(BaseMathObject_owner_get),
1744 static_cast<setter>(nullptr),
1746 nullptr},
1747 {nullptr, nullptr, nullptr, nullptr, nullptr} /* Sentinel */
1748};
1749
1751
1752/* -------------------------------------------------------------------- */
1755
1756#ifdef __GNUC__
1757# ifdef __clang__
1758# pragma clang diagnostic push
1759# pragma clang diagnostic ignored "-Wcast-function-type"
1760# else
1761# pragma GCC diagnostic push
1762# pragma GCC diagnostic ignored "-Wcast-function-type"
1763# endif
1764#endif
1765
1766static PyMethodDef Quaternion_methods[] = {
1767 /* In place only. */
1768 {"identity",
1769 reinterpret_cast<PyCFunction>(Quaternion_identity),
1770 METH_NOARGS,
1771 Quaternion_identity_doc},
1772 {"negate",
1773 reinterpret_cast<PyCFunction>(Quaternion_negate),
1774 METH_NOARGS,
1775 Quaternion_negate_doc},
1776
1777 /* Operate on original or copy. */
1778 {"conjugate",
1779 reinterpret_cast<PyCFunction>(Quaternion_conjugate),
1780 METH_NOARGS,
1781 Quaternion_conjugate_doc},
1782 {"conjugated",
1783 reinterpret_cast<PyCFunction>(Quaternion_conjugated),
1784 METH_NOARGS,
1785 Quaternion_conjugated_doc},
1786
1787 {"invert",
1788 reinterpret_cast<PyCFunction>(Quaternion_invert),
1789 METH_NOARGS,
1790 Quaternion_invert_doc},
1791 {"inverted",
1792 reinterpret_cast<PyCFunction>(Quaternion_inverted),
1793 METH_NOARGS,
1794 Quaternion_inverted_doc},
1795
1796 {"normalize",
1797 reinterpret_cast<PyCFunction>(Quaternion_normalize),
1798 METH_NOARGS,
1799 Quaternion_normalize_doc},
1800 {"normalized",
1801 reinterpret_cast<PyCFunction>(Quaternion_normalized),
1802 METH_NOARGS,
1803 Quaternion_normalized_doc},
1804
1805 /* Return converted representation. */
1806 {"to_euler",
1807 reinterpret_cast<PyCFunction>(Quaternion_to_euler),
1808 METH_VARARGS,
1809 Quaternion_to_euler_doc},
1810 {"to_matrix",
1811 reinterpret_cast<PyCFunction>(Quaternion_to_matrix),
1812 METH_NOARGS,
1813 Quaternion_to_matrix_doc},
1814 {"to_axis_angle",
1815 reinterpret_cast<PyCFunction>(Quaternion_to_axis_angle),
1816 METH_NOARGS,
1817 Quaternion_to_axis_angle_doc},
1818 {"to_swing_twist",
1819 reinterpret_cast<PyCFunction>(Quaternion_to_swing_twist),
1820 METH_O,
1821 Quaternion_to_swing_twist_doc},
1822 {"to_exponential_map",
1823 reinterpret_cast<PyCFunction>(Quaternion_to_exponential_map),
1824 METH_NOARGS,
1825 Quaternion_to_exponential_map_doc},
1826
1827 /* Operation between 2 or more types. */
1828 {"cross", reinterpret_cast<PyCFunction>(Quaternion_cross), METH_O, Quaternion_cross_doc},
1829 {"dot", reinterpret_cast<PyCFunction>(Quaternion_dot), METH_O, Quaternion_dot_doc},
1830 {"rotation_difference",
1831 reinterpret_cast<PyCFunction>(Quaternion_rotation_difference),
1832 METH_O,
1833 Quaternion_rotation_difference_doc},
1834 {"slerp", reinterpret_cast<PyCFunction>(Quaternion_slerp), METH_VARARGS, Quaternion_slerp_doc},
1835 {"rotate", reinterpret_cast<PyCFunction>(Quaternion_rotate), METH_O, Quaternion_rotate_doc},
1836 {"make_compatible",
1837 reinterpret_cast<PyCFunction>(Quaternion_make_compatible),
1838 METH_O,
1839 Quaternion_make_compatible_doc},
1840
1841 /* Base-math methods. */
1842 {"freeze",
1843 reinterpret_cast<PyCFunction>(BaseMathObject_freeze),
1844 METH_NOARGS,
1846
1847 {"copy", reinterpret_cast<PyCFunction>(Quaternion_copy), METH_NOARGS, Quaternion_copy_doc},
1848 {"__copy__", reinterpret_cast<PyCFunction>(Quaternion_copy), METH_NOARGS, Quaternion_copy_doc},
1849 {"__deepcopy__",
1850 reinterpret_cast<PyCFunction>(Quaternion_deepcopy),
1851 METH_VARARGS,
1852 Quaternion_copy_doc},
1853 {nullptr, nullptr, 0, nullptr},
1854};
1855
1856#ifdef __GNUC__
1857# ifdef __clang__
1858# pragma clang diagnostic pop
1859# else
1860# pragma GCC diagnostic pop
1861# endif
1862#endif
1863
1865
1866/* -------------------------------------------------------------------- */
1869
1870#ifdef MATH_STANDALONE
1871# define Quaternion_str nullptr
1872#endif
1873
1875 /* Wrap. */
1876 quaternion_doc,
1877 ".. class:: Quaternion(seq=(1.0, 0.0, 0.0, 0.0), angle=0.0, /)\n"
1878 "\n"
1879 " This object gives access to Quaternions in Blender.\n"
1880 "\n"
1881 " :param seq: A (w, x, y, z) quaternion, a 3D exponential map vector,\n"
1882 " or a 3D axis vector (when *angle* is also provided).\n"
1883 " :type seq: Sequence[float]\n"
1884 " :param angle: rotation angle, in radians\n"
1885 " :type angle: float\n"
1886 "\n"
1887 " The constructor takes arguments in various forms:\n"
1888 "\n"
1889 " (), *no args*\n"
1890 " Create an identity quaternion\n"
1891 " (*wxyz*)\n"
1892 " Create a quaternion from a ``(w, x, y, z)`` vector.\n"
1893 " (*exponential_map*)\n"
1894 " Create a quaternion from a 3d exponential map vector.\n"
1895 "\n"
1896 " .. seealso:: :meth:`to_exponential_map`\n"
1897 " (*axis, angle*)\n"
1898 " Create a quaternion representing a rotation of *angle* radians over *axis*.\n"
1899 "\n"
1900 " .. seealso:: :meth:`to_axis_angle`\n");
1901PyTypeObject quaternion_Type = {
1902 /*ob_base*/ PyVarObject_HEAD_INIT(nullptr, 0)
1903 /*tp_name*/ "Quaternion",
1904 /*tp_basicsize*/ sizeof(QuaternionObject),
1905 /*tp_itemsize*/ 0,
1906 /*tp_dealloc*/ reinterpret_cast<destructor>(BaseMathObject_dealloc),
1907 /*tp_vectorcall_offset*/ 0,
1908 /*tp_getattr*/ nullptr,
1909 /*tp_setattr*/ nullptr,
1910 /*tp_as_async*/ nullptr,
1911 /*tp_repr*/ reinterpret_cast<reprfunc>(Quaternion_repr),
1912 /*tp_as_number*/ &Quaternion_NumMethods,
1913 /*tp_as_sequence*/ &Quaternion_SeqMethods,
1914 /*tp_as_mapping*/ &Quaternion_AsMapping,
1915 /*tp_hash*/ reinterpret_cast<hashfunc>(Quaternion_hash),
1916 /*tp_call*/ nullptr,
1917 /*tp_str*/ reinterpret_cast<reprfunc>(Quaternion_str),
1918 /*tp_getattro*/ nullptr,
1919 /*tp_setattro*/ nullptr,
1920 /*tp_as_buffer*/ &Quaternion_as_buffer,
1921 /*tp_flags*/ Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
1922 /*tp_doc*/ quaternion_doc,
1923 /*tp_traverse*/ reinterpret_cast<traverseproc>(BaseMathObject_traverse),
1924 /*tp_clear*/ reinterpret_cast<inquiry>(BaseMathObject_clear),
1925 /*tp_richcompare*/ static_cast<richcmpfunc>(Quaternion_richcmpr),
1926 /*tp_weaklistoffset*/ 0,
1927 /*tp_iter*/ nullptr,
1928 /*tp_iternext*/ nullptr,
1929 /*tp_methods*/ Quaternion_methods,
1930 /*tp_members*/ nullptr,
1931 /*tp_getset*/ Quaternion_getseters,
1932 /*tp_base*/ nullptr,
1933 /*tp_dict*/ nullptr,
1934 /*tp_descr_get*/ nullptr,
1935 /*tp_descr_set*/ nullptr,
1936 /*tp_dictoffset*/ 0,
1937 /*tp_init*/ nullptr,
1938 /*tp_alloc*/ nullptr,
1939 /*tp_new*/ Quaternion_new,
1940 /*tp_free*/ nullptr,
1941 /*tp_is_gc*/ reinterpret_cast<inquiry>(BaseMathObject_is_gc),
1942 /*tp_bases*/ nullptr,
1943 /*tp_mro*/ nullptr,
1944 /*tp_cache*/ nullptr,
1945 /*tp_subclasses*/ nullptr,
1946 /*tp_weaklist*/ nullptr,
1947 /*tp_del*/ nullptr,
1948 /*tp_version_tag*/ 0,
1949 /*tp_finalize*/ nullptr,
1950 /*tp_vectorcall*/ Quaternion_vectorcall,
1951};
1952
1953#ifdef MATH_STANDALONE
1954# undef Quaternion_str
1955#endif
1956
1958
1959/* -------------------------------------------------------------------- */
1962
1963PyObject *Quaternion_CreatePyObject(const float quat[4], PyTypeObject *base_type)
1964{
1965 QuaternionObject *self;
1966 float *quat_alloc;
1967
1968 quat_alloc = static_cast<float *>(PyMem_Malloc(QUAT_SIZE * sizeof(float)));
1969 if (quat_alloc == nullptr) [[unlikely]] {
1970 PyErr_SetString(PyExc_MemoryError,
1971 "Quaternion(): "
1972 "problem allocating data");
1973 return nullptr;
1974 }
1975
1977 if (self) {
1978 self->quat = quat_alloc;
1979 /* init callbacks as nullptr */
1980 self->cb_user = nullptr;
1981 self->cb_type = self->cb_subtype = 0;
1982
1983 /* NEW */
1984 if (!quat) { /* new empty */
1985 unit_qt(self->quat);
1986 }
1987 else {
1988 copy_qt_qt(self->quat, quat);
1989 }
1990 self->flag = BASE_MATH_FLAG_DEFAULT;
1991 }
1992 else {
1993 PyMem_Free(quat_alloc);
1994 }
1995
1996 return reinterpret_cast<PyObject *>(self);
1997}
1998
1999PyObject *Quaternion_CreatePyObject_wrap(float quat[4], PyTypeObject *base_type)
2000{
2001 QuaternionObject *self;
2002
2004 if (self) {
2005 /* init callbacks as nullptr */
2006 self->cb_user = nullptr;
2007 self->cb_type = self->cb_subtype = 0;
2008
2009 /* WRAP */
2010 self->quat = quat;
2012 }
2013 return reinterpret_cast<PyObject *>(self);
2014}
2015
2016PyObject *Quaternion_CreatePyObject_cb(PyObject *cb_user, uchar cb_type, uchar cb_subtype)
2017{
2018 QuaternionObject *self = reinterpret_cast<QuaternionObject *>(
2019 Quaternion_CreatePyObject(nullptr, nullptr));
2020 if (self) {
2021 Py_INCREF(cb_user);
2022 self->cb_user = cb_user;
2023 self->cb_type = cb_type;
2024 self->cb_subtype = cb_subtype;
2025 BLI_assert(!PyObject_GC_IsTracked((PyObject *)self));
2026 PyObject_GC_Track(self);
2027 }
2028
2029 return reinterpret_cast<PyObject *>(self);
2030}
2031
2033
2034} // namespace blender
#define ATTR_FALLTHROUGH
A dynamically sized string ADT.
#define POINTER_FROM_INT(i)
#define POINTER_AS_INT(i)
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
Definition btVector3.h:356
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
float length(VecOp< float, D >) RET
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
#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 QUAT_SIZE
#define QuaternionObject_Check(v)
#define VectorObject_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
static PyObject * Quaternion_conjugated(QuaternionObject *self)
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
void rotation_between_quats_to_quat(float q[4], const float q1[4], const float q2[4])
static PyObject * Quaternion_deepcopy(QuaternionObject *self, PyObject *args)
static PyObject * Quaternion_normalized(QuaternionObject *self)
static PyObject * Quaternion_imul(PyObject *q1, PyObject *q2)
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
static int Quaternion_axis_set(QuaternionObject *self, PyObject *value, void *type)
static PyObject * Quaternion_to_axis_angle(QuaternionObject *self)
void BaseMathObject_dealloc(BaseMathObject *self)
Definition mathutils.cc:766
static PyObject * Quaternion_dot(QuaternionObject *self, PyObject *value)
MINLINE void copy_v3_v3(float r[3], const float a[3])
static PyObject * Quaternion_to_swing_twist(QuaternionObject *self, PyObject *axis_arg)
int PyC_CheckArgs_DeepCopy(PyObject *args)
void conjugate_qt(float q[4])
float quat_split_swing_and_twist(const float q_in[4], int axis, float r_swing[4], float r_twist[4])
static PyObject * Quaternion_axis_get(QuaternionObject *self, void *type)
static PyNumberMethods Quaternion_NumMethods
Py_hash_t mathutils_array_hash(const float *array, size_t array_len)
Definition mathutils.cc:69
void invert_qt(float q[4])
PyObject * mathutils_dynstr_to_py(DynStr *ds)
Definition mathutils.cc:523
static PyObject * Quaternion_angle_get(QuaternionObject *self, void *)
static void Quaternion_releasebuffer(PyObject *, Py_buffer *view)
PyObject * Quaternion_CreatePyObject_cb(PyObject *cb_user, uchar cb_type, uchar cb_subtype)
static PyObject * Quaternion_conjugate(QuaternionObject *self)
static PyObject * quat_mul_float(QuaternionObject *quat, const float scalar)
static PyObject * Quaternion_identity(QuaternionObject *self)
static int Quaternion_ass_item(QuaternionObject *self, Py_ssize_t i, PyObject *ob)
static PyObject * Quaternion_str(QuaternionObject *self)
float normalize_qt(float q[4])
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")
PyObject * BaseMathObject_owner_get(BaseMathObject *self, void *)
Definition mathutils.cc:690
PyTypeObject quaternion_Type
static PyObject * Quaternion_to_euler(QuaternionObject *self, PyObject *args)
float dot_qtqt(const float a[4], const float b[4])
static PyObject * Quaternion_normalize(QuaternionObject *self)
static PyObject * Quaternion_to_tuple_ext(QuaternionObject *self, int ndigits)
MINLINE float safe_acosf(float a)
PyObject * Euler_CreatePyObject(const float eul[3], const short order, PyTypeObject *base_type)
PyTypeObject euler_Type
void quat_to_eul(float eul[3], const float quat[4])
static PyObject * Quaternion_cross(QuaternionObject *self, PyObject *value)
void axis_angle_to_quat(float r[4], const float axis[3], float angle)
void expmap_to_quat(float r[4], const float expmap[3])
double double_round(double x, int ndigits)
Definition math_base.cc:30
PyObject * Quaternion_CreatePyObject_wrap(float quat[4], PyTypeObject *base_type)
int BaseMathObject_clear(BaseMathObject *self)
Definition mathutils.cc:748
static PyObject * Quaternion_add(PyObject *q1, PyObject *q2)
static PyObject * Quaternion_make_compatible(QuaternionObject *self, PyObject *value)
void mul_qt_qtqt(float q[4], const float a[4], const float b[4])
PyObject * BaseMathObject_freeze(BaseMathObject *self)
Definition mathutils.cc:725
static PyObject * Quaternion_inverted(QuaternionObject *self)
static PyObject * quat__apply_to_copy(PyObject *(*quat_func)(QuaternionObject *), QuaternionObject *self)
static int Quaternion_angle_set(QuaternionObject *self, PyObject *value, void *)
int BaseMathObject_is_gc(BaseMathObject *self)
Definition mathutils.cc:788
void quat_to_compatible_eulO(float eul[3], const float oldrot[3], short order, const float quat[4])
static PyGetSetDef Quaternion_getseters[]
void quat_to_compatible_quat(float q[4], const float a[4], const float old[4])
static int Quaternion_getbuffer(PyObject *obj, Py_buffer *view, int flags)
static int Quaternion_ass_subscript(QuaternionObject *self, PyObject *item, PyObject *value)
static PySequenceMethods Quaternion_SeqMethods
void mul_qt_v3(const float q[4], float r[3])
static PyObject * Quaternion_rotate(QuaternionObject *self, PyObject *value)
void unit_qt(float q[4])
void quat_to_mat3(float m[3][3], const float q[4])
PyObject * BaseMathObject_is_frozen_get(BaseMathObject *self, void *)
Definition mathutils.cc:705
void quat_to_compatible_eul(float eul[3], const float oldrot[3], const float quat[4])
static PyObject * Quaternion_to_exponential_map(QuaternionObject *self)
PyObject * Vector_CreatePyObject(const float *vec, const int vec_num, PyTypeObject *base_type)
PyObject * BaseMathObject_is_valid_get(BaseMathObject *self, void *)
Definition mathutils.cc:711
static PyObject * Quaternion_magnitude_get(QuaternionObject *self, void *)
static Py_hash_t Quaternion_hash(QuaternionObject *self)
static PyObject * Quaternion_slice(QuaternionObject *self, Py_ssize_t start, Py_ssize_t step, Py_ssize_t slice_length)
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)
void copy_qt_qt(float q[4], const float a[4])
void interp_qt_qtqt(float q[4], const float a[4], const float b[4], float t)
int EXPP_FloatsAreEqual(float af, float bf, int maxDiff)
Definition mathutils.cc:492
void quat_to_eulO(float e[3], short order, const float q[4])
static int Quaternion_ass_slice(QuaternionObject *self, Py_ssize_t start, Py_ssize_t step, Py_ssize_t slice_length, PyObject *seq)
@ BASE_MATH_FLAG_IS_WRAP
Definition mathutils.hh:39
@ BASE_MATH_FLAG_HAS_BUFFER_VIEW
Definition mathutils.hh:52
int mathutils_array_parse(float *array, int array_num_min, int array_num_max, PyObject *value, const char *error_prefix)
Definition mathutils.cc:97
void quat_to_axis_angle(float axis[3], float *angle, const float q[4])
static PyObject * Quaternion_negate(QuaternionObject *self)
static PyObject * Quaternion_subscript(QuaternionObject *self, PyObject *item)
void mul_vn_vn(float *array_tar, const float *array_src, int size)
static PyObject * Quaternion_imatmul(PyObject *q1, PyObject *q2)
static PyObject * Quaternion_invert(QuaternionObject *self)
static PyObject * Quaternion_sub(PyObject *q1, PyObject *q2)
static PyObject * Quaternion_item(QuaternionObject *self, Py_ssize_t i)
short euler_order_from_string(const char *str, const char *error_prefix)
static PyMethodDef Quaternion_methods[]
static PyBufferProcs Quaternion_as_buffer
static PyObject * Quaternion_rotation_difference(QuaternionObject *self, PyObject *value)
static PyObject * Quaternion_axis_vector_get(QuaternionObject *self, void *)
static PyObject * Quaternion_matmul(PyObject *q1, PyObject *q2)
static PyObject * Quaternion_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
PyObject * BaseMathObject_is_wrapped_get(BaseMathObject *self, void *)
Definition mathutils.cc:698
char BaseMathObject_is_valid_doc[]
Definition mathutils.cc:710
static PyObject * Quaternion_repr(QuaternionObject *self)
int BaseMathObject_traverse(BaseMathObject *self, visitproc visit, void *arg)
Definition mathutils.cc:742
void add_qt_qtqt(float q[4], const float a[4], const float b[4], float t)
int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error_prefix)
Definition mathutils.cc:426
void quat_to_expmap(float expmap[3], const float q[4])
static PyObject * Quaternion_slerp(QuaternionObject *self, PyObject *args)
char BaseMathObject_is_frozen_doc[]
Definition mathutils.cc:703
static PyObject * Quaternion_to_matrix(QuaternionObject *self)
static PyObject * Quaternion_vectorcall(PyObject *type, PyObject *const *args, const size_t nargsf, PyObject *kwnames)
void mul_vn_vnvn(float *array_tar, const float *array_src_a, const float *array_src_b, int size)
static PyObject * Quaternion_richcmpr(PyObject *a, PyObject *b, int op)
static PyObject * Quaternion_copy(QuaternionObject *self)
void mul_m3_m3m3(float R[3][3], const float A[3][3], const float B[3][3])
static void quat__axis_angle_sanitize(float axis[3], float *angle)
MINLINE void negate_v4_v4(float r[4], const float a[4])
static PyObject * Quaternion_mul(PyObject *q1, PyObject *q2)
static int Quaternion_axis_vector_set(QuaternionObject *self, PyObject *value, void *)
DynStr * BLI_dynstr_new() ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
Definition BLI_dynstr.cc:39
static PyObject * Quaternion_neg(QuaternionObject *self)
int PyC_ParseTypeOrNone(PyObject *o, void *p)
static Py_ssize_t Quaternion_len(QuaternionObject *)
void mul_qt_fl(float q[4], float f)
MINLINE bool is_zero_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
void mat3_to_quat(float q[4], const float mat[3][3])
static PyMappingMethods Quaternion_AsMapping
char BaseMathObject_is_wrapped_doc[]
Definition mathutils.cc:696
float normalize_qt_qt(float r[4], const float q[4])
float angle_wrap_rad(float angle)
#define PyC_TYPE_OR_NONE_INIT(py_type, value_p)
header-only utilities
#define PyTuple_SET_ITEMS(op_arg,...)
#define sqrtf
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float