diff --git a/source/blender/python/api2_2x/Mathutils.c b/source/blender/python/api2_2x/Mathutils.c index 63ab90ad0e3..f36f7337808 100644 --- a/source/blender/python/api2_2x/Mathutils.c +++ b/source/blender/python/api2_2x/Mathutils.c @@ -152,7 +152,7 @@ PyObject *column_vector_multiplication(MatrixObject * mat, VectorObject* vec) vecNew[z++] = (float)dot; dot = 0.0f; } - return (PyObject *) newVectorObject(vecNew, vec->size, Py_NEW); + return newVectorObject(vecNew, vec->size, Py_NEW); } //This is a helper for point/matrix translation PyObject *column_point_multiplication(MatrixObject * mat, PointObject* pt) @@ -181,7 +181,7 @@ PyObject *column_point_multiplication(MatrixObject * mat, PointObject* pt) ptNew[z++] = (float)dot; dot = 0.0f; } - return (PyObject *) newPointObject(ptNew, pt->size, Py_NEW); + return newPointObject(ptNew, pt->size, Py_NEW); } //-----------------row_vector_multiplication (internal)----------- //ROW VECTOR Multiplication - Vector X Matrix @@ -216,7 +216,7 @@ PyObject *row_vector_multiplication(VectorObject* vec, MatrixObject * mat) vecNew[z++] = (float)dot; dot = 0.0f; } - return (PyObject *) newVectorObject(vecNew, size, Py_NEW); + return newVectorObject(vecNew, size, Py_NEW); } //This is a helper for the point class PyObject *row_point_multiplication(PointObject* pt, MatrixObject * mat) @@ -246,7 +246,7 @@ PyObject *row_point_multiplication(PointObject* pt, MatrixObject * mat) ptNew[z++] = (float)dot; dot = 0.0f; } - return (PyObject *) newPointObject(ptNew, size, Py_NEW); + return newPointObject(ptNew, size, Py_NEW); } //-----------------quat_rotation (internal)----------- //This function multiplies a vector/point * quat or vice versa @@ -275,7 +275,7 @@ PyObject *quat_rotation(PyObject *arg1, PyObject *arg2) quat->quat[3]*quat->quat[3]*vec->vec[2] - 2*quat->quat[0]*quat->quat[2]*vec->vec[0] - quat->quat[2]*quat->quat[2]*vec->vec[2] + 2*quat->quat[0]*quat->quat[1]*vec->vec[1] - quat->quat[1]*quat->quat[1]*vec->vec[2] + quat->quat[0]*quat->quat[0]*vec->vec[2]; - return (PyObject *) newVectorObject(rot, 3, Py_NEW); + return newVectorObject(rot, 3, Py_NEW); }else if(PointObject_Check(arg2)){ pt = (PointObject*)arg2; rot[0] = quat->quat[0]*quat->quat[0]*pt->coord[0] + 2*quat->quat[2]*quat->quat[0]*pt->coord[2] - @@ -290,7 +290,7 @@ PyObject *quat_rotation(PyObject *arg1, PyObject *arg2) quat->quat[3]*quat->quat[3]*pt->coord[2] - 2*quat->quat[0]*quat->quat[2]*pt->coord[0] - quat->quat[2]*quat->quat[2]*pt->coord[2] + 2*quat->quat[0]*quat->quat[1]*pt->coord[1] - quat->quat[1]*quat->quat[1]*pt->coord[2] + quat->quat[0]*quat->quat[0]*pt->coord[2]; - return (PyObject *) newPointObject(rot, 3, Py_NEW); + return newPointObject(rot, 3, Py_NEW); } }else if(VectorObject_Check(arg1)){ vec = (VectorObject*)arg1; @@ -308,7 +308,7 @@ PyObject *quat_rotation(PyObject *arg1, PyObject *arg2) quat->quat[3]*quat->quat[3]*vec->vec[2] - 2*quat->quat[0]*quat->quat[2]*vec->vec[0] - quat->quat[2]*quat->quat[2]*vec->vec[2] + 2*quat->quat[0]*quat->quat[1]*vec->vec[1] - quat->quat[1]*quat->quat[1]*vec->vec[2] + quat->quat[0]*quat->quat[0]*vec->vec[2]; - return (PyObject *) newVectorObject(rot, 3, Py_NEW); + return newVectorObject(rot, 3, Py_NEW); } }else if(PointObject_Check(arg1)){ pt = (PointObject*)arg1; @@ -326,7 +326,7 @@ PyObject *quat_rotation(PyObject *arg1, PyObject *arg2) quat->quat[3]*quat->quat[3]*pt->coord[2] - 2*quat->quat[0]*quat->quat[2]*pt->coord[0] - quat->quat[2]*quat->quat[2]*pt->coord[2] + 2*quat->quat[0]*quat->quat[1]*pt->coord[1] - quat->quat[1]*quat->quat[1]*pt->coord[2] + quat->quat[0]*quat->quat[0]*pt->coord[2]; - return (PyObject *) newPointObject(rot, 3, Py_NEW); + return newPointObject(rot, 3, Py_NEW); } } @@ -371,6 +371,7 @@ PyObject *M_Mathutils_Vector(PyObject * self, PyObject * args) PyObject *listObject = NULL; int size, i; float vec[4]; + PyObject *v, *f; size = PySequence_Length(args); if (size == 1) { @@ -384,24 +385,25 @@ PyObject *M_Mathutils_Vector(PyObject * self, PyObject * args) } } else if (size == 0) { //returns a new empty 3d vector - return (PyObject *) newVectorObject(NULL, 3, Py_NEW); + return newVectorObject(NULL, 3, Py_NEW); } else { listObject = EXPP_incr_ret(args); } + if (size<2 || size>4) { // Invalid vector size Py_XDECREF(listObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Vector(): 2-4 floats or ints expected (optionally in a sequence)\n"); } - for (i=0; isize; x++) { vec[x] = 0.5f * (vec1->vec[x] + vec2->vec[x]); } - return (PyObject *) newVectorObject(vec, vec1->size, Py_NEW); + return newVectorObject(vec, vec1->size, Py_NEW); } //----------------------------------Mathutils.ProjectVecs() ------------- //projects vector 1 onto vector 2 @@ -548,7 +551,7 @@ PyObject *M_Mathutils_ProjectVecs(PyObject * self, PyObject * args) for(x = 0; x < size; x++) { vec[x] = (float)(dot * vec2->vec[x]); } - return (PyObject *) newVectorObject(vec, size, Py_NEW); + return newVectorObject(vec, size, Py_NEW); } //----------------------------------MATRIX FUNCTIONS-------------------- //----------------------------------Mathutils.Matrix() ----------------- @@ -557,6 +560,8 @@ PyObject *M_Mathutils_ProjectVecs(PyObject * self, PyObject * args) PyObject *M_Mathutils_Matrix(PyObject * self, PyObject * args) { PyObject *listObject = NULL; + PyObject *argObject, *m, *s, *f; + MatrixObject *mat; int argSize, seqSize = 0, i, j; float matrix[16] = {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}; @@ -569,14 +574,12 @@ PyObject *M_Mathutils_Matrix(PyObject * self, PyObject * args) return (PyObject *) newMatrixObject(NULL, 4, 4, Py_NEW); }else if (argSize == 1){ //copy constructor for matrix objects - PyObject *argObject; argObject = PySequence_GetItem(args, 0); - Py_INCREF(argObject); if(MatrixObject_Check(argObject)){ - MatrixObject *mat; mat = (MatrixObject*)argObject; + argSize = mat->rowSize; //rows - seqSize = mat->colSize; //cols + seqSize = mat->colSize; //col for(i = 0; i < (seqSize * argSize); i++){ matrix[i] = mat->contigPtr[i]; } @@ -584,58 +587,54 @@ PyObject *M_Mathutils_Matrix(PyObject * self, PyObject * args) Py_DECREF(argObject); }else{ //2-4 arguments (all seqs? all same size?) for(i =0; i < argSize; i++){ - PyObject *argObject; argObject = PySequence_GetItem(args, i); if (PySequence_Check(argObject)) { //seq? if(seqSize){ //0 at first if(PySequence_Length(argObject) != seqSize){ //seq size not same + Py_DECREF(argObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Matrix(): expects 0-4 numeric sequences of the same size\n"); } } seqSize = PySequence_Length(argObject); }else{ //arg not a sequence + Py_XDECREF(argObject); return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.Matrix(): expects 0-4 numeric sequences of the same size\n"); } - Py_XDECREF(argObject); + Py_DECREF(argObject); } //all is well... let's continue parsing - listObject = EXPP_incr_ret(args); + listObject = args; for (i = 0; i < argSize; i++){ - PyObject *m; - m = PySequence_GetItem(listObject, i); if (m == NULL) { // Failed to read sequence - Py_XDECREF(listObject); return EXPP_ReturnPyObjError(PyExc_RuntimeError, "Mathutils.Matrix(): failed to parse arguments...\n"); } - for (j = 0; j < seqSize; j++) { - PyObject *s, *f; + for (j = 0; j < seqSize; j++) { s = PySequence_GetItem(m, j); if (s == NULL) { // Failed to read sequence Py_DECREF(m); - Py_XDECREF(listObject); return EXPP_ReturnPyObjError(PyExc_RuntimeError, "Mathutils.Matrix(): failed to parse arguments...\n"); } + f = PyNumber_Float(s); if(f == NULL) { // parsed item is not a number EXPP_decr2(m,s); - Py_XDECREF(listObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Matrix(): expects 0-4 numeric sequences of the same size\n"); } + matrix[(seqSize*i)+j]=(float)PyFloat_AS_DOUBLE(f); EXPP_decr2(f,s); } Py_DECREF(m); } - Py_DECREF(listObject); } - return (PyObject *)newMatrixObject(matrix, argSize, seqSize, Py_NEW); + return newMatrixObject(matrix, argSize, seqSize, Py_NEW); } //----------------------------------Mathutils.RotationMatrix() ---------- //mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc. @@ -1033,14 +1032,14 @@ PyObject *M_Mathutils_Quaternion(PyObject * self, PyObject * args) if ((size == 4 && PySequence_Length(args) !=1) || (size == 3 && PySequence_Length(args) !=2) || (size >4 || size < 3)) { // invalid args/size - Py_XDECREF(listObject); + Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n"); } if(size == 3){ //get angle in axis/angle n = PyNumber_Float(PySequence_GetItem(args, 1)); if(n == NULL) { // parsed item not a number or getItem fail - Py_XDECREF(listObject); + Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n"); } @@ -1053,13 +1052,13 @@ PyObject *M_Mathutils_Quaternion(PyObject * self, PyObject * args) size = PySequence_Length(listObject); if (size != 3) { // invalid args/size - Py_XDECREF(listObject); + Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n"); } n = PyNumber_Float(PySequence_GetItem(args, 0)); if(n == NULL) { // parsed item not a number or getItem fail - Py_XDECREF(listObject); + Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n"); } @@ -1072,38 +1071,40 @@ PyObject *M_Mathutils_Quaternion(PyObject * self, PyObject * args) } } } else if (size == 0) { //returns a new empty quat - return (PyObject *) newQuaternionObject(NULL, Py_NEW); + return newQuaternionObject(NULL, Py_NEW); } else { listObject = EXPP_incr_ret(args); } if (size == 3) { // invalid quat size if(PySequence_Length(args) != 2){ - Py_XDECREF(listObject); + Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n"); } }else{ if(size != 4){ - Py_XDECREF(listObject); + Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Quaternion(): 4d numeric sequence expected or 3d vector and number\n"); } } + for (i=0; iquat, quatV->quat); - return (PyObject*) newQuaternionObject(quat, Py_NEW); + return newQuaternionObject(quat, Py_NEW); } //----------------------------------Mathutils.DotQuats() ---------------- //returns the dot product of 2 quaternions @@ -1178,7 +1180,7 @@ PyObject *M_Mathutils_DifferenceQuats(PyObject * self, PyObject * args) tempQuat[x] /= (float)(dot * dot); } QuatMul(quat, tempQuat, quatV->quat); - return (PyObject *) newQuaternionObject(quat, Py_NEW); + return newQuaternionObject(quat, Py_NEW); } //----------------------------------Mathutils.Slerp() ------------------ //attemps to interpolate 2 quaternions and return the result @@ -1235,7 +1237,7 @@ PyObject *M_Mathutils_Slerp(PyObject * self, PyObject * args) quat[2] = (float)(quat_u[2] * x + quat_v[2] * y); quat[3] = (float)(quat_u[3] * x + quat_v[3] * y); - return (PyObject *) newQuaternionObject(quat, Py_NEW); + return newQuaternionObject(quat, Py_NEW); } //----------------------------------EULER FUNCTIONS---------------------- //----------------------------------Mathutils.Euler() ------------------- @@ -1246,6 +1248,7 @@ PyObject *M_Mathutils_Euler(PyObject * self, PyObject * args) PyObject *listObject = NULL; int size, i; float eul[3]; + PyObject *e, *f; size = PySequence_Length(args); if (size == 1) { @@ -1253,52 +1256,49 @@ PyObject *M_Mathutils_Euler(PyObject * self, PyObject * args) if (PySequence_Check(listObject)) { size = PySequence_Length(listObject); } else { // Single argument was not a sequence - Py_XDECREF(listObject); + Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_TypeError, "Mathutils.Euler(): 3d numeric sequence expected\n"); } } else if (size == 0) { //returns a new empty 3d euler - return (PyObject *) newEulerObject(NULL, Py_NEW); + return newEulerObject(NULL, Py_NEW); } else { listObject = EXPP_incr_ret(args); } + if (size != 3) { // Invalid euler size - Py_XDECREF(listObject); + Py_DECREF(listObject); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Mathutils.Euler(): 3d numeric sequence expected\n"); } - for (i=0; ieul[x] * ((float)Py_PI / 180); } EulToQuat(eul, quat); - return (PyObject *) newQuaternionObject(quat, Py_NEW); + return newQuaternionObject(quat, Py_NEW); } //----------------------------Euler.toMatrix()--------------------- //return a matrix representation of the euler @@ -79,7 +78,7 @@ PyObject *Euler_ToMatrix(EulerObject * self) eul[x] = self->eul[x] * ((float)Py_PI / 180); } EulToMat3(eul, (float (*)[3]) mat); - return (PyObject *) newMatrixObject(mat, 3, 3 , Py_NEW); + return newMatrixObject(mat, 3, 3 , Py_NEW); } //----------------------------Euler.unique()----------------------- //sets the x,y,z values to a unique euler rotation @@ -247,7 +246,7 @@ static PyObject *Euler_repr(EulerObject * self) } strcat(str, "](euler)"); - return EXPP_incr_ret(PyString_FromString(str)); + return PyString_FromString(str); } //---------------------SEQUENCE PROTOCOLS------------------------ //----------------------------len(object)------------------------ @@ -314,6 +313,7 @@ static int Euler_ass_slice(EulerObject * self, int begin, int end, { int i, y, size = 0; float eul[3]; + PyObject *e, *f; CLAMP(begin, 0, 3); CLAMP(end, 0, 3); @@ -326,19 +326,19 @@ static int Euler_ass_slice(EulerObject * self, int begin, int end, } for (i = 0; i < size; i++) { - PyObject *e, *f; - e = PySequence_GetItem(seq, i); if (e == NULL) { // Failed to read sequence return EXPP_ReturnIntError(PyExc_RuntimeError, "euler[begin:end] = []: unable to read sequence\n"); } + f = PyNumber_Float(e); if(f == NULL) { // parsed item not a number Py_DECREF(e); return EXPP_ReturnIntError(PyExc_TypeError, "euler[begin:end] = []: sequence argument not a number\n"); } + eul[i] = (float)PyFloat_AS_DOUBLE(f); EXPP_decr2(f,e); } diff --git a/source/blender/python/api2_2x/matrix.c b/source/blender/python/api2_2x/matrix.c index 48517140988..9d141cb8232 100644 --- a/source/blender/python/api2_2x/matrix.c +++ b/source/blender/python/api2_2x/matrix.c @@ -77,7 +77,7 @@ PyObject *Matrix_toQuat(MatrixObject * self) Mat4ToQuat((float (*)[4])*self->matrix, quat); } - return (PyObject *) newQuaternionObject(quat, Py_NEW); + return newQuaternionObject(quat, Py_NEW); } //---------------------------Matrix.toEuler() -------------------- PyObject *Matrix_toEuler(MatrixObject * self) @@ -95,7 +95,7 @@ PyObject *Matrix_toEuler(MatrixObject * self) for(x = 0; x < 3; x++) { eul[x] *= (float) (180 / Py_PI); } - return (PyObject *) newEulerObject(eul, Py_NEW); + return newEulerObject(eul, Py_NEW); } //---------------------------Matrix.resize4x4() ------------------ PyObject *Matrix_Resize4x4(MatrixObject * self) @@ -372,7 +372,7 @@ static PyObject *Matrix_repr(MatrixObject * self) } } - return EXPP_incr_ret(PyString_FromString(str)); + return PyString_FromString(str); } //---------------------SEQUENCE PROTOCOLS------------------------ @@ -399,6 +399,7 @@ static int Matrix_ass_item(MatrixObject * self, int i, PyObject * ob) { int y, x, size = 0; float vec[4]; + PyObject *m, *f; if(i > self->rowSize || i < 0){ return EXPP_ReturnIntError(PyExc_TypeError, @@ -412,19 +413,19 @@ static int Matrix_ass_item(MatrixObject * self, int i, PyObject * ob) "matrix[attribute] = x: bad sequence size\n"); } for (x = 0; x < size; x++) { - PyObject *m, *f; - m = PySequence_GetItem(ob, x); if (m == NULL) { // Failed to read sequence return EXPP_ReturnIntError(PyExc_RuntimeError, "matrix[attribute] = x: unable to read sequence\n"); } + f = PyNumber_Float(m); if(f == NULL) { // parsed item not a number Py_DECREF(m); return EXPP_ReturnIntError(PyExc_TypeError, "matrix[attribute] = x: sequence argument not a number\n"); } + vec[x] = (float)PyFloat_AS_DOUBLE(f); EXPP_decr2(m, f); } @@ -456,7 +457,7 @@ static PyObject *Matrix_slice(MatrixObject * self, int begin, int end) newVectorObject(self->matrix[count], self->colSize, Py_WRAP)); } - return EXPP_incr_ret(list); + return list; } //----------------------------object[z:y]------------------------ //sequence slice (set) @@ -465,6 +466,8 @@ static int Matrix_ass_slice(MatrixObject * self, int begin, int end, { int i, x, y, size, sub_size = 0; float mat[16]; + PyObject *subseq; + PyObject *m, *f; CLAMP(begin, 0, self->rowSize); CLAMP(end, 0, self->rowSize); @@ -479,32 +482,35 @@ static int Matrix_ass_slice(MatrixObject * self, int begin, int end, //parse sub items for (i = 0; i < size; i++) { //parse each sub sequence - PyObject *subseq; subseq = PySequence_GetItem(seq, i); if (subseq == NULL) { // Failed to read sequence return EXPP_ReturnIntError(PyExc_RuntimeError, "matrix[begin:end] = []: unable to read sequence\n"); } + if(PySequence_Check(subseq)){ //subsequence is also a sequence sub_size = PySequence_Length(subseq); if(sub_size != self->colSize){ + Py_DECREF(subseq); return EXPP_ReturnIntError(PyExc_TypeError, "matrix[begin:end] = []: size mismatch in slice assignment\n"); } for (y = 0; y < sub_size; y++) { - PyObject *m, *f; m = PySequence_GetItem(subseq, y); if (m == NULL) { // Failed to read sequence + Py_DECREF(subseq); return EXPP_ReturnIntError(PyExc_RuntimeError, "matrix[begin:end] = []: unable to read sequence\n"); } + f = PyNumber_Float(m); if(f == NULL) { // parsed item not a number - Py_DECREF(m); + EXPP_decr2(m, subseq); return EXPP_ReturnIntError(PyExc_TypeError, "matrix[begin:end] = []: sequence argument not a number\n"); } + mat[(i * self->colSize) + y] = (float)PyFloat_AS_DOUBLE(f); EXPP_decr2(f, m); } @@ -513,6 +519,7 @@ static int Matrix_ass_slice(MatrixObject * self, int begin, int end, return EXPP_ReturnIntError(PyExc_TypeError, "matrix[begin:end] = []: illegal argument type for built-in operation\n"); } + Py_DECREF(subseq); } //parsed well - now set in matrix for(x = 0; x < (size * sub_size); x++){ @@ -533,7 +540,6 @@ static PyObject *Matrix_add(PyObject * m1, PyObject * m2) 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}; MatrixObject *mat1 = NULL, *mat2 = NULL; - EXPP_incr2(m1, m2); mat1 = (MatrixObject*)m1; mat2 = (MatrixObject*)m2; @@ -542,7 +548,6 @@ static PyObject *Matrix_add(PyObject * m1, PyObject * m2) "Matrix addition: arguments not valid for this operation....\n"); } if(mat1->rowSize != mat2->rowSize || mat1->colSize != mat2->colSize){ - EXPP_decr2((PyObject*)mat1, (PyObject*)mat2); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Matrix addition: matrices must have the same dimensions for this operation\n"); } @@ -553,7 +558,6 @@ static PyObject *Matrix_add(PyObject * m1, PyObject * m2) } } - EXPP_decr2((PyObject*)mat1, (PyObject*)mat2); return newMatrixObject(mat, mat1->rowSize, mat1->colSize, Py_NEW); } //------------------------obj - obj------------------------------ @@ -565,7 +569,6 @@ static PyObject *Matrix_sub(PyObject * m1, PyObject * m2) 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}; MatrixObject *mat1 = NULL, *mat2 = NULL; - EXPP_incr2(m1, m2); mat1 = (MatrixObject*)m1; mat2 = (MatrixObject*)m2; @@ -574,7 +577,6 @@ static PyObject *Matrix_sub(PyObject * m1, PyObject * m2) "Matrix addition: arguments not valid for this operation....\n"); } if(mat1->rowSize != mat2->rowSize || mat1->colSize != mat2->colSize){ - EXPP_decr2((PyObject*)mat1, (PyObject*)mat2); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Matrix addition: matrices must have the same dimensions for this operation\n"); } @@ -585,7 +587,6 @@ static PyObject *Matrix_sub(PyObject * m1, PyObject * m2) } } - EXPP_decr2((PyObject*)mat1, (PyObject*)mat2); return newMatrixObject(mat, mat1->rowSize, mat1->colSize, Py_NEW); } //------------------------obj * obj------------------------------ @@ -598,11 +599,10 @@ static PyObject *Matrix_mul(PyObject * m1, PyObject * m2) 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f}; double dot = 0.0f; MatrixObject *mat1 = NULL, *mat2 = NULL; - PyObject *f = NULL, *retObj = NULL; + PyObject *f = NULL; VectorObject *vec = NULL; PointObject *pt = NULL; - EXPP_incr2(m1, m2); mat1 = (MatrixObject*)m1; mat2 = (MatrixObject*)m2; @@ -611,51 +611,44 @@ static PyObject *Matrix_mul(PyObject * m1, PyObject * m2) PyInt_Check(mat1->coerced_object)){ // FLOAT/INT * MATRIX f = PyNumber_Float(mat1->coerced_object); if(f == NULL) { // parsed item not a number - EXPP_decr2((PyObject*)mat1, (PyObject*)mat2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Matrix multiplication: arguments not acceptable for this operation\n"); } + scalar = (float)PyFloat_AS_DOUBLE(f); for(x = 0; x < mat2->rowSize; x++) { for(y = 0; y < mat2->colSize; y++) { mat[((x * mat2->colSize) + y)] = scalar * mat2->matrix[x][y]; } } - EXPP_decr2((PyObject*)mat1, (PyObject*)mat2); return newMatrixObject(mat, mat2->rowSize, mat2->colSize, Py_NEW); } }else{ if(mat2->coerced_object){ if(VectorObject_Check(mat2->coerced_object)){ //MATRIX * VECTOR - vec = (VectorObject*)EXPP_incr_ret(mat2->coerced_object); - retObj = column_vector_multiplication(mat1, vec); - EXPP_decr3((PyObject*)mat1, (PyObject*)mat2, (PyObject*)vec); - return retObj; + vec = (VectorObject*)mat2->coerced_object; + return column_vector_multiplication(mat1, vec); }else if(PointObject_Check(mat2->coerced_object)){ //MATRIX * POINT - pt = (PointObject*)EXPP_incr_ret(mat2->coerced_object); - retObj = column_point_multiplication(mat1, pt); - EXPP_decr3((PyObject*)mat1, (PyObject*)mat2, (PyObject*)pt); - return retObj; + pt = (PointObject*)mat2->coerced_object; + return column_point_multiplication(mat1, pt); }else if (PyFloat_Check(mat2->coerced_object) || PyInt_Check(mat2->coerced_object)){ // MATRIX * FLOAT/INT f = PyNumber_Float(mat2->coerced_object); if(f == NULL) { // parsed item not a number - EXPP_decr2((PyObject*)mat1, (PyObject*)mat2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Matrix multiplication: arguments not acceptable for this operation\n"); } + scalar = (float)PyFloat_AS_DOUBLE(f); for(x = 0; x < mat1->rowSize; x++) { for(y = 0; y < mat1->colSize; y++) { mat[((x * mat1->colSize) + y)] = scalar * mat1->matrix[x][y]; } } - EXPP_decr2((PyObject*)mat1, (PyObject*)mat2); return newMatrixObject(mat, mat1->rowSize, mat1->colSize, Py_NEW); } }else{ //MATRIX * MATRIX if(mat1->colSize != mat2->rowSize){ - EXPP_decr2((PyObject*)mat1, (PyObject*)mat2); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Matrix multiplication: matrix A rowsize must equal matrix B colsize\n"); } @@ -672,7 +665,6 @@ static PyObject *Matrix_mul(PyObject * m1, PyObject * m2) } } - EXPP_decr2((PyObject*)mat1, (PyObject*)mat2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Matrix multiplication: arguments not acceptable for this operation\n"); } @@ -702,8 +694,7 @@ static int Matrix_coerce(PyObject ** m1, PyObject ** m2) "matrix.coerce(): unknown operand - can't coerce for numeric protocols\n"); } } - Py_INCREF(*m2); - Py_INCREF(*m1); + EXPP_incr2(*m1, *m2); return 0; } //-----------------PROTCOL DECLARATIONS-------------------------- diff --git a/source/blender/python/api2_2x/point.c b/source/blender/python/api2_2x/point.c index bcfd8efefa4..2246f49b6ef 100644 --- a/source/blender/python/api2_2x/point.c +++ b/source/blender/python/api2_2x/point.c @@ -56,7 +56,7 @@ PyObject *Point_toVector(PointObject * self) vec[x] = self->coord[x]; } - return (PyObject *) newVectorObject(vec, self->size, Py_NEW); + return newVectorObject(vec, self->size, Py_NEW); } //----------------------------Point.zero() ---------------------- //set the point data to 0,0,0 @@ -72,6 +72,7 @@ PyObject *Point_Zero(PointObject * self) //free the py_object static void Point_dealloc(PointObject * self) { + Py_XDECREF(self->coerced_object); //only free py_data if(self->data.py_data){ PyMem_Free(self->data.py_data); @@ -154,7 +155,7 @@ static PyObject *Point_repr(PointObject * self) } strcat(str, "](point)"); - return EXPP_incr_ret(PyString_FromString(str)); + return PyString_FromString(str); } //---------------------SEQUENCE PROTOCOLS------------------------ //----------------------------len(object)------------------------ @@ -221,6 +222,7 @@ static int Point_ass_slice(PointObject * self, int begin, int end, { int i, y, size = 0; float coord[3]; + PyObject *v, *f; CLAMP(begin, 0, self->size); CLAMP(end, 0, self->size); @@ -233,8 +235,6 @@ static int Point_ass_slice(PointObject * self, int begin, int end, } for (i = 0; i < size; i++) { - PyObject *v, *f; - v = PySequence_GetItem(seq, i); if (v == NULL) { // Failed to read sequence return EXPP_ReturnIntError(PyExc_RuntimeError, @@ -246,6 +246,7 @@ static int Point_ass_slice(PointObject * self, int begin, int end, return EXPP_ReturnIntError(PyExc_TypeError, "point[begin:end] = []: sequence argument not a number\n"); } + coord[i] = (float)PyFloat_AS_DOUBLE(f); EXPP_decr2(f,v); } @@ -265,7 +266,6 @@ static PyObject *Point_add(PyObject * v1, PyObject * v2) PointObject *coord1 = NULL, *coord2 = NULL; VectorObject *vec = NULL; - EXPP_incr2(v1, v2); coord1 = (PointObject*)v1; coord2 = (PointObject*)v2; @@ -273,19 +273,17 @@ static PyObject *Point_add(PyObject * v1, PyObject * v2) if(coord2->coerced_object){ if(VectorObject_Check(coord2->coerced_object)){ //POINT + VECTOR //Point translation - vec = (VectorObject*)EXPP_incr_ret(coord2->coerced_object); + vec = (VectorObject*)coord2->coerced_object; size = coord1->size; if(vec->size == size){ for(x = 0; x < size; x++){ coord[x] = coord1->coord[x] + vec->vec[x]; } }else{ - EXPP_decr3((PyObject*)coord1, (PyObject*)coord2, (PyObject*)vec); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Point addition: arguments are the wrong size....\n"); } - EXPP_decr3((PyObject*)coord1, (PyObject*)coord2, (PyObject*)vec); - return (PyObject *) newPointObject(coord, size, Py_NEW); + return newPointObject(coord, size, Py_NEW); } }else{ //POINT + POINT size = coord1->size; @@ -294,16 +292,13 @@ static PyObject *Point_add(PyObject * v1, PyObject * v2) coord[x] = coord1->coord[x] + coord2->coord[x]; } }else{ - EXPP_decr2((PyObject*)coord1, (PyObject*)coord2); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Point addition: arguments are the wrong size....\n"); } - EXPP_decr2((PyObject*)coord1, (PyObject*)coord2); - return (PyObject *) newPointObject(coord, size, Py_NEW); + return newPointObject(coord, size, Py_NEW); } } - EXPP_decr2((PyObject*)coord1, (PyObject*)coord2); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Point addition: arguments not valid for this operation....\n"); } @@ -315,7 +310,6 @@ static PyObject *Point_sub(PyObject * v1, PyObject * v2) float coord[3]; PointObject *coord1 = NULL, *coord2 = NULL; - EXPP_incr2(v1, v2); coord1 = (PointObject*)v1; coord2 = (PointObject*)v2; @@ -324,7 +318,6 @@ static PyObject *Point_sub(PyObject * v1, PyObject * v2) "Point subtraction: arguments not valid for this operation....\n"); } if(coord1->size != coord2->size){ - EXPP_decr2((PyObject*)coord1, (PyObject*)coord2); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Point subtraction: points must have the same dimensions for this operation\n"); } @@ -335,8 +328,7 @@ static PyObject *Point_sub(PyObject * v1, PyObject * v2) } //Point - Point = Vector - EXPP_decr2((PyObject*)coord1, (PyObject*)coord2); - return (PyObject *) newVectorObject(coord, size, Py_NEW); + return newVectorObject(coord, size, Py_NEW); } //------------------------obj * obj------------------------------ //mulplication @@ -345,11 +337,10 @@ static PyObject *Point_mul(PyObject * p1, PyObject * p2) int x, size; float coord[3], scalar; PointObject *coord1 = NULL, *coord2 = NULL; - PyObject *f = NULL, *retObj = NULL; + PyObject *f = NULL; MatrixObject *mat = NULL; QuaternionObject *quat = NULL; - EXPP_incr2(p1, p2); coord1 = (PointObject*)p1; coord2 = (PointObject*)p2; @@ -358,17 +349,17 @@ static PyObject *Point_mul(PyObject * p1, PyObject * p2) PyInt_Check(coord1->coerced_object)){ // FLOAT/INT * POINT f = PyNumber_Float(coord1->coerced_object); if(f == NULL) { // parsed item not a number - EXPP_decr2((PyObject*)coord1, (PyObject*)coord2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Point multiplication: arguments not acceptable for this operation\n"); } + scalar = (float)PyFloat_AS_DOUBLE(f); size = coord2->size; for(x = 0; x < size; x++) { coord[x] = coord2->coord[x] * scalar; } - EXPP_decr2((PyObject*)coord1, (PyObject*)coord2); - return (PyObject *) newPointObject(coord, size, Py_NEW); + Py_DECREF(f); + return newPointObject(coord, size, Py_NEW); } }else{ if(coord2->coerced_object){ @@ -376,37 +367,31 @@ static PyObject *Point_mul(PyObject * p1, PyObject * p2) PyInt_Check(coord2->coerced_object)){ // POINT * FLOAT/INT f = PyNumber_Float(coord2->coerced_object); if(f == NULL) { // parsed item not a number - EXPP_decr2((PyObject*)coord1, (PyObject*)coord2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Point multiplication: arguments not acceptable for this operation\n"); } + scalar = (float)PyFloat_AS_DOUBLE(f); size = coord1->size; for(x = 0; x < size; x++) { coord[x] = coord1->coord[x] * scalar; } - EXPP_decr2((PyObject*)coord1, (PyObject*)coord2); - return (PyObject *) newPointObject(coord, size, Py_NEW); + Py_DECREF(f); + return newPointObject(coord, size, Py_NEW); }else if(MatrixObject_Check(coord2->coerced_object)){ //POINT * MATRIX - mat = (MatrixObject*)EXPP_incr_ret(coord2->coerced_object); - retObj = row_point_multiplication(coord1, mat); - EXPP_decr3((PyObject*)coord1, (PyObject*)coord2, (PyObject*)mat); - return retObj; + mat = (MatrixObject*)coord2->coerced_object; + return row_point_multiplication(coord1, mat); }else if(QuaternionObject_Check(coord2->coerced_object)){ //POINT * QUATERNION - quat = (QuaternionObject*)EXPP_incr_ret(coord2->coerced_object); + quat = (QuaternionObject*)coord2->coerced_object; if(coord1->size != 3){ - EXPP_decr2((PyObject*)coord1, (PyObject*)coord2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Point multiplication: only 3D point rotations (with quats) currently supported\n"); } - retObj = quat_rotation((PyObject*)coord1, (PyObject*)quat); - EXPP_decr3((PyObject*)coord1, (PyObject*)coord2, (PyObject*)quat); - return retObj; + return quat_rotation((PyObject*)coord1, (PyObject*)quat); } } } - EXPP_decr2((PyObject*)coord1, (PyObject*)coord2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Point multiplication: arguments not acceptable for this operation\n"); } diff --git a/source/blender/python/api2_2x/quat.c b/source/blender/python/api2_2x/quat.c index 308c5e9fe46..11b16e89c87 100644 --- a/source/blender/python/api2_2x/quat.c +++ b/source/blender/python/api2_2x/quat.c @@ -141,6 +141,7 @@ PyObject *Quaternion_Conjugate(QuaternionObject * self) //free the py_object static void Quaternion_dealloc(QuaternionObject * self) { + Py_XDECREF(self->coerced_object); //only free py_data if(self->data.py_data){ PyMem_Free(self->data.py_data); @@ -244,7 +245,7 @@ static PyObject *Quaternion_repr(QuaternionObject * self) } strcat(str, "](quaternion)"); - return EXPP_incr_ret(PyString_FromString(str)); + return PyString_FromString(str); } //---------------------SEQUENCE PROTOCOLS------------------------ //----------------------------len(object)------------------------ @@ -311,6 +312,7 @@ static int Quaternion_ass_slice(QuaternionObject * self, int begin, int end, { int i, y, size = 0; float quat[4]; + PyObject *q, *f; CLAMP(begin, 0, 4); CLAMP(end, 0, 4); @@ -323,19 +325,19 @@ static int Quaternion_ass_slice(QuaternionObject * self, int begin, int end, } for (i = 0; i < size; i++) { - PyObject *q, *f; - q = PySequence_GetItem(seq, i); if (q == NULL) { // Failed to read sequence return EXPP_ReturnIntError(PyExc_RuntimeError, "quaternion[begin:end] = []: unable to read sequence\n"); } + f = PyNumber_Float(q); if(f == NULL) { // parsed item not a number Py_DECREF(q); return EXPP_ReturnIntError(PyExc_TypeError, "quaternion[begin:end] = []: sequence argument not a number\n"); } + quat[i] = (float)PyFloat_AS_DOUBLE(f); EXPP_decr2(f,q); } @@ -354,7 +356,6 @@ static PyObject *Quaternion_add(PyObject * q1, PyObject * q2) float quat[4]; QuaternionObject *quat1 = NULL, *quat2 = NULL; - EXPP_incr2(q1, q2); quat1 = (QuaternionObject*)q1; quat2 = (QuaternionObject*)q2; @@ -366,8 +367,7 @@ static PyObject *Quaternion_add(PyObject * q1, PyObject * q2) quat[x] = quat1->quat[x] + quat2->quat[x]; } - EXPP_decr2((PyObject*)quat1, (PyObject*)quat2); - return (PyObject *) newQuaternionObject(quat, Py_NEW); + return newQuaternionObject(quat, Py_NEW); } //------------------------obj - obj------------------------------ //subtraction @@ -377,7 +377,6 @@ static PyObject *Quaternion_sub(PyObject * q1, PyObject * q2) float quat[4]; QuaternionObject *quat1 = NULL, *quat2 = NULL; - EXPP_incr2(q1, q2); quat1 = (QuaternionObject*)q1; quat2 = (QuaternionObject*)q2; @@ -389,8 +388,7 @@ static PyObject *Quaternion_sub(PyObject * q1, PyObject * q2) quat[x] = quat1->quat[x] - quat2->quat[x]; } - EXPP_decr2((PyObject*)quat1, (PyObject*)quat2); - return (PyObject *) newQuaternionObject(quat, Py_NEW); + return newQuaternionObject(quat, Py_NEW); } //------------------------obj * obj------------------------------ //mulplication @@ -400,11 +398,10 @@ static PyObject *Quaternion_mul(PyObject * q1, PyObject * q2) float quat[4], scalar; double dot = 0.0f; QuaternionObject *quat1 = NULL, *quat2 = NULL; - PyObject *f = NULL, *retObj = NULL; + PyObject *f = NULL; VectorObject *vec = NULL; PointObject *pt = NULL; - EXPP_incr2(q1, q2); quat1 = (QuaternionObject*)q1; quat2 = (QuaternionObject*)q2; @@ -413,16 +410,15 @@ static PyObject *Quaternion_mul(PyObject * q1, PyObject * q2) PyInt_Check(quat1->coerced_object)){ // FLOAT/INT * QUAT f = PyNumber_Float(quat1->coerced_object); if(f == NULL) { // parsed item not a number - EXPP_decr2((PyObject*)quat1, (PyObject*)quat2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Quaternion multiplication: arguments not acceptable for this operation\n"); } + scalar = (float)PyFloat_AS_DOUBLE(f); for(x = 0; x < 4; x++) { quat[x] = quat2->quat[x] * scalar; } - EXPP_decr2((PyObject*)quat1, (PyObject*)quat2); - return (PyObject *) newQuaternionObject(quat, Py_NEW); + return newQuaternionObject(quat, Py_NEW); } }else{ if(quat2->coerced_object){ @@ -430,47 +426,38 @@ static PyObject *Quaternion_mul(PyObject * q1, PyObject * q2) PyInt_Check(quat2->coerced_object)){ // QUAT * FLOAT/INT f = PyNumber_Float(quat2->coerced_object); if(f == NULL) { // parsed item not a number - EXPP_decr2((PyObject*)quat1, (PyObject*)quat2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Quaternion multiplication: arguments not acceptable for this operation\n"); } + scalar = (float)PyFloat_AS_DOUBLE(f); for(x = 0; x < 4; x++) { quat[x] = quat1->quat[x] * scalar; } - EXPP_decr2((PyObject*)quat1, (PyObject*)quat2); - return (PyObject *) newQuaternionObject(quat, Py_NEW); + return newQuaternionObject(quat, Py_NEW); }else if(VectorObject_Check(quat2->coerced_object)){ //QUAT * VEC - vec = (VectorObject*)EXPP_incr_ret(quat2->coerced_object); + vec = (VectorObject*)quat2->coerced_object; if(vec->size != 3){ - EXPP_decr2((PyObject*)quat1, (PyObject*)quat2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Quaternion multiplication: only 3D vector rotations currently supported\n"); } - retObj = quat_rotation((PyObject*)quat1, (PyObject*)vec); - EXPP_decr3((PyObject*)quat1, (PyObject*)quat2, (PyObject*)vec); - return retObj; + return quat_rotation((PyObject*)quat1, (PyObject*)vec); }else if(PointObject_Check(quat2->coerced_object)){ //QUAT * POINT - pt = (PointObject*)EXPP_incr_ret(quat2->coerced_object); + pt = (PointObject*)quat2->coerced_object; if(pt->size != 3){ - EXPP_decr2((PyObject*)quat1, (PyObject*)quat2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Quaternion multiplication: only 3D point rotations currently supported\n"); } - retObj = quat_rotation((PyObject*)quat1, (PyObject*)pt); - EXPP_decr3((PyObject*)quat1, (PyObject*)quat2, (PyObject*)pt); - return retObj; + return quat_rotation((PyObject*)quat1, (PyObject*)pt); } }else{ //QUAT * QUAT (dot product) for(x = 0; x < 4; x++) { dot += quat1->quat[x] * quat1->quat[x]; } - EXPP_decr2((PyObject*)quat1, (PyObject*)quat2); return PyFloat_FromDouble(dot); } } - EXPP_decr2((PyObject*)quat1, (PyObject*)quat2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Quaternion multiplication: arguments not acceptable for this operation\n"); } diff --git a/source/blender/python/api2_2x/vector.c b/source/blender/python/api2_2x/vector.c index dd8131b2e5a..af151d87d4e 100644 --- a/source/blender/python/api2_2x/vector.c +++ b/source/blender/python/api2_2x/vector.c @@ -73,7 +73,7 @@ PyObject *Vector_toPoint(VectorObject * self) coord[x] = self->vec[x]; } - return (PyObject *) newPointObject(coord, self->size, Py_NEW); + return newPointObject(coord, self->size, Py_NEW); } //----------------------------Vector.zero() ---------------------- //set the vector data to 0,0,0 @@ -176,14 +176,11 @@ PyObject *Vector_ToTrackQuat( VectorObject * self, PyObject * args ) short track = 2, up = 1; if( !PyArg_ParseTuple ( args, "|ss", &strack, &sup ) ) { - return ( EXPP_ReturnPyObjError - ( PyExc_TypeError, - "expected optional two strings\n" ) ); + return EXPP_ReturnPyObjError( PyExc_TypeError, + "expected optional two strings\n" ); } if (self->size != 3) { - return ( EXPP_ReturnPyObjError - ( PyExc_TypeError, - "only for 3D vectors\n" ) ); + return EXPP_ReturnPyObjError( PyExc_TypeError, "only for 3D vectors\n" ); } if (strack) { @@ -283,6 +280,7 @@ PyObject *Vector_ToTrackQuat( VectorObject * self, PyObject * args ) //free the py_object static void Vector_dealloc(VectorObject * self) { + Py_XDECREF(self->coerced_object); //only free py_data if(self->data.py_data){ PyMem_Free(self->data.py_data); @@ -388,7 +386,7 @@ static PyObject *Vector_repr(VectorObject * self) } strcat(str, "](vector)"); - return EXPP_incr_ret(PyString_FromString(str)); + return PyString_FromString(str); } //---------------------SEQUENCE PROTOCOLS------------------------ //----------------------------len(object)------------------------ @@ -455,6 +453,7 @@ static int Vector_ass_slice(VectorObject * self, int begin, int end, { int i, y, size = 0; float vec[4]; + PyObject *v, *f; CLAMP(begin, 0, self->size); CLAMP(end, 0, self->size); @@ -467,19 +466,19 @@ static int Vector_ass_slice(VectorObject * self, int begin, int end, } for (i = 0; i < size; i++) { - PyObject *v, *f; - v = PySequence_GetItem(seq, i); if (v == NULL) { // Failed to read sequence return EXPP_ReturnIntError(PyExc_RuntimeError, "vector[begin:end] = []: unable to read sequence\n"); } + f = PyNumber_Float(v); if(f == NULL) { // parsed item not a number Py_DECREF(v); return EXPP_ReturnIntError(PyExc_TypeError, "vector[begin:end] = []: sequence argument not a number\n"); } + vec[i] = (float)PyFloat_AS_DOUBLE(f); EXPP_decr2(f,v); } @@ -499,7 +498,6 @@ static PyObject *Vector_add(PyObject * v1, PyObject * v2) VectorObject *vec1 = NULL, *vec2 = NULL; PointObject *pt = NULL; - EXPP_incr2(v1, v2); vec1 = (VectorObject*)v1; vec2 = (VectorObject*)v2; @@ -507,23 +505,20 @@ static PyObject *Vector_add(PyObject * v1, PyObject * v2) if(vec2->coerced_object){ if(PointObject_Check(vec2->coerced_object)){ //VECTOR + POINT //Point translation - pt = (PointObject*)EXPP_incr_ret(vec2->coerced_object); + pt = (PointObject*)vec2->coerced_object; size = vec1->size; if(pt->size == size){ for(x = 0; x < size; x++){ vec[x] = vec1->vec[x] + pt->coord[x]; } }else{ - EXPP_decr3((PyObject*)vec1, (PyObject*)vec2, (PyObject*)pt); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Vector addition: arguments are the wrong size....\n"); } - EXPP_decr3((PyObject*)vec1, (PyObject*)vec2, (PyObject*)pt); - return (PyObject *) newPointObject(vec, size, Py_NEW); + return newPointObject(vec, size, Py_NEW); } }else{ //VECTOR + VECTOR if(vec1->size != vec2->size){ - EXPP_decr2((PyObject*)vec1, (PyObject*)vec2); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Vector addition: vectors must have the same dimensions for this operation\n"); } @@ -531,8 +526,7 @@ static PyObject *Vector_add(PyObject * v1, PyObject * v2) for(x = 0; x < size; x++) { vec[x] = vec1->vec[x] + vec2->vec[x]; } - EXPP_decr2((PyObject*)vec1, (PyObject*)vec2); - return (PyObject *) newVectorObject(vec, size, Py_NEW); + return newVectorObject(vec, size, Py_NEW); } } @@ -547,7 +541,6 @@ static PyObject *Vector_sub(PyObject * v1, PyObject * v2) float vec[4]; VectorObject *vec1 = NULL, *vec2 = NULL; - EXPP_incr2(v1, v2); vec1 = (VectorObject*)v1; vec2 = (VectorObject*)v2; @@ -556,7 +549,6 @@ static PyObject *Vector_sub(PyObject * v1, PyObject * v2) "Vector subtraction: arguments not valid for this operation....\n"); } if(vec1->size != vec2->size){ - EXPP_decr2((PyObject*)vec1, (PyObject*)vec2); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Vector subtraction: vectors must have the same dimensions for this operation\n"); } @@ -566,8 +558,7 @@ static PyObject *Vector_sub(PyObject * v1, PyObject * v2) vec[x] = vec1->vec[x] - vec2->vec[x]; } - EXPP_decr2((PyObject*)vec1, (PyObject*)vec2); - return (PyObject *) newVectorObject(vec, size, Py_NEW); + return newVectorObject(vec, size, Py_NEW); } //------------------------obj * obj------------------------------ //mulplication @@ -581,7 +572,6 @@ static PyObject *Vector_mul(PyObject * v1, PyObject * v2) MatrixObject *mat = NULL; QuaternionObject *quat = NULL; - EXPP_incr2(v1, v2); vec1 = (VectorObject*)v1; vec2 = (VectorObject*)v2; @@ -590,54 +580,48 @@ static PyObject *Vector_mul(PyObject * v1, PyObject * v2) PyInt_Check(vec1->coerced_object)){ // FLOAT/INT * VECTOR f = PyNumber_Float(vec1->coerced_object); if(f == NULL) { // parsed item not a number - EXPP_decr2((PyObject*)vec1, (PyObject*)vec2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Vector multiplication: arguments not acceptable for this operation\n"); } + scalar = (float)PyFloat_AS_DOUBLE(f); size = vec2->size; for(x = 0; x < size; x++) { vec[x] = vec2->vec[x] * scalar; } - EXPP_decr2((PyObject*)vec1, (PyObject*)vec2); - return (PyObject *) newVectorObject(vec, size, Py_NEW); + Py_DECREF(f); + return newVectorObject(vec, size, Py_NEW); } }else{ if(vec2->coerced_object){ if(MatrixObject_Check(vec2->coerced_object)){ //VECTOR * MATRIX - mat = (MatrixObject*)EXPP_incr_ret(vec2->coerced_object); - retObj = row_vector_multiplication(vec1, mat); - EXPP_decr3((PyObject*)vec1, (PyObject*)vec2, (PyObject*)mat); - return retObj; + mat = (MatrixObject*)vec2->coerced_object; + return retObj = row_vector_multiplication(vec1, mat); }else if (PyFloat_Check(vec2->coerced_object) || PyInt_Check(vec2->coerced_object)){ // VECTOR * FLOAT/INT f = PyNumber_Float(vec2->coerced_object); if(f == NULL) { // parsed item not a number - EXPP_decr2((PyObject*)vec1, (PyObject*)vec2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Vector multiplication: arguments not acceptable for this operation\n"); } + scalar = (float)PyFloat_AS_DOUBLE(f); size = vec1->size; for(x = 0; x < size; x++) { vec[x] = vec1->vec[x] * scalar; } - EXPP_decr2((PyObject*)vec1, (PyObject*)vec2); - return (PyObject *) newVectorObject(vec, size, Py_NEW); + Py_DECREF(f); + return newVectorObject(vec, size, Py_NEW); }else if(QuaternionObject_Check(vec2->coerced_object)){ //VECTOR * QUATERNION - quat = (QuaternionObject*)EXPP_incr_ret(vec2->coerced_object); + quat = (QuaternionObject*)vec2->coerced_object; if(vec1->size != 3){ - EXPP_decr2((PyObject*)vec1, (PyObject*)vec2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Vector multiplication: only 3D vector rotations (with quats) currently supported\n"); } - retObj = quat_rotation((PyObject*)vec1, (PyObject*)quat); - EXPP_decr3((PyObject*)vec1, (PyObject*)vec2, (PyObject*)quat); - return retObj; + return quat_rotation((PyObject*)vec1, (PyObject*)quat); } }else{ //VECTOR * VECTOR if(vec1->size != vec2->size){ - EXPP_decr2((PyObject*)vec1, (PyObject*)vec2); return EXPP_ReturnPyObjError(PyExc_AttributeError, "Vector multiplication: vectors must have the same dimensions for this operation\n"); } @@ -646,12 +630,10 @@ static PyObject *Vector_mul(PyObject * v1, PyObject * v2) for(x = 0; x < size; x++) { dot += vec1->vec[x] * vec2->vec[x]; } - EXPP_decr2((PyObject*)vec1, (PyObject*)vec2); return PyFloat_FromDouble(dot); } } - EXPP_decr2((PyObject*)vec1, (PyObject*)vec2); return EXPP_ReturnPyObjError(PyExc_TypeError, "Vector multiplication: arguments not acceptable for this operation\n"); } @@ -733,8 +715,6 @@ PyObject* Vector_richcmpr(PyObject *objectA, PyObject *objectB, int comparison_t return EXPP_incr_ret(Py_False); } } - Py_INCREF(objectA); - Py_INCREF(objectB); vecA = (VectorObject*)objectA; vecB = (VectorObject*)objectB;