imbuf, mathutils & readfile: floats were being implicitly promoted to doubles, adjust...
[blender.git] / source / blender / python / generic / mathutils.c
1 /* 
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * This is a new part of Blender.
24  *
25  * Contributor(s): Joseph Gilbert, Campbell Barton
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 /** \file blender/python/generic/mathutils.c
31  *  \ingroup pygen
32  */
33
34 #include <Python.h>
35
36 #include "mathutils.h"
37
38 #include "BLI_math.h"
39 #include "BLI_utildefines.h"
40
41 static char M_Mathutils_doc[] =
42 "This module provides access to matrices, eulers, quaternions and vectors."
43 ;
44 static int mathutils_array_parse_fast(float *array, int array_min, int array_max, PyObject *value, const char *error_prefix)
45 {
46         PyObject *value_fast= NULL;
47         PyObject *item;
48
49         int i, size;
50
51         /* non list/tuple cases */
52         if(!(value_fast=PySequence_Fast(value, error_prefix))) {
53                 /* PySequence_Fast sets the error */
54                 return -1;
55         }
56
57         size= PySequence_Fast_GET_SIZE(value_fast);
58
59         if(size > array_max || size < array_min) {
60                 if (array_max == array_min)     PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected %d", error_prefix, size, array_max);
61                 else                                            PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected [%d - %d]", error_prefix, size, array_min, array_max);
62                 Py_DECREF(value_fast);
63                 return -1;
64         }
65
66         i= size;
67         do {
68                 i--;
69                 if(((array[i]= PyFloat_AsDouble((item= PySequence_Fast_GET_ITEM(value_fast, i)))) == -1.0f) && PyErr_Occurred()) {
70                         PyErr_Format(PyExc_ValueError, "%.200s: sequence index %d expected a number, found '%.200s' type, ", error_prefix, i, Py_TYPE(item)->tp_name);
71                         Py_DECREF(value_fast);
72                         return -1;
73                 }
74         } while(i);
75
76         Py_XDECREF(value_fast);
77         return size;
78 }
79
80 /* helper functionm returns length of the 'value', -1 on error */
81 int mathutils_array_parse(float *array, int array_min, int array_max, PyObject *value, const char *error_prefix)
82 {
83 #if 1 /* approx 6x speedup for mathutils types */
84         int size;
85
86         if(     (VectorObject_Check(value) && (size= ((VectorObject *)value)->size)) ||
87                 (EulerObject_Check(value) && (size= 3)) ||
88                 (QuaternionObject_Check(value) && (size= 4)) ||
89                 (ColorObject_Check(value) && (size= 3))
90         ) {
91                 if(BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
92                         return -1;
93                 }
94
95                 if(size > array_max || size < array_min) {
96                         if (array_max == array_min)     PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected %d", error_prefix, size, array_max);
97                         else                                            PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected [%d - %d]", error_prefix, size, array_min, array_max);
98                         return -1;
99                 }
100
101                 memcpy(array, ((BaseMathObject *)value)->data, size * sizeof(float));
102                 return size;
103         }
104         else
105 #endif
106         {
107                 return mathutils_array_parse_fast(array, array_min, array_max, value, error_prefix);
108         }
109 }
110
111 int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error_prefix)
112 {
113         if(EulerObject_Check(value)) {
114                 if(BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
115                         return -1;
116                 }
117                 else {
118                         eulO_to_mat3(rmat, ((EulerObject *)value)->eul, ((EulerObject *)value)->order);
119                         return 0;
120                 }
121         }
122         else if (QuaternionObject_Check(value)) {
123                 if(BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
124                         return -1;
125                 }
126                 else {
127                         float tquat[4];
128                         normalize_qt_qt(tquat, ((QuaternionObject *)value)->quat);
129                         quat_to_mat3(rmat, tquat);
130                         return 0;
131                 }
132         }
133         else if (MatrixObject_Check(value)) {
134                 if(BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
135                         return -1;
136                 }
137                 else if(((MatrixObject *)value)->col_size < 3 || ((MatrixObject *)value)->row_size < 3) {
138                         PyErr_Format(PyExc_ValueError, "%.200s: matrix must have minimum 3x3 dimensions", error_prefix);
139                         return -1;
140                 }
141                 else {
142                         matrix_as_3x3(rmat, (MatrixObject *)value);
143                         normalize_m3(rmat);
144                         return 0;
145                 }
146         }
147         else {
148                 PyErr_Format(PyExc_TypeError, "%.200s: expected a Euler, Quaternion or Matrix type, found %.200s", error_prefix, Py_TYPE(value)->tp_name);
149                 return -1;
150         }
151 }
152
153
154 //----------------------------------MATRIX FUNCTIONS--------------------
155
156
157 /* Utility functions */
158
159 // LomontRRDCompare4, Ever Faster Float Comparisons by Randy Dillon
160 #define SIGNMASK(i) (-(int)(((unsigned int)(i))>>31))
161
162 int EXPP_FloatsAreEqual(float af, float bf, int maxDiff)
163 {       // solid, fast routine across all platforms
164         // with constant time behavior
165         int ai = *(int *)(&af);
166         int bi = *(int *)(&bf);
167         int test = SIGNMASK(ai^bi);
168         int diff, v1, v2;
169
170         assert((0 == test) || (0xFFFFFFFF == test));
171         diff = (ai ^ (test & 0x7fffffff)) - bi;
172         v1 = maxDiff + diff;
173         v2 = maxDiff - diff;
174         return (v1|v2) >= 0;
175 }
176
177 /*---------------------- EXPP_VectorsAreEqual -------------------------
178   Builds on EXPP_FloatsAreEqual to test vectors */
179 int EXPP_VectorsAreEqual(float *vecA, float *vecB, int size, int floatSteps)
180 {
181         int x;
182         for (x=0; x< size; x++){
183                 if (EXPP_FloatsAreEqual(vecA[x], vecB[x], floatSteps) == 0)
184                         return 0;
185         }
186         return 1;
187 }
188
189
190 /* Mathutils Callbacks */
191
192 /* for mathutils internal use only, eventually should re-alloc but to start with we only have a few users */
193 static Mathutils_Callback *mathutils_callbacks[8] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
194
195 int Mathutils_RegisterCallback(Mathutils_Callback *cb)
196 {
197         int i;
198         
199         /* find the first free slot */
200         for(i= 0; mathutils_callbacks[i]; i++) {
201                 if(mathutils_callbacks[i]==cb) /* already registered? */
202                         return i;
203         }
204         
205         mathutils_callbacks[i] = cb;
206         return i;
207 }
208
209 /* use macros to check for NULL */
210 int _BaseMathObject_ReadCallback(BaseMathObject *self)
211 {
212         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
213         if(cb->get(self, self->cb_subtype) != -1)
214                 return 0;
215
216         if(!PyErr_Occurred())
217                 PyErr_Format(PyExc_RuntimeError, "%s read, user has become invalid", Py_TYPE(self)->tp_name);
218         return -1;
219 }
220
221 int _BaseMathObject_WriteCallback(BaseMathObject *self)
222 {
223         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
224         if(cb->set(self, self->cb_subtype) != -1)
225                 return 0;
226
227         if(!PyErr_Occurred())
228                 PyErr_Format(PyExc_RuntimeError, "%s write, user has become invalid", Py_TYPE(self)->tp_name);
229         return -1;
230 }
231
232 int _BaseMathObject_ReadIndexCallback(BaseMathObject *self, int index)
233 {
234         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
235         if(cb->get_index(self, self->cb_subtype, index) != -1)
236                 return 0;
237
238         if(!PyErr_Occurred())
239                 PyErr_Format(PyExc_RuntimeError, "%s read index, user has become invalid", Py_TYPE(self)->tp_name);
240         return -1;
241 }
242
243 int _BaseMathObject_WriteIndexCallback(BaseMathObject *self, int index)
244 {
245         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
246         if(cb->set_index(self, self->cb_subtype, index) != -1)
247                 return 0;
248
249         if(!PyErr_Occurred())
250                 PyErr_Format(PyExc_RuntimeError, "%s write index, user has become invalid", Py_TYPE(self)->tp_name);
251         return -1;
252 }
253
254 /* BaseMathObject generic functions for all mathutils types */
255 char BaseMathObject_Owner_doc[] = "The item this is wrapping or None  (readonly).";
256 PyObject *BaseMathObject_getOwner(BaseMathObject *self, void *UNUSED(closure))
257 {
258         PyObject *ret= self->cb_user ? self->cb_user : Py_None;
259         Py_INCREF(ret);
260         return ret;
261 }
262
263 char BaseMathObject_Wrapped_doc[] = "True when this object wraps external data (readonly).\n\n:type: boolean";
264 PyObject *BaseMathObject_getWrapped(BaseMathObject *self, void *UNUSED(closure))
265 {
266         return PyBool_FromLong((self->wrapped == Py_WRAP) ? 1:0);
267 }
268
269 int BaseMathObject_traverse(BaseMathObject *self, visitproc visit, void *arg)
270 {
271         Py_VISIT(self->cb_user);
272         return 0;
273 }
274
275 int BaseMathObject_clear(BaseMathObject *self)
276 {
277         Py_CLEAR(self->cb_user);
278         return 0;
279 }
280
281 void BaseMathObject_dealloc(BaseMathObject *self)
282 {
283         /* only free non wrapped */
284         if(self->wrapped != Py_WRAP) {
285                 PyMem_Free(self->data);
286         }
287
288         if(self->cb_user) {
289                 PyObject_GC_UnTrack(self);
290                 BaseMathObject_clear(self);
291         }
292
293         Py_TYPE(self)->tp_free(self); // PyObject_DEL(self); // breaks subtypes
294 }
295
296 /*----------------------------MODULE INIT-------------------------*/
297 static struct PyMethodDef M_Mathutils_methods[] = {
298         {NULL, NULL, 0, NULL}
299 };
300
301 static struct PyModuleDef M_Mathutils_module_def = {
302         PyModuleDef_HEAD_INIT,
303         "mathutils",  /* m_name */
304         M_Mathutils_doc,  /* m_doc */
305         0,  /* m_size */
306         M_Mathutils_methods,  /* m_methods */
307         NULL,  /* m_reload */
308         NULL,  /* m_traverse */
309         NULL,  /* m_clear */
310         NULL,  /* m_free */
311 };
312
313 PyMODINIT_FUNC BPyInit_mathutils(void)
314 {
315         PyObject *submodule;
316         PyObject *item;
317
318         if(PyType_Ready(&vector_Type) < 0)
319                 return NULL;
320         if(PyType_Ready(&matrix_Type) < 0)
321                 return NULL;    
322         if(PyType_Ready(&euler_Type) < 0)
323                 return NULL;
324         if(PyType_Ready(&quaternion_Type) < 0)
325                 return NULL;
326         if(PyType_Ready(&color_Type) < 0)
327                 return NULL;
328
329         submodule = PyModule_Create(&M_Mathutils_module_def);
330         
331         /* each type has its own new() function */
332         PyModule_AddObject(submodule, "Vector",         (PyObject *)&vector_Type);
333         PyModule_AddObject(submodule, "Matrix",         (PyObject *)&matrix_Type);
334         PyModule_AddObject(submodule, "Euler",          (PyObject *)&euler_Type);
335         PyModule_AddObject(submodule, "Quaternion",     (PyObject *)&quaternion_Type);
336         PyModule_AddObject(submodule, "Color",          (PyObject *)&color_Type);
337         
338         /* submodule */
339         PyModule_AddObject(submodule, "geometry",               (item=BPyInit_mathutils_geometry()));
340         /* XXX, python doesnt do imports with this usefully yet
341          * 'from mathutils.geometry import PolyFill'
342          * ...fails without this. */
343         PyDict_SetItemString(PyThreadState_GET()->interp->modules, "mathutils.geometry", item);
344         Py_INCREF(item);
345
346         mathutils_matrix_vector_cb_index= Mathutils_RegisterCallback(&mathutils_matrix_vector_cb);
347
348         return submodule;
349 }