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