/* * * ***** 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): Alex Mole * * ***** END GPL/BL DUAL LICENSE BLOCK ***** */ #include #include #include #include #include #include #include #include "MTex.h" #include "Texture.h" #include "Image.h" #include "constant.h" #include "gen_utils.h" #include "modules.h" /*****************************************************************************/ /* Blender.Texture constants */ /*****************************************************************************/ #define EXPP_TEX_TYPE_NONE 0 #define EXPP_TEX_TYPE_CLOUDS TEX_CLOUDS #define EXPP_TEX_TYPE_WOOD TEX_WOOD #define EXPP_TEX_TYPE_MARBLE TEX_MARBLE #define EXPP_TEX_TYPE_MAGIC TEX_MAGIC #define EXPP_TEX_TYPE_BLEND TEX_BLEND #define EXPP_TEX_TYPE_STUCCI TEX_STUCCI #define EXPP_TEX_TYPE_NOISE TEX_NOISE #define EXPP_TEX_TYPE_IMAGE TEX_IMAGE #define EXPP_TEX_TYPE_PLUGIN TEX_PLUGIN #define EXPP_TEX_TYPE_ENVMAP TEX_ENVMAP #define EXPP_TEX_TYPE_MIN EXPP_TEX_TYPE_NONE #define EXPP_TEX_TYPE_MAX EXPP_TEX_TYPE_ENVMAP /* i can't find these defined anywhere- they're just taken from looking at */ /* the button creation code in source/blender/src/buttons_shading.c */ #define EXPP_TEX_STYPE_CLD_DEFAULT 0 #define EXPP_TEX_STYPE_CLD_COLOR 1 #define EXPP_TEX_STYPE_WOD_BANDS 0 #define EXPP_TEX_STYPE_WOD_RINGS 1 #define EXPP_TEX_STYPE_WOD_BANDNOISE 2 #define EXPP_TEX_STYPE_WOD_RINGNOISE 3 #define EXPP_TEX_STYPE_MAG_DEFAULT 0 #define EXPP_TEX_STYPE_MBL_SOFT 0 #define EXPP_TEX_STYPE_MBL_SHARP 1 #define EXPP_TEX_STYPE_MBL_SHARPER 2 #define EXPP_TEX_STYPE_BLN_LIN 0 #define EXPP_TEX_STYPE_BLN_QUAD 1 #define EXPP_TEX_STYPE_BLN_EASE 2 #define EXPP_TEX_STYPE_BLN_DIAG 3 #define EXPP_TEX_STYPE_BLN_SPHERE 4 #define EXPP_TEX_STYPE_BLN_HALO 5 #define EXPP_TEX_STYPE_STC_PLASTIC 0 #define EXPP_TEX_STYPE_STC_WALLIN 1 #define EXPP_TEX_STYPE_STC_WALLOUT 2 #define EXPP_TEX_STYPE_NSE_DEFAULT 0 #define EXPP_TEX_STYPE_IMG_DEFAULT 0 #define EXPP_TEX_STYPE_PLG_DEFAULT 0 #define EXPP_TEX_STYPE_ENV_STATIC 0 #define EXPP_TEX_STYPE_ENV_ANIM 1 #define EXPP_TEX_STYPE_ENV_LOAD 2 #define EXPP_TEX_FLAG_COLORBAND TEX_COLORBAND #define EXPP_TEX_FLAG_FLIPBLEND TEX_FLIPBLEND #define EXPP_TEX_FLAG_NEGALPHA TEX_NEGALPHA #define EXPP_TEX_IMAGEFLAG_INTERPOL TEX_INTERPOL #define EXPP_TEX_IMAGEFLAG_USEALPHA TEX_USEALPHA #define EXPP_TEX_IMAGEFLAG_MIPMAP TEX_MIPMAP #define EXPP_TEX_IMAGEFLAG_FIELDS TEX_FIELDS #define EXPP_TEX_IMAGEFLAG_ROT90 TEX_IMAROT #define EXPP_TEX_IMAGEFLAG_CALCALPHA TEX_CALCALPHA #define EXPP_TEX_IMAGEFLAG_CYCLIC TEX_ANIMCYCLIC #define EXPP_TEX_IMAGEFLAG_MOVIE TEX_ANIM5 #define EXPP_TEX_IMAGEFLAG_STFIELD TEX_STD_FIELD #define EXPP_TEX_IMAGEFLAG_ANTI TEX_ANTIALI #define EXPP_TEX_EXTEND_EXTEND TEX_EXTEND #define EXPP_TEX_EXTEND_CLIP TEX_CLIP #define EXPP_TEX_EXTEND_REPEAT TEX_REPEAT #define EXPP_TEX_EXTEND_CLIPCUBE TEX_CLIPCUBE #define EXPP_TEX_EXTEND_MIN EXPP_TEX_EXTEND_EXTEND #define EXPP_TEX_EXTEND_MAX EXPP_TEX_EXTEND_CLIPCUBE #define EXPP_TEX_TEXCO_ORCO TEXCO_ORCO #define EXPP_TEX_TEXCO_REFL TEXCO_REFL #define EXPP_TEX_TEXCO_NOR TEXCO_NORM #define EXPP_TEX_TEXCO_GLOB TEXCO_GLOB #define EXPP_TEX_TEXCO_UV TEXCO_UV #define EXPP_TEX_TEXCO_OBJECT TEXCO_OBJECT #define EXPP_TEX_TEXCO_WIN TEXCO_WINDOW #define EXPP_TEX_TEXCO_VIEW TEXCO_VIEW #define EXPP_TEX_TEXCO_STICK TEXCO_STICKY #define EXPP_TEX_MAPTO_COL MAP_COL #define EXPP_TEX_MAPTO_NOR MAP_NORM #define EXPP_TEX_MAPTO_CSP MAP_COLSPEC #define EXPP_TEX_MAPTO_CMIR MAP_COLMIR #define EXPP_TEX_MAPTO_REF MAP_REF #define EXPP_TEX_MAPTO_SPEC MAP_SPEC #define EXPP_TEX_MAPTO_HARD MAP_HAR #define EXPP_TEX_MAPTO_ALPHA MAP_ALPHA #define EXPP_TEX_MAPTO_EMIT MAP_EMIT /****************************************************************************/ /* Texture String->Int maps */ /****************************************************************************/ static const EXPP_map_pair tex_type_map[] = { { "None", EXPP_TEX_TYPE_NONE }, { "Clouds", EXPP_TEX_TYPE_CLOUDS }, { "Wood", EXPP_TEX_TYPE_WOOD }, { "Marble", EXPP_TEX_TYPE_MARBLE }, { "Magic", EXPP_TEX_TYPE_MAGIC }, { "Blend", EXPP_TEX_TYPE_BLEND }, { "Stucci", EXPP_TEX_TYPE_STUCCI }, { "Noise", EXPP_TEX_TYPE_NOISE }, { "Image", EXPP_TEX_TYPE_IMAGE }, { "Plugin", EXPP_TEX_TYPE_PLUGIN }, { "EnvMap", EXPP_TEX_TYPE_ENVMAP }, { NULL, 0 } }; static const EXPP_map_pair tex_flag_map[] = { /* we don't support this yet! */ /* { "ColorBand", EXPP_TEX_FLAG_COLORBAND }, */ { "FlipBlend", EXPP_TEX_FLAG_FLIPBLEND }, { "NegAlpha", EXPP_TEX_FLAG_NEGALPHA }, { NULL, 0 } }; static const EXPP_map_pair tex_imageflag_map[] = { { "InterPol", EXPP_TEX_IMAGEFLAG_INTERPOL }, { "UseAlpha", EXPP_TEX_IMAGEFLAG_USEALPHA }, { "MipMap", EXPP_TEX_IMAGEFLAG_MIPMAP }, { "Fields", EXPP_TEX_IMAGEFLAG_FIELDS }, { "Rot90", EXPP_TEX_IMAGEFLAG_ROT90 }, { "CalcAlpha", EXPP_TEX_IMAGEFLAG_CALCALPHA }, { "Cyclic", EXPP_TEX_IMAGEFLAG_CYCLIC }, { "Movie", EXPP_TEX_IMAGEFLAG_MOVIE }, { "StField", EXPP_TEX_IMAGEFLAG_STFIELD }, { "Anti", EXPP_TEX_IMAGEFLAG_ANTI }, { NULL, 0 } }; static const EXPP_map_pair tex_extend_map[] = { { "Extend", EXPP_TEX_EXTEND_EXTEND }, { "Clip", EXPP_TEX_EXTEND_CLIP }, { "ClipCube", EXPP_TEX_EXTEND_CLIPCUBE }, { "Repeat", EXPP_TEX_EXTEND_REPEAT }, { NULL, 0 } }; /* array of maps for stype */ static const EXPP_map_pair tex_stype_default_map[] = { { "Default", 0 }, { NULL, 0 } }; static const EXPP_map_pair tex_stype_clouds_map[] = { { "Default", 0 }, { "CloudDefault", EXPP_TEX_STYPE_CLD_DEFAULT }, { "CloudColor", EXPP_TEX_STYPE_CLD_COLOR }, { NULL, 0 } }; static const EXPP_map_pair tex_stype_wood_map[] = { { "Default", 0 }, { "WoodBands", EXPP_TEX_STYPE_WOD_BANDS }, { "WoodRings", EXPP_TEX_STYPE_WOD_RINGS }, { "WoodBandNoise", EXPP_TEX_STYPE_WOD_BANDNOISE }, { "WoodRingNoise", EXPP_TEX_STYPE_WOD_RINGNOISE }, { NULL, 0 } }; static const EXPP_map_pair tex_stype_marble_map[] = { { "Default", 0 }, { "MarbleSoft", EXPP_TEX_STYPE_MBL_SOFT }, { "MarbleSharp", EXPP_TEX_STYPE_MBL_SHARP }, { "MarbleSharper", EXPP_TEX_STYPE_MBL_SHARPER }, { NULL , 0 } }; static const EXPP_map_pair tex_stype_blend_map[] = { { "Default", 0 }, { "BlendLin", EXPP_TEX_STYPE_BLN_LIN }, { "BlendQuad", EXPP_TEX_STYPE_BLN_QUAD }, { "BlendEase", EXPP_TEX_STYPE_BLN_EASE }, { "BlendDiag", EXPP_TEX_STYPE_BLN_DIAG }, { "BlendSphere", EXPP_TEX_STYPE_BLN_SPHERE }, { "BlendHalo", EXPP_TEX_STYPE_BLN_HALO }, { NULL , 0 } }; static const EXPP_map_pair tex_stype_stucci_map[] = { { "Default", 0 }, { "StucciPlastic", EXPP_TEX_STYPE_STC_PLASTIC }, { "StucciWallIn", EXPP_TEX_STYPE_STC_WALLIN }, { "StucciWallOut", EXPP_TEX_STYPE_STC_WALLOUT }, { NULL , 0 } }; static const EXPP_map_pair tex_stype_envmap_map[] = { { "Default", 0 }, { "EnvmapStatic", EXPP_TEX_STYPE_ENV_STATIC }, { "EnvmapAnim", EXPP_TEX_STYPE_ENV_ANIM }, { "EnvmapLoad", EXPP_TEX_STYPE_ENV_LOAD }, { NULL , 0 } }; static const EXPP_map_pair *tex_stype_map[] = { tex_stype_default_map, /* none */ tex_stype_clouds_map, tex_stype_wood_map, tex_stype_marble_map, tex_stype_default_map, /* magic */ tex_stype_blend_map, tex_stype_stucci_map, tex_stype_default_map, /* noise */ tex_stype_default_map, /* image */ tex_stype_default_map, /* plugin */ tex_stype_envmap_map }; /*****************************************************************************/ /* Python API function prototypes for the Texture module. */ /*****************************************************************************/ static PyObject *M_Texture_New (PyObject *self, PyObject *args, PyObject *keywords); static PyObject *M_Texture_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.Texture.__doc__ */ /*****************************************************************************/ static char M_Texture_doc[] = "The Blender Texture module\n\ \n\ This module provides access to **Texture** objects in Blender\n"; static char M_Texture_New_doc[] = "Texture.New (name = 'Tex'):\n\ Return a new Texture object with the given type and name."; static char M_Texture_Get_doc[] = "Texture.Get (name = None):\n\ Return the texture with the given 'name', None if not found, or\n\ Return a list with all texture objects in the current scene,\n\ if no argument was given."; /*****************************************************************************/ /* Python method structure definition for Blender.Texture module: */ /*****************************************************************************/ struct PyMethodDef M_Texture_methods[] = { {"New", (PyCFunction) M_Texture_New, METH_VARARGS|METH_KEYWORDS, M_Texture_New_doc}, {"Get", M_Texture_Get, METH_VARARGS, M_Texture_Get_doc}, {NULL, NULL, 0, NULL} }; /*****************************************************************************/ /* Python BPy_Texture methods declarations: */ /*****************************************************************************/ #define GETFUNC(name) static PyObject *Texture_##name(BPy_Texture *self) #define SETFUNC(name) static PyObject *Texture_##name(BPy_Texture *self, \ PyObject *args) GETFUNC (getExtend); GETFUNC (getImage); GETFUNC (getName); GETFUNC (getType); GETFUNC (getSType); SETFUNC (setAnimFrames); SETFUNC (setAnimLength); SETFUNC (setAnimMontage); SETFUNC (setAnimOffset); SETFUNC (setAnimStart); SETFUNC (setBrightness); SETFUNC (setContrast); SETFUNC (setCrop); SETFUNC (setExtend); SETFUNC (setIntExtend); /* special case used for ".extend = ..." */ SETFUNC (setFieldsPerImage); SETFUNC (setFilterSize); SETFUNC (setFlags); SETFUNC (setIntFlags); /* special case used for ".flags = ..." */ SETFUNC (setImage); SETFUNC (setImageFlags); SETFUNC (setIntImageFlags); /* special case used for ".imageFlags = ..." */ SETFUNC (setName); SETFUNC (setNoiseDepth); SETFUNC (setNoiseSize); SETFUNC (setNoiseType); SETFUNC (setRepeat); SETFUNC (setRGBCol); SETFUNC (setSType); SETFUNC (setIntSType); /* special case used for ".stype = ..." */ SETFUNC (setType); SETFUNC (setIntType); /* special case used for ".type = ..." */ SETFUNC (setTurbulence); /*****************************************************************************/ /* Python BPy_Texture methods table: */ /*****************************************************************************/ static PyMethodDef BPy_Texture_methods[] = { /* name, method, flags, doc */ {"getExtend", (PyCFunction)Texture_getExtend, METH_NOARGS, "() - Return Texture extend mode"}, {"getImage", (PyCFunction)Texture_getImage, METH_NOARGS, "() - Return Texture Image"}, {"getName", (PyCFunction)Texture_getName, METH_NOARGS, "() - Return Texture name"}, {"getSType", (PyCFunction)Texture_getSType, METH_NOARGS, "() - Return Texture stype as string"}, {"getType", (PyCFunction)Texture_getType, METH_NOARGS, "() - Return Texture type as string"}, {"setExtend", (PyCFunction)Texture_setExtend, METH_VARARGS, "(s) - Set Texture extend mode"}, {"setFlags", (PyCFunction)Texture_setFlags, METH_VARARGS, "(f1,f2,f3) - Set Texture flags"}, {"setImage", (PyCFunction)Texture_setImage, METH_VARARGS, "(Blender Image) - Set Texture Image"}, {"setImageFlags", (PyCFunction)Texture_setImageFlags, METH_VARARGS, "(s,s,s,s,...) - Set Texture image flags"}, {"setName", (PyCFunction)Texture_setName, METH_VARARGS, "(s) - Set Texture name"}, {"setSType", (PyCFunction)Texture_setSType, METH_VARARGS, "(s) - Set Texture stype"}, {"setType", (PyCFunction)Texture_setType, METH_VARARGS, "(s) - Set Texture type"}, {0} }; /*****************************************************************************/ /* Python Texture_Type callback function prototypes: */ /*****************************************************************************/ static void Texture_dealloc (BPy_Texture *self); static int Texture_setAttr (BPy_Texture *self, char *name, PyObject *v); static int Texture_compare (BPy_Texture *a, BPy_Texture *b); static PyObject *Texture_getAttr (BPy_Texture *self, char *name); static PyObject *Texture_repr (BPy_Texture *self); /*****************************************************************************/ /* Python Texture_Type structure definition: */ /*****************************************************************************/ PyTypeObject Texture_Type = { PyObject_HEAD_INIT(NULL) 0, /* ob_size */ "Blender Texture", /* tp_name */ sizeof (BPy_Texture), /* tp_basicsize */ 0, /* tp_itemsize */ /* methods */ (destructor)Texture_dealloc, /* tp_dealloc */ 0, /* tp_print */ (getattrfunc)Texture_getAttr, /* tp_getattr */ (setattrfunc)Texture_setAttr, /* tp_setattr */ (cmpfunc)Texture_compare, /* tp_compare */ (reprfunc)Texture_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_Texture_methods, /* tp_methods */ 0, /* tp_members */ }; static PyObject *M_Texture_New(PyObject *self, PyObject *args, PyObject *kwords) { char *name_str = "Tex"; static char *kwlist[] = {"name_str", NULL}; PyObject *pytex; /* for Texture object wrapper in Python */ Tex *bltex; /* for actual Tex we create in Blender */ /* Parse the arguments passed in by the Python interpreter */ if (!PyArg_ParseTupleAndKeywords(args, kwords, "|s", kwlist, &name_str)) return EXPP_ReturnPyObjError(PyExc_AttributeError, "expected zero, one or two strings as arguments"); bltex = add_texture(name_str); /* first create the texture in Blender */ if (bltex) /* now create the wrapper obj in Python */ pytex = Texture_CreatePyObject(bltex); else return EXPP_ReturnPyObjError(PyExc_RuntimeError, "couldn't create Texture in Blender"); /* let's return user count to zero, because add_texture() incref'd it */ bltex->id.us = 0; if (pytex == NULL) return EXPP_ReturnPyObjError (PyExc_MemoryError, "couldn't create Tex PyObject"); return pytex; } static PyObject *M_Texture_Get(PyObject *self, PyObject *args) { char * name = NULL; Tex * tex_iter; if (!PyArg_ParseTuple(args, "|s", &name)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected string argument (or nothing)"); tex_iter = G.main->tex.first; if (name) { /* (name) - Search for texture by name */ PyObject *wanted_tex = NULL; while (tex_iter) { if (STREQ(name, tex_iter->id.name+2)) { wanted_tex = Texture_CreatePyObject (tex_iter); break; } tex_iter = tex_iter->id.next; } if (!wanted_tex) { /* Requested texture doesn't exist */ char error_msg[64]; PyOS_snprintf(error_msg, sizeof(error_msg), "Texture \"%s\" not found", name); return EXPP_ReturnPyObjError (PyExc_NameError, error_msg); } return wanted_tex; } else { /* () - return a list of wrappers for all textures in the scene */ int index = 0; PyObject *tex_pylist, *pyobj; tex_pylist = PyList_New (BLI_countlist (&(G.main->tex))); if (!tex_pylist) return PythonReturnErrorObject(PyExc_MemoryError, "couldn't create PyList"); while (tex_iter) { pyobj = Texture_CreatePyObject(tex_iter); if (!pyobj) return PythonReturnErrorObject(PyExc_MemoryError, "couldn't create Texture PyObject"); PyList_SET_ITEM(tex_pylist, index, pyobj); tex_iter = tex_iter->id.next; index++; } return tex_pylist; } } #undef EXPP_ADDCONST #define EXPP_ADDCONST(name) \ constant_insert(d, #name, PyInt_FromLong(EXPP_TEX_TYPE_##name)) static PyObject *M_Texture_TypesDict (void) { PyObject *Types = M_constant_New(); if (Types) { BPy_constant *d = (BPy_constant*) Types; EXPP_ADDCONST (NONE); EXPP_ADDCONST (CLOUDS); EXPP_ADDCONST (WOOD); EXPP_ADDCONST (MARBLE); EXPP_ADDCONST (MAGIC); EXPP_ADDCONST (BLEND); EXPP_ADDCONST (STUCCI); EXPP_ADDCONST (NOISE); EXPP_ADDCONST (IMAGE); EXPP_ADDCONST (PLUGIN); EXPP_ADDCONST (ENVMAP); } return Types; } #undef EXPP_ADDCONST #define EXPP_ADDCONST(name) \ constant_insert(d, #name, PyInt_FromLong(EXPP_TEX_STYPE_##name)) static PyObject *M_Texture_STypesDict (void) { PyObject *STypes = M_constant_New(); if (STypes) { BPy_constant *d = (BPy_constant*) STypes; EXPP_ADDCONST(CLD_DEFAULT); EXPP_ADDCONST(CLD_COLOR); EXPP_ADDCONST(WOD_BANDS); EXPP_ADDCONST(WOD_RINGS); EXPP_ADDCONST(WOD_BANDNOISE); EXPP_ADDCONST(WOD_RINGNOISE); EXPP_ADDCONST(MAG_DEFAULT); EXPP_ADDCONST(MBL_SOFT); EXPP_ADDCONST(MBL_SHARP); EXPP_ADDCONST(MBL_SHARPER); EXPP_ADDCONST(BLN_LIN); EXPP_ADDCONST(BLN_QUAD); EXPP_ADDCONST(BLN_EASE); EXPP_ADDCONST(BLN_DIAG); EXPP_ADDCONST(BLN_SPHERE); EXPP_ADDCONST(BLN_HALO); EXPP_ADDCONST(STC_PLASTIC); EXPP_ADDCONST(STC_WALLIN); EXPP_ADDCONST(STC_WALLOUT); EXPP_ADDCONST(NSE_DEFAULT); EXPP_ADDCONST(IMG_DEFAULT); EXPP_ADDCONST(PLG_DEFAULT); EXPP_ADDCONST(ENV_STATIC); EXPP_ADDCONST(ENV_ANIM); EXPP_ADDCONST(ENV_LOAD); } return STypes; } #undef EXPP_ADDCONST #define EXPP_ADDCONST(name) \ constant_insert(d, #name, PyInt_FromLong(EXPP_TEX_TEXCO_##name)) static PyObject *M_Texture_TexCoDict (void) { PyObject *TexCo = M_constant_New(); if (TexCo) { BPy_constant *d = (BPy_constant*) TexCo; EXPP_ADDCONST(ORCO); EXPP_ADDCONST(REFL); EXPP_ADDCONST(NOR); EXPP_ADDCONST(GLOB); EXPP_ADDCONST(UV); EXPP_ADDCONST(OBJECT); EXPP_ADDCONST(WIN); EXPP_ADDCONST(VIEW); EXPP_ADDCONST(STICK); } return TexCo; } #undef EXPP_ADDCONST #define EXPP_ADDCONST(name) \ constant_insert(d, #name, PyInt_FromLong(EXPP_TEX_MAPTO_##name)) static PyObject *M_Texture_MapToDict (void) { PyObject *MapTo = M_constant_New(); if (MapTo) { BPy_constant *d = (BPy_constant*) MapTo; EXPP_ADDCONST(COL); EXPP_ADDCONST(NOR); EXPP_ADDCONST(CSP); EXPP_ADDCONST(CMIR); EXPP_ADDCONST(REF); EXPP_ADDCONST(SPEC); EXPP_ADDCONST(HARD); EXPP_ADDCONST(ALPHA); EXPP_ADDCONST(EMIT); } return MapTo; } #undef EXPP_ADDCONST #define EXPP_ADDCONST(name) \ constant_insert(d, #name, PyInt_FromLong(EXPP_TEX_FLAG_##name)) static PyObject *M_Texture_FlagsDict (void) { PyObject *Flags = M_constant_New(); if (Flags) { BPy_constant *d = (BPy_constant*) Flags; EXPP_ADDCONST(COLORBAND); EXPP_ADDCONST(FLIPBLEND); EXPP_ADDCONST(NEGALPHA); } return Flags; } #undef EXPP_ADDCONST #define EXPP_ADDCONST(name) \ constant_insert(d, #name, PyInt_FromLong(EXPP_TEX_EXTEND_##name)) static PyObject *M_Texture_ExtendModesDict (void) { PyObject *ExtendModes = M_constant_New(); if (ExtendModes) { BPy_constant *d = (BPy_constant*) ExtendModes; EXPP_ADDCONST(EXTEND); EXPP_ADDCONST(CLIP); EXPP_ADDCONST(CLIPCUBE); EXPP_ADDCONST(REPEAT); } return ExtendModes; } #undef EXPP_ADDCONST #define EXPP_ADDCONST(name) \ constant_insert(d, #name, PyInt_FromLong(EXPP_TEX_IMAGEFLAG_##name)) static PyObject *M_Texture_ImageFlagsDict (void) { PyObject *ImageFlags = M_constant_New(); if (ImageFlags) { BPy_constant *d = (BPy_constant*) ImageFlags; EXPP_ADDCONST(INTERPOL); EXPP_ADDCONST(USEALPHA); EXPP_ADDCONST(MIPMAP); EXPP_ADDCONST(FIELDS); EXPP_ADDCONST(ROT90); EXPP_ADDCONST(CALCALPHA); EXPP_ADDCONST(STFIELD); EXPP_ADDCONST(MOVIE); EXPP_ADDCONST(CYCLIC); } return ImageFlags; } PyObject *Texture_Init (void) { PyObject *submodule; PyObject *dict; /* constants */ PyObject *Types = M_Texture_TypesDict(); PyObject *STypes = M_Texture_STypesDict(); PyObject *TexCo = M_Texture_TexCoDict(); PyObject *MapTo = M_Texture_MapToDict(); PyObject *Flags = M_Texture_FlagsDict(); PyObject *ExtendModes = M_Texture_ExtendModesDict(); PyObject *ImageFlags = M_Texture_ImageFlagsDict(); Texture_Type.ob_type = &PyType_Type; submodule = Py_InitModule3("Blender.Texture", M_Texture_methods, M_Texture_doc); if (Types) PyModule_AddObject(submodule, "Types", Types); if (STypes) PyModule_AddObject(submodule, "STypes", STypes); if (TexCo) PyModule_AddObject(submodule, "TexCo", TexCo); if (MapTo) PyModule_AddObject(submodule, "MapTo", MapTo); if (Flags) PyModule_AddObject(submodule, "Flags", Flags); if (ExtendModes) PyModule_AddObject(submodule, "ExtendModes", ExtendModes); if (ImageFlags) PyModule_AddObject(submodule, "ImageFlags", ImageFlags); /* Add the MTex submodule to this module */ dict = PyModule_GetDict (submodule); PyDict_SetItemString (dict, "MTex", MTex_Init()); return submodule; } PyObject *Texture_CreatePyObject (Tex *tex) { BPy_Texture *pytex; pytex = (BPy_Texture *) PyObject_NEW (BPy_Texture, &Texture_Type); if (!pytex) return EXPP_ReturnPyObjError (PyExc_MemoryError, "couldn't create BPy_Texture PyObject"); pytex->texture = tex; return (PyObject *) pytex; } Tex *Texture_FromPyObject (PyObject *pyobj) { return ((BPy_Texture *)pyobj)->texture; } int Texture_CheckPyObject (PyObject *pyobj) { return (pyobj->ob_type == &Texture_Type); } /*****************************************************************************/ /* Python BPy_Texture methods: */ /*****************************************************************************/ static PyObject *Texture_getExtend(BPy_Texture *self) { PyObject *attr = NULL; const char *extend = NULL; if (EXPP_map_getStrVal (tex_extend_map, self->texture->extend, &extend)) attr = PyString_FromString (extend); if (!attr) return EXPP_ReturnPyObjError (PyExc_RuntimeError, "invalid internal extend mode"); return attr; } static PyObject *Texture_getImage(BPy_Texture *self) { /* we need this to be an IMAGE texture, and we must have an image */ if ((self->texture->type != TEX_IMAGE) || !self->texture->ima) { Py_INCREF (Py_None); return Py_None; } return Image_CreatePyObject (self->texture->ima); } static PyObject *Texture_getName(BPy_Texture *self) { PyObject *attr = PyString_FromString(self->texture->id.name+2); if (!attr) return EXPP_ReturnPyObjError (PyExc_RuntimeError, "couldn't get Texture.name attribute"); return attr; } static PyObject *Texture_getSType(BPy_Texture *self) { PyObject *attr = NULL; const char *stype = NULL; if (EXPP_map_getStrVal (tex_stype_map[self->texture->type], self->texture->stype, &stype)) attr = PyString_FromString (stype); if (!attr) return EXPP_ReturnPyObjError (PyExc_RuntimeError, "invalid texture stype internally"); return attr; } static PyObject *Texture_getType(BPy_Texture *self) { PyObject *attr = NULL; const char *type = NULL; if (EXPP_map_getStrVal (tex_type_map, self->texture->type, &type)) attr = PyString_FromString (type); if (!attr) return EXPP_ReturnPyObjError (PyExc_RuntimeError, "invalid texture type internally"); return attr; } static PyObject *Texture_setAnimFrames(BPy_Texture *self, PyObject *args) { int frames; if (!PyArg_ParseTuple(args, "i", &frames)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected an int"); if (frames < 0) return EXPP_ReturnPyObjError (PyExc_ValueError, "frames cannot be negative"); self->texture->frames = frames; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setAnimLength(BPy_Texture *self, PyObject *args) { int length; if (!PyArg_ParseTuple(args, "i", &length)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected an int"); if (length < 0) return EXPP_ReturnPyObjError (PyExc_ValueError, "length cannot be negative"); self->texture->len = length; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setAnimMontage(BPy_Texture *self, PyObject *args) { int fradur[4][2]; int i, j; if (!PyArg_ParseTuple(args, "((ii)(ii)(ii)(ii))", &fradur[0][0], &fradur[0][1], &fradur[1][0], &fradur[1][1], &fradur[2][0], &fradur[2][1], &fradur[3][0], &fradur[3][1])) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected a tuple of tuples"); for (i=0; i<4; ++i) for (j=0; j<2; ++j) if (fradur[i][j] < 0) return EXPP_ReturnPyObjError (PyExc_ValueError, "values must be greater than zero"); for (i=0; i<4; ++i) for (j=0; j<2; ++j) self->texture->fradur[i][j] = fradur[i][j]; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setAnimOffset(BPy_Texture *self, PyObject *args) { int offset; if (!PyArg_ParseTuple(args, "i", &offset)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected an int"); self->texture->offset = offset; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setAnimStart(BPy_Texture *self, PyObject *args) { int sfra; if (!PyArg_ParseTuple(args, "i", &sfra)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected an int"); if (sfra < 1) return EXPP_ReturnPyObjError (PyExc_ValueError, "start must be greater than zero"); self->texture->sfra = sfra; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setBrightness(BPy_Texture *self, PyObject *args) { float bright; if (!PyArg_ParseTuple(args, "f", &bright)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected a float"); if (bright<0 || bright>2) return EXPP_ReturnPyObjError (PyExc_ValueError, "brightness must be in range [0,2]"); self->texture->bright = bright; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setContrast(BPy_Texture *self, PyObject *args) { float contrast; if (!PyArg_ParseTuple(args, "f", &contrast)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected a float"); if (contrast<0 || contrast>2) return EXPP_ReturnPyObjError (PyExc_ValueError, "contrast must be in range [0,2]"); self->texture->contrast = contrast; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setCrop(BPy_Texture *self, PyObject *args) { float crop[4]; int i; if (!PyArg_ParseTuple(args, "(ffff)", &crop[0], &crop[1], &crop[2], &crop[3])) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected tuple of 4 floats"); for (i=0; i<4; ++i) if (crop[i]<-10 || crop[i]>10) return EXPP_ReturnPyObjError (PyExc_ValueError, "values must be in range [-10,10]"); self->texture->cropxmin = crop[0]; self->texture->cropymin = crop[1]; self->texture->cropxmax = crop[2]; self->texture->cropymax = crop[3]; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setExtend(BPy_Texture *self, PyObject *args) { char *extend = NULL; if (!PyArg_ParseTuple(args, "s", &extend)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected string argument"); if (!EXPP_map_getShortVal (tex_extend_map, extend, &self->texture->extend)) return EXPP_ReturnPyObjError (PyExc_ValueError, "invalid extend mode"); Py_INCREF(Py_None); return Py_None; } static PyObject *Texture_setIntExtend(BPy_Texture *self, PyObject *args) { int extend = 0; if (!PyArg_ParseTuple(args, "i", &extend)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument"); if (extendEXPP_TEX_EXTEND_MAX) return EXPP_ReturnPyObjError (PyExc_ValueError, "invalid extend mode"); self->texture->extend = extend; Py_INCREF(Py_None); return Py_None; } static PyObject *Texture_setFieldsPerImage(BPy_Texture *self, PyObject *args) { int fie_ima; if (!PyArg_ParseTuple(args, "i", &fie_ima)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected an int"); if (fie_ima<1 || fie_ima>200) return EXPP_ReturnPyObjError (PyExc_ValueError, "value must be in range [1,200]"); self->texture->fie_ima = fie_ima; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setFilterSize(BPy_Texture *self, PyObject *args) { float size; if (!PyArg_ParseTuple(args, "f", &size)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected a float"); if (size<0.1 || size>25) return EXPP_ReturnPyObjError (PyExc_ValueError, "filter size must be in range [0.1,25]"); self->texture->filtersize = size; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setFlags(BPy_Texture *self, PyObject *args) { char *sf[3] = { NULL, NULL, NULL }; int i; short flags = 0; short thisflag; if (!PyArg_ParseTuple(args, "|sss", &sf[0], &sf[1], &sf[2])) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected 0-3 string arguments"); for (i=0; i<3; ++i) { if (!sf[i]) break; if (!EXPP_map_getShortVal(tex_flag_map, sf[i], &thisflag)) return EXPP_ReturnPyObjError (PyExc_ValueError, "invalid texture flag name"); flags |= thisflag; } self->texture->flag = flags; Py_INCREF(Py_None); return Py_None; } static PyObject *Texture_setIntFlags(BPy_Texture *self, PyObject *args) { int flags = 0; if (!PyArg_ParseTuple(args, "i", &flags)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument"); self->texture->flag = flags; Py_INCREF(Py_None); return Py_None; } static PyObject *Texture_setImage(BPy_Texture *self, PyObject *args) { PyObject *pyimg; Image *blimg = NULL; if (!PyArg_ParseTuple(args, "O!", &Image_Type, &pyimg)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected an Image"); blimg = Image_FromPyObject (pyimg); if (self->texture->ima) { self->texture->ima->id.us--; } self->texture->ima = blimg; id_us_plus(&blimg->id); Py_INCREF(Py_None); return Py_None; } static PyObject *Texture_setImageFlags(BPy_Texture *self, PyObject *args) { char *sf[9] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }; int i; short flags = 0; short thisflag; if (!PyArg_ParseTuple(args, "|sssssssss", &sf[0], &sf[1], &sf[2], &sf[3], &sf[4], &sf[5], &sf[6], &sf[7], &sf[8])) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected 0-9 string arguments"); for (i=0; i<9; ++i) { if (!sf[i]) break; if (!EXPP_map_getShortVal(tex_imageflag_map, sf[i], &thisflag)) return EXPP_ReturnPyObjError (PyExc_ValueError, "invalid texture image flag name"); flags |= thisflag; } /* MIPMAP and FIELDS can't be used together */ if ((flags & EXPP_TEX_IMAGEFLAG_MIPMAP) && (flags & EXPP_TEX_IMAGEFLAG_FIELDS)) return EXPP_ReturnPyObjError (PyExc_ValueError, "image flags MIPMAP and FIELDS cannot be used together"); self->texture->imaflag = flags; Py_INCREF(Py_None); return Py_None; } static PyObject *Texture_setIntImageFlags(BPy_Texture *self, PyObject *args) { int flags = 0; if (!PyArg_ParseTuple(args, "i", &flags)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument"); /* MIPMAP and FIELDS can't be used together */ if ((flags & EXPP_TEX_IMAGEFLAG_MIPMAP) && (flags & EXPP_TEX_IMAGEFLAG_FIELDS)) return EXPP_ReturnPyObjError (PyExc_ValueError, "image flags MIPMAP and FIELDS cannot be used together"); self->texture->imaflag = flags; Py_INCREF(Py_None); return Py_None; } static PyObject *Texture_setName(BPy_Texture *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->texture->id, buf); Py_INCREF(Py_None); return Py_None; } static PyObject *Texture_setNoiseDepth(BPy_Texture *self, PyObject *args) { int depth; if (!PyArg_ParseTuple(args, "i", &depth)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected an int"); if (depth<0 || depth>6) return EXPP_ReturnPyObjError (PyExc_ValueError, "value must be in range [0,6]"); self->texture->noisedepth = depth; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setNoiseSize(BPy_Texture *self, PyObject *args) { float size; if (!PyArg_ParseTuple(args, "f", &size)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected a float"); if (size<0 || size>2) return EXPP_ReturnPyObjError (PyExc_ValueError, "noise size must be in range [0,2]"); self->texture->noisesize = size; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setNoiseType(BPy_Texture *self, PyObject *args) { char *type; if (!PyArg_ParseTuple(args, "s", &type)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected string argument"); if (STREQ(type, "soft")) self->texture->noisetype = TEX_NOISESOFT; else if (STREQ(type, "hard")) self->texture->noisetype = TEX_NOISEPERL; else return EXPP_ReturnPyObjError (PyExc_ValueError, "noise type must be 'soft' or 'hard'"); Py_INCREF(Py_None); return Py_None; } static PyObject *Texture_setRepeat(BPy_Texture *self, PyObject *args) { int repeat[2]; int i; if (!PyArg_ParseTuple(args, "(ii)", &repeat[0], &repeat[1])) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected tuple of 2 ints"); for (i=0; i<2; ++i) if (repeat[i]<1 || repeat[i]>512) return EXPP_ReturnPyObjError (PyExc_ValueError, "values must be in range [1,512]"); self->texture->xrepeat = repeat[0]; self->texture->yrepeat = repeat[1]; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setRGBCol(BPy_Texture *self, PyObject *args) { float rgb[3]; int i; if (!PyArg_ParseTuple(args, "(fff)", &rgb[0], &rgb[1], &rgb[2])) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected tuple of 3 floats"); for (i=0; i<3; ++i) if (rgb[i]<0 || rgb[i]>2) return EXPP_ReturnPyObjError (PyExc_ValueError, "values must be in range [0,2]"); self->texture->rfac = rgb[0]; self->texture->gfac = rgb[1]; self->texture->bfac = rgb[2]; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setSType(BPy_Texture *self, PyObject *args) { char *stype = NULL; if (!PyArg_ParseTuple(args, "s", &stype)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected string argument"); /* can we really trust texture->type? */ if (!EXPP_map_getShortVal (tex_stype_map[self->texture->type], stype, &self->texture->stype)) return EXPP_ReturnPyObjError (PyExc_ValueError, "invalid texture stype"); Py_INCREF(Py_None); return Py_None; } static PyObject *Texture_setIntSType(BPy_Texture *self, PyObject *args) { int stype = 0; const char *dummy = NULL; if (!PyArg_ParseTuple(args, "i", &stype)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument"); /* use the stype map to find out if this is a valid stype for this type * * note that this will allow CLD_COLOR when type is ENVMAP. there's not * * much that we can do about this though. */ if (!EXPP_map_getStrVal (tex_stype_map[self->texture->type], stype, &dummy)) return EXPP_ReturnPyObjError (PyExc_ValueError, "invalid stype (for this type)"); self->texture->stype = stype; Py_INCREF(Py_None); return Py_None; } static PyObject *Texture_setTurbulence(BPy_Texture *self, PyObject *args) { float turb; if (!PyArg_ParseTuple(args, "f", &turb)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected a float"); if (turb<0 || turb>200) return EXPP_ReturnPyObjError (PyExc_ValueError, "turbulence must be in range [0,200]"); self->texture->turbul = turb; Py_INCREF (Py_None); return Py_None; } static PyObject *Texture_setType(BPy_Texture *self, PyObject *args) { char *type = NULL; if (!PyArg_ParseTuple(args, "s", &type)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected string argument"); if (!EXPP_map_getShortVal (tex_type_map, type, &self->texture->type)) return EXPP_ReturnPyObjError (PyExc_ValueError, "invalid texture type"); Py_INCREF(Py_None); return Py_None; } static PyObject *Texture_setIntType(BPy_Texture *self, PyObject *args) { int type = 0; if (!PyArg_ParseTuple(args, "i", &type)) return EXPP_ReturnPyObjError (PyExc_TypeError, "expected int argument"); if (typeEXPP_TEX_TYPE_MAX) return EXPP_ReturnPyObjError (PyExc_ValueError, "invalid type number"); self->texture->type = type; Py_INCREF(Py_None); return Py_None; } static void Texture_dealloc (BPy_Texture *self) { PyObject_DEL (self); } static PyObject *Texture_getAttr (BPy_Texture *self, char *name) { PyObject *attr = Py_None; Tex *tex = self->texture; if (STREQ(name, "animFrames")) attr = PyInt_FromLong (tex->frames); else if (STREQ(name, "animLength")) attr = PyInt_FromLong (tex->len); else if (STREQ(name, "animMontage")) attr = Py_BuildValue("((i,i),(i,i),(i,i),(i,i))", tex->fradur[0][0], tex->fradur[0][1], tex->fradur[1][0], tex->fradur[1][1], tex->fradur[2][0], tex->fradur[2][1], tex->fradur[3][0], tex->fradur[3][1] ); else if (STREQ(name, "animOffset")) attr = PyInt_FromLong (tex->offset); else if (STREQ(name, "animStart")) attr = PyInt_FromLong (tex->sfra); else if (STREQ(name, "brightness")) attr = PyFloat_FromDouble (tex->bright); else if (STREQ(name, "contrast")) attr = PyFloat_FromDouble (tex->contrast); else if (STREQ(name, "crop")) attr = Py_BuildValue("(f,f,f,f)", tex->cropxmin, tex->cropymin, tex->cropxmax, tex->cropymax); else if (STREQ(name, "extend")) attr = PyInt_FromLong (tex->extend); else if (STREQ(name, "fieldsPerImage")) attr = PyInt_FromLong (tex->fie_ima); else if (STREQ(name, "filterSize")) attr = PyFloat_FromDouble (tex->filtersize); else if (STREQ(name, "flags")) attr = PyInt_FromLong (tex->flag); else if (STREQ(name, "image")) attr = Texture_getImage (self); else if (STREQ(name, "imageFlags")) attr = PyInt_FromLong (tex->imaflag); else if (STREQ(name, "name")) attr = PyString_FromString(tex->id.name+2); else if (STREQ(name, "noiseDepth")) attr = PyInt_FromLong (tex->noisedepth); else if (STREQ(name, "noiseSize")) attr = PyFloat_FromDouble (tex->noisesize); else if (STREQ(name, "noiseType")) { if (tex->noisetype == TEX_NOISESOFT) attr = PyString_FromString ("soft"); else attr = PyString_FromString ("hard"); } else if (STREQ(name, "repeat")) attr = Py_BuildValue ("(i,i)", tex->xrepeat, tex->yrepeat); else if (STREQ(name, "rgbCol")) attr = Py_BuildValue ("(f,f,f)", tex->rfac, tex->gfac, tex->gfac); else if (STREQ(name, "stype")) attr = PyInt_FromLong (tex->stype); else if (STREQ(name, "turbulence")) attr = PyFloat_FromDouble (tex->turbul); else if (STREQ(name, "type")) attr = PyInt_FromLong (tex->type); else if (STREQ(name, "__members__")) attr = Py_BuildValue("[s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s]", "animFrames", "animLength", "animMontage", "animOffset", "animStart", "brightness", "contrast", "crop", "extend", "fieldsPerImage", "filterSize", "flags", "image", "imageFlags", "name", "noiseDepth", "noiseSize", "noiseType", "repeat", "rgbCol", "stype", "turbulence", "type"); 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_Texture_methods, (PyObject *)self, name); } static int Texture_setAttr (BPy_Texture *self, char *name, PyObject *value) { PyObject *valtuple; PyObject *error = NULL; /* Put "value" in a tuple, because we want to pass it to functions * * that only accept PyTuples. */ valtuple = Py_BuildValue("(O)", value); if (!valtuple) return EXPP_ReturnIntError(PyExc_MemoryError, "Texture_setAttr: couldn't create PyTuple"); if (STREQ(name, "animFrames")) error = Texture_setAnimFrames (self, valtuple); else if (STREQ(name, "animLength")) error = Texture_setAnimLength(self, valtuple); else if (STREQ(name, "animMontage")) error = Texture_setAnimMontage(self, valtuple); else if (STREQ(name, "animOffset")) error = Texture_setAnimOffset(self, valtuple); else if (STREQ(name, "animStart")) error = Texture_setAnimStart(self, valtuple); else if (STREQ(name, "brightness")) error = Texture_setBrightness(self, valtuple); else if (STREQ(name, "contrast")) error = Texture_setContrast(self, valtuple); else if (STREQ(name, "crop")) error = Texture_setCrop(self, valtuple); else if (STREQ(name, "extend")) error = Texture_setIntExtend(self, valtuple); else if (STREQ(name, "fieldsPerImage")) error = Texture_setFieldsPerImage(self, valtuple); else if (STREQ(name, "filterSize")) error = Texture_setFilterSize(self, valtuple); else if (STREQ(name, "flags")) error = Texture_setIntFlags(self, valtuple); else if (STREQ(name, "image")) error = Texture_setImage (self, valtuple); else if (STREQ(name, "imageFlags")) error = Texture_setIntImageFlags(self, valtuple); else if (STREQ(name, "name")) error = Texture_setName(self, valtuple); else if (STREQ(name, "noiseDepth")) error = Texture_setNoiseDepth(self, valtuple); else if (STREQ(name, "noiseSize")) error = Texture_setNoiseSize(self, valtuple); else if (STREQ(name, "noiseType")) error = Texture_setNoiseType(self, valtuple); else if (STREQ(name, "repeat")) error = Texture_setRepeat(self, valtuple); else if (STREQ(name, "rgbCol")) error = Texture_setRGBCol(self, valtuple); else if (STREQ(name, "stype")) error = Texture_setIntSType(self, valtuple); else if (STREQ(name, "turbulence")) error = Texture_setTurbulence(self, valtuple); else if (STREQ(name, "type")) error = Texture_setIntType(self, valtuple); else { /* Error */ Py_DECREF(valtuple); return EXPP_ReturnIntError (PyExc_KeyError, "attribute not found"); } Py_DECREF (valtuple); if (error != Py_None) return -1; /* Py_None was INCREF'd by the set*() function, so we need to DECREF it */ Py_DECREF (Py_None); return 0; } static int Texture_compare (BPy_Texture *a, BPy_Texture *b) { return (a->texture == b->texture) ? 0 : -1; } static PyObject *Texture_repr (BPy_Texture *self) { return PyString_FromFormat("[Texture \"%s\"]", self->texture->id.name+2); }