source/blender/python/mathutils/mathutils.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  19  * All rights reserved.
  20  *
  21  * This is a new part of Blender.
  22  *
  23  * Contributor(s): Joseph Gilbert, Campbell Barton
  24  *
  25  * ***** END GPL LICENSE BLOCK *****
  26  */
  27
  28 /** \file blender/python/mathutils/mathutils.c
  29  *  \ingroup pymathutils
  30  */
  31
  32 #include <Python.h>
  33
  34 #include "mathutils.h"
  35
  36 #include "BLI_math.h"
  37 #include "BLI_utildefines.h"
  38 #include "BLI_dynstr.h"
  39
  40 PyDoc_STRVAR(M_Mathutils_doc,
  41 "This module provides access to matrices, eulers, quaternions and vectors."
  42 );
  43 static int mathutils_array_parse_fast(float *array,
  44                                       int size,
  45                                       PyObject *value_fast,
  46                                       const char *error_prefix)
  47 {
  48         PyObject *item;
  49
  50         int i;
  51
  52         i = size;
  53         do {
  54                 i--;
  55                 if (((array[i] = PyFloat_AsDouble((item = PySequence_Fast_GET_ITEM(value_fast, i)))) == -1.0f) &&
  56                     PyErr_Occurred())
  57                 {
  58                         PyErr_Format(PyExc_TypeError,
  59                                      "%.200s: sequence index %d expected a number, "
  60                                      "found '%.200s' type, ",
  61                                      error_prefix, i, Py_TYPE(item)->tp_name);
  62                         Py_DECREF(value_fast);
  63                         return -1;
  64                 }
  65         } while (i);
  66
  67         Py_XDECREF(value_fast);
  68         return size;
  69 }
  70
  71 /* helper functionm returns length of the 'value', -1 on error */
  72 int mathutils_array_parse(float *array, int array_min, int array_max, PyObject *value, const char *error_prefix)
  73 {
  74         int size;
  75
  76 #if 1 /* approx 6x speedup for mathutils types */
  77
  78         if ((size = VectorObject_Check(value)     ? ((VectorObject *)value)->size : 0) ||
  79             (size = EulerObject_Check(value)      ? 3 : 0) ||
  80             (size = QuaternionObject_Check(value) ? 4 : 0) ||
  81             (size = ColorObject_Check(value)      ? 3 : 0))
  82         {
  83                 if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
  84                         return -1;
  85                 }
  86
  87                 if (size > array_max || size < array_min) {
  88                         if (array_max == array_min) {
  89                                 PyErr_Format(PyExc_ValueError,
  90                                              "%.200s: sequence size is %d, expected %d",
  91                                              error_prefix, size, array_max);
  92                         }
  93                         else {
  94                                 PyErr_Format(PyExc_ValueError,
  95                                              "%.200s: sequence size is %d, expected [%d - %d]",
  96                                              error_prefix, size, array_min, array_max);
  97                         }
  98                         return -1;
  99                 }
 100
 101                 memcpy(array, ((BaseMathObject *)value)->data, size * sizeof(float));
 102                 return size;
 103         }
 104         else
 105 #endif
 106         {
 107                 PyObject *value_fast = NULL;
 108
 109                 /* non list/tuple cases */
 110                 if (!(value_fast = PySequence_Fast(value, error_prefix))) {
 111                         /* PySequence_Fast sets the error */
 112                         return -1;
 113                 }
 114
 115                 size = PySequence_Fast_GET_SIZE(value_fast);
 116
 117                 if (size > array_max || size < array_min) {
 118                         if (array_max == array_min) {
 119                                 PyErr_Format(PyExc_ValueError,
 120                                              "%.200s: sequence size is %d, expected %d",
 121                                              error_prefix, size, array_max);
 122                         }
 123                         else {
 124                                 PyErr_Format(PyExc_ValueError,
 125                                              "%.200s: sequence size is %d, expected [%d - %d]",
 126                                              error_prefix, size, array_min, array_max);
 127                         }
 128                         Py_DECREF(value_fast);
 129                         return -1;
 130                 }
 131
 132                 return mathutils_array_parse_fast(array, size, value_fast, error_prefix);
 133         }
 134 }
 135
 136 int mathutils_array_parse_alloc(float **array, int array_min, PyObject *value, const char *error_prefix)
 137 {
 138         int size;
 139
 140 #if 1 /* approx 6x speedup for mathutils types */
 141
 142         if ((size = VectorObject_Check(value)     ? ((VectorObject *)value)->size : 0) ||
 143             (size = EulerObject_Check(value)      ? 3 : 0) ||
 144             (size = QuaternionObject_Check(value) ? 4 : 0) ||
 145             (size = ColorObject_Check(value)      ? 3 : 0))
 146         {
 147                 if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
 148                         return -1;
 149                 }
 150
 151                 if (size < array_min) {
 152                         PyErr_Format(PyExc_ValueError,
 153                                      "%.200s: sequence size is %d, expected > %d",
 154                                      error_prefix, size, array_min);
 155                         return -1;
 156                 }
 157
 158                 *array = PyMem_Malloc(size * sizeof(float));
 159                 memcpy(*array, ((BaseMathObject *)value)->data, size * sizeof(float));
 160                 return size;
 161         }
 162         else
 163 #endif
 164         {
 165                 PyObject *value_fast = NULL;
 166                 // *array = NULL;
 167
 168                 /* non list/tuple cases */
 169                 if (!(value_fast = PySequence_Fast(value, error_prefix))) {
 170                         /* PySequence_Fast sets the error */
 171                         return -1;
 172                 }
 173
 174                 size = PySequence_Fast_GET_SIZE(value_fast);
 175
 176                 if (size < array_min) {
 177                         PyErr_Format(PyExc_ValueError,
 178                                      "%.200s: sequence size is %d, expected > %d",
 179                                      error_prefix, size, array_min);
 180                         return -1;
 181                 }
 182
 183                 *array = PyMem_Malloc(size * sizeof(float));
 184
 185                 return mathutils_array_parse_fast(*array, size, value_fast, error_prefix);
 186         }
 187 }
 188
 189 int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error_prefix)
 190 {
 191         if (EulerObject_Check(value)) {
 192                 if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
 193                         return -1;
 194                 }
 195                 else {
 196                         eulO_to_mat3(rmat, ((EulerObject *)value)->eul, ((EulerObject *)value)->order);
 197                         return 0;
 198                 }
 199         }
 200         else if (QuaternionObject_Check(value)) {
 201                 if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
 202                         return -1;
 203                 }
 204                 else {
 205                         float tquat[4];
 206                         normalize_qt_qt(tquat, ((QuaternionObject *)value)->quat);
 207                         quat_to_mat3(rmat, tquat);
 208                         return 0;
 209                 }
 210         }
 211         else if (MatrixObject_Check(value)) {
 212                 if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
 213                         return -1;
 214                 }
 215                 else if (((MatrixObject *)value)->num_row < 3 || ((MatrixObject *)value)->num_col < 3) {
 216                         PyErr_Format(PyExc_ValueError,
 217                                      "%.200s: matrix must have minimum 3x3 dimensions",
 218                                      error_prefix);
 219                         return -1;
 220                 }
 221                 else {
 222                         matrix_as_3x3(rmat, (MatrixObject *)value);
 223                         normalize_m3(rmat);
 224                         return 0;
 225                 }
 226         }
 227         else {
 228                 PyErr_Format(PyExc_TypeError,
 229                              "%.200s: expected a Euler, Quaternion or Matrix type, "
 230                              "found %.200s", error_prefix, Py_TYPE(value)->tp_name);
 231                 return -1;
 232         }
 233 }
 234
 235
 236 //----------------------------------MATRIX FUNCTIONS--------------------
 237
 238
 239 /* Utility functions */
 240
 241 // LomontRRDCompare4, Ever Faster Float Comparisons by Randy Dillon
 242 #define SIGNMASK(i) (-(int)(((unsigned int)(i)) >> 31))
 243
 244 int EXPP_FloatsAreEqual(float af, float bf, int maxDiff)
 245 {
 246         /* solid, fast routine across all platforms
 247          * with constant time behavior */
 248         int ai = *(int *)(&af);
 249         int bi = *(int *)(&bf);
 250         int test = SIGNMASK(ai ^ bi);
 251         int diff, v1, v2;
 252
 253         assert((0 == test) || (0xFFFFFFFF == test));
 254         diff = (ai ^ (test & 0x7fffffff)) - bi;
 255         v1 = maxDiff + diff;
 256         v2 = maxDiff - diff;
 257         return (v1 | v2) >= 0;
 258 }
 259
 260 /*---------------------- EXPP_VectorsAreEqual -------------------------
 261  * Builds on EXPP_FloatsAreEqual to test vectors */
 262 int EXPP_VectorsAreEqual(float *vecA, float *vecB, int size, int floatSteps)
 263 {
 264         int x;
 265         for (x = 0; x < size; x++) {
 266                 if (EXPP_FloatsAreEqual(vecA[x], vecB[x], floatSteps) == 0)
 267                         return 0;
 268         }
 269         return 1;
 270 }
 271
 272 /* dynstr as python string utility funcions, frees 'ds'! */
 273 PyObject *mathutils_dynstr_to_py(struct DynStr *ds)
 274 {
 275         const int ds_len = BLI_dynstr_get_len(ds); /* space for \0 */
 276         char *ds_buf     = PyMem_Malloc(ds_len + 1);
 277         PyObject *ret;
 278         BLI_dynstr_get_cstring_ex(ds, ds_buf);
 279         BLI_dynstr_free(ds);
 280         ret = PyUnicode_FromStringAndSize(ds_buf, ds_len);
 281         PyMem_Free(ds_buf);
 282         return ret;
 283 }
 284
 285 /* Mathutils Callbacks */
 286
 287 /* for mathutils internal use only, eventually should re-alloc but to start with we only have a few users */
 288 #define MATHUTILS_TOT_CB 8
 289 static Mathutils_Callback *mathutils_callbacks[MATHUTILS_TOT_CB] = {NULL};
 290
 291 unsigned char Mathutils_RegisterCallback(Mathutils_Callback *cb)
 292 {
 293         unsigned char i;
 294
 295         /* find the first free slot */
 296         for (i = 0; mathutils_callbacks[i]; i++) {
 297                 if (mathutils_callbacks[i] == cb) /* already registered? */
 298                         return i;
 299         }
 300
 301         BLI_assert(i < MATHUTILS_TOT_CB);
 302
 303         mathutils_callbacks[i] = cb;
 304         return i;
 305 }
 306
 307 /* use macros to check for NULL */
 308 int _BaseMathObject_ReadCallback(BaseMathObject *self)
 309 {
 310         Mathutils_Callback *cb = mathutils_callbacks[self->cb_type];
 311         if (LIKELY(cb->get(self, self->cb_subtype) != -1)) {
 312                 return 0;
 313         }
 314
 315         if (!PyErr_Occurred()) {
 316                 PyErr_Format(PyExc_RuntimeError,
 317                              "%s read, user has become invalid",
 318                              Py_TYPE(self)->tp_name);
 319         }
 320         return -1;
 321 }
 322
 323 int _BaseMathObject_WriteCallback(BaseMathObject *self)
 324 {
 325         Mathutils_Callback *cb = mathutils_callbacks[self->cb_type];
 326         if (LIKELY(cb->set(self, self->cb_subtype) != -1)) {
 327                 return 0;
 328         }
 329
 330         if (!PyErr_Occurred()) {
 331                 PyErr_Format(PyExc_RuntimeError,
 332                              "%s write, user has become invalid",
 333                              Py_TYPE(self)->tp_name);
 334         }
 335         return -1;
 336 }
 337
 338 int _BaseMathObject_ReadIndexCallback(BaseMathObject *self, int index)
 339 {
 340         Mathutils_Callback *cb = mathutils_callbacks[self->cb_type];
 341         if (LIKELY(cb->get_index(self, self->cb_subtype, index) != -1)) {
 342                 return 0;
 343         }
 344
 345         if (!PyErr_Occurred()) {
 346                 PyErr_Format(PyExc_RuntimeError,
 347                              "%s read index, user has become invalid",
 348                              Py_TYPE(self)->tp_name);
 349         }
 350         return -1;
 351 }
 352
 353 int _BaseMathObject_WriteIndexCallback(BaseMathObject *self, int index)
 354 {
 355         Mathutils_Callback *cb = mathutils_callbacks[self->cb_type];
 356         if (LIKELY(cb->set_index(self, self->cb_subtype, index) != -1)) {
 357                 return 0;
 358         }
 359
 360         if (!PyErr_Occurred()) {
 361                 PyErr_Format(PyExc_RuntimeError,
 362                              "%s write index, user has become invalid",
 363                              Py_TYPE(self)->tp_name);
 364         }
 365         return -1;
 366 }
 367
 368 /* BaseMathObject generic functions for all mathutils types */
 369 char BaseMathObject_owner_doc[] = "The item this is wrapping or None  (read-only).";
 370 PyObject *BaseMathObject_owner_get(BaseMathObject *self, void *UNUSED(closure))
 371 {
 372         PyObject *ret = self->cb_user ? self->cb_user : Py_None;
 373         Py_INCREF(ret);
 374         return ret;
 375 }
 376
 377 char BaseMathObject_is_wrapped_doc[] = "True when this object wraps external data (read-only).\n\n:type: boolean";
 378 PyObject *BaseMathObject_is_wrapped_get(BaseMathObject *self, void *UNUSED(closure))
 379 {
 380         return PyBool_FromLong((self->wrapped == Py_WRAP) ? 1 : 0);
 381 }
 382
 383 int BaseMathObject_traverse(BaseMathObject *self, visitproc visit, void *arg)
 384 {
 385         Py_VISIT(self->cb_user);
 386         return 0;
 387 }
 388
 389 int BaseMathObject_clear(BaseMathObject *self)
 390 {
 391         Py_CLEAR(self->cb_user);
 392         return 0;
 393 }
 394
 395 void BaseMathObject_dealloc(BaseMathObject *self)
 396 {
 397         /* only free non wrapped */
 398         if (self->wrapped != Py_WRAP) {
 399                 PyMem_Free(self->data);
 400         }
 401
 402         if (self->cb_user) {
 403                 PyObject_GC_UnTrack(self);
 404                 BaseMathObject_clear(self);
 405         }
 406
 407         Py_TYPE(self)->tp_free(self); // PyObject_DEL(self); // breaks subtypes
 408 }
 409
 410 /*----------------------------MODULE INIT-------------------------*/
 411 static struct PyMethodDef M_Mathutils_methods[] = {
 412         {NULL, NULL, 0, NULL}
 413 };
 414
 415 static struct PyModuleDef M_Mathutils_module_def = {
 416         PyModuleDef_HEAD_INIT,
 417         "mathutils",  /* m_name */
 418         M_Mathutils_doc,  /* m_doc */
 419         0,  /* m_size */
 420         M_Mathutils_methods,  /* m_methods */
 421         NULL,  /* m_reload */
 422         NULL,  /* m_traverse */
 423         NULL,  /* m_clear */
 424         NULL,  /* m_free */
 425 };
 426
 427 PyMODINIT_FUNC PyInit_mathutils(void)
 428 {
 429         PyObject *submodule;
 430         PyObject *item;
 431         PyObject *sys_modules = PyThreadState_GET()->interp->modules;
 432
 433         if (PyType_Ready(&vector_Type) < 0)
 434                 return NULL;
 435         if (PyType_Ready(&matrix_Type) < 0)
 436                 return NULL;
 437         if (PyType_Ready(&matrix_access_Type) < 0)
 438                 return NULL;
 439         if (PyType_Ready(&euler_Type) < 0)
 440                 return NULL;
 441         if (PyType_Ready(&quaternion_Type) < 0)
 442                 return NULL;
 443         if (PyType_Ready(&color_Type) < 0)
 444                 return NULL;
 445
 446         submodule = PyModule_Create(&M_Mathutils_module_def);
 447
 448         /* each type has its own new() function */
 449         PyModule_AddObject(submodule, "Vector",     (PyObject *)&vector_Type);
 450         PyModule_AddObject(submodule, "Matrix",     (PyObject *)&matrix_Type);
 451         PyModule_AddObject(submodule, "Euler",      (PyObject *)&euler_Type);
 452         PyModule_AddObject(submodule, "Quaternion", (PyObject *)&quaternion_Type);
 453         PyModule_AddObject(submodule, "Color",      (PyObject *)&color_Type);
 454
 455         /* submodule */
 456         PyModule_AddObject(submodule, "geometry",       (item = PyInit_mathutils_geometry()));
 457         /* XXX, python doesnt do imports with this usefully yet
 458          * 'from mathutils.geometry import PolyFill'
 459          * ...fails without this. */
 460         PyDict_SetItemString(sys_modules, "mathutils.geometry", item);
 461         Py_INCREF(item);
 462
 463         /* Noise submodule */
 464         PyModule_AddObject(submodule, "noise", (item = PyInit_mathutils_noise()));
 465         PyDict_SetItemString(sys_modules, "mathutils.noise", item);
 466         Py_INCREF(item);
 467
 468         mathutils_matrix_row_cb_index = Mathutils_RegisterCallback(&mathutils_matrix_row_cb);
 469         mathutils_matrix_col_cb_index = Mathutils_RegisterCallback(&mathutils_matrix_col_cb);
 470         mathutils_matrix_translation_cb_index = Mathutils_RegisterCallback(&mathutils_matrix_translation_cb);
 471
 472         return submodule;
 473 }