archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

minor changes to the python api.

Browse Source 
- pep8 script was giving an error on non utf8 scons source files.
- use PyList_SET_ITEM macro when list type is ensured.
- all mathutils types use subtypes to create new types when available.
- use defines MAT3_UNITY, MAT4_UNITY to initialize unit matrices.
This commit is contained in:
Campbell Barton
2010-11-28 06:03:30 +00:00
parent 9d3a17922c
commit 34ea1cf0b2
23 changed files with 81 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
source/blender/python/generic/bgl.c
View File

@@ -297,9 +297,9 @@ static PyObject *Buffer_slice(PyObject *self, int begin, int end)
list= PyList_New(end-begin);
for (count= begin; count<end; count++)
PyList_SetItem(list, count-begin, Buffer_item(self, count));
for (count= begin; count<end; count++) {
PyList_SET_ITEM(list, count-begin, Buffer_item(self, count));
}
return list;
}
@@ -391,11 +391,11 @@ static PyObject *Buffer_tolist(PyObject *self)
{
int i, len= ((Buffer *)self)->dimensions[0];
PyObject *list= PyList_New(len);
for (i=0; i<len; i++) {
PyList_SetItem(list, i, Buffer_item(self, i));
PyList_SET_ITEM(list, i, Buffer_item(self, i));
}
return list;
}
@@ -404,11 +404,11 @@ static PyObject *Buffer_dimensions(PyObject *self)
Buffer *buffer= (Buffer *) self;
PyObject *list= PyList_New(buffer->ndimensions);
int i;
for (i= 0; i<buffer->ndimensions; i++) {
PyList_SetItem(list, i, PyLong_FromLong(buffer->dimensions[i]));
PyList_SET_ITEM(list, i, PyLong_FromLong(buffer->dimensions[i]));
}
return list;
}

15
source/blender/python/generic/mathutils_color.c
View File

@@ -225,9 +225,8 @@ static PyObject *Color_slice(ColorObject * self, int begin, int end)
begin = MIN2(begin,end);
list = PyList_New(end - begin);
for(count = begin; count < end; count++) {
PyList_SetItem(list, count - begin,
PyFloat_FromDouble(self->col[count]));
for(count= begin; count < end; count++) {
PyList_SET_ITEM(list, count - begin, PyFloat_FromDouble(self->col[count]));
}
return list;
@@ -290,9 +289,7 @@ static PyObject *Color_subscript(ColorObject *self, PyObject *item)
}
}
else {
PyErr_Format(PyExc_TypeError,
"color indices must be integers, not %.200s",
item->ob_type->tp_name);
PyErr_Format(PyExc_TypeError, "color indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
return NULL;
}
}
@@ -321,9 +318,7 @@ static int Color_ass_subscript(ColorObject *self, PyObject *item, PyObject *valu
}
}
else {
PyErr_Format(PyExc_TypeError,
"color indices must be integers, not %.200s",
item->ob_type->tp_name);
PyErr_Format(PyExc_TypeError, "color indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
return -1;
}
}
@@ -468,7 +463,7 @@ static char color_doc[] =
PyTypeObject color_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"color", //tp_name
"mathutils.Color", //tp_name
sizeof(ColorObject), //tp_basicsize
0, //tp_itemsize
(destructor)BaseMathObject_dealloc, //tp_dealloc

17
source/blender/python/generic/mathutils_euler.c
View File

@@ -39,7 +39,7 @@
//----------------------------------mathutils.Euler() -------------------
//makes a new euler for you to play with
static PyObject *Euler_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject *kwds)
static PyObject *Euler_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
PyObject *seq= NULL;
char *order_str= NULL;
@@ -67,7 +67,7 @@ static PyObject *Euler_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject
return NULL;
break;
}
return newEulerObject(eul, order, Py_NEW, NULL);
return newEulerObject(eul, order, Py_NEW, type);
}
short euler_order_from_string(const char *str, const char *error_prefix)
@@ -456,8 +456,7 @@ static PyObject *Euler_slice(EulerObject * self, int begin, int end)
list = PyList_New(end - begin);
for(count = begin; count < end; count++) {
PyList_SetItem(list, count - begin,
PyFloat_FromDouble(self->eul[count]));
PyList_SET_ITEM(list, count - begin, PyFloat_FromDouble(self->eul[count]));
}
return list;
@@ -520,9 +519,7 @@ static PyObject *Euler_subscript(EulerObject *self, PyObject *item)
}
}
else {
PyErr_Format(PyExc_TypeError,
"euler indices must be integers, not %.200s",
item->ob_type->tp_name);
PyErr_Format(PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
return NULL;
}
}
@@ -552,9 +549,7 @@ static int Euler_ass_subscript(EulerObject *self, PyObject *item, PyObject *valu
}
}
else {
PyErr_Format(PyExc_TypeError,
"euler indices must be integers, not %.200s",
item->ob_type->tp_name);
PyErr_Format(PyExc_TypeError, "euler indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
return -1;
}
}
@@ -650,7 +645,7 @@ static char euler_doc[] =
PyTypeObject euler_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"euler", //tp_name
"mathutils.Euler", //tp_name
sizeof(EulerObject), //tp_basicsize
0, //tp_itemsize
(destructor)BaseMathObject_dealloc, //tp_dealloc

