patch #2869 MTex module additions

contributed by Yehoshua Sapir (sapir)

adds attributes to MTex module.  adds module constants.
Uses new style tp_getset.

4 files changed, 858 insertions, 86 deletions

diff --git a/source/blender/python/api2_2x/MTex.c b/source/blender/python/api2_2x/MTex.c
index 6b058361951..16900a15869 100644
--- a/source/blender/python/api2_2x/MTex.c
+++ b/source/blender/python/api2_2x/MTex.c
@@ -25,7 +25,7 @@
  *
  * This is a new part of Blender.
  *
- * Contributor(s): Alex Mole
+ * Contributor(s): Alex Mole, Yehoshua Sapir
  *
  * ***** END GPL/BL DUAL LICENSE BLOCK *****
 */
@@ -33,13 +33,15 @@
 
 #include "BKE_utildefines.h"
 #include "Texture.h"
+#include "Object.h"
 #include "gen_utils.h"
 
+#include <DNA_material_types.h>
 
 /*****************************************************************************/
 /* Python BPy_MTex methods declarations:                                     */
 /*****************************************************************************/
-static PyObject *MTex_setTex( BPy_MTex * self, PyObject * args );
+static PyObject *MTex_setTexMethod( BPy_MTex * self, PyObject * args );
 
 /*****************************************************************************/
 /* Python method structure definition for Blender.Texture.MTex module:       */
