From a9ced6d86ae70b84eab4a20ac61741d591e43298 Mon Sep 17 00:00:00 2001 From: Willian Padovani Germano Date: Thu, 5 Jun 2003 18:03:46 +0000 Subject: [PATCH] * Added two modules: Guignot contributed the Ipo and Metaball modules. Metaball wasn't available in the 2.25 API, it's a new addition. * Minor changes in other files. --- source/blender/python/api2_2x/Blender.c | 2 + source/blender/python/api2_2x/Ipo.c | 460 ++++++++++ source/blender/python/api2_2x/Ipo.h | 180 ++++ source/blender/python/api2_2x/Lamp.c | 16 +- source/blender/python/api2_2x/Metaball.c | 1041 ++++++++++++++++++++++ source/blender/python/api2_2x/Metaball.h | 306 +++++++ source/blender/python/api2_2x/Object.c | 8 +- source/blender/python/api2_2x/modules.h | 31 +- 8 files changed, 2023 insertions(+), 21 deletions(-) create mode 100644 source/blender/python/api2_2x/Ipo.c create mode 100644 source/blender/python/api2_2x/Ipo.h create mode 100644 source/blender/python/api2_2x/Metaball.c create mode 100644 source/blender/python/api2_2x/Metaball.h diff --git a/source/blender/python/api2_2x/Blender.c b/source/blender/python/api2_2x/Blender.c index 7f475238d1d..042785d9a9c 100644 --- a/source/blender/python/api2_2x/Blender.c +++ b/source/blender/python/api2_2x/Blender.c @@ -222,6 +222,8 @@ void M_Blender_Init (void) PyDict_SetItemString (dict, "Lamp", M_Lamp_Init()); PyDict_SetItemString (dict, "Curve", M_Curve_Init()); PyDict_SetItemString (dict, "Armature", M_Armature_Init()); + PyDict_SetItemString (dict, "Ipo", M_Ipo_Init()); + PyDict_SetItemString (dict, "Metaball", M_Metaball_Init()); PyDict_SetItemString (dict, "Image", M_Image_Init()); PyDict_SetItemString (dict, "Window", M_Window_Init()); PyDict_SetItemString (dict, "Draw", M_Draw_Init()); diff --git a/source/blender/python/api2_2x/Ipo.c b/source/blender/python/api2_2x/Ipo.c new file mode 100644 index 00000000000..796ca311c8b --- /dev/null +++ b/source/blender/python/api2_2x/Ipo.c @@ -0,0 +1,460 @@ +/* + * + * ***** 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. + * + * This is a new part of Blender. + * + * Contributor(s): Jacques Guignot + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "Ipo.h" + +/*****************************************************************************/ +/* Function: M_Ipo_New */ +/* Python equivalent: Blender.Ipo.New */ +/*****************************************************************************/ +static PyObject *M_Ipo_New(PyObject *self, PyObject *args) +{ + Ipo *add_ipo(char *name, int idcode); + char*name = NULL; + int code = 0; + C_Ipo *pyipo; + Ipo *blipo; + + if (!PyArg_ParseTuple(args, "si", &name,&code)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected string int arguments")); + + + blipo = add_ipo(name,code); + + if (blipo) + pyipo = (C_Ipo *)PyObject_NEW(C_Ipo, &Ipo_Type); + else + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't create Ipo Data in Blender")); + + if (pyipo == NULL) + return (EXPP_ReturnPyObjError (PyExc_MemoryError, + "couldn't create Ipo Data object")); + + pyipo->ipo = blipo; + + return (PyObject *)pyipo; +} + +/*****************************************************************************/ +/* Function: M_Ipo_Get */ +/* Python equivalent: Blender.Ipo.Get */ +/* Description: Receives a string and returns the ipo data obj */ +/* whose name matches the string. If no argument is */ +/* passed in, a list of all ipo data names in the */ +/* current scene is returned. */ +/*****************************************************************************/ +static PyObject *M_Ipo_Get(PyObject *self, PyObject *args) +{ + char *name = NULL; + Ipo *ipo_iter; + PyObject *ipolist, *pystr; + C_Ipo *wanted_ipo = NULL; + char error_msg[64]; + + if (!PyArg_ParseTuple(args, "|s", &name)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected string argument (or nothing)")); + + ipo_iter = G.main->ipo.first; + + if (name) { /* (name) - Search ipo by name */ + while ((ipo_iter) && (wanted_ipo == NULL)) { + if (strcmp (name, ipo_iter->id.name+2) == 0) { + wanted_ipo = (C_Ipo *)PyObject_NEW(C_Ipo, &Ipo_Type); + if (wanted_ipo) wanted_ipo->ipo = ipo_iter; + } + ipo_iter = ipo_iter->id.next; + } + + if (wanted_ipo == NULL) { /* Requested ipo doesn't exist */ + PyOS_snprintf(error_msg, sizeof(error_msg), + "Ipo \"%s\" not found", name); + return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg)); + } + + return (PyObject *)wanted_ipo; + } + + else { /* () - return a list of all ipos in the scene */ + int index = 0; + + ipolist = PyList_New (BLI_countlist (&(G.main->ipo))); + + if (ipolist == NULL) + return (PythonReturnErrorObject (PyExc_MemoryError, + "couldn't create PyList")); + + while (ipo_iter) { + pystr = PyString_FromString (ipo_iter->id.name+2); + + if (!pystr) + return (PythonReturnErrorObject (PyExc_MemoryError, + "couldn't create PyString")); + + PyList_SET_ITEM (ipolist, index, pystr); + + ipo_iter = ipo_iter->id.next; + index++; + } + + return (ipolist); + } +} + +/*****************************************************************************/ +/* Function: M_Ipo_Init */ +/*****************************************************************************/ +PyObject *M_Ipo_Init (void) +{ + PyObject *submodule; + + printf ("In M_Ipo_Init()\n"); + submodule = Py_InitModule3("Blender.Ipo", + M_Ipo_methods, M_Ipo_doc); + + return (submodule); +} + +/*****************************************************************************/ +/* Python C_Ipo methods: */ +/*****************************************************************************/ +static PyObject *Ipo_getName(C_Ipo *self) +{ + PyObject *attr = PyString_FromString(self->ipo->id.name+2); + + if (attr) return attr; + + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Ipo.name attribute")); +} +static PyObject *Ipo_setName(C_Ipo *self, PyObject *args) +{ + char *name; + char buf[21]; + + if (!PyArg_ParseTuple(args, "s", &name)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected string argument")); + + PyOS_snprintf(buf, sizeof(buf), "%s", name); + + rename_id(&self->ipo->id, buf); + + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject *Ipo_getBlocktype(C_Ipo *self) +{ + PyObject *attr = PyInt_FromLong(self->ipo->blocktype); + + if (attr) return attr; + + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Ipo.blocktype attribute")); +} + + +static PyObject *Ipo_setBlocktype(C_Ipo *self, PyObject *args) +{ + int blocktype = 0; + + if (!PyArg_ParseTuple(args, "i", &blocktype)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected string argument")); + + self->ipo->blocktype = (short)blocktype; + + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject *Ipo_getShowkey(C_Ipo *self) +{ + PyObject *attr = PyInt_FromLong(self->ipo->showkey); + + if (attr) return attr; + + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Ipo.showkey attribute")); +} + + +static PyObject *Ipo_setShowkey(C_Ipo *self, PyObject *args) +{ + int showkey = 0; + + if (!PyArg_ParseTuple(args, "i", &showkey)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected string argument")); + + self->ipo->showkey = (short)showkey; + + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject *Ipo_getPad(C_Ipo *self) +{ + PyObject *attr = PyInt_FromLong(self->ipo->pad); + + if (attr) return attr; + + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Ipo.pad attribute")); +} + + +static PyObject *Ipo_setPad(C_Ipo *self, PyObject *args) +{ + int pad = 0; + + if (!PyArg_ParseTuple(args, "i", &pad)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected string argument")); + + self->ipo->pad = pad; + + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject *Ipo_getRctf(C_Ipo *self) +{ + PyObject* l = PyList_New(0); + PyList_Append( l, PyFloat_FromDouble(self->ipo->cur.xmin)); + PyList_Append( l, PyFloat_FromDouble(self->ipo->cur.xmax)); + PyList_Append( l, PyFloat_FromDouble(self->ipo->cur.ymin)); + PyList_Append( l, PyFloat_FromDouble(self->ipo->cur.ymax)); + return l; + +} + + +static PyObject *Ipo_setRctf(C_Ipo *self, PyObject *args) +{ + float v[4]; + if (!PyArg_ParseTuple(args, "ffff",v,v+1,v+2,v+3)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected 4 float argument")); + + self->ipo->cur.xmin = v[0]; + self->ipo->cur.xmax = v[1]; + self->ipo->cur.ymin = v[2]; + self->ipo->cur.ymax = v[3]; + + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject *Ipo_getNcurves(C_Ipo *self) +{ + int i = 0; + + IpoCurve *icu; + for (icu=self->ipo->curve.first; icu; icu=icu->next){ + i++; + } + + return (PyInt_FromLong(i) ); +} + + +static PyObject *Ipo_getCurveBP(C_Ipo *self, PyObject *args) +{ + struct BPoint *ptrbpoint; + int num = 0,i; + IpoCurve *icu; + PyObject* l; + + if (!PyArg_ParseTuple(args, "i",&num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int argument")); + icu =self->ipo->curve.first; + if(!icu) return (EXPP_ReturnPyObjError (PyExc_TypeError,"No IPO curve")); + for(i = 0;inext; + + } + ptrbpoint = icu->bp; + if(!ptrbpoint)return EXPP_ReturnPyObjError(PyExc_TypeError,"No base point"); + + l = PyList_New(0); + for(i=0;i<4;i++) + PyList_Append( l, PyFloat_FromDouble(ptrbpoint->vec[i])); + return l; +} + +static PyObject *Ipo_getCurveBeztriple(C_Ipo *self, PyObject *args) +{ + struct BezTriple *ptrbt; + int num = 0,pos,i,j; + IpoCurve *icu; + PyObject* l = PyList_New(0); + + if (!PyArg_ParseTuple(args, "ii",&num,&pos)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int argument")); + icu =self->ipo->curve.first; + if(!icu) return (EXPP_ReturnPyObjError (PyExc_TypeError,"No IPO curve")); + for(i = 0;inext; + } + if (pos >= icu->totvert) + return EXPP_ReturnPyObjError(PyExc_TypeError,"Bad bezt number"); + + ptrbt = icu->bezt + pos; + if(!ptrbt) + return EXPP_ReturnPyObjError(PyExc_TypeError,"No bez triple"); + + for(i=0;i<3;i++) + for(j=0;j<3;j++) + PyList_Append( l, PyFloat_FromDouble(ptrbt->vec[i][j])); + return l; +} + + +static PyObject *Ipo_setCurveBeztriple(C_Ipo *self, PyObject *args) +{ + struct BezTriple *ptrbt; + int num = 0,pos,i; + IpoCurve *icu; + PyObject *listargs=0; + + if (!PyArg_ParseTuple(args, "iiO",&num,&pos,&listargs)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int argument")); + icu =self->ipo->curve.first; + if(!icu) return (EXPP_ReturnPyObjError (PyExc_TypeError,"No IPO curve")); + for(i = 0;inext; + } + if (pos >= icu->totvert) + return EXPP_ReturnPyObjError(PyExc_TypeError,"Bad bezt number"); + + ptrbt = icu->bezt + pos; + if(!ptrbt) + return EXPP_ReturnPyObjError(PyExc_TypeError,"No bez triple"); + + for(i=0;i<9;i++) + { + PyObject * xx = PyList_GetItem(listargs,i); + ptrbt->vec[i/3][i%3] = PyFloat_AsDouble(xx); + } + + Py_INCREF(Py_None); + return Py_None; +} + + + + +static PyObject *Ipo_getCurvecurval(C_Ipo *self, PyObject *args) +{ + int num = 0,i; + IpoCurve *icu; + + if (!PyArg_ParseTuple(args, "i",&num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int argument")); + icu =self->ipo->curve.first; + if(!icu) return (EXPP_ReturnPyObjError (PyExc_TypeError,"No IPO curve")); + for(i = 0;inext; + + } + return PyFloat_FromDouble(icu->curval); +} + + + +/*****************************************************************************/ +/* Function: IpoDeAlloc */ +/* Description: This is a callback function for the C_Ipo type. It is */ +/* the destructor function. */ +/*****************************************************************************/ +static void IpoDeAlloc (C_Ipo *self) +{ + PyObject_DEL (self); +} + +/*****************************************************************************/ +/* Function: IpoGetAttr */ +/* Description: This is a callback function for the C_Ipo type. It is */ +/* the function that accesses C_Ipo "member variables" and */ +/* methods. */ +/*****************************************************************************/ +static PyObject *IpoGetAttr (C_Ipo *self, char *name) +{ + return Py_FindMethod(C_Ipo_methods, (PyObject *)self, name); +} + +/*****************************************************************************/ +/* Function: IpoSetAttr */ +/* Description: This is a callback function for the C_Ipo type. It is the */ +/* function that sets Ipo Data attributes (member variables).*/ +/*****************************************************************************/ +static int IpoSetAttr (C_Ipo *self, char *name, PyObject *value) +{ + return 0; /* normal exit */ +} + +/*****************************************************************************/ +/* Function: IpoPrint */ +/* Description: This is a callback function for the C_Ipo type. It */ +/* builds a meaninful string to 'print' ipo objects. */ +/*****************************************************************************/ +static int IpoPrint(C_Ipo *self, FILE *fp, int flags) +{ + fprintf(fp, "[Ipo \"%s\"]", self->ipo->id.name+2); + return 0; +} + +/*****************************************************************************/ +/* Function: IpoRepr */ +/* Description: This is a callback function for the C_Ipo type. It */ +/* builds a meaninful string to represent ipo objects. */ +/*****************************************************************************/ +static PyObject *IpoRepr (C_Ipo *self) +{ + return PyString_FromString(self->ipo->id.name+2); +} + diff --git a/source/blender/python/api2_2x/Ipo.h b/source/blender/python/api2_2x/Ipo.h new file mode 100644 index 00000000000..441384e5534 --- /dev/null +++ b/source/blender/python/api2_2x/Ipo.h @@ -0,0 +1,180 @@ +/* + * + * ***** 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. + * + * This is a new part of Blender. + * + * Contributor(s): Jacques Guignot + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** +*/ + +#ifndef EXPP_IPO_H +#define EXPP_IPO_H + +#include + +#include +#include +#include +#include +#include +#include + +#include "constant.h" +#include "gen_utils.h" +#include "modules.h" + + +/*****************************************************************************/ +/* Python API function prototypes for the Ipo module. */ +/*****************************************************************************/ +static PyObject *M_Ipo_New (PyObject *self, PyObject *args); +static PyObject *M_Ipo_Get (PyObject *self, PyObject *args); + +/*****************************************************************************/ +/* The following string definitions are used for documentation strings. */ +/* In Python these will be written to the console when doing a */ +/* Blender.Ipo.__doc__ */ +/*****************************************************************************/ +char M_Ipo_doc[] = ""; +char M_Ipo_New_doc[] =""; +char M_Ipo_Get_doc[] =""; + + +/*****************************************************************************/ +/* Python method structure definition for Blender.Ipo module: */ +/*****************************************************************************/ + +struct PyMethodDef M_Ipo_methods[] = { + {"New",(PyCFunction)M_Ipo_New, METH_VARARGS|METH_KEYWORDS,M_Ipo_New_doc}, + {"Get", M_Ipo_Get, METH_VARARGS, M_Ipo_Get_doc}, + {"get", M_Ipo_Get, METH_VARARGS, M_Ipo_Get_doc}, + {NULL, NULL, 0, NULL} +}; + +/*****************************************************************************/ +/* Python C_Ipo structure definition: */ +/*****************************************************************************/ +typedef struct { + PyObject_HEAD + Ipo *ipo; +} C_Ipo; + +/*****************************************************************************/ +/* Python C_Ipo methods declarations: */ +/*****************************************************************************/ +static PyObject *Ipo_getName(C_Ipo *self); +static PyObject *Ipo_setName(C_Ipo *self, PyObject *args); +static PyObject *Ipo_getBlocktype(C_Ipo *self); +static PyObject *Ipo_setBlocktype(C_Ipo *self, PyObject *args); +static PyObject *Ipo_getShowkey(C_Ipo *self); +static PyObject *Ipo_setShowkey(C_Ipo *self, PyObject *args); +static PyObject *Ipo_getPad(C_Ipo *self); +static PyObject *Ipo_setPad(C_Ipo *self, PyObject *args); +static PyObject *Ipo_getRctf(C_Ipo *self); +static PyObject *Ipo_setRctf(C_Ipo *self, PyObject *args); + +static PyObject *Ipo_getNcurves(C_Ipo *self); +static PyObject *Ipo_getCurveBP(C_Ipo *self, PyObject *args); +static PyObject *Ipo_getCurvecurval(C_Ipo *self, PyObject *args); + +static PyObject *Ipo_setCurveBeztriple(C_Ipo *self, PyObject *args); +static PyObject *Ipo_getCurveBeztriple(C_Ipo *self, PyObject *args); + +/*****************************************************************************/ +/* Python C_Ipo methods table: */ +/*****************************************************************************/ +static PyMethodDef C_Ipo_methods[] = { + /* name, method, flags, doc */ + {"getName", (PyCFunction)Ipo_getName, METH_NOARGS, + "() - Return Ipo Data name"}, +{"setName", (PyCFunction)Ipo_setName, METH_VARARGS, + "(str) - Change Ipo Data name"}, + {"getBlocktype", (PyCFunction)Ipo_getBlocktype, METH_NOARGS, + "() - Return Ipo blocktype -"}, + {"setBlocktype", (PyCFunction)Ipo_setBlocktype, METH_VARARGS, + "(str) - Change Ipo blocktype"}, + {"getShowkey", (PyCFunction)Ipo_getShowkey, METH_NOARGS, + "() - Return Ipo showkey - "}, + {"setShowkey", (PyCFunction)Ipo_setShowkey, METH_VARARGS, + "(str) - Change Ipo showkey"}, + {"getPad", (PyCFunction)Ipo_getPad, METH_NOARGS, + "() - Return Ipo pad - "}, + {"setPad", (PyCFunction)Ipo_setPad, METH_VARARGS, + "(str) - Change Ipo pad"}, + {"getRctf", (PyCFunction)Ipo_getRctf, METH_NOARGS, + "() - Return Ipo rctf - "}, + {"setRctf", (PyCFunction)Ipo_setRctf, METH_VARARGS, + "(str) - Change Ipo rctf"}, + {"getNcurves", (PyCFunction)Ipo_getNcurves, METH_NOARGS, + "() - Return Ipo ncurves"}, + {"getCurveBP", (PyCFunction)Ipo_getCurveBP, METH_VARARGS, + "() - Return Ipo ncurves"}, + {"getCurveCurval", (PyCFunction)Ipo_getCurvecurval, METH_VARARGS, + "() - Return curval"}, + {"getCurveBeztriple", (PyCFunction)Ipo_getCurveBeztriple, METH_VARARGS, + "() - Return Ipo ncurves"}, + {"setCurveBeztriple", (PyCFunction)Ipo_setCurveBeztriple, METH_VARARGS, + "() - Return curval"}, + {0} +}; + +/*****************************************************************************/ +/* Python Ipo_Type callback function prototypes: */ +/*****************************************************************************/ +static void IpoDeAlloc (C_Ipo *self); +static int IpoPrint (C_Ipo *self, FILE *fp, int flags); +static int IpoSetAttr (C_Ipo *self, char *name, PyObject *v); +static PyObject *IpoGetAttr (C_Ipo *self, char *name); +static PyObject *IpoRepr (C_Ipo *self); + +/*****************************************************************************/ +/* Python Ipo_Type structure definition: */ +/*****************************************************************************/ +static PyTypeObject Ipo_Type = +{ + PyObject_HEAD_INIT(&PyType_Type) + 0, /* ob_size */ + "Ipo", /* tp_name */ + sizeof (C_Ipo), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)IpoDeAlloc, /* tp_dealloc */ + (printfunc)IpoPrint, /* tp_print */ + (getattrfunc)IpoGetAttr, /* tp_getattr */ + (setattrfunc)IpoSetAttr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc)IpoRepr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_as_hash */ + 0,0,0,0,0,0, + 0, /* tp_doc */ + 0,0,0,0,0,0, + C_Ipo_methods, /* tp_methods */ + 0, /* tp_members */ +}; + +#endif /* EXPP_IPO_H */ diff --git a/source/blender/python/api2_2x/Lamp.c b/source/blender/python/api2_2x/Lamp.c index dd61dbd6c96..d950d117429 100644 --- a/source/blender/python/api2_2x/Lamp.c +++ b/source/blender/python/api2_2x/Lamp.c @@ -53,7 +53,7 @@ static PyObject *M_Lamp_New(PyObject *self, PyObject *args, PyObject *keywords) bl_lamp = add_lamp(); /* first create in Blender */ if (bl_lamp) /* now create the wrapper obj in Python */ - py_lamp = (C_Lamp *)Lamp_createPyObject(bl_lamp); + py_lamp = (C_Lamp *)Lamp_CreatePyObject(bl_lamp); else return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't create Lamp Data in Blender")); @@ -112,7 +112,7 @@ static PyObject *M_Lamp_Get(PyObject *self, PyObject *args) while ((lamp_iter) && (wanted_lamp == NULL)) { if (strcmp (name, lamp_iter->id.name+2) == 0) - wanted_lamp = (C_Lamp *)Lamp_createPyObject(lamp_iter); + wanted_lamp = (C_Lamp *)Lamp_CreatePyObject(lamp_iter); lamp_iter = lamp_iter->id.next; } @@ -216,11 +216,11 @@ PyObject *M_Lamp_Init (void) /* Three Python Lamp_Type helper functions needed by the Object module: */ /*****************************************************************************/ -/* Function: Lamp_createPyObject */ +/* Function: Lamp_CreatePyObject */ /* Description: This function will create a new C_Lamp from an existing */ /* Blender lamp structure. */ /*****************************************************************************/ -PyObject *Lamp_createPyObject (Lamp *lamp) +PyObject *Lamp_CreatePyObject (Lamp *lamp) { C_Lamp *pylamp; float *rgb[3]; @@ -243,21 +243,21 @@ PyObject *Lamp_createPyObject (Lamp *lamp) } /*****************************************************************************/ -/* Function: Lamp_checkPyObject */ +/* Function: Lamp_CheckPyObject */ /* Description: This function returns true when the given PyObject is of the */ /* type Lamp. Otherwise it will return false. */ /*****************************************************************************/ -int Lamp_checkPyObject (PyObject *pyobj) +int Lamp_CheckPyObject (PyObject *pyobj) { return (pyobj->ob_type == &Lamp_Type); } /*****************************************************************************/ -/* Function: Lamp_fromPyObject */ +/* Function: Lamp_FromPyObject */ /* Description: This function returns the Blender lamp from the given */ /* PyObject. */ /*****************************************************************************/ -Lamp *Lamp_fromPyObject (PyObject *pyobj) +Lamp *Lamp_FromPyObject (PyObject *pyobj) { return ((C_Lamp *)pyobj)->lamp; } diff --git a/source/blender/python/api2_2x/Metaball.c b/source/blender/python/api2_2x/Metaball.c new file mode 100644 index 00000000000..d338cb45a55 --- /dev/null +++ b/source/blender/python/api2_2x/Metaball.c @@ -0,0 +1,1041 @@ +/* + * + * ***** 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. + * + * This is a new part of Blender. + * + * Contributor(s): Jacques Guignot + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "Metaball.h" + +/*****************************************************************************/ +/* Function: M_Metaball_New */ +/* Python equivalent: Blender.Metaball.New */ +/*****************************************************************************/ +static PyObject *M_Metaball_New(PyObject *self, PyObject *args) +{ + char*name = 0; + C_Metaball *pymball; /* for Data object wrapper in Python */ + MetaBall *blmball; /* for actual Data we create in Blender */ + char buf[21]; + if (!PyArg_ParseTuple(args, "|s", &name)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected string argument (or nothing)")); + printf ("In MetaBall_New()\n"); + + blmball = add_mball(); /* first create the MetaBall Data in Blender */ + + if (blmball) /* now create the wrapper obj in Python */ + pymball = (C_Metaball *)PyObject_NEW(C_Metaball, &Metaball_Type); + else + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't create MetaBall Data in Blender")); + + if (pymball == NULL) + return (EXPP_ReturnPyObjError (PyExc_MemoryError, + "couldn't create MetaBall Data object")); + + pymball->metaball = blmball; + /*link Python mballer wrapper to Blender MetaBall */ + if(name) { /* user gave us a name for the metaball, use it */ + PyOS_snprintf(buf, sizeof(buf), "%s", name); + rename_id(&blmball->id, buf); + } + return (PyObject *)pymball; +} + +/*****************************************************************************/ +/* Function: M_Metaball_Get */ +/* Python equivalent: Blender.Metaball.Get */ +/* Description: Receives a string and returns the metaball data obj */ +/* whose name matches the string. If no argument is */ +/* passed in, a list of all metaball data names in the */ +/* current scene is returned. */ +/*****************************************************************************/ +static PyObject *M_Metaball_Get(PyObject *self, PyObject *args) +{ + char error_msg[64]; + char *name = NULL; + MetaBall *mball_iter; + + if (!PyArg_ParseTuple(args, "|s", &name)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected string argument (or nothing)")); + + mball_iter = G.main->mball.first; + + if (name) { /* (name) - Search mball by name */ + + C_Metaball *wanted_mball = NULL; + + while ((mball_iter) && (wanted_mball == NULL)) { + if (strcmp (name, mball_iter->id.name+2) == 0) { + wanted_mball=(C_Metaball*)PyObject_NEW(C_Metaball,&Metaball_Type); + if (wanted_mball) + wanted_mball->metaball = mball_iter; + } + mball_iter = mball_iter->id.next; + } + + if (wanted_mball == NULL) { /* Requested mball doesn't exist */ + PyOS_snprintf(error_msg, sizeof(error_msg), + "MetaBall \"%s\" not found", name); + return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg)); + } + + return (PyObject *)wanted_mball; + } + + else { /* () - return a list of all mballs in the scene */ + int index = 0; + PyObject *mballlist, *pystr; + + mballlist = PyList_New (BLI_countlist (&(G.main->mball))); + + if (mballlist == NULL) + return (PythonReturnErrorObject (PyExc_MemoryError, + "couldn't create PyList")); + + while (mball_iter) { + pystr = PyString_FromString (mball_iter->id.name+2); + + if (!pystr) + return (PythonReturnErrorObject (PyExc_MemoryError, + "couldn't create PyString")); + + PyList_SET_ITEM (mballlist, index, pystr); + + mball_iter = mball_iter->id.next; + index++; + } + + return (mballlist); + } + +} + +/*******************************************************************************/ +/* Function: M_Metaball_Init */ +/*******************************************************************************/ +PyObject *M_Metaball_Init (void) +{ + PyObject *submodule; + + printf ("In M_Metaball_Init()\n"); + submodule = Py_InitModule3("Blender.Metaball", + M_Metaball_methods, M_Metaball_doc); + + return (submodule); +} + +/*******************************************************************************/ +/* Python C_Metaball methods: */ +/*******************************************************************************/ +static PyObject *Metaball_getName(C_Metaball *self) +{ + + PyObject *attr = PyString_FromString(self->metaball->id.name+2); + + if (attr) return attr; + + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Metaball.name attribute")); +} + + + +static PyObject *Metaball_setName(C_Metaball *self,PyObject*args) +{ + char *name = NULL; + char buf[20]; + + + if (!PyArg_ParseTuple(args, "s", &name)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected string argument")); + PyOS_snprintf(buf, sizeof(buf), "%s", name); + rename_id(&self->metaball->id, buf); + Py_INCREF(Py_None); + return Py_None; +} + + +static PyObject *Metaball_getBbox(C_Metaball *self) +{ + int i,j; + PyObject* ll; + PyObject* l = PyList_New(0); + if (self->metaball->bb == NULL) {Py_INCREF(Py_None);return Py_None;} + for(i = 0;i<8;i++) + { + ll = PyList_New(0); + for(j = 0;j<3;j++) + PyList_Append( ll, PyFloat_FromDouble(self->metaball->bb->vec[i][j])); + PyList_Append( l, ll); + } + + return l; +} + +static PyObject *Metaball_getNMetaElems(C_Metaball *self) +{ + int i = 0; + MetaElem*ptr = self->metaball->elems.first; + if(!ptr) return (PyInt_FromLong(0) ); + while(ptr) + { + i++; + ptr = ptr->next; + } + return (PyInt_FromLong(i) ); +} + +static PyObject *Metaball_getNMetaElems1(C_Metaball *self) +{ + int i = 0; + MetaElem*ptr = self->metaball->disp.first; + if(!ptr) return (PyInt_FromLong(0) ); + while(ptr) + { + i++; + ptr = ptr->next; + } + return (PyInt_FromLong(i) ); +} + + +static PyObject *Metaball_getloc(C_Metaball *self) +{ + PyObject* l = PyList_New(0); + PyList_Append( l, PyFloat_FromDouble(self->metaball->loc[0])); + PyList_Append( l, PyFloat_FromDouble(self->metaball->loc[1])); + PyList_Append( l, PyFloat_FromDouble(self->metaball->loc[2])); + return l; +} + +static PyObject *Metaball_setloc(C_Metaball *self,PyObject*args) +{ + + float val[3]; + if (!PyArg_ParseTuple(args, "fff", val,val+1,val+2)) + return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected three float args")); + + self->metaball->loc[0] = val[0]; + self->metaball->loc[1] = val[1]; + self->metaball->loc[2] = val[2]; + + Py_INCREF(Py_None); + return Py_None; + +} + +static PyObject *Metaball_getrot(C_Metaball *self) +{ + PyObject* l = PyList_New(0); + PyList_Append( l, PyFloat_FromDouble(self->metaball->rot[0])); + PyList_Append( l, PyFloat_FromDouble(self->metaball->rot[1])); + PyList_Append( l, PyFloat_FromDouble(self->metaball->rot[2])); + return l; +} + +static PyObject *Metaball_setrot(C_Metaball *self,PyObject*args) +{ + + float val[3]; + if (!PyArg_ParseTuple(args, "fff", val,val+1,val+2)) + return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected three float args")); + + self->metaball->rot[0] = val[0]; + self->metaball->rot[1] = val[1]; + self->metaball->rot[2] = val[2]; + + Py_INCREF(Py_None); + return Py_None; + +} + +static PyObject *Metaball_getsize(C_Metaball *self) +{ + PyObject* l = PyList_New(0); + PyList_Append( l, PyFloat_FromDouble(self->metaball->size[0])); + PyList_Append( l, PyFloat_FromDouble(self->metaball->size[1])); + PyList_Append( l, PyFloat_FromDouble(self->metaball->size[2])); + return l; +} + +static PyObject *Metaball_setsize(C_Metaball *self,PyObject*args) +{ + + float val[3]; + if (!PyArg_ParseTuple(args, "fff", val,val+1,val+2)) + return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected three float args")); + + self->metaball->size[0] = val[0]; + self->metaball->size[1] = val[1]; + self->metaball->size[2] = val[2]; + + Py_INCREF(Py_None); + return Py_None; + +} +static PyObject *Metaball_getWiresize(C_Metaball *self) +{ + return PyFloat_FromDouble(self->metaball->wiresize); +} + +static PyObject *Metaball_setWiresize(C_Metaball *self,PyObject*args) +{ + + float val; + if (!PyArg_ParseTuple(args, "f", &val)) + return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected float args")); + + self->metaball->wiresize = val; + + Py_INCREF(Py_None); + return Py_None; + +} +static PyObject *Metaball_getRendersize(C_Metaball *self) +{ + return PyFloat_FromDouble(self->metaball->rendersize); +} + +static PyObject *Metaball_setRendersize(C_Metaball *self,PyObject*args) +{ + + float val; + if (!PyArg_ParseTuple(args, "f", &val)) + return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected float args")); + + self->metaball->rendersize = val; + + Py_INCREF(Py_None); + return Py_None; + +} +static PyObject *Metaball_getThresh(C_Metaball *self) +{ + return PyFloat_FromDouble(self->metaball->thresh); +} + +static PyObject *Metaball_setThresh(C_Metaball *self,PyObject*args) +{ + + float val; + if (!PyArg_ParseTuple(args, "f", &val)) + return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected float args")); + + self->metaball->thresh = val; + + Py_INCREF(Py_None); + return Py_None; + +} + + +/*******************************************************************************/ +/* get/set metaelems data, */ +/*******************************************************************************/ + +static PyObject *Metaball_getMetadata(C_Metaball *self,PyObject*args) +{ + int num; + int i = 0; + char*name = NULL; + MetaElem *ptr; + + if (!PyArg_ParseTuple(args, "si", &name,&num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, \ + "expected (string int) argument")); + /*jump to the num-th MetaElem*/ + ptr = self->metaball->elems.first; + if(!ptr) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "no metaelem found")); + for(i = 0;inext; + } + if(!strcmp(name,"type")) + return (PyInt_FromLong(ptr->type)); + if(!strcmp(name,"lay")) + return (PyInt_FromLong(ptr->lay)); + if(!strcmp(name,"selcol")) + return (PyInt_FromLong(ptr->selcol)); + if(!strcmp(name,"flag")) + return (PyInt_FromLong(ptr->flag)); + if(!strcmp(name,"pad")) + return (PyInt_FromLong(ptr->pad)); + if(!strcmp(name,"x")) + return (PyFloat_FromDouble(ptr->x)); + if(!strcmp(name,"y")) + return (PyFloat_FromDouble(ptr->y)); + if(!strcmp(name,"z")) + return (PyFloat_FromDouble(ptr->z)); + if(!strcmp(name,"expx")) + return (PyFloat_FromDouble(ptr->expx)); + if(!strcmp(name,"expy")) + return (PyFloat_FromDouble(ptr->expy)); + if(!strcmp(name,"expz")) + return (PyFloat_FromDouble(ptr->expz)); + if(!strcmp(name,"rad")) + return (PyFloat_FromDouble(ptr->rad)); + if(!strcmp(name,"rad2")) + return (PyFloat_FromDouble(ptr->rad2)); + if(!strcmp(name,"s")) + return (PyFloat_FromDouble(ptr->s)); + if(!strcmp(name,"len")) + return (PyFloat_FromDouble(ptr->len)); + if(!strcmp(name,"maxrad2")) + return (PyFloat_FromDouble(ptr->maxrad2)); + + + + + return (EXPP_ReturnPyObjError (PyExc_TypeError, "unknown name ")); +} + + + +static PyObject *Metaball_setMetadata(C_Metaball *self,PyObject*args) +{ + int num; + int i = 0; + char*name = NULL; + int intval=-1; + float floatval=FP_INFINITE; + int ok = 0; + MetaElem *ptr; + + /* XXX: This won't work. PyArg_ParseTuple will unpack 'args' in its first + * call, so it can't be called again. Better get the value as a float then + * compare it with its int part and, if equal, consider it an int. Note + * that 'ok' isn't used in this function at all, whatever it was meant for */ + if (PyArg_ParseTuple(args, "sii", &name,&num,&intval))ok=1; + if (PyArg_ParseTuple(args, "sif", &name,&num,&floatval)) ok = 2; + if (!ok) +return (EXPP_ReturnPyObjError (PyExc_TypeError, \ + "expected string,int,int or float arguments")); + if (floatval == FP_INFINITE) floatval = (float)intval; + /*jump to the num-th MetaElem*/ + ptr = self->metaball->elems.first; + if(!ptr) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "metaelem not found")); + for(i = 0;inext; + } + if(!strcmp(name,"type")) + {ptr->type=intval;return (PyInt_FromLong(intval));} + if(!strcmp(name,"lay")) + {ptr->lay=intval;return (PyInt_FromLong(intval));} + if(!strcmp(name,"selcol")) + {ptr->selcol=intval;return (PyInt_FromLong(intval));} + if(!strcmp(name,"flag")) + {ptr->flag=intval;return (PyInt_FromLong(intval));} + if(!strcmp(name,"pad")) + {ptr->pad=intval;return (PyInt_FromLong(intval));} + + if(!strcmp(name,"x")) + {ptr->x=floatval;return (PyFloat_FromDouble(floatval));} + if(!strcmp(name,"y")) + {ptr->y=floatval;return (PyFloat_FromDouble(floatval));} + if(!strcmp(name,"z")) + {ptr->z=floatval;return (PyFloat_FromDouble(floatval));} + if(!strcmp(name,"expx")) + {ptr->expx=floatval;return (PyFloat_FromDouble(floatval));} + if(!strcmp(name,"expy")) + {ptr->expy=floatval;return (PyFloat_FromDouble(floatval));} + if(!strcmp(name,"expz")) + {ptr->expz=floatval;return (PyFloat_FromDouble(floatval));} + if(!strcmp(name,"rad")) + {ptr->rad=floatval;return (PyFloat_FromDouble(floatval));} + if(!strcmp(name,"rad2")) + {ptr->rad2=floatval;return (PyFloat_FromDouble(floatval));} + if(!strcmp(name,"s")) + {ptr->s=floatval;return (PyFloat_FromDouble(floatval));} + if(!strcmp(name,"len")) + {ptr->len=floatval;return (PyFloat_FromDouble(floatval));} + if(!strcmp(name,"maxrad2")) + {ptr->maxrad2=floatval;return (PyFloat_FromDouble(floatval));} + + + + return (EXPP_ReturnPyObjError (PyExc_TypeError, "unknown name ")); +} + +static PyObject *Metaball_getMetatype(C_Metaball *self,PyObject*args) +{ + int num; + int i = 0; + MetaElem*ptr = self->metaball->elems.first; + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, \ + "expected int argument")); + if(!ptr) return (PyInt_FromLong(0)); + for(i = 0;inext;} + return (PyInt_FromLong(ptr->type)); +} + + + +static PyObject *Metaball_setMetatype(C_Metaball *self,PyObject*args) +{ + int num,val, i = 0; + MetaElem*ptr = self->metaball->elems.first; + if (!PyArg_ParseTuple(args, "ii", &num,&val)) + return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected int int arguments")); + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->type = val; + + Py_INCREF(Py_None); + return Py_None; + +} + +static PyObject *Metaball_getMetalay(C_Metaball *self,PyObject*args) +{ + int num; + int i = 0; + MetaElem*ptr = self->metaball->elems.first; + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + if(!ptr) return (PyInt_FromLong(0)); + for(i = 0;inext;} + return (PyInt_FromLong(ptr->lay)); +} + + + +static PyObject *Metaball_setMetalay(C_Metaball *self,PyObject*args) +{ + int num,val, i = 0; + MetaElem*ptr = self->metaball->elems.first; + if (!PyArg_ParseTuple(args, "ii", &num,&val)) + return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected int int arguments")); + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->lay = val; + + Py_INCREF(Py_None); + return Py_None; + +} + +static PyObject *Metaball_getMetaflag(C_Metaball *self,PyObject*args) +{ + int num; + int i = 0; + MetaElem*ptr = self->metaball->elems.first; + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + if(!ptr) return (PyInt_FromLong(0)); + for(i = 0;inext;} + return (PyInt_FromLong(ptr->flag)); +} + + + +static PyObject *Metaball_setMetaflag(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num,val, i = 0; + if (!PyArg_ParseTuple(args, "ii", &num,&val)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int int argnts")); + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->flag = val; + + Py_INCREF(Py_None); + return Py_None; + +} + +static PyObject *Metaball_getMetaselcol(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num; + int i = 0; + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + if(!ptr) return (PyInt_FromLong(0)); + for(i = 0;inext;} + return (PyInt_FromLong(ptr->selcol)); +} + + + +static PyObject *Metaball_setMetaselcol(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num,val, i = 0; + if (!PyArg_ParseTuple(args, "ii", &num,&val)) + return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected int int arguments")); + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->selcol = val; + + Py_INCREF(Py_None); + return Py_None; + +} + +static PyObject *Metaball_getMetapad(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num; + int i = 0; + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + if(!ptr) return (PyInt_FromLong(0)); + for(i = 0;inext;} + return (PyInt_FromLong(ptr->pad)); +} + + + +static PyObject *Metaball_setMetapad(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num,val, i = 0; + if (!PyArg_ParseTuple(args, "ii", &num,&val)) + return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected int int arguments")); + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->pad = val; + + Py_INCREF(Py_None); + return Py_None; + +} + +static PyObject *Metaball_getMetax(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num; + int i = 0; + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + if(!ptr) return (PyFloat_FromDouble(0)); + for(i = 0;inext;} + return (PyFloat_FromDouble(ptr->x)); +} + + + +static PyObject *Metaball_setMetax(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num, i = 0; + float val; + if (!PyArg_ParseTuple(args, "if", &num,&val)) + return (EXPP_ReturnPyObjError(PyExc_TypeError,"expected int float args")); + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->x = val; + + Py_INCREF(Py_None); + return Py_None; + +} +static PyObject *Metaball_getMetay(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num; + int i = 0; + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + if(!ptr) return (PyFloat_FromDouble(0)); + for(i = 0;inext;} + return (PyFloat_FromDouble(ptr->y)); +} + + + +static PyObject *Metaball_setMetay(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num, i = 0; + float val; + if (!PyArg_ParseTuple(args, "if", &num,&val)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int float args")); + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->y = val; + + Py_INCREF(Py_None); + return Py_None; + +} + + +static PyObject *Metaball_getMetaz(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num; + int i = 0; + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + if(!ptr) return (PyFloat_FromDouble(0)); + for(i = 0;inext;} + return (PyFloat_FromDouble(ptr->z)); +} + +static PyObject *Metaball_setMetaz(C_Metaball *self,PyObject*args) +{ + int num, i = 0; + MetaElem*ptr = self->metaball->elems.first; + float val; + if (!PyArg_ParseTuple(args, "if", &num,&val)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int float args")); + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->z = val; + + Py_INCREF(Py_None); + return Py_None; + +} + +static PyObject *Metaball_getMetaexpx(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num; + int i = 0; + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + if(!ptr) return (PyFloat_FromDouble(0)); + for(i = 0;inext;} + return (PyFloat_FromDouble(ptr->expx)); +} + +static PyObject *Metaball_setMetaexpx(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num, i = 0; + float val; + if (!PyArg_ParseTuple(args, "if", &num,&val)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int float args")); + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->expx = val; + + Py_INCREF(Py_None); + return Py_None; + +} + +static PyObject *Metaball_getMetaexpy(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num; + int i = 0; + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + if(!ptr) return (PyFloat_FromDouble(0)); + for(i = 0;inext;} + return (PyFloat_FromDouble(ptr->expy)); +} + +static PyObject *Metaball_setMetaexpy(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num, i = 0; + float val; + if (!PyArg_ParseTuple(args, "if", &num,&val)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int float argts")); + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->expy = val; + + Py_INCREF(Py_None); + return Py_None; + +} + +static PyObject *Metaball_getMetaexpz(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num; + int i = 0; + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + if(!ptr) return (PyFloat_FromDouble(0)); + for(i = 0;inext;} + return (PyFloat_FromDouble(ptr->expz)); +} + +static PyObject *Metaball_setMetaexpz(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num, i = 0; + float val; + if (!PyArg_ParseTuple(args, "if", &num,&val)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int float argts")); + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->expz = val; + + Py_INCREF(Py_None); + return Py_None; + +} + + +static PyObject *Metaball_getMetarad(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num; + int i = 0; + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + if(!ptr) return (PyFloat_FromDouble(0)); + for(i = 0;inext;} + return (PyFloat_FromDouble(ptr->rad)); +} + +static PyObject *Metaball_setMetarad(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num, i = 0; + float val; + if (!PyArg_ParseTuple(args, "if", &num,&val)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int float args")); + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->rad = val; + + Py_INCREF(Py_None); + return Py_None; + +} + + + +static PyObject *Metaball_getMetarad2(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num; + int i = 0; + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + if(!ptr) return (PyFloat_FromDouble(0)); + for(i = 0;inext;} + return (PyFloat_FromDouble(ptr->rad2)); +} + +static PyObject *Metaball_setMetarad2(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num, i = 0; + float val; + if (!PyArg_ParseTuple(args, "if", &num,&val)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int float args")); + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->rad2 = val; + + Py_INCREF(Py_None); + return Py_None; + +} + +static PyObject *Metaball_getMetas(C_Metaball *self,PyObject*args) +{ + MetaElem*ptr = self->metaball->elems.first; + int num; + int i = 0; + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + if(!ptr) return (PyFloat_FromDouble(0)); + for(i = 0;inext;} + return (PyFloat_FromDouble(ptr->s)); +} + +static PyObject *Metaball_setMetas(C_Metaball *self,PyObject*args) +{ + int num, i = 0; + float val; + MetaElem *ptr; + + if (!PyArg_ParseTuple(args, "if", &num,&val)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int float args")); + ptr = self->metaball->elems.first; + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->s = val; + + Py_INCREF(Py_None); + return Py_None; + +} + + + +static PyObject *Metaball_getMetalen(C_Metaball *self,PyObject*args) +{ + int num; + int i = 0; + MetaElem *ptr; + + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + ptr = self->metaball->elems.first; + if(!ptr) return (PyFloat_FromDouble(0)); + for(i = 0;inext;} + return (PyFloat_FromDouble(ptr->len)); +} + +static PyObject *Metaball_setMetalen(C_Metaball *self,PyObject*args) +{ + int num, i = 0; + float val; + MetaElem *ptr; + + if (!PyArg_ParseTuple(args, "if", &num,&val)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int float args")); + ptr = self->metaball->elems.first; + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->len = val; + + Py_INCREF(Py_None); + return Py_None; + +} + + + +static PyObject *Metaball_getMetamaxrad2(C_Metaball *self,PyObject*args) +{ + int num; + int i = 0; + MetaElem *ptr; + + if (!PyArg_ParseTuple(args, "i", &num)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); + ptr = self->metaball->elems.first; + if(!ptr) return (PyFloat_FromDouble(0)); + for(i = 0;inext;} + return (PyFloat_FromDouble(ptr->maxrad2)); +} + +static PyObject *Metaball_setMetamaxrad2(C_Metaball *self,PyObject*args) +{ + int num, i = 0; + float val; + MetaElem *ptr; + + if (!PyArg_ParseTuple(args, "if", &num,&val)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int float args")); + ptr = self->metaball->elems.first; + if(!ptr) return (EXPP_ReturnPyObjError (PyExc_TypeError, "No MetaElem")); + for(i = 0;inext;} + ptr->maxrad2 = val; + + Py_INCREF(Py_None); + return Py_None; + +} + + + + + + +/*****************************************************************************/ +/* Function: MetaballDeAlloc */ +/* Description: This is a callback function for the C_Metaball type. It is */ +/* the destructor function. */ +/*****************************************************************************/ +static void MetaballDeAlloc (C_Metaball *self) +{ + PyObject_DEL (self); +} + +static int MetaballPrint (C_Metaball *self, FILE *fp, int flags) +{ + fprintf(fp, "[MetaBall \"%s\"]", self->metaball->id.name+2); + return 0; + +} +/*****************************************************************************/ +/* Function: MetaballGetAttr */ +/* Description: This is a callback function for the C_Metaball type. It is */ +/* the function that accesses C_Metaball "member variables" and */ +/* methods. */ +/*****************************************************************************/ +static PyObject *MetaballGetAttr (C_Metaball *self, char *name) +{ + +if (strcmp (name, "name") == 0)return Metaball_getName (self); +if (strcmp (name, "rot") == 0)return Metaball_getrot (self); + return Py_FindMethod(C_Metaball_methods, (PyObject *)self, name); +} + +/*******************************************************************************/ +/* Function: MetaballSetAttr */ +/* Description: This is a callback function for the C_Metaball type. It is the */ +/* function that sets Metaball Data attributes (member variables).*/ +/*******************************************************************************/ +static int MetaballSetAttr (C_Metaball *self, char *name, PyObject *value) +{ + PyObject *valtuple = Py_BuildValue("(N)", value); + + if (!valtuple) + return EXPP_ReturnIntError(PyExc_MemoryError, + "MetaballSetAttr: couldn't create PyTuple"); + + if (strcmp (name, "name") == 0) + { + Metaball_setName (self, valtuple); + return 0; + } + + if (strcmp (name, "rot") == 0) + { + Metaball_setrot (self, valtuple); + return 0; + } + + return (EXPP_ReturnIntError (PyExc_KeyError,"attribute not found")); +} + +/*****************************************************************************/ +/* Function: MetaballRepr */ +/* Description: This is a callback function for the C_Metaball type. It */ +/* builds a meaninful string to represent metaball objects. */ +/*****************************************************************************/ +static PyObject *MetaballRepr (C_Metaball *self) +{ + return PyString_FromString(self->metaball->id.name+2); +} + diff --git a/source/blender/python/api2_2x/Metaball.h b/source/blender/python/api2_2x/Metaball.h new file mode 100644 index 00000000000..02ffdd2d3f2 --- /dev/null +++ b/source/blender/python/api2_2x/Metaball.h @@ -0,0 +1,306 @@ +/* + * + * ***** 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. + * + * This is a new part of Blender. + * + * Contributor(s): Jacques Guignot + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** +*/ + +#ifndef EXPP_METABALL_H +#define EXPP_METABALL_H + +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "constant.h" +#include "gen_utils.h" +#include "modules.h" + +/*****************************************************************************/ +/* Python C_Metaball defaults: */ +/*****************************************************************************/ + + +/*****************************************************************************/ +/* Python API function prototypes for the Metaball module. */ +/*****************************************************************************/ +static PyObject *M_Metaball_New (PyObject *self, PyObject *args); +static PyObject *M_Metaball_Get (PyObject *self, PyObject *args); + +/*****************************************************************************/ +/* The following string definitions are used for documentation strings. */ +/* In Python these will be written to the console when doing a */ +/* Blender.Metaball.__doc__ */ +/*****************************************************************************/ +char M_Metaball_doc[] = +"The Blender Metaball module\n\n\nMetaballs are spheres\ + that can join each other to create smooth,\ + organic volumes\n. The spheres themseves are called\ + 'Metaelements' and can be accessed from the Metaball module."; + +char M_Metaball_New_doc[] ="Creates a new metaball"; + +char M_Metaball_Get_doc[] ="Retreives an existing metaball"; + +/*****************************************************************************/ +/* Python method structure definition for Blender.Metaball module: */ +/*****************************************************************************/ +struct PyMethodDef M_Metaball_methods[] = { + {"New",M_Metaball_New, METH_VARARGS,M_Metaball_New_doc}, + {"Get", M_Metaball_Get, METH_VARARGS, M_Metaball_Get_doc}, + {"get", M_Metaball_Get, METH_VARARGS, M_Metaball_Get_doc}, + {NULL, NULL, 0, NULL} +}; + +/*****************************************************************************/ +/* Python C_Metaball structure definition: */ +/*****************************************************************************/ +typedef struct { + PyObject_HEAD + MetaBall *metaball; +} C_Metaball; + +/*****************************************************************************/ +/* Python C_Metaball methods declarations: */ +/*****************************************************************************/ +static PyObject *Metaball_getBbox(C_Metaball *self); +static PyObject *Metaball_getName(C_Metaball *self); +static PyObject *Metaball_setName(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getWiresize(C_Metaball *self); +static PyObject *Metaball_setWiresize(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getRendersize(C_Metaball *self); +static PyObject *Metaball_setRendersize(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getThresh(C_Metaball *self); +static PyObject *Metaball_setThresh(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getNMetaElems(C_Metaball *self); +static PyObject *Metaball_getNMetaElems1(C_Metaball *self); +static PyObject *Metaball_getMetatype(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetatype(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetadata(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetadata(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetalay(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetalay(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetaflag(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetaflag(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetaselcol(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetaselcol(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetapad(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetapad(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetax(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetax(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetay(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetay(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetaz(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetaz(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetaexpx(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetaexpx(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetaexpy(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetaexpy(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetaexpz(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetaexpz(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetarad(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetarad(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetarad2(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetarad2(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetas(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetas(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetalen(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetalen(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getMetamaxrad2(C_Metaball *self,PyObject*args); +static PyObject *Metaball_setMetamaxrad2(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getloc(C_Metaball *self); +static PyObject *Metaball_setloc(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getrot(C_Metaball *self); +static PyObject *Metaball_setrot(C_Metaball *self,PyObject*args); +static PyObject *Metaball_getsize(C_Metaball *self); +static PyObject *Metaball_setsize(C_Metaball *self,PyObject*args); + +/*****************************************************************************/ +/* Python C_Metaball methods table: */ +/*****************************************************************************/ +static PyMethodDef C_Metaball_methods[] = { + /* name, method, flags, doc */ + {"getName", (PyCFunction)Metaball_getName,\ + METH_NOARGS, "() - Return Metaball Data name"}, + + {"setName", (PyCFunction)Metaball_setName,\ + METH_VARARGS, "() - Sets Metaball Data name"}, + + {"getWiresize", (PyCFunction)Metaball_getWiresize,\ + METH_NOARGS, "() - Return Metaball Data wiresize"}, + + {"setWiresize", (PyCFunction)Metaball_setWiresize,\ + METH_VARARGS, "() - Sets Metaball Data wiresize"}, + + {"getRendersize", (PyCFunction)Metaball_getRendersize,\ + METH_NOARGS, "() - Return Metaball Data rendersize"}, + + {"setRendersize", (PyCFunction)Metaball_setRendersize,\ + METH_VARARGS, "() - Sets Metaball Data rendersize"}, + + {"getThresh", (PyCFunction)Metaball_getThresh,\ + METH_NOARGS, "() - Return Metaball Data thresh"}, + + {"setThresh", (PyCFunction)Metaball_setThresh,\ + METH_VARARGS, "() - Sets Metaball Data thresh"}, + +{"getBbox", (PyCFunction)Metaball_getBbox,\ + METH_NOARGS, "() - Return Metaball bounding box"}, + + {"getNMetaElems",(PyCFunction)Metaball_getNMetaElems,\ +METH_NOARGS, "() - "}, + + {"getNMetaElems1",(PyCFunction)Metaball_getNMetaElems1,\ +METH_NOARGS, "() - "}, + {"getMetatype", (PyCFunction)Metaball_getMetatype , \ +METH_VARARGS, "() - "}, + {"setMetatype", (PyCFunction)Metaball_setMetatype , \ +METH_VARARGS, "() - "}, + {"getMetadata", (PyCFunction)Metaball_getMetadata , \ +METH_VARARGS, "() - Gets Metaball MetaData "}, + {"setMetadata", (PyCFunction)Metaball_setMetadata , \ +METH_VARARGS, "() - "}, + {"getMetalay", (PyCFunction)Metaball_getMetalay , \ +METH_VARARGS, "() - "}, + {"setMetalay", (PyCFunction)Metaball_setMetalay , \ +METH_VARARGS, "() - "}, + {"getMetaflag", (PyCFunction)Metaball_getMetaflag , \ +METH_VARARGS, "() - "}, + {"setMetaflag", (PyCFunction)Metaball_setMetaflag , \ +METH_VARARGS, "() - "}, + {"getMetaselcol", (PyCFunction)Metaball_getMetaselcol , \ +METH_VARARGS, "() - "}, + {"setMetaselcol", (PyCFunction)Metaball_setMetaselcol , \ +METH_VARARGS, "() - "}, + {"getMetapad", (PyCFunction)Metaball_getMetapad , \ +METH_VARARGS, "() - "}, + {"setMetapad", (PyCFunction)Metaball_setMetapad , \ +METH_VARARGS, "() - "}, + {"getMetax", (PyCFunction)Metaball_getMetax , \ +METH_VARARGS, "() - "}, + {"setMetax", (PyCFunction)Metaball_setMetax , \ +METH_VARARGS, "() - "}, + {"getMetay", (PyCFunction)Metaball_getMetay , \ +METH_VARARGS, "() - "}, + {"setMetay", (PyCFunction)Metaball_setMetay , \ +METH_VARARGS, "() - "}, + {"getMetaz", (PyCFunction)Metaball_getMetaz , \ +METH_VARARGS, "() - "}, + {"setMetaz", (PyCFunction)Metaball_setMetaz , \ +METH_VARARGS, "() - "}, + {"getMetaexpx", (PyCFunction)Metaball_getMetaexpx , \ +METH_VARARGS, "() - "}, + {"setMetaexpx", (PyCFunction)Metaball_setMetaexpx , \ +METH_VARARGS, "() - "}, + {"getMetaexpy", (PyCFunction)Metaball_getMetaexpy , \ +METH_VARARGS, "() - "}, + {"setMetaexpy", (PyCFunction)Metaball_setMetaexpy , \ +METH_VARARGS, "() - "}, + {"getMetaexpz", (PyCFunction)Metaball_getMetaexpz , \ +METH_VARARGS, "() - "}, + {"setMetaexpz", (PyCFunction)Metaball_setMetaexpz , \ +METH_VARARGS, "() - "}, + {"getMetarad", (PyCFunction)Metaball_getMetarad , \ +METH_VARARGS, "() - "}, + {"setMetarad", (PyCFunction)Metaball_setMetarad , \ +METH_VARARGS, "() - "}, + {"getMetarad2", (PyCFunction)Metaball_getMetarad2 , \ +METH_VARARGS, "() - "}, + {"setMetarad2", (PyCFunction)Metaball_setMetarad2 , \ +METH_VARARGS, "() - "}, + {"getMetas", (PyCFunction)Metaball_getMetas , \ +METH_VARARGS, "() - "}, + {"setMetas", (PyCFunction)Metaball_setMetas , \ +METH_VARARGS, "() - "}, + {"getMetalen", (PyCFunction)Metaball_getMetalen , \ +METH_VARARGS, "() - "}, + {"setMetalen", (PyCFunction)Metaball_setMetalen , \ +METH_VARARGS, "() - "}, + {"getMetamaxrad2", (PyCFunction)Metaball_getMetamaxrad2 , \ +METH_VARARGS, "() - "}, + {"setMetamaxrad2", (PyCFunction)Metaball_setMetamaxrad2 , \ +METH_VARARGS, "() - "}, + {"getloc", (PyCFunction)Metaball_getloc , \ +METH_NOARGS, "() - Gets Metaball loc values"}, + {"setloc", (PyCFunction)Metaball_setloc , \ +METH_VARARGS, "(f f f) - Sets Metaball loc values"}, + {"getrot", (PyCFunction)Metaball_getrot , \ +METH_NOARGS, "() - Gets Metaball rot values"}, + {"setrot", (PyCFunction)Metaball_setrot , \ +METH_VARARGS, "(f f f) - Sets Metaball rot values"}, + {"getsize", (PyCFunction)Metaball_getsize , \ +METH_NOARGS, "() - Gets Metaball size values"}, + {"setsize", (PyCFunction)Metaball_setsize , \ +METH_VARARGS, "(f f f) - Sets Metaball size values"}, +/*end of MetaElem data*/ + {0} +}; + +/*****************************************************************************/ +/* Python Metaball_Type callback function prototypes: */ +/*****************************************************************************/ +static void MetaballDeAlloc (C_Metaball *self); +static int MetaballPrint (C_Metaball *self, FILE *fp, int flags); +static int MetaballSetAttr (C_Metaball *self, char *name, PyObject *v); +static PyObject *MetaballGetAttr (C_Metaball *self, char *name); +static PyObject *MetaballRepr (C_Metaball *self); + +/*****************************************************************************/ +/* Python Metaball_Type structure definition: */ +/*****************************************************************************/ +static PyTypeObject Metaball_Type = +{ + PyObject_HEAD_INIT(&PyType_Type) + 0, /* ob_size */ + "Metaball", /* tp_name */ + sizeof (C_Metaball), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)MetaballDeAlloc, /* tp_dealloc */ + (printfunc)MetaballPrint, /* tp_print */ + (getattrfunc)MetaballGetAttr, /* tp_getattr */ + (setattrfunc)MetaballSetAttr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc)MetaballRepr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_as_hash */ + 0,0,0,0,0,0, + 0, /* tp_doc */ + 0,0,0,0,0,0, + C_Metaball_methods, /* tp_methods */ + 0, /* tp_members */ +}; + +#endif /* EXPP_METABALL_H */ diff --git a/source/blender/python/api2_2x/Object.c b/source/blender/python/api2_2x/Object.c index 1a5a64b2ae0..2dcde35c279 100644 --- a/source/blender/python/api2_2x/Object.c +++ b/source/blender/python/api2_2x/Object.c @@ -397,7 +397,7 @@ static PyObject *Object_getData (C_Object *self) case ID_IP: break; case ID_LA: - data_object = Lamp_createPyObject (self->object->data); + data_object = Lamp_CreatePyObject (self->object->data); break; case ID_MA: break; @@ -592,9 +592,9 @@ static PyObject *Object_link (C_Object *self, PyObject *args) "expected an object as argument")); } if (Camera_CheckPyObject (py_data)) - data = (void*) Camera_FromPyObject (py_data); - if (Lamp_checkPyObject (py_data)) - data = (void*) Lamp_fromPyObject (py_data); + data = (void *)Camera_FromPyObject (py_data); + if (Lamp_CheckPyObject (py_data)) + data = (void *)Lamp_FromPyObject (py_data); /* TODO: add the (N)Mesh check and from functions here when finished. */ oldid = (ID*) self->object->data; diff --git a/source/blender/python/api2_2x/modules.h b/source/blender/python/api2_2x/modules.h index f00d2233b45..dcfb2b1658d 100644 --- a/source/blender/python/api2_2x/modules.h +++ b/source/blender/python/api2_2x/modules.h @@ -38,8 +38,10 @@ #include #include #include -#include #include +#include +#include +#include #include /*****************************************************************************/ @@ -77,9 +79,9 @@ int Camera_CheckPyObject (PyObject *pyobj); /* Lamp Data */ PyObject * M_Lamp_Init (void); -PyObject * Lamp_createPyObject (struct Lamp *lamp); -Lamp * Lamp_fromPyObject (PyObject *pyobj); -int Lamp_checkPyObject (PyObject *pyobj); +PyObject * Lamp_CreatePyObject (struct Lamp *lamp); +Lamp * Lamp_FromPyObject (PyObject *pyobj); +int Lamp_CheckPyObject (PyObject *pyobj); /* Curve Data */ PyObject * M_Curve_Init (void); @@ -93,12 +95,23 @@ PyObject * M_ArmatureCreatePyObject (bArmature *armature); bArmature* M_ArmatureFromPyObject (PyObject *py_obj); int M_ArmatureCheckPyObject (PyObject *py_obj); +/* Ipo Data */ +PyObject * M_Ipo_Init (void); +PyObject * Ipo_CreatePyObject (struct Ipo *ipo); +struct Ipo * Ipo_FromPyObject (PyObject *py_obj); +int Ipo_CheckPyObject (PyObject *py_obj); + +/* Metaball Data */ +PyObject * M_Metaball_Init (void); +PyObject * Metaball_CreatePyObject (MetaBall *metaball); +struct MetaBall * Metaball_FromPyObject (PyObject *py_obj); +int Metaball_CheckPyObject (PyObject *py_obj); + /* Particle Effects Data */ -/*PyObject * M_Effect_Init (void); -PyObject * EffectCreatePyObject (struct Effect *effect); -struct Effect * EffectFromPyObject (PyObject *py_obj); -int EffectCheckPyObject (PyObject *py_obj); -*/ +PyObject * M_Effect_Init (void); +PyObject * Effect_CreatePyObject (struct Effect *effect); +struct Effect * Effect_FromPyObject (PyObject *py_obj); +int Effect_CheckPyObject (PyObject *py_obj); /* Image */ PyObject * M_Image_Init (void);