archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity
This repository has been archived on 2023-10-09. You can view files and clone it, but cannot push or open issues or pull requests.
Files
df1acca4c5bdc47d62bee1369e28c378cf68fcc6
blender-archive/source/blender/python/api2_2x/World.c
Willian Padovani Germano 9f43accdb2 BPython: 
- patch by Jonathan Merritt: new function Blender.Draw.Image() + its doc;
- patch by Campbell Barton: .users attribute for many types;
- tiny internal change in nmesh.hasVertexUV() method.

Thanks to Jonathan and Campbell for the patches and the patience!
2005-01-13 03:04:12 +00:00

1069 lines
31 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.
*
* 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 <DNA_scene_types.h> /* for G.scene */
#include "World.h"
#include "Ipo.h"
#include "constant.h"
#include "gen_utils.h"
/*****************************************************************************/
/* Python BPy_World methods declarations: */
/*****************************************************************************/
static PyObject *World_getRange( BPy_World * self );
static PyObject *World_setRange( BPy_World * self, PyObject * args );
static PyObject *World_getIpo( BPy_World * self );
static PyObject *World_setIpo( BPy_World * self, PyObject * args );
static PyObject *World_clearIpo( BPy_World * self );
static PyObject *World_getName( BPy_World * self );
static PyObject *World_setName( BPy_World * self, PyObject * args );
static PyObject *World_getSkytype( BPy_World * self );
static PyObject *World_setSkytype( BPy_World * self, PyObject * args );
static PyObject *World_getMistype( BPy_World * self );
static PyObject *World_setMistype( BPy_World * self, PyObject * args );
static PyObject *World_getHor( BPy_World * self );
static PyObject *World_setHor( BPy_World * self, PyObject * args );
static PyObject *World_getZen( BPy_World * self );
static PyObject *World_setZen( BPy_World * self, PyObject * args );
static PyObject *World_getAmb( BPy_World * self );
static PyObject *World_setAmb( BPy_World * self, PyObject * args );
static PyObject *World_getStar( BPy_World * self );
static PyObject *World_setStar( BPy_World * self, PyObject * args );
static PyObject *World_getMist( BPy_World * self );
static PyObject *World_setMist( BPy_World * self, PyObject * args );
static PyObject *World_getScriptLinks( BPy_World * self, PyObject * args );
static PyObject *World_addScriptLink( BPy_World * self, PyObject * args );
static PyObject *World_clearScriptLinks( BPy_World * self );
static PyObject *World_setCurrent( BPy_World * self );
/*****************************************************************************/
/* 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 );
static PyObject *M_World_GetCurrent( PyObject * self );
/*****************************************************************************/
/* Python World_Type callback function prototypes: */
/*****************************************************************************/
static void World_DeAlloc( BPy_World * self );
//static int World_Print (BPy_World *self, FILE *fp, int flags);
static int World_SetAttr( BPy_World * self, char *name, PyObject * v );
static int World_Compare( BPy_World * a, BPy_World * b );
static PyObject *World_GetAttr( BPy_World * self, char *name );
static PyObject *World_Repr( BPy_World * self );
/*****************************************************************************/
/* 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";
static char M_World_New_doc[] = "() - return a new World object";
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.";
static char M_World_GetCurrent_doc[] = "() - returns the current world, or \
None if the Scene has no world";
/*****************************************************************************/
/* 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},
{"GetActive", ( PyCFunction ) M_World_GetCurrent, METH_NOARGS,
M_World_GetCurrent_doc},
{"GetCurrent", ( PyCFunction ) M_World_GetCurrent, METH_NOARGS,
M_World_GetCurrent_doc},
{"get", M_World_Get, METH_VARARGS, M_World_Get_doc},
{NULL, NULL, 0, NULL}
};
/*****************************************************************************/
/* Python BPy_World methods table: */
/*****************************************************************************/
static PyMethodDef BPy_World_methods[] = {
{"getRange", ( PyCFunction ) World_getRange, METH_NOARGS,
"() - Return World Range"},
{"setRange", ( PyCFunction ) World_setRange, METH_VARARGS,
"() - Change this World's range"},
{"getIpo", ( PyCFunction ) World_getIpo, METH_NOARGS,
"() - Return World Ipo"},
{"setIpo", ( PyCFunction ) World_setIpo, METH_VARARGS,
"() - Change this World's ipo"},
{"clearIpo", ( PyCFunction ) World_clearIpo, METH_VARARGS,
"() - Unlink Ipo from this World"},
{"getName", ( PyCFunction ) World_getName, METH_NOARGS,
"() - Return World Data name"},
{"setName", ( PyCFunction ) World_setName, METH_VARARGS,
"() - Return World Data name"},
{"getSkytype", ( PyCFunction ) World_getSkytype, METH_NOARGS,
"() - Return World Data skytype"},
{"setSkytype", ( PyCFunction ) World_setSkytype, METH_VARARGS,
"() - Return World Data skytype"},
{"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"},
{"getMist", ( PyCFunction ) World_getMist, METH_NOARGS,
"() - Return World Data mist"},
{"setMist", ( PyCFunction ) World_setMist, METH_VARARGS,
"() - Return World Data mist"},
{"getScriptLinks", ( PyCFunction ) World_getScriptLinks, METH_VARARGS,
"(eventname) - Get a list of this world's scriptlinks (Text names) "
"of the given type\n"
"(eventname) - string: FrameChanged or Redraw."},
{"addScriptLink", ( PyCFunction ) World_addScriptLink, METH_VARARGS,
"(text, evt) - Add a new world scriptlink.\n"
"(text) - string: an existing Blender Text name;\n"
"(evt) string: FrameChanged or Redraw."},
{"clearScriptLinks", ( PyCFunction ) World_clearScriptLinks,
METH_NOARGS,
"() - Delete all scriptlinks from this world :)."},
{"setCurrent", ( PyCFunction ) World_setCurrent, METH_NOARGS,
"() - Makes this world the active world for the current scene."},
{"makeActive", ( PyCFunction ) World_setCurrent, METH_NOARGS,
"please use setCurrent instead, this alias will be removed."},
{NULL, NULL, 0, NULL}
};
/*****************************************************************************/
/* Python World_Type structure definition: */
/*****************************************************************************/
PyTypeObject World_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"World", /* tp_name */
sizeof( BPy_World ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
( destructor ) World_DeAlloc, /* tp_dealloc */
0, /* 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,
BPy_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;
BPy_World *pyworld;
World *blworld;
if( !PyArg_ParseTuple( args, "s", &name ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected int argument" ) );
blworld = add_world( name );
if( blworld ) {
/* return user count to zero because add_world() inc'd it */
blworld->id.us = 0;
/* create python wrapper obj */
pyworld =
( BPy_World * ) PyObject_NEW( BPy_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;
BPy_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 =
( BPy_World * )
PyObject_NEW( BPy_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 ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create PyList" ) );
while( world_iter ) {
BPy_World *found_world =
( BPy_World * ) PyObject_NEW( BPy_World,
&World_Type );
found_world->world = world_iter;
PyList_Append( worldlist, ( PyObject * ) found_world );
world_iter = world_iter->id.next;
}
return ( worldlist );
}
}
static PyObject *M_World_GetCurrent( PyObject * self )
{
BPy_World *w = NULL;
if( !G.scene->world ) {
Py_INCREF( Py_None );
return Py_None;
}
w = ( BPy_World * ) PyObject_NEW( BPy_World, &World_Type );
w->world = G.scene->world;
return ( PyObject * ) w;
}
/*@}*/
/**
* \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 *World_Init( void )
{
PyObject *submodule;
World_Type.ob_type = &PyType_Type;
submodule = Py_InitModule3( "Blender.World",
M_World_methods, M_World_doc );
return ( submodule );
}
/*****************************************************************************/
/* Python BPy_World methods: */
/*****************************************************************************/
static PyObject *World_getRange( BPy_World * self )
{
return PyFloat_FromDouble( self->world->range );
}
static PyObject *World_setRange( BPy_World * self, PyObject * args )
{
float range = 0.f;
if( !PyArg_ParseTuple( args, "f", &range ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError, "expected a float argument" ) );
self->world->range = range;
Py_INCREF( Py_None );
return Py_None;
}
static PyObject *World_getIpo( BPy_World * self )
{
struct Ipo *ipo = self->world->ipo;
if( !ipo ) {
Py_INCREF( Py_None );
return Py_None;
}
return Ipo_CreatePyObject( ipo );
}
static PyObject *World_setIpo( BPy_World * self, PyObject * args )
{
PyObject *pyipo = 0;
Ipo *ipo = NULL;
Ipo *oldipo;
if( !PyArg_ParseTuple( args, "O!", &Ipo_Type, &pyipo ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"expected Ipo as argument" );
ipo = Ipo_FromPyObject( pyipo );
if( !ipo )
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"null ipo!" );
if( ipo->blocktype != ID_WO )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"this ipo is not a World type ipo" );
oldipo = self->world->ipo;
if( oldipo ) {
ID *id = &oldipo->id;
if( id->us > 0 )
id->us--;
}
( ( ID * ) & ipo->id )->us++;
self->world->ipo = ipo;
Py_INCREF( Py_None );
return Py_None;
}
static PyObject *World_clearIpo( BPy_World * self )
{
World *world = self->world;
Ipo *ipo = ( Ipo * ) world->ipo;
if( ipo ) {
ID *id = &ipo->id;
if( id->us > 0 )
id->us--;
world->ipo = NULL;
Py_INCREF( Py_True );
return Py_True;
}
Py_INCREF( Py_False ); /* no ipo found */
return Py_False;
}
/**
* \brief World PyMethod getName
*
* \return string: The World Data name.
*/
static PyObject *World_getName( BPy_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( BPy_World * self, PyObject * args )
{
char *name = 0;
char buf[21];
if( !PyArg_ParseTuple( args, "s", &name ) )
return ( EXPP_ReturnPyObjError
( PyExc_TypeError, "expected string argument" ) );
snprintf( buf, sizeof( buf ), "%s", name );
rename_id( &self->world->id, buf );
Py_INCREF( Py_None );
return Py_None;
}
/**
* \brief World PyMethod getSkytype
*
* \return int : The World Data skytype.
*/
static PyObject *World_getSkytype( BPy_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( BPy_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( BPy_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( BPy_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 getMistype
*
* \return int : The World Data mistype.
*/
static PyObject *World_getMistype( BPy_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( BPy_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( BPy_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( BPy_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( BPy_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( BPy_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( BPy_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( BPy_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( BPy_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( BPy_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_getMist( BPy_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( BPy_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;
}
/* world.addScriptLink */
static PyObject *World_addScriptLink( BPy_World * self, PyObject * args )
{
World *world = self->world;
ScriptLink *slink = NULL;
slink = &( world )->scriptlink;
if( !EXPP_addScriptLink( slink, args, 0 ) )
return EXPP_incr_ret( Py_None );
else
return NULL;
}
/* world.clearScriptLinks */
static PyObject *World_clearScriptLinks( BPy_World * self )
{
World *world = self->world;
ScriptLink *slink = NULL;
slink = &( world )->scriptlink;
return EXPP_incr_ret( Py_BuildValue
( "i", EXPP_clearScriptLinks( slink ) ) );
}
/* world.getScriptLinks */
static PyObject *World_getScriptLinks( BPy_World * self, PyObject * args )
{
World *world = self->world;
ScriptLink *slink = NULL;
PyObject *ret = NULL;
slink = &( world )->scriptlink;
ret = EXPP_getScriptLinks( slink, args, 0 );
if( ret )
return ret;
else
return NULL;
}
/* world.setCurrent */
static PyObject *World_setCurrent( BPy_World * self )
{
World *world = self->world;
/* If there is a world then it now has one less user */
if( G.scene->world )
G.scene->world->id.us--;
world->id.us++;
G.scene->world = world;
Py_INCREF( Py_None );
return Py_None;
}
/*@{*/
/**
* \brief The World PyType destructor
*/
static void World_DeAlloc( BPy_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( BPy_World * self, char *name )
{
if( strcmp( name, "name" ) == 0 )
return World_getName( self );
if( strcmp( name, "skytype" ) == 0 )
return World_getSkytype( self );
if( strcmp( name, "mode" ) == 0 )
return World_getMode( 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, "mist" ) == 0 )
return World_getMist( self );
if( strcmp( name, "users" ) == 0 )
return PyInt_FromLong( self->world->id.us );
return Py_FindMethod( BPy_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( BPy_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, "skytype" ) == 0 )
World_setSkytype( self, valtuple );
if( strcmp( name, "mode" ) == 0 )
World_setMode( 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, "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( BPy_World * a, BPy_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(BPy_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( BPy_World * self )
{
return PyString_FromFormat( "[World \"%s\"]",
self->world->id.name + 2 );
}
/*@}*/
/*
static int World_compare (BPy_World *a, BPy_World *b)
{
World *pa = a->world, *pb = b->world;
return (pa == pb) ? 0:-1;
}
*/
PyObject *World_CreatePyObject( struct World * world )
{
BPy_World *blen_object;
blen_object = ( BPy_World * ) PyObject_NEW( BPy_World, &World_Type );
if( blen_object == NULL ) {
return ( NULL );
}
blen_object->world = world;
return ( ( PyObject * ) blen_object );
}
int World_CheckPyObject( PyObject * py_obj )
{
return ( py_obj->ob_type == &World_Type );
}
World *World_FromPyObject( PyObject * py_obj )
{
BPy_World *blen_obj;
blen_obj = ( BPy_World * ) py_obj;
return ( blen_obj->world );
}
/*****************************************************************************/
/* Description: Returns the object with the name specified by the argument */
/* name. Note that the calling function has to remove the first */
/* two characters of the object name. These two characters */
/* specify the type of the object (OB, ME, WO, ...) */
/* The function will return NULL when no object with the given */
/* name is found. */
/*****************************************************************************/
World *GetWorldByName( char *name )
{
World *world_iter;
world_iter = G.main->world.first;
while( world_iter ) {
if( StringEqual( name, GetIdName( &( world_iter->id ) ) ) ) {
return ( world_iter );
}
world_iter = world_iter->id.next;
}
/* There is no object with the given name */
return ( NULL );
}
View Git Blame Copy Permalink