← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

Viewing changes to source/blender/python/api2_2x/Texture.c

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2005-11-06 12:40:03 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20051106124003-3pgs7tcg5rox96xg
Tags: 2.37a-1.1
http://bugs.debian.org/333958
* Non-maintainer upload.
* Split out parts of 01_SConstruct_debian.dpatch again: root_build_dir
  really needs to get adjusted before the clean target runs - closes: #333958,
  see #288882 for reference

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/python/api2_2x/Texture.c
1
 
/* 
2
 
 *
 
1
/*  
 
2
 *  $Id: Texture.c,v 1.11 2005/02/21 22:00:11 ascotan Exp $
3
3
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
4
4
 *
5
5
 * This program is free software; you can redistribute it and/or
24
24
 *
25
25
 * This is a new part of Blender.
26
26
 *
27
 
 * Contributor(s): Alex Mole
 
27
 * Contributor(s): Alex Mole, Nathan Letwory, Joilnen B. Leite
28
28
 *
29
29
 * ***** END GPL/BL DUAL LICENSE BLOCK *****
30
30
*/
40
40
#include "MTex.h"
41
41
#include "Texture.h"
42
42
#include "Image.h"
 
43
#include "Ipo.h"
43
44
#include "constant.h"
44
45
#include "gen_utils.h"
45
 
#include "modules.h"
 
46
 
46
47
 
47
48
 
48
49
/*****************************************************************************/
59
60
#define EXPP_TEX_TYPE_IMAGE                 TEX_IMAGE
60
61
#define EXPP_TEX_TYPE_PLUGIN                TEX_PLUGIN
61
62
#define EXPP_TEX_TYPE_ENVMAP                TEX_ENVMAP
 
63
#define EXPP_TEX_TYPE_MUSGRAVE              TEX_MUSGRAVE
 
64
#define EXPP_TEX_TYPE_VORONOI               TEX_VORONOI
 
65
#define EXPP_TEX_TYPE_DISTNOISE             TEX_DISTNOISE
62
66
 
63
67
#define EXPP_TEX_TYPE_MIN                   EXPP_TEX_TYPE_NONE
64
 
#define EXPP_TEX_TYPE_MAX                   EXPP_TEX_TYPE_ENVMAP
 
68
#define EXPP_TEX_TYPE_MAX                   EXPP_TEX_TYPE_DISTNOISE
65
69
 
66
70
/* i can't find these defined anywhere- they're just taken from looking at   */
67
71
/* the button creation code in source/blender/src/buttons_shading.c          */
90
94
#define EXPP_TEX_STYPE_ENV_STATIC           0
91
95
#define EXPP_TEX_STYPE_ENV_ANIM             1
92
96
#define EXPP_TEX_STYPE_ENV_LOAD             2
 
97
/* musgrave stype */
 
98
#define EXPP_TEX_STYPE_MUS_MFRACTAL         0
 
99
#define EXPP_TEX_STYPE_MUS_RIDGEDMF         1
 
100
#define EXPP_TEX_STYPE_MUS_HYBRIDMF         2
 
101
#define EXPP_TEX_STYPE_MUS_FBM              3
 
102
#define EXPP_TEX_STYPE_MUS_HTERRAIN         4
 
103
/* voronoi stype */
 
104
#define EXPP_TEX_STYPE_VN_INT              0
 
105
#define EXPP_TEX_STYPE_VN_COL1             1
 
106
#define EXPP_TEX_STYPE_VN_COL2             2
 
107
#define EXPP_TEX_STYPE_VN_COL3             3
93
108
 
94
109
#define EXPP_TEX_FLAG_COLORBAND             TEX_COLORBAND
95
110
#define EXPP_TEX_FLAG_FLIPBLEND             TEX_FLIPBLEND
105
120
#define EXPP_TEX_IMAGEFLAG_MOVIE            TEX_ANIM5
106
121
#define EXPP_TEX_IMAGEFLAG_STFIELD          TEX_STD_FIELD
107
122
#define EXPP_TEX_IMAGEFLAG_ANTI             TEX_ANTIALI
 
123
#define EXPP_TEX_IMAGEFLAG_NORMALMAP        TEX_NORMALMAP
108
124
 
109
125
#define EXPP_TEX_EXTEND_EXTEND              TEX_EXTEND
110
126
#define EXPP_TEX_EXTEND_CLIP                TEX_CLIP
133
149
#define EXPP_TEX_MAPTO_HARD                 MAP_HAR
134
150
#define EXPP_TEX_MAPTO_ALPHA                MAP_ALPHA
135
151
#define EXPP_TEX_MAPTO_EMIT                 MAP_EMIT
 
152
#define EXPP_TEX_MAPTO_RAYMIR               MAP_RAYMIRR
 
153
#define EXPP_TEX_MAPTO_DISP                 MAP_DISPLACE
 
154
#define EXPP_TEX_MAPTO_TRANSLU              MAP_TRANSLU
 
155
#define EXPP_TEX_MAPTO_AMB                  MAP_AMB
 
156
 
 
157
#define EXPP_TEX_STYPE_DN_BLENDER          TEX_BLENDER
 
158
#define EXPP_TEX_STYPE_DN_PERLIN           TEX_STDPERLIN
 
159
#define EXPP_TEX_STYPE_DN_IMPROVEPERLIN    TEX_NEWPERLIN
 
160
#define EXPP_TEX_STYPE_DN_VORONOIF1        TEX_VORONOI_F1
 
161
#define EXPP_TEX_STYPE_DN_VORONOIF2        TEX_VORONOI_F2
 
162
#define EXPP_TEX_STYPE_DN_VORONOIF3        TEX_VORONOI_F3
 
163
#define EXPP_TEX_STYPE_DN_VORONOIF4        TEX_VORONOI_F4
 
164
#define EXPP_TEX_STYPE_DN_VORONOIF2F1      TEX_VORONOI_F2F1
 
165
#define EXPP_TEX_STYPE_DN_VORONOICRACKLE   TEX_VORONOI_CRACKLE
 
166
#define EXPP_TEX_STYPE_DN_CELLNOISE        TEX_CELLNOISE
 
167
 
 
168
#define EXPP_TEX_STYPE_VN_TEX_DISTANCE           TEX_DISTANCE
 
169
#define EXPP_TEX_STYPE_VN_TEX_DISTANCE_SQUARED   TEX_DISTANCE_SQUARED
 
170
#define EXPP_TEX_STYPE_VN_TEX_MANHATTAN          TEX_MANHATTAN
 
171
#define EXPP_TEX_STYPE_VN_TEX_CHEBYCHEV          TEX_CHEBYCHEV
 
172
#define EXPP_TEX_STYPE_VN_TEX_MINKOVSKY_HALF     TEX_MINKOVSKY_HALF
 
173
#define EXPP_TEX_STYPE_VN_TEX_MINKOVSKY_FOUR     TEX_MINKOVSKY_FOUR
 
174
#define EXPP_TEX_STYPE_VN_TEX_MINKOVSKY          TEX_MINKOVSKY
136
175
 
137
176
/****************************************************************************/
138
177
/* Texture String->Int maps                                                 */
139
178
/****************************************************************************/
140
179
 
141
180
static const EXPP_map_pair tex_type_map[] = {
142
 
    { "None",   EXPP_TEX_TYPE_NONE },
143
 
    { "Clouds", EXPP_TEX_TYPE_CLOUDS },
144
 
    { "Wood",   EXPP_TEX_TYPE_WOOD },
145
 
    { "Marble", EXPP_TEX_TYPE_MARBLE },
146
 
    { "Magic",  EXPP_TEX_TYPE_MAGIC },
147
 
    { "Blend",  EXPP_TEX_TYPE_BLEND },
148
 
    { "Stucci", EXPP_TEX_TYPE_STUCCI },
149
 
    { "Noise",  EXPP_TEX_TYPE_NOISE },
150
 
    { "Image",  EXPP_TEX_TYPE_IMAGE },
151
 
    { "Plugin", EXPP_TEX_TYPE_PLUGIN },
152
 
    { "EnvMap", EXPP_TEX_TYPE_ENVMAP },
153
 
    { NULL, 0 }
 
181
        {"None", EXPP_TEX_TYPE_NONE},
 
182
        {"Clouds", EXPP_TEX_TYPE_CLOUDS},
 
183
        {"Wood", EXPP_TEX_TYPE_WOOD},
 
184
        {"Marble", EXPP_TEX_TYPE_MARBLE},
 
185
        {"Magic", EXPP_TEX_TYPE_MAGIC},
 
186
        {"Blend", EXPP_TEX_TYPE_BLEND},
 
187
        {"Stucci", EXPP_TEX_TYPE_STUCCI},
 
188
        {"Noise", EXPP_TEX_TYPE_NOISE},
 
189
        {"Image", EXPP_TEX_TYPE_IMAGE},
 
190
        {"Plugin", EXPP_TEX_TYPE_PLUGIN},
 
191
        {"EnvMap", EXPP_TEX_TYPE_ENVMAP},
 
192
        {"Musgrave", EXPP_TEX_TYPE_MUSGRAVE},
 
193
        {"Voronoi", EXPP_TEX_TYPE_VORONOI},
 
194
        {"DistortedNoise", EXPP_TEX_TYPE_DISTNOISE},
 
195
        {NULL, 0}
154
196
};
155
197
 
156
198
static const EXPP_map_pair tex_flag_map[] = {
157
 
    /* we don't support this yet! */
158
 
/*    { "ColorBand",  EXPP_TEX_FLAG_COLORBAND },  */
159
 
    { "FlipBlend",  EXPP_TEX_FLAG_FLIPBLEND },
160
 
    { "NegAlpha",   EXPP_TEX_FLAG_NEGALPHA },
161
 
    { NULL, 0 }
 
199
        /* we don't support this yet! */
 
200
/*  { "ColorBand",  EXPP_TEX_FLAG_COLORBAND },  */
 
201
        {"FlipBlend", EXPP_TEX_FLAG_FLIPBLEND},
 
202
        {"NegAlpha", EXPP_TEX_FLAG_NEGALPHA},
 
203
        {NULL, 0}
162
204
};
163
205
 
164
206
static const EXPP_map_pair tex_imageflag_map[] = {
165
 
    { "InterPol",   EXPP_TEX_IMAGEFLAG_INTERPOL },
166
 
    { "UseAlpha",   EXPP_TEX_IMAGEFLAG_USEALPHA },
167
 
    { "MipMap",     EXPP_TEX_IMAGEFLAG_MIPMAP },
168
 
    { "Fields",     EXPP_TEX_IMAGEFLAG_FIELDS },
169
 
    { "Rot90",      EXPP_TEX_IMAGEFLAG_ROT90 },
170
 
    { "CalcAlpha",  EXPP_TEX_IMAGEFLAG_CALCALPHA },
171
 
    { "Cyclic",     EXPP_TEX_IMAGEFLAG_CYCLIC },
172
 
    { "Movie",      EXPP_TEX_IMAGEFLAG_MOVIE },
173
 
    { "StField",    EXPP_TEX_IMAGEFLAG_STFIELD },
174
 
    { "Anti",       EXPP_TEX_IMAGEFLAG_ANTI },
175
 
    { NULL, 0 }
 
207
        {"InterPol", EXPP_TEX_IMAGEFLAG_INTERPOL},
 
208
        {"UseAlpha", EXPP_TEX_IMAGEFLAG_USEALPHA},
 
209
        {"MipMap", EXPP_TEX_IMAGEFLAG_MIPMAP},
 
210
        {"Fields", EXPP_TEX_IMAGEFLAG_FIELDS},
 
211
        {"Rot90", EXPP_TEX_IMAGEFLAG_ROT90},
 
212
        {"CalcAlpha", EXPP_TEX_IMAGEFLAG_CALCALPHA},
 
213
        {"Cyclic", EXPP_TEX_IMAGEFLAG_CYCLIC},
 
214
        {"Movie", EXPP_TEX_IMAGEFLAG_MOVIE},
 
215
        {"StField", EXPP_TEX_IMAGEFLAG_STFIELD},
 
216
        {"Anti", EXPP_TEX_IMAGEFLAG_ANTI},
 
217
        {"NormalMap", EXPP_TEX_IMAGEFLAG_NORMALMAP},
 
218
        {NULL, 0}
176
219
};
177
220
 
178
221
static const EXPP_map_pair tex_extend_map[] = {
179
 
    { "Extend",     EXPP_TEX_EXTEND_EXTEND },
180
 
    { "Clip",       EXPP_TEX_EXTEND_CLIP },
181
 
    { "ClipCube",   EXPP_TEX_EXTEND_CLIPCUBE },
182
 
    { "Repeat",     EXPP_TEX_EXTEND_REPEAT },
183
 
    { NULL, 0 }
 
222
        {"Extend", EXPP_TEX_EXTEND_EXTEND},
 
223
        {"Clip", EXPP_TEX_EXTEND_CLIP},
 
224
        {"ClipCube", EXPP_TEX_EXTEND_CLIPCUBE},
 
225
        {"Repeat", EXPP_TEX_EXTEND_REPEAT},
 
226
        {NULL, 0}
184
227
};
185
228
 
186
229
/* array of maps for stype */
187
 
