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