Material.c

/* 
 *
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version. The Blender
 * Foundation also sells licenses for use in proprietary software under
 * the Blender License.  See http://www.blender.org/BL/ for information
 * about this.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA	02111-1307, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * This is a new part of Blender.
 *
 * Contributor(s): Willian P. Germano, Michel Selten, Alex Mole
 *
 * ***** END GPL/BL DUAL LICENSE BLOCK *****
*/

#include <BKE_main.h>
#include <BKE_global.h>
#include <BKE_library.h>
#include <MEM_guardedalloc.h>
#include <DNA_ID.h>
#include <BLI_blenlib.h>

#include "constant.h"
#include "gen_utils.h"
#include "bpy_types.h"
#include "modules.h"

#include "MTex.h"
#include "Texture.h"

#include "Material.h"

/*****************************************************************************/
/* Python BPy_Material defaults:																						 */
/*****************************************************************************/
#define EXPP_MAT_MODE_TRACEABLE						MA_TRACEBLE
#define EXPP_MAT_MODE_SHADOW							MA_SHADOW
#define EXPP_MAT_MODE_SHADELESS						MA_SHLESS
#define EXPP_MAT_MODE_WIRE								MA_WIRE
#define EXPP_MAT_MODE_VCOL_LIGHT					MA_VERTEXCOL
#define EXPP_MAT_MODE_HALO								MA_HALO
#define EXPP_MAT_MODE_ZTRANSP							MA_ZTRA
#define EXPP_MAT_MODE_VCOL_PAINT					MA_VERTEXCOLP
#define EXPP_MAT_MODE_ZINVERT							MA_ZINV
#define EXPP_MAT_MODE_HALORINGS						MA_HALO_RINGS
#define EXPP_MAT_MODE_ENV									MA_ENV
#define EXPP_MAT_MODE_HALOLINES						MA_HALO_LINES
#define EXPP_MAT_MODE_ONLYSHADOW					MA_ONLYSHADOW
#define EXPP_MAT_MODE_HALOXALPHA					MA_HALO_XALPHA
#define EXPP_MAT_MODE_HALOSTAR						MA_STAR
#define EXPP_MAT_MODE_TEXFACE							MA_FACETEXTURE
#define EXPP_MAT_MODE_HALOTEX							MA_HALOTEX
#define EXPP_MAT_MODE_HALOPUNO						MA_HALOPUNO
#define EXPP_MAT_MODE_NOMIST							MA_NOMIST
#define EXPP_MAT_MODE_HALOSHADE						MA_HALO_SHADE
#define EXPP_MAT_MODE_HALOFLARE						MA_HALO_FLARE
#define EXPP_MAT_MODE_RADIO								MA_RADIO
#define EXPP_MAT_MODE_RAYMIRROR						MA_RAYMIRROR
#define EXPP_MAT_MODE_ZTRA						MA_ZTRA	
#define EXPP_MAT_MODE_RAYTRANSP						MA_RAYTRANSP
#define EXPP_MAT_MODE_ONLYSHADOW					MA_ONLYSHADOW
#define EXPP_MAT_MODE_NOMIST						MA_NOMIST
#define EXPP_MAT_MODE_ENV						MA_ENV
/* Material MIN, MAX values */
#define EXPP_MAT_ADD_MIN					 0.0
#define EXPP_MAT_ADD_MAX					 1.0
#define EXPP_MAT_ALPHA_MIN				 0.0
#define EXPP_MAT_ALPHA_MAX				 1.0
#define EXPP_MAT_AMB_MIN					 0.0
#define EXPP_MAT_AMB_MAX					 1.0
#define EXPP_MAT_COL_MIN					 0.0 /* min/max for all ... */
#define EXPP_MAT_COL_MAX					 1.0 /* ... color triplets	*/
#define EXPP_MAT_EMIT_MIN					 0.0
#define EXPP_MAT_EMIT_MAX					 1.0
#define EXPP_MAT_REF_MIN					 0.0
#define EXPP_MAT_REF_MAX					 1.0
#define EXPP_MAT_SPEC_MIN					 0.0
#define EXPP_MAT_SPEC_MAX					 2.0
#define EXPP_MAT_SPECTRA_MIN			 0.0
#define EXPP_MAT_SPECTRA_MAX			 1.0
#define EXPP_MAT_ZOFFS_MIN				 0.0
#define EXPP_MAT_ZOFFS_MAX				10.0
#define EXPP_MAT_HALOSIZE_MIN			 0.0
#define EXPP_MAT_HALOSIZE_MAX		 100.0
#define EXPP_MAT_FLARESIZE_MIN		 0.1
#define EXPP_MAT_FLARESIZE_MAX		25.0
#define EXPP_MAT_FLAREBOOST_MIN		 0.1
#define EXPP_MAT_FLAREBOOST_MAX		10.0
#define EXPP_MAT_SUBSIZE_MIN			 0.1
#define EXPP_MAT_SUBSIZE_MAX			25.0