static const EXPP_map_pair tex_stype_default_map[] = { 
188
 
    { "Default", 0 }, 
189
 
    { NULL, 0 } 
 
230
static const EXPP_map_pair tex_stype_default_map[] = {
 
231
        {"Default", 0},
 
232
        {NULL, 0}
190
233
};
191
234
static const EXPP_map_pair tex_stype_clouds_map[] = {
192
 
    { "Default",        0 }, 
193
 
    { "CloudDefault",   EXPP_TEX_STYPE_CLD_DEFAULT },
194
 
    { "CloudColor",     EXPP_TEX_STYPE_CLD_COLOR }, 
195
 
    { NULL, 0 }
 
235
        {"Default", 0},
 
236
        {"CloudDefault", EXPP_TEX_STYPE_CLD_DEFAULT},
 
237
        {"CloudColor", EXPP_TEX_STYPE_CLD_COLOR},
 
238
        {NULL, 0}
196
239
};
197
240
static const EXPP_map_pair tex_stype_wood_map[] = {
198
 
    { "Default",        0 }, 
199
 
    { "WoodBands",      EXPP_TEX_STYPE_WOD_BANDS },
200
 
    { "WoodRings",      EXPP_TEX_STYPE_WOD_RINGS },
201
 
    { "WoodBandNoise",  EXPP_TEX_STYPE_WOD_BANDNOISE },
202
 
    { "WoodRingNoise",  EXPP_TEX_STYPE_WOD_RINGNOISE },
203
 
    { NULL, 0 }
 
241
        {"Default", 0},
 
242
        {"WoodBands", EXPP_TEX_STYPE_WOD_BANDS},
 
243
        {"WoodRings", EXPP_TEX_STYPE_WOD_RINGS},
 
244
        {"WoodBandNoise", EXPP_TEX_STYPE_WOD_BANDNOISE},
 
245
        {"WoodRingNoise", EXPP_TEX_STYPE_WOD_RINGNOISE},
 
246
        {NULL, 0}
204
247
};
205
248
static const EXPP_map_pair tex_stype_marble_map[] = {
206
 
    { "Default",        0 }, 
207
 
    { "MarbleSoft",     EXPP_TEX_STYPE_MBL_SOFT },
208
 
    { "MarbleSharp",    EXPP_TEX_STYPE_MBL_SHARP },
209
 
    { "MarbleSharper",  EXPP_TEX_STYPE_MBL_SHARPER },
210
 
    { NULL , 0 }
 
249
        {"Default", 0},
 
250
        {"MarbleSoft", EXPP_TEX_STYPE_MBL_SOFT},
 
251
        {"MarbleSharp", EXPP_TEX_STYPE_MBL_SHARP},
 
252
        {"MarbleSharper", EXPP_TEX_STYPE_MBL_SHARPER},
 
253
        {NULL, 0}
211
254
};
212
255
static const EXPP_map_pair tex_stype_blend_map[] = {
213
 
    { "Default",        0 }, 
214
 
    { "BlendLin",       EXPP_TEX_STYPE_BLN_LIN },
215
 
    { "BlendQuad",      EXPP_TEX_STYPE_BLN_QUAD },
216
 
    { "BlendEase",      EXPP_TEX_STYPE_BLN_EASE },
217
 
    { "BlendDiag",      EXPP_TEX_STYPE_BLN_DIAG },
218
 
    { "BlendSphere",    EXPP_TEX_STYPE_BLN_SPHERE },
219
 
    { "BlendHalo",      EXPP_TEX_STYPE_BLN_HALO },
220
 
    { NULL , 0 }
 
256
        {"Default", 0},
 
257
        {"BlendLin", EXPP_TEX_STYPE_BLN_LIN},
 
258
        {"BlendQuad", EXPP_TEX_STYPE_BLN_QUAD},
 
259
        {"BlendEase", EXPP_TEX_STYPE_BLN_EASE},
 
260
        {"BlendDiag", EXPP_TEX_STYPE_BLN_DIAG},
 
261
        {"BlendSphere", EXPP_TEX_STYPE_BLN_SPHERE},
 
262
        {"BlendHalo", EXPP_TEX_STYPE_BLN_HALO},
 
263
        {NULL, 0}
221
264
};
222
265
static const EXPP_map_pair tex_stype_stucci_map[] = {
223
 
    { "Default",        0 }, 
224
 
    { "StucciPlastic",  EXPP_TEX_STYPE_STC_PLASTIC },
225
 
    { "StucciWallIn",   EXPP_TEX_STYPE_STC_WALLIN },
226
 
    { "StucciWallOut",  EXPP_TEX_STYPE_STC_WALLOUT },
227
 
    { NULL , 0 }
 
266
        {"Default", 0},
 
267
        {"StucciPlastic", EXPP_TEX_STYPE_STC_PLASTIC},
 
268
        {"StucciWallIn", EXPP_TEX_STYPE_STC_WALLIN},
 
269
        {"StucciWallOut", EXPP_TEX_STYPE_STC_WALLOUT},
 
270
        {NULL, 0}
228
271
};
229
272
static const EXPP_map_pair tex_stype_envmap_map[] = {
230
 
    { "Default",        0 }, 
231
 
    { "EnvmapStatic",   EXPP_TEX_STYPE_ENV_STATIC },
232
 
    { "EnvmapAnim",     EXPP_TEX_STYPE_ENV_ANIM },
233
 
    { "EnvmapLoad",     EXPP_TEX_STYPE_ENV_LOAD },
234
 
    { NULL , 0 }
 
273
        {"Default", 0},
 
274
        {"EnvmapStatic", EXPP_TEX_STYPE_ENV_STATIC},
 
275
        {"EnvmapAnim", EXPP_TEX_STYPE_ENV_ANIM},
 
276
        {"EnvmapLoad", EXPP_TEX_STYPE_ENV_LOAD},
 
277
        {NULL, 0}
 
278
};
 
279
 
 
280
static const EXPP_map_pair tex_stype_musg_map[] = {
 
281
        {"Default", 0},
 
282
        {"MultiFractal", EXPP_TEX_STYPE_MUS_MFRACTAL},
 
283
        {"HeteroTerrain", EXPP_TEX_STYPE_MUS_HTERRAIN},
 
284
        {"RidgedMultiFractal", EXPP_TEX_STYPE_MUS_RIDGEDMF},
 
285
        {"HybridMultiFractal", EXPP_TEX_STYPE_MUS_HYBRIDMF},
 
286
        {"fBM", EXPP_TEX_STYPE_MUS_FBM},
 
287
        {NULL, 0}
 
288
};
 
289
 
 
290
static const EXPP_map_pair tex_stype_distortednoise_map[] = {
 
291
        {"Default", 0},
 
292
        {"BlenderOriginal", EXPP_TEX_STYPE_DN_BLENDER},
 
293
        {"OriginalPerlin", EXPP_TEX_STYPE_DN_PERLIN},
 
294
        {"ImprovedPerlin", EXPP_TEX_STYPE_DN_IMPROVEPERLIN},
 
295
        {"VoronoiF1", EXPP_TEX_STYPE_DN_VORONOIF1},
 
296
        {"VoronoiF2", EXPP_TEX_STYPE_DN_VORONOIF2},
 
297
        {"VoronoiF3", EXPP_TEX_STYPE_DN_VORONOIF3},
 
298
        {"VoronoiF4", EXPP_TEX_STYPE_DN_VORONOIF4},
 
299
        {"VoronoiF2-F1", EXPP_TEX_STYPE_DN_VORONOIF2F1},
 
300
        {"VoronoiCrackle", EXPP_TEX_STYPE_DN_VORONOICRACKLE},
 
301
        {"CellNoise", EXPP_TEX_STYPE_DN_CELLNOISE},
 
302
        {NULL, 0}
 
303
};
 
304
 
 
305
static const EXPP_map_pair tex_stype_voronoi_map[] = {
 
306
        {"Default", 0},
 
307
        {"Int", EXPP_TEX_STYPE_VN_INT},
 
308
        {"Col1", EXPP_TEX_STYPE_VN_COL1},
 
309
        {"Col2", EXPP_TEX_STYPE_VN_COL2},
 
310
        {"Col3", EXPP_TEX_STYPE_VN_COL3},
 
311
        {NULL, 0}
 
312
};
 
313
 
 
314
static const EXPP_map_pair tex_distance_voronoi_map[] = {
 
315
        {"Default", 0},
 
316
        {"Distance", EXPP_TEX_STYPE_VN_TEX_DISTANCE},
 
317
        {"DistanceSquared", EXPP_TEX_STYPE_VN_TEX_DISTANCE_SQUARED},
 
318
        {"Manhattan", EXPP_TEX_STYPE_VN_TEX_MANHATTAN},
 
319
        {"Chebychev", EXPP_TEX_STYPE_VN_TEX_CHEBYCHEV},
 
320
        {"MinkovskyHalf", EXPP_TEX_STYPE_VN_TEX_MINKOVSKY_HALF},
 
321
        {"MinkovskyFour", EXPP_TEX_STYPE_VN_TEX_MINKOVSKY_FOUR},
 
322
        {"Minkovsky", EXPP_TEX_STYPE_VN_TEX_MINKOVSKY},
 
323
        {NULL, 0}
235
324
};
236
325
 
237
326
static const EXPP_map_pair *tex_stype_map[] = {
238
 
    tex_stype_default_map,    /* none */
239
 
    tex_stype_clouds_map,
240
 
    tex_stype_wood_map,
241
 
    tex_stype_marble_map,
242
 
    tex_stype_default_map,    /* magic */
243
 
    tex_stype_blend_map,
244
 
    tex_stype_stucci_map,
245
 
    tex_stype_default_map,    /* noise */
246
 
    tex_stype_default_map,    /* image */
247
 
    tex_stype_default_map,    /* plugin */
248
 
    tex_stype_envmap_map
 
327
        tex_stype_default_map,  /* none */
 
328
        tex_stype_clouds_map,
 
329
        tex_stype_wood_map,
 
330
        tex_stype_marble_map,
 
331
        tex_stype_default_map,  /* magic */
 
332
        tex_stype_blend_map,
 
333
        tex_stype_stucci_map,
 
334
        tex_stype_default_map,  /* noise */
 
335
        tex_stype_default_map,  /* image */
 
336
        tex_stype_default_map,  /* plugin */
 
337
        tex_stype_envmap_map,
 
338
        tex_stype_musg_map,     /* musgrave */
 
339
        tex_stype_voronoi_map,  /* voronoi */
 
340
        tex_stype_distortednoise_map,   /* distorted noise */
 
341
        tex_distance_voronoi_map
249
342
};
250
343
 
251
344
 
252
345
/*****************************************************************************/
253
346
/* Python API function prototypes for the Texture module.                    */
254
347
/*****************************************************************************/
255
 
static PyObject *M_Texture_New (PyObject *self, PyObject *args,
256
 
                               PyObject *keywords);
257
 
static PyObject *M_Texture_Get (PyObject *self, PyObject *args);
 
348
static PyObject *M_Texture_New( PyObject * self, PyObject * args,
 
349
                                PyObject * keywords );
 
350
static PyObject *M_Texture_Get( PyObject * self, PyObject * args );
258
351
 
259
352
/*****************************************************************************/
260
353
/* The following string definitions are used for documentation strings.      */
261
354
/* In Python these will be written to the console when doing a               */
262
355
/* Blender.Texture.__doc__                                                   */
263
356
/*****************************************************************************/
264
 
static char M_Texture_doc[] =
265
 
"The Blender Texture module\n\
 
357
static char M_Texture_doc[] = "The Blender Texture module\n\
266
358
\n\
267
359
This module provides access to **Texture** objects in Blender\n";
268
360
 
269
 
static char M_Texture_New_doc[] =
270
 
"Texture.New (name = 'Tex'):\n\
 
361
static char M_Texture_New_doc[] = "Texture.New (name = 'Tex'):\n\
271
362
        Return a new Texture object with the given type and name.";
272
363
 
273
 
static char M_Texture_Get_doc[] =
274
 
"Texture.Get (name = None):\n\
 
364
static char M_Texture_Get_doc[] = "Texture.Get (name = None):\n\
275
365
        Return the texture with the given 'name', None if not found, or\n\
276
366
        Return a list with all texture objects in the current scene,\n\
277
367
        if no argument was given.";
280
370
/* Python method structure definition for Blender.Texture module:            */
281
371
/*****************************************************************************/
282
372
struct PyMethodDef M_Texture_methods[] = {
283
 
  {"New", (PyCFunction) M_Texture_New,  METH_VARARGS|METH_KEYWORDS, 
284
 
                                                        M_Texture_New_doc},
285
 
  {"Get",   M_Texture_Get,  METH_VARARGS,               M_Texture_Get_doc},
286
 
  {NULL, NULL, 0, NULL}
 
373
        {"New", ( PyCFunction ) M_Texture_New, METH_VARARGS | METH_KEYWORDS,
 
374
         M_Texture_New_doc},
 
375
        {"Get", M_Texture_Get, METH_VARARGS, M_Texture_Get_doc},
 
376
        {NULL, NULL, 0, NULL}
287
377
};
288
378
 
289
379
/*****************************************************************************/
290
 
/* Python BPy_Texture methods declarations:                                   */
 
380
/* Python BPy_Texture methods declarations:                                  */
291
381
/*****************************************************************************/
292
382
#define GETFUNC(name)   static PyObject *Texture_##name(BPy_Texture *self)
293
383
#define SETFUNC(name)   static PyObject *Texture_##name(BPy_Texture *self,   \
294
384
                                                        PyObject *args)
295
385
 
296
 
GETFUNC (getExtend);
297
 
GETFUNC (getImage);
298
 
GETFUNC (getName);
299
 
GETFUNC (getType);
300
 
GETFUNC (getSType);
301
 
SETFUNC (setAnimFrames);
302
 
SETFUNC (setAnimLength);
303
 
SETFUNC (setAnimMontage);
304
 
SETFUNC (setAnimOffset);
305
 
SETFUNC (setAnimStart);
306
 
SETFUNC (setBrightness);
307
 
SETFUNC (setContrast);
308
 
SETFUNC (setCrop);
309
 
SETFUNC (setExtend);
310
 
SETFUNC (setIntExtend);     /* special case used for ".extend = ..." */
311
 
SETFUNC (setFieldsPerImage);
312
 
SETFUNC (setFilterSize);
313
 
SETFUNC (setFlags);
314
 
SETFUNC (setIntFlags);      /* special case used for ".flags = ..." */
315
 
SETFUNC (setImage);
316
 
SETFUNC (setImageFlags);
317
 
SETFUNC (setIntImageFlags); /* special case used for ".imageFlags = ..." */
318
 
SETFUNC (setName);
319
 
SETFUNC (setNoiseDepth);
320
 
SETFUNC (setNoiseSize);
321
 
SETFUNC (setNoiseType);
322
 
SETFUNC (setRepeat);
323
 
SETFUNC (setRGBCol);
324
 
SETFUNC (setSType);
325
 
SETFUNC (setIntSType);      /* special case used for ".stype = ..." */
326
 
SETFUNC (setType);
327
 
SETFUNC (setIntType);       /* special case used for ".type = ..." */
328
 
SETFUNC (setTurbulence);
 
386
GETFUNC( getExtend );
 
387
GETFUNC( getImage );
 
388
GETFUNC( getName );
 
389
GETFUNC( getType );
 
390
GETFUNC( getSType );
 
391
GETFUNC( getIpo );
 
392
GETFUNC( clearIpo );
 
393
SETFUNC( setIpo );
 
394
SETFUNC( setAnimFrames );
 
395
SETFUNC( setAnimLength );
 
396
SETFUNC( setAnimMontage );
 
397
SETFUNC( setAnimOffset );
 
398
SETFUNC( setAnimStart );
 
399
SETFUNC( setBrightness );
 
400
SETFUNC( setContrast );
 
401
SETFUNC( setCrop );
 
402
SETFUNC( setExtend );
 
403
SETFUNC( setIntExtend );        /* special case used for ".extend = ..." */
 
404
SETFUNC( setFieldsPerImage );
 
405
SETFUNC( setFilterSize );
 
406
SETFUNC( setFlags );
 
407
SETFUNC( setIntFlags );         /* special case used for ".flags = ..." */
 
408
SETFUNC( setImage );
 
409
SETFUNC( setImageFlags );
 
410
SETFUNC( setIntImageFlags );    /* special case used for ".imageFlags = ..." */
 
411
SETFUNC( setName );
 
412
SETFUNC( setNoiseDepth );
 
413
SETFUNC( setNoiseSize );
 
414
SETFUNC( setNoiseType );
 
415
SETFUNC( setNoiseBasis );       /* special case used for ".noisebasis or noisebasis2 = ...  */
 
416
SETFUNC( setDistNoise );        /* special case used for ".noisebasis = ...  */
 
417
SETFUNC( setRepeat );
 
418
SETFUNC( setRGBCol );
 
419
SETFUNC( setSType );
 
420
SETFUNC( setIntSType );         /* special case used for ".stype = ..." */
 
421
SETFUNC( setType );
 
422
SETFUNC( setIntType );          /* special case used for ".type = ..." */
 
423
SETFUNC( setTurbulence );
 
424
SETFUNC( setDistMetric );
 
425
SETFUNC( setDistAmnt );
329
426
 
330
427
/*****************************************************************************/
331
 
/* Python BPy_Texture methods table:                                          */
 
428
/* Python BPy_Texture methods table:                                         */
332
429
/*****************************************************************************/
333
430
static PyMethodDef BPy_Texture_methods[] = {
334
 
 /* name, method, flags, doc */
335
 
  {"getExtend", (PyCFunction)Texture_getExtend, METH_NOARGS,
336
 
                            "() - Return Texture extend mode"},
337
 
  {"getImage", (PyCFunction)Texture_getImage, METH_NOARGS,
338
 
                            "() - Return Texture Image"},
339
 
  {"getName", (PyCFunction)Texture_getName, METH_NOARGS,
340
 
                            "() - Return Texture name"},
341
 
  {"getSType", (PyCFunction)Texture_getSType, METH_NOARGS,
342
 
                            "() - Return Texture stype as string"},
343
 
  {"getType", (PyCFunction)Texture_getType, METH_NOARGS,
344
 
                            "() - Return Texture type as string"},
345
 
  {"setExtend", (PyCFunction)Texture_setExtend, METH_VARARGS,
346
 
                            "(s) - Set Texture extend mode"},
347
 
  {"setFlags", (PyCFunction)Texture_setFlags, METH_VARARGS,
348
 
                            "(f1,f2,f3) - Set Texture flags"},
349
 
  {"setImage", (PyCFunction)Texture_setImage, METH_VARARGS,
350
 
                            "(Blender Image) - Set Texture Image"},
351
 
  {"setImageFlags", (PyCFunction)Texture_setImageFlags, METH_VARARGS,
352
 
                            "(s,s,s,s,...) - Set Texture image flags"},
353
 
  {"setName", (PyCFunction)Texture_setName, METH_VARARGS,
354
 
                            "(s) - Set Texture name"},
355
 
  {"setSType", (PyCFunction)Texture_setSType, METH_VARARGS,
356
 
                            "(s) - Set Texture stype"},
357
 
  {"setType", (PyCFunction)Texture_setType, METH_VARARGS,
358
 
                            "(s) - Set Texture type"},
359
 
  {0}
 
431
        /* name, method, flags, doc */
 
432
        {"getExtend", ( PyCFunction ) Texture_getExtend, METH_NOARGS,
 
433
         "() - Return Texture extend mode"},
 
434
        {"getImage", ( PyCFunction ) Texture_getImage, METH_NOARGS,
 
435
         "() - Return Texture Image"},
 
436
        {"getName", ( PyCFunction ) Texture_getName, METH_NOARGS,
 
437
         "() - Return Texture name"},
 
438
        {"getSType", ( PyCFunction ) Texture_getSType, METH_NOARGS,
 
439
         "() - Return Texture stype as string"},
 
440
        {"getType", ( PyCFunction ) Texture_getType, METH_NOARGS,
 
441
         "() - Return Texture type as string"},
 
442
        {"getIpo", ( PyCFunction ) Texture_getIpo, METH_NOARGS,
 
443
         "() - Return Texture Ipo"},
 
444
        {"setIpo", ( PyCFunction ) Texture_setIpo, METH_VARARGS,
 
445
         "(Blender Ipo) - Set Texture Ipo"},
 
446
        {"clearIpo", ( PyCFunction ) Texture_clearIpo, METH_NOARGS,
 
447
         "() - Unlink Ipo from this Texture."},
 
448
        {"setExtend", ( PyCFunction ) Texture_setExtend, METH_VARARGS,
 
449
         "(s) - Set Texture extend mode"},
 
450
        {"setFlags", ( PyCFunction ) Texture_setFlags, METH_VARARGS,
 
451
         "(f1,f2,f3) - Set Texture flags"},
 
452
        {"setImage", ( PyCFunction ) Texture_setImage, METH_VARARGS,
 
453
         "(Blender Image) - Set Texture Image"},
 
454
        {"setImageFlags", ( PyCFunction ) Texture_setImageFlags, METH_VARARGS,
 
455
         "(s,s,s,s,...) - Set Texture image flags"},
 
456
        {"setName", ( PyCFunction ) Texture_setName, METH_VARARGS,
 
457
         "(s) - Set Texture name"},
 
458
        {"setSType", ( PyCFunction ) Texture_setSType, METH_VARARGS,
 
459
         "(s) - Set Texture stype"},
 
460
        {"setType", ( PyCFunction ) Texture_setType, METH_VARARGS,
 
461
         "(s) - Set Texture type"},
 
462
        {"setNoiseBasis", ( PyCFunction ) Texture_setNoiseBasis, METH_VARARGS,
 
463
         "(s) - Set Noise basis"},
 
464
        {"setDistNoise", ( PyCFunction ) Texture_setDistNoise, METH_VARARGS,
 
465
         "(s) - Set Dist Noise"},
 
466
        {"setDistMetric", ( PyCFunction ) Texture_setDistMetric, METH_VARARGS,
 
467
         "(s) - Set Dist Metric"},
 
468
        {NULL, NULL, 0, NULL}
360
469
};
361
470
 
362
471
/*****************************************************************************/
363
 
/* Python Texture_Type callback function prototypes:                          */
 
472
/* Python Texture_Type callback function prototypes:                         */
364
473
/*****************************************************************************/
365
 
static void Texture_dealloc (BPy_Texture *self);
366
 
static int Texture_setAttr (BPy_Texture *self, char *name, PyObject *v);
367
 
static int Texture_compare (BPy_Texture *a, BPy_Texture *b);
368
 
static PyObject *Texture_getAttr (BPy_Texture *self, char *name);
369
 
static PyObject *Texture_repr (BPy_Texture *self);
 
474
static void Texture_dealloc( BPy_Texture * self );
 
475
static int Texture_setAttr( BPy_Texture * self, char *name, PyObject * v );
 
476
static int Texture_compare( BPy_Texture * a, BPy_Texture * b );
 
477
static PyObject *Texture_getAttr( BPy_Texture * self, char *name );
 
478
static PyObject *Texture_repr( BPy_Texture * self );
370
479
 
371
480
 
372
481
/*****************************************************************************/
373
482
/* Python Texture_Type structure definition:                                 */
374
483
/*****************************************************************************/
375
 
PyTypeObject Texture_Type =
376
 
