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
d38a8b20b904687026de14e67aa3084a8037ed67
blender-archive/source/blender/python/api2_2x/Lamp.c

1826 lines
60 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"
/*****************************************************************************/
/* 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_getName( BPy_Lamp * self );
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_getUsers( BPy_Lamp * self );
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_oldsetName( 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 int Lamp_setIpo( BPy_Lamp * self, PyObject * args );
static int Lamp_setName( 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 */
{"getName", ( PyCFunction ) Lamp_getName, METH_NOARGS,
"() - return Lamp name"},
{"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 ) Lamp_oldsetName, 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"},
{NULL, NULL, 0, NULL}
};
/*****************************************************************************/
/* Python attributes get/set structure: */
/*****************************************************************************/
static PyGetSetDef BPy_Lamp_getseters[] = {
{"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},
{"name",
(getter)Lamp_getName, (setter)Lamp_setName,
"Lamp data name",
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},
{"users",
(getter)Lamp_getUsers, (setter)NULL,
"Number of lamp users",
NULL},
{"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) */
NULL, /* 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 = "LampData";
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 */
char buf[21];
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( ); /* 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" ) );
if( strcmp( name_str, "LampData" ) == 0 )
return ( PyObject * ) py_lamp;
else { /* user gave us a name for the lamp, use it */
PyOS_snprintf( buf, sizeof( buf ), "%s", name_str );
rename_id( &bl_lamp->id, buf );
}
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 );
return ( PyObject * ) pylamp;
}
/*****************************************************************************/
/* Function: Lamp_CheckPyObject */
/* Description: This function returns true when the given PyObject is of the */
/* type Lamp. Otherwise it will return false. */
/*****************************************************************************/
int Lamp_CheckPyObject( PyObject * pyobj )
{
return ( pyobj->ob_type == &Lamp_Type );
}
/*****************************************************************************/
/* Function: Lamp_FromPyObject */
/* Description: This function returns the Blender lamp from the given */
/* PyObject. */
/*****************************************************************************/
Lamp *Lamp_FromPyObject( PyObject * pyobj )
{
return ( ( BPy_Lamp * ) pyobj )->lamp;
}
/*****************************************************************************/
/* Description: Returns the lamp with the name specified by the argument */
/* name. Note that the calling function has to remove the first */
/* two characters of the lamp name. These two characters */
/* specify the type of the object (OB, ME, WO, ...) */
/* The function will return NULL when no lamp with the given */
/* name is found. */
/*****************************************************************************/
Lamp *GetLampByName( char *name )
{
Lamp *lamp_iter;
lamp_iter = G.main->lamp.first;
while( lamp_iter ) {
if( StringEqual( name, GetIdName( &( lamp_iter->id ) ) ) ) {
return lamp_iter;
}
lamp_iter = lamp_iter->id.next;
}
/* There is no lamp with the given name */
return NULL;
}
/*****************************************************************************/
/* Python BPy_Lamp methods: */
/*****************************************************************************/
static PyObject *Lamp_getName( BPy_Lamp * self )
{
PyObject *attr = PyString_FromString( self->lamp->id.name + 2 );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Lamp.name attribute" ) );
}
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_setName( BPy_Lamp * self, PyObject * value )
{
char *name = NULL;
char buf[21];
name = PyString_AsString ( value );
if( !name )
return EXPP_ReturnIntError( PyExc_TypeError,
"expected string argument" );
PyOS_snprintf( buf, sizeof( buf ), "%s", name );
rename_id( &self->lamp->id, buf );
return 0;
}
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_INCREF( Py_None );
return Py_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 )
{
Ipo *ipo = NULL;
Ipo *oldipo = self->lamp->ipo;
ID *id;
/* if parameter is not None, check for valid Ipo */
if ( value != Py_None ) {
if ( !Ipo_CheckPyObject( value ) )
return EXPP_ReturnIntError( PyExc_RuntimeError,
"expected an Ipo object" );
ipo = Ipo_FromPyObject( value );
if( !ipo )
return EXPP_ReturnIntError( PyExc_RuntimeError,
"null ipo!" );
if( ipo->blocktype != ID_LA )
return EXPP_ReturnIntError( PyExc_TypeError,
"Ipo is not a lamp data Ipo" );
}
/* if already linked to Ipo, delete link */
if ( oldipo ) {
id = &oldipo->id;
if( id->us > 0 )
id->us--;
}
/* assign new Ipo and increment user count, or set to NULL if deleting */
self->lamp->ipo = ipo;
if ( ipo ) {
id = &ipo->id;
id->us++;
}
return 0;
}
/*
* 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);
return EXPP_incr_ret( Py_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;
}
static PyObject *Lamp_getUsers( BPy_Lamp * self )
{
return PyInt_FromLong( self->lamp->id.us );
}
/* #####DEPRECATED###### */
static PyObject *Lamp_oldsetName( BPy_Lamp * self, PyObject * args )
{
return EXPP_setterWrapper ( (void *)self, args, (setter)Lamp_setName );
}
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