/* * * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. The Blender * Foundation also sells licenses for use in proprietary software under * the Blender License. See http://www.blender.org/BL/ for information * about this. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software Foundation, * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. * All rights reserved. * * This is a new part of Blender. * * Contributor(s): Jacques Guignot * * ***** END GPL/BL DUAL LICENSE BLOCK ***** */ /** * \file World.c * \ingroup scripts * \brief Blender.World Module and World Data PyObject implementation. * * Note: Parameters between "<" and ">" are optional. But if one of them is * given, all preceding ones must be given, too. Of course, this only relates * to the Python functions and methods described here and only inside Python * code. [ This will go to another file later, probably the main exppython * doc file]. XXX Better: put optional args with their default value: * (self, name = "MyName") */ #include #include #include #include #include #include "World.h" /*****************************************************************************/ /* Python API function prototypes for the World module. */ /*****************************************************************************/ static PyObject *M_World_New (PyObject *self, PyObject *args, PyObject *keywords); static PyObject *M_World_Get (PyObject *self, PyObject *args); /*****************************************************************************/ /* The following string definitions are used for documentation strings. */ /* In Python these will be written to the console when doing a */ /* Blender.World.__doc__ */ /*****************************************************************************/ static char M_World_doc[] = "The Blender World module\n\n\ This module provides access to **World Data** objects in Blender\n\n\ Example::\n\n\ from Blender import World, Object, Scene\n\ c = World.New('ortho') # create new ortho world data\n\ c.lens = 35.0 # set lens value\n\ cur = Scene.getCurrent() # get current Scene\n\ ob = Object.New('World') # make world object\n\ ob.link(c) # link world data with this object\n\ cur.link(ob) # link object into scene\n\ cur.setCurrentWorld(ob) # make this world the active\n"; static char M_World_New_doc[] = "(type) - return a new World object of type \"type\", \ which can be 'persp' or 'ortho'.\n\ () - return a new World object of type 'persp'."; static char M_World_Get_doc[] = "(name) - return the world with the name 'name', \ returns None if not found.\n If 'name' is not specified, \ it returns a list of all worlds in the\ncurrent scene."; /*****************************************************************************/ /* Python method structure definition for Blender.World module: */ /*****************************************************************************/ struct PyMethodDef M_World_methods[] = { {"New",(PyCFunction)M_World_New, METH_VARARGS|METH_KEYWORDS,M_World_New_doc}, {"Get", M_World_Get, METH_VARARGS, M_World_Get_doc}, {"get", M_World_Get, METH_VARARGS, M_World_Get_doc}, {NULL, NULL, 0, NULL} }; /*****************************************************************************/ /* Python C_World methods declarations: */ /*****************************************************************************/ static PyObject *World_getName(C_World *self); static PyObject *World_setName(C_World *self, PyObject *args); static PyObject *World_getColormodel(C_World *self); static PyObject *World_setColormodel(C_World *self, PyObject *args ); static PyObject *World_getFastcol(C_World *self); static PyObject *World_setFastcol(C_World *self, PyObject *args ); static PyObject *World_getSkytype(C_World *self); static PyObject *World_setSkytype(C_World *self, PyObject *args ); static PyObject *World_getMode(C_World *self); static PyObject *World_setMode(C_World *self, PyObject *args ); static PyObject *World_getTotex(C_World *self); static PyObject *World_setTotex(C_World *self, PyObject *args ); static PyObject *World_getTexact(C_World *self); static PyObject *World_setTexact(C_World *self, PyObject *args ); static PyObject *World_getMistype(C_World *self); static PyObject *World_setMistype(C_World *self, PyObject *args ); static PyObject *World_getHor(C_World *self); static PyObject *World_setHor(C_World *self, PyObject *args ); static PyObject *World_getZen(C_World *self); static PyObject *World_setZen(C_World *self, PyObject *args ); static PyObject *World_getAmb(C_World *self); static PyObject *World_setAmb(C_World *self, PyObject *args ); static PyObject *World_getStar(C_World *self); static PyObject *World_setStar(C_World *self, PyObject *args ); static PyObject *World_getDof(C_World *self); static PyObject *World_setDof(C_World *self, PyObject *args ); static PyObject *World_getMist(C_World *self); static PyObject *World_setMist(C_World *self, PyObject *args ); /*****************************************************************************/ /* Python C_World methods table: */ /*****************************************************************************/ static PyMethodDef C_World_methods[] = { {"getName", (PyCFunction)World_getName, METH_NOARGS, "() - Return World Data name"}, {"setName", (PyCFunction)World_setName, METH_VARARGS, "() - Return World Data name"}, {"getColormodel", (PyCFunction)World_getColormodel, METH_NOARGS, "() - Return World Data colormodel"}, {"setColormodel", (PyCFunction)World_setColormodel, METH_VARARGS, "() - Return World Data colormodel"}, {"getFastcol", (PyCFunction)World_getFastcol, METH_NOARGS, "() - Return World Data fastcol"}, {"setFastcol", (PyCFunction)World_setFastcol, METH_VARARGS, "() - Return World Data fastcol"}, {"getSkytype", (PyCFunction)World_getSkytype, METH_NOARGS, "() - Return World Data skytype"}, {"setSkytype", (PyCFunction)World_setSkytype, METH_VARARGS, "() - Return World Data skytype"}, {"getMode", (PyCFunction)World_getMode, METH_NOARGS, "() - Return World Data mode"}, {"setMode", (PyCFunction)World_setMode, METH_VARARGS, "() - Return World Data mode"}, {"getTotex", (PyCFunction)World_getTotex, METH_NOARGS, "() - Return World Data totex"}, {"setTotex", (PyCFunction)World_setTotex, METH_VARARGS, "() - Return World Data totex"}, {"getTexact", (PyCFunction)World_getTexact, METH_NOARGS, "() - Return World Data texact"}, {"setTexact", (PyCFunction)World_setTexact, METH_VARARGS, "() - Return World Data texact"}, {"getMistype", (PyCFunction)World_getMistype, METH_NOARGS, "() - Return World Data mistype"}, {"setMistype", (PyCFunction)World_setMistype, METH_VARARGS, "() - Return World Data mistype"}, {"getHor", (PyCFunction)World_getHor, METH_NOARGS, "() - Return World Data hor"}, {"setHor", (PyCFunction)World_setHor, METH_VARARGS, "() - Return World Data hor"}, {"getZen", (PyCFunction)World_getZen, METH_NOARGS, "() - Return World Data zen"}, {"setZen", (PyCFunction)World_setZen, METH_VARARGS, "() - Return World Data zen"}, {"getAmb", (PyCFunction)World_getAmb, METH_NOARGS, "() - Return World Data amb"}, {"setAmb", (PyCFunction)World_setAmb, METH_VARARGS, "() - Return World Data amb"}, {"getStar", (PyCFunction)World_getStar, METH_NOARGS, "() - Return World Data star"}, {"setStar", (PyCFunction)World_setStar, METH_VARARGS, "() - Return World Data star"}, {"getDof", (PyCFunction)World_getDof, METH_NOARGS, "() - Return World Data dof"}, {"setDof", (PyCFunction)World_setDof, METH_VARARGS, "() - Return World Data dof"}, {"getMist", (PyCFunction)World_getMist, METH_NOARGS, "() - Return World Data mist"}, {"setMist", (PyCFunction)World_setMist, METH_VARARGS, "() - Return World Data mist"}, {0} }; /*****************************************************************************/ /* Python World_Type callback function prototypes: */ /*****************************************************************************/ static void World_DeAlloc (C_World *self); static int World_Print (C_World *self, FILE *fp, int flags); static int World_SetAttr (C_World *self, char *name, PyObject *v); static int World_Compare (C_World *a, C_World *b); static PyObject *World_GetAttr (C_World *self, char *name); static PyObject *World_Repr (C_World *self); /*****************************************************************************/ /* Python World_Type structure definition: */ /*****************************************************************************/ PyTypeObject World_Type = { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ "World", /* tp_name */ sizeof (C_World), /* tp_basicsize */ 0, /* tp_itemsize */ /* methods */ (destructor)World_DeAlloc, /* tp_dealloc */ (printfunc)World_Print, /* tp_print */ (getattrfunc)World_GetAttr, /* tp_getattr */ (setattrfunc)World_SetAttr, /* tp_setattr */ (cmpfunc)World_Compare, /* tp_compare */ (reprfunc)World_Repr, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ 0, /* tp_as_hash */ 0,0,0,0,0,0, 0, /* tp_doc */ 0,0,0,0,0,0, C_World_methods, /* tp_methods */ 0, /* tp_members */ }; /** * \defgroup World_Module Blender.World module functions * */ /*@{*/ /** * \brief Python module function: Blender.World.New() * * This is the .New() function of the Blender.World submodule. It creates * new World Data in Blender and returns its Python wrapper object. The * name parameter is mandatory. * \param - string: The World Data name. * \return A new World PyObject. */ static PyObject *M_World_New(PyObject *self, PyObject *args, PyObject *kwords) { World *add_world(char *name); char*name = NULL; C_World *pyworld; World *blworld; if (!PyArg_ParseTuple(args, "s", &name)) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); blworld = add_world(name); if (blworld) pyworld = (C_World *)PyObject_NEW(C_World, &World_Type); else return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't create World Data in Blender")); if (pyworld == NULL) return (EXPP_ReturnPyObjError (PyExc_MemoryError, "couldn't create World Data object")); pyworld->world = blworld; return (PyObject *)pyworld; } /** * \brief Python module function: Blender.World.Get() * * This is the .Get() function of the Blender.World submodule. It searches * the list of current World Data objects and returns a Python wrapper for * the one with the name provided by the user. If called with no arguments, * it returns a list of all current World Data object names in Blender. * \param - string: The name of an existing Blender World Data object. * \return () - A list with the names of all current World Data objects;\n * \return (name) - A Python wrapper for the World Data called 'name' * in Blender. */ static PyObject *M_World_Get(PyObject *self, PyObject *args) { char *name = NULL; World *world_iter; PyObject *worldlist; C_World *wanted_world = NULL; char error_msg[64]; if (!PyArg_ParseTuple(args, "|s", &name)) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected string argument (or nothing)")); world_iter = G.main->world.first; if (name) { /* (name) - Search world by name */ while ((world_iter) && (wanted_world == NULL)) { if (strcmp (name, world_iter->id.name+2) == 0) { wanted_world = (C_World *)PyObject_NEW(C_World, &World_Type); if (wanted_world) wanted_world->world = world_iter; } world_iter = world_iter->id.next; } if (wanted_world == NULL) { /* Requested world doesn't exist */ PyOS_snprintf(error_msg, sizeof(error_msg), "World \"%s\" not found", name); return (EXPP_ReturnPyObjError (PyExc_NameError, error_msg)); } return (PyObject *)wanted_world; } else { /* return a list of all worlds in the scene */ worldlist = PyList_New (0); if (worldlist == NULL) return (PythonReturnErrorObject (PyExc_MemoryError, "couldn't create PyList")); while (world_iter) { C_World *found_world = (C_World *)PyObject_NEW(C_World, &World_Type); found_world->world = world_iter; PyList_Append (worldlist , (PyObject *)found_world); world_iter = world_iter->id.next; } return (worldlist); } } /*@}*/ /** * \brief Initializes the Blender.World submodule * * This function is used by Blender_Init() in Blender.c to register the * Blender.World submodule in the main Blender module. * \return PyObject*: The initialized submodule. */ PyObject *M_World_Init (void) { PyObject *submodule; printf ("In M_World_Init()\n"); World_Type.ob_type = &PyType_Type; submodule = Py_InitModule3("Blender.World", M_World_methods, M_World_doc); return (submodule); } /*****************************************************************************/ /* Python C_World methods: */ /*****************************************************************************/ /** * \defgroup World_Methods World Method Functions * * These are the World PyObject method functions. They are used to get and * set values for the World Data member variables. */ /*@{*/ /** * \brief World PyMethod getName * * \return string: The World Data name. */ static PyObject *World_getName(C_World *self) { PyObject *attr = PyString_FromString(self->world->id.name+2); if (attr) return attr; return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't get World.name attribute")); } /** * \brief World PyMethod setName * \param name - string: The new World Data name. */ static PyObject *World_setName(C_World *self, PyObject *args) { char *name = 0; char buf[21]; puts("mlmlml"); if (!PyArg_ParseTuple(args, "s", &name)) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected string argument")); puts(name); snprintf(buf, sizeof(buf), "%s", name); puts("mlmlml"); rename_id(&self->world->id, buf); Py_INCREF(Py_None); return Py_None; } /** * \brief World PyMethod getColormodel * * \return int : The World Data colormodel. */ static PyObject *World_getColormodel(C_World *self) { PyObject *attr = PyInt_FromLong((long)self->world->colormodel); if (attr) return attr; return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't get World.colormodel attribute")); } /** * \brief World PyMethod setColormodel * * \return int : The World Data colormodel. */ static PyObject *World_setColormodel(C_World *self, PyObject *args ) { int colormodel; if (!PyArg_ParseTuple(args, "i", &colormodel)) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); self->world->colormodel = colormodel; Py_INCREF(Py_None); return Py_None; } /** * \brief World PyMethod getFastcol * * \return int : The World Data fastcol. */ static PyObject *World_getFastcol(C_World *self) { PyObject *attr = PyInt_FromLong((long)self->world->fastcol); if (attr) return attr; return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't get World.fastcol attribute")); } /** * \brief World PyMethod setFastcol * * \return int : The World Data fastcol. */ static PyObject *World_setFastcol(C_World *self, PyObject *args ) { int fastcol; if (!PyArg_ParseTuple(args, "i", &fastcol)) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); self->world->fastcol = fastcol; Py_INCREF(Py_None); return Py_None; } /** * \brief World PyMethod getSkytype * * \return int : The World Data skytype. */ static PyObject *World_getSkytype(C_World *self) { PyObject *attr = PyInt_FromLong((long)self->world->skytype); if (attr) return attr; return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't get World.skytype attribute")); } /** * \brief World PyMethod setSkytype * * \return int : The World Data skytype. */ static PyObject *World_setSkytype(C_World *self, PyObject *args ) { int skytype; if (!PyArg_ParseTuple(args, "i", &skytype)) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); self->world->skytype = skytype; Py_INCREF(Py_None); return Py_None; } /** * \brief World PyMethod getMode * * \return int : The World Data mode. */ static PyObject *World_getMode(C_World *self) { PyObject *attr = PyInt_FromLong((long)self->world->mode); if (attr) return attr; return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't get World.mode attribute")); } /** * \brief World PyMethod setMode * * \return int : The World Data mode. */ static PyObject *World_setMode(C_World *self, PyObject *args ) { int mode; if (!PyArg_ParseTuple(args, "i", &mode)) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); self->world->mode = mode; Py_INCREF(Py_None); return Py_None; } /** * \brief World PyMethod getTotex * * \return int : The World Data totex. */ static PyObject *World_getTotex(C_World *self) { PyObject *attr = PyInt_FromLong((long)self->world->totex); if (attr) return attr; return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't get World.totex attribute")); } /** * \brief World PyMethod setTotex * * \return int : The World Data totex. */ static PyObject *World_setTotex(C_World *self, PyObject *args ) { int totex; if (!PyArg_ParseTuple(args, "i", &totex)) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); self->world->totex = totex; Py_INCREF(Py_None); return Py_None; } /** * \brief World PyMethod getTexact * * \return int : The World Data texact. */ static PyObject *World_getTexact(C_World *self) { PyObject *attr = PyInt_FromLong((long)self->world->texact); if (attr) return attr; return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't get World.texact attribute")); } /** * \brief World PyMethod setTexact * * \return int : The World Data texact. */ static PyObject *World_setTexact(C_World *self, PyObject *args ) { int texact; if (!PyArg_ParseTuple(args, "i", &texact)) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); self->world->texact = texact; Py_INCREF(Py_None); return Py_None; } /** * \brief World PyMethod getMistype * * \return int : The World Data mistype. */ static PyObject *World_getMistype(C_World *self) { PyObject *attr = PyInt_FromLong((long)self->world->mistype); if (attr) return attr; return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't get World.mistype attribute")); } /** * \brief World PyMethod setMistype * * \return int : The World Data mistype. */ static PyObject *World_setMistype(C_World *self, PyObject *args ) { int mistype; if (!PyArg_ParseTuple(args, "i", &mistype)) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument")); self->world->mistype = mistype; Py_INCREF(Py_None); return Py_None; } static PyObject *World_getHor(C_World *self) { PyObject *attr = PyList_New(0); if (!attr) return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't create list")); PyList_Append(attr, PyFloat_FromDouble(self->world->horr)); PyList_Append(attr, PyFloat_FromDouble(self->world->horg)); PyList_Append(attr, PyFloat_FromDouble(self->world->horb)); return attr; } static PyObject *World_setHor(C_World *self, PyObject *args ) { PyObject *listargs=0; if (!PyArg_ParseTuple(args, "O", &listargs)) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected list argument")); self->world->horr = PyFloat_AsDouble(PyList_GetItem(listargs,0)); self->world->horg = PyFloat_AsDouble(PyList_GetItem(listargs,1)); self->world->horb = PyFloat_AsDouble(PyList_GetItem(listargs,2)); Py_INCREF(Py_None); return Py_None; } static PyObject *World_getZen(C_World *self) { PyObject *attr = PyList_New(0); if (!attr) return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't create list")); PyList_Append(attr, PyFloat_FromDouble(self->world->zenr)); PyList_Append(attr, PyFloat_FromDouble(self->world->zeng)); PyList_Append(attr, PyFloat_FromDouble(self->world->zenb)); return attr; } static PyObject *World_setZen(C_World *self, PyObject *args ) { PyObject *listargs=0; if (!PyArg_ParseTuple(args, "O", &listargs)) return (EXPP_ReturnPyObjError (PyExc_TypeError, "expected list argument")); self->world->zenr = PyFloat_AsDouble(PyList_GetItem(listargs,0)); self->world->zeng = PyFloat_AsDouble(PyList_GetItem(listargs,1)); self->world->zenb = PyFloat_AsDouble(PyList_GetItem(listargs,2)); Py_INCREF(Py_None); return Py_None; } static PyObject *World_getAmb(C_World *self) { PyObject *attr = PyList_New(0); if (!attr) return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't create list")); PyList_Append(attr, PyFloat_FromDouble(self->world->ambr)); PyList_Append(attr, PyFloat_FromDouble(self->world->ambg)); PyList_Append(attr, PyFloat_FromDouble(self->world->ambb)); return attr; } static PyObject *World_setAmb(C_World *self, PyObject *args ) { PyObject *listargs=0; if (!PyArg_ParseTuple(args, "O", &listargs)) return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected list argument")); if (!PyList_Check(listargs)) return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected list argument")); if (PyList_Size(listargs)!=3) return (EXPP_ReturnPyObjError (PyExc_TypeError,"wrong list size")); self->world->ambr = PyFloat_AsDouble(PyList_GetItem(listargs,0)); self->world->ambg = PyFloat_AsDouble(PyList_GetItem(listargs,1)); self->world->ambb = PyFloat_AsDouble(PyList_GetItem(listargs,2)); Py_INCREF(Py_None); return Py_None; } static PyObject *World_getStar(C_World *self) { PyObject *attr = PyList_New(0); if (!attr) return (EXPP_ReturnPyObjError (PyExc_RuntimeError,"couldn't create list")); PyList_Append(attr, PyFloat_FromDouble(self->world->starr)); PyList_Append(attr, PyFloat_FromDouble(self->world->starg)); PyList_Append(attr, PyFloat_FromDouble(self->world->starb)); PyList_Append(attr, PyFloat_FromDouble(self->world->starsize)); PyList_Append(attr, PyFloat_FromDouble(self->world->starmindist)); PyList_Append(attr, PyFloat_FromDouble(self->world->stardist)); PyList_Append(attr, PyFloat_FromDouble(self->world->starcolnoise)); return attr; } static PyObject *World_setStar(C_World *self, PyObject *args ) { PyObject *listargs=0; if (!PyArg_ParseTuple(args, "O", &listargs)) return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected list argument")); if (!PyList_Check(listargs)) return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected list argument")); if (PyList_Size(listargs)!=7) return (EXPP_ReturnPyObjError (PyExc_TypeError,"wrong list size")); self->world->starr = PyFloat_AsDouble(PyList_GetItem(listargs,0)); self->world->starg = PyFloat_AsDouble(PyList_GetItem(listargs,1)); self->world->starb = PyFloat_AsDouble(PyList_GetItem(listargs,2)); self->world->starsize = PyFloat_AsDouble(PyList_GetItem(listargs,3)); self->world->starmindist = PyFloat_AsDouble(PyList_GetItem(listargs,4)); self->world->stardist = PyFloat_AsDouble(PyList_GetItem(listargs,5)); self->world->starcolnoise = PyFloat_AsDouble(PyList_GetItem(listargs,6)); Py_INCREF(Py_None); return Py_None; } static PyObject *World_getDof(C_World *self) { PyObject *attr = PyList_New(0); if (!attr) return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't create list")); PyList_Append(attr, PyFloat_FromDouble(self->world->dofsta)); PyList_Append(attr, PyFloat_FromDouble(self->world->dofend)); PyList_Append(attr, PyFloat_FromDouble(self->world->dofmin)); PyList_Append(attr, PyFloat_FromDouble(self->world->dofmax)); return attr; } static PyObject *World_setDof(C_World *self, PyObject *args ) { PyObject *listargs=0; if (!PyArg_ParseTuple(args, "O", &listargs)) return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected list argument")); if (!PyList_Check(listargs)) return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected list argument")); if (PyList_Size(listargs)!=4) return (EXPP_ReturnPyObjError (PyExc_TypeError,"wrong list size")); self->world->dofsta = PyFloat_AsDouble(PyList_GetItem(listargs,0)); self->world->dofend = PyFloat_AsDouble(PyList_GetItem(listargs,1)); self->world->dofmin = PyFloat_AsDouble(PyList_GetItem(listargs,2)); self->world->dofmax= PyFloat_AsDouble(PyList_GetItem(listargs,3)); Py_INCREF(Py_None); return Py_None; } static PyObject *World_getMist(C_World *self) { PyObject *attr = PyList_New(0); if (!attr) return (EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't create list")); PyList_Append(attr, PyFloat_FromDouble(self->world->misi)); PyList_Append(attr, PyFloat_FromDouble(self->world->miststa)); PyList_Append(attr, PyFloat_FromDouble(self->world->mistdist)); PyList_Append(attr, PyFloat_FromDouble(self->world->misthi)); return attr; } static PyObject *World_setMist(C_World *self, PyObject *args ) { PyObject *listargs=0; if (!PyArg_ParseTuple(args, "O", &listargs)) return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected list argument")); if (!PyList_Check(listargs)) return (EXPP_ReturnPyObjError (PyExc_TypeError,"expected list argument")); if (PyList_Size(listargs)!=4) return (EXPP_ReturnPyObjError (PyExc_TypeError,"wrong list size")); self->world->misi = PyFloat_AsDouble(PyList_GetItem(listargs,0)); self->world->miststa = PyFloat_AsDouble(PyList_GetItem(listargs,1)); self->world->mistdist = PyFloat_AsDouble(PyList_GetItem(listargs,2)); self->world->misthi = PyFloat_AsDouble(PyList_GetItem(listargs,3)); Py_INCREF(Py_None); return Py_None; } /*@{*/ /** * \brief The World PyType destructor */ static void World_DeAlloc (C_World *self) { PyObject_DEL (self); } /** * \brief The World PyType attribute getter * * This is the callback called when a user tries to retrieve the contents of * World PyObject data members. Ex. in Python: "print myworld.lens". */ static PyObject *World_GetAttr (C_World *self, char *name) { if (strcmp (name, "name") == 0)return World_getName (self); if (strcmp (name, "colormodel") == 0)return World_getColormodel (self); if (strcmp (name, "fastcol") == 0)return World_getFastcol (self); if (strcmp (name, "skytype") == 0)return World_getSkytype (self); if (strcmp (name, "mode") == 0)return World_getMode (self); if (strcmp (name, "totex") == 0)return World_getTotex (self); if (strcmp (name, "texact") == 0)return World_getTexact (self); if (strcmp (name, "mistype") == 0)return World_getMistype (self); if (strcmp (name, "hor") == 0)return World_getHor (self); if (strcmp (name, "zen") == 0)return World_getZen (self); if (strcmp (name, "amb") == 0)return World_getAmb (self); if (strcmp (name, "star") == 0)return World_getStar (self); if (strcmp (name, "dof") == 0)return World_getDof (self); if (strcmp (name, "mist") == 0)return World_getMist (self); return Py_FindMethod(C_World_methods, (PyObject *)self, name); } /** * \brief The World PyType attribute setter * * This is the callback called when the user tries to change the value of some * World data member. Ex. in Python: "myworld.lens = 45.0". */ static int World_SetAttr (C_World *self, char *name, PyObject *value) { PyObject *valtuple = Py_BuildValue("(O)", value); if (!valtuple) return EXPP_ReturnIntError(PyExc_MemoryError, "WorldSetAttr: couldn't parse args"); if (strcmp (name, "name") == 0) World_setName (self,valtuple); if (strcmp (name, "colormodel") == 0) World_setColormodel (self,valtuple); if (strcmp (name, "fastcol") == 0) World_setFastcol (self,valtuple); if (strcmp (name, "skytype") == 0) World_setSkytype (self,valtuple); if (strcmp (name, "mode") == 0) World_setMode (self,valtuple); if (strcmp (name, "totex") == 0) World_setTotex (self,valtuple); if (strcmp (name, "texact") == 0) World_setTexact (self,valtuple); if (strcmp (name, "mistype") == 0) World_setMistype (self,valtuple); if (strcmp (name, "hor") == 0) World_setHor (self,valtuple); if (strcmp (name, "zen") == 0) World_setZen (self,valtuple); if (strcmp (name, "amb") == 0) World_setAmb (self,valtuple); if (strcmp (name, "star") == 0) World_setStar (self,valtuple); if (strcmp (name, "dof") == 0) World_setDof (self,valtuple); if (strcmp (name, "mist") == 0) World_setMist (self,valtuple); return 0; /* normal exit */ } /** * \brief The World PyType compare function * * This function compares two given World PyObjects, returning 0 for equality * and -1 otherwise. In Python it becomes 1 if they are equal and 0 case not. * The comparison is done with their pointers to Blender World Data objects, * so any two wrappers pointing to the same Blender World Data will be * considered the same World PyObject. Currently, only the "==" and "!=" * comparisons are meaninful -- the "<", "<=", ">" or ">=" are not. */ static int World_Compare (C_World *a, C_World *b) { World *pa = a->world, *pb = b->world; return (pa == pb) ? 0:-1; } /** * \brief The World PyType print callback * * This function is called when the user tries to print a PyObject of type * World. It builds a string with the name of the wrapped Blender World. */ static int World_Print(C_World *self, FILE *fp, int flags) { fprintf(fp, "[World \"%s\"]", self->world->id.name+2); return 0; } /** * \brief The World PyType repr callback * * This function is called when the statement "repr(myworld)" is executed in * Python. Repr gives a string representation of a PyObject. */ static PyObject *World_Repr (C_World *self) { return PyString_FromString(self->world->id.name+2); } /*@}*/