{
377
 
    PyObject_HEAD_INIT(NULL)
378
 
    0,                              /* ob_size */
379
 
    "Blender Texture",              /* tp_name */
380
 
    sizeof (BPy_Texture),           /* tp_basicsize */
381
 
    0,                              /* tp_itemsize */
382
 
    /* methods */
383
 
    (destructor)Texture_dealloc,    /* tp_dealloc */
384
 
    0,                              /* tp_print */
385
 
    (getattrfunc)Texture_getAttr,   /* tp_getattr */
386
 
    (setattrfunc)Texture_setAttr,   /* tp_setattr */
387
 
    (cmpfunc)Texture_compare,       /* tp_compare */
388
 
    (reprfunc)Texture_repr,         /* tp_repr */
389
 
    0,                              /* tp_as_number */
390
 
    0,                              /* tp_as_sequence */
391
 
    0,                              /* tp_as_mapping */
392
 
    0,                              /* tp_as_hash */
393
 
    0,0,0,0,0,0,
394
 
    0,                              /* tp_doc */ 
395
 
    0,0,0,0,0,0,
396
 
    BPy_Texture_methods,            /* tp_methods */
397
 
    0,                              /* tp_members */
 
484
PyTypeObject Texture_Type = {
 
485
        PyObject_HEAD_INIT( NULL ) 0,   /* ob_size */
 
486
        "Blender Texture",      /* tp_name */
 
487
        sizeof( BPy_Texture ),  /* tp_basicsize */
 
488
        0,                      /* tp_itemsize */
 
489
        /* methods */
 
490
        ( destructor ) Texture_dealloc, /* tp_dealloc */
 
491
        0,                      /* tp_print */
 
492
        ( getattrfunc ) Texture_getAttr,        /* tp_getattr */
 
493
        ( setattrfunc ) Texture_setAttr,        /* tp_setattr */
 
494
        ( cmpfunc ) Texture_compare,    /* tp_compare */
 
495
        ( reprfunc ) Texture_repr,      /* tp_repr */
 
496
        0,                      /* tp_as_number */
 
497
        0,                      /* tp_as_sequence */
 
498
        0,                      /* tp_as_mapping */
 
499
        0,                      /* tp_as_hash */
 
500
        0, 0, 0, 0, 0, 0,
 
501
        0,                      /* tp_doc */
 
502
        0, 0, 0, 0, 0, 0,
 
503
        BPy_Texture_methods,    /* tp_methods */
 
504
        0,                      /* tp_members */
 
505
        0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
398
506
};
399
507
 
400
 
static PyObject *M_Texture_New(PyObject *self, PyObject *args, PyObject *kwords)
 
508
static PyObject *M_Texture_New( PyObject * self, PyObject * args,
 
509
                                PyObject * kwords )
401
510
{
402
 
    char        *name_str = "Tex";
403
 
    static char *kwlist[] = {"name_str", NULL};
404
 
    PyObject    *pytex;     /* for Texture object wrapper in Python */
405
 
    Tex         *bltex;     /* for actual Tex we create in Blender */
406
 
 
407
 
    /* Parse the arguments passed in by the Python interpreter */
408
 
    if (!PyArg_ParseTupleAndKeywords(args, kwords, "|s", kwlist, &name_str))
409
 
        return EXPP_ReturnPyObjError(PyExc_AttributeError,
410
 
                        "expected zero, one or two strings as arguments");
411
 
 
412
 
    bltex = add_texture(name_str);  /* first create the texture in Blender */
413
 
 
414
 
    if (bltex)              /* now create the wrapper obj in Python */
415
 
        pytex = Texture_CreatePyObject(bltex);
416
 
    else
417
 
        return EXPP_ReturnPyObjError(PyExc_RuntimeError,
418
 
                                    "couldn't create Texture in Blender");
419
 
 
420
 
    /* let's return user count to zero, because add_texture() incref'd it */
421
 
    bltex->id.us = 0;
422
 
 
423
 
    if (pytex == NULL)
424
 
        return EXPP_ReturnPyObjError (PyExc_MemoryError,
425
 
                                            "couldn't create Tex PyObject");
426
 
 
427
 
    return pytex;
 
511
        char *name_str = "Tex";
 
512
        static char *kwlist[] = { "name_str", NULL };
 
513
        PyObject *pytex;        /* for Texture object wrapper in Python */
 
514
        Tex *bltex;             /* for actual Tex we create in Blender */
 
515
 
 
516
        /* Parse the arguments passed in by the Python interpreter */
 
517
        if( !PyArg_ParseTupleAndKeywords
 
518
            ( args, kwords, "|s", kwlist, &name_str ) )
 
519
                return EXPP_ReturnPyObjError( PyExc_AttributeError,
 
520
                                              "expected zero, one or two strings as arguments" );
 
521
 
 
522
        bltex = add_texture( name_str );  /* first create the texture in Blender */
 
523
 
 
524
        if( bltex )             /* now create the wrapper obj in Python */
 
525
                pytex = Texture_CreatePyObject( bltex );
 
526
        else
 
527
                return EXPP_ReturnPyObjError( PyExc_RuntimeError,
 
528
                                              "couldn't create Texture in Blender" );
 
529
 
 
530
        /* let's return user count to zero, because add_texture() incref'd it */
 
531
        bltex->id.us = 0;
 
532
 
 
533
        if( pytex == NULL )
 
534
                return EXPP_ReturnPyObjError( PyExc_MemoryError,
 
535
                                              "couldn't create Tex PyObject" );
 
536
 
 
537
        return pytex;
428
538
}
429
539
 
430
 
static PyObject *M_Texture_Get(PyObject *self, PyObject *args)
 
540
static PyObject *M_Texture_Get( PyObject * self, PyObject * args )
431
541
{
432
 
    char    * name = NULL;
433
 
    Tex     * tex_iter;
434
 
 
435
 
    if (!PyArg_ParseTuple(args, "|s", &name))
436
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
437
 
                               "expected string argument (or nothing)");
438
 
 
439
 
    tex_iter = G.main->tex.first;
440
 
 
441
 
    if (name) { /* (name) - Search for texture by name */
442
 
        
443
 
        PyObject *wanted_tex = NULL;
444
 
 
445
 
        while (tex_iter) {            
446
 
            if (STREQ(name, tex_iter->id.name+2)) {
447
 
                wanted_tex = Texture_CreatePyObject (tex_iter);
448
 
                break;
449
 
            }
450
 
 
451
 
            tex_iter = tex_iter->id.next;
452
 
        }
453
 
 
454
 
        if (!wanted_tex) { /* Requested texture doesn't exist */
455
 
            char error_msg[64];
456
 
            PyOS_snprintf(error_msg, sizeof(error_msg),
457
 
                                            "Texture \"%s\" not found", name);
458
 
            return EXPP_ReturnPyObjError (PyExc_NameError, error_msg);
459
 
        }
460
 
 
461
 
        return wanted_tex;
462
 
    }
463
 
 
464
 
    else { /* () - return a list of wrappers for all textures in the scene */
465
 
        int index = 0;
466
 
        PyObject *tex_pylist, *pyobj;
467
 
 
468
 
        tex_pylist = PyList_New (BLI_countlist (&(G.main->tex)));
469
 
        if (!tex_pylist)
470
 
            return PythonReturnErrorObject(PyExc_MemoryError,
471
 
                                            "couldn't create PyList");
472
 
 
473
 
        while (tex_iter) {
474
 
            pyobj = Texture_CreatePyObject(tex_iter);
475
 
            if (!pyobj)
476
 
                return PythonReturnErrorObject(PyExc_MemoryError,
477
 
                                    "couldn't create Texture PyObject");
478
 
 
479
 
            PyList_SET_ITEM(tex_pylist, index, pyobj);
480
 
 
481
 
            tex_iter = tex_iter->id.next;
482
 
            index++;
483
 
        }
484
 
 
485
 
        return tex_pylist;
486
 
    }
 
542
        char *name = NULL;
 
543
        Tex *tex_iter;
 
544
 
 
545
        if( !PyArg_ParseTuple( args, "|s", &name ) )
 
546
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
547
                                              "expected string argument (or nothing)" );
 
548
 
 
549
        tex_iter = G.main->tex.first;
 
550
 
 
551
        if( name ) {            /* (name) - Search for texture by name */
 
552
 
 
553
                PyObject *wanted_tex = NULL;
 
554
 
 
555
                while( tex_iter ) {
 
556
                        if( STREQ( name, tex_iter->id.name + 2 ) ) {
 
557
                                wanted_tex =
 
558
                                        Texture_CreatePyObject( tex_iter );
 
559
                                break;
 
560
                        }
 
561
 
 
562
                        tex_iter = tex_iter->id.next;
 
563
                }
 
564
 
 
565
                if( !wanted_tex ) {     /* Requested texture doesn't exist */
 
566
                        char error_msg[64];
 
567
                        PyOS_snprintf( error_msg, sizeof( error_msg ),
 
568
                                       "Texture \"%s\" not found", name );
 
569
                        return EXPP_ReturnPyObjError( PyExc_NameError,
 
570
                                                      error_msg );
 
571
                }
 
572
 
 
573
                return wanted_tex;
 
574
        }
 
575
 
 
576
        else {                  /* () - return a list of wrappers for all textures in the scene */
 
577
                int index = 0;
 
578
                PyObject *tex_pylist, *pyobj;
 
579
 
 
580
                tex_pylist = PyList_New( BLI_countlist( &( G.main->tex ) ) );
 
581
                if( !tex_pylist )
 
582
                        return EXPP_ReturnPyObjError( PyExc_MemoryError,
 
583
                                                      "couldn't create PyList" );
 
584
 
 
585
                while( tex_iter ) {
 
586
                        pyobj = Texture_CreatePyObject( tex_iter );
 
587
                        if( !pyobj )
 
588
                                return EXPP_ReturnPyObjError
 
589
                                        ( PyExc_MemoryError,
 
590
                                          "couldn't create Texture PyObject" );
 
591
 
 
592
                        PyList_SET_ITEM( tex_pylist, index, pyobj );
 
593
 
 
594
                        tex_iter = tex_iter->id.next;
 
595
                        index++;
 
596
                }
 
597
 
 
598
                return tex_pylist;
 
599
        }
487
600
}
488
601
 
489
602
 
