/* * * ***** 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 "Particle.h" #include "Effect.h" /*****************************************************************************/ /* Python BPy_Particle methods table: */ /*****************************************************************************/ static PyMethodDef BPy_Particle_methods[] = { {"getType", (PyCFunction)Effect_getType, METH_NOARGS,"() - Return Effect type"}, {"setType", (PyCFunction)Effect_setType, METH_VARARGS,"() - Set Effect type"}, {"getFlag", (PyCFunction)Effect_getFlag, METH_NOARGS,"() - Return Effect flag"}, {"setFlag", (PyCFunction)Effect_setFlag, METH_VARARGS,"() - Set Effect flag"}, {"getStartTime",(PyCFunction)Particle_getSta, METH_NOARGS,"()-Return particle start time"}, {"setStartTime",(PyCFunction)Particle_setSta, METH_VARARGS, "()- Sets particle start time"}, {"getEndTime",(PyCFunction)Particle_getEnd, METH_NOARGS,"()-Return particle end time"}, {"setEndTime",(PyCFunction)Particle_setEnd, METH_VARARGS, "()- Sets particle end time"}, {"getLifetime",(PyCFunction)Particle_getLifetime, METH_NOARGS,"()-Return particle life time"}, {"setLifetime",(PyCFunction)Particle_setLifetime, METH_VARARGS, "()- Sets particle life time "}, {"getNormfac",(PyCFunction)Particle_getNormfac, METH_NOARGS,"()-Return particle life time"}, {"setNormfac",(PyCFunction)Particle_setNormfac, METH_VARARGS, "()- Sets particle life time "}, {"getObfac",(PyCFunction)Particle_getObfac, METH_NOARGS,"()-Return particle life time"}, {"setObfac",(PyCFunction)Particle_setObfac, METH_VARARGS, "()- Sets particle life time "}, {"getRandfac",(PyCFunction)Particle_getRandfac, METH_NOARGS,"()-Return particle life time"}, {"setRandfac",(PyCFunction)Particle_setRandfac, METH_VARARGS, "()- Sets particle life time "}, {"getTexfac",(PyCFunction)Particle_getTexfac, METH_NOARGS,"()-Return particle life time"}, {"setTexfac",(PyCFunction)Particle_setTexfac, METH_VARARGS, "()- Sets particle life time "}, {"getRandlife",(PyCFunction)Particle_getRandlife, METH_NOARGS,"()-Return particle life time"}, {"setRandlife",(PyCFunction)Particle_setRandlife, METH_VARARGS, "()- Sets particle life time "}, {"getNabla",(PyCFunction)Particle_getNabla, METH_NOARGS,"()-Return particle life time"}, {"setNabla",(PyCFunction)Particle_setNabla, METH_VARARGS, "()- Sets particle life time "}, {"getVectsize",(PyCFunction)Particle_getVectsize, METH_NOARGS,"()-Return particle life time"}, {"setVectsize",(PyCFunction)Particle_setVectsize, METH_VARARGS, "()- Sets particle life time "}, {"getTotpart",(PyCFunction)Particle_getTotpart, METH_NOARGS,"()-Return particle life time"}, {"setTotpart",(PyCFunction)Particle_setTotpart, METH_VARARGS, "()- Sets particle life time "}, {"getTotkey",(PyCFunction)Particle_getTotkey, METH_NOARGS,"()-Return particle life time"}, {"setTotkey",(PyCFunction)Particle_setTotkey, METH_VARARGS, "()- Sets particle life time "}, {"getSeed",(PyCFunction)Particle_getSeed, METH_NOARGS,"()-Return particle life time"}, {"setSeed",(PyCFunction)Particle_setSeed, METH_VARARGS, "()- Sets particle life time "}, {"getForce",(PyCFunction)Particle_getForce, METH_NOARGS,"()-Return particle life time"}, {"setForce",(PyCFunction)Particle_setForce, METH_VARARGS, "()- Sets particle life time "}, {"getMult",(PyCFunction)Particle_getMult, METH_NOARGS,"()-Return particle life time"}, {"setMult",(PyCFunction)Particle_setMult, METH_VARARGS, "()- Sets particle life time "}, {"getLife",(PyCFunction)Particle_getLife, METH_NOARGS,"()-Return particle life time"}, {"setLife",(PyCFunction)Particle_setLife, METH_VARARGS, "()- Sets particle life time "}, {"getMat",(PyCFunction)Particle_getMat, METH_NOARGS,"()-Return particle life time"}, {"setMat",(PyCFunction)Particle_setMat, METH_VARARGS, "()- Sets particle life time "}, {"getChild",(PyCFunction)Particle_getChild, METH_NOARGS,"()-Return particle life time"}, {"setChild",(PyCFunction)Particle_setChild, METH_VARARGS, "()- Sets particle life time "}, {"getDefvec",(PyCFunction)Particle_getDefvec, METH_NOARGS,"()-Return particle life time"}, {"setDefvec",(PyCFunction)Particle_setDefvec, METH_VARARGS, "()- Sets particle life time "}, {0} }; /*****************************************************************************/ /* Python Particle_Type structure definition: */ /*****************************************************************************/ PyTypeObject Particle_Type = { PyObject_HEAD_INIT(NULL) 0, "Particle", sizeof (BPy_Particle), 0, (destructor)ParticleDeAlloc, 0, (getattrfunc)ParticleGetAttr, (setattrfunc)ParticleSetAttr, 0, (reprfunc)ParticleRepr, 0, 0, 0, 0, 0,0,0,0,0,0, 0, 0,0,0,0,0,0, BPy_Particle_methods, 0, }; /*****************************************************************************/ /* The following string definitions are used for documentation strings. */ /* In Python these will be written to the console when doing a */ /* Blender.Particle.__doc__ */ /*****************************************************************************/ char M_Particle_doc[] = "The Blender Particle module\n\n\ This module provides access to **Object Data** in Blender.\n\ Functions :\n\ New(opt name) : creates a new part object with the given name (optional)\n\ Get(name) : retreives a particle with the given name (mandatory)\n\ get(name) : same as Get. Kept for compatibility reasons"; char M_Particle_New_doc[] =""; char M_Particle_Get_doc[] ="xxx"; /*****************************************************************************/ /* Python method structure definition for Blender.Particle module: */ /*****************************************************************************/ struct PyMethodDef M_Particle_methods[] = { {"New",(PyCFunction)M_Particle_New, METH_VARARGS,M_Particle_New_doc}, {"Get", M_Particle_Get, METH_VARARGS, M_Particle_Get_doc}, {"get", M_Particle_Get, METH_VARARGS, M_Particle_Get_doc}, {NULL, NULL, 0, NULL} }; /*****************************************************************************/ /* Function: M_Particle_New */ /* Python equivalent: Blender.Effect.Particle.New */ /*****************************************************************************/ PyObject *M_Particle_New(PyObject *self, PyObject *args) { int type = EFF_PARTICLE; BPy_Effect *pyeffect; Effect *bleffect = 0; bleffect = add_effect(type); if (bleffect == NULL) return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't create Effect Data in Blender")); pyeffect = (BPy_Effect *)PyObject_NEW(BPy_Effect, &Effect_Type); if (pyeffect == NULL) return (EXPP_ReturnPyObjError (PyExc_MemoryError, "couldn't create Effect Data object")); pyeffect->effect = bleffect; return (PyObject *)pyeffect; return 0; } /*****************************************************************************/ /* Function: M_Particle_Get */ /* Python equivalent: Blender.Effect.Particle.Get */ /*****************************************************************************/ PyObject *M_Particle_Get(PyObject *self, PyObject *args) { /*arguments : string object name int : position of effect in the obj's effect list */ char *name = 0; Object *object_iter; Effect *eff; BPy_Particle *wanted_eff; int num,i; if (!PyArg_ParseTuple(args, "si", &name, &num )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected string int argument")); object_iter = G.main->object.first; if (!object_iter)return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "Scene contains no object")); while (object_iter) { if (strcmp(name,object_iter->id.name+2)) { object_iter = object_iter->id.next; continue; } if (object_iter->effect.first != NULL) { eff = object_iter->effect.first; for(i = 0;itype != EFF_PARTICLE)continue; eff = eff->next; if (!eff) return(EXPP_ReturnPyObjError(PyExc_AttributeError,"bject")); } wanted_eff = (BPy_Particle *)PyObject_NEW(BPy_Particle, &Particle_Type); wanted_eff->particle = eff; return (PyObject*)wanted_eff; } object_iter = object_iter->id.next; } Py_INCREF(Py_None); return Py_None; } /*****************************************************************************/ /* Function: Particle_Init */ /*****************************************************************************/ PyObject *Particle_Init (void) { PyObject *submodule; Particle_Type.ob_type = &PyType_Type; submodule = Py_InitModule3("Blender.Particle",M_Particle_methods, M_Particle_doc); return (submodule); } /*****************************************************************************/ /* Python BPy_Particle methods: */ /*****************************************************************************/ PyObject *Particle_getSta(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return PyFloat_FromDouble(ptr->sta); } PyObject *Particle_setSta(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; float val = 0; if (!PyArg_ParseTuple(args, "f", &val )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected float argument")); ptr->sta = val; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getEnd(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return PyFloat_FromDouble(ptr->end); } PyObject *Particle_setEnd(BPy_Particle *self,PyObject *args) { float val = 0; PartEff*ptr = (PartEff*)self->particle; if (!PyArg_ParseTuple(args, "f", &val )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected float argument")); ptr->end = val; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getLifetime(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return PyFloat_FromDouble(ptr->lifetime); } PyObject *Particle_setLifetime(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; float val = 0; if (!PyArg_ParseTuple(args, "f", &val )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected float argument")); ptr->lifetime = val; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getNormfac(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return PyFloat_FromDouble(ptr->normfac); } PyObject *Particle_setNormfac(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; float val = 0; if (!PyArg_ParseTuple(args, "f", &val )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected float argument")); ptr->normfac = val; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getObfac(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return PyFloat_FromDouble(ptr->obfac); } PyObject *Particle_setObfac(BPy_Particle *self,PyObject *args) { float val = 0; PartEff*ptr = (PartEff*)self->particle; if (!PyArg_ParseTuple(args, "f", &val )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected float argument")); ptr->obfac = val; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getRandfac(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return PyFloat_FromDouble(ptr->randfac); } PyObject *Particle_setRandfac(BPy_Particle *self,PyObject *args) { float val = 0; PartEff*ptr = (PartEff*)self->particle; if (!PyArg_ParseTuple(args, "f", &val )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected float argument")); ptr->randfac = val; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getTexfac(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return PyFloat_FromDouble(ptr->texfac); } PyObject *Particle_setTexfac(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; float val = 0; if (!PyArg_ParseTuple(args, "f", &val )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected float argument")); ptr->texfac = val; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getRandlife(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return PyFloat_FromDouble(ptr->randlife); } PyObject *Particle_setRandlife(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; float val = 0; if (!PyArg_ParseTuple(args, "f", &val )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected float argument")); ptr->randlife = val; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getNabla(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return PyFloat_FromDouble(ptr->nabla); } PyObject *Particle_setNabla(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; float val = 0; if (!PyArg_ParseTuple(args, "f", &val )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected float argument")); ptr->nabla = val; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getVectsize(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return PyFloat_FromDouble(ptr->vectsize); } PyObject *Particle_setVectsize(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; float val = 0; if (!PyArg_ParseTuple(args, "f", &val )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected float argument")); ptr->vectsize = val; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getTotpart(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return PyInt_FromLong(ptr->totpart); } PyObject *Particle_setTotpart(BPy_Particle *self,PyObject *args) { int val = 0; PartEff*ptr = (PartEff*)self->particle; if (!PyArg_ParseTuple(args, "i", &val )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected int argument")); ptr->totpart = val; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getTotkey(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return PyInt_FromLong(ptr->totkey); } PyObject *Particle_setTotkey(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; int val = 0; if (!PyArg_ParseTuple(args, "i", &val )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected int argument")); ptr->totkey = val; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getSeed(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return PyInt_FromLong(ptr->seed); } PyObject *Particle_setSeed(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; int val = 0; if (!PyArg_ParseTuple(args, "i", &val )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected int argument")); ptr->seed = val; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getForce(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return Py_BuildValue("(f,f,f)",ptr->force[0],ptr->force[1],ptr->force[2]); } PyObject *Particle_setForce(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; float val[3]; if (PyTuple_Size(args) == 1)args = PyTuple_GetItem(args,0); val[0] = PyFloat_AsDouble(PyTuple_GetItem(args,0)); val[1] = PyFloat_AsDouble(PyTuple_GetItem(args,1)); val[2] = PyFloat_AsDouble(PyTuple_GetItem(args,2)); /* if (!PyArg_ParseTuple(args, "fff", val,val+1,val+2 )) return(EXPP_ReturnPyObjError(PyExc_AttributeError,\ "expected three float arguments")); */ ptr->force[0] = val[0];ptr->force[1] = val[1];ptr->force[2] = val[2]; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getMult(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return Py_BuildValue("(f,f,f,f)", ptr->mult[0],ptr->mult[1],ptr->mult[2],ptr->mult[3]); } PyObject *Particle_setMult(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; float val[4]; if (PyTuple_Size(args) == 1)args = PyTuple_GetItem(args,0); val[0] = PyFloat_AsDouble(PyTuple_GetItem(args,0)); val[1] = PyFloat_AsDouble(PyTuple_GetItem(args,1)); val[2] = PyFloat_AsDouble(PyTuple_GetItem(args,2)); val[3] = PyFloat_AsDouble(PyTuple_GetItem(args,3)); ptr->mult[0] = val[0];ptr->mult[1] = val[1]; ptr->mult[2] = val[2];ptr->mult[3] = val[3]; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getLife(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return Py_BuildValue("(f,f,f,f)", ptr->life[0],ptr->life[1],ptr->life[2],ptr->life[3]); } PyObject *Particle_setLife(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; float val[4]; if (PyTuple_Size(args) == 1)args = PyTuple_GetItem(args,0); val[0] = PyFloat_AsDouble(PyTuple_GetItem(args,0)); val[1] = PyFloat_AsDouble(PyTuple_GetItem(args,1)); val[2] = PyFloat_AsDouble(PyTuple_GetItem(args,2)); val[3] = PyFloat_AsDouble(PyTuple_GetItem(args,3)); ptr->life[0] = val[0];ptr->life[1] = val[1]; ptr->life[2] = val[2];ptr->life[3] = val[3]; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getChild(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return Py_BuildValue("(f,f,f,f)", ptr->child[0],ptr->child[1],ptr->child[2],ptr->child[3]); } PyObject *Particle_setChild(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; float val[4]; if (PyTuple_Size(args) == 1)args = PyTuple_GetItem(args,0); val[0] = PyFloat_AsDouble(PyTuple_GetItem(args,0)); val[1] = PyFloat_AsDouble(PyTuple_GetItem(args,1)); val[2] = PyFloat_AsDouble(PyTuple_GetItem(args,2)); val[3] = PyFloat_AsDouble(PyTuple_GetItem(args,3)); ptr->child[0] = val[0];ptr->child[1] = val[1]; ptr->child[2] = val[2];ptr->child[3] = val[3]; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getMat(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return Py_BuildValue("(f,f,f,f)", ptr->mat[0],ptr->mat[1],ptr->mat[2],ptr->mat[3]); } PyObject *Particle_setMat(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; float val[4]; if (PyTuple_Size(args) == 1)args = PyTuple_GetItem(args,0); val[0] = PyFloat_AsDouble(PyTuple_GetItem(args,0)); val[1] = PyFloat_AsDouble(PyTuple_GetItem(args,1)); val[2] = PyFloat_AsDouble(PyTuple_GetItem(args,2)); val[3] = PyFloat_AsDouble(PyTuple_GetItem(args,3)); ptr->mat[0] = val[0];ptr->mat[1] = val[1]; ptr->mat[2] = val[2];ptr->mat[3] = val[3]; Py_INCREF(Py_None); return Py_None; } PyObject *Particle_getDefvec(BPy_Particle *self) { PartEff*ptr = (PartEff*)self->particle; return Py_BuildValue("(f,f,f)", ptr->defvec[0],ptr->defvec[1],ptr->defvec[2]); } PyObject *Particle_setDefvec(BPy_Particle *self,PyObject *args) { PartEff*ptr = (PartEff*)self->particle; float val[3]; if (PyTuple_Size(args) == 1)args = PyTuple_GetItem(args,0); val[0] = PyFloat_AsDouble(PyTuple_GetItem(args,0)); val[1] = PyFloat_AsDouble(PyTuple_GetItem(args,1)); val[2] = PyFloat_AsDouble(PyTuple_GetItem(args,2)); ptr->defvec[0] = val[0];ptr->defvec[1] = val[1]; ptr->defvec[2] = val[2]; Py_INCREF(Py_None); return Py_None; } /*****************************************************************************/ /* Function: ParticleDeAlloc */ /* Description: This is a callback function for the BPy_Particle type. It is */ /* the destructor function. */ /*****************************************************************************/ void ParticleDeAlloc (BPy_Particle *self) { PartEff*ptr = (PartEff*)self; PyObject_DEL (ptr); } /*****************************************************************************/ /* Function: ParticleGetAttr */ /* Description: This is a callback function for the BPy_Particle type. It is */ /* the function that accesses BPy_Particle "member variables" and */ /* methods. */ /*****************************************************************************/ PyObject *ParticleGetAttr (BPy_Particle *self, char *name) { if (strcmp (name, "seed") == 0) return Particle_getSeed (self); else if (strcmp (name, "nabla") == 0) return Particle_getNabla (self); else if (strcmp (name, "sta") == 0) return Particle_getSta (self); else if (strcmp (name, "end") == 0) return Particle_getEnd (self); else if (strcmp (name, "lifetime") == 0) return Particle_getLifetime (self); else if (strcmp (name, "normfac") == 0) return Particle_getNormfac (self); else if (strcmp (name, "obfac") == 0) return Particle_getObfac (self); else if (strcmp (name, "randfac") == 0) return Particle_getRandfac (self); else if (strcmp (name, "texfac") == 0) return Particle_getTexfac (self); else if (strcmp (name, "randlife") == 0) return Particle_getRandlife (self); else if (strcmp (name, "vectsize") == 0) return Particle_getVectsize (self); else if (strcmp (name, "totpart") == 0) return Particle_getTotpart (self); else if (strcmp (name, "force") == 0) return Particle_getForce (self); else if (strcmp (name, "mult") == 0) return Particle_getMult (self); else if (strcmp (name, "life") == 0) return Particle_getLife (self); else if (strcmp (name, "child") == 0) return Particle_getChild (self); else if (strcmp (name, "mat") == 0) return Particle_getMat (self); else if (strcmp (name, "defvec") == 0) return Particle_getDefvec (self); return Py_FindMethod(BPy_Particle_methods, (PyObject *)self, name); } /*****************************************************************************/ /* Function: ParticleSetAttr */ /* Description: This is a callback function for the BPy_Particle type. It is th*/ /* function that sets Particle Data attributes (member vars) */ /*****************************************************************************/ int ParticleSetAttr (BPy_Particle *self, char *name, PyObject *value) { PyObject *valtuple; PyObject *error = NULL; valtuple = Py_BuildValue("(N)", value); if (!valtuple) return EXPP_ReturnIntError(PyExc_MemoryError, "ParticleSetAttr: couldn't create PyTuple"); if (strcmp (name, "seed") == 0) error = Particle_setSeed (self, valtuple); else if (strcmp (name, "nabla") == 0) error = Particle_setNabla (self, valtuple); else if (strcmp (name, "sta") == 0) error = Particle_setSta (self, valtuple); else if (strcmp (name, "end") == 0) error = Particle_setEnd (self, valtuple); else if (strcmp (name, "lifetime") == 0) error = Particle_setLifetime (self, valtuple); else if (strcmp (name, "normfac") == 0) error = Particle_setNormfac (self, valtuple); else if (strcmp (name, "obfac") == 0) error = Particle_setObfac (self, valtuple); else if (strcmp (name, "randfac") == 0) error = Particle_setRandfac (self, valtuple); else if (strcmp (name, "texfac") == 0) error = Particle_setTexfac (self, valtuple); else if (strcmp (name, "randlife") == 0) error = Particle_setRandlife (self, valtuple); else if (strcmp (name, "nabla") == 0) error = Particle_setNabla (self, valtuple); else if (strcmp (name, "vectsize") == 0) error = Particle_setVectsize (self, valtuple); else if (strcmp (name, "totpart") == 0) error = Particle_setTotpart (self, valtuple); else if (strcmp (name, "seed") == 0) error = Particle_setSeed (self, valtuple); else if (strcmp (name, "force") == 0) error = Particle_setForce (self, valtuple); else if (strcmp (name, "mult") == 0) error = Particle_setMult (self, valtuple); else if (strcmp (name, "life") == 0) error = Particle_setLife (self, valtuple); else if (strcmp (name, "child") == 0) error = Particle_setChild (self, valtuple); else if (strcmp (name, "mat") == 0) error = Particle_setMat (self, valtuple); else if (strcmp (name, "defvec") == 0) error = Particle_setDefvec (self, valtuple); else { Py_DECREF(valtuple); if ((strcmp (name, "Types") == 0) || (strcmp (name, "Modes") == 0)) return (EXPP_ReturnIntError (PyExc_AttributeError, "constant dictionary -- cannot be changed")); else return (EXPP_ReturnIntError (PyExc_KeyError, "attribute not found")); } /*Py_DECREF(valtuple);*/ if (error != Py_None) return -1; Py_DECREF(Py_None); return 0; } /*****************************************************************************/ /* Function: ParticlePrint */ /* Description: This is a callback function for the BPy_Particle type. It */ /* particles a meaninful string to 'print' particle objects. */ /*****************************************************************************/ /* int ParticlePrint(BPy_Particle *self, FILE *fp, int flags) { printf("Hi, I'm a particle!"); return 0; } */ /*****************************************************************************/ /* Function: ParticleRepr */ /* Description: This is a callback function for the BPy_Particle type. It */ /* particles a meaninful string to represent particle objects. */ /*****************************************************************************/ PyObject *ParticleRepr (BPy_Particle *self) { return PyString_FromString("Particle"); } PyObject* ParticleCreatePyObject (struct Effect *particle) { BPy_Particle * blen_object; blen_object = (BPy_Particle*)PyObject_NEW (BPy_Particle, &Particle_Type); if (blen_object == NULL) { return (NULL); } blen_object->particle = particle; return ((PyObject*)blen_object); } int ParticleCheckPyObject (PyObject *py_obj) { return (py_obj->ob_type == &Particle_Type); } struct Particle* ParticleFromPyObject (PyObject *py_obj) { BPy_Particle * blen_obj; blen_obj = (BPy_Particle*)py_obj; return ((struct Particle*)blen_obj->particle); }