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
aad31875d7224c58b1d94bd716bb5aab295fc8cb
blender-archive/source/blender/python/api2_2x/Material.c
Ton Roosendaal aad31875d7 Special bf-committers request; Lamp/World/Material now each have 10 
channels to link texture to.

The amount of code changes seems large, but is mostly getting rind of
hardcoded values (6 and 8) for channels, replacing it with MAX_MTEX.

Further did some fixes;
- Ipo for Lamp showed too many mapping channels
- Texture MapTo buttons for lamp missed the slider to blend texture color
- Lamp texture mapping "View" only worked for Spot, now it uses lamp-
  view vector for all types. (Nice for projections!)
2004-12-04 21:49:02 +00:00

2319 lines
74 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, Michel Selten, Alex Mole,
* Alexander Szakaly
*
* ***** END GPL/BL DUAL LICENSE BLOCK *****
*/
#include <BKE_main.h>
#include <BKE_global.h>
#include <BKE_library.h>
#include <MEM_guardedalloc.h>
#include <DNA_ID.h>
#include <BLI_blenlib.h>
#include "constant.h"
#include "gen_utils.h"
#include "MTex.h"
#include "Texture.h"
#include "Material.h"
#include "Ipo.h"
/*****************************************************************************/
/* Python BPy_Material defaults: */
/*****************************************************************************/
#define EXPP_MAT_MODE_TRACEABLE MA_TRACEBLE
#define EXPP_MAT_MODE_SHADOW MA_SHADOW
#define EXPP_MAT_MODE_SHADELESS MA_SHLESS
#define EXPP_MAT_MODE_WIRE MA_WIRE
#define EXPP_MAT_MODE_VCOL_LIGHT MA_VERTEXCOL
#define EXPP_MAT_MODE_HALO MA_HALO
#define EXPP_MAT_MODE_ZTRANSP MA_ZTRA
#define EXPP_MAT_MODE_VCOL_PAINT MA_VERTEXCOLP
#define EXPP_MAT_MODE_ZINVERT MA_ZINV
#define EXPP_MAT_MODE_HALORINGS MA_HALO_RINGS
#define EXPP_MAT_MODE_ENV MA_ENV
#define EXPP_MAT_MODE_HALOLINES MA_HALO_LINES
#define EXPP_MAT_MODE_ONLYSHADOW MA_ONLYSHADOW
#define EXPP_MAT_MODE_HALOXALPHA MA_HALO_XALPHA
#define EXPP_MAT_MODE_HALOSTAR MA_STAR
#define EXPP_MAT_MODE_TEXFACE MA_FACETEXTURE
#define EXPP_MAT_MODE_HALOTEX MA_HALOTEX
#define EXPP_MAT_MODE_HALOPUNO MA_HALOPUNO
#define EXPP_MAT_MODE_NOMIST MA_NOMIST
#define EXPP_MAT_MODE_HALOSHADE MA_HALO_SHADE
#define EXPP_MAT_MODE_HALOFLARE MA_HALO_FLARE
#define EXPP_MAT_MODE_RADIO MA_RADIO
#define EXPP_MAT_MODE_RAYMIRROR MA_RAYMIRROR
#define EXPP_MAT_MODE_ZTRA MA_ZTRA
#define EXPP_MAT_MODE_RAYTRANSP MA_RAYTRANSP
#define EXPP_MAT_MODE_ONLYSHADOW MA_ONLYSHADOW
#define EXPP_MAT_MODE_NOMIST MA_NOMIST
#define EXPP_MAT_MODE_ENV MA_ENV
/* Material MIN, MAX values */
#define EXPP_MAT_ADD_MIN 0.0
#define EXPP_MAT_ADD_MAX 1.0
#define EXPP_MAT_ALPHA_MIN 0.0
#define EXPP_MAT_ALPHA_MAX 1.0
#define EXPP_MAT_AMB_MIN 0.0
#define EXPP_MAT_AMB_MAX 1.0
#define EXPP_MAT_COL_MIN 0.0 /* min/max for all ... */
#define EXPP_MAT_COL_MAX 1.0 /* ... color triplets */
#define EXPP_MAT_EMIT_MIN 0.0
#define EXPP_MAT_EMIT_MAX 1.0
#define EXPP_MAT_REF_MIN 0.0
#define EXPP_MAT_REF_MAX 1.0
#define EXPP_MAT_SPEC_MIN 0.0
#define EXPP_MAT_SPEC_MAX 2.0
#define EXPP_MAT_SPECTRA_MIN 0.0
#define EXPP_MAT_SPECTRA_MAX 1.0
#define EXPP_MAT_ZOFFS_MIN 0.0
#define EXPP_MAT_ZOFFS_MAX 10.0
#define EXPP_MAT_HALOSIZE_MIN 0.0
#define EXPP_MAT_HALOSIZE_MAX 100.0
#define EXPP_MAT_FLARESIZE_MIN 0.1
#define EXPP_MAT_FLARESIZE_MAX 25.0
#define EXPP_MAT_FLAREBOOST_MIN 0.1
#define EXPP_MAT_FLAREBOOST_MAX 10.0
#define EXPP_MAT_SUBSIZE_MIN 0.1
#define EXPP_MAT_SUBSIZE_MAX 25.0
#define EXPP_MAT_HARD_MIN 1
#define EXPP_MAT_HARD_MAX 255 /* 127 with MODE HALO ON */
#define EXPP_MAT_HALOSEED_MIN 1
#define EXPP_MAT_HALOSEED_MAX 255
#define EXPP_MAT_NFLARES_MIN 1
#define EXPP_MAT_NFLARES_MAX 32
#define EXPP_MAT_FLARESEED_MIN 1
#define EXPP_MAT_FLARESEED_MAX 255
#define EXPP_MAT_NSTARS_MIN 3
#define EXPP_MAT_NSTARS_MAX 50
#define EXPP_MAT_NLINES_MIN 0
#define EXPP_MAT_NLINES_MAX 250
#define EXPP_MAT_NRINGS_MIN 0
#define EXPP_MAT_NRINGS_MAX 24
#define EXPP_MAT_RAYMIRR_MIN 0.0
#define EXPP_MAT_RAYMIRR_MAX 1.0
#define EXPP_MAT_MIRRDEPTH_MIN 0
#define EXPP_MAT_MIRRDEPTH_MAX 10
#define EXPP_MAT_FRESNELMIRR_MIN 0.0
#define EXPP_MAT_FRESNELMIRR_MAX 5.0
#define EXPP_MAT_FRESNELMIRRFAC_MIN 1.0
#define EXPP_MAT_FRESNELMIRRFAC_MAX 5.0
#define EXPP_MAT_ZOFFS_MIN 0.0
#define EXPP_MAT_ZOFFS_MAX 10.0
#define EXPP_MAT_IOR_MIN 1.0
#define EXPP_MAT_IOR_MAX 3.0
#define EXPP_MAT_TRANSDEPTH_MIN 0
#define EXPP_MAT_TRANSDEPTH_MAX 10
#define EXPP_MAT_FRESNELTRANS_MIN 0.0
#define EXPP_MAT_FRESNELTRANS_MAX 5.0
#define EXPP_MAT_FRESNELTRANSFAC_MIN 1.0
#define EXPP_MAT_FRESNELTRANSFAC_MAX 5.0
#define EXPP_MAT_SPECTRANS_MIN 0.0
#define EXPP_MAT_SPECTRANS_MAX 1.0
#define EXPP_MAT_MIRRTRANSADD_MIN 0.0
#define EXPP_MAT_MIRRTRANSADD_MAX 1.0
/*****************************************************************************/
/* Python API function prototypes for the Material module. */
/*****************************************************************************/
static PyObject *M_Material_New( PyObject * self, PyObject * args,
PyObject * keywords );
static PyObject *M_Material_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.Material.__doc__ */
/*****************************************************************************/
static char M_Material_doc[] = "The Blender Material module";
static char M_Material_New_doc[] =
"(name) - return a new material called 'name'\n\
() - return a new material called 'Mat'";
static char M_Material_Get_doc[] =
"(name) - return the material called 'name', None if not found.\n\
() - return a list of all materials in the current scene.";
/*****************************************************************************/
/* Python method structure definition for Blender.Material module: */
/*****************************************************************************/
struct PyMethodDef M_Material_methods[] = {
{"New", ( PyCFunction ) M_Material_New, METH_VARARGS | METH_KEYWORDS,
M_Material_New_doc},
{"Get", M_Material_Get, METH_VARARGS, M_Material_Get_doc},
{"get", M_Material_Get, METH_VARARGS, M_Material_Get_doc},
{NULL, NULL, 0, NULL}
};
/*****************************************************************************/
/* Function: M_Material_New */
/* Python equivalent: Blender.Material.New */
/*****************************************************************************/
static PyObject *M_Material_New( PyObject * self, PyObject * args,
PyObject * keywords )
{
char *name = "Mat";
static char *kwlist[] = { "name", NULL };
BPy_Material *pymat; /* for Material Data object wrapper in Python */
Material *blmat; /* for actual Material Data we create in Blender */
char buf[21];
if( !PyArg_ParseTupleAndKeywords
( args, keywords, "|s", kwlist, &name ) )
return ( EXPP_ReturnPyObjError
( PyExc_AttributeError,
"expected string or nothing as argument" ) );
if( strcmp( name, "Mat" ) != 0 ) /* use gave us a name ? */
PyOS_snprintf( buf, sizeof( buf ), "%s", name );
blmat = add_material( name ); /* first create the Material Data in Blender */
if( blmat ) /* now create the wrapper obj in Python */
pymat = ( BPy_Material * ) Material_CreatePyObject( blmat );
else
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't create Material Data in Blender" ) );
blmat->id.us = 0; /* was incref'ed by add_material() above */
if( pymat == NULL )
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create Material Data object" ) );
return ( PyObject * ) pymat;
}
/*****************************************************************************/
/* Function: M_Material_Get */
/* Python equivalent: Blender.Material.Get */
/* Description: Receives a string and returns the material whose */
/* name matches the string. If no argument is */
/* passed in, a list with all materials in the */
/* current scene is returned. */
/*****************************************************************************/
static PyObject *M_Material_Get( PyObject * self, PyObject * args )
{
char *name = NULL;
Material *mat_iter;
if( !PyArg_ParseTuple( args, "|s", &name ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected string argument (or nothing)" ) );
mat_iter = G.main->mat.first;
if( name ) { /* (name) - Search material by name */
BPy_Material *wanted_mat = NULL;
while( mat_iter ) {
if( strcmp( name, mat_iter->id.name + 2 ) == 0 ) {
wanted_mat =
( BPy_Material * )
Material_CreatePyObject( mat_iter );
break;
}
mat_iter = mat_iter->id.next;
}
if( wanted_mat == NULL ) { /* Requested material doesn't exist */
char error_msg[64];
PyOS_snprintf( error_msg, sizeof( error_msg ),
"Material \"%s\" not found", name );
return EXPP_ReturnPyObjError( PyExc_NameError,
error_msg );
}
return ( PyObject * ) wanted_mat;
}
else { /* () - return a list with all materials in the scene */
int index = 0;
PyObject *matlist, *pyobj;
matlist = PyList_New( BLI_countlist( &( G.main->mat ) ) );
if( !matlist )
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create PyList" ) );
while( mat_iter ) {
pyobj = Material_CreatePyObject( mat_iter );
if( !pyobj )
return ( EXPP_ReturnPyObjError
( PyExc_MemoryError,
"couldn't create PyObject" ) );
PyList_SET_ITEM( matlist, index, pyobj );
mat_iter = mat_iter->id.next;
index++;
}
return matlist;
}
}
static PyObject *Lamp_ModesDict( void )
{
PyObject *Modes = M_constant_New( );
#undef EXPP_ADDCONST
#define EXPP_ADDCONST(name) \
constant_insert(c, #name, PyInt_FromLong(EXPP_MAT_MODE_##name))
/* So that:
* EXPP_ADDCONST(TRACEABLE) becomes:
* constant_insert(c, "TRACEABLE", PyInt_FromLong(EXPP_MAT_MODE_TRACEABLE))
*/
if( Modes ) {
BPy_constant *c = ( BPy_constant * ) Modes;
EXPP_ADDCONST( TRACEABLE );
EXPP_ADDCONST( SHADOW );
EXPP_ADDCONST( SHADELESS );
EXPP_ADDCONST( WIRE );
EXPP_ADDCONST( VCOL_LIGHT );
EXPP_ADDCONST( HALO );
EXPP_ADDCONST( ZTRANSP );
EXPP_ADDCONST( VCOL_PAINT );
EXPP_ADDCONST( ZINVERT );
EXPP_ADDCONST( HALORINGS );
EXPP_ADDCONST( ENV );
EXPP_ADDCONST( HALOLINES );
EXPP_ADDCONST( ONLYSHADOW );
EXPP_ADDCONST( HALOXALPHA );
EXPP_ADDCONST( HALOSTAR );
EXPP_ADDCONST( TEXFACE );
EXPP_ADDCONST( HALOTEX );
EXPP_ADDCONST( HALOPUNO );
EXPP_ADDCONST( NOMIST );
EXPP_ADDCONST( HALOSHADE );
EXPP_ADDCONST( HALOFLARE );
EXPP_ADDCONST( RADIO );
EXPP_ADDCONST( RAYMIRROR );
EXPP_ADDCONST( ZTRA );
EXPP_ADDCONST( RAYTRANSP );
EXPP_ADDCONST( ONLYSHADOW );
EXPP_ADDCONST( NOMIST );
EXPP_ADDCONST( ENV );
}
return Modes;
}
/*****************************************************************************/
/* Function: Material_Init */
/*****************************************************************************/
PyObject *Material_Init( void )
{
PyObject *submodule, *Modes;
Material_Type.ob_type = &PyType_Type;
Modes = Lamp_ModesDict( );
submodule = Py_InitModule3( "Blender.Material",
M_Material_methods, M_Material_doc );
if( Modes )
PyModule_AddObject( submodule, "Modes", Modes );
return ( submodule );
}
/***************************/
/*** The Material PyType ***/
/***************************/
/*****************************************************************************/
/* Python BPy_Material methods declarations: */
/*****************************************************************************/
static PyObject *Material_getIpo( BPy_Material * self );
static PyObject *Material_getName( BPy_Material * self );
static PyObject *Material_getMode( BPy_Material * self );
static PyObject *Material_getRGBCol( BPy_Material * self );
/*static PyObject *Material_getAmbCol(BPy_Material *self);*/
static PyObject *Material_getSpecCol( BPy_Material * self );
static PyObject *Material_getMirCol( BPy_Material * self );
static PyObject *Material_getAmb( BPy_Material * self );
static PyObject *Material_getEmit( BPy_Material * self );
static PyObject *Material_getAlpha( BPy_Material * self );
static PyObject *Material_getRef( BPy_Material * self );
static PyObject *Material_getSpec( BPy_Material * self );
static PyObject *Material_getSpecTransp( BPy_Material * self );
static PyObject *Material_getAdd( BPy_Material * self );
static PyObject *Material_getZOffset( BPy_Material * self );
static PyObject *Material_getHaloSize( BPy_Material * self );
static PyObject *Material_getHaloSeed( BPy_Material * self );
static PyObject *Material_getFlareSize( BPy_Material * self );
static PyObject *Material_getFlareSeed( BPy_Material * self );
static PyObject *Material_getFlareBoost( BPy_Material * self );
static PyObject *Material_getSubSize( BPy_Material * self );
static PyObject *Material_getHardness( BPy_Material * self );
static PyObject *Material_getNFlares( BPy_Material * self );
static PyObject *Material_getNStars( BPy_Material * self );
static PyObject *Material_getNLines( BPy_Material * self );
static PyObject *Material_getNRings( BPy_Material * self );
static PyObject *Material_getRayMirr( BPy_Material * self );
static PyObject *Material_getMirrDepth( BPy_Material * self );
static PyObject *Material_getFresnelMirr( BPy_Material * self );
static PyObject *Material_getFresnelMirrFac( BPy_Material * self );
static PyObject *Material_getIOR( BPy_Material * self );
static PyObject *Material_getTransDepth( BPy_Material * self );
static PyObject *Material_getFresnelTrans( BPy_Material * self );
static PyObject *Material_getFresnelTransFac( BPy_Material * self );
static PyObject *Material_getTextures( BPy_Material * self );
static PyObject *Material_setIpo( BPy_Material * self, PyObject * args );
static PyObject *Material_clearIpo( BPy_Material * self );
static PyObject *Material_setName( BPy_Material * self, PyObject * args );
static PyObject *Material_setMode( BPy_Material * self, PyObject * args );
static PyObject *Material_setIntMode( BPy_Material * self, PyObject * args );
static PyObject *Material_setRGBCol( BPy_Material * self, PyObject * args );
/*static PyObject *Material_setAmbCol(BPy_Material *self, PyObject *args);*/
static PyObject *Material_setSpecCol( BPy_Material * self, PyObject * args );
static PyObject *Material_setMirCol( BPy_Material * self, PyObject * args );
static PyObject *Material_setAmb( BPy_Material * self, PyObject * args );
static PyObject *Material_setEmit( BPy_Material * self, PyObject * args );
static PyObject *Material_setAlpha( BPy_Material * self, PyObject * args );
static PyObject *Material_setRef( BPy_Material * self, PyObject * args );
static PyObject *Material_setSpec( BPy_Material * self, PyObject * args );
static PyObject *Material_setSpecTransp( BPy_Material * self,
PyObject * args );
static PyObject *Material_setAdd( BPy_Material * self, PyObject * args );
static PyObject *Material_setZOffset( BPy_Material * self, PyObject * args );
static PyObject *Material_setHaloSize( BPy_Material * self, PyObject * args );
static PyObject *Material_setHaloSeed( BPy_Material * self, PyObject * args );
static PyObject *Material_setFlareSize( BPy_Material * self, PyObject * args );
static PyObject *Material_setFlareSeed( BPy_Material * self, PyObject * args );
static PyObject *Material_setFlareBoost( BPy_Material * self,
PyObject * args );
static PyObject *Material_setSubSize( BPy_Material * self, PyObject * args );
static PyObject *Material_setHardness( BPy_Material * self, PyObject * args );
static PyObject *Material_setNFlares( BPy_Material * self, PyObject * args );
static PyObject *Material_setNStars( BPy_Material * self, PyObject * args );
static PyObject *Material_setNLines( BPy_Material * self, PyObject * args );
static PyObject *Material_setNRings( BPy_Material * self, PyObject * args );
/* ** Mirror and transp ** */
static PyObject *Material_setRayMirr( BPy_Material * self, PyObject * args );
static PyObject *Material_setMirrDepth( BPy_Material * self, PyObject * args );
static PyObject *Material_setFresnelMirr( BPy_Material * self,
PyObject * args );
static PyObject *Material_setFresnelMirrFac( BPy_Material * self,
PyObject * args );
static PyObject *Material_setIOR( BPy_Material * self, PyObject * args );
static PyObject *Material_setTransDepth( BPy_Material * self,
PyObject * args );
static PyObject *Material_setFresnelTrans( BPy_Material * self,
PyObject * args );
static PyObject *Material_setFresnelTransFac( BPy_Material * self,
PyObject * args );
/* ** */
static PyObject *Material_setTexture( BPy_Material * self, PyObject * args );
static PyObject *Material_clearTexture( BPy_Material * self, PyObject * args );
static PyObject *Material_setColorComponent( BPy_Material * self, char *key,
PyObject * args );
static PyObject *Material_getScriptLinks( BPy_Material * self,
PyObject * args );
static PyObject *Material_addScriptLink( BPy_Material * self,
PyObject * args );
static PyObject *Material_clearScriptLinks( BPy_Material * self );
/*****************************************************************************/
/* Python BPy_Material methods table: */
/*****************************************************************************/
static PyMethodDef BPy_Material_methods[] = {
/* name, method, flags, doc */
{"getName", ( PyCFunction ) Material_getName, METH_NOARGS,
"() - Return Material's name"},
{"getIpo", ( PyCFunction ) Material_getIpo, METH_NOARGS,
"() - Return Material's ipo or None if not found"},
{"getMode", ( PyCFunction ) Material_getMode, METH_NOARGS,
"() - Return Material's mode flags"},
{"getRGBCol", ( PyCFunction ) Material_getRGBCol, METH_NOARGS,
"() - Return Material's rgb color triplet"},
/* {"getAmbCol", (PyCFunction)Material_getAmbCol, METH_NOARGS,
"() - Return Material's ambient color"},*/
{"getSpecCol", ( PyCFunction ) Material_getSpecCol, METH_NOARGS,
"() - Return Material's specular color"},
{"getMirCol", ( PyCFunction ) Material_getMirCol, METH_NOARGS,
"() - Return Material's mirror color"},
{"getAmb", ( PyCFunction ) Material_getAmb, METH_NOARGS,
"() - Return Material's ambient color blend factor"},
{"getEmit", ( PyCFunction ) Material_getEmit, METH_NOARGS,
"() - Return Material's emitting light intensity"},
{"getAlpha", ( PyCFunction ) Material_getAlpha, METH_NOARGS,
"() - Return Material's alpha (transparency) value"},
{"getRef", ( PyCFunction ) Material_getRef, METH_NOARGS,
"() - Return Material's reflectivity"},
{"getSpec", ( PyCFunction ) Material_getSpec, METH_NOARGS,
"() - Return Material's specularity"},
{"getSpecTransp", ( PyCFunction ) Material_getSpecTransp, METH_NOARGS,
"() - Return Material's specular transparency"},
{"getAdd", ( PyCFunction ) Material_getAdd, METH_NOARGS,
"() - Return Material's glow factor"},
{"getZOffset", ( PyCFunction ) Material_getZOffset, METH_NOARGS,
"() - Return Material's artificial offset for faces"},
{"getHaloSize", ( PyCFunction ) Material_getHaloSize, METH_NOARGS,
"() - Return Material's halo size"},
{"getHaloSeed", ( PyCFunction ) Material_getHaloSeed, METH_NOARGS,
"() - Return Material's seed for random ring dimension and line "
"location in halos"},
{"getFlareSize", ( PyCFunction ) Material_getFlareSize, METH_NOARGS,
"() - Return Material's (flare size)/(halo size) factor"},
{"getFlareSeed", ( PyCFunction ) Material_getFlareSeed, METH_NOARGS,
"() - Return Material's flare offset in the seed table"},
{"getFlareBoost", ( PyCFunction ) Material_getFlareBoost, METH_NOARGS,
"() - Return Material's flare boost"},
{"getSubSize", ( PyCFunction ) Material_getSubSize, METH_NOARGS,
"() - Return Material's dimension of subflare, dots and circles"},
{"getHardness", ( PyCFunction ) Material_getHardness, METH_NOARGS,
"() - Return Material's specular hardness"},
{"getNFlares", ( PyCFunction ) Material_getNFlares, METH_NOARGS,
"() - Return Material's number of flares in halo"},
{"getNStars", ( PyCFunction ) Material_getNStars, METH_NOARGS,
"() - Return Material's number of points in the halo stars"},
{"getNLines", ( PyCFunction ) Material_getNLines, METH_NOARGS,
"() - Return Material's number of lines in halo"},
{"getNRings", ( PyCFunction ) Material_getNRings, METH_NOARGS,
"() - Return Material's number of rings in halo"},
{"getRayMirr", ( PyCFunction ) Material_getRayMirr, METH_NOARGS,
"() - Return mount mirror"},
{"getMirrDepth", ( PyCFunction ) Material_getMirrDepth, METH_NOARGS,
"() - Return amount mirror depth"},
{"getFresnelMirr", ( PyCFunction ) Material_getFresnelMirr,
METH_NOARGS,
"() - Return fresnel power for refractions"},
{"getFresnelMirrFac", ( PyCFunction ) Material_getFresnelMirrFac,
METH_NOARGS,
"() - Return fresnel power for refractions factor"},
{"getIOR", ( PyCFunction ) Material_getIOR, METH_NOARGS,
"() - Return IOR"},
{"getTransDepth", ( PyCFunction ) Material_getTransDepth, METH_NOARGS,
"() - Return amount inter-refractions"},
{"getFresnelTrans", ( PyCFunction ) Material_getFresnelTrans,
METH_NOARGS,
"() - Return fresnel power for refractions"},
{"getFresnelTransFac", ( PyCFunction ) Material_getFresnelTransFac,
METH_NOARGS,
"() - Return fresnel power for refractions factor"},
{"getTextures", ( PyCFunction ) Material_getTextures, METH_NOARGS,
"() - Return Material's texture list as a tuple"},
{"setName", ( PyCFunction ) Material_setName, METH_VARARGS,
"(s) - Change Material's name"},
{"setIpo", ( PyCFunction ) Material_setIpo, METH_VARARGS,
"(Blender Ipo) - Change Material's Ipo"},
{"clearIpo", ( PyCFunction ) Material_clearIpo, METH_NOARGS,
"(Blender Ipo) - Unlink Ipo from this Material"},
{"setMode", ( PyCFunction ) Material_setMode, METH_VARARGS,
"([s[,s]]) - Set Material's mode flag(s)"},
{"setRGBCol", ( PyCFunction ) Material_setRGBCol, METH_VARARGS,
"(f,f,f or [f,f,f]) - Set Material's rgb color triplet"},
/* {"setAmbCol", (PyCFunction)Material_setAmbCol, METH_VARARGS,
"(f,f,f or [f,f,f]) - Set Material's ambient color"},*/
{"setSpecCol", ( PyCFunction ) Material_setSpecCol, METH_VARARGS,
"(f,f,f or [f,f,f]) - Set Material's specular color"},
{"setMirCol", ( PyCFunction ) Material_setMirCol, METH_VARARGS,
"(f,f,f or [f,f,f]) - Set Material's mirror color"},
{"setAmb", ( PyCFunction ) Material_setAmb, METH_VARARGS,
"(f) - Set how much the Material's color is affected"
" by \nthe global ambient colors - [0.0, 1.0]"},
{"setEmit", ( PyCFunction ) Material_setEmit, METH_VARARGS,
"(f) - Set Material's emitting light intensity - [0.0, 1.0]"},
{"setAlpha", ( PyCFunction ) Material_setAlpha, METH_VARARGS,
"(f) - Set Material's alpha (transparency) - [0.0, 1.0]"},
{"setRef", ( PyCFunction ) Material_setRef, METH_VARARGS,
"(f) - Set Material's reflectivity - [0.0, 1.0]"},
{"setSpec", ( PyCFunction ) Material_setSpec, METH_VARARGS,
"(f) - Set Material's specularity - [0.0, 2.0]"},
{"setSpecTransp", ( PyCFunction ) Material_setSpecTransp, METH_VARARGS,
"(f) - Set Material's specular transparency - [0.0, 1.0]"},
{"setAdd", ( PyCFunction ) Material_setAdd, METH_VARARGS,
"(f) - Set Material's glow factor - [0.0, 1.0]"},
{"setZOffset", ( PyCFunction ) Material_setZOffset, METH_VARARGS,
"(f) - Set Material's artificial offset - [0.0, 10.0]"},
{"setHaloSize", ( PyCFunction ) Material_setHaloSize, METH_VARARGS,
"(f) - Set Material's halo size - [0.0, 100.0]"},
{"setHaloSeed", ( PyCFunction ) Material_setHaloSeed, METH_VARARGS,
"(i) - Set Material's halo seed - [0, 255]"},
{"setFlareSize", ( PyCFunction ) Material_setFlareSize, METH_VARARGS,
"(f) - Set Material's factor: (flare size)/(halo size) - [0.1, 25.0]"},
{"setFlareSeed", ( PyCFunction ) Material_setFlareSeed, METH_VARARGS,
"(i) - Set Material's flare seed - [0, 255]"},
{"setFlareBoost", ( PyCFunction ) Material_setFlareBoost, METH_VARARGS,
"(f) - Set Material's flare boost - [0.1, 10.0]"},
{"setSubSize", ( PyCFunction ) Material_setSubSize, METH_VARARGS,
"(f) - Set Material's dimension of subflare,"
" dots and circles - [0.1, 25.0]"},
{"setHardness", ( PyCFunction ) Material_setHardness, METH_VARARGS,
"(i) - Set Material's hardness - [1, 255 (127 if halo mode is ON)]"},
{"setNFlares", ( PyCFunction ) Material_setNFlares, METH_VARARGS,
"(i) - Set Material's number of flares in halo - [1, 32]"},
{"setNStars", ( PyCFunction ) Material_setNStars, METH_VARARGS,
"(i) - Set Material's number of stars in halo - [3, 50]"},
{"setNLines", ( PyCFunction ) Material_setNLines, METH_VARARGS,
"(i) - Set Material's number of lines in halo - [0, 250]"},
{"setNRings", ( PyCFunction ) Material_setNRings, METH_VARARGS,
"(i) - Set Material's number of rings in halo - [0, 24]"},
{"setRayMirr", ( PyCFunction ) Material_setRayMirr, METH_VARARGS,
"(f) - Set amount mirror - [0.0, 1.0]"},
{"setMirrDepth", ( PyCFunction ) Material_setMirrDepth, METH_VARARGS,
"(i) - Set amount inter-reflections - [0, 10]"},
{"setFresnelMirr", ( PyCFunction ) Material_setFresnelMirr,
METH_VARARGS,
"(f) - Set fresnel power for mirror - [0.0, 5.0]"},
{"setFresnelMirrFac", ( PyCFunction ) Material_setFresnelMirrFac,
METH_VARARGS,
"(f) - Set blend fac for mirror fresnel - [1.0, 5.0]"},
{"setIOR", ( PyCFunction ) Material_setIOR, METH_VARARGS,
"(f) - Set IOR - [1.0, 3.0]"},
{"setTransDepth", ( PyCFunction ) Material_setTransDepth, METH_VARARGS,
"(i) - Set amount inter-refractions - [0, 10]"},
{"setFresnelTrans", ( PyCFunction ) Material_setFresnelTrans,
METH_VARARGS,
"(f) - Set fresnel power for refractions - [0.0, 5.0]"},
{"setFresnelTransFac", ( PyCFunction ) Material_setFresnelTransFac,
METH_VARARGS,
"(f) - Set fresnel power for refractions factot- [0.0, 5.0]"},
{"setTexture", ( PyCFunction ) Material_setTexture, METH_VARARGS,
"(n,tex,texco=0,mapto=0) - Set numbered texture to tex"},
{"clearTexture", ( PyCFunction ) Material_clearTexture, METH_VARARGS,
"(n) - Remove texture from numbered slot"},
{"getScriptLinks", ( PyCFunction ) Material_getScriptLinks,
METH_VARARGS,
"(eventname) - Get a list of this material's scriptlinks (Text names) "
"of the given type\n"
"(eventname) - string: FrameChanged or Redraw."},
{"addScriptLink", ( PyCFunction ) Material_addScriptLink, METH_VARARGS,
"(text, evt) - Add a new material scriptlink.\n"
"(text) - string: an existing Blender Text name;\n"
"(evt) string: FrameChanged or Redraw."},
{"clearScriptLinks", ( PyCFunction ) Material_clearScriptLinks,
METH_NOARGS,
"() - Delete all scriptlinks from this material."},
{NULL, NULL, 0, NULL}
};
/*****************************************************************************/
/* Python Material_Type callback function prototypes: */
/*****************************************************************************/
static void Material_dealloc( BPy_Material * self );
static int Material_setAttr( BPy_Material * self, char *name, PyObject * v );
static PyObject *Material_getAttr( BPy_Material * self, char *name );
static PyObject *Material_repr( BPy_Material * self );
/*****************************************************************************/
/* Python Material_Type structure definition: */
/*****************************************************************************/
PyTypeObject Material_Type = {
PyObject_HEAD_INIT( NULL )
0, /* ob_size */
"Blender Material", /* tp_name */
sizeof( BPy_Material ), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
( destructor ) Material_dealloc, /* tp_dealloc */
0, /* tp_print */
( getattrfunc ) Material_getAttr, /* tp_getattr */
( setattrfunc ) Material_setAttr, /* tp_setattr */
0, /* tp_compare */
( reprfunc ) Material_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_as_hash */
0, 0, 0, 0, 0, 0,
0, /* tp_doc */
0, 0, 0, 0, 0, 0,
BPy_Material_methods, /* tp_methods */
0, /* tp_members */
};
/*****************************************************************************/
/* Function: Material_dealloc */
/* Description: This is a callback function for the BPy_Material type. It is */
/* the destructor function. */
/*****************************************************************************/
static void Material_dealloc( BPy_Material * self )
{
Py_DECREF( self->col );
Py_DECREF( self->amb );
Py_DECREF( self->spec );
Py_DECREF( self->mir );
PyObject_DEL( self );
}
/*****************************************************************************/
/* Function: Material_CreatePyObject */
/* Description: Create a new BPy_Material from an existing */
/* Blender material structure. */
/*****************************************************************************/
PyObject *Material_CreatePyObject( struct Material *mat )
{
BPy_Material *pymat;
float *col[3], *amb[3], *spec[3], *mir[3];
pymat = ( BPy_Material * ) PyObject_NEW( BPy_Material,
&Material_Type );
if( !pymat )
return EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create BPy_Material object" );
pymat->material = mat;
col[0] = &mat->r;
col[1] = &mat->g;
col[2] = &mat->b;
amb[0] = &mat->ambr;
amb[1] = &mat->ambg;
amb[2] = &mat->ambb;
spec[0] = &mat->specr;
spec[1] = &mat->specg;
spec[2] = &mat->specb;
mir[0] = &mat->mirr;
mir[1] = &mat->mirg;
mir[2] = &mat->mirb;
pymat->col = ( BPy_rgbTuple * ) rgbTuple_New( col );
pymat->amb = ( BPy_rgbTuple * ) rgbTuple_New( amb );
pymat->spec = ( BPy_rgbTuple * ) rgbTuple_New( spec );
pymat->mir = ( BPy_rgbTuple * ) rgbTuple_New( mir );
return ( PyObject * ) pymat;
}
/*****************************************************************************/
/* Function: Material_CheckPyObject */
/* Description: This function returns true when the given PyObject is of the */
/* type Material. Otherwise it will return false. */
/*****************************************************************************/
int Material_CheckPyObject( PyObject * pyobj )
{
return ( pyobj->ob_type == &Material_Type );
}
/*****************************************************************************/
/* Function: Material_FromPyObject */
/* Description: This function returns the Blender material from the given */
/* PyObject. */
/*****************************************************************************/
Material *Material_FromPyObject( PyObject * pyobj )
{
return ( ( BPy_Material * ) pyobj )->material;
}
/*****************************************************************************/
/* Description: Returns the object with the name specified by the argument */
/* name. Note that the calling function has to remove the first */
/* two characters of the object name. These two characters */
/* specify the type of the object (OB, ME, WO, ...) */
/* The function will return NULL when no object with the given */
/* name is found. */
/*****************************************************************************/
Material *GetMaterialByName( char *name )
{
Material *mat_iter;
mat_iter = G.main->mat.first;
while( mat_iter ) {
if( StringEqual( name, GetIdName( &( mat_iter->id ) ) ) ) {
return ( mat_iter );
}
mat_iter = mat_iter->id.next;
}
/* There is no material with the given name */
return ( NULL );
}
/*****************************************************************************/
/* Python BPy_Material methods: */
/*****************************************************************************/
static PyObject *Material_getIpo( BPy_Material * self )
{
Ipo *ipo = self->material->ipo;
if( !ipo ) {
Py_INCREF( Py_None );
return Py_None;
}
return Ipo_CreatePyObject( ipo );
}
static PyObject *Material_getName( BPy_Material * self )
{
PyObject *attr = PyString_FromString( self->material->id.name + 2 );
if( attr )
return attr;
return ( EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.name attribute" ) );
}
static PyObject *Material_getMode( BPy_Material * self )
{
PyObject *attr = PyInt_FromLong( ( long ) self->material->mode );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.Mode attribute" );
}
static PyObject *Material_getRGBCol( BPy_Material * self )
{
return rgbTuple_getCol( self->col );
}
/*
static PyObject *Material_getAmbCol(BPy_Material *self)
{
return rgbTuple_getCol(self->amb);
}
*/
static PyObject *Material_getSpecCol( BPy_Material * self )
{
return rgbTuple_getCol( self->spec );
}
static PyObject *Material_getMirCol( BPy_Material * self )
{
return rgbTuple_getCol( self->mir );
}
static PyObject *Material_getAmb( BPy_Material * self )
{
PyObject *attr = PyFloat_FromDouble( ( double ) self->material->amb );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.amb attribute" );
}
static PyObject *Material_getEmit( BPy_Material * self )
{
PyObject *attr = PyFloat_FromDouble( ( double ) self->material->emit );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.emit attribute" );
}
static PyObject *Material_getAlpha( BPy_Material * self )
{
PyObject *attr =
PyFloat_FromDouble( ( double ) self->material->alpha );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.alpha attribute" );
}
static PyObject *Material_getRef( BPy_Material * self )
{
PyObject *attr = PyFloat_FromDouble( ( double ) self->material->ref );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.ref attribute" );
}
static PyObject *Material_getSpec( BPy_Material * self )
{
PyObject *attr = PyFloat_FromDouble( ( double ) self->material->spec );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.spec attribute" );
}
static PyObject *Material_getSpecTransp( BPy_Material * self )
{
PyObject *attr =
PyFloat_FromDouble( ( double ) self->material->spectra );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.specTransp attribute" );
}
static PyObject *Material_getAdd( BPy_Material * self )
{
PyObject *attr = PyFloat_FromDouble( ( double ) self->material->add );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.add attribute" );
}
static PyObject *Material_getZOffset( BPy_Material * self )
{
PyObject *attr =
PyFloat_FromDouble( ( double ) self->material->zoffs );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.zOffset attribute" );
}
static PyObject *Material_getHaloSize( BPy_Material * self )
{
PyObject *attr =
PyFloat_FromDouble( ( double ) self->material->hasize );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.haloSize attribute" );
}
static PyObject *Material_getFlareSize( BPy_Material * self )
{
PyObject *attr =
PyFloat_FromDouble( ( double ) self->material->flaresize );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.flareSize attribute" );
}
static PyObject *Material_getFlareBoost( BPy_Material * self )
{
PyObject *attr =
PyFloat_FromDouble( ( double ) self->material->flareboost );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.flareBoost attribute" );
}
static PyObject *Material_getSubSize( BPy_Material * self )
{
PyObject *attr =
PyFloat_FromDouble( ( double ) self->material->subsize );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.subSize attribute" );
}
static PyObject *Material_getHaloSeed( BPy_Material * self )
{
PyObject *attr = PyInt_FromLong( ( long ) self->material->seed1 );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.haloSeed attribute" );
}
static PyObject *Material_getFlareSeed( BPy_Material * self )
{
PyObject *attr = PyInt_FromLong( ( long ) self->material->seed2 );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.flareSeed attribute" );
}
static PyObject *Material_getHardness( BPy_Material * self )
{
PyObject *attr = PyInt_FromLong( ( long ) self->material->har );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.hard attribute" );
}
static PyObject *Material_getNFlares( BPy_Material * self )
{
PyObject *attr = PyInt_FromLong( ( long ) self->material->flarec );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.nFlares attribute" );
}
static PyObject *Material_getNStars( BPy_Material * self )
{
PyObject *attr = PyInt_FromLong( ( long ) self->material->starc );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.nStars attribute" );
}
static PyObject *Material_getNLines( BPy_Material * self )
{
PyObject *attr = PyInt_FromLong( ( long ) self->material->linec );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.nLines attribute" );
}
static PyObject *Material_getNRings( BPy_Material * self )
{
PyObject *attr = PyInt_FromLong( ( long ) self->material->ringc );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.nRings attribute" );
}
static PyObject *Material_getRayMirr( BPy_Material * self )
{
PyObject *attr =
PyFloat_FromDouble( ( double ) self->material->ray_mirror );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.nRings attribute" );
}
static PyObject *Material_getMirrDepth( BPy_Material * self )
{
PyObject *attr = PyInt_FromLong( ( long ) self->material->ray_depth );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.nRings attribute" );
}
static PyObject *Material_getFresnelMirr( BPy_Material * self )
{
PyObject *attr =
PyFloat_FromDouble( ( double ) self->material->fresnel_mir );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.nRings attribute" );
}
static PyObject *Material_getFresnelMirrFac( BPy_Material * self )
{
PyObject *attr =
PyFloat_FromDouble( ( double ) self->material->fresnel_mir_i );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.nRings attribute" );
}
static PyObject *Material_getIOR( BPy_Material * self )
{
PyObject *attr = PyFloat_FromDouble( ( double ) self->material->ang );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.nRings attribute" );
}
static PyObject *Material_getTransDepth( BPy_Material * self )
{
PyObject *attr =
PyInt_FromLong( ( long ) self->material->ray_depth_tra );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.nRings attribute" );
}
static PyObject *Material_getFresnelTrans( BPy_Material * self )
{
PyObject *attr =
PyFloat_FromDouble( ( double ) self->material->fresnel_tra );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.nRings attribute" );
}
static PyObject *Material_getFresnelTransFac( BPy_Material * self )
{
PyObject *attr =
PyFloat_FromDouble( ( double ) self->material->fresnel_tra_i );
if( attr )
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"couldn't get Material.nRings attribute" );
}
static PyObject *Material_getTextures( BPy_Material * self )
{
int i;
struct MTex *mtex;
PyObject *t[MAX_MTEX];
PyObject *tuple;
/* build a texture list */
for( i = 0; i < MAX_MTEX; ++i ) {
mtex = self->material->mtex[i];
if( mtex ) {
t[i] = MTex_CreatePyObject( mtex );
} else {
Py_INCREF( Py_None );
t[i] = Py_None;
}
}
/* turn the array into a tuple */
tuple = Py_BuildValue( "NNNNNNNN", t[0], t[1], t[2], t[3],
t[4], t[5], t[6], t[7] );
if( !tuple )
return EXPP_ReturnPyObjError( PyExc_MemoryError,
"Material_getTextures: couldn't create PyTuple" );
return tuple;
}
PyObject *Material_setIpo( BPy_Material * self, PyObject * args )
{
PyObject *pyipo = 0;
Ipo *ipo = NULL;
Ipo *oldipo;
if( !PyArg_ParseTuple( args, "O!", &Ipo_Type, &pyipo ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"expected Ipo as argument" );
ipo = Ipo_FromPyObject( pyipo );
if( !ipo )
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
"null ipo!" );
if( ipo->blocktype != ID_MA )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"this ipo is not a Material type ipo" );
oldipo = self->material->ipo;
if( oldipo ) {
ID *id = &oldipo->id;
if( id->us > 0 )
id->us--;
}
( ( ID * ) & ipo->id )->us++;
self->material->ipo = ipo;
Py_INCREF( Py_None );
return Py_None;
}
static PyObject *Material_clearIpo( BPy_Material * self )
{
Material *mat = self->material;
Ipo *ipo = ( Ipo * ) mat->ipo;
if( ipo ) {
ID *id = &ipo->id;
if( id->us > 0 )
id->us--;
mat->ipo = NULL;
Py_INCREF( Py_True );
return Py_True;
}
Py_INCREF( Py_False ); /* no ipo found */
return Py_False;
}
static PyObject *Material_setName( BPy_Material * self, PyObject * args )
{
char *name;
char buf[21];
if( !PyArg_ParseTuple( args, "s", &name ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected string argument" ) );
PyOS_snprintf( buf, sizeof( buf ), "%s", name );
rename_id( &self->material->id, buf );
Py_INCREF( Py_None );
return Py_None;
}
/* Possible modes are traceable, shadow, shadeless, wire, vcolLight,
* vcolPaint, halo, ztransp, zinvert, haloRings, env, haloLines,
* onlyShadow, xalpha, star, faceTexture, haloTex, haloPuno, noMist,
* haloShaded, haloFlare */
static PyObject *Material_setMode( BPy_Material * self, PyObject * args )
{
int i, flag = 0;
char *m[28] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL
};
if( !PyArg_ParseTuple( args, "|ssssssssssssssssssssssssssss",
&m[0], &m[1], &m[2], &m[3], &m[4], &m[5], &m[6],
&m[7], &m[8], &m[9], &m[10], &m[11], &m[12],
&m[13], &m[14], &m[15], &m[16], &m[17], &m[18],
&m[19], &m[20], &m[21], &m[22], &m[23], &m[24],
&m[25], &m[26], &m[27] ) ) {
return ( EXPP_ReturnPyObjError
( PyExc_AttributeError,
"expected from none to 22 string argument(s)" ) );
}
for( i = 0; i < 28; i++ ) {
if( m[i] == NULL )
break;
if( strcmp( m[i], "Traceable" ) == 0 )
flag |= EXPP_MAT_MODE_TRACEABLE;
else if( strcmp( m[i], "Shadow" ) == 0 )
flag |= EXPP_MAT_MODE_SHADOW;
else if( strcmp( m[i], "Shadeless" ) == 0 )
flag |= EXPP_MAT_MODE_SHADELESS;
else if( strcmp( m[i], "Wire" ) == 0 )
flag |= EXPP_MAT_MODE_WIRE;
else if( strcmp( m[i], "VColLight" ) == 0 )
flag |= EXPP_MAT_MODE_VCOL_LIGHT;
else if( strcmp( m[i], "VColPaint" ) == 0 )
flag |= EXPP_MAT_MODE_VCOL_PAINT;
else if( strcmp( m[i], "Halo" ) == 0 )
flag |= EXPP_MAT_MODE_HALO;
else if( strcmp( m[i], "ZTransp" ) == 0 )
flag |= EXPP_MAT_MODE_ZTRANSP;
else if( strcmp( m[i], "ZInvert" ) == 0 )
flag |= EXPP_MAT_MODE_ZINVERT;
else if( strcmp( m[i], "HaloRings" ) == 0 )
flag |= EXPP_MAT_MODE_HALORINGS;
else if( strcmp( m[i], "Env" ) == 0 )
flag |= EXPP_MAT_MODE_ENV;
else if( strcmp( m[i], "HaloLines" ) == 0 )
flag |= EXPP_MAT_MODE_HALOLINES;
else if( strcmp( m[i], "OnlyShadow" ) == 0 )
flag |= EXPP_MAT_MODE_ONLYSHADOW;
else if( strcmp( m[i], "HaloXAlpha" ) == 0 )
flag |= EXPP_MAT_MODE_HALOXALPHA;
else if( strcmp( m[i], "HaloStar" ) == 0 )
flag |= EXPP_MAT_MODE_HALOSTAR;
else if( strcmp( m[i], "TexFace" ) == 0 )
flag |= EXPP_MAT_MODE_TEXFACE;
else if( strcmp( m[i], "HaloTex" ) == 0 )
flag |= EXPP_MAT_MODE_HALOTEX;
else if( strcmp( m[i], "HaloPuno" ) == 0 )
flag |= EXPP_MAT_MODE_HALOPUNO;
else if( strcmp( m[i], "NoMist" ) == 0 )
flag |= EXPP_MAT_MODE_NOMIST;
else if( strcmp( m[i], "HaloShaded" ) == 0 )
flag |= EXPP_MAT_MODE_HALOSHADE;
else if( strcmp( m[i], "HaloFlare" ) == 0 )
flag |= EXPP_MAT_MODE_HALOFLARE;
else if( strcmp( m[i], "Radio" ) == 0 )
flag |= EXPP_MAT_MODE_RADIO;
/* ** Mirror ** */
else if( strcmp( m[i], "RayMirr" ) == 0 )
flag |= EXPP_MAT_MODE_RAYMIRROR;
else if( strcmp( m[i], "ZTransp" ) == 0 )
flag |= EXPP_MAT_MODE_ZTRA;
else if( strcmp( m[i], "RayTransp" ) == 0 )
flag |= EXPP_MAT_MODE_RAYTRANSP;
else if( strcmp( m[i], "OnlyShadow" ) == 0 )
flag |= EXPP_MAT_MODE_ONLYSHADOW;
else if( strcmp( m[i], "NoMist" ) == 0 )
flag |= EXPP_MAT_MODE_NOMIST;
else if( strcmp( m[i], "Env" ) == 0 )
flag |= EXPP_MAT_MODE_ENV;
/* ** */
else
return ( EXPP_ReturnPyObjError( PyExc_AttributeError,
"unknown Material mode argument" ) );
}
self->material->mode = flag;
Py_INCREF( Py_None );
return Py_None;
}
/* Another helper function, for the same reason.
* (See comment before Material_setIntType above). */
static PyObject *Material_setIntMode( BPy_Material * self, PyObject * args )
{
int value;
if( !PyArg_ParseTuple( args, "i", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected int argument" ) );
self->material->mode = value;
Py_INCREF( Py_None );
return Py_None;
}
static PyObject *Material_setRGBCol( BPy_Material * self, PyObject * args )
{
return rgbTuple_setCol( self->col, args );
}
/*
static PyObject *Material_setAmbCol (BPy_Material *self, PyObject *args)
{
return rgbTuple_setCol(self->amb, args);
}
*/
static PyObject *Material_setSpecCol( BPy_Material * self, PyObject * args )
{
return rgbTuple_setCol( self->spec, args );
}
static PyObject *Material_setMirCol( BPy_Material * self, PyObject * args )
{
return rgbTuple_setCol( self->mir, args );
}
static PyObject *Material_setColorComponent( BPy_Material * self, char *key,
PyObject * args )
{ /* for compatibility with old bpython */
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 1.0]" ) );
value = EXPP_ClampFloat( value, EXPP_MAT_COL_MIN, EXPP_MAT_COL_MAX );
if( !strcmp( key, "R" ) )
self->material->r = value;
else if( !strcmp( key, "G" ) )
self->material->g = value;
else if( !strcmp( key, "B" ) )
self->material->b = value;
else if( !strcmp( key, "specR" ) )
self->material->specr = value;
else if( !strcmp( key, "specG" ) )
self->material->specg = value;
else if( !strcmp( key, "specB" ) )
self->material->specb = value;
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setAmb( BPy_Material * self, PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 1.0]" ) );
self->material->amb = EXPP_ClampFloat( value, EXPP_MAT_AMB_MIN,
EXPP_MAT_AMB_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setEmit( BPy_Material * self, PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 1.0]" ) );
self->material->emit = EXPP_ClampFloat( value, EXPP_MAT_EMIT_MIN,
EXPP_MAT_EMIT_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setSpecTransp( BPy_Material * self, PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 1.0]" ) );
self->material->spectra = EXPP_ClampFloat( value, EXPP_MAT_SPECTRA_MIN,
EXPP_MAT_SPECTRA_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setAlpha( BPy_Material * self, PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 1.0]" ) );
self->material->alpha = EXPP_ClampFloat( value, EXPP_MAT_ALPHA_MIN,
EXPP_MAT_ALPHA_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setRef( BPy_Material * self, PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 1.0]" ) );
self->material->ref = EXPP_ClampFloat( value, EXPP_MAT_REF_MIN,
EXPP_MAT_REF_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setSpec( BPy_Material * self, PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 1.0]" ) );
self->material->spec = EXPP_ClampFloat( value, EXPP_MAT_SPEC_MIN,
EXPP_MAT_SPEC_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setZOffset( BPy_Material * self, PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 10.0]" ) );
self->material->zoffs = EXPP_ClampFloat( value, EXPP_MAT_ZOFFS_MIN,
EXPP_MAT_ZOFFS_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setAdd( BPy_Material * self, PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 1.0]" ) );
self->material->add = EXPP_ClampFloat( value, EXPP_MAT_ADD_MIN,
EXPP_MAT_ADD_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setHaloSize( BPy_Material * self, PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 100.0]" ) );
self->material->hasize = EXPP_ClampFloat( value, EXPP_MAT_HALOSIZE_MIN,
EXPP_MAT_HALOSIZE_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setFlareSize( BPy_Material * self, PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.1, 25.0]" ) );
self->material->flaresize =
EXPP_ClampFloat( value, EXPP_MAT_FLARESIZE_MIN,
EXPP_MAT_FLARESIZE_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setFlareBoost( BPy_Material * self, PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.1, 10.0]" ) );
self->material->flareboost =
EXPP_ClampFloat( value, EXPP_MAT_FLAREBOOST_MIN,
EXPP_MAT_FLAREBOOST_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setSubSize( BPy_Material * self, PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.1, 25.0]" ) );
self->material->subsize = EXPP_ClampFloat( value, EXPP_MAT_SUBSIZE_MIN,
EXPP_MAT_SUBSIZE_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setHaloSeed( BPy_Material * self, PyObject * args )
{
short value;
if( !PyArg_ParseTuple( args, "h", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected int argument in [1, 255]" ) );
self->material->seed1 = EXPP_ClampInt( value, EXPP_MAT_HALOSEED_MIN,
EXPP_MAT_HALOSEED_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setFlareSeed( BPy_Material * self, PyObject * args )
{
short value;
if( !PyArg_ParseTuple( args, "h", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected int argument in [1, 255]" ) );
self->material->seed2 = EXPP_ClampInt( value, EXPP_MAT_FLARESEED_MIN,
EXPP_MAT_FLARESEED_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setHardness( BPy_Material * self, PyObject * args )
{
short value;
if( !PyArg_ParseTuple( args, "h", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected int argument in [1, 255]" ) );
self->material->har = EXPP_ClampInt( value, EXPP_MAT_HARD_MIN,
EXPP_MAT_HARD_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setNFlares( BPy_Material * self, PyObject * args )
{
short value;
if( !PyArg_ParseTuple( args, "h", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected int argument in [1, 32]" ) );
self->material->flarec = EXPP_ClampInt( value, EXPP_MAT_NFLARES_MIN,
EXPP_MAT_NFLARES_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setNStars( BPy_Material * self, PyObject * args )
{
short value;
if( !PyArg_ParseTuple( args, "h", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected int argument in [3, 50]" ) );
self->material->starc = EXPP_ClampInt( value, EXPP_MAT_NSTARS_MIN,
EXPP_MAT_NSTARS_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setNLines( BPy_Material * self, PyObject * args )
{
short value;
if( !PyArg_ParseTuple( args, "h", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected int argument in [0, 250]" ) );
self->material->linec = EXPP_ClampInt( value, EXPP_MAT_NLINES_MIN,
EXPP_MAT_NLINES_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setNRings( BPy_Material * self, PyObject * args )
{
short value;
if( !PyArg_ParseTuple( args, "h", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected int argument in [0, 24]" ) );
self->material->ringc = EXPP_ClampInt( value, EXPP_MAT_NRINGS_MIN,
EXPP_MAT_NRINGS_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setRayMirr( BPy_Material * self, PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 1.0]" ) );
self->material->ray_mirror =
EXPP_ClampFloat( value, EXPP_MAT_RAYMIRR_MIN,
EXPP_MAT_RAYMIRR_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setMirrDepth( BPy_Material * self, PyObject * args )
{
int value;
if( !PyArg_ParseTuple( args, "i", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0, 10]" ) );
self->material->ray_depth =
EXPP_ClampInt( value, EXPP_MAT_MIRRDEPTH_MIN,
EXPP_MAT_MIRRDEPTH_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setFresnelMirr( BPy_Material * self,
PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 5.0]" ) );
self->material->fresnel_mir =
EXPP_ClampFloat( value, EXPP_MAT_FRESNELMIRR_MIN,
EXPP_MAT_FRESNELMIRR_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setFresnelMirrFac( BPy_Material * self,
PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 5.0]" ) );
self->material->fresnel_mir_i =
EXPP_ClampFloat( value, EXPP_MAT_FRESNELMIRRFAC_MIN,
EXPP_MAT_FRESNELMIRRFAC_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setIOR( BPy_Material * self, PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 5.0]" ) );
self->material->ang = EXPP_ClampFloat( value, EXPP_MAT_IOR_MIN,
EXPP_MAT_IOR_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setTransDepth( BPy_Material * self, PyObject * args )
{
int value;
if( !PyArg_ParseTuple( args, "i", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0, 10]" ) );
self->material->ray_depth_tra =
EXPP_ClampInt( value, EXPP_MAT_TRANSDEPTH_MIN,
EXPP_MAT_TRANSDEPTH_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setFresnelTrans( BPy_Material * self,
PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 5.0]" ) );
self->material->fresnel_tra =
EXPP_ClampFloat( value, EXPP_MAT_FRESNELTRANS_MIN,
EXPP_MAT_FRESNELTRANS_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setFresnelTransFac( BPy_Material * self,
PyObject * args )
{
float value;
if( !PyArg_ParseTuple( args, "f", &value ) )
return ( EXPP_ReturnPyObjError( PyExc_TypeError,
"expected float argument in [0.0, 5.0]" ) );
self->material->fresnel_tra_i =
EXPP_ClampFloat( value, EXPP_MAT_FRESNELTRANSFAC_MIN,
EXPP_MAT_FRESNELTRANSFAC_MAX );
return EXPP_incr_ret( Py_None );
}
static PyObject *Material_setTexture( BPy_Material * self, PyObject * args )
{
int texnum;
PyObject *pytex;
Tex *bltex;
int texco = TEXCO_ORCO, mapto = MAP_COL;
if( !PyArg_ParseTuple( args, "iO!|ii", &texnum, &Texture_Type, &pytex,
&texco, &mapto ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"expected int in [0,9] and Texture" );
if( ( texnum < 0 ) || ( texnum >= MAX_MTEX ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"expected int in [0,9] and Texture" );
bltex = Texture_FromPyObject( pytex );
if( !self->material->mtex[texnum] ) {
/* there isn't an mtex for this slot so we need to make one */
self->material->mtex[texnum] = add_mtex( );
} else {
/* we already had a texture here so deal with the old one first */
self->material->mtex[texnum]->tex->id.us--;
}
self->material->mtex[texnum]->tex = bltex;
id_us_plus( &bltex->id );
self->material->mtex[texnum]->texco = texco;
self->material->mtex[texnum]->mapto = mapto;
Py_INCREF( Py_None );
return Py_None;
}
static PyObject *Material_clearTexture( BPy_Material * self, PyObject * args )
{
int texnum;
struct MTex *mtex;
if( !PyArg_ParseTuple( args, "i", &texnum ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"expected int in [0,9]" );
if( ( texnum < 0 ) || ( texnum >= MAX_MTEX ) )
return EXPP_ReturnPyObjError( PyExc_TypeError,
"expected int in [0,9]" );
mtex = self->material->mtex[texnum];
if( mtex ) {
if( mtex->tex )
mtex->tex->id.us--;
MEM_freeN( mtex );
self->material->mtex[texnum] = NULL;
}
Py_INCREF( Py_None );
return Py_None;
}
/* mat.addScriptLink */
static PyObject *Material_addScriptLink( BPy_Material * self, PyObject * args )
{
Material *mat = self->material;
ScriptLink *slink = NULL;
slink = &( mat )->scriptlink;
if( !EXPP_addScriptLink( slink, args, 0 ) )
return EXPP_incr_ret( Py_None );
else
return NULL;
}
/* mat.clearScriptLinks */
static PyObject *Material_clearScriptLinks( BPy_Material * self )
{
Material *mat = self->material;
ScriptLink *slink = NULL;
slink = &( mat )->scriptlink;
return EXPP_incr_ret( Py_BuildValue
( "i", EXPP_clearScriptLinks( slink ) ) );
}
/* mat.getScriptLinks */
static PyObject *Material_getScriptLinks( BPy_Material * self,
PyObject * args )
{
Material *mat = self->material;
ScriptLink *slink = NULL;
PyObject *ret = NULL;
slink = &( mat )->scriptlink;
ret = EXPP_getScriptLinks( slink, args, 0 );
if( ret )
return ret;
else
return NULL;
}
/*****************************************************************************/
/* Function: Material_getAttr */
/* Description: This is a callback function for the BPy_Material type. It is */
/* the function that accesses BPy_Material "member variables" */
/* and methods. */
/*****************************************************************************/
static PyObject *Material_getAttr( BPy_Material * self, char *name )
{
PyObject *attr = Py_None;
if( strcmp( name, "name" ) == 0 )
attr = PyString_FromString( self->material->id.name + 2 );
else if( strcmp( name, "mode" ) == 0 )
attr = PyInt_FromLong( self->material->mode );
else if( strcmp( name, "rgbCol" ) == 0 )
attr = Material_getRGBCol( self );
/* else if (strcmp(name, "ambCol") == 0)
attr = Material_getAmbCol(self);*/
else if( strcmp( name, "specCol" ) == 0 )
attr = Material_getSpecCol( self );
else if( strcmp( name, "mirCol" ) == 0 )
attr = Material_getMirCol( self );
else if( strcmp( name, "R" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->r );
else if( strcmp( name, "G" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->g );
else if( strcmp( name, "B" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->b );
else if( strcmp( name, "specR" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->specr );
else if( strcmp( name, "specG" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->specg );
else if( strcmp( name, "specB" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->specb );
else if( strcmp( name, "amb" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->amb );
else if( strcmp( name, "emit" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->emit );
else if( strcmp( name, "alpha" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->alpha );
else if( strcmp( name, "ref" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->ref );
else if( strcmp( name, "spec" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->spec );
else if( strcmp( name, "specTransp" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->
spectra );
else if( strcmp( name, "add" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->add );
else if( strcmp( name, "zOffset" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->zoffs );
else if( strcmp( name, "haloSize" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->hasize );
else if( strcmp( name, "haloSeed" ) == 0 )
attr = PyInt_FromLong( ( double ) self->material->seed1 );
else if( strcmp( name, "flareSize" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->
flaresize );
else if( strcmp( name, "flareBoost" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->
flareboost );
else if( strcmp( name, "flareSeed" ) == 0 )
attr = PyInt_FromLong( ( double ) self->material->seed2 );
else if( strcmp( name, "subSize" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->
subsize );
else if( strcmp( name, "hard" ) == 0 )
attr = PyInt_FromLong( ( long ) self->material->har );
else if( strcmp( name, "nFlares" ) == 0 )
attr = PyInt_FromLong( ( long ) self->material->flarec );
else if( strcmp( name, "nStars" ) == 0 )
attr = PyInt_FromLong( ( long ) self->material->starc );
else if( strcmp( name, "nLines" ) == 0 )
attr = PyInt_FromLong( ( long ) self->material->linec );
else if( strcmp( name, "nRings" ) == 0 )
attr = PyInt_FromLong( ( long ) self->material->ringc );
else if( strcmp( name, "rayMirr" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->
ray_mirror );
else if( strcmp( name, "rayMirrDepth" ) == 0 )
attr = PyInt_FromLong( ( long ) self->material->ray_depth );
else if( strcmp( name, "fresnelDepth" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->
fresnel_mir );
else if( strcmp( name, "fresnelDepthFac" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->
fresnel_mir_i );
else if( strcmp( name, "IOR" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->ang );
else if( strcmp( name, "transDepth" ) == 0 )
attr = PyInt_FromLong( ( double ) self->material->
ray_depth_tra );
else if( strcmp( name, "fresnelTrans" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->
fresnel_tra );
else if( strcmp( name, "fresnelTransFac" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->
fresnel_tra_i );
else if( strcmp( name, "__members__" ) == 0 ) {
attr = /* 27 items */
Py_BuildValue
( "[s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s]",
"name", "mode", "rgbCol", "specCol", "mirCol", "R",
"G", "B", "alpha", "amb", "emit", "ref", "spec",
"specTransp", "add", "zOffset", "haloSize",
"haloSeed", "flareSize", "flareBoost", "flareSeed",
"subSize", "hard", "nFlares", "nStars", "nLines",
"nRings", "rayMirr", "rayMirrDepth", "fresnelDepth",
"fresnelDepthFac", "IOR", "transDepth",
"fresnelTrans", "fresnelTransFac" );
}
if( !attr )
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create PyObject" ) );
if( attr != Py_None )
return attr; /* member attribute found, return it */
/* not an attribute, search the methods table */
return Py_FindMethod( BPy_Material_methods, ( PyObject * ) self,
name );
}
/****************************************************************************/
/* Function: Material_setAttr */
/* Description: This is a callback function for the BPy_Material type. */
/* It is the function that sets Material attributes (member */
/* variables). */
/****************************************************************************/
static int Material_setAttr( BPy_Material * self, char *name,
PyObject * value )
{
PyObject *valtuple;
PyObject *error = NULL;
/* We're playing a trick on the Python API users here. Even if they use
* Material.member = val instead of Material.setMember(val), we end up using
* the function anyway, since it already has error checking, clamps to the
* right interval and updates the Blender Material structure when necessary.
*/
/* First we put "value" in a tuple, because we want to pass it to functions
* that only accept PyTuples. */
valtuple = Py_BuildValue( "(O)", value );
if( !valtuple ) /* everything OK with our PyObject? */
return EXPP_ReturnIntError( PyExc_MemoryError,
"MaterialSetAttr: couldn't create PyTuple" );
/* Now we just compare "name" with all possible BPy_Material member variables */
if( strcmp( name, "name" ) == 0 )
error = Material_setName( self, valtuple );
else if( strcmp( name, "mode" ) == 0 )
error = Material_setIntMode( self, valtuple ); /* special case */
else if( strcmp( name, "rgbCol" ) == 0 )
error = Material_setRGBCol( self, valtuple );
/* else if (strcmp (name, "ambCol") == 0)
error = Material_setAmbCol (self, valtuple);*/
else if( strcmp( name, "specCol" ) == 0 )
error = Material_setSpecCol( self, valtuple );
else if( strcmp( name, "mirCol" ) == 0 )
error = Material_setMirCol( self, valtuple );
else if( strcmp( name, "R" ) == 0 )
error = Material_setColorComponent( self, "R", valtuple );
else if( strcmp( name, "G" ) == 0 )
error = Material_setColorComponent( self, "G", valtuple );
else if( strcmp( name, "B" ) == 0 )
error = Material_setColorComponent( self, "B", valtuple );
else if( strcmp( name, "specR" ) == 0 )
error = Material_setColorComponent( self, "specR", valtuple );
else if( strcmp( name, "specG" ) == 0 )
error = Material_setColorComponent( self, "specG", valtuple );
else if( strcmp( name, "specB" ) == 0 )
error = Material_setColorComponent( self, "specB", valtuple );
else if( strcmp( name, "amb" ) == 0 )
error = Material_setAmb( self, valtuple );
else if( strcmp( name, "emit" ) == 0 )
error = Material_setEmit( self, valtuple );
else if( strcmp( name, "alpha" ) == 0 )
error = Material_setAlpha( self, valtuple );
else if( strcmp( name, "ref" ) == 0 )
error = Material_setRef( self, valtuple );
else if( strcmp( name, "spec" ) == 0 )
error = Material_setSpec( self, valtuple );
else if( strcmp( name, "specTransp" ) == 0 )
error = Material_setSpecTransp( self, valtuple );
else if( strcmp( name, "add" ) == 0 )
error = Material_setAdd( self, valtuple );
else if( strcmp( name, "zOffset" ) == 0 )
error = Material_setZOffset( self, valtuple );
else if( strcmp( name, "haloSize" ) == 0 )
error = Material_setHaloSize( self, valtuple );
else if( strcmp( name, "haloSeed" ) == 0 )
error = Material_setHaloSeed( self, valtuple );
else if( strcmp( name, "flareSize" ) == 0 )
error = Material_setFlareSize( self, valtuple );
else if( strcmp( name, "flareBoost" ) == 0 )
error = Material_setFlareBoost( self, valtuple );
else if( strcmp( name, "flareSeed" ) == 0 )
error = Material_setFlareSeed( self, valtuple );
else if( strcmp( name, "subSize" ) == 0 )
error = Material_setSubSize( self, valtuple );
else if( strcmp( name, "hard" ) == 0 )
error = Material_setHardness( self, valtuple );
else if( strcmp( name, "nFlares" ) == 0 )
error = Material_setNFlares( self, valtuple );
else if( strcmp( name, "nStars" ) == 0 )
error = Material_setNStars( self, valtuple );
else if( strcmp( name, "nLines" ) == 0 )
error = Material_setNLines( self, valtuple );
else if( strcmp( name, "nRings" ) == 0 )
error = Material_setNRings( self, valtuple );
else if( strcmp( name, "rayMirr" ) == 0 )
error = Material_setRayMirr( self, valtuple );
else if( strcmp( name, "rayMirrDepth" ) == 0 )
error = Material_setMirrDepth( self, valtuple );
else if( strcmp( name, "fresnelDepth" ) == 0 )
error = Material_setFresnelMirr( self, valtuple );
else if( strcmp( name, "fresnelDepthFac" ) == 0 )
error = Material_setFresnelMirrFac( self, valtuple );
else if( strcmp( name, "IOR" ) == 0 )
error = Material_setIOR( self, valtuple );
else if( strcmp( name, "transDepth" ) == 0 )
error = Material_setTransDepth( self, valtuple );
else if( strcmp( name, "fresnelTrans" ) == 0 )
error = Material_setFresnelTrans( self, valtuple );
else if( strcmp( name, "fresnelTransFac" ) == 0 )
error = Material_setFresnelTransFac( self, valtuple );
else { /* Error */
Py_DECREF( valtuple );
return ( EXPP_ReturnIntError( PyExc_AttributeError, name ) );
}
/* valtuple won't be returned to the caller, so we need to DECREF it */
Py_DECREF( valtuple );
if( error != Py_None )
return -1;
/* Py_None was incref'ed by the called Material_set* function. We probably
* don't need to decref Py_None (!), but since Python/C API manual tells us
* to treat it like any other PyObject regarding ref counting ... */
Py_DECREF( Py_None );
return 0; /* normal exit */
}
/*****************************************************************************/
/* Function: Material_repr */
/* Description: This is a callback function for the BPy_Material type. It */
/* builds a meaninful string to represent material objects. */
/*****************************************************************************/
static PyObject *Material_repr( BPy_Material * self )
{
return PyString_FromFormat( "[Material \"%s\"]",
self->material->id.name + 2 );
}
/*****************************************************************************/
/* These functions are used in NMesh.c and Object.c */
/*****************************************************************************/
PyObject *EXPP_PyList_fromMaterialList( Material ** matlist, int len, int all )
{
PyObject *list;
int i;
list = PyList_New( 0 );
if( !matlist )
return list;
for( i = 0; i < len; i++ ) {
Material *mat = matlist[i];
PyObject *ob;
if( mat ) {
ob = Material_CreatePyObject( mat );
PyList_Append( list, ob );
Py_DECREF( ob ); /* because Append increfs */
} else if( all ) { /* return NULL mats (empty slots) as Py_None */
PyList_Append( list, Py_None );
}
}
return list;
}
Material **EXPP_newMaterialList_fromPyList( PyObject * list )
{
int i, len;
BPy_Material *pymat = 0;
Material *mat;
Material **matlist;
len = PySequence_Length( list );
if( len > 16 )
len = 16;
else if( len <= 0 )
return NULL;
matlist = EXPP_newMaterialList( len );
for( i = 0; i < len; i++ ) {
pymat = ( BPy_Material * ) PySequence_GetItem( list, i );
if( Material_CheckPyObject( ( PyObject * ) pymat ) ) {
mat = pymat->material;
matlist[i] = mat;
} else if( ( PyObject * ) pymat == Py_None ) {
matlist[i] = NULL;
} else { /* error; illegal type in material list */
Py_DECREF( pymat );
MEM_freeN( matlist );
return NULL;
}
Py_DECREF( pymat );
}
return matlist;
}
Material **EXPP_newMaterialList( int len )
{
Material **matlist =
( Material ** ) MEM_mallocN( len * sizeof( Material * ),
"MaterialList" );
return matlist;
}
int EXPP_releaseMaterialList( Material ** matlist, int len )
{
int i;
Material *mat;
if( ( len < 0 ) || ( len > MAXMAT ) ) {
printf( "illegal matindex!\n" );
return 0;
}
for( i = 0; i < len; i++ ) {
mat = matlist[i];
if( mat ) {
if( ( ( ID * ) mat )->us > 0 )
( ( ID * ) mat )->us--;
else
printf( "FATAL: material usage=0: %s",
( ( ID * ) mat )->name );
}
}
MEM_freeN( matlist );
return 1;
}
/** expands pointer array of length 'oldsize' to length 'newsize'.
* A pointer to the (void *) array must be passed as first argument
* The array pointer content can be NULL, in this case a new array of length
* 'newsize' is created.
*/
static int expandPtrArray( void **p, int oldsize, int newsize )
{
void *newarray;
if( newsize < oldsize ) {
return 0;
}
newarray = MEM_callocN( sizeof( void * ) * newsize, "PtrArray" );
if( *p ) {
memcpy( newarray, *p, sizeof( void * ) * oldsize );
MEM_freeN( *p );
}
*p = newarray;
return 1;
}
int EXPP_synchronizeMaterialLists( Object * object )
{
Material ***p_dataMaterials = give_matarar( object );
short *nmaterials = give_totcolp( object );
int result = 0;
if( object->totcol > *nmaterials ) {
/* More object mats than data mats */
result = expandPtrArray( ( void * ) p_dataMaterials,
*nmaterials, object->totcol );
*nmaterials = object->totcol;
} else {
if( object->totcol < *nmaterials ) {
/* More data mats than object mats */
result = expandPtrArray( ( void * ) &object->mat,
object->totcol, *nmaterials );
object->totcol = *nmaterials;
}
} /* else no synchronization needed, they are of equal length */
return result; /* 1 if changed, 0 otherwise */
}
void EXPP_incr_mats_us( Material ** matlist, int len )
{
int i;
Material *mat;
if( len <= 0 )
return;
for( i = 0; i < len; i++ ) {
mat = matlist[i];
if( mat )
mat->id.us++;
}
return;
}
View Git Blame Copy Permalink