griefith/test2
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Roll back changes from Big Mathutils Commit on 2005/05/20.

Browse Source
This commit is contained in:
Stephen Swaney
2005-05-22 17:40:00 +00:00
parent 910b0f2cda
commit ece00ff04a
19 changed files with 3697 additions and 3161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/python/BPY_interface.c
View File

@@ -1523,7 +1523,7 @@ PyObject *CreateGlobalDictionary( void )
PyDict_SetItemString( dict, "__name__",
PyString_FromString( "__main__" ) );
return EXPP_incr_ret(dict);
return dict;
}
/*****************************************************************************

148
source/blender/python/api2_2x/Bone.c
View File

@@ -46,14 +46,12 @@
#include <BSE_editaction.h>
#include <BKE_constraint.h>
#include <MEM_guardedalloc.h>
#include <BKE_utildefines.h>
#include "constant.h"
#include "gen_utils.h"
#include "NLA.h"
#include "quat.h"
#include "matrix.h"
#include "vector.h"
#include "Types.h"
//--------------------Python API function prototypes for the Bone module----
static PyObject *M_Bone_New( PyObject * self, PyObject * args );
@@ -539,19 +537,45 @@ PyObject *Bone_CreatePyObject( struct Bone * bone )
//allocate space for python vars
blen_bone->name = PyMem_Malloc( 32 + 1 );
blen_bone->parent = PyMem_Malloc( 32 + 1 );
blen_bone->head = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
blen_bone->tail = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
blen_bone->loc = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
blen_bone->dloc = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
blen_bone->size = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
blen_bone->dsize = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
blen_bone->quat = ( QuaternionObject *)newQuaternionObject( NULL, Py_NEW );
blen_bone->dquat = ( QuaternionObject *)newQuaternionObject( NULL, Py_NEW );
blen_bone->obmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
blen_bone->parmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
blen_bone->defmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
blen_bone->irestmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
blen_bone->posemat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
blen_bone->head =
( VectorObject * )
newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
blen_bone->tail =
( VectorObject * )
newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
blen_bone->loc =
( VectorObject * )
newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
blen_bone->dloc =
( VectorObject * )
newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
blen_bone->size =
( VectorObject * )
newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
blen_bone->dsize =
( VectorObject * )
newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
blen_bone->quat =
( QuaternionObject * )
newQuaternionObject( PyMem_Malloc( 4 * sizeof( float ) ) );
blen_bone->dquat =
( QuaternionObject * )
newQuaternionObject( PyMem_Malloc( 4 * sizeof( float ) ) );
blen_bone->obmat =
( MatrixObject * )
newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
blen_bone->parmat =
( MatrixObject * )
newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
blen_bone->defmat =
( MatrixObject * )
newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
blen_bone->irestmat =
( MatrixObject * )
newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
blen_bone->posemat =
( MatrixObject * )
newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
if( !updatePyBone( blen_bone ) )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
@@ -600,19 +624,45 @@ static PyObject *M_Bone_New( PyObject * self, PyObject * args )
//allocate space for python vars
py_bone->name = PyMem_Malloc( 32 + 1 );
py_bone->parent = PyMem_Malloc( 32 + 1 );
py_bone->head = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
py_bone->tail = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
py_bone->loc = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
py_bone->dloc = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
py_bone->size = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
py_bone->dsize = ( VectorObject *)newVectorObject( NULL, 3, Py_NEW );
py_bone->quat = ( QuaternionObject *)newQuaternionObject( NULL, Py_NEW );
py_bone->dquat = ( QuaternionObject *)newQuaternionObject( NULL, Py_NEW );
py_bone->obmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
py_bone->parmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
py_bone->defmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
py_bone->irestmat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
py_bone->posemat = ( MatrixObject *)newMatrixObject( NULL, 4, 4 , Py_NEW);
py_bone->head =
( VectorObject * )
newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
py_bone->tail =
( VectorObject * )
newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
py_bone->loc =
( VectorObject * )
newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
py_bone->dloc =
( VectorObject * )
newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
py_bone->size =
( VectorObject * )
newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
py_bone->dsize =
( VectorObject * )
newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ), 3 );
py_bone->quat =
( QuaternionObject * )
newQuaternionObject( PyMem_Malloc( 4 * sizeof( float ) ) );
py_bone->dquat =
( QuaternionObject * )
newQuaternionObject( PyMem_Malloc( 4 * sizeof( float ) ) );
py_bone->obmat =
( MatrixObject * )
newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
py_bone->parmat =
( MatrixObject * )
newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
py_bone->defmat =
( MatrixObject * )
newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
py_bone->irestmat =
( MatrixObject * )
newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
py_bone->posemat =
( MatrixObject * )
newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
//default py values
BLI_strncpy( py_bone->name, name_str, strlen( name_str ) + 1 );
@@ -709,17 +759,19 @@ static PyObject *Bone_getWeight( BPy_Bone * self )
static PyObject *Bone_getHead( BPy_Bone * self )
{
PyObject *attr = NULL;
float vec[3];
float *vec;
int x;
if( !self->bone ) { //test to see if linked to armature
//use python vars
vec = PyMem_Malloc( 3 * sizeof( float ) );
for( x = 0; x < 3; x++ )
vec[x] = self->head->vec[x];
attr = ( PyObject * ) newVectorObject( vec, 3, Py_NEW );
attr = ( PyObject * ) newVectorObject( vec, 3 );
} else {
//use bone datastruct
attr = newVectorObject( NULL, 3, Py_NEW );
attr = newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ),
3 );
( ( VectorObject * ) attr )->vec[0] = self->bone->head[0];
( ( VectorObject * ) attr )->vec[1] = self->bone->head[1];
( ( VectorObject * ) attr )->vec[2] = self->bone->head[2];
@@ -735,17 +787,19 @@ static PyObject *Bone_getHead( BPy_Bone * self )
static PyObject *Bone_getTail( BPy_Bone * self )
{
PyObject *attr = NULL;
float vec[3];
float *vec;
int x;
if( !self->bone ) { //test to see if linked to armature
//use python vars
vec = PyMem_Malloc( 3 * sizeof( float ) );
for( x = 0; x < 3; x++ )
vec[x] = self->tail->vec[x];
attr = ( PyObject * ) newVectorObject( vec, 3, Py_NEW );
attr = ( PyObject * ) newVectorObject( vec, 3 );
} else {
//use bone datastruct
attr = newVectorObject( NULL, 3, Py_NEW );
attr = newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ),
3 );
( ( VectorObject * ) attr )->vec[0] = self->bone->tail[0];
( ( VectorObject * ) attr )->vec[1] = self->bone->tail[1];
( ( VectorObject * ) attr )->vec[2] = self->bone->tail[2];
@@ -761,17 +815,19 @@ static PyObject *Bone_getTail( BPy_Bone * self )
static PyObject *Bone_getLoc( BPy_Bone * self )
{
PyObject *attr = NULL;
float vec[3];
float *vec;
int x;
if( !self->bone ) { //test to see if linked to armature
//use python vars
vec = PyMem_Malloc( 3 * sizeof( float ) );
for( x = 0; x < 3; x++ )
vec[x] = self->loc->vec[x];
attr = ( PyObject * ) newVectorObject( vec, 3, Py_NEW );
attr = ( PyObject * ) newVectorObject( vec, 3 );
} else {
//use bone datastruct
attr = newVectorObject( vec, 3, Py_NEW );
attr = newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ),
3 );
( ( VectorObject * ) attr )->vec[0] = self->bone->loc[0];
( ( VectorObject * ) attr )->vec[1] = self->bone->loc[1];
( ( VectorObject * ) attr )->vec[2] = self->bone->loc[2];
@@ -787,17 +843,19 @@ static PyObject *Bone_getLoc( BPy_Bone * self )
static PyObject *Bone_getSize( BPy_Bone * self )
{
PyObject *attr = NULL;
float vec[3];
float *vec;
int x;
if( !self->bone ) { //test to see if linked to armature
//use python vars
vec = PyMem_Malloc( 3 * sizeof( float ) );
for( x = 0; x < 3; x++ )
vec[x] = self->size->vec[x];
attr = ( PyObject * ) newVectorObject( vec, 3, Py_NEW );
attr = ( PyObject * ) newVectorObject( vec, 3 );
} else {
//use bone datastruct
attr = newVectorObject( vec, 3, Py_NEW );
attr = newVectorObject( PyMem_Malloc( 3 * sizeof( float ) ),
3 );
( ( VectorObject * ) attr )->vec[0] = self->bone->size[0];
( ( VectorObject * ) attr )->vec[1] = self->bone->size[1];
( ( VectorObject * ) attr )->vec[2] = self->bone->size[2];
@@ -813,18 +871,20 @@ static PyObject *Bone_getSize( BPy_Bone * self )
static PyObject *Bone_getQuat( BPy_Bone * self )
{
PyObject *attr = NULL;
float quat[4];
float *quat;
int x;
if( !self->bone ) { //test to see if linked to armature
//use python vars - p.s. - you must return a copy or else
//python will trash the internal var
quat = PyMem_Malloc( 4 * sizeof( float ) );
for( x = 0; x < 4; x++ )
quat[x] = self->quat->quat[x];
attr = ( PyObject * ) newQuaternionObject( quat, Py_NEW );
attr = ( PyObject * ) newQuaternionObject( quat );
} else {
//use bone datastruct
attr = newQuaternionObject( NULL, Py_NEW );
attr = newQuaternionObject( PyMem_Malloc
( 4 * sizeof( float ) ) );
( ( QuaternionObject * ) attr )->quat[0] = self->bone->quat[0];
( ( QuaternionObject * ) attr )->quat[1] = self->bone->quat[1];
( ( QuaternionObject * ) attr )->quat[2] = self->bone->quat[2];
@@ -1625,7 +1685,7 @@ static PyObject *Bone_getRestMatrix( BPy_Bone * self, PyObject * args )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected 'bonespace' or 'worldspace'" ) );
matrix = newMatrixObject( NULL, 4, 4 , Py_NEW);
matrix = newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 );
if( !self->bone ) { //test to see if linked to armature
//use python vars

2209
source/blender/python/api2_2x/Mathutils.c
View File

@@ -30,6 +30,7 @@
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
#include <Python.h>
#include <BKE_main.h>
#include <BKE_global.h>
#include <BKE_library.h>
@@ -39,562 +40,765 @@
#include <PIL_time.h>
#include <BLI_rand.h>
#include <math.h>
#include "vector.h"
#include "euler.h"
#include "quat.h"
#include "matrix.h"
#include "blendef.h"
#include "mydevice.h"
#include "constant.h"
#include "gen_utils.h"
#include "Mathutils.h"
//-------------------------DOC STRINGS ---------------------------
/*****************************************************************************/
// Python API function prototypes for the Mathutils module.
/*****************************************************************************/
static PyObject *M_Mathutils_Rand( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_Vector( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_CrossVecs( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_DotVecs( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_AngleBetweenVecs( PyObject * self,
PyObject * args );
static PyObject *M_Mathutils_MidpointVecs( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_VecMultMat( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_ProjectVecs( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_CopyVec( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_Matrix( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_RotationMatrix( PyObject * self,
PyObject * args );
static PyObject *M_Mathutils_ScaleMatrix( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_OrthoProjectionMatrix( PyObject * self,
PyObject * args );
static PyObject *M_Mathutils_ShearMatrix( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_TranslationMatrix( PyObject * self,
PyObject * args );
static PyObject *M_Mathutils_MatMultVec( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_CopyMat( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_Quaternion( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_CrossQuats( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_DotQuats( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_CopyQuat( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_DifferenceQuats( PyObject * self,
PyObject * args );
static PyObject *M_Mathutils_Slerp( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_Euler( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_CopyEuler( PyObject * self, PyObject * args );
static PyObject *M_Mathutils_RotateEuler( PyObject * self, PyObject * args );
/*****************************************************************************/
// The following string definitions are used for documentation strings.
// In Python these will be written to the console when doing a
// Blender.Mathutils.__doc__
/* Mathutils Module 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_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_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_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[] = "() - create a translation matrix from a vector";
static char M_Mathutils_TranslationMatrix_doc[] =
"() - 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";
//-----------------------METHOD DEFINITIONS ----------------------
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";
/****************************************************************************/
// Python method structure definition for Blender.Mathutils module:
/****************************************************************************/
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_VARARGS, 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},
{"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_VARARGS,
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},
{NULL, NULL, 0, NULL}
};
//----------------------------MODULE INIT-------------------------
PyObject *Mathutils_Init(void)
//***************************************************************************
// Function: M_Mathutils_Rand
//***************************************************************************
static PyObject *M_Mathutils_Rand( PyObject * self, PyObject * args )
{
PyObject *submodule;
//seed the generator for the rand function
BLI_srand((unsigned int) (PIL_check_seconds_timer() *
0x7FFFFFFF));
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\n");
}else{
vecCopy[3] = 0.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++] = dot;
dot = 0.0f;
}
return (PyObject *) newVectorObject(vecNew, vec->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, 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\n");
}else{
vecCopy[3] = 0.0f;
}
}
size = vec->size;
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++] = dot;
dot = 0.0f;
}
return (PyObject *) newVectorObject(vecNew, size, Py_NEW);
}
//----------------------------------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( !PyArg_ParseTuple( args, "|ff", &low, &high ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected 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"));
if( ( high < low ) || ( high < 0 && low > 0 ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"high value should be larger than low value\n" ) );
//seed the generator
BLI_srand( ( unsigned int ) ( PIL_check_seconds_timer( ) *
0x7FFFFFFF ) );
//get the random number 0 - 1
rand = BLI_drand();
rand = BLI_drand( );
//set it to range
range = high - low;
rand = rand * range;
rand = rand + low;
return PyFloat_FromDouble(rand);
return PyFloat_FromDouble( ( double ) rand );
}
//----------------------------------VECTOR FUNCTIONS---------------------
//----------------------------------Mathutils.Vector() ------------------
//***************************************************************************
// Function: M_Mathutils_Vector
// Python equivalent: Blender.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)
// accepted. Mixed float and int values accepted. Ints are parsed to float
//***************************************************************************
static PyObject *M_Mathutils_Vector( PyObject * self, PyObject * args )
{
PyObject *listObject = NULL;
int size, i;
float vec[4];
size = PySequence_Length(args);
if (size == 1) {
if ( size == 1 ) {
listObject = PySequence_GetItem(args, 0);
if (PySequence_Check(listObject)) {
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 {
goto bad_args; // Single argument was not a sequence
}
} else if (size == 0) {
//returns a new empty 3d vector
return (PyObject *) newVectorObject(NULL, 3, Py_NEW);
} else if ( size == 0 ) {
return ( PyObject * ) newVectorObject( NULL, 3 );
} else {
listObject = EXPP_incr_ret(args);
Py_INCREF(args);
listObject = 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");
if (size<2 || size>4) {
goto bad_args; // Invalid vector size
}
for (i=0; i<size; i++) {
PyObject *v, *f;
v=PySequence_GetItem(listObject, i);
if (v==NULL) { // Failed to read sequence
Py_XDECREF(listObject);
return EXPP_ReturnPyObjError(PyExc_RuntimeError,
"Mathutils.Vector(): 2-4 floats or ints expected (optionally in a sequence)\n");
if (v==NULL) {
Py_DECREF(listObject);
return NULL; // Failed to read sequence
}
f=PyNumber_Float(v);
if(f==NULL) { // parsed item not a number
if(f==NULL) {
Py_DECREF(v);
Py_XDECREF(listObject);
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Mathutils.Vector(): 2-4 floats or ints expected (optionally in a sequence)\n");
goto bad_args;
}
vec[i]=PyFloat_AS_DOUBLE(f);
EXPP_decr2(f,v);
Py_DECREF(f);
Py_DECREF(v);
}
Py_DECREF(listObject);
return (PyObject *) newVectorObject(vec, size, Py_NEW);
return ( PyObject * ) newVectorObject( vec, size );
bad_args:
Py_XDECREF(listObject);
PyErr_SetString( PyExc_TypeError, "2-4 floats expected (optionally in a sequence)");
return NULL;
}
//----------------------------------Mathutils.CrossVecs() ---------------
//finds perpendicular vector - only 3D is supported
PyObject *M_Mathutils_CrossVecs(PyObject * self, PyObject * args)
//***************************************************************************
//Begin Vector Utils
static PyObject *M_Mathutils_CopyVec( PyObject * self, PyObject * args )
{
PyObject *vecCross = NULL;
VectorObject *vec1 = NULL, *vec2 = NULL;
VectorObject *vector;
float *vec;
int x;
PyObject *retval;
if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2))
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Mathutils.CrossVecs(): expects (2) 3D vector objects\n");
if(vec1->size != 3 || vec2->size != 3)
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Mathutils.CrossVecs(): expects (2) 3D vector objects\n");
if( !PyArg_ParseTuple( args, "O!", &vector_Type, &vector ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected vector type\n" ) );
vec = PyMem_Malloc( vector->size * sizeof( float ) );
for( x = 0; x < vector->size; x++ ) {
vec[x] = vector->vec[x];
}
retval = ( PyObject * ) newVectorObject( vec, vector->size );
PyMem_Free( vec );
return retval;
}
//finds perpendicular vector - only 3D is supported
static PyObject *M_Mathutils_CrossVecs( PyObject * self, PyObject * args )
{
PyObject *vecCross;
VectorObject *vec1;
VectorObject *vec2;
if( !PyArg_ParseTuple
( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError, "expected 2 vector types\n" ) );
if( vec1->size != 3 || vec2->size != 3 )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"only 3D vectors are supported\n" ) );
vecCross = newVectorObject( NULL, 3 );
Crossf( ( ( VectorObject * ) vecCross )->vec, vec1->vec, vec2->vec );
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)
static PyObject *M_Mathutils_DotVecs( PyObject * self, PyObject * args )
{
VectorObject *vec1 = NULL, *vec2 = NULL;
double dot = 0.0f;
VectorObject *vec1;
VectorObject *vec2;
float dot;
int x;
if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2))
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Mathutils.DotVec(): expects (2) vector objects of the same size\n");
if(vec1->size != vec2->size)
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Mathutils.DotVec(): expects (2) vector objects of the same size\n");
dot = 0;
if( !PyArg_ParseTuple
( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError, "expected vector types\n" ) );
if( vec1->size != vec2->size )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"vectors must be of the same size\n" ) );
for(x = 0; x < vec1->size; x++) {
for( x = 0; x < vec1->size; x++ ) {
dot += vec1->vec[x] * vec2->vec[x];
}
return PyFloat_FromDouble(dot);
return PyFloat_FromDouble( ( double ) dot );
}
//----------------------------------Mathutils.AngleBetweenVecs() ---------
//calculates the angle between 2 vectors
PyObject *M_Mathutils_AngleBetweenVecs(PyObject * self, PyObject * args)
static PyObject *M_Mathutils_AngleBetweenVecs( PyObject * self,
PyObject * args )
{
VectorObject *vec1 = NULL, *vec2 = NULL;
double dot = 0.0f, angleRads;
double norm_a = 0.0f, norm_b = 0.0f;
double vec_a[4], vec_b[4];
int x, size;
VectorObject *vec1;
VectorObject *vec2;
float norm;
double dot, angleRads;
int x;
if(!PyArg_ParseTuple(args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2))
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Mathutils.AngleBetweenVecs(): expects (2) vector objects of the same size\n");
if(vec1->size != vec2->size)
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Mathutils.AngleBetweenVecs(): expects (2) vector objects of the same size\n");
dot = 0.0f;
if( !PyArg_ParseTuple
( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError, "expected 2 vector types\n" ) );
if( vec1->size != vec2->size )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"vectors must be of the same size\n" ) );
if( vec1->size > 3 || vec2->size > 3 )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"only 2D,3D vectors are supported\n" ) );
//since size is the same....
size = vec1->size;
//copy vector info
for (x = 0; x < vec1->size; x++){
vec_a[x] = vec1->vec[x];
vec_b[x] = vec2->vec[x];
//normalize vec1
norm = 0.0f;
for( x = 0; x < vec1->size; x++ ) {
norm += vec1->vec[x] * vec1->vec[x];
}
norm = ( float ) sqrt( norm );
for( x = 0; x < vec1->size; x++ ) {
vec1->vec[x] /= norm;
}
//normalize vectors
for(x = 0; x < size; x++) {
norm_a += vec_a[x] * vec_a[x];
norm_b += vec_b[x] * vec_b[x];
//normalize vec2
norm = 0.0f;
for( x = 0; x < vec2->size; x++ ) {
norm += vec2->vec[x] * vec2->vec[x];
}
norm_a = (double)sqrt(norm_a);
norm_b = (double)sqrt(norm_b);
for(x = 0; x < size; x++) {
vec_a[x] /= norm_a;
vec_b[x] /= norm_b;
norm = ( float ) sqrt( norm );
for( x = 0; x < vec2->size; x++ ) {
vec2->vec[x] /= norm;
}
//dot product
for(x = 0; x < size; x++) {
dot += vec_a[x] * vec_b[x];
}
//I believe saacos checks to see if the vectors are normalized
angleRads = (double)acos(dot);
return PyFloat_FromDouble(angleRads * (180 / Py_PI));
}
//----------------------------------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 (PyObject *) 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;
PyObject *retval;
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++) {
for( x = 0; x < vec1->size; x++ ) {
dot += vec1->vec[x] * vec2->vec[x];
}
//I believe saacos checks to see if the vectors are normalized
angleRads = (double)acos( dot );
return PyFloat_FromDouble( angleRads * ( 180 / Py_PI ) );
}
static PyObject *M_Mathutils_MidpointVecs( PyObject * self, PyObject * args )
{
VectorObject *vec1;
VectorObject *vec2;
float *vec;
int x;
PyObject *retval;
if( !PyArg_ParseTuple
( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError, "expected vector types\n" ) );
if( vec1->size != vec2->size )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"vectors must be of the same size\n" ) );
vec = PyMem_Malloc( vec1->size * sizeof( float ) );
for( x = 0; x < vec1->size; x++ ) {
vec[x] = 0.5f * ( vec1->vec[x] + vec2->vec[x] );
}
retval = ( PyObject * ) newVectorObject( vec, vec1->size );
PyMem_Free( vec );
return retval;
}
//row vector multiplication
static PyObject *M_Mathutils_VecMultMat( PyObject * self, PyObject * args )
{
PyObject *ob1 = NULL;
PyObject *ob2 = NULL;
MatrixObject *mat;
VectorObject *vec;
PyObject *retval;
float *vecNew;
int x, y;
int z = 0;
float dot = 0.0f;
//get pyObjects
if( !PyArg_ParseTuple
( args, "O!O!", &vector_Type, &ob1, &matrix_Type, &ob2 ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError,
"vector and matrix object expected - in that order\n" ) );
mat = ( MatrixObject * ) ob2;
vec = ( VectorObject * ) ob1;
if( mat->colSize != vec->size )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"matrix col size and vector size must be the same\n" ) );
vecNew = PyMem_Malloc( vec->size * sizeof( float ) );
for( x = 0; x < mat->colSize; x++ ) {
for( y = 0; y < mat->rowSize; y++ ) {
dot += mat->matrix[y][x] * vec->vec[y];
}
vecNew[z] = dot;
z++;
dot = 0;
}
retval = ( PyObject * ) newVectorObject( vecNew, vec->size );
PyMem_Free( vecNew );
return retval;
}
static PyObject *M_Mathutils_ProjectVecs( PyObject * self, PyObject * args )
{
VectorObject *vec1;
VectorObject *vec2;
PyObject *retval;
float *vec;
float dot = 0.0f;
float dot2 = 0.0f;
int x;
if( !PyArg_ParseTuple
( args, "O!O!", &vector_Type, &vec1, &vector_Type, &vec2 ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError, "expected vector types\n" ) );
if( vec1->size != vec2->size )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"vectors must be of the same size\n" ) );
vec = PyMem_Malloc( vec1->size * sizeof( float ) );
//dot of vec1 & vec2
for( x = 0; x < vec1->size; x++ ) {
dot += vec1->vec[x] * vec2->vec[x];
}
//dot of vec2 & vec2
for( x = 0; x < vec2->size; x++ ) {
dot2 += vec2->vec[x] * vec2->vec[x];
}
//projection
dot /= dot2;
for(x = 0; x < size; x++) {
vec[x] = (float)(dot * vec2->vec[x]);
for( x = 0; x < vec1->size; x++ ) {
vec[x] = dot * vec2->vec[x];
}
return (PyObject *) 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;
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
PyObject *argObject;
argObject = PySequence_GetItem(args, 0);
Py_INCREF(argObject);
if(MatrixObject_Check(argObject)){
MatrixObject *mat;
mat = (MatrixObject*)argObject;
argSize = mat->rowSize; //rows
seqSize = mat->colSize; //cols
for(i = 0; i < (seqSize * argSize); i++){
matrix[i] = mat->contigPtr[i];
}
retval = ( PyObject * ) newVectorObject( vec, vec1->size );
PyMem_Free( vec );
return retval;
}
//End Vector Utils
//***************************************************************************
// Function: M_Mathutils_Matrix // Python equivalent: Blender.Mathutils.Matrix
//***************************************************************************
//mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
static PyObject *M_Mathutils_Matrix( PyObject * self, PyObject * args )
{
PyObject *rowA = NULL;
PyObject *rowB = NULL;
PyObject *rowC = NULL;
PyObject *rowD = NULL;
PyObject *checkOb = NULL;
PyObject *retval = NULL;
int x, rowSize, colSize;
float *mat;
int OK;
if( !PyArg_ParseTuple( args, "|O!O!O!O!", &PyList_Type, &rowA,
&PyList_Type, &rowB,
&PyList_Type, &rowC, &PyList_Type, &rowD ) ) {
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected 0, 2,3 or 4 lists\n" ) );
}
if( !rowA )
return newMatrixObject( NULL, 4, 4 );
if( !rowB )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected 0, 2,3 or 4 lists\n" ) );
//get rowSize
if( rowC ) {
if( rowD ) {
rowSize = 4;
} else {
rowSize = 3;
}
Py_DECREF(argObject);
}else{ //2-4 arguments (all seqs? all same size?)
for(i =0; i < argSize; i++){
PyObject *argObject;
argObject = PySequence_GetItem(args, i);
if (PySequence_Check(argObject)) { //seq?
if(seqSize){ //0 at first
if(PySequence_Length(argObject) != seqSize){ //seq size not same
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Mathutils.Matrix(): expects 0-4 numeric sequences of the same size\n");
} else {
rowSize = 2;
}
//check size and get colSize
OK = 0;
if( ( PyList_Size( rowA ) == PyList_Size( rowB ) ) ) {
if( rowC ) {
if( ( PyList_Size( rowA ) == PyList_Size( rowC ) ) ) {
if( rowD ) {
if( ( PyList_Size( rowA ) ==
PyList_Size( rowD ) ) ) {
OK = 1;
}
}
seqSize = PySequence_Length(argObject);
}else{ //arg not a sequence
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Mathutils.Matrix(): expects 0-4 numeric sequences of the same size\n");
OK = 1;
}
Py_XDECREF(argObject);
}
//all is well... let's continue parsing
listObject = EXPP_incr_ret(args);
for (i = 0; i < argSize; i++){
PyObject *m;
m = PySequence_GetItem(listObject, i);
if (m == NULL) { // Failed to read sequence
Py_XDECREF(listObject);
return EXPP_ReturnPyObjError(PyExc_RuntimeError,
"Mathutils.Matrix(): failed to parse arguments...\n");
}
for (j = 0; j < seqSize; j++) {
PyObject *s, *f;
s = PySequence_GetItem(m, j);
if (s == NULL) { // Failed to read sequence
Py_DECREF(m);
Py_XDECREF(listObject);
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);
Py_XDECREF(listObject);
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Mathutils.Matrix(): expects 0-4 numeric sequences of the same size\n");
}
matrix[(seqSize*i)+j]=PyFloat_AS_DOUBLE(f);
EXPP_decr2(f,s);
}
Py_DECREF(m);
}
Py_DECREF(listObject);
} else
OK = 1;
}
return (PyObject *)newMatrixObject(matrix, argSize, seqSize, Py_NEW);
if( !OK )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"each row of vector must contain the same number of parameters\n" );
colSize = PyList_Size( rowA );
//check for numeric types
/* PyList_GetItem() returns borrowed ref */
for( x = 0; x < colSize; x++ ) {
checkOb = PyList_GetItem( rowA, x );
if( !PyInt_Check( checkOb ) && !PyFloat_Check( checkOb ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"1st list - expected list of numbers\n" ) );
checkOb = PyList_GetItem( rowB, x );
if( !PyInt_Check( checkOb ) && !PyFloat_Check( checkOb ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"2nd list - expected list of numbers\n" ) );
if( rowC ) {
checkOb = PyList_GetItem( rowC, x );
if( !PyInt_Check( checkOb )
&& !PyFloat_Check( checkOb ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError,
"3rd list - expected list of numbers\n" ) );
}
if( rowD ) {
checkOb = PyList_GetItem( rowD, x );
if( !PyInt_Check( checkOb )
&& !PyFloat_Check( checkOb ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError,
"4th list - expected list of numbers\n" ) );
}
}
//allocate space for 1D array
mat = PyMem_Malloc( rowSize * colSize * sizeof( float ) );
//parse rows
for( x = 0; x < colSize; x++ ) {
if( !PyArg_Parse( PyList_GetItem( rowA, x ), "f", &mat[x] ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"rowA - python list not parseable\n" );
}
for( x = 0; x < colSize; x++ ) {
if( !PyArg_Parse
( PyList_GetItem( rowB, x ), "f", &mat[( colSize + x )] ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"rowB - python list not parseable\n" );
}
if( rowC ) {
for( x = 0; x < colSize; x++ ) {
if( !PyArg_Parse
( PyList_GetItem( rowC, x ), "f",
&mat[( ( 2 * colSize ) + x )] ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"rowC - python list not parseable\n" );
}
}
if( rowD ) {
for( x = 0; x < colSize; x++ ) {
if( !PyArg_Parse
( PyList_GetItem( rowD, x ), "f",
&mat[( ( 3 * colSize ) + x )] ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"rowD - python list not parseable\n" );
}
}
//pass to matrix creation
retval = newMatrixObject( mat, rowSize, colSize );
PyMem_Free( mat);
return retval;
}
//----------------------------------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");
//***************************************************************************
// Function: M_Mathutils_RotationMatrix
// Python equivalent: Blender.Mathutils.RotationMatrix
//***************************************************************************
//mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
static PyObject *M_Mathutils_RotationMatrix( PyObject * self, PyObject * args )
{
PyObject *retval;
float *mat;
float angle = 0.0f;
char *axis = NULL;
VectorObject *vec = NULL;
int matSize;
float norm = 0.0f;
float cosAngle = 0.0f;
float sinAngle = 0.0f;
if( !PyArg_ParseTuple
( args, "fi|sO!", &angle, &matSize, &axis, &vector_Type, &vec ) ) {
return ( EXPP_ReturnPyObjError
( PyExc_TypeError,
"expected float int and optional string and vector\n" ) );
}
if(angle < -360.0f || angle > 360.0f)
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Mathutils.RotationMatrix(): angle size not appropriate\n");
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( angle < -360.0f || angle > 360.0f )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"angle size not appropriate\n" );
if( matSize != 2 && matSize != 3 && matSize != 4 )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"can only return a 2x2 3x3 or 4x4 matrix\n" );
if( matSize == 2 && ( axis != NULL || vec != NULL ) )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"cannot create a 2x2 rotation matrix around arbitrary axis\n" );
if( ( matSize == 3 || matSize == 4 ) && axis == NULL )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"please choose an axis of rotation\n" );
if( axis ) {
if( ( ( strcmp( axis, "r" ) == 0 ) ||
( strcmp( axis, "R" ) == 0 ) ) && vec == NULL )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"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");
if( vec ) {
if( vec->size != 3 )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"the arbitrary axis must be a 3D vector\n" );
}
mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
//convert to radians
angle = angle * (float) (Py_PI / 180);
if(axis == NULL && matSize == 2) {
angle = angle * ( float ) ( Py_PI / 180 );
if( axis == NULL && matSize == 2 ) {
//2D rotation matrix
mat[0] = (float) cosf (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)) {
mat[0] = ( ( float ) cos( ( double ) ( angle ) ) );
mat[1] = ( ( float ) sin( ( double ) ( angle ) ) );
mat[2] = ( -( ( float ) sin( ( double ) ( angle ) ) ) );
mat[3] = ( ( float ) cos( ( double ) ( 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)) {
mat[1] = 0.0f;
mat[2] = 0.0f;
mat[3] = 0.0f;
mat[4] = ( ( float ) cos( ( double ) ( angle ) ) );
mat[5] = ( ( float ) sin( ( double ) ( angle ) ) );
mat[6] = 0.0f;
mat[7] = ( -( ( float ) sin( ( double ) ( angle ) ) ) );
mat[8] = ( ( float ) cos( ( double ) ( 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[0] = ( ( float ) cos( ( double ) ( angle ) ) );
mat[1] = 0.0f;
mat[2] = ( -( ( float ) sin( ( double ) ( angle ) ) ) );
mat[3] = 0.0f;
mat[4] = 1.0f;
mat[6] = (float) sin(angle);
mat[8] = (float) cos(angle);
} else if((strcmp(axis, "z") == 0) || (strcmp(axis, "Z") == 0)) {
mat[5] = 0.0f;
mat[6] = ( ( float ) sin( ( double ) ( angle ) ) );
mat[7] = 0.0f;
mat[8] = ( ( float ) cos( ( double ) ( 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[0] = ( ( float ) cos( ( double ) ( angle ) ) );
mat[1] = ( ( float ) sin( ( double ) ( angle ) ) );
mat[2] = 0.0f;
mat[3] = ( -( ( float ) sin( ( double ) ( angle ) ) ) );
mat[4] = ( ( float ) cos( ( double ) ( angle ) ) );
mat[5] = 0.0f;
mat[6] = 0.0f;
mat[7] = 0.0f;
mat[8] = 1.0f;
} else if((strcmp(axis, "r") == 0) || (strcmp(axis, "R") == 0)) {
} else if( ( strcmp( axis, "r" ) == 0 ) ||
( strcmp( axis, "R" ) == 0 ) ) {
//arbitrary rotation
//normalize arbitrary axis
norm = (float) sqrt(vec->vec[0] * vec->vec[0] +
norm = ( float ) sqrt( vec->vec[0] * vec->vec[0] +
vec->vec[1] * vec->vec[1] +
vec->vec[2] * vec->vec[2]);
vec->vec[2] * vec->vec[2] );
vec->vec[0] /= norm;
vec->vec[1] /= norm;
vec->vec[2] /= norm;
//create matrix
cosAngle = (float) cos(angle);
sinAngle = (float) sin(angle);
mat[0] = ((vec->vec[0] * vec->vec[0]) * (1 - cosAngle)) +
cosAngle = ( ( float ) cos( ( double ) ( angle ) ) );
sinAngle = ( ( float ) sin( ( double ) ( 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)) +
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)) +
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");
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"unrecognizable axis of rotation type - expected x,y,z or r\n" );
}
if(matSize == 4) {
if( matSize == 4 ) {
//resize matrix
mat[15] = 1.0f;
mat[14] = 0.0f;
mat[13] = 0.0f;
mat[12] = 0.0f;
mat[11] = 0.0f;
mat[10] = mat[8];
mat[9] = mat[7];
mat[8] = mat[6];
@@ -605,93 +809,146 @@ PyObject *M_Mathutils_RotationMatrix(PyObject * self, PyObject * args)
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, PyObject * args)
{
VectorObject *vec = NULL;
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};
retval = newMatrixObject( mat, matSize, matSize );
if(!PyArg_ParseTuple(args, "O!", &vector_Type, &vec)) {
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Mathutils.TranslationMatrix(): expected vector\n");
PyMem_Free( mat );
return retval;
}
//***************************************************************************
// Function: M_Mathutils_TranslationMatrix
// Python equivalent: Blender.Mathutils.TranslationMatrix
//***************************************************************************
static PyObject *M_Mathutils_TranslationMatrix( PyObject * self,
PyObject * args )
{
VectorObject *vec;
PyObject *retval;
float *mat;
if( !PyArg_ParseTuple( args, "O!", &vector_Type, &vec ) ) {
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected vector\n" ) );
}
if(vec->size != 3 && vec->size != 4) {
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Mathutils.TranslationMatrix(): vector must be 3D or 4D\n");
if( vec->size != 3 && vec->size != 4 ) {
return EXPP_ReturnPyObjError( PyExc_TypeError,
"vector must be 3D or 4D\n" );
}
//create a identity matrix and add translation
Mat4One((float(*)[4]) mat);
mat = PyMem_Malloc( 4 * 4 * sizeof( float ) );
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};
retval = newMatrixObject( mat, 4, 4 );
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");
PyMem_Free( mat );
return retval;
}
//***************************************************************************
// Function: M_Mathutils_ScaleMatrix
// Python equivalent: Blender.Mathutils.ScaleMatrix
//***************************************************************************
//mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
static PyObject *M_Mathutils_ScaleMatrix( PyObject * self, PyObject * args )
{
float factor;
int matSize;
VectorObject *vec = NULL;
float *mat;
float norm = 0.0f;
int x;
PyObject *retval;
if( !PyArg_ParseTuple
( args, "fi|O!", &factor, &matSize, &vector_Type, &vec ) ) {
return ( EXPP_ReturnPyObjError
( PyExc_TypeError,
"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( matSize != 2 && matSize != 3 && matSize != 4 )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"can only return a 2x2 3x3 or 4x4 matrix\n" );
if( vec ) {
if( vec->size > 2 && matSize == 2 )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"please use 2D vectors when scaling in 2D\n" );
}
if(vec == NULL) { //scaling along axis
if(matSize == 2) {
mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
if( vec == NULL ) { //scaling along axis
if( matSize == 2 ) {
mat[0] = factor;
mat[1] = 0.0f;
mat[2] = 0.0f;
mat[3] = factor;
} else {
mat[0] = factor;
mat[1] = 0.0f;
mat[2] = 0.0f;
mat[3] = 0.0f;
mat[4] = factor;
mat[5] = 0.0f;
mat[6] = 0.0f;
mat[7] = 0.0f;
mat[8] = factor;
}
} else { //scaling in arbitrary direction
} else { //scaling in arbitrary direction
//normalize arbitrary axis
for(x = 0; x < vec->size; x++) {
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++) {
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]));
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]));
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) {
if( matSize == 4 ) {
//resize matrix
mat[15] = 1.0f;
mat[14] = 0.0f;
mat[13] = 0.0f;
mat[12] = 0.0f;
mat[11] = 0.0f;
mat[10] = mat[8];
mat[9] = mat[7];
mat[8] = mat[6];
@@ -702,94 +959,152 @@ PyObject *M_Mathutils_ScaleMatrix(PyObject * self, PyObject * args)
mat[3] = 0.0f;
}
//pass to matrix creation
return newMatrixObject(mat, matSize, matSize, Py_NEW);
retval = newMatrixObject( mat, matSize, matSize );
PyMem_Free( mat );
return retval;
}
//----------------------------------Mathutils.OrthoProjectionMatrix() ---
//***************************************************************************
// Function: M_Mathutils_OrthoProjectionMatrix
// Python equivalent: Blender.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)
static PyObject *M_Mathutils_OrthoProjectionMatrix( PyObject * self,
PyObject * args )
{
VectorObject *vec = NULL;
char *plane;
int matSize, x;
int matSize;
float *mat;
VectorObject *vec = NULL;
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");
int x;
PyObject *retval;
if( !PyArg_ParseTuple
( args, "si|O!", &plane, &matSize, &vector_Type, &vec ) ) {
return ( EXPP_ReturnPyObjError
( PyExc_TypeError,
"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( matSize != 2 && matSize != 3 && matSize != 4 )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"can only return a 2x2 3x3 or 4x4 matrix\n" );
if( vec ) {
if( vec->size > 2 && matSize == 2 )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"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) {
if( vec == NULL ) { //ortho projection onto cardinal plane
if( ( ( strcmp( plane, "x" ) == 0 )
|| ( strcmp( plane, "X" ) == 0 ) ) && matSize == 2 ) {
mat = PyMem_Malloc( matSize * matSize *
sizeof( float ) );
mat[0] = 1.0f;
} else if(((strcmp(plane, "y") == 0)
|| (strcmp(plane, "Y") == 0))
&& matSize == 2) {
mat[1] = 0.0f;
mat[2] = 0.0f;
mat[3] = 0.0f;
} else if( ( ( strcmp( plane, "y" ) == 0 )
|| ( strcmp( plane, "Y" ) == 0 ) )
&& matSize == 2 ) {
mat = PyMem_Malloc( matSize * matSize *
sizeof( float ) );
mat[0] = 0.0f;
mat[1] = 0.0f;
mat[2] = 0.0f;
mat[3] = 1.0f;
} else if(((strcmp(plane, "xy") == 0)
|| (strcmp(plane, "XY") == 0))
&& matSize > 2) {
} else if( ( ( strcmp( plane, "xy" ) == 0 )
|| ( strcmp( plane, "XY" ) == 0 ) )
&& matSize > 2 ) {
mat = PyMem_Malloc( matSize * matSize *
sizeof( float ) );
mat[0] = 1.0f;
mat[1] = 0.0f;
mat[2] = 0.0f;
mat[3] = 0.0f;
mat[4] = 1.0f;
} else if(((strcmp(plane, "xz") == 0)
|| (strcmp(plane, "XZ") == 0))
&& matSize > 2) {
mat[5] = 0.0f;
mat[6] = 0.0f;
mat[7] = 0.0f;
mat[8] = 0.0f;
} else if( ( ( strcmp( plane, "xz" ) == 0 )
|| ( strcmp( plane, "XZ" ) == 0 ) )
&& matSize > 2 ) {
mat = PyMem_Malloc( matSize * matSize *
sizeof( float ) );
mat[0] = 1.0f;
mat[1] = 0.0f;
mat[2] = 0.0f;
mat[3] = 0.0f;
mat[4] = 0.0f;
mat[5] = 0.0f;
mat[6] = 0.0f;
mat[7] = 0.0f;
mat[8] = 1.0f;
} else if(((strcmp(plane, "yz") == 0)
|| (strcmp(plane, "YZ") == 0))
&& matSize > 2) {
} else if( ( ( strcmp( plane, "yz" ) == 0 )
|| ( strcmp( plane, "YZ" ) == 0 ) )
&& matSize > 2 ) {
mat = PyMem_Malloc( matSize * matSize *
sizeof( float ) );
mat[0] = 0.0f;
mat[1] = 0.0f;
mat[2] = 0.0f;
mat[3] = 0.0f;
mat[4] = 1.0f;
mat[5] = 0.0f;
mat[6] = 0.0f;
mat[7] = 0.0f;
mat[8] = 1.0f;
} else {
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Mathutils.OrthoProjectionMatrix(): unknown plane - expected: x, y, xy, xz, yz\n");
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"unknown plane - expected: x, y, xy, xz, yz\n" );
}
} else { //arbitrary plane
} else { //arbitrary plane
//normalize arbitrary axis
for(x = 0; x < vec->size; x++) {
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++) {
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]);
if( ( ( strcmp( plane, "r" ) == 0 )
|| ( strcmp( plane, "R" ) == 0 ) ) && matSize == 2 ) {
mat = PyMem_Malloc( matSize * matSize *
sizeof( float ) );
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 = PyMem_Malloc( matSize * matSize *
sizeof( float ) );
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");
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"unknown plane - expected: 'r' expected for axis designation\n" );
}
}
if(matSize == 4) {
if( matSize == 4 ) {
//resize matrix
mat[15] = 1.0f;
mat[14] = 0.0f;
mat[13] = 0.0f;
mat[12] = 0.0f;
mat[11] = 0.0f;
mat[10] = mat[8];
mat[9] = mat[7];
mat[8] = mat[6];
@@ -800,62 +1115,95 @@ PyObject *M_Mathutils_OrthoProjectionMatrix(PyObject * self, PyObject * args)
mat[3] = 0.0f;
}
//pass to matrix creation
return newMatrixObject(mat, matSize, matSize, Py_NEW);
retval = newMatrixObject( mat, matSize, matSize );
PyMem_Free( mat );
return retval;
}
//----------------------------------Mathutils.ShearMatrix() -------------
//creates a shear matrix
PyObject *M_Mathutils_ShearMatrix(PyObject * self, PyObject * args)
//***************************************************************************
// Function: M_Mathutils_ShearMatrix
// Python equivalent: Blender.Mathutils.ShearMatrix
//***************************************************************************
static PyObject *M_Mathutils_ShearMatrix( PyObject * self, PyObject * args )
{
float factor;
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};
float *mat;
PyObject *retval;
if(!PyArg_ParseTuple(args, "sfi", &plane, &factor, &matSize)) {
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Mathutils.ShearMatrix(): expected string float and int\n");
if( !PyArg_ParseTuple( args, "sfi", &plane, &factor, &matSize ) ) {
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"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) {
if( matSize != 2 && matSize != 3 && matSize != 4 )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"can only return a 2x2 3x3 or 4x4 matrix\n" );
if( ( ( strcmp( plane, "x" ) == 0 ) || ( strcmp( plane, "X" ) == 0 ) )
&& matSize == 2 ) {
mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
mat[0] = 1.0f;
mat[1] = 0.0f;
mat[2] = factor;
mat[3] = 1.0f;
} else if(((strcmp(plane, "y") == 0)
|| (strcmp(plane, "Y") == 0)) && matSize == 2) {
} else if( ( ( strcmp( plane, "y" ) == 0 )
|| ( strcmp( plane, "Y" ) == 0 ) ) && matSize == 2 ) {
mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
mat[0] = 1.0f;
mat[1] = factor;
mat[2] = 0.0f;
mat[3] = 1.0f;
} else if(((strcmp(plane, "xy") == 0)
|| (strcmp(plane, "XY") == 0)) && matSize > 2) {
} else if( ( ( strcmp( plane, "xy" ) == 0 )
|| ( strcmp( plane, "XY" ) == 0 ) ) && matSize > 2 ) {
mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
mat[0] = 1.0f;
mat[1] = 0.0f;
mat[2] = 0.0f;
mat[3] = 0.0f;
mat[4] = 1.0f;
mat[5] = 0.0f;
mat[6] = factor;
mat[7] = factor;
} else if(((strcmp(plane, "xz") == 0)
|| (strcmp(plane, "XZ") == 0)) && matSize > 2) {
mat[8] = 0.0f;
} else if( ( ( strcmp( plane, "xz" ) == 0 )
|| ( strcmp( plane, "XZ" ) == 0 ) ) && matSize > 2 ) {
mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
mat[0] = 1.0f;
mat[1] = 0.0f;
mat[2] = 0.0f;
mat[3] = factor;
mat[4] = 1.0f;
mat[5] = factor;
mat[6] = 0.0f;
mat[7] = 0.0f;
mat[8] = 1.0f;
} else if(((strcmp(plane, "yz") == 0)
|| (strcmp(plane, "YZ") == 0)) && matSize > 2) {
} else if( ( ( strcmp( plane, "yz" ) == 0 )
|| ( strcmp( plane, "YZ" ) == 0 ) ) && matSize > 2 ) {
mat = PyMem_Malloc( matSize * matSize * sizeof( float ) );
mat[0] = 1.0f;
mat[1] = factor;
mat[2] = factor;
mat[3] = 0.0f;
mat[4] = 1.0f;
mat[5] = 0.0f;
mat[6] = 0.0f;
mat[7] = 0.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");
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected: x, y, xy, xz, yz or wrong matrix size for shearing plane\n" );
}
if(matSize == 4) {
if( matSize == 4 ) {
//resize matrix
mat[15] = 1.0f;
mat[14] = 0.0f;
mat[13] = 0.0f;
mat[12] = 0.0f;
mat[11] = 0.0f;
mat[10] = mat[8];
mat[9] = mat[7];
mat[8] = mat[6];
@@ -866,405 +1214,388 @@ PyObject *M_Mathutils_ShearMatrix(PyObject * self, PyObject * args)
mat[3] = 0.0f;
}
//pass to matrix creation
return newMatrixObject(mat, matSize, matSize, Py_NEW);
retval = newMatrixObject( mat, matSize, matSize );
PyMem_Free( mat );
return retval;
}
//----------------------------------QUATERNION FUNCTIONS-----------------
//----------------------------------Mathutils.Quaternion() --------------
PyObject *M_Mathutils_Quaternion(PyObject * self, PyObject * args)
//***************************************************************************
//Begin Matrix Utils
static PyObject *M_Mathutils_CopyMat( PyObject * self, PyObject * args )
{
PyObject *listObject = NULL, *n, *q, *f;
int size, i;
float quat[4];
double norm = 0.0f, angle = 0.0f;
MatrixObject *matrix;
float *mat;
int x, y, z;
PyObject *retval;
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_XDECREF(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_XDECREF(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 (PySequence_Check(listObject)) {
size = PySequence_Length(listObject);
if (size != 3) {
// invalid args/size
Py_XDECREF(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_XDECREF(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");
}
if( !PyArg_ParseTuple( args, "O!", &matrix_Type, &matrix ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected matrix\n" ) );
mat = PyMem_Malloc( matrix->rowSize * matrix->colSize *
sizeof( float ) );
z = 0;
for( x = 0; x < matrix->rowSize; x++ ) {
for( y = 0; y < matrix->colSize; y++ ) {
mat[z] = matrix->matrix[x][y];
z++;
}
} else if (size == 0) { //returns a new empty quat
return (PyObject *) newQuaternionObject(NULL, Py_NEW);
} else {
listObject = EXPP_incr_ret(args);
}
if (size == 3) { // invalid quat size
if(PySequence_Length(args) != 2){
Py_XDECREF(listObject);
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n");
}
}else{
if(size != 4){
Py_XDECREF(listObject);
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n");
}
}
for (i=0; i<size; i++) { //parse
q = PySequence_GetItem(listObject, i);
if (q == NULL) { // Failed to read sequence
Py_XDECREF(listObject);
return EXPP_ReturnPyObjError(PyExc_RuntimeError,
"Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n");
}
f = PyNumber_Float(q);
if(f == NULL) { // parsed item not a number
Py_DECREF(q);
Py_XDECREF(listObject);
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n");
}
quat[i] = PyFloat_AS_DOUBLE(f);
EXPP_decr2(f, q);
}
if(size == 3){ //calculate the quat based on axis/angle
norm = sqrt(quat[0] * quat[0] + quat[1] * quat[1] + quat[2] * quat[2]);
quat[0] /= norm;
quat[1] /= norm;
quat[2] /= norm;
angle = angle * (Py_PI / 180);
quat[3] =(float) (sin(angle/ 2.0f)) * quat[2];
quat[2] =(float) (sin(angle/ 2.0f)) * quat[1];
quat[1] =(float) (sin(angle/ 2.0f)) * quat[0];
quat[0] =(float) (cos(angle/ 2.0f));
}
Py_DECREF(listObject);
return (PyObject *) newQuaternionObject(quat, Py_NEW);
retval = ( PyObject * ) newMatrixObject( mat, matrix->rowSize,
matrix->colSize );
PyMem_Free( mat );
return retval;
}
//----------------------------------Mathutils.CrossQuats() ----------------
//quaternion multiplication - associate not commutative
PyObject *M_Mathutils_CrossQuats(PyObject * self, PyObject * args)
static PyObject *M_Mathutils_MatMultVec( PyObject * self, PyObject * args )
{
QuaternionObject *quatU = NULL, *quatV = NULL;
float quat[4];
if(!PyArg_ParseTuple(args, "O!O!", &quaternion_Type, &quatU,
&quaternion_Type, &quatV))
return EXPP_ReturnPyObjError(PyExc_TypeError,"Mathutils.CrossQuats(): expected Quaternion types");
QuatMul(quat, quatU->quat, quatV->quat);
PyObject *ob1 = NULL;
PyObject *ob2 = NULL;
MatrixObject *mat;
VectorObject *vec;
PyObject *retval;
float *vecNew;
int x, y;
int z = 0;
float dot = 0.0f;
return (PyObject*) newQuaternionObject(quat, Py_NEW);
//get pyObjects
if( !PyArg_ParseTuple
( args, "O!O!", &matrix_Type, &ob1, &vector_Type, &ob2 ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError,
"matrix and vector object expected - in that order\n" ) );
mat = ( MatrixObject * ) ob1;
vec = ( VectorObject * ) ob2;
if( mat->rowSize != vec->size )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"matrix row size and vector size must be the same\n" ) );
vecNew = PyMem_Malloc( vec->size * sizeof( float ) );
for( x = 0; x < mat->rowSize; x++ ) {
for( y = 0; y < mat->colSize; y++ ) {
dot += mat->matrix[x][y] * vec->vec[y];
}
vecNew[z] = dot;
z++;
dot = 0;
}
retval = ( PyObject * ) newVectorObject( vecNew, vec->size );
PyMem_Free( vecNew );
return retval;
}
//----------------------------------Mathutils.DotQuats() ----------------
//returns the dot product of 2 quaternions
PyObject *M_Mathutils_DotQuats(PyObject * self, PyObject * args)
//***************************************************************************
// Function: M_Mathutils_Quaternion
// Python equivalent: Blender.Mathutils.Quaternion
//***************************************************************************
static PyObject *M_Mathutils_Quaternion( PyObject * self, PyObject * args )
{
QuaternionObject *quatU = NULL, *quatV = NULL;
double dot = 0.0f;
PyObject *listObject;
float *vec = NULL;
float *quat = NULL;
float angle = 0.0f;
int x;
float norm;
PyObject *retval;
if(!PyArg_ParseTuple(args, "O!O!", &quaternion_Type, &quatU,
&quaternion_Type, &quatV))
return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.DotQuats(): expected Quaternion types");
if( !PyArg_ParseTuple
( args, "O!|f", &PyList_Type, &listObject, &angle ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError,
"expected list and optional float\n" ) );
for(x = 0; x < 4; x++) {
if( PyList_Size( listObject ) != 4 && PyList_Size( listObject ) != 3 )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"3 or 4 expected floats for the quaternion\n" ) );
vec = PyMem_Malloc( PyList_Size( listObject ) * sizeof( float ) );
for( x = 0; x < PyList_Size( listObject ); x++ ) {
if( !PyArg_Parse
( PyList_GetItem( listObject, x ), "f", &vec[x] ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"python list not parseable\n" );
}
if( PyList_Size( listObject ) == 3 ) { //an axis of rotation
norm = ( float ) sqrt( vec[0] * vec[0] + vec[1] * vec[1] +
vec[2] * vec[2] );
vec[0] /= norm;
vec[1] /= norm;
vec[2] /= norm;
angle = angle * ( float ) ( Py_PI / 180 );
quat = PyMem_Malloc( 4 * sizeof( float ) );
quat[0] = ( float ) ( cos( ( double ) ( angle ) / 2 ) );
quat[1] =
( float ) ( sin( ( double ) ( angle ) / 2 ) ) * vec[0];
quat[2] =
( float ) ( sin( ( double ) ( angle ) / 2 ) ) * vec[1];
quat[3] =
( float ) ( sin( ( double ) ( angle ) / 2 ) ) * vec[2];
retval = newQuaternionObject( quat );
} else
retval = newQuaternionObject( vec );
/* freeing a NULL ptr is ok */
PyMem_Free( vec );
PyMem_Free( quat );
return retval;
}
//***************************************************************************
//Begin Quaternion Utils
static PyObject *M_Mathutils_CopyQuat( PyObject * self, PyObject * args )
{
QuaternionObject *quatU;
float *quat = NULL;
PyObject *retval;
if( !PyArg_ParseTuple( args, "O!", &quaternion_Type, &quatU ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected Quaternion type" ) );
quat = PyMem_Malloc( 4 * sizeof( float ) );
quat[0] = quatU->quat[0];
quat[1] = quatU->quat[1];
quat[2] = quatU->quat[2];
quat[3] = quatU->quat[3];
retval = ( PyObject * ) newQuaternionObject( quat );
PyMem_Free( quat );
return retval;
}
static PyObject *M_Mathutils_CrossQuats( PyObject * self, PyObject * args )
{
QuaternionObject *quatU;
QuaternionObject *quatV;
float *quat = NULL;
PyObject *retval;
if( !PyArg_ParseTuple( args, "O!O!", &quaternion_Type, &quatU,
&quaternion_Type, &quatV ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected Quaternion types" ) );
quat = PyMem_Malloc( 4 * sizeof( float ) );
QuatMul( quat, quatU->quat, quatV->quat );
retval = ( PyObject * ) newQuaternionObject( quat );
PyMem_Free( quat );
return retval;
}
static PyObject *M_Mathutils_DotQuats( PyObject * self, PyObject * args )
{
QuaternionObject *quatU;
QuaternionObject *quatV;
int x;
float dot = 0.0f;
if( !PyArg_ParseTuple( args, "O!O!", &quaternion_Type, &quatU,
&quaternion_Type, &quatV ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"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");
return PyFloat_FromDouble( ( double ) ( dot ) );
}
static PyObject *M_Mathutils_DifferenceQuats( PyObject * self,
PyObject * args )
{
QuaternionObject *quatU;
QuaternionObject *quatV;
float *quat = NULL;
float *tempQuat = NULL;
PyObject *retval;
int x;
float dot = 0.0f;
if( !PyArg_ParseTuple( args, "O!O!", &quaternion_Type,
&quatU, &quaternion_Type, &quatV ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected Quaternion types" ) );
quat = PyMem_Malloc( 4 * sizeof( float ) );
tempQuat = PyMem_Malloc( 4 * sizeof( float ) );
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]);
dot = ( float ) sqrt( ( double ) tempQuat[0] * ( double ) tempQuat[0] +
( double ) tempQuat[1] * ( double ) tempQuat[1] +
( double ) tempQuat[2] * ( double ) tempQuat[2] +
( double ) tempQuat[3] *
( double ) tempQuat[3] );
for(x = 0; x < 4; x++) {
tempQuat[x] /= (dot * dot);
for( x = 0; x < 4; x++ ) {
tempQuat[x] /= ( dot * dot );
}
QuatMul(quat, tempQuat, quatV->quat);
return (PyObject *) newQuaternionObject(quat, Py_NEW);
QuatMul( quat, tempQuat, quatV->quat );
retval = ( PyObject * ) newQuaternionObject( quat );
PyMem_Free( quat );
PyMem_Free( tempQuat );
return retval;
}
//----------------------------------Mathutils.Slerp() ------------------
//attemps to interpolate 2 quaternions and return the result
PyObject *M_Mathutils_Slerp(PyObject * self, PyObject * args)
static 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, val;
int flag = 0, z;
QuaternionObject *quatU;
QuaternionObject *quatV;
float *quat = NULL;
PyObject *retval;
float param, x, y, cosD, sinD, deltaD, IsinD, val;
int flag, z;
if(!PyArg_ParseTuple(args, "O!O!f", &quaternion_Type,
&quatU, &quaternion_Type, &quatV, &param))
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Mathutils.Slerp(): expected Quaternion types and float");
if( !PyArg_ParseTuple( args, "O!O!f", &quaternion_Type,
&quatU, &quaternion_Type, &quatV, &param ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"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");
quat = PyMem_Malloc( 4 * sizeof( float ) );
//copy quats
for(z = 0; z < 4; z++){
quat_u[z] = quatU->quat[z];
quat_v[z] = quatV->quat[z];
cosD = quatU->quat[0] * quatV->quat[0] +
quatU->quat[1] * quatV->quat[1] +
quatU->quat[2] * quatV->quat[2] +
quatU->quat[3] * quatV->quat[3];
flag = 0;
if( cosD < 0.0f ) {
flag = 1;
cosD = -cosD;
}
//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
if( cosD > .99999f ) {
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;
sinD = ( float ) sqrt( 1.0f - cosD * cosD );
deltaD = ( float ) atan2( sinD, cosD );
IsinD = 1.0f / sinD;
x = ( float ) sin( ( 1.0f - param ) * deltaD ) * IsinD;
y = ( float ) sin( param * deltaD ) * IsinD;
}
//interpolate
quat[0] = quat_u[0] * x + quat_v[0] * y;
quat[1] = quat_u[1] * x + quat_v[1] * y;
quat[2] = quat_u[2] * x + quat_v[2] * y;
quat[3] = quat_u[3] * x + quat_v[3] * y;
return (PyObject *) 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];
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.Euler(): 3d numeric sequence expected\n");
}
} else if (size == 0) {
//returns a new empty 3d euler
return (PyObject *) newEulerObject(NULL, Py_NEW);
} else {
listObject = EXPP_incr_ret(args);
for( z = 0; z < 4; z++ ) {
val = quatV->quat[z];
if( val )
val = -val;
quat[z] = ( quatU->quat[z] * x ) + ( val * y );
}
if (size != 3) { // Invalid euler size
Py_XDECREF(listObject);
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Mathutils.Euler(): 3d numeric sequence expected\n");
retval = ( PyObject * ) newQuaternionObject( quat );
PyMem_Free( quat );
return retval;
}
//***************************************************************************
// Function: M_Mathutils_Euler
// Python equivalent: Blender.Mathutils.Euler
//***************************************************************************
static PyObject *M_Mathutils_Euler( PyObject * self, PyObject * args )
{
PyObject *listObject;
float *vec = NULL;
PyObject *retval;
int x;
if( !PyArg_ParseTuple( args, "O!", &PyList_Type, &listObject ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected list\n" ) );
if( PyList_Size( listObject ) != 3 )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"only 3d eulers are supported\n" );
vec = PyMem_Malloc( 3 * sizeof( float ) );
for( x = 0; x < 3; x++ ) {
if( !PyArg_Parse
( PyList_GetItem( listObject, x ), "f", &vec[x] ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"python list not parseable\n" );
}
for (i=0; i<size; i++) {
PyObject *e, *f;
e = PySequence_GetItem(listObject, i);
if (e == NULL) { // Failed to read sequence
Py_XDECREF(listObject);
return EXPP_ReturnPyObjError(PyExc_RuntimeError,
"Mathutils.Euler(): 3d numeric sequence expected\n");
}
f = PyNumber_Float(e);
if(f == NULL) { // parsed item not a number
Py_DECREF(e);
Py_XDECREF(listObject);
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Mathutils.Euler(): 3d numeric sequence expected\n");
}
eul[i]=PyFloat_AS_DOUBLE(f);
EXPP_decr2(f,e);
}
Py_DECREF(listObject);
return (PyObject *) newEulerObject(eul, Py_NEW);
}
//#############################DEPRECATED################################
//#######################################################################
//----------------------------------Mathutils.CopyMat() -----------------
//copies a matrix into a new matrix
PyObject *M_Mathutils_CopyMat(PyObject * self, PyObject * args)
{
PyObject *matrix = NULL;
retval = ( PyObject * ) newEulerObject( vec );
printf("Mathutils.CopyMat(): Deprecated :use Mathutils.Matrix() to copy matrices\n");
printf("Method will be removed in 2 releases\n");
matrix = M_Mathutils_Matrix(self, args);
if(matrix == NULL)
return NULL; //error string already set if we get here
else
return matrix;
PyMem_Free( vec );
return retval;
}
//----------------------------------Mathutils.CopyVec() -----------------
//makes a new vector that is a copy of the input
PyObject *M_Mathutils_CopyVec(PyObject * self, PyObject * args)
{
PyObject *vec = NULL;
printf("Mathutils.CopyVec(): Deprecated: use Mathutils.Vector() to copy vectors\n");
printf("Method will be removed in 2 releases\n");
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;
printf("Mathutils.CopyQuat(): Deprecated:use Mathutils.Quaternion() to copy vectors\n");
printf("Method will be removed in 2 releases\n");
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;
//***************************************************************************
//Begin Euler Util
printf("Mathutils.CopyEuler(): Deprecated:use Mathutils.Euler() to copy vectors\n");
printf("Method will be removed in 2 releases\n");
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)
static PyObject *M_Mathutils_CopyEuler( PyObject * self, PyObject * args )
{
EulerObject *Eul = NULL;
EulerObject *eulU;
float *eul = NULL;
PyObject *retval;
if( !PyArg_ParseTuple( args, "O!", &euler_Type, &eulU ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected Euler types" ) );
eul = PyMem_Malloc( 3 * sizeof( float ) );
eul[0] = eulU->eul[0];
eul[1] = eulU->eul[1];
eul[2] = eulU->eul[2];
retval = ( PyObject * ) newEulerObject( eul );
PyMem_Free( eul );
return retval;
}
static PyObject *M_Mathutils_RotateEuler( PyObject * self, PyObject * args )
{
EulerObject *Eul;
float angle;
char *axis;
int x;
if(!PyArg_ParseTuple(args, "O!fs", &euler_Type, &Eul, &angle, &axis))
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Mathutils.RotateEuler(): expected euler type & float & string");
if( !PyArg_ParseTuple
( args, "O!fs", &euler_Type, &Eul, &angle, &axis ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError,
"expected euler type & float & string" ) );
printf("Mathutils.RotateEuler(): Deprecated:use Euler.rotate() to rotate a euler\n");
printf("Method will be removed in 2 releases\n");
Euler_Rotate(Eul, Py_BuildValue("fs", angle, axis));
return EXPP_incr_ret(Py_None);
}
//----------------------------------Mathutils.MatMultVec() --------------
//COLUMN VECTOR Multiplication (Matrix X Vector)
PyObject *M_Mathutils_MatMultVec(PyObject * self, PyObject * args)
{
MatrixObject *mat = NULL;
VectorObject *vec = NULL;
PyObject *retObj = NULL;
//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");
printf("Mathutils.MatMultVec(): Deprecated: use matrix * vec to perform column vector multiplication\n");
printf("Method will be removed in 2 releases\n");
EXPP_incr2((PyObject*)vec, (PyObject*)mat);
retObj = column_vector_multiplication(mat, vec);
if(!retObj){
return NULL;
angle *= ( float ) ( Py_PI / 180 );
for( x = 0; x < 3; x++ ) {
Eul->eul[x] *= ( float ) ( Py_PI / 180 );
}
euler_rot( Eul->eul, angle, *axis );
for( x = 0; x < 3; x++ ) {
Eul->eul[x] *= ( float ) ( 180 / Py_PI );
}
EXPP_decr2((PyObject*)vec, (PyObject*)mat);
return retObj;
return EXPP_incr_ret( Py_None );
}
//----------------------------------Mathutils.VecMultMat() ---------------
//ROW VECTOR Multiplication - Vector X Matrix
PyObject *M_Mathutils_VecMultMat(PyObject * self, PyObject * args)
//***************************************************************************
// Function: Mathutils_Init
//***************************************************************************
PyObject *Mathutils_Init( void )
{
MatrixObject *mat = NULL;
VectorObject *vec = NULL;
PyObject *retObj = NULL;
//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");
printf("Mathutils.VecMultMat(): Deprecated: use vec * matrix to perform row vector multiplication\n");
printf("Method will be removed in 2 releases\n");
EXPP_incr2((PyObject*)vec, (PyObject*)mat);
retObj = row_vector_multiplication(vec, mat);
if(!retObj){
return NULL;
}
EXPP_decr2((PyObject*)vec, (PyObject*)mat);
return retObj;
PyObject *mod =
Py_InitModule3( "Blender.Mathutils", M_Mathutils_methods,
M_Mathutils_doc );
return ( mod );
}
//#######################################################################
//#############################DEPRECATED################################

38
source/blender/python/api2_2x/Mathutils.h
View File

@@ -29,48 +29,14 @@
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
//Include this file for access to vector, quat, matrix, euler, etc...
#ifndef EXPP_Mathutils_H
#define EXPP_Mathutils_H
#include <Python.h>
#include "vector.h"
#include "matrix.h"
#include "quat.h"
#include "euler.h"
#include "Types.h"
PyObject *Mathutils_Init( void );
PyObject *row_vector_multiplication(VectorObject* vec, MatrixObject * mat);
PyObject *column_vector_multiplication(MatrixObject * mat, VectorObject* vec);
PyObject *M_Mathutils_Rand(PyObject * self, PyObject * args);
PyObject *M_Mathutils_Vector(PyObject * self, PyObject * args);
PyObject *M_Mathutils_CrossVecs(PyObject * self, PyObject * args);
PyObject *M_Mathutils_DotVecs(PyObject * self, PyObject * args);
PyObject *M_Mathutils_AngleBetweenVecs(PyObject * self, PyObject * args);
PyObject *M_Mathutils_MidpointVecs(PyObject * self, PyObject * args);
PyObject *M_Mathutils_ProjectVecs(PyObject * self, PyObject * args);
PyObject *M_Mathutils_Matrix(PyObject * self, PyObject * args);
PyObject *M_Mathutils_RotationMatrix(PyObject * self, PyObject * args);
PyObject *M_Mathutils_TranslationMatrix(PyObject * self, PyObject * args);
PyObject *M_Mathutils_ScaleMatrix(PyObject * self, PyObject * args);
PyObject *M_Mathutils_OrthoProjectionMatrix(PyObject * self, PyObject * args);
PyObject *M_Mathutils_ShearMatrix(PyObject * self, PyObject * args);
PyObject *M_Mathutils_Quaternion(PyObject * self, PyObject * args);
PyObject *M_Mathutils_CrossQuats(PyObject * self, PyObject * args);
PyObject *M_Mathutils_DotQuats(PyObject * self, PyObject * args);
PyObject *M_Mathutils_DifferenceQuats(PyObject * self, PyObject * args);
PyObject *M_Mathutils_Slerp(PyObject * self, PyObject * args);
PyObject *M_Mathutils_Euler(PyObject * self, PyObject * args);
//DEPRECATED
PyObject *M_Mathutils_CopyMat(PyObject * self, PyObject * args);
PyObject *M_Mathutils_CopyVec(PyObject * self, PyObject * args);
PyObject *M_Mathutils_CopyQuat(PyObject * self, PyObject * args);
PyObject *M_Mathutils_CopyEuler(PyObject * self, PyObject * args);
PyObject *M_Mathutils_RotateEuler(PyObject * self, PyObject * args);
PyObject *M_Mathutils_MatMultVec(PyObject * self, PyObject * args);
PyObject *M_Mathutils_VecMultMat(PyObject * self, PyObject * args);
#endif /* EXPP_Mathutils_H */

10
source/blender/python/api2_2x/NMesh.c
View File

@@ -58,15 +58,14 @@
#include "BLI_blenlib.h"
#include "BLI_arithb.h"
#include "MEM_guardedalloc.h"
#include "BKE_utildefines.h"
#include "blendef.h"
#include "mydevice.h"
#include "Object.h"
#include "vector.h"
#include "constant.h"
#include "gen_utils.h"
#include "Mathutils.h"
/* only used for ob.oopsloc at the moment */
#include "DNA_oops_types.h"
@@ -760,11 +759,12 @@ static PyObject *NMVert_getattr( PyObject * self, char *name )
BPy_NMVert *mv = ( BPy_NMVert * ) self;
if( !strcmp( name, "co" ) || !strcmp( name, "loc" ) )
return newVectorObject(mv->co,3,Py_WRAP);
return newVectorProxy( mv->co, 3 );
else if( strcmp( name, "no" ) == 0 )
return newVectorObject(mv->no,3,Py_WRAP);
return newVectorProxy( mv->no, 3 );
else if( strcmp( name, "uvco" ) == 0 )
return newVectorObject(mv->uvco,3,Py_WRAP);
return newVectorProxy( mv->uvco, 3 );
else if( strcmp( name, "index" ) == 0 )
return PyInt_FromLong( mv->index );
else if( strcmp( name, "sel" ) == 0 )

75
source/blender/python/api2_2x/Object.c
View File

@@ -59,7 +59,6 @@
#include "Ipo.h"
#include "Lattice.h"
#include "modules.h"
#include "Mathutils.h"
#include "constant.h"
/* only used for oops location get/set at the moment */
@@ -647,14 +646,14 @@ PyObject *M_Object_New( PyObject * self, PyObject * args )
object->dupend = 100;
/* Gameengine defaults */
object->mass = 1.0f;
object->inertia = 1.0f;
object->formfactor = 0.4f;
object->damping = 0.04f;
object->rdamping = 0.1f;
object->anisotropicFriction[0] = 1.0f;
object->anisotropicFriction[1] = 1.0f;
object->anisotropicFriction[2] = 1.0f;
object->mass = 1.0;
object->inertia = 1.0;
object->formfactor = 0.4;
object->damping = 0.04;
object->rdamping = 0.1;
object->anisotropicFriction[0] = 1.0;
object->anisotropicFriction[1] = 1.0;
object->anisotropicFriction[2] = 1.0;
object->gameflag = OB_PROP;
object->lay = 1; // Layer, by default visible
@@ -1115,20 +1114,21 @@ static PyObject *Object_getDrawType( BPy_Object * self )
static PyObject *Object_getEuler( BPy_Object * self )
{
float eul[3];
EulerObject *eul;
eul[0] = self->object->rot[0];
eul[1] = self->object->rot[1];
eul[2] = self->object->rot[2];
eul = ( EulerObject * ) newEulerObject( NULL );
eul->eul[0] = self->object->rot[0];
eul->eul[1] = self->object->rot[1];
eul->eul[2] = self->object->rot[2];
return ( PyObject * ) newEulerObject( eul, Py_WRAP );
return ( PyObject * ) eul;
}
static PyObject *Object_getInverseMatrix( BPy_Object * self )
{
MatrixObject *inverse =
( MatrixObject * ) newMatrixObject( NULL, 4, 4, Py_NEW);
( MatrixObject * ) newMatrixObject( NULL, 4, 4 );
Mat4Invert( (float ( * )[4])*inverse->matrix, self->object->obmat );
return ( ( PyObject * ) inverse );
@@ -1175,29 +1175,35 @@ static PyObject *Object_getMaterials( BPy_Object * self, PyObject * args )
static PyObject *Object_getMatrix( BPy_Object * self, PyObject * args )
{
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};
PyObject *matrix;
char *space = "worldspace"; /* default to world */
if( !PyArg_ParseTuple( args, "|s", &space ) ) {
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected a string or nothing" ) );
}
//new matrix
matrix = newMatrixObject( NULL, 4, 4 );
if( BLI_streq( space, "worldspace" ) ) { /* Worldspace matrix */
disable_where_script( 1 );
where_is_object( self->object );
disable_where_script( 0 );
Mat4CpyMat4((float ( * )[4]) *( ( MatrixObject * ) matrix )->matrix,
self->object->obmat );
} else if( BLI_streq( space, "localspace" ) ) { /* Localspace matrix */
object_to_mat4( self->object, (float (*)[4])matrix );
return newMatrixObject(matrix,4,4,Py_NEW);
} else if( BLI_streq( space, "old_worldspace" ) ) {
object_to_mat4( self->object,
( float ( * )[4] ) *( ( MatrixObject * ) matrix )->matrix );
/* old behavior, prior to 2.34, check this method's doc string: */
} else if( BLI_streq( space, "old_worldspace" ) ) {
Mat4CpyMat4( (float ( * )[4]) *( ( MatrixObject * ) matrix )->matrix,
self->object->obmat );
} else {
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"wrong parameter, expected nothing or either 'worldspace' (default),\n\
'localspace' or 'old_worldspace'" ) );
}
return newMatrixObject((float*)self->object->obmat,4,4,Py_WRAP);
return matrix;
}
static PyObject *Object_getName( BPy_Object * self )
@@ -1379,7 +1385,7 @@ static PyObject *Object_getBoundBox( BPy_Object * self )
does not have its own memory,
we must create vectors that allocate space */
vector = newVectorObject( NULL, 3, Py_NEW);
vector = newVectorObject( NULL, 3 );
memcpy( ( ( VectorObject * ) vector )->vec,
tmpvec, 3 * sizeof( float ) );
PyList_SET_ITEM( bbox, i, vector );
@@ -1400,7 +1406,7 @@ static PyObject *Object_getBoundBox( BPy_Object * self )
/* create vectors referencing object bounding box coords */
for( i = 0; i < 8; i++ ) {
vector = newVectorObject( vec, 3, Py_WRAP );
vector = newVectorObject( vec, 3 );
PyList_SET_ITEM( bbox, i, vector );
vec += 3;
}
@@ -3917,18 +3923,17 @@ int setupSB(Object* ob){
}
if(ob->soft){
ob->soft->nodemass = 1.0f;
ob->soft->grav = 0.0f;
ob->soft->mediafrict = 0.5f;
ob->soft->rklimit = 0.1f;
ob->soft->goalspring = 0.5f;
ob->soft->goalfrict = 0.0f;
ob->soft->mingoal = 0.0f;
ob->soft->maxgoal = 1.0f;
ob->soft->inspring = 0.5f;
ob->soft->infrict = 0.5f;
ob->soft->defgoal = 0.7f;
ob->soft->nodemass = 1.0;
ob->soft->grav = 0.0;
ob->soft->mediafrict = 0.5;
ob->soft->rklimit = 0.1;
ob->soft->goalspring = 0.5;
ob->soft->goalfrict = 0.0;
ob->soft->mingoal = 0.0;
ob->soft->maxgoal = 1.0;
ob->soft->inspring = 0.5;
ob->soft->infrict = 0.5;
ob->soft->defgoal = 0.7;
return 1;
}
else {

6
source/blender/python/api2_2x/Object.h
View File

@@ -33,6 +33,7 @@
#ifndef EXPP_OBJECT_H
#define EXPP_OBJECT_H
#include <Python.h>
#include <stdio.h>
#include <BDR_editobject.h>
#include <BKE_armature.h>
@@ -59,7 +60,10 @@
#include <DNA_action_types.h>
#include "gen_utils.h"
#include "vector.h"
#include "matrix.h"
#include "euler.h"
#include "quat.h"
/* The Object PyType Object defined in Object.c */
extern PyTypeObject Object_Type;

1
source/blender/python/api2_2x/Types.c
View File

@@ -57,7 +57,6 @@ void types_InitAll( void )
CurNurb_Type.ob_type = &PyType_Type;
Curve_Type.ob_type = &PyType_Type;
Effect_Type.ob_type = &PyType_Type;
Font_Type.ob_type = &PyType_Type;
Image_Type.ob_type = &PyType_Type;
Ipo_Type.ob_type = &PyType_Type;
IpoCurve_Type.ob_type = &PyType_Type;

4
source/blender/python/api2_2x/Window.c
View File

@@ -830,7 +830,7 @@ static PyObject *M_Window_GetViewMatrix( PyObject * self )
viewmat =
( PyObject * ) newMatrixObject( ( float * ) G.vd->viewmat, 4,
4, Py_WRAP );
4 );
if( !viewmat )
return EXPP_ReturnPyObjError( PyExc_MemoryError,
@@ -854,7 +854,7 @@ static PyObject *M_Window_GetPerspMatrix( PyObject * self )
perspmat =
( PyObject * ) newMatrixObject( ( float * ) G.vd->persmat, 4,
4, Py_WRAP);
4 );
if( !perspmat )
return EXPP_ReturnPyObjError( PyExc_MemoryError,

552
source/blender/python/api2_2x/euler.c
View File

@@ -29,385 +29,329 @@
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
#include <BLI_arithb.h>
#include <BKE_utildefines.h>
#include "Mathutils.h"
#include "gen_utils.h"
#include "euler.h"
//-------------------------DOC STRINGS ---------------------------
//doc strings
char Euler_Zero_doc[] = "() - set all values in the euler to 0";
char Euler_Unique_doc[] ="() - sets the euler rotation a unique shortest arc rotation - tests for gimbal lock";
char Euler_ToMatrix_doc[] = "() - returns a rotation matrix representing the euler rotation";
char Euler_ToQuat_doc[] = "() - returns a quaternion representing the euler rotation";
char Euler_Rotate_doc[] = "() - rotate a euler by certain amount around an axis of rotation";
//-----------------------METHOD DEFINITIONS ----------------------
char Euler_Unique_doc[] =
"() - sets the euler rotation a unique shortest arc rotation - tests for gimbal lock";
char Euler_ToMatrix_doc[] =
"() - returns a rotation matrix representing the euler rotation";
char Euler_ToQuat_doc[] =
"() - returns a quaternion representing the euler rotation";
//methods table
struct PyMethodDef Euler_methods[] = {
{"zero", (PyCFunction) Euler_Zero, METH_NOARGS, Euler_Zero_doc},
{"unique", (PyCFunction) Euler_Unique, METH_NOARGS, Euler_Unique_doc},
{"toMatrix", (PyCFunction) Euler_ToMatrix, METH_NOARGS, Euler_ToMatrix_doc},
{"toQuat", (PyCFunction) Euler_ToQuat, METH_NOARGS, Euler_ToQuat_doc},
{"rotate", (PyCFunction) Euler_Rotate, METH_VARARGS, Euler_Rotate_doc},
{"zero", ( PyCFunction ) Euler_Zero, METH_NOARGS,
Euler_Zero_doc},
{"unique", ( PyCFunction ) Euler_Unique, METH_NOARGS,
Euler_Unique_doc},
{"toMatrix", ( PyCFunction ) Euler_ToMatrix, METH_NOARGS,
Euler_ToMatrix_doc},
{"toQuat", ( PyCFunction ) Euler_ToQuat, METH_NOARGS,
Euler_ToQuat_doc},
{NULL, NULL, 0, NULL}
};
//-----------------------------METHODS----------------------------
//----------------------------Euler.toQuat()----------------------
//return a quaternion representation of the euler
PyObject *Euler_ToQuat(EulerObject * self)
/*****************************/
// Euler Python Object
/*****************************/
//euler methods
PyObject *Euler_ToQuat( EulerObject * self )
{
float eul[3];
float quat[4];
float *quat;
int x;
for(x = 0; x < 3; x++) {
eul[x] = self->eul[x] * ((float)Py_PI / 180);
for( x = 0; x < 3; x++ ) {
self->eul[x] *= ( float ) ( Py_PI / 180 );
}
EulToQuat(eul, quat);
if(self->data.blend_data)
return (PyObject *) newQuaternionObject(quat, Py_WRAP);
else
return (PyObject *) newQuaternionObject(quat, Py_NEW);
quat = PyMem_Malloc( 4 * sizeof( float ) );
EulToQuat( self->eul, quat );
for( x = 0; x < 3; x++ ) {
self->eul[x] *= ( float ) ( 180 / Py_PI );
}
return ( PyObject * ) newQuaternionObject( quat );
}
//----------------------------Euler.toMatrix()---------------------
//return a matrix representation of the euler
PyObject *Euler_ToMatrix(EulerObject * self)
PyObject *Euler_ToMatrix( EulerObject * self )
{
float eul[3];
float mat[9] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
float *mat;
int x;
for(x = 0; x < 3; x++) {
eul[x] = self->eul[x] * ((float)Py_PI / 180);
for( x = 0; x < 3; x++ ) {
self->eul[x] *= ( float ) ( Py_PI / 180 );
}
EulToMat3(eul, (float (*)[3]) mat);
if(self->data.blend_data)
return (PyObject *) newMatrixObject(mat, 3, 3 , Py_WRAP);
else
return (PyObject *) newMatrixObject(mat, 3, 3 , Py_NEW);
mat = PyMem_Malloc( 3 * 3 * sizeof( float ) );
EulToMat3( self->eul, ( float ( * )[3] ) mat );
for( x = 0; x < 3; x++ ) {
self->eul[x] *= ( float ) ( 180 / Py_PI );
}
return ( PyObject * ) newMatrixObject( mat, 3, 3 );
}
//----------------------------Euler.unique()-----------------------
//sets the x,y,z values to a unique euler rotation
PyObject *Euler_Unique(EulerObject * self)
PyObject *Euler_Unique( EulerObject * self )
{
double heading, pitch, bank;
double pi2 = Py_PI * 2.0f;
double piO2 = Py_PI / 2.0f;
double Opi2 = 1.0f / pi2;
float heading, pitch, bank;
float pi2 = ( float ) Py_PI * 2.0f;
float piO2 = ( float ) Py_PI / 2.0f;
float Opi2 = 1.0f / pi2;
//radians
heading = self->eul[0] * (float)Py_PI / 180;
pitch = self->eul[1] * (float)Py_PI / 180;
bank = self->eul[2] * (float)Py_PI / 180;
heading = self->eul[0] * ( float ) ( Py_PI / 180 );
pitch = self->eul[1] * ( float ) ( Py_PI / 180 );
bank = self->eul[2] * ( float ) ( Py_PI / 180 );
//wrap heading in +180 / -180
pitch += Py_PI;
pitch -= floor(pitch * Opi2) * pi2;
pitch -= Py_PI;
pitch += ( float ) Py_PI;
pitch -= ( float ) floor( pitch * Opi2 ) * pi2;
pitch -= ( float ) Py_PI;
if(pitch < -piO2) {
pitch = -Py_PI - pitch;
heading += Py_PI;
bank += Py_PI;
} else if(pitch > piO2) {
pitch = Py_PI - pitch;
heading += Py_PI;
bank += Py_PI;
if( pitch < -piO2 ) {
pitch = ( float ) -Py_PI - pitch;
heading += ( float ) Py_PI;
bank += ( float ) Py_PI;
} else if( pitch > piO2 ) {
pitch = ( float ) Py_PI - pitch;
heading += ( float ) Py_PI;
bank += ( float ) Py_PI;
}
//gimbal lock test
if(fabs(pitch) > piO2 - 1e-4) {
if( fabs( pitch ) > piO2 - 1e-4 ) {
heading += bank;
bank = 0.0f;
} else {
bank += Py_PI;
bank -= (floor(bank * Opi2)) * pi2;
bank -= Py_PI;
bank += ( float ) Py_PI;
bank -= ( float ) ( floor( bank * Opi2 ) ) * pi2;
bank -= ( float ) Py_PI;
}
heading += Py_PI;
heading -= (floor(heading * Opi2)) * pi2;
heading -= Py_PI;
heading += ( float ) Py_PI;
heading -= ( float ) ( floor( heading * Opi2 ) ) * pi2;
heading -= ( float ) Py_PI;
//back to degrees
self->eul[0] = heading * 180 / (float)Py_PI;
self->eul[1] = pitch * 180 / (float)Py_PI;
self->eul[2] = bank * 180 / (float)Py_PI;
self->eul[0] = heading * ( float ) ( 180 / Py_PI );
self->eul[1] = pitch * ( float ) ( 180 / Py_PI );
self->eul[2] = bank * ( float ) ( 180 / Py_PI );
return (PyObject*)self;
return EXPP_incr_ret( Py_None );
}
//----------------------------Euler.zero()-------------------------
//sets the euler to 0,0,0
PyObject *Euler_Zero(EulerObject * self)
PyObject *Euler_Zero( EulerObject * self )
{
self->eul[0] = 0.0;
self->eul[1] = 0.0;
self->eul[2] = 0.0;
return (PyObject*)self;
return EXPP_incr_ret( Py_None );
}
//----------------------------Euler.rotate()-----------------------
//rotates a euler a certain amount and returns the result
//should return a unique euler rotation (i.e. no 720 degree pitches :)
PyObject *Euler_Rotate(EulerObject * self, PyObject *args)
static void Euler_dealloc( EulerObject * self )
{
float angle = 0.0f;
char *axis;
int x;
/* since we own this memory... */
PyMem_Free( self->eul );
if(!PyArg_ParseTuple(args, "fs", &angle, &axis)){
return EXPP_ReturnPyObjError(PyExc_TypeError,
"euler.rotate():expected angle (float) and axis (x,y,z)");
}
if(!STREQ3(axis,"x","y","z")){
return EXPP_ReturnPyObjError(PyExc_TypeError,
"euler.rotate(): expected axis to be 'x', 'y' or 'z'");
}
//covert to radians
angle *= ((float)Py_PI / 180);
for(x = 0; x < 3; x++) {
self->eul[x] *= ((float)Py_PI / 180);
}
euler_rot(self->eul, angle, *axis);
//convert back from radians
for(x = 0; x < 3; x++) {
self->eul[x] *= (180 / (float)Py_PI);
}
return (PyObject*)self;
PyObject_DEL( self );
}
//----------------------------dealloc()(internal) ------------------
//free the py_object
static void Euler_dealloc(EulerObject * self)
static PyObject *Euler_getattr( EulerObject * self, char *name )
{
//only free py_data
if(self->data.py_data){
PyMem_Free(self->data.py_data);
if( ELEM3( name[0], 'x', 'y', 'z' ) && name[1] == 0 ) {
return PyFloat_FromDouble( self->eul[name[0] - 'x'] );
}
PyObject_DEL(self);
return Py_FindMethod( Euler_methods, ( PyObject * ) self, name );
}
//----------------------------getattr()(internal) ------------------
//object.attribute access (get)
static PyObject *Euler_getattr(EulerObject * self, char *name)
static int Euler_setattr( EulerObject * self, char *name, PyObject * e )
{
int x;
float val;
if(STREQ(name,"x")){
return PyFloat_FromDouble(self->eul[0]);
}else if(STREQ(name, "y")){
return PyFloat_FromDouble(self->eul[1]);
}else if(STREQ(name, "z")){
return PyFloat_FromDouble(self->eul[2]);
}
if( !PyArg_Parse( e, "f", &val ) )
return EXPP_ReturnIntError( PyExc_TypeError,
"unable to parse float argument\n" );
return Py_FindMethod(Euler_methods, (PyObject *) self, name);
if( ELEM3( name[0], 'x', 'y', 'z' ) && name[1] == 0 ) {
self->eul[name[0] - 'x'] = val;
return 0;
} else
return -1;
}
//----------------------------setattr()(internal) ------------------
//object.attribute access (set)
static int Euler_setattr(EulerObject * self, char *name, PyObject * e)
/* Eulers Sequence methods */
static PyObject *Euler_item( EulerObject * self, int i )
{
PyObject *f = NULL;
if( i < 0 || i >= 3 )
return EXPP_ReturnPyObjError( PyExc_IndexError,
"array index out of range\n" );
f = PyNumber_Float(e);
if(f == NULL) { // parsed item not a number
return EXPP_ReturnIntError(PyExc_TypeError,
"euler.attribute = x: argument not a number\n");
}
if(STREQ(name,"x")){
self->eul[0] = PyFloat_AS_DOUBLE(f);
}else if(STREQ(name, "y")){
self->eul[1] = PyFloat_AS_DOUBLE(f);
}else if(STREQ(name, "z")){
self->eul[2] = PyFloat_AS_DOUBLE(f);
}else{
Py_DECREF(f);
return EXPP_ReturnIntError(PyExc_AttributeError,
"euler.attribute = x: unknown attribute\n");
}
Py_DECREF(f);
return 0;
return Py_BuildValue( "f", self->eul[i] );
}
//----------------------------print object (internal)--------------
//print the object to screen
static PyObject *Euler_repr(EulerObject * self)
static PyObject *Euler_slice( EulerObject * self, int begin, int end )
{
int i;
char buffer[48], str[1024];
BLI_strncpy(str,"[",1024);
for(i = 0; i < 3; i++){
if(i < (2)){
sprintf(buffer, "%.6f, ", self->eul[i]);
strcat(str,buffer);
}else{
sprintf(buffer, "%.6f", self->eul[i]);
strcat(str,buffer);
}
}
strcat(str, "](euler)");
return EXPP_incr_ret(PyString_FromString(str));
}
//---------------------SEQUENCE PROTOCOLS------------------------
//----------------------------len(object)------------------------
//sequence length
static int Euler_len(EulerObject * self)
{
return 3;
}
//----------------------------object[]---------------------------
//sequence accessor (get)
static PyObject *Euler_item(EulerObject * self, int i)
{
if(i < 0 || i >= 3)
return EXPP_ReturnPyObjError(PyExc_IndexError,
"euler[attribute]: array index out of range\n");
return Py_BuildValue("f", self->eul[i]);
}
//----------------------------object[]-------------------------
//sequence accessor (set)
static int Euler_ass_item(EulerObject * self, int i, PyObject * ob)
{
PyObject *f = NULL;
f = PyNumber_Float(ob);
if(f == NULL) { // parsed item not a number
return EXPP_ReturnIntError(PyExc_TypeError,
"euler[attribute] = x: argument not a number\n");
}
if(i < 0 || i >= 3){
Py_DECREF(f);
return EXPP_ReturnIntError(PyExc_IndexError,
"euler[attribute] = x: array assignment index out of range\n");
}
self->eul[i] = PyFloat_AS_DOUBLE(f);
Py_DECREF(f);
return 0;
}
//----------------------------object[z:y]------------------------
//sequence slice (get)
static PyObject *Euler_slice(EulerObject * self, int begin, int end)
{
PyObject *list = NULL;
PyObject *list;
int count;
CLAMP(begin, 0, 3);
CLAMP(end, 0, 3);
begin = MIN2(begin,end);
if( begin < 0 )
begin = 0;
if( end > 3 )
end = 3;
if( begin > end )
begin = end;
list = PyList_New(end - begin);
for(count = begin; count < end; count++) {
PyList_SetItem(list, count - begin,
PyFloat_FromDouble(self->eul[count]));
list = PyList_New( end - begin );
for( count = begin; count < end; count++ ) {
PyList_SetItem( list, count - begin,
PyFloat_FromDouble( self->eul[count] ) );
}
return list;
}
//----------------------------object[z:y]------------------------
//sequence slice (set)
static int Euler_ass_slice(EulerObject * self, int begin, int end,
PyObject * seq)
static int Euler_ass_item( EulerObject * self, int i, PyObject * ob )
{
int i, y, size = 0;
float eul[3];
if( i < 0 || i >= 3 )
return EXPP_ReturnIntError( PyExc_IndexError,
"array assignment index out of range\n" );
CLAMP(begin, 0, 3);
CLAMP(end, 0, 3);
begin = MIN2(begin,end);
if( !PyNumber_Check( ob ) )
return EXPP_ReturnIntError( PyExc_IndexError,
"Euler member must be a number\n" );
size = PySequence_Length(seq);
if(size != (end - begin)){
return EXPP_ReturnIntError(PyExc_TypeError,
"euler[begin:end] = []: size mismatch in slice assignment\n");
}
for (i = 0; i < size; i++) {
PyObject *e, *f;
e = PySequence_GetItem(seq, i);
if (e == NULL) { // Failed to read sequence
return EXPP_ReturnIntError(PyExc_RuntimeError,
"euler[begin:end] = []: unable to read sequence\n");
}
f = PyNumber_Float(e);
if(f == NULL) { // parsed item not a number
Py_DECREF(e);
return EXPP_ReturnIntError(PyExc_TypeError,
"euler[begin:end] = []: sequence argument not a number\n");
}
eul[i] = PyFloat_AS_DOUBLE(f);
EXPP_decr2(f,e);
}
//parsed well - now set in vector
for(y = 0; y < 3; y++){
self->eul[begin + y] = eul[y];
if( !PyFloat_Check( ob ) && !PyInt_Check( ob ) ) {
return EXPP_ReturnIntError( PyExc_TypeError,
"int or float expected\n" );
} else {
self->eul[i] = ( float ) PyFloat_AsDouble( ob );
}
return 0;
}
//-----------------PROTCOL DECLARATIONS--------------------------
static int Euler_ass_slice( EulerObject * self, int begin, int end,
PyObject * seq )
{
int count, z;
if( begin < 0 )
begin = 0;
if( end > 3 )
end = 3;
if( begin > end )
begin = end;
if( !PySequence_Check( seq ) )
return EXPP_ReturnIntError( PyExc_TypeError,
"illegal argument type for built-in operation\n" );
if( PySequence_Length( seq ) != ( end - begin ) )
return EXPP_ReturnIntError( PyExc_TypeError,
"size mismatch in slice assignment\n" );
z = 0;
for( count = begin; count < end; count++ ) {
PyObject *ob = PySequence_GetItem( seq, z );
z++;
if( !PyFloat_Check( ob ) && !PyInt_Check( ob ) ) {
Py_DECREF( ob );
return -1;
} else {
if( !PyArg_Parse( ob, "f", &self->eul[count] ) ) {
Py_DECREF( ob );
return -1;
}
}
}
return 0;
}
static PyObject *Euler_repr( EulerObject * self )
{
int i, maxindex = 3 - 1;
char ftoa[24];
PyObject *str1, *str2;
str1 = PyString_FromString( "[" );
for( i = 0; i < maxindex; i++ ) {
sprintf( ftoa, "%.4f, ", self->eul[i] );
str2 = PyString_FromString( ftoa );
if( !str1 || !str2 )
goto error;
PyString_ConcatAndDel( &str1, str2 );
}
sprintf( ftoa, "%.4f]\n", self->eul[maxindex] );
str2 = PyString_FromString( ftoa );
if( !str1 || !str2 )
goto error;
PyString_ConcatAndDel( &str1, str2 );
if( str1 )
return str1;
error:
Py_XDECREF( str1 );
Py_XDECREF( str2 );
return EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create PyString!\n" );
}
static PySequenceMethods Euler_SeqMethods = {
(inquiry) Euler_len, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(intargfunc) 0, /* sq_repeat */
(intargfunc) Euler_item, /* sq_item */
(intintargfunc) Euler_slice, /* sq_slice */
(intobjargproc) Euler_ass_item, /* sq_ass_item */
(intintobjargproc) Euler_ass_slice, /* sq_ass_slice */
( inquiry ) 0, /* sq_length */
( binaryfunc ) 0, /* sq_concat */
( intargfunc ) 0, /* sq_repeat */
( intargfunc ) Euler_item, /* sq_item */
( intintargfunc ) Euler_slice, /* sq_slice */
( intobjargproc ) Euler_ass_item, /* sq_ass_item */
( intintobjargproc ) Euler_ass_slice, /* sq_ass_slice */
};
//------------------PY_OBECT DEFINITION--------------------------
PyTypeObject euler_Type = {
PyObject_HEAD_INIT(NULL)
0, /*ob_size */
"euler", /*tp_name */
sizeof(EulerObject), /*tp_basicsize */
0, /*tp_itemsize */
(destructor) Euler_dealloc, /*tp_dealloc */
(printfunc) 0, /*tp_print */
(getattrfunc) Euler_getattr, /*tp_getattr */
(setattrfunc) Euler_setattr, /*tp_setattr */
0, /*tp_compare */
(reprfunc) Euler_repr, /*tp_repr */
0, /*tp_as_number */
&Euler_SeqMethods, /*tp_as_sequence */
PyObject_HEAD_INIT( NULL )
0, /*ob_size */
"euler", /*tp_name */
sizeof( EulerObject ), /*tp_basicsize */
0, /*tp_itemsize */
( destructor ) Euler_dealloc, /*tp_dealloc */
( printfunc ) 0, /*tp_print */
( getattrfunc ) Euler_getattr, /*tp_getattr */
( setattrfunc ) Euler_setattr, /*tp_setattr */
0, /*tp_compare */
( reprfunc ) Euler_repr, /*tp_repr */
0, /*tp_as_number */
&Euler_SeqMethods, /*tp_as_sequence */
};
//------------------------newEulerObject (internal)-------------
//creates a new euler object
/*pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
(i.e. it was allocated elsewhere by MEM_mallocN())
pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
(i.e. it must be created here with PyMEM_malloc())*/
PyObject *newEulerObject(float *eul, int type)
PyObject *newEulerObject( float *eul )
{
EulerObject *self;
int x;
euler_Type.ob_type = &PyType_Type;
self = PyObject_NEW(EulerObject, &euler_Type);
self->data.blend_data = NULL;
self->data.py_data = NULL;
if(type == Py_WRAP){
self->data.blend_data = eul;
self->eul = self->data.blend_data;
}else if (type == Py_NEW){
self->data.py_data = PyMem_Malloc(3 * sizeof(float));
self->eul = self->data.py_data;
if(!eul) { //new empty
for(x = 0; x < 3; x++) {
self->eul[x] = 0.0f;
}
}else{
for(x = 0; x < 3; x++){
self->eul[x] = eul[x];
}
self = PyObject_NEW( EulerObject, &euler_Type );
/*
we own the self->eul memory and will free it later.
if we received an input arg, copy to our internal array
*/
self->eul = PyMem_Malloc( 3 * sizeof( float ) );
if( ! self->eul )
return EXPP_ReturnPyObjError( PyExc_MemoryError,
"newEulerObject:PyMem_Malloc failed" );
if( !eul ) {
for( x = 0; x < 3; x++ ) {
self->eul[x] = 0.0f;
}
} else{
for( x = 0; x < 3; x++){
self->eul[x] = eul[x];
}
}else{ //bad type
return NULL;
}
return (PyObject *) EXPP_incr_ret((PyObject *)self);
}
return ( PyObject * ) self;
}

32
source/blender/python/api2_2x/euler.h
View File

@@ -1,3 +1,4 @@
/*
* $Id$
*
@@ -34,28 +35,33 @@
#ifndef EXPP_euler_h
#define EXPP_euler_h
#include "Python.h"
#include "gen_utils.h"
#include "Types.h"
#include <BLI_arithb.h>
#include "quat.h"
#include "matrix.h"
#include "BKE_utildefines.h"
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
/*****************************/
// Euler Python Object
/*****************************/
#define EulerObject_Check(v) ((v)->ob_type == &euler_Type)
typedef struct {
PyObject_VAR_HEAD
struct{
float *py_data; //python managed
float *blend_data; //blender managed
}data;
float *eul; //1D array of data (alias)
PyObject_VAR_HEAD float *eul;
} EulerObject;
/*struct data contains a pointer to the actual data that the
object uses. It can use either PyMem allocated data (which will
be stored in py_data) or be a wrapper for data allocated through
blender (stored in blend_data). This is an either/or struct not both*/
//prototypes
PyObject *newEulerObject( float *eul );
PyObject *Euler_Zero( EulerObject * self );
PyObject *Euler_Unique( EulerObject * self );
PyObject *Euler_ToMatrix( EulerObject * self );
PyObject *Euler_ToQuat( EulerObject * self );
PyObject *Euler_Rotate( EulerObject * self, PyObject *args );
PyObject *newEulerObject( float *eul, int type );
#endif /* EXPP_euler_h */

25
source/blender/python/api2_2x/gen_utils.c
View File

@@ -120,31 +120,6 @@ int EXPP_ReturnIntError( PyObject * type, char *error_msg )
/* Description: This function increments the reference count of the given */
/* Python object (usually Py_None) and returns it. */
/*****************************************************************************/
void EXPP_incr2( PyObject * ob1, PyObject * ob2 )
{
Py_INCREF( ob1 );
Py_INCREF( ob2 );
}
void EXPP_incr3( PyObject * ob1, PyObject * ob2, PyObject * ob3 )
{
Py_INCREF( ob1 );
Py_INCREF( ob2 );
Py_INCREF( ob3 );
}
void EXPP_decr2( PyObject * ob1, PyObject * ob2 )
{
Py_DECREF( ob1 );
Py_DECREF( ob2 );
}
void EXPP_decr3( PyObject * ob1, PyObject * ob2, PyObject * ob3 )
{
Py_DECREF( ob1 );
Py_DECREF( ob2 );
Py_DECREF( ob3 );
}
PyObject *EXPP_incr_ret( PyObject * object )
{

6
source/blender/python/api2_2x/gen_utils.h
View File

@@ -50,8 +50,6 @@
#include <DNA_listBase.h>
#define Py_PI 3.14159265358979323846
#define Py_WRAP 1024
#define Py_NEW 2048
/*
Py_RETURN_NONE
@@ -74,10 +72,6 @@ char *event_to_name( short event );
float EXPP_ClampFloat( float value, float min, float max );
int EXPP_ClampInt( int value, int min, int max );
void EXPP_incr2( PyObject * ob1, PyObject * ob2 );
void EXPP_incr3( PyObject * ob1, PyObject * ob2, PyObject * ob3 );
void EXPP_decr2( PyObject * ob1, PyObject * ob2 );
void EXPP_decr3( PyObject * ob1, PyObject * ob2, PyObject * ob3 );
PyObject *EXPP_incr_ret( PyObject * object );
PyObject *EXPP_incr_ret_True(void);
PyObject *EXPP_incr_ret_False(void);

1570
source/blender/python/api2_2x/matrix.c
View File

@@ -28,804 +28,1010 @@
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
#include <BKE_utildefines.h>
#include <BLI_arithb.h>
#include "Mathutils.h"
#include "gen_utils.h"
#include "matrix.h"
//-------------------------DOC STRINGS ---------------------------
//doc strings
char Matrix_Zero_doc[] = "() - set all values in the matrix to 0";
char Matrix_Identity_doc[] = "() - set the square matrix to it's identity matrix";
char Matrix_Identity_doc[] =
"() - set the square matrix to it's identity matrix";
char Matrix_Transpose_doc[] = "() - set the matrix to it's transpose";
char Matrix_Determinant_doc[] = "() - return the determinant of the matrix";
char Matrix_Invert_doc[] = "() - set the matrix to it's inverse if an inverse is possible";
char Matrix_TranslationPart_doc[] = "() - return a vector encompassing the translation of the matrix";
char Matrix_RotationPart_doc[] = "() - return a vector encompassing the rotation of the matrix";
char Matrix_Invert_doc[] =
"() - set the matrix to it's inverse if an inverse is possible";
char Matrix_TranslationPart_doc[] =
"() - return a vector encompassing the translation of the matrix";
char Matrix_RotationPart_doc[] =
"() - return a vector encompassing the rotation of the matrix";
char Matrix_Resize4x4_doc[] = "() - resize the matrix to a 4x4 square matrix";
char Matrix_toEuler_doc[] = "() - convert matrix to a euler angle rotation";
char Matrix_toQuat_doc[] = "() - convert matrix to a quaternion rotation";
//-----------------------METHOD DEFINITIONS ----------------------
//methods table
struct PyMethodDef Matrix_methods[] = {
{"zero", (PyCFunction) Matrix_Zero, METH_NOARGS, Matrix_Zero_doc},
{"identity", (PyCFunction) Matrix_Identity, METH_NOARGS, Matrix_Identity_doc},
{"transpose", (PyCFunction) Matrix_Transpose, METH_NOARGS, Matrix_Transpose_doc},
{"determinant", (PyCFunction) Matrix_Determinant, METH_NOARGS, Matrix_Determinant_doc},
{"invert", (PyCFunction) Matrix_Invert, METH_NOARGS, Matrix_Invert_doc},
{"translationPart", (PyCFunction) Matrix_TranslationPart, METH_NOARGS, Matrix_TranslationPart_doc},
{"rotationPart", (PyCFunction) Matrix_RotationPart, METH_NOARGS, Matrix_RotationPart_doc},
{"resize4x4", (PyCFunction) Matrix_Resize4x4, METH_NOARGS, Matrix_Resize4x4_doc},
{"toEuler", (PyCFunction) Matrix_toEuler, METH_NOARGS, Matrix_toEuler_doc},
{"toQuat", (PyCFunction) Matrix_toQuat, METH_NOARGS, Matrix_toQuat_doc},
{"zero", ( PyCFunction ) Matrix_Zero, METH_NOARGS,
Matrix_Zero_doc},
{"identity", ( PyCFunction ) Matrix_Identity, METH_NOARGS,
Matrix_Identity_doc},
{"transpose", ( PyCFunction ) Matrix_Transpose, METH_NOARGS,
Matrix_Transpose_doc},
{"determinant", ( PyCFunction ) Matrix_Determinant, METH_NOARGS,
Matrix_Determinant_doc},
{"invert", ( PyCFunction ) Matrix_Invert, METH_NOARGS,
Matrix_Invert_doc},
{"translationPart", ( PyCFunction ) Matrix_TranslationPart,
METH_NOARGS,
Matrix_TranslationPart_doc},
{"rotationPart", ( PyCFunction ) Matrix_RotationPart, METH_NOARGS,
Matrix_RotationPart_doc},
{"resize4x4", ( PyCFunction ) Matrix_Resize4x4, METH_NOARGS,
Matrix_Resize4x4_doc},
{"toEuler", ( PyCFunction ) Matrix_toEuler, METH_NOARGS,
Matrix_toEuler_doc},
{"toQuat", ( PyCFunction ) Matrix_toQuat, METH_NOARGS,
Matrix_toQuat_doc},
{NULL, NULL, 0, NULL}
};
//-----------------------------METHODS----------------------------
//---------------------------Matrix.toQuat() ---------------------
PyObject *Matrix_toQuat(MatrixObject * self)
{
float quat[4];
//must be 3-4 cols, 3-4 rows, square matrix
if(self->colSize < 3 || self->rowSize < 3 || (self->colSize != self->rowSize)) {
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Matrix.toQuat(): inappropriate matrix size - expects 3x3 or 4x4 matrix\n");
}
if(self->colSize == 3){
Mat3ToQuat((float (*)[3])*self->matrix, quat);
}else{
Mat4ToQuat((float (*)[4])*self->matrix, quat);
}
if(self->data.blend_data)
return (PyObject *) newQuaternionObject(quat, Py_WRAP);
else
return (PyObject *) newQuaternionObject(quat, Py_NEW);
}
//---------------------------Matrix.toEuler() --------------------
PyObject *Matrix_toEuler(MatrixObject * self)
/*****************************/
// Matrix Python Object
/*****************************/
PyObject *Matrix_toQuat( MatrixObject * self )
{
float eul[3];
float *quat, *mat;
if( self->colSize < 3 ) {
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"inappropriate matrix size\n" );
} else if( self->colSize > 2 ) { //3 or 4 col
if( self->rowSize < 3 ) //3 or 4 row
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"inappropriate matrix size\n" );
mat = PyMem_Malloc( 3 * 3 * sizeof( float ) );
if( mat == NULL ) {
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating matrix\n\n" ) );
}
mat[0] = self->matrix[0][0];
mat[1] = self->matrix[0][1];
mat[2] = self->matrix[0][2];
mat[3] = self->matrix[1][0];
mat[4] = self->matrix[1][1];
mat[5] = self->matrix[1][2];
mat[6] = self->matrix[2][0];
mat[7] = self->matrix[2][1];
mat[8] = self->matrix[2][2];
}
quat = PyMem_Malloc( 4 * sizeof( float ) );
if( quat == NULL ) {
PyMem_Free( mat );
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating quat\n\n" ) );
}
Mat3ToQuat( ( float ( * )[3] ) mat, quat );
return ( PyObject * ) newQuaternionObject( quat );
}
PyObject *Matrix_toEuler( MatrixObject * self )
{
float *eul, *mat;
int x;
//must be 3-4 cols, 3-4 rows, square matrix
if(self->colSize !=3 || self->rowSize != 3) {
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Matrix.toQuat(): inappropriate matrix size - expects 3x3 matrix\n");
}
Mat3ToEul((float (*)[3])*self->matrix, eul);
//have to convert to degrees
for(x = 0; x < 3; x++) {
eul[x] *= (float) (180 / Py_PI);
if( self->colSize < 3 ) {
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"inappropriate matrix size\n" );
} else if( self->colSize > 2 ) { //3 or 4 col
if( self->rowSize < 3 ) //3 or 4 row
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"inappropriate matrix size\n" );
mat = PyMem_Malloc( 3 * 3 * sizeof( float ) );
if( mat == NULL ) {
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating mat\n\n" ) );
}
mat[0] = self->matrix[0][0];
mat[1] = self->matrix[0][1];
mat[2] = self->matrix[0][2];
mat[3] = self->matrix[1][0];
mat[4] = self->matrix[1][1];
mat[5] = self->matrix[1][2];
mat[6] = self->matrix[2][0];
mat[7] = self->matrix[2][1];
mat[8] = self->matrix[2][2];
}
if(self->data.blend_data)
return (PyObject *) newEulerObject(eul, Py_WRAP);
else
return (PyObject *) newEulerObject(eul, Py_NEW);
eul = PyMem_Malloc( 3 * sizeof( float ) );
if( eul == NULL ) {
PyMem_Free( mat );
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating eul\n\n" ) );
}
Mat3ToEul( ( float ( * )[3] ) mat, eul );
for( x = 0; x < 3; x++ ) {
eul[x] *= ( float ) ( 180 / Py_PI );
}
return ( PyObject * ) newEulerObject( eul );
}
//---------------------------Matrix.resize4x4() ------------------
PyObject *Matrix_Resize4x4(MatrixObject * self)
PyObject *Matrix_Resize4x4( MatrixObject * self )
{
int x, first_row_elem, curr_pos, new_pos, blank_columns, blank_rows;
float *mat;
int x, row, col;
if(self->data.blend_data){
return EXPP_ReturnPyObjError(PyExc_TypeError,
"cannot resize wrapped data - only python matrices\n");
if( self->colSize == 4 && self->rowSize == 4 )
return EXPP_incr_ret( Py_None );
mat = PyMem_Malloc( 4 * 4 * sizeof( float ) );
if( mat == NULL ) {
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating mat\n\n" ) );
}
for( x = 0; x < 16; x++ ) {
mat[x] = 0.0f;
}
self->data.py_data = PyMem_Realloc(self->data.py_data, (sizeof(float) * 16));
if(self->data.py_data == NULL) {
return EXPP_ReturnPyObjError(PyExc_MemoryError,
"matrix.resize4x4(): problem allocating pointer space\n\n");
if( self->colSize == 2 ) { //2x2, 2x3, 2x4
mat[0] = self->matrix[0][0];
mat[1] = self->matrix[0][1];
mat[4] = self->matrix[1][0];
mat[5] = self->matrix[1][1];
if( self->rowSize > 2 ) {
mat[8] = self->matrix[2][0];
mat[9] = self->matrix[2][1];
}
if( self->rowSize > 3 ) {
mat[12] = self->matrix[3][0];
mat[13] = self->matrix[3][1];
}
mat[10] = 1.0f;
mat[15] = 1.0f;
} else if( self->colSize == 3 ) { //3x2, 3x3, 3x4
mat[0] = self->matrix[0][0];
mat[1] = self->matrix[0][1];
mat[2] = self->matrix[0][2];
mat[4] = self->matrix[1][0];
mat[5] = self->matrix[1][1];
mat[6] = self->matrix[1][2];
if( self->rowSize > 2 ) {
mat[8] = self->matrix[2][0];
mat[9] = self->matrix[2][1];
mat[10] = self->matrix[2][2];
}
if( self->rowSize > 3 ) {
mat[12] = self->matrix[3][0];
mat[13] = self->matrix[3][1];
mat[14] = self->matrix[3][2];
}
if( self->rowSize == 2 )
mat[10] = 1.0f;
mat[15] = 1.0f;
} else if( self->colSize == 4 ) { //2x4, 3x4
mat[0] = self->matrix[0][0];
mat[1] = self->matrix[0][1];
mat[2] = self->matrix[0][2];
mat[3] = self->matrix[0][3];
mat[4] = self->matrix[1][0];
mat[5] = self->matrix[1][1];
mat[6] = self->matrix[1][2];
mat[7] = self->matrix[1][3];
if( self->rowSize > 2 ) {
mat[8] = self->matrix[2][0];
mat[9] = self->matrix[2][1];
mat[10] = self->matrix[2][2];
mat[11] = self->matrix[2][3];
}
if( self->rowSize == 2 )
mat[10] = 1.0f;
mat[15] = 1.0f;
}
self->contigPtr = self->data.py_data; //force
self->matrix = PyMem_Realloc(self->matrix, (sizeof(float) * 4));
if(self->matrix == NULL) {
return EXPP_ReturnPyObjError(PyExc_MemoryError,
"matrix.resize4x4(): problem allocating pointer space\n\n");
PyMem_Free( self->matrix );
PyMem_Free( self->contigPtr );
self->contigPtr = PyMem_Malloc( 4 * 4 * sizeof( float ) );
if( self->contigPtr == NULL ) {
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating array space\n\n" ) );
}
//set row pointers
for(x = 0; x < 4; x++) {
self->matrix[x] = self->contigPtr + (x * 4);
self->matrix = PyMem_Malloc( 4 * sizeof( float * ) );
if( self->matrix == NULL ) {
PyMem_Free( self->contigPtr );
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating pointer space\n\n" ) );
}
//move data to new spot in array + clean
for(blank_rows = (4 - self->rowSize); blank_rows > 0; blank_rows--){
for(x = 0; x < 4; x++){
self->contigPtr[(4 * (self->rowSize + (blank_rows - 1))) + x] = 0.0f;
for( x = 0; x < 4; x++ ) {
self->matrix[x] = self->contigPtr + ( x * 4 );
}
for( row = 0; row < 4; row++ ) {
for( col = 0; col < 4; col++ ) {
self->matrix[row][col] = mat[( row * 4 ) + col];
}
}
for(x = 1; x <= self->rowSize; x++){
first_row_elem = (self->colSize * (self->rowSize - x));
curr_pos = (first_row_elem + (self->colSize -1));
new_pos = (4 * (self->rowSize - x )) + (curr_pos - first_row_elem);
for(blank_columns = (4 - self->colSize); blank_columns > 0; blank_columns--){
self->contigPtr[new_pos + blank_columns] = 0.0f;
}
for(curr_pos; curr_pos >= first_row_elem; curr_pos--){
self->contigPtr[new_pos] = self->contigPtr[curr_pos];
new_pos--;
}
}
self->rowSize = 4;
PyMem_Free( mat );
self->colSize = 4;
return (PyObject*)self;
}
//---------------------------Matrix.translationPart() ------------
PyObject *Matrix_TranslationPart(MatrixObject * self)
{
float vec[4];
self->rowSize = 4;
if(self->colSize < 3 && self->rowSize < 4){
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Matrix.translationPart: inappropriate matrix size\n");
return EXPP_incr_ret( Py_None );
}
PyObject *Matrix_TranslationPart( MatrixObject * self )
{
float *vec = NULL;
PyObject *retval;
if( self->colSize < 3 ) {
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"inappropriate matrix size\n" );
} else if( self->colSize > 2 ) { //3 or 4 columns
if( self->rowSize < 4 ) //all 4 rows
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"inappropriate matrix size\n" );
vec = PyMem_Malloc( 3 * sizeof( float ) );
if( vec == NULL ) {
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating vec\n\n" ) );
}
vec[0] = self->matrix[3][0];
vec[1] = self->matrix[3][1];
vec[2] = self->matrix[3][2];
}
vec[0] = self->matrix[3][0];
vec[1] = self->matrix[3][1];
vec[2] = self->matrix[3][2];
return newVectorObject(vec, 3, Py_NEW);
retval = ( PyObject * ) newVectorObject( vec, 3 );
PyMem_Free( vec );
return retval;
}
//---------------------------Matrix.rotationPart() ---------------
PyObject *Matrix_RotationPart(MatrixObject * self)
{
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(self->colSize < 3 && self->rowSize < 3){
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Matrix.rotationPart: inappropriate matrix size\n");
PyObject *Matrix_RotationPart( MatrixObject * self )
{
float *mat;
if( self->colSize < 3 ) {
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"inappropriate matrix size\n" );
} else if( self->colSize > 2 ) { //3 or 4 col
if( self->rowSize < 3 ) //3 or 4 row
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"inappropriate matrix size\n" );
mat = PyMem_Malloc( 3 * 3 * sizeof( float ) );
if( mat == NULL ) {
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating mat\n\n" ) );
}
mat[0] = self->matrix[0][0];
mat[1] = self->matrix[0][1];
mat[2] = self->matrix[0][2];
mat[3] = self->matrix[1][0];
mat[4] = self->matrix[1][1];
mat[5] = self->matrix[1][2];
mat[6] = self->matrix[2][0];
mat[7] = self->matrix[2][1];
mat[8] = self->matrix[2][2];
}
mat[0] = self->matrix[0][0];
mat[1] = self->matrix[0][1];
mat[2] = self->matrix[0][2];
mat[3] = self->matrix[1][0];
mat[4] = self->matrix[1][1];
mat[5] = self->matrix[1][2];
mat[6] = self->matrix[2][0];
mat[7] = self->matrix[2][1];
mat[8] = self->matrix[2][2];
return newMatrixObject(mat, 3, 3, Py_NEW);
return ( PyObject * ) newMatrixObject( mat, 3, 3 );
}
//---------------------------Matrix.invert() ---------------------
PyObject *Matrix_Invert(MatrixObject * self)
{
int x, y, z = 0;
float det = 0.0f;
PyObject *f = NULL;
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(self->rowSize != self->colSize){
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Matrix.invert: only square matrices are supported\n");
}
PyObject *Matrix_Invert( MatrixObject * self )
{
float det;
int x, y, z;
float *mat = NULL;
float t;
if( self->rowSize != self->colSize )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"only square matrices are supported\n" );
//calculate the determinant
f = Matrix_Determinant(self);
det = PyFloat_AS_DOUBLE(f);
if( self->rowSize == 2 ) {
det = Det2x2( self->matrix[0][0], self->matrix[0][1],
self->matrix[1][0], self->matrix[1][1] );
} else if( self->rowSize == 3 ) {
det = Det3x3( self->matrix[0][0], self->matrix[0][1],
self->matrix[0][2], self->matrix[1][0],
self->matrix[1][1], self->matrix[1][2],
self->matrix[2][0], self->matrix[2][1],
self->matrix[2][2] );
} else if( self->rowSize == 4 ) {
det = Det4x4( (float ( * )[4]) *self->matrix );
} else {
return EXPP_ReturnPyObjError( PyExc_StandardError,
"error calculating determinant for inverse()\n" );
}
if( det != 0 ) {
if(det != 0) {
//calculate the classical adjoint
if(self->rowSize == 2) {
if( self->rowSize == 2 ) {
mat = PyMem_Malloc( self->rowSize * self->colSize *
sizeof( float ) );
if( mat == NULL ) {
return ( EXPP_ReturnPyObjError
( PyExc_MemoryError,
"problem allocating mat\n\n" ) );
}
mat[0] = self->matrix[1][1];
mat[1] = -self->matrix[1][0];
mat[2] = -self->matrix[0][1];
mat[3] = self->matrix[0][0];
} else if(self->rowSize == 3) {
Mat3Adj((float (*)[3]) mat,(float (*)[3]) *self->matrix);
} else if(self->rowSize == 4) {
Mat4Adj((float (*)[4]) mat, (float (*)[4]) *self->matrix);
} else if( self->rowSize == 3 ) {
mat = PyMem_Malloc( self->rowSize * self->colSize *
sizeof( float ) );
if( mat == NULL ) {
return ( EXPP_ReturnPyObjError
( PyExc_MemoryError,
"problem allocating mat\n\n" ) );
}
Mat3Adj( ( float ( * )[3] ) mat,( float ( * )[3] ) *self->matrix );
} else if( self->rowSize == 4 ) {
mat = PyMem_Malloc( self->rowSize * self->colSize *
sizeof( float ) );
if( mat == NULL ) {
return ( EXPP_ReturnPyObjError
( PyExc_MemoryError,
"problem allocating mat\n\n" ) );
}
Mat4Adj( ( float ( * )[4] ) mat, ( float ( * )[4] ) *self->matrix );
}
//divide by determinate
for(x = 0; x < (self->rowSize * self->colSize); x++) {
for( x = 0; x < ( self->rowSize * self->colSize ); x++ ) {
mat[x] /= det;
}
//set values
for(x = 0; x < self->rowSize; x++) {
for(y = 0; y < self->colSize; y++) {
z = 0;
for( x = 0; x < self->rowSize; x++ ) {
for( y = 0; y < self->colSize; y++ ) {
self->matrix[x][y] = mat[z];
z++;
}
}
//transpose
Matrix_Transpose(self);
if( self->rowSize == 2 ) {
t = self->matrix[1][0];
self->matrix[1][0] = self->matrix[0][1];
self->matrix[0][1] = t;
/*
Note: is the code below correct?
transposing mat and not copying into self->matrix?
s. swaney 11-oct-2004
*/
} else if( self->rowSize == 3 ) {
Mat3Transp( ( float ( * )[3] ) mat );
} else if( self->rowSize == 4 ) {
Mat4Transp( ( float ( * )[4] ) mat );
}
} else {
printf("Matrix.invert: matrix does not have an inverse\n");
printf( "matrix does not have an inverse - none attempted\n" );
}
return (PyObject*)self;
PyMem_Free( mat );
return EXPP_incr_ret( Py_None );
}
//---------------------------Matrix.determinant() ----------------
PyObject *Matrix_Determinant(MatrixObject * self)
PyObject *Matrix_Determinant( MatrixObject * self )
{
float det = 0.0f;
float det;
if(self->rowSize != self->colSize){
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Matrix.determinant: only square matrices are supported\n");
}
if( self->rowSize != self->colSize )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"only square matrices are supported\n" );
if(self->rowSize == 2) {
det = Det2x2(self->matrix[0][0], self->matrix[0][1],
self->matrix[1][0], self->matrix[1][1]);
} else if(self->rowSize == 3) {
det = Det3x3(self->matrix[0][0], self->matrix[0][1],
self->matrix[0][2], self->matrix[1][0],
self->matrix[1][1], self->matrix[1][2],
self->matrix[2][0], self->matrix[2][1],
self->matrix[2][2]);
if( self->rowSize == 2 ) {
det = Det2x2( self->matrix[0][0], self->matrix[0][1],
self->matrix[1][0], self->matrix[1][1] );
} else if( self->rowSize == 3 ) {
det = Det3x3( self->matrix[0][0], self->matrix[0][1],
self->matrix[0][2], self->matrix[1][0],
self->matrix[1][1], self->matrix[1][2],
self->matrix[2][0], self->matrix[2][1],
self->matrix[2][2] );
} else if( self->rowSize == 4 ) {
det = Det4x4( (float ( * )[4]) *self->matrix );
} else {
det = Det4x4((float (*)[4]) *self->matrix);
return EXPP_ReturnPyObjError( PyExc_StandardError,
"error in determinant()\n" );
}
return PyFloat_FromDouble( (double) det );
}
//---------------------------Matrix.transpose() ------------------
PyObject *Matrix_Transpose(MatrixObject * self)
PyObject *Matrix_Transpose( MatrixObject * self )
{
float t = 0.0f;
float t;
if(self->rowSize != self->colSize){
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Matrix.transpose: only square matrices are supported\n");
}
if( self->rowSize != self->colSize )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"only square matrices are supported\n" );
if(self->rowSize == 2) {
if( self->rowSize == 2 ) {
t = self->matrix[1][0];
self->matrix[1][0] = self->matrix[0][1];
self->matrix[0][1] = t;
} else if(self->rowSize == 3) {
Mat3Transp((float (*)[3])*self->matrix);
} else {
Mat4Transp((float (*)[4])*self->matrix);
}
} else if( self->rowSize == 3 ) {
Mat3Transp( (float ( * )[3])*self->matrix );
} else if( self->rowSize == 4 ) {
Mat4Transp( (float ( * )[4])*self->matrix );
} else
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"unable to transpose matrix\n" ) );
return (PyObject*)self;
return EXPP_incr_ret( Py_None );
}
//---------------------------Matrix.zero() -----------------------
PyObject *Matrix_Zero(MatrixObject * self)
PyObject *Matrix_Zero( MatrixObject * self )
{
int row, col;
for(row = 0; row < self->rowSize; row++) {
for(col = 0; col < self->colSize; col++) {
for( row = 0; row < self->rowSize; row++ ) {
for( col = 0; col < self->colSize; col++ ) {
self->matrix[row][col] = 0.0f;
}
}
return (PyObject*)self;
return EXPP_incr_ret( Py_None );
}
//---------------------------Matrix.identity(() ------------------
PyObject *Matrix_Identity(MatrixObject * self)
{
if(self->rowSize != self->colSize){
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Matrix.identity: only square matrices are supported\n");
}
if(self->rowSize == 2) {
PyObject *Matrix_Identity( MatrixObject * self )
{
if( self->rowSize != self->colSize )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"only square matrices supported\n" ) );
if( self->rowSize == 2 ) {
self->matrix[0][0] = 1.0f;
self->matrix[0][1] = 0.0f;
self->matrix[1][0] = 0.0f;
self->matrix[1][1] = 1.0f;
} else if(self->rowSize == 3) {
Mat3One((float (*)[3]) *self->matrix);
} else {
Mat4One((float (*)[4]) *self->matrix);
} else if( self->rowSize == 3 ) {
Mat3One( ( float ( * )[3] ) *self->matrix );
} else if( self->rowSize == 4 ) {
Mat4One( ( float ( * )[4] ) *self->matrix );
} else
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"unable to create identity matrix\n" ) );
return EXPP_incr_ret( Py_None );
}
static void Matrix_dealloc( MatrixObject * self )
{
PyMem_Free( self->contigPtr );
PyMem_Free( self->matrix );
PyObject_DEL( self );
}
static PyObject *Matrix_getattr( MatrixObject * self, char *name )
{
if( strcmp( name, "rowSize" ) == 0 ) {
return PyInt_FromLong( ( long ) self->rowSize );
} else if( strcmp( name, "colSize" ) == 0 ) {
return PyInt_FromLong( ( long ) self->colSize );
}
return (PyObject*)self;
return Py_FindMethod( Matrix_methods, ( PyObject * ) self, name );
}
//----------------------------dealloc()(internal) ----------------
//free the py_object
static void Matrix_dealloc(MatrixObject * self)
{
Py_XDECREF(self->coerced_object);
PyMem_Free(self->matrix);
//only free py_data
if(self->data.py_data){
PyMem_Free(self->data.py_data);
}
PyObject_DEL(self);
}
//----------------------------getattr()(internal) ----------------
//object.attribute access (get)
static PyObject *Matrix_getattr(MatrixObject * self, char *name)
{
if(STREQ(name, "rowSize")) {
return PyInt_FromLong((long) self->rowSize);
} else if(STREQ(name, "colSize")) {
return PyInt_FromLong((long) self->colSize);
}
return Py_FindMethod(Matrix_methods, (PyObject *) self, name);
}
//----------------------------setattr()(internal) ----------------
//object.attribute access (set)
static int Matrix_setattr(MatrixObject * self, char *name, PyObject * v)
static int Matrix_setattr( MatrixObject * self, char *name, PyObject * v )
{
/* This is not supported. */
return (-1);
return ( -1 );
}
//----------------------------print object (internal)-------------
//print the object to screen
static PyObject *Matrix_repr(MatrixObject * self)
static PyObject *Matrix_repr( MatrixObject * self )
{
PyObject *repr, *str;
int x, y;
char buffer[48], str[1024];
char ftoa[24];
BLI_strncpy(str,"",1024);
for(x = 0; x < self->rowSize; x++){
sprintf(buffer, "[", x);
strcat(str,buffer);
for(y = 0; y < (self->colSize - 1); y++) {
sprintf(buffer, "%.6f, ", self->matrix[x][y]);
strcat(str,buffer);
}
if(x < (self->rowSize-1)){
sprintf(buffer, "%.6f](matrix [row %d])\n", self->matrix[x][y], x);
strcat(str,buffer);
}else{
sprintf(buffer, "%.6f](matrix [row %d])", self->matrix[x][y], x);
strcat(str,buffer);
repr = PyString_FromString( "" );
if( !repr )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"Attribute error in PyMatrix (repr)\n" ) );
for( x = 0; x < self->rowSize; x++ ) {
str = PyString_FromString( "[" );
PyString_ConcatAndDel( &repr, str );
for( y = 0; y < ( self->colSize - 1 ); y++ ) {
sprintf( ftoa, "%.4f, ", self->matrix[x][y] );
str = PyString_FromString( ftoa );
PyString_ConcatAndDel( &repr, str );
}
sprintf( ftoa, "%.4f]\n", self->matrix[x][y] );
str = PyString_FromString( ftoa );
PyString_ConcatAndDel( &repr, str );
}
return EXPP_incr_ret(PyString_FromString(str));
return repr;
}
//---------------------SEQUENCE PROTOCOLS------------------------
//----------------------------len(object)------------------------
//sequence length
static int Matrix_len(MatrixObject * self)
{
return (self->colSize * self->rowSize);
}
//----------------------------object[]---------------------------
//sequence accessor (get)
//the wrapped vector gives direct access to the matrix data
static PyObject *Matrix_item(MatrixObject * self, int i)
{
if(i < 0 || i >= self->rowSize)
return EXPP_ReturnPyObjError(PyExc_IndexError,
"matrix[attribute]: array index out of range\n");
return newVectorObject(self->matrix[i], self->colSize, Py_WRAP);
}
//----------------------------object[]-------------------------
//sequence accessor (set)
static int Matrix_ass_item(MatrixObject * self, int i, PyObject * ob)
{
int y, x, size = 0;
float vec[4];
if(i > self->rowSize || i < 0){
return EXPP_ReturnIntError(PyExc_TypeError,
"matrix[attribute] = x: bad row\n");
}
if(PySequence_Check(ob)){
size = PySequence_Length(ob);
if(size != self->colSize){
return EXPP_ReturnIntError(PyExc_TypeError,
"matrix[attribute] = x: bad sequence size\n");
}
for (x = 0; x < size; x++) {
PyObject *m, *f;
m = PySequence_GetItem(ob, x);
if (m == NULL) { // Failed to read sequence
return EXPP_ReturnIntError(PyExc_RuntimeError,
"matrix[attribute] = x: unable to read sequence\n");
}
f = PyNumber_Float(m);
if(f == NULL) { // parsed item not a number
Py_DECREF(m);
return EXPP_ReturnIntError(PyExc_TypeError,
"matrix[attribute] = x: sequence argument not a number\n");
}
vec[x] = PyFloat_AS_DOUBLE(f);
EXPP_decr2(m, f);
}
//parsed well - now set in matrix
for(y = 0; y < size; y++){
self->matrix[i][y] = vec[y];
}
return 0;
}else{
return EXPP_ReturnIntError(PyExc_TypeError,
"matrix[attribute] = x: expects a sequence of column size\n");
}
}
//----------------------------object[z:y]------------------------
//sequence slice (get)
static PyObject *Matrix_slice(MatrixObject * self, int begin, int end)
{
PyObject *list = NULL;
int count;
CLAMP(begin, 0, self->rowSize);
CLAMP(end, 0, self->rowSize);
begin = MIN2(begin,end);
list = PyList_New(end - begin);
for(count = begin; count < end; count++) {
PyList_SetItem(list, count - begin,
newVectorObject(self->matrix[count], self->colSize, Py_WRAP));
}
return EXPP_incr_ret(list);
}
//----------------------------object[z:y]------------------------
//sequence slice (set)
static int Matrix_ass_slice(MatrixObject * self, int begin, int end,
PyObject * seq)
{
int i, x, y, size, sub_size;
float mat[16];
CLAMP(begin, 0, self->rowSize);
CLAMP(end, 0, self->rowSize);
begin = MIN2(begin,end);
if(PySequence_Check(seq)){
size = PySequence_Length(seq);
if(size != (end - begin)){
return EXPP_ReturnIntError(PyExc_TypeError,
"matrix[begin:end] = []: size mismatch in slice assignment\n");
}
//parse sub items
for (i = 0; i < size; i++) {
//parse each sub sequence
PyObject *subseq;
subseq = PySequence_GetItem(seq, i);
if (subseq == NULL) { // Failed to read sequence
return EXPP_ReturnIntError(PyExc_RuntimeError,
"matrix[begin:end] = []: unable to read sequence\n");
}
if(PySequence_Check(subseq)){
//subsequence is also a sequence
sub_size = PySequence_Length(subseq);
if(sub_size != self->colSize){
return EXPP_ReturnIntError(PyExc_TypeError,
"matrix[begin:end] = []: size mismatch in slice assignment\n");
}
for (y = 0; y < sub_size; y++) {
PyObject *m, *f;
m = PySequence_GetItem(subseq, y);
if (m == NULL) { // Failed to read sequence
return EXPP_ReturnIntError(PyExc_RuntimeError,
"matrix[begin:end] = []: unable to read sequence\n");
}
f = PyNumber_Float(m);
if(f == NULL) { // parsed item not a number
Py_DECREF(m);
return EXPP_ReturnIntError(PyExc_TypeError,
"matrix[begin:end] = []: sequence argument not a number\n");
}
mat[(i * self->colSize) + y] = PyFloat_AS_DOUBLE(f);
EXPP_decr2(f, m);
}
}else{
Py_DECREF(subseq);
return EXPP_ReturnIntError(PyExc_TypeError,
"matrix[begin:end] = []: illegal argument type for built-in operation\n");
}
}
//parsed well - now set in matrix
for(x = 0; x < (size * sub_size); x++){
self->matrix[begin + (int)floor(x / self->colSize)][x % self->colSize] = mat[x];
}
return 0;
}else{
return EXPP_ReturnIntError(PyExc_TypeError,
"matrix[begin:end] = []: illegal argument type for built-in operation\n");
}
}
//------------------------NUMERIC PROTOCOLS----------------------
//------------------------obj + obj------------------------------
static PyObject *Matrix_add(PyObject * m1, PyObject * m2)
{
int x, y;
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};
MatrixObject *mat1 = NULL, *mat2 = NULL;
EXPP_incr2(m1, m2);
mat1 = (MatrixObject*)m1;
mat2 = (MatrixObject*)m2;
if(mat1->coerced_object || mat2->coerced_object){
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Matrix addition: arguments not valid for this operation....\n");
}
if(mat1->rowSize != mat2->rowSize || mat1->colSize != mat2->colSize){
EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Matrix addition: matrices must have the same dimensions for this operation\n");
}
for(x = 0; x < mat1->rowSize; x++) {
for(y = 0; y < mat1->colSize; y++) {
mat[((x * mat1->colSize) + y)] = mat1->matrix[x][y] + mat2->matrix[x][y];
}
}
EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
return newMatrixObject(mat, mat1->rowSize, mat1->colSize, Py_NEW);
}
//------------------------obj - obj------------------------------
//subtraction
static PyObject *Matrix_sub(PyObject * m1, PyObject * m2)
{
int x, y;
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};
MatrixObject *mat1 = NULL, *mat2 = NULL;
EXPP_incr2(m1, m2);
mat1 = (MatrixObject*)m1;
mat2 = (MatrixObject*)m2;
if(mat1->coerced_object || mat2->coerced_object){
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Matrix addition: arguments not valid for this operation....\n");
}
if(mat1->rowSize != mat2->rowSize || mat1->colSize != mat2->colSize){
EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Matrix addition: matrices must have the same dimensions for this operation\n");
}
for(x = 0; x < mat1->rowSize; x++) {
for(y = 0; y < mat1->colSize; y++) {
mat[((x * mat1->colSize) + y)] = mat1->matrix[x][y] - mat2->matrix[x][y];
}
}
EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
return newMatrixObject(mat, mat1->rowSize, mat1->colSize, Py_NEW);
}
//------------------------obj * obj------------------------------
//mulplication
static PyObject *Matrix_mul(PyObject * m1, PyObject * m2)
{
int x, y, z;
float scalar;
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};
double dot = 0.0f;
MatrixObject *mat1 = NULL, *mat2 = NULL;
PyObject *f = NULL, *retObj = NULL;
VectorObject *vec = NULL;
EXPP_incr2(m1, m2);
mat1 = (MatrixObject*)m1;
mat2 = (MatrixObject*)m2;
if(mat1->coerced_object){
if (PyFloat_Check(mat1->coerced_object) ||
PyInt_Check(mat1->coerced_object)){ // FLOAT/INT * MATRIX
f = PyNumber_Float(mat1->coerced_object);
if(f == NULL) { // parsed item not a number
EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Matrix multiplication: arguments not acceptable for this operation\n");
}
scalar = PyFloat_AS_DOUBLE(f);
for(x = 0; x < mat2->rowSize; x++) {
for(y = 0; y < mat2->colSize; y++) {
mat[((x * mat2->colSize) + y)] = scalar * mat2->matrix[x][y];
}
}
EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
return newMatrixObject(mat, mat2->rowSize, mat2->colSize, Py_NEW);
}
}else{
if(mat2->coerced_object){
if(VectorObject_Check(mat2->coerced_object)){ //MATRIX * VECTOR
vec = (VectorObject*)EXPP_incr_ret(mat2->coerced_object);
retObj = column_vector_multiplication(mat1, vec);
EXPP_decr3((PyObject*)mat1, (PyObject*)mat2, (PyObject*)vec);
return retObj;
}else if (PyFloat_Check(mat2->coerced_object) ||
PyInt_Check(mat2->coerced_object)){ // MATRIX * FLOAT/INT
f = PyNumber_Float(mat2->coerced_object);
if(f == NULL) { // parsed item not a number
EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Matrix multiplication: arguments not acceptable for this operation\n");
}
scalar = PyFloat_AS_DOUBLE(f);
for(x = 0; x < mat1->rowSize; x++) {
for(y = 0; y < mat1->colSize; y++) {
mat[((x * mat1->colSize) + y)] = scalar * mat1->matrix[x][y];
}
}
EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
return newMatrixObject(mat, mat1->rowSize, mat1->colSize, Py_NEW);
}
}else{ //MATRIX * MATRIX
if(mat1->colSize != mat2->rowSize){
EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Matrix multiplication: matrix A rowsize must equal matrix B colsize\n");
}
for(x = 0; x < mat1->rowSize; x++) {
for(y = 0; y < mat2->colSize; y++) {
for(z = 0; z < mat1->colSize; z++) {
dot += (mat1->matrix[x][z] * mat2->matrix[z][y]);
}
mat[((x * mat1->rowSize) + y)] = dot;
dot = 0.0f;
}
}
return newMatrixObject(mat, mat1->rowSize, mat2->colSize, Py_NEW);
}
}
EXPP_decr2((PyObject*)mat1, (PyObject*)mat2);
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Matrix multiplication: arguments not acceptable for this operation\n");
}
//------------------------coerce(obj, obj)-----------------------
//coercion of unknown types to type MatrixObject for numeric protocols
/*Coercion() is called whenever a math operation has 2 operands that
it doesn't understand how to evaluate. 2+Matrix for example. We want to
evaluate some of these operations like: (vector * 2), however, for math
to proceed, the unknown operand must be cast to a type that python math will
understand. (e.g. in the case above case, 2 must be cast to a vector and
then call vector.multiply(vector, scalar_cast_as_vector)*/
static int Matrix_coerce(PyObject ** m1, PyObject ** m2)
//no support for matrix[x][y] so have to return by sequence index
//will return a row from the matrix to support previous API
//compatability
static PyObject *Matrix_item( MatrixObject * self, int i )
{
float *vec = NULL;
PyObject *retval;
int 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};
PyObject *coerced = NULL;
if(!MatrixObject_Check(*m2)) {
if(VectorObject_Check(*m2) || PyFloat_Check(*m2) || PyInt_Check(*m2)) {
coerced = EXPP_incr_ret(*m2);
*m2 = newMatrixObject(NULL,3,3,Py_NEW);
((MatrixObject*)*m2)->coerced_object = coerced;
}else{
return EXPP_ReturnIntError(PyExc_TypeError,
"matrix.coerce(): unknown operand - can't coerce for numeric protocols\n");
}
if( i < 0 || i >= self->rowSize )
return EXPP_ReturnPyObjError( PyExc_IndexError,
"matrix row index out of range\n" );
vec = PyMem_Malloc( self->colSize * sizeof( float ) );
if( vec == NULL ) {
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating vec\n\n" ) );
}
Py_INCREF(*m2);
Py_INCREF(*m1);
for( x = 0; x < self->colSize; x++ ) {
vec[x] = self->matrix[i][x];
}
retval =( PyObject * ) newVectorObject( vec, self->colSize );
PyMem_Free( vec );
return retval;
}
static PyObject *Matrix_slice( MatrixObject * self, int begin, int end )
{
PyObject *list;
int count, maxsize, x, y;
maxsize = self->colSize * self->rowSize;
if( begin < 0 )
begin = 0;
if( end > maxsize )
end = maxsize;
if( begin > end )
begin = end;
list = PyList_New( end - begin );
for( count = begin; count < end; count++ ) {
x = ( int ) floor( ( double ) ( count / self->colSize ) );
y = count % self->colSize;
PyList_SetItem( list, count - begin,
PyFloat_FromDouble( self->matrix[x][y] ) );
}
return list;
}
static int Matrix_ass_item( MatrixObject * self, int i, PyObject * ob )
{
int maxsize, x, y;
maxsize = self->colSize * self->rowSize;
if( i < 0 || i >= maxsize )
return EXPP_ReturnIntError( PyExc_IndexError,
"array assignment index out of range\n" );
if( !PyInt_Check( ob ) && !PyFloat_Check( ob ) )
return EXPP_ReturnIntError( PyExc_IndexError,
"matrix member must be a number\n" );
x = ( int ) floor( ( double ) ( i / self->colSize ) );
y = i % self->colSize;
self->matrix[x][y] = ( float ) PyFloat_AsDouble( ob );
return 0;
}
//-----------------PROTCOL DECLARATIONS--------------------------
static PySequenceMethods Matrix_SeqMethods = {
(inquiry) Matrix_len, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(intargfunc) 0, /* sq_repeat */
(intargfunc) Matrix_item, /* sq_item */
(intintargfunc) Matrix_slice, /* sq_slice */
(intobjargproc) Matrix_ass_item, /* sq_ass_item */
(intintobjargproc) Matrix_ass_slice, /* sq_ass_slice */
};
static PyNumberMethods Matrix_NumMethods = {
(binaryfunc) Matrix_add, /* __add__ */
(binaryfunc) Matrix_sub, /* __sub__ */
(binaryfunc) Matrix_mul, /* __mul__ */
(binaryfunc) 0, /* __div__ */
(binaryfunc) 0, /* __mod__ */
(binaryfunc) 0, /* __divmod__ */
(ternaryfunc) 0, /* __pow__ */
(unaryfunc) 0, /* __neg__ */
(unaryfunc) 0, /* __pos__ */
(unaryfunc) 0, /* __abs__ */
(inquiry) 0, /* __nonzero__ */
(unaryfunc) 0, /* __invert__ */
(binaryfunc) 0, /* __lshift__ */
(binaryfunc) 0, /* __rshift__ */
(binaryfunc) 0, /* __and__ */
(binaryfunc) 0, /* __xor__ */
(binaryfunc) 0, /* __or__ */
(coercion) Matrix_coerce, /* __coerce__ */
(unaryfunc) 0, /* __int__ */
(unaryfunc) 0, /* __long__ */
(unaryfunc) 0, /* __float__ */
(unaryfunc) 0, /* __oct__ */
(unaryfunc) 0, /* __hex__ */
};
//------------------PY_OBECT DEFINITION--------------------------
PyTypeObject matrix_Type = {
PyObject_HEAD_INIT(NULL) /* required python macro */
0, /*ob_size */
"Matrix", /*tp_name */
sizeof(MatrixObject), /*tp_basicsize */
0, /*tp_itemsize */
(destructor) Matrix_dealloc, /*tp_dealloc */
(printfunc) 0, /*tp_print */
(getattrfunc) Matrix_getattr, /*tp_getattr */
(setattrfunc) Matrix_setattr, /*tp_setattr */
0, /*tp_compare */
(reprfunc) Matrix_repr, /*tp_repr */
&Matrix_NumMethods, /*tp_as_number */
&Matrix_SeqMethods, /*tp_as_sequence */
};
//------------------------newMatrixObject (internal)-------------
//creates a new matrix object
//self->matrix self->contiguous_ptr (reference to data.xxx)
// [0]------------->[0]
// [1]
// [2]
// [1]------------->[3]
// [4]
// [5]
// ....
//self->matrix[1][1] = self->contiguous_ptr[4] = self->data.xxx_data[4]
/*pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
(i.e. it was allocated elsewhere by MEM_mallocN())
pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
(i.e. it must be created here with PyMEM_malloc())*/
PyObject *newMatrixObject(float *mat, int rowSize, int colSize, int type)
{
MatrixObject *self;
int x, row, col;
//matrix objects can be any 2-4row x 2-4col matrix
if(rowSize < 2 || rowSize > 4 || colSize < 2 || colSize > 4){
return EXPP_ReturnPyObjError(PyExc_RuntimeError,
"matrix(): row and column sizes must be between 2 and 4\n");
static int Matrix_ass_slice( MatrixObject * self, int begin, int end,
PyObject * seq )
{
int count, maxsize, x, y, z;
maxsize = self->colSize * self->rowSize;
if( begin < 0 )
begin = 0;
if( end > maxsize )
end = maxsize;
if( begin > end )
begin = end;
if( !PySequence_Check( seq ) )
return EXPP_ReturnIntError( PyExc_TypeError,
"illegal argument type for built-in operation\n" );
if( PySequence_Length( seq ) != ( end - begin ) )
return EXPP_ReturnIntError( PyExc_TypeError,
"size mismatch in slice assignment\n" );
z = 0;
for( count = begin; count < end; count++ ) {
PyObject *ob = PySequence_GetItem( seq, z );
z++;
if( !PyInt_Check( ob ) && !PyFloat_Check( ob ) )
return EXPP_ReturnIntError( PyExc_IndexError,
"list member must be a number\n" );
x = ( int ) floor( ( double ) ( count / self->colSize ) );
y = count % self->colSize;
if( !PyArg_Parse( ob, "f", &self->matrix[x][y] ) ) {
Py_DECREF( ob );
return -1;
}
}
return 0;
}
static int Matrix_len( MatrixObject * self )
{
return ( self->colSize * self->rowSize );
}
static PyObject *Matrix_add( PyObject * m1, PyObject * m2 )
{
float *mat;
int matSize, rowSize, colSize, x, y;
if( ( !Matrix_CheckPyObject( m1 ) )
|| ( !Matrix_CheckPyObject( m2 ) ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"unsupported type for this operation\n" );
if( ( ( MatrixObject * ) m1 )->flag > 0
|| ( ( MatrixObject * ) m2 )->flag > 0 )
return EXPP_ReturnPyObjError( PyExc_ArithmeticError,
"cannot add scalar to a matrix\n" );
if( ( ( MatrixObject * ) m1 )->rowSize !=
( ( MatrixObject * ) m2 )->rowSize
|| ( ( MatrixObject * ) m1 )->colSize !=
( ( MatrixObject * ) m2 )->colSize )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"matrices must be the same same for this operation\n" );
rowSize = ( ( ( MatrixObject * ) m1 )->rowSize );
colSize = ( ( ( MatrixObject * ) m1 )->colSize );
matSize = rowSize * colSize;
mat = PyMem_Malloc( matSize * sizeof( float ) );
if( mat == NULL ) {
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating mat\n\n" ) );
}
for( x = 0; x < rowSize; x++ ) {
for( y = 0; y < colSize; y++ ) {
mat[( ( x * rowSize ) + y )] =
( ( MatrixObject * ) m1 )->matrix[x][y] +
( ( MatrixObject * ) m2 )->matrix[x][y];
}
}
matrix_Type.ob_type = &PyType_Type;
self = PyObject_NEW(MatrixObject, &matrix_Type);
self->data.blend_data = NULL;
self->data.py_data = NULL;
self->rowSize = rowSize;
self->colSize = colSize;
self->coerced_object = NULL;
return newMatrixObject( mat, rowSize, colSize );
}
if(type == Py_WRAP){
self->data.blend_data = mat;
self->contigPtr = self->data.blend_data;
//create pointer array
self->matrix = PyMem_Malloc(rowSize * sizeof(float *));
if(self->matrix == NULL) { //allocation failure
return EXPP_ReturnPyObjError( PyExc_MemoryError,
"matrix(): problem allocating pointer space\n");
static PyObject *Matrix_sub( PyObject * m1, PyObject * m2 )
{
float *mat;
int matSize, rowSize, colSize, x, y;
if( ( !Matrix_CheckPyObject( m1 ) )
|| ( !Matrix_CheckPyObject( m2 ) ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"unsupported type for this operation\n" );
if( ( ( MatrixObject * ) m1 )->flag > 0
|| ( ( MatrixObject * ) m2 )->flag > 0 )
return EXPP_ReturnPyObjError( PyExc_ArithmeticError,
"cannot subtract a scalar from a matrix\n" );
if( ( ( MatrixObject * ) m1 )->rowSize !=
( ( MatrixObject * ) m2 )->rowSize
|| ( ( MatrixObject * ) m1 )->colSize !=
( ( MatrixObject * ) m2 )->colSize )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"matrices must be the same same for this operation\n" );
rowSize = ( ( ( MatrixObject * ) m1 )->rowSize );
colSize = ( ( ( MatrixObject * ) m1 )->colSize );
matSize = rowSize * colSize;
mat = PyMem_Malloc( matSize * sizeof( float ) );
if( mat == NULL ) {
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating mat\n\n" ) );
}
for( x = 0; x < rowSize; x++ ) {
for( y = 0; y < colSize; y++ ) {
mat[( ( x * rowSize ) + y )] =
( ( MatrixObject * ) m1 )->matrix[x][y] -
( ( MatrixObject * ) m2 )->matrix[x][y];
}
//pointer array points to contigous memory
for(x = 0; x < rowSize; x++) {
self->matrix[x] = self->contigPtr + (x * colSize);
}
return newMatrixObject( mat, rowSize, colSize );
}
static PyObject *Matrix_mul( PyObject * m1, PyObject * m2 )
{
PyObject *retval;
int matSizeV, rowSizeV, colSizeV, rowSizeW, colSizeW, matSizeW, x, y,z;
MatrixObject *matV;
MatrixObject *matW;
float *mat = NULL;
float dot = 0;
if( ( !Matrix_CheckPyObject( m1 ) )
|| ( !Matrix_CheckPyObject( m2 ) ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"unsupported type for this operation\n" );
//get some vars
rowSizeV = ( ( ( MatrixObject * ) m1 )->rowSize );
colSizeV = ( ( ( MatrixObject * ) m1 )->colSize );
matSizeV = rowSizeV * colSizeV;
rowSizeW = ( ( ( MatrixObject * ) m2 )->rowSize );
colSizeW = ( ( ( MatrixObject * ) m2 )->colSize );
matSizeW = rowSizeW * colSizeW;
matV = ( ( MatrixObject * ) m1 );
matW = ( ( MatrixObject * ) m2 );
//coerced int or float for scalar multiplication
if( matW->flag > 1 || matW->flag > 2 ) {
if( rowSizeV != rowSizeW && colSizeV != colSizeW )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"Matrix dimension error during scalar multiplication\n" );
mat = PyMem_Malloc( matSizeV * sizeof( float ) );
if( mat == NULL ) {
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating mat\n\n" ) );
}
}else if (type == Py_NEW){
self->data.py_data = PyMem_Malloc(rowSize * colSize * sizeof(float));
if(self->data.py_data == NULL) { //allocation failure
return EXPP_ReturnPyObjError( PyExc_MemoryError,
"matrix(): problem allocating pointer space\n");
for( x = 0; x < rowSizeV; x++ ) {
for( y = 0; y < colSizeV; y++ ) {
mat[( ( x * rowSizeV ) + y )] =
matV->matrix[x][y] *
matW->matrix[x][y];
}
}
self->contigPtr = self->data.py_data;
//create pointer array
self->matrix = PyMem_Malloc(rowSize * sizeof(float *));
if(self->matrix == NULL) { //allocation failure
PyMem_Free(self->data.py_data);
return EXPP_ReturnPyObjError( PyExc_MemoryError,
"matrix(): problem allocating pointer space\n");
retval = ( PyObject* ) newMatrixObject( mat, rowSizeV, colSizeV );
PyMem_Free( mat );
return retval;
} else if( matW->flag == 0 && matV->flag == 0 ) { //true matrix multiplication
if( colSizeV != rowSizeW ) {
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"Matrix multiplication undefined...\n" );
}
//pointer array points to contigous memory
for(x = 0; x < rowSize; x++) {
self->matrix[x] = self->contigPtr + (x * colSize);
mat = PyMem_Malloc( ( rowSizeV * colSizeW ) *
sizeof( float ) );
if( mat == NULL ) {
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating mat\n\n" ) );
}
//parse
if(mat) { //if a float array passed
for(row = 0; row < rowSize; row++) {
for(col = 0; col < colSize; col++) {
self->matrix[row][col] = mat[(row * colSize) + col];
for( x = 0; x < rowSizeV; x++ ) {
for( y = 0; y < colSizeW; y++ ) {
for( z = 0; z < colSizeV; z++ ) {
dot += ( matV->matrix[x][z] *
matW->matrix[z][y] );
}
mat[( ( x * rowSizeV ) + y )] = dot;
dot = 0;
}
}
retval = ( PyObject* ) newMatrixObject( mat, rowSizeV, colSizeW );
PyMem_Free( mat );
return retval;
} else
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"Error in matrix_mul...\n" );
}
//coercion of unknown types to type MatrixObject for numeric protocols
static int Matrix_coerce( PyObject ** m1, PyObject ** m2 )
{
long *tempI;
double *tempF;
float *mat;
int x, matSize;
matSize =
( ( ( MatrixObject * ) * m1 )->rowSize ) *
( ( ( MatrixObject * ) * m1 )->rowSize );
if( Matrix_CheckPyObject( *m1 ) ) {
if( Matrix_CheckPyObject( *m2 ) ) { //matrix & matrix
Py_INCREF( *m1 );
Py_INCREF( *m2 );
return 0;
} else {
if( VectorObject_Check( *m2 ) ) { //matrix & vector?
printf( "use MatMultVec() for column vector multiplication\n" );
Py_INCREF( *m1 );
return 0;
} else if( PyNumber_Check( *m2 ) ) { //& scalar?
if( PyInt_Check( *m2 ) ) { //it's a int
tempI = PyMem_Malloc( 1 *
sizeof( long ) );
if( tempI == NULL ) {
return ( EXPP_ReturnIntError
( PyExc_MemoryError,
"problem allocating tempI\n\n" ) );
}
*tempI = PyInt_AsLong( *m2 );
mat = PyMem_Malloc( matSize *
sizeof( float ) );
if( mat == NULL ) {
PyMem_Free( tempI );
return ( EXPP_ReturnIntError
( PyExc_MemoryError,
"problem allocating mat\n\n" ) );
}
for( x = 0; x < matSize; x++ ) {
mat[x] = ( float ) *tempI;
}
PyMem_Free( tempI );
*m2 = newMatrixObject( mat,
( ( ( MatrixObject * ) * m1 )->rowSize ), ( ( ( MatrixObject * ) * m1 )->colSize ) );
( ( MatrixObject * ) * m2 )->flag = 1; //int coercion
PyMem_Free( mat );
Py_INCREF( *m1 );
return 0;
} else if( PyFloat_Check( *m2 ) ) { //it's a float
tempF = PyMem_Malloc( 1 *
sizeof
( double ) );
if( tempF == NULL ) {
return ( EXPP_ReturnIntError
( PyExc_MemoryError,
"problem allocating tempF\n\n" ) );
}
*tempF = PyFloat_AsDouble( *m2 );
mat = PyMem_Malloc( matSize *
sizeof( float ) );
if( mat == NULL ) {
PyMem_Free( tempF );
return ( EXPP_ReturnIntError
( PyExc_MemoryError,
"problem allocating mat\n\n" ) );
}
for( x = 0; x < matSize; x++ ) {
mat[x] = ( float ) *tempF;
}
PyMem_Free( tempF );
*m2 = newMatrixObject( mat,
( ( ( MatrixObject * ) * m1 )->rowSize ), ( ( ( MatrixObject * ) * m1 )->colSize ) );
( ( MatrixObject * ) * m2 )->flag = 2; //float coercion
PyMem_Free( mat );
Py_INCREF( *m1 );
return 0;
}
}
} else { //or if no arguments are passed return identity matrix
Matrix_Identity(self);
//unknom2n type or numeric cast failure
printf( "attempting matrix operation m2ith unsupported type...\n" );
Py_INCREF( *m1 );
return 0; //operation m2ill type check
}
}else{ //bad type
return NULL;
} else {
//1st not Matrix
printf( "numeric protocol failure...\n" );
return -1; //this should not occur - fail
}
return (PyObject *) EXPP_incr_ret((PyObject *)self);
return -1;
}
//******************************************************************
// Matrix definition
//******************************************************************
static PySequenceMethods Matrix_SeqMethods = {
( inquiry ) Matrix_len, /* sq_length */
( binaryfunc ) 0, /* sq_concat */
( intargfunc ) 0, /* sq_repeat */
( intargfunc ) Matrix_item, /* sq_item */
( intintargfunc ) Matrix_slice, /* sq_slice */
( intobjargproc ) Matrix_ass_item, /* sq_ass_item */
( intintobjargproc ) Matrix_ass_slice, /* sq_ass_slice */
};
static PyNumberMethods Matrix_NumMethods = {
( binaryfunc ) Matrix_add, /* __add__ */
( binaryfunc ) Matrix_sub, /* __sub__ */
( binaryfunc ) Matrix_mul, /* __mul__ */
( binaryfunc ) 0, /* __div__ */
( binaryfunc ) 0, /* __mod__ */
( binaryfunc ) 0, /* __divmod__ */
( ternaryfunc ) 0, /* __pow__ */
( unaryfunc ) 0, /* __neg__ */
( unaryfunc ) 0, /* __pos__ */
( unaryfunc ) 0, /* __abs__ */
( inquiry ) 0, /* __nonzero__ */
( unaryfunc ) 0, /* __invert__ */
( binaryfunc ) 0, /* __lshift__ */
( binaryfunc ) 0, /* __rshift__ */
( binaryfunc ) 0, /* __and__ */
( binaryfunc ) 0, /* __xor__ */
( binaryfunc ) 0, /* __or__ */
( coercion ) Matrix_coerce, /* __coerce__ */
( unaryfunc ) 0, /* __int__ */
( unaryfunc ) 0, /* __long__ */
( unaryfunc ) 0, /* __float__ */
( unaryfunc ) 0, /* __oct__ */
( unaryfunc ) 0, /* __hex__ */
};
PyTypeObject matrix_Type = {
PyObject_HEAD_INIT( NULL ) /* required python macro */
0, /*ob_size */
"Matrix", /*tp_name */
sizeof( MatrixObject ), /*tp_basicsize */
0, /*tp_itemsize */
( destructor ) Matrix_dealloc, /*tp_dealloc */
( printfunc ) 0, /*tp_print */
( getattrfunc ) Matrix_getattr, /*tp_getattr */
( setattrfunc ) Matrix_setattr, /*tp_setattr */
0, /*tp_compare */
( reprfunc ) Matrix_repr, /*tp_repr */
&Matrix_NumMethods, /*tp_as_number */
&Matrix_SeqMethods, /*tp_as_sequence */
};
//******************************************************************
//Function: newMatrixObject
//******************************************************************
PyObject *newMatrixObject( float *mat, int rowSize, int colSize )
{
MatrixObject *self;
int row, col, x;
if( rowSize < 2 || rowSize > 4 || colSize < 2 || colSize > 4 )
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"row and column sizes must be between 2 and 4\n" ) );
self = PyObject_NEW( MatrixObject, &matrix_Type );
//generate contigous memory space
self->contigPtr = PyMem_Malloc( rowSize * colSize * sizeof( float ) );
if( self->contigPtr == NULL ) {
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating array space\n\n" ) );
}
//create pointer array
self->matrix = PyMem_Malloc( rowSize * sizeof( float * ) );
if( self->matrix == NULL ) {
PyMem_Free( self->contigPtr );
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"problem allocating pointer space\n\n" ) );
}
//pointer array points to contigous memory
for( x = 0; x < rowSize; x++ ) {
self->matrix[x] = self->contigPtr + ( x * colSize );
}
if( mat ) { //if a float array passed
for( row = 0; row < rowSize; row++ ) {
for( col = 0; col < colSize; col++ ) {
self->matrix[row][col] =
mat[( row * colSize ) + col];
}
}
} else { //or if NULL passed
for( row = 0; row < rowSize; row++ ) {
for( col = 0; col < colSize; col++ ) {
self->matrix[row][col] = 0.0f;
}
}
}
//set size vars of matrix
self->rowSize = rowSize;
self->colSize = colSize;
//set coercion flag
self->flag = 0;
return ( ( PyObject * ) self );
}

43
source/blender/python/api2_2x/matrix.h
View File

@@ -33,31 +33,37 @@
#ifndef EXPP_matrix_h
#define EXPP_matrix_h
#define MatrixObject_Check(v) ((v)->ob_type == &matrix_Type)
#include "Python.h"
#include "BLI_arithb.h"
#include "vector.h"
#include "gen_utils.h"
#include "Types.h"
#include "quat.h"
#include "euler.h"
#define Matrix_CheckPyObject(v) ((v)->ob_type == &matrix_Type)
/*****************************/
/* Matrix Python Object */
/*****************************/
typedef float **ptRow;
typedef struct _Matrix {
PyObject_VAR_HEAD
struct{
float *py_data; //python managed
float *blend_data; //blender managed
}data;
ptRow matrix; //ptr to the contigPtr (accessor)
float *contigPtr; //1D array of data (alias)
PyObject_VAR_HEAD /* standard python macro */
ptRow matrix;
float *contigPtr;
int rowSize;
int colSize;
PyObject *coerced_object;
int flag;
//0 - no coercion
//1 - coerced from int
//2 - coerced from float
} MatrixObject;
/*coerced_object is a pointer to the object that it was
coerced from when a dummy vector needs to be created from
the coerce() function for numeric protocol operations*/
/*struct data contains a pointer to the actual data that the
object uses. It can use either PyMem allocated data (which will
be stored in py_data) or be a wrapper for data allocated through
blender (stored in blend_data). This is an either/or struct not both*/
//prototypes
/*****************************************************************************/
/* Python API function prototypes. */
/*****************************************************************************/
PyObject *newMatrixObject( float *mat, int rowSize, int colSize );
PyObject *Matrix_Zero( MatrixObject * self );
PyObject *Matrix_Identity( MatrixObject * self );
PyObject *Matrix_Transpose( MatrixObject * self );
@@ -68,6 +74,5 @@ PyObject *Matrix_RotationPart( MatrixObject * self );
PyObject *Matrix_Resize4x4( MatrixObject * self );
PyObject *Matrix_toEuler( MatrixObject * self );
PyObject *Matrix_toQuat( MatrixObject * self );
PyObject *newMatrixObject(float *mat, int rowSize, int colSize, int type);
#endif /* EXPP_matrix_H */

918
source/blender/python/api2_2x/quat.c
View File

@@ -29,571 +29,545 @@
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
#include <BLI_arithb.h>
#include <BKE_utildefines.h>
#include "Mathutils.h"
#include "gen_utils.h"
#include "quat.h"
//-------------------------DOC STRINGS ---------------------------
char Quaternion_Identity_doc[] = "() - set the quaternion to it's identity (1, vector)";
char Quaternion_Negate_doc[] = "() - set all values in the quaternion to their negative";
//doc strings
char Quaternion_Identity_doc[] =
"() - set the quaternion to it's identity (1, vector)";
char Quaternion_Negate_doc[] =
"() - set all values in the quaternion to their negative";
char Quaternion_Conjugate_doc[] = "() - set the quaternion to it's conjugate";
char Quaternion_Inverse_doc[] = "() - set the quaternion to it's inverse";
char Quaternion_Normalize_doc[] = "() - normalize the vector portion of the quaternion";
char Quaternion_ToEuler_doc[] = "() - return a euler rotation representing the quaternion";
char Quaternion_ToMatrix_doc[] = "() - return a rotation matrix representing the quaternion";
//-----------------------METHOD DEFINITIONS ----------------------
char Quaternion_Normalize_doc[] =
"() - normalize the vector portion of the quaternion";
char Quaternion_ToEuler_doc[] =
"() - return a euler rotation representing the quaternion";
char Quaternion_ToMatrix_doc[] =
"() - return a rotation matrix representing the quaternion";
//methods table
struct PyMethodDef Quaternion_methods[] = {
{"identity", (PyCFunction) Quaternion_Identity, METH_NOARGS, Quaternion_Identity_doc},
{"negate", (PyCFunction) Quaternion_Negate, METH_NOARGS, Quaternion_Negate_doc},
{"conjugate", (PyCFunction) Quaternion_Conjugate, METH_NOARGS, Quaternion_Conjugate_doc},
{"inverse", (PyCFunction) Quaternion_Inverse, METH_NOARGS, Quaternion_Inverse_doc},
{"normalize", (PyCFunction) Quaternion_Normalize, METH_NOARGS, Quaternion_Normalize_doc},
{"toEuler", (PyCFunction) Quaternion_ToEuler, METH_NOARGS, Quaternion_ToEuler_doc},
{"toMatrix", (PyCFunction) Quaternion_ToMatrix, METH_NOARGS, Quaternion_ToMatrix_doc},
{"identity", ( PyCFunction ) Quaternion_Identity, METH_NOARGS,
Quaternion_Identity_doc},
{"negate", ( PyCFunction ) Quaternion_Negate, METH_NOARGS,
Quaternion_Negate_doc},
{"conjugate", ( PyCFunction ) Quaternion_Conjugate, METH_NOARGS,
Quaternion_Conjugate_doc},
{"inverse", ( PyCFunction ) Quaternion_Inverse, METH_NOARGS,
Quaternion_Inverse_doc},
{"normalize", ( PyCFunction ) Quaternion_Normalize, METH_NOARGS,
Quaternion_Normalize_doc},
{"toEuler", ( PyCFunction ) Quaternion_ToEuler, METH_NOARGS,
Quaternion_ToEuler_doc},
{"toMatrix", ( PyCFunction ) Quaternion_ToMatrix, METH_NOARGS,
Quaternion_ToMatrix_doc},
{NULL, NULL, 0, NULL}
};
//-----------------------------METHODS------------------------------
//----------------------------Quaternion.toEuler()------------------
//return the quat as a euler
PyObject *Quaternion_ToEuler(QuaternionObject * self)
/* ****** prototypes ********** */
PyObject *Quaternion_add( PyObject * q1, PyObject * q2 );
PyObject *Quaternion_sub( PyObject * q1, PyObject * q2 );
PyObject *Quaternion_mul( PyObject * q1, PyObject * q2 );
int Quaternion_coerce( PyObject ** q1, PyObject ** q2 );
/*****************************/
// Quaternion Python Object
/*****************************/
PyObject *Quaternion_ToEuler( QuaternionObject * self )
{
float eul[3];
float *eul;
int x;
QuatToEul(self->quat, eul);
for(x = 0; x < 3; x++) {
eul[x] *= (180 / (float)Py_PI);
eul = PyMem_Malloc( 3 * sizeof( float ) );
QuatToEul( self->quat, eul );
for( x = 0; x < 3; x++ ) {
eul[x] *= ( float ) ( 180 / Py_PI );
}
if(self->data.blend_data)
return newEulerObject(eul, Py_WRAP);
else
return newEulerObject(eul, Py_NEW);
return ( PyObject * ) newEulerObject( eul );
}
//----------------------------Quaternion.toMatrix()------------------
//return the quat as a matrix
PyObject *Quaternion_ToMatrix(QuaternionObject * self)
{
float mat[9] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
QuatToMat3(self->quat, (float (*)[3]) mat);
if(self->data.blend_data)
return newMatrixObject(mat, 3, 3, Py_WRAP);
else
return newMatrixObject(mat, 3, 3, Py_NEW);
PyObject *Quaternion_ToMatrix( QuaternionObject * self )
{
float *mat;
mat = PyMem_Malloc( 3 * 3 * sizeof( float ) );
QuatToMat3( self->quat, ( float ( * )[3] ) mat );
return ( PyObject * ) newMatrixObject( mat, 3, 3 );
}
//----------------------------Quaternion.normalize()----------------
//normalize the axis of rotation of [theta,vector]
PyObject *Quaternion_Normalize(QuaternionObject * self)
PyObject *Quaternion_Normalize( QuaternionObject * self )
{
NormalQuat(self->quat);
return (PyObject*)self;
NormalQuat( self->quat );
return EXPP_incr_ret( Py_None );
}
//----------------------------Quaternion.inverse()------------------
//invert the quat
PyObject *Quaternion_Inverse(QuaternionObject * self)
PyObject *Quaternion_Inverse( QuaternionObject * self )
{
double mag = 0.0f;
float mag = 0.0f;
int x;
for(x = 1; x < 4; x++) {
for( x = 1; x < 4; x++ ) {
self->quat[x] = -self->quat[x];
}
for(x = 0; x < 4; x++) {
mag += (self->quat[x] * self->quat[x]);
for( x = 0; x < 4; x++ ) {
mag += ( self->quat[x] * self->quat[x] );
}
mag = sqrt(mag);
for(x = 0; x < 4; x++) {
self->quat[x] /= (mag * mag);
mag = ( float ) sqrt( mag );
for( x = 0; x < 4; x++ ) {
self->quat[x] /= ( mag * mag );
}
return (PyObject*)self;
return EXPP_incr_ret( Py_None );
}
//----------------------------Quaternion.identity()-----------------
//generate the identity quaternion
PyObject *Quaternion_Identity(QuaternionObject * self)
PyObject *Quaternion_Identity( QuaternionObject * self )
{
self->quat[0] = 1.0;
self->quat[1] = 0.0;
self->quat[2] = 0.0;
self->quat[3] = 0.0;
return (PyObject*)self;
return EXPP_incr_ret( Py_None );
}
//----------------------------Quaternion.negate()-------------------
//negate the quat
PyObject *Quaternion_Negate(QuaternionObject * self)
{
int x;
for(x = 0; x < 4; x++) {
self->quat[x] = -self->quat[x];
}
return (PyObject*)self;
}
//----------------------------Quaternion.conjugate()----------------
//negate the vector part
PyObject *Quaternion_Conjugate(QuaternionObject * self)
{
int x;
for(x = 1; x < 4; x++) {
self->quat[x] = -self->quat[x];
}
return (PyObject*)self;
}
//----------------------------dealloc()(internal) ------------------
//free the py_object
static void Quaternion_dealloc(QuaternionObject * self)
{
//only free py_data
if(self->data.py_data){
PyMem_Free(self->data.py_data);
}
PyObject_DEL(self);
}
//----------------------------getattr()(internal) ------------------
//object.attribute access (get)
static PyObject *Quaternion_getattr(QuaternionObject * self, char *name)
{
int x;
double mag = 0.0f;
float vec[3];
if(STREQ(name,"w")){
return PyFloat_FromDouble(self->quat[0]);
}else if(STREQ(name, "x")){
return PyFloat_FromDouble(self->quat[1]);
}else if(STREQ(name, "y")){
return PyFloat_FromDouble(self->quat[2]);
}else if(STREQ(name, "z")){
return PyFloat_FromDouble(self->quat[3]);
PyObject *Quaternion_Negate( QuaternionObject * self )
{
int x;
for( x = 0; x < 4; x++ ) {
self->quat[x] = -self->quat[x];
}
if(STREQ(name, "magnitude")) {
for(x = 0; x < 4; x++) {
return EXPP_incr_ret( Py_None );
}
PyObject *Quaternion_Conjugate( QuaternionObject * self )
{
int x;
for( x = 1; x < 4; x++ ) {
self->quat[x] = -self->quat[x];
}
return EXPP_incr_ret( Py_None );
}
static void Quaternion_dealloc( QuaternionObject * self )
{
PyMem_Free( self->quat );
PyObject_DEL( self );
}
static PyObject *Quaternion_getattr( QuaternionObject * self, char *name )
{
double mag = 0.0f;
float *vec = NULL;
int x;
PyObject *retval;
if( ELEM4( name[0], 'w', 'x', 'y', 'z' ) && name[1] == 0 ) {
return PyFloat_FromDouble( self->quat[name[0] - 'w'] );
}
if( strcmp( name, "magnitude" ) == 0 ) {
for( x = 0; x < 4; x++ ) {
mag += self->quat[x] * self->quat[x];
}
mag = sqrt(mag);
return PyFloat_FromDouble(mag);
mag = ( float ) sqrt( mag );
return PyFloat_FromDouble( mag );
}
if(STREQ(name, "angle")) {
if( strcmp( name, "angle" ) == 0 ) {
mag = self->quat[0];
mag = 2 * (acos(mag));
mag *= (180 / Py_PI);
return PyFloat_FromDouble(mag);
mag = 2 * ( acos( mag ) );
mag *= ( 180 / Py_PI );
return PyFloat_FromDouble( mag );
}
if(STREQ(name, "axis")) {
mag = self->quat[0] * (Py_PI / 180);
mag = 2 * (acos(mag));
mag = sin(mag / 2);
for(x = 0; x < 3; x++) {
vec[x] = (self->quat[x + 1] / mag);
if( strcmp( name, "axis" ) == 0 ) {
mag = ( double ) ( self->quat[0] * ( Py_PI / 180 ) );
mag = 2 * ( acos( mag ) );
mag = sin( mag / 2 );
vec = PyMem_Malloc( 3 * sizeof( float ) );
for( x = 0; x < 3; x++ ) {
vec[x] = ( self->quat[x + 1] / ( ( float ) ( mag ) ) );
}
Normalise(vec);
return (PyObject *) newVectorObject(vec, 3, Py_NEW);
Normalise( vec );
retval = ( PyObject * ) newVectorObject( vec, 3 );
PyMem_Free( vec );
return retval;
}
return Py_FindMethod(Quaternion_methods, (PyObject *) self, name);
return Py_FindMethod( Quaternion_methods, ( PyObject * ) self, name );
}
//----------------------------setattr()(internal) ------------------
//object.attribute access (set)
static int Quaternion_setattr(QuaternionObject * self, char *name, PyObject * q)
static int Quaternion_setattr( QuaternionObject * self, char *name,
PyObject * v )
{
PyObject *f = NULL;
float val;
f = PyNumber_Float(q);
if(f == NULL) { // parsed item not a number
return EXPP_ReturnIntError(PyExc_TypeError,
"quaternion.attribute = x: argument not a number\n");
if( !PyFloat_Check( v ) && !PyInt_Check( v ) ) {
return EXPP_ReturnIntError( PyExc_TypeError,
"int or float expected\n" );
} else {
if( !PyArg_Parse( v, "f", &val ) )
return EXPP_ReturnIntError( PyExc_TypeError,
"unable to parse float argument\n" );
}
if( ELEM4( name[0], 'w', 'x', 'y', 'z' ) && name[1] == 0 ) {
self->quat[name[0] - 'w'] = val;
} else
return -1;
if(STREQ(name,"w")){
self->quat[0] = PyFloat_AS_DOUBLE(f);
}else if(STREQ(name, "x")){
self->quat[1] = PyFloat_AS_DOUBLE(f);
}else if(STREQ(name, "y")){
self->quat[2] = PyFloat_AS_DOUBLE(f);
}else if(STREQ(name, "z")){
self->quat[3] = PyFloat_AS_DOUBLE(f);
}else{
Py_DECREF(f);
return EXPP_ReturnIntError(PyExc_AttributeError,
"quaternion.attribute = x: unknown attribute\n");
}
Py_DECREF(f);
return 0;
}
//----------------------------print object (internal)--------------
//print the object to screen
static PyObject *Quaternion_repr(QuaternionObject * self)
/* Quaternions Sequence methods */
static PyObject *Quaternion_item( QuaternionObject * self, int i )
{
int i;
char buffer[48], str[1024];
if( i < 0 || i >= 4 )
return EXPP_ReturnPyObjError( PyExc_IndexError,
"array index out of range\n" );
BLI_strncpy(str,"[",1024);
for(i = 0; i < 4; i++){
if(i < (3)){
sprintf(buffer, "%.6f, ", self->quat[i]);
strcat(str,buffer);
}else{
sprintf(buffer, "%.6f", self->quat[i]);
strcat(str,buffer);
}
}
strcat(str, "](quaternion)");
return EXPP_incr_ret(PyString_FromString(str));
return Py_BuildValue( "f", self->quat[i] );
}
//---------------------SEQUENCE PROTOCOLS------------------------
//----------------------------len(object)------------------------
//sequence length
static int Quaternion_len(QuaternionObject * self)
{
return 4;
}
//----------------------------object[]---------------------------
//sequence accessor (get)
static PyObject *Quaternion_item(QuaternionObject * self, int i)
{
if(i < 0 || i >= 4)
return EXPP_ReturnPyObjError(PyExc_IndexError,
"quaternion[attribute]: array index out of range\n");
return Py_BuildValue("f", self->quat[i]);
}
//----------------------------object[]-------------------------
//sequence accessor (set)
static int Quaternion_ass_item(QuaternionObject * self, int i, PyObject * ob)
static PyObject *Quaternion_slice( QuaternionObject * self, int begin,
int end )
{
PyObject *f = NULL;
f = PyNumber_Float(ob);
if(f == NULL) { // parsed item not a number
return EXPP_ReturnIntError(PyExc_TypeError,
"quaternion[attribute] = x: argument not a number\n");
}
if(i < 0 || i >= 4){
Py_DECREF(f);
return EXPP_ReturnIntError(PyExc_IndexError,
"quaternion[attribute] = x: array assignment index out of range\n");
}
self->quat[i] = PyFloat_AS_DOUBLE(f);
Py_DECREF(f);
return 0;
}
//----------------------------object[z:y]------------------------
//sequence slice (get)
static PyObject *Quaternion_slice(QuaternionObject * self, int begin, int end)
{
PyObject *list = NULL;
PyObject *list;
int count;
CLAMP(begin, 0, 4);
CLAMP(end, 0, 4);
begin = MIN2(begin,end);
if( begin < 0 )
begin = 0;
if( end > 4 )
end = 4;
if( begin > end )
begin = end;
list = PyList_New(end - begin);
for(count = begin; count < end; count++) {
PyList_SetItem(list, count - begin,
PyFloat_FromDouble(self->quat[count]));
list = PyList_New( end - begin );
for( count = begin; count < end; count++ ) {
PyList_SetItem( list, count - begin,
PyFloat_FromDouble( self->quat[count] ) );
}
return list;
}
//----------------------------object[z:y]------------------------
//sequence slice (set)
static int Quaternion_ass_slice(QuaternionObject * self, int begin, int end,
PyObject * seq)
static int Quaternion_ass_item( QuaternionObject * self, int i, PyObject * ob )
{
int i, y, size = 0;
float quat[4];
if( i < 0 || i >= 4 )
return EXPP_ReturnIntError( PyExc_IndexError,
"array assignment index out of range\n" );
if( !PyNumber_Check( ob ) )
return EXPP_ReturnIntError( PyExc_IndexError,
"Quaternion member must be a number\n" );
CLAMP(begin, 0, 4);
CLAMP(end, 0, 4);
begin = MIN2(begin,end);
size = PySequence_Length(seq);
if(size != (end - begin)){
return EXPP_ReturnIntError(PyExc_TypeError,
"quaternion[begin:end] = []: size mismatch in slice assignment\n");
}
for (i = 0; i < size; i++) {
PyObject *q, *f;
q = PySequence_GetItem(seq, i);
if (q == NULL) { // Failed to read sequence
return EXPP_ReturnIntError(PyExc_RuntimeError,
"quaternion[begin:end] = []: unable to read sequence\n");
}
f = PyNumber_Float(q);
if(f == NULL) { // parsed item not a number
Py_DECREF(q);
return EXPP_ReturnIntError(PyExc_TypeError,
"quaternion[begin:end] = []: sequence argument not a number\n");
}
quat[i] = PyFloat_AS_DOUBLE(f);
EXPP_decr2(f,q);
}
//parsed well - now set in vector
for(y = 0; y < size; y++){
self->quat[begin + y] = quat[y];
if( !PyFloat_Check( ob ) && !PyInt_Check( ob ) ) {
return EXPP_ReturnIntError( PyExc_TypeError,
"int or float expected\n" );
} else {
self->quat[i] = ( float ) PyFloat_AsDouble( ob );
}
return 0;
}
//------------------------NUMERIC PROTOCOLS----------------------
//------------------------obj + obj------------------------------
//addition
static PyObject *Quaternion_add(PyObject * q1, PyObject * q2)
static int Quaternion_ass_slice( QuaternionObject * self, int begin, int end,
PyObject * seq )
{
int x;
float quat[4];
QuaternionObject *quat1 = NULL, *quat2 = NULL;
int count, z;
EXPP_incr2(q1, q2);
quat1 = (QuaternionObject*)q1;
quat2 = (QuaternionObject*)q2;
if( begin < 0 )
begin = 0;
if( end > 4 )
end = 4;
if( begin > end )
begin = end;
if(quat1->coerced_object || quat2->coerced_object){
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Quaternion addition: arguments not valid for this operation....\n");
}
for(x = 0; x < 4; x++) {
quat[x] = quat1->quat[x] + quat2->quat[x];
}
if( !PySequence_Check( seq ) )
return EXPP_ReturnIntError( PyExc_TypeError,
"illegal argument type for built-in operation\n" );
if( PySequence_Length( seq ) != ( end - begin ) )
return EXPP_ReturnIntError( PyExc_TypeError,
"size mismatch in slice assignment\n" );
EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
return (PyObject *) newQuaternionObject(quat, Py_NEW);
}
//------------------------obj - obj------------------------------
//subtraction
static PyObject *Quaternion_sub(PyObject * q1, PyObject * q2)
{
int x;
float quat[4];
QuaternionObject *quat1 = NULL, *quat2 = NULL;
z = 0;
for( count = begin; count < end; count++ ) {
PyObject *ob = PySequence_GetItem( seq, z );
z++;
EXPP_incr2(q1, q2);
quat1 = (QuaternionObject*)q1;
quat2 = (QuaternionObject*)q2;
if(quat1->coerced_object || quat2->coerced_object){
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Quaternion addition: arguments not valid for this operation....\n");
}
for(x = 0; x < 4; x++) {
quat[x] = quat1->quat[x] - quat2->quat[x];
}
EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
return (PyObject *) newQuaternionObject(quat, Py_NEW);
}
//------------------------obj * obj------------------------------
//mulplication
static PyObject *Quaternion_mul(PyObject * q1, PyObject * q2)
{
int x;
float quat[4], scalar, newVec[3];
double dot = 0.0f;
QuaternionObject *quat1 = NULL, *quat2 = NULL;
PyObject *f = NULL;
VectorObject *vec = NULL;
EXPP_incr2(q1, q2);
quat1 = (QuaternionObject*)q1;
quat2 = (QuaternionObject*)q2;
if(quat1->coerced_object){
if (PyFloat_Check(quat1->coerced_object) ||
PyInt_Check(quat1->coerced_object)){ // FLOAT/INT * QUAT
f = PyNumber_Float(quat1->coerced_object);
if(f == NULL) { // parsed item not a number
EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Quaternion multiplication: arguments not acceptable for this operation\n");
if( !PyFloat_Check( ob ) && !PyInt_Check( ob ) ) {
Py_DECREF( ob );
return -1;
} else {
if( !PyArg_Parse( ob, "f", &self->quat[count] ) ) {
Py_DECREF( ob );
return -1;
}
scalar = PyFloat_AS_DOUBLE(f);
for(x = 0; x < 4; x++) {
quat[x] = quat2->quat[x] * scalar;
}
EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
return (PyObject *) newQuaternionObject(quat, Py_NEW);
}
}else{
if(quat2->coerced_object){
if (PyFloat_Check(quat2->coerced_object) ||
PyInt_Check(quat2->coerced_object)){ // QUAT * FLOAT/INT
f = PyNumber_Float(quat2->coerced_object);
if(f == NULL) { // parsed item not a number
EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Quaternion multiplication: arguments not acceptable for this operation\n");
}
scalar = PyFloat_AS_DOUBLE(f);
for(x = 0; x < 4; x++) {
quat[x] = quat1->quat[x] * scalar;
}
EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
return (PyObject *) newQuaternionObject(quat, Py_NEW);
}else if(VectorObject_Check(quat2->coerced_object)){ //QUAT * VEC
vec = (VectorObject*)EXPP_incr_ret(quat2->coerced_object);
if(vec->size != 3){
EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Quaternion multiplication: only 3D vector rotations currently supported\n");
}
newVec[0] = quat1->quat[0]*quat1->quat[0]*vec->vec[0] +
2*quat1->quat[2]*quat1->quat[0]*vec->vec[2] -
2*quat1->quat[3]*quat1->quat[0]*vec->vec[1] +
quat1->quat[1]*quat1->quat[1]*vec->vec[0] +
2*quat1->quat[2]*quat1->quat[1]*vec->vec[1] +
2*quat1->quat[3]*quat1->quat[1]*vec->vec[2] -
quat1->quat[3]*quat1->quat[3]*vec->vec[0] -
quat1->quat[2]*quat1->quat[2]*vec->vec[0];
newVec[1] = 2*quat1->quat[1]*quat1->quat[2]*vec->vec[0] +
quat1->quat[2]*quat1->quat[2]*vec->vec[1] +
2*quat1->quat[3]*quat1->quat[2]*vec->vec[2] +
2*quat1->quat[0]*quat1->quat[3]*vec->vec[0] -
quat1->quat[3]*quat1->quat[3]*vec->vec[1] +
quat1->quat[0]*quat1->quat[0]*vec->vec[1] -
2*quat1->quat[1]*quat1->quat[0]*vec->vec[2] -
quat1->quat[1]*quat1->quat[1]*vec->vec[1];
newVec[2] = 2*quat1->quat[1]*quat1->quat[3]*vec->vec[0] +
2*quat1->quat[2]*quat1->quat[3]*vec->vec[1] +
quat1->quat[3]*quat1->quat[3]*vec->vec[2] -
2*quat1->quat[0]*quat1->quat[2]*vec->vec[0] -
quat1->quat[2]*quat1->quat[2]*vec->vec[2] +
2*quat1->quat[0]*quat1->quat[1]*vec->vec[1] -
quat1->quat[1]*quat1->quat[1]*vec->vec[2] +
quat1->quat[0]*quat1->quat[0]*vec->vec[2];
EXPP_decr3((PyObject*)quat1, (PyObject*)quat2, (PyObject*)vec);
return newVectorObject(newVec,3,Py_NEW);
}
}else{ //QUAT * QUAT (dot product)
for(x = 0; x < 4; x++) {
dot += quat1->quat[x] * quat1->quat[x];
}
EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
return PyFloat_FromDouble(dot);
}
}
EXPP_decr2((PyObject*)quat1, (PyObject*)quat2);
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Quaternion multiplication: arguments not acceptable for this operation\n");
return 0;
}
//------------------------coerce(obj, obj)-----------------------
static PyObject *Quaternion_repr( QuaternionObject * self )
{
int i, maxindex = 4 - 1;
char ftoa[24];
PyObject *str1, *str2;
str1 = PyString_FromString( "[" );
for( i = 0; i < maxindex; i++ ) {
sprintf( ftoa, "%.4f, ", self->quat[i] );
str2 = PyString_FromString( ftoa );
if( !str1 || !str2 )
goto error;
PyString_ConcatAndDel( &str1, str2 );
}
sprintf( ftoa, "%.4f]", self->quat[maxindex] );
str2 = PyString_FromString( ftoa );
if( !str1 || !str2 )
goto error;
PyString_ConcatAndDel( &str1, str2 );
if( str1 )
return str1;
error:
Py_XDECREF( str1 );
Py_XDECREF( str2 );
return EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create PyString!\n" );
}
PyObject *Quaternion_add( PyObject * q1, PyObject * q2 )
{
float *quat = NULL;
PyObject *retval;
int x;
if( ( !QuaternionObject_Check( q1 ) )
|| ( !QuaternionObject_Check( q2 ) ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"unsupported type for this operation\n" );
if( ( ( QuaternionObject * ) q1 )->flag > 0
|| ( ( QuaternionObject * ) q2 )->flag > 0 )
return EXPP_ReturnPyObjError( PyExc_ArithmeticError,
"cannot add a scalar and a quat\n" );
quat = PyMem_Malloc( 4 * sizeof( float ) );
for( x = 0; x < 4; x++ ) {
quat[x] =
( ( ( QuaternionObject * ) q1 )->quat[x] ) +
( ( ( QuaternionObject * ) q2 )->quat[x] );
}
retval = ( PyObject * ) newQuaternionObject( quat );
PyMem_Free( quat );
return retval;
}
PyObject *Quaternion_sub( PyObject * q1, PyObject * q2 )
{
float *quat = NULL;
PyObject *retval;
int x;
if( ( !QuaternionObject_Check( q1 ) )
|| ( !QuaternionObject_Check( q2 ) ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"unsupported type for this operation\n" );
if( ( ( QuaternionObject * ) q1 )->flag > 0
|| ( ( QuaternionObject * ) q2 )->flag > 0 )
return EXPP_ReturnPyObjError( PyExc_ArithmeticError,
"cannot subtract a scalar and a quat\n" );
quat = PyMem_Malloc( 4 * sizeof( float ) );
for( x = 0; x < 4; x++ ) {
quat[x] =
( ( ( QuaternionObject * ) q1 )->quat[x] ) -
( ( ( QuaternionObject * ) q2 )->quat[x] );
}
retval = ( PyObject * ) newQuaternionObject( quat );
PyMem_Free( quat );
return retval;
}
PyObject *Quaternion_mul( PyObject * q1, PyObject * q2 )
{
float *quat = NULL;
PyObject *retval;
int x;
if( ( !QuaternionObject_Check( q1 ) )
|| ( !QuaternionObject_Check( q2 ) ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"unsupported type for this operation\n" );
if( ( ( QuaternionObject * ) q1 )->flag == 0
&& ( ( QuaternionObject * ) q2 )->flag == 0 )
return EXPP_ReturnPyObjError( PyExc_ArithmeticError,
"please use the dot or cross product to multiply quaternions\n" );
quat = PyMem_Malloc( 4 * sizeof( float ) );
//scalar mult by quat
for( x = 0; x < 4; x++ ) {
quat[x] =
( ( QuaternionObject * ) q1 )->quat[x] *
( ( QuaternionObject * ) q2 )->quat[x];
}
retval = ( PyObject * ) newQuaternionObject( quat );
PyMem_Free( quat );
return retval;
}
//coercion of unknown types to type QuaternionObject for numeric protocols
/*Coercion() is called whenever a math operation has 2 operands that
it doesn't understand how to evaluate. 2+Matrix for example. We want to
evaluate some of these operations like: (vector * 2), however, for math
to proceed, the unknown operand must be cast to a type that python math will
understand. (e.g. in the case above case, 2 must be cast to a vector and
then call vector.multiply(vector, scalar_cast_as_vector)*/
static int Quaternion_coerce(PyObject ** q1, PyObject ** q2)
int Quaternion_coerce( PyObject ** q1, PyObject ** q2 )
{
long *tempI = NULL;
double *tempF = NULL;
float *quat = NULL;
int x;
float quat[4];
PyObject *coerced = NULL;
if(!QuaternionObject_Check(*q2)) {
if(VectorObject_Check(*q2) || PyFloat_Check(*q2) || PyInt_Check(*q2)) {
coerced = EXPP_incr_ret(*q2);
*q2 = newQuaternionObject(NULL,Py_NEW);
((QuaternionObject*)*q2)->coerced_object = coerced;
}else{
return EXPP_ReturnIntError(PyExc_TypeError,
"quaternion.coerce(): unknown operand - can't coerce for numeric protocols\n");
if( QuaternionObject_Check( *q1 ) ) {
if( QuaternionObject_Check( *q2 ) ) { //two Quaternions
Py_INCREF( *q1 );
Py_INCREF( *q2 );
return 0;
} else {
if( PyNumber_Check( *q2 ) ) {
if( PyInt_Check( *q2 ) ) { //cast scalar to Quaternion
tempI = PyMem_Malloc( 1 *
sizeof( long ) );
*tempI = PyInt_AsLong( *q2 );
quat = PyMem_Malloc( 4 *
sizeof( float ) );
for( x = 0; x < 4; x++ ) {
quat[x] = ( float ) *tempI;
}
PyMem_Free( tempI );
*q2 = newQuaternionObject( quat );
PyMem_Free( quat );
( ( QuaternionObject * ) * q2 )->flag = 1; //int coercion
Py_INCREF( *q1 ); /* fixme: is this needed? */
return 0;
} else if( PyFloat_Check( *q2 ) ) { //cast scalar to Quaternion
tempF = PyMem_Malloc( 1 *
sizeof
( double ) );
*tempF = PyFloat_AsDouble( *q2 );
quat = PyMem_Malloc( 4 *
sizeof( float ) );
for( x = 0; x < 4; x++ ) {
quat[x] = ( float ) *tempF;
}
PyMem_Free( tempF );
*q2 = newQuaternionObject( quat );
PyMem_Free( quat );
( ( QuaternionObject * ) * q2 )->flag = 2; //float coercion
Py_INCREF( *q1 ); /* fixme: is this needed? */
return 0;
}
}
//unknown type or numeric cast failure
printf( "attempting quaternion operation with unsupported type...\n" );
Py_INCREF( *q1 ); /* fixme: is this needed? */
return 0; //operation will type check
}
} else {
printf( "numeric protocol failure...\n" );
return -1; //this should not occur - fail
}
EXPP_incr2(*q1, *q2);
return 0;
return -1;
}
//-----------------PROTCOL DECLARATIONS--------------------------
static PySequenceMethods Quaternion_SeqMethods = {
(inquiry) Quaternion_len, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(intargfunc) 0, /* sq_repeat */
(intargfunc) Quaternion_item, /* sq_item */
(intintargfunc) Quaternion_slice, /* sq_slice */
(intobjargproc) Quaternion_ass_item, /* sq_ass_item */
(intintobjargproc) Quaternion_ass_slice, /* sq_ass_slice */
( inquiry ) 0, /* sq_length */
( binaryfunc ) 0, /* sq_concat */
( intargfunc ) 0, /* sq_repeat */
( intargfunc ) Quaternion_item, /* sq_item */
( intintargfunc ) Quaternion_slice, /* sq_slice */
( intobjargproc ) Quaternion_ass_item, /* sq_ass_item */
( intintobjargproc ) Quaternion_ass_slice, /* sq_ass_slice */
};
static PyNumberMethods Quaternion_NumMethods = {
(binaryfunc) Quaternion_add, /* __add__ */
(binaryfunc) Quaternion_sub, /* __sub__ */
(binaryfunc) Quaternion_mul, /* __mul__ */
(binaryfunc) 0, /* __div__ */
(binaryfunc) 0, /* __mod__ */
(binaryfunc) 0, /* __divmod__ */
(ternaryfunc) 0, /* __pow__ */
(unaryfunc) 0, /* __neg__ */
(unaryfunc) 0, /* __pos__ */
(unaryfunc) 0, /* __abs__ */
(inquiry) 0, /* __nonzero__ */
(unaryfunc) 0, /* __invert__ */
(binaryfunc) 0, /* __lshift__ */
(binaryfunc) 0, /* __rshift__ */
(binaryfunc) 0, /* __and__ */
(binaryfunc) 0, /* __xor__ */
(binaryfunc) 0, /* __or__ */
(coercion) Quaternion_coerce, /* __coerce__ */
(unaryfunc) 0, /* __int__ */
(unaryfunc) 0, /* __long__ */
(unaryfunc) 0, /* __float__ */
(unaryfunc) 0, /* __oct__ */
(unaryfunc) 0, /* __hex__ */
( binaryfunc ) Quaternion_add, /* __add__ */
( binaryfunc ) Quaternion_sub, /* __sub__ */
( binaryfunc ) Quaternion_mul, /* __mul__ */
( binaryfunc ) 0, /* __div__ */
( binaryfunc ) 0, /* __mod__ */
( binaryfunc ) 0, /* __divmod__ */
( ternaryfunc ) 0, /* __pow__ */
( unaryfunc ) 0, /* __neg__ */
( unaryfunc ) 0, /* __pos__ */
( unaryfunc ) 0, /* __abs__ */
( inquiry ) 0, /* __nonzero__ */
( unaryfunc ) 0, /* __invert__ */
( binaryfunc ) 0, /* __lshift__ */
( binaryfunc ) 0, /* __rshift__ */
( binaryfunc ) 0, /* __and__ */
( binaryfunc ) 0, /* __xor__ */
( binaryfunc ) 0, /* __or__ */
( coercion ) Quaternion_coerce, /* __coerce__ */
( unaryfunc ) 0, /* __int__ */
( unaryfunc ) 0, /* __long__ */
( unaryfunc ) 0, /* __float__ */
( unaryfunc ) 0, /* __oct__ */
( unaryfunc ) 0, /* __hex__ */
};
//------------------PY_OBECT DEFINITION--------------------------
PyTypeObject quaternion_Type = {
PyObject_HEAD_INIT(NULL)
0, /*ob_size */
"quaternion", /*tp_name */
sizeof(QuaternionObject), /*tp_basicsize */
0, /*tp_itemsize */
(destructor) Quaternion_dealloc, /*tp_dealloc */
(printfunc) 0, /*tp_print */
(getattrfunc) Quaternion_getattr, /*tp_getattr */
(setattrfunc) Quaternion_setattr, /*tp_setattr */
0, /*tp_compare */
(reprfunc) Quaternion_repr, /*tp_repr */
&Quaternion_NumMethods, /*tp_as_number */
&Quaternion_SeqMethods, /*tp_as_sequence */
PyObject_HEAD_INIT( NULL )
0, /*ob_size */
"quaternion", /*tp_name */
sizeof( QuaternionObject ), /*tp_basicsize */
0, /*tp_itemsize */
( destructor ) Quaternion_dealloc, /*tp_dealloc */
( printfunc ) 0, /*tp_print */
( getattrfunc ) Quaternion_getattr, /*tp_getattr */
( setattrfunc ) Quaternion_setattr, /*tp_setattr */
0, /*tp_compare */
( reprfunc ) Quaternion_repr, /*tp_repr */
&Quaternion_NumMethods, /*tp_as_number */
&Quaternion_SeqMethods, /*tp_as_sequence */
};
//------------------------newQuaternionObject (internal)-------------
//creates a new quaternion object
/*pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
(i.e. it was allocated elsewhere by MEM_mallocN())
pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
(i.e. it must be created here with PyMEM_malloc())*/
PyObject *newQuaternionObject(float *quat, int type)
/** Creates a new quaternion object.
*
* Memory for a new quaternion is allocated. The quaternion copies the given
* list of parameters or initializes to the identity, if a <code>NULL</code>
* pointer is given as parameter. The memory will be freed in the dealloc
* routine.
*
* @param quat Pointer to a list of floats for the quanternion parameters w, x, y, z.
* @return Quaternion Python object.
* @see Quaternion_Identity
*/
PyObject *newQuaternionObject( float *quat )
{
QuaternionObject *self;
int x;
quaternion_Type.ob_type = &PyType_Type;
self = PyObject_NEW(QuaternionObject, &quaternion_Type);
self->data.blend_data = NULL;
self->data.py_data = NULL;
self->coerced_object = NULL;
if(type == Py_WRAP){
self->data.blend_data = quat;
self->quat = self->data.blend_data;
}else if (type == Py_NEW){
self->data.py_data = PyMem_Malloc(4 * sizeof(float));
self->quat = self->data.py_data;
if(!quat) { //new empty
Quaternion_Identity(self);
}else{
for(x = 0; x < 4; x++){
self->quat[x] = quat[x];
}
self = PyObject_NEW( QuaternionObject, &quaternion_Type );
self->quat = PyMem_Malloc( 4 * sizeof( float ) );
if( !quat ) {
Quaternion_Identity(self);
} else {
for( x = 0; x < 4; x++ ) {
self->quat[x] = quat[x];
}
}else{ //bad type
return NULL;
}
return (PyObject *) EXPP_incr_ret((PyObject *)self);
self->flag = 0;
return ( PyObject * ) self;
}

36
source/blender/python/api2_2x/quat.h
View File

@@ -34,27 +34,34 @@
#ifndef EXPP_quat_h
#define EXPP_quat_h
#include "Python.h"
#include "gen_utils.h"
#include "Types.h"
#include <BLI_arithb.h>
#include "euler.h"
#include "matrix.h"
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
/*****************************/
// Quaternion Python Object
/*****************************/
#define QuaternionObject_Check(v) ((v)->ob_type == &quaternion_Type)
typedef struct {
PyObject_VAR_HEAD
struct{
float *py_data; //python managed
float *blend_data; //blender managed
}data;
float *quat; //1D array of data (alias)
PyObject *coerced_object;
PyObject_VAR_HEAD float *quat;
int flag;
//0 - no coercion
//1 - coerced from int
//2 - coerced from float
} QuaternionObject;
/*coerced_object is a pointer to the object that it was
coerced from when a dummy vector needs to be created from
the coerce() function for numeric protocol operations*/
/*struct data contains a pointer to the actual data that the
object uses. It can use either PyMem allocated data (which will
be stored in py_data) or be a wrapper for data allocated through
blender (stored in blend_data). This is an either/or struct not both*/
//prototypes
PyObject *newQuaternionObject( float *quat );
PyObject *Quaternion_Identity( QuaternionObject * self );
PyObject *Quaternion_Negate( QuaternionObject * self );
PyObject *Quaternion_Conjugate( QuaternionObject * self );
@@ -62,6 +69,5 @@ PyObject *Quaternion_Inverse( QuaternionObject * self );
PyObject *Quaternion_Normalize( QuaternionObject * self );
PyObject *Quaternion_ToEuler( QuaternionObject * self );
PyObject *Quaternion_ToMatrix( QuaternionObject * self );
PyObject *newQuaternionObject( float *quat, int type );
#endif /* EXPP_quat_h */

1145
source/blender/python/api2_2x/vector.c
View File

@@ -28,652 +28,707 @@
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
#include <BKE_utildefines.h>
#include "Mathutils.h"
#include "gen_utils.h"
#include "vector.h"
//-------------------------DOC STRINGS ---------------------------
//doc strings
char Vector_Zero_doc[] = "() - set all values in the vector to 0";
char Vector_Normalize_doc[] = "() - normalize the vector";
char Vector_Negate_doc[] = "() - changes vector to it's additive inverse";
char Vector_Resize2D_doc[] = "() - resize a vector to [x,y]";
char Vector_Resize3D_doc[] = "() - resize a vector to [x,y,z]";
char Vector_Resize4D_doc[] = "() - resize a vector to [x,y,z,w]";
//-----------------------METHOD DEFINITIONS ----------------------
//method table
struct PyMethodDef Vector_methods[] = {
{"zero", (PyCFunction) Vector_Zero, METH_NOARGS, Vector_Zero_doc},
{"normalize", (PyCFunction) Vector_Normalize, METH_NOARGS, Vector_Normalize_doc},
{"negate", (PyCFunction) Vector_Negate, METH_NOARGS, Vector_Negate_doc},
{"resize2D", (PyCFunction) Vector_Resize2D, METH_NOARGS, Vector_Resize2D_doc},
{"resize3D", (PyCFunction) Vector_Resize3D, METH_NOARGS, Vector_Resize2D_doc},
{"resize4D", (PyCFunction) Vector_Resize4D, METH_NOARGS, Vector_Resize2D_doc},
{"zero", ( PyCFunction ) Vector_Zero, METH_NOARGS,
Vector_Zero_doc},
{"normalize", ( PyCFunction ) Vector_Normalize, METH_NOARGS,
Vector_Normalize_doc},
{"negate", ( PyCFunction ) Vector_Negate, METH_NOARGS,
Vector_Negate_doc},
{"resize2D", ( PyCFunction ) Vector_Resize2D, METH_NOARGS,
Vector_Resize2D_doc},
{"resize3D", ( PyCFunction ) Vector_Resize3D, METH_NOARGS,
Vector_Resize2D_doc},
{"resize4D", ( PyCFunction ) Vector_Resize4D, METH_NOARGS,
Vector_Resize2D_doc},
{NULL, NULL, 0, NULL}
};
//-----------------------------METHODS----------------------------
//----------------------------Vector.zero() ----------------------
//set the vector data to 0,0,0
PyObject *Vector_Zero(VectorObject * self)
/******prototypes*************/
PyObject *Vector_add( PyObject * v1, PyObject * v2 );
PyObject *Vector_sub( PyObject * v1, PyObject * v2 );
PyObject *Vector_mul( PyObject * v1, PyObject * v2 );
PyObject *Vector_div( PyObject * v1, PyObject * v2 );
int Vector_coerce( PyObject ** v1, PyObject ** v2 );
/*****************************/
// Vector Python Object
/*****************************/
//object methods
PyObject *Vector_Zero( VectorObject * self )
{
int x;
for(x = 0; x < self->size; x++) {
for( x = 0; x < self->size; x++ ) {
self->vec[x] = 0.0f;
}
return (PyObject*)self;
}
//----------------------------Vector.normalize() -----------------
//normalize the vector data to a unit vector
PyObject *Vector_Normalize(VectorObject * self)
{
int x;
float norm = 0.0f;
for(x = 0; x < self->size; x++) {
return EXPP_incr_ret( Py_None );
}
PyObject *Vector_Normalize( VectorObject * self )
{
float norm;
int x;
norm = 0.0f;
for( x = 0; x < self->size; x++ ) {
norm += self->vec[x] * self->vec[x];
}
norm = (float) sqrt(norm);
for(x = 0; x < self->size; x++) {
norm = ( float ) sqrt( norm );
for( x = 0; x < self->size; x++ ) {
self->vec[x] /= norm;
}
return (PyObject*)self;
return EXPP_incr_ret( Py_None );
}
//----------------------------Vector.negate() --------------------
//set the vector to it's negative -x, -y, -z
PyObject *Vector_Negate(VectorObject * self)
PyObject *Vector_Negate( VectorObject * self )
{
int x;
for(x = 0; x < self->size; x++) {
self->vec[x] = -(self->vec[x]);
}
return (PyObject*)self;
}
//----------------------------Vector.resize2D() ------------------
//resize the vector to x,y
PyObject *Vector_Resize2D(VectorObject * self)
{
if(self->data.blend_data){
return EXPP_ReturnPyObjError(PyExc_TypeError,
"vector.resize2d(): cannot resize wrapped data - only python vectors\n");
for( x = 0; x < self->size; x++ ) {
self->vec[x] = -( self->vec[x] );
}
self->data.py_data =
PyMem_Realloc(self->data.py_data, (sizeof(float) * 2));
if(self->data.py_data == NULL) {
return EXPP_ReturnPyObjError(PyExc_MemoryError,
"vector.resize2d(): problem allocating pointer space\n\n");
}
self->vec = self->data.py_data; //force
self->size = 2;
return (PyObject*)self;
return EXPP_incr_ret( Py_None );
}
//----------------------------Vector.resize3D() ------------------
//resize the vector to x,y,z
PyObject *Vector_Resize3D(VectorObject * self)
PyObject *Vector_Resize2D( VectorObject * self )
{
if(self->data.blend_data){
return EXPP_ReturnPyObjError(PyExc_TypeError,
"vector.resize3d(): cannot resize wrapped data - only python vectors\n");
float x, y;
if( self->size == 4 || self->size == 3 ) {
x = self->vec[0];
y = self->vec[1];
PyMem_Free( self->vec );
self->vec = PyMem_Malloc( 2 * sizeof( float ) );
self->vec[0] = x;
self->vec[1] = y;
self->size = 2;
}
self->data.py_data =
PyMem_Realloc(self->data.py_data, (sizeof(float) * 3));
if(self->data.py_data == NULL) {
return EXPP_ReturnPyObjError(PyExc_MemoryError,
"vector.resize3d(): problem allocating pointer space\n\n");
}
self->vec = self->data.py_data; //force
if(self->size == 2){
self->data.py_data[2] = 0.0f;
}
self->size = 3;
return (PyObject*)self;
return EXPP_incr_ret( Py_None );
}
//----------------------------Vector.resize4D() ------------------
//resize the vector to x,y,z,w
PyObject *Vector_Resize4D(VectorObject * self)
PyObject *Vector_Resize3D( VectorObject * self )
{
if(self->data.blend_data){
return EXPP_ReturnPyObjError(PyExc_TypeError,
"vector.resize4d(): cannot resize wrapped data - only python vectors\n");
float x, y, z;
if( self->size == 2 ) {
x = self->vec[0];
y = self->vec[1];
PyMem_Free( self->vec );
self->vec = PyMem_Malloc( 3 * sizeof( float ) );
self->vec[0] = x;
self->vec[1] = y;
self->vec[2] = 0.0f;
self->size = 3;
} else if( self->size == 4 ) {
x = self->vec[0];
y = self->vec[1];
z = self->vec[2];
PyMem_Free( self->vec );
self->vec = PyMem_Malloc( 3 * sizeof( float ) );
self->vec[0] = x;
self->vec[1] = y;
self->vec[2] = z;
self->size = 3;
}
self->data.py_data =
PyMem_Realloc(self->data.py_data, (sizeof(float) * 4));
if(self->data.py_data == NULL) {
return EXPP_ReturnPyObjError(PyExc_MemoryError,
"vector.resize4d(): problem allocating pointer space\n\n");
}
self->vec = self->data.py_data; //force
if(self->size == 2){
self->data.py_data[2] = 0.0f;
self->data.py_data[3] = 0.0f;
}else if(self->size == 3){
self->data.py_data[3] = 0.0f;
}
self->size = 4;
return (PyObject*)self;
return EXPP_incr_ret( Py_None );
}
//----------------------------dealloc()(internal) ----------------
//free the py_object
static void Vector_dealloc(VectorObject * self)
{
//only free py_data
if(self->data.py_data){
PyMem_Free(self->data.py_data);
}
PyObject_DEL(self);
}
//----------------------------getattr()(internal) ----------------
//object.attribute access (get)
static PyObject *Vector_getattr(VectorObject * self, char *name)
{
int x;
double dot = 0.0f;
if(STREQ(name,"x")){
return PyFloat_FromDouble(self->vec[0]);
}else if(STREQ(name, "y")){
return PyFloat_FromDouble(self->vec[1]);
}else if(STREQ(name, "z")){
if(self->size > 2){
return PyFloat_FromDouble(self->vec[2]);
}else{
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"vector.z: illegal attribute access\n");
PyObject *Vector_Resize4D( VectorObject * self )
{
float x, y, z;
if( self->size == 2 ) {
x = self->vec[0];
y = self->vec[1];
PyMem_Free( self->vec );
self->vec = PyMem_Malloc( 4 * sizeof( float ) );
self->vec[0] = x;
self->vec[1] = y;
self->vec[2] = 0.0f;
self->vec[3] = 1.0f;
self->size = 4;
} else if( self->size == 3 ) {
x = self->vec[0];
y = self->vec[1];
z = self->vec[2];
PyMem_Free( self->vec );
self->vec = PyMem_Malloc( 4 * sizeof( float ) );
self->vec[0] = x;
self->vec[1] = y;
self->vec[2] = z;
self->vec[3] = 1.0f;
self->size = 4;
}
return EXPP_incr_ret( Py_None );
}
static void Vector_dealloc( VectorObject * self )
{
/* if we own this memory we must delete it */
if( self->delete_pymem )
PyMem_Free( self->vec );
PyObject_DEL( self );
}
static PyObject *Vector_getattr( VectorObject * self, char *name )
{
if( self->size == 4 && ELEM4( name[0], 'x', 'y', 'z', 'w' )
&& name[1] == 0 ) {
if( ( name[0] ) == ( 'w' ) ) {
return PyFloat_FromDouble( self->vec[3] );
} else {
return PyFloat_FromDouble( self->vec[name[0] - 'x'] );
}
}else if(STREQ(name, "w")){
if(self->size > 3){
return PyFloat_FromDouble(self->vec[3]);
}else{
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"vector.w: illegal attribute access\n");
}
}else if(STREQ2(name, "length", "magnitude")) {
for(x = 0; x < self->size; x++){
dot += (self->vec[x] * self->vec[x]);
}
return PyFloat_FromDouble(sqrt(dot));
} else if( self->size == 3 && ELEM3( name[0], 'x', 'y', 'z' )
&& name[1] == 0 )
return PyFloat_FromDouble( self->vec[name[0] - 'x'] );
else if( self->size == 2 && ELEM( name[0], 'x', 'y' ) && name[1] == 0 )
return PyFloat_FromDouble( self->vec[name[0] - 'x'] );
if( ( strcmp( name, "length" ) == 0 ) ) {
if( self->size == 4 ) {
return PyFloat_FromDouble( sqrt
( self->vec[0] *
self->vec[0] +
self->vec[1] *
self->vec[1] +
self->vec[2] *
self->vec[2] +
self->vec[3] *
self->vec[3] ) );
} else if( self->size == 3 ) {
return PyFloat_FromDouble( sqrt
( self->vec[0] *
self->vec[0] +
self->vec[1] *
self->vec[1] +
self->vec[2] *
self->vec[2] ) );
} else if( self->size == 2 ) {
return PyFloat_FromDouble( sqrt
( self->vec[0] *
self->vec[0] +
self->vec[1] *
self->vec[1] ) );
} else
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"can only return the length of a 2D ,3D or 4D vector\n" );
}
return Py_FindMethod(Vector_methods, (PyObject *) self, name);
return Py_FindMethod( Vector_methods, ( PyObject * ) self, name );
}
//----------------------------setattr()(internal) ----------------
//object.attribute access (set)
static int Vector_setattr(VectorObject * self, char *name, PyObject * v)
static int Vector_setattr( VectorObject * self, char *name, PyObject * v )
{
PyObject *f = NULL;
float val;
int valTemp;
f = PyNumber_Float(v);
if(f == NULL) { // parsed item not a number
return EXPP_ReturnIntError(PyExc_TypeError,
"vector.attribute = x: argument not a number\n");
}
if(STREQ(name,"x")){
self->vec[0] = PyFloat_AS_DOUBLE(f);
}else if(STREQ(name, "y")){
self->vec[1] = PyFloat_AS_DOUBLE(f);
}else if(STREQ(name, "z")){
if(self->size > 2){
self->vec[2] = PyFloat_AS_DOUBLE(f);
}else{
Py_DECREF(f);
return EXPP_ReturnIntError(PyExc_AttributeError,
"vector.z = x: illegal attribute access\n");
if( !PyFloat_Check( v ) ) {
if( !PyInt_Check( v ) ) {
return EXPP_ReturnIntError( PyExc_TypeError,
"int or float expected\n" );
} else {
if( !PyArg_Parse( v, "i", &valTemp ) )
return EXPP_ReturnIntError( PyExc_TypeError,
"unable to parse int argument\n" );
val = ( float ) valTemp;
}
}else if(STREQ(name, "w")){
if(self->size > 3){
self->vec[3] = PyFloat_AS_DOUBLE(f);
}else{
Py_DECREF(f);
return EXPP_ReturnIntError(PyExc_AttributeError,
"vector.w = x: illegal attribute access\n");
}
}else{
Py_DECREF(f);
return EXPP_ReturnIntError(PyExc_AttributeError,
"vector.attribute = x: unknown attribute\n");
} else {
if( !PyArg_Parse( v, "f", &val ) )
return EXPP_ReturnIntError( PyExc_TypeError,
"unable to parse float argument\n" );
}
if( self->size == 4 && ELEM4( name[0], 'x', 'y', 'z', 'w' )
&& name[1] == 0 ) {
if( ( name[0] ) == ( 'w' ) ) {
self->vec[3] = val;
} else {
self->vec[name[0] - 'x'] = val;
}
} else if( self->size == 3 && ELEM3( name[0], 'x', 'y', 'z' )
&& name[1] == 0 )
self->vec[name[0] - 'x'] = val;
else if( self->size == 2 && ELEM( name[0], 'x', 'y' ) && name[1] == 0 )
self->vec[name[0] - 'x'] = val;
else
return -1;
Py_DECREF(f);
return 0;
}
//----------------------------print object (internal)-------------
//print the object to screen
static PyObject *Vector_repr(VectorObject * self)
{
int i;
char buffer[48], str[1024];
BLI_strncpy(str,"[",1024);
for(i = 0; i < self->size; i++){
if(i < (self->size - 1)){
sprintf(buffer, "%.6f, ", self->vec[i]);
strcat(str,buffer);
}else{
sprintf(buffer, "%.6f", self->vec[i]);
strcat(str,buffer);
}
}
strcat(str, "](vector)");
return EXPP_incr_ret(PyString_FromString(str));
}
//---------------------SEQUENCE PROTOCOLS------------------------
//----------------------------len(object)------------------------
//sequence length
static int Vector_len(VectorObject * self)
/* Vectors Sequence methods */
static int Vector_len( VectorObject * self )
{
return self->size;
}
//----------------------------object[]---------------------------
//sequence accessor (get)
static PyObject *Vector_item(VectorObject * self, int i)
{
if(i < 0 || i >= self->size)
return EXPP_ReturnPyObjError(PyExc_IndexError,
"vector[attribute]: array index out of range\n");
return Py_BuildValue("f", self->vec[i]);
static PyObject *Vector_item( VectorObject * self, int i )
{
if( i < 0 || i >= self->size )
return EXPP_ReturnPyObjError( PyExc_IndexError,
"array index out of range\n" );
return Py_BuildValue( "f", self->vec[i] );
}
//----------------------------object[]-------------------------
//sequence accessor (set)
static int Vector_ass_item(VectorObject * self, int i, PyObject * ob)
{
PyObject *f = NULL;
f = PyNumber_Float(ob);
if(f == NULL) { // parsed item not a number
return EXPP_ReturnIntError(PyExc_TypeError,
"vector[attribute] = x: argument not a number\n");
}
if(i < 0 || i >= self->size){
Py_DECREF(f);
return EXPP_ReturnIntError(PyExc_IndexError,
"vector[attribute] = x: array assignment index out of range\n");
}
self->vec[i] = PyFloat_AS_DOUBLE(f);
Py_DECREF(f);
return 0;
}
//----------------------------object[z:y]------------------------
//sequence slice (get)
static PyObject *Vector_slice(VectorObject * self, int begin, int end)
static PyObject *Vector_slice( VectorObject * self, int begin, int end )
{
PyObject *list = NULL;
PyObject *list;
int count;
CLAMP(begin, 0, self->size);
CLAMP(end, 0, self->size);
begin = MIN2(begin,end);
if( begin < 0 )
begin = 0;
if( end > self->size )
end = self->size;
if( begin > end )
begin = end;
list = PyList_New(end - begin);
for(count = begin; count < end; count++) {
PyList_SetItem(list, count - begin,
PyFloat_FromDouble(self->vec[count]));
list = PyList_New( end - begin );
for( count = begin; count < end; count++ ) {
PyList_SetItem( list, count - begin,
PyFloat_FromDouble( self->vec[count] ) );
}
return list;
}
//----------------------------object[z:y]------------------------
//sequence slice (set)
static int Vector_ass_slice(VectorObject * self, int begin, int end,
PyObject * seq)
static int Vector_ass_item( VectorObject * self, int i, PyObject * ob )
{
int i, y, size = 0;
float vec[4];
if( i < 0 || i >= self->size )
return EXPP_ReturnIntError( PyExc_IndexError,
"array assignment index out of range\n" );
if( !PyInt_Check( ob ) && !PyFloat_Check( ob ) )
return EXPP_ReturnIntError( PyExc_IndexError,
"vector member must be a number\n" );
CLAMP(begin, 0, self->size);
CLAMP(end, 0, self->size);
begin = MIN2(begin,end);
self->vec[i] = ( float ) PyFloat_AsDouble( ob );
size = PySequence_Length(seq);
if(size != (end - begin)){
return EXPP_ReturnIntError(PyExc_TypeError,
"vector[begin:end] = []: size mismatch in slice assignment\n");
}
for (i = 0; i < size; i++) {
PyObject *v, *f;
v = PySequence_GetItem(seq, i);
if (v == NULL) { // Failed to read sequence
return EXPP_ReturnIntError(PyExc_RuntimeError,
"vector[begin:end] = []: unable to read sequence\n");
}
f = PyNumber_Float(v);
if(f == NULL) { // parsed item not a number
Py_DECREF(v);
return EXPP_ReturnIntError(PyExc_TypeError,
"vector[begin:end] = []: sequence argument not a number\n");
}
vec[i] = PyFloat_AS_DOUBLE(f);
EXPP_decr2(f,v);
}
//parsed well - now set in vector
for(y = 0; y < size; y++){
self->vec[begin + y] = vec[y];
}
return 0;
}
//------------------------NUMERIC PROTOCOLS----------------------
//------------------------obj + obj------------------------------
//addition
static PyObject *Vector_add(PyObject * v1, PyObject * v2)
static int Vector_ass_slice( VectorObject * self, int begin, int end,
PyObject * seq )
{
int x, size;
float vec[4];
VectorObject *vec1 = NULL, *vec2 = NULL;
int count, z;
EXPP_incr2(v1, v2);
vec1 = (VectorObject*)v1;
vec2 = (VectorObject*)v2;
if( begin < 0 )
begin = 0;
if( end > self->size )
end = self->size;
if( begin > end )
begin = end;
if(vec1->coerced_object || vec2->coerced_object){
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Vector addition: arguments not valid for this operation....\n");
}
if(vec1->size != vec2->size){
EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Vector addition: vectors must have the same dimensions for this operation\n");
}
if( !PySequence_Check( seq ) )
return EXPP_ReturnIntError( PyExc_TypeError,
"illegal argument type for built-in operation\n" );
if( PySequence_Length( seq ) != ( end - begin ) )
return EXPP_ReturnIntError( PyExc_TypeError,
"size mismatch in slice assignment\n" );
size = vec1->size;
for(x = 0; x < size; x++) {
vec[x] = vec1->vec[x] + vec2->vec[x];
}
z = 0;
for( count = begin; count < end; count++ ) {
PyObject *ob = PySequence_GetItem( seq, z );
z++;
if( !PyInt_Check( ob ) && !PyFloat_Check( ob ) )
return EXPP_ReturnIntError( PyExc_IndexError,
"list member must be a number\n" );
EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
return (PyObject *) newVectorObject(vec, size, Py_NEW);
}
//------------------------obj - obj------------------------------
//subtraction
static PyObject *Vector_sub(PyObject * v1, PyObject * v2)
{
int x, size;
float vec[4];
VectorObject *vec1 = NULL, *vec2 = NULL;
EXPP_incr2(v1, v2);
vec1 = (VectorObject*)v1;
vec2 = (VectorObject*)v2;
if(vec1->coerced_object || vec2->coerced_object){
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Vector subtraction: arguments not valid for this operation....\n");
}
if(vec1->size != vec2->size){
EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Vector subtraction: vectors must have the same dimensions for this operation\n");
}
size = vec1->size;
for(x = 0; x < size; x++) {
vec[x] = vec1->vec[x] - vec2->vec[x];
}
EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
return (PyObject *) newVectorObject(vec, size, Py_NEW);
}
//------------------------obj * obj------------------------------
//mulplication
static PyObject *Vector_mul(PyObject * v1, PyObject * v2)
{
int x, size;
float vec[4], scalar, newVec[3];
double dot = 0.0f;
VectorObject *vec1 = NULL, *vec2 = NULL;
PyObject *f = NULL, *retObj = NULL;
MatrixObject *mat = NULL;
QuaternionObject *quat = NULL;
EXPP_incr2(v1, v2);
vec1 = (VectorObject*)v1;
vec2 = (VectorObject*)v2;
if(vec1->coerced_object){
if (PyFloat_Check(vec1->coerced_object) ||
PyInt_Check(vec1->coerced_object)){ // FLOAT/INT * VECTOR
f = PyNumber_Float(vec1->coerced_object);
if(f == NULL) { // parsed item not a number
EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Vector multiplication: arguments not acceptable for this operation\n");
}
scalar = PyFloat_AS_DOUBLE(f);
size = vec2->size;
for(x = 0; x < size; x++) {
vec[x] = vec2->vec[x] * scalar;
}
EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
return (PyObject *) newVectorObject(vec, size, Py_NEW);
}
}else{
if(vec2->coerced_object){
if(MatrixObject_Check(vec2->coerced_object)){ //VECTOR * MATRIX
mat = (MatrixObject*)EXPP_incr_ret(vec2->coerced_object);
retObj = row_vector_multiplication(vec1, mat);
EXPP_decr3((PyObject*)vec1, (PyObject*)vec2, (PyObject*)mat);
return retObj;
}else if (PyFloat_Check(vec2->coerced_object) ||
PyInt_Check(vec2->coerced_object)){ // VECTOR * FLOAT/INT
f = PyNumber_Float(vec2->coerced_object);
if(f == NULL) { // parsed item not a number
EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Vector multiplication: arguments not acceptable for this operation\n");
}
scalar = PyFloat_AS_DOUBLE(f);
size = vec1->size;
for(x = 0; x < size; x++) {
vec[x] = vec1->vec[x] * scalar;
}
EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
return (PyObject *) newVectorObject(vec, size, Py_NEW);
}else if(QuaternionObject_Check(vec2->coerced_object)){ //QUAT * VEC
quat = (QuaternionObject*)EXPP_incr_ret(vec2->coerced_object);
if(vec1->size != 3){
EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Vector multiplication: only 3D vector rotations (with quats) currently supported\n");
}
newVec[0] = quat->quat[0]*quat->quat[0]*vec1->vec[0] +
2*quat->quat[2]*quat->quat[0]*vec1->vec[2] -
2*quat->quat[3]*quat->quat[0]*vec1->vec[1] +
quat->quat[1]*quat->quat[1]*vec1->vec[0] +
2*quat->quat[2]*quat->quat[1]*vec1->vec[1] +
2*quat->quat[3]*quat->quat[1]*vec1->vec[2] -
quat->quat[3]*quat->quat[3]*vec1->vec[0] -
quat->quat[2]*quat->quat[2]*vec1->vec[0];
newVec[1] = 2*quat->quat[1]*quat->quat[2]*vec1->vec[0] +
quat->quat[2]*quat->quat[2]*vec1->vec[1] +
2*quat->quat[3]*quat->quat[2]*vec1->vec[2] +
2*quat->quat[0]*quat->quat[3]*vec1->vec[0] -
quat->quat[3]*quat->quat[3]*vec1->vec[1] +
quat->quat[0]*quat->quat[0]*vec1->vec[1] -
2*quat->quat[1]*quat->quat[0]*vec1->vec[2] -
quat->quat[1]*quat->quat[1]*vec1->vec[1];
newVec[2] = 2*quat->quat[1]*quat->quat[3]*vec1->vec[0] +
2*quat->quat[2]*quat->quat[3]*vec1->vec[1] +
quat->quat[3]*quat->quat[3]*vec1->vec[2] -
2*quat->quat[0]*quat->quat[2]*vec1->vec[0] -
quat->quat[2]*quat->quat[2]*vec1->vec[2] +
2*quat->quat[0]*quat->quat[1]*vec1->vec[1] -
quat->quat[1]*quat->quat[1]*vec1->vec[2] +
quat->quat[0]*quat->quat[0]*vec1->vec[2];
EXPP_decr3((PyObject*)vec1, (PyObject*)vec2, (PyObject*)quat);
return newVectorObject(newVec,3,Py_NEW);
}
}else{ //VECTOR * VECTOR
if(vec1->size != vec2->size){
EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Vector multiplication: vectors must have the same dimensions for this operation\n");
}
size = vec1->size;
//dot product
for(x = 0; x < size; x++) {
dot += vec1->vec[x] * vec2->vec[x];
}
EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
return PyFloat_FromDouble(dot);
if( !PyArg_Parse( ob, "f", &self->vec[count] ) ) {
Py_DECREF( ob );
return -1;
}
}
EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
return EXPP_ReturnPyObjError(PyExc_TypeError,
"Vector multiplication: arguments not acceptable for this operation\n");
return 0;
}
//------------------------obj / obj------------------------------
//division
static PyObject *Vector_div(PyObject * v1, PyObject * v2)
static PyObject *Vector_repr( VectorObject * self )
{
int x, size;
float vec[4];
VectorObject *vec1 = NULL, *vec2 = NULL;
int i, maxindex = self->size - 1;
char ftoa[24];
PyObject *str1, *str2;
EXPP_incr2(v1, v2);
vec1 = (VectorObject*)v1;
vec2 = (VectorObject*)v2;
str1 = PyString_FromString( "[" );
if(vec1->coerced_object || vec2->coerced_object){
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Vector division: arguments not valid for this operation....\n");
}
if(vec1->size != vec2->size){
EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
return EXPP_ReturnPyObjError(PyExc_AttributeError,
"Vector division: vectors must have the same dimensions for this operation\n");
for( i = 0; i < maxindex; i++ ) {
sprintf( ftoa, "%.4f, ", self->vec[i] );
str2 = PyString_FromString( ftoa );
if( !str1 || !str2 )
goto error;
PyString_ConcatAndDel( &str1, str2 );
}
size = vec1->size;
for(x = 0; x < size; x++) {
vec[x] = vec1->vec[x] / vec2->vec[x];
}
sprintf( ftoa, "%.4f]", self->vec[maxindex] );
str2 = PyString_FromString( ftoa );
if( !str1 || !str2 )
goto error;
PyString_ConcatAndDel( &str1, str2 );
EXPP_decr2((PyObject*)vec1, (PyObject*)vec2);
return (PyObject *) newVectorObject(vec, size, Py_NEW);
if( str1 )
return str1;
error:
Py_XDECREF( str1 );
Py_XDECREF( str2 );
return EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create PyString!\n" );
}
//------------------------coerce(obj, obj)-----------------------
//coercion of unknown types to type VectorObject for numeric protocols
/*Coercion() is called whenever a math operation has 2 operands that
it doesn't understand how to evaluate. 2+Matrix for example. We want to
evaluate some of these operations like: (vector * 2), however, for math
to proceed, the unknown operand must be cast to a type that python math will
understand. (e.g. in the case above case, 2 must be cast to a vector and
then call vector.multiply(vector, scalar_cast_as_vector)*/
static int Vector_coerce(PyObject ** v1, PyObject ** v2)
PyObject *Vector_add( PyObject * v1, PyObject * v2 )
{
float *vec;
int x;
float vec[4];
PyObject *coerced = NULL;
PyObject *retval;
if(!VectorObject_Check(*v2)) {
if(MatrixObject_Check(*v2) || PyFloat_Check(*v2) || PyInt_Check(*v2) || QuaternionObject_Check(*v2)) {
coerced = EXPP_incr_ret(*v2);
*v2 = newVectorObject(NULL,3,Py_NEW);
((VectorObject*)*v2)->coerced_object = coerced;
}else{
return EXPP_ReturnIntError(PyExc_TypeError,
"vector.coerce(): unknown operand - can't coerce for numeric protocols\n");
}
if( ( !VectorObject_Check( v1 ) ) || ( !VectorObject_Check( v2 ) ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"unsupported type for this operation\n" );
if( ( ( VectorObject * ) v1 )->flag != 0
|| ( ( VectorObject * ) v2 )->flag != 0 )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"cannot add a scalar to a vector\n" );
if( ( ( VectorObject * ) v1 )->size !=
( ( VectorObject * ) v2 )->size )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"vectors must have the same dimensions for this operation\n" );
vec = PyMem_Malloc( ( ( ( VectorObject * ) v1 )->size ) *
sizeof( float ) );
for( x = 0; x < ( ( VectorObject * ) v1 )->size; x++ ) {
vec[x] = ( ( VectorObject * ) v1 )->vec[x] +
( ( VectorObject * ) v2 )->vec[x];
}
EXPP_incr2(*v1, *v2);
return 0;
retval = ( PyObject * ) newVectorObject( vec,
( ( ( VectorObject * ) v1 )->
size ) );
PyMem_Free( vec );
return retval;
}
//-----------------PROTCOL DECLARATIONS--------------------------
PyObject *Vector_sub( PyObject * v1, PyObject * v2 )
{
float *vec;
int x;
PyObject *retval;
if( ( !VectorObject_Check( v1 ) ) || ( !VectorObject_Check( v2 ) ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"unsupported type for this operation\n" );
if( ( ( VectorObject * ) v1 )->flag != 0
|| ( ( VectorObject * ) v2 )->flag != 0 )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"cannot subtract a scalar from a vector\n" );
if( ( ( VectorObject * ) v1 )->size !=
( ( VectorObject * ) v2 )->size )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"vectors must have the same dimensions for this operation\n" );
vec = PyMem_Malloc( ( ( ( VectorObject * ) v1 )->size ) *
sizeof( float ) );
for( x = 0; x < ( ( VectorObject * ) v1 )->size; x++ ) {
vec[x] = ( ( VectorObject * ) v1 )->vec[x] -
( ( VectorObject * ) v2 )->vec[x];
}
retval = ( PyObject * ) newVectorObject( vec,
( ( ( VectorObject * ) v1 )->
size ) );
PyMem_Free( vec );
return retval;
}
PyObject *Vector_mul( PyObject * v1, PyObject * v2 )
{
float *vec;
int x;
PyObject *retval;
if( ( !VectorObject_Check( v1 ) ) || ( !VectorObject_Check( v2 ) ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"unsupported type for this operation\n" );
if( ( ( VectorObject * ) v1 )->flag == 0
&& ( ( VectorObject * ) v2 )->flag == 0 )
return EXPP_ReturnPyObjError( PyExc_ArithmeticError,
"please use the dot product or the cross product to multiply vectors\n" );
if( ( ( VectorObject * ) v1 )->size !=
( ( VectorObject * ) v2 )->size )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"vector dimension error during Vector_mul\n" );
vec = PyMem_Malloc( ( ( ( VectorObject * ) v1 )->size ) *
sizeof( float ) );
for( x = 0; x < ( ( VectorObject * ) v1 )->size; x++ ) {
vec[x] = ( ( VectorObject * ) v1 )->vec[x] *
( ( VectorObject * ) v2 )->vec[x];
}
retval = ( PyObject * ) newVectorObject( vec,
( ( ( VectorObject * ) v1 )->
size ) );
PyMem_Free( vec );
return retval;
}
PyObject *Vector_div( PyObject * v1, PyObject * v2 )
{
float *vec;
int x;
PyObject *retval;
if( ( !VectorObject_Check( v1 ) ) || ( !VectorObject_Check( v2 ) ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"unsupported type for this operation\n" );
if( ( ( VectorObject * ) v1 )->flag == 0
&& ( ( VectorObject * ) v2 )->flag == 0 )
return EXPP_ReturnPyObjError( PyExc_ArithmeticError,
"cannot divide two vectors\n" );
if( ( ( VectorObject * ) v1 )->flag != 0
&& ( ( VectorObject * ) v2 )->flag == 0 )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"cannot divide a scalar by a vector\n" );
if( ( ( VectorObject * ) v1 )->size !=
( ( VectorObject * ) v2 )->size )
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"vector dimension error during Vector_mul\n" );
vec = PyMem_Malloc( ( ( ( VectorObject * ) v1 )->size ) *
sizeof( float ) );
for( x = 0; x < ( ( VectorObject * ) v1 )->size; x++ ) {
vec[x] = ( ( VectorObject * ) v1 )->vec[x] /
( ( VectorObject * ) v2 )->vec[x];
}
retval = ( PyObject * ) newVectorObject( vec,
( ( ( VectorObject * ) v1 )->
size ) );
PyMem_Free( vec );
return retval;
}
//coercion of unknown types to type VectorObject for numeric protocols
int Vector_coerce( PyObject ** v1, PyObject ** v2 )
{
long *tempI;
double *tempF;
float *vec;
int x;
if( VectorObject_Check( *v1 ) ) {
if( VectorObject_Check( *v2 ) ) { //two vectors
Py_INCREF( *v1 ); /* fixme: wahy are we bumping the ref count? */
Py_INCREF( *v2 );
return 0;
} else {
if( Matrix_CheckPyObject( *v2 ) ) {
printf( "vector/matrix numeric protocols unsupported...\n" );
Py_INCREF( *v1 );
return 0; //operation will type check
} else if( PyNumber_Check( *v2 ) ) {
if( PyInt_Check( *v2 ) ) { //cast scalar to vector
tempI = PyMem_Malloc( 1 *
sizeof( long ) );
*tempI = PyInt_AsLong( *v2 );
vec = PyMem_Malloc( ( ( ( VectorObject
* ) *
v1 )->size ) *
sizeof( float ) );
for( x = 0;
x < ( ( ( VectorObject * ) * v1 )->size );
x++ ) {
vec[x] = ( float ) *tempI;
}
PyMem_Free( tempI );
*v2 = newVectorObject( vec,
( ( ( VectorObject * ) * v1 )->size ) );
( ( VectorObject * ) * v2 )->flag = 1; //int coercion
Py_INCREF( *v1 );
return 0;
} else if( PyFloat_Check( *v2 ) ) { //cast scalar to vector
tempF = PyMem_Malloc( 1 *
sizeof
( double ) );
*tempF = PyFloat_AsDouble( *v2 );
vec = PyMem_Malloc( ( ( ( VectorObject
* ) *
v1 )->size ) *
sizeof( float ) );
for( x = 0;
x <
( ( ( VectorObject * ) *
v1 )->size ); x++ ) {
vec[x] = ( float ) *tempF;
}
PyMem_Free( tempF );
*v2 = newVectorObject( vec,
( ( ( VectorObject * ) * v1 )->size ) );
( ( VectorObject * ) * v2 )->flag = 2; //float coercion
Py_INCREF( *v1 );
return 0;
}
}
//unknown type or numeric cast failure
printf( "attempting vector operation with unsupported type...\n" );
Py_INCREF( *v1 );
return 0; //operation will type check
}
} else {
printf( "numeric protocol failure...\n" );
return -1; //this should not occur - fail
}
return -1;
}
static PySequenceMethods Vector_SeqMethods = {
(inquiry) Vector_len, /* sq_length */
(binaryfunc) 0, /* sq_concat */
(intargfunc) 0, /* sq_repeat */
(intargfunc) Vector_item, /* sq_item */
(intintargfunc) Vector_slice, /* sq_slice */
(intobjargproc) Vector_ass_item, /* sq_ass_item */
(intintobjargproc) Vector_ass_slice, /* sq_ass_slice */
( inquiry ) Vector_len, /* sq_length */
( binaryfunc ) 0, /* sq_concat */
( intargfunc ) 0, /* sq_repeat */
( intargfunc ) Vector_item, /* sq_item */
( intintargfunc ) Vector_slice, /* sq_slice */
( intobjargproc ) Vector_ass_item, /* sq_ass_item */
( intintobjargproc ) Vector_ass_slice, /* sq_ass_slice */
};
static PyNumberMethods Vector_NumMethods = {
(binaryfunc) Vector_add, /* __add__ */
(binaryfunc) Vector_sub, /* __sub__ */
(binaryfunc) Vector_mul, /* __mul__ */
(binaryfunc) Vector_div, /* __div__ */
(binaryfunc) 0, /* __mod__ */
(binaryfunc) 0, /* __divmod__ */
(ternaryfunc) 0, /* __pow__ */
(unaryfunc) 0, /* __neg__ */
(unaryfunc) 0, /* __pos__ */
(unaryfunc) 0, /* __abs__ */
(inquiry) 0, /* __nonzero__ */
(unaryfunc) 0, /* __invert__ */
(binaryfunc) 0, /* __lshift__ */
(binaryfunc) 0, /* __rshift__ */
(binaryfunc) 0, /* __and__ */
(binaryfunc) 0, /* __xor__ */
(binaryfunc) 0, /* __or__ */
(coercion) Vector_coerce, /* __coerce__ */
(unaryfunc) 0, /* __int__ */
(unaryfunc) 0, /* __long__ */
(unaryfunc) 0, /* __float__ */
(unaryfunc) 0, /* __oct__ */
(unaryfunc) 0, /* __hex__ */
( binaryfunc ) Vector_add, /* __add__ */
( binaryfunc ) Vector_sub, /* __sub__ */
( binaryfunc ) Vector_mul, /* __mul__ */
( binaryfunc ) Vector_div, /* __div__ */
( binaryfunc ) 0, /* __mod__ */
( binaryfunc ) 0, /* __divmod__ */
( ternaryfunc ) 0, /* __pow__ */
( unaryfunc ) 0, /* __neg__ */
( unaryfunc ) 0, /* __pos__ */
( unaryfunc ) 0, /* __abs__ */
( inquiry ) 0, /* __nonzero__ */
( unaryfunc ) 0, /* __invert__ */
( binaryfunc ) 0, /* __lshift__ */
( binaryfunc ) 0, /* __rshift__ */
( binaryfunc ) 0, /* __and__ */
( binaryfunc ) 0, /* __xor__ */
( binaryfunc ) 0, /* __or__ */
( coercion ) Vector_coerce, /* __coerce__ */
( unaryfunc ) 0, /* __int__ */
( unaryfunc ) 0, /* __long__ */
( unaryfunc ) 0, /* __float__ */
( unaryfunc ) 0, /* __oct__ */
( unaryfunc ) 0, /* __hex__ */
};
//------------------PY_OBECT DEFINITION--------------------------
PyTypeObject vector_Type = {
PyObject_HEAD_INIT(NULL)
0, /*ob_size */
"vector", /*tp_name */
sizeof(VectorObject), /*tp_basicsize */
0, /*tp_itemsize */
(destructor) Vector_dealloc, /*tp_dealloc */
(printfunc) 0, /*tp_print */
(getattrfunc) Vector_getattr, /*tp_getattr */
(setattrfunc) Vector_setattr, /*tp_setattr */
0, /*tp_compare */
(reprfunc) Vector_repr, /*tp_repr */
&Vector_NumMethods, /*tp_as_number */
&Vector_SeqMethods, /*tp_as_sequence */
PyObject_HEAD_INIT( NULL ) 0, /*ob_size */
"vector", /*tp_name */
sizeof( VectorObject ), /*tp_basicsize */
0, /*tp_itemsize */
( destructor ) Vector_dealloc, /*tp_dealloc */
( printfunc ) 0, /*tp_print */
( getattrfunc ) Vector_getattr, /*tp_getattr */
( setattrfunc ) Vector_setattr, /*tp_setattr */
0, /*tp_compare */
( reprfunc ) Vector_repr, /*tp_repr */
&Vector_NumMethods, /*tp_as_number */
&Vector_SeqMethods, /*tp_as_sequence */
};
//------------------------newVectorObject (internal)-------------
//creates a new vector object
/*pass Py_WRAP - if vector is a WRAPPER for data allocated by BLENDER
(i.e. it was allocated elsewhere by MEM_mallocN())
pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
(i.e. it must be created here with PyMEM_malloc())*/
PyObject *newVectorObject(float *vec, int size, int type)
/*
* create a Vector Object( vec, size )
*
* Note: Vector now uses copy semantics like STL containers.
* Memory for vec member is allocated on python stack.
* We own this memory and will free it later.
*
* size arg is number of floats to alloc.
*
* if vec arg is NULL
* fill our vec with zeros
* initialize 4d vectors to zero in homogenous coords.
* else
* vec param is copied into our local memory and always freed.
*/
PyObject *newVectorObject( float *vec, int size )
{
VectorObject *self;
int x;
vector_Type.ob_type = &PyType_Type;
self = PyObject_NEW(VectorObject, &vector_Type);
self->data.blend_data = NULL;
self->data.py_data = NULL;
self->size = size;
self->coerced_object = NULL;
if(type == Py_WRAP){
self->data.blend_data = vec;
self->vec = self->data.blend_data;
}else if (type == Py_NEW){
self->data.py_data = PyMem_Malloc(size * sizeof(float));
self->vec = self->data.py_data;
if(!vec) { //new empty
for(x = 0; x < size; x++){
self->vec[x] = 0.0f;
}
if(size == 4) /* do the homogenous thing */
self->vec[3] = 1.0f;
}else{
for(x = 0; x < size; x++){
self->vec[x] = vec[x];
}
self = PyObject_NEW( VectorObject, &vector_Type );
self->vec = PyMem_Malloc( size * sizeof( float ) );
self->delete_pymem = 1; /* must free this alloc later */
if( !vec ) {
for( x = 0; x < size; x++ ) {
self->vec[x] = 0.0f;
}
if( size == 4 ) /* do the homogenous thing */
self->vec[3] = 1.0f;
} else {
for( x = 0; x < size; x++ ){
self->vec[x] = vec[x];
}
}else{ //bad type
return NULL;
}
return (PyObject *) EXPP_incr_ret((PyObject *)self);
self->size = size;
self->flag = 0;
return ( PyObject * ) self;
}
/*
create a Vector that is a proxy for blender data.
we do not own this data, we NEVER free it.
Note: users must deal with bad pointer issue
*/
PyObject *newVectorProxy( float *vec, int size)
{
VectorObject *proxy;
proxy = PyObject_NEW( VectorObject, &vector_Type );
proxy->delete_pymem = 0; /* must NOT free this alloc later */
if( !vec || size < 1 ) {
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"cannot creat zero length vector proxy" );
}
proxy->vec = vec;
proxy->size = size;
proxy->flag = 0;
return ( PyObject * ) proxy;
}

38
source/blender/python/api2_2x/vector.h
View File

@@ -33,34 +33,40 @@
#ifndef EXPP_vector_h
#define EXPP_vector_h
#include "Python.h"
#include "gen_utils.h"
#include "Types.h"
#include "matrix.h"
#include "BKE_utildefines.h"
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
/*****************************/
// Vector Python Object
/*****************************/
#define VectorObject_Check(v) ((v)->ob_type == &vector_Type)
typedef struct {
PyObject_VAR_HEAD
struct{
float *py_data; //python managed
float *blend_data; //blender managed
}data;
float *vec; //1D array of data (alias)
PyObject_VAR_HEAD float *vec;
int size;
PyObject *coerced_object;
int flag;
//0 - no coercion
//1 - coerced from int
//2 - coerced from float
int delete_pymem; /* flag to delete the memory vec points at */
} VectorObject;
/*coerced_object is a pointer to the object that it was
coerced from when a dummy vector needs to be created from
the coerce() function for numeric protocol operations*/
/*struct data contains a pointer to the actual data that the
object uses. It can use either PyMem allocated data (which will
be stored in py_data) or be a wrapper for data allocated through
blender (stored in blend_data). This is an either/or struct not both*/
//prototypes
PyObject *newVectorObject( float *vec, int size );
PyObject *newVectorProxy( float *vec, int size );
PyObject *Vector_Zero( VectorObject * self );
PyObject *Vector_Normalize( VectorObject * self );
PyObject *Vector_Negate( VectorObject * self );
PyObject *Vector_Resize2D( VectorObject * self );
PyObject *Vector_Resize3D( VectorObject * self );
PyObject *Vector_Resize4D( VectorObject * self );
PyObject *newVectorObject(float *vec, int size, int type);
#endif /* EXPP_vector_h */