fix for a bug in mathutils when a vector was accessing a matrix and the matrix size...
[blender.git] / 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 {       // solid, fast routine across all platforms
246         // with constant time behavior
247         int ai = *(int *)(&af);
248         int bi = *(int *)(&bf);
249         int test = SIGNMASK(ai^bi);
250         int diff, v1, v2;
251
252         assert((0 == test) || (0xFFFFFFFF == test));
253         diff = (ai ^ (test & 0x7fffffff)) - bi;
254         v1 = maxDiff + diff;
255         v2 = maxDiff - diff;
256         return (v1|v2) >= 0;
257 }
258
259 /*---------------------- EXPP_VectorsAreEqual -------------------------
260   Builds on EXPP_FloatsAreEqual to test vectors */
261 int EXPP_VectorsAreEqual(float *vecA, float *vecB, int size, int floatSteps)
262 {
263         int x;
264         for (x = 0; x < size; x++) {
265                 if (EXPP_FloatsAreEqual(vecA[x], vecB[x], floatSteps) == 0)
266                         return 0;
267         }
268         return 1;
269 }
270
271 /* dynstr as python string utility funcions, frees 'ds'! */
272 PyObject *mathutils_dynstr_to_py(struct DynStr *ds)
273 {
274         const int ds_len = BLI_dynstr_get_len(ds); /* space for \0 */
275         char *ds_buf     = PyMem_Malloc(ds_len + 1);
276         PyObject *ret;
277         BLI_dynstr_get_cstring_ex(ds, ds_buf);
278         BLI_dynstr_free(ds);
279         ret = PyUnicode_FromStringAndSize(ds_buf, ds_len);
280         PyMem_Free(ds_buf);
281         return ret;
282 }
283
284 /* Mathutils Callbacks */
285
286 /* for mathutils internal use only, eventually should re-alloc but to start with we only have a few users */
287 static Mathutils_Callback *mathutils_callbacks[8] = {NULL};
288
289 int Mathutils_RegisterCallback(Mathutils_Callback *cb)
290 {
291         int i;
292         
293         /* find the first free slot */
294         for (i = 0; mathutils_callbacks[i]; i++) {
295                 if (mathutils_callbacks[i] == cb) /* already registered? */
296                         return i;
297         }
298         
299         mathutils_callbacks[i] = cb;
300         return i;
301 }
302
303 /* use macros to check for NULL */
304 int _BaseMathObject_ReadCallback(BaseMathObject *self)
305 {
306         Mathutils_Callback *cb = mathutils_callbacks[self->cb_type];
307         if (cb->get(self, self->cb_subtype) != -1)
308                 return 0;
309
310         if (!PyErr_Occurred()) {
311                 PyErr_Format(PyExc_RuntimeError,
312                              "%s read, user has become invalid",
313                              Py_TYPE(self)->tp_name);
314         }
315         return -1;
316 }
317
318 int _BaseMathObject_WriteCallback(BaseMathObject *self)
319 {
320         Mathutils_Callback *cb = mathutils_callbacks[self->cb_type];
321         if (cb->set(self, self->cb_subtype) != -1)
322                 return 0;
323
324         if (!PyErr_Occurred()) {
325                 PyErr_Format(PyExc_RuntimeError,
326                              "%s write, user has become invalid",
327                              Py_TYPE(self)->tp_name);
328         }
329         return -1;
330 }
331
332 int _BaseMathObject_ReadIndexCallback(BaseMathObject *self, int index)
333 {
334         Mathutils_Callback *cb = mathutils_callbacks[self->cb_type];
335         if (cb->get_index(self, self->cb_subtype, index) != -1)
336                 return 0;
337
338         if (!PyErr_Occurred()) {
339                 PyErr_Format(PyExc_RuntimeError,
340                              "%s read index, user has become invalid",
341                              Py_TYPE(self)->tp_name);
342         }
343         return -1;
344 }
345
346 int _BaseMathObject_WriteIndexCallback(BaseMathObject *self, int index)
347 {
348         Mathutils_Callback *cb = mathutils_callbacks[self->cb_type];
349         if (cb->set_index(self, self->cb_subtype, index) != -1)
350                 return 0;
351
352         if (!PyErr_Occurred()) {
353                 PyErr_Format(PyExc_RuntimeError,
354                              "%s write index, user has become invalid",
355                              Py_TYPE(self)->tp_name);
356         }
357         return -1;
358 }
359
360 /* BaseMathObject generic functions for all mathutils types */
361 char BaseMathObject_owner_doc[] = "The item this is wrapping or None  (readonly).";
362 PyObject *BaseMathObject_owner_get(BaseMathObject *self, void *UNUSED(closure))
363 {
364         PyObject *ret = self->cb_user ? self->cb_user : Py_None;
365         Py_INCREF(ret);
366         return ret;
367 }
368
369 char BaseMathObject_is_wrapped_doc[] = "True when this object wraps external data (readonly).\n\n:type: boolean";
370 PyObject *BaseMathObject_is_wrapped_get(BaseMathObject *self, void *UNUSED(closure))
371 {
372         return PyBool_FromLong((self->wrapped == Py_WRAP) ? 1:0);
373 }
374
375 int BaseMathObject_traverse(BaseMathObject *self, visitproc visit, void *arg)
376 {
377         Py_VISIT(self->cb_user);
378         return 0;
379 }
380
381 int BaseMathObject_clear(BaseMathObject *self)
382 {
383         Py_CLEAR(self->cb_user);
384         return 0;
385 }
386
387 void BaseMathObject_dealloc(BaseMathObject *self)
388 {
389         /* only free non wrapped */
390         if (self->wrapped != Py_WRAP) {
391                 PyMem_Free(self->data);
392         }
393
394         if (self->cb_user) {
395                 PyObject_GC_UnTrack(self);
396                 BaseMathObject_clear(self);
397         }
398
399         Py_TYPE(self)->tp_free(self); // PyObject_DEL(self); // breaks subtypes
400 }
401
402 /*----------------------------MODULE INIT-------------------------*/
403 static struct PyMethodDef M_Mathutils_methods[] = {
404         {NULL, NULL, 0, NULL}
405 };
406
407 static struct PyModuleDef M_Mathutils_module_def = {
408         PyModuleDef_HEAD_INIT,
409         "mathutils",  /* m_name */
410         M_Mathutils_doc,  /* m_doc */
411         0,  /* m_size */
412         M_Mathutils_methods,  /* m_methods */
413         NULL,  /* m_reload */
414         NULL,  /* m_traverse */
415         NULL,  /* m_clear */
416         NULL,  /* m_free */
417 };
418
419 PyMODINIT_FUNC PyInit_mathutils(void)
420 {
421         PyObject *submodule;
422         PyObject *item;
423         PyObject *sys_modules = PyThreadState_GET()->interp->modules;
424
425         if (PyType_Ready(&vector_Type) < 0)
426                 return NULL;
427         if (PyType_Ready(&matrix_Type) < 0)
428                 return NULL;
429         if (PyType_Ready(&matrix_access_Type) < 0)
430                 return NULL;
431         if (PyType_Ready(&euler_Type) < 0)
432                 return NULL;
433         if (PyType_Ready(&quaternion_Type) < 0)
434                 return NULL;
435         if (PyType_Ready(&color_Type) < 0)
436                 return NULL;
437
438         submodule = PyModule_Create(&M_Mathutils_module_def);
439         
440         /* each type has its own new() function */
441         PyModule_AddObject(submodule, "Vector",         (PyObject *)&vector_Type);
442         PyModule_AddObject(submodule, "Matrix",         (PyObject *)&matrix_Type);
443         PyModule_AddObject(submodule, "Euler",          (PyObject *)&euler_Type);
444         PyModule_AddObject(submodule, "Quaternion",     (PyObject *)&quaternion_Type);
445         PyModule_AddObject(submodule, "Color",          (PyObject *)&color_Type);
446         
447         /* submodule */
448         PyModule_AddObject(submodule, "geometry",               (item = PyInit_mathutils_geometry()));
449         /* XXX, python doesnt do imports with this usefully yet
450          * 'from mathutils.geometry import PolyFill'
451          * ...fails without this. */
452         PyDict_SetItemString(sys_modules, "mathutils.geometry", item);
453         Py_INCREF(item);
454
455         /* Noise submodule */
456         PyModule_AddObject(submodule, "noise",          (item = PyInit_mathutils_noise()));
457         PyDict_SetItemString(sys_modules, "mathutils.noise", item);
458         Py_INCREF(item);
459
460         mathutils_matrix_row_cb_index = Mathutils_RegisterCallback(&mathutils_matrix_row_cb);
461         mathutils_matrix_col_cb_index = Mathutils_RegisterCallback(&mathutils_matrix_col_cb);
462         mathutils_matrix_translation_cb_index = Mathutils_RegisterCallback(&mathutils_matrix_translation_cb);
463
464         return submodule;
465 }