Page MenuHome
Files F2354

py_material_shader.txt
Public
Actions

py_material_shader.txt
View Options

Index: source/blender/python/api2_2x/Material.c
===================================================================
RCS file: /cvsroot/bf-blender/blender/source/blender/python/api2_2x/Material.c,v
retrieving revision 1.33
diff -u -p -u -r1.33 Material.c
--- source/blender/python/api2_2x/Material.c 27 May 2005 05:39:40 -0000 1.33
+++ source/blender/python/api2_2x/Material.c 6 Jun 2005 00:48:21 -0000
@@ -103,6 +103,56 @@
#define EXPP_MAT_SPEC_MAX 2.0
#define EXPP_MAT_SPECTRA_MIN 0.0
#define EXPP_MAT_SPECTRA_MAX 1.0
+
+/* Shader spesific settings */
+#define EXPP_MAT_SPEC_SHADER_MIN 0
+#define EXPP_MAT_SPEC_SHADER_MAX 3
+#define EXPP_MAT_DIFFUSE_SHADER_MIN 0
+#define EXPP_MAT_DIFFUSE_SHADER_MAX 4
+
+#define EXPP_MAT_ROUGHNESS_MIN 0.0
+#define EXPP_MAT_ROUGHNESS_MAX 3.140
+#define EXPP_MAT_SPECSIZE_MIN 0.0
+#define EXPP_MAT_SPECSIZE_MAX 1.530
+#define EXPP_MAT_DIFFUSESIZE_MIN 0.0
+#define EXPP_MAT_DIFFUSESIZE_MAX 3.140
+#define EXPP_MAT_SPECSMOOTH_MIN 0.0
+#define EXPP_MAT_SPECSMOOTH_MAX 1.0
+#define EXPP_MAT_DIFFUSESMOOTH_MIN 0.0
+#define EXPP_MAT_DIFFUSESMOOTH_MAX 1.0
+#define EXPP_MAT_DIFFUSE_DARKNESS_MIN 0.0
+#define EXPP_MAT_DIFFUSE_DARKNESS_MAX 2.0
+#define EXPP_MAT_REFRACINDEX_MIN 1.0
+#define EXPP_MAT_REFRACINDEX_MAX 10.0
+#define EXPP_MAT_RMS_MIN 0.0
+#define EXPP_MAT_RMS_MAX 0.4
+/* End shader settings */
+
+/* diff_shader */
+#define MA_DIFF_LAMBERT 0
+#define MA_DIFF_ORENNAYAR 1
+#define MA_DIFF_TOON 2
+#define MA_DIFF_MINNAERT 3
+
+/* spec_shader */
+#define MA_SPEC_COOKTORR 0
+#define MA_SPEC_PHONG 1
+#define MA_SPEC_BLINN 2
+#define MA_SPEC_TOON 3
+#define MA_SPEC_WARDISO 4
+
+/* shader dicts - Diffuse */
+#define EXPP_MAT_SHADER_DIFFUSE_LAMBERT MA_DIFF_LAMBERT
+#define EXPP_MAT_SHADER_DIFFUSE_ORENNAYAR MA_DIFF_ORENNAYAR
+#define EXPP_MAT_SHADER_DIFFUSE_TOON MA_DIFF_TOON
+#define EXPP_MAT_SHADER_DIFFUSE_MINNAERT MA_DIFF_MINNAERT
+/* shader dicts - Specualr */
+#define EXPP_MAT_SHADER_SPEC_COOKTORR MA_SPEC_COOKTORR
+#define EXPP_MAT_SHADER_SPEC_PHONG MA_SPEC_PHONG
+#define EXPP_MAT_SHADER_SPEC_BLINN MA_SPEC_BLINN
+#define EXPP_MAT_SHADER_SPEC_TOON MA_SPEC_TOON
+#define EXPP_MAT_SHADER_SPEC_WARDISO MA_SPEC_WARDISO
+
#define EXPP_MAT_ZOFFS_MIN 0.0
#define EXPP_MAT_ZOFFS_MAX 10.0
#define EXPP_MAT_HALOSIZE_MIN 0.0
@@ -137,6 +187,10 @@
#define EXPP_MAT_FRESNELMIRR_MAX 5.0
#define EXPP_MAT_FRESNELMIRRFAC_MIN 1.0
#define EXPP_MAT_FRESNELMIRRFAC_MAX 5.0
+#define EXPP_MAT_FILTER_MIN 0.0
+#define EXPP_MAT_FILTER_MAX 1.0
+#define EXPP_MAT_TRANSLUCENCY_MIN 0.0
+#define EXPP_MAT_TRANSLUCENCY_MAX 1.0
#define EXPP_MAT_ZOFFS_MIN 0.0
#define EXPP_MAT_ZOFFS_MAX 10.0
#define EXPP_MAT_IOR_MIN 1.0
@@ -314,7 +368,7 @@ static PyObject *M_Material_Get( PyObjec
}
}
-static PyObject *Lamp_ModesDict( void )
+static PyObject *Material_ModesDict( void )
{
PyObject *Modes = M_constant_New( );
@@ -355,32 +409,65 @@ static PyObject *Lamp_ModesDict( void )
EXPP_ADDCONST( RAYMIRROR );
EXPP_ADDCONST( ZTRA );
EXPP_ADDCONST( RAYTRANSP );
- EXPP_ADDCONST( ONLYSHADOW );
- EXPP_ADDCONST( NOMIST );
- EXPP_ADDCONST( ENV );
}
return Modes;
}
+
+static PyObject *Material_ShadersDict( void )
+{
+ PyObject *Shaders = M_constant_New( );
+
+#undef EXPP_ADDCONST
+#define EXPP_ADDCONST(name) \
+ constant_insert(c, #name, PyInt_FromLong(EXPP_MAT_SHADER_##name))
+
+/* So that:
+ * EXPP_ADDCONST(DIFFUSE_LAMBERT) becomes:
+ * constant_insert(c, "TRACEABLE", PyInt_FromLong(EXPP_MAT_SHADER_DIFFUSE_LAMBERT))
+ */
+
+ if( Shaders ) {
+ BPy_constant *c = ( BPy_constant * ) Shaders;
+
+ EXPP_ADDCONST( DIFFUSE_LAMBERT );
+ EXPP_ADDCONST( DIFFUSE_ORENNAYAR );
+ EXPP_ADDCONST( DIFFUSE_TOON );
+ EXPP_ADDCONST( DIFFUSE_MINNAERT );
+
+ EXPP_ADDCONST( SPEC_COOKTORR );
+ EXPP_ADDCONST( SPEC_PHONG );
+ EXPP_ADDCONST( SPEC_BLINN );
+ EXPP_ADDCONST( SPEC_TOON );
+ EXPP_ADDCONST( SPEC_WARDISO );
+ }
+
+ return Shaders;
+}
+
+
/*****************************************************************************/
/* Function: Material_Init */
/*****************************************************************************/
PyObject *Material_Init( void )
{
- PyObject *submodule, *Modes;
+ PyObject *submodule, *Modes, *Shaders;
Material_Type.ob_type = &PyType_Type;
- Modes = Lamp_ModesDict( );
+ Modes = Material_ModesDict( );
+ Shaders = Material_ShadersDict( );
submodule = Py_InitModule3( "Blender.Material",
M_Material_methods, M_Material_doc );
if( Modes )
PyModule_AddObject( submodule, "Modes", Modes );
-
+ if( Shaders )
+ PyModule_AddObject( submodule, "Shaders", Shaders );
+
PyModule_AddIntConstant( submodule, "RGB", IPOKEY_RGB );
PyModule_AddIntConstant( submodule, "ALPHA", IPOKEY_ALPHA );
PyModule_AddIntConstant( submodule, "HALOSIZE", IPOKEY_HALOSIZE );
@@ -427,6 +514,18 @@ static PyObject *Material_getNFlares( BP
static PyObject *Material_getNStars( BPy_Material * self );
static PyObject *Material_getNLines( BPy_Material * self );
static PyObject *Material_getNRings( BPy_Material * self );
+/* Shader settings */
+static PyObject *Material_getSpecShader( BPy_Material * self );
+static PyObject *Material_getDiffuseShader( BPy_Material * self );
+static PyObject *Material_getRoughness( BPy_Material * self );
+static PyObject *Material_getSpecSize( BPy_Material * self );
+static PyObject *Material_getDiffuseSize( BPy_Material * self );
+static PyObject *Material_getSpecSmooth( BPy_Material * self );
+static PyObject *Material_getDiffuseSmooth( BPy_Material * self );
+static PyObject *Material_getDiffuseDarkness( BPy_Material * self );
+static PyObject *Material_getRefracIndex( BPy_Material * self );
+static PyObject *Material_getRms( BPy_Material * self );
+
static PyObject *Material_getRayMirr( BPy_Material * self );
static PyObject *Material_getMirrDepth( BPy_Material * self );
static PyObject *Material_getFresnelMirr( BPy_Material * self );
@@ -435,6 +534,8 @@ static PyObject *Material_getIOR( BPy_Ma
static PyObject *Material_getTransDepth( BPy_Material * self );
static PyObject *Material_getFresnelTrans( BPy_Material * self );
static PyObject *Material_getFresnelTransFac( BPy_Material * self );
+static PyObject *Material_getFilter( BPy_Material * self );
+static PyObject *Material_getTranslucency( 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 );
@@ -466,6 +567,19 @@ static PyObject *Material_setNFlares( BP
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 );
+
+/* Shader */
+static PyObject *Material_setSpecShader( BPy_Material * self, PyObject * args );
+static PyObject *Material_setDiffuseShader( BPy_Material * self, PyObject * args );
+static PyObject *Material_setRoughness( BPy_Material * self, PyObject * args );
+static PyObject *Material_setSpecSize( BPy_Material * self, PyObject * args );
+static PyObject *Material_setDiffuseSize( BPy_Material * self, PyObject * args );
+static PyObject *Material_setSpecSmooth( BPy_Material * self, PyObject * args );
+static PyObject *Material_setDiffuseSmooth( BPy_Material * self, PyObject * args );
+static PyObject *Material_setDiffuseDarkness( BPy_Material * self, PyObject * args );
+static PyObject *Material_setRefracIndex( BPy_Material * self, PyObject * args );
+static PyObject *Material_setRms( 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 );
@@ -473,6 +587,10 @@ static PyObject *Material_setFresnelMirr
PyObject * args );
static PyObject *Material_setFresnelMirrFac( BPy_Material * self,
PyObject * args );
+static PyObject *Material_setFilter( BPy_Material * self,
+ PyObject * args );
+static PyObject *Material_setTranslucency( BPy_Material * self,
+ PyObject * args );
static PyObject *Material_setIOR( BPy_Material * self, PyObject * args );
static PyObject *Material_setTransDepth( BPy_Material * self,
PyObject * args );
@@ -523,6 +641,28 @@ static PyMethodDef BPy_Material_methods[
"() - Return Material's reflectivity"},
{"getSpec", ( PyCFunction ) Material_getSpec, METH_NOARGS,
"() - Return Material's specularity"},
+ /* Shader spesific settings */
+ {"getSpecShader", ( PyCFunction ) Material_getSpecShader, METH_NOARGS,
+ "() - Returns Material's specular shader" },
+ {"getDiffuseShader", ( PyCFunction ) Material_getSpecShader, METH_NOARGS,
+ "() - Returns Material's diffuse shader" },
+ {"getRoughness", ( PyCFunction ) Material_getRoughness, METH_NOARGS,
+ "() - Returns Material's Roughness (Applies to the \"Oren Nayar\" Diffuse Shader Only)" },
+ {"getSpecSize", ( PyCFunction ) Material_getSpecSize, METH_NOARGS,
+ "() - Returns Material's size of speculara area (Applies to the \"Toon\" Specular Shader Only)" },
+ {"getDiffuseSize", ( PyCFunction ) Material_getDiffuseSize, METH_NOARGS,
+ "() - Returns Material's size of diffuse area (Applies to the \"Toon\" Diffuse Shader Only)" },
+ {"getSpecSmooth", ( PyCFunction ) Material_getSpecSmooth, METH_NOARGS,
+ "() - Returns Material's smoothing of specular area (Applies to the \"Toon\" Diffuse Shader Only)" },
+ {"getDiffuseSmooth", ( PyCFunction ) Material_getDiffuseSmooth, METH_NOARGS,
+ "() - Returns Material's smoothing of diffuse area (Applies to the \"Toon\" Diffuse Shader Only)" },
+ {"getDiffuseDarkness", ( PyCFunction ) Material_getDiffuseDarkness, METH_NOARGS,
+ "() - Returns Material's diffuse darkness (Applies to the \"Minnaert\" Diffuse Shader Only)" },
+ {"getRefracIndex", ( PyCFunction ) Material_getRefracIndex, METH_NOARGS,
+ "() - Returns Material's Index of Refraction (Applies to the \"Blinn\" Specular Shader Only)" },
+ {"getRms", ( PyCFunction ) Material_getRms, METH_NOARGS,
+ "() - Returns Material's standard deviation of surface slope (Applies to the \"WardIso\" Specular Shader Only)" },
+ /* End shader settings */
{"getSpecTransp", ( PyCFunction ) Material_getSpecTransp, METH_NOARGS,
"() - Return Material's specular transparency"},
{"getAdd", ( PyCFunction ) Material_getAdd, METH_NOARGS,
@@ -562,6 +702,12 @@ static PyMethodDef BPy_Material_methods[
{"getFresnelMirrFac", ( PyCFunction ) Material_getFresnelMirrFac,
METH_NOARGS,
"() - Return fresnel power for refractions factor"},
+ {"getFilter", ( PyCFunction ) Material_getFilter,
+ METH_NOARGS,
+ "() - Return the amount of filtering when transperent raytrace is enabled"},
+ {"getTranslucency", ( PyCFunction ) Material_getTranslucency,
+ METH_NOARGS,
+ "() - Return the Translucency, the amount of diffuse shading of the back side"},
{"getIOR", ( PyCFunction ) Material_getIOR, METH_NOARGS,
"() - Return IOR"},
{"getTransDepth", ( PyCFunction ) Material_getTransDepth, METH_NOARGS,
@@ -590,6 +736,30 @@ static PyMethodDef BPy_Material_methods[
"(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"},
+
+ /* Shader spesific settings */
+ {"setSpecShader", ( PyCFunction ) Material_setSpecShader, METH_NOARGS,
+ "(i) - Set the Material's specular shader" },
+ {"setDiffuseShader", ( PyCFunction ) Material_setDiffuseShader, METH_NOARGS,
+ "(i) - Set the Material's diffuse shader" },
+ {"setRoughness", ( PyCFunction ) Material_setRoughness, METH_NOARGS,
+ "(f) - Set the Material's Roughness (Applies to the \"Oren Nayar\" Diffuse Shader Only)" },
+ {"setSpecSize", ( PyCFunction ) Material_setSpecSize, METH_NOARGS,
+ "(f) - Set the Material's size of speculara area (Applies to the \"Toon\" Specular Shader Only)" },
+ {"setDiffuseSize", ( PyCFunction ) Material_setDiffuseSize, METH_NOARGS,
+ "(f) - Set the Material's size of diffuse area (Applies to the \"Toon\" Diffuse Shader Only)" },
+ {"setSpecSmooth", ( PyCFunction ) Material_setSpecSmooth, METH_NOARGS,
+ "(f) - Set the Material's smoothing of specular area (Applies to the \"Toon\" Specular Shader Only)" },
+ {"setDiffuseSmooth", ( PyCFunction ) Material_setDiffuseSmooth, METH_NOARGS,
+ "(f) - Set the Material's smoothing of diffuse area (Applies to the \"Toon\" Diffuse Shader Only)" },
+ {"setDiffuseDarkness", ( PyCFunction ) Material_setDiffuseDarkness, METH_NOARGS,
+ "(f) - Set the Material's diffuse darkness (Applies to the \"Minnaert\" Diffuse Shader Only)" },
+ {"setRefracIndex", ( PyCFunction ) Material_setRefracIndex, METH_NOARGS,
+ "(f) - Set the Material's Index of Refraction (Applies to the \"Blinn\" Specular Shader Only)" },
+ {"setRms", ( PyCFunction ) Material_setRms, METH_NOARGS,
+ "(f) - Set the Material's standard deviation of surface slope (Applies to the \"WardIso\" Specular Shader Only)" },
+ /* End shader settings */
+
{"setMirCol", ( PyCFunction ) Material_setMirCol, METH_VARARGS,
"(f,f,f or [f,f,f]) - Set Material's mirror color"},
{"setAmb", ( PyCFunction ) Material_setAmb, METH_VARARGS,
@@ -642,6 +812,12 @@ static PyMethodDef BPy_Material_methods[
{"setFresnelMirrFac", ( PyCFunction ) Material_setFresnelMirrFac,
METH_VARARGS,
"(f) - Set blend fac for mirror fresnel - [1.0, 5.0]"},
+ {"setFilter", ( PyCFunction ) Material_setFresnelMirrFac,
+ METH_VARARGS,
+ "(f) - Set the amount of filtering when transperent raytrace is enabled"},
+ {"setTranslucency", ( PyCFunction ) Material_setTranslucency,
+ METH_VARARGS,
+ "(f) - Set the Translucency, the amount of diffuse shading of the back side"},
{"setIOR", ( PyCFunction ) Material_setIOR, METH_VARARGS,
"(f) - Set IOR - [1.0, 3.0]"},
{"setTransDepth", ( PyCFunction ) Material_setTransDepth, METH_VARARGS,
@@ -868,6 +1044,116 @@ static PyObject *Material_getMirCol( BPy
return rgbTuple_getCol( self->mir );
}
+static PyObject *Material_getSpecShader( BPy_Material * self )
+{
+ PyObject *attr = PyInt_FromLong( ( long ) self->material->spec_shader );
+
+ if( attr )
+ return attr;
+
+ return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+ "couldn't get Material.specShader attribute" );
+}
+
+static PyObject *Material_getDiffuseShader( BPy_Material * self )
+{
+ PyObject *attr = PyInt_FromLong( ( long ) self->material->diff_shader );
+
+ if( attr )
+ return attr;
+
+ return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+ "couldn't get Material.diffuseShader attribute" );
+}
+
+static PyObject *Material_getRoughness( BPy_Material * self )
+{
+ PyObject *attr = PyFloat_FromDouble( ( double ) self->material->roughness );
+
+ if( attr )
+ return attr;
+
+ return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+ "couldn't get Material.roughness attribute" );
+}
+
+static PyObject *Material_getSpecSize( BPy_Material * self )
+{
+ PyObject *attr = PyFloat_FromDouble( ( double ) self->material->param[2] );
+
+ if( attr )
+ return attr;
+
+ return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+ "couldn't get Material.specSize attribute" );
+}
+
+static PyObject *Material_getDiffuseSize( BPy_Material * self )
+{
+ PyObject *attr = PyFloat_FromDouble( ( double ) self->material->param[0] );
+
+ if( attr )
+ return attr;
+
+ return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+ "couldn't get Material.diffuseSize attribute" );
+}
+
+static PyObject *Material_getSpecSmooth( BPy_Material * self )
+{
+ PyObject *attr = PyFloat_FromDouble( ( double ) self->material->param[3] );
+
+ if( attr )
+ return attr;
+
+ return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+ "couldn't get Material.specSmooth attribute" );
+}
+
+static PyObject *Material_getDiffuseSmooth( BPy_Material * self )
+{
+ PyObject *attr = PyFloat_FromDouble( ( double ) self->material->param[1] );
+
+ if( attr )
+ return attr;
+
+ return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+ "couldn't get Material.diffuseSmooth( attribute" );
+}
+
+static PyObject *Material_getDiffuseDarkness( BPy_Material * self )
+{
+ PyObject *attr = PyFloat_FromDouble( ( double ) self->material->darkness );
+
+ if( attr )
+ return attr;
+
+ return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+ "couldn't get Material.diffuseDarkness attribute" );
+}
+
+static PyObject *Material_getRefracIndex( BPy_Material * self )
+{
+ PyObject *attr = PyFloat_FromDouble( ( double ) self->material->refrac );
+
+ if( attr )
+ return attr;
+
+ return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+ "couldn't get Material.refracIndex attribute" );
+}
+
+static PyObject *Material_getRms( BPy_Material * self )
+{
+ PyObject *attr = PyFloat_FromDouble( ( double ) self->material->rms );
+
+ if( attr )
+ return attr;
+
+ return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+ "couldn't get Material.rms attribute" );
+}
+
static PyObject *Material_getAmb( BPy_Material * self )
{
PyObject *attr = PyFloat_FromDouble( ( double ) self->material->amb );
@@ -1093,7 +1379,7 @@ static PyObject *Material_getRayMirr( BP
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
- "couldn't get Material.nRings attribute" );
+ "couldn't get Material.rayMirr attribute" );
}
static PyObject *Material_getMirrDepth( BPy_Material * self )
@@ -1104,7 +1390,7 @@ static PyObject *Material_getMirrDepth(
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
- "couldn't get Material.nRings attribute" );
+ "couldn't get Material.rayMirrDepth attribute" );
}
static PyObject *Material_getFresnelMirr( BPy_Material * self )
@@ -1116,7 +1402,7 @@ static PyObject *Material_getFresnelMirr
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
- "couldn't get Material.nRings attribute" );
+ "couldn't get Material.fresnelDepth attribute" );
}
static PyObject *Material_getFresnelMirrFac( BPy_Material * self )
@@ -1128,7 +1414,31 @@ static PyObject *Material_getFresnelMirr
return attr;
return EXPP_ReturnPyObjError( PyExc_RuntimeError,
- "couldn't get Material.nRings attribute" );
+ "couldn't get Material.fresnelDepthFac attribute" );
+}
+
+static PyObject *Material_getFilter( BPy_Material * self )
+{
+ PyObject *attr =
+ PyFloat_FromDouble( ( double ) self->material->filter );
+
+ if( attr )
+ return attr;
+
+ return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+ "couldn't get Material.filter attribute" );
+}
+
+static PyObject *Material_getTranslucency( BPy_Material * self )
+{
+ PyObject *attr =
+ PyFloat_FromDouble( ( double ) self->material->translucency );
+
+ if( attr )
+ return attr;
+
+ return EXPP_ReturnPyObjError( PyExc_RuntimeError,
+ "couldn't get Material.translucency attribute" );
}
static PyObject *Material_getIOR( BPy_Material * self )
@@ -1510,6 +1820,158 @@ static PyObject *Material_setMirCol( BPy
return rgbTuple_setCol( self->mir, args );
}
+
+static PyObject *Material_setSpecShader( BPy_Material * self, PyObject * args )
+{
+ int value;
+
+ if( !PyArg_ParseTuple( args, "i", &value ) )
+ return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+ "expected int argument" ) );
+
+ self->material->spec_shader = EXPP_ClampInt( value, EXPP_MAT_SPEC_SHADER_MIN,
+ EXPP_MAT_SPEC_SHADER_MAX );
+
+ Py_INCREF( Py_None );
+ return Py_None;
+}
+
+static PyObject *Material_setDiffuseShader( BPy_Material * self, PyObject * args )
+{
+ int value;
+
+ if( !PyArg_ParseTuple( args, "i", &value ) )
+ return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+ "expected int argument" ) );
+
+ self->material->diff_shader = EXPP_ClampInt( value, EXPP_MAT_DIFFUSE_SHADER_MIN,
+ EXPP_MAT_DIFFUSE_SHADER_MAX );
+
+ Py_INCREF( Py_None );
+ return Py_None;
+}
+
+
+static PyObject *Material_setRoughness( BPy_Material * self, PyObject * args )
+{
+ float value;
+
+ if( !PyArg_ParseTuple( args, "f", &value ) )
+ return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+ "expected float argument in [0.0, 3.14]" ) );
+
+ self->material->roughness = EXPP_ClampFloat( value, EXPP_MAT_ROUGHNESS_MIN,
+ EXPP_MAT_ROUGHNESS_MAX );
+
+ return EXPP_incr_ret( Py_None );
+}
+
+
+static PyObject *Material_setSpecSize( BPy_Material * self, PyObject * args )
+{
+ float value;
+
+ if( !PyArg_ParseTuple( args, "f", &value ) )
+ return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+ "expected float argument in [0.0, 1.53]" ) );
+
+ self->material->param[2] = EXPP_ClampFloat( value, EXPP_MAT_SPECSIZE_MIN,
+ EXPP_MAT_SPECSIZE_MAX );
+
+ return EXPP_incr_ret( Py_None );
+}
+
+
+static PyObject *Material_setDiffuseSize( BPy_Material * self, PyObject * args )
+{
+ float value;
+
+ if( !PyArg_ParseTuple( args, "f", &value ) )
+ return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+ "expected float argument in [0.0, 3.14]" ) );
+
+ self->material->param[0] = EXPP_ClampFloat( value, EXPP_MAT_DIFFUSESIZE_MIN,
+ EXPP_MAT_DIFFUSESIZE_MAX );
+
+ return EXPP_incr_ret( Py_None );
+}
+
+
+static PyObject *Material_setSpecSmooth( BPy_Material * self, PyObject * args )
+{
+ float value;
+
+ if( !PyArg_ParseTuple( args, "f", &value ) )
+ return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+ "expected float argument in [0.0, 1.0]" ) );
+
+ self->material->param[2] = EXPP_ClampFloat( value, EXPP_MAT_SPECSMOOTH_MIN,
+ EXPP_MAT_SPECSMOOTH_MAX );
+
+ return EXPP_incr_ret( Py_None );
+}
+
+
+static PyObject *Material_setDiffuseSmooth( BPy_Material * self, PyObject * args )
+{
+ float value;
+
+ if( !PyArg_ParseTuple( args, "f", &value ) )
+ return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+ "expected float argument in [0.0, 1.0]" ) );
+
+ self->material->param[1] = EXPP_ClampFloat( value, EXPP_MAT_DIFFUSESMOOTH_MIN,
+ EXPP_MAT_DIFFUSESMOOTH_MAX );
+
+ return EXPP_incr_ret( Py_None );
+}
+
+
+static PyObject *Material_setDiffuseDarkness( BPy_Material * self, PyObject * args )
+{
+ float value;
+
+ if( !PyArg_ParseTuple( args, "f", &value ) )
+ return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+ "expected float argument in [0.0, 2.0]" ) );
+
+ self->material->darkness = EXPP_ClampFloat( value, EXPP_MAT_DIFFUSE_DARKNESS_MIN,
+ EXPP_MAT_DIFFUSE_DARKNESS_MAX );
+
+ return EXPP_incr_ret( Py_None );
+}
+
+
+static PyObject *Material_setRefracIndex( BPy_Material * self, PyObject * args )
+{
+ float value;
+
+ if( !PyArg_ParseTuple( args, "f", &value ) )
+ return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+ "expected float argument in [1.0, 10.0]" ) );
+
+ self->material->refrac = EXPP_ClampFloat( value, EXPP_MAT_REFRACINDEX_MIN,
+ EXPP_MAT_REFRACINDEX_MAX );
+
+ return EXPP_incr_ret( Py_None );
+}
+
+
+static PyObject *Material_setRms( BPy_Material * self, PyObject * args )
+{
+ float value;
+
+ if( !PyArg_ParseTuple( args, "f", &value ) )
+ return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+ "expected float argument in [0.0, 0.4]" ) );
+
+ self->material->rms = EXPP_ClampFloat( value, EXPP_MAT_RMS_MIN,
+ EXPP_MAT_RMS_MAX );
+
+ return EXPP_incr_ret( Py_None );
+}
+
+
static PyObject *Material_setColorComponent( BPy_Material * self, char *key,
PyObject * args )
{ /* for compatibility with old bpython */
@@ -1868,6 +2330,38 @@ static PyObject *Material_setFresnelMirr
return EXPP_incr_ret( Py_None );
}
+static PyObject *Material_setFilter( BPy_Material * self,
+ PyObject * args )
+{
+ float value;
+
+ if( !PyArg_ParseTuple( args, "f", &value ) )
+ return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+ "expected float argument in [0.0, 1.0]" ) );
+
+ self->material->filter =
+ EXPP_ClampFloat( value, EXPP_MAT_FILTER_MIN,
+ EXPP_MAT_FILTER_MAX );
+
+ return EXPP_incr_ret( Py_None );
+}
+
+static PyObject *Material_setTranslucency( BPy_Material * self,
+ PyObject * args )
+{
+ float value;
+
+ if( !PyArg_ParseTuple( args, "f", &value ) )
+ return ( EXPP_ReturnPyObjError( PyExc_TypeError,
+ "expected float argument in [0.0, 1.0]" ) );
+
+ self->material->translucency =
+ EXPP_ClampFloat( value, EXPP_MAT_TRANSLUCENCY_MIN,
+ EXPP_MAT_TRANSLUCENCY_MAX );
+
+ return EXPP_incr_ret( Py_None );
+}
+
static PyObject *Material_setIOR( BPy_Material * self, PyObject * args )
{
float value;
@@ -2115,6 +2609,12 @@ static PyObject *Material_getAttr( BPy_M
else if( strcmp( name, "fresnelDepthFac" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->
fresnel_mir_i );
+ else if( strcmp( name, "filter" ) == 0 )
+ attr = PyFloat_FromDouble( ( double ) self->material->
+ filter );
+ else if( strcmp( name, "translucency" ) == 0 )
+ attr = PyFloat_FromDouble( ( double ) self->material->
+ translucency );
else if( strcmp( name, "IOR" ) == 0 )
attr = PyFloat_FromDouble( ( double ) self->material->ang );
else if( strcmp( name, "transDepth" ) == 0 )
@@ -2129,6 +2629,38 @@ static PyObject *Material_getAttr( BPy_M
else if( strcmp( name, "users" ) == 0 )
attr = PyInt_FromLong( ( double ) self->material->
id.us );
+ /* Shader settings*/
+ else if( strcmp( name, "specShader" ) == 0 )
+ attr = PyInt_FromLong( ( double ) self->material->
+ spec_shader );
+ else if( strcmp( name, "diffuseShader" ) == 0 )
+ attr = PyInt_FromLong( ( double ) self->material->
+ diff_shader );
+ else if( strcmp( name, "roughness" ) == 0 )
+ attr = PyFloat_FromDouble( ( double ) self->material->
+ roughness );
+ else if( strcmp( name, "specSize" ) == 0 )
+ attr = PyFloat_FromDouble( ( double ) self->material->
+ param[2] );
+ else if( strcmp( name, "diffuseSize" ) == 0 )
+ attr = PyFloat_FromDouble( ( double ) self->material->
+ param[0] );
+ else if( strcmp( name, "specSmooth" ) == 0 )
+ attr = PyFloat_FromDouble( ( double ) self->material->
+ param[3] );
+ else if( strcmp( name, "diffuseSmooth" ) == 0 )
+ attr = PyFloat_FromDouble( ( double ) self->material->
+ param[1] );
+ else if( strcmp( name, "diffuseDarkness" ) == 0 )
+ attr = PyFloat_FromDouble( ( double ) self->material->
+ darkness );
+ else if( strcmp( name, "refracIndex" ) == 0 )
+ attr = PyFloat_FromDouble( ( double ) self->material->
+ refrac );
+ else if( strcmp( name, "rms" ) == 0 )
+ attr = PyFloat_FromDouble( ( double ) self->material->
+ rms );
+
else if (strcmp(name, "oopsLoc") == 0) {
if (G.soops) {
Oops *oops= G.soops->oops.first;
@@ -2166,7 +2698,7 @@ static PyObject *Material_getAttr( BPy_M
else if( strcmp( name, "__members__" ) == 0 ) {
attr = /* 30 items */
Py_BuildValue
- ( "[s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s]",
+ ( "[s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s,s]",
"name", "mode", "rgbCol", "specCol", "mirCol", "R",
"G", "B", "alpha", "amb", "emit", "ref", "spec",
"specTransp", "add", "zOffset", "haloSize",
@@ -2174,9 +2706,12 @@ static PyObject *Material_getAttr( BPy_M
"subSize", "hard", "nFlares", "nStars", "nLines",
"nRings", "rayMirr", "rayMirrDepth", "fresnelDepth",
"fresnelDepthFac", "IOR", "transDepth",
- "fresnelTrans", "fresnelTransFac", "users", "oopsLoc", "oopsSel" );
- }
-
+ "fresnelTrans", "fresnelTransFac", "users", "oopsLoc", "oopsSel",
+ "filter", "translucency",
+ "shader", "roughness", "specSize", "diffuseSize", "specSmooth",
+ "diffuseSmooth", "diffuseDarkness", "refracIndex", "rms");
+ }
+
if( !attr )
return ( EXPP_ReturnPyObjError( PyExc_MemoryError,
"couldn't create PyObject" ) );
@@ -2286,6 +2821,10 @@ static int Material_setAttr( BPy_Materia
error = Material_setFresnelMirr( self, valtuple );
else if( strcmp( name, "fresnelDepthFac" ) == 0 )
error = Material_setFresnelMirrFac( self, valtuple );
+ else if( strcmp( name, "filter" ) == 0 )
+ error = Material_setFilter( self, valtuple );
+ else if( strcmp( name, "translucency" ) == 0 )
+ error = Material_setTranslucency( self, valtuple );
else if( strcmp( name, "IOR" ) == 0 )
error = Material_setIOR( self, valtuple );
else if( strcmp( name, "transDepth" ) == 0 )
@@ -2294,6 +2833,27 @@ static int Material_setAttr( BPy_Materia
error = Material_setFresnelTrans( self, valtuple );
else if( strcmp( name, "fresnelTransFac" ) == 0 )
error = Material_setFresnelTransFac( self, valtuple );
+ /* Shader settings */
+ else if( strcmp( name, "specShader" ) == 0 )
+ error = Material_setSpecShader( self, valtuple );
+ else if( strcmp( name, "diffuseShader" ) == 0 )
+ error = Material_setDiffuseShader( self, valtuple );
+ else if( strcmp( name, "roughness" ) == 0 )
+ error = Material_setRoughness( self, valtuple );
+ else if( strcmp( name, "specSize" ) == 0 )
+ error = Material_setSpecSize( self, valtuple );
+ else if( strcmp( name, "diffuseSize" ) == 0 )
+ error = Material_setDiffuseSize( self, valtuple );
+ else if( strcmp( name, "specSmooth" ) == 0 )
+ error = Material_setSpecSmooth( self, valtuple );
+ else if( strcmp( name, "diffuseSmooth" ) == 0 )
+ error = Material_setDiffuseSmooth( self, valtuple );
+ else if( strcmp( name, "diffuseDarkness" ) == 0 )
+ error = Material_setDiffuseDarkness( self, valtuple );
+ else if( strcmp( name, "refracIndex" ) == 0 )
+ error = Material_setRefracIndex( self, valtuple );
+ else if( strcmp( name, "rms" ) == 0 )
+ error = Material_setRms( self, valtuple );
else if (strcmp (name, "oopsLoc") == 0) {
if (G.soops) {
Oops *oops= G.soops->oops.first;
Index: source/blender/python/api2_2x/doc/Material.py
===================================================================
RCS file: /cvsroot/bf-blender/blender/source/blender/python/api2_2x/doc/Material.py,v
retrieving revision 1.12
diff -u -p -u -r1.12 Material.py
--- source/blender/python/api2_2x/doc/Material.py 27 May 2005 05:39:41 -0000 1.12
+++ source/blender/python/api2_2x/doc/Material.py 6 Jun 2005 00:48:22 -0000
@@ -56,6 +56,19 @@ Example::
such possibilities in the Modes dict below: each halo-related mode that
uses an already taken value is preceded by "-" and appear below the normal
mode which also uses that value.
+
+
+@type Shaders: readonly dictionary
+@var Shaders: The available Material Modes.
+ - DIFFUSE_LAMBERT - Make Material use the lambert diffuse shader.
+ - DIFFUSE_ORENNAYAR - Make Material use the orennayar diffuse shader.
+ - DIFFUSE_TOON - Make Material use the toon diffuse shader.
+ - DIFFUSE_MINNAERT - Make Material use the minnaert diffuse shader.
+ - SPEC_COOKTORR - Make Material use the cooktorr specular shader.
+ - SPEC_PHONG - Make Material use the phong specular shader.
+ - SPEC_BLINN - Make Material use the blinn specular shader.
+ - SPEC_TOON - Make Material use the toon specular shader.
+ - SPEC_WARDISO - Make Material use the wardiso specular shader.
"""
def New (name = 'Mat'):
@@ -124,6 +137,20 @@ class Material:
@cvar fresnelTrans: Power of Fresnel for transparency.
@cvar fresnelTransFac: Blending factor for Fresnel.
@cvar specTrans: Makes specular areas opaque on transparent materials.
+
+ @cvar specShader: Specular shader from one of the shaders in Material.Shaders dict - [0, 4].
+ @cvar diffuseShader: Diffuse shader from one of the shaders in Material.Shaders dict - [0, 3].
+ @cvar roughness: Material's Roughness (Applies to the \"Oren Nayar\" Diffuse Shader Only) - [0.0, 3.14].
+ @cvar specSize: Material's size of speculara area (Applies to the \"Toon\" Specular Shader Only) - [0.0, 1.53].
+ @cvar diffuseSize: Material's size of diffuse area (Applies to the \"Toon\" Diffuse Shader Only) - [0.0, 3.14].
+ @cvar specSmooth: Material's smoothing of specular area (Applies to the \"Toon\" Specular Shader Only) - [0.0, 1.0].
+ @cvar diffuseSmooth: Material's smoothing of diffuse area (Applies to the \"Toon\" Diffuse Shader Only) - [0.0, 1.0].
+ @cvar diffuseDarkness: Material's diffuse darkness (Applies to the \"Minnaert\" Diffuse Shader Only) - [0.0, 2.0].
+ @cvar refracIndex: Material's Index of Refraction (Applies to the \"Blinn\" Specular Shader Only) - [1.0, 10.0].
+ @cvar rms: Material's standard deviation of surface slope (Applies to the \"WardIso\" Specular Shader Only) - [0.0, 0.4].
+ @cvar filter: Amount of filtering when transperent raytrace is enabled - [0.0, 1.0].
+ @cvar translucency: Amount of diffuse shading of the back side - [0.0, 1.0].
+
@warning: Most member variables assume values in some [Min, Max] interval.
When trying to set them, the given parameter will be clamped to lie in
that range: if val < Min, then val = Min, if val > Max, then val = Max.
@@ -343,6 +370,162 @@ class Material:
Set the specular transparency.
@type spectransp: float
@param spectransp: The new value in [0.0, 1.0].
+ """
+
+ def setSpecShader(specShader):
+ """
+ Set the material's specular shader from one of the shaders in Material.Shaders dict.
+ @type specShader: int
+ @param specShader: The new value in [0, 4].
+ """
+
+ def getSpecShader(specShader):
+ """
+ Get the material's specular shader from one of the shaders in Material.Shaders dict.
+ @rtype: int
+ """
+
+ def setDiffuseShader(diffuseShader):
+ """
+ Set the material's diffuse shader from one of the shaders in Material.Shaders dict.
+ @type diffuseShader: int
+ @param diffuseShader: The new value in [0, 3].
+ """
+
+ def getDiffuseShader():
+ """
+ Get the material's diffuse shader from one of the shaders in Material.Shaders dict.
+ @rtype: int
+ """
+
+ def setRoughness(roughness):
+ """
+ Set the material's roughness (Applies to the \"Oren Nayar\" Diffuse Shader Only)
+ @type roughness: float
+ @param roughness: The new value in [0.0, 3.14].
+ """
+
+ def getRoughness():
+ """
+ Get the material's roughness (Applies to the \"Oren Nayar\" Diffuse Shader Only)
+ @rtype: float
+ """
+
+ def setSpecSize(specSize):
+ """
+ Set the material's size of speculara area (Applies to the \"Toon\" Specular Shader Only)
+ @type specSize: float
+ @param specSize: The new value in [0.0, 1.53].
+ """
+
+ def getSpecSize():
+ """
+ Get the material's size of speculara area (Applies to the \"Toon\" Specular Shader Only)
+ @rtype specSize: float
+ """
+
+ def setSpecSize(diffuseSize):
+ """
+ Set the material's size of diffuse area (Applies to the \"Toon\" Diffuse Shader Only)
+ @type diffuseSize: float
+ @param diffuseSize: The new value in [0.0, 3.14].
+ """
+
+ def getSpecSize():
+ """
+ Get the material's size of diffuse area (Applies to the \"Toon\" Diffuse Shader Only)
+ @rtype: float
+ """
+
+ def setSpecSmooth(specSmooth):
+ """
+ Set the material's smoothing of specular area (Applies to the \"Toon\" Specular Shader Only)
+ @type specSmooth: float
+ @param specSmooth: The new value in [0.0, 1.0].
+ """
+
+ def getSpecSmooth():
+ """
+ Get the material's smoothing of specular area (Applies to the \"Toon\" Specular Shader Only)
+ @rtype: float
+ """
+
+ def setDiffuseSmooth(diffuseSmooth):
+ """
+ Set the material's smoothing of diffuse area (Applies to the \"Toon\" Diffuse Shader Only)
+ @type diffuseSmooth: float
+ @param diffuseSmooth: The new value in [0.0, 1.0].
+ """
+
+ def getDiffuseSmooth():
+ """
+ Get the material's smoothing of diffuse area (Applies to the \"Toon\" Diffuse Shader Only)
+ @rtype: float
+ """
+
+ def setDiffuseDarkness(diffuseDarkness):
+ """
+ Set the material's diffuse darkness (Applies to the \"Minnaert\" Diffuse Shader Only)
+ @type diffuseDarkness: float
+ @param diffuseDarkness: The new value in [0.0, 2.0].
+ """
+
+ def getDiffuseDarkness():
+ """
+ Get the material's diffuse darkness (Applies to the \"Minnaert\" Diffuse Shader Only)
+ @rtype: float
+ """
+
+ def setRefracIndex(refracIndex):
+ """
+ Set the material's Index of Refraction (Applies to the \"Blinn\" Specular Shader Only)
+ @type refracIndex: float
+ @param refracIndex: The new value in [1.0, 10.0].
+ """
+
+ def getRefracIndex():
+ """
+ Get the material's Index of Refraction (Applies to the \"Blinn\" Specular Shader Only)
+ @rtype: float
+ """
+
+ def setRms(rms):
+ """
+ Set the material's standard deviation of surface slope (Applies to the \"WardIso\" Specular Shader Only)
+ @type rms: float
+ @param rms: The new value in [0.0, 0.4].
+ """
+
+ def getRms():
+ """
+ Get the material's standard deviation of surface slope (Applies to the \"WardIso\" Specular Shader Only)
+ @rtype: float
+ """
+
+ def setFilter(filter):
+ """
+ Set the material's amount of filtering when transperent raytrace is enabled
+ @type filter: float
+ @param filter: The new value in [0.0, 1.0].
+ """
+
+ def getFilter():
+ """
+ Get the material's amount of filtering when transperent raytrace is enabled
+ @rtype: float
+ """
+
+ def setTranslucency(translucency):
+ """
+ Set the material's amount of diffuse shading of the back side
+ @type translucency: float
+ @param translucency: The new value in [0.0, 1.0].
+ """
+
+ def getTranslucency():
+ """
+ Get the material's amount of diffuse shading of the back side
+ @rtype: float
"""
def getAdd():

File Metadata

Mime Type
text/x-diff
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
91/97/790df14a83360121b060f686cb95

Event Timeline