#define EXPP_MAT_HARD_MIN				 1
#define EXPP_MAT_HARD_MAX			 255	/* 127 with MODE HALO ON */
#define EXPP_MAT_HALOSEED_MIN		 1
#define EXPP_MAT_HALOSEED_MAX  255
#define EXPP_MAT_NFLARES_MIN		 1
#define EXPP_MAT_NFLARES_MAX		32
#define EXPP_MAT_FLARESEED_MIN	 1
#define EXPP_MAT_FLARESEED_MAX 255
#define EXPP_MAT_NSTARS_MIN			 3
#define EXPP_MAT_NSTARS_MAX			50
#define EXPP_MAT_NLINES_MIN			 0
#define EXPP_MAT_NLINES_MAX		 250
#define EXPP_MAT_NRINGS_MIN			 0
#define EXPP_MAT_NRINGS_MAX			24

#define EXPP_MAT_RAYMIRR_MIN			 0.0
#define EXPP_MAT_RAYMIRR_MAX			 1.0
#define EXPP_MAT_MIRRDEPTH_MIN			 0
#define EXPP_MAT_MIRRDEPTH_MAX			 10
#define EXPP_MAT_FRESNELMIRR_MIN			0.0
#define EXPP_MAT_FRESNELMIRR_MAX			5.0
#define EXPP_MAT_FRESNELMIRRFAC_MIN			1.0
#define EXPP_MAT_FRESNELMIRRFAC_MAX			5.0
#define EXPP_MAT_ZOFFS_MIN				0.0
#define EXPP_MAT_ZOFFS_MAX				10.0
#define EXPP_MAT_IOR_MIN				1.0
#define EXPP_MAT_IOR_MAX				3.0
#define EXPP_MAT_TRANSDEPTH_MIN				0
#define EXPP_MAT_TRANSDEPTH_MAX				10
#define EXPP_MAT_FRESNELTRANS_MIN			0.0
#define EXPP_MAT_FRESNELTRANS_MAX			5.0
#define EXPP_MAT_FRESNELTRANSFAC_MIN			1.0
#define EXPP_MAT_FRESNELTRANSFAC_MAX			5.0
#define EXPP_MAT_SPECTRANS_MIN				0.0
#define EXPP_MAT_SPECTRANS_MAX				1.0
#define EXPP_MAT_MIRRTRANSADD_MIN			0.0
#define EXPP_MAT_MIRRTRANSADD_MAX			1.0







/*****************************************************************************/
/* Python API function prototypes for the Material module.									 */
/*****************************************************************************/
static PyObject *M_Material_New (PyObject *self, PyObject *args,
															 PyObject *keywords);
static PyObject *M_Material_Get (PyObject *self, PyObject *args);

/*****************************************************************************/
/* The following string definitions are used for documentation strings.			 */
/* In Python these will be written to the console when doing a							 */
/* Blender.Material.__doc__																									 */
/*****************************************************************************/
static char M_Material_doc[] =
"The Blender Material module";

static char M_Material_New_doc[] =
"(name) - return a new material called 'name'\n\
() - return a new material called 'Mat'";

static char M_Material_Get_doc[] =
"(name) - return the material called 'name', None if not found.\n\
() - return a list of all materials in the current scene.";

/*****************************************************************************/
/* Python method structure definition for Blender.Material module:					 */
/*****************************************************************************/
struct PyMethodDef M_Material_methods[] = {
	{"New",(PyCFunction)M_Material_New, METH_VARARGS|METH_KEYWORDS,
					M_Material_New_doc},
	{"Get",					M_Material_Get,					METH_VARARGS, M_Material_Get_doc},
	{"get",					M_Material_Get,					METH_VARARGS, M_Material_Get_doc},
	{NULL, NULL, 0, NULL}
};

/*****************************************************************************/
/* Function:							M_Material_New																		 */
/* Python equivalent:			Blender.Material.New															 */
/*****************************************************************************/
static PyObject *M_Material_New(PyObject *self, PyObject *args,
								PyObject *keywords)
{
	char *name = "Mat";
	static char *kwlist[] = {"name", NULL};
	BPy_Material *pymat; /* for Material Data object wrapper in Python */
	Material *blmat; /* for actual Material Data we create in Blender */
	char buf[21];

	if (!PyArg_ParseTupleAndKeywords(args, keywords, "|s", kwlist, &name))
		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
						"expected string or nothing as argument"));

	if (strcmp(name, "Mat") != 0) /* use gave us a name ?*/
		PyOS_snprintf(buf, sizeof(buf), "%s", name);

	blmat = add_material(name); /* first create the Material Data in Blender */

	if (blmat) /* now create the wrapper obj in Python */
		pymat = (BPy_Material *)Material_CreatePyObject (blmat);
	else
		return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
														"couldn't create Material Data in Blender"));

	blmat->id.us = 0; /* was incref'ed by add_material() above */

	if (pymat == NULL)
		return (EXPP_ReturnPyObjError (PyExc_MemoryError,
														"couldn't create Material Data object"));

	return (PyObject *)pymat;
}

