- UNUSED macro wasn't throwing an error with GCC if a var become used.
[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 /* Note: Changes to Mathutils since 2.4x
31  * use radians rather then degrees
32  * - Mathutils.Vector/Euler/Quaternion(), now only take single sequence arguments.
33  * - Mathutils.MidpointVecs --> vector.lerp(other, fac)
34  * - Mathutils.AngleBetweenVecs --> vector.angle(other)
35  * - Mathutils.ProjectVecs --> vector.project(other)
36  * - Mathutils.DifferenceQuats --> quat.difference(other)
37  * - Mathutils.Slerp --> quat.slerp(other, fac)
38  * - Mathutils.Rand: removed, use pythons random module
39  * - Mathutils.RotationMatrix(angle, size, axis_flag, axis) --> Mathutils.RotationMatrix(angle, size, axis); merge axis & axis_flag args
40  * - Matrix.scalePart --> Matrix.scale_part
41  * - Matrix.translationPart --> Matrix.translation_part
42  * - Matrix.rotationPart --> Matrix.rotation_part
43  * - toMatrix --> to_matrix
44  * - toEuler --> to_euler
45  * - toQuat --> to_quat
46  * - Vector.toTrackQuat --> Vector.to_track_quat
47  * - Quaternion * Quaternion --> cross product (not dot product)
48  * - Euler.rotate(angle, axis) --> Euler.rotate_axis(axis, angle)
49  *
50  * moved into class functions.
51  * - Mathutils.RotationMatrix -> mathutils.Matrix.Rotation
52  * - Mathutils.ScaleMatrix -> mathutils.Matrix.Scale
53  * - Mathutils.ShearMatrix -> mathutils.Matrix.Shear
54  * - Mathutils.TranslationMatrix -> mathutils.Matrix.Translation
55  * - Mathutils.OrthoProjectionMatrix -> mathutils.Matrix.OrthoProjection
56  *
57  * Moved to Geometry module: Intersect, TriangleArea, TriangleNormal, QuadNormal, LineIntersect
58  */
59
60 #include "mathutils.h"
61
62 #include "BLI_math.h"
63
64 #include "BKE_utildefines.h"
65
66 //-------------------------DOC STRINGS ---------------------------
67 static char M_Mathutils_doc[] =
68 "This module provides access to matrices, eulers, quaternions and vectors.";
69
70 /* helper functionm returns length of the 'value', -1 on error */
71 int mathutils_array_parse(float *array, int array_min, int array_max, PyObject *value, const char *error_prefix)
72 {
73         PyObject *value_fast= NULL;
74
75         int i, size;
76
77         /* non list/tuple cases */
78         if(!(value_fast=PySequence_Fast(value, error_prefix))) {
79                 /* PySequence_Fast sets the error */
80                 return -1;
81         }
82
83         size= PySequence_Fast_GET_SIZE(value_fast);
84
85         if(size > array_max || size < array_min) {
86                 if (array_max == array_min)     PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected %d", error_prefix, size, array_max);
87                 else                                            PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected [%d - %d]", error_prefix, size, array_min, array_max);
88                 Py_DECREF(value_fast);
89                 return -1;
90         }
91
92         i= size;
93         do {
94                 i--;
95                 if(((array[i]= PyFloat_AsDouble(PySequence_Fast_GET_ITEM(value_fast, i))) == -1.0) && PyErr_Occurred()) {
96                         PyErr_Format(PyExc_ValueError, "%.200s: sequence index %d is not a float", error_prefix, i);
97                         Py_DECREF(value_fast);
98                         return -1;
99                 }
100         } while(i);
101
102         Py_XDECREF(value_fast);
103         return size;
104 }
105
106 //----------------------------------MATRIX FUNCTIONS--------------------
107
108
109 /* Utility functions */
110
111 // LomontRRDCompare4, Ever Faster Float Comparisons by Randy Dillon
112 #define SIGNMASK(i) (-(int)(((unsigned int)(i))>>31))
113
114 int EXPP_FloatsAreEqual(float af, float bf, int maxDiff)
115 {       // solid, fast routine across all platforms
116         // with constant time behavior
117         int ai = *(int *)(&af);
118         int bi = *(int *)(&bf);
119         int test = SIGNMASK(ai^bi);
120         int diff, v1, v2;
121
122         assert((0 == test) || (0xFFFFFFFF == test));
123         diff = (ai ^ (test & 0x7fffffff)) - bi;
124         v1 = maxDiff + diff;
125         v2 = maxDiff - diff;
126         return (v1|v2) >= 0;
127 }
128
129 /*---------------------- EXPP_VectorsAreEqual -------------------------
130   Builds on EXPP_FloatsAreEqual to test vectors */
131 int EXPP_VectorsAreEqual(float *vecA, float *vecB, int size, int floatSteps)
132 {
133         int x;
134         for (x=0; x< size; x++){
135                 if (EXPP_FloatsAreEqual(vecA[x], vecB[x], floatSteps) == 0)
136                         return 0;
137         }
138         return 1;
139 }
140
141
142 /* Mathutils Callbacks */
143
144 /* for mathutils internal use only, eventually should re-alloc but to start with we only have a few users */
145 Mathutils_Callback *mathutils_callbacks[8] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
146
147 int Mathutils_RegisterCallback(Mathutils_Callback *cb)
148 {
149         int i;
150         
151         /* find the first free slot */
152         for(i= 0; mathutils_callbacks[i]; i++) {
153                 if(mathutils_callbacks[i]==cb) /* already registered? */
154                         return i;
155         }
156         
157         mathutils_callbacks[i] = cb;
158         return i;
159 }
160
161 /* use macros to check for NULL */
162 int _BaseMathObject_ReadCallback(BaseMathObject *self)
163 {
164         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
165         if(cb->get(self, self->cb_subtype))
166                 return 1;
167
168         if(!PyErr_Occurred())
169                 PyErr_Format(PyExc_SystemError, "%s user has become invalid", Py_TYPE(self)->tp_name);
170         return 0;
171 }
172
173 int _BaseMathObject_WriteCallback(BaseMathObject *self)
174 {
175         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
176         if(cb->set(self, self->cb_subtype))
177                 return 1;
178
179         if(!PyErr_Occurred())
180                 PyErr_Format(PyExc_SystemError, "%s user has become invalid", Py_TYPE(self)->tp_name);
181         return 0;
182 }
183
184 int _BaseMathObject_ReadIndexCallback(BaseMathObject *self, int index)
185 {
186         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
187         if(cb->get_index(self, self->cb_subtype, index))
188                 return 1;
189
190         if(!PyErr_Occurred())
191                 PyErr_Format(PyExc_SystemError, "%s user has become invalid", Py_TYPE(self)->tp_name);
192         return 0;
193 }
194
195 int _BaseMathObject_WriteIndexCallback(BaseMathObject *self, int index)
196 {
197         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
198         if(cb->set_index(self, self->cb_subtype, index))
199                 return 1;
200
201         if(!PyErr_Occurred())
202                 PyErr_Format(PyExc_SystemError, "%s user has become invalid", Py_TYPE(self)->tp_name);
203         return 0;
204 }
205
206 /* BaseMathObject generic functions for all mathutils types */
207 char BaseMathObject_Owner_doc[] = "The item this is wrapping or None  (readonly).";
208 PyObject *BaseMathObject_getOwner(BaseMathObject *self, void *UNUSED(closure))
209 {
210         PyObject *ret= self->cb_user ? self->cb_user : Py_None;
211         Py_INCREF(ret);
212         return ret;
213 }
214
215 char BaseMathObject_Wrapped_doc[] = "True when this object wraps external data (readonly).\n\n:type: boolean";
216 PyObject *BaseMathObject_getWrapped(BaseMathObject *self, void *UNUSED(closure))
217 {
218         return PyBool_FromLong((self->wrapped == Py_WRAP) ? 1:0);
219 }
220
221 void BaseMathObject_dealloc(BaseMathObject * self)
222 {
223         /* only free non wrapped */
224         if(self->wrapped != Py_WRAP)
225                 PyMem_Free(self->data);
226
227         Py_XDECREF(self->cb_user);
228         Py_TYPE(self)->tp_free(self); // PyObject_DEL(self); // breaks subtypes
229 }
230
231 /*----------------------------MODULE INIT-------------------------*/
232 struct PyMethodDef M_Mathutils_methods[] = {
233         {NULL, NULL, 0, NULL}
234 };
235
236 static struct PyModuleDef M_Mathutils_module_def = {
237         PyModuleDef_HEAD_INIT,
238         "mathutils",  /* m_name */
239         M_Mathutils_doc,  /* m_doc */
240         0,  /* m_size */
241         M_Mathutils_methods,  /* m_methods */
242         0,  /* m_reload */
243         0,  /* m_traverse */
244         0,  /* m_clear */
245         0,  /* m_free */
246 };
247
248 PyObject *Mathutils_Init(void)
249 {
250         PyObject *submodule;
251         
252         if( PyType_Ready( &vector_Type ) < 0 )
253                 return NULL;
254         if( PyType_Ready( &matrix_Type ) < 0 )
255                 return NULL;    
256         if( PyType_Ready( &euler_Type ) < 0 )
257                 return NULL;
258         if( PyType_Ready( &quaternion_Type ) < 0 )
259                 return NULL;
260         if( PyType_Ready( &color_Type ) < 0 )
261                 return NULL;
262
263         submodule = PyModule_Create(&M_Mathutils_module_def);
264         PyDict_SetItemString(PyImport_GetModuleDict(), M_Mathutils_module_def.m_name, submodule);
265         
266         /* each type has its own new() function */
267         PyModule_AddObject( submodule, "Vector",                (PyObject *)&vector_Type );
268         PyModule_AddObject( submodule, "Matrix",                (PyObject *)&matrix_Type );
269         PyModule_AddObject( submodule, "Euler",                 (PyObject *)&euler_Type );
270         PyModule_AddObject( submodule, "Quaternion",    (PyObject *)&quaternion_Type );
271         PyModule_AddObject( submodule, "Color",                 (PyObject *)&color_Type );
272         
273         mathutils_matrix_vector_cb_index= Mathutils_RegisterCallback(&mathutils_matrix_vector_cb);
274
275         return (submodule);
276 }