490
603
#undef EXPP_ADDCONST
491
604
#define EXPP_ADDCONST(name) \
492
605
        constant_insert(d, #name, PyInt_FromLong(EXPP_TEX_TYPE_##name))
493
 
    
494
 
static PyObject *M_Texture_TypesDict (void)
 
606
 
 
607
static PyObject *M_Texture_TypesDict( void )
495
608
{
496
 
    PyObject *Types = M_constant_New();
497
 
    if (Types) {
498
 
        BPy_constant *d = (BPy_constant*) Types;
499
 
        
500
 
        EXPP_ADDCONST (NONE);
501
 
        EXPP_ADDCONST (CLOUDS);
502
 
        EXPP_ADDCONST (WOOD);
503
 
        EXPP_ADDCONST (MARBLE);
504
 
        EXPP_ADDCONST (MAGIC);
505
 
        EXPP_ADDCONST (BLEND);
506
 
        EXPP_ADDCONST (STUCCI);
507
 
        EXPP_ADDCONST (NOISE);
508
 
        EXPP_ADDCONST (IMAGE);
509
 
        EXPP_ADDCONST (PLUGIN);
510
 
        EXPP_ADDCONST (ENVMAP);
511
 
    }
512
 
    return Types;
 
609
        PyObject *Types = M_constant_New(  );
 
610
        if( Types ) {
 
611
                BPy_constant *d = ( BPy_constant * ) Types;
 
612
 
 
613
                EXPP_ADDCONST( NONE );
 
614
                EXPP_ADDCONST( CLOUDS );
 
615
                EXPP_ADDCONST( WOOD );
 
616
                EXPP_ADDCONST( MARBLE );
 
617
                EXPP_ADDCONST( MAGIC );
 
618
                EXPP_ADDCONST( BLEND );
 
619
                EXPP_ADDCONST( STUCCI );
 
620
                EXPP_ADDCONST( NOISE );
 
621
                EXPP_ADDCONST( IMAGE );
 
622
                EXPP_ADDCONST( PLUGIN );
 
623
                EXPP_ADDCONST( ENVMAP );
 
624
                EXPP_ADDCONST( MUSGRAVE );
 
625
                EXPP_ADDCONST( VORONOI );
 
626
                EXPP_ADDCONST( DISTNOISE );
 
627
        }
 
628
        return Types;
513
629
}
514
630
 
515
631
#undef EXPP_ADDCONST
516
632
#define EXPP_ADDCONST(name) \
517
633
        constant_insert(d, #name, PyInt_FromLong(EXPP_TEX_STYPE_##name))
518
 
    
519
 
static PyObject *M_Texture_STypesDict (void)
 
634
 
 
635
static PyObject *M_Texture_STypesDict( void )
520
636
{
521
 
    PyObject *STypes = M_constant_New();
522
 
    if (STypes) {
523
 
        BPy_constant *d = (BPy_constant*) STypes;
 
637
        PyObject *STypes = M_constant_New(  );
 
638
        if( STypes ) {
 
639
                BPy_constant *d = ( BPy_constant * ) STypes;
524
640
 
525
 
        EXPP_ADDCONST(CLD_DEFAULT);
526
 
        EXPP_ADDCONST(CLD_COLOR);
527
 
        EXPP_ADDCONST(WOD_BANDS);
528
 
        EXPP_ADDCONST(WOD_RINGS);
529
 
        EXPP_ADDCONST(WOD_BANDNOISE);
530
 
        EXPP_ADDCONST(WOD_RINGNOISE);
531
 
        EXPP_ADDCONST(MAG_DEFAULT);
532
 
        EXPP_ADDCONST(MBL_SOFT);
533
 
        EXPP_ADDCONST(MBL_SHARP);
534
 
        EXPP_ADDCONST(MBL_SHARPER);
535
 
        EXPP_ADDCONST(BLN_LIN);
536
 
        EXPP_ADDCONST(BLN_QUAD);
537
 
        EXPP_ADDCONST(BLN_EASE);
538
 
        EXPP_ADDCONST(BLN_DIAG);
539
 
        EXPP_ADDCONST(BLN_SPHERE);
540
 
        EXPP_ADDCONST(BLN_HALO);
541
 
        EXPP_ADDCONST(STC_PLASTIC);
542
 
        EXPP_ADDCONST(STC_WALLIN);
543
 
        EXPP_ADDCONST(STC_WALLOUT);
544
 
        EXPP_ADDCONST(NSE_DEFAULT);
545
 
        EXPP_ADDCONST(IMG_DEFAULT);
546
 
        EXPP_ADDCONST(PLG_DEFAULT);
547
 
        EXPP_ADDCONST(ENV_STATIC);
548
 
        EXPP_ADDCONST(ENV_ANIM);
549
 
        EXPP_ADDCONST(ENV_LOAD);
550
 
    }
551
 
    return STypes;
 
641
                EXPP_ADDCONST( CLD_DEFAULT );
 
642
                EXPP_ADDCONST( CLD_COLOR );
 
643
                EXPP_ADDCONST( WOD_BANDS );
 
644
                EXPP_ADDCONST( WOD_RINGS );
 
645
                EXPP_ADDCONST( WOD_BANDNOISE );
 
646
                EXPP_ADDCONST( WOD_RINGNOISE );
 
647
                EXPP_ADDCONST( MAG_DEFAULT );
 
648
                EXPP_ADDCONST( MBL_SOFT );
 
649
                EXPP_ADDCONST( MBL_SHARP );
 
650
                EXPP_ADDCONST( MBL_SHARPER );
 
651
                EXPP_ADDCONST( BLN_LIN );
 
652
                EXPP_ADDCONST( BLN_QUAD );
 
653
                EXPP_ADDCONST( BLN_EASE );
 
654
                EXPP_ADDCONST( BLN_DIAG );
 
655
                EXPP_ADDCONST( BLN_SPHERE );
 
656
                EXPP_ADDCONST( BLN_HALO );
 
657
                EXPP_ADDCONST( STC_PLASTIC );
 
658
                EXPP_ADDCONST( STC_WALLIN );
 
659
                EXPP_ADDCONST( STC_WALLOUT );
 
660
                EXPP_ADDCONST( NSE_DEFAULT );
 
661
                EXPP_ADDCONST( IMG_DEFAULT );
 
662
                EXPP_ADDCONST( PLG_DEFAULT );
 
663
                EXPP_ADDCONST( ENV_STATIC );
 
664
                EXPP_ADDCONST( ENV_ANIM );
 
665
                EXPP_ADDCONST( ENV_LOAD );
 
666
                EXPP_ADDCONST( MUS_MFRACTAL );
 
667
                EXPP_ADDCONST( MUS_RIDGEDMF );
 
668
                EXPP_ADDCONST( MUS_HYBRIDMF );
 
669
                EXPP_ADDCONST( MUS_FBM );
 
670
                EXPP_ADDCONST( MUS_HTERRAIN );
 
671
                EXPP_ADDCONST( DN_BLENDER );
 
672
                EXPP_ADDCONST( DN_PERLIN );
 
673
                EXPP_ADDCONST( DN_IMPROVEPERLIN );
 
674
                EXPP_ADDCONST( DN_VORONOIF1 );
 
675
                EXPP_ADDCONST( DN_VORONOIF2 );
 
676
                EXPP_ADDCONST( DN_VORONOIF3 );
 
677
                EXPP_ADDCONST( DN_VORONOIF4 );
 
678
                EXPP_ADDCONST( DN_VORONOIF2F1 );
 
679
                EXPP_ADDCONST( DN_VORONOICRACKLE );
 
680
                EXPP_ADDCONST( DN_CELLNOISE );
 
681
                EXPP_ADDCONST( VN_INT );
 
682
                EXPP_ADDCONST( VN_COL1 );
 
683
                EXPP_ADDCONST( VN_COL2 );
 
684
                EXPP_ADDCONST( VN_COL3 );
 
685
                EXPP_ADDCONST( VN_TEX_DISTANCE );
 
686
                EXPP_ADDCONST( VN_TEX_DISTANCE_SQUARED );
 
687
                EXPP_ADDCONST( VN_TEX_MANHATTAN );
 
688
                EXPP_ADDCONST( VN_TEX_CHEBYCHEV );
 
689
                EXPP_ADDCONST( VN_TEX_MINKOVSKY_HALF );
 
690
                EXPP_ADDCONST( VN_TEX_MINKOVSKY_FOUR );
 
691
                EXPP_ADDCONST( VN_TEX_MINKOVSKY );
 
692
        }
 
693
        return STypes;
552
694
}
553
695
 
554
696
#undef EXPP_ADDCONST
555
697
#define EXPP_ADDCONST(name) \
556
698
        constant_insert(d, #name, PyInt_FromLong(EXPP_TEX_TEXCO_##name))
557
 
    
558
 
static PyObject *M_Texture_TexCoDict (void)
 
699
 
 
700
static PyObject *M_Texture_TexCoDict( void )
559
701
{
560
 
    PyObject *TexCo = M_constant_New();
561
 
    if (TexCo) {
562
 
        BPy_constant *d = (BPy_constant*) TexCo;
 
702
        PyObject *TexCo = M_constant_New(  );
 
703
        if( TexCo ) {
 
704
                BPy_constant *d = ( BPy_constant * ) TexCo;
563
705
 
564
 
        EXPP_ADDCONST(ORCO);
565
 
        EXPP_ADDCONST(REFL);
566
 
        EXPP_ADDCONST(NOR);
567
 
        EXPP_ADDCONST(GLOB);
568
 
        EXPP_ADDCONST(UV);
569
 
        EXPP_ADDCONST(OBJECT);
570
 
        EXPP_ADDCONST(WIN);
571
 
        EXPP_ADDCONST(VIEW);
572
 
        EXPP_ADDCONST(STICK);
573
 
    }
574
 
    return TexCo;
 
706
                EXPP_ADDCONST( ORCO );
 
707
                EXPP_ADDCONST( REFL );
 
708
                EXPP_ADDCONST( NOR );
 
709
                EXPP_ADDCONST( GLOB );
 
710
                EXPP_ADDCONST( UV );
 
711
                EXPP_ADDCONST( OBJECT );
 
712
                EXPP_ADDCONST( WIN );
 
713
                EXPP_ADDCONST( VIEW );
 
714
                EXPP_ADDCONST( STICK );
 
715
        }
 
716
        return TexCo;
575
717
}
576
718
 
577
719
 
578
720
#undef EXPP_ADDCONST
579
721
#define EXPP_ADDCONST(name) \
580
722
        constant_insert(d, #name, PyInt_FromLong(EXPP_TEX_MAPTO_##name))
581
 
    
582
 
static PyObject *M_Texture_MapToDict (void)
 
723
 
 
724
static PyObject *M_Texture_MapToDict( void )
583
725
{
584
 
    PyObject *MapTo = M_constant_New();
585
 
    if (MapTo) {
586
 
        BPy_constant *d = (BPy_constant*) MapTo;
 
726
        PyObject *MapTo = M_constant_New(  );
 
727
        if( MapTo ) {
 
728
                BPy_constant *d = ( BPy_constant * ) MapTo;
587
729
 
588
 
        EXPP_ADDCONST(COL);
589
 
        EXPP_ADDCONST(NOR);
590
 
        EXPP_ADDCONST(CSP);
591
 
        EXPP_ADDCONST(CMIR);
592
 
        EXPP_ADDCONST(REF);
593
 
        EXPP_ADDCONST(SPEC);
594
 
        EXPP_ADDCONST(HARD);
595
 
        EXPP_ADDCONST(ALPHA);
596
 
        EXPP_ADDCONST(EMIT);
597
 
    }
598
 
    return MapTo;
 
730
                EXPP_ADDCONST( COL );
 
731
                EXPP_ADDCONST( NOR );
 
732
                EXPP_ADDCONST( CSP );
 
733
                EXPP_ADDCONST( CMIR );
 
734
                EXPP_ADDCONST( REF );
 
735
                EXPP_ADDCONST( SPEC );
 
736
                EXPP_ADDCONST( HARD );
 
737
                EXPP_ADDCONST( ALPHA );
 
738
                EXPP_ADDCONST( EMIT );
 
739
                EXPP_ADDCONST( RAYMIR );
 
740
                EXPP_ADDCONST( AMB );
 
741
                EXPP_ADDCONST( TRANSLU );
 
742
                EXPP_ADDCONST( DISP );
 
743
        }
 
744
        return MapTo;
599
745
}
600
746
 
601
747
 
602
748
#undef EXPP_ADDCONST
603
749
#define EXPP_ADDCONST(name) \
604
750
        constant_insert(d, #name, PyInt_FromLong(EXPP_TEX_FLAG_##name))
605
 
    
606
 
static PyObject *M_Texture_FlagsDict (void)
 
751
 
 
752
static PyObject *M_Texture_FlagsDict( void )
607
753
{
608
 
    PyObject *Flags = M_constant_New();
609
 
    if (Flags) {
610
 
        BPy_constant *d = (BPy_constant*) Flags;
 
754
        PyObject *Flags = M_constant_New(  );
 
755
        if( Flags ) {
 
756
                BPy_constant *d = ( BPy_constant * ) Flags;
611
757
 
612
 
        EXPP_ADDCONST(COLORBAND);
613
 
        EXPP_ADDCONST(FLIPBLEND);
614
 
        EXPP_ADDCONST(NEGALPHA);
615
 
    }
616
 
    return Flags;
 
758
                EXPP_ADDCONST( COLORBAND );
 
759
                EXPP_ADDCONST( FLIPBLEND );
 
760
                EXPP_ADDCONST( NEGALPHA );
 
761
        }
 
762
        return Flags;
617
763
}
618
764
 
619
765
 
620
766
#undef EXPP_ADDCONST
621
767
#define EXPP_ADDCONST(name) \
622
768
        constant_insert(d, #name, PyInt_FromLong(EXPP_TEX_EXTEND_##name))
623
 
    
624
 
static PyObject *M_Texture_ExtendModesDict (void)
 
769
 
 
770
static PyObject *M_Texture_ExtendModesDict( void )
625
771
{
626
 
    PyObject *ExtendModes = M_constant_New();
627
 
    if (ExtendModes) {
628
 
        BPy_constant *d = (BPy_constant*) ExtendModes;
 
772
        PyObject *ExtendModes = M_constant_New(  );
 
773
        if( ExtendModes ) {
 
774
                BPy_constant *d = ( BPy_constant * ) ExtendModes;
629
775
 
630
 
        EXPP_ADDCONST(EXTEND);
631
 
        EXPP_ADDCONST(CLIP);
632
 
        EXPP_ADDCONST(CLIPCUBE);
633
 
        EXPP_ADDCONST(REPEAT);
634
 
    }
635
 
    return ExtendModes;
 
776
                EXPP_ADDCONST( EXTEND );
 
777
                EXPP_ADDCONST( CLIP );
 
778
                EXPP_ADDCONST( CLIPCUBE );
 
779
                EXPP_ADDCONST( REPEAT );
 
780
        }
 
781
        return ExtendModes;
636
782
}
637
783
 
638
784
 
639
785
#undef EXPP_ADDCONST
640
786
#define EXPP_ADDCONST(name) \
641
787
        constant_insert(d, #name, PyInt_FromLong(EXPP_TEX_IMAGEFLAG_##name))
642
 
    
643
 
static PyObject *M_Texture_ImageFlagsDict (void)
644
 
{
645
 
    PyObject *ImageFlags = M_constant_New();
646
 
    if (ImageFlags) {
647
 
        BPy_constant *d = (BPy_constant*) ImageFlags;
648
 
 
649
 
        EXPP_ADDCONST(INTERPOL);
650
 
        EXPP_ADDCONST(USEALPHA);
651
 
        EXPP_ADDCONST(MIPMAP);
652
 
        EXPP_ADDCONST(FIELDS);
653
 
        EXPP_ADDCONST(ROT90);
654
 
        EXPP_ADDCONST(CALCALPHA);
655
 
        EXPP_ADDCONST(STFIELD);
656
 
        EXPP_ADDCONST(MOVIE);
657
 
        EXPP_ADDCONST(CYCLIC);
658
 
    }
659
 
    return ImageFlags;
660
 
}
661
 
 
662
 
 
663
 
PyObject *Texture_Init (void)
664
 
{
665
 
    PyObject *submodule;
666
 
    PyObject  *dict;
667
 
    
668
 
    /* constants */
669
 
    PyObject *Types = M_Texture_TypesDict();
670
 
    PyObject *STypes = M_Texture_STypesDict();
671
 
    PyObject *TexCo = M_Texture_TexCoDict();
672
 
    PyObject *MapTo = M_Texture_MapToDict();
673
 
    PyObject *Flags = M_Texture_FlagsDict();
674
 
    PyObject *ExtendModes = M_Texture_ExtendModesDict();
675
 
    PyObject *ImageFlags = M_Texture_ImageFlagsDict();
676
 
        
677
 
    Texture_Type.ob_type = &PyType_Type;
678
 
 
679
 
    submodule = Py_InitModule3("Blender.Texture", 
680
 
                                        M_Texture_methods, M_Texture_doc);
681
 
 
682
 
    if (Types)
683
 
        PyModule_AddObject(submodule, "Types", Types);
684
 
    if (STypes)
685
 
        PyModule_AddObject(submodule, "STypes", STypes);
686
 
    if (TexCo)
687
 
        PyModule_AddObject(submodule, "TexCo", TexCo);
688
 
    if (MapTo)
689
 
        PyModule_AddObject(submodule, "MapTo", MapTo);
690
 
    if (Flags)
691
 
        PyModule_AddObject(submodule, "Flags", Flags);
692
 
    if (ExtendModes)
693
 
        PyModule_AddObject(submodule, "ExtendModes", ExtendModes);
694
 
    if (ImageFlags)
695
 
        PyModule_AddObject(submodule, "ImageFlags", ImageFlags);
696
 
    
697
 
    /* Add the MTex submodule to this module */
698
 
    dict = PyModule_GetDict (submodule);
699
 
    PyDict_SetItemString (dict, "MTex", MTex_Init());
700
 
  
701
 
    return submodule;
702
 
}
703
 
 
704
 
PyObject *Texture_CreatePyObject (Tex *tex)
705
 
{
706
 
    BPy_Texture *pytex;
707
 
 
708
 
    pytex = (BPy_Texture *) PyObject_NEW (BPy_Texture, &Texture_Type);
709
 
    if (!pytex)
710
 
        return EXPP_ReturnPyObjError (PyExc_MemoryError,
711
 
                                  "couldn't create BPy_Texture PyObject");
712
 
 
713
 
    pytex->texture = tex;
714
 
    return (PyObject *) pytex;
715
 
}
716
 
 
717
 
Tex *Texture_FromPyObject (PyObject *pyobj)
718
 
{
719
 
    return ((BPy_Texture *)pyobj)->texture;
720
 
}
721
 
 
722
 
 
723
 
int Texture_CheckPyObject (PyObject *pyobj)
724
 
{
725
 
    return (pyobj->ob_type == &Texture_Type);
 
788
 
 
789
static PyObject *M_Texture_ImageFlagsDict( void )
 
790
{
 
791
        PyObject *ImageFlags = M_constant_New(  );
 
792
        if( ImageFlags ) {
 
793
                BPy_constant *d = ( BPy_constant * ) ImageFlags;
 
794
 
 
795
                EXPP_ADDCONST( INTERPOL );
 
796
                EXPP_ADDCONST( USEALPHA );
 
797
                EXPP_ADDCONST( MIPMAP );
 
798
                EXPP_ADDCONST( FIELDS );
 
799
                EXPP_ADDCONST( ROT90 );
 
800
                EXPP_ADDCONST( CALCALPHA );
 
801
                EXPP_ADDCONST( STFIELD );
 
802
                EXPP_ADDCONST( MOVIE );
 
803
                EXPP_ADDCONST( CYCLIC );
 
804
                EXPP_ADDCONST( NORMALMAP );
 
805
        }
 
806
        return ImageFlags;
 
807
}
 
808
 
 
809
 
 
810
PyObject *Texture_Init( void )
 
811
{
 
812
        PyObject *submodule;
 
813
        PyObject *dict;
 
814
 
 
815
        /* constants */
 
816
        PyObject *Types = M_Texture_TypesDict(  );
 
817
        PyObject *STypes = M_Texture_STypesDict(  );
 
818
        PyObject *TexCo = M_Texture_TexCoDict(  );
 
819
        PyObject *MapTo = M_Texture_MapToDict(  );
 
820
        PyObject *Flags = M_Texture_FlagsDict(  );
 
821
        PyObject *ExtendModes = M_Texture_ExtendModesDict(  );
 
822
        PyObject *ImageFlags = M_Texture_ImageFlagsDict(  );
 
823
 
 
824
        Texture_Type.ob_type = &PyType_Type;
 
825
 
 
826
        submodule = Py_InitModule3( "Blender.Texture",
 
827
                                    M_Texture_methods, M_Texture_doc );
 
828
 
 
829
        if( Types )
 
830
                PyModule_AddObject( submodule, "Types", Types );
 
831
        if( STypes )
 
832
                PyModule_AddObject( submodule, "STypes", STypes );
 
833
        if( TexCo )
 
834
                PyModule_AddObject( submodule, "TexCo", TexCo );
 
835
        if( MapTo )
 
836
                PyModule_AddObject( submodule, "MapTo", MapTo );
 
837
        if( Flags )
 
838
                PyModule_AddObject( submodule, "Flags", Flags );
 
839
        if( ExtendModes )
 
840
                PyModule_AddObject( submodule, "ExtendModes", ExtendModes );
 
841
        if( ImageFlags )
 
842
                PyModule_AddObject( submodule, "ImageFlags", ImageFlags );
 
843
 
 
844
        /* Add the MTex submodule to this module */
 
845
        dict = PyModule_GetDict( submodule );
 
846
        PyDict_SetItemString( dict, "MTex", MTex_Init(  ) );
 
847
 
 
848
        return submodule;
 
849
}
 
850
 
 
851
PyObject *Texture_CreatePyObject( Tex * tex )
 
852
{
 
853
        BPy_Texture *pytex;
 
854
 
 
855
        pytex = ( BPy_Texture * ) PyObject_NEW( BPy_Texture, &Texture_Type );
 
856
        if( !pytex )
 
857
                return EXPP_ReturnPyObjError( PyExc_MemoryError,
 
858
                                              "couldn't create BPy_Texture PyObject" );
 
859
 
 
860
        pytex->texture = tex;
 
861
        return ( PyObject * ) pytex;
 
862
}
 
863
 
 
864
Tex *Texture_FromPyObject( PyObject * pyobj )
 
865
{
 
866
        return ( ( BPy_Texture * ) pyobj )->texture;
 
867
}
 
868
 
 
869
 
 
870
int Texture_CheckPyObject( PyObject * pyobj )
 
871
{
 
872
        return ( pyobj->ob_type == &Texture_Type );
726
873
}
727
874
 
728
875
 
730
877
/* Python BPy_Texture methods:                                               */
731
878
/*****************************************************************************/
732
879
 
733
 
static PyObject *Texture_getExtend(BPy_Texture *self)
734
 
{
735
 
    PyObject *attr = NULL;
736
 
    const char *extend = NULL;
737
 
 
738
 
    if (EXPP_map_getStrVal (tex_extend_map, self->texture->extend, &extend))
739
 
        attr = PyString_FromString (extend);
740
 
    
741
 
    if (!attr) 
742
 
        return EXPP_ReturnPyObjError (PyExc_RuntimeError,
743
 
                                    "invalid internal extend mode");
744
 
    
745
 
    return attr;
746
 
}
747
 
 
748
 
static PyObject *Texture_getImage(BPy_Texture *self)
749
 
{
750
 
    /* we need this to be an IMAGE texture, and we must have an image */
751
 
    if ((self->texture->type != TEX_IMAGE) || !self->texture->ima)
752
 
    {
753
 
        Py_INCREF (Py_None);
754
 
        return Py_None;
755
 
    }
756
 
        
757
 
    return Image_CreatePyObject (self->texture->ima);
758
 
}
759
 
 
760
 
 
761
 
static PyObject *Texture_getName(BPy_Texture *self)
762
 
{
763
 
    PyObject *attr = PyString_FromString(self->texture->id.name+2);
764
 
    if (!attr) 
765
 
        return EXPP_ReturnPyObjError (PyExc_RuntimeError,
766
 
                                    "couldn't get Texture.name attribute");
767
 
    
768
 
    return attr;
769
 
}
770
 
 
771
 
static PyObject *Texture_getSType(BPy_Texture *self)
772
 
{
773
 
    PyObject *attr = NULL;
774
 
    const char *stype = NULL;
775
 
 
776
 
    if (EXPP_map_getStrVal (tex_stype_map[self->texture->type], 
777
 
                                            self->texture->stype, &stype))
778
 
        attr = PyString_FromString (stype);
779
 
    
780
 
    if (!attr) 
781
 
        return EXPP_ReturnPyObjError (PyExc_RuntimeError,
782
 
                                    "invalid texture stype internally");
783
 
    
784
 
    return attr;
785
 
}
786
 
 
787
 
static PyObject *Texture_getType(BPy_Texture *self)
788
 
{
789
 
    PyObject *attr = NULL;
790
 
    const char *type = NULL;
791
 
 
792
 
    if (EXPP_map_getStrVal (tex_type_map, self->texture->type, &type))
793
 
        attr = PyString_FromString (type);
794
 
    
795
 
    if (!attr) 
796
 
        return EXPP_ReturnPyObjError (PyExc_RuntimeError,
797
 
                                    "invalid texture type internally");
798
 
    
799
 
    return attr;
800
 
}
801
 
 
802
 
 
803
 
static PyObject *Texture_setAnimFrames(BPy_Texture *self, PyObject *args)
804
 
{
805
 
    int frames;
806
 
    if (!PyArg_ParseTuple(args, "i", &frames))
807
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
808
 
                                        "expected an int");
809
 
 
810
 
    if (frames < 0)
811
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
812
 
                                        "frames cannot be negative");
813
 
 
814
 
    self->texture->frames = frames;
815
 
    
816
 
    Py_INCREF (Py_None);
817
 
    return Py_None;
818
 
}
819
 
 
820
 
 
821
 
static PyObject *Texture_setAnimLength(BPy_Texture *self, PyObject *args)
822
 
{
823
 
    int length;
824
 
    if (!PyArg_ParseTuple(args, "i", &length))
825
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
826
 
                                        "expected an int");
827
 
 
828
 
    if (length < 0)
829
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
830
 
                                        "length cannot be negative");
831
 
 
832
 
    self->texture->len = length;
833
 
    
834
 
    Py_INCREF (Py_None);
835
 
    return Py_None;
836
 
}
837
 
 
838
 
 
839
 
static PyObject *Texture_setAnimMontage(BPy_Texture *self, PyObject *args)
840
 
{
841
 
    int fradur[4][2];
842
 
    int i, j;
843
 
    if (!PyArg_ParseTuple(args, "((ii)(ii)(ii)(ii))", 
844
 
                                        &fradur[0][0], &fradur[0][1],
845
 
                                        &fradur[1][0], &fradur[1][1],
846
 
                                        &fradur[2][0], &fradur[2][1],
847
 
                                        &fradur[3][0], &fradur[3][1]))
848
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
849
 
                                        "expected a tuple of tuples");
850
 
 
851
 
    for (i=0; i<4; ++i)
852
 
        for (j=0; j<2; ++j)
853
 
            if (fradur[i][j] < 0)
854
 
                return EXPP_ReturnPyObjError (PyExc_ValueError,
855
 
                                        "values must be greater than zero");
856
 
 
857
 
    for (i=0; i<4; ++i)
858
 
        for (j=0; j<2; ++j)
859
 
            self->texture->fradur[i][j] = fradur[i][j];
860
 
    
861
 
    Py_INCREF (Py_None);
862
 
    return Py_None;
863
 
}
864
 
 
865
 
 
866
 
static PyObject *Texture_setAnimOffset(BPy_Texture *self, PyObject *args)
867
 
{
868
 
    int offset;
869
 
    if (!PyArg_ParseTuple(args, "i", &offset))
870
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
871
 
                                        "expected an int");
872
 
 
873
 
    self->texture->offset = offset;
874
 
    
875
 
    Py_INCREF (Py_None);
876
 
    return Py_None;
877
 
}
878
 
 
879
 
 
880
 
static PyObject *Texture_setAnimStart(BPy_Texture *self, PyObject *args)
881
 
{
882
 
    int sfra;
883
 
    if (!PyArg_ParseTuple(args, "i", &sfra))
884
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
885
 
                                        "expected an int");
886
 
 
887
 
    if (sfra < 1)
888
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
889
 
                                        "start must be greater than zero");
890
 
 
891
 
    self->texture->sfra = sfra;
892
 
    
893
 
    Py_INCREF (Py_None);
894
 
    return Py_None;
895
 
}
896
 
 
897
 
 
898
 
static PyObject *Texture_setBrightness(BPy_Texture *self, PyObject *args)
899
 
{
900
 
    float bright;
901
 
    if (!PyArg_ParseTuple(args, "f", &bright))
902
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
903
 
                                        "expected a float");
904
 
 
905
 
    if (bright<0 || bright>2)
906
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
907
 
                                        "brightness must be in range [0,2]");
908
 
 
909
 
    self->texture->bright = bright;
