From 5e7f9dfa084d978bbcb96dad7ac2bae80789714e Mon Sep 17 00:00:00 2001 From: Willian Padovani Germano Date: Sun, 23 Nov 2003 17:46:06 +0000 Subject: 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. --- source/blender/python/api2_2x/Blender.c | 1 + source/blender/python/api2_2x/Image.c | 9 + source/blender/python/api2_2x/Image.h | 3 +- source/blender/python/api2_2x/MTex.c | 255 +++++ source/blender/python/api2_2x/MTex.h | 65 ++ source/blender/python/api2_2x/Material.c | 103 +- source/blender/python/api2_2x/Texture.c | 1513 ++++++++++++++++++++++++++ source/blender/python/api2_2x/Texture.h | 67 ++ source/blender/python/api2_2x/Types.c | 4 +- source/blender/python/api2_2x/Types.h | 4 +- source/blender/python/api2_2x/doc/Blender.py | 1 + source/blender/python/api2_2x/gen_utils.c | 69 +- source/blender/python/api2_2x/gen_utils.h | 19 +- source/blender/python/api2_2x/modules.h | 3 + 14 files changed, 2109 insertions(+), 7 deletions(-) create mode 100644 source/blender/python/api2_2x/MTex.c create mode 100644 source/blender/python/api2_2x/MTex.h create mode 100644 source/blender/python/api2_2x/Texture.c create mode 100644 source/blender/python/api2_2x/Texture.h (limited to 'source/blender/python/api2_2x') diff --git a/source/blender/python/api2_2x/Blender.c b/source/blender/python/api2_2x/Blender.c index a6d347aa9f1..9ece702af8d 100644 --- a/source/blender/python/api2_2x/Blender.c +++ b/source/blender/python/api2_2x/Blender.c @@ -229,4 +229,5 @@ void M_Blender_Init (void) PyDict_SetItemString (dict, "Effect", Effect_Init()); PyDict_SetItemString (dict, "Text", Text_Init()); PyDict_SetItemString (dict, "World", World_Init()); + PyDict_SetItemString (dict, "Texture", Texture_Init()); } diff --git a/source/blender/python/api2_2x/Image.c b/source/blender/python/api2_2x/Image.c index 0a99c781e4d..82e23c8931a 100644 --- a/source/blender/python/api2_2x/Image.c +++ b/source/blender/python/api2_2x/Image.c @@ -337,6 +337,15 @@ int Image_CheckPyObject (PyObject *pyobj) return (pyobj->ob_type == &Image_Type); } +/*****************************************************************************/ +/* Function: Image_FromPyObject */ +/* Description: Returns the Blender Image associated with this object */ +/*****************************************************************************/ +Image *Image_FromPyObject (PyObject *pyobj) +{ + return ((BPy_Image *)pyobj)->image; +} + /*****************************************************************************/ /* Python BPy_Image methods: */ /*****************************************************************************/ diff --git a/source/blender/python/api2_2x/Image.h b/source/blender/python/api2_2x/Image.h index 4a62d22bf34..e758e924f53 100644 --- a/source/blender/python/api2_2x/Image.h +++ b/source/blender/python/api2_2x/Image.h @@ -24,7 +24,7 @@ * * This is a new part of Blender. * - * Contributor(s): Willian P. Germano + * Contributor(s): Willian P. Germano, Alex Mole * * ***** END GPL/BL DUAL LICENSE BLOCK ***** */ @@ -55,5 +55,6 @@ extern PyTypeObject Image_Type; /* The Image PyType Object */ PyObject *Image_Init (void); PyObject *Image_CreatePyObject (Image *image); int Image_CheckPyObject (PyObject *pyobj); +Image *Image_FromPyObject (PyObject *pyobj); #endif /* EXPP_IMAGE_H */ diff --git a/source/blender/python/api2_2x/MTex.c b/source/blender/python/api2_2x/MTex.c new file mode 100644 index 00000000000..3740e30cc8f --- /dev/null +++ b/source/blender/python/api2_2x/MTex.c @@ -0,0 +1,255 @@ +/* + * + * ***** 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 "constant.h" +#include "gen_utils.h" +#include "modules.h" + + +/*****************************************************************************/ +/* Python BPy_MTex methods declarations: */ +/*****************************************************************************/ +static PyObject *MTex_setTex(BPy_MTex *self, PyObject *args); + +/*****************************************************************************/ +/* Python method structure definition for Blender.Texture.MTex module: */ +/*****************************************************************************/ +struct PyMethodDef M_MTex_methods[] = { + {NULL, NULL, 0, NULL} +}; + +/*****************************************************************************/ +/* Python BPy_MTex methods table: */ +/*****************************************************************************/ +static PyMethodDef BPy_MTex_methods[] = { + /* name, method, flags, doc */ + {"setTex", (PyCFunction)MTex_setTex, METH_VARARGS, + "(i) - Set MTex Texture"}, + {0} +}; + +/*****************************************************************************/ +/* Python MTex_Type callback function prototypes: */ +/*****************************************************************************/ +static void MTex_dealloc (BPy_MTex *self); +static int MTex_setAttr (BPy_MTex *self, char *name, PyObject *v); +static int MTex_compare (BPy_MTex *a, BPy_MTex *b); +static PyObject *MTex_getAttr (BPy_MTex *self, char *name); +static PyObject *MTex_repr (BPy_MTex *self); + + +/*****************************************************************************/ +/* Python MTex_Type structure definition: */ +/*****************************************************************************/ +PyTypeObject MTex_Type = +{ + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + "Blender MTex", /* tp_name */ + sizeof (BPy_MTex), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + (destructor)MTex_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + (getattrfunc)MTex_getAttr, /* tp_getattr */ + (setattrfunc)MTex_setAttr, /* tp_setattr */ + (cmpfunc)MTex_compare, /* tp_compare */ + (reprfunc)MTex_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, + 0, /* tp_methods */ + 0, /* tp_members */ +}; + + +PyObject *MTex_Init (void) +{ + PyObject *submodule; + + MTex_Type.ob_type = &PyType_Type; + + submodule = Py_InitModule("Blender.Texture.MTex", M_MTex_methods); + + return submodule; +} + +PyObject *MTex_CreatePyObject (MTex *mtex) +{ + BPy_MTex *pymtex; + + pymtex = (BPy_MTex *) PyObject_NEW (BPy_MTex, &MTex_Type); + if (!pymtex) + return EXPP_ReturnPyObjError (PyExc_MemoryError, + "couldn't create BPy_MTex PyObject"); + + pymtex->mtex = mtex; + return (PyObject *) pymtex; +} + +MTex *MTex_FromPyObject (PyObject *pyobj) +{ + return ((BPy_MTex *)pyobj)->mtex; +} + + +int MTex_CheckPyObject (PyObject *pyobj) +{ + return (pyobj->ob_type == &MTex_Type); +} + + +/*****************************************************************************/ +/* Python BPy_MTex methods: */ +/*****************************************************************************/ + +static PyObject *MTex_setTex(BPy_MTex *self, PyObject *args) +{ + BPy_Texture *pytex = NULL; + if (!PyArg_ParseTuple(args, "O!", &Texture_Type, &pytex)) + return EXPP_ReturnPyObjError (PyExc_TypeError, + "expected Texture argument"); + + if (self->mtex->tex) + self->mtex->tex->id.us--; + + self->mtex->tex = Texture_FromPyObject((PyObject*)pytex); + + Py_INCREF(Py_None); + return Py_None; +} + +static void MTex_dealloc (BPy_MTex *self) +{ + PyObject_DEL (self); +} + +static PyObject *MTex_getAttr (BPy_MTex *self, char *name) +{ + if (STREQ(name, "tex")) + { + if (self->mtex->tex) + return Texture_CreatePyObject (self->mtex->tex); + else + { + Py_INCREF (Py_None); + return Py_None; + } + } + else if (STREQ(name, "texco")) + return PyInt_FromLong(self->mtex->texco); + else if (STREQ(name, "mapto")) + return PyInt_FromLong(self->mtex->mapto); + + else if (STREQ(name, "__members__")) + return Py_BuildValue("[s,s,s]", "tex", "texco", "mapto"); + + /* not an attribute, search the methods table */ + return Py_FindMethod(BPy_MTex_methods, (PyObject *)self, name); +} + +static int MTex_setAttr (BPy_MTex *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, + "MTex_setAttr: couldn't create PyTuple"); + + if (STREQ(name, "tex")) + error = MTex_setTex(self, valtuple); + else if (STREQ(name, "texco")) + { + if (PyInt_Check(value)) + { + int texco = PyInt_AsLong(value); + /* TODO: sanity-check this input! */ + self->mtex->texco = texco; + Py_INCREF (Py_None); /* because we decref it below */ + error = Py_None; + } + } + else if (STREQ(name, "mapto")) + { + if (PyInt_Check(value)) + { + int mapto = PyInt_AsLong(value); + /* TODO: sanity-check this input! */ + self->mtex->mapto = mapto; + Py_INCREF (Py_None); /* because we decref it below */ + error = Py_None; + } + } + + 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 MTex_compare (BPy_MTex *a, BPy_MTex *b) +{ + return (a->mtex == b->mtex) ? 0 : -1; +} + +static PyObject *MTex_repr (BPy_MTex *self) +{ + return PyString_FromFormat("[MTex]"); +} + diff --git a/source/blender/python/api2_2x/MTex.h b/source/blender/python/api2_2x/MTex.h new file mode 100644 index 00000000000..0363f16c4da --- /dev/null +++ b/source/blender/python/api2_2x/MTex.h @@ -0,0 +1,65 @@ +/* + * + * ***** 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 ***** +*/ + +#ifndef EXPP_MTEX_H +#define EXPP_MTEX_H + +#include + +#include + + +/*****************************************************************************/ +/* Python BPy_MTex structure definition */ +/*****************************************************************************/ + +typedef struct { + PyObject_HEAD + MTex *mtex; +} BPy_MTex; + +extern PyTypeObject MTex_Type; + +#define BPy_MTex_Check(v) ((v)->ob_type == &MTex_Type) + + +/*****************************************************************************/ +/* Module Blender.Texture.MTex - public functions */ +/*****************************************************************************/ + +PyObject *MTex_Init (void); +PyObject* MTex_CreatePyObject (struct MTex *obj); +int MTex_CheckPyObject (PyObject *py_obj); +MTex* MTex_FromPyObject (PyObject *py_obj); + + +#endif /* EXPP_MTEX_H */ + diff --git a/source/blender/python/api2_2x/Material.c b/source/blender/python/api2_2x/Material.c index 2d2de751aa0..abf2c349edc 100644 --- a/source/blender/python/api2_2x/Material.c +++ b/source/blender/python/api2_2x/Material.c @@ -24,7 +24,7 @@ * * This is a new part of Blender. * - * Contributor(s): Willian P. Germano, Michel Selten + * Contributor(s): Willian P. Germano, Michel Selten, Alex Mole * * ***** END GPL/BL DUAL LICENSE BLOCK ***** */ @@ -41,6 +41,9 @@ #include "bpy_types.h" #include "modules.h" +#include "MTex.h" +#include "Texture.h" + #include "Material.h" /*****************************************************************************/ @@ -345,6 +348,7 @@ 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_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); @@ -373,6 +377,8 @@ 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); +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); @@ -435,6 +441,8 @@ static PyMethodDef BPy_Material_methods[] = { "() - Return Material's number of lines in halo"}, {"getNRings", (PyCFunction)Material_getNRings, METH_NOARGS, "() - Return Material's number of rings in halo"}, + {"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, @@ -491,6 +499,10 @@ static PyMethodDef BPy_Material_methods[] = { "(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]"}, + {"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"}, {0} }; @@ -878,6 +890,36 @@ static PyObject *Material_getNRings(BPy_Material *self) "couldn't get Material.nRings attribute"); } +static PyObject *Material_getTextures(BPy_Material *self) +{ + int i; + struct MTex *mtex; + PyObject *t[8]; + PyObject *tuple; + + /* build a texture list */ + for (i=0; i<8; ++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; +} + static PyObject *Material_setIpo(BPy_Material *self, PyObject *args) { PyObject *pyipo = 0; @@ -1352,6 +1394,65 @@ static PyObject *Material_setNRings(BPy_Material *self, PyObject *args) 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,7] and Texture"); + if ((texnum<0) || (texnum>=8)) + return EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int in [0,7] 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,7]"); + if ((texnum<0) || (texnum>=8)) + return EXPP_ReturnPyObjError (PyExc_TypeError, + "expected int in [0,7]"); + + 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; +} + /*****************************************************************************/ /* Function: Material_getAttr */ /* Description: This is a callback function for the BPy_Material type. It is */ 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 +#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_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 (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); +} + diff --git a/source/blender/python/api2_2x/Texture.h b/source/blender/python/api2_2x/Texture.h new file mode 100644 index 00000000000..9afa837a809 --- /dev/null +++ b/source/blender/python/api2_2x/Texture.h @@ -0,0 +1,67 @@ +/* + * + * ***** 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 ***** +*/ + +/* based on Image.h */ + +#ifndef EXPP_TEXTURE_H +#define EXPP_TEXTURE_H + +#include +#include +#include + + +/*****************************************************************************/ +/* Python BPy_Texture structure definition */ +/*****************************************************************************/ + +typedef struct { + PyObject_HEAD + Tex *texture; +} BPy_Texture; + +extern PyTypeObject Texture_Type; + +#define BPy_Texture_Check(v) ((v)->ob_type == &Texture_Type) + + +/*****************************************************************************/ +/* Module Blender.Texture - public functions */ +/*****************************************************************************/ + +PyObject * Texture_Init(void); +PyObject * Texture_CreatePyObject(struct Tex *tex); +int Texture_CheckPyObject(PyObject *pyobj); +Tex * Texture_FromPyObject (PyObject *pyobj); + + +#endif /* EXPP_TEXTURE_H */ + diff --git a/source/blender/python/api2_2x/Types.c b/source/blender/python/api2_2x/Types.c index 843a5ca79e4..5dbdc8efcfb 100644 --- a/source/blender/python/api2_2x/Types.c +++ b/source/blender/python/api2_2x/Types.c @@ -24,7 +24,7 @@ * * This is a new part of Blender. * - * Contributor(s): Willian P. Germano + * Contributor(s): Willian P. Germano, Alex Mole * * ***** END GPL/BL DUAL LICENSE BLOCK ***** */ @@ -53,6 +53,8 @@ PyObject *Types_Init (void) /* Another one that needs to be here: */ Text_Type.ob_type = &PyType_Type; + Texture_Type.ob_type = &PyType_Type; + submodule = Py_InitModule3 ("Blender.Types", Null_methods, M_Types_doc); dict = PyModule_GetDict(submodule); diff --git a/source/blender/python/api2_2x/Types.h b/source/blender/python/api2_2x/Types.h index 92ca131b8e0..65923ccfd1a 100644 --- a/source/blender/python/api2_2x/Types.h +++ b/source/blender/python/api2_2x/Types.h @@ -24,7 +24,7 @@ * * This is a new part of Blender. * - * Contributor(s): Willian P. Germano + * Contributor(s): Willian P. Germano, Alex Mole * * ***** END GPL/BL DUAL LICENSE BLOCK ***** */ @@ -36,6 +36,8 @@ extern PyTypeObject Button_Type, Material_Type; +extern PyTypeObject Texture_Type; + extern PyTypeObject Object_Type; extern PyTypeObject Scene_Type; extern PyTypeObject NMesh_Type, NMFace_Type, NMVert_Type, NMCol_Type; diff --git a/source/blender/python/api2_2x/doc/Blender.py b/source/blender/python/api2_2x/doc/Blender.py index a5698123920..035d1719dcf 100644 --- a/source/blender/python/api2_2x/doc/Blender.py +++ b/source/blender/python/api2_2x/doc/Blender.py @@ -24,6 +24,7 @@ The Blender Python API Reference - L{Object} - L{NMesh} - L{Material} + - L{Texture} - L{Armature} - L{Camera} - L{Lamp} diff --git a/source/blender/python/api2_2x/gen_utils.c b/source/blender/python/api2_2x/gen_utils.c index 916616fcf9e..fdf624935ab 100644 --- a/source/blender/python/api2_2x/gen_utils.c +++ b/source/blender/python/api2_2x/gen_utils.c @@ -57,7 +57,7 @@ float EXPP_ClampFloat (float value, float min, float max) /* Description: This function returns true if both given strings are equal, */ /* otherwise it returns false. */ /*****************************************************************************/ -int StringEqual (char * string1, char * string2) +int StringEqual (const char * string1, const char * string2) { return (strcmp(string1, string2)==0); } @@ -188,3 +188,70 @@ PyObject *EXPP_tuple_repr(PyObject *self, int size) return repr; } + + + +/****************************************************************************/ +/* Description: searches through a map for a pair with a given name. If the */ +/* pair is present, its ival is stored in *ival and nonzero is */ +/* returned. If the pair is absent, zero is returned. */ +/****************************************************************************/ +int EXPP_map_getIntVal (const EXPP_map_pair *map, const char *sval, int *ival) +{ + while (map->sval) + { + if (StringEqual(sval, map->sval)) + { + *ival = map->ival; + return 1; + } + ++map; + } + return 0; +} + +/****************************************************************************/ +/* Description: searches through a map for a pair with a given name. If the */ +/* pair is present, its ival is stored in *ival and nonzero is */ +/* returned. If the pair is absent, zero is returned. */ +/* note: this function is identical to EXPP_map_getIntVal except that the */ +/* output is stored in a short value. */ +/****************************************************************************/ +int EXPP_map_getShortVal (const EXPP_map_pair *map, + const char *sval, short *ival) +{ + while (map->sval) + { + if (StringEqual(sval, map->sval)) + { + *ival = map->ival; + return 1; + } + ++map; + } + return 0; +} + +/****************************************************************************/ +/* Description: searches through a map for a pair with a given ival. If the */ +/* pair is present, a pointer to its name is stored in *sval */ +/* and nonzero is returned. If the pair is absent, zero is */ +/* returned. */ +/****************************************************************************/ +int EXPP_map_getStrVal (const EXPP_map_pair *map, + int ival, const char **sval) +{ + while (map->sval) + { + if (ival == map->ival) + { + *sval = map->sval; + return 1; + } + ++map; + } + return 0; +} + + + diff --git a/source/blender/python/api2_2x/gen_utils.h b/source/blender/python/api2_2x/gen_utils.h index d8546512157..6c487c07489 100644 --- a/source/blender/python/api2_2x/gen_utils.h +++ b/source/blender/python/api2_2x/gen_utils.h @@ -24,7 +24,7 @@ * * This is a new part of Blender. * - * Contributor(s): Michel Selten, Willian P. Germano + * Contributor(s): Michel Selten, Willian P. Germano, Alex Mole * * ***** END GPL/BL DUAL LICENSE BLOCK ***** */ @@ -44,7 +44,7 @@ #include #include -int StringEqual (char * string1, char * string2); +int StringEqual (const char * string1, const char * string2); char * GetIdName (ID *id); ID *GetIdFromList(ListBase *list, char *name); @@ -63,4 +63,19 @@ int EXPP_ReturnIntError (PyObject *type, char *error_msg); int EXPP_check_sequence_consistency (PyObject *seq, PyTypeObject *against); PyObject *EXPP_tuple_repr(PyObject *self, int size); + +/* mapping utilities - see Texture.c for an example of how to use these */ +typedef struct { + const char *sval; + int ival; +} EXPP_map_pair; + +/* maps must end with a pair that has NULL as sval */ +int EXPP_map_getIntVal (const EXPP_map_pair *map, + const char *sval, int *ival); +int EXPP_map_getShortVal (const EXPP_map_pair *map, + const char *sval, short *ival); +int EXPP_map_getStrVal (const EXPP_map_pair *map, + int ival, const char **sval); + #endif /* EXPP_gen_utils_h */ diff --git a/source/blender/python/api2_2x/modules.h b/source/blender/python/api2_2x/modules.h index 2a5e67494d3..899b368cdca 100644 --- a/source/blender/python/api2_2x/modules.h +++ b/source/blender/python/api2_2x/modules.h @@ -102,6 +102,9 @@ void EXPP_incr_mats_us (Material **matlist, int len); PyObject * EXPP_PyList_fromMaterialList(Material **matlist, int len); Material * GetMaterialByName (char * name); +/* Texture */ +PyObject * Texture_Init (void); + /* Camera Data */ PyObject * Camera_Init (void); PyObject * Camera_CreatePyObject (struct Camera *cam); -- cgit v1.2.3