/*****************************************************************************/
/* Function:							M_Material_Get																		 */
/* Python equivalent:			Blender.Material.Get															 */
/* Description:						Receives a string and returns the material whose	 */
/*												name matches the string.	If no argument is				 */
/*												passed in, a list with all materials in the				 */
/*												current scene is returned.												 */
/*****************************************************************************/
static PyObject *M_Material_Get(PyObject *self, PyObject *args)
{
	char	 *name = NULL;
	Material *mat_iter;

	if (!PyArg_ParseTuple(args, "|s", &name))
		return (EXPP_ReturnPyObjError (PyExc_TypeError,
						"expected string argument (or nothing)"));

	mat_iter = G.main->mat.first;

	if (name) { /* (name) - Search material by name */

		BPy_Material *wanted_mat = NULL;

		while (mat_iter) {
			if (strcmp (name, mat_iter->id.name+2) == 0) {
				wanted_mat = (BPy_Material *)Material_CreatePyObject (mat_iter);
				break;
			}
			mat_iter = mat_iter->id.next;
		}

		if (wanted_mat == NULL) { /* Requested material doesn't exist */
			char error_msg[64];
			PyOS_snprintf(error_msg, sizeof(error_msg),
											"Material \"%s\" not found", name);
			return EXPP_ReturnPyObjError (PyExc_NameError, error_msg);
		}

		return (PyObject *)wanted_mat;
	}

	else { /* () - return a list with all materials in the scene */
		int index = 0;
		PyObject *matlist, *pyobj;

		matlist = PyList_New (BLI_countlist (&(G.main->mat)));

		if (!matlist)
			return (EXPP_ReturnPyObjError (PyExc_MemoryError,
							"couldn't create PyList"));

		while (mat_iter) {
			pyobj = Material_CreatePyObject (mat_iter);

			if (!pyobj)
				return (EXPP_ReturnPyObjError (PyExc_MemoryError,
									"couldn't create PyObject"));

			PyList_SET_ITEM (matlist, index, pyobj);

			mat_iter = mat_iter->id.next;
			index++;
		}

		return matlist;
	}
}