910
 
    
911
 
    Py_INCREF (Py_None);
912
 
    return Py_None;
913
 
}
914
 
 
915
 
 
916
 
static PyObject *Texture_setContrast(BPy_Texture *self, PyObject *args)
917
 
{
918
 
    float contrast;
919
 
    if (!PyArg_ParseTuple(args, "f", &contrast))
920
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
921
 
                                        "expected a float");
922
 
 
923
 
    if (contrast<0 || contrast>2)
924
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
925
 
                                        "contrast must be in range [0,2]");
926
 
 
927
 
    self->texture->contrast = contrast;
928
 
    
929
 
    Py_INCREF (Py_None);
930
 
    return Py_None;
931
 
}
932
 
 
933
 
 
934
 
static PyObject *Texture_setCrop(BPy_Texture *self, PyObject *args)
935
 
{
936
 
    float crop[4];
937
 
    int i;
938
 
    if (!PyArg_ParseTuple(args, "(ffff)", 
939
 
                            &crop[0], &crop[1], &crop[2], &crop[3]))
940
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
941
 
                                        "expected tuple of 4 floats");
942
 
    
943
 
    for (i=0; i<4; ++i)
944
 
        if (crop[i]<-10 || crop[i]>10)
945
 
            return EXPP_ReturnPyObjError (PyExc_ValueError,
946
 
                                        "values must be in range [-10,10]");
947
 
 
948
 
    self->texture->cropxmin = crop[0];
949
 
    self->texture->cropymin = crop[1];
950
 
    self->texture->cropxmax = crop[2];
951
 
    self->texture->cropymax = crop[3];
952
 
    
953
 
    Py_INCREF (Py_None);
954
 
    return Py_None;
955
 
}
956
 
 
957
 
 
958
 
static PyObject *Texture_setExtend(BPy_Texture *self, PyObject *args)
959
 
{
960
 
    char *extend = NULL;
961
 
    if (!PyArg_ParseTuple(args, "s", &extend))
962
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
963
 
                                           "expected string argument");
964
 
 
965
 
    if (!EXPP_map_getShortVal (tex_extend_map, extend, &self->texture->extend))
966
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
967
 
                                           "invalid extend mode");    
968
 
 
969
 
    Py_INCREF(Py_None);
970
 
    return Py_None;
971
 
}
972
 
 
973
 
static PyObject *Texture_setIntExtend(BPy_Texture *self, PyObject *args)
974
 
{
975
 
    int extend = 0;
976
 
    if (!PyArg_ParseTuple(args, "i", &extend))
977
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
978
 
                                           "expected int argument");
979
 
    
980
 
    if (extend<EXPP_TEX_EXTEND_MIN || extend>EXPP_TEX_EXTEND_MAX)
981
 
        return EXPP_ReturnPyObjError (PyExc_ValueError, 
982
 
                                            "invalid extend mode");
983
 
    
984
 
    self->texture->extend = extend;
985
 
    
986
 
    Py_INCREF(Py_None);
987
 
    return Py_None;
988
 
}
989
 
 
990
 
static PyObject *Texture_setFieldsPerImage(BPy_Texture *self, PyObject *args)
991
 
{
992
 
    int fie_ima;
993
 
    if (!PyArg_ParseTuple(args, "i", &fie_ima))
994
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
995
 
                                        "expected an int");
996
 
 
997
 
    if (fie_ima<1 || fie_ima>200)
998
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
999
 
                                     "value must be in range [1,200]");
1000
 
 
1001
 
    self->texture->fie_ima = fie_ima;
1002
 
    
1003
 
    Py_INCREF (Py_None);
1004
 
    return Py_None;
1005
 
}
1006
 
 
1007
 
static PyObject *Texture_setFilterSize(BPy_Texture *self, PyObject *args)
1008
 
{
1009
 
    float size;
1010
 
    if (!PyArg_ParseTuple(args, "f", &size))
1011
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1012
 
                                        "expected a float");
1013
 
 
1014
 
    if (size<0.1 || size>25)
1015
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
1016
 
                           "filter size must be in range [0.1,25]");
1017
 
 
1018
 
    self->texture->filtersize = size;
1019
 
    
1020
 
    Py_INCREF (Py_None);
1021
 
    return Py_None;
1022
 
}
1023
 
 
1024
 
static PyObject *Texture_setFlags(BPy_Texture *self, PyObject *args)
1025
 
{
1026
 
    char *sf[3] = { NULL, NULL, NULL };
1027
 
    int i;
1028
 
    short flags = 0;
1029
 
    short thisflag;
1030
 
    if (!PyArg_ParseTuple(args, "|sss", &sf[0], &sf[1], &sf[2]))
1031
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1032
 
                                           "expected 0-3 string arguments");
1033
 
 
1034
 
    for (i=0; i<3; ++i)
1035
 
    {
1036
 
        if (!sf[i]) break;
1037
 
 
1038
 
        if (!EXPP_map_getShortVal(tex_flag_map, sf[i], &thisflag))
1039
 
            return EXPP_ReturnPyObjError (PyExc_ValueError,
1040
 
                                            "invalid texture flag name");
1041
 
 
1042
 
        flags |= thisflag;
1043
 
    }
1044
 
 
1045
 
    self->texture->flag = flags;
1046
 
 
1047
 
    Py_INCREF(Py_None);
1048
 
    return Py_None;
1049
 
}
1050
 
 
1051
 
static PyObject *Texture_setIntFlags(BPy_Texture *self, PyObject *args)
1052
 
{
1053
 
    int flags = 0;
1054
 
    if (!PyArg_ParseTuple(args, "i", &flags))
1055
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1056
 
                                           "expected int argument");
1057
 
    
1058
 
    self->texture->flag = flags;
1059
 
    
1060
 
    Py_INCREF(Py_None);
1061
 
    return Py_None;
1062
 
}
1063
 
 
1064
 
 
1065
 
static PyObject *Texture_setImage(BPy_Texture *self, PyObject *args)
1066
 
{
1067
 
    PyObject *pyimg;
1068
 
    Image *blimg = NULL;
1069
 
 
1070
 
    if (!PyArg_ParseTuple(args, "O!", &Image_Type, &pyimg))
1071
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1072
 
                                        "expected an Image");
1073
 
    blimg = Image_FromPyObject (pyimg);
1074
 
 
1075
 
    if (self->texture->ima) {
1076
 
        self->texture->ima->id.us--;
1077
 
    }
1078
 
 
1079
 
    self->texture->ima = blimg;
1080
 
    id_us_plus(&blimg->id);
1081
 
 
1082
 
    Py_INCREF(Py_None);
1083
 
    return Py_None;
1084
 
}
1085
 
 
1086
 
 
1087
 
static PyObject *Texture_setImageFlags(BPy_Texture *self, PyObject *args)
1088
 
{
1089
 
    char *sf[9] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
1090
 
    int i;
1091
 
    short flags = 0;
1092
 
    short thisflag;
1093
 
    if (!PyArg_ParseTuple(args, "|sssssssss", &sf[0], &sf[1], &sf[2], &sf[3],
1094
 
                                    &sf[4], &sf[5], &sf[6], &sf[7], &sf[8]))
1095
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1096
 
                                           "expected 0-9 string arguments");
1097
 
 
1098
 
    for (i=0; i<9; ++i)
1099
 
    {
1100
 
        if (!sf[i]) break;
1101
 
 
1102
 
        if (!EXPP_map_getShortVal(tex_imageflag_map, sf[i], &thisflag))
1103
 
            return EXPP_ReturnPyObjError (PyExc_ValueError,
1104
 
                                            "invalid texture image flag name");
1105
 
 
1106
 
        flags |= thisflag;
1107
 
    }
1108
 
 
1109
 
    /* MIPMAP and FIELDS can't be used together */
1110
 
    if ((flags & EXPP_TEX_IMAGEFLAG_MIPMAP) &&
1111
 
            (flags & EXPP_TEX_IMAGEFLAG_FIELDS))
1112
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
1113
 
                  "image flags MIPMAP and FIELDS cannot be used together");
1114
 
    
1115
 
    self->texture->imaflag = flags;
1116
 
 
1117
 
    Py_INCREF(Py_None);
1118
 
    return Py_None;
1119
 
}
1120
 
 
1121
 
static PyObject *Texture_setIntImageFlags(BPy_Texture *self, PyObject *args)
1122
 
{
1123
 
    int flags = 0;
1124
 
    if (!PyArg_ParseTuple(args, "i", &flags))
1125
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1126
 
                                           "expected int argument");
1127
 
    
1128
 
    /* MIPMAP and FIELDS can't be used together */
1129
 
    if ((flags & EXPP_TEX_IMAGEFLAG_MIPMAP) &&
1130
 
            (flags & EXPP_TEX_IMAGEFLAG_FIELDS))
1131
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
1132
 
                  "image flags MIPMAP and FIELDS cannot be used together");
1133
 
    
1134
 
    self->texture->imaflag = flags;
1135
 
    
1136
 
    Py_INCREF(Py_None);
1137
 
    return Py_None;
1138
 
}
1139
 
 
1140
 
static PyObject *Texture_setName(BPy_Texture *self, PyObject *args)
1141
 
{
1142
 
    char *name;
1143
 
    char buf[21];
1144
 
 
1145
 
    if (!PyArg_ParseTuple(args, "s", &name))
1146
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1147
 
                                           "expected string argument");
1148
 
 
1149
 
    PyOS_snprintf(buf, sizeof(buf), "%s", name);
1150
 
    rename_id(&self->texture->id, buf);
1151
 
 
1152
 
    Py_INCREF(Py_None);
1153
 
    return Py_None;
1154
 
}
1155
 
 
1156
 
static PyObject *Texture_setNoiseDepth(BPy_Texture *self, PyObject *args)
1157
 
{
1158
 
    int depth;
1159
 
    if (!PyArg_ParseTuple(args, "i", &depth))
1160
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1161
 
                                        "expected an int");
1162
 
 
1163
 
    if (depth<0 || depth>6)
1164
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
1165
 
                                     "value must be in range [0,6]");
1166
 
 
1167
 
    self->texture->noisedepth = depth;
1168
 
    
1169
 
    Py_INCREF (Py_None);
1170
 
    return Py_None;
1171
 
}
1172
 
 
1173
 
static PyObject *Texture_setNoiseSize(BPy_Texture *self, PyObject *args)
1174
 
{
1175
 
    float size;
1176
 
    if (!PyArg_ParseTuple(args, "f", &size))
1177
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1178
 
                                        "expected a float");
1179
 
 
1180
 
    if (size<0 || size>2)
1181
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
1182
 
                           "noise size must be in range [0,2]");
1183
 
 
1184
 
    self->texture->noisesize = size;
1185
 
    
1186
 
    Py_INCREF (Py_None);
1187
 
    return Py_None;
1188
 
}
1189
 
 
1190
 
static PyObject *Texture_setNoiseType(BPy_Texture *self, PyObject *args)
1191
 
{
1192
 
    char *type;
1193
 
 
1194
 
    if (!PyArg_ParseTuple(args, "s", &type))
1195
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1196
 
                                           "expected string argument");
1197
 
 
1198
 
    if (STREQ(type, "soft"))
1199
 
        self->texture->noisetype = TEX_NOISESOFT;
1200
 
    else if (STREQ(type, "hard"))
1201
 
        self->texture->noisetype = TEX_NOISEPERL;
1202
 
    
1203
 
    else
1204
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
1205
 
                                    "noise type must be 'soft' or 'hard'");
1206
 
 
1207
 
    Py_INCREF(Py_None);
1208
 
    return Py_None;
1209
 
}
1210
 
 
1211
 
static PyObject *Texture_setRepeat(BPy_Texture *self, PyObject *args)
1212
 
{
1213
 
    int repeat[2];
1214
 
    int i;
1215
 
    if (!PyArg_ParseTuple(args, "(ii)", &repeat[0], &repeat[1]))
1216
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1217
 
                                        "expected tuple of 2 ints");
1218
 
    
1219
 
    for (i=0; i<2; ++i)
1220
 
        if (repeat[i]<1 || repeat[i]>512)
1221
 
            return EXPP_ReturnPyObjError (PyExc_ValueError,
1222
 
                                    "values must be in range [1,512]");
1223
 
 
1224
 
    self->texture->xrepeat = repeat[0];
1225
 
    self->texture->yrepeat = repeat[1];
1226
 
    
1227
 
    Py_INCREF (Py_None);
1228
 
    return Py_None;
1229
 
}
1230
 
 
1231
 
static PyObject *Texture_setRGBCol(BPy_Texture *self, PyObject *args)
1232
 
{
1233
 
    float rgb[3];
1234
 
    int i;
1235
 
    if (!PyArg_ParseTuple(args, "(fff)", &rgb[0], &rgb[1], &rgb[2]))
1236
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1237
 
                                        "expected tuple of 3 floats");
1238
 
    
1239
 
    for (i=0; i<3; ++i)
1240
 
        if (rgb[i]<0 || rgb[i]>2)
1241
 
            return EXPP_ReturnPyObjError (PyExc_ValueError,
1242
 
                                    "values must be in range [0,2]");
1243
 
 
1244
 
    self->texture->rfac = rgb[0];
1245
 
    self->texture->gfac = rgb[1];
1246
 
    self->texture->bfac = rgb[2];
1247
 
    
1248
 
    Py_INCREF (Py_None);
1249
 
    return Py_None;
1250
 
}
1251
 
 
1252
 
 
1253
 
static PyObject *Texture_setSType(BPy_Texture *self, PyObject *args)
1254
 
{
1255
 
    char *stype = NULL;
1256
 
    if (!PyArg_ParseTuple(args, "s", &stype))
1257
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1258
 
                                           "expected string argument");
1259
 
 
1260
 
    /* can we really trust texture->type? */
1261
 
    if (!EXPP_map_getShortVal (tex_stype_map[self->texture->type], 
1262
 
                                            stype, &self->texture->stype))
1263
 
        return EXPP_ReturnPyObjError (PyExc_ValueError, 
1264
 
                                                "invalid texture stype");
1265
 
 
1266
 
    Py_INCREF(Py_None);
1267
 
    return Py_None;
1268
 
}
1269
 
 
1270
 
static PyObject *Texture_setIntSType(BPy_Texture *self, PyObject *args)
1271
 
{
1272
 
    int stype = 0;
1273
 
    const char *dummy = NULL;
1274
 
    if (!PyArg_ParseTuple(args, "i", &stype))
1275
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1276
 
                                           "expected int argument");
1277
 
    
1278
 
    /* use the stype map to find out if this is a valid stype for this type *
1279
 
     * note that this will allow CLD_COLOR when type is ENVMAP. there's not *
1280
 
     * much that we can do about this though.                               */
1281
 
    if (!EXPP_map_getStrVal (tex_stype_map[self->texture->type], stype, &dummy))
1282
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
1283
 
                                            "invalid stype (for this type)");
1284
 
    
1285
 
    self->texture->stype = stype;
1286
 
    
1287
 
    Py_INCREF(Py_None);
1288
 
    return Py_None;
1289
 
}
1290
 
 
1291
 
static PyObject *Texture_setTurbulence(BPy_Texture *self, PyObject *args)
1292
 
{
1293
 
    float turb;
1294
 
    if (!PyArg_ParseTuple(args, "f", &turb))
1295
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1296
 
                                        "expected a float");
1297
 
 
1298
 
    if (turb<0 || turb>200)
1299
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
1300
 
                           "turbulence must be in range [0,200]");
1301
 
 
1302
 
    self->texture->turbul = turb;
1303
 
    
1304
 
    Py_INCREF (Py_None);
1305
 
    return Py_None;
1306
 
}
1307
 
 
1308
 
static PyObject *Texture_setType(BPy_Texture *self, PyObject *args)
1309
 
{
1310
 
    char *type = NULL;
1311
 
    if (!PyArg_ParseTuple(args, "s", &type))
1312
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1313
 
                                           "expected string argument");
1314
 
 
1315
 
    if (!EXPP_map_getShortVal (tex_type_map, type, &self->texture->type))
1316
 
        return EXPP_ReturnPyObjError (PyExc_ValueError,
1317
 
                                           "invalid texture type");    
1318
 
 
1319
 
    Py_INCREF(Py_None);
1320
 
    return Py_None;
1321
 
}
1322
 
 
1323
 
static PyObject *Texture_setIntType(BPy_Texture *self, PyObject *args)
1324
 
{
1325
 
    int type = 0;
1326
 
    if (!PyArg_ParseTuple(args, "i", &type))
1327
 
        return EXPP_ReturnPyObjError (PyExc_TypeError,
1328
 
                                           "expected int argument");
1329
 
    
1330
 
    if (type<EXPP_TEX_TYPE_MIN || type>EXPP_TEX_TYPE_MAX)
1331
 
        return EXPP_ReturnPyObjError (PyExc_ValueError, 
1332
 
                                            "invalid type number");
1333
 
    
1334
 
    self->texture->type = type;
1335
 
    
1336
 
    Py_INCREF(Py_None);
1337
 
    return Py_None;
1338
 
}
1339
 
 
1340
 
static void Texture_dealloc (BPy_Texture *self)
1341
 
{
1342
 
    PyObject_DEL (self);
1343
 
}
1344
 
 
1345
 
static PyObject *Texture_getAttr (BPy_Texture *self, char *name)
1346
 
