diff options
Diffstat (limited to 'intern/python/py_main.c')
| -rw-r--r-- | intern/python/py_main.c | 2292 |
1 files changed, 2292 insertions, 0 deletions
diff --git a/intern/python/py_main.c b/intern/python/py_main.c new file mode 100644 index 00000000000..308ab0266ff --- /dev/null +++ b/intern/python/py_main.c @@ -0,0 +1,2292 @@ +/** + * $Id$ + * ***** 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. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +/* CVS */ + +/* $Author$ */ +/* $Date$ */ +/* $RCSfile$ */ +/* $Revision$ */ + +/* Jan Walter's stuff */ +#include "Python.h" +#include "blender.h" + +static PyObject* ErrorObject; + +uint* mcol_to_vcol(Mesh *me); +void mcol_to_rgb(uint col, float *r, float *g, float *b); +void initBlender(); +static PyObject* blend_connect(PyObject* self, PyObject* args); +static PyObject* blend_getObject(PyObject* self, PyObject* args); +/* Jan Walter's stuff */ + +/* Daniel Dunbar's stuff */ +void start_python (void); +void end_python(void); +void txt_do_python (Text* text); +void do_all_scripts(short event); +void do_all_scriptlist(ListBase* list, short event); +void do_pyscript(ID *id, short event); +void clear_bad_scriptlink(ID* id, Text* byebye); +void clear_bad_scriptlinks(Text *byebye); +void free_scriptlink(ScriptLink *slink); +void copy_scriptlink(ScriptLink *scriptlink); + +void start_python (void) +{ + Py_SetProgramName("blender"); + Py_Initialize(); + initBlender(); +} + +void end_python(void) +{ + Py_Finalize(); +} + +void txt_do_python (Text* text) +{ + char filename[] = "test.py"; + FILE* fp = NULL; + + if (text->name) + { + fp = fopen(text->name, "r"); + } + else + { + fp = fopen(filename, "r"); + } + if (fp) + { + if (text->name) + { + PyRun_AnyFile(fp, text->name); + } + else + { + PyRun_AnyFile(fp, filename); + } + } + else + { + if (text->name) + { + printf("Couldn't run %s ...\n", text->name); + } + else + { + printf("Couldn't run test.py ...\n"); + } + } +} + +void do_all_scripts(short event) +{ +} + +void do_all_scriptlist(ListBase* list, short event) +{ +} + +void do_pyscript(ID *id, short event) +{ +} + +void clear_bad_scriptlink(ID* id, Text* byebye) +{ +} + +void clear_bad_scriptlinks(Text *byebye) +{ +} + +void free_scriptlink(ScriptLink *slink) +{ +} + +void copy_scriptlink(ScriptLink *scriptlink) +{ +} +/* Daniel Dunbar's stuff */ + +ID* find_name_in_list(ID* list, const char* name) +{ + while (list) + { + if (STREQ(name, list->name+2)) + { + break; + } + else + { + list = list->next; + } + } + + return list; +} + +/* Jan Walter's stuff */ +/**************/ +/* structures */ +/**************/ + +typedef struct { + PyObject_HEAD + char name[24]; + PyObject* Lens; + PyObject* ClSta; + PyObject* ClEnd; +} camobject; + +staticforward PyTypeObject Camtype; + +typedef struct { + PyObject_HEAD + PyObject* startFrame; + PyObject* endFrame; + PyObject* currentFrame; + PyObject* xResolution; + PyObject* yResolution; + PyObject* pixelAspectRatio; +} dspobject; + +staticforward PyTypeObject Dsptype; + +typedef struct { + PyObject_HEAD + char name[24]; + PyObject* R; + PyObject* G; + PyObject* B; +} lmpobject; + +staticforward PyTypeObject Lmptype; + +typedef struct { + PyObject_HEAD + char name[24]; + PyObject* R; + PyObject* G; + PyObject* B; +} matobject; + +staticforward PyTypeObject Mattype; + +typedef struct { + PyObject_HEAD + char name[24]; + PyObject* vertices; + PyObject* normals; + PyObject* colors; + PyObject* faces; + PyObject* texture; + PyObject* texcoords; +} mshobject; + +staticforward PyTypeObject Mshtype; + +typedef struct { + PyObject_HEAD + char name[24]; + PyObject* matrix; + PyObject* inverseMatrix; + PyObject* materials; + PyObject* data; + PyObject* type; +} objobject; + +staticforward PyTypeObject Objtype; + +typedef struct { + PyObject_HEAD + char name[24]; + PyObject* objects; +} sceobject; + +staticforward PyTypeObject Scetype; + +/**********/ +/* camera */ +/**********/ + +static struct PyMethodDef cam_methods[] = { + { NULL, NULL } +}; + +static camobject* +newcamobject(char* name) +{ + camobject* self; + ID* list = NULL; + + self = PyObject_NEW(camobject, &Camtype); + if (self == NULL) + { + return NULL; + } + strcpy(self->name, name); + self->Lens = PyFloat_FromDouble(35.0); + self->ClSta = PyFloat_FromDouble(0.1); + self->ClEnd = PyFloat_FromDouble(100.0); + + return self; +} + +static void +cam_dealloc(camobject* self) +{ + camobject* cam = (camobject*) self; + + Py_DECREF(cam->Lens); + Py_DECREF(cam->ClSta); + Py_DECREF(cam->ClEnd); + + PyMem_DEL(self); +} + +static int +cam_print(camobject* self, FILE* fp, int flags) +{ + fprintf(fp, "Camera(name = \"%s\")\n", self->name); + + return 0; +} + +static PyObject* +cam_repr(camobject* self) +{ + PyObject* s; + + s = PyString_FromString("Camera()\n"); + + return s; +} + +static PyObject* +cam_str(camobject* self) +{ + PyObject* s; + + s = PyString_FromString("Camera()\n"); + + return s; +} + +#include "structmember.h" + +static struct memberlist cam_memberlist[] = { + /* XXXX Add lines like { "foo", T_INT, OFF(foo), RO } */ + {"Lens", T_OBJECT, offsetof(camobject, Lens), RO}, + {"ClSta", T_OBJECT, offsetof(camobject, ClSta), RO}, + {"ClEnd", T_OBJECT, offsetof(camobject, ClEnd), RO}, + {NULL} +}; + +static PyObject* +cam_getattr(camobject* self, char* name) +{ + PyObject* rv; + + /* XXXX Add your own getattr code here */ + rv = PyMember_Get((char*) self, cam_memberlist, name); + if (rv) + { + return rv; + } + PyErr_Clear(); + + return Py_FindMethod(cam_methods, (PyObject*)self, name); +} + + +static int +cam_setattr(camobject* self, char* name, PyObject* v) +{ + /* XXXX Add your own setattr code here */ + if ( v == NULL ) + { + PyErr_SetString(PyExc_AttributeError, "Cannot delete attribute"); + return -1; + } + + return PyMember_Set((char*)/*XXXX*/0, cam_memberlist, name, v); +} + +static char Camtype__doc__[] = +"" +; + +static PyTypeObject Camtype = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "Camera", /*tp_name*/ + sizeof(camobject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) cam_dealloc, /*tp_dealloc*/ + (printfunc) cam_print, /*tp_print*/ + (getattrfunc) cam_getattr, /*tp_getattr*/ + (setattrfunc) cam_setattr, /*tp_setattr*/ + (cmpfunc) 0, /*tp_compare*/ + (reprfunc) cam_repr, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + (hashfunc) 0, /*tp_hash*/ + (ternaryfunc) 0, /*tp_call*/ + (reprfunc) cam_str, /*tp_str*/ + + /* Space for future expansion */ + 0L,0L,0L,0L, + Camtype__doc__ /* Documentation string */ +}; + +/********************/ +/* display settings */ +/********************/ + +static struct PyMethodDef dsp_methods[] = { + { NULL, NULL } +}; + +static dspobject* +newdspobject(void) +{ + dspobject* self; + ID* list = NULL; + + self = PyObject_NEW(dspobject, &Dsptype); + if (self == NULL) + { + return NULL; + } + self->startFrame = PyInt_FromLong(1); + self->endFrame = PyInt_FromLong(250); + self->currentFrame = PyInt_FromLong(1); + self->xResolution = PyInt_FromLong(320); + self->yResolution = PyInt_FromLong(256); + self->pixelAspectRatio = PyFloat_FromDouble(1.0); + + return self; +} + +static void +dsp_dealloc(dspobject* self) +{ + dspobject* dsp = (dspobject*) self; + + Py_DECREF(dsp->startFrame); + Py_DECREF(dsp->endFrame); + Py_DECREF(dsp->currentFrame); + Py_DECREF(dsp->xResolution); + Py_DECREF(dsp->yResolution); + Py_DECREF(dsp->pixelAspectRatio); + + PyMem_DEL(self); +} + +static int +dsp_print(dspobject* self, FILE* fp, int flags) +{ + fprintf(fp, "DisplaySettings()\n"); + + return 0; +} + +static PyObject* +dsp_repr(dspobject* self) +{ + PyObject* s; + + s = PyString_FromString("DisplaySettings()()\n"); + + return s; +} + +static PyObject* +dsp_str(dspobject* self) +{ + PyObject* s; + + s = PyString_FromString("DisplaySettings()()\n"); + + return s; +} + +#include "structmember.h" + +static struct memberlist dsp_memberlist[] = { + /* XXXX Add lines like { "foo", T_INT, OFF(foo), RO } */ + {"startFrame", T_OBJECT, offsetof(dspobject, startFrame), RO}, + {"endFrame", T_OBJECT, offsetof(dspobject, endFrame), RO}, + {"currentFrame", T_OBJECT, offsetof(dspobject, currentFrame), RO}, + {"xResolution", T_OBJECT, offsetof(dspobject, xResolution), RO}, + {"yResolution", T_OBJECT, offsetof(dspobject, yResolution), RO}, + {"pixelAspectRatio", T_OBJECT, offsetof(dspobject, pixelAspectRatio), RO}, + {NULL} +}; + +static PyObject* +dsp_getattr(dspobject* self, char* name) +{ + PyObject* rv; + + /* XXXX Add your own getattr code here */ + rv = PyMember_Get((char*) self, dsp_memberlist, name); + if (rv) + { + return rv; + } + PyErr_Clear(); + + return Py_FindMethod(dsp_methods, (PyObject*)self, name); +} + + +static int +dsp_setattr(dspobject* self, char* name, PyObject* v) +{ + /* XXXX Add your own setattr code here */ + if ( v == NULL ) + { + PyErr_SetString(PyExc_AttributeError, "Cannot delete attribute"); + return -1; + } + + return PyMember_Set((char*)/*XXXX*/0, dsp_memberlist, name, v); +} + +static char Dsptype__doc__[] = +"" +; + +static PyTypeObject Dsptype = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "DisplaySettings", /*tp_name*/ + sizeof(dspobject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) dsp_dealloc, /*tp_dealloc*/ + (printfunc) dsp_print, /*tp_print*/ + (getattrfunc) dsp_getattr, /*tp_getattr*/ + (setattrfunc) dsp_setattr, /*tp_setattr*/ + (cmpfunc) 0, /*tp_compare*/ + (reprfunc) dsp_repr, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + (hashfunc) 0, /*tp_hash*/ + (ternaryfunc) 0, /*tp_call*/ + (reprfunc) dsp_str, /*tp_str*/ + + /* Space for future expansion */ + 0L,0L,0L,0L, + Dsptype__doc__ /* Documentation string */ +}; + +/********/ +/* Lamp */ +/********/ + +static struct PyMethodDef lmp_methods[] = { + { NULL, NULL } +}; + +static lmpobject* +newlmpobject(char* name) +{ + lmpobject* self; + ID* list = NULL; + + self = PyObject_NEW(lmpobject, &Lmptype); + if (self == NULL) + { + return NULL; + } + strcpy(self->name, name); + self->R = PyFloat_FromDouble(0.8); + self->G = PyFloat_FromDouble(0.8); + self->B = PyFloat_FromDouble(0.8); + + return self; +} + +static void +lmp_dealloc(lmpobject* self) +{ + lmpobject* lmp = (lmpobject*) self; + + Py_DECREF(lmp->R); + Py_DECREF(lmp->G); + Py_DECREF(lmp->B); + + PyMem_DEL(self); +} + +static int +lmp_print(lmpobject* self, FILE* fp, int flags) +{ + fprintf(fp, "Lamp(name = \"%s\")\n", self->name); + + return 0; +} + +static PyObject* +lmp_repr(lmpobject* self) +{ + PyObject* s; + + s = PyString_FromString("Lamp()\n"); + + return s; +} + +static PyObject* +lmp_str(lmpobject* self) +{ + PyObject* s; + + s = PyString_FromString("Lamp()\n"); + + return s; +} + +#include "structmember.h" + +static struct memberlist lmp_memberlist[] = { + /* XXXX Add lines like { "foo", T_INT, OFF(foo), RO } */ + {"R", T_OBJECT, offsetof(lmpobject, R), RO}, + {"G", T_OBJECT, offsetof(lmpobject, G), RO}, + {"B", T_OBJECT, offsetof(lmpobject, B), RO}, + {NULL} +}; + +static PyObject* +lmp_getattr(lmpobject* self, char* name) +{ + PyObject* rv; + + /* XXXX Add your own getattr code here */ + rv = PyMember_Get((char*) self, lmp_memberlist, name); + if (rv) + { + return rv; + } + PyErr_Clear(); + + return Py_FindMethod(lmp_methods, (PyObject*)self, name); +} + + +static int +lmp_setattr(lmpobject* self, char* name, PyObject* v) +{ + /* XXXX Add your own setattr code here */ + if ( v == NULL ) + { + PyErr_SetString(PyExc_AttributeError, "Cannot delete attribute"); + return -1; + } + + return PyMember_Set((char*)/*XXXX*/0, lmp_memberlist, name, v); +} + +static char Lmptype__doc__[] = +"" +; + +static PyTypeObject Lmptype = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "Lamp", /*tp_name*/ + sizeof(lmpobject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) lmp_dealloc, /*tp_dealloc*/ + (printfunc) lmp_print, /*tp_print*/ + (getattrfunc) lmp_getattr, /*tp_getattr*/ + (setattrfunc) lmp_setattr, /*tp_setattr*/ + (cmpfunc) 0, /*tp_compare*/ + (reprfunc) lmp_repr, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + (hashfunc) 0, /*tp_hash*/ + (ternaryfunc) 0, /*tp_call*/ + (reprfunc) lmp_str, /*tp_str*/ + + /* Space for future expansion */ + 0L,0L,0L,0L, + Lmptype__doc__ /* Documentation string */ +}; + +/************/ +/* material */ +/************/ + +static struct PyMethodDef mat_methods[] = { + { NULL, NULL } +}; + +static matobject* +newmatobject(char* name) +{ + matobject* self; + ID* list = NULL; + + self = PyObject_NEW(matobject, &Mattype); + if (self == NULL) + { + return NULL; + } + strcpy(self->name, name); + self->R = PyFloat_FromDouble(0.8); + self->G = PyFloat_FromDouble(0.8); + self->B = PyFloat_FromDouble(0.8); + + return self; +} + +static void +mat_dealloc(matobject* self) +{ + matobject* mat = (matobject*) self; + + Py_DECREF(mat->R); + Py_DECREF(mat->G); + Py_DECREF(mat->B); + + PyMem_DEL(self); +} + +static int +mat_print(matobject* self, FILE* fp, int flags) +{ + fprintf(fp, "Material(name = \"%s\")\n", self->name); + + return 0; +} + +static PyObject* +mat_repr(matobject* self) +{ + PyObject* s; + + s = PyString_FromString("Material()\n"); + + return s; +} + +static PyObject* +mat_str(matobject* self) +{ + PyObject* s; + + s = PyString_FromString("Material()\n"); + + return s; +} + +#include "structmember.h" + +static struct memberlist mat_memberlist[] = { + /* XXXX Add lines like { "foo", T_INT, OFF(foo), RO } */ + {"R", T_OBJECT, offsetof(matobject, R), RO}, + {"G", T_OBJECT, offsetof(matobject, G), RO}, + {"B", T_OBJECT, offsetof(matobject, B), RO}, + {NULL} +}; + +static PyObject* +mat_getattr(matobject* self, char* name) +{ + PyObject* rv; + + /* XXXX Add your own getattr code here */ + rv = PyMember_Get((char*) self, mat_memberlist, name); + if (rv) + { + return rv; + } + PyErr_Clear(); + + return Py_FindMethod(mat_methods, (PyObject*)self, name); +} + + +static int +mat_setattr(matobject* self, char* name, PyObject* v) +{ + /* XXXX Add your own setattr code here */ + if ( v == NULL ) + { + PyErr_SetString(PyExc_AttributeError, "Cannot delete attribute"); + return -1; + } + + return PyMember_Set((char*)/*XXXX*/0, mat_memberlist, name, v); +} + +static char Mattype__doc__[] = +"" +; + +static PyTypeObject Mattype = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "Material", /*tp_name*/ + sizeof(matobject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) mat_dealloc, /*tp_dealloc*/ + (printfunc) mat_print, /*tp_print*/ + (getattrfunc) mat_getattr, /*tp_getattr*/ + (setattrfunc) mat_setattr, /*tp_setattr*/ + (cmpfunc) 0, /*tp_compare*/ + (reprfunc) mat_repr, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + (hashfunc) 0, /*tp_hash*/ + (ternaryfunc) 0, /*tp_call*/ + (reprfunc) mat_str, /*tp_str*/ + + /* Space for future expansion */ + 0L,0L,0L,0L, + Mattype__doc__ /* Documentation string */ +}; + +/********/ +/* mesh */ +/********/ + +static char msh_addFace__doc__[] = +"addFace(self, i1, i2, i3, i4, isSmooth, matIndex)" +; + +static PyObject* +msh_addFace(mshobject* self, PyObject* args) +{ + int index; + int i1, i2, i3, i4; + int isSmooth, matIndex; + PyObject* item = NULL; + + if (!PyArg_ParseTuple(args, "iiiiii", &i1, &i2, &i3, &i4, + &isSmooth, &matIndex)) + { + return NULL; + } + item = PyList_New(6); + PyList_SetItem(item, 0, PyInt_FromLong(i1)); + PyList_SetItem(item, 1, PyInt_FromLong(i2)); + PyList_SetItem(item, 2, PyInt_FromLong(i3)); + PyList_SetItem(item, 3, PyInt_FromLong(i4)); + PyList_SetItem(item, 4, PyInt_FromLong(isSmooth)); + PyList_SetItem(item, 5, PyInt_FromLong(matIndex)); + PyList_Append(self->faces, item); + index = PyList_Size(self->faces) - 1; + + return PyInt_FromLong(index); +} + +static char msh_addTexCoords__doc__[] = +"addTexCoords(self, coords)" +; + +static PyObject* +msh_addTexCoords(mshobject* self, PyObject* args) +{ + float u, v; + PyObject* item = NULL; + + if (!PyArg_ParseTuple(args, "ff", + &u, &v)) + { + return NULL; + } + if (u < 0.0) + { + u = 0.0; + } + if (u > 1.0) + { + u = 1.0; + } + if (v < 0.0) + { + v = 0.0; + } + if (v > 1.0) + { + v = 1.0; + } + item = PyList_New(2); + PyList_SetItem(item, 0, PyFloat_FromDouble(u)); + PyList_SetItem(item, 1, PyFloat_FromDouble(v)); + PyList_Append(self->texcoords, item); + + Py_INCREF(Py_None); + return Py_None; +} + +static char msh_addTexture__doc__[] = +"addTexture(self, filename)" +; + +static PyObject* +msh_addTexture(mshobject* self, PyObject* args) +{ + char* filename = NULL; + + if (!PyArg_ParseTuple(args, "s", &filename)) + { + return NULL; + } + self->texture = PyString_FromString(filename); + + Py_INCREF(Py_None); + return Py_None; +} + +static char msh_addVertex__doc__[] = +"addVertex(self, x, y, z, nx, ny, nz, r = -1.0, g = 0.0, b = 0.0)" +; + +static PyObject* +msh_addVertex(mshobject* self, PyObject* args) +{ + int index; + float x, y, z, nx, ny, nz; + float r = -1.0, g = 0.0, b = 0.0; + PyObject* item1 = NULL; + PyObject* item2 = NULL; + PyObject* item3 = NULL; + + if (!PyArg_ParseTuple(args, "ffffff|fff", &x, &y, &z, &nx, &ny, &nz, + &r, &g, &b)) + { + return NULL; + } + item1 = PyList_New(3); + item2 = PyList_New(3); + if (r != -1.0) + { + item3 = PyList_New(3); + } + PyList_SetItem(item1, 0, PyFloat_FromDouble(x)); + PyList_SetItem(item1, 1, PyFloat_FromDouble(y)); + PyList_SetItem(item1, 2, PyFloat_FromDouble(z)); + PyList_SetItem(item2, 0, PyFloat_FromDouble(nx)); + PyList_SetItem(item2, 1, PyFloat_FromDouble(ny)); + PyList_SetItem(item2, 2, PyFloat_FromDouble(nz)); + if (r != -1.0) + { + PyList_SetItem(item3, 0, PyFloat_FromDouble(r)); + PyList_SetItem(item3, 1, PyFloat_FromDouble(g)); + PyList_SetItem(item3, 2, PyFloat_FromDouble(b)); + } + PyList_Append(self->vertices, item1); + PyList_Append(self->normals, item2); + if (r != -1.0) + { + PyList_Append(self->colors, item3); + } + index = PyList_Size(self->vertices) - 1; + + return PyInt_FromLong(index); +} + +static struct PyMethodDef msh_methods[] = { + {"addFace", (PyCFunction)msh_addFace, + METH_VARARGS, msh_addFace__doc__}, + {"addTexCoords", (PyCFunction)msh_addTexCoords, + METH_VARARGS, msh_addTexCoords__doc__}, + {"addTexture", (PyCFunction)msh_addTexture, + METH_VARARGS, msh_addTexture__doc__}, + {"addVertex", (PyCFunction)msh_addVertex, + METH_VARARGS, msh_addVertex__doc__}, + + { NULL, NULL } +}; + +static mshobject* +newmshobject(char* name) +{ + mshobject* self; + ID* list = NULL; + + self = PyObject_NEW(mshobject, &Mshtype); + if (self == NULL) + { + return NULL; + } + strcpy(self->name, name); + self->vertices = PyList_New(0); + self->normals = PyList_New(0); + self->colors = PyList_New(0); + self->faces = PyList_New(0); + self->texcoords = PyList_New(0); + Py_INCREF(Py_None); + self->texture = Py_None; + + return self; +} + +static void +msh_dealloc(mshobject* self) +{ + mshobject* msh = (mshobject*) self; + + Py_DECREF(msh->vertices); + Py_DECREF(msh->normals); + Py_DECREF(msh->colors); + Py_DECREF(msh->faces); + Py_DECREF(msh->texture); + Py_DECREF(msh->texcoords); + + PyMem_DEL(self); +} + +static int +msh_print(mshobject* self, FILE* fp, int flags) +{ + fprintf(fp, "Mesh(name = \"%s\",\n", self->name); + fprintf(fp, " vertices = %d,\n", PyList_Size(self->vertices)); + fprintf(fp, " faces = %d)\n", PyList_Size(self->faces)); + + return 0; +} + +static PyObject* +msh_repr(mshobject* self) +{ + PyObject* s; + + s = PyString_FromString("Mesh()\n"); + + return s; +} + +static PyObject* +msh_str(mshobject* self) +{ + PyObject* s; + + s = PyString_FromString("Mesh()\n"); + + return s; +} + +#include "structmember.h" + +static struct memberlist msh_memberlist[] = { + /* XXXX Add lines like { "foo", T_INT, OFF(foo), RO } */ + {"vertices", T_OBJECT, offsetof(mshobject, vertices), RO}, + {"normals", T_OBJECT, offsetof(mshobject, normals), RO}, + {"colors", T_OBJECT, offsetof(mshobject, colors), RO}, + {"faces", T_OBJECT, offsetof(mshobject, faces), RO}, + {"texture", T_OBJECT, offsetof(mshobject, texture), RO}, + {"texcoords", T_OBJECT, offsetof(mshobject, texcoords), RO}, + {NULL} +}; + +static PyObject* +msh_getattr(mshobject* self, char* name) +{ + PyObject* rv; + + /* XXXX Add your own getattr code here */ + rv = PyMember_Get((char*) self, msh_memberlist, name); + if (rv) + { + return rv; + } + PyErr_Clear(); + + return Py_FindMethod(msh_methods, (PyObject*)self, name); +} + + +static int +msh_setattr(mshobject* self, char* name, PyObject* v) +{ + /* XXXX Add your own setattr code here */ + if ( v == NULL ) + { + PyErr_SetString(PyExc_AttributeError, "Cannot delete attribute"); + return -1; + } + + return PyMember_Set((char*)/*XXXX*/0, msh_memberlist, name, v); +} + +static char Mshtype__doc__[] = +"" +; + +static PyTypeObject Mshtype = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "Mesh", /*tp_name*/ + sizeof(mshobject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) msh_dealloc, /*tp_dealloc*/ + (printfunc) msh_print, /*tp_print*/ + (getattrfunc) msh_getattr, /*tp_getattr*/ + (setattrfunc) msh_setattr, /*tp_setattr*/ + (cmpfunc) 0, /*tp_compare*/ + (reprfunc) msh_repr, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + (hashfunc) 0, /*tp_hash*/ + (ternaryfunc) 0, /*tp_call*/ + (reprfunc) msh_str, /*tp_str*/ + + /* Space for future expansion */ + 0L,0L,0L,0L, + Mshtype__doc__ /* Documentation string */ +}; + +/**********/ +/* object */ +/**********/ + +static struct PyMethodDef obj_methods[] = { + + { NULL, NULL } +}; + +static objobject* +newobjobject(char* name) +{ + objobject* self = NULL; + PyObject* row1 = NULL; + PyObject* row2 = NULL; + PyObject* row3 = NULL; + PyObject* row4 = NULL; + + self = PyObject_NEW(objobject, &Objtype); + if (self == NULL) + { + return NULL; + } + strcpy(self->name, name); + self->matrix = PyList_New(4); + row1 = PyList_New(4); + row2 = PyList_New(4); + row3 = PyList_New(4); + row4 = PyList_New(4); + PyList_SetItem(row1, 0, PyInt_FromLong(1)); + PyList_SetItem(row1, 1, PyInt_FromLong(0)); + PyList_SetItem(row1, 2, PyInt_FromLong(0)); + PyList_SetItem(row1, 3, PyInt_FromLong(0)); + PyList_SetItem(row2, 0, PyInt_FromLong(0)); + PyList_SetItem(row2, 1, PyInt_FromLong(1)); + PyList_SetItem(row2, 2, PyInt_FromLong(0)); + PyList_SetItem(row2, 3, PyInt_FromLong(0)); + PyList_SetItem(row3, 0, PyInt_FromLong(0)); + PyList_SetItem(row3, 1, PyInt_FromLong(0)); + PyList_SetItem(row3, 2, PyInt_FromLong(1)); + PyList_SetItem(row3, 3, PyInt_FromLong(0)); + PyList_SetItem(row4, 0, PyInt_FromLong(0)); + PyList_SetItem(row4, 1, PyInt_FromLong(0)); + PyList_SetItem(row4, 2, PyInt_FromLong(0)); + PyList_SetItem(row4, 3, PyInt_FromLong(1)); + PyList_SetItem(self->matrix, 0, row1); + PyList_SetItem(self->matrix, 1, row2); + PyList_SetItem(self->matrix, 2, row3); + PyList_SetItem(self->matrix, 3, row4); + self->inverseMatrix = PyList_New(4); + row1 = PyList_New(4); + row2 = PyList_New(4); + row3 = PyList_New(4); + row4 = PyList_New(4); + PyList_SetItem(row1, 0, PyInt_FromLong(1)); + PyList_SetItem(row1, 1, PyInt_FromLong(0)); + PyList_SetItem(row1, 2, PyInt_FromLong(0)); + PyList_SetItem(row1, 3, PyInt_FromLong(0)); + PyList_SetItem(row2, 0, PyInt_FromLong(0)); + PyList_SetItem(row2, 1, PyInt_FromLong(1)); + PyList_SetItem(row2, 2, PyInt_FromLong(0)); + PyList_SetItem(row2, 3, PyInt_FromLong(0)); + PyList_SetItem(row3, 0, PyInt_FromLong(0)); + PyList_SetItem(row3, 1, PyInt_FromLong(0)); + PyList_SetItem(row3, 2, PyInt_FromLong(1)); + PyList_SetItem(row3, 3, PyInt_FromLong(0)); + PyList_SetItem(row4, 0, PyInt_FromLong(0)); + PyList_SetItem(row4, 1, PyInt_FromLong(0)); + PyList_SetItem(row4, 2, PyInt_FromLong(0)); + PyList_SetItem(row4, 3, PyInt_FromLong(1)); + PyList_SetItem(self->inverseMatrix, 0, row1); + PyList_SetItem(self->inverseMatrix, 1, row2); + PyList_SetItem(self->inverseMatrix, 2, row3); + PyList_SetItem(self->inverseMatrix, 3, row4); + self->materials = PyList_New(0); + Py_INCREF(Py_None); + self->data = Py_None; + Py_INCREF(Py_None); + self->type = Py_None; + + return self; +} + +static void +obj_dealloc(objobject* self) +{ + objobject* obj = (objobject*) self; + + Py_DECREF(obj->matrix); + Py_DECREF(obj->inverseMatrix); + Py_DECREF(obj->materials); + Py_DECREF(obj->data); + Py_DECREF(obj->type); + + PyMem_DEL(self); +} + +static int +obj_print(objobject* self, FILE* fp, int flags) +{ + fprintf(fp, "Object(name = \"%s\",\n", self->name); +/* fprintf(fp, " matrix = %s,\n", */ +/* PyString_AsString(mtx_repr((mtxobject*) self->matrix))); */ + if (self->type == Py_None) + { + fprintf(fp, " data = None)\n"); + } + else + { + fprintf(fp, " data = %s(\"%s\"))\n", + PyString_AsString(self->type), + PyString_AsString(self->data)); + } + + return 0; +} + +static PyObject* +obj_repr(objobject* self) +{ + PyObject* s; + + s = PyString_FromString("Object()\n"); + + return s; +} + +static PyObject* +obj_str(objobject* self) +{ + PyObject* s; + + s = PyString_FromString("Object()\n"); + + return s; +} + +#include "structmember.h" + +static struct memberlist obj_memberlist[] = { + /* XXXX Add lines like { "foo", T_INT, OFF(foo), RO } */ + {"data", T_OBJECT, offsetof(objobject, data), RO}, + {"matrix", T_OBJECT, offsetof(objobject, matrix), RO}, + {"inverseMatrix", T_OBJECT, offsetof(objobject, inverseMatrix), RO}, + {"materials", T_OBJECT, offsetof(objobject, materials), RO}, + {"type", T_OBJECT, offsetof(objobject, type), RO}, + {NULL} +}; + +static PyObject* +obj_getattr(objobject* self, char* name) +{ + PyObject* rv; + + /* XXXX Add your own getattr code here */ + rv = PyMember_Get((char*) self, obj_memberlist, name); + if (rv) + { + return rv; + } + PyErr_Clear(); + + return Py_FindMethod(obj_methods, (PyObject*)self, name); +} + + +static int +obj_setattr(objobject* self, char* name, PyObject* v) +{ + /* XXXX Add your own setattr code here */ + if ( v == NULL ) + { + PyErr_SetString(PyExc_AttributeError, "Cannot delete attribute"); + return -1; + } + + return PyMember_Set((char*)/*XXXX*/0, obj_memberlist, name, v); +} + +static char Objtype__doc__[] = +"" +; + +static PyTypeObject Objtype = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "Object", /*tp_name*/ + sizeof(objobject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) obj_dealloc, /*tp_dealloc*/ + (printfunc) obj_print, /*tp_print*/ + (getattrfunc) obj_getattr, /*tp_getattr*/ + (setattrfunc) obj_setattr, /*tp_setattr*/ + (cmpfunc) 0, /*tp_compare*/ + (reprfunc) obj_repr, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + (hashfunc) 0, /*tp_hash*/ + (ternaryfunc) 0, /*tp_call*/ + (reprfunc) obj_str, /*tp_str*/ + + /* Space for future expansion */ + 0L,0L,0L,0L, + Objtype__doc__ /* Documentation string */ +}; + +/*********/ +/* scene */ +/*********/ + +static char sce_addObject__doc__[] = +"addObject(self, object)" +; + +static PyObject* +sce_addObject(sceobject* self, PyObject* args) +{ + int index; + PyObject* object = NULL; + + if (!PyArg_ParseTuple(args, "O", &object)) + { + return NULL; + } + PyList_Append(self->objects, object); + index = PyList_Size(self->objects) - 1; + + return PyInt_FromLong(index); +} + +static char sce_getCurrentCamera__doc__[] = +"getCurrentCamera(self)" +; + +static PyObject* +sce_getCurrentCamera(sceobject* self, PyObject* args) +{ + char* name = NULL; + PyObject* camera = NULL; + + if (!PyArg_ParseTuple(args, "")) + { + return NULL; + } + if (G.scene->camera) + { + name = G.scene->camera->id.name+2; + camera = blend_getObject(NULL, + Py_BuildValue("(O)", + PyString_FromString(name))); + + return camera; + } + else + { + Py_INCREF(Py_None); + return Py_None; + } +} + +static struct PyMethodDef sce_methods[] = { + {"addObject", (PyCFunction)sce_addObject, + METH_VARARGS, sce_addObject__doc__}, + {"getCurrentCamera", (PyCFunction)sce_getCurrentCamera, + METH_VARARGS, sce_getCurrentCamera__doc__}, + + { NULL, NULL } +}; + +static sceobject* +newsceobject(char* name) +{ + sceobject* self; + + self = PyObject_NEW(sceobject, &Scetype); + if (self == NULL) + { + return NULL; + } + strcpy(self->name, name); + self->objects = PyList_New(0); + + return self; +} + +static void +sce_dealloc(sceobject* self) +{ + sceobject* sce = (sceobject*) self; + + Py_DECREF(sce->objects); + + PyMem_DEL(self); +} + +static int +sce_print(sceobject* self, FILE* fp, int flags) +{ + fprintf(fp, "Scene(name = \"%s\",\n", self->name); + fprintf(fp, " objects = %d)\n", PyList_Size(self->objects)); + + return 0; +} + +static PyObject* +sce_repr(sceobject* self) +{ + PyObject* s; + + s = PyString_FromString("Scene()\n"); + + return s; +} + +static PyObject* +sce_str(sceobject* self) +{ + PyObject* s; + + s = PyString_FromString("Scene()\n"); + + return s; +} + +#include "structmember.h" + +static struct memberlist sce_memberlist[] = { + /* XXXX Add lines like { "foo", T_INT, OFF(foo), RO } */ + {"objects", T_OBJECT, offsetof(sceobject, objects), RO}, + {NULL} +}; + +static PyObject* +sce_getattr(sceobject* self, char* name) +{ + PyObject* rv; + + /* XXXX Add your own getattr code here */ + rv = PyMember_Get((char*) self, sce_memberlist, name); + if (rv) + { + return rv; + } + PyErr_Clear(); + + return Py_FindMethod(sce_methods, (PyObject*)self, name); +} + + +static int +sce_setattr(sceobject* self, char* name, PyObject* v) +{ + /* XXXX Add your own setattr code here */ + if ( v == NULL ) + { + PyErr_SetString(PyExc_AttributeError, "Cannot delete attribute"); + return -1; + } + + return PyMember_Set((char*)/*XXXX*/0, sce_memberlist, name, v); +} + +static char Scetype__doc__[] = +"" +; + +static PyTypeObject Scetype = { + PyObject_HEAD_INIT(&PyType_Type) + 0, /*ob_size*/ + "Scene", /*tp_name*/ + sizeof(sceobject), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor) sce_dealloc, /*tp_dealloc*/ + (printfunc) sce_print, /*tp_print*/ + (getattrfunc) sce_getattr, /*tp_getattr*/ + (setattrfunc) sce_setattr, /*tp_setattr*/ + (cmpfunc) 0, /*tp_compare*/ + (reprfunc) sce_repr, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + (hashfunc) 0, /*tp_hash*/ + (ternaryfunc) 0, /*tp_call*/ + (reprfunc) sce_str, /*tp_str*/ + + /* Space for future expansion */ + 0L,0L,0L,0L, + Scetype__doc__ /* Documentation string */ +}; + +static char blend_Mesh__doc__[] = +"Creates an (empty) instance of a Blender mesh.\n\ + E.g.: \"m = Blender.Mesh('Plane')\"\n\ + To create faces first add vertices with \n\ + \"i1 = m.addVertex(x, y, z, nx, ny, nz, r = -1.0, r = 0.0, b = 0.0)\"\n\ + then create faces with \n\ + \"index = m.addFace(i1, i2, i3, i4, isSmooth, matIndex)\".\ +" +; + +static PyObject* +blend_Mesh(PyObject* self, PyObject* args) +{ + if (!PyArg_ParseTuple(args, "")) + { + return NULL; + } + + Py_INCREF(Py_None); + return Py_None; +} + +static char blend_Object__doc__[] = +"Creates an instance of a Blender object" +; + +static PyObject* +blend_Object(PyObject* self, PyObject* args) +{ + char* name = NULL; + + if (!PyArg_ParseTuple(args, "s", &name)) + { + return NULL; + } + + return ((PyObject*) newobjobject(name)); +} + +static char blend_Scene__doc__[] = +"Creates an instance of a Blender scene" +; + +static PyObject* +blend_Scene(PyObject* self, PyObject* args) +{ + char* name = NULL; + + if (!PyArg_ParseTuple(args, "s", &name)) + { + return NULL; + } + + return ((PyObject*) newsceobject(name)); +} + +static char blend_addMesh__doc__[] = +"Blender.addMesh(type, sceneName)\n\ + where type is one of [\"Plane\"]" +; + +static PyObject* +blend_addMesh(PyObject* self, PyObject* args) +{ + char* type = NULL; + char* sceneName = NULL; + PyObject* tuple = NULL; + PyObject* object = NULL; + PyObject* mesh = NULL; + PyObject* index = NULL; + PyObject* indices = NULL; + objobject* obj = NULL; + mshobject* msh = NULL; + + if (!PyArg_ParseTuple(args, "ss", &type, &sceneName)) + { + return NULL; + } + + if (strcmp(type, "Plane") == 0) + { + obj = newobjobject(type); + msh = newmshobject(type); + object = (PyObject*) obj; + mesh = (PyObject*) msh; + indices = PyList_New(6); + /* vertices */ + index = msh_addVertex((mshobject*) mesh, + Py_BuildValue("ffffff", + 1.0, 1.0, 0.0, 0.0, 0.0, 1.0)); + PyList_SetItem(indices, 0, index); + index = msh_addVertex((mshobject*) mesh, + Py_BuildValue("ffffff", + 1.0, -1.0, 0.0, 0.0, 0.0, 1.0)); + PyList_SetItem(indices, 1, index); + index = msh_addVertex((mshobject*) mesh, + Py_BuildValue("ffffff", + -1.0, -1.0, 0.0, 0.0, 0.0, 1.0)); + PyList_SetItem(indices, 2, index); + index = msh_addVertex((mshobject*) mesh, + Py_BuildValue("ffffff", + -1.0, 1.0, 0.0, 0.0, 0.0, 1.0)); + PyList_SetItem(indices, 3, index); + PyList_SetItem(indices, 4, PyInt_FromLong(0)); /* smooth flag */ + PyList_SetItem(indices, 5, PyInt_FromLong(0)); /* material index */ + /* faces */ + msh_addFace((mshobject*) mesh, + Py_BuildValue("OOOOOO", + PyList_GetItem(indices, 0), + PyList_GetItem(indices, 3), + PyList_GetItem(indices, 2), + PyList_GetItem(indices, 1), + PyList_GetItem(indices, 4), + PyList_GetItem(indices, 5))); + /* connection */ + blend_connect(self, Py_BuildValue("OO", + PyString_FromString(obj->name), + PyString_FromString(msh->name))); + blend_connect(self, Py_BuildValue("OO", + PyString_FromString(sceneName), + PyString_FromString(obj->name))); + /* return value */ + tuple = PyTuple_New(2); + PyTuple_SetItem(tuple, 0, object); + PyTuple_SetItem(tuple, 1, mesh); + + return tuple; + } + + Py_INCREF(Py_None); + return Py_None; +} + +static char blend_connect__doc__[] = +"connect(obj1, obj2)" +; + +static PyObject* +blend_connect(PyObject* self, PyObject* args) +{ + PyObject* obj1 = NULL; + PyObject* obj2 = NULL; + + if (!PyArg_ParseTuple(args, "OO", &obj1, &obj2)) + { + return NULL; + } + if (obj1->ob_type == &Objtype) + { + if (obj2->ob_type == &Mshtype) + { + Py_INCREF(obj2); + ((objobject*) obj1)->data = obj2; + ((objobject*) obj1)->type = PyString_FromString("Mesh"); + } + } + else if (obj1->ob_type == &Scetype) + { + if (obj2->ob_type == &Objtype) + { + sce_addObject((sceobject*) obj1, Py_BuildValue("(O)", obj2)); + } + } + + Py_INCREF(Py_None); + return Py_None; +} + +static char blend_getCamera__doc__[] = +"getCamera()" +; + +static PyObject* +blend_getCamera(PyObject* self, PyObject* args) +{ + char* name = NULL; + ID* list = NULL; + Camera* cam = NULL; + camobject* camera = NULL; + + if (!PyArg_ParseTuple(args, "s", &name)) + { + return NULL; + } + list = find_name_in_list((ID*) G.main->camera.first, name); + if (list) + { + cam = (Camera*) list; + camera = newcamobject(cam->id.name+2); + camera->Lens = PyFloat_FromDouble(cam->lens); + camera->ClSta = PyFloat_FromDouble(cam->clipsta); + camera->ClEnd = PyFloat_FromDouble(cam->clipend); + + return (PyObject*) camera; + } + else + { + Py_INCREF(Py_None); + return Py_None; + } +} + +static char blend_getCurrentScene__doc__[] = +"getCurrentScene()" +; + +static PyObject* +blend_getCurrentScene(PyObject* self, PyObject* args) +{ + char* name = NULL; + sceobject* scene = NULL; + Base* base = NULL; + Object* obj = NULL; + + if (!PyArg_ParseTuple(args, "")) + { + return NULL; + } + + /* create scene in Python */ + name = G.scene->id.name+2; + scene = newsceobject(name); + + /* add existing objects */ + base = G.scene->base.first; + while (base) + { + obj = base->object; + PyList_Append(scene->objects, PyString_FromString(obj->id.name+2)); + base = base->next; + } + + return (PyObject*) scene; +} + +static char blend_getDisplaySettings__doc__[] = +"getDisplaySettings()" +; + +static PyObject* +blend_getDisplaySettings(PyObject* self, PyObject* args) +{ + RenderData* rd = NULL; + dspobject* displayObject = NULL; + + if (!PyArg_ParseTuple(args, "")) + { + return NULL; + } + rd = &(G.scene->r); + displayObject = newdspobject(); + displayObject->startFrame = PyInt_FromLong(rd->sfra); + displayObject->endFrame = PyInt_FromLong(rd->efra); + displayObject->currentFrame = PyInt_FromLong(rd->cfra); + displayObject->xResolution = PyInt_FromLong(rd->xsch); + displayObject->yResolution = PyInt_FromLong(rd->ysch); + displayObject->pixelAspectRatio = PyInt_FromLong(rd->yasp / + (1.0 * rd->xasp)); + + return (PyObject*) displayObject; +} + +static char blend_getLamp__doc__[] = +"getLamp(name)" +; + +static PyObject* +blend_getLamp(PyObject* self, PyObject* args) +{ + char* name = NULL; + ID* list = NULL; + Lamp* lmp = NULL; + lmpobject* lamp = NULL; + + if (!PyArg_ParseTuple(args, "s", &name)) + { + return NULL; + } + list = find_name_in_list((ID*) G.main->lamp.first, name); + if (list) + { + lmp = (Lamp*) list; + lamp = newlmpobject(lmp->id.name+2); + lamp->R = PyFloat_FromDouble(lmp->r); + lamp->G = PyFloat_FromDouble(lmp->g); + lamp->B = PyFloat_FromDouble(lmp->b); +/* lamp->Dist = PyFloat_FromDouble(lmp->dist); */ +/* lamp->SpoSi = PyFloat_FromDouble(lmp->spotsize); */ +/* lamp->SpoBl = PyFloat_FromDouble(lmp->spotblend); */ +/* lamp->Quad1 = PyFloat_FromDouble(lmp->att1); */ +/* lamp->Quad2 = PyFloat_FromDouble(lmp->att2); */ +/* lamp->HaInt = PyFloat_FromDouble(lmp->haint); */ + +/* lamp->OfsX = PyFloat_FromDouble(lmp->); */ +/* lamp->OfsY = PyFloat_FromDouble(lmp->); */ +/* lamp->OfsZ = PyFloat_FromDouble(lmp->); */ +/* lamp->SizeX = PyFloat_FromDouble(lmp->); */ +/* lamp->SizeY = PyFloat_FromDouble(lmp->); */ +/* lamp->SizeZ = PyFloat_FromDouble(lmp->); */ +/* lamp->texR = PyFloat_FromDouble(lmp->); */ +/* lamp->texG = PyFloat_FromDouble(lmp->); */ +/* lamp->texB = PyFloat_FromDouble(lmp->); */ +/* lamp->DefVar = PyFloat_FromDouble(lmp->); */ +/* lamp->Col = PyFloat_FromDouble(lmp->); */ +/* lamp->Nor = PyFloat_FromDouble(lmp->); */ +/* lamp->Var = PyFloat_FromDouble(lmp->); */ + + return (PyObject*) lamp; + } + else + { + Py_INCREF(Py_None); + return Py_None; + } +} + +static char blend_getMaterial__doc__[] = +"getMaterial(name)" +; + +static PyObject* +blend_getMaterial(PyObject* self, PyObject* args) +{ + char* name = NULL; + ID* list = NULL; + Material* mat = NULL; + matobject* material = NULL; + + if (!PyArg_ParseTuple(args, "s", &name)) + { + return NULL; + } + list = find_name_in_list((ID*) G.main->mat.first, name); + if (list) + { + mat = (Material*) list; + material = newmatobject(mat->id.name+2); + material->R = PyFloat_FromDouble(mat->r); + material->G = PyFloat_FromDouble(mat->g); + material->B = PyFloat_FromDouble(mat->b); + + return (PyObject*) material; + } + else + { + Py_INCREF(Py_None); + return Py_None; + } +} + +static char blend_getMesh__doc__[] = +"getMesh(name)" +; + +static PyObject* +blend_getMesh(PyObject* self, PyObject* args) +{ + int i; + float r, g, b; + char dummy[] = ""; + char* name = NULL; + char* filename = NULL; + uint* mcol = NULL; + ID* list = NULL; + Mesh* msh = NULL; + mshobject* mesh = NULL; + MFace* mface = NULL; + TFace* tface = NULL; + + if (!PyArg_ParseTuple(args, "s", &name)) + { + return NULL; + } + list = find_name_in_list((ID*) G.main->mesh.first, name); + if (list) + { + msh = (Mesh*) list; + mesh = newmshobject(msh->id.name+2); + /* is there color information? */ + if (msh->mcol) + { + mcol = mcol_to_vcol(msh); + } + /* add vertices */ + for (i = 0; i < msh->totvert; i++) + { + if (msh->mcol && mcol) + { + mcol_to_rgb(*mcol, &r, &g, &b); + msh_addVertex(mesh, + Py_BuildValue("fffffffff", + msh->mvert[i].co[0], + msh->mvert[i].co[1], + msh->mvert[i].co[2], + msh->mvert[i].no[0] / 32767.0, + msh->mvert[i].no[1] / 32767.0, + msh->mvert[i].no[2] / 32767.0, + r, g, b)); + mcol++; + } + else + { + msh_addVertex(mesh, + Py_BuildValue("ffffff", + msh->mvert[i].co[0], + msh->mvert[i].co[1], + msh->mvert[i].co[2], + msh->mvert[i].no[0] / 32767.0, + msh->mvert[i].no[1] / 32767.0, + msh->mvert[i].no[2] / 32767.0)); + } + } + /* add faces */ + for (i = 0; i < msh->totface; i++) + { + mface = ((MFace*) msh->mface)+i; + msh_addFace(mesh, + Py_BuildValue("iiiiii", + mface->v1, mface->v2, + mface->v3, mface->v4, + mface->flag, mface->mat_nr)); + } + /* add texture coordinates */ + if (msh->tface) + { + tface = (TFace*) msh->tface; + if (tface->tpage) + { + filename = ((Image*) tface->tpage)->name; + } + else + { + filename = dummy; + } + msh_addTexture(mesh, + Py_BuildValue("(O)", PyString_FromString(filename))); + for (i = 0; i < msh->totface; i++) + { + tface = (TFace*) msh->tface+i; + msh_addTexCoords(mesh, + Py_BuildValue("ff", + tface->uv[0][0], + tface->uv[0][1])); + msh_addTexCoords(mesh, + Py_BuildValue("ff", + tface->uv[1][0], + tface->uv[1][1])); + msh_addTexCoords(mesh, + Py_BuildValue("ff", + tface->uv[2][0], + tface->uv[2][1])); + msh_addTexCoords(mesh, + Py_BuildValue("ff", + tface->uv[3][0], + tface->uv[3][1])); + } + } + + return (PyObject*) mesh; + } + else + { + Py_INCREF(Py_None); + return Py_None; + } +} + +static char blend_getObject__doc__[] = +"getObject(name)" +; + +static PyObject* +blend_getObject(PyObject* self, PyObject* args) +{ + int i; + float inverse[4][4]; + char* name = NULL; + ID* list = NULL; + Object* obj = NULL; + Mesh* msh = NULL; + objobject* object = NULL; + PyObject* row1 = NULL; + PyObject* row2 = NULL; + PyObject* row3 = NULL; + PyObject* row4 = NULL; + + if (!PyArg_ParseTuple(args, "s", &name)) + { + return NULL; + } + list = find_name_in_list((ID*) G.main->object.first, name); + if (list) + { + obj = (Object*) list; + object = newobjobject(obj->id.name+2); + Py_DECREF(object->matrix); + object->matrix = PyList_New(4); + row1 = PyList_New(4); + row2 = PyList_New(4); + row3 = PyList_New(4); + row4 = PyList_New(4); + PyList_SetItem(row1, 0, PyFloat_FromDouble(obj->obmat[0][0])); + PyList_SetItem(row1, 1, PyFloat_FromDouble(obj->obmat[0][1])); + PyList_SetItem(row1, 2, PyFloat_FromDouble(obj->obmat[0][2])); + PyList_SetItem(row1, 3, PyFloat_FromDouble(obj->obmat[0][3])); + PyList_SetItem(row2, 0, PyFloat_FromDouble(obj->obmat[1][0])); + PyList_SetItem(row2, 1, PyFloat_FromDouble(obj->obmat[1][1])); + PyList_SetItem(row2, 2, PyFloat_FromDouble(obj->obmat[1][2])); + PyList_SetItem(row2, 3, PyFloat_FromDouble(obj->obmat[1][3])); + PyList_SetItem(row3, 0, PyFloat_FromDouble(obj->obmat[2][0])); + PyList_SetItem(row3, 1, PyFloat_FromDouble(obj->obmat[2][1])); + PyList_SetItem(row3, 2, PyFloat_FromDouble(obj->obmat[2][2])); + PyList_SetItem(row3, 3, PyFloat_FromDouble(obj->obmat[2][3])); + PyList_SetItem(row4, 0, PyFloat_FromDouble(obj->obmat[3][0])); + PyList_SetItem(row4, 1, PyFloat_FromDouble(obj->obmat[3][1])); + PyList_SetItem(row4, 2, PyFloat_FromDouble(obj->obmat[3][2])); + PyList_SetItem(row4, 3, PyFloat_FromDouble(obj->obmat[3][3])); + PyList_SetItem(object->matrix, 0, row1); + PyList_SetItem(object->matrix, 1, row2); + PyList_SetItem(object->matrix, 2, row3); + PyList_SetItem(object->matrix, 3, row4); + /* inverse matrix */ + Mat4Invert(inverse, obj->obmat); + Py_DECREF(object->inverseMatrix); + object->inverseMatrix = PyList_New(4); + row1 = PyList_New(4); + row2 = PyList_New(4); + row3 = PyList_New(4); + row4 = PyList_New(4); + PyList_SetItem(row1, 0, PyFloat_FromDouble(inverse[0][0])); + PyList_SetItem(row1, 1, PyFloat_FromDouble(inverse[0][1])); + PyList_SetItem(row1, 2, PyFloat_FromDouble(inverse[0][2])); + PyList_SetItem(row1, 3, PyFloat_FromDouble(inverse[0][3])); + PyList_SetItem(row2, 0, PyFloat_FromDouble(inverse[1][0])); + PyList_SetItem(row2, 1, PyFloat_FromDouble(inverse[1][1])); + PyList_SetItem(row2, 2, PyFloat_FromDouble(inverse[1][2])); + PyList_SetItem(row2, 3, PyFloat_FromDouble(inverse[1][3])); + PyList_SetItem(row3, 0, PyFloat_FromDouble(inverse[2][0])); + PyList_SetItem(row3, 1, PyFloat_FromDouble(inverse[2][1])); + PyList_SetItem(row3, 2, PyFloat_FromDouble(inverse[2][2])); + PyList_SetItem(row3, 3, PyFloat_FromDouble(inverse[2][3])); + PyList_SetItem(row4, 0, PyFloat_FromDouble(inverse[3][0])); + PyList_SetItem(row4, 1, PyFloat_FromDouble(inverse[3][1])); + PyList_SetItem(row4, 2, PyFloat_FromDouble(inverse[3][2])); + PyList_SetItem(row4, 3, PyFloat_FromDouble(inverse[3][3])); + PyList_SetItem(object->inverseMatrix, 0, row1); + PyList_SetItem(object->inverseMatrix, 1, row2); + PyList_SetItem(object->inverseMatrix, 2, row3); + PyList_SetItem(object->inverseMatrix, 3, row4); + Py_DECREF(object->materials); + object->materials = PyList_New(obj->totcol); + for (i = 0; i < obj->totcol; i++) + { + if (obj->mat[i]) + { + PyList_SetItem(object->materials, i, + PyString_FromString(obj->mat[i]->id.name+2)); + } + else + { + Py_INCREF(Py_None); + PyList_SetItem(object->materials, i, Py_None); + } + } /* check type */ + switch (obj->type) + { + case OB_EMPTY: + printf("Empty\n"); + break; + case OB_MESH: + object->data = PyString_FromString(((Mesh*) obj->data)->id.name+2); + object->type = PyString_FromString("Mesh"); + msh = (Mesh*) obj->data; + for (i = 0; i < msh->totcol; i++) + { + if (msh->mat[i]) + { + PyList_SetItem(object->materials, i, + PyString_FromString(msh->mat[i]->id.name+2)); + } + } + break; + case OB_CURVE: + printf("Curve\n"); + break; + case OB_SURF: + printf("Surface\n"); + break; + case OB_FONT: + printf("Font\n"); + break; + case OB_MBALL: + printf("Metaball\n"); + break; + case OB_LAMP: + object->data = PyString_FromString(((Lamp*) obj->data)->id.name+2); + object->type = PyString_FromString("Lamp"); + break; + case OB_CAMERA: + object->data = PyString_FromString(((Camera*) obj->data)->id.name+2); + object->type = PyString_FromString("Camera"); + break; + case OB_IKA: + printf("Ika\n"); + break; + case OB_WAVE: + printf("Wave\n"); + break; + case OB_LATTICE: + printf("Lattice\n"); + break; + default: + printf("ERROR: py_main.c:blend_getObject(...)\n"); + printf(" unknown type ...\n"); + break; + } + + return (PyObject*) object; + } + else + { + Py_INCREF(Py_None); + return Py_None; + } +} + +static char blend_isCamera__doc__[] = +"isCamera(name)" +; + +static PyObject* +blend_isCamera(PyObject* self, PyObject* args) +{ + char* name = NULL; + ID* list = NULL; + Object* obj = NULL; + + if (!PyArg_ParseTuple(args, "s", &name)) + { + return NULL; + } + list = find_name_in_list((ID*) G.main->object.first, name); + if (list) + { + obj = (Object*) list; + if (obj->type == OB_CAMERA) + { + return PyInt_FromLong(1); + } + else + { + return PyInt_FromLong(0); + } + } + else + { + return NULL; + } +} + +static char blend_isLamp__doc__[] = +"isLamp(name)" +; + +static PyObject* +blend_isLamp(PyObject* self, PyObject* args) +{ + char* name = NULL; + ID* list = NULL; + Object* obj = NULL; + + if (!PyArg_ParseTuple(args, "s", &name)) + { + return NULL; + } + list = find_name_in_list((ID*) G.main->object.first, name); + if (list) + { + obj = (Object*) list; + if (obj->type == OB_LAMP) + { + return PyInt_FromLong(1); + } + else + { + return PyInt_FromLong(0); + } + } + else + { + return NULL; + } +} + +static char blend_isMesh__doc__[] = +"isMesh(name)" +; + +static PyObject* +blend_isMesh(PyObject* self, PyObject* args) +{ + char* name = NULL; + ID* list = NULL; + Object* obj = NULL; + + if (!PyArg_ParseTuple(args, "s", &name)) + { + return NULL; + } + list = find_name_in_list((ID*) G.main->object.first, name); + if (list) + { + obj = (Object*) list; + if (obj->type == OB_MESH) + { + return PyInt_FromLong(1); + } + else + { + return PyInt_FromLong(0); + } + } + else + { + return NULL; + } +} + +static char blend_setCurrentFrame__doc__[] = +"setCurrentFrame(frame)" +; + +static PyObject* +blend_setCurrentFrame(PyObject* self, PyObject* args) +{ + int frame = -1; + + if (!PyArg_ParseTuple(args, "i", &frame)) + { + return NULL; + } + CFRA = frame; + drawview3d(); + + Py_INCREF(Py_None); + return Py_None; +} + +/* List of methods defined in the module */ + +static struct PyMethodDef blend_methods[] = { + {"Mesh", (PyCFunction) blend_Mesh, + METH_VARARGS, blend_Mesh__doc__}, + {"Object", (PyCFunction) blend_Object, + METH_VARARGS, blend_Object__doc__}, + {"Scene", (PyCFunction) blend_Scene, + METH_VARARGS, blend_Scene__doc__}, + {"addMesh", (PyCFunction) blend_addMesh, + METH_VARARGS, blend_addMesh__doc__}, + {"connect", (PyCFunction) blend_connect, + METH_VARARGS, blend_connect__doc__}, + {"getCamera", (PyCFunction) blend_getCamera, + METH_VARARGS, blend_getCamera__doc__}, + {"getCurrentScene", (PyCFunction) blend_getCurrentScene, + METH_VARARGS, blend_getCurrentScene__doc__}, + {"getDisplaySettings", (PyCFunction) blend_getDisplaySettings, + METH_VARARGS, blend_getDisplaySettings__doc__}, + {"getLamp", (PyCFunction) blend_getLamp, + METH_VARARGS, blend_getLamp__doc__}, + {"getMaterial", (PyCFunction) blend_getMaterial, + METH_VARARGS, blend_getMaterial__doc__}, + {"getMesh", (PyCFunction) blend_getMesh, + METH_VARARGS, blend_getMesh__doc__}, + {"getObject", (PyCFunction) blend_getObject, + METH_VARARGS, blend_getObject__doc__}, + {"isCamera", (PyCFunction) blend_isCamera, + METH_VARARGS, blend_isCamera__doc__}, + {"isLamp", (PyCFunction) blend_isLamp, + METH_VARARGS, blend_isLamp__doc__}, + {"isMesh", (PyCFunction) blend_isMesh, + METH_VARARGS, blend_isMesh__doc__}, + {"setCurrentFrame", (PyCFunction) blend_setCurrentFrame, + METH_VARARGS, blend_setCurrentFrame__doc__}, + { NULL, (PyCFunction) NULL, 0, NULL } +}; + +static char Blender_module_documentation[] = +"This is the Python API for Blender" +; + +void +initBlender() +{ + PyObject* m; + PyObject* d; + + /* Create the module and add the functions */ + m = Py_InitModule4("Blender", blend_methods, + Blender_module_documentation, + (PyObject*)NULL,PYTHON_API_VERSION); + + /* Add some symbolic constants to the module */ + d = PyModule_GetDict(m); + ErrorObject = PyString_FromString("Blender.error"); + PyDict_SetItemString(d, "error", ErrorObject); + + /* XXXX Add constants here */ + + /* Check for errors */ + if (PyErr_Occurred()) + { + Py_FatalError("can't initialize module Blender"); + } +} +/* Jan Walter's stuff */ |