bartvdbraak/blender
1
0
Fork 4
Code Issues 4 Pull Requests 1 Actions 1 Packages Projects Releases Wiki Activity
8718b91af0
blender/intern/python/py_main.c
Kent Mein 0fbadc8eb7 Yes I did it again ;) 
added the following 3 lines to everything in the intern dir:
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

Kent
--
mein@cs.umn.edu
2002-11-25 09:53:07 +00:00

2298 lines
51 KiB
C
Raw Blame History

/**
* $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$ */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
/* 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 */
Reference in New Issue View Git Blame Copy Permalink