diff options
Diffstat (limited to 'source/blender/python/api2_2x/Bone.c')
| -rw-r--r-- | source/blender/python/api2_2x/Bone.c | 2544 |
1 files changed, 1351 insertions, 1193 deletions
diff --git a/source/blender/python/api2_2x/Bone.c b/source/blender/python/api2_2x/Bone.c index 52c1e33d586..0367fa99a65 100644 --- a/source/blender/python/api2_2x/Bone.c +++ b/source/blender/python/api2_2x/Bone.c @@ -53,200 +53,215 @@ #include "matrix.h" #include "vector.h" -//------------------------Python API function prototypes for the Bone module--------------------------- -static PyObject *M_Bone_New (PyObject * self, PyObject * args); -//------------------------Python API Doc strings for the Bone module-------------------------------------- +//--------------------Python API function prototypes for the Bone module---- +static PyObject *M_Bone_New( PyObject * self, PyObject * args ); + +//------------------------Python API Doc strings for the Bone module-------- char M_Bone_doc[] = "The Blender Bone module\n\n\ This module provides control over **Bone Data** objects in Blender.\n\n\ Example::\n\n\ from Blender import Armature.Bone\n\ l = Armature.Bone.New()\n"; char M_Bone_New_doc[] = "(name) - return a new Bone of name 'name'."; -//--------------- Python method structure definition for Blender.Armature.Bone module------------ + +//----- Python method structure definition for Blender.Armature.Bone module--- struct PyMethodDef M_Bone_methods[] = { - {"New", (PyCFunction) M_Bone_New, METH_VARARGS, M_Bone_New_doc}, - {NULL, NULL, 0, NULL} + {"New", ( PyCFunction ) M_Bone_New, METH_VARARGS, M_Bone_New_doc}, + {NULL, NULL, 0, NULL} }; -//--------------- Python BPy_Bone methods declarations:--------------------------------------------------- -static PyObject *Bone_getName (BPy_Bone * self); -static PyObject *Bone_getRoll (BPy_Bone * self); -static PyObject *Bone_getHead (BPy_Bone * self); -static PyObject *Bone_getTail (BPy_Bone * self); -static PyObject *Bone_getLoc (BPy_Bone * self); -static PyObject *Bone_getSize (BPy_Bone * self); -static PyObject *Bone_getQuat (BPy_Bone * self); -static PyObject *Bone_getParent (BPy_Bone * self); -static PyObject *Bone_hasParent (BPy_Bone * self); -static PyObject *Bone_getWeight (BPy_Bone * self); -static PyObject *Bone_getBoneclass (BPy_Bone * self); -static PyObject *Bone_hasIK(BPy_Bone * self); -static PyObject *Bone_getChildren (BPy_Bone * self); -static PyObject *Bone_clearParent (BPy_Bone * self); -static PyObject *Bone_clearChildren (BPy_Bone * self); -static PyObject *Bone_hide (BPy_Bone * self); -static PyObject *Bone_unhide (BPy_Bone * self); -static PyObject *Bone_setName (BPy_Bone * self, PyObject * args); -static PyObject *Bone_setRoll (BPy_Bone * self, PyObject * args); -static PyObject *Bone_setHead (BPy_Bone * self, PyObject * args); -static PyObject *Bone_setTail (BPy_Bone * self, PyObject * args); -static PyObject *Bone_setLoc (BPy_Bone * self, PyObject * args); -static PyObject *Bone_setSize (BPy_Bone * self, PyObject * args); -static PyObject *Bone_setQuat (BPy_Bone * self, PyObject * args); -static PyObject *Bone_setParent(BPy_Bone *self, PyObject *args); -static PyObject *Bone_setWeight(BPy_Bone *self, PyObject *args); -static PyObject *Bone_setPose (BPy_Bone *self, PyObject *args); -static PyObject *Bone_setBoneclass (BPy_Bone *self, PyObject *args); -static PyObject *Bone_getRestMatrix(BPy_Bone * self, PyObject *args); -//--------------- Python BPy_Bone methods table:----------------------------------------------------------------- +//--------------- Python BPy_Bone methods declarations:------------------- +static PyObject *Bone_getName( BPy_Bone * self ); +static PyObject *Bone_getRoll( BPy_Bone * self ); +static PyObject *Bone_getHead( BPy_Bone * self ); +static PyObject *Bone_getTail( BPy_Bone * self ); +static PyObject *Bone_getLoc( BPy_Bone * self ); +static PyObject *Bone_getSize( BPy_Bone * self ); +static PyObject *Bone_getQuat( BPy_Bone * self ); +static PyObject *Bone_getParent( BPy_Bone * self ); +static PyObject *Bone_hasParent( BPy_Bone * self ); +static PyObject *Bone_getWeight( BPy_Bone * self ); +static PyObject *Bone_getBoneclass( BPy_Bone * self ); +static PyObject *Bone_hasIK( BPy_Bone * self ); +static PyObject *Bone_getChildren( BPy_Bone * self ); +static PyObject *Bone_clearParent( BPy_Bone * self ); +static PyObject *Bone_clearChildren( BPy_Bone * self ); +static PyObject *Bone_hide( BPy_Bone * self ); +static PyObject *Bone_unhide( BPy_Bone * self ); +static PyObject *Bone_setName( BPy_Bone * self, PyObject * args ); +static PyObject *Bone_setRoll( BPy_Bone * self, PyObject * args ); +static PyObject *Bone_setHead( BPy_Bone * self, PyObject * args ); +static PyObject *Bone_setTail( BPy_Bone * self, PyObject * args ); +static PyObject *Bone_setLoc( BPy_Bone * self, PyObject * args ); +static PyObject *Bone_setSize( BPy_Bone * self, PyObject * args ); +static PyObject *Bone_setQuat( BPy_Bone * self, PyObject * args ); +static PyObject *Bone_setParent( BPy_Bone * self, PyObject * args ); +static PyObject *Bone_setWeight( BPy_Bone * self, PyObject * args ); +static PyObject *Bone_setPose( BPy_Bone * self, PyObject * args ); +static PyObject *Bone_setBoneclass( BPy_Bone * self, PyObject * args ); +static PyObject *Bone_getRestMatrix( BPy_Bone * self, PyObject * args ); + +//--------------- Python BPy_Bone methods table:-------------------------- static PyMethodDef BPy_Bone_methods[] = { - {"getName", (PyCFunction) Bone_getName, METH_NOARGS, - "() - return Bone name"}, - {"getRoll", (PyCFunction) Bone_getRoll, METH_NOARGS, - "() - return Bone roll"}, - {"getHead", (PyCFunction) Bone_getHead, METH_NOARGS, - "() - return Bone head"}, - {"getTail", (PyCFunction) Bone_getTail, METH_NOARGS, - "() - return Bone tail"}, - {"getLoc", (PyCFunction) Bone_getLoc, METH_NOARGS, "() - return Bone loc"}, - {"getSize", (PyCFunction) Bone_getSize, METH_NOARGS, - "() - return Bone size"}, - {"getQuat", (PyCFunction) Bone_getQuat, METH_NOARGS, - "() - return Bone quat"}, - {"hide", (PyCFunction) Bone_hide, METH_NOARGS, - "() - hides the bone"}, - {"unhide", (PyCFunction) Bone_unhide, METH_NOARGS, - "() - unhides the bone"}, - {"getWeight", (PyCFunction) Bone_getWeight, METH_NOARGS, - "() - return Bone weight"}, - {"getBoneclass", (PyCFunction) Bone_getBoneclass, METH_NOARGS, - "() - return Bone boneclass"}, - {"hasIK", (PyCFunction)Bone_hasIK, METH_VARARGS, - "() - get the Bone IKToParent flag."}, - {"getParent", (PyCFunction) Bone_getParent, METH_NOARGS, - "() - return the parent bone of this one if it exists." - " None if not found. You can check this condition with the " - "hasParent() method."}, - {"hasParent", (PyCFunction) Bone_hasParent, METH_NOARGS, - "() - return true if bone has a parent"}, - {"getChildren", (PyCFunction) Bone_getChildren, METH_NOARGS, - "() - return Bone children list"}, - {"clearParent", (PyCFunction) Bone_clearParent, METH_NOARGS, - "() - clears the bone's parent in the armature and makes it root"}, - {"clearChildren", (PyCFunction) Bone_clearChildren, METH_NOARGS, - "() - remove the children associated with this bone"}, - {"setName", (PyCFunction) Bone_setName, METH_VARARGS, - "(str) - rename Bone"}, - {"setRoll", (PyCFunction) Bone_setRoll, METH_VARARGS, - "(float) - set Bone roll"}, - {"setHead", (PyCFunction) Bone_setHead, METH_VARARGS, - "(float,float,float) - set Bone head pos"}, - {"setTail", (PyCFunction) Bone_setTail, METH_VARARGS, - "(float,float,float) - set Bone tail pos"}, - {"setLoc", (PyCFunction) Bone_setLoc, METH_VARARGS, - "(float,float,float) - set Bone loc"}, - {"setSize", (PyCFunction) Bone_setSize, METH_VARARGS, - "(float,float,float) - set Bone size"}, - {"setQuat", (PyCFunction) Bone_setQuat, METH_VARARGS, - "(float,float,float,float) - set Bone quat"}, - {"setParent", (PyCFunction)Bone_setParent, METH_VARARGS, - "() - set the Bone parent of this one."}, - {"setWeight", (PyCFunction)Bone_setWeight, METH_VARARGS, - "() - set the Bone weight."}, - {"setPose", (PyCFunction)Bone_setPose, METH_VARARGS, - "() - set a pose for this bone at a frame."}, - {"setBoneclass", (PyCFunction)Bone_setBoneclass, METH_VARARGS, - "() - set the Bone boneclass."}, - {"getRestMatrix", (PyCFunction)Bone_getRestMatrix, METH_VARARGS, - "() - return the rest matrix for this bone"}, - {NULL, NULL, 0, NULL} + {"getName", ( PyCFunction ) Bone_getName, METH_NOARGS, + "() - return Bone name"}, + {"getRoll", ( PyCFunction ) Bone_getRoll, METH_NOARGS, + "() - return Bone roll"}, + {"getHead", ( PyCFunction ) Bone_getHead, METH_NOARGS, + "() - return Bone head"}, + {"getTail", ( PyCFunction ) Bone_getTail, METH_NOARGS, + "() - return Bone tail"}, + {"getLoc", ( PyCFunction ) Bone_getLoc, METH_NOARGS, + "() - return Bone loc"}, + {"getSize", ( PyCFunction ) Bone_getSize, METH_NOARGS, + "() - return Bone size"}, + {"getQuat", ( PyCFunction ) Bone_getQuat, METH_NOARGS, + "() - return Bone quat"}, + {"hide", ( PyCFunction ) Bone_hide, METH_NOARGS, + "() - hides the bone"}, + {"unhide", ( PyCFunction ) Bone_unhide, METH_NOARGS, + "() - unhides the bone"}, + {"getWeight", ( PyCFunction ) Bone_getWeight, METH_NOARGS, + "() - return Bone weight"}, + {"getBoneclass", ( PyCFunction ) Bone_getBoneclass, METH_NOARGS, + "() - return Bone boneclass"}, + {"hasIK", ( PyCFunction ) Bone_hasIK, METH_VARARGS, + "() - get the Bone IKToParent flag."}, + {"getParent", ( PyCFunction ) Bone_getParent, METH_NOARGS, + "() - return the parent bone of this one if it exists." + " None if not found. You can check this condition with the " + "hasParent() method."}, + {"hasParent", ( PyCFunction ) Bone_hasParent, METH_NOARGS, + "() - return true if bone has a parent"}, + {"getChildren", ( PyCFunction ) Bone_getChildren, METH_NOARGS, + "() - return Bone children list"}, + {"clearParent", ( PyCFunction ) Bone_clearParent, METH_NOARGS, + "() - clears the bone's parent in the armature and makes it root"}, + {"clearChildren", ( PyCFunction ) Bone_clearChildren, METH_NOARGS, + "() - remove the children associated with this bone"}, + {"setName", ( PyCFunction ) Bone_setName, METH_VARARGS, + "(str) - rename Bone"}, + {"setRoll", ( PyCFunction ) Bone_setRoll, METH_VARARGS, + "(float) - set Bone roll"}, + {"setHead", ( PyCFunction ) Bone_setHead, METH_VARARGS, + "(float,float,float) - set Bone head pos"}, + {"setTail", ( PyCFunction ) Bone_setTail, METH_VARARGS, + "(float,float,float) - set Bone tail pos"}, + {"setLoc", ( PyCFunction ) Bone_setLoc, METH_VARARGS, + "(float,float,float) - set Bone loc"}, + {"setSize", ( PyCFunction ) Bone_setSize, METH_VARARGS, + "(float,float,float) - set Bone size"}, + {"setQuat", ( PyCFunction ) Bone_setQuat, METH_VARARGS, + "(float,float,float,float) - set Bone quat"}, + {"setParent", ( PyCFunction ) Bone_setParent, METH_VARARGS, + "() - set the Bone parent of this one."}, + {"setWeight", ( PyCFunction ) Bone_setWeight, METH_VARARGS, + "() - set the Bone weight."}, + {"setPose", ( PyCFunction ) Bone_setPose, METH_VARARGS, + "() - set a pose for this bone at a frame."}, + {"setBoneclass", ( PyCFunction ) Bone_setBoneclass, METH_VARARGS, + "() - set the Bone boneclass."}, + {"getRestMatrix", ( PyCFunction ) Bone_getRestMatrix, METH_VARARGS, + "() - return the rest matrix for this bone"}, + {NULL, NULL, 0, NULL} }; -//--------------- Python TypeBone callback function prototypes---------------------------------------- -static void Bone_dealloc (BPy_Bone * bone); -static PyObject *Bone_getAttr (BPy_Bone * bone, char *name); -static int Bone_setAttr (BPy_Bone * bone, char *name, PyObject * v); -static int Bone_compare (BPy_Bone * a1, BPy_Bone * a2); -static PyObject *Bone_repr (BPy_Bone * bone); -//--------------- Python TypeBone structure definition------------------------------------------------------ + +//--------------- Python TypeBone callback function prototypes---------- +static void Bone_dealloc( BPy_Bone * bone ); +static PyObject *Bone_getAttr( BPy_Bone * bone, char *name ); +static int Bone_setAttr( BPy_Bone * bone, char *name, PyObject * v ); +static int Bone_compare( BPy_Bone * a1, BPy_Bone * a2 ); +static PyObject *Bone_repr( BPy_Bone * bone ); + +//--------------- Python TypeBone structure definition------------- PyTypeObject Bone_Type = { - PyObject_HEAD_INIT (NULL) 0, /* ob_size */ - "Blender Bone", /* tp_name */ - sizeof (BPy_Bone), /* tp_basicsize */ - 0, /* tp_itemsize */ - /* methods */ - (destructor) Bone_dealloc, /* tp_dealloc */ - 0, /* tp_print */ - (getattrfunc) Bone_getAttr, /* tp_getattr */ - (setattrfunc) Bone_setAttr, /* tp_setattr */ - (cmpfunc) Bone_compare, /* tp_compare */ - (reprfunc) Bone_repr, /* tp_repr */ - 0, /* tp_as_number */ - 0, /* tp_as_sequence */ - 0, /* tp_as_mapping */ - 0, /* tp_as_hash */ - 0, 0, 0, 0, 0, 0, - 0, /* tp_doc */ - 0, 0, 0, 0, 0, 0, - BPy_Bone_methods, /* tp_methods */ - 0, /* tp_members */ + PyObject_HEAD_INIT( NULL ) + 0, /* ob_size */ + "Blender Bone", /* tp_name */ + sizeof( BPy_Bone ), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + ( destructor ) Bone_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + ( getattrfunc ) Bone_getAttr, /* tp_getattr */ + ( setattrfunc ) Bone_setAttr, /* tp_setattr */ + ( cmpfunc ) Bone_compare, /* tp_compare */ + ( reprfunc ) Bone_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_as_hash */ + 0, 0, 0, 0, 0, 0, + 0, /* tp_doc */ + 0, 0, 0, 0, 0, 0, + BPy_Bone_methods, /* tp_methods */ + 0, /* tp_members */ }; -//--------------- Bone Module Init---------------------------------------------------------------------------------------- -PyObject * -Bone_Init (void) + +//--------------- Bone Module Init----------------------------- +PyObject *Bone_Init( void ) { - PyObject *submodule; - - Bone_Type.ob_type = &PyType_Type; - - submodule = Py_InitModule3 ("Blender.Armature.Bone", - M_Bone_methods, M_Bone_doc); - - PyModule_AddIntConstant(submodule, "ROT", POSE_ROT); - PyModule_AddIntConstant(submodule, "LOC", POSE_LOC); - PyModule_AddIntConstant(submodule, "SIZE", POSE_SIZE); - PyModule_AddIntConstant(submodule, "SKINNABLE", 0); - PyModule_AddIntConstant(submodule, "UNSKINNABLE", 1); - PyModule_AddIntConstant(submodule, "HEAD", 2); - PyModule_AddIntConstant(submodule, "NECK", 3); - PyModule_AddIntConstant(submodule, "BACK", 4); - PyModule_AddIntConstant(submodule, "SHOULDER", 5); - PyModule_AddIntConstant(submodule, "ARM", 6); - PyModule_AddIntConstant(submodule, "HAND", 7); - PyModule_AddIntConstant(submodule, "FINGER", 8); - PyModule_AddIntConstant(submodule, "THUMB", 9); - PyModule_AddIntConstant(submodule, "PELVIS", 10); - PyModule_AddIntConstant(submodule, "LEG", 11); - PyModule_AddIntConstant(submodule, "FOOT", 12); - PyModule_AddIntConstant(submodule, "TOE", 13); - PyModule_AddIntConstant(submodule, "TENTACLE", 14); - - return (submodule); + PyObject *submodule; + + Bone_Type.ob_type = &PyType_Type; + + submodule = Py_InitModule3( "Blender.Armature.Bone", + M_Bone_methods, M_Bone_doc ); + + PyModule_AddIntConstant( submodule, "ROT", POSE_ROT ); + PyModule_AddIntConstant( submodule, "LOC", POSE_LOC ); + PyModule_AddIntConstant( submodule, "SIZE", POSE_SIZE ); + PyModule_AddIntConstant( submodule, "SKINNABLE", 0 ); + PyModule_AddIntConstant( submodule, "UNSKINNABLE", 1 ); + PyModule_AddIntConstant( submodule, "HEAD", 2 ); + PyModule_AddIntConstant( submodule, "NECK", 3 ); + PyModule_AddIntConstant( submodule, "BACK", 4 ); + PyModule_AddIntConstant( submodule, "SHOULDER", 5 ); + PyModule_AddIntConstant( submodule, "ARM", 6 ); + PyModule_AddIntConstant( submodule, "HAND", 7 ); + PyModule_AddIntConstant( submodule, "FINGER", 8 ); + PyModule_AddIntConstant( submodule, "THUMB", 9 ); + PyModule_AddIntConstant( submodule, "PELVIS", 10 ); + PyModule_AddIntConstant( submodule, "LEG", 11 ); + PyModule_AddIntConstant( submodule, "FOOT", 12 ); + PyModule_AddIntConstant( submodule, "TOE", 13 ); + PyModule_AddIntConstant( submodule, "TENTACLE", 14 ); + + return ( submodule ); } -//--------------- Bone module internal callbacks------------------------------------------------------------- -//--------------- updatePyBone------------------------------------------------------------------------------------- -int -updatePyBone(BPy_Bone *self) + +//--------------- Bone module internal callbacks----------------- + +//--------------- updatePyBone------------------------------------ +int updatePyBone( BPy_Bone * self ) { - int x,y; + int x, y; char *parent_str = ""; - if(!self->bone){ + if( !self->bone ) { //nothing to update - not linked return 0; - }else{ - BLI_strncpy(self->name, self->bone->name, strlen(self->bone->name) + 1); + } else { + BLI_strncpy( self->name, self->bone->name, + strlen( self->bone->name ) + 1 ); self->roll = self->bone->roll; self->flag = self->bone->flag; self->boneclass = self->bone->boneclass; self->dist = self->bone->dist; self->weight = self->bone->weight; - if(self->bone->parent){ - self->parent = BLI_strncpy(self->parent, self->bone->parent->name, strlen(self->bone->parent->name) + 1); - }else{ - self->parent = BLI_strncpy(self->parent, parent_str, strlen(parent_str) + 1); + if( self->bone->parent ) { + self->parent = + BLI_strncpy( self->parent, + self->bone->parent->name, + strlen( self->bone->parent-> + name ) + 1 ); + } else { + self->parent = + BLI_strncpy( self->parent, parent_str, + strlen( parent_str ) + 1 ); } - for(x = 0; x < 3; x++){ + for( x = 0; x < 3; x++ ) { self->head->vec[x] = self->bone->head[x]; self->tail->vec[x] = self->bone->tail[x]; self->loc->vec[x] = self->bone->loc[x]; @@ -254,43 +269,49 @@ updatePyBone(BPy_Bone *self) self->size->vec[x] = self->bone->size[x]; self->dsize->vec[x] = self->bone->dsize[x]; } - for(x = 0; x < 4; x++){ + for( x = 0; x < 4; x++ ) { self->quat->quat[x] = self->bone->quat[x]; self->dquat->quat[x] = self->bone->dquat[x]; } - for(x = 0; x < 4; x++){ - for(y = 0; y < 4; y++){ - self->obmat->matrix[x][y] = self->bone->obmat[x][y]; - self->parmat->matrix[x][y] = self->bone->parmat[x][y]; - self->defmat->matrix[x][y] = self->bone->defmat[x][y]; - self->irestmat->matrix[x][y] = self->bone->irestmat[x][y]; - self->posemat->matrix[x][y] = self->bone->posemat[x][y]; + for( x = 0; x < 4; x++ ) { + for( y = 0; y < 4; y++ ) { + self->obmat->matrix[x][y] = + self->bone->obmat[x][y]; + self->parmat->matrix[x][y] = + self->bone->parmat[x][y]; + self->defmat->matrix[x][y] = + self->bone->defmat[x][y]; + self->irestmat->matrix[x][y] = + self->bone->irestmat[x][y]; + self->posemat->matrix[x][y] = + self->bone->posemat[x][y]; } } return 1; } } -//--------------- updateBoneData------------------------------------------------------------------------------------- -int -updateBoneData(BPy_Bone *self, Bone *parent) + +//--------------- updateBoneData------------------------------------ +int updateBoneData( BPy_Bone * self, Bone * parent ) { //called from Armature.addBone() - int x,y; + int x, y; - //called in Armature.addBone() to update the Bone * data - if(!self->bone){ + //called in Armature.addBone() to update the Bone * data + if( !self->bone ) { //nothing to update - not linked return 0; - }else{ - BLI_strncpy(self->bone->name, self->name, strlen(self->name) + 1); + } else { + BLI_strncpy( self->bone->name, self->name, + strlen( self->name ) + 1 ); self->bone->roll = self->roll; self->bone->flag = self->flag; self->bone->boneclass = self->boneclass; self->bone->dist = self->dist; self->bone->weight = self->weight; - self->bone->parent = parent; //parent will be checked from self->parent string in addBone() + self->bone->parent = parent; //parent will be checked from self->parent string in addBone() - for(x = 0; x < 3; x++){ + for( x = 0; x < 3; x++ ) { self->bone->head[x] = self->head->vec[x]; self->bone->tail[x] = self->tail->vec[x]; self->bone->loc[x] = self->loc->vec[x]; @@ -298,293 +319,370 @@ updateBoneData(BPy_Bone *self, Bone *parent) self->bone->size[x] = self->size->vec[x]; self->bone->dsize[x] = self->dsize->vec[x]; } - for(x = 0; x < 4; x++){ + for( x = 0; x < 4; x++ ) { self->bone->quat[x] = self->quat->quat[x]; self->bone->dquat[x] = self->dquat->quat[x]; } - for(x = 0; x < 4; x++){ - for(y = 0; y < 4; y++){ - self->bone->obmat[x][y] = self->obmat->matrix[x][y]; - self->bone->parmat[x][y] = self->parmat->matrix[x][y]; - self->bone->defmat[x][y] = self->defmat->matrix[x][y]; - self->bone->irestmat[x][y] = self->irestmat->matrix[x][y]; - self->bone->posemat[x][y] = self->posemat->matrix[x][y]; + for( x = 0; x < 4; x++ ) { + for( y = 0; y < 4; y++ ) { + self->bone->obmat[x][y] = + self->obmat->matrix[x][y]; + self->bone->parmat[x][y] = + self->parmat->matrix[x][y]; + self->bone->defmat[x][y] = + self->defmat->matrix[x][y]; + self->bone->irestmat[x][y] = + self->irestmat->matrix[x][y]; + self->bone->posemat[x][y] = + self->posemat->matrix[x][y]; } } return 1; } } -//--------------- testChildbase-------------------------------------------------------------------------------- -static int -testChildbase(Bone *bone, Bone *test) + +//--------------- testChildbase---------------------------------- +static int testChildbase( Bone * bone, Bone * test ) { Bone *child; - for(child = bone->childbase.first; child; child = child->next){ - if(child == test){ + for( child = bone->childbase.first; child; child = child->next ) { + if( child == test ) { return 1; } - if(child->childbase.first != NULL) - testChildbase(child, test); + if( child->childbase.first != NULL ) + testChildbase( child, test ); } return 0; } -//--------------- returnBoneclassEnum--------------------------------------------------------------------- -static PyObject * -returnBoneclassEnum(int value) + +//--------------- returnBoneclassEnum---------------------------- +static PyObject *returnBoneclassEnum( int value ) { char *str; - str = PyMem_Malloc(32 + 1); - - switch(value){ - case 0: - BLI_strncpy(str,"SKINNABLE",32); break; - case 1: - BLI_strncpy(str,"UNSKINNABLE",32); break; - case 2: - BLI_strncpy(str,"HEAD",32); break; - case 3: - BLI_strncpy(str,"NECK",32); break; - case 4: - BLI_strncpy(str,"BACK",32); break; - case 5: - BLI_strncpy(str,"SHOULDER",32); break; - case 6: - BLI_strncpy(str,"ARM",32); break; - case 7: - BLI_strncpy(str,"HAND",32); break; - case 8: - BLI_strncpy(str,"FINGER",32); break; - case 9: - BLI_strncpy(str,"THUMB",32); break; - case 10: - BLI_strncpy(str,"PELVIS",32); break; - case 11: - BLI_strncpy(str,"LEG",32); break; - case 12: - BLI_strncpy(str,"FOOT",32); break; - case 13: - BLI_strncpy(str,"TOE",32); break; - case 14: - BLI_strncpy(str,"TENTACLE",32); break; - default: - BLI_strncpy(str, "SKINNABLE",32); break; + str = PyMem_Malloc( 32 + 1 ); + + switch ( value ) { + case 0: + BLI_strncpy( str, "SKINNABLE", 32 ); + break; + case 1: + BLI_strncpy( str, "UNSKINNABLE", 32 ); + break; + case 2: + BLI_strncpy( str, "HEAD", 32 ); + break; + case 3: + BLI_strncpy( str, "NECK", 32 ); + break; + case 4: + BLI_strncpy( str, "BACK", 32 ); + break; + case 5: + BLI_strncpy( str, "SHOULDER", 32 ); + break; + case 6: + BLI_strncpy( str, "ARM", 32 ); + break; + case 7: + BLI_strncpy( str, "HAND", 32 ); + break; + case 8: + BLI_strncpy( str, "FINGER", 32 ); + break; + case 9: + BLI_strncpy( str, "THUMB", 32 ); + break; + case 10: + BLI_strncpy( str, "PELVIS", 32 ); + break; + case 11: + BLI_strncpy( str, "LEG", 32 ); + break; + case 12: + BLI_strncpy( str, "FOOT", 32 ); + break; + case 13: + BLI_strncpy( str, "TOE", 32 ); + break; + case 14: + BLI_strncpy( str, "TENTACLE", 32 ); + break; + default: + BLI_strncpy( str, "SKINNABLE", 32 ); + break; } - return (PyObject*)PyString_FromString(str); + return ( PyObject * ) PyString_FromString( str ); } -//---------------BPy_Bone internal callbacks/methods--------------------------------------------- -//--------------- dealloc--------------------------------------------------------------------------------------- -static void -Bone_dealloc (BPy_Bone * self) + +//---------------BPy_Bone internal callbacks/methods--------------- + +//--------------- dealloc------------------------------------------ +static void Bone_dealloc( BPy_Bone * self ) { - PyMem_Free (self->name); - PyMem_Free (self->parent); - PyObject_DEL (self); + PyMem_Free( self->name ); + PyMem_Free( self->parent ); + PyObject_DEL( self ); } -//---------------getattr--------------------------------------------------------------------------------------- -static PyObject * -Bone_getAttr (BPy_Bone * self, char *name) + +//---------------getattr------------------------------------------- +static PyObject *Bone_getAttr( BPy_Bone * self, char *name ) { - PyObject *attr = Py_None; - - if (strcmp (name, "name") == 0) - attr = Bone_getName (self); - else if (strcmp (name, "roll") == 0) - attr = Bone_getRoll (self); - else if (strcmp (name, "head") == 0) - attr = Bone_getHead (self); - else if (strcmp (name, "tail") == 0) - attr = Bone_getTail (self); - else if (strcmp (name, "size") == 0) - attr = Bone_getSize (self); - else if (strcmp (name, "loc") == 0) - attr = Bone_getLoc (self); - else if (strcmp (name, "quat") == 0) - attr = Bone_getQuat (self); - else if (strcmp (name, "parent") == 0) - /* Skip the checks for Py_None as its a valid result to this call. */ - return Bone_getParent (self); - else if (strcmp (name, "children") == 0) - attr = Bone_getChildren (self); - else if (strcmp (name, "weight") == 0) - attr = Bone_getWeight (self); - else if (strcmp (name, "boneclass") == 0) - attr = Bone_getBoneclass (self); - else if (strcmp (name, "ik") == 0) - attr = Bone_hasIK (self); - else if (strcmp (name, "__members__") == 0) - { - /* 9 entries */ - attr = Py_BuildValue ("[s,s,s,s,s,s,s,s,s,s,s]", - "name", "roll", "head", "tail", "loc", "size", - "quat", "parent", "children", "weight", "boneclass", "ik"); - } - - if (!attr) - return (EXPP_ReturnPyObjError (PyExc_MemoryError, - "couldn't create PyObject")); - - if (attr != Py_None) - return attr; /* member attribute found, return it */ - - /* not an attribute, search the methods table */ - return Py_FindMethod (BPy_Bone_methods, (PyObject *) self, name); + PyObject *attr = Py_None; + + if( strcmp( name, "name" ) == 0 ) + attr = Bone_getName( self ); + else if( strcmp( name, "roll" ) == 0 ) + attr = Bone_getRoll( self ); + else if( strcmp( name, "head" ) == 0 ) + attr = Bone_getHead( self ); + else if( strcmp( name, "tail" ) == 0 ) + attr = Bone_getTail( self ); + else if( strcmp( name, "size" ) == 0 ) + attr = Bone_getSize( self ); + else if( strcmp( name, "loc" ) == 0 ) + attr = Bone_getLoc( self ); + else if( strcmp( name, "quat" ) == 0 ) + attr = Bone_getQuat( self ); + else if( strcmp( name, "parent" ) == 0 ) + /* Skip the checks for Py_None as its a valid result to this call. */ + return Bone_getParent( self ); + else if( strcmp( name, "children" ) == 0 ) + attr = Bone_getChildren( self ); + else if( strcmp( name, "weight" ) == 0 ) + attr = Bone_getWeight( self ); + else if( strcmp( name, "boneclass" ) == 0 ) + attr = Bone_getBoneclass( self ); + else if( strcmp( name, "ik" ) == 0 ) + attr = Bone_hasIK( self ); + else if( strcmp( name, "__members__" ) == 0 ) { + /* 9 entries */ + attr = Py_BuildValue( "[s,s,s,s,s,s,s,s,s,s,s]", + "name", "roll", "head", "tail", "loc", + "size", "quat", "parent", "children", + "weight", "boneclass", "ik" ); + } + + if( !attr ) + return ( EXPP_ReturnPyObjError( PyExc_MemoryError, + "couldn't create PyObject" ) ); + + if( attr != Py_None ) + return attr; /* member attribute found, return it */ + + /* not an attribute, search the methods table */ + return Py_FindMethod( BPy_Bone_methods, ( PyObject * ) self, name ); } -//--------------- setattr--------------------------------------------------------------------------------------- -static int -Bone_setAttr (BPy_Bone * self, char *name, PyObject * value) + +//--------------- setattr------------------------------------------- +static int Bone_setAttr( BPy_Bone * self, char *name, PyObject * value ) { - PyObject *valtuple; - PyObject *error = NULL; + PyObject *valtuple; + PyObject *error = NULL; - valtuple = Py_BuildValue ("(O)", value); /* the set* functions expect a tuple */ + valtuple = Py_BuildValue( "(O)", value ); /* the set* functions expect a tuple */ - if (!valtuple) - return EXPP_ReturnIntError (PyExc_MemoryError, - "BoneSetAttr: couldn't create tuple"); + if( !valtuple ) + return EXPP_ReturnIntError( PyExc_MemoryError, + "BoneSetAttr: couldn't create tuple" ); - if (strcmp (name, "name") == 0) - error = Bone_setName (self, valtuple); - else - { /* Error */ - Py_DECREF (valtuple); + if( strcmp( name, "name" ) == 0 ) + error = Bone_setName( self, valtuple ); + else { /* Error */ + Py_DECREF( valtuple ); - /* ... member with the given name was found */ - return (EXPP_ReturnIntError (PyExc_KeyError, "attribute not found")); - } + /* ... member with the given name was found */ + return ( EXPP_ReturnIntError + ( PyExc_KeyError, "attribute not found" ) ); + } - Py_DECREF (valtuple); + Py_DECREF( valtuple ); - if (error != Py_None) - return -1; + if( error != Py_None ) + return -1; - Py_DECREF (Py_None); /* was incref'ed by the called Bone_set* function */ - return 0; /* normal exit */ + Py_DECREF( Py_None ); /* was incref'ed by the called Bone_set* function */ + return 0; /* normal exit */ } -//--------------- repr--------------------------------------------------------------------------------------- -static PyObject * -Bone_repr (BPy_Bone * self) + +//--------------- repr--------------------------------------------- +static PyObject *Bone_repr( BPy_Bone * self ) { - if (self->bone) - return PyString_FromFormat ("[Bone \"%s\"]", self->bone->name); - else - return PyString_FromString ("NULL"); + if( self->bone ) + return PyString_FromFormat( "[Bone \"%s\"]", + self->bone->name ); + else + return PyString_FromString( "NULL" ); } -//--------------- compare--------------------------------------------------------------------------------------- -static int -Bone_compare (BPy_Bone * a, BPy_Bone * b) + +//--------------- compare------------------------------------------ +static int Bone_compare( BPy_Bone * a, BPy_Bone * b ) { - Bone *pa = a->bone, *pb = b->bone; - return (pa == pb) ? 0 : -1; + Bone *pa = a->bone, *pb = b->bone; + return ( pa == pb ) ? 0 : -1; } -//--------------- Bone_CreatePyObject-------------------------------------------------------------------- -PyObject * -Bone_CreatePyObject (struct Bone * bone) + +//--------------- Bone_CreatePyObject--------------------------------- +PyObject *Bone_CreatePyObject( struct Bone * bone ) { BPy_Bone *blen_bone; - blen_bone = (BPy_Bone *) PyObject_NEW (BPy_Bone, &Bone_Type); + blen_bone = ( BPy_Bone * ) PyObject_NEW( BPy_Bone, &Bone_Type ); //set the all important Bone flag blen_bone->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(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 , "bone struct empty"); - - return ((PyObject *) blen_bone); + blen_bone->name = PyMem_Malloc( 32 + 1 ); + blen_bone->parent = PyMem_Malloc( 32 + 1 ); + 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, + "bone struct empty" ); + + return ( ( PyObject * ) blen_bone ); } -//--------------- Bone_CheckPyObject-------------------------------------------------------------------- -int -Bone_CheckPyObject (PyObject * py_obj) + +//--------------- Bone_CheckPyObject-------------------------------- +int Bone_CheckPyObject( PyObject * py_obj ) { - return (py_obj->ob_type == &Bone_Type); + return ( py_obj->ob_type == &Bone_Type ); } -//--------------- Bone_FromPyObject-------------------------------------------------------------------- -struct Bone * -Bone_FromPyObject (PyObject * py_obj) + +//--------------- Bone_FromPyObject--------------------------------- +struct Bone *Bone_FromPyObject( PyObject * py_obj ) { - BPy_Bone *blen_obj; - - blen_obj = (BPy_Bone *) py_obj; - if (!((BPy_Bone*)py_obj)->bone) { //test to see if linked to armature - //use python vars - return NULL; - }else{ - //use bone datastruct - return (blen_obj->bone); - } + BPy_Bone *blen_obj; + + blen_obj = ( BPy_Bone * ) py_obj; + if( !( ( BPy_Bone * ) py_obj )->bone ) { //test to see if linked to armature + //use python vars + return NULL; + } else { + //use bone datastruct + return ( blen_obj->bone ); + } } -//--------------- Python Bone Module methods------------------------------------------------------------------ -//--------------- Blender.Armature.Bone.New()----------------------------------------------------------------- -static PyObject * -M_Bone_New (PyObject * self, PyObject * args) + +//--------------- Python Bone Module methods------------------------ + +//--------------- Blender.Armature.Bone.New()----------------------- +static PyObject *M_Bone_New( PyObject * self, PyObject * args ) { char *name_str = "BoneName"; char *parent_str = ""; BPy_Bone *py_bone = NULL; /* for Bone Data object wrapper in Python */ - if (!PyArg_ParseTuple (args, "|s", &name_str)) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, - "expected string or empty argument")); + if( !PyArg_ParseTuple( args, "|s", &name_str ) ) + return ( EXPP_ReturnPyObjError( PyExc_AttributeError, + "expected string or empty argument" ) ); //create python bone - py_bone = (BPy_Bone *) PyObject_NEW (BPy_Bone, &Bone_Type); + py_bone = ( BPy_Bone * ) PyObject_NEW( BPy_Bone, &Bone_Type ); //allocate space for python vars - py_bone->name= PyMem_Malloc (32 + 1); - py_bone->parent =PyMem_Malloc (32 + 1); - 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); - + py_bone->name = PyMem_Malloc( 32 + 1 ); + py_bone->parent = PyMem_Malloc( 32 + 1 ); + 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); - BLI_strncpy(py_bone->parent, parent_str, strlen(parent_str) + 1); + BLI_strncpy( py_bone->name, name_str, strlen( name_str ) + 1 ); + BLI_strncpy( py_bone->parent, parent_str, strlen( parent_str ) + 1 ); py_bone->roll = 0.0f; py_bone->flag = 32; py_bone->boneclass = BONE_SKINNABLE; py_bone->dist = 1.0f; py_bone->weight = 1.0f; - Vector_Zero(py_bone->head); - Vector_Zero(py_bone->loc); - Vector_Zero(py_bone->dloc); - Vector_Zero(py_bone->size); - Vector_Zero(py_bone->dsize); - Quaternion_Identity(py_bone->quat); - Quaternion_Identity(py_bone->dquat); - Matrix_Identity(py_bone->obmat); - Matrix_Identity(py_bone->parmat); - Matrix_Identity(py_bone->defmat); - Matrix_Identity(py_bone->irestmat); - Matrix_Identity(py_bone->posemat); + Vector_Zero( py_bone->head ); + Vector_Zero( py_bone->loc ); + Vector_Zero( py_bone->dloc ); + Vector_Zero( py_bone->size ); + Vector_Zero( py_bone->dsize ); + Quaternion_Identity( py_bone->quat ); + Quaternion_Identity( py_bone->dquat ); + Matrix_Identity( py_bone->obmat ); + Matrix_Identity( py_bone->parmat ); + Matrix_Identity( py_bone->defmat ); + Matrix_Identity( py_bone->irestmat ); + Matrix_Identity( py_bone->posemat ); //default tail of 2,0,0 py_bone->tail->vec[0] = 2.0f; @@ -594,734 +692,771 @@ M_Bone_New (PyObject * self, PyObject * args) //set the datapointer to null (unlinked) py_bone->bone = NULL; - return (PyObject *) py_bone; + return ( PyObject * ) py_bone; } -//--------------- Python BPy_Bone methods------------------------------------------------------------------ -//--------------- BPy_Bone.getName()-------------------------------------------------------------------------- -static PyObject * -Bone_getName (BPy_Bone * self) + +//--------------- Python BPy_Bone methods--------------------------- + +//--------------- BPy_Bone.getName()-------------------------------- +static PyObject *Bone_getName( BPy_Bone * self ) { - PyObject *attr = NULL; - - if (!self->bone) { //test to see if linked to armature - //use python vars - attr = PyString_FromString (self->name); - }else{ - //use bone datastruct - attr = PyString_FromString (self->bone->name); - } - if (attr) - return attr; - - return (EXPP_ReturnPyObjError (PyExc_RuntimeError, - "couldn't get Bone.name attribute")); + PyObject *attr = NULL; + + if( !self->bone ) { //test to see if linked to armature + //use python vars + attr = PyString_FromString( self->name ); + } else { + //use bone datastruct + attr = PyString_FromString( self->bone->name ); + } + if( attr ) + return attr; + + return ( EXPP_ReturnPyObjError( PyExc_RuntimeError, + "couldn't get Bone.name attribute" ) ); } -//--------------- BPy_Bone.getRoll()------------------------------------------------------------------------------ -static PyObject * -Bone_getRoll (BPy_Bone * self) + +//--------------- BPy_Bone.getRoll()--------------------------------- +static PyObject *Bone_getRoll( BPy_Bone * self ) { - PyObject *attr = NULL; - - if (!self->bone) { //test to see if linked to armature - //use python vars - attr = Py_BuildValue ("f", self->roll); - }else{ - //use bone datastruct - attr = Py_BuildValue ("f", self->bone->roll); - } - if (attr) - return attr; - - return (EXPP_ReturnPyObjError (PyExc_RuntimeError, - "couldn't get Bone.roll attribute")); + PyObject *attr = NULL; + + if( !self->bone ) { //test to see if linked to armature + //use python vars + attr = Py_BuildValue( "f", self->roll ); + } else { + //use bone datastruct + attr = Py_BuildValue( "f", self->bone->roll ); + } + if( attr ) + return attr; + + return ( EXPP_ReturnPyObjError( PyExc_RuntimeError, + "couldn't get Bone.roll attribute" ) ); } -//--------------- BPy_Bone.getWeight()---------------------------------------------------------------------------- -static PyObject * -Bone_getWeight (BPy_Bone * self) + +//--------------- BPy_Bone.getWeight()--------------------------------- +static PyObject *Bone_getWeight( BPy_Bone * self ) { - PyObject *attr = NULL; - - if (!self->bone) { //test to see if linked to armature - //use python vars - attr = Py_BuildValue ("f", self->weight); - }else{ - //use bone datastruct - attr = Py_BuildValue ("f", self->bone->weight); - } - if (attr) - return attr; - - return (EXPP_ReturnPyObjError (PyExc_RuntimeError, - "couldn't get Bone.weight attribute")); + PyObject *attr = NULL; + + if( !self->bone ) { //test to see if linked to armature + //use python vars + attr = Py_BuildValue( "f", self->weight ); + } else { + //use bone datastruct + attr = Py_BuildValue( "f", self->bone->weight ); + } + if( attr ) + return attr; + + return ( EXPP_ReturnPyObjError( PyExc_RuntimeError, + "couldn't get Bone.weight attribute" ) ); } -//--------------- BPy_Bone.getHead()-------------------------------------------------------------------------- -static PyObject * -Bone_getHead (BPy_Bone * self) + +//--------------- BPy_Bone.getHead()---------------------------------- +static PyObject *Bone_getHead( BPy_Bone * self ) { - PyObject *attr = NULL; - 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); - }else{ - //use bone datastruct - 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]; - } - if (attr) - return attr; - - return (EXPP_ReturnPyObjError (PyExc_RuntimeError, - "couldn't get Bone.head attribute")); + PyObject *attr = NULL; + 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 ); + } else { + //use bone datastruct + 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]; + } + if( attr ) + return attr; + + return ( EXPP_ReturnPyObjError( PyExc_RuntimeError, + "couldn't get Bone.head attribute" ) ); } -//--------------- BPy_Bone.getTail()-------------------------------------------------------------------------- -static PyObject * -Bone_getTail (BPy_Bone * self) + +//--------------- BPy_Bone.getTail()--------------------------------- +static PyObject *Bone_getTail( BPy_Bone * self ) { - PyObject *attr = NULL; - 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); - }else{ - //use bone datastruct - 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]; - } - if (attr) - return attr; - - return (EXPP_ReturnPyObjError (PyExc_RuntimeError, - "couldn't get Bone.tail attribute")); + PyObject *attr = NULL; + 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 ); + } else { + //use bone datastruct + 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]; + } + if( attr ) + return attr; + + return ( EXPP_ReturnPyObjError( PyExc_RuntimeError, + "couldn't get Bone.tail attribute" ) ); } -//--------------- BPy_Bone.getLoc()---------------------------------------------------------------------------- -static PyObject * -Bone_getLoc (BPy_Bone * self) + +//--------------- BPy_Bone.getLoc()--------------------------------- +static PyObject *Bone_getLoc( BPy_Bone * self ) { - PyObject *attr = NULL; - 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); - }else{ - //use bone datastruct - 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]; - } - if (attr) - return attr; - - return (EXPP_ReturnPyObjError (PyExc_RuntimeError, - "couldn't get Bone.loc attribute")); + PyObject *attr = NULL; + 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 ); + } else { + //use bone datastruct + 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]; + } + if( attr ) + return attr; + + return ( EXPP_ReturnPyObjError( PyExc_RuntimeError, + "couldn't get Bone.loc attribute" ) ); } -//--------------- BPy_Bone.getSize()---------------------------------------------------------------------------- -static PyObject * -Bone_getSize (BPy_Bone * self) + +//--------------- BPy_Bone.getSize()----------------------------- +static PyObject *Bone_getSize( BPy_Bone * self ) { - PyObject *attr = NULL; - 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); - }else{ - //use bone datastruct - 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]; - } - if (attr) - return attr; - - return (EXPP_ReturnPyObjError (PyExc_RuntimeError, - "couldn't get Bone.size attribute")); + PyObject *attr = NULL; + 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 ); + } else { + //use bone datastruct + 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]; + } + if( attr ) + return attr; + + return ( EXPP_ReturnPyObjError( PyExc_RuntimeError, + "couldn't get Bone.size attribute" ) ); } -//--------------- BPy_Bone.getQuat()---------------------------------------------------------------------------- -static PyObject * -Bone_getQuat (BPy_Bone * self) + +//--------------- BPy_Bone.getQuat()-------------------------------- +static PyObject *Bone_getQuat( BPy_Bone * self ) { - PyObject *attr = NULL; - 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); - }else{ - //use bone datastruct - 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]; - ((QuaternionObject*)attr)->quat[3] = self->bone->quat[3]; - } - - return attr; + PyObject *attr = NULL; + 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 ); + } else { + //use bone datastruct + 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]; + ( ( QuaternionObject * ) attr )->quat[3] = self->bone->quat[3]; + } + + return attr; } -//--------------- BPy_Bone.hasParent()-------------------------------------------------------------------------- -static PyObject * -Bone_hasParent (BPy_Bone * self) + +//--------------- BPy_Bone.hasParent()--------------------------- +static PyObject *Bone_hasParent( BPy_Bone * self ) { - char * parent_str = ""; + char *parent_str = ""; - if (!self->bone) { //test to see if linked to armature + if( !self->bone ) { //test to see if linked to armature //use python vars - if (BLI_streq(self->parent, parent_str)) { - Py_INCREF (Py_False); - return Py_False; - }else{ - Py_INCREF (Py_True); - return Py_True; + if( BLI_streq( self->parent, parent_str ) ) { + Py_INCREF( Py_False ); + return Py_False; + } else { + Py_INCREF( Py_True ); + return Py_True; } - }else{ + } else { //use bone datastruct - if (self->bone->parent) { - Py_INCREF (Py_True); - return Py_True; - }else{ - Py_INCREF (Py_False); - return Py_False; + if( self->bone->parent ) { + Py_INCREF( Py_True ); + return Py_True; + } else { + Py_INCREF( Py_False ); + return Py_False; } } } -//--------------- BPy_Bone.getParent()-------------------------------------------------------------------------- -static PyObject * -Bone_getParent (BPy_Bone * self) + +//--------------- BPy_Bone.getParent()------------------------------ +static PyObject *Bone_getParent( BPy_Bone * self ) { - char * parent_str = ""; - if (!self->bone) { //test to see if linked to armature + char *parent_str = ""; + if( !self->bone ) { //test to see if linked to armature //use python vars - if (BLI_streq(self->parent, parent_str)) { - return EXPP_incr_ret (Py_None); - }else{ - return PyString_FromString(self->parent); - } - }else{ + if( BLI_streq( self->parent, parent_str ) ) { + return EXPP_incr_ret( Py_None ); + } else { + return PyString_FromString( self->parent ); + } + } else { //use bone datastruct - if (self->bone->parent) { - return Bone_CreatePyObject (self->bone->parent); - }else{ - return EXPP_incr_ret (Py_None); + if( self->bone->parent ) { + return Bone_CreatePyObject( self->bone->parent ); + } else { + return EXPP_incr_ret( Py_None ); } } } -//--------------- BPy_Bone.getChildren()-------------------------------------------------------------------------- -static PyObject * -Bone_getChildren (BPy_Bone * self) + +//--------------- BPy_Bone.getChildren()----------------------------- +static PyObject *Bone_getChildren( BPy_Bone * self ) { - int totbones = 0; - Bone *current = NULL; - PyObject *listbones = NULL; - int i; - - if (!self->bone) { //test to see if linked to armature - //use python vars - return EXPP_incr_ret (Py_None); - }else{ - //use bone datastruct - current = self->bone->childbase.first; - for (; current; current = current->next) - totbones++; - - /* Create a list with a bone wrapper for each bone */ - current = self->bone->childbase.first; - listbones = PyList_New (totbones); - for (i = 0; i < totbones; i++){ - assert (current); - PyList_SetItem (listbones, i, Bone_CreatePyObject (current)); - current = current->next; - } - return listbones; - } + int totbones = 0; + Bone *current = NULL; + PyObject *listbones = NULL; + int i; + + if( !self->bone ) { //test to see if linked to armature + //use python vars + return EXPP_incr_ret( Py_None ); + } else { + //use bone datastruct + current = self->bone->childbase.first; + for( ; current; current = current->next ) + totbones++; + + /* Create a list with a bone wrapper for each bone */ + current = self->bone->childbase.first; + listbones = PyList_New( totbones ); + for( i = 0; i < totbones; i++ ) { + assert( current ); + PyList_SetItem( listbones, i, + Bone_CreatePyObject( current ) ); + current = current->next; + } + return listbones; + } } -//--------------- BPy_Bone.setName()-------------------------------------------------------------------------- -static PyObject * -Bone_setName (BPy_Bone * self, PyObject * args) + +//--------------- BPy_Bone.setName()--------------------------------- +static PyObject *Bone_setName( BPy_Bone * self, PyObject * args ) { - char *name; - - if (!PyArg_ParseTuple (args, "s", &name)) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, "expected string argument")); - - if (!self->bone) { //test to see if linked to armature - //use python vars - BLI_strncpy(self->name, name, strlen(name) + 1); - }else{ - //use bone datastruct - BLI_strncpy(self->bone->name, name, strlen(name) + 1); - } - return EXPP_incr_ret (Py_None); + char *name; + + if( !PyArg_ParseTuple( args, "s", &name ) ) + return ( EXPP_ReturnPyObjError + ( PyExc_AttributeError, + "expected string argument" ) ); + + if( !self->bone ) { //test to see if linked to armature + //use python vars + BLI_strncpy( self->name, name, strlen( name ) + 1 ); + } else { + //use bone datastruct + BLI_strncpy( self->bone->name, name, strlen( name ) + 1 ); + } + return EXPP_incr_ret( Py_None ); } -//--------------- BPy_Bone.setRoll()-------------------------------------------------------------------------- -PyObject * -Bone_setRoll (BPy_Bone * self, PyObject * args) + +//--------------- BPy_Bone.setRoll()-------------------------------- +PyObject *Bone_setRoll( BPy_Bone * self, PyObject * args ) { - float roll; - - if (!PyArg_ParseTuple (args, "f", &roll)) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, - "expected float argument")); - - if (!self->bone) { //test to see if linked to armature - //use python vars - self->roll = roll; - }else{ - //use bone datastruct - self->bone->roll = roll; - } - return EXPP_incr_ret (Py_None); + float roll; + + if( !PyArg_ParseTuple( args, "f", &roll ) ) + return ( EXPP_ReturnPyObjError( PyExc_AttributeError, + "expected float argument" ) ); + + if( !self->bone ) { //test to see if linked to armature + //use python vars + self->roll = roll; + } else { + //use bone datastruct + self->bone->roll = roll; + } + return EXPP_incr_ret( Py_None ); } -//--------------- BPy_Bone.setHead()-------------------------------------------------------------------------- -static PyObject * -Bone_setHead (BPy_Bone * self, PyObject * args) + +//--------------- BPy_Bone.setHead()--------------------------------- +static PyObject *Bone_setHead( BPy_Bone * self, PyObject * args ) { - float f1, f2, f3; - int status; + float f1, f2, f3; + int status; - if (PyObject_Length (args) == 3) - status = PyArg_ParseTuple (args, "fff", &f1, &f2, &f3); - else - status = PyArg_ParseTuple (args, "(fff)", &f1, &f2, &f3); + if( PyObject_Length( args ) == 3 ) + status = PyArg_ParseTuple( args, "fff", &f1, &f2, &f3 ); + else + status = PyArg_ParseTuple( args, "(fff)", &f1, &f2, &f3 ); - if (!status) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, - "expected 3 (or a list of 3) float arguments")); + if( !status ) + return ( EXPP_ReturnPyObjError( PyExc_AttributeError, + "expected 3 (or a list of 3) float arguments" ) ); - if (!self->bone) { //test to see if linked to armature + if( !self->bone ) { //test to see if linked to armature //use python vars self->head->vec[0] = f1; self->head->vec[1] = f2; self->head->vec[2] = f3; - }else{ + } else { //use bone datastruct self->bone->head[0] = f1; self->bone->head[1] = f2; self->bone->head[2] = f3; - } - return EXPP_incr_ret (Py_None); -} -//--------------- BPy_Bone.setTail()-------------------------------------------------------------------------- -static PyObject * -Bone_setTail (BPy_Bone * self, PyObject * args) -{ - float f1, f2, f3; - int status; - - if (PyObject_Length (args) == 3) - status = PyArg_ParseTuple (args, "fff", &f1, &f2, &f3); - else - status = PyArg_ParseTuple (args, "(fff)", &f1, &f2, &f3); - - if (!status) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, - "expected 3 (or a list of 3) float arguments")); - - if (!self->bone) { //test to see if linked to armature - //use python vars - self->tail->vec[0] = f1; - self->tail->vec[1] = f2; - self->tail->vec[2] = f3; - }else{ - //use bone datastruct - self->bone->tail[0] = f1; - self->bone->tail[1] = f2; - self->bone->tail[2] = f3; - } - return EXPP_incr_ret (Py_None); + } + return EXPP_incr_ret( Py_None ); } -//--------------- BPy_Bone.setLoc()-------------------------------------------------------------------------- -static PyObject * -Bone_setLoc (BPy_Bone * self, PyObject * args) + +//--------------- BPy_Bone.setTail()--------------------------------- +static PyObject *Bone_setTail( BPy_Bone * self, PyObject * args ) { - float f1, f2, f3; - int status; - - if (PyObject_Length (args) == 3) - status = PyArg_ParseTuple (args, "fff", &f1, &f2, &f3); - else - status = PyArg_ParseTuple (args, "(fff)", &f1, &f2, &f3); - - if (!status) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, - "expected 3 (or a list of 3) float arguments")); - - if (!self->bone) { //test to see if linked to armature - //use python vars - self->loc->vec[0] = f1; - self->loc->vec[1] = f2; - self->loc->vec[2] = f3; - }else{ - //use bone datastruct - self->bone->loc[0] = f1; - self->bone->loc[1] = f2; - self->bone->loc[2] = f3; - } - return EXPP_incr_ret (Py_None); + float f1, f2, f3; + int status; + + if( PyObject_Length( args ) == 3 ) + status = PyArg_ParseTuple( args, "fff", &f1, &f2, &f3 ); + else + status = PyArg_ParseTuple( args, "(fff)", &f1, &f2, &f3 ); + + if( !status ) + return ( EXPP_ReturnPyObjError( PyExc_AttributeError, + "expected 3 (or a list of 3) float arguments" ) ); + + if( !self->bone ) { //test to see if linked to armature + //use python vars + self->tail->vec[0] = f1; + self->tail->vec[1] = f2; + self->tail->vec[2] = f3; + } else { + //use bone datastruct + self->bone->tail[0] = f1; + self->bone->tail[1] = f2; + self->bone->tail[2] = f3; + } + return EXPP_incr_ret( Py_None ); } -//--------------- BPy_Bone.setSize()-------------------------------------------------------------------------- -static PyObject * -Bone_setSize (BPy_Bone * self, PyObject * args) + +//--------------- BPy_Bone.setLoc()---------------------------------- +static PyObject *Bone_setLoc( BPy_Bone * self, PyObject * args ) { - float f1, f2, f3; - int status; - - if (PyObject_Length (args) == 3) - status = PyArg_ParseTuple (args, "fff", &f1, &f2, &f3); - else - status = PyArg_ParseTuple (args, "(fff)", &f1, &f2, &f3); - - if (!status) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, - "expected 3 (or a list of 3) float arguments")); - - if (!self->bone) { //test to see if linked to armature - //use python vars - self->size->vec[0] = f1; - self->size->vec[1] = f2; - self->size->vec[2] = f3; - }else{ - //use bone datastruct - self->bone->size[0] = f1; - self->bone->size[1] = f2; - self->bone->size[2] = f3; - } - return EXPP_incr_ret (Py_None); + float f1, f2, f3; + int status; + + if( PyObject_Length( args ) == 3 ) + status = PyArg_ParseTuple( args, "fff", &f1, &f2, &f3 ); + else + status = PyArg_ParseTuple( args, "(fff)", &f1, &f2, &f3 ); + + if( !status ) + return ( EXPP_ReturnPyObjError( PyExc_AttributeError, + "expected 3 (or a list of 3) float arguments" ) ); + + if( !self->bone ) { //test to see if linked to armature + //use python vars + self->loc->vec[0] = f1; + self->loc->vec[1] = f2; + self->loc->vec[2] = f3; + } else { + //use bone datastruct + self->bone->loc[0] = f1; + self->bone->loc[1] = f2; + self->bone->loc[2] = f3; + } + return EXPP_incr_ret( Py_None ); } -//--------------- BPy_Bone.setQuat()-------------------------------------------------------------------------- -static PyObject * -Bone_setQuat (BPy_Bone * self, PyObject * args) + +//--------------- BPy_Bone.setSize()--------------------------------- +static PyObject *Bone_setSize( BPy_Bone * self, PyObject * args ) { - float f1, f2, f3, f4; - PyObject *argument; - QuaternionObject *quatOb; - int status; + float f1, f2, f3; + int status; + + if( PyObject_Length( args ) == 3 ) + status = PyArg_ParseTuple( args, "fff", &f1, &f2, &f3 ); + else + status = PyArg_ParseTuple( args, "(fff)", &f1, &f2, &f3 ); - if (!PyArg_ParseTuple(args, "O", &argument)) - return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected quaternion or float list")); + if( !status ) + return ( EXPP_ReturnPyObjError( PyExc_AttributeError, + "expected 3 (or a list of 3) float arguments" ) ); + + if( !self->bone ) { //test to see if linked to armature + //use python vars + self->size->vec[0] = f1; + self->size->vec[1] = f2; + self->size->vec[2] = f3; + } else { + //use bone datastruct + self->bone->size[0] = f1; + self->bone->size[1] = f2; + self->bone->size[2] = f3; + } + return EXPP_incr_ret( Py_None ); +} - if(QuaternionObject_Check(argument)){ - status = PyArg_ParseTuple(args, "O!", &quaternion_Type, &quatOb); +//--------------- BPy_Bone.setQuat()------------------------------- +static PyObject *Bone_setQuat( BPy_Bone * self, PyObject * args ) +{ + float f1, f2, f3, f4; + PyObject *argument; + QuaternionObject *quatOb; + int status; + + if( !PyArg_ParseTuple( args, "O", &argument ) ) + return ( EXPP_ReturnPyObjError + ( PyExc_TypeError, + "expected quaternion or float list" ) ); + + if( QuaternionObject_Check( argument ) ) { + status = PyArg_ParseTuple( args, "O!", &quaternion_Type, + &quatOb ); f1 = quatOb->quat[0]; f2 = quatOb->quat[1]; f3 = quatOb->quat[2]; f4 = quatOb->quat[3]; - }else{ - status = PyArg_ParseTuple (args, "(ffff)", &f1, &f2, &f3, &f4); - } - - if (!status) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, - "unable to parse argument")); - - if (!self->bone) { //test to see if linked to armature - //use python vars - self->quat->quat[0] = f1; - self->quat->quat[1] = f2; - self->quat->quat[2] = f3; - self->quat->quat[3] = f4; - }else{ - //use bone datastruct - self->bone->quat[0] = f1; - self->bone->quat[1] = f2; - self->bone->quat[2] = f3; - self->bone->quat[3] = f4; - } - return EXPP_incr_ret (Py_None); + } else { + status = PyArg_ParseTuple( args, "(ffff)", &f1, &f2, &f3, + &f4 ); + } + + if( !status ) + return ( EXPP_ReturnPyObjError( PyExc_AttributeError, + "unable to parse argument" ) ); + + if( !self->bone ) { //test to see if linked to armature + //use python vars + self->quat->quat[0] = f1; + self->quat->quat[1] = f2; + self->quat->quat[2] = f3; + self->quat->quat[3] = f4; + } else { + //use bone datastruct + self->bone->quat[0] = f1; + self->bone->quat[1] = f2; + self->bone->quat[2] = f3; + self->bone->quat[3] = f4; + } + return EXPP_incr_ret( Py_None ); } -//--------------- BPy_Bone.setParent()------------------------------------------------------------------------- -static PyObject * -Bone_setParent(BPy_Bone *self, PyObject *args) + +//--------------- BPy_Bone.setParent()------------------------------ +static PyObject *Bone_setParent( BPy_Bone * self, PyObject * args ) { - BPy_Bone* py_bone; + BPy_Bone *py_bone; float M_boneObjectspace[4][4]; float iM_parentRest[4][4]; - if (!PyArg_ParseTuple(args, "O", &py_bone)) - return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected bone object argument")); + if( !PyArg_ParseTuple( args, "O", &py_bone ) ) + return ( EXPP_ReturnPyObjError + ( PyExc_TypeError, + "expected bone object argument" ) ); - if (!self->bone) { //test to see if linked to armature + if( !self->bone ) { //test to see if linked to armature //use python vars - BLI_strncpy(self->parent, py_bone->name, strlen(py_bone->name) + 1); - }else{ + BLI_strncpy( self->parent, py_bone->name, + strlen( py_bone->name ) + 1 ); + } else { //use bone datastruct - if(!py_bone->bone) - return (EXPP_ReturnPyObjError (PyExc_TypeError, "Parent bone must be linked to armature first!")); + if( !py_bone->bone ) + return ( EXPP_ReturnPyObjError + ( PyExc_TypeError, + "Parent bone must be linked to armature first!" ) ); - if(py_bone->bone == self->bone) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, "Cannot parent to self")); + if( py_bone->bone == self->bone ) + return ( EXPP_ReturnPyObjError + ( PyExc_AttributeError, + "Cannot parent to self" ) ); //test to see if were creating an illegal loop by parenting to child - if(testChildbase(self->bone, py_bone->bone)) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, "Cannot parent to child")); + if( testChildbase( self->bone, py_bone->bone ) ) + return ( EXPP_ReturnPyObjError + ( PyExc_AttributeError, + "Cannot parent to child" ) ); - //set the parent of self - in this case we are changing the parenting after this bone + //set the parent of self - in this case + //we are changing the parenting after this bone //has been linked in it's armature - if(self->bone->parent){ //we are parenting something previously parented + if( self->bone->parent ) { //we are parenting something previously parented //remove the childbase link from the parent bone - BLI_remlink(&self->bone->parent->childbase, self->bone); + BLI_remlink( &self->bone->parent->childbase, + self->bone ); //now get rid of the parent transformation - get_objectspace_bone_matrix(self->bone->parent, M_boneObjectspace, 0,0); - Mat4MulVecfl(M_boneObjectspace, self->bone->head); - Mat4MulVecfl(M_boneObjectspace, self->bone->tail); - + get_objectspace_bone_matrix( self->bone->parent, + M_boneObjectspace, 0, 0 ); + Mat4MulVecfl( M_boneObjectspace, self->bone->head ); + Mat4MulVecfl( M_boneObjectspace, self->bone->tail ); + //add to the childbase of new parent - BLI_addtail (&py_bone->bone->childbase, self->bone); + BLI_addtail( &py_bone->bone->childbase, self->bone ); //transform bone according to new parent - get_objectspace_bone_matrix(py_bone->bone, M_boneObjectspace, 0,0); - Mat4Invert (iM_parentRest, M_boneObjectspace); - Mat4MulVecfl(iM_parentRest, self->bone->head); - Mat4MulVecfl(iM_parentRest, self->bone->tail); + get_objectspace_bone_matrix( py_bone->bone, + M_boneObjectspace, 0, 0 ); + Mat4Invert( iM_parentRest, M_boneObjectspace ); + Mat4MulVecfl( iM_parentRest, self->bone->head ); + Mat4MulVecfl( iM_parentRest, self->bone->tail ); //set parent self->bone->parent = py_bone->bone; - }else{ //not previously parented + } else { //not previously parented //add to the childbase of new parent - BLI_addtail (&py_bone->bone->childbase, self->bone); + BLI_addtail( &py_bone->bone->childbase, self->bone ); //transform bone according to new parent - get_objectspace_bone_matrix(py_bone->bone, M_boneObjectspace, 0,0); - Mat4Invert (iM_parentRest, M_boneObjectspace); - Mat4MulVecfl(iM_parentRest, self->bone->head); - Mat4MulVecfl(iM_parentRest, self->bone->tail); + get_objectspace_bone_matrix( py_bone->bone, + M_boneObjectspace, 0, 0 ); + Mat4Invert( iM_parentRest, M_boneObjectspace ); + Mat4MulVecfl( iM_parentRest, self->bone->head ); + Mat4MulVecfl( iM_parentRest, self->bone->tail ); self->bone->parent = py_bone->bone; } } - return EXPP_incr_ret (Py_None); + return EXPP_incr_ret( Py_None ); } -//--------------- BPy_Bone.setWeight()------------------------------------------------------------------------- -static PyObject * -Bone_setWeight(BPy_Bone *self, PyObject *args) + +//--------------- BPy_Bone.setWeight()---------------------------- +static PyObject *Bone_setWeight( BPy_Bone * self, PyObject * args ) { - float weight; - - if (!PyArg_ParseTuple (args, "f", &weight)) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, - "expected float argument")); - - if (!self->bone) { //test to see if linked to armature - //use python vars - self->weight = weight; - }else{ - //use bone datastruct - self->bone->weight = weight; - } - return EXPP_incr_ret (Py_None); + float weight; + + if( !PyArg_ParseTuple( args, "f", &weight ) ) + return ( EXPP_ReturnPyObjError( PyExc_AttributeError, + "expected float argument" ) ); + + if( !self->bone ) { //test to see if linked to armature + //use python vars + self->weight = weight; + } else { + //use bone datastruct + self->bone->weight = weight; + } + return EXPP_incr_ret( Py_None ); } -//--------------- BPy_Bone.clearParent()------------------------------------------------------------------------- -static PyObject * -Bone_clearParent(BPy_Bone *self) + +//--------------- BPy_Bone.clearParent()-------------------------- +static PyObject *Bone_clearParent( BPy_Bone * self ) { - bArmature *arm = NULL; - Bone *bone = NULL; - Bone *parent = NULL; - Bone *child = NULL; - Bone *childPrev = NULL; - int firstChild; - float M_boneObjectspace[4][4]; - char *parent_str = ""; - - if (!self->bone) { //test to see if linked to armature - //use python vars - BLI_strncpy(self->parent, parent_str, strlen(parent_str) + 1); - }else{ - //use bone datastruct - if(self->bone->parent == NULL) - return EXPP_incr_ret(Py_None); - - //get parent and remove link - parent = self->bone->parent; - self->bone->parent = NULL; - - //remove the childbase link from the parent bone - firstChild = 1; - for(child = parent->childbase.first; child; child = child->next){ - if(child == self->bone && firstChild){ + bArmature *arm = NULL; + Bone *bone = NULL; + Bone *parent = NULL; + Bone *child = NULL; + Bone *childPrev = NULL; + int firstChild; + float M_boneObjectspace[4][4]; + char *parent_str = ""; + + if( !self->bone ) { //test to see if linked to armature + //use python vars + BLI_strncpy( self->parent, parent_str, + strlen( parent_str ) + 1 ); + } else { + //use bone datastruct + if( self->bone->parent == NULL ) + return EXPP_incr_ret( Py_None ); + + //get parent and remove link + parent = self->bone->parent; + self->bone->parent = NULL; + + //remove the childbase link from the parent bone + firstChild = 1; + for( child = parent->childbase.first; child; + child = child->next ) { + if( child == self->bone && firstChild ) { parent->childbase.first = child->next; child->next = NULL; break; + } + if( child == self->bone && !firstChild ) { + childPrev->next = child->next; + child->next = NULL; + break; + } + firstChild = 0; + childPrev = child; } - if(child == self->bone && !firstChild){ - childPrev->next = child->next; - child->next = NULL; - break; - } - firstChild = 0; - childPrev = child; - } - //now get rid of the parent transformation - get_objectspace_bone_matrix(parent, M_boneObjectspace, 0,0); + //now get rid of the parent transformation + get_objectspace_bone_matrix( parent, M_boneObjectspace, 0, 0 ); - //transformation of local bone - Mat4MulVecfl(M_boneObjectspace, self->bone->head); - Mat4MulVecfl(M_boneObjectspace, self->bone->tail); + //transformation of local bone + Mat4MulVecfl( M_boneObjectspace, self->bone->head ); + Mat4MulVecfl( M_boneObjectspace, self->bone->tail ); - //get the root bone - while(parent->parent != NULL){ - parent = parent->parent; - } + //get the root bone + while( parent->parent != NULL ) { + parent = parent->parent; + } - //add unlinked bone to the bonebase of the armature - for (arm = G.main->armature.first; arm; arm= arm->id.next) { - for(bone = arm->bonebase.first; bone; bone = bone->next){ - if(parent == bone){ - //we found the correct armature - now add it as root bone - BLI_addtail (&arm->bonebase, self->bone); - break; + //add unlinked bone to the bonebase of the armature + for( arm = G.main->armature.first; arm; arm = arm->id.next ) { + for( bone = arm->bonebase.first; bone; + bone = bone->next ) { + if( parent == bone ) { + //we found the correct armature - now add it as root bone + BLI_addtail( &arm->bonebase, + self->bone ); + break; + } } - } + } } - } - return EXPP_incr_ret (Py_None); + return EXPP_incr_ret( Py_None ); } -//--------------- BPy_Bone.clearChildren()------------------------------------------------------------------------- -static PyObject * -Bone_clearChildren(BPy_Bone *self) -{ - Bone *root = NULL; - Bone *child = NULL; - bArmature *arm = NULL; - Bone *bone = NULL; - Bone *prev = NULL; - Bone *next = NULL; - float M_boneObjectspace[4][4]; - int first; - - if (!self->bone) { //test to see if linked to armature - //use python vars - return EXPP_incr_ret (Py_None); - }else{ - //use bone datastruct - if(self->bone->childbase.first == NULL) - return EXPP_incr_ret(Py_None); + +//--------------- BPy_Bone.clearChildren()------------------------ +static PyObject *Bone_clearChildren( BPy_Bone * self ) +{ + Bone *root = NULL; + Bone *child = NULL; + bArmature *arm = NULL; + Bone *bone = NULL; + Bone *prev = NULL; + Bone *next = NULL; + float M_boneObjectspace[4][4]; + int first; + + if( !self->bone ) { //test to see if linked to armature + //use python vars + return EXPP_incr_ret( Py_None ); + } else { + //use bone datastruct + if( self->bone->childbase.first == NULL ) + return EXPP_incr_ret( Py_None ); //is this bone a part of an armature.... //get root bone for testing root = self->bone->parent; - if(root != NULL){ - while (root->parent != NULL){ + if( root != NULL ) { + while( root->parent != NULL ) { root = root->parent; } - }else{ + } else { root = self->bone; } //test armatures for root bone - for(arm= G.main->armature.first; arm; arm = arm->id.next){ - for(bone = arm->bonebase.first; bone; bone = bone->next){ - if(bone == root) + for( arm = G.main->armature.first; arm; arm = arm->id.next ) { + for( bone = arm->bonebase.first; bone; + bone = bone->next ) { + if( bone == root ) break; } - if(bone == root) + if( bone == root ) break; } - if(arm == NULL) - return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't find armature that contains this bone")); - - //now get rid of the parent transformation - get_objectspace_bone_matrix(self->bone, M_boneObjectspace, 0,0); - - //set children as root - first = 1; - for(child = self->bone->childbase.first; child; child = next){ - //undo transformation of local bone - Mat4MulVecfl(M_boneObjectspace, child->head); - Mat4MulVecfl(M_boneObjectspace, child->tail); - - //set next pointers to NULL - if(first){ - prev = child; - first = 0; - }else{ - prev->next = NULL; - prev = child; - } - next = child->next; + if( arm == NULL ) + return ( EXPP_ReturnPyObjError + ( PyExc_RuntimeError, + "couldn't find armature that contains this bone" ) ); + + //now get rid of the parent transformation + get_objectspace_bone_matrix( self->bone, M_boneObjectspace, 0, + 0 ); + + //set children as root + first = 1; + for( child = self->bone->childbase.first; child; child = next ) { + //undo transformation of local bone + Mat4MulVecfl( M_boneObjectspace, child->head ); + Mat4MulVecfl( M_boneObjectspace, child->tail ); + + //set next pointers to NULL + if( first ) { + prev = child; + first = 0; + } else { + prev->next = NULL; + prev = child; + } + next = child->next; - //remove parenting and linking - child->parent = NULL; - BLI_remlink(&self->bone->childbase, child); + //remove parenting and linking + child->parent = NULL; + BLI_remlink( &self->bone->childbase, child ); - //add as root - BLI_addtail (&arm->bonebase, child); + //add as root + BLI_addtail( &arm->bonebase, child ); + } } - } - Py_INCREF(Py_None); - return Py_None; + Py_INCREF( Py_None ); + return Py_None; } -//--------------- BPy_Bone.hide()--------------------------------------------------------------------------------- -static PyObject * -Bone_hide(BPy_Bone *self) + +//--------------- BPy_Bone.hide()----------------------------------- +static PyObject *Bone_hide( BPy_Bone * self ) { - if (!self->bone) { //test to see if linked to armature - //use python vars - return EXPP_ReturnPyObjError (PyExc_TypeError, "link bone to armature before attempting to hide/unhide"); - }else{ - //use bone datastruct - if(!(self->bone->flag & BONE_HIDDEN)) + if( !self->bone ) { //test to see if linked to armature + //use python vars + return EXPP_ReturnPyObjError( PyExc_TypeError, + "link bone to armature before attempting to hide/unhide" ); + } else { + //use bone datastruct + if( !( self->bone->flag & BONE_HIDDEN ) ) self->bone->flag |= BONE_HIDDEN; - } - return EXPP_incr_ret (Py_None); + } + return EXPP_incr_ret( Py_None ); } -//--------------- BPy_Bone.unhide()--------------------------------------------------------------------------------- -static PyObject * -Bone_unhide(BPy_Bone *self) + +//--------------- BPy_Bone.unhide()------------------------------- +static PyObject *Bone_unhide( BPy_Bone * self ) { - if (!self->bone) { //test to see if linked to armature - //use python vars - return EXPP_ReturnPyObjError (PyExc_TypeError, "link bone to armature before attempting to hide/unhide"); - }else{ - //use bone datastruct - if(self->bone->flag & BONE_HIDDEN) - self->bone->flag &= ~BONE_HIDDEN; - } - return EXPP_incr_ret (Py_None); + if( !self->bone ) { //test to see if linked to armature + //use python vars + return EXPP_ReturnPyObjError( PyExc_TypeError, + "link bone to armature before attempting to hide/unhide" ); + } else { + //use bone datastruct + if( self->bone->flag & BONE_HIDDEN ) + self->bone->flag &= ~BONE_HIDDEN; + } + return EXPP_incr_ret( Py_None ); } -//--------------- BPy_Bone.setPose()----------------------------------------------------------------------------------- -static PyObject * -Bone_setPose (BPy_Bone *self, PyObject *args) + +//--------------- BPy_Bone.setPose()------------------------------- +static PyObject *Bone_setPose( BPy_Bone * self, PyObject * args ) { Bone *root = NULL; bPoseChannel *chan = NULL; bPoseChannel *setChan = NULL; bPoseChannel *test = NULL; - Object *object =NULL; + Object *object = NULL; bArmature *arm = NULL; Bone *bone = NULL; PyObject *flaglist = NULL; @@ -1331,230 +1466,253 @@ Bone_setPose (BPy_Bone *self, PyObject *args) int flagValue = 0; int makeCurve = 1; - if (!self->bone) { //test to see if linked to armature - //use python vars - return EXPP_ReturnPyObjError (PyExc_TypeError, "cannot set pose unless bone is linked to armature"); - }else{ - //use bone datastruct - if (!PyArg_ParseTuple (args, "O!|O!", &PyList_Type, &flaglist, &Action_Type, &py_action)) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, - "expected list of flags and optional action")); - - for(x = 0; x < PyList_Size(flaglist); x++){ - item = PyList_GetItem(flaglist, x); - if(PyInt_Check(item)){ - flagValue |= PyInt_AsLong(item); - }else{ - return (EXPP_ReturnPyObjError (PyExc_AttributeError, - "expected list of flags (ints)")); - } - } - - //is this bone a part of an armature.... - //get root bone for testing - root = self->bone->parent; - if(root != NULL){ - while (root->parent != NULL){ - root = root->parent; - } - }else{ - root = self->bone; - } - //test armatures for root bone - for(arm= G.main->armature.first; arm; arm = arm->id.next){ - for(bone = arm->bonebase.first; bone; bone = bone->next){ - if(bone == root) - break; - } - if(bone == root) - break; - } - if(arm == NULL) - return (EXPP_ReturnPyObjError (PyExc_RuntimeError, - "bone must belong to an armature to set it's pose!")); - - //find if armature is object linked.... - for(object = G.main->object.first; object; object = object->id.next){ - if(object->data == arm){ - break; - } - } - - if(object == NULL) - return (EXPP_ReturnPyObjError (PyExc_RuntimeError, - "armature must be linked to an object to set a pose!")); - - //set the active action as this one - if(py_action !=NULL){ - if(py_action->action != NULL){ - object->action = py_action->action; + if( !self->bone ) { //test to see if linked to armature + //use python vars + return EXPP_ReturnPyObjError( PyExc_TypeError, + "cannot set pose unless bone is linked to armature" ); + } else { + //use bone datastruct + if( !PyArg_ParseTuple + ( args, "O!|O!", &PyList_Type, &flaglist, &Action_Type, + &py_action ) ) + return ( EXPP_ReturnPyObjError + ( PyExc_AttributeError, + "expected list of flags and optional action" ) ); + + for( x = 0; x < PyList_Size( flaglist ); x++ ) { + item = PyList_GetItem( flaglist, x ); + if( PyInt_Check( item ) ) { + flagValue |= PyInt_AsLong( item ); + } else { + return ( EXPP_ReturnPyObjError + ( PyExc_AttributeError, + "expected list of flags (ints)" ) ); + } + } + + //is this bone a part of an armature.... + //get root bone for testing + root = self->bone->parent; + if( root != NULL ) { + while( root->parent != NULL ) { + root = root->parent; + } + } else { + root = self->bone; } - } - - //if object doesn't have a pose create one - if (!object->pose) - object->pose = MEM_callocN(sizeof(bPose), "Pose"); - - //if bone does have a channel create one - verify_pose_channel(object->pose, self->bone->name); - //create temp Pose Channel - chan = MEM_callocN(sizeof(bPoseChannel), "PoseChannel"); - //set the variables for this pose - memcpy (chan->loc, self->bone->loc, sizeof (chan->loc)); - memcpy (chan->quat, self->bone->quat, sizeof (chan->quat)); - memcpy (chan->size, self->bone->size, sizeof (chan->size)); - strcpy (chan->name, self->bone->name); - chan->flag |= flagValue; - //set it to the channel - setChan = set_pose_channel(object->pose, chan); - //frees unlinked pose/bone channels from object - collect_pose_garbage(object); - - //create an action if one not already assigned to object - if (!py_action && !object->action){ - object->action = (bAction*)add_empty_action(); - object->ipowin= ID_AC; - }else{ - //test if posechannel is already in action - for(test = object->action->chanbase.first; test; test = test->next){ - if(test == setChan) - makeCurve = 0; //already there + //test armatures for root bone + for( arm = G.main->armature.first; arm; arm = arm->id.next ) { + for( bone = arm->bonebase.first; bone; + bone = bone->next ) { + if( bone == root ) + break; + } + if( bone == root ) + break; + } + if( arm == NULL ) + return ( EXPP_ReturnPyObjError( PyExc_RuntimeError, + "bone must belong to an armature to set it's pose!" ) ); + + //find if armature is object linked.... + for( object = G.main->object.first; object; + object = object->id.next ) { + if( object->data == arm ) { + break; + } } - } - - //set action keys - if (setChan->flag & POSE_ROT){ - set_action_key(object->action, setChan, AC_QUAT_X, makeCurve); - set_action_key(object->action, setChan, AC_QUAT_Y, makeCurve); - set_action_key(object->action, setChan, AC_QUAT_Z, makeCurve); - set_action_key(object->action, setChan, AC_QUAT_W, makeCurve); - } - if (setChan->flag & POSE_SIZE){ - set_action_key(object->action, setChan, AC_SIZE_X, makeCurve); - set_action_key(object->action, setChan, AC_SIZE_Y, makeCurve); - set_action_key(object->action, setChan, AC_SIZE_Z, makeCurve); - } - if (setChan->flag & POSE_LOC){ - set_action_key(object->action, setChan, AC_LOC_X, makeCurve); - set_action_key(object->action, setChan, AC_LOC_Y, makeCurve); - set_action_key(object->action, setChan, AC_LOC_Z, makeCurve); - } - //rebuild ipos - remake_action_ipos(object->action); - - //rebuild displists - rebuild_all_armature_displists(); + + if( object == NULL ) + return ( EXPP_ReturnPyObjError( PyExc_RuntimeError, + "armature must be linked to an object to set a pose!" ) ); + + //set the active action as this one + if( py_action != NULL ) { + if( py_action->action != NULL ) { + object->action = py_action->action; + } + } + //if object doesn't have a pose create one + if( !object->pose ) + object->pose = MEM_callocN( sizeof( bPose ), "Pose" ); + + //if bone does have a channel create one + verify_pose_channel( object->pose, self->bone->name ); + //create temp Pose Channel + chan = MEM_callocN( sizeof( bPoseChannel ), "PoseChannel" ); + //set the variables for this pose + memcpy( chan->loc, self->bone->loc, sizeof( chan->loc ) ); + memcpy( chan->quat, self->bone->quat, sizeof( chan->quat ) ); + memcpy( chan->size, self->bone->size, sizeof( chan->size ) ); + strcpy( chan->name, self->bone->name ); + chan->flag |= flagValue; + //set it to the channel + setChan = set_pose_channel( object->pose, chan ); + //frees unlinked pose/bone channels from object + collect_pose_garbage( object ); + + //create an action if one not already assigned to object + if( !py_action && !object->action ) { + object->action = ( bAction * ) add_empty_action( ); + object->ipowin = ID_AC; + } else { + //test if posechannel is already in action + for( test = object->action->chanbase.first; test; + test = test->next ) { + if( test == setChan ) + makeCurve = 0; //already there + } + } + + //set action keys + if( setChan->flag & POSE_ROT ) { + set_action_key( object->action, setChan, AC_QUAT_X, + makeCurve ); + set_action_key( object->action, setChan, AC_QUAT_Y, + makeCurve ); + set_action_key( object->action, setChan, AC_QUAT_Z, + makeCurve ); + set_action_key( object->action, setChan, AC_QUAT_W, + makeCurve ); + } + if( setChan->flag & POSE_SIZE ) { + set_action_key( object->action, setChan, AC_SIZE_X, + makeCurve ); + set_action_key( object->action, setChan, AC_SIZE_Y, + makeCurve ); + set_action_key( object->action, setChan, AC_SIZE_Z, + makeCurve ); + } + if( setChan->flag & POSE_LOC ) { + set_action_key( object->action, setChan, AC_LOC_X, + makeCurve ); + set_action_key( object->action, setChan, AC_LOC_Y, + makeCurve ); + set_action_key( object->action, setChan, AC_LOC_Z, + makeCurve ); + } + //rebuild ipos + remake_action_ipos( object->action ); + + //rebuild displists + rebuild_all_armature_displists( ); } - return EXPP_incr_ret (Py_None); + return EXPP_incr_ret( Py_None ); } -//--------------- BPy_Bone.getBoneclass()---------------------------------------------------------------------------- -static PyObject * -Bone_getBoneclass (BPy_Bone * self) +//--------------- BPy_Bone.getBoneclass()-------------------------- +static PyObject *Bone_getBoneclass( BPy_Bone * self ) { - PyObject *attr = NULL; - - if (!self->bone) { //test to see if linked to armature - //use python vars - attr = returnBoneclassEnum(self->boneclass); - }else{ - //use bone datastruct - attr = returnBoneclassEnum(self->bone->boneclass); - } - if (attr) - return attr; - - return (EXPP_ReturnPyObjError (PyExc_RuntimeError, - "couldn't get Bone.Boneclass attribute")); + PyObject *attr = NULL; + + if( !self->bone ) { //test to see if linked to armature + //use python vars + attr = returnBoneclassEnum( self->boneclass ); + } else { + //use bone datastruct + attr = returnBoneclassEnum( self->bone->boneclass ); + } + if( attr ) + return attr; + + return ( EXPP_ReturnPyObjError( PyExc_RuntimeError, + "couldn't get Bone.Boneclass attribute" ) ); } -//--------------- BPy_Bone.setBoneclass()------------------------------------------------------------------------- -static PyObject * -Bone_setBoneclass(BPy_Bone *self, PyObject *args) + +//--------------- BPy_Bone.setBoneclass()--------------------------- +static PyObject *Bone_setBoneclass( BPy_Bone * self, PyObject * args ) { - int boneclass; - - if (!PyArg_ParseTuple (args, "i", &boneclass)) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, - "expected enum argument")); - - if (!self->bone) { //test to see if linked to armature - //use python vars - self->boneclass = boneclass; - }else{ - //use bone datastruct - self->bone->boneclass = boneclass; - } - return EXPP_incr_ret (Py_None); + int boneclass; + + if( !PyArg_ParseTuple( args, "i", &boneclass ) ) + return ( EXPP_ReturnPyObjError( PyExc_AttributeError, + "expected enum argument" ) ); + + if( !self->bone ) { //test to see if linked to armature + //use python vars + self->boneclass = boneclass; + } else { + //use bone datastruct + self->bone->boneclass = boneclass; + } + return EXPP_incr_ret( Py_None ); } -//--------------- BPy_Bone.hasIK()---------------------------------------------------------------------------- -static PyObject * -Bone_hasIK (BPy_Bone * self) + +//--------------- BPy_Bone.hasIK()------------------------------- +static PyObject *Bone_hasIK( BPy_Bone * self ) { - if (!self->bone) { //test to see if linked to armature - //use python vars - if(self->flag & BONE_IK_TOPARENT){ - Py_INCREF (Py_True); + if( !self->bone ) { //test to see if linked to armature + //use python vars + if( self->flag & BONE_IK_TOPARENT ) { + Py_INCREF( Py_True ); return Py_True; - }else{ - Py_INCREF (Py_False); + } else { + Py_INCREF( Py_False ); return Py_False; - } - }else{ - //use bone datastruct - if(self->bone->flag & BONE_IK_TOPARENT){ - Py_INCREF (Py_True); + } + } else { + //use bone datastruct + if( self->bone->flag & BONE_IK_TOPARENT ) { + Py_INCREF( Py_True ); return Py_True; - }else{ - Py_INCREF (Py_False); + } else { + Py_INCREF( Py_False ); return Py_False; - } - } - return (EXPP_ReturnPyObjError (PyExc_RuntimeError, - "couldn't get Bone.Boneclass attribute")); + } + } + return ( EXPP_ReturnPyObjError( PyExc_RuntimeError, + "couldn't get Bone.Boneclass attribute" ) ); } -//--------------- BPy_Bone.getRestMatrix()---------------------------------------------------------------------------- -static PyObject * -Bone_getRestMatrix(BPy_Bone * self, PyObject *args) + +//--------------- BPy_Bone.getRestMatrix()------------------------- +static PyObject *Bone_getRestMatrix( BPy_Bone * self, PyObject * args ) { char *local = "worldspace"; char *bonespace = "bonespace"; char *worldspace = "worldspace"; - PyObject *matrix; + PyObject *matrix; float delta[3]; float root[3]; float p_root[3]; - if (!PyArg_ParseTuple (args, "|s", &local)) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, - "expected string")); + if( !PyArg_ParseTuple( args, "|s", &local ) ) + return ( EXPP_ReturnPyObjError( PyExc_AttributeError, + "expected string" ) ); - if(!BLI_streq(local, bonespace) && !BLI_streq(local, worldspace)) - return (EXPP_ReturnPyObjError (PyExc_AttributeError, - "expected 'bonespace' or 'worldspace'")); + if( !BLI_streq( local, bonespace ) && !BLI_streq( local, worldspace ) ) + return ( EXPP_ReturnPyObjError( PyExc_AttributeError, + "expected 'bonespace' or 'worldspace'" ) ); - matrix = newMatrixObject(PyMem_Malloc(16 * sizeof(float)),4,4); + matrix = newMatrixObject( PyMem_Malloc( 16 * sizeof( float ) ), 4, 4 ); - if (!self->bone) { //test to see if linked to armature + if( !self->bone ) { //test to see if linked to armature //use python vars - if(BLI_streq(local, worldspace)){ - VecSubf (delta, self->tail->vec, self->head->vec); - make_boneMatrixvr( *((MatrixObject*)matrix)->matrix, delta, self->roll); - }else if(BLI_streq(local, bonespace)){ - return (EXPP_ReturnPyObjError (PyExc_AttributeError, - "bone not yet linked to an armature....'")); + if( BLI_streq( local, worldspace ) ) { + VecSubf( delta, self->tail->vec, self->head->vec ); + make_boneMatrixvr( *( ( MatrixObject * ) matrix )-> + matrix, delta, self->roll ); + } else if( BLI_streq( local, bonespace ) ) { + return ( EXPP_ReturnPyObjError( PyExc_AttributeError, + "bone not yet linked to an armature....'" ) ); } - }else{ + } else { //use bone datastruct - if(BLI_streq(local, worldspace)){ - get_objectspace_bone_matrix (self->bone, *((MatrixObject*)matrix)->matrix, 1, 1); - }else if(BLI_streq(local, bonespace)){ - VecSubf (delta, self->bone->tail, self->bone->head); - make_boneMatrixvr( *((MatrixObject*)matrix)->matrix, delta, self->bone->roll); - if(self->bone->parent){ - get_bone_root_pos(self->bone,root,1); - get_bone_root_pos(self->bone->parent,p_root,1); - VecSubf(delta,root,p_root); - VECCOPY(((MatrixObject*)matrix)->matrix[3], delta); + if( BLI_streq( local, worldspace ) ) { + get_objectspace_bone_matrix( self->bone, + *( ( MatrixObject * ) + matrix )->matrix, 1, + 1 ); + } else if( BLI_streq( local, bonespace ) ) { + VecSubf( delta, self->bone->tail, self->bone->head ); + make_boneMatrixvr( *( ( MatrixObject * ) matrix )-> + matrix, delta, self->bone->roll ); + if( self->bone->parent ) { + get_bone_root_pos( self->bone, root, 1 ); + get_bone_root_pos( self->bone->parent, p_root, + 1 ); + VecSubf( delta, root, p_root ); + VECCOPY( ( ( MatrixObject * ) matrix )-> + matrix[3], delta ); } } } |