static PyObject *Lamp_ModesDict (void)
{
	PyObject *Modes = M_constant_New();

#undef EXPP_ADDCONST
#define EXPP_ADDCONST(name) \
	constant_insert(c, #name, PyInt_FromLong(EXPP_MAT_MODE_##name))

/* So that:
 * EXPP_ADDCONST(TRACEABLE) becomes:
 * constant_insert(c, "TRACEABLE", PyInt_FromLong(EXPP_MAT_MODE_TRACEABLE))
 */

	if (Modes) {
		BPy_constant *c = (BPy_constant *)Modes;
		
		EXPP_ADDCONST(TRACEABLE);
		EXPP_ADDCONST(SHADOW);
		EXPP_ADDCONST(SHADELESS);
		EXPP_ADDCONST(WIRE);
		EXPP_ADDCONST(VCOL_LIGHT);
		EXPP_ADDCONST(HALO);
		EXPP_ADDCONST(ZTRANSP);
		EXPP_ADDCONST(VCOL_PAINT);
		EXPP_ADDCONST(ZINVERT);
		EXPP_ADDCONST(HALORINGS);
		EXPP_ADDCONST(ENV);
		EXPP_ADDCONST(HALOLINES);
		EXPP_ADDCONST(ONLYSHADOW);
		EXPP_ADDCONST(HALOXALPHA);
		EXPP_ADDCONST(HALOSTAR);
		EXPP_ADDCONST(TEXFACE);
		EXPP_ADDCONST(HALOTEX);
		EXPP_ADDCONST(HALOPUNO);
		EXPP_ADDCONST(NOMIST);
		EXPP_ADDCONST(HALOSHADE);
		EXPP_ADDCONST(HALOFLARE);
		EXPP_ADDCONST(RADIO);
		EXPP_ADDCONST(RAYMIRROR);
		EXPP_ADDCONST(ZTRA);
		EXPP_ADDCONST(RAYTRANSP);
		EXPP_ADDCONST(ONLYSHADOW);
		EXPP_ADDCONST(NOMIST);
		EXPP_ADDCONST(ENV);

	}

	return Modes;
}

/*****************************************************************************/
/* Function:							Material_Init																			 */
/*****************************************************************************/
PyObject *Material_Init (void)
{
	PyObject	*submodule, *Modes;

	Material_Type.ob_type = &PyType_Type;

	Modes = Lamp_ModesDict ();

	submodule = Py_InitModule3("Blender.Material",
									M_Material_methods, M_Material_doc);

	if (Modes) PyModule_AddObject(submodule, "Modes", Modes);
	return (submodule);
}

/***************************/
/*** The Material PyType ***/
/***************************/

/*****************************************************************************/
/* Python BPy_Material methods declarations:																 */
/*****************************************************************************/
static PyObject *Material_getIpo(BPy_Material *self);
static PyObject *Material_getName(BPy_Material *self);
static PyObject *Material_getMode(BPy_Material *self);
static PyObject *Material_getRGBCol(BPy_Material *self);
/*static PyObject *Material_getAmbCol(BPy_Material *self);*/
static PyObject *Material_getSpecCol(BPy_Material *self);
static PyObject *Material_getMirCol(BPy_Material *self);
static PyObject *Material_getAmb(BPy_Material *self);
static PyObject *Material_getEmit(BPy_Material *self);
static PyObject *Material_getAlpha(BPy_Material *self);
static PyObject *Material_getRef(BPy_Material *self);
static PyObject *Material_getSpec(BPy_Material *self);
static PyObject *Material_getSpecTransp(BPy_Material *self);
static PyObject *Material_getAdd(BPy_Material *self);
static PyObject *Material_getZOffset(BPy_Material *self);
static PyObject *Material_getHaloSize(BPy_Material *self);
static PyObject *Material_getHaloSeed(BPy_Material *self);
static PyObject *Material_getFlareSize(BPy_Material *self);
static PyObject *Material_getFlareSeed(BPy_Material *self);
static PyObject *Material_getFlareBoost(BPy_Material *self);
static PyObject *Material_getSubSize(BPy_Material *self);
static PyObject *Material_getHardness(BPy_Material *self);
static PyObject *Material_getNFlares(BPy_Material *self);
static PyObject *Material_getNStars(BPy_Material *self);
static PyObject *Material_getNLines(BPy_Material *self);
static PyObject *Material_getNRings(BPy_Material *self);
static PyObject *Material_getRayMirr(BPy_Material *self);
static PyObject *Material_getMirrDepth(BPy_Material *self);
static PyObject *Material_getFresnelMirr(BPy_Material *self);
static PyObject *Material_getFresnelMirrFac(BPy_Material *self);
static PyObject *Material_getIOR(BPy_Material *self);
static PyObject *Material_getTransDepth(BPy_Material *self);
static PyObject *Material_getFresnelTrans(BPy_Material *self);
static PyObject *Material_getFresnelTransFac(BPy_Material *self);
static PyObject *Material_getTextures(BPy_Material *self);
static PyObject *Material_setIpo(BPy_Material *self, PyObject *args);
static PyObject *Material_clearIpo(BPy_Material *self);
static PyObject *Material_setName(BPy_Material *self, PyObject *args);
static PyObject *Material_setMode(BPy_Material *self, PyObject *args);
static PyObject *Material_setIntMode(BPy_Material *self, PyObject *args);
static PyObject *Material_setRGBCol(BPy_Material *self, PyObject *args);
/*static PyObject *Material_setAmbCol(BPy_Material *self, PyObject *args);*/
static PyObject *Material_setSpecCol(BPy_Material *self, PyObject *args);
static PyObject *Material_setMirCol(BPy_Material *self, PyObject *args);
static PyObject *Material_setAmb(BPy_Material *self, PyObject *args);
static PyObject *Material_setEmit(BPy_Material *self, PyObject *args);
static PyObject *Material_setAlpha(BPy_Material *self, PyObject *args);
static PyObject *Material_setRef(BPy_Material *self, PyObject *args);
static PyObject *Material_setSpec(BPy_Material *self, PyObject *args);
static PyObject *Material_setSpecTransp(BPy_Material *self, PyObject *args);
static PyObject *Material_setAdd(BPy_Material *self, PyObject *args);
static PyObject *Material_setZOffset(BPy_Material *self, PyObject *args);
static PyObject *Material_setHaloSize(BPy_Material *self, PyObject *args);
static PyObject *Material_setHaloSeed(BPy_Material *self, PyObject *args);
static PyObject *Material_setFlareSize(BPy_Material *self, PyObject *args);
static PyObject *Material_setFlareSeed(BPy_Material *self, PyObject *args);
static PyObject *Material_setFlareBoost(BPy_Material *self, PyObject *args);
static PyObject *Material_setSubSize(BPy_Material *self, PyObject *args);
static PyObject *Material_setHardness(BPy_Material *self, PyObject *args);
static PyObject *Material_setNFlares(BPy_Material *self, PyObject *args);
static PyObject *Material_setNStars(BPy_Material *self, PyObject *args);
static PyObject *Material_setNLines(BPy_Material *self, PyObject *args);
static PyObject *Material_setNRings(BPy_Material *self, PyObject *args);
/* ** Mirror and transp ** */
static PyObject *Material_setRayMirr(BPy_Material *self, PyObject *args);
static PyObject *Material_setMirrDepth(BPy_Material *self, PyObject *args);
static PyObject *Material_setFresnelMirr(BPy_Material *self, PyObject *args); 
static PyObject *Material_setFresnelMirrFac(BPy_Material *self, PyObject *args); 
static PyObject *Material_setIOR(BPy_Material *self, PyObject *args); 
static PyObject *Material_setTransDepth(BPy_Material *self, PyObject *args);
static PyObject *Material_setFresnelTrans(BPy_Material *self, PyObject *args); 
static PyObject *Material_setFresnelTransFac(BPy_Material *self, PyObject *args); 
/* ** */
static PyObject *Material_setTexture(BPy_Material *self, PyObject *args);
static PyObject *Material_clearTexture(BPy_Material *self, PyObject *args);

static PyObject *Material_setColorComponent(BPy_Material *self, char *key,
								PyObject *args);

static PyObject *Material_getScriptLinks(BPy_Material *self, PyObject *args);
static PyObject *Material_addScriptLink(BPy_Material *self, PyObject *args);
static PyObject *Material_clearScriptLinks(BPy_Material *self);

/*****************************************************************************/
/* Python BPy_Material methods table:																				 */
/*****************************************************************************/
static PyMethodDef BPy_Material_methods[] = {
 /* name, method, flags, doc */
	{"getName", (PyCFunction)Material_getName, METH_NOARGS,
			"() - Return Material's name"},
	{"getIpo", (PyCFunction)Material_getIpo, METH_NOARGS,
			"() - Return Material's ipo or None if not found"},
	{"getMode", (PyCFunction)Material_getMode, METH_NOARGS,
			"() - Return Material's mode flags"},
	{"getRGBCol", (PyCFunction)Material_getRGBCol, METH_NOARGS,
			"() - Return Material's rgb color triplet"},
/*	{"getAmbCol", (PyCFunction)Material_getAmbCol, METH_NOARGS,
			"() - Return Material's ambient color"},*/
	{"getSpecCol", (PyCFunction)Material_getSpecCol, METH_NOARGS,
			"() - Return Material's specular color"},
	{"getMirCol", (PyCFunction)Material_getMirCol, METH_NOARGS,
			"() - Return Material's mirror color"},
	{"getAmb", (PyCFunction)Material_getAmb, METH_NOARGS,
			"() - Return Material's ambient color blend factor"},
	{"getEmit", (PyCFunction)Material_getEmit, METH_NOARGS,
			"() - Return Material's emitting light intensity"},
	{"getAlpha", (PyCFunction)Material_getAlpha, METH_NOARGS,
			"() - Return Material's alpha (transparency) value"},
	{"getRef", (PyCFunction)Material_getRef, METH_NOARGS,
			"() - Return Material's reflectivity"},
	{"getSpec", (PyCFunction)Material_getSpec, METH_NOARGS,
			"() - Return Material's specularity"},
	{"getSpecTransp", (PyCFunction)Material_getSpecTransp, METH_NOARGS,
			"() - Return Material's specular transparency"},
	{"getAdd", (PyCFunction)Material_getAdd, METH_NOARGS,
			"() - Return Material's glow factor"},
	{"getZOffset", (PyCFunction)Material_getZOffset, METH_NOARGS,
			"() - Return Material's artificial offset for faces"},
	{"getHaloSize", (PyCFunction)Material_getHaloSize, METH_NOARGS,
			"() - Return Material's halo size"},
	{"getHaloSeed", (PyCFunction)Material_getHaloSeed, METH_NOARGS,
			"() - Return Material's seed for random ring dimension and line "
			"location in halos"},
	{"getFlareSize", (PyCFunction)Material_getFlareSize, METH_NOARGS,
			"() - Return Material's (flare size)/(halo size) factor"},
	{"getFlareSeed", (PyCFunction)Material_getFlareSeed, METH_NOARGS,
			"() - Return Material's flare offset in the seed table"},
	{"getFlareBoost", (PyCFunction)Material_getFlareBoost, METH_NOARGS,
			"() - Return Material's flare boost"},
	{"getSubSize", (PyCFunction)Material_getSubSize, METH_NOARGS,
			"() - Return Material's dimension of subflare, dots and circles"},
	{"getHardness", (PyCFunction)Material_getHardness, METH_NOARGS,
			"() - Return Material's specular hardness"},
	{"getNFlares", (PyCFunction)Material_getNFlares, METH_NOARGS,
			"() - Return Material's number of flares in halo"},
	{"getNStars", (PyCFunction)Material_getNStars, METH_NOARGS,
			"() - Return Material's number of points in the halo stars"},
	{"getNLines", (PyCFunction)Material_getNLines, METH_NOARGS,
			"() - Return Material's number of lines in halo"},
	{"getNRings", (PyCFunction)Material_getNRings, METH_NOARGS,
			"() - Return Material's number of rings in halo"},
	{"getRayMirr", (PyCFunction)Material_getRayMirr, METH_NOARGS,
			"() - Return mount mirror"},
	{"getMirrDepth", (PyCFunction)Material_getMirrDepth, METH_NOARGS,
			"() - Return amount mirror depth"},
	{"getFresnelMirr", (PyCFunction)Material_getFresnelMirr, METH_NOARGS,
			"() - Return fresnel power for refractions"},
	{"getFresnelMirrFac", (PyCFunction)Material_getFresnelMirrFac, METH_NOARGS,
			"() - Return fresnel power for refractions factor"},
	{"getIOR", (PyCFunction)Material_getIOR, METH_NOARGS,
			"() - Return IOR"},
	{"getTransDepth", (PyCFunction)Material_getTransDepth, METH_NOARGS,
			"() - Return amount inter-refractions"},
	{"getFresnelTrans", (PyCFunction)Material_getFresnelTrans, METH_NOARGS,
			"() - Return fresnel power for refractions"},
	{"getFresnelTransFac", (PyCFunction)Material_getFresnelTransFac, METH_NOARGS,
			"() - Return fresnel power for refractions factor"},
	{"getTextures", (PyCFunction)Material_getTextures, METH_NOARGS,
			"() - Return Material's texture list as a tuple"},
	{"setName", (PyCFunction)Material_setName, METH_VARARGS,
			"(s) - Change Material's name"},
	{"setIpo", (PyCFunction)Material_setIpo, METH_VARARGS,
			"(Blender Ipo) - Change Material's Ipo"},
	{"clearIpo", (PyCFunction)Material_clearIpo, METH_NOARGS,
			"(Blender Ipo) - Unlink Ipo from this Material"},
	{"setMode", (PyCFunction)Material_setMode, METH_VARARGS,
			"([s[,s]]) - Set Material's mode flag(s)"},
	{"setRGBCol", (PyCFunction)Material_setRGBCol, METH_VARARGS,
			"(f,f,f or [f,f,f]) - Set Material's rgb color triplet"},
/*	{"setAmbCol", (PyCFunction)Material_setAmbCol, METH_VARARGS,
			"(f,f,f or [f,f,f]) - Set Material's ambient color"},*/
	{"setSpecCol", (PyCFunction)Material_setSpecCol, METH_VARARGS,
			"(f,f,f or [f,f,f]) - Set Material's specular color"},
	{"setMirCol", (PyCFunction)Material_setMirCol, METH_VARARGS,
			"(f,f,f or [f,f,f]) - Set Material's mirror color"},
	{"setAmb", (PyCFunction)Material_setAmb, METH_VARARGS,
			"(f) - Set how much the Material's color is affected"
							" by \nthe global ambient colors - [0.0, 1.0]"},
	{"setEmit", (PyCFunction)Material_setEmit, METH_VARARGS,
			"(f) - Set Material's emitting light intensity - [0.0, 1.0]"},
	{"setAlpha", (PyCFunction)Material_setAlpha, METH_VARARGS,
			"(f) - Set Material's alpha (transparency) - [0.0, 1.0]"},
	{"setRef", (PyCFunction)Material_setRef, METH_VARARGS,
			"(f) - Set Material's reflectivity - [0.0, 1.0]"},
	{"setSpec", (PyCFunction)Material_setSpec, METH_VARARGS,
			"(f) - Set Material's specularity - [0.0, 2.0]"},
	{"setSpecTransp", (PyCFunction)Material_setSpecTransp, METH_VARARGS,
			"(f) - Set Material's specular transparency - [0.0, 1.0]"},
	{"setAdd", (PyCFunction)Material_setAdd, METH_VARARGS,
			"(f) - Set Material's glow factor - [0.0, 1.0]"},
	{"setZOffset", (PyCFunction)Material_setZOffset, METH_VARARGS,
			"(f) - Set Material's artificial offset - [0.0, 10.0]"},
	{"setHaloSize", (PyCFunction)Material_setHaloSize, METH_VARARGS,
			"(f) - Set Material's halo size - [0.0, 100.0]"},
	{"setHaloSeed", (PyCFunction)Material_setHaloSeed, METH_VARARGS,
			"(i) - Set Material's halo seed - [0, 255]"},
	{"setFlareSize", (PyCFunction)Material_setFlareSize, METH_VARARGS,
			"(f) - Set Material's factor: (flare size)/(halo size) - [0.1, 25.0]"},
	{"setFlareSeed", (PyCFunction)Material_setFlareSeed, METH_VARARGS,
			"(i) - Set Material's flare seed - [0, 255]"},
	{"setFlareBoost", (PyCFunction)Material_setFlareBoost, METH_VARARGS,
			"(f) - Set Material's flare boost - [0.1, 10.0]"},
	{"setSubSize", (PyCFunction)Material_setSubSize, METH_VARARGS,
			"(f) - Set Material's dimension of subflare,"
							" dots and circles - [0.1, 25.0]"},
	{"setHardness", (PyCFunction)Material_setHardness, METH_VARARGS,
			"(i) - Set Material's hardness - [1, 255 (127 if halo mode is ON)]"},
	{"setNFlares", (PyCFunction)Material_setNFlares, METH_VARARGS,
			"(i) - Set Material's number of flares in halo - [1, 32]"},
	{"setNStars", (PyCFunction)Material_setNStars, METH_VARARGS,
			"(i) - Set Material's number of stars in halo - [3, 50]"},
	{"setNLines", (PyCFunction)Material_setNLines, METH_VARARGS,
			"(i) - Set Material's number of lines in halo - [0, 250]"},
	{"setNRings", (PyCFunction)Material_setNRings, METH_VARARGS,
			"(i) - Set Material's number of rings in halo - [0, 24]"},
	{"setRayMirr", (PyCFunction)Material_setRayMirr, METH_VARARGS,
			"(f) - Set amount mirror - [0.0, 1.0]"},
	{"setMirrDepth", (PyCFunction)Material_setMirrDepth, METH_VARARGS,
			"(i) - Set amount inter-reflections - [0, 10]"},
	{"setFresnelMirr", (PyCFunction)Material_setFresnelMirr, METH_VARARGS,
			"(f) - Set fresnel power for mirror - [0.0, 5.0]"},
	{"setFresnelMirrFac", (PyCFunction)Material_setFresnelMirrFac, METH_VARARGS,
			"(f) - Set blend fac for mirror fresnel - [1.0, 5.0]"},
	{"setIOR", (PyCFunction)Material_setIOR, METH_VARARGS,
			"(f) - Set IOR - [1.0, 3.0]"},
	{"setTransDepth", (PyCFunction)Material_setTransDepth, METH_VARARGS,
			"(i) - Set amount inter-refractions - [0, 10]"},
	{"setFresnelTrans", (PyCFunction)Material_setFresnelTrans, METH_VARARGS,
			"(f) - Set fresnel power for refractions - [0.0, 5.0]"},
	{"setFresnelTransFac", (PyCFunction)Material_setFresnelTransFac, METH_VARARGS,
			"(f) - Set fresnel power for refractions factot- [0.0, 5.0]"},
	{"setTexture", (PyCFunction)Material_setTexture, METH_VARARGS,
			 "(n,tex,texco=0,mapto=0) - Set numbered texture to tex"},
	{"clearTexture", (PyCFunction)Material_clearTexture, METH_VARARGS,
			"(n) - Remove texture from numbered slot"},
	{"getScriptLinks", (PyCFunction)Material_getScriptLinks, METH_VARARGS,
			"(eventname) - Get a list of this material's scriptlinks (Text names) "
			"of the given type\n"
	"(eventname) - string: FrameChanged or Redraw."},
	{"addScriptLink", (PyCFunction)Material_addScriptLink, METH_VARARGS,
			"(text, evt) - Add a new material scriptlink.\n"
	"(text) - string: an existing Blender Text name;\n"
	"(evt) string: FrameChanged or Redraw."},
	{"clearScriptLinks", (PyCFunction)Material_clearScriptLinks, METH_NOARGS,
			"() - Delete all scriptlinks from this material."},
	{NULL, NULL, 0, NULL}
};

/*****************************************************************************/
/* Python Material_Type callback function prototypes:												 */
/*****************************************************************************/
static void Material_dealloc (BPy_Material *self);
static int Material_setAttr (BPy_Material *self, char *name, PyObject *v);
static PyObject *Material_getAttr (BPy_Material *self, char *name);
static PyObject *Material_repr (BPy_Material *self);

/*****************************************************************************/
/* Python Material_Type structure definition:																 */
/*****************************************************************************/
PyTypeObject Material_Type =
{
	PyObject_HEAD_INIT(NULL)
	0,																			/* ob_size */
	"Blender Material",											/* tp_name */
	sizeof (BPy_Material),									/* tp_basicsize */
	0,																			/* tp_itemsize */
	/* methods */
	(destructor)Material_dealloc,						/* tp_dealloc */
	0,																			/* tp_print */
	(getattrfunc)Material_getAttr,					/* tp_getattr */
	(setattrfunc)Material_setAttr,					/* tp_setattr */
	0,																			/* tp_compare */
	(reprfunc)Material_repr,								/* tp_repr */
	0,																			/* tp_as_number */
	0,																			/* tp_as_sequence */
	0,																			/* tp_as_mapping */
	0,																			/* tp_as_hash */
	0,0,0,0,0,0,
	0,																			/* tp_doc */ 
	0,0,0,0,0,0,
	BPy_Material_methods,											/* tp_methods */
	0,																			/* tp_members */
};

/*****************************************************************************/
/* Function:		Material_dealloc																						 */
/* Description: This is a callback function for the BPy_Material type. It is */
/*							the destructor function.																		 */
/*****************************************************************************/
static void Material_dealloc (BPy_Material *self)
{
	Py_DECREF (self->col);
	Py_DECREF (self->amb);
	Py_DECREF (self->spec);
	Py_DECREF (self->mir);
	PyObject_DEL (self);
}

/*****************************************************************************/
/* Function:		Material_CreatePyObject																			 */
/* Description: This function will create a new BPy_Material from an existing*/
/*							Blender material structure.																	 */
/*****************************************************************************/
PyObject *Material_CreatePyObject (struct Material *mat)
{
	BPy_Material *pymat;
	float *col[3], *amb[3], *spec[3], *mir[3];

	pymat = (BPy_Material *)PyObject_NEW (BPy_Material, &Material_Type);

	if (!pymat)
		return EXPP_ReturnPyObjError (PyExc_MemoryError,
						"couldn't create BPy_Material object");

	pymat->material = mat;

	col[0] = &mat->r;
	col[1] = &mat->g;
	col[2] = &mat->b;

	amb[0] = &mat->ambr;
	amb[1] = &mat->ambg;
	amb[2] = &mat->ambb;

	spec[0] = &mat->specr;
	spec[1] = &mat->specg;
	spec[2] = &mat->specb;

	mir[0] = &mat->mirr;
	mir[1] = &mat->mirg;
	mir[2] = &mat->mirb;

	pymat->col	= (BPy_rgbTuple *)rgbTuple_New(col);
	pymat->amb	= (BPy_rgbTuple *)rgbTuple_New(amb);
	pymat->spec 	= (BPy_rgbTuple *)rgbTuple_New(spec);
	pymat->mir	= (BPy_rgbTuple *)rgbTuple_New(mir);

	return (PyObject *)pymat;
}

/*****************************************************************************/
/* Function:		Material_CheckPyObject																			 */
/* Description: This function returns true when the given PyObject is of the */
/*							type Material. Otherwise it will return false.							 */
/*****************************************************************************/
int Material_CheckPyObject (PyObject *pyobj)
{
	return (pyobj->ob_type == &Material_Type);
}

/*****************************************************************************/
/* Function:		Material_FromPyObject																				 */
/* Description: This function returns the Blender material from the given		 */
/*							PyObject.																										 */
/*****************************************************************************/
Material *Material_FromPyObject (PyObject *pyobj)
{
	return ((BPy_Material *)pyobj)->material;
}

/*****************************************************************************/
/* Description: Returns the object with the name specified by the argument	 */
/*							name. Note that the calling function has to remove the first */
/*							two characters of the object name. These two characters			 */
/*							specify the type of the object (OB, ME, WO, ...)						 */
/*							The function will return NULL when no object with the given  */
/*							name is found.																							 */
/*****************************************************************************/
Material * GetMaterialByName (char * name)
{
	Material	* mat_iter;

	mat_iter = G.main->mat.first;
	while (mat_iter)
	{
		if (StringEqual (name, GetIdName (&(mat_iter->id))))
		{
			return (mat_iter);
		}
		mat_iter = mat_iter->id.next;
	}

	/* There is no material with the given name */
	return (NULL);
}

/*****************************************************************************/
/* Python BPy_Material methods:																								 */
/*****************************************************************************/

static PyObject *Material_getIpo(BPy_Material *self)
{
	Ipo *ipo = self->material->ipo;

	if (!ipo) {
		Py_INCREF(Py_None);
		return Py_None;
	}
	
	return Ipo_CreatePyObject (ipo);
}

static PyObject *Material_getName(BPy_Material *self)
{
	PyObject *attr = PyString_FromString(self->material->id.name+2);

	if (attr) return attr;

	return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't get Material.name attribute"));
}

static PyObject *Material_getMode(BPy_Material *self)
{
	PyObject *attr = PyInt_FromLong((long)self->material->mode);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't get Material.Mode attribute");
}

static PyObject *Material_getRGBCol(BPy_Material *self)
{
	return rgbTuple_getCol(self->col);
}
/*
static PyObject *Material_getAmbCol(BPy_Material *self)
{
	return rgbTuple_getCol(self->amb);
}
*/
static PyObject *Material_getSpecCol(BPy_Material *self)
{
	return rgbTuple_getCol(self->spec);
}

static PyObject *Material_getMirCol(BPy_Material *self)
{
	return rgbTuple_getCol(self->mir);
}

static PyObject *Material_getAmb(BPy_Material *self)
{
	PyObject *attr = PyFloat_FromDouble((double)self->material->amb);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't get Material.amb attribute");
}

static PyObject *Material_getEmit(BPy_Material *self)
{
	PyObject *attr = PyFloat_FromDouble((double)self->material->emit);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't get Material.emit attribute");
}

static PyObject *Material_getAlpha(BPy_Material *self)
{
	PyObject *attr = PyFloat_FromDouble((double)self->material->alpha);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't get Material.alpha attribute");
}

static PyObject *Material_getRef(BPy_Material *self)
{
	PyObject *attr = PyFloat_FromDouble((double)self->material->ref);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't get Material.ref attribute");
}

static PyObject *Material_getSpec(BPy_Material *self)
{
	PyObject *attr = PyFloat_FromDouble((double)self->material->spec);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't get Material.spec attribute");
}

static PyObject *Material_getSpecTransp(BPy_Material *self)
{
	PyObject *attr = PyFloat_FromDouble((double)self->material->spectra);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
							"couldn't get Material.specTransp attribute");
}

