Skip to content
Snippets Groups Projects
Commit b1e0ce96 authored by Jacques Guignot's avatar Jacques Guignot
Browse files

*** empty log message ***

parent 798063ac
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
source/blender/python/api2_2x/World.c 0 → 100644
+ 1001
− 0
View file @ b1e0ce96
/*
*
* ***** 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 <BKE_main.h>
#include <BKE_global.h>
#include <BKE_object.h>
#include <BKE_library.h>
#include <BLI_blenlib.h>
#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 <name> - 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 <name> - 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);
}
/*@}*/
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment