diff options
author | Joseph Gilbert <ascotan@gmail.com> | 2003-11-13 07:00:59 +0300 |
---|---|---|
committer | Joseph Gilbert <ascotan@gmail.com> | 2003-11-13 07:00:59 +0300 |
commit | a4aad039aa69784c61ff1eb8da8505c3b4e89172 (patch) | |
tree | 800a963b46d8a437cab93522d98848d96f727872 /source/blender/python | |
parent | 0e9dd3060e04459d4ecb5ccbce138de7532a3425 (diff) |
The new Lattice module for python
- enabled all the Lattice methods in Object.c
- added Lattice types to Types.c
- add Lattice initialization to Blender.c
- updated makefile for new lattice file
- added Lattice.c/Lattice.h
Diffstat (limited to 'source/blender/python')
-rw-r--r-- | source/blender/python/api2_2x/Blender.c | 1 | ||||
-rw-r--r-- | source/blender/python/api2_2x/Lattice.c | 727 | ||||
-rw-r--r-- | source/blender/python/api2_2x/Lattice.h | 220 | ||||
-rw-r--r-- | source/blender/python/api2_2x/Object.c | 18 | ||||
-rw-r--r-- | source/blender/python/api2_2x/Types.c | 2 | ||||
-rw-r--r-- | source/blender/python/api2_2x/Types.h | 1 | ||||
-rw-r--r-- | source/blender/python/api2_2x/modules.h | 7 |
7 files changed, 967 insertions, 9 deletions
diff --git a/source/blender/python/api2_2x/Blender.c b/source/blender/python/api2_2x/Blender.c index 13bb9570085..a6d347aa9f1 100644 --- a/source/blender/python/api2_2x/Blender.c +++ b/source/blender/python/api2_2x/Blender.c @@ -216,6 +216,7 @@ void M_Blender_Init (void) PyDict_SetItemString (dict, "Material", Material_Init()); PyDict_SetItemString (dict, "Camera", Camera_Init()); PyDict_SetItemString (dict, "Lamp", Lamp_Init()); + PyDict_SetItemString (dict, "Lattice", Lattice_Init()); PyDict_SetItemString (dict, "Curve", Curve_Init()); PyDict_SetItemString (dict, "Armature", Armature_Init()); PyDict_SetItemString (dict, "Ipo", Ipo_Init()); diff --git a/source/blender/python/api2_2x/Lattice.c b/source/blender/python/api2_2x/Lattice.c new file mode 100644 index 00000000000..b35decd15df --- /dev/null +++ b/source/blender/python/api2_2x/Lattice.c @@ -0,0 +1,727 @@ +/* + * + * ***** 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): Joseph Gilbert + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#include "Lattice.h" + +//*************************************************************************** +// Function: Lattice_CreatePyObject +//*************************************************************************** +PyObject *Lattice_CreatePyObject (Lattice *lt) +{ + BPy_Lattice *pyLat; + + pyLat = (BPy_Lattice *)PyObject_NEW (BPy_Lattice, &Lattice_Type); + + if (!pyLat) + return EXPP_ReturnPyObjError (PyExc_MemoryError, + "couldn't create BPy_Lattice PyObject"); + + pyLat->Lattice = lt; + + return (PyObject *)pyLat; +} + +//*************************************************************************** +// Function: Lattice_FromPyObject +//*************************************************************************** + +Lattice *Lattice_FromPyObject (PyObject *pyobj) +{ + return ((BPy_Lattice *)pyobj)->Lattice; +} + +//*************************************************************************** +// Function: Lattice_CheckPyObject +//*************************************************************************** +int Lattice_CheckPyObject (PyObject *pyobj) +{ + return (pyobj->ob_type == &Lattice_Type); +} + +//*************************************************************************** +// Function: M_Lattice_New +// Python equivalent: Blender.Lattice.New +//*************************************************************************** +static PyObject *M_Lattice_New(PyObject *self, PyObject *args) +{ + char *name = NULL; + char buf[21]; + Lattice * bl_Lattice; // blender Lattice object + PyObject * py_Lattice; // python wrapper + + if (!PyArg_ParseTuple(args, "|s", &name)) + return EXPP_ReturnPyObjError (PyExc_AttributeError, + "expected string and int arguments (or nothing)"); + + bl_Lattice = add_lattice(); + bl_Lattice->id.us = 0; + + if (bl_Lattice) + py_Lattice = Lattice_CreatePyObject (bl_Lattice); + else + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't create Lattice Object in Blender"); + if (!py_Lattice) + return EXPP_ReturnPyObjError (PyExc_MemoryError, + "couldn't create Lattice Object wrapper"); + + if (name) { + PyOS_snprintf(buf, sizeof(buf), "%s", name); + rename_id(&bl_Lattice->id, buf); + } + + return py_Lattice; +} + +//*************************************************************************** +// Function: M_Lattice_Get +// Python equivalent: Blender.Lattice.Get +//*************************************************************************** +static PyObject *M_Lattice_Get(PyObject *self, PyObject *args) +{ + char *name = NULL; + Lattice *lat_iter; + + if (!PyArg_ParseTuple(args, "|s", &name)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected string argument (or nothing)")); + + lat_iter = G.main->latt.first; + + if (name) { /* (name) - Search Lattice by name */ + + PyObject *wanted_lat = NULL; + + while ((lat_iter) && (wanted_lat == NULL)) { + if (strcmp (name, lat_iter->id.name+2) == 0) { + wanted_lat = Lattice_CreatePyObject (lat_iter); + } + + lat_iter = lat_iter->id.next; + } + + if (wanted_lat == NULL) { /* Requested Lattice doesn't exist */ + char error_msg[64]; + PyOS_snprintf(error_msg, sizeof(error_msg), + "Lattice \"%s\" not found", name); + return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg)); + } + + return wanted_lat; + } + + else { /* () - return a list of all Lattices in the scene */ + int index = 0; + PyObject *latlist, *pyobj; + + latlist = PyList_New (BLI_countlist (&(G.main->latt))); + + if (latlist == NULL) + return (EXPP_ReturnPyObjError (PyExc_MemoryError, + "couldn't create PyList")); + + while (lat_iter) { + pyobj = Lattice_CreatePyObject(lat_iter); + + if (!pyobj) + return (EXPP_ReturnPyObjError (PyExc_MemoryError, + "couldn't create PyString")); + + PyList_SET_ITEM (latlist, index, pyobj); + + lat_iter = lat_iter->id.next; + index++; + } + + return (latlist); + } +} +//*************************************************************************** +// Function: Lattice_Init +//*************************************************************************** +PyObject *Lattice_Init (void) +{ + PyObject *mod= Py_InitModule3("Blender.Lattice", M_Lattice_methods, M_Lattice_doc); + PyObject *dict= PyModule_GetDict(mod); + + Lattice_Type.ob_type = &PyType_Type; + + //Module dictionary + #define EXPP_ADDCONST(x) PyDict_SetItemString(dict, #x, PyInt_FromLong(LT_##x)) + EXPP_ADDCONST(GRID); + EXPP_ADDCONST(OUTSIDE); + + #undef EXPP_ADDCONST + #define EXPP_ADDCONST(x) PyDict_SetItemString(dict, #x, PyInt_FromLong(KEY_##x)) + EXPP_ADDCONST(LINEAR); + EXPP_ADDCONST(CARDINAL); + EXPP_ADDCONST(BSPLINE); + + return(mod); +} + +//*************************************************************************** +// Python BPy_Lattice methods: +//*************************************************************************** +static PyObject *Lattice_getName(BPy_Lattice *self) +{ + PyObject *attr = PyString_FromString(self->Lattice->id.name+2); + + if (attr) return attr; + + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "couldn't get Lattice.name attribute"); +} + +static PyObject *Lattice_setName(BPy_Lattice *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->Lattice->id, buf); + + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject *Lattice_setPartitions(BPy_Lattice *self, PyObject *args) +{ + int x = 0; + int y = 0; + int z = 0; + Lattice * bl_Lattice; + + if (!PyArg_ParseTuple(args, "iii", &x, &y, &z)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int,int,int argument")); + + bl_Lattice = self->Lattice; + + if(x <2 || y < 2 || z < 2) + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "partition values must be 2 or greater")); + + bl_Lattice->pntsu = (short)x; + bl_Lattice->pntsv = (short)y; + bl_Lattice->pntsw = (short)z; + resizelattice(bl_Lattice); + + Py_INCREF (Py_None); + return Py_None; +} + +static PyObject *Lattice_getPartitions(BPy_Lattice *self, PyObject *args) +{ + Lattice * bl_Lattice; + bl_Lattice = self->Lattice; + + return Py_BuildValue("[i,i,i]", (int)bl_Lattice->pntsu, + (int)bl_Lattice->pntsv, + (int)bl_Lattice->pntsw); +} + +static PyObject *Lattice_getKeyTypes(BPy_Lattice *self, PyObject *args) +{ + Lattice * bl_Lattice; + char *linear = "linear"; + char *cardinal = "cardinal"; + char *bspline = "bspline"; + char *s_x = NULL, *s_y = NULL, *s_z = NULL; + + bl_Lattice = self->Lattice; + + if ((bl_Lattice->typeu) == KEY_LINEAR) + s_x = linear; + else if ((bl_Lattice->typeu) == KEY_CARDINAL) + s_x = cardinal; + else if ((bl_Lattice->typeu) == KEY_BSPLINE) + s_x = bspline; + else + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "bad key type..."); + + if ((bl_Lattice->typev) == KEY_LINEAR) + s_y = linear; + else if ((bl_Lattice->typev) == KEY_CARDINAL) + s_y = cardinal; + else if ((bl_Lattice->typev) == KEY_BSPLINE) + s_z = bspline; + else + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "bad key type..."); + + if ((bl_Lattice->typew) == KEY_LINEAR) + s_z = linear; + else if ((bl_Lattice->typew) == KEY_CARDINAL) + s_z = cardinal; + else if ((bl_Lattice->typew) == KEY_BSPLINE) + s_z = bspline; + else + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "bad key type..."); + + /* we made sure no s_[xyz] is NULL */ + return Py_BuildValue("[s,s,s]", s_x, s_y, s_z); +} + +static PyObject *Lattice_setKeyTypes(BPy_Lattice *self, PyObject *args) +{ + int x; + int y; + int z; + Lattice * bl_Lattice; + + if (!PyArg_ParseTuple(args, "iii", &x, &y, &z)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int,int,int argument")); + + bl_Lattice = self->Lattice; + + if (x == KEY_LINEAR) + bl_Lattice->typeu = KEY_LINEAR; + else if (x == KEY_CARDINAL) + bl_Lattice->typeu = KEY_CARDINAL; + else if (x == KEY_BSPLINE) + bl_Lattice->typeu = KEY_BSPLINE; + else + return EXPP_ReturnPyObjError (PyExc_TypeError, + "type must be LINEAR, CARDINAL OR BSPLINE"); + + if (y == KEY_LINEAR) + bl_Lattice->typev = KEY_LINEAR; + else if (y == KEY_CARDINAL) + bl_Lattice->typev = KEY_CARDINAL; + else if (y == KEY_BSPLINE) + bl_Lattice->typev = KEY_BSPLINE; + else + return EXPP_ReturnPyObjError (PyExc_TypeError, + "type must be LINEAR, CARDINAL OR BSPLINE"); + + if (z == KEY_LINEAR) + bl_Lattice->typew = KEY_LINEAR; + else if (z == KEY_CARDINAL) + bl_Lattice->typew = KEY_CARDINAL; + else if (z == KEY_BSPLINE) + bl_Lattice->typew = KEY_BSPLINE; + else + return EXPP_ReturnPyObjError (PyExc_TypeError, + "type must be LINEAR, CARDINAL OR BSPLINE"); + + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject *Lattice_setMode(BPy_Lattice *self, PyObject *args) +{ + short type; + Lattice * bl_Lattice; + bl_Lattice = self->Lattice; + + if (!PyArg_ParseTuple(args, "h", &type)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected string argument")); + + if (type == LT_GRID) + bl_Lattice->flag = LT_GRID; + else if (type == LT_OUTSIDE) + { + bl_Lattice->flag = LT_OUTSIDE + LT_GRID; + outside_lattice(bl_Lattice); + } + else + return EXPP_ReturnPyObjError (PyExc_TypeError, + "type must be either GRID or OUTSIDE"); + + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject *Lattice_getMode(BPy_Lattice *self, PyObject *args) +{ + char type[24]; + Lattice * bl_Lattice; + bl_Lattice = self->Lattice; + + if (bl_Lattice->flag & LT_GRID) + sprintf(type, "Grid"); + else if (bl_Lattice->flag & LT_OUTSIDE) + sprintf(type, "Outside"); + else + return EXPP_ReturnPyObjError (PyExc_TypeError, + "bad mode type..."); + + return Py_BuildValue("s", type); +} + +static PyObject *Lattice_setPoint(BPy_Lattice *self, PyObject *args) +{ + BPoint *bp, *bpoint; + short size; + Lattice * bl_Lattice; + int index, x; + float tempInt; + PyObject * listObject; + + if (!PyArg_ParseTuple(args, "iO!", &index, &PyList_Type, &listObject)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int & list argument")); + + if(!PyList_Check(listObject)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "2nd parameter should be a python list")); + + if (!(PyList_Size(listObject) == 3)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "Please pass 3 parameters in the list [x,y,z]")); + + //init + bp= 0; + bl_Lattice = self->Lattice; + + //get bpoints + bp= bl_Lattice->def; + + if(bp == 0) + return (EXPP_ReturnPyObjError (PyExc_AttributeError, + "no lattice points!")); + + //calculate size of lattice + size= bl_Lattice->pntsu*bl_Lattice->pntsv*bl_Lattice->pntsw; + + if (index < 0 || index > size) + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "index outside of lattice size!")); + + //get the bpoint + while (index) + { + index--; + bp++; + } + bpoint = bp; + + for (x = 0; x < PyList_Size(listObject); x++) { + if (!(PyArg_Parse((PyList_GetItem(listObject, x)), "f", &tempInt))) + return EXPP_ReturnPyObjError (PyExc_TypeError, + "python list integer not parseable"); + bpoint->vec[x] = tempInt; + } + + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject *Lattice_getPoint(BPy_Lattice *self, PyObject *args) +{ + BPoint *bp, *bpoint; + short size; + Lattice * bl_Lattice; + int index; + + if (!PyArg_ParseTuple(args, "i", &index)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int argument")); + + //init + bp= 0; + bl_Lattice = self->Lattice; + + //get bpoints + bp= bl_Lattice->def; + + if(bp == 0) + return (EXPP_ReturnPyObjError (PyExc_AttributeError, + "no lattice points!")); + + //calculate size of lattice + size= bl_Lattice->pntsu*bl_Lattice->pntsv*bl_Lattice->pntsw; + + if (index < 0 || index > size) + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "index outside of lattice size!")); + + //get the bpoint + while (index) + { + index--; + bp++; + } + bpoint = bp; + + if(bpoint == 0) + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "bpoint does not exist")); + + return Py_BuildValue("[f,f,f]", bp->vec[0] ,bp->vec[1] ,bp->vec[2]); +} + +//This function will not do anything if there are no children +static PyObject *Lattice_applyDeform(BPy_Lattice *self) +{ + Object* ob; + Base *base; + Object *par; + + if (!Lattice_IsLinkedToObject(self)) + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "Lattice must be linked to an object to apply it's deformation!")); + + //deform children + base= FIRSTBASE; + while(base) { + if( (par= base->object->parent) ) { + if(par->type==OB_LATTICE) { + object_deform(base->object); + } + } + base= base->next; + } + + + Py_INCREF(Py_None); + return Py_None; +} + +static PyObject *Lattice_insertKey(BPy_Lattice *self, PyObject *args) +{ + Lattice *lt; + int frame, oldfra; + + if (!PyArg_ParseTuple(args, "i", &frame)) + return (EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int argument")); + + lt = self->Lattice; + + //set the current frame + if (frame > 0) { + oldfra = G.scene->r.cfra; + G.scene->r.cfra = frame; + } + else + return (EXPP_ReturnPyObjError (PyExc_RuntimeError, + "frame value has to be greater than 0")); + + //insert a keybock for the lattice + insert_lattkey(lt); + + allqueue(REDRAWHEADERS, 0); + + Py_INCREF(Py_None); + return Py_None; +} + +//*************************************************************************** +// Function: Lattice_dealloc +// Description: This is a callback function for the BPy_Lattice type. It is +// the destructor function. +//*************************************************************************** +static void Lattice_dealloc (BPy_Lattice *self) +{ + PyObject_DEL (self); +} + +//*************************************************************************** +// Function: Lattice_getAttr +// Description: This is a callback function for the BPy_Lattice type. It is +// the function that accesses BPy_Lattice member variables and +// methods. +//*************************************************************************** +static PyObject *Lattice_getAttr (BPy_Lattice *self, char *name) +{ + PyObject *attr = Py_None; + + if (!self->Lattice || !Lattice_InLatList(self)) + return EXPP_ReturnPyObjError (PyExc_RuntimeError, + "Lattice was already deleted!"); + + if (strcmp(name, "name") == 0) + attr = PyString_FromString(self->Lattice->id.name+2); + else if (strcmp(name, "width") == 0) + attr = Py_BuildValue("i",self->Lattice->pntsu); + else if (strcmp(name, "height") == 0) + attr = Py_BuildValue("i",self->Lattice->pntsv); + else if (strcmp(name, "depth") == 0) + attr = Py_BuildValue("i",self->Lattice->pntsw); + else if (strcmp(name, "widthType") == 0) + { + if(self->Lattice->typeu == 0) + attr = Py_BuildValue("s","Linear"); + else if (self->Lattice->typeu == 1) + attr = Py_BuildValue("s","Cardinal"); + else if (self->Lattice->typeu == 2) + attr = Py_BuildValue("s","Bspline"); + else + return EXPP_ReturnPyObjError (PyExc_ValueError, + "bad widthType..."); + } + else if (strcmp(name, "heightType") == 0) + { + if(self->Lattice->typev == 0) + attr = Py_BuildValue("s","Linear"); + else if (self->Lattice->typev== 1) + attr = Py_BuildValue("s","Cardinal"); + else if (self->Lattice->typev == 2) + attr = Py_BuildValue("s","Bspline"); + else + return EXPP_ReturnPyObjError (PyExc_ValueError, + "bad widthType..."); + } + else if (strcmp(name, "depthType") == 0) + { + if(self->Lattice->typew == 0) + attr = Py_BuildValue("s","Linear"); + else if (self->Lattice->typew == 1) + attr = Py_BuildValue("s","Cardinal"); + else if (self->Lattice->typew == 2) + attr = Py_BuildValue("s","Bspline"); + else + return EXPP_ReturnPyObjError (PyExc_ValueError, + "bad widthType..."); + } + else if (strcmp(name, "mode") == 0) + { + if(self->Lattice->flag == 1) + attr = Py_BuildValue("s","Grid"); + else if (self->Lattice->flag == 3) + attr = Py_BuildValue("s","Outside"); + else + return EXPP_ReturnPyObjError (PyExc_ValueError, + "bad mode..."); + } + else if (strcmp(name, "latSize") == 0) + { + attr = Py_BuildValue("i",self->Lattice->pntsu * + self->Lattice->pntsv * + self->Lattice->pntsw); + } + else if (strcmp(name, "__members__") == 0) + attr = Py_BuildValue("[s,s,s,s,s,s,s,s,s]", "name","width","height","depth", + "widthType","heightType","depthType","mode","latSize"); + + if (!attr) + return (EXPP_ReturnPyObjError (PyExc_MemoryError, + "couldn't create PyObject")); + + if (attr != Py_None) return attr; // attribute found, return its value + + // not an attribute, search the methods table + return Py_FindMethod(BPy_Lattice_methods, (PyObject *)self, name); +} + +//*************************************************************************** +// Function: Lattice_setAttr +// Description: This is a callback function for the BPy_Lattice type. It is the +// function that changes Lattice Data members values. If this +// data is linked to a Blender Lattice, it also gets updated. +//*************************************************************************** +static int Lattice_setAttr (BPy_Lattice *self, char *name, PyObject *value) +{ + PyObject *valtuple; + PyObject *error = NULL; + + if (!self->Lattice || !Lattice_InLatList(self)) + return EXPP_ReturnIntError (PyExc_RuntimeError, + "Lattice was already deleted!"); + + valtuple = Py_BuildValue("(O)", value);// the set* functions expect a tuple + + if (!valtuple) + return EXPP_ReturnIntError(PyExc_MemoryError, + "LatticeSetAttr: couldn't create PyTuple"); + + if (strcmp (name, "name") == 0) + error = Lattice_setName (self, valtuple); + else { // Error: no such member in the Lattice Data structure + Py_DECREF(value); + Py_DECREF(valtuple); + return (EXPP_ReturnIntError (PyExc_KeyError, + "attribute not found or immutable")); + } + Py_DECREF(valtuple); + + if (error != Py_None) return -1; + + return 0; // normal exit +} + +//*************************************************************************** +// Function: Lattice_repr +// Description: This is a callback function for the BPy_Lattice type. It +// builds a meaninful string to represent Lattice objects. +//*************************************************************************** +static PyObject *Lattice_repr (BPy_Lattice *self) +{ + if (self->Lattice && Lattice_InLatList(self)) + return PyString_FromFormat("[Lattice \"%s\"]", self->Lattice->id.name+2); + else + return PyString_FromString("[Lattice <deleted>]"); +} + +//*************************************************************************** +// Function: Internal Lattice functions +//*************************************************************************** +// Internal function to confirm if a Lattice wasn't unlinked from main. +static int Lattice_InLatList(BPy_Lattice *self) +{ + Lattice *lat_iter = G.main->latt.first; + + while (lat_iter) { + if (self->Lattice == lat_iter) return 1; // ok, still linked + + lat_iter = lat_iter->id.next; + } + // uh-oh, it was already deleted + self->Lattice = NULL; // so we invalidate the pointer + return 0; +} + +// Internal function to confirm if a Lattice has an object it's linked to. +static int Lattice_IsLinkedToObject(BPy_Lattice *self) +{ + //check to see if lattice is linked to an object + Object * ob= G.main->object.first; + while(ob) { + if(ob->type==OB_LATTICE){ + if(self->Lattice == ob->data){ + return 1; + } + } + ob = ob->id.next; + } + return 0; +}
\ No newline at end of file diff --git a/source/blender/python/api2_2x/Lattice.h b/source/blender/python/api2_2x/Lattice.h new file mode 100644 index 00000000000..8b733f1c199 --- /dev/null +++ b/source/blender/python/api2_2x/Lattice.h @@ -0,0 +1,220 @@ +/* + * + * ***** 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): Joseph Gilbert + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** +*/ + +#ifndef EXPP_Lattice_H +#define EXPP_Lattice_H + +#include <Python.h> +#include <BKE_main.h> +#include <BKE_global.h> +#include <BKE_library.h> +#include <BKE_lattice.h> +#include <BKE_utildefines.h> +#include <BKE_key.h> +#include <BLI_blenlib.h> +#include <DNA_lattice_types.h> +#include <DNA_key_types.h> +#include <BIF_editlattice.h> +#include <BIF_editkey.h> +#include "blendef.h" +#include "mydevice.h" +#include "constant.h" +#include "gen_utils.h" +#include "modules.h" + +/*****************************************************************************/ +/* Python API function prototypes for the Lattice module. */ +/*****************************************************************************/ +static PyObject *M_Lattice_New (PyObject *self, PyObject *args); +static PyObject *M_Lattice_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.Lattice.__doc__ Lattice Module strings */ +/*****************************************************************************/ +static char M_Lattice_doc[] = +"The Blender Lattice module\n\n"; + +static char M_Lattice_New_doc[] = +"() - return a new Lattice object"; + +static char M_Lattice_Get_doc[] = +"() - geta a Lattice from blender"; + +/*****************************************************************************/ +/* Python method structure definition for Blender.Lattice module: */ +/*****************************************************************************/ +struct PyMethodDef M_Lattice_methods[] = { + {"New",(PyCFunction)M_Lattice_New, METH_VARARGS, + M_Lattice_New_doc}, + {"Get",(PyCFunction)M_Lattice_Get, METH_VARARGS, + M_Lattice_Get_doc}, + {NULL, NULL, 0, NULL} +}; + +/*****************************************************************************/ +/* Python BPy_Lattice structure definition: */ +/*****************************************************************************/ +typedef struct { + PyObject_HEAD + Lattice *Lattice; +} BPy_Lattice; + +/*****************************************************************************/ +/* Python BPy_Lattice methods declarations: */ +/*****************************************************************************/ +static PyObject *Lattice_getName(BPy_Lattice *self); +static PyObject *Lattice_setName(BPy_Lattice *self, PyObject *args); +static PyObject *Lattice_setPartitions(BPy_Lattice *self, PyObject *args); +static PyObject *Lattice_getPartitions(BPy_Lattice *self, PyObject *args); +static PyObject *Lattice_setKeyTypes(BPy_Lattice *self, PyObject *args); +static PyObject *Lattice_getKeyTypes(BPy_Lattice *self, PyObject *args); +static PyObject *Lattice_setMode(BPy_Lattice *self, PyObject *args); +static PyObject *Lattice_getMode(BPy_Lattice *self, PyObject *args); +static PyObject *Lattice_setPoint(BPy_Lattice *self, PyObject *args); +static PyObject *Lattice_getPoint(BPy_Lattice *self, PyObject *args); +static PyObject *Lattice_applyDeform(BPy_Lattice *self); +static PyObject *Lattice_insertKey(BPy_Lattice *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.Lattice.__doc__ Lattice Strings */ +/*****************************************************************************/ +static char Lattice_getName_doc[] = +"() - Return Lattice Object name"; + +static char Lattice_setName_doc[] = +"(str) - Change Lattice Object name"; + +static char Lattice_setPartitions_doc[] = +"(str) - Set the number of Partitions in x,y,z"; + +static char Lattice_getPartitions_doc[] = +"(str) - Get the number of Partitions in x,y,z"; + +static char Lattice_setKeyTypes_doc[] = +"(str) - Set the key types for x,y,z dimensions"; + +static char Lattice_getKeyTypes_doc[] = +"(str) - Get the key types for x,y,z dimensions"; + +static char Lattice_setMode_doc[] = +"(str) - Make an outside or grid lattice"; + +static char Lattice_getMode_doc[] = +"(str) - Get lattice mode type"; + +static char Lattice_setPoint_doc[] = +"(str) - Set the coordinates of a point on the lattice"; + +static char Lattice_getPoint_doc[] = +"(str) - Get the coordinates of a point on the lattice"; + +static char Lattice_applyDeform_doc[] = +"(str) - Apply the new lattice deformation to children"; + +static char Lattice_insertKey_doc[] = +"(str) - Set a new key for the lattice at specified frame"; + +/*****************************************************************************/ +/* Python BPy_Lattice methods table: */ +/*****************************************************************************/ +static PyMethodDef BPy_Lattice_methods[] = { + /* name, method, flags, doc */ + {"getName", (PyCFunction)Lattice_getName, METH_NOARGS, + Lattice_getName_doc}, + {"setName", (PyCFunction)Lattice_setName, METH_VARARGS, + Lattice_setName_doc}, + {"setPartitions", (PyCFunction)Lattice_setPartitions, METH_VARARGS, + Lattice_setPartitions_doc}, + {"getPartitions", (PyCFunction)Lattice_getPartitions, METH_NOARGS, + Lattice_getPartitions_doc}, + {"setKeyTypes", (PyCFunction)Lattice_setKeyTypes, METH_VARARGS, + Lattice_setKeyTypes_doc}, + {"getKeyTypes", (PyCFunction)Lattice_getKeyTypes, METH_NOARGS, + Lattice_getKeyTypes_doc}, + {"setMode", (PyCFunction)Lattice_setMode, METH_VARARGS, + Lattice_setMode_doc}, + {"getMode", (PyCFunction)Lattice_getMode, METH_NOARGS, + Lattice_getMode_doc}, + {"setPoint", (PyCFunction)Lattice_setPoint, METH_VARARGS, + Lattice_setPoint_doc}, + {"getPoint", (PyCFunction)Lattice_getPoint, METH_VARARGS, + Lattice_getPoint_doc}, + {"applyDeform", (PyCFunction)Lattice_applyDeform, METH_NOARGS, + Lattice_applyDeform_doc}, + {"insertKey", (PyCFunction)Lattice_insertKey, METH_VARARGS, + Lattice_insertKey_doc}, + {0} +}; + +/*****************************************************************************/ +/* Python Lattice_Type callback function prototypes: */ +/*****************************************************************************/ +static void Lattice_dealloc (BPy_Lattice *self); +static int Lattice_setAttr (BPy_Lattice *self, char *name, PyObject *v); +static PyObject *Lattice_getAttr (BPy_Lattice *self, char *name); +static PyObject *Lattice_repr (BPy_Lattice *self); + +/*****************************************************************************/ +/* Python Lattice_Type structure definition: */ +/*****************************************************************************/ +PyTypeObject Lattice_Type = +{ + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + "Blender Lattice", /* tp_name */ + sizeof (BPy_Lattice), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)Lattice_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc)Lattice_getAttr, /* tp_getattr */ + (setattrfunc)Lattice_setAttr, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc)Lattice_repr, /* 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, + BPy_Lattice_methods, /* tp_methods */ + 0, /* tp_members */ +}; + +static int Lattice_InLatList(BPy_Lattice *self); +static int Lattice_IsLinkedToObject(BPy_Lattice *self); + +#endif /* EXPP_LATTICE_H */ diff --git a/source/blender/python/api2_2x/Object.c b/source/blender/python/api2_2x/Object.c index 5500abadf38..d8e0185baed 100644 --- a/source/blender/python/api2_2x/Object.c +++ b/source/blender/python/api2_2x/Object.c @@ -268,7 +268,7 @@ PyObject *M_Object_New(PyObject *self, PyObject *args) /* else if (strcmp (str_type, "Text") == 0) type = OB_FONT; */ /* else if (strcmp (str_type, "Ika") == 0) type = OB_IKA; */ else if (strcmp (str_type, "Lamp") == 0) type = OB_LAMP; -// else if (strcmp (str_type, "Lattice") == 0) type = OB_LATTICE; + else if (strcmp (str_type, "Lattice") == 0) type = OB_LATTICE; /* else if (strcmp (str_type, "Mball") == 0) type = OB_MBALL; */ else if (strcmp (str_type, "Mesh") == 0) type = OB_MESH; /* else if (strcmp (str_type, "Surf") == 0) type = OB_SURF; */ @@ -586,10 +586,10 @@ int EXPP_add_obdata(struct Object *object) object->data = add_mesh(); G.totmesh++; break; -/* case OB_LATTICE: + case OB_LATTICE: object->data = (void *)add_lattice(); object->dt = OB_WIRE; - break;*/ + break; /* TODO the following types will be supported later case OB_SURF: @@ -657,7 +657,7 @@ static PyObject *Object_getData (BPy_Object *self) data_object = Lamp_CreatePyObject (object->data); break; case OB_LATTICE: -// data_object = Lattice_CreatePyObject (object->data); + data_object = Lattice_CreatePyObject (object->data); break; case ID_MA: break; @@ -935,8 +935,8 @@ static PyObject *Object_link (BPy_Object *self, PyObject *args) data = (void *)Curve_FromPyObject (py_data); if (NMesh_CheckPyObject (py_data)) data = (void *)Mesh_FromPyObject (py_data, self->object); - //if (Lattice_CheckPyObject (py_data)) - // data = (void *)Lattice_FromPyObject (py_data); + if (Lattice_CheckPyObject (py_data)) + data = (void *)Lattice_FromPyObject (py_data); /* have we set data to something good? */ if( !data ) @@ -979,13 +979,13 @@ static PyObject *Object_link (BPy_Object *self, PyObject *args) "The 'link' object is incompatible with the base object")); } break; - /*case ID_LT: + case ID_LT: if (self->object->type != OB_LATTICE) { return (PythonReturnErrorObject (PyExc_AttributeError, "The 'link' object is incompatible with the base object")); } - break;*/ + break; default: return (PythonReturnErrorObject (PyExc_AttributeError, "Linking this object type is not supported")); @@ -1325,7 +1325,7 @@ static PyObject *Object_shareFrom (BPy_Object *self, PyObject *args) case OB_CAMERA: /* we can probably add the other types, too */ case OB_ARMATURE: case OB_CURVE: - //case OB_LATTICE: + case OB_LATTICE: oldid = (ID*) self->object->data; id = (ID*) object->object->data; self->object->data = object->object->data; diff --git a/source/blender/python/api2_2x/Types.c b/source/blender/python/api2_2x/Types.c index 5fc56c3248f..843a5ca79e4 100644 --- a/source/blender/python/api2_2x/Types.c +++ b/source/blender/python/api2_2x/Types.c @@ -85,6 +85,8 @@ PyObject *Types_Init (void) PyDict_SetItemString(dict, "ButtonType", (PyObject *)&Button_Type); + PyDict_SetItemString(dict, "LatticeType", (PyObject *)&Lattice_Type); + /* External helper Types available to the main ones above */ PyDict_SetItemString(dict, "vectorType", (PyObject *)&vector_Type); diff --git a/source/blender/python/api2_2x/Types.h b/source/blender/python/api2_2x/Types.h index ced99ceecd3..92ca131b8e0 100644 --- a/source/blender/python/api2_2x/Types.h +++ b/source/blender/python/api2_2x/Types.h @@ -42,6 +42,7 @@ extern PyTypeObject NMesh_Type, NMFace_Type, NMVert_Type, NMCol_Type; extern PyTypeObject Camera_Type, Lamp_Type, Image_Type, Text_Type; extern PyTypeObject Armature_Type, Bone_Type; extern PyTypeObject Curve_Type, Ipo_Type, Metaball_Type; +extern PyTypeObject Lattice_Type; extern PyTypeObject vector_Type, buffer_Type, rgbTuple_Type, constant_Type; diff --git a/source/blender/python/api2_2x/modules.h b/source/blender/python/api2_2x/modules.h index 328a47eff52..2a5e67494d3 100644 --- a/source/blender/python/api2_2x/modules.h +++ b/source/blender/python/api2_2x/modules.h @@ -39,6 +39,7 @@ #include <DNA_mesh_types.h> #include <DNA_camera_types.h> #include <DNA_lamp_types.h> +#include <DNA_lattice_types.h> #include <DNA_curve_types.h> #include <DNA_armature_types.h> #include <DNA_ipo_types.h> @@ -170,6 +171,12 @@ int World_CheckPyObject (PyObject *py_obj); World * World_FromPyObject (PyObject *py_obj); World * GetWorldByName (char * name); +/* Lattice */ +PyObject * Lattice_Init (void); +PyObject * Lattice_CreatePyObject (Lattice *lt); +Lattice * Lattice_FromPyObject (PyObject *pyobj); +int Lattice_CheckPyObject (PyObject *pyobj); + /* Init functions for other modules */ PyObject * Window_Init (void); PyObject * Draw_Init (void); |