2
source/blender/python/generic/mathutils_geometry.c
View File

@@ -435,7 +435,7 @@ static PyObject *M_Geometry_PolyFill(PyObject *UNUSED(self), PyObject * polyLine
index= 0;
dl_face= dl->index;
while(index < dl->parts) {
PyList_SetItem(tri_list, index, Py_BuildValue("iii", dl_face[0], dl_face[1], dl_face[2]) );
PyList_SET_ITEM(tri_list, index, Py_BuildValue("iii", dl_face[0], dl_face[1], dl_face[2]) );
dl_face+= 3;
index++;
}

24
source/blender/python/generic/mathutils_matrix.c
View File

@@ -105,7 +105,7 @@ Mathutils_Callback mathutils_matrix_vector_cb = {
//----------------------------------mathutils.Matrix() -----------------
//mat is a 1D array of floats - row[0][0],row[0][1], row[1][0], etc.
//create a new matrix type
static PyObject *Matrix_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject *kwds)
static PyObject *Matrix_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
PyObject *argObject, *m, *s;
MatrixObject *mat;
@@ -124,7 +124,7 @@ static PyObject *Matrix_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject
PyErr_SetString(PyExc_AttributeError, "mathutils.Matrix(): expects 0-4 numeric sequences of the same size");
return NULL;
} else if (argSize == 0) { //return empty 4D matrix
return (PyObject *) newMatrixObject(NULL, 4, 4, Py_NEW, NULL);
return (PyObject *) newMatrixObject(NULL, 4, 4, Py_NEW, type);
}else if (argSize == 1){
//copy constructor for matrix objects
argObject = PyTuple_GET_ITEM(args, 0);
@@ -180,7 +180,7 @@ static PyObject *Matrix_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject
}
}
}
return newMatrixObject(matrix, argSize, seqSize, Py_NEW, NULL);
return newMatrixObject(matrix, argSize, seqSize, Py_NEW, type);
}
/*-----------------------CLASS-METHODS----------------------------*/
@@ -1410,7 +1410,7 @@ static PyObject *Matrix_slice(MatrixObject * self, int begin, int end)
list = PyList_New(end - begin);
for(count = begin; count < end; count++) {
PyList_SetItem(list, count - begin,
PyList_SET_ITEM(list, count - begin,
newVectorObject_cb((PyObject *)self, self->colSize, mathutils_matrix_vector_cb_index, count));
}
@@ -1597,7 +1597,7 @@ static PyObject *Matrix_mul(PyObject * m1, PyObject * m2)
}
}
return newMatrixObject(mat, mat2->rowSize, mat1->colSize, Py_NEW, NULL);
return newMatrixObject(mat, mat2->rowSize, mat1->colSize, Py_NEW, Py_TYPE(mat1));
}
if(mat1==NULL){
@@ -1608,7 +1608,7 @@ static PyObject *Matrix_mul(PyObject * m1, PyObject * m2)
mat[((x * mat2->colSize) + y)] = scalar * mat2->matrix[x][y];
}
}
return newMatrixObject(mat, mat2->rowSize, mat2->colSize, Py_NEW, NULL);
return newMatrixObject(mat, mat2->rowSize, mat2->colSize, Py_NEW, Py_TYPE(mat2));
}
PyErr_SetString(PyExc_TypeError, "Matrix multiplication: arguments not acceptable for this operation");
@@ -1627,7 +1627,7 @@ static PyObject *Matrix_mul(PyObject * m1, PyObject * m2)
mat[((x * mat1->colSize) + y)] = scalar * mat1->matrix[x][y];
}
}
return newMatrixObject(mat, mat1->rowSize, mat1->colSize, Py_NEW, NULL);
return newMatrixObject(mat, mat1->rowSize, mat1->colSize, Py_NEW, Py_TYPE(mat1));
}
}
PyErr_SetString(PyExc_TypeError, "Matrix multiplication: arguments not acceptable for this operation");
@@ -1688,9 +1688,7 @@ static PyObject *Matrix_subscript(MatrixObject* self, PyObject* item)
}
}
else {
PyErr_Format(PyExc_TypeError,
"vector indices must be integers, not %.200s",
item->ob_type->tp_name);
PyErr_Format(PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
return NULL;
}
}
@@ -1719,9 +1717,7 @@ static int Matrix_ass_subscript(MatrixObject* self, PyObject* item, PyObject* va
}
}
else {
PyErr_Format(PyExc_TypeError,
"matrix indices must be integers, not %.200s",
item->ob_type->tp_name);
PyErr_Format(PyExc_TypeError, "matrix indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
return -1;
}
}
@@ -1865,7 +1861,7 @@ static char matrix_doc[] =
PyTypeObject matrix_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"matrix", /*tp_name*/
"mathutils.Matrix", /*tp_name*/
sizeof(MatrixObject), /*tp_basicsize*/
0, /*tp_itemsize*/
(destructor)BaseMathObject_dealloc, /*tp_dealloc*/