{
1347
 
    PyObject *attr = Py_None;
1348
 
    Tex *tex = self->texture;
1349
 
 
1350
 
    if (STREQ(name, "animFrames"))
1351
 
        attr = PyInt_FromLong (tex->frames);
1352
 
    else if (STREQ(name, "animLength"))
1353
 
        attr = PyInt_FromLong (tex->len);
1354
 
    else if (STREQ(name, "animMontage"))
1355
 
        attr = Py_BuildValue("((i,i),(i,i),(i,i),(i,i))", 
1356
 
                            tex->fradur[0][0], tex->fradur[0][1],
1357
 
                            tex->fradur[1][0], tex->fradur[1][1],
1358
 
                            tex->fradur[2][0], tex->fradur[2][1],
1359
 
                            tex->fradur[3][0], tex->fradur[3][1] );
1360
 
    else if (STREQ(name, "animOffset"))
1361
 
        attr = PyInt_FromLong (tex->offset);
1362
 
    else if (STREQ(name, "animStart"))
1363
 
        attr = PyInt_FromLong (tex->sfra);
1364
 
    else if (STREQ(name, "brightness"))
1365
 
        attr = PyFloat_FromDouble (tex->bright);
1366
 
    else if (STREQ(name, "contrast"))
1367
 
        attr = PyFloat_FromDouble (tex->contrast);
1368
 
    else if (STREQ(name, "crop"))
1369
 
        attr = Py_BuildValue("(f,f,f,f)", tex->cropxmin, tex->cropymin, 
1370
 
                                          tex->cropxmax, tex->cropymax);
1371
 
    else if (STREQ(name, "extend"))
1372
 
        attr = PyInt_FromLong (tex->extend);
1373
 
    else if (STREQ(name, "fieldsPerImage"))
1374
 
        attr = PyInt_FromLong (tex->fie_ima);
1375
 
    else if (STREQ(name, "filterSize"))
1376
 
        attr = PyFloat_FromDouble (tex->filtersize);
1377
 
    else if (STREQ(name, "flags"))
1378
 
        attr = PyInt_FromLong (tex->flag);
1379
 
    else if (STREQ(name, "image"))
1380
 
        attr = Texture_getImage (self);
1381
 
    else if (STREQ(name, "imageFlags"))
1382
 
        attr = PyInt_FromLong (tex->imaflag);
1383
 
    else if (STREQ(name, "name"))
1384
 
        attr = PyString_FromString(tex->id.name+2);
1385
 
    else if (STREQ(name, "noiseDepth"))
1386
 
        attr = PyInt_FromLong (tex->noisedepth);
1387
 
    else if (STREQ(name, "noiseSize"))
1388
 
        attr = PyFloat_FromDouble (tex->noisesize);
1389
 
    else if (STREQ(name, "noiseType"))
1390
 
    {
1391
 
        if (tex->noisetype == TEX_NOISESOFT)
1392
 
            attr = PyString_FromString ("soft");
1393
 
        else
1394
 
            attr = PyString_FromString ("hard");
1395
 
    }
1396
 
    else if (STREQ(name, "repeat"))
1397
 
        attr = Py_BuildValue ("(i,i)", tex->xrepeat, tex->yrepeat);
1398
 
    else if (STREQ(name, "rgbCol"))
1399
 
        attr = Py_BuildValue ("(f,f,f)", tex->rfac, tex->gfac, tex->gfac);
1400
 
    else if (STREQ(name, "stype"))
1401
 
        attr = PyInt_FromLong (tex->stype);
1402
 
    else if (STREQ(name, "turbulence"))
1403
 
        attr = PyFloat_FromDouble (tex->turbul);
1404
 
    else if (STREQ(name, "type"))
1405
 
        attr = PyInt_FromLong (tex->type);
1406
 
 
1407
 
    
1408
 
    else if (STREQ(name, "__members__"))
1409
 
        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]", 
1410
 
                "animFrames", "animLength", "animMontage", "animOffset",
1411
 
                "animStart", "brightness", "contrast", "crop", "extend",
1412
 
                "fieldsPerImage", "filterSize", "flags", "image", 
1413
 
                "imageFlags", "name", "noiseDepth", "noiseSize", "noiseType",
1414
 
                "repeat", "rgbCol", "stype", "turbulence", "type");
1415
 
 
1416
 
    if (!attr)
1417
 
        return EXPP_ReturnPyObjError (PyExc_MemoryError,
1418
 
                                            "couldn't create PyObject");
1419
 
 
1420
 
    if (attr != Py_None) 
1421
 
        return attr; /* member attribute found, return it */
1422
 
 
1423
 
    /* not an attribute, search the methods table */
1424
 
    return Py_FindMethod(BPy_Texture_methods, (PyObject *)self, name);
1425
 
}
1426
 
 
1427
 
 
1428
 
static int Texture_setAttr (BPy_Texture *self, char *name, PyObject *value)
1429
 
{
1430
 
    PyObject *valtuple; 
1431
 
    PyObject *error = NULL;
1432
 
 
1433
 
    /* Put "value" in a tuple, because we want to pass it to functions  *
1434
 
     * that only accept PyTuples.                                       */
1435
 
    valtuple = Py_BuildValue("(O)", value);
1436
 
    if (!valtuple)
1437
 
        return EXPP_ReturnIntError(PyExc_MemoryError,
1438
 
                                "Texture_setAttr: couldn't create PyTuple");
1439
 
 
1440
 
    if (STREQ(name, "animFrames"))
1441
 
        error = Texture_setAnimFrames (self, valtuple);
1442
 
    else if (STREQ(name, "animLength"))
1443
 
        error = Texture_setAnimLength(self, valtuple);
1444
 
    else if (STREQ(name, "animMontage"))
1445
 
        error = Texture_setAnimMontage(self, valtuple);
1446
 
    else if (STREQ(name, "animOffset"))
1447
 
        error = Texture_setAnimOffset(self, valtuple);
1448
 
    else if (STREQ(name, "animStart"))
1449
 
        error = Texture_setAnimStart(self, valtuple);
1450
 
    else if (STREQ(name, "brightness"))
1451
 
        error = Texture_setBrightness(self, valtuple);
1452
 
    else if (STREQ(name, "contrast"))
1453
 
        error = Texture_setContrast(self, valtuple);
1454
 
    else if (STREQ(name, "crop"))
1455
 
        error = Texture_setCrop(self, valtuple);
1456
 
    else if (STREQ(name, "extend"))
1457
 
        error = Texture_setIntExtend(self, valtuple);
1458
 
    else if (STREQ(name, "fieldsPerImage"))
1459
 
        error = Texture_setFieldsPerImage(self, valtuple);
1460
 
    else if (STREQ(name, "filterSize"))
1461
 
        error = Texture_setFilterSize(self, valtuple);
1462
 
    else if (STREQ(name, "flags"))
1463
 
        error = Texture_setIntFlags(self, valtuple);
1464
 
    else if (STREQ(name, "image"))
1465
 
        error = Texture_setImage (self, valtuple);
1466
 
    else if (STREQ(name, "imageFlags"))
1467
 
        error = Texture_setIntImageFlags(self, valtuple);
1468
 
    else if (STREQ(name, "name"))
1469
 
        error = Texture_setName(self, valtuple);
1470
 
    else if (STREQ(name, "noiseDepth"))
1471
 
        error = Texture_setNoiseDepth(self, valtuple);
1472
 
    else if (STREQ(name, "noiseSize"))
1473
 
        error = Texture_setNoiseSize(self, valtuple);
1474
 
    else if (STREQ(name, "noiseType"))
1475
 
        error = Texture_setNoiseType(self, valtuple);
1476
 
    else if (STREQ(name, "repeat"))
1477
 
        error = Texture_setRepeat(self, valtuple);
1478
 
    else if (STREQ(name, "rgbCol"))
1479
 
        error = Texture_setRGBCol(self, valtuple);
1480
 
    else if (STREQ(name, "stype"))
1481
 
        error = Texture_setIntSType(self, valtuple);
1482
 
    else if (STREQ(name, "turbulence"))
1483
 
        error = Texture_setTurbulence(self, valtuple);
1484
 
    else if (STREQ(name, "type"))
1485
 
        error = Texture_setIntType(self, valtuple);
1486
 
    
1487
 
    else { 
1488
 
        /* Error */
1489
 
        Py_DECREF(valtuple);
1490
 
        return EXPP_ReturnIntError (PyExc_KeyError, "attribute not found");
1491
 
    }
1492
 
 
1493
 
    Py_DECREF (valtuple);
1494
 
 
1495
 
    if (error != Py_None) 
1496
 
        return -1;
1497
 
 
1498
 
    /* Py_None was INCREF'd by the set*() function, so we need to DECREF it */
1499
 
    Py_DECREF (Py_None);
1500
 
    
1501
 
    return 0;
1502
 
}
1503
 
 
1504
 
static int Texture_compare (BPy_Texture *a, BPy_Texture *b)
1505
 
{
1506
 
    return (a->texture == b->texture) ? 0 : -1;
1507
 
}
1508
 
 
1509
 
static PyObject *Texture_repr (BPy_Texture *self)
1510
 
{
1511
 
    return PyString_FromFormat("[Texture \"%s\"]", self->texture->id.name+2);
1512
 
}
1513
 
 
 
880
static PyObject *Texture_getExtend( BPy_Texture * self )
 
881
{
 
882
        PyObject *attr = NULL;
 
883
        const char *extend = NULL;
 
884
 
 
885
        if( EXPP_map_getStrVal
 
886
            ( tex_extend_map, self->texture->extend, &extend ) )
 
887
                attr = PyString_FromString( extend );
 
888
 
 
889
        if( !attr )
 
890
                return EXPP_ReturnPyObjError( PyExc_RuntimeError,
 
891
                                              "invalid internal extend mode" );
 
892
 
 
893
        return attr;
 
894
}
 
895
 
 
896
static PyObject *Texture_getImage( BPy_Texture * self )
 
897
{
 
898
        /* we need this to be an IMAGE texture, and we must have an image */
 
899
        if( ( self->texture->type != TEX_IMAGE ) || !self->texture->ima ) {
 
900
                Py_INCREF( Py_None );
 
901
                return Py_None;
 
902
        }
 
903
 
 
904
        return Image_CreatePyObject( self->texture->ima );
 
905
}
 
906
 
 
907
 
 
908
static PyObject *Texture_getName( BPy_Texture * self )
 
909
{
 
910
        PyObject *attr = PyString_FromString( self->texture->id.name + 2 );
 
911
        if( !attr )
 
912
                return EXPP_ReturnPyObjError( PyExc_RuntimeError,
 
913
                                              "couldn't get Texture.name attribute" );
 
914
 
 
915
        return attr;
 
916
}
 
917
 
 
918
static PyObject *Texture_getSType( BPy_Texture * self )
 
919
{
 
920
        PyObject *attr = NULL;
 
921
        const char *stype = NULL;
 
922
        int n_stype;
 
923
 
 
924
        if( self->texture->type == EXPP_TEX_TYPE_ENVMAP )
 
925
                n_stype = self->texture->env->stype;
 
926
        else
 
927
                n_stype = self->texture->stype;
 
928
        if( EXPP_map_getStrVal( tex_stype_map[self->texture->type],
 
929
                                n_stype, &stype ) )
 
930
                attr = PyString_FromString( stype );
 
931
 
 
932
        if( !attr )
 
933
                return EXPP_ReturnPyObjError( PyExc_RuntimeError,
 
934
                                              "invalid texture stype internally" );
 
935
 
 
936
        return attr;
 
937
}
 
938
 
 
939
static PyObject *Texture_getType( BPy_Texture * self )
 
940
{
 
941
        PyObject *attr = NULL;
 
942
        const char *type = NULL;
 
943
 
 
944
        if( EXPP_map_getStrVal( tex_type_map, self->texture->type, &type ) )
 
945
                attr = PyString_FromString( type );
 
946
 
 
947
        if( !attr )
 
948
                return EXPP_ReturnPyObjError( PyExc_RuntimeError,
 
949
                                              "invalid texture type internally" );
 
950
 
 
951
        return attr;
 
952
}
 
953
 
 
954
static PyObject *Texture_setAnimFrames( BPy_Texture * self, PyObject * args )
 
955
{
 
956
        int frames;
 
957
        if( !PyArg_ParseTuple( args, "i", &frames ) )
 
958
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
959
                                              "expected an int" );
 
960
 
 
961
        if( frames < 0 )
 
962
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
963
                                              "frames cannot be negative" );
 
964
 
 
965
        self->texture->frames = frames;
 
966
 
 
967
        Py_INCREF( Py_None );
 
968
        return Py_None;
 
969
}
 
970
 
 
971
static PyObject *Texture_setAnimLength( BPy_Texture * self, PyObject * args )
 
972
{
 
973
        int length;
 
974
        if( !PyArg_ParseTuple( args, "i", &length ) )
 
975
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
976
                                              "expected an int" );
 
977
 
 
978
        if( length < 0 )
 
979
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
980
                                              "length cannot be negative" );
 
981
 
 
982
        self->texture->len = length;
 
983
 
 
984
        Py_INCREF( Py_None );
 
985
        return Py_None;
 
986
}
 
987
 
 
988
 
 
989
static PyObject *Texture_setAnimMontage( BPy_Texture * self, PyObject * args )
 
990
{
 
991
        int fradur[4][2];
 
992
        int i, j;
 
993
        if( !PyArg_ParseTuple( args, "((ii)(ii)(ii)(ii))",
 
994
                               &fradur[0][0], &fradur[0][1],
 
995
                               &fradur[1][0], &fradur[1][1],
 
996
                               &fradur[2][0], &fradur[2][1],
 
997
                               &fradur[3][0], &fradur[3][1] ) )
 
998
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
999
                                              "expected a tuple of tuples" );
 
1000
 
 
1001
        for( i = 0; i < 4; ++i )
 
1002
                for( j = 0; j < 2; ++j )
 
1003
                        if( fradur[i][j] < 0 )
 
1004
                                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1005
                                                              "values must be greater than zero" );
 
1006
 
 
1007
        for( i = 0; i < 4; ++i )
 
1008
                for( j = 0; j < 2; ++j )
 
1009
                        self->texture->fradur[i][j] = fradur[i][j];
 
1010
 
 
1011
        Py_INCREF( Py_None );
 
1012
        return Py_None;
 
1013
}
 
1014
 
 
1015
 
 
1016
static PyObject *Texture_setAnimOffset( BPy_Texture * self, PyObject * args )
 
1017
{
 
1018
        int offset;
 
1019
        if( !PyArg_ParseTuple( args, "i", &offset ) )
 
1020
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1021
                                              "expected an int" );
 
1022
 
 
1023
        self->texture->offset = offset;
 
1024
 
 
1025
        Py_INCREF( Py_None );
 
1026
        return Py_None;
 
1027
}
 
1028
 
 
1029
 
 
1030
static PyObject *Texture_setAnimStart( BPy_Texture * self, PyObject * args )
 
1031
{
 
1032
        int sfra;
 
1033
        if( !PyArg_ParseTuple( args, "i", &sfra ) )
 
1034
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1035
                                              "expected an int" );
 
1036
 
 
1037
        if( sfra < 1 )
 
1038
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1039
                                              "start must be greater than zero" );
 
1040
 
 
1041
        self->texture->sfra = sfra;
 
1042
 
 
1043
        Py_INCREF( Py_None );
 
1044
        return Py_None;
 
1045
}
 
1046
 
 
1047
 
 
1048
static PyObject *Texture_setBrightness( BPy_Texture * self, PyObject * args )
 
1049
{
 
1050
        float bright;
 
1051
        if( !PyArg_ParseTuple( args, "f", &bright ) )
 
1052
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1053
                                              "expected a float" );
 
1054
 
 
1055
        if( bright < 0 || bright > 2 )
 
1056
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1057
                                              "brightness must be in range [0,2]" );
 
1058
 
 
1059
        self->texture->bright = bright;
 
1060
 
 
1061
        Py_INCREF( Py_None );
 
1062
        return Py_None;
 
1063
}
 
1064
 
 
1065
 
 
1066
static PyObject *Texture_setContrast( BPy_Texture * self, PyObject * args )
 
1067
{
 
1068
        float contrast;
 
1069
        if( !PyArg_ParseTuple( args, "f", &contrast ) )
 
1070
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1071
                                              "expected a float" );
 
1072
 
 
1073
        if( contrast < 0 || contrast > 2 )
 
1074
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1075
                                              "contrast must be in range [0,2]" );
 
1076
 
 
1077
        self->texture->contrast = contrast;
 
1078
 
 
1079
        Py_INCREF( Py_None );
 
1080
        return Py_None;
 
1081
}
 
1082
 
 
1083
 
 
1084
static PyObject *Texture_setCrop( BPy_Texture * self, PyObject * args )
 
1085
{
 
1086
        float crop[4];
 
1087
        int i;
 
1088
        if( !PyArg_ParseTuple( args, "(ffff)",
 
1089
                               &crop[0], &crop[1], &crop[2], &crop[3] ) )
 
1090
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1091
                                              "expected tuple of 4 floats" );
 
1092
 
 
1093
        for( i = 0; i < 4; ++i )
 
1094
                if( crop[i] < -10 || crop[i] > 10 )
 
1095
                        return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1096
                                                      "values must be in range [-10,10]" );
 
1097
 
 
1098
        self->texture->cropxmin = crop[0];
 
1099
        self->texture->cropymin = crop[1];
 
1100
        self->texture->cropxmax = crop[2];
 
1101
        self->texture->cropymax = crop[3];
 
1102
 
 
1103
        Py_INCREF( Py_None );
 
1104
        return Py_None;
 
1105
}
 
1106
 
 
1107
 
 
1108
static PyObject *Texture_setExtend( BPy_Texture * self, PyObject * args )
 
1109
{
 
1110
        char *extend = NULL;
 
1111
        if( !PyArg_ParseTuple( args, "s", &extend ) )
 
1112
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1113
                                              "expected string argument" );
 
1114
 
 
1115
        if( !EXPP_map_getShortVal
 
1116
            ( tex_extend_map, extend, &self->texture->extend ) )
 
1117
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1118
                                              "invalid extend mode" );
 
1119
 
 
1120
        Py_INCREF( Py_None );
 
1121
        return Py_None;
 
1122
}
 
1123
 
 
1124
static PyObject *Texture_setIntExtend( BPy_Texture * self, PyObject * args )
 
1125
{
 
1126
        int extend = 0;
 
1127
        if( !PyArg_ParseTuple( args, "i", &extend ) )
 
1128
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1129
                                              "expected int argument" );
 
1130
 
 
1131
        if( extend < EXPP_TEX_EXTEND_MIN || extend > EXPP_TEX_EXTEND_MAX )
 
1132
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1133
                                              "invalid extend mode" );
 
1134
 
 
1135
        self->texture->extend = extend;
 
1136
 
 
1137
        Py_INCREF( Py_None );
 
1138
        return Py_None;
 
1139
}
 
1140
 
 
1141
static PyObject *Texture_setFieldsPerImage( BPy_Texture * self,
 
1142
                                            PyObject * args )
 
1143
{
 
1144
        int fie_ima;
 
1145
        if( !PyArg_ParseTuple( args, "i", &fie_ima ) )
 
1146
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1147
                                              "expected an int" );
 
1148
 
 
1149
        if( fie_ima < 1 || fie_ima > 200 )
 
1150
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1151
                                              "value must be in range [1,200]" );
 
1152
 
 
1153
        self->texture->fie_ima = fie_ima;
 
1154
 
 
1155
        Py_INCREF( Py_None );
 
1156
        return Py_None;
 
1157
}
 
1158
 
 
1159
static PyObject *Texture_setFilterSize( BPy_Texture * self, PyObject * args )
 
1160
{
 
1161
        float size;
 
1162
        if( !PyArg_ParseTuple( args, "f", &size ) )
 
1163
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1164
                                              "expected a float" );
 
1165
 
 
1166
        if( size < 0.1 || size > 25 )
 
1167
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1168
                                              "filter size must be in range [0.1,25]" );
 
1169
 
 
1170
        self->texture->filtersize = size;
 
1171
 
 
1172
        Py_INCREF( Py_None );
 
1173
        return Py_None;
 
1174
}
 
1175
 
 
1176
static PyObject *Texture_setFlags( BPy_Texture * self, PyObject * args )
 
1177
{
 
1178
        char *sf[3] = { NULL, NULL, NULL };
 
1179
        int i;
 
1180
        short flags = 0;
 
1181
        short thisflag;
 
1182
        if( !PyArg_ParseTuple( args, "|sss", &sf[0], &sf[1], &sf[2] ) )
 
1183
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1184
                                              "expected 0-3 string arguments" );
 