static PyObject *Material_getAdd(BPy_Material *self)
{
	PyObject *attr = PyFloat_FromDouble((double)self->material->add);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
																	 "couldn't get Material.add attribute");
}

static PyObject *Material_getZOffset(BPy_Material *self)
{
	PyObject *attr = PyFloat_FromDouble((double)self->material->zoffs);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
												"couldn't get Material.zOffset attribute");
}

static PyObject *Material_getHaloSize(BPy_Material *self)
{
	PyObject *attr = PyFloat_FromDouble((double)self->material->hasize);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
									 "couldn't get Material.haloSize attribute");
}

static PyObject *Material_getFlareSize(BPy_Material *self)
{
	PyObject *attr = PyFloat_FromDouble((double)self->material->flaresize);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
										 "couldn't get Material.flareSize attribute");
}

static PyObject *Material_getFlareBoost(BPy_Material *self)
{
	PyObject *attr = PyFloat_FromDouble((double)self->material->flareboost);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
										 "couldn't get Material.flareBoost attribute");
}

static PyObject *Material_getSubSize(BPy_Material *self)
{
	PyObject *attr = PyFloat_FromDouble((double)self->material->subsize);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
							 "couldn't get Material.subSize attribute");
}

static PyObject *Material_getHaloSeed(BPy_Material *self)
{
	PyObject *attr = PyInt_FromLong((long)self->material->seed1);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
											 "couldn't get Material.haloSeed attribute");
}

