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
c4f6ac80df03aa236f8dbfe7dc92f6e06121cceb
blender-archive/source/blender/python/api2_2x/Lamp.c
Campbell Barton c97be098f7 Python API 
made all libdata hashable - use the object type,name and lib for the hash.
added .tag to libdata so we can test if data's been processed without using dictionaries
added libdataseq.tag (write only) setting the tag flag (which can always be dirty)
2007-03-26 02:10:24 +00:00

1710 lines
57 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): Willian P. Germano, Nathan Letwory, Stephen Swaney,
* Ken Hughes
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
#include "Lamp.h" /*This must come first*/
#include "BKE_main.h"
#include "BKE_global.h"
#include "BKE_object.h"
#include "BKE_library.h"
#include "BLI_blenlib.h"
#include "BIF_space.h"
#include "BSE_editipo.h"
#include "mydevice.h"
#include "Ipo.h"
#include "constant.h"
#include "gen_utils.h"
#include "gen_library.h"
/*****************************************************************************/
/* Python BPy_Lamp defaults: */
/*****************************************************************************/
/* Lamp types */
/* NOTE:
these are the same values as LA_* from DNA_lamp_types.h
is there some reason we are not simply using those #defines?
s. swaney 8-oct-2004
*/
#define EXPP_LAMP_TYPE_LAMP 0
#define EXPP_LAMP_TYPE_SUN 1
#define EXPP_LAMP_TYPE_SPOT 2
#define EXPP_LAMP_TYPE_HEMI 3
#define EXPP_LAMP_TYPE_AREA 4
#define EXPP_LAMP_TYPE_YF_PHOTON 5
/*
define a constant to keep magic numbers out of the code
this value should be equal to the last EXPP_LAMP_TYPE_*
*/
#define EXPP_LAMP_TYPE_MAX 5
/* Lamp mode flags */
#define EXPP_LAMP_MODE_SHADOWS 1
#define EXPP_LAMP_MODE_HALO 2
#define EXPP_LAMP_MODE_LAYER 4
#define EXPP_LAMP_MODE_QUAD 8
#define EXPP_LAMP_MODE_NEGATIVE 16
#define EXPP_LAMP_MODE_ONLYSHADOW 32
#define EXPP_LAMP_MODE_SPHERE 64
#define EXPP_LAMP_MODE_SQUARE 128
#define EXPP_LAMP_MODE_TEXTURE 256
#define EXPP_LAMP_MODE_OSATEX 512
#define EXPP_LAMP_MODE_DEEPSHADOW 1024
#define EXPP_LAMP_MODE_NODIFFUSE 2048
#define EXPP_LAMP_MODE_NOSPECULAR 4096
#define EXPP_LAMP_MODE_SHAD_RAY 8192
/* Lamp MIN, MAX values */
#define EXPP_LAMP_SAMPLES_MIN 1
#define EXPP_LAMP_SAMPLES_MAX 16
#define EXPP_LAMP_BUFFERSIZE_MIN 512
#define EXPP_LAMP_BUFFERSIZE_MAX 5120
#define EXPP_LAMP_ENERGY_MIN 0.0
#define EXPP_LAMP_ENERGY_MAX 10.0
#define EXPP_LAMP_DIST_MIN 0.1f
#define EXPP_LAMP_DIST_MAX 5000.0
#define EXPP_LAMP_SPOTSIZE_MIN 1.0
#define EXPP_LAMP_SPOTSIZE_MAX 180.0
#define EXPP_LAMP_SPOTBLEND_MIN 0.00
#define EXPP_LAMP_SPOTBLEND_MAX 1.00
#define EXPP_LAMP_CLIPSTART_MIN 0.1f
#define EXPP_LAMP_CLIPSTART_MAX 1000.0
#define EXPP_LAMP_CLIPEND_MIN 1.0
#define EXPP_LAMP_CLIPEND_MAX 5000.0
#define EXPP_LAMP_BIAS_MIN 0.01f
#define EXPP_LAMP_BIAS_MAX 5.00
#define EXPP_LAMP_SOFTNESS_MIN 1.0
#define EXPP_LAMP_SOFTNESS_MAX 100.0
#define EXPP_LAMP_HALOINT_MIN 0.0
#define EXPP_LAMP_HALOINT_MAX 5.0
#define EXPP_LAMP_HALOSTEP_MIN 0
#define EXPP_LAMP_HALOSTEP_MAX 12
#define EXPP_LAMP_QUAD1_MIN 0.0
#define EXPP_LAMP_QUAD1_MAX 1.0
#define EXPP_LAMP_QUAD2_MIN 0.0
#define EXPP_LAMP_QUAD2_MAX 1.0
#define EXPP_LAMP_COL_MIN 0.0
#define EXPP_LAMP_COL_MAX 1.0
/* Raytracing settings */
#define EXPP_LAMP_RAYSAMPLES_MIN 1
#define EXPP_LAMP_RAYSAMPLES_MAX 16
#define EXPP_LAMP_AREASIZE_MIN 0.01f
#define EXPP_LAMP_AREASIZE_MAX 100.0f
/* Lamp_setComponent() keys for which color to get/set */
#define EXPP_LAMP_COMP_R 0x00
#define EXPP_LAMP_COMP_G 0x01
#define EXPP_LAMP_COMP_B 0x02
#define IPOKEY_RGB 0
#define IPOKEY_ENERGY 1
#define IPOKEY_SPOTSIZE 2
#define IPOKEY_OFFSET 3
#define IPOKEY_SIZE 4
/*****************************************************************************/
/* Python API function prototypes for the Lamp module. */
/*****************************************************************************/
static PyObject *M_Lamp_New( PyObject * self, PyObject * args,
PyObject * keywords );
static PyObject *M_Lamp_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.Lamp.__doc__ */
/*****************************************************************************/
static char M_Lamp_doc[] = "The Blender Lamp module\n\n\
This module provides control over **Lamp Data** objects in Blender.\n\n\
Example::\n\n\
from Blender import Lamp\n\
l = Lamp.New('Spot') # create new 'Spot' lamp data\n\
l.setMode('square', 'shadow') # set these two lamp mode flags\n\
ob = Object.New('Lamp') # create new lamp object\n\
ob.link(l) # link lamp obj with lamp data\n";
static char M_Lamp_New_doc[] = "Lamp.New (type = 'Lamp', name = 'LampData'):\n\
Return a new Lamp Data object with the given type and name.";
static char M_Lamp_Get_doc[] = "Lamp.Get (name = None):\n\
Return the Lamp Data with the given name, None if not found, or\n\
Return a list with all Lamp Data objects in the current scene,\n\
if no argument was given.";
/*****************************************************************************/
/* Python method structure definition for Blender.Lamp module: */
/*****************************************************************************/
struct PyMethodDef M_Lamp_methods[] = {
{"New", ( PyCFunction ) M_Lamp_New, METH_VARARGS | METH_KEYWORDS,
M_Lamp_New_doc},
{"Get", M_Lamp_Get, METH_VARARGS, M_Lamp_Get_doc},
{"get", M_Lamp_Get, METH_VARARGS, M_Lamp_Get_doc},
{NULL, NULL, 0, NULL}
};
/*****************************************************************************/
/* Python BPy_Lamp methods declarations: */
/*****************************************************************************/
static PyObject *Lamp_getType( BPy_Lamp * self );
static PyObject *Lamp_getTypesConst( void );
static PyObject *Lamp_getMode( BPy_Lamp * self );
static PyObject *Lamp_getModesConst( void );
static PyObject *Lamp_getSamples( BPy_Lamp * self );
static PyObject *Lamp_getRaySamplesX( BPy_Lamp * self );
static PyObject *Lamp_getRaySamplesY( BPy_Lamp * self );
static PyObject *Lamp_getAreaSizeX( BPy_Lamp * self );
static PyObject *Lamp_getAreaSizeY( BPy_Lamp * self );
static PyObject *Lamp_getBufferSize( BPy_Lamp * self );
static PyObject *Lamp_getHaloStep( BPy_Lamp * self );
static PyObject *Lamp_getEnergy( BPy_Lamp * self );
static PyObject *Lamp_getDist( BPy_Lamp * self );
static PyObject *Lamp_getSpotSize( BPy_Lamp * self );
static PyObject *Lamp_getSpotBlend( BPy_Lamp * self );
static PyObject *Lamp_getClipStart( BPy_Lamp * self );
static PyObject *Lamp_getClipEnd( BPy_Lamp * self );
static PyObject *Lamp_getBias( BPy_Lamp * self );
static PyObject *Lamp_getSoftness( BPy_Lamp * self );
static PyObject *Lamp_getHaloInt( BPy_Lamp * self );
static PyObject *Lamp_getQuad1( BPy_Lamp * self );
static PyObject *Lamp_getQuad2( BPy_Lamp * self );
static PyObject *Lamp_getCol( BPy_Lamp * self );
static PyObject *Lamp_getIpo( BPy_Lamp * self );
static PyObject *Lamp_getComponent( BPy_Lamp * self, void * closure );
static PyObject *Lamp_clearIpo( BPy_Lamp * self );
static PyObject *Lamp_insertIpoKey( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetIpo( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetType( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetMode( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetSamples( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetRaySamplesX( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetRaySamplesY( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetAreaSizeX( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetAreaSizeY( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetBufferSize( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetHaloStep( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetEnergy( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetDist( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetSpotSize( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetSpotBlend( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetClipStart( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetClipEnd( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetBias( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetSoftness( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetHaloInt( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetQuad1( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetQuad2( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_oldsetCol( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_copy( BPy_Lamp * self );
static int Lamp_setIpo( BPy_Lamp * self, PyObject * args );
static int Lamp_setType( BPy_Lamp * self, PyObject * args );
static int Lamp_setMode( BPy_Lamp * self, PyObject * args );
static int Lamp_setSamples( BPy_Lamp * self, PyObject * args );
static int Lamp_setRaySamplesX( BPy_Lamp * self, PyObject * args );
static int Lamp_setRaySamplesY( BPy_Lamp * self, PyObject * args );
static int Lamp_setAreaSizeX( BPy_Lamp * self, PyObject * args );
static int Lamp_setAreaSizeY( BPy_Lamp * self, PyObject * args );
static int Lamp_setBufferSize( BPy_Lamp * self, PyObject * args );
static int Lamp_setHaloStep( BPy_Lamp * self, PyObject * args );
static int Lamp_setEnergy( BPy_Lamp * self, PyObject * args );
static int Lamp_setDist( BPy_Lamp * self, PyObject * args );
static int Lamp_setSpotSize( BPy_Lamp * self, PyObject * args );
static int Lamp_setSpotBlend( BPy_Lamp * self, PyObject * args );
static int Lamp_setClipStart( BPy_Lamp * self, PyObject * args );
static int Lamp_setClipEnd( BPy_Lamp * self, PyObject * args );
static int Lamp_setBias( BPy_Lamp * self, PyObject * args );
static int Lamp_setSoftness( BPy_Lamp * self, PyObject * args );
static int Lamp_setHaloInt( BPy_Lamp * self, PyObject * args );
static int Lamp_setQuad1( BPy_Lamp * self, PyObject * args );
static int Lamp_setQuad2( BPy_Lamp * self, PyObject * args );
static int Lamp_setCol( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_getScriptLinks( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_addScriptLink( BPy_Lamp * self, PyObject * args );
static PyObject *Lamp_clearScriptLinks( BPy_Lamp * self, PyObject * args );
static int Lamp_setComponent( BPy_Lamp * self, PyObject * value, void * closure );
/*****************************************************************************/
/* Python BPy_Lamp methods table: */
/*****************************************************************************/
static PyMethodDef BPy_Lamp_methods[] = {
/* name, method, flags, doc */
{"getType", ( PyCFunction ) Lamp_getType, METH_NOARGS,
"() - return Lamp type - 'Lamp':0, 'Sun':1, 'Spot':2, 'Hemi':3, 'Area':4, 'Photon':5"},
{"getMode", ( PyCFunction ) Lamp_getMode, METH_NOARGS,
"() - return Lamp mode flags (or'ed value)"},
{"getSamples", ( PyCFunction ) Lamp_getSamples, METH_NOARGS,
"() - return Lamp samples value"},
{"getRaySamplesX", ( PyCFunction ) Lamp_getRaySamplesX, METH_NOARGS,
"() - return Lamp raytracing samples on the X axis"},
{"getRaySamplesY", ( PyCFunction ) Lamp_getRaySamplesY, METH_NOARGS,
"() - return Lamp raytracing samples on the Y axis"},
{"getAreaSizeX", ( PyCFunction ) Lamp_getAreaSizeX, METH_NOARGS,
"() - return Lamp area size on the X axis"},
{"getAreaSizeY", ( PyCFunction ) Lamp_getAreaSizeY, METH_NOARGS,
"() - return Lamp area size on the Y axis"},
{"getBufferSize", ( PyCFunction ) Lamp_getBufferSize, METH_NOARGS,
"() - return Lamp buffer size value"},
{"getHaloStep", ( PyCFunction ) Lamp_getHaloStep, METH_NOARGS,
"() - return Lamp halo step value"},
{"getEnergy", ( PyCFunction ) Lamp_getEnergy, METH_NOARGS,
"() - return Lamp energy value"},
{"getDist", ( PyCFunction ) Lamp_getDist, METH_NOARGS,
"() - return Lamp clipping distance value"},
{"getSpotSize", ( PyCFunction ) Lamp_getSpotSize, METH_NOARGS,
"() - return Lamp spot size value"},
{"getSpotBlend", ( PyCFunction ) Lamp_getSpotBlend, METH_NOARGS,
"() - return Lamp spot blend value"},
{"getClipStart", ( PyCFunction ) Lamp_getClipStart, METH_NOARGS,
"() - return Lamp clip start value"},
{"getClipEnd", ( PyCFunction ) Lamp_getClipEnd, METH_NOARGS,
"() - return Lamp clip end value"},
{"getBias", ( PyCFunction ) Lamp_getBias, METH_NOARGS,
"() - return Lamp bias value"},
{"getSoftness", ( PyCFunction ) Lamp_getSoftness, METH_NOARGS,
"() - return Lamp softness value"},
{"getHaloInt", ( PyCFunction ) Lamp_getHaloInt, METH_NOARGS,
"() - return Lamp halo intensity value"},
{"getQuad1", ( PyCFunction ) Lamp_getQuad1, METH_NOARGS,
"() - return light intensity value #1 for a Quad Lamp"},
{"getQuad2", ( PyCFunction ) Lamp_getQuad2, METH_NOARGS,
"() - return light intensity value #2 for a Quad Lamp"},
{"getCol", ( PyCFunction ) Lamp_getCol, METH_NOARGS,
"() - return light rgb color triplet"},
{"setName", ( PyCFunction ) GenericLib_setName_with_method, METH_VARARGS,
"(str) - rename Lamp"},
{"setType", ( PyCFunction ) Lamp_oldsetType, METH_VARARGS,
"(str) - change Lamp type, which can be 'Lamp', 'Sun', 'Spot', 'Hemi', 'Area', 'Photon'"},
{"setMode", ( PyCFunction ) Lamp_oldsetMode, METH_VARARGS,
"([up to eight str's]) - Set Lamp mode flag(s)"},
{"setSamples", ( PyCFunction ) Lamp_oldsetSamples, METH_VARARGS,
"(int) - change Lamp samples value"},
{"setRaySamplesX", ( PyCFunction ) Lamp_oldsetRaySamplesX, METH_VARARGS,
"(int) - change Lamp ray X samples value in [1,16]"},
{"setRaySamplesY", ( PyCFunction ) Lamp_oldsetRaySamplesY, METH_VARARGS,
"(int) - change Lamp ray Y samples value in [1,16]"},
{"setAreaSizeX", ( PyCFunction ) Lamp_oldsetAreaSizeX, METH_VARARGS,
"(float) - change Lamp ray X size for area lamps, value in [0.01, 100.0]"},
{"setAreaSizeY", ( PyCFunction ) Lamp_oldsetAreaSizeY, METH_VARARGS,
"(float) - change Lamp ray Y size for area lamps, value in [0.01, 100.0]"},
{"setBufferSize", ( PyCFunction ) Lamp_oldsetBufferSize, METH_VARARGS,
"(int) - change Lamp buffer size value"},
{"setHaloStep", ( PyCFunction ) Lamp_oldsetHaloStep, METH_VARARGS,
"(int) - change Lamp halo step value"},
{"setEnergy", ( PyCFunction ) Lamp_oldsetEnergy, METH_VARARGS,
"(float) - change Lamp energy value"},
{"setDist", ( PyCFunction ) Lamp_oldsetDist, METH_VARARGS,
"(float) - change Lamp clipping distance value"},
{"setSpotSize", ( PyCFunction ) Lamp_oldsetSpotSize, METH_VARARGS,
"(float) - change Lamp spot size value"},
{"setSpotBlend", ( PyCFunction ) Lamp_oldsetSpotBlend, METH_VARARGS,
"(float) - change Lamp spot blend value"},
{"setClipStart", ( PyCFunction ) Lamp_oldsetClipStart, METH_VARARGS,
"(float) - change Lamp clip start value"},
{"setClipEnd", ( PyCFunction ) Lamp_oldsetClipEnd, METH_VARARGS,
"(float) - change Lamp clip end value"},
{"setBias", ( PyCFunction ) Lamp_oldsetBias, METH_VARARGS,
"(float) - change Lamp draw size value"},
{"setSoftness", ( PyCFunction ) Lamp_oldsetSoftness, METH_VARARGS,
"(float) - change Lamp softness value"},
{"setHaloInt", ( PyCFunction ) Lamp_oldsetHaloInt, METH_VARARGS,
"(float) - change Lamp halo intensity value"},
{"setQuad1", ( PyCFunction ) Lamp_oldsetQuad1, METH_VARARGS,
"(float) - change light intensity value #1 for a Quad Lamp"},
{"setQuad2", ( PyCFunction ) Lamp_oldsetQuad2, METH_VARARGS,
"(float) - change light intensity value #2 for a Quad Lamp"},
{"setCol", ( PyCFunction ) Lamp_oldsetCol, METH_VARARGS,
"(f,f,f) or ([f,f,f]) - change light's rgb color triplet"},
{"getScriptLinks", ( PyCFunction ) Lamp_getScriptLinks, METH_VARARGS,
"(eventname) - Get a list of this lamp's scriptlinks (Text names) "
"of the given type\n"
"(eventname) - string: FrameChanged, Redraw or Render."},
{"addScriptLink", ( PyCFunction ) Lamp_addScriptLink, METH_VARARGS,
"(text, evt) - Add a new lamp scriptlink.\n"
"(text) - string: an existing Blender Text name;\n"
"(evt) string: FrameChanged, Redraw or Render."},
{"clearScriptLinks", ( PyCFunction ) Lamp_clearScriptLinks,
METH_VARARGS,
"() - Delete all scriptlinks from this lamp.\n"
"([s1<,s2,s3...>]) - Delete specified scriptlinks from this lamp."},
{"getIpo", ( PyCFunction ) Lamp_getIpo, METH_NOARGS,
"() - get IPO for this lamp"},
{"clearIpo", ( PyCFunction ) Lamp_clearIpo, METH_NOARGS,
"() - unlink the IPO for this lamp"},
{"setIpo", ( PyCFunction ) Lamp_oldsetIpo, METH_VARARGS,
"( lamp-ipo ) - link an IPO to this lamp"},
{"insertIpoKey", ( PyCFunction ) Lamp_insertIpoKey, METH_VARARGS,
"( Lamp IPO type ) - Inserts a key into IPO"},
{"__copy__", ( PyCFunction ) Lamp_copy, METH_NOARGS,
"() - Makes a copy of this lamp."},
{"copy", ( PyCFunction ) Lamp_copy, METH_NOARGS,
"() - Makes a copy of this lamp."},
{NULL, NULL, 0, NULL}
};
/*****************************************************************************/
/* Python attributes get/set structure: */
/*****************************************************************************/
static PyGetSetDef BPy_Lamp_getseters[] = {
GENERIC_LIB_GETSETATTR,
{"bias",
(getter)Lamp_getBias, (setter)Lamp_setBias,
"Lamp shadow map sampling bias",
NULL},
{"bufferSize",
(getter)Lamp_getBufferSize, (setter)Lamp_setBufferSize,
"Lamp shadow buffer size",
NULL},
{"clipEnd",
(getter)Lamp_getClipEnd, (setter)Lamp_setClipEnd,
"Lamp shadow map clip end",
NULL},
{"clipStart",
(getter)Lamp_getClipStart, (setter)Lamp_setClipStart,
"Lamp shadow map clip start",
NULL},
{"col",
(getter)Lamp_getCol, (setter)Lamp_setCol,
"Lamp RGB color triplet",
NULL},
{"dist",
(getter)Lamp_getDist, (setter)Lamp_setDist,
"Lamp clipping distance",
NULL},
{"energy",
(getter)Lamp_getEnergy, (setter)Lamp_setEnergy,
"Lamp light intensity",
NULL},
{"haloInt",
(getter)Lamp_getHaloInt, (setter)Lamp_setHaloInt,
"Lamp spotlight halo intensity",
NULL},
{"haloStep",
(getter)Lamp_getHaloStep, (setter)Lamp_setHaloStep,
"Lamp volumetric halo sampling frequency",
NULL},
{"ipo",
(getter)Lamp_getIpo, (setter)Lamp_setIpo,
"Lamp Ipo",
NULL},
{"mode",
(getter)Lamp_getMode, (setter)Lamp_setMode,
"Lamp mode bitmask",
NULL},
{"quad1",
(getter)Lamp_getQuad1, (setter)Lamp_setQuad1,
"Quad lamp linear distance attenuation",
NULL},
{"quad2",
(getter)Lamp_getQuad2, (setter)Lamp_setQuad2,
"Quad lamp quadratic distance attenuation",
NULL},
{"samples",
(getter)Lamp_getSamples, (setter)Lamp_setSamples,
"Lamp shadow map samples",
NULL},
{"raySamplesX",
(getter)Lamp_getRaySamplesX, (setter)Lamp_setRaySamplesX,
"Lamp raytracing samples on the X axis",
NULL},
{"raySamplesY",
(getter)Lamp_getRaySamplesY, (setter)Lamp_setRaySamplesY,
"Lamp raytracing samples on the Y axis",
NULL},
{"areaSizeX",
(getter)Lamp_getAreaSizeX, (setter)Lamp_setAreaSizeX,
"Lamp X size for an arealamp",
NULL},
{"areaSizeY",
(getter)Lamp_getAreaSizeY, (setter)Lamp_setAreaSizeY,
"Lamp Y size for an arealamp",
NULL},
{"softness",
(getter)Lamp_getSoftness, (setter)Lamp_setSoftness,
"Lamp shadow sample area size",
NULL},
{"spotBlend",
(getter)Lamp_getSpotBlend, (setter)Lamp_setSpotBlend,
"Lamp spotlight edge softness",
NULL},
{"spotSize",
(getter)Lamp_getSpotSize, (setter)Lamp_setSpotSize,
"Lamp spotlight beam angle (in degrees)",
NULL},
{"type",
(getter)Lamp_getType, (setter)Lamp_setType,
"Lamp type",
NULL},
{"R",
(getter)Lamp_getComponent, (setter)Lamp_setComponent,
"Lamp color red component",
(void *)EXPP_LAMP_COMP_R},
{"r",
(getter)Lamp_getComponent, (setter)Lamp_setComponent,
"Lamp color red component",
(void *)EXPP_LAMP_COMP_R},
{"G",
(getter)Lamp_getComponent, (setter)Lamp_setComponent,
"Lamp color green component",
(void *)EXPP_LAMP_COMP_G},
{"g",
(getter)Lamp_getComponent, (setter)Lamp_setComponent,
"Lamp color green component",
(void *)EXPP_LAMP_COMP_G},
{"B",
(getter)Lamp_getComponent, (setter)Lamp_setComponent,
"Lamp color blue component",
(void *)EXPP_LAMP_COMP_B},
{"b",
(getter)Lamp_getComponent, (setter)Lamp_setComponent,
"Lamp color blue component",
(void *)EXPP_LAMP_COMP_B},
{"Modes",
(getter)Lamp_getModesConst, (setter)NULL,
"Dictionary of values for 'mode' attribute",
NULL},
{"Types",
(getter)Lamp_getTypesConst, (setter)NULL,
"Dictionary of values for 'type' attribute",
NULL},
{NULL,NULL,NULL,NULL,NULL} /* Sentinel */
};
/*****************************************************************************/
/* Python TypeLamp callback function prototypes: */
/*****************************************************************************/
static void Lamp_dealloc( BPy_Lamp * lamp );
static int Lamp_compare( BPy_Lamp * a, BPy_Lamp * b );
static PyObject *Lamp_repr( BPy_Lamp * lamp );
/*****************************************************************************/
/* Python TypeLamp structure definition: */
/*****************************************************************************/
PyTypeObject Lamp_Type = {
PyObject_HEAD_INIT( NULL ) /* required py macro */
0, /* ob_size */
/* For printing, in format "<module>.<name>" */
"Blender Lamp", /* char *tp_name; */
sizeof( BPy_Lamp ), /* int tp_basicsize; */
0, /* tp_itemsize; For allocation */
/* Methods to implement standard operations */
( destructor ) Lamp_dealloc,/* destructor tp_dealloc; */
NULL, /* printfunc tp_print; */
NULL, /* getattrfunc tp_getattr; */
NULL, /* setattrfunc tp_setattr; */
( cmpfunc ) Lamp_compare, /* cmpfunc tp_compare; */
( reprfunc ) Lamp_repr, /* reprfunc 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_Lamp_methods, /* struct PyMethodDef *tp_methods; */
NULL, /* struct PyMemberDef *tp_members; */
BPy_Lamp_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
};
/*****************************************************************************/
/* Function: M_Lamp_New */
/* Python equivalent: Blender.Lamp.New */
/*****************************************************************************/
static PyObject *M_Lamp_New( PyObject * self, PyObject * args,
PyObject * keywords )
{
char *type_str = "Lamp";
char *name_str = "Lamp";
static char *kwlist[] = { "type_str", "name_str", NULL };
BPy_Lamp *py_lamp; /* for Lamp Data object wrapper in Python */
Lamp *bl_lamp; /* for actual Lamp Data we create in Blender */
if( !PyArg_ParseTupleAndKeywords( args, keywords, "|ss", kwlist,
&type_str, &name_str ) )
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"expected string(s) or empty argument" ) );
bl_lamp = add_lamp( name_str ); /* first create in Blender */
if( bl_lamp ) /* now create the wrapper obj in Python */
py_lamp = ( BPy_Lamp * ) Lamp_CreatePyObject( bl_lamp );
else
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't create Lamp Data in Blender" ) );
/* let's return user count to zero, because ... */
bl_lamp->id.us = 0; /* ... add_lamp() incref'ed it */
if( py_lamp == NULL )
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create Lamp Data object" ) );
if( strcmp( type_str, "Lamp" ) == 0 )
bl_lamp->type = ( short ) EXPP_LAMP_TYPE_LAMP;
else if( strcmp( type_str, "Sun" ) == 0 )
bl_lamp->type = ( short ) EXPP_LAMP_TYPE_SUN;
else if( strcmp( type_str, "Spot" ) == 0 )
bl_lamp->type = ( short ) EXPP_LAMP_TYPE_SPOT;
else if( strcmp( type_str, "Hemi" ) == 0 )
bl_lamp->type = ( short ) EXPP_LAMP_TYPE_HEMI;
else if( strcmp( type_str, "Area" ) == 0 )
bl_lamp->type = ( short ) EXPP_LAMP_TYPE_AREA;
else if( strcmp( type_str, "Photon" ) == 0 )
bl_lamp->type = ( short ) EXPP_LAMP_TYPE_YF_PHOTON;
else
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"unknown lamp type" ) );
return ( PyObject * ) py_lamp;
}
/*****************************************************************************/
/* Function: M_Lamp_Get */
/* Python equivalent: Blender.Lamp.Get */
/* Description: Receives a string and returns the lamp data obj */
/* whose name matches the string. If no argument is */
/* passed in, a list of all lamp data names in the */
/* current scene is returned. */
/*****************************************************************************/
static PyObject *M_Lamp_Get( PyObject * self, PyObject * args )
{
char *name = NULL;
Lamp *lamp_iter;
if( !PyArg_ParseTuple( args, "|s", &name ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected string argument (or nothing)" ) );
lamp_iter = G.main->lamp.first;
if( name ) { /* (name) - Search lamp by name */
BPy_Lamp *wanted_lamp = NULL;
while( ( lamp_iter ) && ( wanted_lamp == NULL ) ) {
if( strcmp( name, lamp_iter->id.name + 2 ) == 0 )
wanted_lamp =
( BPy_Lamp * )
Lamp_CreatePyObject( lamp_iter );
lamp_iter = lamp_iter->id.next;
}
if( wanted_lamp == NULL ) { /* Requested lamp doesn't exist */
char error_msg[64];
PyOS_snprintf( error_msg, sizeof( error_msg ),
"Lamp \"%s\" not found", name );
return ( EXPP_ReturnPyObjError
( PyExc_NameError, error_msg ) );
}
return ( PyObject * ) wanted_lamp;
}
else { /* () - return a list of all lamps in the scene */
int index = 0;
PyObject *lamplist, *pyobj;
lamplist = PyList_New( BLI_countlist( &( G.main->lamp ) ) );
if( lamplist == NULL )
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create PyList" ) );
while( lamp_iter ) {
pyobj = Lamp_CreatePyObject( lamp_iter );
if( !pyobj )
return ( EXPP_ReturnPyObjError
( PyExc_MemoryError,
"couldn't create PyString" ) );
PyList_SET_ITEM( lamplist, index, pyobj );
lamp_iter = lamp_iter->id.next;
index++;
}
return lamplist;
}
}
static PyObject *Lamp_TypesDict( void )
{ /* create the Blender.Lamp.Types constant dict */
PyObject *Types = PyConstant_New( );
if( Types ) {
BPy_constant *c = ( BPy_constant * ) Types;
PyConstant_Insert( c, "Lamp",
PyInt_FromLong( EXPP_LAMP_TYPE_LAMP ) );
PyConstant_Insert( c, "Sun",
PyInt_FromLong( EXPP_LAMP_TYPE_SUN ) );
PyConstant_Insert( c, "Spot",
PyInt_FromLong( EXPP_LAMP_TYPE_SPOT ) );
PyConstant_Insert( c, "Hemi",
PyInt_FromLong( EXPP_LAMP_TYPE_HEMI ) );
PyConstant_Insert( c, "Area",
PyInt_FromLong( EXPP_LAMP_TYPE_AREA ) );
PyConstant_Insert( c, "Photon",
PyInt_FromLong( EXPP_LAMP_TYPE_YF_PHOTON ) );
}
return Types;
}
static PyObject *Lamp_ModesDict( void )
{ /* create the Blender.Lamp.Modes constant dict */
PyObject *Modes = PyConstant_New( );
if( Modes ) {
BPy_constant *c = ( BPy_constant * ) Modes;
PyConstant_Insert( c, "Shadows",
PyInt_FromLong( EXPP_LAMP_MODE_SHADOWS ) );
PyConstant_Insert( c, "Halo",
PyInt_FromLong( EXPP_LAMP_MODE_HALO ) );
PyConstant_Insert( c, "Layer",
PyInt_FromLong( EXPP_LAMP_MODE_LAYER ) );
PyConstant_Insert( c, "Quad",
PyInt_FromLong( EXPP_LAMP_MODE_QUAD ) );
PyConstant_Insert( c, "Negative",
PyInt_FromLong( EXPP_LAMP_MODE_NEGATIVE ) );
PyConstant_Insert( c, "Sphere",
PyInt_FromLong( EXPP_LAMP_MODE_SPHERE ) );
PyConstant_Insert( c, "Square",
PyInt_FromLong( EXPP_LAMP_MODE_SQUARE ) );
PyConstant_Insert( c, "OnlyShadow",
PyInt_FromLong( EXPP_LAMP_MODE_ONLYSHADOW ) );
PyConstant_Insert( c, "NoDiffuse",
PyInt_FromLong( EXPP_LAMP_MODE_NODIFFUSE ) );
PyConstant_Insert( c, "NoSpecular",
PyInt_FromLong( EXPP_LAMP_MODE_NOSPECULAR ) );
PyConstant_Insert( c, "RayShadow",
PyInt_FromLong( EXPP_LAMP_MODE_SHAD_RAY ) );
}
return Modes;
}
/*****************************************************************************/
/* Function: Lamp_Init */
/*****************************************************************************/
/* Needed by the Blender module, to register the Blender.Lamp submodule */
PyObject *Lamp_Init( void )
{
PyObject *submodule, *Types, *Modes;
if( PyType_Ready( &Lamp_Type ) < 0)
return NULL;
Types = Lamp_TypesDict( );
Modes = Lamp_ModesDict( );
submodule =
Py_InitModule3( "Blender.Lamp", M_Lamp_methods, M_Lamp_doc );
if( Types )
PyModule_AddObject( submodule, "Types", Types );
if( Modes )
PyModule_AddObject( submodule, "Modes", Modes );
PyModule_AddIntConstant( submodule, "RGB", IPOKEY_RGB );
PyModule_AddIntConstant( submodule, "ENERGY", IPOKEY_ENERGY );
PyModule_AddIntConstant( submodule, "SPOTSIZE", IPOKEY_SPOTSIZE );
PyModule_AddIntConstant( submodule, "OFFSET", IPOKEY_OFFSET );
PyModule_AddIntConstant( submodule, "SIZE", IPOKEY_SIZE );
return submodule;
}
/* Three Python Lamp_Type helper functions needed by the Object module: */
/*****************************************************************************/
/* Function: Lamp_CreatePyObject */
/* Description: This function will create a new BPy_Lamp from an existing */
/* Blender lamp structure. */
/*****************************************************************************/
PyObject *Lamp_CreatePyObject( Lamp * lamp )
{
BPy_Lamp *pylamp;
float *rgb[3];
pylamp = ( BPy_Lamp * ) PyObject_NEW( BPy_Lamp, &Lamp_Type );
if( !pylamp )
return EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create BPy_Lamp object" );
pylamp->lamp = lamp;
rgb[0] = &lamp->r;
rgb[1] = &lamp->g;
rgb[2] = &lamp->b;
pylamp->color = ( BPy_rgbTuple * ) rgbTuple_New( rgb );
Py_INCREF(pylamp->color);
return ( PyObject * ) pylamp;
}
/*****************************************************************************/
/* Function: Lamp_FromPyObject */
/* Description: This function returns the Blender lamp from the given */
/* PyObject. */
/*****************************************************************************/
Lamp *Lamp_FromPyObject( PyObject * pyobj )
{
return ( ( BPy_Lamp * ) pyobj )->lamp;
}
/*****************************************************************************/
/* Python BPy_Lamp methods: */
/*****************************************************************************/
/* Lamp.__copy__ */
static PyObject *Lamp_copy( BPy_Lamp * self )
{
Lamp *lamp = copy_lamp(self->lamp );
lamp->id.us = 0;
return Lamp_CreatePyObject(lamp);
}
static PyObject *Lamp_getType( BPy_Lamp * self )
{
PyObject *attr = PyInt_FromLong( self->lamp->type );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.type attribute" ) );
}
static PyObject *Lamp_getMode( BPy_Lamp * self )
{
PyObject *attr = PyInt_FromLong( self->lamp->mode );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.mode attribute" ) );
}
static PyObject *Lamp_getSamples( BPy_Lamp * self )
{
PyObject *attr = PyInt_FromLong( self->lamp->samp );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.samples attribute" ) );
}
static PyObject *Lamp_getRaySamplesX( BPy_Lamp * self )
{
PyObject *attr = PyInt_FromLong( self->lamp->ray_samp );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.raySamplesX attribute" ) );
}
static PyObject *Lamp_getRaySamplesY( BPy_Lamp * self )
{
PyObject *attr = PyInt_FromLong( self->lamp->ray_sampy );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.raySamplesY attribute" ) );
}
static PyObject *Lamp_getAreaSizeX( BPy_Lamp * self )
{
PyObject *attr = PyFloat_FromDouble( self->lamp->area_size );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.areaSizeX attribute" ) );
}
static PyObject *Lamp_getAreaSizeY( BPy_Lamp * self )
{
PyObject *attr = PyFloat_FromDouble( self->lamp->area_sizey );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.areaSizeY attribute" ) );
}
static PyObject *Lamp_getBufferSize( BPy_Lamp * self )
{
PyObject *attr = PyInt_FromLong( self->lamp->bufsize );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.bufferSize attribute" ) );
}
static PyObject *Lamp_getHaloStep( BPy_Lamp * self )
{
PyObject *attr = PyInt_FromLong( self->lamp->shadhalostep );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.haloStep attribute" ) );
}
static PyObject *Lamp_getEnergy( BPy_Lamp * self )
{
PyObject *attr = PyFloat_FromDouble( self->lamp->energy );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.energy attribute" ) );
}
static PyObject *Lamp_getDist( BPy_Lamp * self )
{
PyObject *attr = PyFloat_FromDouble( self->lamp->dist );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.dist attribute" ) );
}
static PyObject *Lamp_getSpotSize( BPy_Lamp * self )
{
PyObject *attr = PyFloat_FromDouble( self->lamp->spotsize );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.spotSize attribute" ) );
}
static PyObject *Lamp_getSpotBlend( BPy_Lamp * self )
{
PyObject *attr = PyFloat_FromDouble( self->lamp->spotblend );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.spotBlend attribute" ) );
}
static PyObject *Lamp_getClipStart( BPy_Lamp * self )
{
PyObject *attr = PyFloat_FromDouble( self->lamp->clipsta );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.clipStart attribute" ) );
}
static PyObject *Lamp_getClipEnd( BPy_Lamp * self )
{
PyObject *attr = PyFloat_FromDouble( self->lamp->clipend );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.clipEnd attribute" ) );
}
static PyObject *Lamp_getBias( BPy_Lamp * self )
{
PyObject *attr = PyFloat_FromDouble( self->lamp->bias );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.bias attribute" ) );
}
static PyObject *Lamp_getSoftness( BPy_Lamp * self )
{
PyObject *attr = PyFloat_FromDouble( self->lamp->soft );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.softness attribute" ) );
}
static PyObject *Lamp_getHaloInt( BPy_Lamp * self )
{
PyObject *attr = PyFloat_FromDouble( self->lamp->haint );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.haloInt attribute" ) );
}
static PyObject *Lamp_getQuad1( BPy_Lamp * self )
{ /* should we complain if Lamp is not of type Quad? */
PyObject *attr = PyFloat_FromDouble( self->lamp->att1 );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.quad1 attribute" ) );
}
static PyObject *Lamp_getQuad2( BPy_Lamp * self )
{ /* should we complain if Lamp is not of type Quad? */
PyObject *attr = PyFloat_FromDouble( self->lamp->att2 );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.quad2 attribute" ) );
}
static PyObject *Lamp_getCol( BPy_Lamp * self )
{
return rgbTuple_getCol( self->color );
}
static int Lamp_setType( BPy_Lamp * self, PyObject * value )
{
return EXPP_setIValueRange ( value, &self->lamp->type,
0, EXPP_LAMP_TYPE_MAX, 'h' );
}
static int Lamp_setMode( BPy_Lamp * self, PyObject * value )
{
short param;
static short bitmask = EXPP_LAMP_MODE_SHADOWS
| EXPP_LAMP_MODE_HALO
| EXPP_LAMP_MODE_LAYER
| EXPP_LAMP_MODE_QUAD
| EXPP_LAMP_MODE_NEGATIVE
| EXPP_LAMP_MODE_ONLYSHADOW
| EXPP_LAMP_MODE_SPHERE
| EXPP_LAMP_MODE_SQUARE
| EXPP_LAMP_MODE_NODIFFUSE
| EXPP_LAMP_MODE_NOSPECULAR
| EXPP_LAMP_MODE_SHAD_RAY;
if( !PyInt_CheckExact ( value ) ) {
char errstr[128];
sprintf ( errstr , "expected int bitmask of 0x%04x", bitmask );
return EXPP_ReturnIntError( PyExc_TypeError, errstr );
}
param = (short)PyInt_AS_LONG ( value );
if ( ( param & bitmask ) != param )
return EXPP_ReturnIntError( PyExc_ValueError,
"invalid bit(s) set in mask" );
self->lamp->mode = param;
return 0;
}
static int Lamp_setSamples( BPy_Lamp * self, PyObject * value )
{
return EXPP_setIValueClamped ( value, &self->lamp->samp,
EXPP_LAMP_SAMPLES_MIN,
EXPP_LAMP_SAMPLES_MAX, 'h' );
}
static int Lamp_setRaySamplesX( BPy_Lamp * self, PyObject * value )
{
return EXPP_setIValueClamped ( value, &self->lamp->ray_samp,
EXPP_LAMP_RAYSAMPLES_MIN,
EXPP_LAMP_RAYSAMPLES_MAX, 'h' );
}
static int Lamp_setRaySamplesY( BPy_Lamp * self, PyObject * value )
{
return EXPP_setIValueClamped ( value, &self->lamp->ray_sampy,
EXPP_LAMP_RAYSAMPLES_MIN,
EXPP_LAMP_RAYSAMPLES_MAX, 'h' );
}
static int Lamp_setAreaSizeX( BPy_Lamp * self, PyObject * value )
{
return EXPP_setFloatClamped ( value, &self->lamp->area_size,
EXPP_LAMP_AREASIZE_MIN,
EXPP_LAMP_AREASIZE_MAX );
}
static int Lamp_setAreaSizeY( BPy_Lamp * self, PyObject * value )
{
return EXPP_setFloatClamped ( value, &self->lamp->area_sizey,
EXPP_LAMP_AREASIZE_MIN,
EXPP_LAMP_AREASIZE_MAX );
}
static int Lamp_setBufferSize( BPy_Lamp * self, PyObject * value )
{
return EXPP_setIValueClamped ( value, &self->lamp->bufsize,
EXPP_LAMP_BUFFERSIZE_MIN,
EXPP_LAMP_BUFFERSIZE_MAX, 'h' );
}
static int Lamp_setHaloStep( BPy_Lamp * self, PyObject * value )
{
return EXPP_setIValueClamped ( value, &self->lamp->shadhalostep,
EXPP_LAMP_HALOSTEP_MIN,
EXPP_LAMP_HALOSTEP_MAX, 'h' );
}
static int Lamp_setEnergy( BPy_Lamp * self, PyObject * value )
{
return EXPP_setFloatClamped ( value, &self->lamp->energy,
EXPP_LAMP_ENERGY_MIN,
EXPP_LAMP_ENERGY_MAX );
}
static int Lamp_setDist( BPy_Lamp * self, PyObject * value )
{
return EXPP_setFloatClamped ( value, &self->lamp->dist,
EXPP_LAMP_DIST_MIN,
EXPP_LAMP_DIST_MAX );
}
static int Lamp_setSpotSize( BPy_Lamp * self, PyObject * value )
{
return EXPP_setFloatClamped ( value, &self->lamp->spotsize,
EXPP_LAMP_SPOTSIZE_MIN,
EXPP_LAMP_SPOTSIZE_MAX );
}
static int Lamp_setSpotBlend( BPy_Lamp * self, PyObject * value )
{
return EXPP_setFloatClamped ( value, &self->lamp->spotblend,
EXPP_LAMP_SPOTBLEND_MIN,
EXPP_LAMP_SPOTBLEND_MAX );
}
static int Lamp_setClipStart( BPy_Lamp * self, PyObject * value )
{
return EXPP_setFloatClamped ( value, &self->lamp->clipsta,
EXPP_LAMP_CLIPSTART_MIN,
EXPP_LAMP_CLIPSTART_MAX );
}
static int Lamp_setClipEnd( BPy_Lamp * self, PyObject * value )
{
return EXPP_setFloatClamped ( value, &self->lamp->clipend,
EXPP_LAMP_CLIPEND_MIN,
EXPP_LAMP_CLIPEND_MAX );
}
static int Lamp_setBias( BPy_Lamp * self, PyObject * value )
{
return EXPP_setFloatClamped ( value, &self->lamp->bias,
EXPP_LAMP_BIAS_MIN,
EXPP_LAMP_BIAS_MAX );
}
static int Lamp_setSoftness( BPy_Lamp * self, PyObject * value )
{
return EXPP_setFloatClamped ( value, &self->lamp->soft,
EXPP_LAMP_SOFTNESS_MIN,
EXPP_LAMP_SOFTNESS_MAX );
}
static int Lamp_setHaloInt( BPy_Lamp * self, PyObject * value )
{
return EXPP_setFloatClamped ( value, &self->lamp->haint,
EXPP_LAMP_HALOINT_MIN,
EXPP_LAMP_HALOINT_MAX );
}
static int Lamp_setQuad1( BPy_Lamp * self, PyObject * value )
{
return EXPP_setFloatClamped ( value, &self->lamp->att1,
EXPP_LAMP_QUAD1_MIN,
EXPP_LAMP_QUAD1_MAX );
}
static int Lamp_setQuad2( BPy_Lamp * self, PyObject * value )
{
return EXPP_setFloatClamped ( value, &self->lamp->att2,
EXPP_LAMP_QUAD2_MIN,
EXPP_LAMP_QUAD2_MAX );
}
static PyObject *Lamp_getComponent( BPy_Lamp * self, void * closure )
{
PyObject *attr = NULL;
switch ( (int)closure ) {
case EXPP_LAMP_COMP_R:
attr = PyFloat_FromDouble( self->lamp->r );
break;
case EXPP_LAMP_COMP_G:
attr = PyFloat_FromDouble( self->lamp->g );
break;
case EXPP_LAMP_COMP_B:
attr = PyFloat_FromDouble( self->lamp->b );
break;
default:
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"unknown color component specified" );
}
if( !attr )
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"PyFloat_FromDouble() failed" );
return attr;
}
static int Lamp_setComponent( BPy_Lamp * self, PyObject * value,
void * closure )
{
float color;
if( !PyNumber_Check ( value ) )
return EXPP_ReturnIntError( PyExc_TypeError,
"expected float argument in [0.0,1.0]" );
color = (float)PyFloat_AsDouble( value );
color = EXPP_ClampFloat( color, EXPP_LAMP_COL_MIN, EXPP_LAMP_COL_MAX );
switch ( (int)closure ) {
case EXPP_LAMP_COMP_R:
self->lamp->r = color;
return 0;
case EXPP_LAMP_COMP_G:
self->lamp->g = color;
return 0;
case EXPP_LAMP_COMP_B:
self->lamp->b = color;
return 0;
}
return EXPP_ReturnIntError( PyExc_RuntimeError,
"unknown color component specified" );
}
static int Lamp_setCol( BPy_Lamp * self, PyObject * args )
{
return rgbTuple_setCol( self->color, args );
}
/* lamp.addScriptLink */
static PyObject *Lamp_addScriptLink( BPy_Lamp * self, PyObject * args )
{
Lamp *lamp = self->lamp;
ScriptLink *slink = NULL;
slink = &( lamp )->scriptlink;
return EXPP_addScriptLink( slink, args, 0 );
}
/* lamp.clearScriptLinks */
static PyObject *Lamp_clearScriptLinks( BPy_Lamp * self, PyObject * args )
{
Lamp *lamp = self->lamp;
ScriptLink *slink = NULL;
slink = &( lamp )->scriptlink;
return EXPP_clearScriptLinks( slink, args );
}
/* mat.getScriptLinks */
static PyObject *Lamp_getScriptLinks( BPy_Lamp * self, PyObject * args )
{
Lamp *lamp = self->lamp;
ScriptLink *slink = NULL;
PyObject *ret = NULL;
slink = &( lamp )->scriptlink;
ret = EXPP_getScriptLinks( slink, args, 0 );
if( ret )
return ret;
else
return NULL;
}
/*****************************************************************************/
/* Function: Lamp_dealloc */
/* Description: This is a callback function for the BPy_Lamp type. It is */
/* the destructor function. */
/*****************************************************************************/
static void Lamp_dealloc( BPy_Lamp * self )
{
Py_DECREF( self->color );
PyObject_DEL( self );
}
/*****************************************************************************/
/* Function: Lamp_compare */
/* Description: This is a callback function for the BPy_Lamp type. It */
/* compares two Lamp_Type objects. Only the "==" and "!=" */
/* comparisons are meaningful. Returns 0 for equality and -1 */
/* if they don't point to the same Blender Lamp struct. */
/* In Python it becomes 1 if they are equal, 0 otherwise. */
/*****************************************************************************/
static int Lamp_compare( BPy_Lamp * a, BPy_Lamp * b )
{
return ( a->lamp == b->lamp ) ? 0 : -1;
}
/*****************************************************************************/
/* Function: Lamp_repr */
/* Description: This is a callback function for the BPy_Lamp type. It */
/* builds a meaninful string to represent lamp objects. */
/*****************************************************************************/
static PyObject *Lamp_repr( BPy_Lamp * self )
{
return PyString_FromFormat( "[Lamp \"%s\"]", self->lamp->id.name + 2 );
}
static PyObject *Lamp_getIpo( BPy_Lamp * self )
{
struct Ipo *ipo = self->lamp->ipo;
if( !ipo )
Py_RETURN_NONE;
return Ipo_CreatePyObject( ipo );
}
/*
* this should accept a Py_None argument and just delete the Ipo link
* (as Lamp_clearIpo() does)
*/
static int Lamp_setIpo( BPy_Lamp * self, PyObject * value )
{
return GenericLib_assignData(value, (void **) &self->lamp->ipo, 0, 1, ID_IP, ID_LA);
}
/*
* Lamp_insertIpoKey()
* inserts Lamp IPO key for RGB,ENERGY,SPOTSIZE,OFFSET,SIZE
*/
static PyObject *Lamp_insertIpoKey( BPy_Lamp * 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->lamp->texact);
if (key == IPOKEY_RGB ) {
insertkey((ID *)self->lamp, ID_LA, NULL, NULL, LA_COL_R);
insertkey((ID *)self->lamp, ID_LA, NULL, NULL,LA_COL_G);
insertkey((ID *)self->lamp, ID_LA, NULL, NULL,LA_COL_B);
}
if (key == IPOKEY_ENERGY ) {
insertkey((ID *)self->lamp, ID_LA, NULL, NULL,LA_ENERGY);
}
if (key == IPOKEY_SPOTSIZE ) {
insertkey((ID *)self->lamp, ID_LA, NULL, NULL,LA_SPOTSI);
}
if (key == IPOKEY_OFFSET ) {
insertkey((ID *)self->lamp, ID_LA, NULL, NULL, map+MAP_OFS_X);
insertkey((ID *)self->lamp, ID_LA, NULL, NULL, map+MAP_OFS_Y);
insertkey((ID *)self->lamp, ID_LA, NULL, NULL, map+MAP_OFS_Z);
}
if (key == IPOKEY_SIZE ) {
insertkey((ID *)self->lamp, ID_LA, NULL, NULL, map+MAP_SIZE_X);
insertkey((ID *)self->lamp, ID_LA, NULL, NULL, map+MAP_SIZE_Y);
insertkey((ID *)self->lamp, ID_LA, NULL, NULL, map+MAP_SIZE_Z);
}
allspace(REMAKEIPO, 0);
EXPP_allqueue(REDRAWIPO, 0);
EXPP_allqueue(REDRAWVIEW3D, 0);
EXPP_allqueue(REDRAWACTION, 0);
EXPP_allqueue(REDRAWNLA, 0);
Py_RETURN_NONE;
}
static PyObject *Lamp_getModesConst( void )
{
PyObject * attr = Py_BuildValue
( "{s:h,s:h,s:h,s:h,s:h,s:h,s:h,s:h,s:h,s:h,s:h}",
"Shadows", EXPP_LAMP_MODE_SHADOWS, "Halo",
EXPP_LAMP_MODE_HALO, "Layer", EXPP_LAMP_MODE_LAYER,
"Quad", EXPP_LAMP_MODE_QUAD, "Negative",
EXPP_LAMP_MODE_NEGATIVE, "OnlyShadow",
EXPP_LAMP_MODE_ONLYSHADOW, "Sphere",
EXPP_LAMP_MODE_SPHERE, "Square",
EXPP_LAMP_MODE_SQUARE, "NoDiffuse",
EXPP_LAMP_MODE_NODIFFUSE, "NoSpecular",
EXPP_LAMP_MODE_NOSPECULAR, "RayShadow",
EXPP_LAMP_MODE_SHAD_RAY);
if( !attr )
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.Modes attribute" );
return attr;
}
static PyObject *Lamp_getTypesConst( void )
{
PyObject *attr = Py_BuildValue( "{s:h,s:h,s:h,s:h,s:h,s:h}",
"Lamp", EXPP_LAMP_TYPE_LAMP,
"Sun", EXPP_LAMP_TYPE_SUN,
"Spot", EXPP_LAMP_TYPE_SPOT,
"Hemi", EXPP_LAMP_TYPE_HEMI,
"Area", EXPP_LAMP_TYPE_AREA,
"Photon", EXPP_LAMP_TYPE_YF_PHOTON );
if( !attr )
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.Types attribute" );
return attr;
}
/* #####DEPRECATED###### */
static PyObject *Lamp_oldsetSamples( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setSamples );
}
static PyObject *Lamp_oldsetRaySamplesX( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setRaySamplesX );
}
static PyObject *Lamp_oldsetRaySamplesY( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setRaySamplesY );
}
static PyObject *Lamp_oldsetAreaSizeX( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setAreaSizeX );
}
static PyObject *Lamp_oldsetAreaSizeY( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setAreaSizeY );
}
static PyObject *Lamp_oldsetBufferSize( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setBufferSize );
}
static PyObject *Lamp_oldsetHaloStep( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setHaloStep );
}
static PyObject *Lamp_oldsetEnergy( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setEnergy );
}
static PyObject *Lamp_oldsetDist( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setDist );
}
static PyObject *Lamp_oldsetSpotSize( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setSpotSize );
}
static PyObject *Lamp_oldsetSpotBlend( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setSpotBlend );
}
static PyObject *Lamp_oldsetClipStart( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setClipStart );
}
static PyObject *Lamp_oldsetClipEnd( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setClipEnd );
}
static PyObject *Lamp_oldsetBias( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setBias );
}
static PyObject *Lamp_oldsetSoftness( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setSoftness );
}
static PyObject *Lamp_oldsetHaloInt( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setHaloInt );
}
static PyObject *Lamp_oldsetQuad1( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setQuad1 );
}
static PyObject *Lamp_oldsetQuad2( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setQuad2 );
}
static PyObject *Lamp_oldsetIpo( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setIpo );
}
static PyObject *Lamp_oldsetCol( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setCol );
}
/*
* the "not-well-behaved" methods which require more processing than
* just the simple wrapper
*/
/*
* clearIpo() returns True/False depending on whether lamp has an Ipo
*/
static PyObject *Lamp_clearIpo( BPy_Lamp * self )
{
/* if Ipo defined, delete it and return true */
if( self->lamp->ipo ) {
PyObject *value = Py_BuildValue( "(O)", Py_None );
EXPP_setterWrapper ( (void *)self, value, (setter)Lamp_setIpo );
Py_DECREF ( value );
return EXPP_incr_ret_True();
}
return EXPP_incr_ret_False(); /* no ipo found */
}
/*
* setType() accepts a string while mode setter takes an integer
*/
static PyObject *Lamp_oldsetType( BPy_Lamp * self, PyObject * args )
{
char *type;
PyObject *value, *error;
/* parse string argument */
if( !PyArg_ParseTuple( args, "s", &type ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected string argument" ) );
/* check for valid arguments, set type accordingly */
if( !strcmp( type, "Lamp" ) )
self->lamp->type = ( short ) EXPP_LAMP_TYPE_LAMP;
else if( !strcmp( type, "Sun" ) )
self->lamp->type = ( short ) EXPP_LAMP_TYPE_SUN;
else if( !strcmp( type, "Spot" ) )
self->lamp->type = ( short ) EXPP_LAMP_TYPE_SPOT;
else if( !strcmp( type, "Hemi" ) )
self->lamp->type = ( short ) EXPP_LAMP_TYPE_HEMI;
else if( !strcmp( type, "Area" ) )
self->lamp->type = ( short ) EXPP_LAMP_TYPE_AREA;
else if( !strcmp( type, "Photon" ) )
self->lamp->type = ( short ) EXPP_LAMP_TYPE_YF_PHOTON;
else
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"unknown lamp type" );
/* build tuple, call wrapper */
value = Py_BuildValue( "(i)", type );
error = EXPP_setterWrapper ( (void *)self, value, (setter)Lamp_setType );
Py_DECREF ( value );
return error;
}
/*
* setMode() accepts up to ten strings while mode setter takes an integer
*/
static PyObject *Lamp_oldsetMode( BPy_Lamp * self, PyObject * args )
{
short i, flag = 0;
PyObject *error, *value;
char *name;
/* check that we're passed a tuple of no more than 10 args*/
if ( !PyTuple_Check( args ) || PyTuple_Size( args ) > 10 )
return EXPP_ReturnPyObjError ( PyExc_AttributeError,
"expected up to 10 string arguments" );
/* check each argument for type, find its value */
for ( i = (short)PyTuple_Size( args ); i-- ; ) {
name = PyString_AsString ( PyTuple_GET_ITEM( args, i ) );
if( !name )
return EXPP_ReturnPyObjError ( PyExc_AttributeError,
"expected string argument" );
if( !strcmp( name, "Shadows" ) )
flag |= ( short ) EXPP_LAMP_MODE_SHADOWS;
else if( !strcmp( name, "Halo" ) )
flag |= ( short ) EXPP_LAMP_MODE_HALO;
else if( !strcmp( name, "Layer" ) )
flag |= ( short ) EXPP_LAMP_MODE_LAYER;
else if( !strcmp( name, "Quad" ) )
flag |= ( short ) EXPP_LAMP_MODE_QUAD;
else if( !strcmp( name, "Negative" ) )
flag |= ( short ) EXPP_LAMP_MODE_NEGATIVE;
else if( !strcmp( name, "OnlyShadow" ) )
flag |= ( short ) EXPP_LAMP_MODE_ONLYSHADOW;
else if( !strcmp( name, "Sphere" ) )
flag |= ( short ) EXPP_LAMP_MODE_SPHERE;
else if( !strcmp( name, "Square" ) )
flag |= ( short ) EXPP_LAMP_MODE_SQUARE;
else if( !strcmp( name, "NoDiffuse" ) )
flag |= ( short ) EXPP_LAMP_MODE_NODIFFUSE;
else if( !strcmp( name, "NoSpecular" ) )
flag |= ( short ) EXPP_LAMP_MODE_NOSPECULAR;
else if( !strcmp( name, "RayShadow" ) )
flag |= ( short ) EXPP_LAMP_MODE_SHAD_RAY;
else
return EXPP_ReturnPyObjError( PyExc_AttributeError,
"unknown lamp flag argument" );
}
/* build tuple, call wrapper */
value = Py_BuildValue( "(i)", flag );
error = EXPP_setterWrapper ( (void *)self, value, (setter)Lamp_setMode );
Py_DECREF ( value );
return error;
}
View Git Blame Copy Permalink