1185
 
 
1186
        for( i = 0; i < 3; ++i ) {
 
1187
                if( !sf[i] )
 
1188
                        break;
 
1189
 
 
1190
                if( !EXPP_map_getShortVal( tex_flag_map, sf[i], &thisflag ) )
 
1191
                        return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1192
                                                      "invalid texture flag name" );
 
1193
 
 
1194
                flags |= thisflag;
 
1195
        }
 
1196
 
 
1197
        self->texture->flag = flags;
 
1198
 
 
1199
        Py_INCREF( Py_None );
 
1200
        return Py_None;
 
1201
}
 
1202
 
 
1203
static PyObject *Texture_setIntFlags( BPy_Texture * self, PyObject * args )
 
1204
{
 
1205
        int flags = 0;
 
1206
        if( !PyArg_ParseTuple( args, "i", &flags ) )
 
1207
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1208
                                              "expected int argument" );
 
1209
 
 
1210
        self->texture->flag = flags;
 
1211
 
 
1212
        Py_INCREF( Py_None );
 
1213
        return Py_None;
 
1214
}
 
1215
 
 
1216
 
 
1217
static PyObject *Texture_setImage( BPy_Texture * self, PyObject * args )
 
1218
{
 
1219
        PyObject *pyimg;
 
1220
        Image *blimg = NULL;
 
1221
 
 
1222
        if( !PyArg_ParseTuple( args, "O!", &Image_Type, &pyimg ) )
 
1223
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1224
                                              "expected an Image" );
 
1225
        blimg = Image_FromPyObject( pyimg );
 
1226
 
 
1227
        if( self->texture->ima ) {
 
1228
                self->texture->ima->id.us--;
 
1229
        }
 
1230
 
 
1231
        self->texture->ima = blimg;
 
1232
        id_us_plus( &blimg->id );
 
1233
 
 
1234
        Py_INCREF( Py_None );
 
1235
        return Py_None;
 
1236
}
 
1237
 
 
1238
 
 
1239
static PyObject *Texture_setImageFlags( BPy_Texture * self, PyObject * args )
 
1240
{
 
1241
        char *sf[9] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
 
1242
        int i;
 
1243
        short flags = 0;
 
1244
        short thisflag;
 
1245
        if( !PyArg_ParseTuple
 
1246
            ( args, "|sssssssss", &sf[0], &sf[1], &sf[2], &sf[3], &sf[4],
 
1247
              &sf[5], &sf[6], &sf[7], &sf[8] ) )
 
1248
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1249
                                              "expected 0-9 string arguments" );
 
1250
 
 
1251
        for( i = 0; i < 9; ++i ) {
 
1252
                if( !sf[i] )
 
1253
                        break;
 
1254
 
 
1255
                if( !EXPP_map_getShortVal
 
1256
                    ( tex_imageflag_map, sf[i], &thisflag ) )
 
1257
                        return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1258
                                                      "invalid texture image flag name" );
 
1259
 
 
1260
                flags |= thisflag;
 
1261
        }
 
1262
 
 
1263
        /* MIPMAP and FIELDS can't be used together */
 
1264
        if( ( flags & EXPP_TEX_IMAGEFLAG_MIPMAP ) &&
 
1265
            ( flags & EXPP_TEX_IMAGEFLAG_FIELDS ) )
 
1266
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1267
                                              "image flags MIPMAP and FIELDS cannot be used together" );
 
1268
 
 
1269
        self->texture->imaflag = flags;
 
1270
 
 
1271
        Py_INCREF( Py_None );
 
1272
        return Py_None;
 
1273
}
 
1274
 
 
1275
static PyObject *Texture_setIntImageFlags( BPy_Texture * self,
 
1276
                                           PyObject * args )
 
1277
{
 
1278
        int flags = 0;
 
1279
        if( !PyArg_ParseTuple( args, "i", &flags ) )
 
1280
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1281
                                              "expected int argument" );
 
1282
 
 
1283
        /* MIPMAP and FIELDS can't be used together */
 
1284
        if( ( flags & EXPP_TEX_IMAGEFLAG_MIPMAP ) &&
 
1285
            ( flags & EXPP_TEX_IMAGEFLAG_FIELDS ) )
 
1286
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1287
                                              "image flags MIPMAP and FIELDS cannot be used together" );
 
1288
 
 
1289
        self->texture->imaflag = flags;
 
1290
 
 
1291
        Py_INCREF( Py_None );
 
1292
        return Py_None;
 
1293
}
 
1294
 
 
1295
static PyObject *Texture_setName( BPy_Texture * self, PyObject * args )
 
1296
{
 
1297
        char *name;
 
1298
        char buf[21];
 
1299
 
 
1300
        if( !PyArg_ParseTuple( args, "s", &name ) )
 
1301
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1302
                                              "expected string argument" );
 
1303
 
 
1304
        PyOS_snprintf( buf, sizeof( buf ), "%s", name );
 
1305
        rename_id( &self->texture->id, buf );
 
1306
 
 
1307
        Py_INCREF( Py_None );
 
1308
        return Py_None;
 
1309
}
 
1310
 
 
1311
static PyObject *Texture_setNoiseDepth( BPy_Texture * self, PyObject * args )
 
1312
{
 
1313
        int depth;
 
1314
        if( !PyArg_ParseTuple( args, "i", &depth ) )
 
1315
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1316
                                              "expected an int" );
 
1317
 
 
1318
        if( depth < 0 || depth > 6 )
 
1319
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1320
                                              "value must be in range [0,6]" );
 
1321
 
 
1322
        self->texture->noisedepth = depth;
 
1323
 
 
1324
        Py_INCREF( Py_None );
 
1325
        return Py_None;
 
1326
}
 
1327
 
 
1328
static PyObject *Texture_setNoiseSize( BPy_Texture * self, PyObject * args )
 
1329
{
 
1330
        float size;
 
1331
        if( !PyArg_ParseTuple( args, "f", &size ) )
 
1332
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1333
                                              "expected a float" );
 
1334
 
 
1335
        if( size < 0 || size > 2 )
 
1336
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1337
                                              "noise size must be in range [0,2]" );
 
1338
 
 
1339
        self->texture->noisesize = size;
 
1340
 
 
1341
        Py_INCREF( Py_None );
 
1342
        return Py_None;
 
1343
}
 
1344
 
 
1345
static PyObject *Texture_setNoiseType( BPy_Texture * self, PyObject * args )
 
1346
{
 
1347
        char *type;
 
1348
 
 
1349
        if( !PyArg_ParseTuple( args, "s", &type ) )
 
1350
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1351
                                              "expected string argument" );
 
1352
 
 
1353
        if( STREQ( type, "soft" ) )
 
1354
                self->texture->noisetype = TEX_NOISESOFT;
 
1355
        else if( STREQ( type, "hard" ) )
 
1356
                self->texture->noisetype = TEX_NOISEPERL;
 
1357
 
 
1358
        else
 
1359
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1360
                                              "noise type must be 'soft' or 'hard'" );
 
1361
 
 
1362
        Py_INCREF( Py_None );
 
1363
        return Py_None;
 
1364
}
 
1365
 
 
1366
static PyObject *Texture_setNoiseBasis( BPy_Texture * self, PyObject * args )
 
1367
{
 
1368
        char *nbasis;
 
1369
 
 
1370
        if( !PyArg_ParseTuple( args, "s", &nbasis ) )
 
1371
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1372
                                              "expected string argument" );
 
1373
        if( self->texture->type == EXPP_TEX_TYPE_MUSGRAVE &&
 
1374
            EXPP_map_getShortVal( tex_stype_map[EXPP_TEX_TYPE_DISTNOISE],
 
1375
                                  nbasis, &self->texture->noisebasis ) );
 
1376
        else if( self->texture->type == EXPP_TEX_TYPE_DISTNOISE &&
 
1377
                 !EXPP_map_getShortVal( tex_stype_map[EXPP_TEX_TYPE_DISTNOISE],
 
1378
                                        nbasis, &self->texture->noisebasis2 ) )
 
1379
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1380
                                              "invalid noise basis" );
 
1381
 
 
1382
        Py_INCREF( Py_None );
 
1383
        return Py_None;
 
1384
}
 
1385
 
 
1386
/* Distorted Noise */
 
1387
static PyObject *Texture_setDistNoise( BPy_Texture * self, PyObject * args )
 
1388
{
 
1389
        char *nbasis;
 
1390
 
 
1391
        if( !PyArg_ParseTuple( args, "s", &nbasis ) )
 
1392
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1393
                                              "expected string argument" );
 
1394
        if( self->texture->type == EXPP_TEX_TYPE_DISTNOISE &&
 
1395
            !EXPP_map_getShortVal( tex_stype_map[EXPP_TEX_TYPE_DISTNOISE],
 
1396
                                   nbasis, &self->texture->noisebasis ) )
 
1397
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1398
                                              "invalid noise basis" );
 
1399
 
 
1400
        Py_INCREF( Py_None );
 
1401
        return Py_None;
 
1402
}
 
1403
 
 
1404
static PyObject *Texture_setRepeat( BPy_Texture * self, PyObject * args )
 
1405
{
 
1406
        int repeat[2];
 
1407
        int i;
 
1408
        if( !PyArg_ParseTuple( args, "(ii)", &repeat[0], &repeat[1] ) )
 
1409
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1410
                                              "expected tuple of 2 ints" );
 
1411
 
 
1412
        for( i = 0; i < 2; ++i )
 
1413
                if( repeat[i] < 1 || repeat[i] > 512 )
 
1414
                        return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1415
                                                      "values must be in range [1,512]" );
 
1416
 
 
1417
        self->texture->xrepeat = repeat[0];
 
1418
        self->texture->yrepeat = repeat[1];
 
1419
 
 
1420
        Py_INCREF( Py_None );
 
1421
        return Py_None;
 
1422
}
 
1423
 
 
1424
static PyObject *Texture_setRGBCol( BPy_Texture * self, PyObject * args )
 
1425
{
 
1426
        float rgb[3];
 
1427
        int i;
 
1428
        if( !PyArg_ParseTuple( args, "(fff)", &rgb[0], &rgb[1], &rgb[2] ) )
 
1429
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1430
                                              "expected tuple of 3 floats" );
 
1431
 
 
1432
        for( i = 0; i < 3; ++i )
 
1433
                if( rgb[i] < 0 || rgb[i] > 2 )
 
1434
                        return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1435
                                                      "values must be in range [0,2]" );
 
1436
 
 
1437
        self->texture->rfac = rgb[0];
 
1438
        self->texture->gfac = rgb[1];
 
1439
        self->texture->bfac = rgb[2];
 
1440
 
 
1441
        Py_INCREF( Py_None );
 
1442
        return Py_None;
 
1443
}
 
1444
 
 
1445
 
 
1446
static PyObject *Texture_setSType( BPy_Texture * self, PyObject * args )
 
1447
{
 
1448
        char *stype = NULL;
 
1449
        if( !PyArg_ParseTuple( args, "s", &stype ) )
 
1450
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1451
                                              "expected string argument" );
 
1452
 
 
1453
        /* can we really trust texture->type? */
 
1454
        if( ( self->texture->type == EXPP_TEX_TYPE_VORONOI &&
 
1455
              EXPP_map_getShortVal( tex_stype_map[self->texture->type],
 
1456
                                    stype, &self->texture->vn_coltype ) ) );
 
1457
        else if( ( self->texture->type == EXPP_TEX_TYPE_MUSGRAVE &&
 
1458
                   EXPP_map_getShortVal( tex_stype_map
 
1459
                                         [EXPP_TEX_TYPE_DISTNOISE], stype,
 
1460
                                         &self->texture->noisebasis ) ) );
 
1461
        else if( ( self->texture->type == EXPP_TEX_TYPE_ENVMAP &&
 
1462
              EXPP_map_getShortVal( tex_stype_map[self->texture->type],
 
1463
                                    stype, &self->texture->env->stype ) ) );
 
1464
        else if( !EXPP_map_getShortVal
 
1465
                 ( tex_stype_map[self->texture->type], stype,
 
1466
                   &self->texture->stype ) )
 
1467
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1468
                                              "invalid texture stype" );
 
1469
 
 
1470
        Py_INCREF( Py_None );
 
1471
        return Py_None;
 
1472
}
 
1473
 
 
1474
static PyObject *Texture_setIntSType( BPy_Texture * self, PyObject * args )
 
1475
{
 
1476
        int stype = 0;
 
1477
        const char *dummy = NULL;
 
1478
        if( !PyArg_ParseTuple( args, "i", &stype ) )
 
1479
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1480
                                              "expected int argument" );
 
1481
 
 
1482
        /* use the stype map to find out if this is a valid stype for this type *
 
1483
         * note that this will allow CLD_COLOR when type is ENVMAP. there's not *
 
1484
         * much that we can do about this though.                               */
 
1485
        if( !EXPP_map_getStrVal
 
1486
            ( tex_stype_map[self->texture->type], stype, &dummy ) )
 
1487
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1488
                                              "invalid stype (for this type)" );
 
1489
 
 
1490
        if( self->texture->type == EXPP_TEX_TYPE_ENVMAP )
 
1491
                self->texture->env->stype = stype;
 
1492
        else
 
1493
                self->texture->stype = stype;
 
1494
 
 
1495
        Py_INCREF( Py_None );
 
1496
        return Py_None;
 
1497
}
 
1498
 
 
1499
static PyObject *Texture_setTurbulence( BPy_Texture * self, PyObject * args )
 
1500
{
 
1501
        float turb;
 
1502
        if( !PyArg_ParseTuple( args, "f", &turb ) )
 
1503
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1504
                                              "expected a float" );
 
1505
 
 
1506
        if( turb < 0 || turb > 200 )
 
1507
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1508
                                              "turbulence must be in range [0,200]" );
 
1509
 
 
1510
        self->texture->turbul = turb;
 
1511
 
 
1512
        Py_INCREF( Py_None );
 
1513
        return Py_None;
 
1514
}
 
1515
 
 
1516
static PyObject *Texture_setType( BPy_Texture * self, PyObject * args )
 
1517
{
 
1518
        char *type = NULL;
 
1519
        if( !PyArg_ParseTuple( args, "s", &type ) )
 
1520
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1521
                                              "expected string argument" );
 
1522
 
 
1523
        if( !EXPP_map_getShortVal( tex_type_map, type, &self->texture->type ) )
 
1524
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1525
                                              "invalid texture type" );
 
1526
 
 
1527
        Py_INCREF( Py_None );
 
1528
        return Py_None;
 
1529
}
 
1530
 
 
1531
 
 
1532
static PyObject *Texture_setHFrac( BPy_Texture * self, PyObject * args )
 
1533
{
 
1534
        float mg_H;
 
1535
        if( !PyArg_ParseTuple( args, "f", &mg_H ) )
 
1536
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1537
                                              "expected a float" );
 
1538
 
 
1539
        if( mg_H < 0 || mg_H > 2 )
 
1540
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1541
                                              "turbulence must be in range [0,2]" );
 
1542
 
 
1543
        self->texture->mg_H = mg_H;
 
1544
 
 
1545
        Py_INCREF( Py_None );
 
1546
        return Py_None;
 
1547
}
 
1548
 
 
1549
static PyObject *Texture_setLacunarity( BPy_Texture * self, PyObject * args )
 
1550
{
 
1551
        float mg_lac;
 
1552
        if( !PyArg_ParseTuple( args, "f", &mg_lac ) )
 
1553
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1554
                                              "expected a float" );
 
1555
 
 
1556
        if( mg_lac < 0 || mg_lac > 6 )
 
1557
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1558
                                              "lacunarity must be in range [0,6]" );
 
1559
 
 
1560
        self->texture->mg_lacunarity = mg_lac;
 
1561
 
 
1562
        Py_INCREF( Py_None );
 
1563
        return Py_None;
 
1564
}
 
1565
 
 
1566
static PyObject *Texture_setOcts( BPy_Texture * self, PyObject * args )
 
1567
{
 
1568
        float mg_oct;
 
1569
        if( !PyArg_ParseTuple( args, "f", &mg_oct ) )
 
1570
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1571
                                              "expected a float" );
 
1572
 
 
1573
        if( mg_oct < 0 || mg_oct > 8 )
 
1574
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1575
                                              "turbulence must be in range [0,8]" );
 
1576
 
 
1577
        self->texture->mg_octaves = mg_oct;
 
1578
 
 
1579
        Py_INCREF( Py_None );
 
1580
        return Py_None;
 
1581
}
 
1582
 
 
1583
static PyObject *Texture_setiScale( BPy_Texture * self, PyObject * args )
 
1584
{
 
1585
        float ns_osc;
 
1586
        if( !PyArg_ParseTuple( args, "f", &ns_osc ) )
 
1587
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1588
                                              "expected a float" );
 
1589
 
 
1590
        if( ns_osc < 0 || ns_osc > 10 )
 
1591
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1592
                                              "turbulence must be in range [0,10]" );
 
1593
 
 
1594
        self->texture->ns_outscale = ns_osc;
 
1595
 
 
1596
        Py_INCREF( Py_None );
 
1597
        return Py_None;
 
1598
}
 
1599
 
 
1600
static PyObject *Texture_setIntType( BPy_Texture * self, PyObject * args )
 
1601
{
 
1602
        int type = 0;
 
1603
        if( !PyArg_ParseTuple( args, "i", &type ) )
 
1604
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1605
                                              "expected int argument" );
 
1606
 
 
1607
        if( type < EXPP_TEX_TYPE_MIN || type > EXPP_TEX_TYPE_MAX )
 
1608
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1609
                                              "invalid type number" );
 
1610
 
 
1611
        self->texture->type = type;
 
1612
 
 
1613
        Py_INCREF( Py_None );
 
1614
        return Py_None;
 
1615
}
 
1616
 
 
1617
static PyObject *Texture_setDistMetric( BPy_Texture * self, PyObject * args )
 
1618
{
 
1619
        char *dist = NULL;
 
1620
 
 
1621
        if( !PyArg_ParseTuple( args, "s", &dist ) )
 
1622
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1623
                                              "expected string argument" );
 
1624
        /* can we really trust texture->type? */
 
1625
        if( self->texture->type == EXPP_TEX_TYPE_VORONOI &&
 
1626
            !EXPP_map_getShortVal( tex_stype_map[self->texture->type + 2],
 
1627
                                   dist, &self->texture->vn_distm ) )
 
1628
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1629
                                              "invalid dist metric type" );
 
1630
 
 
1631
        Py_INCREF( Py_None );
 
1632
        return Py_None;
 
1633
}
 
1634
 
 
1635
static PyObject *Texture_setExp( BPy_Texture * self, PyObject * args )
 
1636
{
 
1637
        float vn_mexp;
 
1638
        if( !PyArg_ParseTuple( args, "f", &vn_mexp ) )
 
1639
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1640
                                              "expected a float" );
 
1641
 
 
1642
        if( vn_mexp < 0 || vn_mexp > 10 )
 
1643
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1644
                                              "Exp  must be in range [0,10]" );
 
1645
 
 
1646
        self->texture->vn_mexp = vn_mexp;
 
