diff options
Diffstat (limited to 'source/blender/bpython/intern/opy_matrix.c')
| -rw-r--r-- | source/blender/bpython/intern/opy_matrix.c | 173 |
1 files changed, 173 insertions, 0 deletions
diff --git a/source/blender/bpython/intern/opy_matrix.c b/source/blender/bpython/intern/opy_matrix.c new file mode 100644 index 00000000000..cd93bd5f311 --- /dev/null +++ b/source/blender/bpython/intern/opy_matrix.c @@ -0,0 +1,173 @@ +/* python.c MIXED MODEL + * + * june 99 + * $Id$ + * + * this code might die... + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "Python.h" +#include "BPY_tools.h" +#include "BPY_macros.h" + +#include "BLI_arithb.h" +#include "opy_vector.h" + +PyObject *BPY_tuple_repr(PyObject *self, int size); + +/* PROTOS */ +// PyObject *newVectorObject(float *vec, int size); + +/*****************************/ +/* Matrix Python Object */ +/*****************************/ + + +#define GETROWVECTOR(mat, i) ( (float *) mat[i]) + +static void Matrix_dealloc(MatrixObject *self) { + Py_DECREF(self->rows[0]); + Py_DECREF(self->rows[1]); + Py_DECREF(self->rows[2]); + Py_DECREF(self->rows[3]); + + PyMem_DEL(self); +} + +#undef MethodDef +#define MethodDef(func) _MethodDef(func, Matrix) + +static char Matrix_inverse_doc[] = "() - returns inverse of matrix"; + +static PyObject *Matrix_inverse(PyObject *self, PyObject *args) +{ + float inverse[4][4]; + MatrixObject *mat = (MatrixObject *) self; + Mat4Invert(inverse, mat->mat); + return newMatrixObject(inverse); +} + +struct PyMethodDef Matrix_methods[] = { + MethodDef(inverse), + {NULL, NULL} +}; + +static PyObject *Matrix_getattr(MatrixObject *self, char *name) +{ + PyObject *list; + float val[3]; + + if (strcmp(name, "rot")==0) { + float mat3[3][3]; + + Mat3CpyMat4(mat3, self->mat); + Mat3ToEul(mat3, val); + + } else if (strcmp(name, "size")==0) { + Mat4ToSize(self->mat, val); + /* Oh man, this is BAD. */ + } else if (strcmp(name, "loc")==0) { + VECCOPY(val, (float *) (self->mat)[3]); + + } else { + PyErr_SetString(PyExc_AttributeError, name); + return NULL; + } + + list= PyList_New(3); + PyList_SetItem(list, 0, PyFloat_FromDouble(val[0])); + PyList_SetItem(list, 1, PyFloat_FromDouble(val[1])); + PyList_SetItem(list, 2, PyFloat_FromDouble(val[2])); + + return list; +} + +static int Matrix_setattr(MatrixObject *self, char *name, PyObject *v) { + return -1; +} + +static PyObject *Matrix_repr (MatrixObject *self) { + return BPY_tuple_repr((PyObject *) self, 4); +} + +static PyObject *Matrix_item(MatrixObject *self, int i) +{ + if (i < 0 || i >= 4) { + PyErr_SetString(PyExc_IndexError, "array index out of range"); + return NULL; + } + return BPY_incr_ret(self->rows[i]); +} + +static PySequenceMethods Matrix_SeqMethods = { + (inquiry) 0, /*sq_length*/ + (binaryfunc) 0, /*sq_concat*/ + (intargfunc) 0, /*sq_repeat*/ + (intargfunc) Matrix_item, /*sq_item*/ + (intintargfunc) 0, /*sq_slice*/ + (intobjargproc) 0, /*sq_ass_item*/ + (intintobjargproc) 0, /*sq_ass_slice*/ +}; + +PyTypeObject Matrix_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "Matrix", /*tp_name*/ + sizeof(MatrixObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) Matrix_dealloc, /*tp_dealloc*/ + (printfunc) 0, /*tp_print*/ + (getattrfunc) Matrix_getattr, /*tp_getattr*/ + (setattrfunc) Matrix_setattr, /*tp_setattr*/ + 0, /*tp_compare*/ + (reprfunc) Matrix_repr, /*tp_repr*/ + 0, /*tp_as_number*/ + &Matrix_SeqMethods, /*tp_as_sequence*/ +}; + +PyObject *newMatrixObject(Matrix4Ptr mat) { + MatrixObject *self; + + self= PyObject_NEW(MatrixObject, &Matrix_Type); + self->mat= mat; + + BPY_TRY(self->rows[0]= newVectorObject(GETROWVECTOR(self->mat, 0), 4)); + BPY_TRY(self->rows[1]= newVectorObject(GETROWVECTOR(self->mat, 1), 4)); + BPY_TRY(self->rows[2]= newVectorObject(GETROWVECTOR(self->mat, 2), 4)); + BPY_TRY(self->rows[3]= newVectorObject(GETROWVECTOR(self->mat, 3), 4)); + + return (PyObject*) self; +} + +void init_py_matrix(void) { + Matrix_Type.ob_type = &PyType_Type; +} |