/* * $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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 ***** */ #include "Mathutils.h" #include "BLI_arithb.h" #include "PIL_time.h" #include "BLI_rand.h" #include "BKE_utildefines.h" #include "gen_utils.h" //-------------------------DOC STRINGS --------------------------- static char M_Mathutils_doc[] = "The Blender Mathutils module\n\n"; static char M_Mathutils_Vector_doc[] = "() - create a new vector object from a list of floats"; static char M_Mathutils_Matrix_doc[] = "() - create a new matrix object from a list of floats"; static char M_Mathutils_Quaternion_doc[] = "() - create a quaternion from a list or an axis of rotation and an angle"; static char M_Mathutils_Euler_doc[] = "() - create and return a new euler object"; static char M_Mathutils_Rand_doc[] = "() - return a random number"; static char M_Mathutils_CrossVecs_doc[] = "() - returns a vector perpedicular to the 2 vectors crossed"; static char M_Mathutils_CopyVec_doc[] = "() - create a copy of vector"; static char M_Mathutils_DotVecs_doc[] = "() - return the dot product of two vectors"; static char M_Mathutils_AngleBetweenVecs_doc[] = "() - returns the angle between two vectors in degrees"; static char M_Mathutils_MidpointVecs_doc[] = "() - return the vector to the midpoint between two vectors"; static char M_Mathutils_MatMultVec_doc[] = "() - multiplies a matrix by a column vector"; static char M_Mathutils_VecMultMat_doc[] = "() - multiplies a row vector by a matrix"; static char M_Mathutils_ProjectVecs_doc[] = "() - returns the projection vector from the projection of vecA onto vecB"; static char M_Mathutils_RotationMatrix_doc[] = "() - construct a rotation matrix from an angle and axis of rotation"; static char M_Mathutils_ScaleMatrix_doc[] = "() - construct a scaling matrix from a scaling factor"; static char M_Mathutils_OrthoProjectionMatrix_doc[] = "() - construct a orthographic projection matrix from a selected plane"; static char M_Mathutils_ShearMatrix_doc[] = "() - construct a shearing matrix from a plane of shear and a shear factor"; static char M_Mathutils_CopyMat_doc[] = "() - create a copy of a matrix"; static char M_Mathutils_TranslationMatrix_doc[] = "(vec) - create a translation matrix from a vector"; static char M_Mathutils_CopyQuat_doc[] = "() - copy quatB to quatA"; static char M_Mathutils_CopyEuler_doc[] = "() - copy eulB to eultA"; static char M_Mathutils_CrossQuats_doc[] = "() - return the mutliplication of two quaternions"; static char M_Mathutils_DotQuats_doc[] = "() - return the dot product of two quaternions"; static char M_Mathutils_Slerp_doc[] = "() - returns the interpolation between two quaternions"; static char M_Mathutils_DifferenceQuats_doc[] = "() - return the angular displacment difference between two quats"; static char M_Mathutils_RotateEuler_doc[] = "() - rotate euler by an axis and angle"; static char M_Mathutils_Intersect_doc[] = "(v1, v2, v3, ray, orig, clip=1) - returns the intersection between a ray and a triangle, if possible, returns None otherwise"; static char M_Mathutils_TriangleArea_doc[] = "(v1, v2, v3) - returns the area size of the 2D or 3D triangle defined"; static char M_Mathutils_TriangleNormal_doc[] = "(v1, v2, v3) - returns the normal of the 3D triangle defined"; static char M_Mathutils_QuadNormal_doc[] = "(v1, v2, v3, v4) - returns the normal of the 3D quad defined"; static char M_Mathutils_LineIntersect_doc[] = "(v1, v2, v3, v4) - returns a tuple with the points on each line respectively closest to the other"; static char M_Mathutils_Point_doc[] = "Creates a 2d or 3d point object"; //-----------------------METHOD DEFINITIONS ---------------------- struct PyMethodDef M_Mathutils_methods[] = { {"Rand", (PyCFunction) M_Mathutils_Rand, METH_VARARGS, M_Mathutils_Rand_doc}, {"Vector", (PyCFunction) M_Mathutils_Vector, METH_VARARGS, M_Mathutils_Vector_doc}, {"CrossVecs", (PyCFunction) M_Mathutils_CrossVecs, METH_VARARGS, M_Mathutils_CrossVecs_doc}, {"DotVecs", (PyCFunction) M_Mathutils_DotVecs, METH_VARARGS, M_Mathutils_DotVecs_doc}, {"AngleBetweenVecs", (PyCFunction) M_Mathutils_AngleBetweenVecs, METH_VARARGS, M_Mathutils_AngleBetweenVecs_doc}, {"MidpointVecs", (PyCFunction) M_Mathutils_MidpointVecs, METH_VARARGS, M_Mathutils_MidpointVecs_doc}, {"VecMultMat", (PyCFunction) M_Mathutils_VecMultMat, METH_VARARGS, M_Mathutils_VecMultMat_doc}, {"ProjectVecs", (PyCFunction) M_Mathutils_ProjectVecs, METH_VARARGS, M_Mathutils_ProjectVecs_doc}, {"CopyVec", (PyCFunction) M_Mathutils_CopyVec, METH_VARARGS, M_Mathutils_CopyVec_doc}, {"Matrix", (PyCFunction) M_Mathutils_Matrix, METH_VARARGS, M_Mathutils_Matrix_doc}, {"RotationMatrix", (PyCFunction) M_Mathutils_RotationMatrix, METH_VARARGS, M_Mathutils_RotationMatrix_doc}, {"ScaleMatrix", (PyCFunction) M_Mathutils_ScaleMatrix, METH_VARARGS, M_Mathutils_ScaleMatrix_doc}, {"ShearMatrix", (PyCFunction) M_Mathutils_ShearMatrix, METH_VARARGS, M_Mathutils_ShearMatrix_doc}, {"TranslationMatrix", (PyCFunction) M_Mathutils_TranslationMatrix, METH_O, M_Mathutils_TranslationMatrix_doc}, {"CopyMat", (PyCFunction) M_Mathutils_CopyMat, METH_VARARGS, M_Mathutils_CopyMat_doc}, {"OrthoProjectionMatrix", (PyCFunction) M_Mathutils_OrthoProjectionMatrix, METH_VARARGS, M_Mathutils_OrthoProjectionMatrix_doc}, {"MatMultVec", (PyCFunction) M_Mathutils_MatMultVec, METH_VARARGS, M_Mathutils_MatMultVec_doc}, {"Quaternion", (PyCFunction) M_Mathutils_Quaternion, METH_VARARGS, M_Mathutils_Quaternion_doc}, {"CopyQuat", (PyCFunction) M_Mathutils_CopyQuat, METH_VARARGS, M_Mathutils_CopyQuat_doc}, {"CrossQuats", (PyCFunction) M_Mathutils_CrossQuats, METH_VARARGS, M_Mathutils_CrossQuats_doc}, {"DotQuats", (PyCFunction) M_Mathutils_DotQuats, METH_VARARGS, M_Mathutils_DotQuats_doc}, {"DifferenceQuats", (PyCFunction) M_Mathutils_DifferenceQuats, METH_VARARGS,M_Mathutils_DifferenceQuats_doc}, {"Slerp", (PyCFunction) M_Mathutils_Slerp, METH_VARARGS, M_Mathutils_Slerp_doc}, {"Euler", (PyCFunction) M_Mathutils_Euler, METH_VARARGS, M_Mathutils_Euler_doc}, {"CopyEuler", (PyCFunction) M_Mathutils_CopyEuler, METH_VARARGS, M_Mathutils_CopyEuler_doc}, {"RotateEuler", (PyCFunction) M_Mathutils_RotateEuler, METH_VARARGS, M_Mathutils_RotateEuler_doc}, {"Intersect", ( PyCFunction ) M_Mathutils_Intersect, METH_VARARGS, M_Mathutils_Intersect_doc}, {"TriangleArea", ( PyCFunction ) M_Mathutils_TriangleArea, METH_VARARGS, M_Mathutils_TriangleArea_doc}, {"TriangleNormal", ( PyCFunction ) M_Mathutils_TriangleNormal, METH_VARARGS, M_Mathutils_TriangleNormal_doc}, {"QuadNormal", ( PyCFunction ) M_Mathutils_QuadNormal, METH_VARARGS, M_Mathutils_QuadNormal_doc}, {"LineIntersect", ( PyCFunction ) M_Mathutils_LineIntersect, METH_VARARGS, M_Mathutils_LineIntersect_doc}, {"Point", (PyCFunction) M_Mathutils_Point, METH_VARARGS, M_Mathutils_Point_doc}, {NULL, NULL, 0, NULL} }; //----------------------------MODULE INIT------------------------- PyObject *Mathutils_Init(void) { PyObject *submodule; //seed the generator for the rand function BLI_srand((unsigned int) (PIL_check_seconds_timer() * 0x7FFFFFFF)); /* needed for getseters */ 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; submodule = Py_InitModule3("Blender.Mathutils", M_Mathutils_methods, M_Mathutils_doc); return (submodule); } //-----------------------------METHODS---------------------------- //----------------column_vector_multiplication (internal)--------- //COLUMN VECTOR Multiplication (Matrix X Vector) // [1][2][3] [a] // [4][5][6] * [b] // [7][8][9] [c] //vector/matrix multiplication IS NOT COMMUTATIVE!!!! PyObject *column_vector_multiplication(MatrixObject * mat, VectorObject* vec) { float vecNew[4], vecCopy[4]; double dot = 0.0f; int x, y, z = 0; if(mat->rowSize != vec->size){ if(mat->rowSize == 4 && vec->size != 3){ return EXPP_ReturnPyObjError(PyExc_AttributeError, "matrix * vector: matrix row size and vector size must be the same"); }else{ vecCopy[3] = 1.0f; } } for(x = 0; x < vec->size; x++){ vecCopy[x] = vec->vec[x]; } for(x = 0; x < mat->rowSize; x++) { for(y = 0; y < mat->colSize; y++) { dot += mat->matrix[x][y] * vecCopy[y]; } vecNew[z++] = (float)dot; dot = 0.0f; } return newVectorObject(vecNew, vec->size, Py_NEW); } //This is a helper for point/matrix translation PyObject *column_point_multiplication(MatrixObject * mat, PointObject* pt) { float ptNew[4], ptCopy[4]; double dot = 0.0f; int x, y, z = 0; if(mat->rowSize != pt->size){ if(mat->rowSize == 4 && pt->size != 3){ return EXPP_ReturnPyObjError(PyExc_AttributeError, "matrix * point: matrix row size and point size must be the same\n"); }else{ ptCopy[3] = 0.0f; } } for(x = 0; x < pt->size; x++){ ptCopy[x] = pt->coord[x]; } for(x = 0; x < mat->rowSize; x++) { for(y = 0; y < mat->colSize; y++) { dot += mat->matrix[x][y] * ptCopy[y]; } ptNew[z++] = (float)dot; dot = 0.0f; } return newPointObject(ptNew, pt->size, Py_NEW); } //-----------------row_vector_multiplication (internal)----------- //ROW VECTOR Multiplication - Vector X Matrix //[x][y][z] * [1][2][3] // [4][5][6] // [7][8][9] //vector/matrix multiplication IS NOT COMMUTATIVE!!!! PyObject *row_vector_multiplication(VectorObject* vec, MatrixObject * mat) { float vecNew[4], vecCopy[4]; double dot = 0.0f; int x, y, z = 0, vec_size = vec->size; if(mat->colSize != vec_size){ if(mat->rowSize == 4 && vec_size != 3){ return EXPP_ReturnPyObjError(PyExc_AttributeError, "vector * matrix: matrix column size and the vector size must be the same"); }else{ vecCopy[3] = 1.0f; } } for(x = 0; x < vec_size; x++){ vecCopy[x] = vec->vec[x]; } //muliplication for(x = 0; x < mat->colSize; x++) { for(y = 0; y < mat->rowSize; y++) { dot += mat->matrix[y][x] * vecCopy[y]; } vecNew[z++] = (float)dot; dot = 0.0f; } return newVectorObject(vecNew, vec_size, Py_NEW); } //This is a helper for the point class PyObject *row_point_multiplication(PointObject* pt, MatrixObject * mat) { float ptNew[4], ptCopy[4]; double dot = 0.0f; int x, y, z = 0, size; if(mat->colSize != pt->size){ if(mat->rowSize == 4 && pt->size != 3){ return EXPP_ReturnPyObjError(PyExc_AttributeError, "point * matrix: matrix column size and the point size must be the same\n"); }else{ ptCopy[3] = 0.0f; } } size = pt->size; for(x = 0; x < pt->size; x++){ ptCopy[x] = pt->coord[x]; } //muliplication for(x = 0; x < mat->colSize; x++) { for(y = 0; y < mat->rowSize; y++) { dot += mat->matrix[y][x] * ptCopy[y]; } ptNew[z++] = (float)dot; dot = 0.0f; } return newPointObject(ptNew, size, Py_NEW); } //-----------------quat_rotation (internal)----------- //This function multiplies a vector/point * quat or vice versa //to rotate the point/vector by the quaternion //arguments should all be 3D PyObject *quat_rotation(PyObject *arg1, PyObject *arg2) { float rot[3]; QuaternionObject *quat = NULL; VectorObject *vec = NULL; PointObject *pt = NULL; if(QuaternionObject_Check(arg1)){ quat = (QuaternionObject*)arg1; if(VectorObject_Check(arg2)){ vec = (VectorObject*)arg2; rot[0] = quat->quat[0]*quat->quat[0]*vec->vec[0] + 2*quat->quat[2]*quat->quat[0]*vec->vec[2] - 2*quat->quat[3]*quat->quat[0]*vec->vec[1] + quat->quat[1]*quat->quat[1]*vec->vec[0] + 2*quat->quat[2]*quat->quat[1]*vec->vec[1] + 2*quat->quat[3]*quat->quat[1]*vec->vec[2] - quat->quat[3]*quat->quat[3]*vec->vec[0] - quat->quat[2]*quat->quat[2]*vec->vec[0]; rot[1] = 2*quat->quat[1]*quat->quat[2]*vec->vec[0] + quat->quat[2]*quat->quat[2]*vec->vec[1] + 2*quat->quat[3]*quat->quat[2]*vec->vec[2] + 2*quat->quat[0]*quat->quat[3]*vec->vec[0] - quat->quat[3]*quat->quat[3]*vec->vec[1] + quat->quat[0]*quat->quat[0]*vec->vec[1] - 2*quat->quat[1]*quat->quat[0]*vec->vec[2] - quat->quat[1]*quat->quat[1]*vec->vec[1]; rot[2] = 2*quat->quat[1]*quat->quat[3]*vec->vec[0] + 2*quat->quat[2]*quat->quat[3]*vec->vec[1] + quat->quat[3]*quat->quat[3]*vec->vec[2] - 2*quat->quat[0]*quat->quat[2]*vec->vec[0] - quat->quat[2]*quat->quat[2]*vec->vec[2] + 2*quat->quat[0]*quat->quat[1]*vec->vec[1] - quat->quat[1]*quat->quat[1]*vec->vec[2] + quat->quat[0]*quat->quat[0]*vec->vec[2]; return newVectorObject(rot, 3, Py_NEW); }else if(PointObject_Check(arg2)){ pt = (PointObject*)arg2; rot[0] = quat->quat[0]*quat->quat[0]*pt->coord[0] + 2*quat->quat[2]*quat->quat[0]*pt->coord[2] - 2*quat->quat[3]*quat->quat[0]*pt->coord[1] + quat->quat[1]*quat->quat[1]*pt->coord[0] + 2*quat->quat[2]*quat->quat[1]*pt->coord[1] + 2*quat->quat[3]*quat->quat[1]*pt->coord[2] - quat->quat[3]*quat->quat[3]*pt->coord[0] - quat->quat[2]*quat->quat[2]*pt->coord[0]; rot[1] = 2*quat->quat[1]*quat->quat[2]*pt->coord[0] + quat->quat[2]*quat->quat[2]*pt->coord[1] + 2*quat->quat[3]*quat->quat[2]*pt->coord[2] + 2*quat->quat[0]*quat->quat[3]*pt->coord[0] - quat->quat[3]*quat->quat[3]*pt->coord[1] + quat->quat[0]*quat->quat[0]*pt->coord[1] - 2*quat->quat[1]*quat->quat[0]*pt->coord[2] - quat->quat[1]*quat->quat[1]*pt->coord[1]; rot[2] = 2*quat->quat[1]*quat->quat[3]*pt->coord[0] + 2*quat->quat[2]*quat->quat[3]*pt->coord[1] + quat->quat[3]*quat->quat[3]*pt->coord[2] - 2*quat->quat[0]*quat->quat[2]*pt->coord[0] - quat->quat[2]*quat->quat[2]*pt->coord[2] + 2*quat->quat[0]*quat->quat[1]*pt->coord[1] - quat->quat[1]*quat->quat[1]*pt->coord[2] + quat->quat[0]*quat->quat[0]*pt->coord[2]; return newPointObject(rot, 3, Py_NEW); } }else if(VectorObject_Check(arg1)){ vec = (VectorObject*)arg1; if(QuaternionObject_Check(arg2)){ quat = (QuaternionObject*)arg2; rot[0] = quat->quat[0]*quat->quat[0]*vec->vec[0] + 2*quat->quat[2]*quat->quat[0]*vec->vec[2] - 2*quat->quat[3]*quat->quat[0]*vec->vec[1] + quat->quat[1]*quat->quat[1]*vec->vec[0] + 2*quat->quat[2]*quat->quat[1]*vec->vec[1] + 2*quat->quat[3]*quat->quat[1]*vec->vec[2] - quat->quat[3]*quat->quat[3]*vec->vec[0] - quat->quat[2]*quat->quat[2]*vec->vec[0]; rot[1] = 2*quat->quat[1]*quat->quat[2]*vec->vec[0] + quat->quat[2]*quat->quat[2]*vec->vec[1] + 2*quat->quat[3]*quat->quat[2]*vec->vec[2] + 2*quat->quat[0]*quat->quat[3]*vec->vec[0] - quat->quat[3]*quat->quat[3]*vec->vec[1] + quat->quat[0]*quat->quat[0]*vec->vec[1] - 2*quat->quat[1]*quat->quat[0]*vec->vec[2] - quat->quat[1]*quat->quat[1]*vec->vec[1]; rot[2] = 2*quat->quat[1]*quat->quat[3]*vec->vec[0] + 2*quat->quat[2]*quat->quat[3]*vec->vec[1] + quat->quat[3]*quat->quat[3]*vec->vec[2] - 2*quat->quat[0]*quat->quat[2]*vec->vec[0] - quat->quat[2]*quat->quat[2]*vec->vec[2] + 2*quat->quat[0]*quat->quat[1]*vec->vec[1] - quat->quat[1]*quat->quat[1]*vec->vec[2] + quat->quat[0]*quat->quat[0]*vec->vec[2]; return newVectorObject(rot, 3, Py_NEW); } }else if(PointObject_Check(arg1)){ pt = (PointObject*)arg1; if(QuaternionObject_Check(arg2)){ quat = (QuaternionObject*)arg2; rot[0] = quat->quat[0]*quat->quat[0]*pt->coord[0] + 2*quat->quat[2]*quat->quat[0]*pt->coord[2] - 2*quat->quat[3]*quat->quat[0]*pt->coord[1] + quat->quat[1]*quat->quat[1]*pt->coord[0] + 2*quat->quat[2]*quat->quat[1]*pt->coord[1] + 2*quat->quat[3]*quat->quat[1]*pt->coord[2] - quat->quat[3]*quat->quat[3]*pt->coord[0] - quat->quat[2]*quat->quat[2]*pt->coord[0]; rot[1] = 2*quat->quat[1]*quat->quat[2]*pt->coord[0] + quat->quat[2]*quat->quat[2]*pt->coord[1] + 2*quat->quat[3]*quat->quat[2]*pt->coord[2] + 2*quat->quat[0]*quat->quat[3]*pt->coord[0] - quat->quat[3]*quat->quat[3]*pt->coord[1] + quat->quat[0]*quat->quat[0]*pt->coord[1] - 2*quat->quat[1]*quat->quat[0]*pt->coord[2] - quat->quat[1]*quat->quat[1]*pt->coord[1]; rot[2] = 2*quat->quat[1]*quat->quat[3]*pt->coord[0] + 2*quat->quat[2]*quat->quat[3]*pt->coord[1] + quat->quat[3]*quat->quat[3]*pt->coord[2] - 2*quat->quat[0]*quat->quat[2]*pt->coord[0] - quat->quat[2]*quat->quat[2]*pt->coord[2] + 2*quat->quat[0]*quat->quat[1]*pt->coord[1] - quat->quat[1]*quat->quat[1]*pt->coord[2] + quat->quat[0]*quat->quat[0]*pt->coord[2]; return newPointObject(rot, 3, Py_NEW); } } return (EXPP_ReturnPyObjError(PyExc_RuntimeError, "quat_rotation(internal): internal problem rotating vector/point\n")); } //----------------------------------Mathutils.Rand() -------------------- //returns a random number between a high and low value PyObject *M_Mathutils_Rand(PyObject * self, PyObject * args) { float high, low, range; double rand; //initializers high = 1.0; low = 0.0; if(!PyArg_ParseTuple(args, "|ff", &low, &high)) return (EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.Rand(): expected nothing or optional (float, float)\n")); if((high < low) || (high < 0 && low > 0)) return (EXPP_ReturnPyObjError(PyExc_ValueError, "Mathutils.Rand(): high value should be larger than low value\n")); //get the random number 0 - 1 rand = BLI_drand(); //set it to range range = high - low; rand = rand * range; rand = rand + low; return PyFloat_FromDouble(rand); } //----------------------------------VECTOR FUNCTIONS--------------------- //----------------------------------Mathutils.Vector() ------------------ // Supports 2D, 3D, and 4D vector objects both int and float values // accepted. Mixed float and int values accepted. Ints are parsed to float PyObject *M_Mathutils_Vector(PyObject * self, PyObject * args) { PyObject *listObject = NULL; int size, i; float vec[4]; PyObject *v, *f; size = PySequence_Length(args); if (size == 1) { listObject = PySequence_GetItem(args, 0); if (PySequence_Check(listObject)) { size = PySequence_Length(listObject); } else { // Single argument was not a sequence Py_XDECREF(listObject); return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.Vector(): 2-4 floats or ints expected (optionally in a sequence)\n"); } } else if (size == 0) { //returns a new empty 3d vector return newVectorObject(NULL, 3, Py_NEW); } else { listObject = EXPP_incr_ret(args); } if (size<2 || size>4) { // Invalid vector size Py_XDECREF(listObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Vector(): 2-4 floats or ints expected (optionally in a sequence)\n"); } for (i=0; isize != 3 || vec2->size != 3) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.CrossVecs(): expects (2) 3D vector objects\n"); vecCross = newVectorObject(NULL, 3, Py_NEW); Crossf(((VectorObject*)vecCross)->vec, vec1->vec, vec2->vec); return vecCross; } //----------------------------------Mathutils.DotVec() ------------------- //calculates the dot product of two vectors PyObject *M_Mathutils_DotVecs(PyObject * self, PyObject * args) { VectorObject *vec1 = NULL, *vec2 = NULL; double dot = 0.0f; int x; if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2)) return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.DotVecs(): expects (2) vector objects of the same size\n"); if(vec1->size != vec2->size) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.DotVecs(): expects (2) vector objects of the same size\n"); for(x = 0; x < vec1->size; x++) { dot += vec1->vec[x] * vec2->vec[x]; } return PyFloat_FromDouble(dot); } //----------------------------------Mathutils.AngleBetweenVecs() --------- //calculates the angle between 2 vectors PyObject *M_Mathutils_AngleBetweenVecs(PyObject * self, PyObject * args) { VectorObject *vec1 = NULL, *vec2 = NULL; double dot = 0.0f, angleRads, test_v1 = 0.0f, test_v2 = 0.0f; int x, size; if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2)) goto AttributeError1; //not vectors if(vec1->size != vec2->size) goto AttributeError1; //bad sizes //since size is the same.... size = vec1->size; for(x = 0; x < size; x++) { test_v1 += vec1->vec[x] * vec1->vec[x]; test_v2 += vec2->vec[x] * vec2->vec[x]; } if (!test_v1 || !test_v2){ goto AttributeError2; //zero-length vector } //dot product for(x = 0; x < size; x++) { dot += vec1->vec[x] * vec2->vec[x]; } dot /= (sqrt(test_v1) * sqrt(test_v2)); angleRads = (double)saacos(dot); return PyFloat_FromDouble(angleRads * (180/ Py_PI)); AttributeError1: return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.AngleBetweenVecs(): expects (2) VECTOR objects of the same size\n"); AttributeError2: return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.AngleBetweenVecs(): zero length vectors are not acceptable arguments\n"); } //----------------------------------Mathutils.MidpointVecs() ------------- //calculates the midpoint between 2 vectors PyObject *M_Mathutils_MidpointVecs(PyObject * self, PyObject * args) { VectorObject *vec1 = NULL, *vec2 = NULL; float vec[4]; int x; if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2)) return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.MidpointVecs(): expects (2) vector objects of the same size\n"); if(vec1->size != vec2->size) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.MidpointVecs(): expects (2) vector objects of the same size\n"); for(x = 0; x < vec1->size; x++) { vec[x] = 0.5f * (vec1->vec[x] + vec2->vec[x]); } return newVectorObject(vec, vec1->size, Py_NEW); } //----------------------------------Mathutils.ProjectVecs() ------------- //projects vector 1 onto vector 2 PyObject *M_Mathutils_ProjectVecs(PyObject * self, PyObject * args) { VectorObject *vec1 = NULL, *vec2 = NULL; float vec[4]; double dot = 0.0f, dot2 = 0.0f; int x, size; if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2)) return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.ProjectVecs(): expects (2) vector objects of the same size\n"); if(vec1->size != vec2->size) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.ProjectVecs(): expects (2) vector objects of the same size\n"); //since they are the same size... size = vec1->size; //get dot products for(x = 0; x < size; x++) { dot += vec1->vec[x] * vec2->vec[x]; dot2 += vec2->vec[x] * vec2->vec[x]; } //projection dot /= dot2; for(x = 0; x < size; x++) { vec[x] = (float)(dot * vec2->vec[x]); } return newVectorObject(vec, size, Py_NEW); } //----------------------------------MATRIX FUNCTIONS-------------------- //----------------------------------Mathutils.Matrix() ----------------- //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc. //create a new matrix type PyObject *M_Mathutils_Matrix(PyObject * self, PyObject * args) { PyObject *listObject = NULL; PyObject *argObject, *m, *s, *f; MatrixObject *mat; int argSize, seqSize = 0, i, j; float matrix[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}; argSize = PySequence_Length(args); if(argSize > 4){ //bad arg nums return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Matrix(): expects 0-4 numeric sequences of the same size\n"); } else if (argSize == 0) { //return empty 4D matrix return (PyObject *) newMatrixObject(NULL, 4, 4, Py_NEW); }else if (argSize == 1){ //copy constructor for matrix objects argObject = PySequence_GetItem(args, 0); if(MatrixObject_Check(argObject)){ mat = (MatrixObject*)argObject; argSize = mat->rowSize; //rows seqSize = mat->colSize; //col for(i = 0; i < (seqSize * argSize); i++){ matrix[i] = mat->contigPtr[i]; } } Py_DECREF(argObject); }else{ //2-4 arguments (all seqs? all same size?) for(i =0; i < argSize; i++){ argObject = PySequence_GetItem(args, i); if (PySequence_Check(argObject)) { //seq? if(seqSize){ //0 at first if(PySequence_Length(argObject) != seqSize){ //seq size not same Py_DECREF(argObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Matrix(): expects 0-4 numeric sequences of the same size\n"); } } seqSize = PySequence_Length(argObject); }else{ //arg not a sequence Py_XDECREF(argObject); return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.Matrix(): expects 0-4 numeric sequences of the same size\n"); } Py_DECREF(argObject); } //all is well... let's continue parsing listObject = args; for (i = 0; i < argSize; i++){ m = PySequence_GetItem(listObject, i); if (m == NULL) { // Failed to read sequence return EXPP_ReturnPyObjError(PyExc_RuntimeError, "Mathutils.Matrix(): failed to parse arguments...\n"); } for (j = 0; j < seqSize; j++) { s = PySequence_GetItem(m, j); if (s == NULL) { // Failed to read sequence Py_DECREF(m); return EXPP_ReturnPyObjError(PyExc_RuntimeError, "Mathutils.Matrix(): failed to parse arguments...\n"); } f = PyNumber_Float(s); if(f == NULL) { // parsed item is not a number EXPP_decr2(m,s); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Matrix(): expects 0-4 numeric sequences of the same size\n"); } matrix[(seqSize*i)+j]=(float)PyFloat_AS_DOUBLE(f); EXPP_decr2(f,s); } Py_DECREF(m); } } return newMatrixObject(matrix, argSize, seqSize, Py_NEW); } //----------------------------------Mathutils.RotationMatrix() ---------- //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc. //creates a rotation matrix PyObject *M_Mathutils_RotationMatrix(PyObject * self, PyObject * args) { VectorObject *vec = NULL; char *axis = NULL; int matSize; float angle = 0.0f, norm = 0.0f, cosAngle = 0.0f, sinAngle = 0.0f; float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}; if(!PyArg_ParseTuple (args, "fi|sO!", &angle, &matSize, &axis, &vector_Type, &vec)) { return EXPP_ReturnPyObjError (PyExc_TypeError, "Mathutils.RotationMatrix(): expected float int and optional string and vector\n"); } /* Clamp to -360:360 */ while (angle<-360.0f) angle+=360.0; while (angle>360.0f) angle-=360.0; if(matSize != 2 && matSize != 3 && matSize != 4) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.RotationMatrix(): can only return a 2x2 3x3 or 4x4 matrix\n"); if(matSize == 2 && (axis != NULL || vec != NULL)) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.RotationMatrix(): cannot create a 2x2 rotation matrix around arbitrary axis\n"); if((matSize == 3 || matSize == 4) && axis == NULL) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.RotationMatrix(): please choose an axis of rotation for 3d and 4d matrices\n"); if(axis) { if(((strcmp(axis, "r") == 0) || (strcmp(axis, "R") == 0)) && vec == NULL) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.RotationMatrix(): please define the arbitrary axis of rotation\n"); } if(vec) { if(vec->size != 3) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.RotationMatrix(): the arbitrary axis must be a 3D vector\n"); } //convert to radians angle = angle * (float) (Py_PI / 180); if(axis == NULL && matSize == 2) { //2D rotation matrix mat[0] = (float) cos (angle); mat[1] = (float) sin (angle); mat[2] = -((float) sin(angle)); mat[3] = (float) cos(angle); } else if((strcmp(axis, "x") == 0) || (strcmp(axis, "X") == 0)) { //rotation around X mat[0] = 1.0f; mat[4] = (float) cos(angle); mat[5] = (float) sin(angle); mat[7] = -((float) sin(angle)); mat[8] = (float) cos(angle); } else if((strcmp(axis, "y") == 0) || (strcmp(axis, "Y") == 0)) { //rotation around Y mat[0] = (float) cos(angle); mat[2] = -((float) sin(angle)); mat[4] = 1.0f; mat[6] = (float) sin(angle); mat[8] = (float) cos(angle); } else if((strcmp(axis, "z") == 0) || (strcmp(axis, "Z") == 0)) { //rotation around Z mat[0] = (float) cos(angle); mat[1] = (float) sin(angle); mat[3] = -((float) sin(angle)); mat[4] = (float) cos(angle); mat[8] = 1.0f; } else if((strcmp(axis, "r") == 0) || (strcmp(axis, "R") == 0)) { //arbitrary rotation //normalize arbitrary axis norm = (float) sqrt(vec->vec[0] * vec->vec[0] + vec->vec[1] * vec->vec[1] + vec->vec[2] * vec->vec[2]); vec->vec[0] /= norm; vec->vec[1] /= norm; vec->vec[2] /= norm; if (isnan(vec->vec[0]) || isnan(vec->vec[1]) || isnan(vec->vec[2])) { /* zero length vector, return an identity matrix, could also return an error */ mat[0]= mat[4] = mat[8] = 1.0f; } else { /* create matrix */ cosAngle = (float) cos(angle); sinAngle = (float) sin(angle); mat[0] = ((vec->vec[0] * vec->vec[0]) * (1 - cosAngle)) + cosAngle; mat[1] = ((vec->vec[0] * vec->vec[1]) * (1 - cosAngle)) + (vec->vec[2] * sinAngle); mat[2] = ((vec->vec[0] * vec->vec[2]) * (1 - cosAngle)) - (vec->vec[1] * sinAngle); mat[3] = ((vec->vec[0] * vec->vec[1]) * (1 - cosAngle)) - (vec->vec[2] * sinAngle); mat[4] = ((vec->vec[1] * vec->vec[1]) * (1 - cosAngle)) + cosAngle; mat[5] = ((vec->vec[1] * vec->vec[2]) * (1 - cosAngle)) + (vec->vec[0] * sinAngle); mat[6] = ((vec->vec[0] * vec->vec[2]) * (1 - cosAngle)) + (vec->vec[1] * sinAngle); mat[7] = ((vec->vec[1] * vec->vec[2]) * (1 - cosAngle)) - (vec->vec[0] * sinAngle); mat[8] = ((vec->vec[2] * vec->vec[2]) * (1 - cosAngle)) + cosAngle; } } else { return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.RotationMatrix(): unrecognizable axis of rotation type - expected x,y,z or r\n"); } if(matSize == 4) { //resize matrix mat[10] = mat[8]; mat[9] = mat[7]; mat[8] = mat[6]; mat[7] = 0.0f; mat[6] = mat[5]; mat[5] = mat[4]; mat[4] = mat[3]; mat[3] = 0.0f; } //pass to matrix creation return newMatrixObject(mat, matSize, matSize, Py_NEW); } //----------------------------------Mathutils.TranslationMatrix() ------- //creates a translation matrix PyObject *M_Mathutils_TranslationMatrix(PyObject * self, VectorObject * vec) { float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}; if(!VectorObject_Check(vec)) { return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.TranslationMatrix(): expected vector\n"); } if(vec->size != 3 && vec->size != 4) { return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.TranslationMatrix(): vector must be 3D or 4D\n"); } //create a identity matrix and add translation Mat4One((float(*)[4]) mat); mat[12] = vec->vec[0]; mat[13] = vec->vec[1]; mat[14] = vec->vec[2]; return newMatrixObject(mat, 4, 4, Py_NEW); } //----------------------------------Mathutils.ScaleMatrix() ------------- //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc. //creates a scaling matrix PyObject *M_Mathutils_ScaleMatrix(PyObject * self, PyObject * args) { VectorObject *vec = NULL; float norm = 0.0f, factor; int matSize, x; float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}; if(!PyArg_ParseTuple (args, "fi|O!", &factor, &matSize, &vector_Type, &vec)) { return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.ScaleMatrix(): expected float int and optional vector\n"); } if(matSize != 2 && matSize != 3 && matSize != 4) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.ScaleMatrix(): can only return a 2x2 3x3 or 4x4 matrix\n"); if(vec) { if(vec->size > 2 && matSize == 2) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.ScaleMatrix(): please use 2D vectors when scaling in 2D\n"); } if(vec == NULL) { //scaling along axis if(matSize == 2) { mat[0] = factor; mat[3] = factor; } else { mat[0] = factor; mat[4] = factor; mat[8] = factor; } } else { //scaling in arbitrary direction //normalize arbitrary axis for(x = 0; x < vec->size; x++) { norm += vec->vec[x] * vec->vec[x]; } norm = (float) sqrt(norm); for(x = 0; x < vec->size; x++) { vec->vec[x] /= norm; } if(matSize == 2) { mat[0] = 1 +((factor - 1) *(vec->vec[0] * vec->vec[0])); mat[1] =((factor - 1) *(vec->vec[0] * vec->vec[1])); mat[2] =((factor - 1) *(vec->vec[0] * vec->vec[1])); mat[3] = 1 + ((factor - 1) *(vec->vec[1] * vec->vec[1])); } else { mat[0] = 1 + ((factor - 1) *(vec->vec[0] * vec->vec[0])); mat[1] =((factor - 1) *(vec->vec[0] * vec->vec[1])); mat[2] =((factor - 1) *(vec->vec[0] * vec->vec[2])); mat[3] =((factor - 1) *(vec->vec[0] * vec->vec[1])); mat[4] = 1 + ((factor - 1) *(vec->vec[1] * vec->vec[1])); mat[5] =((factor - 1) *(vec->vec[1] * vec->vec[2])); mat[6] =((factor - 1) *(vec->vec[0] * vec->vec[2])); mat[7] =((factor - 1) *(vec->vec[1] * vec->vec[2])); mat[8] = 1 + ((factor - 1) *(vec->vec[2] * vec->vec[2])); } } if(matSize == 4) { //resize matrix mat[10] = mat[8]; mat[9] = mat[7]; mat[8] = mat[6]; mat[7] = 0.0f; mat[6] = mat[5]; mat[5] = mat[4]; mat[4] = mat[3]; mat[3] = 0.0f; } //pass to matrix creation return newMatrixObject(mat, matSize, matSize, Py_NEW); } //----------------------------------Mathutils.OrthoProjectionMatrix() --- //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc. //creates an ortho projection matrix PyObject *M_Mathutils_OrthoProjectionMatrix(PyObject * self, PyObject * args) { VectorObject *vec = NULL; char *plane; int matSize, x; float norm = 0.0f; float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}; if(!PyArg_ParseTuple (args, "si|O!", &plane, &matSize, &vector_Type, &vec)) { return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.OrthoProjectionMatrix(): expected string and int and optional vector\n"); } if(matSize != 2 && matSize != 3 && matSize != 4) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.OrthoProjectionMatrix(): can only return a 2x2 3x3 or 4x4 matrix\n"); if(vec) { if(vec->size > 2 && matSize == 2) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.OrthoProjectionMatrix(): please use 2D vectors when scaling in 2D\n"); } if(vec == NULL) { //ortho projection onto cardinal plane if(((strcmp(plane, "x") == 0) || (strcmp(plane, "X") == 0)) && matSize == 2) { mat[0] = 1.0f; } else if(((strcmp(plane, "y") == 0) || (strcmp(plane, "Y") == 0)) && matSize == 2) { mat[3] = 1.0f; } else if(((strcmp(plane, "xy") == 0) || (strcmp(plane, "XY") == 0)) && matSize > 2) { mat[0] = 1.0f; mat[4] = 1.0f; } else if(((strcmp(plane, "xz") == 0) || (strcmp(plane, "XZ") == 0)) && matSize > 2) { mat[0] = 1.0f; mat[8] = 1.0f; } else if(((strcmp(plane, "yz") == 0) || (strcmp(plane, "YZ") == 0)) && matSize > 2) { mat[4] = 1.0f; mat[8] = 1.0f; } else { return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.OrthoProjectionMatrix(): unknown plane - expected: x, y, xy, xz, yz\n"); } } else { //arbitrary plane //normalize arbitrary axis for(x = 0; x < vec->size; x++) { norm += vec->vec[x] * vec->vec[x]; } norm = (float) sqrt(norm); for(x = 0; x < vec->size; x++) { vec->vec[x] /= norm; } if(((strcmp(plane, "r") == 0) || (strcmp(plane, "R") == 0)) && matSize == 2) { mat[0] = 1 - (vec->vec[0] * vec->vec[0]); mat[1] = -(vec->vec[0] * vec->vec[1]); mat[2] = -(vec->vec[0] * vec->vec[1]); mat[3] = 1 - (vec->vec[1] * vec->vec[1]); } else if(((strcmp(plane, "r") == 0) || (strcmp(plane, "R") == 0)) && matSize > 2) { mat[0] = 1 - (vec->vec[0] * vec->vec[0]); mat[1] = -(vec->vec[0] * vec->vec[1]); mat[2] = -(vec->vec[0] * vec->vec[2]); mat[3] = -(vec->vec[0] * vec->vec[1]); mat[4] = 1 - (vec->vec[1] * vec->vec[1]); mat[5] = -(vec->vec[1] * vec->vec[2]); mat[6] = -(vec->vec[0] * vec->vec[2]); mat[7] = -(vec->vec[1] * vec->vec[2]); mat[8] = 1 - (vec->vec[2] * vec->vec[2]); } else { return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.OrthoProjectionMatrix(): unknown plane - expected: 'r' expected for axis designation\n"); } } if(matSize == 4) { //resize matrix mat[10] = mat[8]; mat[9] = mat[7]; mat[8] = mat[6]; mat[7] = 0.0f; mat[6] = mat[5]; mat[5] = mat[4]; mat[4] = mat[3]; mat[3] = 0.0f; } //pass to matrix creation return newMatrixObject(mat, matSize, matSize, Py_NEW); } //----------------------------------Mathutils.ShearMatrix() ------------- //creates a shear matrix PyObject *M_Mathutils_ShearMatrix(PyObject * self, PyObject * args) { int matSize; char *plane; float factor; float mat[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}; if(!PyArg_ParseTuple(args, "sfi", &plane, &factor, &matSize)) { return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.ShearMatrix(): expected string float and int\n"); } if(matSize != 2 && matSize != 3 && matSize != 4) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.ShearMatrix(): can only return a 2x2 3x3 or 4x4 matrix\n"); if(((strcmp(plane, "x") == 0) || (strcmp(plane, "X") == 0)) && matSize == 2) { mat[0] = 1.0f; mat[2] = factor; mat[3] = 1.0f; } else if(((strcmp(plane, "y") == 0) || (strcmp(plane, "Y") == 0)) && matSize == 2) { mat[0] = 1.0f; mat[1] = factor; mat[3] = 1.0f; } else if(((strcmp(plane, "xy") == 0) || (strcmp(plane, "XY") == 0)) && matSize > 2) { mat[0] = 1.0f; mat[4] = 1.0f; mat[6] = factor; mat[7] = factor; } else if(((strcmp(plane, "xz") == 0) || (strcmp(plane, "XZ") == 0)) && matSize > 2) { mat[0] = 1.0f; mat[3] = factor; mat[4] = 1.0f; mat[5] = factor; mat[8] = 1.0f; } else if(((strcmp(plane, "yz") == 0) || (strcmp(plane, "YZ") == 0)) && matSize > 2) { mat[0] = 1.0f; mat[1] = factor; mat[2] = factor; mat[4] = 1.0f; mat[8] = 1.0f; } else { return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.ShearMatrix(): expected: x, y, xy, xz, yz or wrong matrix size for shearing plane\n"); } if(matSize == 4) { //resize matrix mat[10] = mat[8]; mat[9] = mat[7]; mat[8] = mat[6]; mat[7] = 0.0f; mat[6] = mat[5]; mat[5] = mat[4]; mat[4] = mat[3]; mat[3] = 0.0f; } //pass to matrix creation return newMatrixObject(mat, matSize, matSize, Py_NEW); } //----------------------------------QUATERNION FUNCTIONS----------------- //----------------------------------Mathutils.Quaternion() -------------- PyObject *M_Mathutils_Quaternion(PyObject * self, PyObject * args) { PyObject *listObject = NULL, *n, *q, *f; int size, i; float quat[4]; double norm = 0.0f, angle = 0.0f; size = PySequence_Length(args); if (size == 1 || size == 2) { //seq? listObject = PySequence_GetItem(args, 0); if (PySequence_Check(listObject)) { size = PySequence_Length(listObject); if ((size == 4 && PySequence_Length(args) !=1) || (size == 3 && PySequence_Length(args) !=2) || (size >4 || size < 3)) { // invalid args/size Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n"); } if(size == 3){ //get angle in axis/angle n = PyNumber_Float(PySequence_GetItem(args, 1)); if(n == NULL) { // parsed item not a number or getItem fail Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n"); } angle = PyFloat_AS_DOUBLE(n); Py_DECREF(n); } }else{ listObject = PySequence_GetItem(args, 1); if (size>1 && PySequence_Check(listObject)) { size = PySequence_Length(listObject); if (size != 3) { // invalid args/size Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n"); } n = PyNumber_Float(PySequence_GetItem(args, 0)); if(n == NULL) { // parsed item not a number or getItem fail Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n"); } angle = PyFloat_AS_DOUBLE(n); Py_DECREF(n); } else { // argument was not a sequence Py_XDECREF(listObject); return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n"); } } } else if (size == 0) { //returns a new empty quat return newQuaternionObject(NULL, Py_NEW); } else { listObject = EXPP_incr_ret(args); } if (size == 3) { // invalid quat size if(PySequence_Length(args) != 2){ Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n"); } }else{ if(size != 4){ Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n"); } } for (i=0; iquat, quatV->quat); return newQuaternionObject(quat, Py_NEW); } //----------------------------------Mathutils.DotQuats() ---------------- //returns the dot product of 2 quaternions PyObject *M_Mathutils_DotQuats(PyObject * self, PyObject * args) { QuaternionObject *quatU = NULL, *quatV = NULL; double dot = 0.0f; int x; if(!PyArg_ParseTuple(args, "O!O!", &quaternion_Type, &quatU, &quaternion_Type, &quatV)) return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.DotQuats(): expected Quaternion types"); for(x = 0; x < 4; x++) { dot += quatU->quat[x] * quatV->quat[x]; } return PyFloat_FromDouble(dot); } //----------------------------------Mathutils.DifferenceQuats() --------- //returns the difference between 2 quaternions PyObject *M_Mathutils_DifferenceQuats(PyObject * self, PyObject * args) { QuaternionObject *quatU = NULL, *quatV = NULL; float quat[4], tempQuat[4]; double dot = 0.0f; int x; if(!PyArg_ParseTuple(args, "O!O!", &quaternion_Type, &quatU, &quaternion_Type, &quatV)) return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.DifferenceQuats(): expected Quaternion types"); tempQuat[0] = quatU->quat[0]; tempQuat[1] = -quatU->quat[1]; tempQuat[2] = -quatU->quat[2]; tempQuat[3] = -quatU->quat[3]; dot = sqrt(tempQuat[0] * tempQuat[0] + tempQuat[1] * tempQuat[1] + tempQuat[2] * tempQuat[2] + tempQuat[3] * tempQuat[3]); for(x = 0; x < 4; x++) { tempQuat[x] /= (float)(dot * dot); } QuatMul(quat, tempQuat, quatV->quat); return newQuaternionObject(quat, Py_NEW); } //----------------------------------Mathutils.Slerp() ------------------ //attemps to interpolate 2 quaternions and return the result PyObject *M_Mathutils_Slerp(PyObject * self, PyObject * args) { QuaternionObject *quatU = NULL, *quatV = NULL; float quat[4], quat_u[4], quat_v[4], param; double x, y, dot, sinT, angle, IsinT; int z; if(!PyArg_ParseTuple(args, "O!O!f", &quaternion_Type, &quatU, &quaternion_Type, &quatV, ¶m)) return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.Slerp(): expected Quaternion types and float"); if(param > 1.0f || param < 0.0f) return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Slerp(): interpolation factor must be between 0.0 and 1.0"); //copy quats for(z = 0; z < 4; z++){ quat_u[z] = quatU->quat[z]; quat_v[z] = quatV->quat[z]; } //dot product dot = quat_u[0] * quat_v[0] + quat_u[1] * quat_v[1] + quat_u[2] * quat_v[2] + quat_u[3] * quat_v[3]; //if negative negate a quat (shortest arc) if(dot < 0.0f) { quat_v[0] = -quat_v[0]; quat_v[1] = -quat_v[1]; quat_v[2] = -quat_v[2]; quat_v[3] = -quat_v[3]; dot = -dot; } if(dot > .99999f) { //very close x = 1.0f - param; y = param; } else { //calculate sin of angle sinT = sqrt(1.0f - (dot * dot)); //calculate angle angle = atan2(sinT, dot); //caluculate inverse of sin(theta) IsinT = 1.0f / sinT; x = sin((1.0f - param) * angle) * IsinT; y = sin(param * angle) * IsinT; } //interpolate quat[0] = (float)(quat_u[0] * x + quat_v[0] * y); quat[1] = (float)(quat_u[1] * x + quat_v[1] * y); quat[2] = (float)(quat_u[2] * x + quat_v[2] * y); quat[3] = (float)(quat_u[3] * x + quat_v[3] * y); return newQuaternionObject(quat, Py_NEW); } //----------------------------------EULER FUNCTIONS---------------------- //----------------------------------Mathutils.Euler() ------------------- //makes a new euler for you to play with PyObject *M_Mathutils_Euler(PyObject * self, PyObject * args) { PyObject *listObject = NULL; int size, i; float eul[3]; PyObject *e, *f; size = PySequence_Length(args); if (size == 1) { listObject = PySequence_GetItem(args, 0); if (PySequence_Check(listObject)) { size = PySequence_Length(listObject); } else { // Single argument was not a sequence Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.Euler(): 3d numeric sequence expected\n"); } } else if (size == 0) { //returns a new empty 3d euler return newEulerObject(NULL, Py_NEW); } else { listObject = EXPP_incr_ret(args); } if (size != 3) { // Invalid euler size Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Euler(): 3d numeric sequence expected\n"); } for (i=0; i3) { // Invalid vector size Py_XDECREF(listObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Point(): 2-3 floats or ints expected (optionally in a sequence)\n"); } for (i=0; isize != 3 || vec2->size != 3 || vec3->size != 3 || ray->size != 3 || ray_off->size != 3) return ( EXPP_ReturnPyObjError( PyExc_TypeError, "only 3D vectors for all parameters\n" ) ); VECCOPY(v1, vec1->vec); VECCOPY(v2, vec2->vec); VECCOPY(v3, vec3->vec); VECCOPY(dir, ray->vec); Normalize(dir); VECCOPY(orig, ray_off->vec); /* find vectors for two edges sharing v1 */ VecSubf(e1, v2, v1); VecSubf(e2, v3, v1); /* begin calculating determinant - also used to calculated U parameter */ Crossf(pvec, dir, e2); /* if determinant is near zero, ray lies in plane of triangle */ det = Inpf(e1, pvec); if (det > -0.000001 && det < 0.000001) { return EXPP_incr_ret( Py_None ); } inv_det = 1.0f / det; /* calculate distance from v1 to ray origin */ VecSubf(tvec, orig, v1); /* calculate U parameter and test bounds */ u = Inpf(tvec, pvec) * inv_det; if (clip && (u < 0.0f || u > 1.0f)) { return EXPP_incr_ret( Py_None ); } /* prepare to test the V parameter */ Crossf(qvec, tvec, e1); /* calculate V parameter and test bounds */ v = Inpf(dir, qvec) * inv_det; if (clip && (v < 0.0f || u + v > 1.0f)) { return EXPP_incr_ret( Py_None ); } /* calculate t, ray intersects triangle */ t = Inpf(e2, qvec) * inv_det; VecMulf(dir, t); VecAddf(pvec, orig, dir); return newVectorObject(pvec, 3, Py_NEW); } //----------------------------------Mathutils.LineIntersect() ------------------- /* Line-Line intersection using algorithm from mathworld.wolfram.com */ PyObject *M_Mathutils_LineIntersect( PyObject * self, PyObject * args ) { PyObject * tuple; VectorObject *vec1, *vec2, *vec3, *vec4; float v1[3], v2[3], v3[3], v4[3], i1[3], i2[3]; if( !PyArg_ParseTuple ( args, "O!O!O!O!", &vector_Type, &vec1, &vector_Type, &vec2 , &vector_Type, &vec3, &vector_Type, &vec4 ) ) return ( EXPP_ReturnPyObjError ( PyExc_TypeError, "expected 4 vector types\n" ) ); if( vec1->size != vec2->size || vec1->size != vec3->size || vec1->size != vec2->size) return ( EXPP_ReturnPyObjError( PyExc_TypeError, "vectors must be of the same size\n" ) ); if( vec1->size == 3 || vec1->size == 2) { int result; if (vec1->size == 3) { VECCOPY(v1, vec1->vec); VECCOPY(v2, vec2->vec); VECCOPY(v3, vec3->vec); VECCOPY(v4, vec4->vec); } else { v1[0] = vec1->vec[0]; v1[1] = vec1->vec[1]; v1[2] = 0.0f; v2[0] = vec2->vec[0]; v2[1] = vec2->vec[1]; v2[2] = 0.0f; v3[0] = vec3->vec[0]; v3[1] = vec3->vec[1]; v3[2] = 0.0f; v4[0] = vec4->vec[0]; v4[1] = vec4->vec[1]; v4[2] = 0.0f; } result = LineIntersectLine(v1, v2, v3, v4, i1, i2); if (result == 0) { /* colinear */ return EXPP_incr_ret( Py_None ); } else { tuple = PyTuple_New( 2 ); PyTuple_SetItem( tuple, 0, newVectorObject(i1, vec1->size, Py_NEW) ); PyTuple_SetItem( tuple, 1, newVectorObject(i2, vec1->size, Py_NEW) ); return tuple; } } else { return ( EXPP_ReturnPyObjError( PyExc_TypeError, "2D/3D vectors only\n" ) ); } } //---------------------------------NORMALS FUNCTIONS-------------------- //----------------------------------Mathutils.QuadNormal() ------------------- PyObject *M_Mathutils_QuadNormal( PyObject * self, PyObject * args ) { VectorObject *vec1; VectorObject *vec2; VectorObject *vec3; VectorObject *vec4; float v1[3], v2[3], v3[3], v4[3], e1[3], e2[3], n1[3], n2[3]; if( !PyArg_ParseTuple ( args, "O!O!O!O!", &vector_Type, &vec1, &vector_Type, &vec2 , &vector_Type, &vec3, &vector_Type, &vec4 ) ) return ( EXPP_ReturnPyObjError ( PyExc_TypeError, "expected 4 vector types\n" ) ); if( vec1->size != vec2->size || vec1->size != vec3->size || vec1->size != vec4->size) return ( EXPP_ReturnPyObjError( PyExc_TypeError, "vectors must be of the same size\n" ) ); if( vec1->size != 3 ) return ( EXPP_ReturnPyObjError( PyExc_TypeError, "only 3D vectors\n" ) ); VECCOPY(v1, vec1->vec); VECCOPY(v2, vec2->vec); VECCOPY(v3, vec3->vec); VECCOPY(v4, vec4->vec); /* find vectors for two edges sharing v2 */ VecSubf(e1, v1, v2); VecSubf(e2, v3, v2); Crossf(n1, e2, e1); Normalize(n1); /* find vectors for two edges sharing v4 */ VecSubf(e1, v3, v4); VecSubf(e2, v1, v4); Crossf(n2, e2, e1); Normalize(n2); /* adding and averaging the normals of both triangles */ VecAddf(n1, n2, n1); Normalize(n1); return newVectorObject(n1, 3, Py_NEW); } //----------------------------Mathutils.TriangleNormal() ------------------- PyObject *M_Mathutils_TriangleNormal( PyObject * self, PyObject * args ) { VectorObject *vec1, *vec2, *vec3; float v1[3], v2[3], v3[3], e1[3], e2[3], n[3]; if( !PyArg_ParseTuple ( args, "O!O!O!", &vector_Type, &vec1, &vector_Type, &vec2 , &vector_Type, &vec3 ) ) return ( EXPP_ReturnPyObjError ( PyExc_TypeError, "expected 3 vector types\n" ) ); if( vec1->size != vec2->size || vec1->size != vec3->size ) return ( EXPP_ReturnPyObjError( PyExc_TypeError, "vectors must be of the same size\n" ) ); if( vec1->size != 3 ) return ( EXPP_ReturnPyObjError( PyExc_TypeError, "only 3D vectors\n" ) ); VECCOPY(v1, vec1->vec); VECCOPY(v2, vec2->vec); VECCOPY(v3, vec3->vec); /* find vectors for two edges sharing v2 */ VecSubf(e1, v1, v2); VecSubf(e2, v3, v2); Crossf(n, e2, e1); Normalize(n); return newVectorObject(n, 3, Py_NEW); } //--------------------------------- AREA FUNCTIONS-------------------- //----------------------------------Mathutils.TriangleArea() ------------------- PyObject *M_Mathutils_TriangleArea( PyObject * self, PyObject * args ) { VectorObject *vec1, *vec2, *vec3; float v1[3], v2[3], v3[3]; if( !PyArg_ParseTuple ( args, "O!O!O!", &vector_Type, &vec1, &vector_Type, &vec2 , &vector_Type, &vec3 ) ) return ( EXPP_ReturnPyObjError ( PyExc_TypeError, "expected 3 vector types\n" ) ); if( vec1->size != vec2->size || vec1->size != vec3->size ) return ( EXPP_ReturnPyObjError( PyExc_TypeError, "vectors must be of the same size\n" ) ); if (vec1->size == 3) { VECCOPY(v1, vec1->vec); VECCOPY(v2, vec2->vec); VECCOPY(v3, vec3->vec); return PyFloat_FromDouble( AreaT3Dfl(v1, v2, v3) ); } else if (vec1->size == 2) { v1[0] = vec1->vec[0]; v1[1] = vec1->vec[1]; v2[0] = vec2->vec[0]; v2[1] = vec2->vec[1]; v3[0] = vec3->vec[0]; v3[1] = vec3->vec[1]; return PyFloat_FromDouble( AreaF2Dfl(v1, v2, v3) ); } else { return ( EXPP_ReturnPyObjError( PyExc_TypeError, "only 2D,3D vectors are supported\n" ) ); } } //#############################DEPRECATED################################ //####################################################################### //----------------------------------Mathutils.CopyMat() ----------------- //copies a matrix into a new matrix PyObject *M_Mathutils_CopyMat(PyObject * self, PyObject * args) { PyObject *matrix = NULL; static char warning = 1; if( warning ) { printf("Mathutils.CopyMat(): deprecated :use Mathutils.Matrix() to copy matrices\n"); --warning; } matrix = M_Mathutils_Matrix(self, args); if(matrix == NULL) return NULL; //error string already set if we get here else return matrix; } //----------------------------------Mathutils.CopyVec() ----------------- //makes a new vector that is a copy of the input PyObject *M_Mathutils_CopyVec(PyObject * self, PyObject * args) { PyObject *vec = NULL; static char warning = 1; if( warning ) { printf("Mathutils.CopyVec(): Deprecated: use Mathutils.Vector() to copy vectors\n"); --warning; } vec = M_Mathutils_Vector(self, args); if(vec == NULL) return NULL; //error string already set if we get here else return vec; } //----------------------------------Mathutils.CopyQuat() -------------- //Copies a quaternion to a new quat PyObject *M_Mathutils_CopyQuat(PyObject * self, PyObject * args) { PyObject *quat = NULL; static char warning = 1; if( warning ) { printf("Mathutils.CopyQuat(): Deprecated: use Mathutils.Quaternion() to copy vectors\n"); --warning; } quat = M_Mathutils_Quaternion(self, args); if(quat == NULL) return NULL; //error string already set if we get here else return quat; } //----------------------------------Mathutils.CopyEuler() --------------- //copies a euler to a new euler PyObject *M_Mathutils_CopyEuler(PyObject * self, PyObject * args) { PyObject *eul = NULL; static char warning = 1; if( warning ) { printf("Mathutils.CopyEuler(): deprecated:use Mathutils.Euler() to copy vectors\n"); --warning; } eul = M_Mathutils_Euler(self, args); if(eul == NULL) return NULL; //error string already set if we get here else return eul; } //----------------------------------Mathutils.RotateEuler() ------------ //rotates a euler a certain amount and returns the result //should return a unique euler rotation (i.e. no 720 degree pitches :) PyObject *M_Mathutils_RotateEuler(PyObject * self, PyObject * args) { EulerObject *Eul = NULL; float angle; char *axis; static char warning = 1; if( warning ) { printf("Mathutils.RotateEuler(): Deprecated:use Euler.rotate() to rotate a euler\n"); --warning; } if(!PyArg_ParseTuple(args, "O!fs", &euler_Type, &Eul, &angle, &axis)) return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.RotateEuler(): expected euler type & float & string"); Euler_Rotate(Eul, Py_BuildValue("fs", angle, axis)); Py_RETURN_NONE; } //----------------------------------Mathutils.MatMultVec() -------------- //COLUMN VECTOR Multiplication (Matrix X Vector) PyObject *M_Mathutils_MatMultVec(PyObject * self, PyObject * args) { MatrixObject *mat = NULL; VectorObject *vec = NULL; static char warning = 1; if( warning ) { printf("Mathutils.MatMultVec(): Deprecated: use matrix * vec to perform column vector multiplication\n"); --warning; } //get pyObjects if(!PyArg_ParseTuple(args, "O!O!", &matrix_Type, &mat, &vector_Type, &vec)) return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.MatMultVec(): MatMultVec() expects a matrix and a vector object - in that order\n"); return column_vector_multiplication(mat, vec); } //----------------------------------Mathutils.VecMultMat() --------------- //ROW VECTOR Multiplication - Vector X Matrix PyObject *M_Mathutils_VecMultMat(PyObject * self, PyObject * args) { MatrixObject *mat = NULL; VectorObject *vec = NULL; static char warning = 1; if( warning ) { printf("Mathutils.VecMultMat(): Deprecated: use vec * matrix to perform row vector multiplication\n"); --warning; } //get pyObjects if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec, &matrix_Type, &mat)) return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.VecMultMat(): VecMultMat() expects a vector and matrix object - in that order\n"); return row_vector_multiplication(vec, mat); } //####################################################################### //#############################DEPRECATED################################