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
b21df550d3a7aaa5925effe4fb7dc38f99592c22
blender-archive/source/blender/python/api2_2x/World.c
Campbell Barton 0a2b8b1308 A user submitted a BVH file that took a long time to import (I didnt end up finishing since it was so slow) 
this is mainly because adding pose keyframes recalculates every handle so importing became increasingly slow.

added a 'fast' argument to insertkey that python api's insertPoseKey can make use of since it alredy accepts a 'fast' option.

The ~4450 frame, 31 bone BVH imports in ~108sec now

Seperated editmode switch statement in space.c's event handling,
if editmode is disabled, or the images is a render or composite, UV editing operations are ignored.
In previous releases it has given an annoying warning if selecting or scaling is attempted when out of UV/Face mode.
2007-09-18 06:41:29 +00:00

1035 lines
34 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, Johnny Matthews
*
* ***** 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 "World.h" /*This must come first*/
#include "DNA_scene_types.h" /* for G.scene */
#include "BKE_global.h"
#include "BKE_world.h"
#include "BKE_main.h"
#include "BKE_library.h"
#include "BLI_blenlib.h"
#include "BSE_editipo.h"
#include "BIF_space.h"
#include "mydevice.h"
#include "Ipo.h"
#include "gen_utils.h"
#include "gen_library.h"
#define IPOKEY_ZENITH 0
#define IPOKEY_HORIZON 1
#define IPOKEY_MIST 2
#define IPOKEY_STARS 3
#define IPOKEY_OFFSET 4
#define IPOKEY_SIZE 5
/*****************************************************************************/
/* 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_oldsetIpo( BPy_World * self, PyObject * args );
static int World_setIpo( BPy_World * self, PyObject * args );
static PyObject *World_clearIpo( BPy_World * self );
static PyObject *World_insertIpoKey( BPy_World * self, PyObject * args );
static PyObject *World_getMode( BPy_World * self );
static PyObject *World_oldsetMode( BPy_World * self, PyObject * args );
static int World_setMode( BPy_World * self, PyObject * args );
static PyObject *World_getSkytype( BPy_World * self );
static PyObject *World_oldsetSkytype( BPy_World * self, PyObject * args );
static int World_setSkytype( BPy_World * self, PyObject * args );
static PyObject *World_getMistype( BPy_World * self );
static PyObject *World_oldsetMistype( BPy_World * self, PyObject * args );
static int World_setMistype( BPy_World * self, PyObject * args );
static PyObject *World_getHor( BPy_World * self );
static PyObject *World_oldsetHor( BPy_World * self, PyObject * args );
static int World_setHor( BPy_World * self, PyObject * args );
static PyObject *World_getZen( BPy_World * self );
static PyObject *World_oldsetZen( BPy_World * self, PyObject * args );
static int World_setZen( BPy_World * self, PyObject * args );
static PyObject *World_getAmb( BPy_World * self );
static PyObject *World_oldsetAmb( BPy_World * self, PyObject * args );
static int World_setAmb( BPy_World * self, PyObject * args );
static PyObject *World_getStar( BPy_World * self );
static PyObject *World_oldsetStar( BPy_World * self, PyObject * args );
static int World_setStar( BPy_World * self, PyObject * args );
static PyObject *World_getMist( BPy_World * self );
static PyObject *World_oldsetMist( BPy_World * self, PyObject * args );
static int World_setMist( BPy_World * self, PyObject * args );
static PyObject *World_getScriptLinks( BPy_World * self, PyObject * value );
static PyObject *World_addScriptLink( BPy_World * self, PyObject * args );
static PyObject *World_clearScriptLinks( BPy_World * self, PyObject * args );
static PyObject *World_setCurrent( BPy_World * self );
static PyObject *World_copy( 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 int World_Print (BPy_World *self, FILE *fp, int flags);
static int World_Compare( BPy_World * a, BPy_World * b );
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_oldsetIpo, METH_VARARGS,
"() - Change this World's ipo"},
{"clearIpo", ( PyCFunction ) World_clearIpo, METH_VARARGS,
"() - Unlink Ipo from this World"},
{"getName", ( PyCFunction ) GenericLib_getName, METH_NOARGS,
"() - Return World Data name"},
{"setName", ( PyCFunction ) GenericLib_setName_with_method, METH_VARARGS,
"() - Set World Data name"},
{"getMode", ( PyCFunction ) World_getMode, METH_NOARGS,
"() - Return World Data mode"},
{"setMode", ( PyCFunction ) World_oldsetMode, METH_VARARGS,
"(i) - Set World Data mode"},
{"getSkytype", ( PyCFunction ) World_getSkytype, METH_NOARGS,
"() - Return World Data skytype"},
{"setSkytype", ( PyCFunction ) World_oldsetSkytype, METH_VARARGS,
"() - Return World Data skytype"},
{"getMistype", ( PyCFunction ) World_getMistype, METH_NOARGS,
"() - Return World Data mistype"},
{"setMistype", ( PyCFunction ) World_oldsetMistype, METH_VARARGS,
"() - Return World Data mistype"},
{"getHor", ( PyCFunction ) World_getHor, METH_NOARGS,
"() - Return World Data hor"},
{"setHor", ( PyCFunction ) World_oldsetHor, METH_VARARGS,
"() - Return World Data hor"},
{"getZen", ( PyCFunction ) World_getZen, METH_NOARGS,
"() - Return World Data zen"},
{"setZen", ( PyCFunction ) World_oldsetZen, METH_VARARGS,
"() - Return World Data zen"},
{"getAmb", ( PyCFunction ) World_getAmb, METH_NOARGS,
"() - Return World Data amb"},
{"setAmb", ( PyCFunction ) World_oldsetAmb, METH_VARARGS,
"() - Return World Data amb"},
{"getStar", ( PyCFunction ) World_getStar, METH_NOARGS,
"() - Return World Data star"},
{"setStar", ( PyCFunction ) World_oldsetStar, METH_VARARGS,
"() - Return World Data star"},
{"getMist", ( PyCFunction ) World_getMist, METH_NOARGS,
"() - Return World Data mist"},
{"setMist", ( PyCFunction ) World_oldsetMist, METH_VARARGS,
"() - Return World Data mist"},
{"getScriptLinks", ( PyCFunction ) World_getScriptLinks, METH_O,
"(eventname) - Get a list of this world's scriptlinks (Text names) "
"of the given type\n"
"(eventname) - string: FrameChanged, Redraw or Render."},
{"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, Redraw or Render."},
{"clearScriptLinks", ( PyCFunction ) World_clearScriptLinks,
METH_VARARGS,
"() - Delete all scriptlinks from this world.\n"
"([s1<,s2,s3...>]) - Delete specified 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."},
{"insertIpoKey", ( PyCFunction ) World_insertIpoKey, METH_VARARGS,
"( World IPO type ) - Inserts a key into the IPO"},
{"__copy__", ( PyCFunction ) World_copy, METH_NOARGS,
"() - Makes a copy of this world."},
{"copy", ( PyCFunction ) World_copy, METH_NOARGS,
"() - Makes a copy of this world."},
{NULL, NULL, 0, NULL}
};
/*****************************************************************************/
/* Python attributes get/set structure: */
/*****************************************************************************/
static PyGetSetDef BPy_World_getseters[] = {
GENERIC_LIB_GETSETATTR,
{"skytype", (getter)World_getSkytype, (setter)World_setSkytype,
"sky settings as a list", NULL},
{"mode", (getter)World_getMode, (setter)World_setMode,
"world mode", NULL},
{"mistype", (getter)World_getMistype, (setter)World_setMistype,
"world mist type", NULL},
{"hor", (getter)World_getHor, (setter)World_setHor,
"world horizon color", NULL},
{"amb", (getter)World_getAmb, (setter)World_setAmb,
"world ambient color", NULL},
{"mist", (getter)World_getMist, (setter)World_setMist,
"world mist settings", NULL},
{"ipo", (getter)World_getIpo, (setter)World_setIpo,
"world ipo", NULL},
{NULL,NULL,NULL,NULL,NULL} /* Sentinel */
};
/*****************************************************************************/
/* 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 */
NULL, /* tp_dealloc */
0, /* tp_print */
NULL, /* tp_getattr */
NULL, /* tp_setattr */
( cmpfunc ) World_Compare, /* tp_compare */
( reprfunc ) World_Repr, /* tp_repr */
/* Method suites for standard classes */
NULL, /* PyNumberMethods *tp_as_number; */
NULL, /* PySequenceMethods *tp_as_sequence; */
NULL, /* PyMappingMethods *tp_as_mapping; */
/* More standard operations (here for binary compatibility) */
( hashfunc ) GenericLib_hash, /* hashfunc tp_hash; */
NULL, /* ternaryfunc tp_call; */
NULL, /* reprfunc tp_str; */
NULL, /* getattrofunc tp_getattro; */
NULL, /* setattrofunc tp_setattro; */
/* Functions to access object as input/output buffer */
NULL, /* PyBufferProcs *tp_as_buffer; */
/*** Flags to define presence of optional/expanded features ***/
Py_TPFLAGS_DEFAULT, /* long tp_flags; */
NULL, /* char *tp_doc; Documentation string */
/*** Assigned meaning in release 2.0 ***/
/* call function for all accessible objects */
NULL, /* traverseproc tp_traverse; */
/* delete references to contained objects */
NULL, /* inquiry tp_clear; */
/*** Assigned meaning in release 2.1 ***/
/*** rich comparisons ***/
NULL, /* richcmpfunc tp_richcompare; */
/*** weak reference enabler ***/
0, /* long tp_weaklistoffset; */
/*** Added in release 2.2 ***/
/* Iterators */
NULL, /* getiterfunc tp_iter; */
NULL, /* iternextfunc tp_iternext; */
/*** Attribute descriptor and subclassing stuff ***/
BPy_World_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
BPy_World_getseters, /* struct PyGetSetDef *tp_getset; */
NULL, /* struct _typeobject *tp_base; */
NULL, /* PyObject *tp_dict; */
NULL, /* descrgetfunc tp_descr_get; */
NULL, /* descrsetfunc tp_descr_set; */
0, /* long tp_dictoffset; */
NULL, /* initproc tp_init; */
NULL, /* allocfunc tp_alloc; */
NULL, /* newfunc tp_new; */
/* Low-level free-memory routine */
NULL, /* freefunc tp_free; */
/* For PyObject_IS_GC */
NULL, /* inquiry tp_is_gc; */
NULL, /* PyObject *tp_bases; */
/* method resolution order */
NULL, /* PyObject *tp_mro; */
NULL, /* PyObject *tp_cache; */
NULL, /* PyObject *tp_subclasses; */
NULL, /* PyObject *tp_weaklist; */
NULL
};
/**
* \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 )
{
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;
char error_msg[64];
if( !PyArg_ParseTuple( args, "|s", &name ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected string argument (or nothing)" ) );
if( name ) { /* (name) - Search world by name */
world_iter = ( World * ) GetIdFromList( &( G.main->world ), name );
if( world_iter == 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 * ) World_CreatePyObject(world_iter);
}
else { /* return a list of all worlds in the scene */
world_iter = G.main->world.first;
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 );
Py_DECREF(found_world);
world_iter = world_iter->id.next;
}
return ( worldlist );
}
}
static PyObject *M_World_GetCurrent( PyObject * self )
{
BPy_World *w = NULL;
#if 0 /* add back in when bpy becomes "official" */
static char warning = 1;
if( warning ) {
printf("Blender.World.GetCurrent() deprecated!\n\tuse bpy.scenes.world instead\n");
--warning;
}
#endif
if( !G.scene->world )
Py_RETURN_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;
if( PyType_Ready( &World_Type ) < 0 )
return NULL;
submodule = Py_InitModule3( "Blender.World",
M_World_methods, M_World_doc );
PyModule_AddIntConstant( submodule, "ZENITH", IPOKEY_ZENITH );
PyModule_AddIntConstant( submodule, "HORIZON", IPOKEY_HORIZON );
PyModule_AddIntConstant( submodule, "MIST", IPOKEY_MIST );
PyModule_AddIntConstant( submodule, "STARS", IPOKEY_STARS );
PyModule_AddIntConstant( submodule, "OFFSET", IPOKEY_OFFSET );
PyModule_AddIntConstant( submodule, "SIZE", IPOKEY_SIZE );
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_RETURN_NONE;
}
static PyObject *World_getIpo( BPy_World * self )
{
struct Ipo *ipo = self->world->ipo;
if( !ipo )
Py_RETURN_NONE;
return Ipo_CreatePyObject( ipo );
}
static int World_setIpo( BPy_World * self, PyObject * value )
{
return GenericLib_assignData(value, (void **) &self->world->ipo, 0, 1, ID_IP, ID_WO);
}
static PyObject *World_oldsetIpo( BPy_World * self, PyObject * args )
{
return EXPP_setterWrapper( (void *)self, args, (setter)World_setIpo );
}
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;
return EXPP_incr_ret_True();
}
return EXPP_incr_ret_False(); /* no ipo found */
}
/**
* \brief World PyMethod getSkytype
*
* \return int : The World Data skytype.
*/
static PyObject *World_getSkytype( BPy_World * self )
{
return PyInt_FromLong( ( long ) self->world->skytype );
}
/**
* \brief World PyMethod setSkytype
*
* \return int : The World Data skytype.
*/
static int World_setSkytype( BPy_World * self, PyObject * value )
{
if( !PyInt_Check(value) )
return ( EXPP_ReturnIntError( PyExc_TypeError,
"expected int argument" ) );
self->world->skytype = (short)PyInt_AsLong(value);
return 0;
}
static PyObject *World_oldsetSkytype( BPy_World * self, PyObject * args )
{
return EXPP_setterWrapper( (void *)self, args, (setter)World_setSkytype );
}
/**
* \brief World PyMethod getMode
*
* \return int : The World Data mode.
*/
static PyObject *World_getMode( BPy_World * self )
{
return PyInt_FromLong( ( long ) self->world->mode );
}
/**
* \brief World PyMethod setMode
*
* \return int : The World Data mode.
*/
static int World_setMode( BPy_World * self, PyObject * value )
{
if( !PyInt_Check(value) )
return ( EXPP_ReturnIntError( PyExc_TypeError,
"expected int argument" ) );
self->world->mode = (short)PyInt_AsLong(value);
return 0;
}
static PyObject *World_oldsetMode( BPy_World * self, PyObject * args )
{
return EXPP_setterWrapper( (void *)self, args, (setter)World_setMode );
}
/**
* \brief World PyMethod getMistype
*
* \return int : The World Data mistype.
*/
static PyObject *World_getMistype( BPy_World * self )
{
return PyInt_FromLong( ( long ) self->world->mistype );
}
/**
* \brief World PyMethod setMistype
*
* \return int : The World Data mistype.
*/
static int World_setMistype( BPy_World * self, PyObject * value )
{
if( !PyInt_Check(value) )
return ( EXPP_ReturnIntError( PyExc_TypeError,
"expected int argument" ) );
self->world->mistype = (short)PyInt_AsLong(value);
return 0;
}
static PyObject *World_oldsetMistype( BPy_World * self, PyObject * args )
{
return EXPP_setterWrapper( (void *)self, args, (setter)World_setMistype );
}
static PyObject *World_getHor( BPy_World * self )
{
PyObject *attr = PyList_New( 3 );
if( !attr )
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't create list" ) );
PyList_SET_ITEM( attr, 0, PyFloat_FromDouble( self->world->horr ) );
PyList_SET_ITEM( attr, 1, PyFloat_FromDouble( self->world->horg ) );
PyList_SET_ITEM( attr, 2, PyFloat_FromDouble( self->world->horb ) );
return attr;
}
static int World_setHor( BPy_World * self, PyObject * value )
{
if( !PyList_Check( value ) )
return ( EXPP_ReturnIntError( PyExc_TypeError,
"expected list argument" ) );
if( PyList_Size( value ) != 3 )
return ( EXPP_ReturnIntError
( PyExc_TypeError, "list size must be 3" ) );
self->world->horr = (float)PyFloat_AsDouble( PyList_GetItem( value, 0 ) );
self->world->horg = (float)PyFloat_AsDouble( PyList_GetItem( value, 1 ) );
self->world->horb = (float)PyFloat_AsDouble( PyList_GetItem( value, 2 ) );
return 0;
}
static PyObject *World_oldsetHor( BPy_World * self, PyObject * args )
{
return EXPP_setterWrapper( (void *)self, args, (setter)World_setHor );
}
static PyObject *World_getZen( BPy_World * self )
{
PyObject *attr = PyList_New( 3 );
if( !attr )
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't create list" ) );
PyList_SET_ITEM( attr, 0, PyFloat_FromDouble( self->world->zenr ) );
PyList_SET_ITEM( attr, 1, PyFloat_FromDouble( self->world->zeng ) );
PyList_SET_ITEM( attr, 2, PyFloat_FromDouble( self->world->zenb ) );
return attr;
}
static int World_setZen( BPy_World * self, PyObject * value )
{
if( !PyList_Check( value ) )
return ( EXPP_ReturnIntError( PyExc_TypeError,
"expected list argument" ) );
if( PyList_Size( value ) != 3 )
return ( EXPP_ReturnIntError
( PyExc_TypeError, "list size must be 3" ) );
self->world->zenr = (float)PyFloat_AsDouble( PyList_GetItem( value, 0 ) );
self->world->zeng = (float)PyFloat_AsDouble( PyList_GetItem( value, 1 ) );
self->world->zenb = (float)PyFloat_AsDouble( PyList_GetItem( value, 2 ) );
return 0;
}
static PyObject *World_oldsetZen( BPy_World * self, PyObject * args )
{
return EXPP_setterWrapper( (void *)self, args, (setter)World_setZen );
}
static PyObject *World_getAmb( BPy_World * self )
{
PyObject *attr = PyList_New( 3 );
if( !attr )
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't create list" ) );
PyList_SET_ITEM( attr, 0, PyFloat_FromDouble( self->world->ambr ) );
PyList_SET_ITEM( attr, 1, PyFloat_FromDouble( self->world->ambg ) );
PyList_SET_ITEM( attr, 2, PyFloat_FromDouble( self->world->ambb ) );
return attr;
}
static int World_setAmb( BPy_World * self, PyObject * value )
{
if( !PyList_Check( value ) )
return ( EXPP_ReturnIntError( PyExc_TypeError,
"expected list argument" ) );
if( PyList_Size( value ) != 3 )
return ( EXPP_ReturnIntError
( PyExc_TypeError, "wrong list size" ) );
self->world->ambr = (float)PyFloat_AsDouble( PyList_GetItem( value, 0 ) );
self->world->ambg = (float)PyFloat_AsDouble( PyList_GetItem( value, 1 ) );
self->world->ambb = (float)PyFloat_AsDouble( PyList_GetItem( value, 2 ) );
return 0;
}
static PyObject *World_oldsetAmb( BPy_World * self, PyObject * args )
{
return EXPP_setterWrapper( (void *)self, args, (setter)World_setAmb );
}
static PyObject *World_getStar( BPy_World * self )
{
PyObject *attr = PyList_New( 7 );
if( !attr )
return ( EXPP_ReturnPyObjError
( PyExc_RuntimeError, "couldn't create list" ) );
PyList_SET_ITEM( attr, 0, PyFloat_FromDouble( self->world->starr ) );
PyList_SET_ITEM( attr, 1, PyFloat_FromDouble( self->world->starg ) );
PyList_SET_ITEM( attr, 2, PyFloat_FromDouble( self->world->starb ) );
PyList_SET_ITEM( attr, 3, PyFloat_FromDouble( self->world->starsize ) );
PyList_SET_ITEM( attr, 4, PyFloat_FromDouble( self->world->starmindist ) );
PyList_SET_ITEM( attr, 5, PyFloat_FromDouble( self->world->stardist ) );
PyList_SET_ITEM( attr, 6, PyFloat_FromDouble( self->world->starcolnoise ) );
return attr;
}
static int World_setStar( BPy_World * self, PyObject * value )
{
if( !PyList_Check( value ) )
return ( EXPP_ReturnIntError
( PyExc_TypeError, "expected list argument" ) );
if( PyList_Size( value ) != 7 )
return ( EXPP_ReturnIntError
( PyExc_TypeError, "wrong list size" ) );
self->world->starr = (float)PyFloat_AsDouble( PyList_GetItem( value, 0 ) );
self->world->starg = (float)PyFloat_AsDouble( PyList_GetItem( value, 1 ) );
self->world->starb = (float)PyFloat_AsDouble( PyList_GetItem( value, 2 ) );
self->world->starsize =
(float)PyFloat_AsDouble( PyList_GetItem( value, 3 ) );
self->world->starmindist =
(float)PyFloat_AsDouble( PyList_GetItem( value, 4 ) );
self->world->stardist =
(float)PyFloat_AsDouble( PyList_GetItem( value, 5 ) );
self->world->starcolnoise =
(float)PyFloat_AsDouble( PyList_GetItem( value, 6 ) );
return 0;
}
static PyObject *World_oldsetStar( BPy_World * self, PyObject * args )
{
return EXPP_setterWrapper( (void *)self, args, (setter)World_setStar );
}
static PyObject *World_getMist( BPy_World * self )
{
PyObject *attr = PyList_New( 4 );
if( !attr )
return ( EXPP_ReturnPyObjError
( PyExc_RuntimeError, "couldn't create list" ) );
PyList_SET_ITEM( attr, 0, PyFloat_FromDouble( self->world->misi ) );
PyList_SET_ITEM( attr, 1, PyFloat_FromDouble( self->world->miststa ) );
PyList_SET_ITEM( attr, 2, PyFloat_FromDouble( self->world->mistdist ) );
PyList_SET_ITEM( attr, 3, PyFloat_FromDouble( self->world->misthi ) );
return attr;
}
static int World_setMist( BPy_World * self, PyObject * value )
{
if( !PyList_Check( value ) )
return ( EXPP_ReturnIntError
( PyExc_TypeError, "expected list argument" ) );
if( PyList_Size( value ) != 4 )
return ( EXPP_ReturnIntError
( PyExc_TypeError, "wrong list size" ) );
self->world->misi = (float)PyFloat_AsDouble( PyList_GetItem( value, 0 ) );
self->world->miststa =
(float)PyFloat_AsDouble( PyList_GetItem( value, 1 ) );
self->world->mistdist =
(float)PyFloat_AsDouble( PyList_GetItem( value, 2 ) );
self->world->misthi =
(float)PyFloat_AsDouble( PyList_GetItem( value, 3 ) );
return 0;
}
static PyObject *World_oldsetMist( BPy_World * self, PyObject * args )
{
return EXPP_setterWrapper( (void *)self, args, (setter)World_setMist );
}
/* world.addScriptLink */
static PyObject *World_addScriptLink( BPy_World * self, PyObject * args )
{
World *world = self->world;
ScriptLink *slink = NULL;
slink = &( world )->scriptlink;
return EXPP_addScriptLink( slink, args, 0 );
}
/* world.clearScriptLinks */
static PyObject *World_clearScriptLinks( BPy_World * self, PyObject * args )
{
World *world = self->world;
ScriptLink *slink = NULL;
slink = &( world )->scriptlink;
return EXPP_clearScriptLinks( slink, args );
}
/* world.getScriptLinks */
static PyObject *World_getScriptLinks( BPy_World * self, PyObject * value )
{
World *world = self->world;
ScriptLink *slink = NULL;
PyObject *ret = NULL;
slink = &( world )->scriptlink;
ret = EXPP_getScriptLinks( slink, value, 0 );
if( ret )
return ret;
else
return NULL;
}
/* world.setCurrent */
static PyObject *World_setCurrent( BPy_World * self )
{
World *world = self->world;
#if 0 /* add back in when bpy becomes "official" */
static char warning = 1;
if( warning ) {
printf("world.setCurrent() deprecated!\n\tuse bpy.scenes.world=world instead\n");
--warning;
}
#endif
/* 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_RETURN_NONE;
}
/* world.__copy__ */
static PyObject *World_copy( BPy_World * self )
{
World *world = copy_world(self->world );
world->id.us = 0;
return World_CreatePyObject(world);
}
/**
* \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 )
{
return ( a->world == b->world ) ? 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 );
}
World *World_FromPyObject( PyObject * py_obj )
{
BPy_World *blen_obj;
blen_obj = ( BPy_World * ) py_obj;
return ( blen_obj->world );
}
/*
* World_insertIpoKey()
* inserts World IPO key for ZENITH,HORIZON,MIST,STARS,OFFSET,SIZE
*/
static PyObject *World_insertIpoKey( BPy_World * self, PyObject * args )
{
int key = 0, map;
if( !PyArg_ParseTuple( args, "i", &( key ) ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected int argument" ) );
map = texchannel_to_adrcode(self->world->texact);
if(key == IPOKEY_ZENITH) {
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_ZEN_R, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_ZEN_G, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_ZEN_B, 0);
}
if(key == IPOKEY_HORIZON) {
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_HOR_R, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_HOR_G, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_HOR_B, 0);
}
if(key == IPOKEY_MIST) {
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_MISI, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_MISTDI, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_MISTSTA, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_MISTHI, 0);
}
if(key == IPOKEY_STARS) {
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_STAR_R, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_STAR_G, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_STAR_B, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_STARDIST, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, WO_STARSIZE, 0);
}
if(key == IPOKEY_OFFSET) {
insertkey((ID *)self->world, ID_WO, NULL, NULL, map+MAP_OFS_X, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, map+MAP_OFS_Y, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, map+MAP_OFS_Z, 0);
}
if(key == IPOKEY_SIZE) {
insertkey((ID *)self->world, ID_WO, NULL, NULL, map+MAP_SIZE_X, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, map+MAP_SIZE_Y, 0);
insertkey((ID *)self->world, ID_WO, NULL, NULL, map+MAP_SIZE_Z, 0);
}
allspace(REMAKEIPO, 0);
EXPP_allqueue(REDRAWIPO, 0);
EXPP_allqueue(REDRAWVIEW3D, 0);
EXPP_allqueue(REDRAWACTION, 0);
EXPP_allqueue(REDRAWNLA, 0);
Py_RETURN_NONE;
}
View Git Blame Copy Permalink