728 lines
20 KiB
C
728 lines
20 KiB
C
/*
|
|
*
|
|
* ***** 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; unused
|
|
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 = -1, oldfra = -1;
|
|
|
|
if (!PyArg_ParseTuple(args, "i", &frame))
|
|
return (EXPP_ReturnPyObjError (PyExc_TypeError,
|
|
"expected int argument"));
|
|
|
|
lt = self->Lattice;
|
|
|
|
//set the current frame
|
|
if (frame > 0) {
|
|
frame = EXPP_ClampInt (frame, 1, 18000);
|
|
oldfra = G.scene->r.cfra;
|
|
G.scene->r.cfra = frame;
|
|
}
|
|
// else just use current frame, then
|
|
// return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
// "frame value has to be greater than 0"));
|
|
|
|
//insert a keybock for the lattice
|
|
insert_lattkey(lt);
|
|
|
|
if (frame > 0) G.scene->r.cfra = oldfra;
|
|
|
|
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;
|
|
}
|