Major documentation updates. The original Freestyle API reference

(http://freestyle.sourceforge.net/doc/html/index.html) has been
incorporated into the Blender/Freestyle Python API implementation
in the form of Sphinx-based embedded docstrings.  Some C++-specific
descriptions of classes and functions were revised so that they are
suitable for Python programmers.  Missing docstrings were filled,
and sparse descriptions were extended.  By means of the new
documentation system for Blender, an up-to-date Freestyle Python
API reference will be part of the Blender 2.5 documentation.

1 files changed, 365 insertions, 135 deletions

diff --git a/source/blender/freestyle/intern/python/BPy_FrsMaterial.cpp b/source/blender/freestyle/intern/python/BPy_FrsMaterial.cpp
index 462ea7e3430..0eea750440c 100644
--- a/source/blender/freestyle/intern/python/BPy_FrsMaterial.cpp
+++ b/source/blender/freestyle/intern/python/BPy_FrsMaterial.cpp
@@ -8,112 +8,6 @@ extern "C" {
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
-/*---------------  Python API function prototypes for FrsMaterial instance  -----------*/
-static int FrsMaterial___init__(BPy_FrsMaterial *self, PyObject *args, PyObject *kwds);
-static void FrsMaterial___dealloc__(BPy_FrsMaterial *self);
-static PyObject * FrsMaterial___repr__(BPy_FrsMaterial *self);
-
-static PyObject * FrsMaterial_diffuse( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_diffuseR( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_diffuseG( BPy_FrsMaterial* self) ;
-static PyObject * FrsMaterial_diffuseB( BPy_FrsMaterial* self) ;
-static PyObject * FrsMaterial_diffuseA( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_specular( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_specularR( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_specularG( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_specularB( BPy_FrsMaterial* self) ;
-static PyObject * FrsMaterial_specularA( BPy_FrsMaterial* self) ;
-static PyObject * FrsMaterial_ambient( BPy_FrsMaterial* self) ;
-static PyObject * FrsMaterial_ambientR( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_ambientG( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_ambientB( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_ambientA( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_emission( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_emissionR( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_emissionG( BPy_FrsMaterial* self) ;
-static PyObject * FrsMaterial_emissionB( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_emissionA( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_shininess( BPy_FrsMaterial* self);
-static PyObject * FrsMaterial_setDiffuse( BPy_FrsMaterial *self, PyObject *args );
-static PyObject * FrsMaterial_setSpecular( BPy_FrsMaterial *self, PyObject *args );
-static PyObject * FrsMaterial_setAmbient( BPy_FrsMaterial *self, PyObject *args );
-static PyObject * FrsMaterial_setEmission( BPy_FrsMaterial *self, PyObject *args );
-static PyObject * FrsMaterial_setShininess( BPy_FrsMaterial *self, PyObject *args );
-
-/*----------------------FrsMaterial instance definitions ----------------------------*/
-static PyMethodDef BPy_FrsMaterial_methods[] = {
-	{"diffuse", ( PyCFunction ) FrsMaterial_diffuse, METH_NOARGS, "() Returns the diffuse color as a 4 float array"},
-	{"diffuseR", ( PyCFunction ) FrsMaterial_diffuseR, METH_NOARGS, "() Returns the red component of the diffuse color "},
-	{"diffuseG", ( PyCFunction ) FrsMaterial_diffuseG, METH_NOARGS, "() Returns the green component of the diffuse color "},
-	{"diffuseB", ( PyCFunction ) FrsMaterial_diffuseB, METH_NOARGS, "() Returns the blue component of the diffuse color "},
-	{"diffuseA", ( PyCFunction ) FrsMaterial_diffuseA, METH_NOARGS, "() Returns the alpha component of the diffuse color "},
-	{"specular", ( PyCFunction ) FrsMaterial_specular, METH_NOARGS, "() Returns the specular color as a 4 float array"},
-	{"specularR", ( PyCFunction ) FrsMaterial_specularR, METH_NOARGS, "() Returns the red component of the specular color "},
-	{"specularG", ( PyCFunction ) FrsMaterial_specularG, METH_NOARGS, "() Returns the green component of the specular color "},
-	{"specularB", ( PyCFunction ) FrsMaterial_specularB, METH_NOARGS, "() Returns the blue component of the specular color "},
-	{"specularA", ( PyCFunction ) FrsMaterial_specularA, METH_NOARGS, "() Returns the alpha component of the specular color "},
-	{"ambient", ( PyCFunction ) FrsMaterial_ambient, METH_NOARGS, "() Returns the ambient color as a 4 float array"},
-	{"ambientR", ( PyCFunction ) FrsMaterial_ambientR, METH_NOARGS, "() Returns the red component of the ambient color "},
-	{"ambientG", ( PyCFunction ) FrsMaterial_ambientG, METH_NOARGS, "() Returns the green component of the ambient color "},
-	{"ambientB", ( PyCFunction ) FrsMaterial_ambientB, METH_NOARGS, "() Returns the blue component of the ambient color "},
-	{"ambientA", ( PyCFunction ) FrsMaterial_ambientA, METH_NOARGS, "() Returns the alpha component of the ambient color "},
-	{"emission", ( PyCFunction ) FrsMaterial_emission, METH_NOARGS, "() Returns the emission color as a 4 float array"},
-	{"emissionR", ( PyCFunction ) FrsMaterial_emissionR, METH_NOARGS, "() Returns the red component of the emission color "},
-	{"emissionG", ( PyCFunction ) FrsMaterial_emissionG, METH_NOARGS, "() Returns the green component of the emission color "},
-	{"emissionB", ( PyCFunction ) FrsMaterial_emissionB, METH_NOARGS, "() Returns the blue component of the emission color "},
-	{"emissionA", ( PyCFunction ) FrsMaterial_emissionA, METH_NOARGS, "() Returns the alpha component of the emission color "},
-	{"shininess", ( PyCFunction ) FrsMaterial_shininess, METH_NOARGS, "() Returns the shininess coefficient "},
-	{"setDiffuse", ( PyCFunction ) FrsMaterial_setDiffuse, METH_NOARGS, "(float r, float g, float b, float a) Sets the diffuse color"},
-	{"setSpecular", ( PyCFunction ) FrsMaterial_setSpecular, METH_NOARGS, "(float r, float g, float b, float a) Sets the specular color"},
-	{"setAmbient", ( PyCFunction ) FrsMaterial_setAmbient, METH_NOARGS, "(float r, float g, float b, float a) Sets the ambient color"},
-	{"setEmission", ( PyCFunction ) FrsMaterial_setEmission, METH_NOARGS, "(float r, float g, float b, float a) Sets the emission color"},
-	{"setShininess", ( PyCFunction ) FrsMaterial_setShininess, METH_NOARGS, "(float r, float g, float b, float a) Sets the shininess color"},
-	{NULL, NULL, 0, NULL}
-};
-
-/*-----------------------BPy_FrsMaterial type definition ------------------------------*/
-
-PyTypeObject FrsMaterial_Type = {
-	PyVarObject_HEAD_INIT(NULL, 0)
-	"FrsMaterial",                  /* tp_name */
-	sizeof(BPy_FrsMaterial),        /* tp_basicsize */
-	0,                              /* tp_itemsize */
-	(destructor)FrsMaterial___dealloc__, /* tp_dealloc */
-	0,                              /* tp_print */
-	0,                              /* tp_getattr */
-	0,                              /* tp_setattr */
-	0,                              /* tp_reserved */
-	(reprfunc)FrsMaterial___repr__, /* tp_repr */
-	0,                              /* tp_as_number */
-	0,                              /* tp_as_sequence */
-	0,                              /* tp_as_mapping */
-	0,                              /* tp_hash  */
-	0,                              /* tp_call */
-	0,                              /* tp_str */
-	0,                              /* tp_getattro */
-	0,                              /* tp_setattro */
-	0,                              /* tp_as_buffer */
-	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
-	"FrsMaterial objects",          /* tp_doc */
-	0,                              /* tp_traverse */
-	0,                              /* tp_clear */
-	0,                              /* tp_richcompare */
-	0,                              /* tp_weaklistoffset */
-	0,                              /* tp_iter */
-	0,                              /* tp_iternext */
-	BPy_FrsMaterial_methods,        /* tp_methods */
-	0,                              /* tp_members */
-	0,                              /* tp_getset */
-	0,                              /* tp_base */
-	0,                              /* tp_dict */
-	0,                              /* tp_descr_get */
-	0,                              /* tp_descr_set */
-	0,                              /* tp_dictoffset */
-	(initproc)FrsMaterial___init__, /* tp_init */
-	0,                              /* tp_alloc */
-	PyType_GenericNew,              /* tp_new */
-};
-
 //-------------------MODULE INITIALIZATION--------------------------------
 int FrsMaterial_Init( PyObject *module )
 {
@@ -130,6 +24,36 @@ int FrsMaterial_Init( PyObject *module )
 
 //------------------------INSTANCE METHODS ----------------------------------
 
+static char FrsMaterial___doc__[] =
+"Class defining a material.\n"
+"\n"
+".. method:: __init__()\n"
+"\n"
+"   Default constructor.\n"
+"\n"
+".. method:: __init__(m)\n"
+"\n"
+"   Copy constructor.\n"
+"\n"
+"   :arg m: A Material object.\n"
+"   :type m: :class:`FrsMaterial`\n"
+"\n"
+".. method:: __init__(iDiffuse, iAmbiant, iSpecular, iEmission, iShininess)\n"
+"\n"
+"   Builds a Material from its diffuse, ambiant, specular, emissive\n"
+"   colors and a shininess coefficient.\n"
+"\n"
+"   :arg iDiffuse: The diffuse color.\n"
+"   :type iDiffuse: :class:`Mathutils.Vector`, list of tuple of 4 float values\n"
+"   :arg iAmbiant: The ambiant color.\n"
+"   :type iAmbiant: :class:`Mathutils.Vector`, list of tuple of 4 float values\n"
+"   :arg iSpecular: The specular color.\n"
+"   :type iSpecular: :class:`Mathutils.Vector`, list of tuple of 4 float values\n"
+"   :arg iEmission: The emissive color.\n"
+"   :type iEmission: :class:`Mathutils.Vector`, list of tuple of 4 float values\n"
+"   :arg iShininess: The shininess coefficient.\n"
+"   :type iShininess: :class:`Mathutils.Vector`, list of tuple of 4 float values\n";
+
 static int Vec4(PyObject *obj, float *v)
 {
 	if (VectorObject_Check(obj) && ((VectorObject *)obj)->size == 4) {
@@ -147,7 +71,7 @@ static int Vec4(PyObject *obj, float *v)
 	return 1;
 }
 
-int FrsMaterial___init__(BPy_FrsMaterial *self, PyObject *args, PyObject *kwds)
+static int FrsMaterial___init__(BPy_FrsMaterial *self, PyObject *args, PyObject *kwds)
 {
 	PyObject *obj1 = 0, *obj2 = 0, *obj3 = 0, *obj4 = 0;
 	float f1[4], f2[4], f3[4], f4[4], f5 = 0.;
@@ -178,7 +102,7 @@ int FrsMaterial___init__(BPy_FrsMaterial *self, PyObject *args, PyObject *kwds)
 	return 0;
 }
 
-void FrsMaterial___dealloc__( BPy_FrsMaterial* self)
+static void FrsMaterial___dealloc__( BPy_FrsMaterial* self)
 {
 	if( self->m && !self->borrowed )
 		delete self->m;
@@ -186,12 +110,20 @@ void FrsMaterial___dealloc__( BPy_FrsMaterial* self)
 }
 
 
-PyObject * FrsMaterial___repr__( BPy_FrsMaterial* self)
+static PyObject * FrsMaterial___repr__( BPy_FrsMaterial* self)
 {
     return PyUnicode_FromFormat("FrsMaterial - address: %p", self->m );
 }
 
-PyObject * FrsMaterial_diffuse( BPy_FrsMaterial* self) {
+static char FrsMaterial_diffuse___doc__[] =
+".. method:: diffuse()\n"
+"\n"
+"   Returns the diffuse color.\n"
+"\n"
+"   :return: The diffuse color.\n"
+"   :rtype: Tuple of 4 float values\n";
+
+static PyObject * FrsMaterial_diffuse( BPy_FrsMaterial* self) {
 	const float *diffuse = self->m->diffuse();
 	PyObject *py_diffuse = PyTuple_New(4);
 	
@@ -203,23 +135,63 @@ PyObject * FrsMaterial_diffuse( BPy_FrsMaterial* self) {
 	return py_diffuse;
 }
 
-PyObject * FrsMaterial_diffuseR( BPy_FrsMaterial* self) {
+static char FrsMaterial_diffuseR___doc__[] =
+".. method:: diffuseR()\n"
+"\n"
+"   Returns the red component of the diffuse color.\n"
+"\n"
+"   :return: The red component of the diffuse color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_diffuseR( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->diffuseR() );
 }
 
-PyObject * FrsMaterial_diffuseG( BPy_FrsMaterial* self) {
+static char FrsMaterial_diffuseG___doc__[] =
+".. method:: diffuseG()\n"
+"\n"
+"   Returns the green component of the diffuse color.\n"
+"\n"
+"   :return: The green component of the diffuse color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_diffuseG( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->diffuseG() );
 }
 
-PyObject * FrsMaterial_diffuseB( BPy_FrsMaterial* self) {
+static char FrsMaterial_diffuseB___doc__[] =
+".. method:: diffuseB()\n"
+"\n"
+"   Returns the blue component of the diffuse color.\n"
+"\n"
+"   :return: The blue component of the diffuse color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_diffuseB( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->diffuseB() );
 }
 
-PyObject * FrsMaterial_diffuseA( BPy_FrsMaterial* self) {
+static char FrsMaterial_diffuseA___doc__[] =
+".. method:: diffuseA()\n"
+"\n"
+"   Returns the alpha component of the diffuse color.\n"
+"\n"
+"   :return: The alpha component of the diffuse color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_diffuseA( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->diffuseA() );
 }
 
-PyObject * FrsMaterial_specular( BPy_FrsMaterial* self) {
+static char FrsMaterial_specular___doc__[] =
+".. method:: specular()\n"
+"\n"
+"   Returns the specular color.\n"
+"\n"
+"   :return: The specular color.\n"
+"   :rtype: Tuple of 4 float values\n";
+
+static PyObject * FrsMaterial_specular( BPy_FrsMaterial* self) {
 	const float *specular = self->m->specular();
 	PyObject *py_specular = PyTuple_New(4);
 	
@@ -231,23 +203,63 @@ PyObject * FrsMaterial_specular( BPy_FrsMaterial* self) {
 	return py_specular;
 }
 
-PyObject * FrsMaterial_specularR( BPy_FrsMaterial* self) {
+static char FrsMaterial_specularR___doc__[] =
+".. method:: specularR()\n"
+"\n"
+"   Returns the red component of the specular color.\n"
+"\n"
+"   :return: The red component of the specular color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_specularR( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->specularR() );
 }
 
-PyObject * FrsMaterial_specularG( BPy_FrsMaterial* self) {
+static char FrsMaterial_specularG___doc__[] =
+".. method:: specularG()\n"
+"\n"
+"   Returns the green component of the specular color.\n"
+"\n"
+"   :return: The green component of the specular color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_specularG( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->specularG() );
 }
 
-PyObject * FrsMaterial_specularB( BPy_FrsMaterial* self) {
+static char FrsMaterial_specularB___doc__[] =
+".. method:: specularB()\n"
+"\n"
+"   Returns the blue component of the specular color.\n"
+"\n"
+"   :return: The blue component of the specular color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_specularB( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->specularB() );
 }
 
-PyObject * FrsMaterial_specularA( BPy_FrsMaterial* self) {
+static char FrsMaterial_specularA___doc__[] =
+".. method:: specularA()\n"
+"\n"
+"   Returns the alpha component of the specular color.\n"
+"\n"
+"   :return: The alpha component of the specular color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_specularA( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->specularA() );
 }
 
-PyObject * FrsMaterial_ambient( BPy_FrsMaterial* self) {
+static char FrsMaterial_ambient___doc__[] =
+".. method:: ambient()\n"
+"\n"
+"   Returns the ambiant color.\n"
+"\n"
+"   :return: The ambiant color.\n"
+"   :rtype: Tuple of 4 float values\n";
+
+static PyObject * FrsMaterial_ambient( BPy_FrsMaterial* self) {
 	const float *ambient = self->m->ambient();
 	PyObject *py_ambient = PyTuple_New(4);
 	
@@ -259,23 +271,63 @@ PyObject * FrsMaterial_ambient( BPy_FrsMaterial* self) {
 	return py_ambient;
 }
 
-PyObject * FrsMaterial_ambientR( BPy_FrsMaterial* self) {
+static char FrsMaterial_ambientR___doc__[] =
+".. method:: ambientR()\n"
+"\n"
+"   Returns the red component of the ambiant color.\n"
+"\n"
+"   :return: The red component of the ambiant color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_ambientR( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->ambientR() );
 }
 
-PyObject * FrsMaterial_ambientG( BPy_FrsMaterial* self) {
+static char FrsMaterial_ambientG___doc__[] =
+".. method:: ambientG()\n"
+"\n"
+"   Returns the green component of the ambiant color.\n"
+"\n"
+"   :return: The green component of the ambiant color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_ambientG( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->ambientG() );
 }
 
-PyObject * FrsMaterial_ambientB( BPy_FrsMaterial* self) {
+static char FrsMaterial_ambientB___doc__[] =
+".. method:: ambientB()\n"
+"\n"
+"   Returns the blue component of the ambiant color.\n"
+"\n"
+"   :return: The blue component of the ambiant color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_ambientB( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->ambientB() );
 }
 
-PyObject * FrsMaterial_ambientA( BPy_FrsMaterial* self) {
+static char FrsMaterial_ambientA___doc__[] =
+".. method:: ambientA()\n"
+"\n"
+"   Returns the alpha component of the ambiant color.\n"
+"\n"
+"   :return: The alpha component of the ambiant color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_ambientA( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->ambientA() );
 }
 
-PyObject * FrsMaterial_emission( BPy_FrsMaterial* self) {
+static char FrsMaterial_emission___doc__[] =
+".. method:: emission()\n"
+"\n"
+"   Returns the emissive color.\n"
+"\n"
+"   :return: the emissive color.\n"
+"   :rtype: Tuple of 4 float values\n";
+
+static PyObject * FrsMaterial_emission( BPy_FrsMaterial* self) {
 	const float *emission = self->m->emission();
 	PyObject *py_emission = PyTuple_New(4);
 	
@@ -287,27 +339,81 @@ PyObject * FrsMaterial_emission( BPy_FrsMaterial* self) {
 	return py_emission;
 }
 
-PyObject * FrsMaterial_emissionR( BPy_FrsMaterial* self) {
+static char FrsMaterial_emissionR___doc__[] =
+".. method:: emissionR()\n"
+"\n"
+"   Returns the red component of the emissive color.\n"
+"\n"
+"   :return: The red component of the emissive color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_emissionR( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->emissionR() );
 }
 
-PyObject * FrsMaterial_emissionG( BPy_FrsMaterial* self) {
+static char FrsMaterial_emissionG___doc__[] =
+".. method:: emissionG()\n"
+"\n"
+"   Returns the green component of the emissive color.\n"
+"\n"
+"   :return: The green component of the emissive color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_emissionG( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->emissionG() );
 }
 
-PyObject * FrsMaterial_emissionB( BPy_FrsMaterial* self) {
+static char FrsMaterial_emissionB___doc__[] =
+".. method:: emissionB()\n"
+"\n"
+"   Returns the blue component of the emissive color.\n"
+"\n"
+"   :return: The blue component of the emissive color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_emissionB( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->emissionB() );
 }
 
-PyObject * FrsMaterial_emissionA( BPy_FrsMaterial* self) {
+static char FrsMaterial_emissionA___doc__[] =
+".. method:: emissionA()\n"
+"\n"
+"   Returns the alpha component of the emissive color.\n"
+"\n"
+"   :return: The alpha component of the emissive color.\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_emissionA( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->emissionA() );
 }
 
-PyObject * FrsMaterial_shininess( BPy_FrsMaterial* self) {
+static char FrsMaterial_shininess___doc__[] =
+".. method:: shininess()\n"
+"\n"
+"   Returns the shininess coefficient.\n"
+"\n"
+"   :return: Shininess\n"
+"   :rtype: float\n";
+
+static PyObject * FrsMaterial_shininess( BPy_FrsMaterial* self) {
 	return PyFloat_FromDouble( self->m->shininess() );
 }
 
-PyObject * FrsMaterial_setDiffuse( BPy_FrsMaterial *self, PyObject *args ) {
+static char FrsMaterial_setDiffuse___doc__[] =
+".. method:: setDiffuse(r, g, b, a)\n"
+"\n"
+"   Sets the diffuse color.\n"
+"\n"
+"   :arg r: Red component.\n"
+"   :type r: float\n"
+"   :arg g: Green component.\n"
+"   :type g: float\n"
+"   :arg b: Blue component.\n"
+"   :type b: float\n"
+"   :arg a: Alpha component.\n"
+"   :type a: float\n";
+
+static PyObject * FrsMaterial_setDiffuse( BPy_FrsMaterial *self, PyObject *args ) {
 	float f1, f2, f3, f4;
 
 	if(!( PyArg_ParseTuple(args, "ffff", &f1, &f2, &f3, &f4)  ))
@@ -318,7 +424,21 @@ PyObject * FrsMaterial_setDiffuse( BPy_FrsMaterial *self, PyObject *args ) {
 	Py_RETURN_NONE;
 }
  
-PyObject * FrsMaterial_setSpecular( BPy_FrsMaterial *self, PyObject *args ) {
+static char FrsMaterial_setSpecular___doc__[] =
+".. method:: setSpecular(r, g, b, a)\n"
+"\n"
+"   Sets the specular color.\n"
+"\n"
+"   :arg r: Red component.\n"
+"   :type r: float\n"
+"   :arg g: Green component.\n"
+"   :type g: float\n"
+"   :arg b: Blue component.\n"
+"   :type b: float\n"
+"   :arg a: Alpha component.\n"
+"   :type a: float\n";
+
+static PyObject * FrsMaterial_setSpecular( BPy_FrsMaterial *self, PyObject *args ) {
 	float f1, f2, f3, f4;
 
 	if(!( PyArg_ParseTuple(args, "ffff", &f1, &f2, &f3, &f4)  ))
@@ -329,7 +449,21 @@ PyObject * FrsMaterial_setSpecular( BPy_FrsMaterial *self, PyObject *args ) {
 	Py_RETURN_NONE;
 }
 
-PyObject * FrsMaterial_setAmbient( BPy_FrsMaterial *self, PyObject *args ) {
+static char FrsMaterial_setAmbient___doc__[] =
+".. method:: setAmbient(r, g, b, a)\n"
+"\n"
+"   Sets the ambiant color.\n"
+"\n"
+"   :arg r: Red component.\n"
+"   :type r: float\n"
+"   :arg g: Green component.\n"
+"   :type g: float\n"
+"   :arg b: Blue component.\n"
+"   :type b: float\n"
+"   :arg a: Alpha component.\n"
+"   :type a: float\n";
+
+static PyObject * FrsMaterial_setAmbient( BPy_FrsMaterial *self, PyObject *args ) {
 	float f1, f2, f3, f4;
 
 	if(!( PyArg_ParseTuple(args, "ffff", &f1, &f2, &f3, &f4)  ))
@@ -340,7 +474,21 @@ PyObject * FrsMaterial_setAmbient( BPy_FrsMaterial *self, PyObject *args ) {
 	Py_RETURN_NONE;
 }
 
-PyObject * FrsMaterial_setEmission( BPy_FrsMaterial *self, PyObject *args ) {
+static char FrsMaterial_setEmission___doc__[] =
+".. method:: setEmission(r, g, b, a)\n"
+"\n"
+"   Sets the emissive color.\n"
+"\n"
+"   :arg r: Red component.\n"
+"   :type r: float\n"
+"   :arg g: Green component.\n"
+"   :type g: float\n"
+"   :arg b: Blue component.\n"
+"   :type b: float\n"
+"   :arg a: Alpha component.\n"
+"   :type a: float\n";
+
+static PyObject * FrsMaterial_setEmission( BPy_FrsMaterial *self, PyObject *args ) {
 	float f1, f2, f3, f4;
 
 	if(!( PyArg_ParseTuple(args, "ffff", &f1, &f2, &f3, &f4)  ))
@@ -351,7 +499,15 @@ PyObject * FrsMaterial_setEmission( BPy_FrsMaterial *self, PyObject *args ) {
 	Py_RETURN_NONE;
 }
 
-PyObject * FrsMaterial_setShininess( BPy_FrsMaterial *self, PyObject *args ) {
+static char FrsMaterial_setShininess___doc__[] =
+".. method:: setShininess(s)\n"
+"\n"
+"   Sets the shininess.\n"
+"\n"
+"   :arg s: Shininess.\n"
+"   :type s: float\n";
+
+static PyObject * FrsMaterial_setShininess( BPy_FrsMaterial *self, PyObject *args ) {
 	float f;
 
 	if(!( PyArg_ParseTuple(args, "f", &f)  ))
@@ -362,6 +518,80 @@ PyObject * FrsMaterial_setShininess( BPy_FrsMaterial *self, PyObject *args ) {
 	Py_RETURN_NONE;
 }
 
+/*----------------------FrsMaterial instance definitions ----------------------------*/
+static PyMethodDef BPy_FrsMaterial_methods[] = {
+	{"diffuse", ( PyCFunction ) FrsMaterial_diffuse, METH_NOARGS, FrsMaterial_diffuse___doc__},
+	{"diffuseR", ( PyCFunction ) FrsMaterial_diffuseR, METH_NOARGS, FrsMaterial_diffuseR___doc__},
+	{"diffuseG", ( PyCFunction ) FrsMaterial_diffuseG, METH_NOARGS, FrsMaterial_diffuseG___doc__},
+	{"diffuseB", ( PyCFunction ) FrsMaterial_diffuseB, METH_NOARGS, FrsMaterial_diffuseB___doc__},
+	{"diffuseA", ( PyCFunction ) FrsMaterial_diffuseA, METH_NOARGS, FrsMaterial_diffuseA___doc__},
+	{"specular", ( PyCFunction ) FrsMaterial_specular, METH_NOARGS, FrsMaterial_specular___doc__},
+	{"specularR", ( PyCFunction ) FrsMaterial_specularR, METH_NOARGS, FrsMaterial_specularR___doc__},
+	{"specularG", ( PyCFunction ) FrsMaterial_specularG, METH_NOARGS, FrsMaterial_specularG___doc__},
+	{"specularB", ( PyCFunction ) FrsMaterial_specularB, METH_NOARGS, FrsMaterial_specularB___doc__},
+	{"specularA", ( PyCFunction ) FrsMaterial_specularA, METH_NOARGS, FrsMaterial_specularA___doc__},
+	{"ambient", ( PyCFunction ) FrsMaterial_ambient, METH_NOARGS, FrsMaterial_ambient___doc__},
+	{"ambientR", ( PyCFunction ) FrsMaterial_ambientR, METH_NOARGS, FrsMaterial_ambientR___doc__},
+	{"ambientG", ( PyCFunction ) FrsMaterial_ambientG, METH_NOARGS, FrsMaterial_ambientG___doc__},
+	{"ambientB", ( PyCFunction ) FrsMaterial_ambientB, METH_NOARGS, FrsMaterial_ambientB___doc__},
+	{"ambientA", ( PyCFunction ) FrsMaterial_ambientA, METH_NOARGS, FrsMaterial_ambientA___doc__},
+	{"emission", ( PyCFunction ) FrsMaterial_emission, METH_NOARGS, FrsMaterial_emission___doc__},
+	{"emissionR", ( PyCFunction ) FrsMaterial_emissionR, METH_NOARGS, FrsMaterial_emissionR___doc__},
+	{"emissionG", ( PyCFunction ) FrsMaterial_emissionG, METH_NOARGS, FrsMaterial_emissionG___doc__},
+	{"emissionB", ( PyCFunction ) FrsMaterial_emissionB, METH_NOARGS, FrsMaterial_emissionB___doc__},
+	{"emissionA", ( PyCFunction ) FrsMaterial_emissionA, METH_NOARGS, FrsMaterial_emissionA___doc__},
+	{"shininess", ( PyCFunction ) FrsMaterial_shininess, METH_NOARGS, FrsMaterial_shininess___doc__},
+	{"setDiffuse", ( PyCFunction ) FrsMaterial_setDiffuse, METH_NOARGS, FrsMaterial_setDiffuse___doc__},
+	{"setSpecular", ( PyCFunction ) FrsMaterial_setSpecular, METH_NOARGS, FrsMaterial_setSpecular___doc__},
+	{"setAmbient", ( PyCFunction ) FrsMaterial_setAmbient, METH_NOARGS, FrsMaterial_setAmbient___doc__},
+	{"setEmission", ( PyCFunction ) FrsMaterial_setEmission, METH_NOARGS, FrsMaterial_setEmission___doc__},
+	{"setShininess", ( PyCFunction ) FrsMaterial_setShininess, METH_NOARGS, FrsMaterial_setShininess___doc__},
+	{NULL, NULL, 0, NULL}
+};
+
+/*-----------------------BPy_FrsMaterial type definition ------------------------------*/
+
+PyTypeObject FrsMaterial_Type = {
+	PyVarObject_HEAD_INIT(NULL, 0)
+	"FrsMaterial",                  /* tp_name */
+	sizeof(BPy_FrsMaterial),        /* tp_basicsize */
+	0,                              /* tp_itemsize */
+	(destructor)FrsMaterial___dealloc__, /* tp_dealloc */
+	0,                              /* tp_print */
+	0,                              /* tp_getattr */
+	0,                              /* tp_setattr */
+	0,                              /* tp_reserved */
+	(reprfunc)FrsMaterial___repr__, /* tp_repr */
+	0,                              /* tp_as_number */
+	0,                              /* tp_as_sequence */
+	0,                              /* tp_as_mapping */
+	0,                              /* tp_hash  */
+	0,                              /* tp_call */
+	0,                              /* tp_str */
+	0,                              /* tp_getattro */
+	0,                              /* tp_setattro */
+	0,                              /* tp_as_buffer */
+	Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
+	FrsMaterial___doc__,            /* tp_doc */
+	0,                              /* tp_traverse */
+	0,                              /* tp_clear */
+	0,                              /* tp_richcompare */
+	0,                              /* tp_weaklistoffset */
+	0,                              /* tp_iter */
+	0,                              /* tp_iternext */
+	BPy_FrsMaterial_methods,        /* tp_methods */
+	0,                              /* tp_members */
+	0,                              /* tp_getset */
+	0,                              /* tp_base */
+	0,                              /* tp_dict */
+	0,                              /* tp_descr_get */
+	0,                              /* tp_descr_set */
+	0,                              /* tp_dictoffset */
+	(initproc)FrsMaterial___init__, /* tp_init */
+	0,                              /* tp_alloc */
+	PyType_GenericNew,              /* tp_new */
+};
+
 ///////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef __cplusplus