21#ifndef MATH_STANDALONE
36 static const char order[][4] = {
"XYZ",
"XZY",
"YXZ",
"YZX",
"ZXY",
"ZYX"};
45#define MAKE_ID3(a, b, c) ((a) | ((b) << 8) | ((c) << 16))
47 switch (*(
reinterpret_cast<const int32_t *
>(
str))) {
71 PyErr_Format(PyExc_ValueError,
"%s: invalid euler order '%s'", error_prefix,
str);
87 PyTuple_SET_ITEM(
ret, i, PyFloat_FromDouble(
double_round(
double(self->eul[i]), ndigits)));
92 PyTuple_SET_ITEM(
ret, i, PyFloat_FromDouble(self->eul[i]));
106 PyObject *
const *args,
110 if (kwnames && PyTuple_GET_SIZE(kwnames)) [[unlikely]] {
111 PyErr_SetString(PyExc_TypeError,
112 "mathutils.Euler(): "
113 "takes no keyword args");
120 const size_t nargs = PyVectorcall_NARGS(nargsf);
126 const char *order_str;
128 if (((order_str = PyUnicode_AsUTF8(args[1])) ==
nullptr) ||
142 PyErr_Format(PyExc_TypeError,
143 "mathutils.Euler(): "
144 "takes at most 2 arguments (%zd given)",
152static PyObject *
Euler_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
155 if (kwds && PyDict_GET_SIZE(kwds)) [[unlikely]] {
156 PyErr_SetString(PyExc_TypeError,
157 "mathutils.Euler(): "
158 "takes no keyword args");
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);
174 Euler_to_quaternion_doc,
175 ".. method:: to_quaternion()\n"
177 " Return a quaternion representation of the euler.\n"
179 " :return: Quaternion representation of the euler.\n"
180 " :rtype: :class:`Quaternion`\n");
197 ".. method:: to_matrix()\n"
199 " Return a matrix representation of the euler.\n"
201 " :return: A 3x3 rotation matrix representation of the euler.\n"
202 " :rtype: :class:`Matrix`\n");
219 ".. method:: zero()\n"
221 " Set all values to zero.\n");
239 Euler_rotate_axis_doc,
240 ".. method:: rotate_axis(axis, angle, /)\n"
242 " Rotates the euler a certain amount, wrapping the result to produce\n"
243 " a unique euler rotation (no 720 degree pitches).\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");
254 if (!PyArg_ParseTuple(args,
261 PyErr_SetString(PyExc_TypeError,
262 "Euler.rotate_axis(): "
263 "expected an axis 'X', 'Y', 'Z' and an angle (float)");
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'");
288 ".. method:: rotate(other, /)\n"
290 " Rotates the euler by another mathutils value.\n"
292 " :param other: rotation component of mathutils value\n"
293 " :type other: :class:`Euler` | :class:`Quaternion` | :class:`Matrix`\n");
296 float self_rmat[3][3], other_rmat[3][3], rmat[3][3];
317 Euler_make_compatible_doc,
318 ".. method:: make_compatible(other, /)\n"
320 " Make this euler compatible with another,\n"
321 " so interpolating between them works as intended.\n"
323 " :param other: Other euler rotation.\n"
324 " :type other: :class:`Euler`\n"
326 " .. note:: the rotation order is not taken into account for this function.\n");
339 "euler.make_compatible(other), invalid 'other' arg") == -1)
354 ".. method:: copy()\n"
356 " Returns a copy of this euler.\n"
358 " :return: A copy of the euler.\n"
359 " :rtype: :class:`Euler`\n"
361 " .. note:: use this to get a copy of a wrapped euler with\n"
362 " no reference to the original data.\n");
387 PyObject *
ret, *tuple;
401#ifndef MATH_STANDALONE
413 "<Euler (x=%.4f, y=%.4f, z=%.4f), order='%s'>",
439 memset(view, 0,
sizeof(*view));
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);
446 if ((flags & PyBUF_WRITABLE) == 0) {
449 if (flags & PyBUF_FORMAT) {
450 view->format =
const_cast<char *
>(
"f");
464 if (view->readonly == 0) {
507 res = ok ? Py_False : Py_True;
514 res = Py_NotImplemented;
523 return Py_NewRef(res);
561 PyErr_SetString(PyExc_IndexError,
563 "array index out of range");
571 return PyFloat_FromDouble(self->eul[i]);
583 f = PyFloat_AsDouble(value);
584 if (f == -1 && PyErr_Occurred()) {
585 PyErr_SetString(PyExc_TypeError,
586 "euler[attribute] = x: "
587 "assigned value not a number");
592 PyErr_SetString(PyExc_IndexError,
593 "euler[attribute] = x: "
594 "array assignment index out of range");
611 Py_ssize_t slice_length)
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) {
621 PyTuple_SET_ITEM(tuple, i, PyFloat_FromDouble(self->eul[
index]));
632 EulerObject *self, Py_ssize_t start, Py_ssize_t
step, Py_ssize_t slice_length, PyObject *
seq)
649 eul, slice_length, slice_length,
seq,
"mathutils.Euler[slice] = seq") == -1)
654 Py_ssize_t
index = start;
655 for (Py_ssize_t i = 0; i < slice_length; i++,
index +=
step) {
657 self->eul[
index] = eul[i];
667 if (PyIndex_Check(item)) {
669 i = PyNumber_AsSsize_t(item, PyExc_IndexError);
670 if (i == -1 && PyErr_Occurred()) {
678 if (PySlice_Check(item)) {
679 Py_ssize_t start, stop,
step, slice_length;
681 if (PySlice_GetIndicesEx(item,
EULER_SIZE, &start, &stop, &
step, &slice_length) < 0) {
689 PyExc_TypeError,
"euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
696 if (PyIndex_Check(item)) {
697 Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);
698 if (i == -1 && PyErr_Occurred()) {
706 if (PySlice_Check(item)) {
707 Py_ssize_t start, stop,
step, slice_length;
709 if (PySlice_GetIndicesEx(item,
EULER_SIZE, &start, &stop, &
step, &slice_length) < 0) {
717 PyExc_TypeError,
"euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
757 "Euler axis angle in radians.\n"
775 "Euler rotation order.\n"
777 ":type: Literal['XYZ', 'XZY', 'YXZ', 'YZX', 'ZXY', 'ZYX']\n");
790 const char *order_str;
797 if (((order_str = PyUnicode_AsUTF8(value)) ==
nullptr) ||
838 static_cast<setter
>(
nullptr),
843 static_cast<setter
>(
nullptr),
848 static_cast<setter
>(
nullptr),
853 static_cast<setter
>(
nullptr),
856 {
nullptr,
nullptr,
nullptr,
nullptr,
nullptr} };
866# pragma clang diagnostic push
867# pragma clang diagnostic ignored "-Wcast-function-type"
869# pragma GCC diagnostic push
870# pragma GCC diagnostic ignored "-Wcast-function-type"
875 {
"zero",
reinterpret_cast<PyCFunction
>(
Euler_zero), METH_NOARGS, Euler_zero_doc},
879 Euler_to_matrix_doc},
883 Euler_to_quaternion_doc},
887 Euler_rotate_axis_doc},
888 {
"rotate",
reinterpret_cast<PyCFunction
>(
Euler_rotate), METH_O, Euler_rotate_doc},
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},
902 {
nullptr,
nullptr, 0,
nullptr},
907# pragma clang diagnostic pop
909# pragma GCC diagnostic pop
919#ifdef MATH_STANDALONE
920# define Euler_str nullptr
926 ".. class:: Euler(angles=(0.0, 0.0, 0.0), order='XYZ', /)\n"
928 " This object gives access to Eulers in Blender.\n"
930 " .. seealso:: `Euler angles <https://en.wikipedia.org/wiki/Euler_angles>`__ on "
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");
938 PyVarObject_HEAD_INIT(
nullptr, 0)
957 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC,
989#ifdef MATH_STANDALONE
1004 eul_alloc =
static_cast<float *
>(PyMem_Malloc(
EULER_SIZE *
sizeof(
float)));
1005 if (eul_alloc ==
nullptr) [[unlikely]] {
1006 PyErr_SetString(PyExc_MemoryError,
1008 "problem allocating data");
1014 self->eul = eul_alloc;
1017 self->cb_user =
nullptr;
1018 self->cb_type = self->cb_subtype = 0;
1028 self->
order = order;
1031 PyMem_Free(eul_alloc);
1034 return reinterpret_cast<PyObject *
>(self);
1044 self->cb_user =
nullptr;
1045 self->cb_type = self->cb_subtype = 0;
1050 self->
order = order;
1053 return reinterpret_cast<PyObject *
>(self);
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);
1072 return reinterpret_cast<PyObject *
>(self);
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.
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
#define BaseMath_ReadCallback_ForWrite(_self)
#define BaseMath_Prepare_ForBufferAccess(_self, _view, _flags)
#define BaseMath_ReadIndexCallback(_self, _index)
#define BaseMath_WriteCallback(_self)
#define BASE_MATH_NEW(struct_name, root_type, base_type)
#define BaseMathObject_Prepare_ForHash(_self)
#define BASE_MATH_FLAG_DEFAULT
#define BaseMath_Prepare_ForWrite(_self)
#define BaseMath_ReadCallback(_self)
#define BaseMath_WriteIndexCallback(_self, _index)
#define MAKE_ID3(a, b, c)
#define EulerObject_Check(v)
char BaseMathObject_owner_doc[]
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
char BaseMathObject_freeze_doc[]
int EXPP_VectorsAreEqual(const float *vecA, const float *vecB, int size, int floatSteps)
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)
void BaseMathObject_dealloc(BaseMathObject *self)
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)
PyObject * mathutils_dynstr_to_py(DynStr *ds)
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 *)
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)
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)
int BaseMathObject_clear(BaseMathObject *self)
PyObject * BaseMathObject_freeze(BaseMathObject *self)
static const char * euler_order_str(EulerObject *self)
int BaseMathObject_is_gc(BaseMathObject *self)
void eulO_to_mat3(float M[3][3], const float e[3], short order)
PyObject * BaseMathObject_is_frozen_get(BaseMathObject *self, void *)
static PyMappingMethods Euler_AsMapping
PyObject * BaseMathObject_is_valid_get(BaseMathObject *self, void *)
static PyGetSetDef Euler_getseters[]
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_HAS_BUFFER_VIEW
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)
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 *)
char BaseMathObject_is_valid_doc[]
int BaseMathObject_traverse(BaseMathObject *self, visitproc visit, void *arg)
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)
static Py_hash_t Euler_hash(EulerObject *self)
static Py_ssize_t Euler_len(EulerObject *)
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[]
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
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[]
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