2e01dbe4cde9f3d69214be281c93689e0d4f03c5
[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  * - geometry.Intersect -> intersect_ray_tri
59  * - geometry.ClosestPointOnLine -> intersect_point_line
60  * - geometry.PointInTriangle2D -> intersect_point_tri_2d
61  * - geometry.PointInQuad2D -> intersect_point_quad_2d
62  * - geometry.LineIntersect -> intersect_line_line
63  * - geometry.LineIntersect2D -> intersect_line_line_2d
64  * - geometry.BezierInterp -> interpolate_bezier
65  * - geometry.TriangleArea -> area_tri
66  * - geometry.QuadNormal, TriangleNormal -> normal
67  * - geometry.PolyFill -> tesselate_polygon
68  * - geometry.BoxPack2D -> box_pack_2d
69  * - geometry.BarycentricTransform -> barycentric_transform
70  */
71
72 #include "mathutils.h"
73
74 #include "BLI_math.h"
75 #include "BLI_utildefines.h"
76
77
78
79 //-------------------------DOC STRINGS ---------------------------
80 static char M_Mathutils_doc[] =
81 "This module provides access to matrices, eulers, quaternions and vectors.";
82
83 /* helper functionm returns length of the 'value', -1 on error */
84 int mathutils_array_parse(float *array, int array_min, int array_max, PyObject *value, const char *error_prefix)
85 {
86         PyObject *value_fast= NULL;
87
88         int i, size;
89
90         /* non list/tuple cases */
91         if(!(value_fast=PySequence_Fast(value, error_prefix))) {
92                 /* PySequence_Fast sets the error */
93                 return -1;
94         }
95
96         size= PySequence_Fast_GET_SIZE(value_fast);
97
98         if(size > array_max || size < array_min) {
99                 if (array_max == array_min)     PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected %d", error_prefix, size, array_max);
100                 else                                            PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected [%d - %d]", error_prefix, size, array_min, array_max);
101                 Py_DECREF(value_fast);
102                 return -1;
103         }
104
105         i= size;
106         do {
107                 i--;
108                 if(((array[i]= PyFloat_AsDouble(PySequence_Fast_GET_ITEM(value_fast, i))) == -1.0) && PyErr_Occurred()) {
109                         PyErr_Format(PyExc_ValueError, "%.200s: sequence index %d is not a float", error_prefix, i);
110                         Py_DECREF(value_fast);
111                         return -1;
112                 }
113         } while(i);
114
115         Py_XDECREF(value_fast);
116         return size;
117 }
118
119 //----------------------------------MATRIX FUNCTIONS--------------------
120
121
122 /* Utility functions */
123
124 // LomontRRDCompare4, Ever Faster Float Comparisons by Randy Dillon
125 #define SIGNMASK(i) (-(int)(((unsigned int)(i))>>31))
126
127 int EXPP_FloatsAreEqual(float af, float bf, int maxDiff)
128 {       // solid, fast routine across all platforms
129         // with constant time behavior
130         int ai = *(int *)(&af);
131         int bi = *(int *)(&bf);
132         int test = SIGNMASK(ai^bi);
133         int diff, v1, v2;
134
135         assert((0 == test) || (0xFFFFFFFF == test));
136         diff = (ai ^ (test & 0x7fffffff)) - bi;
137         v1 = maxDiff + diff;
138         v2 = maxDiff - diff;
139         return (v1|v2) >= 0;
140 }
141
142 /*---------------------- EXPP_VectorsAreEqual -------------------------
143   Builds on EXPP_FloatsAreEqual to test vectors */
144 int EXPP_VectorsAreEqual(float *vecA, float *vecB, int size, int floatSteps)
145 {
146         int x;
147         for (x=0; x< size; x++){
148                 if (EXPP_FloatsAreEqual(vecA[x], vecB[x], floatSteps) == 0)
149                         return 0;
150         }
151         return 1;
152 }
153
154
155 /* Mathutils Callbacks */
156
157 /* for mathutils internal use only, eventually should re-alloc but to start with we only have a few users */
158 Mathutils_Callback *mathutils_callbacks[8] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
159
160 int Mathutils_RegisterCallback(Mathutils_Callback *cb)
161 {
162         int i;
163         
164         /* find the first free slot */
165         for(i= 0; mathutils_callbacks[i]; i++) {
166                 if(mathutils_callbacks[i]==cb) /* already registered? */
167                         return i;
168         }
169         
170         mathutils_callbacks[i] = cb;
171         return i;
172 }
173
174 /* use macros to check for NULL */
175 int _BaseMathObject_ReadCallback(BaseMathObject *self)
176 {
177         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
178         if(cb->get(self, self->cb_subtype))
179                 return 1;
180
181         if(!PyErr_Occurred())
182                 PyErr_Format(PyExc_SystemError, "%s user has become invalid", Py_TYPE(self)->tp_name);
183         return 0;
184 }
185
186 int _BaseMathObject_WriteCallback(BaseMathObject *self)
187 {
188         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
189         if(cb->set(self, self->cb_subtype))
190                 return 1;
191
192         if(!PyErr_Occurred())
193                 PyErr_Format(PyExc_SystemError, "%s user has become invalid", Py_TYPE(self)->tp_name);
194         return 0;
195 }
196
197 int _BaseMathObject_ReadIndexCallback(BaseMathObject *self, int index)
198 {
199         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
200         if(cb->get_index(self, self->cb_subtype, index))
201                 return 1;
202
203         if(!PyErr_Occurred())
204                 PyErr_Format(PyExc_SystemError, "%s user has become invalid", Py_TYPE(self)->tp_name);
205         return 0;
206 }
207
208 int _BaseMathObject_WriteIndexCallback(BaseMathObject *self, int index)
209 {
210         Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
211         if(cb->set_index(self, self->cb_subtype, index))
212                 return 1;
213
214         if(!PyErr_Occurred())
215                 PyErr_Format(PyExc_SystemError, "%s user has become invalid", Py_TYPE(self)->tp_name);
216         return 0;
217 }
218
219 /* BaseMathObject generic functions for all mathutils types */
220 char BaseMathObject_Owner_doc[] = "The item this is wrapping or None  (readonly).";
221 PyObject *BaseMathObject_getOwner(BaseMathObject *self, void *UNUSED(closure))
222 {
223         PyObject *ret= self->cb_user ? self->cb_user : Py_None;
224         Py_INCREF(ret);
225         return ret;
226 }
227
228 char BaseMathObject_Wrapped_doc[] = "True when this object wraps external data (readonly).\n\n:type: boolean";
229 PyObject *BaseMathObject_getWrapped(BaseMathObject *self, void *UNUSED(closure))
230 {
231         return PyBool_FromLong((self->wrapped == Py_WRAP) ? 1:0);
232 }
233
234 void BaseMathObject_dealloc(BaseMathObject * self)
235 {
236         /* only free non wrapped */
237         if(self->wrapped != Py_WRAP)
238                 PyMem_Free(self->data);
239
240         Py_XDECREF(self->cb_user);
241         Py_TYPE(self)->tp_free(self); // PyObject_DEL(self); // breaks subtypes
242 }
243
244 /*----------------------------MODULE INIT-------------------------*/
245 struct PyMethodDef M_Mathutils_methods[] = {
246         {NULL, NULL, 0, NULL}
247 };
248
249 static struct PyModuleDef M_Mathutils_module_def = {
250         PyModuleDef_HEAD_INIT,
251         "mathutils",  /* m_name */
252         M_Mathutils_doc,  /* m_doc */
253         0,  /* m_size */
254         M_Mathutils_methods,  /* m_methods */
255         0,  /* m_reload */
256         0,  /* m_traverse */
257         0,  /* m_clear */
258         0,  /* m_free */
259 };
260
261 PyMODINIT_FUNC BPyInit_mathutils(void)
262 {
263         PyObject *submodule;
264         PyObject *item;
265
266         if( PyType_Ready( &vector_Type ) < 0 )
267                 return NULL;
268         if( PyType_Ready( &matrix_Type ) < 0 )
269                 return NULL;    
270         if( PyType_Ready( &euler_Type ) < 0 )
271                 return NULL;
272         if( PyType_Ready( &quaternion_Type ) < 0 )
273                 return NULL;
274         if( PyType_Ready( &color_Type ) < 0 )
275                 return NULL;
276
277         submodule = PyModule_Create(&M_Mathutils_module_def);
278         
279         /* each type has its own new() function */
280         PyModule_AddObject( submodule, "Vector",                (PyObject *)&vector_Type );
281         PyModule_AddObject( submodule, "Matrix",                (PyObject *)&matrix_Type );
282         PyModule_AddObject( submodule, "Euler",                 (PyObject *)&euler_Type );
283         PyModule_AddObject( submodule, "Quaternion",    (PyObject *)&quaternion_Type );
284         PyModule_AddObject( submodule, "Color",                 (PyObject *)&color_Type );
285         
286         /* submodule */
287         PyModule_AddObject( submodule, "geometry",              (item=BPyInit_mathutils_geometry()));
288         /* XXX, python doesnt do imports with this usefully yet
289          * 'from mathutils.geometry import PolyFill'
290          * ...fails without this. */
291         PyDict_SetItemString(PyThreadState_GET()->interp->modules, "mathutils.geometry", item);
292         Py_INCREF(item);
293
294         mathutils_matrix_vector_cb_index= Mathutils_RegisterCallback(&mathutils_matrix_vector_cb);
295
296         return submodule;
297 }