patch-Texture3.c.txt
Public
Actions

Authored By

	Ken Hughes (khughes)
	Nov 13 2013, 1:07 PM

Size

37 KB

Subscribers

None

patch-Texture3.c.txt
View Options

	--- source/blender/python/api2_2x/Texture.c 2005-08-28 21:41:53.000000000 -0700
	+++ source/blender/python/api2_2x/Texture.c 2005-08-28 21:42:37.000000000 -0700
	@@ -1,5 +1,5 @@
	/*
	- * $Id: Texture.c,v 1.5 2005/08/29 03:46:48 khughes Exp $
	+ * $Id: Texture.c,v 1.7 2005/08/29 04:34:57 khughes Exp $
	*
	* *** BEGIN GPL/BL DUAL LICENSE BLOCK ***
	*
	@@ -46,27 +46,13 @@
	#include "render.h"
	#include "gen_utils.h"

	-
	/*****************************************************************************/
	/* Blender.Texture constants */
	/*****************************************************************************/
	#define EXPP_TEX_TYPE_NONE 0
	-#define EXPP_TEX_TYPE_CLOUDS TEX_CLOUDS
	-#define EXPP_TEX_TYPE_WOOD TEX_WOOD
	-#define EXPP_TEX_TYPE_MARBLE TEX_MARBLE
	-#define EXPP_TEX_TYPE_MAGIC TEX_MAGIC
	-#define EXPP_TEX_TYPE_BLEND TEX_BLEND
	-#define EXPP_TEX_TYPE_STUCCI TEX_STUCCI
	-#define EXPP_TEX_TYPE_NOISE TEX_NOISE
	-#define EXPP_TEX_TYPE_IMAGE TEX_IMAGE
	-#define EXPP_TEX_TYPE_PLUGIN TEX_PLUGIN
	-#define EXPP_TEX_TYPE_ENVMAP TEX_ENVMAP
	-#define EXPP_TEX_TYPE_MUSGRAVE TEX_MUSGRAVE
	-#define EXPP_TEX_TYPE_VORONOI TEX_VORONOI
	-#define EXPP_TEX_TYPE_DISTNOISE TEX_DISTNOISE

	#define EXPP_TEX_TYPE_MIN EXPP_TEX_TYPE_NONE
	-#define EXPP_TEX_TYPE_MAX EXPP_TEX_TYPE_DISTNOISE
	+#define EXPP_TEX_TYPE_MAX TEX_DISTNOISE

	#define EXPP_TEX_ANIMFRAME_MIN 0
	#define EXPP_TEX_ANIMFRAME_MAX ((int)MAXFRAMEF)
	@@ -126,28 +112,38 @@

	/* i can't find these defined anywhere- they're just taken from looking at */
	/* the button creation code in source/blender/src/buttons_shading.c */
	+/* cloud stype */
	#define EXPP_TEX_STYPE_CLD_DEFAULT 0
	#define EXPP_TEX_STYPE_CLD_COLOR 1
	+/* wood stype */
	#define EXPP_TEX_STYPE_WOD_BANDS 0
	#define EXPP_TEX_STYPE_WOD_RINGS 1
	#define EXPP_TEX_STYPE_WOD_BANDNOISE 2
	#define EXPP_TEX_STYPE_WOD_RINGNOISE 3
	+/* magic stype */
	#define EXPP_TEX_STYPE_MAG_DEFAULT 0
	+/* marble stype */
	#define EXPP_TEX_STYPE_MBL_SOFT 0
	#define EXPP_TEX_STYPE_MBL_SHARP 1
	#define EXPP_TEX_STYPE_MBL_SHARPER 2
	+/* blend stype */
	#define EXPP_TEX_STYPE_BLN_LIN 0
	#define EXPP_TEX_STYPE_BLN_QUAD 1
	#define EXPP_TEX_STYPE_BLN_EASE 2
	#define EXPP_TEX_STYPE_BLN_DIAG 3
	#define EXPP_TEX_STYPE_BLN_SPHERE 4
	#define EXPP_TEX_STYPE_BLN_HALO 5
	+/* stucci stype */
	#define EXPP_TEX_STYPE_STC_PLASTIC 0
	#define EXPP_TEX_STYPE_STC_WALLIN 1
	#define EXPP_TEX_STYPE_STC_WALLOUT 2
	+/* noise stype */
	#define EXPP_TEX_STYPE_NSE_DEFAULT 0
	+/* image stype */
	#define EXPP_TEX_STYPE_IMG_DEFAULT 0
	+/* plug-in stype */
	#define EXPP_TEX_STYPE_PLG_DEFAULT 0
	+/* envmap stype */
	#define EXPP_TEX_STYPE_ENV_STATIC 0
	#define EXPP_TEX_STYPE_ENV_ANIM 1
	#define EXPP_TEX_STYPE_ENV_LOAD 2
	@@ -158,96 +154,18 @@
	#define EXPP_TEX_STYPE_MUS_FBM 3
	#define EXPP_TEX_STYPE_MUS_HTERRAIN 4
	/* voronoi stype */
	-#define EXPP_TEX_STYPE_VN_INT 0
	-#define EXPP_TEX_STYPE_VN_COL1 1
	-#define EXPP_TEX_STYPE_VN_COL2 2
	-#define EXPP_TEX_STYPE_VN_COL3 3
	-
	-#define EXPP_TEX_FLAG_COLORBAND TEX_COLORBAND
	-#define EXPP_TEX_FLAG_FLIPBLEND TEX_FLIPBLEND
	-#define EXPP_TEX_FLAG_NEGALPHA TEX_NEGALPHA
	-#define EXPP_TEX_FLAG_CHECKER_ODD TEX_CHECKER_ODD
	-#define EXPP_TEX_FLAG_CHECKER_EVEN TEX_CHECKER_EVEN
	-
	-#define EXPP_TEX_IMAGEFLAG_INTERPOL TEX_INTERPOL
	-#define EXPP_TEX_IMAGEFLAG_USEALPHA TEX_USEALPHA
	-#define EXPP_TEX_IMAGEFLAG_MIPMAP TEX_MIPMAP
	-#define EXPP_TEX_IMAGEFLAG_FIELDS TEX_FIELDS
	-#define EXPP_TEX_IMAGEFLAG_ROT90 TEX_IMAROT
	-#define EXPP_TEX_IMAGEFLAG_CALCALPHA TEX_CALCALPHA
	-#define EXPP_TEX_IMAGEFLAG_CYCLIC TEX_ANIMCYCLIC
	-#define EXPP_TEX_IMAGEFLAG_MOVIE TEX_ANIM5
	-#define EXPP_TEX_IMAGEFLAG_STFIELD TEX_STD_FIELD
	-#define EXPP_TEX_IMAGEFLAG_ANTI TEX_ANTIALI
	-#define EXPP_TEX_IMAGEFLAG_NORMALMAP TEX_NORMALMAP
	-
	-#define EXPP_TEX_EXTEND_EXTEND TEX_EXTEND
	-#define EXPP_TEX_EXTEND_CLIP TEX_CLIP
	-#define EXPP_TEX_EXTEND_REPEAT TEX_REPEAT
	-#define EXPP_TEX_EXTEND_CLIPCUBE TEX_CLIPCUBE
	-#define EXPP_TEX_EXTEND_CHECKER TEX_CHECKER
	-
	-#define EXPP_TEX_EXTEND_MIN EXPP_TEX_EXTEND_EXTEND
	-#define EXPP_TEX_EXTEND_MAX EXPP_TEX_EXTEND_CHECKER
	-
	-#define EXPP_TEX_TEXCO_ORCO TEXCO_ORCO
	-#define EXPP_TEX_TEXCO_REFL TEXCO_REFL
	-#define EXPP_TEX_TEXCO_NOR TEXCO_NORM
	-#define EXPP_TEX_TEXCO_GLOB TEXCO_GLOB
	-#define EXPP_TEX_TEXCO_UV TEXCO_UV
	-#define EXPP_TEX_TEXCO_OBJECT TEXCO_OBJECT
	-#define EXPP_TEX_TEXCO_WIN TEXCO_WINDOW
	-#define EXPP_TEX_TEXCO_VIEW TEXCO_VIEW
	-#define EXPP_TEX_TEXCO_STICK TEXCO_STICKY
	-
	-#define EXPP_TEX_MAPTO_COL MAP_COL
	-#define EXPP_TEX_MAPTO_NOR MAP_NORM
	-#define EXPP_TEX_MAPTO_CSP MAP_COLSPEC
	-#define EXPP_TEX_MAPTO_CMIR MAP_COLMIR
	-#define EXPP_TEX_MAPTO_REF MAP_REF
	-#define EXPP_TEX_MAPTO_SPEC MAP_SPEC
	-#define EXPP_TEX_MAPTO_HARD MAP_HAR
	-#define EXPP_TEX_MAPTO_ALPHA MAP_ALPHA
	-#define EXPP_TEX_MAPTO_EMIT MAP_EMIT
	-#define EXPP_TEX_MAPTO_RAYMIR MAP_RAYMIRR
	-#define EXPP_TEX_MAPTO_DISP MAP_DISPLACE
	-#define EXPP_TEX_MAPTO_TRANSLU MAP_TRANSLU
	-#define EXPP_TEX_MAPTO_AMB MAP_AMB
	-
	-#define EXPP_TEX_STYPE_DN_BLENDER TEX_BLENDER
	-#define EXPP_TEX_STYPE_DN_PERLIN TEX_STDPERLIN
	-#define EXPP_TEX_STYPE_DN_IMPROVEPERLIN TEX_NEWPERLIN
	-#define EXPP_TEX_STYPE_DN_VORONOIF1 TEX_VORONOI_F1
	-#define EXPP_TEX_STYPE_DN_VORONOIF2 TEX_VORONOI_F2
	-#define EXPP_TEX_STYPE_DN_VORONOIF3 TEX_VORONOI_F3
	-#define EXPP_TEX_STYPE_DN_VORONOIF4 TEX_VORONOI_F4
	-#define EXPP_TEX_STYPE_DN_VORONOIF2F1 TEX_VORONOI_F2F1
	-#define EXPP_TEX_STYPE_DN_VORONOICRACKLE TEX_VORONOI_CRACKLE
	-#define EXPP_TEX_STYPE_DN_CELLNOISE TEX_CELLNOISE
	-
	-#define EXPP_TEX_STYPE_VN_TEX_DISTANCE TEX_DISTANCE
	-#define EXPP_TEX_STYPE_VN_TEX_DISTANCE_SQUARED TEX_DISTANCE_SQUARED
	-#define EXPP_TEX_STYPE_VN_TEX_MANHATTAN TEX_MANHATTAN
	-#define EXPP_TEX_STYPE_VN_TEX_CHEBYCHEV TEX_CHEBYCHEV
	-#define EXPP_TEX_STYPE_VN_TEX_MINKOVSKY_HALF TEX_MINKOVSKY_HALF
	-#define EXPP_TEX_STYPE_VN_TEX_MINKOVSKY_FOUR TEX_MINKOVSKY_FOUR
	-#define EXPP_TEX_STYPE_VN_TEX_MINKOVSKY TEX_MINKOVSKY
	-
	-#define EXPP_TEX_NOISE_SINE 0
	-#define EXPP_TEX_NOISE_SAW 1
	-#define EXPP_TEX_NOISE_TRI 2
	-#define EXPP_TEX_NOISEBASIS2 0xffff
	-
	-#define EXPP_TEX_NOISE_BLENDER TEX_BLENDER
	-#define EXPP_TEX_NOISE_PERLIN TEX_STDPERLIN
	-#define EXPP_TEX_NOISE_IMPROVEPERLIN TEX_NEWPERLIN
	-#define EXPP_TEX_NOISE_VORONOIF1 TEX_VORONOI_F1
	-#define EXPP_TEX_NOISE_VORONOIF2 TEX_VORONOI_F2
	-#define EXPP_TEX_NOISE_VORONOIF3 TEX_VORONOI_F3
	-#define EXPP_TEX_NOISE_VORONOIF4 TEX_VORONOI_F4
	-#define EXPP_TEX_NOISE_VORONOIF2F1 TEX_VORONOI_F2F1
	-#define EXPP_TEX_NOISE_VORONOICRACKLE TEX_VORONOI_CRACKLE
	-#define EXPP_TEX_NOISE_CELLNOISE TEX_CELLNOISE
	+#define EXPP_TEX_STYPE_VN_INT 0
	+#define EXPP_TEX_STYPE_VN_COL1 1
	+#define EXPP_TEX_STYPE_VN_COL2 2
	+#define EXPP_TEX_STYPE_VN_COL3 3
	+
	+#define EXPP_TEX_EXTEND_MIN TEX_EXTEND
	+#define EXPP_TEX_EXTEND_MAX TEX_CHECKER
	+
	+#define EXPP_TEX_NOISE_SINE 0
	+#define EXPP_TEX_NOISE_SAW 1
	+#define EXPP_TEX_NOISE_TRI 2
	+#define EXPP_TEX_NOISEBASIS2 0xffff

	/****************************************************************************/
	/* Texture String->Int maps */
	@@ -255,56 +173,56 @@

	static const EXPP_map_pair tex_type_map[] = {
	{"None", EXPP_TEX_TYPE_NONE},
	- {"Clouds", EXPP_TEX_TYPE_CLOUDS},
	- {"Wood", EXPP_TEX_TYPE_WOOD},
	- {"Marble", EXPP_TEX_TYPE_MARBLE},
	- {"Magic", EXPP_TEX_TYPE_MAGIC},
	- {"Blend", EXPP_TEX_TYPE_BLEND},
	- {"Stucci", EXPP_TEX_TYPE_STUCCI},
	- {"Noise", EXPP_TEX_TYPE_NOISE},
	- {"Image", EXPP_TEX_TYPE_IMAGE},
	- {"Plugin", EXPP_TEX_TYPE_PLUGIN},
	- {"EnvMap", EXPP_TEX_TYPE_ENVMAP},
	- {"Musgrave", EXPP_TEX_TYPE_MUSGRAVE},
	- {"Voronoi", EXPP_TEX_TYPE_VORONOI},
	- {"DistortedNoise", EXPP_TEX_TYPE_DISTNOISE},
	+ {"Clouds", TEX_CLOUDS},
	+ {"Wood", TEX_WOOD},
	+ {"Marble", TEX_MARBLE},
	+ {"Magic", TEX_MAGIC},
	+ {"Blend", TEX_BLEND},
	+ {"Stucci", TEX_STUCCI},
	+ {"Noise", TEX_NOISE},
	+ {"Image", TEX_IMAGE},
	+ {"Plugin", TEX_PLUGIN},
	+ {"EnvMap", TEX_ENVMAP},
	+ {"Musgrave", TEX_MUSGRAVE},
	+ {"Voronoi", TEX_VORONOI},
	+ {"DistortedNoise", TEX_DISTNOISE},
	{NULL, 0}
	};

	static const EXPP_map_pair tex_flag_map[] = {
	/* NOTE "CheckerOdd" and "CheckerEven" are new */
	#if 0
	- {"ColorBand", EXPP_TEX_FLAG_COLORBAND },
	+ {"ColorBand", TEX_COLORBAND },
	#endif
	- {"FlipBlend", EXPP_TEX_FLAG_FLIPBLEND},
	- {"NegAlpha", EXPP_TEX_FLAG_NEGALPHA},
	- {"CheckerOdd",EXPP_TEX_FLAG_CHECKER_ODD},
	- {"CheckerEven",EXPP_TEX_FLAG_CHECKER_EVEN},
	+ {"FlipBlend", TEX_FLIPBLEND},
	+ {"NegAlpha", TEX_NEGALPHA},
	+ {"CheckerOdd",TEX_CHECKER_ODD},
	+ {"CheckerEven",TEX_CHECKER_EVEN},
	{NULL, 0}
	};

	static const EXPP_map_pair tex_imageflag_map[] = {
	- {"InterPol", EXPP_TEX_IMAGEFLAG_INTERPOL},
	- {"UseAlpha", EXPP_TEX_IMAGEFLAG_USEALPHA},
	- {"MipMap", EXPP_TEX_IMAGEFLAG_MIPMAP},
	- {"Fields", EXPP_TEX_IMAGEFLAG_FIELDS},
	- {"Rot90", EXPP_TEX_IMAGEFLAG_ROT90},
	- {"CalcAlpha", EXPP_TEX_IMAGEFLAG_CALCALPHA},
	- {"Cyclic", EXPP_TEX_IMAGEFLAG_CYCLIC},
	- {"Movie", EXPP_TEX_IMAGEFLAG_MOVIE},
	- {"StField", EXPP_TEX_IMAGEFLAG_STFIELD},
	- {"Anti", EXPP_TEX_IMAGEFLAG_ANTI},
	- {"NormalMap", EXPP_TEX_IMAGEFLAG_NORMALMAP},
	+ {"InterPol", TEX_INTERPOL},
	+ {"UseAlpha", TEX_USEALPHA},
	+ {"MipMap", TEX_MIPMAP},
	+ {"Fields", TEX_FIELDS},
	+ {"Rot90", TEX_IMAROT},
	+ {"CalcAlpha", TEX_CALCALPHA},
	+ {"Cyclic", TEX_ANIMCYCLIC},
	+ {"Movie", TEX_ANIM5},
	+ {"StField", TEX_STD_FIELD},
	+ {"Anti", TEX_ANTIALI},
	+ {"NormalMap", TEX_NORMALMAP},
	{NULL, 0}
	};

	static const EXPP_map_pair tex_extend_map[] = {
	- {"Extend", EXPP_TEX_EXTEND_EXTEND},
	- {"Clip", EXPP_TEX_EXTEND_CLIP},
	- {"ClipCube", EXPP_TEX_EXTEND_CLIPCUBE},
	- {"Repeat", EXPP_TEX_EXTEND_REPEAT},
	+ {"Extend", TEX_EXTEND},
	+ {"Clip", TEX_CLIP},
	+ {"ClipCube", TEX_CLIPCUBE},
	+ {"Repeat", TEX_REPEAT},
	/* NOTE "Checker" is new */
	- {"Checker", EXPP_TEX_EXTEND_CHECKER},
	+ {"Checker", TEX_CHECKER},
	{NULL, 0}
	};

	@@ -371,16 +289,16 @@

	static const EXPP_map_pair tex_stype_distortednoise_map[] = {
	{"Default", 0},
	- {"BlenderOriginal", EXPP_TEX_STYPE_DN_BLENDER},
	- {"OriginalPerlin", EXPP_TEX_STYPE_DN_PERLIN},
	- {"ImprovedPerlin", EXPP_TEX_STYPE_DN_IMPROVEPERLIN},
	- {"VoronoiF1", EXPP_TEX_STYPE_DN_VORONOIF1},
	- {"VoronoiF2", EXPP_TEX_STYPE_DN_VORONOIF2},
	- {"VoronoiF3", EXPP_TEX_STYPE_DN_VORONOIF3},
	- {"VoronoiF4", EXPP_TEX_STYPE_DN_VORONOIF4},
	- {"VoronoiF2-F1", EXPP_TEX_STYPE_DN_VORONOIF2F1},
	- {"VoronoiCrackle", EXPP_TEX_STYPE_DN_VORONOICRACKLE},
	- {"CellNoise", EXPP_TEX_STYPE_DN_CELLNOISE},
	+ {"BlenderOriginal", TEX_BLENDER},
	+ {"OriginalPerlin", TEX_STDPERLIN},
	+ {"ImprovedPerlin", TEX_NEWPERLIN},
	+ {"VoronoiF1", TEX_VORONOI_F1},
	+ {"VoronoiF2", TEX_VORONOI_F2},
	+ {"VoronoiF3", TEX_VORONOI_F3},
	+ {"VoronoiF4", TEX_VORONOI_F4},
	+ {"VoronoiF2-F1", TEX_VORONOI_F2F1},
	+ {"VoronoiCrackle", TEX_VORONOI_CRACKLE},
	+ {"CellNoise", TEX_CELLNOISE},
	{NULL, 0}
	};

	@@ -395,13 +313,13 @@

	static const EXPP_map_pair tex_distance_voronoi_map[] = {
	{"Default", 0},
	- {"Distance", EXPP_TEX_STYPE_VN_TEX_DISTANCE},
	- {"DistanceSquared", EXPP_TEX_STYPE_VN_TEX_DISTANCE_SQUARED},
	- {"Manhattan", EXPP_TEX_STYPE_VN_TEX_MANHATTAN},
	- {"Chebychev", EXPP_TEX_STYPE_VN_TEX_CHEBYCHEV},
	- {"MinkovskyHalf", EXPP_TEX_STYPE_VN_TEX_MINKOVSKY_HALF},
	- {"MinkovskyFour", EXPP_TEX_STYPE_VN_TEX_MINKOVSKY_FOUR},
	- {"Minkovsky", EXPP_TEX_STYPE_VN_TEX_MINKOVSKY},
	+ {"Distance", TEX_DISTANCE},
	+ {"DistanceSquared", TEX_DISTANCE_SQUARED},
	+ {"Manhattan", TEX_MANHATTAN},
	+ {"Chebychev", TEX_CHEBYCHEV},
	+ {"MinkovskyHalf", TEX_MINKOVSKY_HALF},
	+ {"MinkovskyFour", TEX_MINKOVSKY_FOUR},
	+ {"Minkovsky", TEX_MINKOVSKY},
	{NULL, 0}
	};

	@@ -787,47 +705,47 @@
	{"interpol",
	(getter)Texture_getImageFlags, (setter)Texture_setImageFlags,
	"Interpolate image's pixels to fit texture mapping enabled ('ImageFlags')",
	- (void *)EXPP_TEX_IMAGEFLAG_INTERPOL},
	+ (void *)TEX_INTERPOL},
	{"useAlpha",
	(getter)Texture_getImageFlags, (setter)Texture_setImageFlags,
	"Use of image's alpha channel enabled ('ImageFlags')",
	- (void *)EXPP_TEX_IMAGEFLAG_USEALPHA},
	+ (void *)TEX_USEALPHA},
	{"calcAlpha",
	(getter)Texture_getImageFlags, (setter)Texture_setImageFlags,
	"Calculation of image's alpha channel enabled ('ImageFlags')",
	- (void *)EXPP_TEX_IMAGEFLAG_CALCALPHA},
	+ (void *)TEX_CALCALPHA},
	{"mipmap",
	(getter)Texture_getImageFlags, (setter)Texture_setImageFlags,
	"Mipmaps enabled ('ImageFlags')",
	- (void *)EXPP_TEX_IMAGEFLAG_MIPMAP},
	+ (void *)TEX_MIPMAP},
	{"fields",
	(getter)Texture_getImageFlags, (setter)Texture_setImageFlags,
	"Use of image's fields enabled ('ImageFlags')",
	- (void *)EXPP_TEX_IMAGEFLAG_FIELDS},
	+ (void *)TEX_FIELDS},
	{"rot90",
	(getter)Texture_getImageFlags, (setter)Texture_setImageFlags,
	"X/Y flip for rendering enabled ('ImageFlags')",
	- (void *)EXPP_TEX_IMAGEFLAG_ROT90},
	+ (void *)TEX_IMAROT},
	{"cyclic",
	(getter)Texture_getImageFlags, (setter)Texture_setImageFlags,
	"Looping of animated frames enabled ('ImageFlags')",
	- (void *)EXPP_TEX_IMAGEFLAG_CYCLIC},
	+ (void *)TEX_ANIMCYCLIC},
	{"movie",
	(getter)Texture_getImageFlags, (setter)Texture_setImageFlags,
	"Movie frames as images enabled ('ImageFlags')",
	- (void *)EXPP_TEX_IMAGEFLAG_MOVIE},
	+ (void *)TEX_ANIM5},
	{"anti",
	(getter)Texture_getImageFlags, (setter)Texture_setImageFlags,
	"Image anti-aliasing enabled ('ImageFlags')",
	- (void *)EXPP_TEX_IMAGEFLAG_ANTI},
	+ (void *)TEX_ANTIALI},
	{"stField",
	(getter)Texture_getImageFlags, (setter)Texture_setImageFlags,
	"Standard field deinterlacing enabled ('ImageFlags')",
	- (void *)EXPP_TEX_IMAGEFLAG_STFIELD},
	+ (void *)TEX_STD_FIELD},
	{"normalMap",
	(getter)Texture_getImageFlags, (setter)Texture_setImageFlags,
	"Use of image RGB values for normal mapping enabled ('ImageFlags')",
	- (void *)EXPP_TEX_IMAGEFLAG_NORMALMAP},
	+ (void *)TEX_NORMALMAP},
	{NULL,NULL,NULL,NULL,NULL} /* Sentinel */
	};

	@@ -1033,236 +951,247 @@
	PyObject_DEL( self );
	}

	-#undef EXPP_ADDCONST
	-#define EXPP_ADDCONST(name) \
	- PyConstant_Insert(d, #name, PyInt_FromLong(EXPP_TEX_TYPE_##name))
	-
	static PyObject *M_Texture_TypesDict( void )
	{
	PyObject *Types = PyConstant_New( );
	if( Types ) {
	BPy_constant d = ( BPy_constant ) Types;
	-
	- EXPP_ADDCONST( NONE );
	- EXPP_ADDCONST( CLOUDS );
	- EXPP_ADDCONST( WOOD );
	- EXPP_ADDCONST( MARBLE );
	- EXPP_ADDCONST( MAGIC );
	- EXPP_ADDCONST( BLEND );
	- EXPP_ADDCONST( STUCCI );
	- EXPP_ADDCONST( NOISE );
	- EXPP_ADDCONST( IMAGE );
	- EXPP_ADDCONST( PLUGIN );
	- EXPP_ADDCONST( ENVMAP );
	- EXPP_ADDCONST( MUSGRAVE );
	- EXPP_ADDCONST( VORONOI );
	- EXPP_ADDCONST( DISTNOISE );
	+ PyConstant_Insert(d, "NONE", PyInt_FromLong(EXPP_TEX_TYPE_NONE));
	+ PyConstant_Insert(d, "CLOUDS", PyInt_FromLong(TEX_CLOUDS));
	+ PyConstant_Insert(d, "WOOD", PyInt_FromLong(TEX_WOOD));
	+ PyConstant_Insert(d, "MARBLE", PyInt_FromLong(TEX_MARBLE));
	+ PyConstant_Insert(d, "MAGIC", PyInt_FromLong(TEX_MAGIC));
	+ PyConstant_Insert(d, "BLEND", PyInt_FromLong(TEX_BLEND));
	+ PyConstant_Insert(d, "STUCCI", PyInt_FromLong(TEX_STUCCI));
	+ PyConstant_Insert(d, "NOISE", PyInt_FromLong(TEX_NOISE));
	+ PyConstant_Insert(d, "IMAGE", PyInt_FromLong(TEX_IMAGE));
	+ PyConstant_Insert(d, "PLUGIN", PyInt_FromLong(TEX_PLUGIN));
	+ PyConstant_Insert(d, "ENVMAP", PyInt_FromLong(TEX_ENVMAP));
	+ PyConstant_Insert(d, "MUSGRAVE", PyInt_FromLong(TEX_MUSGRAVE));
	+ PyConstant_Insert(d, "VORONOI", PyInt_FromLong(TEX_VORONOI));
	+ PyConstant_Insert(d, "DISTNOISE", PyInt_FromLong(TEX_DISTNOISE));
	}
	return Types;
	}

	-#undef EXPP_ADDCONST
	-#define EXPP_ADDCONST(name) \
	- PyConstant_Insert(d, #name, PyInt_FromLong(EXPP_TEX_STYPE_##name))
	-
	static PyObject *M_Texture_STypesDict( void )
	{
	PyObject *STypes = PyConstant_New( );
	if( STypes ) {
	BPy_constant d = ( BPy_constant ) STypes;

	- EXPP_ADDCONST( CLD_DEFAULT );
	- EXPP_ADDCONST( CLD_COLOR );
	- EXPP_ADDCONST( WOD_BANDS );
	- EXPP_ADDCONST( WOD_RINGS );
	- EXPP_ADDCONST( WOD_BANDNOISE );
	- EXPP_ADDCONST( WOD_RINGNOISE );
	- EXPP_ADDCONST( MAG_DEFAULT );
	- EXPP_ADDCONST( MBL_SOFT );
	- EXPP_ADDCONST( MBL_SHARP );
	- EXPP_ADDCONST( MBL_SHARPER );
	- EXPP_ADDCONST( BLN_LIN );
	- EXPP_ADDCONST( BLN_QUAD );
	- EXPP_ADDCONST( BLN_EASE );
	- EXPP_ADDCONST( BLN_DIAG );
	- EXPP_ADDCONST( BLN_SPHERE );
	- EXPP_ADDCONST( BLN_HALO );
	- EXPP_ADDCONST( STC_PLASTIC );
	- EXPP_ADDCONST( STC_WALLIN );
	- EXPP_ADDCONST( STC_WALLOUT );
	- EXPP_ADDCONST( NSE_DEFAULT );
	- EXPP_ADDCONST( IMG_DEFAULT );
	- EXPP_ADDCONST( PLG_DEFAULT );
	- EXPP_ADDCONST( ENV_STATIC );
	- EXPP_ADDCONST( ENV_ANIM );
	- EXPP_ADDCONST( ENV_LOAD );
	- EXPP_ADDCONST( MUS_MFRACTAL );
	- EXPP_ADDCONST( MUS_RIDGEDMF );
	- EXPP_ADDCONST( MUS_HYBRIDMF );
	- EXPP_ADDCONST( MUS_FBM );
	- EXPP_ADDCONST( MUS_HTERRAIN );
	- EXPP_ADDCONST( DN_BLENDER );
	- EXPP_ADDCONST( DN_PERLIN );
	- EXPP_ADDCONST( DN_IMPROVEPERLIN );
	- EXPP_ADDCONST( DN_VORONOIF1 );
	- EXPP_ADDCONST( DN_VORONOIF2 );
	- EXPP_ADDCONST( DN_VORONOIF3 );
	- EXPP_ADDCONST( DN_VORONOIF4 );
	- EXPP_ADDCONST( DN_VORONOIF2F1 );
	- EXPP_ADDCONST( DN_VORONOICRACKLE );
	- EXPP_ADDCONST( DN_CELLNOISE );
	- EXPP_ADDCONST( VN_INT );
	- EXPP_ADDCONST( VN_COL1 );
	- EXPP_ADDCONST( VN_COL2 );
	- EXPP_ADDCONST( VN_COL3 );
	- EXPP_ADDCONST( VN_TEX_DISTANCE );
	- EXPP_ADDCONST( VN_TEX_DISTANCE_SQUARED );
	- EXPP_ADDCONST( VN_TEX_MANHATTAN );
	- EXPP_ADDCONST( VN_TEX_CHEBYCHEV );
	- EXPP_ADDCONST( VN_TEX_MINKOVSKY_HALF );
	- EXPP_ADDCONST( VN_TEX_MINKOVSKY_FOUR );
	- EXPP_ADDCONST( VN_TEX_MINKOVSKY );
	+ PyConstant_Insert(d, "CLD_DEFAULT",
	+ PyInt_FromLong(EXPP_TEX_STYPE_CLD_DEFAULT));
	+ PyConstant_Insert(d, "CLD_COLOR",
	+ PyInt_FromLong(EXPP_TEX_STYPE_CLD_COLOR));
	+ PyConstant_Insert(d, "WOD_BANDS",
	+ PyInt_FromLong(EXPP_TEX_STYPE_WOD_BANDS));
	+ PyConstant_Insert(d, "WOD_RINGS",
	+ PyInt_FromLong(EXPP_TEX_STYPE_WOD_RINGS));
	+ PyConstant_Insert(d, "WOD_BANDNOISE",
	+ PyInt_FromLong(EXPP_TEX_STYPE_WOD_BANDNOISE));
	+ PyConstant_Insert(d, "WOD_RINGNOISE",
	+ PyInt_FromLong(EXPP_TEX_STYPE_WOD_RINGNOISE));
	+ PyConstant_Insert(d, "MAG_DEFAULT",
	+ PyInt_FromLong(EXPP_TEX_STYPE_MAG_DEFAULT));
	+ PyConstant_Insert(d, "MBL_SOFT",
	+ PyInt_FromLong(EXPP_TEX_STYPE_MBL_SOFT));
	+ PyConstant_Insert(d, "MBL_SHARP",
	+ PyInt_FromLong(EXPP_TEX_STYPE_MBL_SHARP));
	+ PyConstant_Insert(d, "MBL_SHARPER",
	+ PyInt_FromLong(EXPP_TEX_STYPE_MBL_SHARPER));
	+ PyConstant_Insert(d, "BLN_LIN",
	+ PyInt_FromLong(EXPP_TEX_STYPE_BLN_LIN));
	+ PyConstant_Insert(d, "BLN_QUAD",
	+ PyInt_FromLong(EXPP_TEX_STYPE_BLN_QUAD));
	+ PyConstant_Insert(d, "BLN_EASE",
	+ PyInt_FromLong(EXPP_TEX_STYPE_BLN_EASE));
	+ PyConstant_Insert(d, "BLN_DIAG",
	+ PyInt_FromLong(EXPP_TEX_STYPE_BLN_DIAG));
	+ PyConstant_Insert(d, "BLN_SPHERE",
	+ PyInt_FromLong(EXPP_TEX_STYPE_BLN_SPHERE));
	+ PyConstant_Insert(d, "BLN_HALO",
	+ PyInt_FromLong(EXPP_TEX_STYPE_BLN_HALO));
	+ PyConstant_Insert(d, "STC_PLASTIC",
	+ PyInt_FromLong(EXPP_TEX_STYPE_STC_PLASTIC));
	+ PyConstant_Insert(d, "STC_WALLIN",
	+ PyInt_FromLong(EXPP_TEX_STYPE_STC_WALLIN));
	+ PyConstant_Insert(d, "STC_WALLOUT",
	+ PyInt_FromLong(EXPP_TEX_STYPE_STC_WALLOUT));
	+ PyConstant_Insert(d, "NSE_DEFAULT",
	+ PyInt_FromLong(EXPP_TEX_STYPE_NSE_DEFAULT));
	+ PyConstant_Insert(d, "IMG_DEFAULT",
	+ PyInt_FromLong(EXPP_TEX_STYPE_IMG_DEFAULT));
	+ PyConstant_Insert(d, "PLG_DEFAULT",
	+ PyInt_FromLong(EXPP_TEX_STYPE_PLG_DEFAULT));
	+ PyConstant_Insert(d, "ENV_STATIC",
	+ PyInt_FromLong(EXPP_TEX_STYPE_ENV_STATIC));
	+ PyConstant_Insert(d, "ENV_ANIM",
	+ PyInt_FromLong(EXPP_TEX_STYPE_ENV_ANIM));
	+ PyConstant_Insert(d, "ENV_LOAD",
	+ PyInt_FromLong(EXPP_TEX_STYPE_ENV_LOAD));
	+ PyConstant_Insert(d, "MUS_MFRACTAL",
	+ PyInt_FromLong(EXPP_TEX_STYPE_MUS_MFRACTAL));
	+ PyConstant_Insert(d, "MUS_RIDGEDMF",
	+ PyInt_FromLong(EXPP_TEX_STYPE_MUS_RIDGEDMF));
	+ PyConstant_Insert(d, "MUS_HYBRIDMF",
	+ PyInt_FromLong(EXPP_TEX_STYPE_MUS_HYBRIDMF));
	+ PyConstant_Insert(d, "MUS_FBM",
	+ PyInt_FromLong(EXPP_TEX_STYPE_MUS_FBM));
	+ PyConstant_Insert(d, "MUS_HTERRAIN",
	+ PyInt_FromLong(EXPP_TEX_STYPE_MUS_HTERRAIN));
	+ PyConstant_Insert(d, "DN_BLENDER",
	+ PyInt_FromLong(TEX_BLENDER));
	+ PyConstant_Insert(d, "DN_PERLIN",
	+ PyInt_FromLong(TEX_STDPERLIN));
	+ PyConstant_Insert(d, "DN_IMPROVEPERLIN",
	+ PyInt_FromLong(TEX_NEWPERLIN));
	+ PyConstant_Insert(d, "DN_VORONOIF1",
	+ PyInt_FromLong(TEX_VORONOI_F1));
	+ PyConstant_Insert(d, "DN_VORONOIF2",
	+ PyInt_FromLong(TEX_VORONOI_F2));
	+ PyConstant_Insert(d, "DN_VORONOIF3",
	+ PyInt_FromLong(TEX_VORONOI_F3));
	+ PyConstant_Insert(d, "DN_VORONOIF4",
	+ PyInt_FromLong(TEX_VORONOI_F4));
	+ PyConstant_Insert(d, "DN_VORONOIF2F1",
	+ PyInt_FromLong(TEX_VORONOI_F2F1));
	+ PyConstant_Insert(d, "DN_VORONOICRACKLE",
	+ PyInt_FromLong(TEX_VORONOI_CRACKLE));
	+ PyConstant_Insert(d, "DN_CELLNOISE",
	+ PyInt_FromLong(TEX_CELLNOISE));
	+ PyConstant_Insert(d, "VN_INT",
	+ PyInt_FromLong(EXPP_TEX_STYPE_VN_INT));
	+ PyConstant_Insert(d, "VN_COL1",
	+ PyInt_FromLong(EXPP_TEX_STYPE_VN_COL1));
	+ PyConstant_Insert(d, "VN_COL2",
	+ PyInt_FromLong(EXPP_TEX_STYPE_VN_COL2));
	+ PyConstant_Insert(d, "VN_COL3",
	+ PyInt_FromLong(EXPP_TEX_STYPE_VN_COL3));
	+ PyConstant_Insert(d, "VN_TEX_DISTANCE",
	+ PyInt_FromLong(TEX_DISTANCE));
	+ PyConstant_Insert(d, "VN_TEX_DISTANCE_SQUARED",
	+ PyInt_FromLong(TEX_DISTANCE_SQUARED));
	+ PyConstant_Insert(d, "VN_TEX_MANHATTAN",
	+ PyInt_FromLong(TEX_MANHATTAN));
	+ PyConstant_Insert(d, "VN_TEX_CHEBYCHEV",
	+ PyInt_FromLong(TEX_CHEBYCHEV));
	+ PyConstant_Insert(d, "VN_TEX_MINKOVSKY_HALF",
	+ PyInt_FromLong(TEX_MINKOVSKY_HALF));
	+ PyConstant_Insert(d, "VN_TEX_MINKOVSKY_FOUR",
	+ PyInt_FromLong(TEX_MINKOVSKY_FOUR));
	+ PyConstant_Insert(d, "VN_TEX_MINKOVSKY",
	+ PyInt_FromLong(TEX_MINKOVSKY));
	+
	}
	return STypes;
	}

	-#undef EXPP_ADDCONST
	-#define EXPP_ADDCONST(name) \
	- PyConstant_Insert(d, #name, PyInt_FromLong(EXPP_TEX_TEXCO_##name))
	-
	static PyObject *M_Texture_TexCoDict( void )
	{
	PyObject *TexCo = PyConstant_New( );
	if( TexCo ) {
	BPy_constant d = ( BPy_constant ) TexCo;
	-
	- EXPP_ADDCONST( ORCO );
	- EXPP_ADDCONST( REFL );
	- EXPP_ADDCONST( NOR );
	- EXPP_ADDCONST( GLOB );
	- EXPP_ADDCONST( UV );
	- EXPP_ADDCONST( OBJECT );
	- EXPP_ADDCONST( WIN );
	- EXPP_ADDCONST( VIEW );
	- EXPP_ADDCONST( STICK );
	+ PyConstant_Insert(d, "ORCO", PyInt_FromLong(TEXCO_ORCO));
	+ PyConstant_Insert(d, "REFL", PyInt_FromLong(TEXCO_REFL));
	+ PyConstant_Insert(d, "NOR", PyInt_FromLong(TEXCO_NORM));
	+ PyConstant_Insert(d, "GLOB", PyInt_FromLong(TEXCO_GLOB));
	+ PyConstant_Insert(d, "UV", PyInt_FromLong(TEXCO_UV));
	+ PyConstant_Insert(d, "OBJECT", PyInt_FromLong(TEXCO_OBJECT));
	+ PyConstant_Insert(d, "WIN", PyInt_FromLong(TEXCO_WINDOW));
	+ PyConstant_Insert(d, "VIEW", PyInt_FromLong(TEXCO_VIEW));
	+ PyConstant_Insert(d, "STICK", PyInt_FromLong(TEXCO_STICKY));
	}
	return TexCo;
	}

	-
	-#undef EXPP_ADDCONST
	-#define EXPP_ADDCONST(name) \
	- PyConstant_Insert(d, #name, PyInt_FromLong(EXPP_TEX_MAPTO_##name))
	-
	static PyObject *M_Texture_MapToDict( void )
	{
	PyObject *MapTo = PyConstant_New( );
	if( MapTo ) {
	BPy_constant d = ( BPy_constant ) MapTo;
	-
	- EXPP_ADDCONST( COL );
	- EXPP_ADDCONST( NOR );
	- EXPP_ADDCONST( CSP );
	- EXPP_ADDCONST( CMIR );
	- EXPP_ADDCONST( REF );
	- EXPP_ADDCONST( SPEC );
	- EXPP_ADDCONST( HARD );
	- EXPP_ADDCONST( ALPHA );
	- EXPP_ADDCONST( EMIT );
	- EXPP_ADDCONST( RAYMIR );
	- EXPP_ADDCONST( AMB );
	- EXPP_ADDCONST( TRANSLU );
	- EXPP_ADDCONST( DISP );
	+ PyConstant_Insert(d, "COL", PyInt_FromLong(MAP_COL));
	+ PyConstant_Insert(d, "NOR", PyInt_FromLong(MAP_NORM));
	+ PyConstant_Insert(d, "CSP", PyInt_FromLong(MAP_COLSPEC));
	+ PyConstant_Insert(d, "CMIR", PyInt_FromLong(MAP_COLMIR));
	+ PyConstant_Insert(d, "REF", PyInt_FromLong(MAP_REF));
	+ PyConstant_Insert(d, "SPEC", PyInt_FromLong(MAP_SPEC));
	+ PyConstant_Insert(d, "HARD", PyInt_FromLong(MAP_HAR));
	+ PyConstant_Insert(d, "ALPHA", PyInt_FromLong(MAP_ALPHA));
	+ PyConstant_Insert(d, "EMIT", PyInt_FromLong(MAP_EMIT));
	+ PyConstant_Insert(d, "RAYMIR", PyInt_FromLong(MAP_RAYMIRR));
	+ PyConstant_Insert(d, "AMB", PyInt_FromLong(MAP_AMB));
	+ PyConstant_Insert(d, "TRANSLU", PyInt_FromLong(MAP_TRANSLU));
	+ PyConstant_Insert(d, "DISP", PyInt_FromLong(MAP_DISPLACE));
	}
	return MapTo;
	}

	-
	-#undef EXPP_ADDCONST
	-#define EXPP_ADDCONST(name) \
	- PyConstant_Insert(d, #name, PyInt_FromLong(EXPP_TEX_FLAG_##name))
	-
	static PyObject *M_Texture_FlagsDict( void )
	{
	PyObject *Flags = PyConstant_New( );
	if( Flags ) {
	BPy_constant d = ( BPy_constant ) Flags;
	-
	- EXPP_ADDCONST( COLORBAND );
	- EXPP_ADDCONST( FLIPBLEND );
	- EXPP_ADDCONST( NEGALPHA );
	- EXPP_ADDCONST( CHECKER_ODD );
	- EXPP_ADDCONST( CHECKER_EVEN );
	+ PyConstant_Insert(d, "COLORBAND", PyInt_FromLong(TEX_COLORBAND));
	+ PyConstant_Insert(d, "FLIPBLEND", PyInt_FromLong(TEX_FLIPBLEND));
	+ PyConstant_Insert(d, "NEGALPHA", PyInt_FromLong(TEX_NEGALPHA));
	+ PyConstant_Insert(d, "CHECKER_ODD", PyInt_FromLong(TEX_CHECKER_ODD));
	+ PyConstant_Insert(d, "CHECKER_EVEN", PyInt_FromLong(TEX_CHECKER_EVEN));
	}
	return Flags;
	}

	-
	-#undef EXPP_ADDCONST
	-#define EXPP_ADDCONST(name) \
	- PyConstant_Insert(d, #name, PyInt_FromLong(EXPP_TEX_EXTEND_##name))
	-
	static PyObject *M_Texture_ExtendModesDict( void )
	{
	PyObject *ExtendModes = PyConstant_New( );
	if( ExtendModes ) {
	BPy_constant d = ( BPy_constant ) ExtendModes;
	-
	- EXPP_ADDCONST( EXTEND );
	- EXPP_ADDCONST( CLIP );
	- EXPP_ADDCONST( CLIPCUBE );
	- EXPP_ADDCONST( REPEAT );
	+ PyConstant_Insert(d, "EXTEND", PyInt_FromLong(TEX_EXTEND));
	+ PyConstant_Insert(d, "CLIP", PyInt_FromLong(TEX_CLIP));
	+ PyConstant_Insert(d, "CLIPCUBE", PyInt_FromLong(TEX_CLIPCUBE));
	+ PyConstant_Insert(d, "REPEAT", PyInt_FromLong(TEX_REPEAT));
	}
	return ExtendModes;
	}

	-#undef EXPP_ADDCONST
	-#define EXPP_ADDCONST(name) \
	- PyConstant_Insert(d, #name, PyInt_FromLong(EXPP_TEX_IMAGEFLAG_##name))
	-
	static PyObject *M_Texture_ImageFlagsDict( void )
	{
	PyObject *ImageFlags = PyConstant_New( );
	if( ImageFlags ) {
	BPy_constant d = ( BPy_constant ) ImageFlags;
	-
	- EXPP_ADDCONST( INTERPOL );
	- EXPP_ADDCONST( USEALPHA );
	- EXPP_ADDCONST( MIPMAP );
	- EXPP_ADDCONST( FIELDS );
	- EXPP_ADDCONST( ROT90 );
	- EXPP_ADDCONST( CALCALPHA );
	- EXPP_ADDCONST( STFIELD );
	- EXPP_ADDCONST( MOVIE );
	- EXPP_ADDCONST( CYCLIC );
	- EXPP_ADDCONST( NORMALMAP );
	+ PyConstant_Insert(d, "INTERPOL", PyInt_FromLong(TEX_INTERPOL));
	+ PyConstant_Insert(d, "USEALPHA", PyInt_FromLong(TEX_USEALPHA));
	+ PyConstant_Insert(d, "MIPMAP", PyInt_FromLong(TEX_MIPMAP));
	+ PyConstant_Insert(d, "FIELDS", PyInt_FromLong(TEX_FIELDS));
	+ PyConstant_Insert(d, "ROT90", PyInt_FromLong(TEX_IMAROT));
	+ PyConstant_Insert(d, "CALCALPHA", PyInt_FromLong(TEX_CALCALPHA));
	+ PyConstant_Insert(d, "STFIELD", PyInt_FromLong(TEX_STD_FIELD));
	+ PyConstant_Insert(d, "MOVIE", PyInt_FromLong(TEX_ANIM5));
	+ PyConstant_Insert(d, "CYCLIC", PyInt_FromLong(TEX_ANIMCYCLIC));
	+ PyConstant_Insert(d, "NORMALMAP", PyInt_FromLong(TEX_NORMALMAP));
	}
	return ImageFlags;
	}

	-#undef EXPP_ADDCONST
	-#define EXPP_ADDCONST(name) \
	- PyConstant_Insert(d, #name, PyInt_FromLong(EXPP_TEX_NOISE_##name))
	-
	static PyObject *M_Texture_NoiseDict( void )
	{
	PyObject *Noise = PyConstant_New( );
	if( Noise ) {
	BPy_constant d = ( BPy_constant ) Noise;
	-
	- EXPP_ADDCONST( SINE );
	- EXPP_ADDCONST( SAW );
	- EXPP_ADDCONST( TRI );
	- EXPP_ADDCONST( BLENDER );
	- EXPP_ADDCONST( PERLIN );
	- EXPP_ADDCONST( IMPROVEPERLIN );
	- EXPP_ADDCONST( VORONOIF1 );
	- EXPP_ADDCONST( VORONOIF2 );
	- EXPP_ADDCONST( VORONOIF3 );
	- EXPP_ADDCONST( VORONOIF4 );
	- EXPP_ADDCONST( VORONOIF2F1 );
	- EXPP_ADDCONST( VORONOICRACKLE );
	- EXPP_ADDCONST( CELLNOISE );
	+ PyConstant_Insert(d, "SINE", PyInt_FromLong(EXPP_TEX_NOISE_SINE));
	+ PyConstant_Insert(d, "SAW", PyInt_FromLong(EXPP_TEX_NOISE_SAW));
	+ PyConstant_Insert(d, "TRI", PyInt_FromLong(EXPP_TEX_NOISE_TRI));
	+ PyConstant_Insert(d, "BLENDER", PyInt_FromLong(TEX_BLENDER));
	+ PyConstant_Insert(d, "PERLIN", PyInt_FromLong(TEX_STDPERLIN));
	+ PyConstant_Insert(d, "IMPROVEPERLIN", PyInt_FromLong(TEX_NEWPERLIN));
	+ PyConstant_Insert(d, "VORONOIF1", PyInt_FromLong(TEX_VORONOI_F1));
	+ PyConstant_Insert(d, "VORONOIF2", PyInt_FromLong(TEX_VORONOI_F2));
	+ PyConstant_Insert(d, "VORONOIF3", PyInt_FromLong(TEX_VORONOI_F3));
	+ PyConstant_Insert(d, "VORONOIF4", PyInt_FromLong(TEX_VORONOI_F4));
	+ PyConstant_Insert(d, "VORONOIF2F1", PyInt_FromLong(TEX_VORONOI_F2F1));
	+ PyConstant_Insert(d, "VORONOICRACKLE",
	+ PyInt_FromLong(TEX_VORONOI_CRACKLE));
	+ PyConstant_Insert(d, "CELLNOISE", PyInt_FromLong(TEX_CELLNOISE));
	}
	return Noise;
	}
	@@ -1383,13 +1312,13 @@
	const char *stype = NULL;
	int n_stype;

	- if( self->texture->type == EXPP_TEX_TYPE_VORONOI )
	+ if( self->texture->type == TEX_VORONOI )
	n_stype = self->texture->vn_coltype;
	#if 0
	- else if( self->texture->type == EXPP_TEX_TYPE_MUSGRAVE )
	+ else if( self->texture->type == TEX_MUSGRAVE )
	n_stype = self->texture->noisebasis;
	#endif
	- else if( self->texture->type == EXPP_TEX_TYPE_ENVMAP )
	+ else if( self->texture->type == TEX_ENVMAP )
	n_stype = self->texture->env->stype;
	else
	n_stype = self->texture->stype;
	@@ -1534,13 +1463,13 @@
	static int Texture_setFlags( BPy_Texture * self, PyObject * value )
	{
	int param;
	- int bitmask = EXPP_TEX_FLAG_FLIPBLEND
	+ int bitmask = TEX_FLIPBLEND
	#if 0
	- \| EXPP_TEX_FLAG_COLORBAND
	+ \| TEX_COLORBAND
	#endif
	- \| EXPP_TEX_FLAG_NEGALPHA
	- \| EXPP_TEX_FLAG_CHECKER_ODD
	- \| EXPP_TEX_FLAG_CHECKER_EVEN;
	+ \| TEX_NEGALPHA
	+ \| TEX_CHECKER_ODD
	+ \| TEX_CHECKER_EVEN;

	if( !PyInt_CheckExact ( value ) ) {
	char errstr[128];
	@@ -1558,7 +1487,7 @@
	#if 0
	/* if Colorband enabled, make sure we allocate memory for it */

	- if ( ( param & EXPP_TEX_FLAG_COLORBAND ) && !self->texture->coba )
	+ if ( ( param & TEX_COLORBAND ) && !self->texture->coba )
	self->texture->coba = add_colorband();
	#endif

	@@ -1608,17 +1537,17 @@
	*/

	} else {
	- int bitmask = EXPP_TEX_IMAGEFLAG_INTERPOL
	- \| EXPP_TEX_IMAGEFLAG_USEALPHA
	- \| EXPP_TEX_IMAGEFLAG_MIPMAP
	- \| EXPP_TEX_IMAGEFLAG_FIELDS
	- \| EXPP_TEX_IMAGEFLAG_ROT90
	- \| EXPP_TEX_IMAGEFLAG_CALCALPHA
	- \| EXPP_TEX_IMAGEFLAG_CYCLIC
	- \| EXPP_TEX_IMAGEFLAG_MOVIE
	- \| EXPP_TEX_IMAGEFLAG_ANTI
	- \| EXPP_TEX_IMAGEFLAG_STFIELD
	- \| EXPP_TEX_IMAGEFLAG_NORMALMAP;
	+ int bitmask = TEX_INTERPOL
	+ \| TEX_USEALPHA
	+ \| TEX_MIPMAP
	+ \| TEX_FIELDS
	+ \| TEX_IMAROT
	+ \| TEX_CALCALPHA
	+ \| TEX_ANIMCYCLIC
	+ \| TEX_ANIM5
	+ \| TEX_ANTIALI
	+ \| TEX_STD_FIELD
	+ \| TEX_NORMALMAP;

	if( !PyInt_CheckExact ( value ) ) {
	char errstr[128];
	@@ -1634,8 +1563,8 @@

	/* "mipmap" and "fields" can't be set at the same time */

	- if( ( param & EXPP_TEX_IMAGEFLAG_MIPMAP ) &&
	- ( param & EXPP_TEX_IMAGEFLAG_FIELDS ) )
	+ if( ( param & TEX_MIPMAP ) &&
	+ ( param & TEX_FIELDS ) )
	return EXPP_ReturnIntError( PyExc_ValueError,
	"image flags MIPMAP and FIELDS cannot be used together" );

	@@ -1712,9 +1641,9 @@

	param = PyInt_AS_LONG ( value );

	- if ( param < EXPP_TEX_STYPE_DN_BLENDER
	- \|\| ( param > EXPP_TEX_STYPE_DN_VORONOICRACKLE
	- && param != EXPP_TEX_STYPE_DN_CELLNOISE ) )
	+ if ( param < TEX_BLENDER
	+ \|\| ( param > TEX_VORONOI_CRACKLE
	+ && param != TEX_CELLNOISE ) )
	return EXPP_ReturnIntError( PyExc_ValueError,
	"invalid noise type" );

	@@ -1738,9 +1667,9 @@

	param = PyInt_AS_LONG ( value );

	- if ( param < EXPP_TEX_STYPE_DN_BLENDER
	- \|\| ( param > EXPP_TEX_STYPE_DN_VORONOICRACKLE
	- && param != EXPP_TEX_STYPE_DN_CELLNOISE ) )
	+ if ( param < TEX_BLENDER
	+ \|\| ( param > TEX_VORONOI_CRACKLE
	+ && param != TEX_CELLNOISE ) )
	return EXPP_ReturnIntError( PyExc_ValueError,
	"invalid noise type" );

	@@ -1818,13 +1747,13 @@
	return EXPP_ReturnIntError( PyExc_ValueError,
	"invalid stype (for this type)" );

	- if( self->texture->type == EXPP_TEX_TYPE_VORONOI )
	+ if( self->texture->type == TEX_VORONOI )
	self->texture->vn_coltype = param;
	#if 0
	- else if( self->texture->type == EXPP_TEX_TYPE_MUSGRAVE )
	+ else if( self->texture->type == TEX_MUSGRAVE )
	self->texture->noisebasis = param;
	#endif
	- else if( self->texture->type == EXPP_TEX_TYPE_ENVMAP )
	+ else if( self->texture->type == TEX_ENVMAP )
	self->texture->env->stype = param;
	else
	self->texture->stype = param;
	@@ -1879,7 +1808,7 @@
	* from texture_panel_envmap() in source/blender/src/buttons_shading.c)
	*/

	- if( !err && self->texture->type == EXPP_TEX_TYPE_ENVMAP
	+ if( !err && self->texture->type == TEX_ENVMAP
	&& !self->texture->env ) {
	self->texture->env = RE_add_envmap();
	self->texture->env->object= OBACT;
	@@ -1897,7 +1826,7 @@
	"expected string argument" );

	/* can we really trust texture->type? */
	- if( self->texture->type == EXPP_TEX_TYPE_VORONOI &&
	+ if( self->texture->type == TEX_VORONOI &&
	!EXPP_map_getShortVal( tex_stype_map[self->texture->type + 2],
	dist, &self->texture->vn_distm ) )
	return EXPP_ReturnPyObjError( PyExc_ValueError,
	@@ -1907,8 +1836,8 @@
	return Py_None;
	#else
	return EXPP_setShortRange ( value, &self->texture->vn_distm,
	- EXPP_TEX_STYPE_VN_TEX_DISTANCE,
	- EXPP_TEX_STYPE_VN_TEX_MINKOVSKY );
	+ TEX_DISTANCE,
	+ TEX_MINKOVSKY );
	#endif
	}

	@@ -2360,13 +2289,13 @@
	{
	PyObject *attr;

	- if( self->texture->type == EXPP_TEX_TYPE_VORONOI )
	+ if( self->texture->type == TEX_VORONOI )
	attr = PyInt_FromLong( self->texture->vn_coltype );
	#if 0
	- else if( self->texture->type == EXPP_TEX_TYPE_MUSGRAVE )
	+ else if( self->texture->type == TEX_MUSGRAVE )
	attr = PyInt_FromLong( self->texture->noisebasis );
	#endif
	- else if( self->texture->type == EXPP_TEX_TYPE_ENVMAP )
	+ else if( self->texture->type == TEX_ENVMAP )
	attr = PyInt_FromLong( self->texture->env->stype );
	else
	attr = PyInt_FromLong( self->texture->stype );
	@@ -2557,7 +2486,7 @@
	* from texture_panel_envmap() in source/blender/src/buttons_shading.c)
	*/

	- if( self->texture->type == EXPP_TEX_TYPE_ENVMAP
	+ if( self->texture->type == TEX_ENVMAP
	&& !self->texture->env ) {
	self->texture->env = RE_add_envmap();
	self->texture->env->object= OBACT;
	@@ -2600,11 +2529,11 @@
	if( !PyArg_ParseTuple( args, "s", &nbasis ) )
	return EXPP_ReturnPyObjError( PyExc_TypeError,
	"expected string argument" );
	- if( self->texture->type == EXPP_TEX_TYPE_MUSGRAVE &&
	- EXPP_map_getShortVal( tex_stype_map[EXPP_TEX_TYPE_DISTNOISE],
	+ if( self->texture->type == TEX_MUSGRAVE &&
	+ EXPP_map_getShortVal( tex_stype_map[TEX_DISTNOISE],
	nbasis, &self->texture->noisebasis ) );
	- else if( self->texture->type == EXPP_TEX_TYPE_DISTNOISE &&
	- !EXPP_map_getShortVal( tex_stype_map[EXPP_TEX_TYPE_DISTNOISE],
	+ else if( self->texture->type == TEX_DISTNOISE &&
	+ !EXPP_map_getShortVal( tex_stype_map[TEX_DISTNOISE],
	nbasis, &self->texture->noisebasis2 ) )
	return EXPP_ReturnPyObjError( PyExc_ValueError,
	"invalid noise basis" );
	@@ -2621,8 +2550,8 @@
	if( !PyArg_ParseTuple( args, "s", &nbasis ) )
	return EXPP_ReturnPyObjError( PyExc_TypeError,
	"expected string argument" );
	- if( self->texture->type == EXPP_TEX_TYPE_DISTNOISE &&
	- !EXPP_map_getShortVal( tex_stype_map[EXPP_TEX_TYPE_DISTNOISE],
	+ if( self->texture->type == TEX_DISTNOISE &&
	+ !EXPP_map_getShortVal( tex_stype_map[TEX_DISTNOISE],
	nbasis, &self->texture->noisebasis ) )
	return EXPP_ReturnPyObjError( PyExc_ValueError,
	"invalid noise basis" );
	@@ -2639,16 +2568,16 @@
	"expected string argument" );

	/* can we really trust texture->type? */
	- if( ( self->texture->type == EXPP_TEX_TYPE_VORONOI &&
	+ if( ( self->texture->type == TEX_VORONOI &&
	EXPP_map_getShortVal( tex_stype_map[self->texture->type],
	stype, &self->texture->vn_coltype ) ) );
	#if 0
	- else if( ( self->texture->type == EXPP_TEX_TYPE_MUSGRAVE &&
	+ else if( ( self->texture->type == TEX_MUSGRAVE &&
	EXPP_map_getShortVal( tex_stype_map
	- [EXPP_TEX_TYPE_DISTNOISE], stype,
	+ [TEX_DISTNOISE], stype,
	&self->texture->noisebasis ) ) );
	#endif
	- else if( ( self->texture->type == EXPP_TEX_TYPE_ENVMAP &&
	+ else if( ( self->texture->type == TEX_ENVMAP &&
	EXPP_map_getShortVal( tex_stype_map[self->texture->type],
	stype, &self->texture->env->stype ) ) );
	else if( !EXPP_map_getShortVal
	@@ -2670,7 +2599,7 @@
	return EXPP_ReturnPyObjError( PyExc_TypeError,
	"expected string argument" );
	/* can we really trust texture->type? */
	- if( self->texture->type == EXPP_TEX_TYPE_VORONOI &&
	+ if( self->texture->type == TEX_VORONOI &&
	!EXPP_map_getShortVal( tex_stype_map[self->texture->type + 2],
	dist, &self->texture->vn_distm ) )
	return EXPP_ReturnPyObjError( PyExc_ValueError,

File Metadata

Mime Type: text/x-diff
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 3d/ba/7b6d5f5919af63f04163bbd2bc5a

patch-Texture3.c.txtPublicActions

patch-Texture3.c.txtView Options

File Metadata

Event Timeline

patch-Texture3.c.txt
Public
Actions

patch-Texture3.c.txt
View Options