static PyObject *Material_getFlareSeed(BPy_Material *self)
{
	PyObject *attr = PyInt_FromLong((long)self->material->seed2);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
											 "couldn't get Material.flareSeed attribute");
}

static PyObject *Material_getHardness(BPy_Material *self)
{
	PyObject *attr = PyInt_FromLong((long)self->material->har);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
											 "couldn't get Material.hard attribute");
}

static PyObject *Material_getNFlares(BPy_Material *self)
{
	PyObject *attr = PyInt_FromLong((long)self->material->flarec);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
											 "couldn't get Material.nFlares attribute");
}

static PyObject *Material_getNStars(BPy_Material *self)
{
	PyObject *attr = PyInt_FromLong((long)self->material->starc);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
											 "couldn't get Material.nStars attribute");
}

static PyObject *Material_getNLines(BPy_Material *self)
{
	PyObject *attr = PyInt_FromLong((long)self->material->linec);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
											 "couldn't get Material.nLines attribute");
}

static PyObject *Material_getNRings(BPy_Material *self)
{
	PyObject *attr = PyInt_FromLong((long)self->material->ringc);

	if (attr) return attr;

	return EXPP_ReturnPyObjError (PyExc_RuntimeError,
											 "couldn't get Material.nRings attribute");
}

static PyObject *Material_getRayMirr(BPy_Material *self)
{
	PyObject *attr = PyFloat_FromDouble((double)self->material->ray_mirror);