diff options
author | Willian Padovani Germano <wpgermano@gmail.com> | 2003-11-23 20:46:06 +0300 |
---|---|---|
committer | Willian Padovani Germano <wpgermano@gmail.com> | 2003-11-23 20:46:06 +0300 |
commit | 5e7f9dfa084d978bbcb96dad7ac2bae80789714e (patch) | |
tree | 65767c41ef26feb0a7724ad3b4f05daaa69e253e /source/blender/python/api2_2x/Texture.c | |
parent | 511b098c81913a8ce437ebed6c7f211dd9563f1b (diff) |
BPython:
-- New module: Blender.Texture, by new developer Alex Mole.
Most of it is done: guess only Ipo, envmap, colorband and plugin were not implemented yet.
Diffstat (limited to 'source/blender/python/api2_2x/Texture.c')
-rw-r--r-- | source/blender/python/api2_2x/Texture.c | 1513 |
1 files changed, 1513 insertions, 0 deletions
diff --git a/source/blender/python/api2_2x/Texture.c b/source/blender/python/api2_2x/Texture.c new file mode 100644 index 00000000000..a6d7550af7a --- /dev/null +++ b/source/blender/python/api2_2x/Texture.c @@ -0,0 +1,1513 @@ +/* + * + * ***** 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 <BKE_main.h> +#include <BKE_global.h> +#include <BKE_object.h> +#include <BKE_library.h> +#include <BLI_blenlib.h> +#include <BKE_texture.h> +#include <BKE_utildefines.h> + +#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_default_map, /* magic */ + tex_stype_marble_map, + 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 (extend<EXPP_TEX_EXTEND_MIN || extend>EXPP_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 (type<EXPP_TEX_TYPE_MIN || type>EXPP_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); +} + |