20#ifndef MATH_STANDALONE
29 "This module provides access to math operations.\n"
33 " Classes, methods and attributes that accept vectors also accept other numeric sequences,\n"
34 " such as tuples, lists.\n"
36 "The :mod:`mathutils` module provides the following classes:\n"
40 "- :class:`Matrix`,\n"
41 "- :class:`Quaternion`,\n"
42 "- :class:`Vector`,\n");
47 const char *error_prefix)
53 PyObject **value_fast_items = PySequence_Fast_ITEMS(value_fast);
54 for (
int i = 0; i < array_num; i++) {
55 if (((
array[i] = PyFloat_AsDouble(item = value_fast_items[i])) == -1.0f) && PyErr_Occurred()) {
56 PyErr_Format(PyExc_TypeError,
57 "%.200s: sequence index %d expected a number, "
58 "found '%.200s' type, ",
61 Py_TYPE(item)->tp_name);
77 mult = _PyHASH_MULTIPLIER;
82 y = _Py_HashDouble(
nullptr,
double(
array[i++]));
91 if (
x == Py_uhash_t(-1)) {
98 float *
array,
int array_num_min,
int array_num_max, PyObject *value,
const char *error_prefix)
100 const uint flag = array_num_max;
119 if (
num > array_num_max ||
num < array_num_min) {
120 if (array_num_max == array_num_min) {
121 PyErr_Format(PyExc_ValueError,
122 "%.200s: sequence length is %d, expected %d",
128 PyErr_Format(PyExc_ValueError,
129 "%.200s: sequence length is %d, expected [%d - %d]",
143 PyObject *value_fast =
nullptr;
146 if (!(value_fast = PySequence_Fast(value, error_prefix))) {
151 num = PySequence_Fast_GET_SIZE(value_fast);
157 if (
num > array_num_max ||
num < array_num_min) {
158 if (array_num_max == array_num_min) {
159 PyErr_Format(PyExc_ValueError,
160 "%.200s: sequence length is %d, expected %d",
166 PyErr_Format(PyExc_ValueError,
167 "%.200s: sequence length is %d, expected [%d - %d]",
173 Py_DECREF(value_fast);
180 Py_DECREF(value_fast);
185 const int array_num_left = array_num_max -
num;
186 if (array_num_left) {
187 memset(&
array[
num], 0,
sizeof(
float) * array_num_left);
198 const char *error_prefix)
212 if (
num < array_num_min) {
213 PyErr_Format(PyExc_ValueError,
214 "%.200s: sequence size is %d, expected >= %d",
221 *
array =
static_cast<float *
>(PyMem_Malloc(
num *
sizeof(
float)));
228 PyObject *value_fast =
nullptr;
233 if (!(value_fast = PySequence_Fast(value, error_prefix))) {
238 num = PySequence_Fast_GET_SIZE(value_fast);
240 if (
num < array_num_min) {
241 Py_DECREF(value_fast);
242 PyErr_Format(PyExc_ValueError,
243 "%.200s: sequence size is %d, expected >= %d",
250 *
array =
static_cast<float *
>(PyMem_Malloc(
num *
sizeof(
float)));
253 Py_DECREF(value_fast);
265 const char *error_prefix)
267 PyObject *value_fast;
268 const int array_dim_flag = array_dim;
274 if (!(value_fast = PySequence_Fast(value, error_prefix))) {
279 num = PySequence_Fast_GET_SIZE(value_fast);
282 PyObject **value_fast_items = PySequence_Fast_ITEMS(value_fast);
287 fp = *
array =
static_cast<float *
>(PyMem_Malloc(
num * array_dim *
sizeof(
float)));
289 for (i = 0; i <
num; i++, fp += array_dim) {
290 PyObject *item = value_fast_items[i];
301 Py_DECREF(value_fast);
308 PyObject *value_fast, **value_fast_items, *item;
310 if (!(value_fast = PySequence_Fast(value, error_prefix))) {
315 if ((size = PySequence_Fast_GET_SIZE(value_fast)) != array_dim) {
316 PyErr_Format(PyExc_ValueError,
317 "%.200s: sequence size is %d, expected %d",
321 Py_DECREF(value_fast);
325 value_fast_items = PySequence_Fast_ITEMS(value_fast);
329 if (((
array[i] = PyC_Long_AsI32(item = value_fast_items[i])) == -1) && PyErr_Occurred()) {
330 PyErr_Format(PyExc_TypeError,
"%.200s: sequence index %d expected an int", error_prefix, i);
335 Py_DECREF(value_fast);
343 const char *error_prefix)
345 PyObject *value_fast;
350 if (!(value_fast = PySequence_Fast(value, error_prefix))) {
355 size = PySequence_Fast_GET_SIZE(value_fast);
358 PyObject **value_fast_items = PySequence_Fast_ITEMS(value_fast);
361 ip = *
array =
static_cast<int *
>(PyMem_Malloc(size * array_dim *
sizeof(
int)));
363 for (i = 0; i < size; i++, ip += array_dim) {
364 PyObject *item = value_fast_items[i];
375 Py_DECREF(value_fast);
380 const char *error_prefix,
384 PyObject *value_fast;
385 if (!(value_fast = PySequence_Fast(value, error_prefix))) {
390 const int size = PySequence_Fast_GET_SIZE(value_fast);
392 PyObject **value_fast_items = PySequence_Fast_ITEMS(value_fast);
396 for (
int i = 0; i < size; i++) {
397 r_offsets[i] = count;
398 const int subseq_len = int(PySequence_Size(value_fast_items[i]));
399 if (subseq_len == -1) {
401 PyExc_ValueError,
"%.200s: sequence expected to have subsequences", error_prefix);
402 Py_DECREF(value_fast);
405 count += int(PySequence_Size(value_fast_items[i]));
407 r_offsets.
last() = count;
413 PyObject *subseq = value_fast_items[i];
416 Py_DECREF(value_fast);
422 Py_DECREF(value_fast);
434 (
reinterpret_cast<const EulerObject *
>(value))->eul,
435 (
reinterpret_cast<const EulerObject *
>(value))->order);
452 if ((
reinterpret_cast<MatrixObject *
>(value))->row_num < 3 ||
456 PyExc_ValueError,
"%.200s: matrix must have minimum 3x3 dimensions", error_prefix);
465 PyErr_Format(PyExc_TypeError,
466 "%.200s: expected a Euler, Quaternion or Matrix type, "
469 Py_TYPE(value)->tp_name);
490#define SIGNMASK(i) (-int((uint(i)) >> 31))
496 const int ai = *
reinterpret_cast<const int *
>(&af);
497 const int bi = *
reinterpret_cast<const int *
>(&bf);
501 BLI_assert((0 == test) || (0xFFFFFFFF == test));
502 diff = (ai ^ (test & 0x7fffffff)) - bi;
505 return (v1 |
v2) >= 0;
514 for (
x = 0;
x < size;
x++) {
522#ifndef MATH_STANDALONE
526 char *ds_buf =
static_cast<char *
>(PyMem_Malloc(ds_len + 1));
530 ret = PyUnicode_FromStringAndSize(ds_buf, ds_len);
540#define MATHUTILS_TOT_CB 17
564 if (cb->
check(self) != -1) [[likely]] {
575 if (cb->
get(self, self->cb_subtype) != -1) [[likely]] {
579 if (!PyErr_Occurred()) {
580 PyErr_Format(PyExc_RuntimeError,
"%s read, user has become invalid", Py_TYPE(self)->tp_name);
588 if (cb->
set(self, self->cb_subtype) != -1) [[likely]] {
592 if (!PyErr_Occurred()) {
593 PyErr_Format(PyExc_RuntimeError,
"%s write, user has become invalid", Py_TYPE(self)->tp_name);
601 if (cb->
get_index(self, self->cb_subtype,
index) != -1) [[likely]] {
605 if (!PyErr_Occurred()) {
607 PyExc_RuntimeError,
"%s read index, user has become invalid", Py_TYPE(self)->tp_name);
615 if (cb->
set_index(self, self->cb_subtype,
index) != -1) [[likely]] {
619 if (!PyErr_Occurred()) {
621 PyExc_RuntimeError,
"%s write index, user has become invalid", Py_TYPE(self)->tp_name);
628 PyErr_Format(PyExc_TypeError,
"%s is frozen (immutable)", Py_TYPE(self)->tp_name);
634 PyExc_TypeError,
"%s is not frozen (mutable), call freeze first", Py_TYPE(self)->tp_name);
640 PyErr_Format(PyExc_ValueError,
"%s: cannot resize frozen data", error_prefix);
644 PyErr_Format(PyExc_ValueError,
"%s: cannot resize wrapped data", error_prefix);
648 PyErr_Format(PyExc_BufferError,
649 "%s: cannot resize data while exported to buffer protocol",
653 if (self->cb_user) [[unlikely]] {
654 PyErr_Format(PyExc_ValueError,
"%s: cannot resize owned data", error_prefix);
662 if (view ==
nullptr) [[unlikely]] {
663 PyErr_SetString(PyExc_BufferError,
"null view in get-buffer is obsolete");
667 PyErr_SetString(PyExc_BufferError,
668 "Data is already exported via buffer protocol, "
669 "multiple simultaneous exports are not allowed.");
672 if (flags & PyBUF_WRITABLE) {
677 PyErr_SetString(PyExc_BufferError,
"Data is frozen, cannot get a writable buffer");
687 "The item this is wrapping or None (read-only).\n"
692 PyObject *
ret = self->cb_user ? self->cb_user : Py_None;
693 return Py_NewRef(
ret);
697 "True when this object wraps external data (read-only).\n\n:type: bool";
704 "True when this object has been frozen (read-only).\n\n:type: bool";
717 ".. method:: freeze()\n"
719 " Make this object immutable.\n"
721 " After this the object can be hashed, used in dictionaries & sets.\n"
723 " :return: An instance of this object.\n"
728 PyErr_SetString(PyExc_TypeError,
"Cannot freeze wrapped/owned data");
733 PyErr_SetString(PyExc_BufferError,
"Cannot freeze data while exported to buffer protocol");
739 return Py_NewRef(self);
744 Py_VISIT(self->cb_user);
750 Py_CLEAR(self->cb_user);
758 PyObject *cb_user = self->cb_user;
759 self->cb_user =
reinterpret_cast<PyObject *
>(
uintptr_t(-1));
760 bool is_tracked = PyObject_GC_IsTracked(
reinterpret_cast<PyObject *
>(self));
761 self->cb_user = cb_user;
770 PyMem_Free(self->data);
775 PyObject_GC_UnTrack(self);
781 PyObject_GC_UnTrack(self);
785 Py_TYPE(self)->tp_free(self);
790 return self->cb_user !=
nullptr;
796 if (
ELEM(base_type,
nullptr, root_type)) {
797 obj = _PyObject_GC_New(root_type);
805 obj = base_type->tp_alloc(base_type, 0);
808 PyObject_GC_UnTrack(obj);
818 {
nullptr,
nullptr, 0,
nullptr},
838#ifndef MATH_STANDALONE
850 PyObject *sys_modules = PyImport_GetModuleDict();
894#ifndef MATH_STANDALONE
A dynamically sized string ADT.
MutableSpan< T > as_mutable_span()
const T & last(const int64_t n=0) const
void reinitialize(const int64_t new_size)
constexpr int64_t size() const
constexpr T * data() const
IndexRange index_range() const
IMETHOD Vector diff(const Vector &a, const Vector &b, double dt)
VecBase< float, D > constexpr mod(VecOp< float, D >, VecOp< float, D >) RET
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
#define BaseMath_CheckCallback(_self)
#define BaseMath_WriteCallback(_self)
#define BaseMath_ReadCallback(_self)
#define BaseMathObject_CheckExact(v)
#define ColorObject_Check(v)
#define EulerObject_Check(v)
#define MatrixObject_Check(v)
#define QuaternionObject_Check(v)
#define VectorObject_Check(v)
int _BaseMathObject_ResizeOkOrRaiseExc(BaseMathObject *self, const char *error_prefix)
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)
static bool BaseMathObject_is_tracked(BaseMathObject *self)
void BaseMathObject_dealloc(BaseMathObject *self)
PyMODINIT_FUNC PyInit_mathutils_noise()
bool mathutils_array_parse_alloc_viseq(PyObject *value, const char *error_prefix, Array< int > &r_offsets, Array< int > &r_data)
Py_hash_t mathutils_array_hash(const float *array, size_t array_len)
PyObject * mathutils_dynstr_to_py(DynStr *ds)
uchar mathutils_matrix_col_cb_index
uchar mathutils_matrix_row_cb_index
void normalize_m3(float R[3][3]) ATTR_NONNULL()
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 *)
PyTypeObject quaternion_Type
PyTypeObject matrix_access_Type
static Mathutils_Callback * mathutils_callbacks[MATHUTILS_TOT_CB]
int BaseMathObject_clear(BaseMathObject *self)
PyObject * BaseMathObject_freeze(BaseMathObject *self)
void BLI_dynstr_free(DynStr *ds) ATTR_NONNULL()
int mathutils_array_parse_alloc_vi(int **array, int array_dim, PyObject *value, const char *error_prefix)
Mathutils_Callback mathutils_matrix_col_cb
int BaseMathObject_is_gc(BaseMathObject *self)
int mathutils_array_parse_alloc(float **array, int array_num_min, PyObject *value, const char *error_prefix)
void eulO_to_mat3(float M[3][3], const float e[3], short order)
void quat_to_mat3(float m[3][3], const float q[4])
PyObject * BaseMathObject_is_frozen_get(BaseMathObject *self, void *)
static int mathutils_array_parse_fast(float *array, const int array_num, PyObject *value_fast, const char *error_prefix)
static PyModuleDef M_Mathutils_module_def
void _BaseMathObject_RaiseNotFrozenExc(const BaseMathObject *self)
PyObject * BaseMathObject_is_valid_get(BaseMathObject *self, void *)
void matrix_as_3x3(float mat[3][3], MatrixObject *self)
PyMODINIT_FUNC PyInit_mathutils()
PyMODINIT_FUNC PyInit_mathutils_interpolate()
Mathutils_Callback mathutils_matrix_row_cb
BMesh const char void * data
PyObject * _BaseMathObject_new_impl(PyTypeObject *root_type, PyTypeObject *base_type)
int EXPP_FloatsAreEqual(float af, float bf, int maxDiff)
@ BASE_MATH_FLAG_IS_FROZEN
@ BASE_MATH_FLAG_HAS_BUFFER_VIEW
int mathutils_array_parse(float *array, int array_num_min, int array_num_max, PyObject *value, const char *error_prefix)
PyMODINIT_FUNC PyInit_mathutils_bvhtree()
uchar Mathutils_RegisterCallback(Mathutils_Callback *cb)
ATTR_WARN_UNUSED_RESULT const size_t num
int _BaseMathObject_WriteCallback(BaseMathObject *self)
int _BaseMathObject_ReadCallback(BaseMathObject *self)
_W64 unsigned int uintptr_t
PyObject * BaseMathObject_is_wrapped_get(BaseMathObject *self, void *)
char BaseMathObject_is_valid_doc[]
Mathutils_Callback mathutils_matrix_translation_cb
ATTR_WARN_UNUSED_RESULT const BMVert * v2
int BaseMathObject_traverse(BaseMathObject *self, visitproc visit, void *arg)
int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error_prefix)
int PyC_Module_AddToSysModules(PyObject *sys_modules, PyObject *module)
PyMODINIT_FUNC PyInit_mathutils_kdtree()
uchar mathutils_matrix_translation_cb_index
char BaseMathObject_is_frozen_doc[]
PyMODINIT_FUNC PyInit_mathutils_geometry()
static PyMethodDef M_Mathutils_methods[]
void BLI_dynstr_get_cstring_ex(const DynStr *__restrict ds, char *__restrict rets) ATTR_NONNULL()
int mathutils_int_array_parse(int *array, int array_dim, PyObject *value, const char *error_prefix)
void _BaseMathObject_RaiseFrozenExc(const BaseMathObject *self)
int BLI_dynstr_get_len(const DynStr *ds) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
int _BaseMathObject_WriteIndexCallback(BaseMathObject *self, int index)
int _BaseMathObject_RaiseBufferViewExc(BaseMathObject *self, Py_buffer *view, int flags)
int mathutils_array_parse_alloc_v(float **array, int array_dim, PyObject *value, const char *error_prefix)
int _BaseMathObject_CheckCallback(BaseMathObject *self)
char BaseMathObject_is_wrapped_doc[]
int _BaseMathObject_ReadIndexCallback(BaseMathObject *self, int index)
float normalize_qt_qt(float r[4], const float q[4])
BaseMathGetIndexFunc get_index
BaseMathSetIndexFunc set_index