33
source/blender/python/generic/mathutils_quat.c
View File

@@ -151,7 +151,7 @@ static PyObject *Quaternion_Cross(QuaternionObject *self, QuaternionObject *valu
return NULL;
mul_qt_qtqt(quat, self->quat, value->quat);
return newQuaternionObject(quat, Py_NEW, NULL);
return newQuaternionObject(quat, Py_NEW, Py_TYPE(self));
}
//----------------------------Quaternion.dot(other)------------------
@@ -202,7 +202,7 @@ static PyObject *Quaternion_Difference(QuaternionObject * self, QuaternionObject
rotation_between_quats_to_quat(quat, self->quat, value->quat);
return newQuaternionObject(quat, Py_NEW, NULL);
return newQuaternionObject(quat, Py_NEW, Py_TYPE(self));
}
static char Quaternion_Slerp_doc[] =
@@ -237,7 +237,7 @@ static PyObject *Quaternion_Slerp(QuaternionObject *self, PyObject *args)
interp_qt_qtqt(quat, self->quat, value->quat, fac);
return newQuaternionObject(quat, Py_NEW, NULL);
return newQuaternionObject(quat, Py_NEW, Py_TYPE(self));
}
//----------------------------Quaternion.normalize()----------------
@@ -490,8 +490,7 @@ static PyObject *Quaternion_slice(QuaternionObject * self, int begin, int end)
list = PyList_New(end - begin);
for(count = begin; count < end; count++) {
PyList_SetItem(list, count - begin,
PyFloat_FromDouble(self->quat[count]));
PyList_SET_ITEM(list, count - begin, PyFloat_FromDouble(self->quat[count]));
}
return list;
@@ -556,9 +555,7 @@ static PyObject *Quaternion_subscript(QuaternionObject *self, PyObject *item)
}
}
else {
PyErr_Format(PyExc_TypeError,
"quaternion indices must be integers, not %.200s",
item->ob_type->tp_name);
PyErr_Format(PyExc_TypeError, "quaternion indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
return NULL;
}
}
@@ -588,9 +585,7 @@ static int Quaternion_ass_subscript(QuaternionObject *self, PyObject *item, PyOb
}
}
else {
PyErr_Format(PyExc_TypeError,
"quaternion indices must be integers, not %.200s",
item->ob_type->tp_name);
PyErr_Format(PyExc_TypeError, "quaternion indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
return -1;
}
}
@@ -614,7 +609,7 @@ static PyObject *Quaternion_add(PyObject * q1, PyObject * q2)
return NULL;
add_qt_qtqt(quat, quat1->quat, quat2->quat, 1.0f);
return newQuaternionObject(quat, Py_NEW, NULL);
return newQuaternionObject(quat, Py_NEW, Py_TYPE(q1));
}
//------------------------obj - obj------------------------------
//subtraction
@@ -639,7 +634,7 @@ static PyObject *Quaternion_sub(PyObject * q1, PyObject * q2)
quat[x] = quat1->quat[x] - quat2->quat[x];
}
return newQuaternionObject(quat, Py_NEW, NULL);
return newQuaternionObject(quat, Py_NEW, Py_TYPE(q1));
}
//------------------------obj * obj------------------------------
//mulplication
@@ -661,7 +656,7 @@ static PyObject *Quaternion_mul(PyObject * q1, PyObject * q2)
if(quat1 && quat2) { /* QUAT*QUAT (cross product) */
mul_qt_qtqt(quat, quat1->quat, quat2->quat);
return newQuaternionObject(quat, Py_NEW, NULL);
return newQuaternionObject(quat, Py_NEW, Py_TYPE(q1));
}
/* the only case this can happen (for a supported type is "FLOAT*QUAT" ) */
@@ -670,7 +665,7 @@ static PyObject *Quaternion_mul(PyObject * q1, PyObject * q2)
if ((scalar == -1.0 && PyErr_Occurred())==0) { /* FLOAT*QUAT */
QUATCOPY(quat, quat2->quat);
mul_qt_fl(quat, scalar);
return newQuaternionObject(quat, Py_NEW, NULL);
return newQuaternionObject(quat, Py_NEW, Py_TYPE(q2));
}
PyErr_SetString(PyExc_TypeError, "Quaternion multiplication: val * quat, val is not an acceptable type");
return NULL;
@@ -685,7 +680,7 @@ static PyObject *Quaternion_mul(PyObject * q1, PyObject * q2)
if ((scalar == -1.0 && PyErr_Occurred())==0) { /* QUAT*FLOAT */
QUATCOPY(quat, quat1->quat);
mul_qt_fl(quat, scalar);
return newQuaternionObject(quat, Py_NEW, NULL);
return newQuaternionObject(quat, Py_NEW, Py_TYPE(q1));
}
}
@@ -860,7 +855,7 @@ static int Quaternion_setAxisVec(QuaternionObject *self, PyObject *value, void *
}
//----------------------------------mathutils.Quaternion() --------------
static PyObject *Quaternion_new(PyTypeObject *UNUSED(type), PyObject *args, PyObject *kwds)
static PyObject *Quaternion_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
PyObject *seq= NULL;
float angle = 0.0f;
@@ -889,7 +884,7 @@ static PyObject *Quaternion_new(PyTypeObject *UNUSED(type), PyObject *args, PyOb
break;
/* PyArg_ParseTuple assures no more then 2 */
}
return newQuaternionObject(quat, Py_NEW, NULL);
return newQuaternionObject(quat, Py_NEW, type);
}
@@ -933,7 +928,7 @@ static char quaternion_doc[] =
PyTypeObject quaternion_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"quaternion", //tp_name
"mathutils.Quaternion", //tp_name
sizeof(QuaternionObject), //tp_basicsize
0, //tp_itemsize
(destructor)BaseMathObject_dealloc, //tp_dealloc

