392 lines
13 KiB
C
392 lines
13 KiB
C
/*
|
|
* $Id$
|
|
*
|
|
* ***** BEGIN GPL LICENSE BLOCK *****
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
|
* All rights reserved.
|
|
*
|
|
* This is a new part of Blender.
|
|
*
|
|
* Contributor(s): Joseph Gilbert, Campbell Barton
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*/
|
|
|
|
/* Note: Changes to Mathutils since 2.4x
|
|
* use radians rather then degrees
|
|
* - Mathutils.Vector/Euler/Quaternion(), now only take single sequence arguments.
|
|
* - Mathutils.MidpointVecs --> vector.lerp(other, fac)
|
|
* - Mathutils.AngleBetweenVecs --> vector.angle(other)
|
|
* - Mathutils.ProjectVecs --> vector.project(other)
|
|
* - Mathutils.DifferenceQuats --> quat.difference(other)
|
|
* - Mathutils.Slerp --> quat.slerp(other, fac)
|
|
* - Mathutils.Rand: removed, use pythons random module
|
|
* - Mathutils.RotationMatrix(angle, size, axis_flag, axis) --> Mathutils.RotationMatrix(angle, size, axis); merge axis & axis_flag args
|
|
* - Mathutils.OrthoProjectionMatrix(plane, size, axis) --> Mathutils.OrthoProjectionMatrix(axis, size); merge axis & plane args
|
|
* - Mathutils.ShearMatrix(plane, factor, size) --> Mathutils.ShearMatrix(plane, size, factor); swap size & factor args, match other constructors.
|
|
* - Matrix.scalePart --> Matrix.scale_part
|
|
* - Matrix.translationPart --> Matrix.translation_part
|
|
* - Matrix.rotationPart --> Matrix.rotation_part
|
|
* - mathutils.Matrix.Shear(plane, fac, size), now takes a pair of floats for 3x3 or 4x4 shear factor.
|
|
* - toMatrix --> to_matrix
|
|
* - toEuler --> to_euler
|
|
* - toQuat --> to_quat
|
|
* - Vector.toTrackQuat --> Vector.to_track_quat
|
|
* - Vector.rotate(axis, angle) --> rotate(other), where other can be Euler/Quaternion/Matrix.
|
|
* - Quaternion * Quaternion --> cross product (not dot product)
|
|
* - Euler.rotate(angle, axis) --> Euler.rotate_axis(axis, angle)
|
|
* - Euler.unique() *removed*, not a standard function only toggled different rotations.
|
|
* - Matrix.rotation_part() -> to_3x3()
|
|
* - Matrix.scale_part() -> to_scale()
|
|
* - Matrix.translation_part() -> to_translation()
|
|
* - Matrix.resize4x4() -> resize_4x4()
|
|
* - Euler.to_quat() -> to_quaternion()
|
|
* - Matrix.to_quat() -> to_quaternion()
|
|
* resizing nolonger returns the resized value.
|
|
* - Vector.resize2D -> resize_2d
|
|
* - Vector.resize3D -> resize_3d
|
|
* - Vector.resize4D -> resize_4d
|
|
* added new functions.
|
|
* - Vector.to_2d()
|
|
* - Vector.to_3d()
|
|
* - Vector.to_4d()
|
|
* moved into class functions.
|
|
* - Mathutils.RotationMatrix -> mathutils.Matrix.Rotation
|
|
* - Mathutils.ScaleMatrix -> mathutils.Matrix.Scale
|
|
* - Mathutils.ShearMatrix -> mathutils.Matrix.Shear
|
|
* - Mathutils.TranslationMatrix -> mathutils.Matrix.Translation
|
|
* - Mathutils.OrthoProjectionMatrix -> mathutils.Matrix.OrthoProjection
|
|
*
|
|
* Moved to Geometry module: Intersect, TriangleArea, TriangleNormal, QuadNormal, LineIntersect
|
|
* - geometry.Intersect -> intersect_ray_tri
|
|
* - geometry.ClosestPointOnLine -> intersect_point_line
|
|
* - geometry.PointInTriangle2D -> intersect_point_tri_2d
|
|
* - geometry.PointInQuad2D -> intersect_point_quad_2d
|
|
* - geometry.LineIntersect -> intersect_line_line
|
|
* - geometry.LineIntersect2D -> intersect_line_line_2d
|
|
* - geometry.BezierInterp -> interpolate_bezier
|
|
* - geometry.TriangleArea -> area_tri
|
|
* - geometry.QuadNormal, TriangleNormal -> normal
|
|
* - geometry.PolyFill -> tesselate_polygon
|
|
* - geometry.BoxPack2D -> box_pack_2d
|
|
* - geometry.BarycentricTransform -> barycentric_transform
|
|
*/
|
|
|
|
#include <Python.h>
|
|
|
|
#include "mathutils.h"
|
|
|
|
#include "BLI_math.h"
|
|
#include "BLI_utildefines.h"
|
|
|
|
|
|
|
|
//-------------------------DOC STRINGS ---------------------------
|
|
static char M_Mathutils_doc[] =
|
|
"This module provides access to matrices, eulers, quaternions and vectors."
|
|
;
|
|
static int mathutils_array_parse_fast(float *array, int array_min, int array_max, PyObject *value, const char *error_prefix)
|
|
{
|
|
PyObject *value_fast= NULL;
|
|
PyObject *item;
|
|
|
|
int i, size;
|
|
|
|
/* non list/tuple cases */
|
|
if(!(value_fast=PySequence_Fast(value, error_prefix))) {
|
|
/* PySequence_Fast sets the error */
|
|
return -1;
|
|
}
|
|
|
|
size= PySequence_Fast_GET_SIZE(value_fast);
|
|
|
|
if(size > array_max || size < array_min) {
|
|
if (array_max == array_min) PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected %d", error_prefix, size, array_max);
|
|
else PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected [%d - %d]", error_prefix, size, array_min, array_max);
|
|
Py_DECREF(value_fast);
|
|
return -1;
|
|
}
|
|
|
|
i= size;
|
|
do {
|
|
i--;
|
|
if(((array[i]= PyFloat_AsDouble((item= PySequence_Fast_GET_ITEM(value_fast, i)))) == -1.0) && PyErr_Occurred()) {
|
|
PyErr_Format(PyExc_ValueError, "%.200s: sequence index %d expected a number, found '%.200s' type, ", error_prefix, i, Py_TYPE(item)->tp_name);
|
|
Py_DECREF(value_fast);
|
|
return -1;
|
|
}
|
|
} while(i);
|
|
|
|
Py_XDECREF(value_fast);
|
|
return size;
|
|
}
|
|
|
|
/* helper functionm returns length of the 'value', -1 on error */
|
|
int mathutils_array_parse(float *array, int array_min, int array_max, PyObject *value, const char *error_prefix)
|
|
{
|
|
#if 1 /* approx 6x speedup for mathutils types */
|
|
int size;
|
|
|
|
if( (VectorObject_Check(value) && (size= ((VectorObject *)value)->size)) ||
|
|
(EulerObject_Check(value) && (size= 3)) ||
|
|
(QuaternionObject_Check(value) && (size= 4)) ||
|
|
(ColorObject_Check(value) && (size= 3))
|
|
) {
|
|
if(!BaseMath_ReadCallback((BaseMathObject *)value)) {
|
|
return -1;
|
|
}
|
|
|
|
if(size > array_max || size < array_min) {
|
|
if (array_max == array_min) PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected %d", error_prefix, size, array_max);
|
|
else PyErr_Format(PyExc_ValueError, "%.200s: sequence size is %d, expected [%d - %d]", error_prefix, size, array_min, array_max);
|
|
return -1;
|
|
}
|
|
|
|
memcpy(array, ((BaseMathObject *)value)->data, size * sizeof(float));
|
|
return size;
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
return mathutils_array_parse_fast(array, array_min, array_max, value, error_prefix);
|
|
}
|
|
}
|
|
|
|
int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error_prefix)
|
|
{
|
|
if(EulerObject_Check(value)) {
|
|
if(!BaseMath_ReadCallback((BaseMathObject *)value)) {
|
|
return -1;
|
|
}
|
|
else {
|
|
eulO_to_mat3(rmat, ((EulerObject *)value)->eul, ((EulerObject *)value)->order);
|
|
return 0;
|
|
}
|
|
}
|
|
else if (QuaternionObject_Check(value)) {
|
|
if(!BaseMath_ReadCallback((BaseMathObject *)value)) {
|
|
return -1;
|
|
}
|
|
else {
|
|
float tquat[4];
|
|
normalize_qt_qt(tquat, ((QuaternionObject *)value)->quat);
|
|
quat_to_mat3(rmat, tquat);
|
|
return 0;
|
|
}
|
|
}
|
|
else if (MatrixObject_Check(value)) {
|
|
if(!BaseMath_ReadCallback((BaseMathObject *)value)) {
|
|
return -1;
|
|
}
|
|
else if(((MatrixObject *)value)->col_size < 3 || ((MatrixObject *)value)->row_size < 3) {
|
|
PyErr_Format(PyExc_ValueError, "%.200s: matrix must have minimum 3x3 dimensions", error_prefix);
|
|
return -1;
|
|
}
|
|
else {
|
|
matrix_as_3x3(rmat, (MatrixObject *)value);
|
|
normalize_m3(rmat);
|
|
return 0;
|
|
}
|
|
}
|
|
else {
|
|
PyErr_Format(PyExc_TypeError, "%.200s: expected a Euler, Quaternion or Matrix type, found %.200s", error_prefix, Py_TYPE(value)->tp_name);
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
|
|
//----------------------------------MATRIX FUNCTIONS--------------------
|
|
|
|
|
|
/* Utility functions */
|
|
|
|
// LomontRRDCompare4, Ever Faster Float Comparisons by Randy Dillon
|
|
#define SIGNMASK(i) (-(int)(((unsigned int)(i))>>31))
|
|
|
|
int EXPP_FloatsAreEqual(float af, float bf, int maxDiff)
|
|
{ // solid, fast routine across all platforms
|
|
// with constant time behavior
|
|
int ai = *(int *)(&af);
|
|
int bi = *(int *)(&bf);
|
|
int test = SIGNMASK(ai^bi);
|
|
int diff, v1, v2;
|
|
|
|
assert((0 == test) || (0xFFFFFFFF == test));
|
|
diff = (ai ^ (test & 0x7fffffff)) - bi;
|
|
v1 = maxDiff + diff;
|
|
v2 = maxDiff - diff;
|
|
return (v1|v2) >= 0;
|
|
}
|
|
|
|
/*---------------------- EXPP_VectorsAreEqual -------------------------
|
|
Builds on EXPP_FloatsAreEqual to test vectors */
|
|
int EXPP_VectorsAreEqual(float *vecA, float *vecB, int size, int floatSteps)
|
|
{
|
|
int x;
|
|
for (x=0; x< size; x++){
|
|
if (EXPP_FloatsAreEqual(vecA[x], vecB[x], floatSteps) == 0)
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* Mathutils Callbacks */
|
|
|
|
/* for mathutils internal use only, eventually should re-alloc but to start with we only have a few users */
|
|
static Mathutils_Callback *mathutils_callbacks[8] = {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL};
|
|
|
|
int Mathutils_RegisterCallback(Mathutils_Callback *cb)
|
|
{
|
|
int i;
|
|
|
|
/* find the first free slot */
|
|
for(i= 0; mathutils_callbacks[i]; i++) {
|
|
if(mathutils_callbacks[i]==cb) /* already registered? */
|
|
return i;
|
|
}
|
|
|
|
mathutils_callbacks[i] = cb;
|
|
return i;
|
|
}
|
|
|
|
/* use macros to check for NULL */
|
|
int _BaseMathObject_ReadCallback(BaseMathObject *self)
|
|
{
|
|
Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
|
|
if(cb->get(self, self->cb_subtype))
|
|
return 1;
|
|
|
|
if(!PyErr_Occurred())
|
|
PyErr_Format(PyExc_RuntimeError, "%s user has become invalid", Py_TYPE(self)->tp_name);
|
|
return 0;
|
|
}
|
|
|
|
int _BaseMathObject_WriteCallback(BaseMathObject *self)
|
|
{
|
|
Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
|
|
if(cb->set(self, self->cb_subtype))
|
|
return 1;
|
|
|
|
if(!PyErr_Occurred())
|
|
PyErr_Format(PyExc_RuntimeError, "%s user has become invalid", Py_TYPE(self)->tp_name);
|
|
return 0;
|
|
}
|
|
|
|
int _BaseMathObject_ReadIndexCallback(BaseMathObject *self, int index)
|
|
{
|
|
Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
|
|
if(cb->get_index(self, self->cb_subtype, index))
|
|
return 1;
|
|
|
|
if(!PyErr_Occurred())
|
|
PyErr_Format(PyExc_RuntimeError, "%s user has become invalid", Py_TYPE(self)->tp_name);
|
|
return 0;
|
|
}
|
|
|
|
int _BaseMathObject_WriteIndexCallback(BaseMathObject *self, int index)
|
|
{
|
|
Mathutils_Callback *cb= mathutils_callbacks[self->cb_type];
|
|
if(cb->set_index(self, self->cb_subtype, index))
|
|
return 1;
|
|
|
|
if(!PyErr_Occurred())
|
|
PyErr_Format(PyExc_RuntimeError, "%s user has become invalid", Py_TYPE(self)->tp_name);
|
|
return 0;
|
|
}
|
|
|
|
/* BaseMathObject generic functions for all mathutils types */
|
|
char BaseMathObject_Owner_doc[] = "The item this is wrapping or None (readonly).";
|
|
PyObject *BaseMathObject_getOwner(BaseMathObject *self, void *UNUSED(closure))
|
|
{
|
|
PyObject *ret= self->cb_user ? self->cb_user : Py_None;
|
|
Py_INCREF(ret);
|
|
return ret;
|
|
}
|
|
|
|
char BaseMathObject_Wrapped_doc[] = "True when this object wraps external data (readonly).\n\n:type: boolean";
|
|
PyObject *BaseMathObject_getWrapped(BaseMathObject *self, void *UNUSED(closure))
|
|
{
|
|
return PyBool_FromLong((self->wrapped == Py_WRAP) ? 1:0);
|
|
}
|
|
|
|
void BaseMathObject_dealloc(BaseMathObject * self)
|
|
{
|
|
/* only free non wrapped */
|
|
if(self->wrapped != Py_WRAP)
|
|
PyMem_Free(self->data);
|
|
|
|
Py_XDECREF(self->cb_user);
|
|
Py_TYPE(self)->tp_free(self); // PyObject_DEL(self); // breaks subtypes
|
|
}
|
|
|
|
/*----------------------------MODULE INIT-------------------------*/
|
|
static struct PyMethodDef M_Mathutils_methods[] = {
|
|
{NULL, NULL, 0, NULL}
|
|
};
|
|
|
|
static struct PyModuleDef M_Mathutils_module_def = {
|
|
PyModuleDef_HEAD_INIT,
|
|
"mathutils", /* m_name */
|
|
M_Mathutils_doc, /* m_doc */
|
|
0, /* m_size */
|
|
M_Mathutils_methods, /* m_methods */
|
|
NULL, /* m_reload */
|
|
NULL, /* m_traverse */
|
|
NULL, /* m_clear */
|
|
NULL, /* m_free */
|
|
};
|
|
|
|
PyMODINIT_FUNC BPyInit_mathutils(void)
|
|
{
|
|
PyObject *submodule;
|
|
PyObject *item;
|
|
|
|
if( PyType_Ready( &vector_Type ) < 0 )
|
|
return NULL;
|
|
if( PyType_Ready( &matrix_Type ) < 0 )
|
|
return NULL;
|
|
if( PyType_Ready( &euler_Type ) < 0 )
|
|
return NULL;
|
|
if( PyType_Ready( &quaternion_Type ) < 0 )
|
|
return NULL;
|
|
if( PyType_Ready( &color_Type ) < 0 )
|
|
return NULL;
|
|
|
|
submodule = PyModule_Create(&M_Mathutils_module_def);
|
|
|
|
/* each type has its own new() function */
|
|
PyModule_AddObject( submodule, "Vector", (PyObject *)&vector_Type );
|
|
PyModule_AddObject( submodule, "Matrix", (PyObject *)&matrix_Type );
|
|
PyModule_AddObject( submodule, "Euler", (PyObject *)&euler_Type );
|
|
PyModule_AddObject( submodule, "Quaternion", (PyObject *)&quaternion_Type );
|
|
PyModule_AddObject( submodule, "Color", (PyObject *)&color_Type );
|
|
|
|
/* submodule */
|
|
PyModule_AddObject( submodule, "geometry", (item=BPyInit_mathutils_geometry()));
|
|
/* XXX, python doesnt do imports with this usefully yet
|
|
* 'from mathutils.geometry import PolyFill'
|
|
* ...fails without this. */
|
|
PyDict_SetItemString(PyThreadState_GET()->interp->modules, "mathutils.geometry", item);
|
|
Py_INCREF(item);
|
|
|
|
mathutils_matrix_vector_cb_index= Mathutils_RegisterCallback(&mathutils_matrix_vector_cb);
|
|
|
|
return submodule;
|
|
}
|