1647
 
 
1648
        Py_INCREF( Py_None );
 
1649
        return Py_None;
 
1650
}
 
1651
 
 
1652
static PyObject *Texture_setW1( BPy_Texture * self, PyObject * args )
 
1653
{
 
1654
        float vn_w1;
 
1655
        if( !PyArg_ParseTuple( args, "f", &vn_w1 ) )
 
1656
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1657
                                              "expected a float" );
 
1658
 
 
1659
        if( vn_w1 < -2 || vn_w1 > 2 )
 
1660
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1661
                                              "Exp  must be in range [0,10]" );
 
1662
 
 
1663
        self->texture->vn_w1 = vn_w1;
 
1664
 
 
1665
        Py_INCREF( Py_None );
 
1666
        return Py_None;
 
1667
}
 
1668
 
 
1669
static PyObject *Texture_setW2( BPy_Texture * self, PyObject * args )
 
1670
{
 
1671
        float vn_w2;
 
1672
        if( !PyArg_ParseTuple( args, "f", &vn_w2 ) )
 
1673
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1674
                                              "expected a float" );
 
1675
 
 
1676
        if( vn_w2 < -2 || vn_w2 > 2 )
 
1677
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1678
                                              "Exp  must be in range [0,10]" );
 
1679
 
 
1680
        self->texture->vn_w2 = vn_w2;
 
1681
 
 
1682
        Py_INCREF( Py_None );
 
1683
        return Py_None;
 
1684
}
 
1685
 
 
1686
static PyObject *Texture_setW3( BPy_Texture * self, PyObject * args )
 
1687
{
 
1688
        float vn_w3;
 
1689
        if( !PyArg_ParseTuple( args, "f", &vn_w3 ) )
 
1690
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1691
                                              "expected a float" );
 
1692
 
 
1693
        if( vn_w3 < -2 || vn_w3 > 2 )
 
1694
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1695
                                              "Exp  must be in range [0,10]" );
 
1696
 
 
1697
        self->texture->vn_w3 = vn_w3;
 
1698
 
 
1699
        Py_INCREF( Py_None );
 
1700
        return Py_None;
 
1701
}
 
1702
 
 
1703
static PyObject *Texture_setW4( BPy_Texture * self, PyObject * args )
 
1704
{
 
1705
        float vn_w4;
 
1706
        if( !PyArg_ParseTuple( args, "f", &vn_w4 ) )
 
1707
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1708
                                              "expected a float" );
 
1709
 
 
1710
        if( vn_w4 < -2 || vn_w4 > 2 )
 
1711
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1712
                                              "Exp  must be in range [0,10]" );
 
1713
 
 
1714
        self->texture->vn_w4 = vn_w4;
 
1715
 
 
1716
        Py_INCREF( Py_None );
 
1717
        return Py_None;
 
1718
}
 
1719
 
 
1720
static PyObject *Texture_setDistAmnt( BPy_Texture * self, PyObject * args )
 
1721
{
 
1722
        float dist_amount;
 
1723
        if( !PyArg_ParseTuple( args, "f", &dist_amount ) )
 
1724
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1725
                                              "expected a float" );
 
1726
 
 
1727
        if( dist_amount < 0 || dist_amount > 10 )
 
1728
                return EXPP_ReturnPyObjError( PyExc_ValueError,
 
1729
                                              "Exp  must be in range [0,10]" );
 
1730
 
 
1731
        self->texture->dist_amount = dist_amount;
 
1732
 
 
1733
        Py_INCREF( Py_None );
 
1734
        return Py_None;
 
1735
}
 
1736
 
 
1737
static void Texture_dealloc( BPy_Texture * self )
 
1738
{
 
1739
        PyObject_DEL( self );
 
1740
}
 
1741
 
 
1742
static PyObject *Texture_getAttr( BPy_Texture * self, char *name )
 
1743
{
 
1744
        PyObject *attr = Py_None;
 
1745
        Tex *tex = self->texture;
 
1746
 
 
1747
        if( STREQ( name, "animFrames" ) )
 
1748
                attr = PyInt_FromLong( tex->frames );
 
1749
        else if( STREQ( name, "animLength" ) )
 
1750
                attr = PyInt_FromLong( tex->len );
 
1751
        else if( STREQ( name, "animMontage" ) )
 
1752
                attr = Py_BuildValue( "((i,i),(i,i),(i,i),(i,i))",
 
1753
                                      tex->fradur[0][0], tex->fradur[0][1],
 
1754
                                      tex->fradur[1][0], tex->fradur[1][1],
 
1755
                                      tex->fradur[2][0], tex->fradur[2][1],
 
1756
                                      tex->fradur[3][0], tex->fradur[3][1] );
 
1757
        else if( STREQ( name, "animOffset" ) )
 
1758
                attr = PyInt_FromLong( tex->offset );
 
1759
        else if( STREQ( name, "animStart" ) )
 
1760
                attr = PyInt_FromLong( tex->sfra );
 
1761
        else if( STREQ( name, "brightness" ) )
 
1762
                attr = PyFloat_FromDouble( tex->bright );
 
1763
        else if( STREQ( name, "contrast" ) )
 
1764
                attr = PyFloat_FromDouble( tex->contrast );
 
1765
        else if( STREQ( name, "crop" ) )
 
1766
                attr = Py_BuildValue( "(f,f,f,f)", tex->cropxmin,
 
1767
                                      tex->cropymin, tex->cropxmax,
 
1768
                                      tex->cropymax );
 
1769
        else if( STREQ( name, "extend" ) )
 
1770
                attr = PyInt_FromLong( tex->extend );
 
1771
        else if( STREQ( name, "fieldsPerImage" ) )
 
1772
                attr = PyInt_FromLong( tex->fie_ima );
 
1773
        else if( STREQ( name, "filterSize" ) )
 
1774
                attr = PyFloat_FromDouble( tex->filtersize );
 
1775
        else if( STREQ( name, "flags" ) )
 
1776
                attr = PyInt_FromLong( tex->flag );
 
1777
        else if( STREQ( name, "image" ) )
 
1778
                attr = Texture_getImage( self );
 
1779
        else if( STREQ( name, "imageFlags" ) )
 
1780
                attr = PyInt_FromLong( tex->imaflag );
 
1781
        else if( STREQ( name, "name" ) )
 
1782
                attr = PyString_FromString( tex->id.name + 2 );
 
1783
        else if( STREQ( name, "noiseDepth" ) )
 
1784
                attr = PyInt_FromLong( tex->noisedepth );
 
1785
        else if( STREQ( name, "noiseSize" ) )
 
1786
                attr = PyFloat_FromDouble( tex->noisesize );
 
1787
        else if( STREQ( name, "noiseType" ) ) {
 
1788
                if( tex->noisetype == TEX_NOISESOFT )
 
1789
                        attr = PyString_FromString( "soft" );
 
1790
                else
 
1791
                        attr = PyString_FromString( "hard" );
 
1792
        } else if( STREQ( name, "repeat" ) )
 
1793
                attr = Py_BuildValue( "(i,i)", tex->xrepeat, tex->yrepeat );
 
1794
        else if( STREQ( name, "rgbCol" ) )
 
1795
                attr = Py_BuildValue( "(f,f,f)", tex->rfac, tex->gfac,
 
1796
                                      tex->gfac );
 
1797
        else if( STREQ( name, "stype" ) )
 
1798
                if( self->texture->type == EXPP_TEX_TYPE_ENVMAP )
 
1799
                        attr = PyInt_FromLong( tex->env->stype );
 
1800
                else
 
1801
                        attr = PyInt_FromLong( tex->stype );
 
1802
        else if( STREQ( name, "turbulence" ) )
 
1803
                attr = PyFloat_FromDouble( tex->turbul );
 
1804
        else if( STREQ( name, "type" ) )
 
1805
                attr = PyInt_FromLong( tex->type );
 
1806
        else if( STREQ( name, "hFracDim" ) )
 
1807
                attr = PyInt_FromLong( tex->mg_H );
 
1808
        else if( STREQ( name, "lacunarity" ) )
 
1809
                attr = PyFloat_FromDouble( tex->mg_lacunarity );
 
1810
        else if( STREQ( name, "octs" ) )
 
1811
                attr = PyFloat_FromDouble( tex->mg_octaves );
 
1812
        else if( STREQ( name, "iSacale" ) )
 
1813
                attr = PyFloat_FromDouble( tex->ns_outscale );
 
1814
        else if( STREQ( name, "exp" ) )
 
1815
                attr = PyFloat_FromDouble( tex->vn_mexp );
 
1816
        else if( STREQ( name, "weight1" ) )
 
1817
                attr = PyFloat_FromDouble( tex->vn_w1 );
 
1818
        else if( STREQ( name, "weight2" ) )
 
1819
                attr = PyFloat_FromDouble( tex->vn_w2 );
 
1820
        else if( STREQ( name, "weight3" ) )
 
1821
                attr = PyFloat_FromDouble( tex->vn_w3 );
 
1822
        else if( STREQ( name, "weight4" ) )
 
1823
                attr = PyFloat_FromDouble( tex->vn_w4 );
 
1824
        else if( STREQ( name, "distAmnt" ) )
 
1825
                attr = PyFloat_FromDouble( tex->vn_w4 );
 
1826
        else if( STREQ( name, "users" ) )
 
1827
                attr = PyInt_FromLong( tex->id.us );    
 
1828
 
 
1829
        else if( STREQ( name, "__members__" ) )
 
1830
                attr = Py_BuildValue
 
1831
                        ( "[s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s]",
 
1832
                          "animFrames", "animLength", "animMontage",
 
1833
                          "animOffset", "animStart", "brightness", "contrast",
 
1834
                          "crop", "extend", "fieldsPerImage", "filterSize",
 
1835
                          "flags", "image", "imageFlags", "name", "noiseDepth",
 
1836
                          "noiseSize", "noiseType", "repeat", "rgbCol",
 
1837
                          "stype", "turbulence", "type", "hFracDim",
 
1838
                          "lacunarity", "octs", "iScale", "exp", "weight1",
 
1839
                          "weight2", "weight3", "weight4", "distAmnt", "users" );
 
1840
 
 
1841
        if( !attr )
 
1842
                return EXPP_ReturnPyObjError( PyExc_MemoryError,
 
1843
                                              "couldn't create PyObject" );
 
1844
 
 
1845
        if( attr != Py_None )
 
1846
                return attr;    /* member attribute found, return it */
 
1847
 
 
1848
        /* not an attribute, search the methods table */
 
1849
        return Py_FindMethod( BPy_Texture_methods, ( PyObject * ) self, name );
 
1850
}
 
1851
 
 
1852
 
 
1853
static int Texture_setAttr( BPy_Texture * self, char *name, PyObject * value )
 
1854
{
 
1855
        PyObject *valtuple;
 
1856
        PyObject *error = NULL;
 
1857
 
 
1858
        /* Put "value" in a tuple, because we want to pass it to functions  *
 
1859
         * that only accept PyTuples.                                       */
 
1860
        valtuple = Py_BuildValue( "(O)", value );
 
1861
        if( !valtuple )
 
1862
                return EXPP_ReturnIntError( PyExc_MemoryError,
 
1863
                                            "Texture_setAttr: couldn't create PyTuple" );
 
1864
 
 
1865
        if( STREQ( name, "animFrames" ) )
 
1866
                error = Texture_setAnimFrames( self, valtuple );
 
1867
        else if( STREQ( name, "animLength" ) )
 
1868
                error = Texture_setAnimLength( self, valtuple );
 
1869
        else if( STREQ( name, "animMontage" ) )
 
1870
                error = Texture_setAnimMontage( self, valtuple );
 
1871
        else if( STREQ( name, "animOffset" ) )
 
1872
                error = Texture_setAnimOffset( self, valtuple );
 
1873
        else if( STREQ( name, "animStart" ) )
 
1874
                error = Texture_setAnimStart( self, valtuple );
 
1875
        else if( STREQ( name, "brightness" ) )
 
1876
                error = Texture_setBrightness( self, valtuple );
 
1877
        else if( STREQ( name, "contrast" ) )
 
1878
                error = Texture_setContrast( self, valtuple );
 
1879
        else if( STREQ( name, "crop" ) )
 
1880
                error = Texture_setCrop( self, valtuple );
 
1881
        else if( STREQ( name, "extend" ) )
 
1882
                error = Texture_setIntExtend( self, valtuple );
 
1883
        else if( STREQ( name, "fieldsPerImage" ) )
 
1884
                error = Texture_setFieldsPerImage( self, valtuple );
 
1885
        else if( STREQ( name, "filterSize" ) )
 
1886
                error = Texture_setFilterSize( self, valtuple );
 
1887
        else if( STREQ( name, "flags" ) )
 
1888
                error = Texture_setIntFlags( self, valtuple );
 
1889
        else if( STREQ( name, "image" ) )
 
1890
                error = Texture_setImage( self, valtuple );
 
1891
        else if( STREQ( name, "imageFlags" ) )
 
1892
                error = Texture_setIntImageFlags( self, valtuple );
 
1893
        else if( STREQ( name, "name" ) )
 
1894
                error = Texture_setName( self, valtuple );
 
1895
        else if( STREQ( name, "noiseDepth" ) )
 
1896
                error = Texture_setNoiseDepth( self, valtuple );
 
1897
        else if( STREQ( name, "noiseSize" ) )
 
1898
                error = Texture_setNoiseSize( self, valtuple );
 
1899
        else if( STREQ( name, "noiseType" ) )
 
1900
                error = Texture_setNoiseType( self, valtuple );
 
1901
        else if( STREQ( name, "repeat" ) )
 
1902
                error = Texture_setRepeat( self, valtuple );
 
1903
        else if( STREQ( name, "rgbCol" ) )
 
1904
                error = Texture_setRGBCol( self, valtuple );
 
1905
        else if( STREQ( name, "stype" ) )
 
1906
                error = Texture_setIntSType( self, valtuple );
 
1907
        else if( STREQ( name, "turbulence" ) )
 
1908
                error = Texture_setTurbulence( self, valtuple );
 
1909
        else if( STREQ( name, "type" ) )
 
1910
                error = Texture_setIntType( self, valtuple );
 
1911
        else if( STREQ( name, "hFracDim" ) )
 
1912
                error = Texture_setHFrac( self, valtuple );
 
1913
        else if( STREQ( name, "lacunarity" ) )
 
1914
                error = Texture_setLacunarity( self, valtuple );
 
1915
        else if( STREQ( name, "octs" ) )
 
1916
                error = Texture_setOcts( self, valtuple );
 
1917
        else if( STREQ( name, "iScale" ) )
 
1918
                error = Texture_setiScale( self, valtuple );
 
1919
        else if( STREQ( name, "exp" ) )
 
1920
                error = Texture_setExp( self, valtuple );
 
1921
        else if( STREQ( name, "weight1" ) )
 
1922
                error = Texture_setW1( self, valtuple );
 
1923
        else if( STREQ( name, "weight2" ) )
 
1924
                error = Texture_setW2( self, valtuple );
 
1925
        else if( STREQ( name, "weight3" ) )
 
1926
                error = Texture_setW3( self, valtuple );
 
1927
        else if( STREQ( name, "weight4" ) )
 
1928
                error = Texture_setW4( self, valtuple );
 
1929
        else if( STREQ( name, "distAmnt" ) )
 
1930
                error = Texture_setDistAmnt( self, valtuple );
 
1931
 
 
1932
 
 
1933
        else {
 
1934
                /* Error */
 
1935
                Py_DECREF( valtuple );
 
1936
                return EXPP_ReturnIntError( PyExc_KeyError,
 
1937
                                            "attribute not found" );
 
1938
        }
 
1939
 
 
1940
        Py_DECREF( valtuple );
 
1941
 
 
1942
        if( error != Py_None )
 
1943
                return -1;
 
1944
 
 
1945
        /* Py_None was INCREF'd by the set*() function, so we need to DECREF it */
 
1946
        Py_DECREF( Py_None );
 
1947
 
 
1948
        return 0;
 
1949
}
 
1950
 
 
1951
static int Texture_compare( BPy_Texture * a, BPy_Texture * b )
 
1952
{
 
1953
        return ( a->texture == b->texture ) ? 0 : -1;
 
1954
}
 
1955
 
 
1956
static PyObject *Texture_repr( BPy_Texture * self )
 
1957
{
 
1958
        return PyString_FromFormat( "[Texture \"%s\"]",
 
1959
                                    self->texture->id.name + 2 );
 
1960
}
 
1961
 
 
1962
static PyObject *Texture_getIpo( BPy_Texture * self )
 
1963
{
 
1964
        struct Ipo *ipo = self->texture->ipo;
 
1965
 
 
1966
        if( !ipo ) {
 
1967
                Py_INCREF( Py_None );
 
1968
                return Py_None;
 
1969
        }
 
1970
 
 
1971
        return Ipo_CreatePyObject( ipo );
 
1972
}
 
1973
 
 
1974
extern PyTypeObject Ipo_Type;
 
1975
 
 
1976
static PyObject *Texture_setIpo( BPy_Texture * self, PyObject * args )
 
1977
{
 
1978
        PyObject *pyipo = 0;
 
1979
        Ipo *ipo = NULL;
 
1980
        Ipo *oldipo;
 
1981
 
 
1982
        if( !PyArg_ParseTuple( args, "O!", &Ipo_Type, &pyipo ) )
 
1983
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1984
                                              "expected Ipo as argument" );
 
1985
 
 
1986
        ipo = Ipo_FromPyObject( pyipo );
 
1987
 
 
1988
        if( !ipo )
 
1989
                return EXPP_ReturnPyObjError( PyExc_RuntimeError,
 
1990
                                              "null ipo!" );
 
1991
 
 
1992
        if( ipo->blocktype != ID_TE )
 
1993
                return EXPP_ReturnPyObjError( PyExc_TypeError,
 
1994
                                              "this ipo is not a texture data ipo" );
 
1995
 
 
1996
        oldipo = self->texture->ipo;
 
1997
        if( oldipo ) {
 
1998
                ID *id = &oldipo->id;
 
1999
                if( id->us > 0 )
 
2000
                        id->us--;
 
2001
        }
 
2002
 
 
2003
        ( ( ID * ) & ipo->id )->us++;
 
2004
 
 
2005
        self->texture->ipo = ipo;
 
2006
 
 
2007
        Py_INCREF( Py_None );
 
2008
        return Py_None;
 
2009
}
 
2010
 
 
2011
static PyObject *Texture_clearIpo( BPy_Texture * self )
 
2012
{
 
2013
        Tex *tex = self->texture;
 
2014
        Ipo *ipo = ( Ipo * ) tex->ipo;
 
2015
 
 
2016
        if( ipo ) {
 
2017
                ID *id = &ipo->id;
 
2018
                if( id->us > 0 )
 
2019
                        id->us--;
 
2020
                tex->ipo = NULL;
 
2021
 
 
2022
                return EXPP_incr_ret_True();
 
2023
        }
 
2024
 
 
2025
        return EXPP_incr_ret_False(); /* no ipo found */
 
2026
}