16
source/blender/python/generic/mathutils_vector.c
View File

@@ -379,9 +379,7 @@ static PyObject *Vector_ToTrackQuat(VectorObject *self, PyObject *args )
flip vector around, since vectoquat expect a vector from target to tracking object
and the python function expects the inverse (a vector to the target).
*/
vec[0] = -self->vec[0];
vec[1] = -self->vec[1];
vec[2] = -self->vec[2];
negate_v3_v3(vec, self->vec);
vec_to_quat( quat,vec, track, up);
@@ -1400,9 +1398,7 @@ static PyObject *Vector_subscript(VectorObject* self, PyObject* item)
}
}
else {
PyErr_Format(PyExc_TypeError,
"vector indices must be integers, not %.200s",
item->ob_type->tp_name);
PyErr_Format(PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
return NULL;
}
}
@@ -1431,9 +1427,7 @@ static int Vector_ass_subscript(VectorObject* self, PyObject* item, PyObject* va
}
}
else {
PyErr_Format(PyExc_TypeError,
"vector indices must be integers, not %.200s",
item->ob_type->tp_name);
PyErr_Format(PyExc_TypeError, "vector indices must be integers, not %.200s", Py_TYPE(item)->tp_name);
return -1;
}
}
@@ -2163,7 +2157,7 @@ static char vector_doc[] =
PyTypeObject vector_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
/* For printing, in format "<module>.<name>" */
"vector", /* char *tp_name; */
"mathutils.Vector", /* char *tp_name; */
sizeof(VectorObject), /* int tp_basicsize; */
0, /* tp_itemsize; For allocation */
@@ -2296,6 +2290,6 @@ PyObject *newVectorObject_cb(PyObject *cb_user, int size, int cb_type, int cb_su
self->cb_type= (unsigned char)cb_type;
self->cb_subtype= (unsigned char)cb_subtype;
}
return (PyObject *)self;
}

2
source/blender/python/intern/bpy_rna.c
View File

@@ -305,7 +305,7 @@ PyObject *pyrna_math_object_from_array(PointerRNA *ptr, PropertyRNA *prop)
case PROP_QUATERNION:
if(len==3) { /* euler */
if(is_thick) {
/* attempt to get order, only needed for thixk types since wrapped with update via callbacks */
/* attempt to get order, only needed for thick types since wrapped with update via callbacks */
PropertyRNA *prop_eul_order= NULL;
short order= pyrna_rotation_euler_order_get(ptr, &prop_eul_order, ROT_MODE_XYZ);