@@ -53,7 +55,7 @@ struct PyMethodDef M_MTex_methods[] = {
 /*****************************************************************************/
 static PyMethodDef BPy_MTex_methods[] = {
 	/* name, method, flags, doc */
-	{"setTex", ( PyCFunction ) MTex_setTex, METH_VARARGS,
+	{"setTex", ( PyCFunction ) MTex_setTexMethod, METH_VARARGS,
 	 "(i) - Set MTex Texture"},
 	{NULL, NULL, 0, NULL}
 };
@@ -62,15 +64,126 @@ static PyMethodDef BPy_MTex_methods[] = {
 /* Python MTex_Type callback function prototypes:                            */
 /*****************************************************************************/
 static void MTex_dealloc( BPy_MTex * self );
-static int MTex_setAttr( BPy_MTex * self, char *name, PyObject * v );
 static int MTex_compare( BPy_MTex * a, BPy_MTex * b );
-static PyObject *MTex_getAttr( BPy_MTex * self, char *name );
 static PyObject *MTex_repr( BPy_MTex * self );
 
+#define MTEXGET(x) \
+	static PyObject *MTex_get##x( BPy_MTex *self, void *closure );
+#define MTEXSET(x) \
+	static int MTex_set##x( BPy_MTex *self, PyObject *value, void *closure);
+#define MTEXGETSET(x) \
+	MTEXGET(x) \
+	MTEXSET(x)
+
+MTEXGETSET(Tex)
+MTEXGETSET(TexCo)
+MTEXGETSET(Object)
+MTEXGETSET(MapTo)
+MTEXGETSET(Col)
+MTEXGETSET(DVar)
+MTEXGETSET(BlendMode)
+MTEXGETSET(ColFac)
+MTEXGETSET(NorFac)
+MTEXGETSET(VarFac)
+MTEXGETSET(DispFac)
+MTEXGETSET(WarpFac)
+MTEXGETSET(Ofs)
+MTEXGETSET(Size)
+MTEXGETSET(Mapping)
+MTEXGETSET(Flag)
+MTEXGETSET(ProjX)
+MTEXGETSET(ProjY)
+MTEXGETSET(ProjZ)
+MTEXGETSET(MapToFlag)
+
+/*****************************************************************************/
+/* Python get/set methods table                                              */
+/*****************************************************************************/
+
+static PyGetSetDef MTex_getseters[] = {
+	{ "tex", (getter) MTex_getTex, (setter) MTex_setTex,
+		"Texture whose mapping this MTex describes", NULL },
+	{ "texco", (getter) MTex_getTexCo, (setter) MTex_setTexCo,
+		"Texture coordinate space (UV, Global, etc.)", NULL },
+	{ "object", (getter) MTex_getObject, (setter) MTex_setObject,
+		"Object whose space to use when texco is Object", NULL },
+	{ "mapto", (getter) MTex_getMapTo, (setter) MTex_setMapTo,
+		"What values the texture affects", NULL },
+	{ "col", (getter) MTex_getCol, (setter) MTex_setCol,
+		"Color that the texture blends with", NULL },
+	{ "dvar", (getter) MTex_getDVar, (setter) MTex_setDVar,
+		"Value that the texture blends with when not blending colors", NULL },
+	{ "blendmode", (getter) MTex_getBlendMode, (setter) MTex_setBlendMode,
+		"Texture blending mode", NULL },
+	{ "colfac", (getter) MTex_getColFac, (setter) MTex_setColFac,
+		"Factor by which texture affects color", NULL },
+	{ "norfac", (getter) MTex_getNorFac, (setter) MTex_setNorFac,
+		"Factor by which texture affects normal", NULL },
+	{ "varfac", (getter) MTex_getVarFac, (setter) MTex_setVarFac,
+		"Factor by which texture affects most variables", NULL },
+	{ "dispfac", (getter) MTex_getDispFac, (setter) MTex_setDispFac,
+		"Factor by which texture affects displacement", NULL },
+	{ "warpfac", (getter) MTex_getWarpFac, (setter) MTex_setWarpFac,
+		"Factor by which texture affects warp", NULL },
+	{ "ofs", (getter) MTex_getOfs, (setter) MTex_setOfs,
+		"Offset to adjust texture space", NULL },
+	{ "size", (getter) MTex_getSize, (setter) MTex_setSize,
+		"Size to scale texture space", NULL },
+	{ "mapping", (getter) MTex_getMapping, (setter) MTex_setMapping,
+		"Mapping of texture coordinates (flat, cube, etc.)", NULL },
+	{ "stencil", (getter) MTex_getFlag, (setter) MTex_setFlag,
+		"Stencil mode", (void*) MTEX_STENCIL },
+	{ "neg", (getter) MTex_getFlag, (setter) MTex_setFlag,
+		"Negate texture values mode", (void*) MTEX_NEGATIVE },
+	{ "noRGB", (getter) MTex_getFlag, (setter) MTex_setFlag,
+		"Convert texture RGB values to intensity values",
+		(void*) MTEX_RGBTOINT },
+	{ "correctNor", (getter) MTex_getFlag, (setter) MTex_setFlag,
+		"Correct normal mapping for Texture space and Object space",
+		(void*) MTEX_VIEWSPACE },
+	{ "xproj", (getter) MTex_getProjX, (setter) MTex_setProjX,
+		"Projection of X axis to Texture space", NULL },
+	{ "yproj", (getter) MTex_getProjY, (setter) MTex_setProjY,
+		"Projection of Y axis to Texture space", NULL },
+	{ "zproj", (getter) MTex_getProjZ, (setter) MTex_setProjZ,
+		"Projection of Z axis to Texture space", NULL },
+	{ "mtCol", (getter) MTex_getMapToFlag, (setter) MTex_setMapToFlag,
+		"How texture maps to color", (void*) MAP_COL },
+	{ "mtNor", (getter) MTex_getMapToFlag, (setter) MTex_setMapToFlag,
+		"How texture maps to normals", (void*) MAP_NORM },
+	{ "mtCsp", (getter) MTex_getMapToFlag, (setter) MTex_setMapToFlag,
+		"How texture maps to specularity color", (void*) MAP_COLSPEC },
+	{ "mtCmir", (getter) MTex_getMapToFlag, (setter) MTex_setMapToFlag,
+		"How texture maps to mirror color", (void*) MAP_COLMIR },
+	{ "mtRef", (getter) MTex_getMapToFlag, (setter) MTex_setMapToFlag,
+		"How texture maps to reflectivity", (void*) MAP_REF },
+	{ "mtSpec", (getter) MTex_getMapToFlag, (setter) MTex_setMapToFlag,
+		"How texture maps to specularity", (void*) MAP_SPEC },
+	{ "mtEmit", (getter) MTex_getMapToFlag, (setter) MTex_setMapToFlag,
+		"How texture maps to emit value", (void*) MAP_EMIT },
+	{ "mtAlpha", (getter) MTex_getMapToFlag, (setter) MTex_setMapToFlag,
+		"How texture maps to alpha value", (void*) MAP_ALPHA },
+	{ "mtHard", (getter) MTex_getMapToFlag, (setter) MTex_setMapToFlag,
+		"How texture maps to hardness", (void*) MAP_HAR },
+	{ "mtRayMir", (getter) MTex_getMapToFlag, (setter) MTex_setMapToFlag,
+		"How texture maps to RayMir value", (void*) MAP_RAYMIRR },
+	{ "mtTranslu", (getter) MTex_getMapToFlag, (setter) MTex_setMapToFlag,
+		"How texture maps to translucency", (void*) MAP_TRANSLU },
+	{ "mtAmb", (getter) MTex_getMapToFlag, (setter) MTex_setMapToFlag,
+		"How texture maps to ambient value", (void*) MAP_AMB },
+	{ "mtDisp", (getter) MTex_getMapToFlag, (setter) MTex_setMapToFlag,
+		"How texture maps to displacement", (void*) MAP_DISPLACE },
+	{ "mtWarp", (getter) MTex_getMapToFlag, (setter) MTex_setMapToFlag,
+		"How texture maps to warp", (void*) MAP_WARP },
+	{ NULL, NULL, NULL, NULL, NULL }
+};
+
+
 
 /*****************************************************************************/
 /* Python MTex_Type structure definition:                                    */
 /*****************************************************************************/
+
 PyTypeObject MTex_Type = {
 	PyObject_HEAD_INIT( NULL ) 
 	0,	/* ob_size */
@@ -80,27 +193,55 @@ PyTypeObject MTex_Type = {
 	/* methods */
 	( destructor ) MTex_dealloc,	/* tp_dealloc */
 	0,			/* tp_print */
-	( getattrfunc ) MTex_getAttr,	/* tp_getattr */
-	( setattrfunc ) MTex_setAttr,	/* tp_setattr */
+	0,	/* tp_getattr */
+	0,	/* tp_setattr */
 	( cmpfunc ) MTex_compare,	/* tp_compare */
 	( reprfunc ) MTex_repr,	/* tp_repr */
 	0,			/* tp_as_number */
 	0,			/* tp_as_sequence */
 	0,			/* tp_as_mapping */
 	0,			/* tp_as_hash */
-	0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0,
+  /*** Flags to define presence of optional/expanded features ***/
+	Py_TPFLAGS_DEFAULT,	/*    long tp_flags; */
 	0,			/* tp_doc */
 	0, 0, 0, 0, 0, 0,
-	0,			/* tp_methods */
+	BPy_MTex_methods,			/* tp_methods */
 	0,			/* tp_members */
+	MTex_getseters,  /*    struct PyGetSetDef *tp_getset; */
+	0,			/*    struct _typeobject *tp_base; */
+	0,			/*    PyObject *tp_dict; */
+	0,			/*    descrgetfunc tp_descr_get; */
+	0,			/*    descrsetfunc tp_descr_set; */
+	0,			/*    long tp_dictoffset; */
+	0,			/*    initproc tp_init; */
+	0,			/*    allocfunc tp_alloc; */
+	0,			/*    newfunc tp_new; */
+	/*  Low-level free-memory routine */
+	0,			/*    freefunc tp_free;  */
+	/* For PyObject_IS_GC */
+	0,			/*    inquiry tp_is_gc;  */
+	0,			/*    PyObject *tp_bases; */
+	/* method resolution order */
+	0,			/*    PyObject *tp_mro;  */
+	0,			/*    PyObject *tp_cache; */
+	0,			/*    PyObject *tp_subclasses; */
+	0,			/*    PyObject *tp_weaklist; */
+	0
 };
 
 
 PyObject *MTex_Init( void )
 {
 	PyObject *submodule;
+/*	PyObject *dict; */
 
-	MTex_Type.ob_type = &PyType_Type;
+	/* call PyType_Ready() to init dictionaries & such */
+	if( PyType_Ready( &MTex_Type) < 0)
+		return NULL;
+
+	/* So do we need this? */
+/*	MTex_Type.ob_type = &PyType_Type;*/
 
 	submodule = Py_InitModule( "Blender.Texture.MTex", M_MTex_methods );
 
@@ -136,17 +277,27 @@ int MTex_CheckPyObject( PyObject * pyobj )
 /* Python BPy_MTex methods:                                                  */
 /*****************************************************************************/
 
-static PyObject *MTex_setTex( BPy_MTex * self, PyObject * args )
+static PyObject *MTex_setTexMethod( BPy_MTex * self, PyObject * args )
 {
-	BPy_Texture *pytex = NULL;
-	if( !PyArg_ParseTuple( args, "O!", &Texture_Type, &pytex ) )
+	Tex *tex;
+
+	if( args == Py_None )
+	{
+		tex = NULL;
+	} else if( Texture_CheckPyObject( args ) ) {
+		tex = Texture_FromPyObject( args );
+	} else {
 		return EXPP_ReturnPyObjError( PyExc_TypeError,
 					      "expected Texture argument" );
-
+	}
+	
 	if( self->mtex->tex )
 		self->mtex->tex->id.us--;
 
-	self->mtex->tex = Texture_FromPyObject( ( PyObject * ) pytex );
+	self->mtex->tex = tex;
+
+	if( self->mtex->tex )
+		self->mtex->tex->id.us++;
 
 	Py_INCREF( Py_None );
 	return Py_None;
@@ -157,83 +308,581 @@ static void MTex_dealloc( BPy_MTex * self )
 	PyObject_DEL( self );
 }
 
-static PyObject *MTex_getAttr( BPy_MTex * self, char *name )
+static int MTex_compare( BPy_MTex * a, BPy_MTex * b )
 {
-	if( STREQ( name, "tex" ) ) {
-		if( self->mtex->tex )
-			return Texture_CreatePyObject( self->mtex->tex );
-		else {
-			Py_INCREF( Py_None );
-			return Py_None;
-		}
-	} else if( STREQ( name, "texco" ) )
-		return PyInt_FromLong( self->mtex->texco );
-	else if( STREQ( name, "mapto" ) )
-		return PyInt_FromLong( self->mtex->mapto );
-
-	else if( STREQ( name, "__members__" ) )
-		return Py_BuildValue( "[s,s,s]", "tex", "texco", "mapto" );
-
-	/* not an attribute, search the methods table */
-	return Py_FindMethod( BPy_MTex_methods, ( PyObject * ) self, name );
-}
-
-static int MTex_setAttr( BPy_MTex * self, char *name, PyObject * value )
-{
-	PyObject *valtuple;
-	PyObject *error = NULL;
-
-	/* Put "value" in a tuple, because we want to pass it to functions  *
-	 * that only accept PyTuples.                                       */
-	valtuple = Py_BuildValue( "(O)", value );
-	if( !valtuple )
-		return EXPP_ReturnIntError( PyExc_MemoryError,
-					    "MTex_setAttr: couldn't create PyTuple" );
-
-	if( STREQ( name, "tex" ) )
-		error = MTex_setTex( self, valtuple );
-	else if( STREQ( name, "texco" ) ) {
-		if( PyInt_Check( value ) ) {
-			int texco = PyInt_AsLong( value );
-			/* TODO: sanity-check this input! */
-			self->mtex->texco = (short)texco;
-			Py_INCREF( Py_None );	/* because we decref it below */
-			error = Py_None;
-		}
-	} else if( STREQ( name, "mapto" ) ) {
-		if( PyInt_Check( value ) ) {
-			int mapto = PyInt_AsLong( value );
-			/* TODO: sanity-check this input! */
-			self->mtex->mapto = (short)mapto;
-			Py_INCREF( Py_None );	/* because we decref it below */
-			error = Py_None;
-		}
+	return ( a->mtex == b->mtex ) ? 0 : -1;
+}
+
+static PyObject *MTex_repr( BPy_MTex * self )
+{
+	return PyString_FromFormat( "[MTex]" );
+}
+
+
+/*****************************************************************************/
+/* Python BPy_MTex get and set functions:                                    */
+/*****************************************************************************/
+
+static PyObject *MTex_getTex( BPy_MTex *self, void *closure )
+{
+	if( self->mtex->tex )
+		return Texture_CreatePyObject( self->mtex->tex );
+	else {
+		Py_INCREF( Py_None );
+		return Py_None;
 	}
+}
 
+static int MTex_setTex( BPy_MTex *self, PyObject *value, void *closure)
+{
+	Tex *tex;
+
+	if( value == Py_None )
+	{
+		tex = NULL;
+	} else if( Texture_CheckPyObject( value ) ) {
+		tex = Texture_FromPyObject( value );
+	} else {
+		return EXPP_ReturnIntError( PyExc_TypeError,
+					      "expected Texture argument" );
+	}
+	
+	if( self->mtex->tex )
+		self->mtex->tex->id.us--;
+
+	self->mtex->tex = tex;
+
+	if( self->mtex->tex )
+		self->mtex->tex->id.us++;
+
+	return 0;
+}
+
+static PyObject *MTex_getTexCo( BPy_MTex *self, void *closure )
+{
+	return PyInt_FromLong( self->mtex->texco );
+}
+
+static int MTex_setTexCo( BPy_MTex *self, PyObject *value, void *closure)
+{
+	int texco;
+
+	if( !PyInt_Check( value ) ) {
+		return EXPP_ReturnIntError( PyExc_TypeError,
+			"Value must be a member of Texture.TexCo dictionary" );
+	}
+
+	texco = PyInt_AsLong( value ) ;
+
+	if (texco != TEXCO_ORCO && texco != TEXCO_REFL && texco != TEXCO_NORM &&
+		texco != TEXCO_GLOB && texco != TEXCO_UV && texco != TEXCO_OBJECT &&
+		texco != TEXCO_WINDOW && texco != TEXCO_VIEW && texco != TEXCO_STICKY )
+		return EXPP_ReturnIntError( PyExc_ValueError,
+			"Value must be a member of Texture.TexCo dictionary" );
+
+	self->mtex->texco = texco;
+
+	return 0;
+}
+
+static PyObject *MTex_getObject( BPy_MTex *self, void *closure )
+{
+	if( self->mtex->object )
+		return Object_CreatePyObject( self->mtex->object );
 	else {
-		/* Error */
-		Py_DECREF( valtuple );
-		return EXPP_ReturnIntError( PyExc_KeyError,
-					    "attribute not found" );
+		Py_INCREF( Py_None );
+		return Py_None;
 	}
+}
 
-	Py_DECREF( valtuple );
+static int MTex_setObject( BPy_MTex *self, PyObject *value, void *closure)
+{
+	Object *obj;
+
+	if( value == Py_None )
+	{
+		obj = NULL;
+	} else if( Object_CheckPyObject( value ) ) {
+		obj = Object_FromPyObject( value );
+	} else {
+		return EXPP_ReturnIntError( PyExc_TypeError,
+					      "expected Object argument" );
+	}
+	
+	if( self->mtex->object )
+		self->mtex->object->id.us--;
 
-	if( error != Py_None )
-		return -1;
+	self->mtex->object = obj;
 
-	/* Py_None was INCREF'd by the set*() function, so we need to DECREF it */
-	Py_DECREF( Py_None );
+	if( self->mtex->object )
+		self->mtex->object->id.us++;
 
 	return 0;
 }
 
-static int MTex_compare( BPy_MTex * a, BPy_MTex * b )
+static PyObject *MTex_getMapTo( BPy_MTex *self, void *closure )
 {
-	return ( a->mtex == b->mtex ) ? 0 : -1;
+	return PyInt_FromLong( self->mtex->mapto );
 }
 
-static PyObject *MTex_repr( BPy_MTex * self )
+static int MTex_setMapTo( BPy_MTex *self, PyObject *value, void *closure)
 {
-	return PyString_FromFormat( "[MTex]" );
+	int mapto;
+
+	if( !PyInt_Check( value ) ) {
+		return EXPP_ReturnIntError( PyExc_TypeError,
+			"expected an int" );
+	}
+
+	mapto = PyInt_AsLong( value );
+
+	/* This method is deprecated anyway. */
+	if ( mapto < 0 || mapto > 16383 ) {
+		return EXPP_ReturnIntError( PyExc_ValueError,
+			"Value must be a sum of values from Texture.MapTo dictionary" );
+	}
+
+	self->mtex->mapto = mapto;
+
+	return 0;
+}
+
+static PyObject *MTex_getCol( BPy_MTex *self, void *closure )
+{
+	return Py_BuildValue( "(f,f,f)", self->mtex->r, self->mtex->g,
+		self->mtex->b );
+}
+
+static int MTex_setCol( BPy_MTex *self, PyObject *value, void *closure)
+{
+	float rgb[3];
+	int i;
+
+	if( !PyArg_ParseTuple( value, "fff",
+		&rgb[0], &rgb[1], &rgb[2] ) )
+
+		return EXPP_ReturnIntError( PyExc_TypeError,
+					      "expected tuple of 3 floats" );
+
+	for( i = 0; i < 3; ++i )
+		if( rgb[i] < 0 || rgb[i] > 1 )
+			return EXPP_ReturnIntError( PyExc_ValueError,
+					      "values must be in range [0,1]" );
+
+	self->mtex->r = rgb[0];
+	self->mtex->g = rgb[1];
+	self->mtex->b = rgb[2];
+
+	return 0;
+}
+
+static PyObject *MTex_getDVar( BPy_MTex *self, void *closure )
+{
+	return PyFloat_FromDouble(self->mtex->def_var);
+}
+
+static int MTex_setDVar( BPy_MTex *self, PyObject *value, void *closure)
+{
+	float f;
+
+	if ( !PyFloat_Check( value ) )
+		return EXPP_ReturnIntError( PyExc_TypeError,
+						"expected a float" );
+
+	f = PyFloat_AsDouble(value);
+
+	if (f < 0 || f > 1)
+		return EXPP_ReturnIntError( PyExc_ValueError,
+					      "values must be in range [0,1]" );
+
+	self->mtex->def_var = f;
+
+	return 0;
+}
+
+static PyObject *MTex_getBlendMode( BPy_MTex *self, void *closure )
+{
+	return PyInt_FromLong(self->mtex->blendtype);
+}
+
+static int MTex_setBlendMode( BPy_MTex *self, PyObject *value, void *closure)
+{
+	int n;
+
+	if ( !PyInt_Check( value ) )
+		return EXPP_ReturnIntError( PyExc_TypeError,
+					    "Value must be member of Texture.BlendModes dictionary" );
+
+	n = PyInt_AsLong(value);
+
+/*	if (n != MTEX_BLEND && n != MTEX_MUL && n != MTEX_ADD &&
+		n != MTEX_SUB && n != MTEX_DIV && n != MTEX_DARK &&
+		n != MTEX_DIFF && n != MTEX_LIGHT && n != MTEX_SCREEN)*/
+	if (n < 0 || n > 8)
+	{
+		return EXPP_ReturnIntError( PyExc_ValueError,
+					    "Value must be member of Texture.BlendModes dictionary" );
+	}
+
+	self->mtex->blendtype = n;
+
+	return 0;
+}
+
+static PyObject *MTex_getColFac( BPy_MTex *self, void *closure )
+{
+	return PyFloat_FromDouble(self->mtex->colfac);
+}
+
+static int MTex_setColFac( BPy_MTex *self, PyObject *value, void *closure)
+{
+	float f;
+
+	if ( !PyFloat_Check( value ) )
+		return EXPP_ReturnIntError( PyExc_TypeError,
+						"expected a float" );
+
+	f = PyFloat_AsDouble(value);
+
+	if (f < 0 || f > 1)
+		return EXPP_ReturnIntError( PyExc_ValueError,
+					      "values must be in range [0,1]" );
+
+	self->mtex->colfac = f;
+
+	return 0;
+}
+
+static PyObject *MTex_getNorFac( BPy_MTex *self, void *closure )
+{
+	return PyFloat_FromDouble(self->mtex->norfac);
+}
+
+static int MTex_setNorFac( BPy_MTex *self, PyObject *value, void *closure)
+{
+	float f;
+
+	if ( !PyFloat_Check( value ) )
+		return EXPP_ReturnIntError( PyExc_TypeError,
+						"expected a float" );
+
+	f = PyFloat_AsDouble(value);
+
+	if (f < 0 || f > 25)
+		return EXPP_ReturnIntError( PyExc_ValueError,
+					      "values must be in range [0,25]" );
+
+	self->mtex->norfac = f;
+
+	return 0;
+}
+
+static PyObject *MTex_getVarFac( BPy_MTex *self, void *closure )
+{
+	return PyFloat_FromDouble(self->mtex->varfac);
+}
+
+static int MTex_setVarFac( BPy_MTex *self, PyObject *value, void *closure)
+{
+	float f;
+
+	if ( !PyFloat_Check( value ) )
+		return EXPP_ReturnIntError( PyExc_TypeError,
+						"expected a float" );
+
+	f = PyFloat_AsDouble(value);
+
+	if (f < 0 || f > 1)
+		return EXPP_ReturnIntError( PyExc_ValueError,
+					      "values must be in range [0,1]" );
+
+	self->mtex->varfac = f;
+
+	return 0;
+}
+
+static PyObject *MTex_getDispFac( BPy_MTex *self, void *closure )
+{
+	return PyFloat_FromDouble(self->mtex->dispfac);
+}
+
+static int MTex_setDispFac( BPy_MTex *self, PyObject *value, void *closure)
+{
+	float f;
+
+	if ( !PyFloat_Check( value ) )
+		return EXPP_ReturnIntError( PyExc_TypeError,
+						"expected a float" );
+
+	f = PyFloat_AsDouble(value);
+
+	if (f < 0 || f > 1)
+		return EXPP_ReturnIntError( PyExc_ValueError,
+					      "values must be in range [0,1]" );
+
+	self->mtex->dispfac = f;
+
+	return 0;
+}
+
+static PyObject *MTex_getWarpFac( BPy_MTex *self, void *closure )
+{
+	return PyFloat_FromDouble(self->mtex->warpfac);
+}
+
+static int MTex_setWarpFac( BPy_MTex *self, PyObject *value, void *closure)
+{
+	float f;
+
+	if ( !PyFloat_Check( value ) )
+		return EXPP_ReturnIntError( PyExc_TypeError,
+						"expected a float" );
+
+	f = PyFloat_AsDouble(value);
+
+	if (f < 0 || f > 1)
+		return EXPP_ReturnIntError( PyExc_ValueError,
+					      "values must be in range [0,1]" );
+
+	self->mtex->warpfac = f;
+
+	return 0;
+}
+
+static PyObject *MTex_getOfs( BPy_MTex *self, void *closure )
+{
+	return Py_BuildValue( "(f,f,f)", self->mtex->ofs[0], self->mtex->ofs[1],
+		self->mtex->ofs[2] );
+}
+
+static int MTex_setOfs( BPy_MTex *self, PyObject *value, void *closure)
+{
+	float f[3];
+	int i;
+
+	if( !PyArg_ParseTuple( value, "fff", &f[0], &f[1], &f[2] ) )
+
+		return EXPP_ReturnIntError( PyExc_TypeError,
+					      "expected tuple of 3 floats" );
+
+	for( i = 0; i < 3; ++i )
+		if( f[i] < -10 || f[i] > 10 )
+			return EXPP_ReturnIntError( PyExc_ValueError,
+					      "values must be in range [-10,10]" );
+
+	self->mtex->ofs[0] = f[0];
+	self->mtex->ofs[1] = f[1];
+	self->mtex->ofs[2] = f[2];
+
+	return 0;
+}
+
+static PyObject *MTex_getSize( BPy_MTex *self, void *closure )
+{
+	return Py_BuildValue( "(f,f,f)", self->mtex->size[0], self->mtex->size[1],
+		self->mtex->size[2] );
+}
+
+static int MTex_setSize( BPy_MTex *self, PyObject *value, void *closure)
+{
+	float f[3];
+	int i;
+
+	if( !PyArg_ParseTuple( value, "fff", &f[0], &f[1], &f[2] ) )
+
+		return EXPP_ReturnIntError( PyExc_TypeError,
+					      "expected tuple of 3 floats" );
+
+	for( i = 0; i < 3; ++i )
+		if( f[i] < -100 || f[i] > 100 )
+			return EXPP_ReturnIntError( PyExc_ValueError,
+					      "values must be in range [-100,100]" );
+
+	self->mtex->size[0] = f[0];
+	self->mtex->size[1] = f[1];
+	self->mtex->size[2] = f[2];
+
+	return 0;
+}
+
+static PyObject *MTex_getMapping( BPy_MTex *self, void *closure )
+{
+	return PyInt_FromLong( self->mtex->mapping );
+}
+
+static int MTex_setMapping( BPy_MTex *self, PyObject *value, void *closure)
+{
+	int n;
+
+	if ( !PyInt_Check( value ) )
+		return EXPP_ReturnIntError( PyExc_TypeError,
+				"Value must be member of Texture.Mappings dictionary" );
+
+	n = PyInt_AsLong(value);
+
+/*	if (n != MTEX_FLAT && n != MTEX_TUBE && n != MTEX_CUBE &&
+		n != MTEX_SPHERE) */
+	if (n < 0 || n > 3)
+	{
+		return EXPP_ReturnIntError( PyExc_ValueError,
+			    "Value must be member of Texture.Mappings dictionary" );
+	}
+
+	self->mtex->mapping = n;
+
+	return 0;
+}
+
+static PyObject *MTex_getFlag( BPy_MTex *self, void *closure )
+{
+	return PyBool_FromLong( self->mtex->texflag & ((int) closure) );
+}
+
+static int MTex_setFlag( BPy_MTex *self, PyObject *value, void *closure)
+{
+	if ( !PyBool_Check( value ) )
+		return EXPP_ReturnIntError( PyExc_TypeError,
+				"expected a bool");
+
+	if ( value == Py_True )
+		self->mtex->texflag |= (int)closure;
+	else
+		self->mtex->texflag &= ~((int) closure);
+
+	return 0;
+}
+
+static PyObject *MTex_getProjX( BPy_MTex *self, void *closure )
+{
+	return PyInt_FromLong( self->mtex->projx );
+}
+
+static int MTex_setProjX( BPy_MTex *self, PyObject *value, void *closure)
+{
+	int proj;
+
+	if( !PyInt_Check( value ) ) {
+		return EXPP_ReturnIntError( PyExc_TypeError,
+			"Value must be a member of Texture.Proj dictionary" );
+	}
+
+	proj = PyInt_AsLong( value ) ;
+
+	/* valid values are from PROJ_N to PROJ_Z = 0 to 3 */
+	if (proj < 0 || proj > 3)
+		return EXPP_ReturnIntError( PyExc_ValueError,
+			"Value must be a member of Texture.Proj dictionary" );
+
+	self->mtex->projx = proj;
+
+	return 0;
+}
+
+static PyObject *MTex_getProjY( BPy_MTex *self, void *closure )
+{
+	return PyInt_FromLong( self->mtex->projy );
+}
+
+static int MTex_setProjY( BPy_MTex *self, PyObject *value, void *closure )
+{
+	int proj;
+
+	if( !PyInt_Check( value ) ) {
+		return EXPP_ReturnIntError( PyExc_TypeError,
+			"Value must be a member of Texture.Proj dictionary" );
+	}
+
+	proj = PyInt_AsLong( value ) ;
+
+	/* valid values are from PROJ_N to PROJ_Z = 0 to 3 */
+	if (proj < 0 || proj > 3)
+		return EXPP_ReturnIntError( PyExc_ValueError,
+			"Value must be a member of Texture.Proj dictionary" );
+
+	self->mtex->projy = proj;
+
+	return 0;
+}
+
+static PyObject *MTex_getProjZ( BPy_MTex *self, void *closure )
+{
+	return PyInt_FromLong( self->mtex->projz );
+}
+
+static int MTex_setProjZ( BPy_MTex *self, PyObject *value, void *closure)
+{
+	int proj;
+
+	if( !PyInt_Check( value ) ) {
+		return EXPP_ReturnIntError( PyExc_TypeError,
+			"Value must be a member of Texture.Proj dictionary" );
+	}
+
+	proj = PyInt_AsLong( value ) ;
+
+	/* valid values are from PROJ_N to PROJ_Z = 0 to 3 */
+	if (proj < 0 || proj > 3)
+		return EXPP_ReturnIntError( PyExc_ValueError,
+			"Value must be a member of Texture.Proj dictionary" );
+
+	self->mtex->projz = proj;
+
+	return 0;
+}
+
+static PyObject *MTex_getMapToFlag( BPy_MTex *self, void *closure )
+{
+	int flag = (int) closure;
+
+	if ( self->mtex->mapto & flag )
+	{
+		return PyInt_FromLong( ( self->mtex->maptoneg & flag ) ? -1 : 1 );
+	} else {
+		return PyInt_FromLong( 0 );
+	}
+}
+
+static int MTex_setMapToFlag( BPy_MTex *self, PyObject *value, void *closure)
+{
+	int flag = (int) closure;
+	int intVal;
+
+	if ( !PyInt_Check( value ) )
+		return EXPP_ReturnIntError( PyExc_TypeError,
+				"expected an int");
+
+	intVal = PyInt_AsLong( value );
+
+	if (flag == MAP_COL || flag == MAP_COLSPEC || flag == MAP_COLMIR ||
+		flag == MAP_WARP) {
+		if (intVal < 0 || intVal > 1) {
+			return EXPP_ReturnIntError( PyExc_ValueError,
+				"value for that mapping must be 0 or 1" );
+		}
+	} else {
+		if (intVal < -1 || intVal > 1) {
+			return EXPP_ReturnIntError( PyExc_ValueError,
+				"value for that mapping must be -1, 0 or 1" );
+		}
+	}
+
+	switch (intVal)
+	{
+	case 0:
+		self->mtex->mapto &= ~flag;
+		self->mtex->maptoneg &= ~flag;
+		break;
+
+	case 1:
+		self->mtex->mapto |= flag;
+		self->mtex->maptoneg &= ~flag;
+		break;
+
+	case -1:
+		self->mtex->mapto |= flag;
+		self->mtex->maptoneg |= flag;
+		break;
+	}
+
+	return 0;
 }
diff --git a/source/blender/python/api2_2x/Texture.c b/source/blender/python/api2_2x/Texture.c
index 30cb602416b..7f576069795 100644
--- a/source/blender/python/api2_2x/Texture.c
+++ b/source/blender/python/api2_2x/Texture.c
@@ -1044,7 +1044,7 @@ static PyObject *M_Texture_STypesDict( void )
 					PyInt_FromLong(TEX_BLENDER));
 		PyConstant_Insert(d, "DN_PERLIN",
 					PyInt_FromLong(TEX_STDPERLIN));
-		PyConstant_Insert(d, "DN_IMPROVEPERLIN",
+		PyConstant_Insert(d, "DN_IMPROVEDPERLIN",
 					PyInt_FromLong(TEX_NEWPERLIN));
 		PyConstant_Insert(d, "DN_VORONOIF1",
 					PyInt_FromLong(TEX_VORONOI_F1));
@@ -1123,6 +1123,7 @@ static PyObject *M_Texture_MapToDict( void )
 		PyConstant_Insert(d, "AMB", PyInt_FromLong(MAP_AMB));
 		PyConstant_Insert(d, "TRANSLU", PyInt_FromLong(MAP_TRANSLU));
 		PyConstant_Insert(d, "DISP", PyInt_FromLong(MAP_DISPLACE));
+		PyConstant_Insert(d, "WARP", PyInt_FromLong(MAP_WARP));
 	}
 	return MapTo;
 }
@@ -1183,7 +1184,7 @@ static PyObject *M_Texture_NoiseDict( void )
 		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, "IMPROVEDPERLIN", 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));
@@ -1196,6 +1197,50 @@ static PyObject *M_Texture_NoiseDict( void )
 	return Noise;
 }
 
+static PyObject *M_Texture_BlendModesDict( void )
+{
+	PyObject *BlendModes = PyConstant_New(  );
+	if( BlendModes ) {
+		BPy_constant *d = ( BPy_constant * ) BlendModes;
+		PyConstant_Insert(d, "MIX", PyInt_FromLong(MTEX_BLEND));
+		PyConstant_Insert(d, "MULTIPLY", PyInt_FromLong(MTEX_MUL));
+		PyConstant_Insert(d, "ADD", PyInt_FromLong(MTEX_ADD));
+		PyConstant_Insert(d, "SUBTRACT", PyInt_FromLong(MTEX_SUB));
+		PyConstant_Insert(d, "DIVIDE", PyInt_FromLong(MTEX_DIV));
+		PyConstant_Insert(d, "DARKEN", PyInt_FromLong(MTEX_DARK));
+		PyConstant_Insert(d, "DIFFERENCE", PyInt_FromLong(MTEX_DIFF));
+		PyConstant_Insert(d, "LIGHTEN", PyInt_FromLong(MTEX_LIGHT));
+		PyConstant_Insert(d, "SCREEN", PyInt_FromLong(MTEX_SCREEN));
+	}
+	return BlendModes;
+}
+
+static PyObject *M_Texture_MappingsDict( void )
+{
+	PyObject *Mappings = PyConstant_New(  );
+	if( Mappings ) {
+		BPy_constant *d = ( BPy_constant * ) Mappings;
+		PyConstant_Insert(d, "FLAT", PyInt_FromLong(MTEX_FLAT));
+		PyConstant_Insert(d, "CUBE", PyInt_FromLong(MTEX_CUBE));
+		PyConstant_Insert(d, "TUBE", PyInt_FromLong(MTEX_TUBE));
+		PyConstant_Insert(d, "SPHERE", PyInt_FromLong(MTEX_SPHERE));
+	}
+	return Mappings;
+}
+
+static PyObject *M_Texture_ProjDict( void )
+{
+	PyObject *Proj = PyConstant_New(  );
+	if( Proj ) {
+		BPy_constant *d = ( BPy_constant * ) Proj;
+		PyConstant_Insert(d, "NONE", PyInt_FromLong(PROJ_N));
+		PyConstant_Insert(d, "X", PyInt_FromLong(PROJ_X));
+		PyConstant_Insert(d, "Y", PyInt_FromLong(PROJ_Y));
+		PyConstant_Insert(d, "Z", PyInt_FromLong(PROJ_Z));
+	}
+	return Proj;
+}
+
 PyObject *Texture_Init( void )
 {
 	PyObject *submodule;
@@ -1210,6 +1255,9 @@ PyObject *Texture_Init( void )
 	PyObject *ExtendModes = M_Texture_ExtendModesDict(  );
 	PyObject *ImageFlags = M_Texture_ImageFlagsDict(  );
 	PyObject *Noise = M_Texture_NoiseDict(  );
+	PyObject *BlendModes = M_Texture_BlendModesDict(  );
+	PyObject *Mappings = M_Texture_MappingsDict(  );
+	PyObject *Proj = M_Texture_ProjDict(  );
 
 	if( PyType_Ready( &Texture_Type ) < 0)
 		return NULL;
@@ -1233,6 +1281,12 @@ PyObject *Texture_Init( void )
 		PyModule_AddObject( submodule, "ImageFlags", ImageFlags );
 	if( Noise )
 		PyModule_AddObject( submodule, "Noise", Noise );
+	if ( BlendModes )
+		PyModule_AddObject( submodule, "BlendModes", BlendModes );
+	if ( Mappings )
+		PyModule_AddObject( submodule, "Mappings", Mappings );
+	if ( Proj )
+		PyModule_AddObject( submodule, "Proj", Proj );
 
 	/* Add the MTex submodule to this module */
 	dict = PyModule_GetDict( submodule );
diff --git a/source/blender/python/api2_2x/doc/API_intro.py b/source/blender/python/api2_2x/doc/API_intro.py
index 999d692ae0c..31ab333f231 100644
--- a/source/blender/python/api2_2x/doc/API_intro.py
+++ b/source/blender/python/api2_2x/doc/API_intro.py
@@ -41,7 +41,7 @@ The Blender Python API Reference
   - L{Text}
   - L{Text3d}
      - L{Font}
-  - L{Texture}
+  - L{Texture} (*)
   - L{TimeLine}
   - L{Types}
   - L{Window}
diff --git a/source/blender/python/api2_2x/doc/Texture.py b/source/blender/python/api2_2x/doc/Texture.py
index 454a6efa40d..18b0be4ccb1 100644
--- a/source/blender/python/api2_2x/doc/Texture.py
+++ b/source/blender/python/api2_2x/doc/Texture.py
@@ -7,6 +7,10 @@
 """
 The Blender.Texture submodule.
 
+B{New}:
+  - many new attributes in L{MTex} submodule
+  - new dictionaries (L{Texture.BlendModes}, L{Texture.Mappings}, L{Texture.Proj}) to use for the values of some of the new L{MTex} attributes.
+
 Texture
 =======
 
@@ -88,7 +92,7 @@ Example::
         - TRI - Produce bands using triangle wave (marble, wood textures)
         - BLENDER - Original Blender algorithm
         - PERLIN - Ken Perlin's original (1985) algorithm
-        - IMPROVEPERLIN - Ken Perlin's newer (2002) algorithm
+        - IMPROVEDPERLIN - Ken Perlin's newer (2002) algorithm
         - VORONOIF1 - none
         - VORONOIF2 - none
         - VORONOIF3 - none
@@ -97,6 +101,32 @@ Example::
         - VORONOICRACKLE - none
         - CELLNOISE - Steven Worley's cellular basis algorithm (1996)
 
+@type BlendModes: readonly dictionary
+@var BlendModes: The available texture blending modes:
+    - MIX - mix texture with value
+    - MULTIPLY - multiply texture with value
+    - ADD - add texture to value
+    - SUBTRACT - subtract texture from value
+    - DIVIDE - divide value by texture
+    - DARKEN - replace value with texture if texture is darker
+    - DIFFERENCE - difference of texture from value
+    - LIGHTEN - replace value with texture if texture is lighter
+    - SCREEN - 'screen' mode
+
+@type Mappings: readonly dictionary
+@var Mappings: The available 2D texture coordinate mappings for images:
+    - FLAT - flat projection
+    - CUBE - cube projection
+    - TUBE - cylindrical projection
+    - SPHERE - spherical projection
+
+@type Proj: readonly dictionary
+@var Proj: The available projections per axis:
+    - NONE - axis isn't used
+    - X - axis is used as final x axis
+    - Y - axis is used as final y axis
+    - Z - axis is used as final z axis
+
 @type STypes: readonly dictionary
 @var STypes: Texture-type specific data. Depending on the value of
     Texture.type, certain groups will make sense. For instance, when a texture 
@@ -151,7 +181,7 @@ Example::
         13. Distorted noise type
             - DN_BLENDER - Original Blender algorithm
             - DN_PERLIN - Ken Perlin's original (1985) algorithm
-            - DN_IMPROVEPERLIN - Ken Perlin's newer (2002) algorithm
+            - DN_IMPROVEDPERLIN - Ken Perlin's newer (2002) algorithm
             - DN_VORONOIF1 - none
             - DN_VORONOIF2 - none
             - DN_VORONOIF3 - none
@@ -177,11 +207,16 @@ Example::
     - NOR - Make the texture affect the rendered normal
     - CSP - Make the texture affect the specularity colour
     - CMIR - Make the texture affect the mirror colour
-    - REF - Make the texture affect the value of the material's reflectivity
-    - SPEC - Make the texture affect the value of specularity
+    - REF - Make the texture affect the diffuse reflectivity value
+    - SPEC - Make the texture affect the specularity value
     - HARD - Make the texture affect the hardness value
     - ALPHA - Make the texture affect the alpha value
-    - EMIT - Make the texture affext the emit value
+    - EMIT - Make the texture affect the emit value
+    - RAYMIR - Make the texture affect the mirror reflectivity value
+    - DISP - Make the texture displace the mesh
+    - TRANSLU - Make the texture affect the translucency value
+    - AMB - Make the texture affect the ambient value
+    - WARP - Make the texture affect texture coordinates for the following textures
 @type MapTo: readonly dictionary
 
 """
@@ -449,6 +484,40 @@ class MTex:
     @type tex: Blender Texture
     @ivar texco: Texture coordinates ("Map input"). See L{TexCo}
     @ivar mapto: "Map to" field of texture. OR'd values of L{MapTo}
+    @ivar object: Object whose space to use when texco is Object
+    @type object: Blender Object
+    @ivar col: Color that the texture blends with
+    @ivar dvar: Value that the texture blends with when not blending colors
+    @ivar blendmode: Texture blending mode. L{BlendModes}
+    @ivar colfac: Factor by which texture affects color
+    @ivar norfac: Factor by which texture affects normal
+    @ivar varfac: Factor by which texture affects most variables
+    @ivar dispfac: Factor by which texture affects displacement
+    @ivar warpfac: Factor by which texture affects warp
+    @ivar ofs: Offset to adjust texture space
+    @ivar size: Size to scale texture space
+    @ivar mapping: Mapping of texture coordinates (flat, cube, etc.). L{Mappings}
+    @ivar stencil: Stencil mode
+    @ivar neg: Negate texture values mode
+    @ivar noRGB: Convert texture RGB values to intensity values
+    @ivar correctNor: Correct normal mapping for Texture space and Object space
+    @ivar xproj: Projection of X axis to Texture space. L{Proj}
+    @ivar yproj: Projection of Y axis to Texture space. L{Proj}
+    @ivar zproj: Projection of Z axis to Texture space. L{Proj}
+    @ivar mtCol: How texture maps to color
+    @ivar mtNor: How texture maps to normals
+    @ivar mtCsp: How texture maps to specularity color
+    @ivar mtCmir: How texture maps to mirror color
+    @ivar mtRef: How texture maps to reflectivity
+    @ivar mtSpec: How texture maps to specularity
+    @ivar mtEmit: How texture maps to emit value
+    @ivar mtAlpha: How texture maps to alpha value
+    @ivar mtHard: How texture maps to hardness
+    @ivar mtRayMir: How texture maps to RayMir value
+    @ivar mtTranslu: How texture maps to translucency
+    @ivar mtAmb: How texture maps to ambient value
+    @ivar mtDisp: How texture maps to displacement
+    @ivar mtWarp: How texture maps to warp
     """
 
     def getIpo():