diff options
Diffstat (limited to 'source/blender/python/api2_2x/vector.c')
| -rw-r--r-- | source/blender/python/api2_2x/vector.c | 222 |
1 files changed, 222 insertions, 0 deletions
diff --git a/source/blender/python/api2_2x/vector.c b/source/blender/python/api2_2x/vector.c new file mode 100644 index 00000000000..1e893a33dcd --- /dev/null +++ b/source/blender/python/api2_2x/vector.c @@ -0,0 +1,222 @@ +/* + * + * ***** 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. + * + * + * Contributor(s): Willian P. Germano + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +/* This file is the old bpython opy_vector.c with minor modifications */ + +#include "vector.h" + +/*****************************/ +/* Vector Python Object */ +/*****************************/ +#define VectorObject_Check(v) ((v)->ob_type == &Vector_Type) + +static void Vector_dealloc(VectorObject *self) +{ + PyMem_DEL(self); +} + +static PyObject *Vector_getattr(VectorObject *self, char *name) +{ + if (self->size==3 && ELEM3(name[0], 'x', 'y', 'z') && name[1]==0) + return PyFloat_FromDouble(self->vec[ name[0]-'x' ]); + + return EXPP_ReturnPyObjError(PyExc_AttributeError, "attribute not found"); +} + +static int Vector_setattr(VectorObject *self, char *name, PyObject *v) +{ + float val; + + if (!PyArg_Parse(v, "f", &val)) + return EXPP_ReturnIntError(PyExc_TypeError, + "expected float argument"); + + if (self->size==3 && ELEM3(name[0], 'x', 'y', 'z') && name[1]==0) + self->vec[ name[0]-'x' ]= val; + else + return -1; + + return 0; +} + +/* Vectors Sequence methods */ + +static int Vector_len(VectorObject *self) +{ + return self->size; +} + +static PyObject *Vector_item(VectorObject *self, int i) +{ + if (i < 0 || i >= self->size) + return EXPP_ReturnPyObjError (PyExc_IndexError, + "array index out of range"); + + return Py_BuildValue("f", self->vec[i]); +} + +static PyObject *Vector_slice(VectorObject *self, int begin, int end) +{ + PyObject *list; + int count; + + if (begin < 0) begin= 0; + if (end > self->size) end= self->size; + if (begin > end) begin= end; + + list= PyList_New(end-begin); + + for (count = begin; count < end; count++) + PyList_SetItem(list, count-begin, PyFloat_FromDouble(self->vec[count])); + + return list; +} + +static int Vector_ass_item(VectorObject *self, int i, PyObject *ob) +{ + if (i < 0 || i >= self->size) + return EXPP_ReturnIntError(PyExc_IndexError, + "array assignment index out of range"); + + if (!PyNumber_Check(ob)) + return EXPP_ReturnIntError(PyExc_IndexError, + "vector member must be a number"); + + self->vec[i]= PyFloat_AsDouble(ob); + + return 0; +} + +static int Vector_ass_slice(VectorObject *self, int begin, int end, PyObject *seq) +{ + int count; + + if (begin < 0) begin= 0; + if (end > self->size) end= self->size; + if (begin > end) begin= end; + + if (!PySequence_Check(seq)) + return EXPP_ReturnIntError(PyExc_TypeError, + "illegal argument type for built-in operation"); + + if (PySequence_Length(seq) != (end - begin)) + return EXPP_ReturnIntError(PyExc_TypeError, + "size mismatch in slice assignment"); + + for (count = begin; count < end; count++) { + PyObject *ob = PySequence_GetItem(seq, count); + + if (!PyArg_Parse(ob, "f", &self->vec[count])) { + Py_DECREF(ob); + return -1; + } + + Py_DECREF(ob); + } + + return 0; +} + +PyObject *EXPP_tuple_repr(PyObject *self, int size) +{ + PyObject *repr, *comma, *item; + int i; + +/*@ note: a value must be built because the list is decrefed! + * otherwise we have nirvana pointers inside python.. */ + + repr = PyString_FromString("("); + if (!repr) return 0; + + item = PySequence_GetItem(self, 0); + PyString_ConcatAndDel(&repr, PyObject_Repr(item)); + Py_DECREF(item); + + comma = PyString_FromString(", "); + + for (i = 1; i < size; i++) { + PyString_Concat(&repr, comma); + item = PySequence_GetItem(self, i); + PyString_ConcatAndDel(&repr, PyObject_Repr(item)); + Py_DECREF(item); + } + + PyString_ConcatAndDel(&repr, PyString_FromString(")")); + Py_DECREF(comma); + + return repr; + +} + +static PyObject *Vector_repr (VectorObject *self) +{ + return EXPP_tuple_repr((PyObject *) self, self->size); +} + +static PySequenceMethods Vector_SeqMethods = +{ + (inquiry) Vector_len, /* sq_length */ + (binaryfunc) 0, /* sq_concat */ + (intargfunc) 0, /* sq_repeat */ + (intargfunc) Vector_item, /* sq_item */ + (intintargfunc) Vector_slice, /* sq_slice */ + (intobjargproc) Vector_ass_item, /* sq_ass_item */ + (intintobjargproc) Vector_ass_slice, /* sq_ass_slice */ +}; + +PyTypeObject Vector_Type = +{ + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "Vector", /*tp_name*/ + sizeof(VectorObject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) Vector_dealloc, /*tp_dealloc*/ + (printfunc) 0, /*tp_print*/ + (getattrfunc) Vector_getattr, /*tp_getattr*/ + (setattrfunc) Vector_setattr, /*tp_setattr*/ + 0, /*tp_compare*/ + (reprfunc) Vector_repr, /*tp_repr*/ + 0, /*tp_as_number*/ + &Vector_SeqMethods, /*tp_as_sequence*/ +}; + +PyObject *newVectorObject(float *vec, int size) +{ + VectorObject *self; + + self= PyObject_NEW(VectorObject, &Vector_Type); + + self->vec= vec; + self->size= size; + + return (PyObject*) self; +} |