1c1 < /* --- > /* 18c18 < * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. --- > * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 60,75c60,75 < #define EXPP_MAT_ADD_MIN 0.0f < #define EXPP_MAT_ADD_MAX 1.0f < #define EXPP_MAT_ALPHA_MIN 0.0f < #define EXPP_MAT_ALPHA_MAX 1.0f < #define EXPP_MAT_AMB_MIN 0.0f < #define EXPP_MAT_AMB_MAX 1.0f < #define EXPP_MAT_COL_MIN 0.0f /* min/max for all ... */ < #define EXPP_MAT_COL_MAX 1.0f /* ... color triplets */ < #define EXPP_MAT_EMIT_MIN 0.0f < #define EXPP_MAT_EMIT_MAX 1.0f < #define EXPP_MAT_REF_MIN 0.0f < #define EXPP_MAT_REF_MAX 1.0f < #define EXPP_MAT_SPEC_MIN 0.0f < #define EXPP_MAT_SPEC_MAX 2.0f < #define EXPP_MAT_SPECTRA_MIN 0.0f < #define EXPP_MAT_SPECTRA_MAX 1.0f --- > #define EXPP_MAT_ADD_MIN 0.0f > #define EXPP_MAT_ADD_MAX 1.0f > #define EXPP_MAT_ALPHA_MIN 0.0f > #define EXPP_MAT_ALPHA_MAX 1.0f > #define EXPP_MAT_AMB_MIN 0.0f > #define EXPP_MAT_AMB_MAX 1.0f > #define EXPP_MAT_COL_MIN 0.0f /* min/max for all ... */ > #define EXPP_MAT_COL_MAX 1.0f /* ... color triplets */ > #define EXPP_MAT_EMIT_MIN 0.0f > #define EXPP_MAT_EMIT_MAX 1.0f > #define EXPP_MAT_REF_MIN 0.0f > #define EXPP_MAT_REF_MAX 1.0f > #define EXPP_MAT_SPEC_MIN 0.0f > #define EXPP_MAT_SPEC_MAX 2.0f > #define EXPP_MAT_SPECTRA_MIN 0.0f > #define EXPP_MAT_SPECTRA_MAX 1.0f 79,94c79,94 < #define EXPP_MAT_ROUGHNESS_MIN 0.0f < #define EXPP_MAT_ROUGHNESS_MAX 3.140f < #define EXPP_MAT_SPECSIZE_MIN 0.0f < #define EXPP_MAT_SPECSIZE_MAX 1.530f < #define EXPP_MAT_DIFFUSESIZE_MIN 0.0f < #define EXPP_MAT_DIFFUSESIZE_MAX 3.140f < #define EXPP_MAT_SPECSMOOTH_MIN 0.0f < #define EXPP_MAT_SPECSMOOTH_MAX 1.0f < #define EXPP_MAT_DIFFUSESMOOTH_MIN 0.0f < #define EXPP_MAT_DIFFUSESMOOTH_MAX 1.0f < #define EXPP_MAT_DIFFUSE_DARKNESS_MIN 0.0f < #define EXPP_MAT_DIFFUSE_DARKNESS_MAX 2.0f < #define EXPP_MAT_REFRACINDEX_MIN 1.0f < #define EXPP_MAT_REFRACINDEX_MAX 10.0f < #define EXPP_MAT_RMS_MIN 0.0f < #define EXPP_MAT_RMS_MAX 0.4f --- > #define EXPP_MAT_ROUGHNESS_MIN 0.0f > #define EXPP_MAT_ROUGHNESS_MAX 3.140f > #define EXPP_MAT_SPECSIZE_MIN 0.0f > #define EXPP_MAT_SPECSIZE_MAX 1.530f > #define EXPP_MAT_DIFFUSESIZE_MIN 0.0f > #define EXPP_MAT_DIFFUSESIZE_MAX 3.140f > #define EXPP_MAT_SPECSMOOTH_MIN 0.0f > #define EXPP_MAT_SPECSMOOTH_MAX 1.0f > #define EXPP_MAT_DIFFUSESMOOTH_MIN 0.0f > #define EXPP_MAT_DIFFUSESMOOTH_MAX 1.0f > #define EXPP_MAT_DIFFUSE_DARKNESS_MIN 0.0f > #define EXPP_MAT_DIFFUSE_DARKNESS_MAX 2.0f > #define EXPP_MAT_REFRACINDEX_MIN 1.0f > #define EXPP_MAT_REFRACINDEX_MAX 10.0f > #define EXPP_MAT_RMS_MIN 0.0f > #define EXPP_MAT_RMS_MAX 0.4f 97,110c97,110 < #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.1f < #define EXPP_MAT_FLARESIZE_MAX 25.0 < #define EXPP_MAT_FLAREBOOST_MIN 0.1f < #define EXPP_MAT_FLAREBOOST_MAX 10.0 < #define EXPP_MAT_SUBSIZE_MIN 0.1f < #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 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.1f > #define EXPP_MAT_FLARESIZE_MAX 25.0 > #define EXPP_MAT_FLAREBOOST_MIN 0.1f > #define EXPP_MAT_FLAREBOOST_MAX 10.0 > #define EXPP_MAT_SUBSIZE_MIN 0.1f > #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 0 112,114c112,114 < #define EXPP_MAT_NFLARES_MIN 1 < #define EXPP_MAT_NFLARES_MAX 32 < #define EXPP_MAT_FLARESEED_MIN 0 --- > #define EXPP_MAT_NFLARES_MIN 1 > #define EXPP_MAT_NFLARES_MAX 32 > #define EXPP_MAT_FLARESEED_MIN 0 116,156c116,156 < #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_RAYMIRRGLOSS_MIN 0.0 < #define EXPP_MAT_RAYMIRRGLOSS_MAX 1.0 < #define EXPP_MAT_RAYMIRRGLOSSSAMPLES_MIN 0 < #define EXPP_MAT_RAYMIRRGLOSSSAMPLES_MAX 255 < #define EXPP_MAT_RAYTRANSPGLOSS_MIN 0.0 < #define EXPP_MAT_RAYTRANSPGLOSS_MAX 1.0 < #define EXPP_MAT_RAYTRANSPGLOSSSAMPLES_MIN 0 < #define EXPP_MAT_RAYTRANSPGLOSSSAMPLES_MAX 255 < #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 < #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 --- > #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_RAYMIRRGLOSS_MIN 0.0 > #define EXPP_MAT_RAYMIRRGLOSS_MAX 1.0 > #define EXPP_MAT_RAYMIRRGLOSSSAMPLES_MIN 0 > #define EXPP_MAT_RAYMIRRGLOSSSAMPLES_MAX 255 > #define EXPP_MAT_RAYTRANSPGLOSS_MIN 0.0 > #define EXPP_MAT_RAYTRANSPGLOSS_MAX 1.0 > #define EXPP_MAT_RAYTRANSPGLOSSSAMPLES_MIN 0 > #define EXPP_MAT_RAYTRANSPGLOSSSAMPLES_MAX 255 > #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 > #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 160,171c160,171 < #define EXPP_MAT_COMP_R 0 < #define EXPP_MAT_COMP_G 1 < #define EXPP_MAT_COMP_B 2 < #define EXPP_MAT_COMP_SPECR 3 < #define EXPP_MAT_COMP_SPECG 4 < #define EXPP_MAT_COMP_SPECB 5 < #define EXPP_MAT_COMP_MIRR 6 < #define EXPP_MAT_COMP_MIRG 7 < #define EXPP_MAT_COMP_MIRB 8 < #define EXPP_MAT_COMP_SSSR 9 < #define EXPP_MAT_COMP_SSSG 10 < #define EXPP_MAT_COMP_SSSB 11 --- > #define EXPP_MAT_COMP_R 0 > #define EXPP_MAT_COMP_G 1 > #define EXPP_MAT_COMP_B 2 > #define EXPP_MAT_COMP_SPECR 3 > #define EXPP_MAT_COMP_SPECG 4 > #define EXPP_MAT_COMP_SPECB 5 > #define EXPP_MAT_COMP_MIRR 6 > #define EXPP_MAT_COMP_MIRG 7 > #define EXPP_MAT_COMP_MIRB 8 > #define EXPP_MAT_COMP_SSSR 9 > #define EXPP_MAT_COMP_SSSG 10 > #define EXPP_MAT_COMP_SSSB 11 175,176c175,176 < #define IPOKEY_ALPHA 1 < #define IPOKEY_HALOSIZE 2 --- > #define IPOKEY_ALPHA 1 > #define IPOKEY_HALOSIZE 2 185,196c185,200 < #define EXPP_MAT_SSS_SCALE_MIN 0.001 < #define EXPP_MAT_SSS_SCALE_MAX 1000.0 < #define EXPP_MAT_SSS_RADIUS_MIN 0.0 < #define EXPP_MAT_SSS_RADIUS_MAX 10000.0 < #define EXPP_MAT_SSS_IOR_MIN 0.1 < #define EXPP_MAT_SSS_IOR_MAX 2.0 < #define EXPP_MAT_SSS_ERROR_MIN 0.0 < #define EXPP_MAT_SSS_ERROR_MAX 1.0 < #define EXPP_MAT_SSS_FRONT_MIN 0.0 < #define EXPP_MAT_SSS_FRONT_MAX 2.0 < #define EXPP_MAT_SSS_BACK_MIN 0.0 < #define EXPP_MAT_SSS_BACK_MAX 10.0 --- > #define EXPP_MAT_SSS_SCALE_MIN 0.001 > #define EXPP_MAT_SSS_SCALE_MAX 1000.0 > #define EXPP_MAT_SSS_RADIUS_MIN 0.0 > #define EXPP_MAT_SSS_RADIUS_MAX 10000.0 > #define EXPP_MAT_SSS_IOR_MIN 0.1 > #define EXPP_MAT_SSS_IOR_MAX 2.0 > #define EXPP_MAT_SSS_ERROR_MIN 0.0 > #define EXPP_MAT_SSS_ERROR_MAX 1.0 > #define EXPP_MAT_SSS_FRONT_MIN 0.0 > #define EXPP_MAT_SSS_FRONT_MAX 2.0 > #define EXPP_MAT_SSS_BACK_MIN 0.0 > #define EXPP_MAT_SSS_BACK_MAX 10.0 > > /* ColorRamp Settings */ > #define EXPP_MAT_COLORBAND_FACTOR_MIN 0.0 > #define EXPP_MAT_COLORBAND_FACTOR_MAX 1.0 203c207 < PyObject * keywords ); --- > PyObject * keywords ); 214c218 < "(name) - return a new material called 'name'\n\ --- > "(name) - return a new material called 'name'\n\ 218c222 < "(name) - return the material called 'name', None if not found.\n\ --- > "(name) - return the material called 'name', None if not found.\n\ 225,229c229,233 < {"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} --- > {"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} 233,234c237,238 < /* Function: M_Material_New */ < /* Python equivalent: Blender.Material.New */ --- > /* Function: M_Material_New */ > /* Python equivalent: Blender.Material.New */ 237c241 < PyObject * keywords ) --- > PyObject * keywords ) 239,243c243,247 < 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]; --- > 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]; 245,249c249,253 < if( !PyArg_ParseTupleAndKeywords < ( args, keywords, "|s", kwlist, &name ) ) < return ( EXPP_ReturnPyObjError < ( PyExc_AttributeError, < "expected string or nothing as argument" ) ); --- > if( !PyArg_ParseTupleAndKeywords > ( args, keywords, "|s", kwlist, &name ) ) > return ( EXPP_ReturnPyObjError > ( PyExc_AttributeError, > "expected string or nothing as argument" ) ); 251,252c255,256 < if( strcmp( name, "Mat" ) != 0 ) /* use gave us a name ? */ < PyOS_snprintf( buf, sizeof( buf ), "%s", name ); --- > if( strcmp( name, "Mat" ) != 0 ) /* use gave us a name ? */ > PyOS_snprintf( buf, sizeof( buf ), "%s", name ); 254c258 < blmat = add_material( name ); /* first create the Material Data in Blender */ --- > blmat = add_material( name ); /* first create the Material Data in Blender */ 256,260c260,264 < 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" ) ); --- > 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" ) ); 262c266 < blmat->id.us = 0; /* was incref'ed by add_material() above */ --- > blmat->id.us = 0; /* was incref'ed by add_material() above */ 264,266c268,270 < if( pymat == NULL ) < return ( EXPP_ReturnPyObjError( PyExc_MemoryError, < "couldn't create Material Data object" ) ); --- > if( pymat == NULL ) > return ( EXPP_ReturnPyObjError( PyExc_MemoryError, > "couldn't create Material Data object" ) ); 268c272 < return ( PyObject * ) pymat; --- > return ( PyObject * ) pymat; 272,277c276,281 < /* 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. */ --- > /* 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. */ 281,282c285,286 < char *name = NULL; < Material *mat_iter; --- > char *name = NULL; > Material *mat_iter; 284,327c288,331 < if( !PyArg_ParseTuple( args, "|s", &name ) ) < return ( EXPP_ReturnPyObjError( PyExc_TypeError, < "expected string argument (or nothing)" ) ); < < if( name ) { /* (name) - Search material by name */ < < mat_iter = ( Material * ) GetIdFromList( &( G.main->mat ), name ); < < if( mat_iter == 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 Material_CreatePyObject( mat_iter ); < } < < 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" ) ); < < mat_iter = G.main->mat.first; < while( mat_iter ) { < pyobj = Material_CreatePyObject( mat_iter ); < < if( !pyobj ) { < Py_DECREF(matlist); < return ( EXPP_ReturnPyObjError < ( PyExc_MemoryError, < "couldn't create PyObject" ) ); < } < PyList_SET_ITEM( matlist, index, pyobj ); < < mat_iter = mat_iter->id.next; < index++; < } --- > if( !PyArg_ParseTuple( args, "|s", &name ) ) > return ( EXPP_ReturnPyObjError( PyExc_TypeError, > "expected string argument (or nothing)" ) ); > > if( name ) { /* (name) - Search material by name */ > > mat_iter = ( Material * ) GetIdFromList( &( G.main->mat ), name ); > > if( mat_iter == 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 Material_CreatePyObject( mat_iter ); > } > > 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" ) ); > > mat_iter = G.main->mat.first; > while( mat_iter ) { > pyobj = Material_CreatePyObject( mat_iter ); > > if( !pyobj ) { > Py_DECREF(matlist); > return ( EXPP_ReturnPyObjError > ( PyExc_MemoryError, > "couldn't create PyObject" ) ); > } > PyList_SET_ITEM( matlist, index, pyobj ); > > mat_iter = mat_iter->id.next; > index++; > } 329,330c333,334 < return matlist; < } --- > return matlist; > } 335c339,342 < PyObject *Modes = PyConstant_New( ); --- > PyObject *Modes = PyConstant_New( ); > > if( Modes ) { > BPy_constant *c = ( BPy_constant * ) Modes; 337,338c344,379 < if( Modes ) { < BPy_constant *c = ( BPy_constant * ) Modes; --- > PyConstant_Insert(c, "TRACEABLE", PyInt_FromLong(MA_TRACEBLE)); > PyConstant_Insert(c, "SHADOW", PyInt_FromLong(MA_SHADOW)); > PyConstant_Insert(c, "SHADOWBUF", PyInt_FromLong(MA_SHADBUF)); > PyConstant_Insert(c, "TANGENTSTR", PyInt_FromLong(MA_TANGENT_STR)); > PyConstant_Insert(c, "FULLOSA", PyInt_FromLong(MA_FULL_OSA)); > PyConstant_Insert(c, "RAYBIAS", PyInt_FromLong(MA_RAYBIAS)); > PyConstant_Insert(c, "TRANSPSHADOW", PyInt_FromLong(MA_SHADOW_TRA)); > PyConstant_Insert(c, "RAMPCOL", PyInt_FromLong(MA_RAMP_COL)); > PyConstant_Insert(c, "RAMPSPEC", PyInt_FromLong(MA_RAMP_SPEC)); > PyConstant_Insert(c, "SHADELESS", PyInt_FromLong(MA_SHLESS)); > PyConstant_Insert(c, "WIRE", PyInt_FromLong(MA_WIRE)); > PyConstant_Insert(c, "VCOL_LIGHT", PyInt_FromLong(MA_VERTEXCOL)); > PyConstant_Insert(c, "HALO", PyInt_FromLong(MA_HALO)); > PyConstant_Insert(c, "ZTRANSP", PyInt_FromLong(MA_ZTRA)); > PyConstant_Insert(c, "VCOL_PAINT", PyInt_FromLong(MA_VERTEXCOLP)); > PyConstant_Insert(c, "ZINVERT", PyInt_FromLong(MA_ZINV)); > PyConstant_Insert(c, "HALORINGS", PyInt_FromLong(MA_HALO_RINGS)); > PyConstant_Insert(c, "ENV", PyInt_FromLong(MA_ENV)); > PyConstant_Insert(c, "HALOLINES", PyInt_FromLong(MA_HALO_LINES)); > PyConstant_Insert(c, "ONLYSHADOW", PyInt_FromLong(MA_ONLYSHADOW)); > PyConstant_Insert(c, "HALOXALPHA", PyInt_FromLong(MA_HALO_XALPHA)); > PyConstant_Insert(c, "HALOSTAR", PyInt_FromLong(MA_STAR)); > PyConstant_Insert(c, "TEXFACE", PyInt_FromLong(MA_FACETEXTURE)); > PyConstant_Insert(c, "HALOTEX", PyInt_FromLong(MA_HALOTEX)); > PyConstant_Insert(c, "HALOPUNO", PyInt_FromLong(MA_HALOPUNO)); > PyConstant_Insert(c, "NOMIST", PyInt_FromLong(MA_NOMIST)); > PyConstant_Insert(c, "HALOSHADE", PyInt_FromLong(MA_HALO_SHADE)); > PyConstant_Insert(c, "HALOFLARE", PyInt_FromLong(MA_HALO_FLARE)); > PyConstant_Insert(c, "RADIO", PyInt_FromLong(MA_RADIO)); > PyConstant_Insert(c, "RAYMIRROR", PyInt_FromLong(MA_RAYMIRROR)); > PyConstant_Insert(c, "ZTRA", PyInt_FromLong(MA_ZTRA)); > PyConstant_Insert(c, "RAYTRANSP", PyInt_FromLong(MA_RAYTRANSP)); > PyConstant_Insert(c, "TANGENT_V", PyInt_FromLong(MA_TANGENT_V)); > PyConstant_Insert(c, "NMAP_TS", PyInt_FromLong(MA_NORMAP_TANG)); > PyConstant_Insert(c, "GROUP_EXCLUSIVE", PyInt_FromLong(MA_GROUP_NOLAY)); > PyConstant_Insert(c, "TEXFACE_ALPHA", PyInt_FromLong(MA_FACETEXTURE_ALPHA)); 340,377c381 < PyConstant_Insert(c, "TRACEABLE", PyInt_FromLong(MA_TRACEBLE)); < PyConstant_Insert(c, "SHADOW", PyInt_FromLong(MA_SHADOW)); < PyConstant_Insert(c, "SHADOWBUF", PyInt_FromLong(MA_SHADBUF)); < PyConstant_Insert(c, "TANGENTSTR", PyInt_FromLong(MA_TANGENT_STR)); < PyConstant_Insert(c, "FULLOSA", PyInt_FromLong(MA_FULL_OSA)); < PyConstant_Insert(c, "RAYBIAS", PyInt_FromLong(MA_RAYBIAS)); < PyConstant_Insert(c, "TRANSPSHADOW", PyInt_FromLong(MA_SHADOW_TRA)); < PyConstant_Insert(c, "RAMPCOL", PyInt_FromLong(MA_RAMP_COL)); < PyConstant_Insert(c, "RAMPSPEC", PyInt_FromLong(MA_RAMP_SPEC)); < PyConstant_Insert(c, "SHADELESS", PyInt_FromLong(MA_SHLESS)); < PyConstant_Insert(c, "WIRE", PyInt_FromLong(MA_WIRE)); < PyConstant_Insert(c, "VCOL_LIGHT", PyInt_FromLong(MA_VERTEXCOL)); < PyConstant_Insert(c, "HALO", PyInt_FromLong(MA_HALO)); < PyConstant_Insert(c, "ZTRANSP", PyInt_FromLong(MA_ZTRA)); < PyConstant_Insert(c, "VCOL_PAINT", PyInt_FromLong(MA_VERTEXCOLP)); < PyConstant_Insert(c, "ZINVERT", PyInt_FromLong(MA_ZINV)); < PyConstant_Insert(c, "HALORINGS", PyInt_FromLong(MA_HALO_RINGS)); < PyConstant_Insert(c, "ENV", PyInt_FromLong(MA_ENV)); < PyConstant_Insert(c, "HALOLINES", PyInt_FromLong(MA_HALO_LINES)); < PyConstant_Insert(c, "ONLYSHADOW", PyInt_FromLong(MA_ONLYSHADOW)); < PyConstant_Insert(c, "HALOXALPHA", PyInt_FromLong(MA_HALO_XALPHA)); < PyConstant_Insert(c, "HALOSTAR", PyInt_FromLong(MA_STAR)); < PyConstant_Insert(c, "TEXFACE", PyInt_FromLong(MA_FACETEXTURE)); < PyConstant_Insert(c, "HALOTEX", PyInt_FromLong(MA_HALOTEX)); < PyConstant_Insert(c, "HALOPUNO", PyInt_FromLong(MA_HALOPUNO)); < PyConstant_Insert(c, "NOMIST", PyInt_FromLong(MA_NOMIST)); < PyConstant_Insert(c, "HALOSHADE", PyInt_FromLong(MA_HALO_SHADE)); < PyConstant_Insert(c, "HALOFLARE", PyInt_FromLong(MA_HALO_FLARE)); < PyConstant_Insert(c, "RADIO", PyInt_FromLong(MA_RADIO)); < PyConstant_Insert(c, "RAYMIRROR", PyInt_FromLong(MA_RAYMIRROR)); < PyConstant_Insert(c, "ZTRA", PyInt_FromLong(MA_ZTRA)); < PyConstant_Insert(c, "RAYTRANSP", PyInt_FromLong(MA_RAYTRANSP)); < PyConstant_Insert(c, "TANGENT_V", PyInt_FromLong(MA_TANGENT_V)); < PyConstant_Insert(c, "NMAP_TS", PyInt_FromLong(MA_NORMAP_TANG)); < PyConstant_Insert(c, "GROUP_EXCLUSIVE", PyInt_FromLong(MA_GROUP_NOLAY)); < PyConstant_Insert(c, "TEXFACE_ALPHA", PyInt_FromLong(MA_FACETEXTURE_ALPHA)); < < } --- > } 379c383 < return Modes; --- > return Modes; 385,388c389 < PyObject *Shaders = PyConstant_New( ); < < if( Shaders ) { < BPy_constant *c = ( BPy_constant * ) Shaders; --- > PyObject *Shaders = PyConstant_New( ); 390,398c391,392 < PyConstant_Insert(c, "DIFFUSE_LAMBERT", PyInt_FromLong(MA_DIFF_LAMBERT)); < PyConstant_Insert(c, "DIFFUSE_ORENNAYAR", PyInt_FromLong(MA_DIFF_ORENNAYAR)); < PyConstant_Insert(c, "DIFFUSE_TOON", PyInt_FromLong(MA_DIFF_TOON)); < PyConstant_Insert(c, "DIFFUSE_MINNAERT", PyInt_FromLong(MA_DIFF_MINNAERT)); < PyConstant_Insert(c, "SPEC_COOKTORR", PyInt_FromLong(MA_SPEC_COOKTORR)); < PyConstant_Insert(c, "SPEC_PHONG", PyInt_FromLong(MA_SPEC_PHONG)); < PyConstant_Insert(c, "SPEC_BLINN", PyInt_FromLong(MA_SPEC_BLINN)); < PyConstant_Insert(c, "SPEC_TOON", PyInt_FromLong(MA_SPEC_TOON)); < PyConstant_Insert(c, "SPEC_WARDISO", PyInt_FromLong(MA_SPEC_WARDISO)); --- > if( Shaders ) { > BPy_constant *c = ( BPy_constant * ) Shaders; 400,402c394,449 < } < < return Shaders; --- > PyConstant_Insert(c, "DIFFUSE_LAMBERT", PyInt_FromLong(MA_DIFF_LAMBERT)); > PyConstant_Insert(c, "DIFFUSE_ORENNAYAR", PyInt_FromLong(MA_DIFF_ORENNAYAR)); > PyConstant_Insert(c, "DIFFUSE_TOON", PyInt_FromLong(MA_DIFF_TOON)); > PyConstant_Insert(c, "DIFFUSE_MINNAERT", PyInt_FromLong(MA_DIFF_MINNAERT)); > PyConstant_Insert(c, "SPEC_COOKTORR", PyInt_FromLong(MA_SPEC_COOKTORR)); > PyConstant_Insert(c, "SPEC_PHONG", PyInt_FromLong(MA_SPEC_PHONG)); > PyConstant_Insert(c, "SPEC_BLINN", PyInt_FromLong(MA_SPEC_BLINN)); > PyConstant_Insert(c, "SPEC_TOON", PyInt_FromLong(MA_SPEC_TOON)); > PyConstant_Insert(c, "SPEC_WARDISO", PyInt_FromLong(MA_SPEC_WARDISO)); > > } > > return Shaders; > } > > static PyObject *Material_ColorRampMethodsDict( void ) > { > PyObject *Methods = PyConstant_New( ); > if( Methods ) > { > BPy_constant *c = (BPy_constant * ) Methods; > > PyConstant_Insert(c, "BLEND", PyInt_FromLong(MA_RAMP_BLEND)); > PyConstant_Insert(c, "MIX", PyInt_FromLong(MA_RAMP_BLEND));//This one is added to solve confusion between Blend-Mix name. > PyConstant_Insert(c, "ADD", PyInt_FromLong(MA_RAMP_ADD)); > PyConstant_Insert(c, "MULT", PyInt_FromLong(MA_RAMP_MULT)); > PyConstant_Insert(c, "SUB", PyInt_FromLong(MA_RAMP_SUB)); > PyConstant_Insert(c, "SCREEN", PyInt_FromLong(MA_RAMP_SCREEN)); > PyConstant_Insert(c, "DIV", PyInt_FromLong(MA_RAMP_DIV)); > PyConstant_Insert(c, "DIFF", PyInt_FromLong(MA_RAMP_DIFF)); > PyConstant_Insert(c, "DARK", PyInt_FromLong(MA_RAMP_DARK)); > PyConstant_Insert(c, "LIGHT", PyInt_FromLong(MA_RAMP_LIGHT)); > PyConstant_Insert(c, "OVERLAY", PyInt_FromLong(MA_RAMP_OVERLAY)); > PyConstant_Insert(c, "DODGE", PyInt_FromLong(MA_RAMP_DODGE)); > PyConstant_Insert(c, "BURN", PyInt_FromLong(MA_RAMP_BURN)); > PyConstant_Insert(c, "HUE", PyInt_FromLong(MA_RAMP_HUE)); > PyConstant_Insert(c, "SAT", PyInt_FromLong(MA_RAMP_SAT)); > PyConstant_Insert(c, "VAL", PyInt_FromLong(MA_RAMP_VAL)); > PyConstant_Insert(c, "COLOR", PyInt_FromLong(MA_RAMP_COLOR)); > } > return Methods; > } > > static PyObject *Material_ColorRampInputDict( void ) > { > PyObject *Inputs = PyConstant_New( ); > if( Inputs ) > { > BPy_constant *c = (BPy_constant * ) Inputs; > > PyConstant_Insert(c, "SHADER", PyInt_FromLong(MA_RAMP_IN_SHADER)); > PyConstant_Insert(c, "ENERGY", PyInt_FromLong(MA_RAMP_IN_ENERGY)); > PyConstant_Insert(c, "NORMAL", PyInt_FromLong(MA_RAMP_IN_NOR)); > PyConstant_Insert(c, "RESULT", PyInt_FromLong(MA_RAMP_IN_RESULT)); > } > return Inputs; 405d451 < 407c453 < /* Function: Material_Init */ --- > /* Function: Material_Init */ 411,414c457 < PyObject *submodule, *Modes, *Shaders; < < if( PyType_Ready( &Material_Type ) < 0) < return NULL; --- > PyObject *submodule, *Modes, *Shaders, *ColorBandInput, *ColorBandMethod; 416,417c459,460 < Modes = Material_ModesDict( ); < Shaders = Material_ShadersDict( ); --- > if( PyType_Ready( &Material_Type ) < 0) > return NULL; 419,435c462,487 < 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 ); < PyModule_AddIntConstant( submodule, "MODE", IPOKEY_MODE ); < PyModule_AddIntConstant( submodule, "ALLCOLOR", IPOKEY_ALLCOLOR ); < PyModule_AddIntConstant( submodule, "ALLMIRROR", IPOKEY_ALLMIRROR ); < PyModule_AddIntConstant( submodule, "OFS", IPOKEY_OFS ); < PyModule_AddIntConstant( submodule, "SIZE", IPOKEY_SIZE ); < PyModule_AddIntConstant( submodule, "ALLMAPPING", IPOKEY_ALLMAPPING ); --- > Modes = Material_ModesDict( ); > Shaders = Material_ShadersDict( ); > ColorBandMethod = Material_ColorRampMethodsDict( ); > ColorBandInput = Material_ColorRampInputDict( ); > > 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 ); > if( ColorBandMethod ) > PyModule_AddObject( submodule, "ColorBandMethod", ColorBandMethod ); > if( ColorBandInput ) > PyModule_AddObject( submodule, "ColorBandInput", ColorBandInput ); > > PyModule_AddIntConstant( submodule, "RGB", IPOKEY_RGB ); > PyModule_AddIntConstant( submodule, "ALPHA", IPOKEY_ALPHA ); > PyModule_AddIntConstant( submodule, "HALOSIZE", IPOKEY_HALOSIZE ); > PyModule_AddIntConstant( submodule, "MODE", IPOKEY_MODE ); > PyModule_AddIntConstant( submodule, "ALLCOLOR", IPOKEY_ALLCOLOR ); > PyModule_AddIntConstant( submodule, "ALLMIRROR", IPOKEY_ALLMIRROR ); > PyModule_AddIntConstant( submodule, "OFS", IPOKEY_OFS ); > PyModule_AddIntConstant( submodule, "SIZE", IPOKEY_SIZE ); > PyModule_AddIntConstant( submodule, "ALLMAPPING", IPOKEY_ALLMAPPING ); 437c489 < return ( submodule ); --- > return ( submodule ); 497c549 < void * closure ); --- > void * closure ); 559c611 < void * closure ); --- > void * closure ); 649a702,717 > //RampCol Factor: > static PyObject *Material_getColorBandDiffuseFactor( BPy_Material * self ); > static PyObject *Material_getColorBandSpecularFactor( BPy_Material * self ); > static int Material_setColorBandDiffuseFactor ( BPy_Material * self, PyObject * value ); > static int Material_setColorBandSpecularFactor ( BPy_Material * self, PyObject * value ); > //RampCol Method: > static PyObject *Material_getColorBandDiffuseMethod( BPy_Material * self ); > static PyObject *Material_getColorBandSpecularMethod ( BPy_Material * self ); > static int Material_setColorBandDiffuseMethod ( BPy_Material * self, PyObject * value); > static int Material_setColorBandSpecularMethod ( BPy_Material * self, PyObject * value); > //RampCol Input: > static PyObject *Material_getColorBandDiffuseInput( BPy_Material * self ); > static PyObject *Material_getColorBandSpecularInput( BPy_Material * self ); > static int Material_setColorBandDiffuseInput ( BPy_Material * self, PyObject * value); > static int Material_setColorBandSpecularInput ( BPy_Material * self, PyObject * value); > 655,883c723,963 < /* name, method, flags, doc */ < {"getName", ( PyCFunction ) GenericLib_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"}, < /* Shader specific settings */ < {"getSpecShader", ( PyCFunction ) Material_getSpecShader, METH_NOARGS, < "() - Returns Material's specular shader" }, < {"getDiffuseShader", ( PyCFunction ) Material_getDiffuseShader, 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 specular 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, < "() - 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"}, < {"getRayTransGloss", ( PyCFunction ) Material_getGlossTrans, METH_NOARGS, < "() - Return amount refraction glossiness"}, < {"getRayMirrGlossSamples", ( PyCFunction ) Material_getGlossMirrSamples, METH_NOARGS, < "() - Return amount mirror glossiness"}, < {"getFilter", ( PyCFunction ) Material_getFilter, METH_NOARGS, < "() - Return the amount of filtering when transparent 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, < "() - 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 ) GenericLib_setName_with_method, METH_VARARGS, < "(s) - Change Material's name"}, < {"setIpo", ( PyCFunction ) Matr_oldsetIpo, METH_VARARGS, < "(Blender Ipo) - Change Material's Ipo"}, < {"clearIpo", ( PyCFunction ) Material_clearIpo, METH_NOARGS, < "(Blender Ipo) - Unlink Ipo from this Material"}, < {"insertIpoKey", ( PyCFunction ) Material_insertIpoKey, METH_VARARGS, < "(Material Ipo Constant) - Insert IPO Key at current frame"}, < {"setMode", ( PyCFunction ) Matr_oldsetMode, METH_VARARGS, < "([s[,s]]) - Set Material's mode flag(s)"}, < {"setRGBCol", ( PyCFunction ) Matr_oldsetRGBCol, METH_VARARGS, < "(f,f,f or [f,f,f]) - Set Material's rgb color triplet"}, < /* {"setAmbCol", (PyCFunction)Matr_oldsetAmbCol, METH_VARARGS, < "(f,f,f or [f,f,f]) - Set Material's ambient color"},*/ < {"setSpecCol", ( PyCFunction ) Matr_oldsetSpecCol, METH_VARARGS, < "(f,f,f or [f,f,f]) - Set Material's specular color"}, < < /* Shader spesific settings */ < {"setSpecShader", ( PyCFunction ) Matr_oldsetSpecShader, METH_VARARGS, < "(i) - Set the Material's specular shader" }, < {"setDiffuseShader", ( PyCFunction ) Matr_oldsetDiffuseShader, METH_VARARGS, < "(i) - Set the Material's diffuse shader" }, < {"setRoughness", ( PyCFunction ) Matr_oldsetRoughness, METH_VARARGS, < "(f) - Set the Material's Roughness (applies to the \"Oren Nayar\" Diffuse Shader only)" }, < {"setSpecSize", ( PyCFunction ) Matr_oldsetSpecSize, METH_VARARGS, < "(f) - Set the Material's size of specular area (applies to the \"Toon\" Specular Shader only)" }, < {"setDiffuseSize", ( PyCFunction ) Matr_oldsetDiffuseSize, METH_VARARGS, < "(f) - Set the Material's size of diffuse area (applies to the \"Toon\" Diffuse Shader only)" }, < {"setSpecSmooth", ( PyCFunction ) Matr_oldsetSpecSmooth, METH_VARARGS, < "(f) - Set the Material's smoothing of specular area (applies to the \"Toon\" Specular Shader only)" }, < {"setDiffuseSmooth", ( PyCFunction ) Matr_oldsetDiffuseSmooth, METH_VARARGS, < "(f) - Set the Material's smoothing of diffuse area (applies to the \"Toon\" Diffuse Shader only)" }, < {"setDiffuseDarkness", ( PyCFunction ) Matr_oldsetDiffuseDarkness, METH_VARARGS, < "(f) - Set the Material's diffuse darkness (applies to the \"Minnaert\" Diffuse Shader only)" }, < {"setRefracIndex", ( PyCFunction ) Matr_oldsetRefracIndex, METH_VARARGS, < "(f) - Set the Material's Index of Refraction (applies to the \"Blinn\" Specular Shader only)" }, < {"setRms", ( PyCFunction ) Matr_oldsetRms, METH_VARARGS, < "(f) - Set the Material's standard deviation of surface slope (applies to the \"WardIso\" Specular Shader only)" }, < /* End shader settings */ < < {"setMirCol", ( PyCFunction ) Matr_oldsetMirCol, METH_VARARGS, < "(f,f,f or [f,f,f]) - Set Material's mirror color"}, < {"setAmb", ( PyCFunction ) Matr_oldsetAmb, METH_VARARGS, < "(f) - Set how much the Material's color is affected" < " by \nthe global ambient colors - [0.0, 1.0]"}, < {"setEmit", ( PyCFunction ) Matr_oldsetEmit, METH_VARARGS, < "(f) - Set Material's emitting light intensity - [0.0, 1.0]"}, < {"setAlpha", ( PyCFunction ) Matr_oldsetAlpha, METH_VARARGS, < "(f) - Set Material's alpha (transparency) - [0.0, 1.0]"}, < {"setRef", ( PyCFunction ) Matr_oldsetRef, METH_VARARGS, < "(f) - Set Material's reflectivity - [0.0, 1.0]"}, < {"setSpec", ( PyCFunction ) Matr_oldsetSpec, METH_VARARGS, < "(f) - Set Material's specularity - [0.0, 2.0]"}, < {"setSpecTransp", ( PyCFunction ) Matr_oldsetSpecTransp, METH_VARARGS, < "(f) - Set Material's specular transparency - [0.0, 1.0]"}, < {"setAdd", ( PyCFunction ) Matr_oldsetAdd, METH_VARARGS, < "(f) - Set Material's glow factor - [0.0, 1.0]"}, < {"setZOffset", ( PyCFunction ) Matr_oldsetZOffset, METH_VARARGS, < "(f) - Set Material's artificial offset - [0.0, 10.0]"}, < {"setHaloSize", ( PyCFunction ) Matr_oldsetHaloSize, METH_VARARGS, < "(f) - Set Material's halo size - [0.0, 100.0]"}, < {"setHaloSeed", ( PyCFunction ) Matr_oldsetHaloSeed, METH_VARARGS, < "(i) - Set Material's halo seed - [0, 255]"}, < {"setFlareSize", ( PyCFunction ) Matr_oldsetFlareSize, METH_VARARGS, < "(f) - Set Material's factor: (flare size)/(halo size) - [0.1, 25.0]"}, < {"setFlareSeed", ( PyCFunction ) Matr_oldsetFlareSeed, METH_VARARGS, < "(i) - Set Material's flare seed - [0, 255]"}, < {"setFlareBoost", ( PyCFunction ) Matr_oldsetFlareBoost, METH_VARARGS, < "(f) - Set Material's flare boost - [0.1, 10.0]"}, < {"setSubSize", ( PyCFunction ) Matr_oldsetSubSize, METH_VARARGS, < "(f) - Set Material's dimension of subflare," < " dots and circles - [0.1, 25.0]"}, < {"setHardness", ( PyCFunction ) Matr_oldsetHardness, METH_VARARGS, < "(i) - Set Material's hardness - [1, 255 (127 if halo mode is ON)]"}, < {"setNFlares", ( PyCFunction ) Matr_oldsetNFlares, METH_VARARGS, < "(i) - Set Material's number of flares in halo - [1, 32]"}, < {"setNStars", ( PyCFunction ) Matr_oldsetNStars, METH_VARARGS, < "(i) - Set Material's number of stars in halo - [3, 50]"}, < {"setNLines", ( PyCFunction ) Matr_oldsetNLines, METH_VARARGS, < "(i) - Set Material's number of lines in halo - [0, 250]"}, < {"setNRings", ( PyCFunction ) Matr_oldsetNRings, METH_VARARGS, < "(i) - Set Material's number of rings in halo - [0, 24]"}, < {"setRayMirr", ( PyCFunction ) Matr_oldsetRayMirr, METH_VARARGS, < "(f) - Set amount mirror - [0.0, 1.0]"}, < {"setMirrDepth", ( PyCFunction ) Matr_oldsetMirrDepth, METH_VARARGS, < "(i) - Set amount inter-reflections - [0, 10]"}, < {"setFresnelMirr", ( PyCFunction ) Matr_oldsetFresnelMirr, METH_VARARGS, < "(f) - Set fresnel power for mirror - [0.0, 5.0]"}, < {"setFresnelMirrFac", ( PyCFunction ) Matr_oldsetFresnelMirrFac, METH_VARARGS, < "(f) - Set blend fac for mirror fresnel - [1.0, 5.0]"}, < {"setRayTransGloss", ( PyCFunction ) Material_setGlossTrans, METH_VARARGS, < "(f) - Set amount refraction glossiness - [0.0, 1.0]"}, < {"setRayMirrGlossSamples", ( PyCFunction ) Material_setGlossMirrSamples, METH_VARARGS, < "(f) - Set amount mirror glossiness - [0.0, 1.0]"}, < {"setFilter", ( PyCFunction ) Matr_oldsetFilter, METH_VARARGS, < "(f) - Set the amount of filtering when transparent raytrace is enabled"}, < {"setTranslucency", ( PyCFunction ) Matr_oldsetTranslucency, METH_VARARGS, < "(f) - Set the Translucency, the amount of diffuse shading of the back side"}, < {"setIOR", ( PyCFunction ) Matr_oldsetIOR, METH_VARARGS, < "(f) - Set IOR - [1.0, 3.0]"}, < {"setTransDepth", ( PyCFunction ) Matr_oldsetTransDepth, METH_VARARGS, < "(i) - Set amount inter-refractions - [0, 10]"}, < {"setFresnelTrans", ( PyCFunction ) Matr_oldsetFresnelTrans, METH_VARARGS, < "(f) - Set fresnel power for refractions - [0.0, 5.0]"}, < {"setFresnelTransFac", ( PyCFunction ) Matr_oldsetFresnelTransFac, METH_VARARGS, < "(f) - Set fresnel power for refractions factor- [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_O, < "(n) - Remove texture from numbered slot"}, < {"getScriptLinks", ( PyCFunction ) Material_getScriptLinks, METH_O, < "(eventname) - Get a list of this material's scriptlinks (Text names) " < "of the given type\n" < "(eventname) - string: FrameChanged, Redraw or Render."}, < {"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, Redraw or Render."}, < {"clearScriptLinks", ( PyCFunction ) Material_clearScriptLinks, METH_VARARGS, < "() - Delete all scriptlinks from this material.\n" < "([s1<,s2,s3...>]) - Delete specified scriptlinks from this material."}, < {"__copy__", ( PyCFunction ) Material_copy, METH_NOARGS, < "() - Return a copy of the material."}, < {"copy", ( PyCFunction ) Material_copy, METH_NOARGS, < "() - Return a copy of the material."}, < {NULL, NULL, 0, NULL} --- > /* name, method, flags, doc */ > {"getName", ( PyCFunction ) GenericLib_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"}, > /* Shader specific settings */ > {"getSpecShader", ( PyCFunction ) Material_getSpecShader, METH_NOARGS, > "() - Returns Material's specular shader" }, > {"getDiffuseShader", ( PyCFunction ) Material_getDiffuseShader, 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 specular 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, > "() - 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"}, > {"getRayTransGloss", ( PyCFunction ) Material_getGlossTrans, METH_NOARGS, > "() - Return amount refraction glossiness"}, > {"getRayMirrGlossSamples", ( PyCFunction ) Material_getGlossMirrSamples, METH_NOARGS, > "() - Return amount mirror glossiness"}, > {"getFilter", ( PyCFunction ) Material_getFilter, METH_NOARGS, > "() - Return the amount of filtering when transparent 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, > "() - 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 ) GenericLib_setName_with_method, METH_VARARGS, > "(s) - Change Material's name"}, > {"setIpo", ( PyCFunction ) Matr_oldsetIpo, METH_VARARGS, > "(Blender Ipo) - Change Material's Ipo"}, > {"clearIpo", ( PyCFunction ) Material_clearIpo, METH_NOARGS, > "(Blender Ipo) - Unlink Ipo from this Material"}, > {"insertIpoKey", ( PyCFunction ) Material_insertIpoKey, METH_VARARGS, > "(Material Ipo Constant) - Insert IPO Key at current frame"}, > {"setMode", ( PyCFunction ) Matr_oldsetMode, METH_VARARGS, > "([s[,s]]) - Set Material's mode flag(s)"}, > {"setRGBCol", ( PyCFunction ) Matr_oldsetRGBCol, METH_VARARGS, > "(f,f,f or [f,f,f]) - Set Material's rgb color triplet"}, > /* {"setAmbCol", (PyCFunction)Matr_oldsetAmbCol, METH_VARARGS, > "(f,f,f or [f,f,f]) - Set Material's ambient color"},*/ > {"setSpecCol", ( PyCFunction ) Matr_oldsetSpecCol, METH_VARARGS, > "(f,f,f or [f,f,f]) - Set Material's specular color"}, > > /* Shader spesific settings */ > {"setSpecShader", ( PyCFunction ) Matr_oldsetSpecShader, METH_VARARGS, > "(i) - Set the Material's specular shader" }, > {"setDiffuseShader", ( PyCFunction ) Matr_oldsetDiffuseShader, METH_VARARGS, > "(i) - Set the Material's diffuse shader" }, > {"setRoughness", ( PyCFunction ) Matr_oldsetRoughness, METH_VARARGS, > "(f) - Set the Material's Roughness (applies to the \"Oren Nayar\" Diffuse Shader only)" }, > {"setSpecSize", ( PyCFunction ) Matr_oldsetSpecSize, METH_VARARGS, > "(f) - Set the Material's size of specular area (applies to the \"Toon\" Specular Shader only)" }, > {"setDiffuseSize", ( PyCFunction ) Matr_oldsetDiffuseSize, METH_VARARGS, > "(f) - Set the Material's size of diffuse area (applies to the \"Toon\" Diffuse Shader only)" }, > {"setSpecSmooth", ( PyCFunction ) Matr_oldsetSpecSmooth, METH_VARARGS, > "(f) - Set the Material's smoothing of specular area (applies to the \"Toon\" Specular Shader only)" }, > {"setDiffuseSmooth", ( PyCFunction ) Matr_oldsetDiffuseSmooth, METH_VARARGS, > "(f) - Set the Material's smoothing of diffuse area (applies to the \"Toon\" Diffuse Shader only)" }, > {"setDiffuseDarkness", ( PyCFunction ) Matr_oldsetDiffuseDarkness, METH_VARARGS, > "(f) - Set the Material's diffuse darkness (applies to the \"Minnaert\" Diffuse Shader only)" }, > {"setRefracIndex", ( PyCFunction ) Matr_oldsetRefracIndex, METH_VARARGS, > "(f) - Set the Material's Index of Refraction (applies to the \"Blinn\" Specular Shader only)" }, > {"setRms", ( PyCFunction ) Matr_oldsetRms, METH_VARARGS, > "(f) - Set the Material's standard deviation of surface slope (applies to the \"WardIso\" Specular Shader only)" }, > /* End shader settings */ > > {"setMirCol", ( PyCFunction ) Matr_oldsetMirCol, METH_VARARGS, > "(f,f,f or [f,f,f]) - Set Material's mirror color"}, > {"setAmb", ( PyCFunction ) Matr_oldsetAmb, METH_VARARGS, > "(f) - Set how much the Material's color is affected" > " by \nthe global ambient colors - [0.0, 1.0]"}, > {"setEmit", ( PyCFunction ) Matr_oldsetEmit, METH_VARARGS, > "(f) - Set Material's emitting light intensity - [0.0, 1.0]"}, > {"setAlpha", ( PyCFunction ) Matr_oldsetAlpha, METH_VARARGS, > "(f) - Set Material's alpha (transparency) - [0.0, 1.0]"}, > {"setRef", ( PyCFunction ) Matr_oldsetRef, METH_VARARGS, > "(f) - Set Material's reflectivity - [0.0, 1.0]"}, > {"setSpec", ( PyCFunction ) Matr_oldsetSpec, METH_VARARGS, > "(f) - Set Material's specularity - [0.0, 2.0]"}, > {"setSpecTransp", ( PyCFunction ) Matr_oldsetSpecTransp, METH_VARARGS, > "(f) - Set Material's specular transparency - [0.0, 1.0]"}, > {"setAdd", ( PyCFunction ) Matr_oldsetAdd, METH_VARARGS, > "(f) - Set Material's glow factor - [0.0, 1.0]"}, > {"setZOffset", ( PyCFunction ) Matr_oldsetZOffset, METH_VARARGS, > "(f) - Set Material's artificial offset - [0.0, 10.0]"}, > {"setHaloSize", ( PyCFunction ) Matr_oldsetHaloSize, METH_VARARGS, > "(f) - Set Material's halo size - [0.0, 100.0]"}, > {"setHaloSeed", ( PyCFunction ) Matr_oldsetHaloSeed, METH_VARARGS, > "(i) - Set Material's halo seed - [0, 255]"}, > {"setFlareSize", ( PyCFunction ) Matr_oldsetFlareSize, METH_VARARGS, > "(f) - Set Material's factor: (flare size)/(halo size) - [0.1, 25.0]"}, > {"setFlareSeed", ( PyCFunction ) Matr_oldsetFlareSeed, METH_VARARGS, > "(i) - Set Material's flare seed - [0, 255]"}, > {"setFlareBoost", ( PyCFunction ) Matr_oldsetFlareBoost, METH_VARARGS, > "(f) - Set Material's flare boost - [0.1, 10.0]"}, > {"setSubSize", ( PyCFunction ) Matr_oldsetSubSize, METH_VARARGS, > "(f) - Set Material's dimension of subflare," > " dots and circles - [0.1, 25.0]"}, > {"setHardness", ( PyCFunction ) Matr_oldsetHardness, METH_VARARGS, > "(i) - Set Material's hardness - [1, 255 (127 if halo mode is ON)]"}, > {"setNFlares", ( PyCFunction ) Matr_oldsetNFlares, METH_VARARGS, > "(i) - Set Material's number of flares in halo - [1, 32]"}, > {"setNStars", ( PyCFunction ) Matr_oldsetNStars, METH_VARARGS, > "(i) - Set Material's number of stars in halo - [3, 50]"}, > {"setNLines", ( PyCFunction ) Matr_oldsetNLines, METH_VARARGS, > "(i) - Set Material's number of lines in halo - [0, 250]"}, > {"setNRings", ( PyCFunction ) Matr_oldsetNRings, METH_VARARGS, > "(i) - Set Material's number of rings in halo - [0, 24]"}, > {"setRayMirr", ( PyCFunction ) Matr_oldsetRayMirr, METH_VARARGS, > "(f) - Set amount mirror - [0.0, 1.0]"}, > {"setMirrDepth", ( PyCFunction ) Matr_oldsetMirrDepth, METH_VARARGS, > "(i) - Set amount inter-reflections - [0, 10]"}, > {"setFresnelMirr", ( PyCFunction ) Matr_oldsetFresnelMirr, METH_VARARGS, > "(f) - Set fresnel power for mirror - [0.0, 5.0]"}, > {"setFresnelMirrFac", ( PyCFunction ) Matr_oldsetFresnelMirrFac, METH_VARARGS, > "(f) - Set blend fac for mirror fresnel - [1.0, 5.0]"}, > {"setRayTransGloss", ( PyCFunction ) Material_setGlossTrans, METH_VARARGS, > "(f) - Set amount refraction glossiness - [0.0, 1.0]"}, > {"setRayMirrGlossSamples", ( PyCFunction ) Material_setGlossMirrSamples, METH_VARARGS, > "(f) - Set amount mirror glossiness - [0.0, 1.0]"}, > {"setFilter", ( PyCFunction ) Matr_oldsetFilter, METH_VARARGS, > "(f) - Set the amount of filtering when transparent raytrace is enabled"}, > {"setTranslucency", ( PyCFunction ) Matr_oldsetTranslucency, METH_VARARGS, > "(f) - Set the Translucency, the amount of diffuse shading of the back side"}, > {"setIOR", ( PyCFunction ) Matr_oldsetIOR, METH_VARARGS, > "(f) - Set IOR - [1.0, 3.0]"}, > {"setTransDepth", ( PyCFunction ) Matr_oldsetTransDepth, METH_VARARGS, > "(i) - Set amount inter-refractions - [0, 10]"}, > {"setFresnelTrans", ( PyCFunction ) Matr_oldsetFresnelTrans, METH_VARARGS, > "(f) - Set fresnel power for refractions - [0.0, 5.0]"}, > {"setFresnelTransFac", ( PyCFunction ) Matr_oldsetFresnelTransFac, METH_VARARGS, > "(f) - Set fresnel power for refractions factor- [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_O, > "(n) - Remove texture from numbered slot"}, > {"getScriptLinks", ( PyCFunction ) Material_getScriptLinks, METH_O, > "(eventname) - Get a list of this material's scriptlinks (Text names) " > "of the given type\n" > "(eventname) - string: FrameChanged, Redraw or Render."}, > {"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, Redraw or Render."}, > {"clearScriptLinks", ( PyCFunction ) Material_clearScriptLinks, METH_VARARGS, > "() - Delete all scriptlinks from this material.\n" > "([s1<,s2,s3...>]) - Delete specified scriptlinks from this material."}, > {"__copy__", ( PyCFunction ) Material_copy, METH_NOARGS, > "() - Return a copy of the material."}, > {"copy", ( PyCFunction ) Material_copy, METH_NOARGS, > "() - Return a copy of the material."}, > {"getColorBandDiffuseFactor", ( PyCFunction ) Material_getColorBandDiffuseFactor, METH_NOARGS, "() - Return the material Factor aplied to the Diffuse ColorBand"}, > {"getColorBandSpecularFactor", ( PyCFunction ) Material_getColorBandSpecularFactor, METH_NOARGS, "() - Return the material Factor aplied to the Specular ColorBand"}, > {"setColorBandDiffuseFactor", ( PyCFunction ) Material_setColorBandDiffuseFactor, METH_VARARGS, "(float) - Sets the material Factor aplied to the Diffuse ColorBand"}, > {"setColorBandSpecularFactor", ( PyCFunction ) Material_setColorBandSpecularFactor, METH_VARARGS, "(float) - Sets the material Factor aplied to the Specular ColorBand"}, > {"getColorBandDiffuseMethod", ( PyCFunction ) Material_getColorBandDiffuseMethod, METH_NOARGS, "() - Returns tha actual material Diffuse Method"}, > {"getColorBandSpecularMethod", ( PyCFunction ) Material_getColorBandSpecularMethod, METH_NOARGS, "() - Returns tha actual material Specular Method"}, > {"setColorBandDiffuseMethod", ( PyCFunction ) Material_setColorBandDiffuseMethod, METH_VARARGS, "(int) - Sets the material Method aplied to the Diffuse ColorBand"}, > {"setColorBandSpecularMethod", ( PyCFunction ) Material_setColorBandSpecularMethod, METH_VARARGS, "(int) - Sets the material Method aplied to the Specular ColorBand"}, > {"getColorBandDiffuseInput", ( PyCFunction ) Material_getColorBandDiffuseInput, METH_NOARGS, "() - Returns tha actual material Diffuse Input"}, > {"getColorBandSpecularInput", ( PyCFunction ) Material_getColorBandSpecularInput, METH_NOARGS, "() - Returns tha actual material Specular Input"}, > {"setColorBandDiffuseInput", ( PyCFunction ) Material_setColorBandDiffuseInput, METH_VARARGS, "(int) - Sets the material Input aplied to the Diffuse ColorBand"}, > {"setColorBandSpecularInput", ( PyCFunction ) Material_setColorBandSpecularInput, METH_VARARGS, "(int) - Sets the material Input aplied to the Specular ColorBand"}, > {NULL, NULL, 0, NULL} 891,1207c971,1295 < GENERIC_LIB_GETSETATTR, < {"add", < (getter)Material_getAdd, (setter)Material_setAdd, < "Strength of the add effect", < NULL}, < {"alpha", < (getter)Material_getAlpha, (setter)Material_setAlpha, < "Alpha setting ", < NULL}, < {"shadAlpha", < (getter)Material_getShadAlpha, (setter)Material_setShadAlpha, < "Shadow Alpha setting", < NULL}, < {"amb", < (getter)Material_getAmb, (setter)Material_setAmb, < "Amount of global ambient color material receives", < NULL}, < {"diffuseDarkness", < (getter)Material_getDiffuseDarkness, (setter)Material_setDiffuseDarkness, < "Material's diffuse darkness (\"Minnaert\" diffuse shader only)", < NULL}, < {"diffuseShader", < (getter)Material_getDiffuseShader, (setter)Material_setDiffuseShader, < "Diffuse shader type", < NULL}, < {"diffuseSize", < (getter)Material_getDiffuseSize, (setter)Material_setDiffuseSize, < "Material's diffuse area size (\"Toon\" diffuse shader only)", < NULL}, < {"diffuseSmooth", < (getter)Material_getDiffuseSmooth, (setter)Material_setDiffuseSmooth, < "Material's diffuse area smoothing (\"Toon\" diffuse shader only)", < NULL}, < {"emit", < (getter)Material_getEmit, (setter)Material_setEmit, < "Amount of light the material emits", < NULL}, < {"filter", < (getter)Material_getFilter, (setter)Material_setFilter, < "Amount of filtering when transparent raytrace is enabled", < NULL}, < {"flareBoost", < (getter)Material_getFlareBoost, (setter)Material_setFlareBoost, < "Flare's extra strength", < NULL}, < {"flareSeed", < (getter)Material_getFlareSeed, (setter)Material_setFlareSeed, < "Offset in the flare seed table", < NULL}, < {"flareSize", < (getter)Material_getFlareSize, (setter)Material_setFlareSize, < "Ratio of flare size to halo size", < NULL}, < {"fresnelDepth", < (getter)Material_getFresnelMirr, (setter)Material_setFresnelMirr, < "Power of Fresnel for mirror reflection", < NULL}, < {"fresnelDepthFac", < (getter)Material_getFresnelMirrFac, (setter)Material_setFresnelMirrFac, < "Blending factor for Fresnel mirror", < NULL}, < {"fresnelTrans", < (getter)Material_getFresnelTrans, (setter)Material_setFresnelTrans, < "Power of Fresnel for transparency", < NULL}, < {"fresnelTransFac", < (getter)Material_getFresnelTransFac, (setter)Material_setFresnelTransFac, < "Blending factor for Fresnel transparency", < NULL}, < {"rbFriction", < (getter)Material_getRigidBodyFriction, (setter)Material_setRigidBodyFriction, < "Rigid Body Friction coefficient", < NULL}, < {"rbRestitution", < (getter)Material_getRigidBodyRestitution, (setter)Material_setRigidBodyRestitution, < "Rigid Body Restitution coefficient", < NULL}, < < {"haloSeed", < (getter)Material_getHaloSeed, (setter)Material_setHaloSeed, < "Randomizes halo ring dimension and line location", < NULL}, < {"haloSize", < (getter)Material_getHaloSize, (setter)Material_setHaloSize, < "Dimension of the halo", < NULL}, < {"hard", < (getter)Material_getHardness, (setter)Material_setHardness, < "Specularity hardness", < NULL}, < {"IOR", < (getter)Material_getIOR, (setter)Material_setIOR, < "Angular index of refraction for raytrace", < NULL}, < {"ipo", < (getter)Material_getIpo, (setter)Material_setIpo, < "Material Ipo data", < NULL}, < {"mirCol", < (getter)Material_getMirCol, (setter)Material_setMirCol, < "Mirror RGB color triplet", < NULL}, < {"mirR", < (getter)Material_getColorComponent, (setter)Material_setColorComponent, < "Mirror color red component", < (void *) EXPP_MAT_COMP_MIRR }, < {"mirG", < (getter)Material_getColorComponent, (setter)Material_setColorComponent, < "Mirror color green component", < (void *) EXPP_MAT_COMP_MIRG }, < {"mirB", < (getter)Material_getColorComponent, (setter)Material_setColorComponent, < "Mirror color blue component", < (void *) EXPP_MAT_COMP_MIRB }, < {"sssCol", < (getter)Material_getSssCol, (setter)Material_setSssCol, < "Sss RGB color triplet", < NULL}, < {"sssR", < (getter)Material_getColorComponent, (setter)Material_setColorComponent, < "SSS color red component", < (void *) EXPP_MAT_COMP_SSSR }, < {"sssG", < (getter)Material_getColorComponent, (setter)Material_setColorComponent, < "SSS color green component", < (void *) EXPP_MAT_COMP_SSSG }, < {"sssB", < (getter)Material_getColorComponent, (setter)Material_setColorComponent, < "SSS color blue component", < (void *) EXPP_MAT_COMP_SSSB }, < {"mode", < (getter)Material_getMode, (setter)Material_setMode, < "Material mode bitmask", < NULL}, < {"nFlares", < (getter)Material_getNFlares, (setter)Material_setNFlares, < "Number of subflares with halo", < NULL}, < {"nLines", < (getter)Material_getNLines, (setter)Material_setNLines, < "Number of star-shaped lines with halo", < NULL}, < {"nRings", < (getter)Material_getNRings, (setter)Material_setNRings, < "Number of rings with halo", < NULL}, < {"nStars", < (getter)Material_getNStars, (setter)Material_setNStars, < "Number of star points with halo", < NULL}, < {"rayMirr", < (getter)Material_getRayMirr, (setter)Material_setRayMirr, < "Mirror reflection amount for raytrace", < NULL}, < {"rayMirrDepth", < (getter)Material_getMirrDepth, (setter)Material_setMirrDepth, < "Amount of raytrace inter-reflections", < NULL}, < {"ref", < (getter)Material_getRef, (setter)Material_setRef, < "Amount of reflections (for shader)", < NULL}, < {"refracIndex", < (getter)Material_getRefracIndex, (setter)Material_setRefracIndex, < "Material's Index of Refraction (applies to the \"Blinn\" Specular Shader only", < NULL}, < {"glossMir", < (getter)Material_getGlossMirr, (setter)Material_setGlossMirr, < "Reflection glossiness", < NULL}, < {"sampGlossMir", < (getter)Material_getGlossMirrSamples, (setter)Material_setGlossMirrSamples, < "Reflection glossiness", < NULL}, < {"glossTra", < (getter)Material_getGlossTrans, (setter)Material_setGlossTrans, < "Refraction glossiness", < NULL}, < {"sampGlossTra", < (getter)Material_getGlossMirrSamples, (setter)Material_setGlossMirrSamples, < "Refraction glossiness", < NULL}, < {"rgbCol", < (getter)Material_getRGBCol, (setter)Material_setRGBCol, < "Diffuse RGB color triplet", < NULL}, < {"rms", < (getter)Material_getRms, (setter)Material_setRms, < "Material's surface slope standard deviation (\"WardIso\" specular shader only)", < NULL}, < {"roughness", < (getter)Material_getRoughness, (setter)Material_setRoughness, < "Material's roughness (\"Oren Nayar\" diffuse shader only)", < NULL}, < {"spec", < (getter)Material_getSpec, (setter)Material_setSpec, < "Degree of specularity", < NULL}, < {"specCol", < (getter)Material_getSpecCol, (setter)Material_setSpecCol, < "Specular RGB color triplet", < NULL}, < {"specR", < (getter)Material_getColorComponent, (setter)Material_setColorComponent, < "Specular color red component", < (void *) EXPP_MAT_COMP_SPECR }, < {"specG", < (getter)Material_getColorComponent, (setter)Material_setColorComponent, < "Specular color green component", < (void *) EXPP_MAT_COMP_SPECG }, < {"specB", < (getter)Material_getColorComponent, (setter)Material_setColorComponent, < "Specular color blue component", < (void *) EXPP_MAT_COMP_SPECB }, < {"specTransp", < (getter)Material_getSpecTransp, (setter)Material_setSpecTransp, < "Makes specular areas opaque on transparent materials", < NULL}, < {"specShader", < (getter)Material_getSpecShader, (setter)Material_setSpecShader, < "Specular shader type", < NULL}, < {"specSize", < (getter)Material_getSpecSize, (setter)Material_setSpecSize, < "Material's specular area size (\"Toon\" specular shader only)", < NULL}, < {"specSmooth", < (getter)Material_getSpecSmooth, (setter)Material_setSpecSmooth, < "Sets the smoothness of specular toon area", < NULL}, < {"subSize", < (getter)Material_getSubSize, (setter)Material_setSubSize, < "Dimension of subflares, dots and circles", < NULL}, < {"transDepth", < (getter)Material_getTransDepth, (setter)Material_setTransDepth, < "Amount of refractions for raytrace", < NULL}, < {"translucency", < (getter)Material_getTranslucency, (setter)Material_setTranslucency, < "Amount of diffuse shading of the back side", < NULL}, < {"zOffset", < (getter)Material_getZOffset, (setter)Material_setZOffset, < "Artificial offset in the Z buffer (for Ztransp option)", < NULL}, < {"lightGroup", < (getter)Material_getLightGroup, (setter)Material_setLightGroup, < "Set the light group for this material", < NULL}, < {"R", < (getter)Material_getColorComponent, (setter)Material_setColorComponent, < "Diffuse color red component", < (void *) EXPP_MAT_COMP_R }, < {"G", < (getter)Material_getColorComponent, (setter)Material_setColorComponent, < "Diffuse color green component", < (void *) EXPP_MAT_COMP_G }, < {"B", < (getter)Material_getColorComponent, (setter)Material_setColorComponent, < "Diffuse color blue component", < (void *) EXPP_MAT_COMP_B }, < {"colorbandDiffuse", < (getter)Material_getColorband, (setter)Material_setColorband, < "The diffuse colorband for this material", < (void *) 0}, < {"colorbandSpecular", < (getter)Material_getColorband, (setter)Material_setColorband, < "The specular colorband for this material", < (void *) 1}, < < /* SSS settings */ < {"enableSSS", < (getter)Material_getSssEnable, (setter)Material_setSssEnable, < "if true, SSS will be rendered for this material", < NULL}, < {"sssScale", < (getter)Material_getSssScale, (setter)Material_setSssScale, < "object scale for sss", < NULL}, < {"sssRadiusRed", < (getter)Material_getSssRadius, (setter)Material_setSssRadius, < "Mean red scattering path length", < (void *) 0}, < {"sssRadiusGreen", < (getter)Material_getSssRadius, (setter)Material_setSssRadius, < "Mean red scattering path length", < (void *) 1}, < {"sssRadiusBlue", < (getter)Material_getSssRadius, (setter)Material_setSssRadius, < "Mean red scattering path length", < (void *) 0}, < {"sssIOR", < (getter)Material_getSssIOR, (setter)Material_setSssIOR, < "index of refraction", < NULL}, < {"sssError", < (getter)Material_getSssError, (setter)Material_setSssError, < "Error", < NULL}, < {"sssColorBlend", < (getter)Material_getSssColorBlend, (setter)Material_setSssColorBlend, < "Blend factor for SSS Colors", < NULL}, < {"sssTextureScatter", < (getter)Material_getSssTexScatter, (setter)Material_setSssTexScatter, < "Texture scattering factor", < NULL}, < {"sssFont", < (getter)Material_getSssFront, (setter)Material_setSssFront, < "Front scattering weight", < NULL}, < {"sssBack", < (getter)Material_getSssBack, (setter)Material_setSssBack, < "Back scattering weight", < NULL}, < {NULL,NULL,NULL,NULL,NULL} /* Sentinel */ --- > GENERIC_LIB_GETSETATTR, > {"add", > (getter)Material_getAdd, (setter)Material_setAdd, > "Strength of the add effect", > NULL}, > {"alpha", > (getter)Material_getAlpha, (setter)Material_setAlpha, > "Alpha setting ", > NULL}, > {"shadAlpha", > (getter)Material_getShadAlpha, (setter)Material_setShadAlpha, > "Shadow Alpha setting", > NULL}, > {"amb", > (getter)Material_getAmb, (setter)Material_setAmb, > "Amount of global ambient color material receives", > NULL}, > {"diffuseDarkness", > (getter)Material_getDiffuseDarkness, (setter)Material_setDiffuseDarkness, > "Material's diffuse darkness (\"Minnaert\" diffuse shader only)", > NULL}, > {"diffuseShader", > (getter)Material_getDiffuseShader, (setter)Material_setDiffuseShader, > "Diffuse shader type", > NULL}, > {"diffuseSize", > (getter)Material_getDiffuseSize, (setter)Material_setDiffuseSize, > "Material's diffuse area size (\"Toon\" diffuse shader only)", > NULL}, > {"diffuseSmooth", > (getter)Material_getDiffuseSmooth, (setter)Material_setDiffuseSmooth, > "Material's diffuse area smoothing (\"Toon\" diffuse shader only)", > NULL}, > {"emit", > (getter)Material_getEmit, (setter)Material_setEmit, > "Amount of light the material emits", > NULL}, > {"filter", > (getter)Material_getFilter, (setter)Material_setFilter, > "Amount of filtering when transparent raytrace is enabled", > NULL}, > {"flareBoost", > (getter)Material_getFlareBoost, (setter)Material_setFlareBoost, > "Flare's extra strength", > NULL}, > {"flareSeed", > (getter)Material_getFlareSeed, (setter)Material_setFlareSeed, > "Offset in the flare seed table", > NULL}, > {"flareSize", > (getter)Material_getFlareSize, (setter)Material_setFlareSize, > "Ratio of flare size to halo size", > NULL}, > {"fresnelDepth", > (getter)Material_getFresnelMirr, (setter)Material_setFresnelMirr, > "Power of Fresnel for mirror reflection", > NULL}, > {"fresnelDepthFac", > (getter)Material_getFresnelMirrFac, (setter)Material_setFresnelMirrFac, > "Blending factor for Fresnel mirror", > NULL}, > {"fresnelTrans", > (getter)Material_getFresnelTrans, (setter)Material_setFresnelTrans, > "Power of Fresnel for transparency", > NULL}, > {"fresnelTransFac", > (getter)Material_getFresnelTransFac, (setter)Material_setFresnelTransFac, > "Blending factor for Fresnel transparency", > NULL}, > {"rbFriction", > (getter)Material_getRigidBodyFriction, (setter)Material_setRigidBodyFriction, > "Rigid Body Friction coefficient", > NULL}, > {"rbRestitution", > (getter)Material_getRigidBodyRestitution, (setter)Material_setRigidBodyRestitution, > "Rigid Body Restitution coefficient", > NULL}, > > {"haloSeed", > (getter)Material_getHaloSeed, (setter)Material_setHaloSeed, > "Randomizes halo ring dimension and line location", > NULL}, > {"haloSize", > (getter)Material_getHaloSize, (setter)Material_setHaloSize, > "Dimension of the halo", > NULL}, > {"hard", > (getter)Material_getHardness, (setter)Material_setHardness, > "Specularity hardness", > NULL}, > {"IOR", > (getter)Material_getIOR, (setter)Material_setIOR, > "Angular index of refraction for raytrace", > NULL}, > {"ipo", > (getter)Material_getIpo, (setter)Material_setIpo, > "Material Ipo data", > NULL}, > {"mirCol", > (getter)Material_getMirCol, (setter)Material_setMirCol, > "Mirror RGB color triplet", > NULL}, > {"mirR", > (getter)Material_getColorComponent, (setter)Material_setColorComponent, > "Mirror color red component", > (void *) EXPP_MAT_COMP_MIRR }, > {"mirG", > (getter)Material_getColorComponent, (setter)Material_setColorComponent, > "Mirror color green component", > (void *) EXPP_MAT_COMP_MIRG }, > {"mirB", > (getter)Material_getColorComponent, (setter)Material_setColorComponent, > "Mirror color blue component", > (void *) EXPP_MAT_COMP_MIRB }, > {"sssCol", > (getter)Material_getSssCol, (setter)Material_setSssCol, > "Sss RGB color triplet", > NULL}, > {"sssR", > (getter)Material_getColorComponent, (setter)Material_setColorComponent, > "SSS color red component", > (void *) EXPP_MAT_COMP_SSSR }, > {"sssG", > (getter)Material_getColorComponent, (setter)Material_setColorComponent, > "SSS color green component", > (void *) EXPP_MAT_COMP_SSSG }, > {"sssB", > (getter)Material_getColorComponent, (setter)Material_setColorComponent, > "SSS color blue component", > (void *) EXPP_MAT_COMP_SSSB }, > {"mode", > (getter)Material_getMode, (setter)Material_setMode, > "Material mode bitmask", > NULL}, > {"nFlares", > (getter)Material_getNFlares, (setter)Material_setNFlares, > "Number of subflares with halo", > NULL}, > {"nLines", > (getter)Material_getNLines, (setter)Material_setNLines, > "Number of star-shaped lines with halo", > NULL}, > {"nRings", > (getter)Material_getNRings, (setter)Material_setNRings, > "Number of rings with halo", > NULL}, > {"nStars", > (getter)Material_getNStars, (setter)Material_setNStars, > "Number of star points with halo", > NULL}, > {"rayMirr", > (getter)Material_getRayMirr, (setter)Material_setRayMirr, > "Mirror reflection amount for raytrace", > NULL}, > {"rayMirrDepth", > (getter)Material_getMirrDepth, (setter)Material_setMirrDepth, > "Amount of raytrace inter-reflections", > NULL}, > {"ref", > (getter)Material_getRef, (setter)Material_setRef, > "Amount of reflections (for shader)", > NULL}, > {"refracIndex", > (getter)Material_getRefracIndex, (setter)Material_setRefracIndex, > "Material's Index of Refraction (applies to the \"Blinn\" Specular Shader only", > NULL}, > {"glossMir", > (getter)Material_getGlossMirr, (setter)Material_setGlossMirr, > "Reflection glossiness", > NULL}, > {"sampGlossMir", > (getter)Material_getGlossMirrSamples, (setter)Material_setGlossMirrSamples, > "Reflection glossiness", > NULL}, > {"glossTra", > (getter)Material_getGlossTrans, (setter)Material_setGlossTrans, > "Refraction glossiness", > NULL}, > {"sampGlossTra", > (getter)Material_getGlossMirrSamples, (setter)Material_setGlossMirrSamples, > "Refraction glossiness", > NULL}, > {"rgbCol", > (getter)Material_getRGBCol, (setter)Material_setRGBCol, > "Diffuse RGB color triplet", > NULL}, > {"rms", > (getter)Material_getRms, (setter)Material_setRms, > "Material's surface slope standard deviation (\"WardIso\" specular shader only)", > NULL}, > {"roughness", > (getter)Material_getRoughness, (setter)Material_setRoughness, > "Material's roughness (\"Oren Nayar\" diffuse shader only)", > NULL}, > {"spec", > (getter)Material_getSpec, (setter)Material_setSpec, > "Degree of specularity", > NULL}, > {"specCol", > (getter)Material_getSpecCol, (setter)Material_setSpecCol, > "Specular RGB color triplet", > NULL}, > {"specR", > (getter)Material_getColorComponent, (setter)Material_setColorComponent, > "Specular color red component", > (void *) EXPP_MAT_COMP_SPECR }, > {"specG", > (getter)Material_getColorComponent, (setter)Material_setColorComponent, > "Specular color green component", > (void *) EXPP_MAT_COMP_SPECG }, > {"specB", > (getter)Material_getColorComponent, (setter)Material_setColorComponent, > "Specular color blue component", > (void *) EXPP_MAT_COMP_SPECB }, > {"specTransp", > (getter)Material_getSpecTransp, (setter)Material_setSpecTransp, > "Makes specular areas opaque on transparent materials", > NULL}, > {"specShader", > (getter)Material_getSpecShader, (setter)Material_setSpecShader, > "Specular shader type", > NULL}, > {"specSize", > (getter)Material_getSpecSize, (setter)Material_setSpecSize, > "Material's specular area size (\"Toon\" specular shader only)", > NULL}, > {"specSmooth", > (getter)Material_getSpecSmooth, (setter)Material_setSpecSmooth, > "Sets the smoothness of specular toon area", > NULL}, > {"subSize", > (getter)Material_getSubSize, (setter)Material_setSubSize, > "Dimension of subflares, dots and circles", > NULL}, > {"transDepth", > (getter)Material_getTransDepth, (setter)Material_setTransDepth, > "Amount of refractions for raytrace", > NULL}, > {"translucency", > (getter)Material_getTranslucency, (setter)Material_setTranslucency, > "Amount of diffuse shading of the back side", > NULL}, > {"zOffset", > (getter)Material_getZOffset, (setter)Material_setZOffset, > "Artificial offset in the Z buffer (for Ztransp option)", > NULL}, > {"lightGroup", > (getter)Material_getLightGroup, (setter)Material_setLightGroup, > "Set the light group for this material", > NULL}, > {"R", > (getter)Material_getColorComponent, (setter)Material_setColorComponent, > "Diffuse color red component", > (void *) EXPP_MAT_COMP_R }, > {"G", > (getter)Material_getColorComponent, (setter)Material_setColorComponent, > "Diffuse color green component", > (void *) EXPP_MAT_COMP_G }, > {"B", > (getter)Material_getColorComponent, (setter)Material_setColorComponent, > "Diffuse color blue component", > (void *) EXPP_MAT_COMP_B }, > {"colorbandDiffuse", > (getter)Material_getColorband, (setter)Material_setColorband, > "The diffuse colorband for this material", > (void *) 0}, > {"colorbandSpecular", > (getter)Material_getColorband, (setter)Material_setColorband, > "The specular colorband for this material", > (void *) 1}, > {"colorbandSpecularFactor", > (getter)Material_getColorBandSpecularFactor, (setter)Material_setColorBandSpecularFactor, > "The specular colorband factor for this material", > ( void * ) 1}, > {"colorbandDiffuseFactor", > (getter)Material_getColorBandDiffuseFactor, (setter)Material_setColorBandDiffuseFactor, > "The diffuse colorband factor for this material", > ( void * ) 1}, > > /* SSS settings */ > {"enableSSS", > (getter)Material_getSssEnable, (setter)Material_setSssEnable, > "if true, SSS will be rendered for this material", > NULL}, > {"sssScale", > (getter)Material_getSssScale, (setter)Material_setSssScale, > "object scale for sss", > NULL}, > {"sssRadiusRed", > (getter)Material_getSssRadius, (setter)Material_setSssRadius, > "Mean red scattering path length", > (void *) 0}, > {"sssRadiusGreen", > (getter)Material_getSssRadius, (setter)Material_setSssRadius, > "Mean red scattering path length", > (void *) 1}, > {"sssRadiusBlue", > (getter)Material_getSssRadius, (setter)Material_setSssRadius, > "Mean red scattering path length", > (void *) 0}, > {"sssIOR", > (getter)Material_getSssIOR, (setter)Material_setSssIOR, > "index of refraction", > NULL}, > {"sssError", > (getter)Material_getSssError, (setter)Material_setSssError, > "Error", > NULL}, > {"sssColorBlend", > (getter)Material_getSssColorBlend, (setter)Material_setSssColorBlend, > "Blend factor for SSS Colors", > NULL}, > {"sssTextureScatter", > (getter)Material_getSssTexScatter, (setter)Material_setSssTexScatter, > "Texture scattering factor", > NULL}, > {"sssFont", > (getter)Material_getSssFront, (setter)Material_setSssFront, > "Front scattering weight", > NULL}, > {"sssBack", > (getter)Material_getSssBack, (setter)Material_setSssBack, > "Back scattering weight", > NULL}, > {NULL,NULL,NULL,NULL,NULL} /* Sentinel */ 1221,1249c1309,1337 < PyObject_HEAD_INIT( NULL ) /* required py macro */ < 0, /* ob_size */ < /* For printing, in format "." */ < "Blender Material", /* char *tp_name; */ < sizeof( BPy_Material ), /* int tp_basicsize; */ < 0, /* tp_itemsize; For allocation */ < < /* Methods to implement standard operations */ < < ( destructor ) Material_dealloc,/* destructor tp_dealloc; */ < NULL, /* printfunc tp_print; */ < NULL, /* getattrfunc tp_getattr; */ < NULL, /* setattrfunc tp_setattr; */ < ( cmpfunc ) Material_compare,/* cmpfunc tp_compare; */ < ( reprfunc ) Material_repr, /* reprfunc tp_repr; */ < < /* Method suites for standard classes */ < < NULL, /* PyNumberMethods *tp_as_number; */ < NULL, /* PySequenceMethods *tp_as_sequence; */ < NULL, /* PyMappingMethods *tp_as_mapping; */ < < /* More standard operations (here for binary compatibility) */ < < ( hashfunc ) GenericLib_hash, /* hashfunc tp_hash; */ < NULL, /* ternaryfunc tp_call; */ < NULL, /* reprfunc tp_str; */ < NULL, /* getattrofunc tp_getattro; */ < NULL, /* setattrofunc tp_setattro; */ --- > PyObject_HEAD_INIT( NULL ) /* required py macro */ > 0, /* ob_size */ > /* For printing, in format "." */ > "Blender Material", /* char *tp_name; */ > sizeof( BPy_Material ), /* int tp_basicsize; */ > 0, /* tp_itemsize; For allocation */ > > /* Methods to implement standard operations */ > > ( destructor ) Material_dealloc,/* destructor tp_dealloc; */ > NULL, /* printfunc tp_print; */ > NULL, /* getattrfunc tp_getattr; */ > NULL, /* setattrfunc tp_setattr; */ > ( cmpfunc ) Material_compare,/* cmpfunc tp_compare; */ > ( reprfunc ) Material_repr, /* reprfunc tp_repr; */ > > /* Method suites for standard classes */ > > NULL, /* PyNumberMethods *tp_as_number; */ > NULL, /* PySequenceMethods *tp_as_sequence; */ > NULL, /* PyMappingMethods *tp_as_mapping; */ > > /* More standard operations (here for binary compatibility) */ > > ( hashfunc ) GenericLib_hash, /* hashfunc tp_hash; */ > NULL, /* ternaryfunc tp_call; */ > NULL, /* reprfunc tp_str; */ > NULL, /* getattrofunc tp_getattro; */ > NULL, /* setattrofunc tp_setattro; */ 1251,1252c1339,1340 < /* Functions to access object as input/output buffer */ < NULL, /* PyBufferProcs *tp_as_buffer; */ --- > /* Functions to access object as input/output buffer */ > NULL, /* PyBufferProcs *tp_as_buffer; */ 1255c1343 < Py_TPFLAGS_DEFAULT, /* long tp_flags; */ --- > Py_TPFLAGS_DEFAULT, /* long tp_flags; */ 1257c1345 < NULL, /* char *tp_doc; Documentation string */ --- > NULL, /* char *tp_doc; Documentation string */ 1259,1260c1347,1348 < /* call function for all accessible objects */ < NULL, /* traverseproc tp_traverse; */ --- > /* call function for all accessible objects */ > NULL, /* traverseproc tp_traverse; */ 1262,1263c1350,1351 < /* delete references to contained objects */ < NULL, /* inquiry tp_clear; */ --- > /* delete references to contained objects */ > NULL, /* inquiry tp_clear; */ 1267c1355 < NULL, /* richcmpfunc tp_richcompare; */ --- > NULL, /* richcmpfunc tp_richcompare; */ 1270c1358 < 0, /* long tp_weaklistoffset; */ --- > 0, /* long tp_weaklistoffset; */ 1273,1275c1361,1363 < /* Iterators */ < NULL, /* getiterfunc tp_iter; */ < NULL, /* iternextfunc tp_iternext; */ --- > /* Iterators */ > NULL, /* getiterfunc tp_iter; */ > NULL, /* iternextfunc tp_iternext; */ 1278,1299c1366,1387 < BPy_Material_methods, /* struct PyMethodDef *tp_methods; */ < NULL, /* struct PyMemberDef *tp_members; */ < BPy_Material_getseters, /* struct PyGetSetDef *tp_getset; */ < NULL, /* struct _typeobject *tp_base; */ < NULL, /* PyObject *tp_dict; */ < NULL, /* descrgetfunc tp_descr_get; */ < NULL, /* descrsetfunc tp_descr_set; */ < 0, /* long tp_dictoffset; */ < NULL, /* initproc tp_init; */ < NULL, /* allocfunc tp_alloc; */ < NULL, /* newfunc tp_new; */ < /* Low-level free-memory routine */ < NULL, /* freefunc tp_free; */ < /* For PyObject_IS_GC */ < NULL, /* inquiry tp_is_gc; */ < NULL, /* PyObject *tp_bases; */ < /* method resolution order */ < NULL, /* PyObject *tp_mro; */ < NULL, /* PyObject *tp_cache; */ < NULL, /* PyObject *tp_subclasses; */ < NULL, /* PyObject *tp_weaklist; */ < NULL --- > BPy_Material_methods, /* struct PyMethodDef *tp_methods; */ > NULL, /* struct PyMemberDef *tp_members; */ > BPy_Material_getseters, /* struct PyGetSetDef *tp_getset; */ > NULL, /* struct _typeobject *tp_base; */ > NULL, /* PyObject *tp_dict; */ > NULL, /* descrgetfunc tp_descr_get; */ > NULL, /* descrsetfunc tp_descr_set; */ > 0, /* long tp_dictoffset; */ > NULL, /* initproc tp_init; */ > NULL, /* allocfunc tp_alloc; */ > NULL, /* newfunc tp_new; */ > /* Low-level free-memory routine */ > NULL, /* freefunc tp_free; */ > /* For PyObject_IS_GC */ > NULL, /* inquiry tp_is_gc; */ > NULL, /* PyObject *tp_bases; */ > /* method resolution order */ > NULL, /* PyObject *tp_mro; */ > NULL, /* PyObject *tp_cache; */ > NULL, /* PyObject *tp_subclasses; */ > NULL, /* PyObject *tp_weaklist; */ > NULL 1303c1391 < /* Function: Material_dealloc */ --- > /* Function: Material_dealloc */ 1305c1393 < /* the destructor function. */ --- > /* the destructor function. */ 1309,1314c1397,1402 < Py_DECREF( self->col ); < Py_DECREF( self->amb ); < Py_DECREF( self->spec ); < Py_DECREF( self->mir ); < Py_DECREF( self->sss ); < PyObject_DEL( self ); --- > Py_DECREF( self->col ); > Py_DECREF( self->amb ); > Py_DECREF( self->spec ); > Py_DECREF( self->mir ); > Py_DECREF( self->sss ); > PyObject_DEL( self ); 1318c1406 < /* Function: Material_CreatePyObject */ --- > /* Function: Material_CreatePyObject */ 1320c1408 < /* Blender material structure. */ --- > /* Blender material structure. */ 1324,1325c1412,1416 < BPy_Material *pymat; < float *col[3], *amb[3], *spec[3], *mir[3], *sss[3]; --- > BPy_Material *pymat; > float *col[3], *amb[3], *spec[3], *mir[3], *sss[3]; > > pymat = ( BPy_Material * ) PyObject_NEW( BPy_Material, > &Material_Type ); 1327,1328c1418,1420 < pymat = ( BPy_Material * ) PyObject_NEW( BPy_Material, < &Material_Type ); --- > if( !pymat ) > return EXPP_ReturnPyObjError( PyExc_MemoryError, > "couldn't create BPy_Material object" ); 1330,1332c1422 < if( !pymat ) < return EXPP_ReturnPyObjError( PyExc_MemoryError, < "couldn't create BPy_Material object" ); --- > pymat->material = mat; 1334c1424,1426 < pymat->material = mat; --- > col[0] = &mat->r; > col[1] = &mat->g; > col[2] = &mat->b; 1336,1338c1428,1430 < col[0] = &mat->r; < col[1] = &mat->g; < col[2] = &mat->b; --- > amb[0] = &mat->ambr; > amb[1] = &mat->ambg; > amb[2] = &mat->ambb; 1340,1342c1432,1434 < amb[0] = &mat->ambr; < amb[1] = &mat->ambg; < amb[2] = &mat->ambb; --- > spec[0] = &mat->specr; > spec[1] = &mat->specg; > spec[2] = &mat->specb; 1344,1346c1436,1438 < spec[0] = &mat->specr; < spec[1] = &mat->specg; < spec[2] = &mat->specb; --- > mir[0] = &mat->mirr; > mir[1] = &mat->mirg; > mir[2] = &mat->mirb; 1348,1354c1440,1442 < mir[0] = &mat->mirr; < mir[1] = &mat->mirg; < mir[2] = &mat->mirb; < < sss[0] = &mat->sss_col[0]; < sss[1] = &mat->sss_col[1]; < sss[2] = &mat->sss_col[2]; --- > sss[0] = &mat->sss_col[0]; > sss[1] = &mat->sss_col[1]; > sss[2] = &mat->sss_col[2]; 1356,1360c1444,1448 < 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 ); < pymat->sss = ( BPy_rgbTuple * ) rgbTuple_New( sss ); --- > 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 ); > pymat->sss = ( BPy_rgbTuple * ) rgbTuple_New( sss ); 1362c1450 < return ( PyObject * ) pymat; --- > return ( PyObject * ) pymat; 1366c1454 < /* Function: Material_FromPyObject */ --- > /* Function: Material_FromPyObject */ 1368c1456 < /* PyObject. */ --- > /* PyObject. */ 1372c1460 < return ( ( BPy_Material * ) pyobj )->material; --- > return ( ( BPy_Material * ) pyobj )->material; 1377c1465 < Ipo *ipo = self->material->ipo; --- > Ipo *ipo = self->material->ipo; 1379,1380c1467,1468 < if( !ipo ) < Py_RETURN_NONE; --- > if( !ipo ) > Py_RETURN_NONE; 1382c1470 < return Ipo_CreatePyObject( ipo ); --- > return Ipo_CreatePyObject( ipo ); 1387c1475 < return PyInt_FromLong( ( long ) self->material->mode ); --- > return PyInt_FromLong( ( long ) self->material->mode ); 1392c1480 < return rgbTuple_getCol( self->col ); --- > return rgbTuple_getCol( self->col ); 1398c1486 < return rgbTuple_getCol(self->amb); --- > return rgbTuple_getCol(self->amb); 1403c1491 < return rgbTuple_getCol( self->spec ); --- > return rgbTuple_getCol( self->spec ); 1408c1496 < return rgbTuple_getCol( self->mir ); --- > return rgbTuple_getCol( self->mir ); 1413c1501 < return rgbTuple_getCol( self->sss ); --- > return rgbTuple_getCol( self->sss ); 1418c1506 < return PyInt_FromLong( ( long ) self->material->spec_shader ); --- > return PyInt_FromLong( ( long ) self->material->spec_shader ); 1423c1511 < return PyInt_FromLong( ( long ) self->material->diff_shader ); --- > return PyInt_FromLong( ( long ) self->material->diff_shader ); 1428c1516 < return PyFloat_FromDouble( ( double ) self->material->roughness ); --- > return PyFloat_FromDouble( ( double ) self->material->roughness ); 1433c1521 < return PyFloat_FromDouble( ( double ) self->material->param[2] ); --- > return PyFloat_FromDouble( ( double ) self->material->param[2] ); 1438c1526 < return PyFloat_FromDouble( ( double ) self->material->param[0] ); --- > return PyFloat_FromDouble( ( double ) self->material->param[0] ); 1443c1531 < return PyFloat_FromDouble( ( double ) self->material->param[3] ); --- > return PyFloat_FromDouble( ( double ) self->material->param[3] ); 1448c1536 < return PyFloat_FromDouble( ( double ) self->material->param[1] ); --- > return PyFloat_FromDouble( ( double ) self->material->param[1] ); 1453c1541 < return PyFloat_FromDouble( ( double ) self->material->darkness ); --- > return PyFloat_FromDouble( ( double ) self->material->darkness ); 1458c1546 < return PyFloat_FromDouble( ( double ) self->material->refrac ); --- > return PyFloat_FromDouble( ( double ) self->material->refrac ); 1460c1548 < --- > 1463c1551 < return PyFloat_FromDouble( ( double ) self->material->rms ); --- > return PyFloat_FromDouble( ( double ) self->material->rms ); 1468c1556 < return PyFloat_FromDouble( ( double ) self->material->amb ); --- > return PyFloat_FromDouble( ( double ) self->material->amb ); 1473c1561 < return PyFloat_FromDouble( ( double ) self->material->emit ); --- > return PyFloat_FromDouble( ( double ) self->material->emit ); 1478c1566 < return PyFloat_FromDouble( ( double ) self->material->alpha ); --- > return PyFloat_FromDouble( ( double ) self->material->alpha ); 1483c1571 < return PyFloat_FromDouble( ( double ) self->material->shad_alpha ); --- > return PyFloat_FromDouble( ( double ) self->material->shad_alpha ); 1488c1576 < return PyFloat_FromDouble( ( double ) self->material->ref ); --- > return PyFloat_FromDouble( ( double ) self->material->ref ); 1493c1581 < return PyFloat_FromDouble( ( double ) self->material->spec ); --- > return PyFloat_FromDouble( ( double ) self->material->spec ); 1498c1586 < return PyFloat_FromDouble( ( double ) self->material->spectra ); --- > return PyFloat_FromDouble( ( double ) self->material->spectra ); 1503c1591 < return PyFloat_FromDouble( ( double ) self->material->add ); --- > return PyFloat_FromDouble( ( double ) self->material->add ); 1508c1596 < return PyFloat_FromDouble( ( double ) self->material->zoffs ); --- > return PyFloat_FromDouble( ( double ) self->material->zoffs ); 1513c1601 < return Group_CreatePyObject( self->material->group ); --- > return Group_CreatePyObject( self->material->group ); 1518c1606 < return PyFloat_FromDouble( ( double ) self->material->hasize ); --- > return PyFloat_FromDouble( ( double ) self->material->hasize ); 1523c1611 < return PyFloat_FromDouble( ( double ) self->material->flaresize ); --- > return PyFloat_FromDouble( ( double ) self->material->flaresize ); 1528c1616 < return PyFloat_FromDouble( ( double ) self->material->flareboost ); --- > return PyFloat_FromDouble( ( double ) self->material->flareboost ); 1533c1621 < return PyFloat_FromDouble( ( double ) self->material->subsize ); --- > return PyFloat_FromDouble( ( double ) self->material->subsize ); 1538c1626 < return PyInt_FromLong( ( long ) self->material->seed1 ); --- > return PyInt_FromLong( ( long ) self->material->seed1 ); 1543c1631 < return PyInt_FromLong( ( long ) self->material->seed2 ); --- > return PyInt_FromLong( ( long ) self->material->seed2 ); 1548c1636 < return PyInt_FromLong( ( long ) self->material->har ); --- > return PyInt_FromLong( ( long ) self->material->har ); 1553c1641 < return PyInt_FromLong( ( long ) self->material->flarec ); --- > return PyInt_FromLong( ( long ) self->material->flarec ); 1558c1646 < return PyInt_FromLong( ( long ) self->material->starc ); --- > return PyInt_FromLong( ( long ) self->material->starc ); 1563c1651 < return PyInt_FromLong( ( long ) self->material->linec ); --- > return PyInt_FromLong( ( long ) self->material->linec ); 1568c1656 < return PyInt_FromLong( ( long ) self->material->ringc ); --- > return PyInt_FromLong( ( long ) self->material->ringc ); 1573c1661 < return PyFloat_FromDouble( ( double ) self->material->ray_mirror ); --- > return PyFloat_FromDouble( ( double ) self->material->ray_mirror ); 1578c1666 < return PyInt_FromLong( ( long ) self->material->ray_depth ); --- > return PyInt_FromLong( ( long ) self->material->ray_depth ); 1583c1671 < return PyFloat_FromDouble( ( double ) self->material->fresnel_mir ); --- > return PyFloat_FromDouble( ( double ) self->material->fresnel_mir ); 1588c1676 < return PyFloat_FromDouble( ( double ) self->material->fresnel_mir_i ); --- > return PyFloat_FromDouble( ( double ) self->material->fresnel_mir_i ); 1593c1681 < return PyFloat_FromDouble( ( double ) self->material->filter ); --- > return PyFloat_FromDouble( ( double ) self->material->filter ); 1598c1686 < return PyFloat_FromDouble( ( double ) self->material->translucency ); --- > return PyFloat_FromDouble( ( double ) self->material->translucency ); 1603c1691 < return PyFloat_FromDouble( ( double ) self->material->ang ); --- > return PyFloat_FromDouble( ( double ) self->material->ang ); 1608c1696 < return PyInt_FromLong( ( long ) self->material->ray_depth_tra ); --- > return PyInt_FromLong( ( long ) self->material->ray_depth_tra ); 1613c1701 < return PyFloat_FromDouble( ( double ) self->material->fresnel_tra ); --- > return PyFloat_FromDouble( ( double ) self->material->fresnel_tra ); 1618c1706 < return PyFloat_FromDouble( ( double ) self->material->fresnel_tra_i ); --- > return PyFloat_FromDouble( ( double ) self->material->fresnel_tra_i ); 1623c1711 < return PyFloat_FromDouble( ( double ) self->material->gloss_mir ); --- > return PyFloat_FromDouble( ( double ) self->material->gloss_mir ); 1628c1716 < return PyInt_FromLong( ( long ) self->material->samp_gloss_mir ); --- > return PyInt_FromLong( ( long ) self->material->samp_gloss_mir ); 1633c1721 < return PyFloat_FromDouble( ( double ) self->material->gloss_tra ); --- > return PyFloat_FromDouble( ( double ) self->material->gloss_tra ); 1638c1726 < return PyInt_FromLong( ( long ) self->material->samp_gloss_tra ); --- > return PyInt_FromLong( ( long ) self->material->samp_gloss_tra ); 1643c1731 < return PyFloat_FromDouble( ( double ) self->material->friction ); --- > return PyFloat_FromDouble( ( double ) self->material->friction ); 1648c1736 < return PyFloat_FromDouble( ( double ) self->material->reflect ); --- > return PyFloat_FromDouble( ( double ) self->material->reflect ); 1654c1742 < return EXPP_getBitfield( &self->material->sss_flag, MA_DIFF_SSS, 'h' ); --- > return EXPP_getBitfield( &self->material->sss_flag, MA_DIFF_SSS, 'h' ); 1659c1747 < return PyFloat_FromDouble( ( double ) self->material->sss_scale ); --- > return PyFloat_FromDouble( ( double ) self->material->sss_scale ); 1664c1752 < return PyFloat_FromDouble( ( double ) (self->material->sss_radius[GET_INT_FROM_POINTER(type)]) ); --- > return PyFloat_FromDouble( ( double ) (self->material->sss_radius[GET_INT_FROM_POINTER(type)]) ); 1669c1757 < return PyFloat_FromDouble( ( double ) self->material->sss_ior); --- > return PyFloat_FromDouble( ( double ) self->material->sss_ior); 1674c1762 < return PyFloat_FromDouble( ( double ) self->material->sss_error); --- > return PyFloat_FromDouble( ( double ) self->material->sss_error); 1679c1767 < return PyFloat_FromDouble( ( double ) self->material->sss_colfac); --- > return PyFloat_FromDouble( ( double ) self->material->sss_colfac); 1684c1772 < return PyFloat_FromDouble( ( double ) self->material->sss_texfac); --- > return PyFloat_FromDouble( ( double ) self->material->sss_texfac); 1689c1777 < return PyFloat_FromDouble( ( double ) self->material->sss_front); --- > return PyFloat_FromDouble( ( double ) self->material->sss_front); 1694c1782 < return PyFloat_FromDouble( ( double ) self->material->sss_back); --- > return PyFloat_FromDouble( ( double ) self->material->sss_back); 1699,1721c1787,1809 < int i; < struct MTex *mtex; < PyObject *t[MAX_MTEX]; < PyObject *tuple; < < /* build a texture list */ < for( i = 0; i < MAX_MTEX; ++i ) { < mtex = self->material->mtex[i]; < < if( mtex ) { < t[i] = MTex_CreatePyObject( mtex ); < } else { < Py_INCREF( Py_None ); < t[i] = Py_None; < } < } < < /* turn the array into a tuple */ < tuple = Py_BuildValue( "NNNNNNNNNN", t[0], t[1], t[2], t[3], < t[4], t[5], t[6], t[7], t[8], t[9] ); < if( !tuple ) < return EXPP_ReturnPyObjError( PyExc_MemoryError, < "Material_getTextures: couldn't create PyTuple" ); --- > int i; > struct MTex *mtex; > PyObject *t[MAX_MTEX]; > PyObject *tuple; > > /* build a texture list */ > for( i = 0; i < MAX_MTEX; ++i ) { > mtex = self->material->mtex[i]; > > if( mtex ) { > t[i] = MTex_CreatePyObject( mtex ); > } else { > Py_INCREF( Py_None ); > t[i] = Py_None; > } > } > > /* turn the array into a tuple */ > tuple = Py_BuildValue( "NNNNNNNNNN", t[0], t[1], t[2], t[3], > t[4], t[5], t[6], t[7], t[8], t[9] ); > if( !tuple ) > return EXPP_ReturnPyObjError( PyExc_MemoryError, > "Material_getTextures: couldn't create PyTuple" ); 1723c1811 < return tuple; --- > return tuple; 1733c1821 < return GenericLib_assignData(value, (void **) &self->material->ipo, 0, 1, ID_IP, ID_MA); --- > return GenericLib_assignData(value, (void **) &self->material->ipo, 0, 1, ID_IP, ID_MA); 1737c1825 < /* --- > /* 1745,1811d1832 < < if( !PyArg_ParseTuple( args, "i", &( key ) ) ) < return ( EXPP_ReturnPyObjError( PyExc_AttributeError, < "expected int argument" ) ); < < map = texchannel_to_adrcode(self->material->texact); < < if(key==IPOKEY_RGB || key==IPOKEY_ALLCOLOR) { < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_COL_R, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_COL_G, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_COL_B, 0); < } < if(key==IPOKEY_ALPHA || key==IPOKEY_ALLCOLOR) { < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_ALPHA, 0); < } < if(key==IPOKEY_HALOSIZE || key==IPOKEY_ALLCOLOR) { < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_HASIZE, 0); < } < if(key==IPOKEY_MODE || key==IPOKEY_ALLCOLOR) { < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_MODE, 0); < } < if(key==IPOKEY_ALLCOLOR) { < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_SPEC_R, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_SPEC_G, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_SPEC_B, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_REF, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_EMIT, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_AMB, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_SPEC, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_HARD, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_MODE, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_TRANSLU, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_ADD, 0); < } < if(key==IPOKEY_ALLMIRROR) { < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_RAYM, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_FRESMIR, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_FRESMIRI, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_FRESTRA, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_FRESTRAI, 0); < } < if(key==IPOKEY_OFS || key==IPOKEY_ALLMAPPING) { < insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_OFS_X, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_OFS_Y, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_OFS_Z, 0); < } < if(key==IPOKEY_SIZE || key==IPOKEY_ALLMAPPING) { < insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_SIZE_X, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_SIZE_Y, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_SIZE_Z, 0); < } < if(key==IPOKEY_ALLMAPPING) { < insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_R, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_G, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_B, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_DVAR, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_COLF, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_NORF, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_VARF, 0); < insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_DISP, 0); < } < < allspace(REMAKEIPO, 0); < EXPP_allqueue(REDRAWIPO, 0); < EXPP_allqueue(REDRAWVIEW3D, 0); < EXPP_allqueue(REDRAWACTION, 0); < EXPP_allqueue(REDRAWNLA, 0); 1813c1834,1901 < Py_RETURN_NONE; --- > if( !PyArg_ParseTuple( args, "i", &( key ) ) ) > return ( EXPP_ReturnPyObjError( PyExc_AttributeError, > "expected int argument" ) ); > > map = texchannel_to_adrcode(self->material->texact); > > if(key==IPOKEY_RGB || key==IPOKEY_ALLCOLOR) { > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_COL_R, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_COL_G, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_COL_B, 0); > } > if(key==IPOKEY_ALPHA || key==IPOKEY_ALLCOLOR) { > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_ALPHA, 0); > } > if(key==IPOKEY_HALOSIZE || key==IPOKEY_ALLCOLOR) { > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_HASIZE, 0); > } > if(key==IPOKEY_MODE || key==IPOKEY_ALLCOLOR) { > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_MODE, 0); > } > if(key==IPOKEY_ALLCOLOR) { > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_SPEC_R, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_SPEC_G, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_SPEC_B, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_REF, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_EMIT, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_AMB, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_SPEC, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_HARD, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_MODE, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_TRANSLU, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_ADD, 0); > } > if(key==IPOKEY_ALLMIRROR) { > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_RAYM, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_FRESMIR, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_FRESMIRI, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_FRESTRA, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, MA_FRESTRAI, 0); > } > if(key==IPOKEY_OFS || key==IPOKEY_ALLMAPPING) { > insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_OFS_X, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_OFS_Y, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_OFS_Z, 0); > } > if(key==IPOKEY_SIZE || key==IPOKEY_ALLMAPPING) { > insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_SIZE_X, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_SIZE_Y, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_SIZE_Z, 0); > } > if(key==IPOKEY_ALLMAPPING) { > insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_R, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_G, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_B, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_DVAR, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_COLF, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_NORF, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_VARF, 0); > insertkey((ID *)self->material, ID_MA, NULL, NULL, map+MAP_DISP, 0); > } > > allspace(REMAKEIPO, 0); > EXPP_allqueue(REDRAWIPO, 0); > EXPP_allqueue(REDRAWVIEW3D, 0); > EXPP_allqueue(REDRAWACTION, 0); > EXPP_allqueue(REDRAWNLA, 0); > > Py_RETURN_NONE; 1818c1906 < int param; --- > int param; 1820,1829c1908,1917 < if( !PyInt_Check( value ) ) { < char errstr[128]; < sprintf ( errstr , "expected int bitmask of 0x%08x", MA_MODE_MASK ); < return EXPP_ReturnIntError( PyExc_TypeError, errstr ); < } < param = PyInt_AS_LONG ( value ); < < if ( ( param & MA_MODE_MASK ) != param ) < return EXPP_ReturnIntError( PyExc_ValueError, < "invalid bit(s) set in mask" ); --- > if( !PyInt_Check( value ) ) { > char errstr[128]; > sprintf ( errstr , "expected int bitmask of 0x%08x", MA_MODE_MASK ); > return EXPP_ReturnIntError( PyExc_TypeError, errstr ); > } > param = PyInt_AS_LONG ( value ); > > if ( ( param & MA_MODE_MASK ) != param ) > return EXPP_ReturnIntError( PyExc_ValueError, > "invalid bit(s) set in mask" ); 1831,1832c1919,1920 < self->material->mode &= ( MA_RAMP_COL | MA_RAMP_SPEC ); < self->material->mode |= param & ~( MA_RAMP_COL | MA_RAMP_SPEC ); --- > self->material->mode &= ( MA_RAMP_COL | MA_RAMP_SPEC ); > self->material->mode |= param & ~( MA_RAMP_COL | MA_RAMP_SPEC ); 1834c1922 < return 0; --- > return 0; 1839c1927 < return rgbTuple_setCol( self->col, value ); --- > return rgbTuple_setCol( self->col, value ); 1845c1933 < return rgbTuple_setCol(self->amb, value); --- > return rgbTuple_setCol(self->amb, value); 1851c1939 < return rgbTuple_setCol( self->spec, value ); --- > return rgbTuple_setCol( self->spec, value ); 1856c1944 < return rgbTuple_setCol( self->mir, value ); --- > return rgbTuple_setCol( self->mir, value ); 1861c1949 < return rgbTuple_setCol( self->sss, value ); --- > return rgbTuple_setCol( self->sss, value ); 1865c1953 < void * closure ) --- > void * closure ) 1867c1955 < float param; --- > float param; 1869,1915c1957,2003 < if( !PyNumber_Check ( value ) ) < return EXPP_ReturnIntError( PyExc_TypeError, < "expected float argument in [0.0,1.0]" ); < < param = (float)PyFloat_AsDouble( value ); < param = EXPP_ClampFloat( param, EXPP_MAT_COL_MIN, EXPP_MAT_COL_MAX ); < < switch ( GET_INT_FROM_POINTER(closure) ) { < case EXPP_MAT_COMP_R: < self->material->r = param; < return 0; < case EXPP_MAT_COMP_G: < self->material->g = param; < return 0; < case EXPP_MAT_COMP_B: < self->material->b = param; < return 0; < case EXPP_MAT_COMP_SPECR: < self->material->specr = param; < return 0; < case EXPP_MAT_COMP_SPECG: < self->material->specg = param; < return 0; < case EXPP_MAT_COMP_SPECB: < self->material->specb = param; < return 0; < case EXPP_MAT_COMP_MIRR: < self->material->mirr = param; < return 0; < case EXPP_MAT_COMP_MIRG: < self->material->mirg = param; < return 0; < case EXPP_MAT_COMP_MIRB: < self->material->mirb = param; < return 0; < case EXPP_MAT_COMP_SSSR: < self->material->sss_col[0] = param; < return 0; < case EXPP_MAT_COMP_SSSG: < self->material->sss_col[1] = param; < return 0; < case EXPP_MAT_COMP_SSSB: < self->material->sss_col[2] = param; < return 0; < } < return EXPP_ReturnIntError( PyExc_RuntimeError, < "unknown color component specified" ); --- > if( !PyNumber_Check ( value ) ) > return EXPP_ReturnIntError( PyExc_TypeError, > "expected float argument in [0.0,1.0]" ); > > param = (float)PyFloat_AsDouble( value ); > param = EXPP_ClampFloat( param, EXPP_MAT_COL_MIN, EXPP_MAT_COL_MAX ); > > switch ( GET_INT_FROM_POINTER(closure) ) { > case EXPP_MAT_COMP_R: > self->material->r = param; > return 0; > case EXPP_MAT_COMP_G: > self->material->g = param; > return 0; > case EXPP_MAT_COMP_B: > self->material->b = param; > return 0; > case EXPP_MAT_COMP_SPECR: > self->material->specr = param; > return 0; > case EXPP_MAT_COMP_SPECG: > self->material->specg = param; > return 0; > case EXPP_MAT_COMP_SPECB: > self->material->specb = param; > return 0; > case EXPP_MAT_COMP_MIRR: > self->material->mirr = param; > return 0; > case EXPP_MAT_COMP_MIRG: > self->material->mirg = param; > return 0; > case EXPP_MAT_COMP_MIRB: > self->material->mirb = param; > return 0; > case EXPP_MAT_COMP_SSSR: > self->material->sss_col[0] = param; > return 0; > case EXPP_MAT_COMP_SSSG: > self->material->sss_col[1] = param; > return 0; > case EXPP_MAT_COMP_SSSB: > self->material->sss_col[2] = param; > return 0; > } > return EXPP_ReturnIntError( PyExc_RuntimeError, > "unknown color component specified" ); 1921,1924c2009,2012 < { < return EXPP_setFloatClamped ( value, &self->material->amb, < EXPP_MAT_AMB_MIN, < EXPP_MAT_AMB_MAX ); --- > { > return EXPP_setFloatClamped ( value, &self->material->amb, > EXPP_MAT_AMB_MIN, > EXPP_MAT_AMB_MAX ); 1929,1931c2017,2019 < return EXPP_setFloatClamped ( value, &self->material->emit, < EXPP_MAT_EMIT_MIN, < EXPP_MAT_EMIT_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->emit, > EXPP_MAT_EMIT_MIN, > EXPP_MAT_EMIT_MAX ); 1936,1938c2024,2026 < return EXPP_setFloatClamped ( value, &self->material->spectra, < EXPP_MAT_SPECTRA_MIN, < EXPP_MAT_SPECTRA_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->spectra, > EXPP_MAT_SPECTRA_MIN, > EXPP_MAT_SPECTRA_MAX ); 1943,1945c2031,2033 < return EXPP_setFloatClamped ( value, &self->material->alpha, < EXPP_MAT_ALPHA_MIN, < EXPP_MAT_ALPHA_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->alpha, > EXPP_MAT_ALPHA_MIN, > EXPP_MAT_ALPHA_MAX ); 1950,1952c2038,2040 < return EXPP_setFloatClamped ( value, &self->material->shad_alpha, < EXPP_MAT_ALPHA_MIN, < EXPP_MAT_ALPHA_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->shad_alpha, > EXPP_MAT_ALPHA_MIN, > EXPP_MAT_ALPHA_MAX ); 1957,1959c2045,2047 < return EXPP_setFloatClamped ( value, &self->material->ref, < EXPP_MAT_REF_MIN, < EXPP_MAT_REF_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->ref, > EXPP_MAT_REF_MIN, > EXPP_MAT_REF_MAX ); 1964,1966c2052,2054 < return EXPP_setFloatClamped ( value, &self->material->spec, < EXPP_MAT_SPEC_MIN, < EXPP_MAT_SPEC_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->spec, > EXPP_MAT_SPEC_MIN, > EXPP_MAT_SPEC_MAX ); 1971,1973c2059,2061 < return EXPP_setFloatClamped ( value, &self->material->zoffs, < EXPP_MAT_ZOFFS_MIN, < EXPP_MAT_ZOFFS_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->zoffs, > EXPP_MAT_ZOFFS_MIN, > EXPP_MAT_ZOFFS_MAX ); 1978c2066 < return GenericLib_assignData(value, (void **) &self->material->group, NULL, 1, ID_GR, 0); --- > return GenericLib_assignData(value, (void **) &self->material->group, NULL, 1, ID_GR, 0); 1983,1985c2071,2073 < return EXPP_setFloatClamped ( value, &self->material->add, < EXPP_MAT_ADD_MIN, < EXPP_MAT_ADD_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->add, > EXPP_MAT_ADD_MIN, > EXPP_MAT_ADD_MAX ); 1990,1992c2078,2080 < return EXPP_setFloatClamped ( value, &self->material->hasize, < EXPP_MAT_HALOSIZE_MIN, < EXPP_MAT_HALOSIZE_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->hasize, > EXPP_MAT_HALOSIZE_MIN, > EXPP_MAT_HALOSIZE_MAX ); 1997,1999c2085,2087 < return EXPP_setFloatClamped ( value, &self->material->flaresize, < EXPP_MAT_FLARESIZE_MIN, < EXPP_MAT_FLARESIZE_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->flaresize, > EXPP_MAT_FLARESIZE_MIN, > EXPP_MAT_FLARESIZE_MAX ); 2004,2006c2092,2094 < return EXPP_setFloatClamped ( value, &self->material->flareboost, < EXPP_MAT_FLAREBOOST_MIN, < EXPP_MAT_FLAREBOOST_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->flareboost, > EXPP_MAT_FLAREBOOST_MIN, > EXPP_MAT_FLAREBOOST_MAX ); 2011,2013c2099,2101 < return EXPP_setFloatClamped ( value, &self->material->subsize, < EXPP_MAT_SUBSIZE_MIN, < EXPP_MAT_SUBSIZE_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->subsize, > EXPP_MAT_SUBSIZE_MIN, > EXPP_MAT_SUBSIZE_MAX ); 2018,2020c2106,2108 < return EXPP_setIValueClamped ( value, &self->material->seed1, < EXPP_MAT_HALOSEED_MIN, < EXPP_MAT_HALOSEED_MAX, 'b' ); --- > return EXPP_setIValueClamped ( value, &self->material->seed1, > EXPP_MAT_HALOSEED_MIN, > EXPP_MAT_HALOSEED_MAX, 'b' ); 2025,2027c2113,2115 < return EXPP_setIValueClamped ( value, &self->material->seed2, < EXPP_MAT_FLARESEED_MIN, < EXPP_MAT_FLARESEED_MAX, 'b' ); --- > return EXPP_setIValueClamped ( value, &self->material->seed2, > EXPP_MAT_FLARESEED_MIN, > EXPP_MAT_FLARESEED_MAX, 'b' ); 2032,2034c2120,2122 < return EXPP_setIValueClamped ( value, &self->material->har, < EXPP_MAT_HARD_MIN, < EXPP_MAT_HARD_MAX, 'h' ); --- > return EXPP_setIValueClamped ( value, &self->material->har, > EXPP_MAT_HARD_MIN, > EXPP_MAT_HARD_MAX, 'h' ); 2039,2041c2127,2129 < return EXPP_setIValueClamped ( value, &self->material->flarec, < EXPP_MAT_NFLARES_MIN, < EXPP_MAT_NFLARES_MAX, 'h' ); --- > return EXPP_setIValueClamped ( value, &self->material->flarec, > EXPP_MAT_NFLARES_MIN, > EXPP_MAT_NFLARES_MAX, 'h' ); 2046,2048c2134,2136 < return EXPP_setIValueClamped ( value, &self->material->starc, < EXPP_MAT_NSTARS_MIN, < EXPP_MAT_NSTARS_MAX, 'h' ); --- > return EXPP_setIValueClamped ( value, &self->material->starc, > EXPP_MAT_NSTARS_MIN, > EXPP_MAT_NSTARS_MAX, 'h' ); 2053,2055c2141,2143 < return EXPP_setIValueClamped ( value, &self->material->linec, < EXPP_MAT_NLINES_MIN, < EXPP_MAT_NLINES_MAX, 'h' ); --- > return EXPP_setIValueClamped ( value, &self->material->linec, > EXPP_MAT_NLINES_MIN, > EXPP_MAT_NLINES_MAX, 'h' ); 2060,2062c2148,2150 < return EXPP_setIValueClamped ( value, &self->material->ringc, < EXPP_MAT_NRINGS_MIN, < EXPP_MAT_NRINGS_MAX, 'h' ); --- > return EXPP_setIValueClamped ( value, &self->material->ringc, > EXPP_MAT_NRINGS_MIN, > EXPP_MAT_NRINGS_MAX, 'h' ); 2067,2069c2155,2157 < return EXPP_setFloatClamped ( value, &self->material->ray_mirror, < EXPP_MAT_RAYMIRR_MIN, < EXPP_MAT_RAYMIRR_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->ray_mirror, > EXPP_MAT_RAYMIRR_MIN, > EXPP_MAT_RAYMIRR_MAX ); 2074,2076c2162,2164 < return EXPP_setIValueClamped ( value, &self->material->ray_depth, < EXPP_MAT_MIRRDEPTH_MIN, < EXPP_MAT_MIRRDEPTH_MAX, 'h' ); --- > return EXPP_setIValueClamped ( value, &self->material->ray_depth, > EXPP_MAT_MIRRDEPTH_MIN, > EXPP_MAT_MIRRDEPTH_MAX, 'h' ); 2081,2083c2169,2171 < return EXPP_setFloatClamped ( value, &self->material->fresnel_mir, < EXPP_MAT_FRESNELMIRR_MIN, < EXPP_MAT_FRESNELMIRR_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->fresnel_mir, > EXPP_MAT_FRESNELMIRR_MIN, > EXPP_MAT_FRESNELMIRR_MAX ); 2088,2090c2176,2178 < return EXPP_setFloatClamped ( value, &self->material->fresnel_mir_i, < EXPP_MAT_FRESNELMIRRFAC_MIN, < EXPP_MAT_FRESNELMIRRFAC_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->fresnel_mir_i, > EXPP_MAT_FRESNELMIRRFAC_MIN, > EXPP_MAT_FRESNELMIRRFAC_MAX ); 2095,2097c2183,2185 < return EXPP_setFloatClamped ( value, &self->material->ang, < EXPP_MAT_IOR_MIN, < EXPP_MAT_IOR_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->ang, > EXPP_MAT_IOR_MIN, > EXPP_MAT_IOR_MAX ); 2102,2104c2190,2192 < return EXPP_setIValueClamped ( value, &self->material->ray_depth_tra, < EXPP_MAT_TRANSDEPTH_MIN, < EXPP_MAT_TRANSDEPTH_MAX, 'h' ); --- > return EXPP_setIValueClamped ( value, &self->material->ray_depth_tra, > EXPP_MAT_TRANSDEPTH_MIN, > EXPP_MAT_TRANSDEPTH_MAX, 'h' ); 2109,2111c2197,2199 < return EXPP_setFloatClamped ( value, &self->material->fresnel_tra, < EXPP_MAT_FRESNELTRANS_MIN, < EXPP_MAT_FRESNELTRANS_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->fresnel_tra, > EXPP_MAT_FRESNELTRANS_MIN, > EXPP_MAT_FRESNELTRANS_MAX ); 2116,2118c2204,2206 < return EXPP_setFloatClamped ( value, &self->material->fresnel_tra_i, < EXPP_MAT_FRESNELTRANSFAC_MIN, < EXPP_MAT_FRESNELTRANSFAC_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->fresnel_tra_i, > EXPP_MAT_FRESNELTRANSFAC_MIN, > EXPP_MAT_FRESNELTRANSFAC_MAX ); 2123,2125c2211,2213 < return EXPP_setFloatClamped ( value, &self->material->gloss_mir, < EXPP_MAT_RAYMIRRGLOSS_MIN, < EXPP_MAT_RAYMIRRGLOSS_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->gloss_mir, > EXPP_MAT_RAYMIRRGLOSS_MIN, > EXPP_MAT_RAYMIRRGLOSS_MAX ); 2130,2132c2218,2220 < return EXPP_setIValueClamped ( value, &self->material->samp_gloss_mir, < EXPP_MAT_RAYMIRRGLOSSSAMPLES_MIN, < EXPP_MAT_RAYMIRRGLOSSSAMPLES_MAX, 'h' ); --- > return EXPP_setIValueClamped ( value, &self->material->samp_gloss_mir, > EXPP_MAT_RAYMIRRGLOSSSAMPLES_MIN, > EXPP_MAT_RAYMIRRGLOSSSAMPLES_MAX, 'h' ); 2137,2139c2225,2227 < return EXPP_setFloatClamped ( value, &self->material->gloss_tra, < EXPP_MAT_RAYTRANSPGLOSS_MIN, < EXPP_MAT_RAYTRANSPGLOSS_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->gloss_tra, > EXPP_MAT_RAYTRANSPGLOSS_MIN, > EXPP_MAT_RAYTRANSPGLOSS_MAX ); 2144,2146c2232,2234 < return EXPP_setIValueClamped ( value, &self->material->samp_gloss_tra, < EXPP_MAT_RAYTRANSPGLOSSSAMPLES_MIN, < EXPP_MAT_RAYTRANSPGLOSSSAMPLES_MAX, 'h' ); --- > return EXPP_setIValueClamped ( value, &self->material->samp_gloss_tra, > EXPP_MAT_RAYTRANSPGLOSSSAMPLES_MIN, > EXPP_MAT_RAYTRANSPGLOSSSAMPLES_MAX, 'h' ); 2151,2153c2239,2241 < return EXPP_setFloatClamped ( value, &self->material->friction, < 0.f, < 100.f ); --- > return EXPP_setFloatClamped ( value, &self->material->friction, > 0.f, > 100.f ); 2158,2160c2246,2248 < return EXPP_setFloatClamped ( value, &self->material->reflect, < 0.f, < 1.f ); --- > return EXPP_setFloatClamped ( value, &self->material->reflect, > 0.f, > 1.f ); 2168,2170c2256,2258 < return EXPP_setIValueRange( value, &self->material->spec_shader, < MA_SPEC_COOKTORR, < MA_SPEC_WARDISO, 'h' ); --- > return EXPP_setIValueRange( value, &self->material->spec_shader, > MA_SPEC_COOKTORR, > MA_SPEC_WARDISO, 'h' ); 2175,2177c2263,2265 < return EXPP_setIValueRange( value, &self->material->diff_shader, < MA_DIFF_LAMBERT, < MA_DIFF_MINNAERT, 'h' ); --- > return EXPP_setIValueRange( value, &self->material->diff_shader, > MA_DIFF_LAMBERT, > MA_DIFF_MINNAERT, 'h' ); 2182,2184c2270,2272 < return EXPP_setFloatClamped ( value, &self->material->roughness, < EXPP_MAT_ROUGHNESS_MIN, < EXPP_MAT_ROUGHNESS_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->roughness, > EXPP_MAT_ROUGHNESS_MIN, > EXPP_MAT_ROUGHNESS_MAX ); 2189,2191c2277,2279 < return EXPP_setFloatClamped ( value, &self->material->param[2], < EXPP_MAT_SPECSIZE_MIN, < EXPP_MAT_SPECSIZE_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->param[2], > EXPP_MAT_SPECSIZE_MIN, > EXPP_MAT_SPECSIZE_MAX ); 2196,2198c2284,2286 < return EXPP_setFloatClamped ( value, &self->material->param[0], < EXPP_MAT_DIFFUSESIZE_MIN, < EXPP_MAT_DIFFUSESIZE_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->param[0], > EXPP_MAT_DIFFUSESIZE_MIN, > EXPP_MAT_DIFFUSESIZE_MAX ); 2203,2205c2291,2293 < return EXPP_setFloatClamped ( value, &self->material->param[3], < EXPP_MAT_SPECSMOOTH_MIN, < EXPP_MAT_SPECSMOOTH_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->param[3], > EXPP_MAT_SPECSMOOTH_MIN, > EXPP_MAT_SPECSMOOTH_MAX ); 2210,2212c2298,2300 < return EXPP_setFloatClamped ( value, &self->material->param[1], < EXPP_MAT_DIFFUSESMOOTH_MIN, < EXPP_MAT_DIFFUSESMOOTH_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->param[1], > EXPP_MAT_DIFFUSESMOOTH_MIN, > EXPP_MAT_DIFFUSESMOOTH_MAX ); 2217,2219c2305,2307 < return EXPP_setFloatClamped ( value, &self->material->darkness, < EXPP_MAT_DIFFUSE_DARKNESS_MIN, < EXPP_MAT_DIFFUSE_DARKNESS_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->darkness, > EXPP_MAT_DIFFUSE_DARKNESS_MIN, > EXPP_MAT_DIFFUSE_DARKNESS_MAX ); 2224,2226c2312,2314 < return EXPP_setFloatClamped ( value, &self->material->refrac, < EXPP_MAT_REFRACINDEX_MIN, < EXPP_MAT_REFRACINDEX_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->refrac, > EXPP_MAT_REFRACINDEX_MIN, > EXPP_MAT_REFRACINDEX_MAX ); 2231,2233c2319,2321 < return EXPP_setFloatClamped ( value, &self->material->rms, < EXPP_MAT_RMS_MIN, < EXPP_MAT_RMS_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->rms, > EXPP_MAT_RMS_MIN, > EXPP_MAT_RMS_MAX ); 2238,2240c2326,2328 < return EXPP_setFloatClamped ( value, &self->material->filter, < EXPP_MAT_FILTER_MIN, < EXPP_MAT_FILTER_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->filter, > EXPP_MAT_FILTER_MIN, > EXPP_MAT_FILTER_MAX ); 2245,2247c2333,2335 < return EXPP_setFloatClamped ( value, &self->material->translucency, < EXPP_MAT_TRANSLUCENCY_MIN, < EXPP_MAT_TRANSLUCENCY_MAX ); --- > return EXPP_setFloatClamped ( value, &self->material->translucency, > EXPP_MAT_TRANSLUCENCY_MIN, > EXPP_MAT_TRANSLUCENCY_MAX ); 2253c2341 < return EXPP_setBitfield( value, &self->material->sss_flag, MA_DIFF_SSS, 'h' ); --- > return EXPP_setBitfield( value, &self->material->sss_flag, MA_DIFF_SSS, 'h' ); 2258,2260c2346,2348 < return EXPP_setFloatClamped ( value, &self->material->sss_scale, < EXPP_MAT_SSS_SCALE_MIN, < EXPP_MAT_SSS_SCALE_MAX); --- > return EXPP_setFloatClamped ( value, &self->material->sss_scale, > EXPP_MAT_SSS_SCALE_MIN, > EXPP_MAT_SSS_SCALE_MAX); 2265,2267c2353,2355 < return EXPP_setFloatClamped ( value, &self->material->sss_radius[GET_INT_FROM_POINTER(type)], < EXPP_MAT_SSS_RADIUS_MIN, < EXPP_MAT_SSS_RADIUS_MAX); --- > return EXPP_setFloatClamped ( value, &self->material->sss_radius[GET_INT_FROM_POINTER(type)], > EXPP_MAT_SSS_RADIUS_MIN, > EXPP_MAT_SSS_RADIUS_MAX); 2272,2274c2360,2362 < return EXPP_setFloatClamped ( value, &self->material->sss_ior, < EXPP_MAT_SSS_IOR_MIN, < EXPP_MAT_SSS_IOR_MAX); --- > return EXPP_setFloatClamped ( value, &self->material->sss_ior, > EXPP_MAT_SSS_IOR_MIN, > EXPP_MAT_SSS_IOR_MAX); 2279,2281c2367,2369 < return EXPP_setFloatClamped ( value, &self->material->sss_error, < EXPP_MAT_SSS_IOR_MIN, < EXPP_MAT_SSS_IOR_MAX); --- > return EXPP_setFloatClamped ( value, &self->material->sss_error, > EXPP_MAT_SSS_IOR_MIN, > EXPP_MAT_SSS_IOR_MAX); 2286,2288c2374,2376 < return EXPP_setFloatClamped ( value, &self->material->sss_colfac, < 0.0, < 1.0); --- > return EXPP_setFloatClamped ( value, &self->material->sss_colfac, > 0.0, > 1.0); 2293,2295c2381,2383 < return EXPP_setFloatClamped ( value, &self->material->sss_texfac, < 0.0, < 1.0); --- > return EXPP_setFloatClamped ( value, &self->material->sss_texfac, > 0.0, > 1.0); 2300,2302c2388,2390 < return EXPP_setFloatClamped ( value, &self->material->sss_front, < EXPP_MAT_SSS_FRONT_MIN, < EXPP_MAT_SSS_FRONT_MAX); --- > return EXPP_setFloatClamped ( value, &self->material->sss_front, > EXPP_MAT_SSS_FRONT_MIN, > EXPP_MAT_SSS_FRONT_MAX); 2307,2309c2395,2397 < return EXPP_setFloatClamped ( value, &self->material->sss_back, < EXPP_MAT_SSS_BACK_MIN, < EXPP_MAT_SSS_BACK_MAX); --- > return EXPP_setFloatClamped ( value, &self->material->sss_back, > EXPP_MAT_SSS_BACK_MIN, > EXPP_MAT_SSS_BACK_MAX); 2317,2343c2405,2431 < int texnum; < PyObject *pytex; < Tex *bltex; < int texco = TEXCO_ORCO, mapto = MAP_COL; < < if( !PyArg_ParseTuple( args, "iO!|ii", &texnum, &Texture_Type, &pytex, < &texco, &mapto ) ) < return EXPP_ReturnPyObjError( PyExc_TypeError, < "expected int in [0,9] and Texture" ); < if( ( texnum < 0 ) || ( texnum >= MAX_MTEX ) ) < return EXPP_ReturnPyObjError( PyExc_TypeError, < "expected int in [0,9] and Texture" ); < < bltex = Texture_FromPyObject( pytex ); < < if( !self->material->mtex[texnum] ) { < /* there isn't an mtex for this slot so we need to make one */ < self->material->mtex[texnum] = add_mtex( ); < } else { < /* we already had a texture here so deal with the old one first */ < self->material->mtex[texnum]->tex->id.us--; < } < < self->material->mtex[texnum]->tex = bltex; < id_us_plus( &bltex->id ); < self->material->mtex[texnum]->texco = (short)texco; < self->material->mtex[texnum]->mapto = (short)mapto; --- > int texnum; > PyObject *pytex; > Tex *bltex; > int texco = TEXCO_ORCO, mapto = MAP_COL; > > if( !PyArg_ParseTuple( args, "iO!|ii", &texnum, &Texture_Type, &pytex, > &texco, &mapto ) ) > return EXPP_ReturnPyObjError( PyExc_TypeError, > "expected int in [0,9] and Texture" ); > if( ( texnum < 0 ) || ( texnum >= MAX_MTEX ) ) > return EXPP_ReturnPyObjError( PyExc_TypeError, > "expected int in [0,9] and Texture" ); > > bltex = Texture_FromPyObject( pytex ); > > if( !self->material->mtex[texnum] ) { > /* there isn't an mtex for this slot so we need to make one */ > self->material->mtex[texnum] = add_mtex( ); > } else { > /* we already had a texture here so deal with the old one first */ > self->material->mtex[texnum]->tex->id.us--; > } > > self->material->mtex[texnum]->tex = bltex; > id_us_plus( &bltex->id ); > self->material->mtex[texnum]->texco = (short)texco; > self->material->mtex[texnum]->mapto = (short)mapto; 2345c2433 < Py_RETURN_NONE; --- > Py_RETURN_NONE; 2350,2363c2438,2451 < int texnum = (int)PyInt_AsLong(value); < struct MTex *mtex; < /* non ints will be -1 */ < if( ( texnum < 0 ) || ( texnum >= MAX_MTEX ) ) < return EXPP_ReturnPyObjError( PyExc_TypeError, < "expected int in [0,9]" ); < < mtex = self->material->mtex[texnum]; < if( mtex ) { < if( mtex->tex ) < mtex->tex->id.us--; < MEM_freeN( mtex ); < self->material->mtex[texnum] = NULL; < } --- > int texnum = (int)PyInt_AsLong(value); > struct MTex *mtex; > /* non ints will be -1 */ > if( ( texnum < 0 ) || ( texnum >= MAX_MTEX ) ) > return EXPP_ReturnPyObjError( PyExc_TypeError, > "expected int in [0,9]" ); > > mtex = self->material->mtex[texnum]; > if( mtex ) { > if( mtex->tex ) > mtex->tex->id.us--; > MEM_freeN( mtex ); > self->material->mtex[texnum] = NULL; > } 2365c2453 < Py_RETURN_NONE; --- > Py_RETURN_NONE; 2371,2372c2459,2460 < Material *mat = self->material; < ScriptLink *slink = NULL; --- > Material *mat = self->material; > ScriptLink *slink = NULL; 2374c2462 < slink = &( mat )->scriptlink; --- > slink = &( mat )->scriptlink; 2376c2464 < return EXPP_addScriptLink( slink, args, 0 ); --- > return EXPP_addScriptLink( slink, args, 0 ); 2382,2383c2470,2471 < Material *mat = self->material; < ScriptLink *slink = NULL; --- > Material *mat = self->material; > ScriptLink *slink = NULL; 2385c2473 < slink = &( mat )->scriptlink; --- > slink = &( mat )->scriptlink; 2387c2475 < return EXPP_clearScriptLinks( slink, args ); --- > return EXPP_clearScriptLinks( slink, args ); 2392c2480 < PyObject * value ) --- > PyObject * value ) 2394,2396c2482,2484 < Material *mat = self->material; < ScriptLink *slink = NULL; < PyObject *ret = NULL; --- > Material *mat = self->material; > ScriptLink *slink = NULL; > PyObject *ret = NULL; 2398c2486 < slink = &( mat )->scriptlink; --- > slink = &( mat )->scriptlink; 2400,2401c2488,2489 < /* can't this just return? EXP_getScriptLinks() returns a PyObject* < * or NULL anyway */ --- > /* can't this just return? EXP_getScriptLinks() returns a PyObject* > * or NULL anyway */ 2403c2491 < ret = EXPP_getScriptLinks( slink, value, 0 ); --- > ret = EXPP_getScriptLinks( slink, value, 0 ); 2405,2408c2493,2496 < if( ret ) < return ret; < else < return NULL; --- > if( ret ) > return ret; > else > return NULL; 2414,2429c2502,2503 < BPy_Material *pymat; /* for Material Data object wrapper in Python */ < Material *blmat; /* for actual Material Data we create in Blender */ < < blmat = copy_material( self->material ); /* first copy 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" ) ); --- > BPy_Material *pymat; /* for Material Data object wrapper in Python */ > Material *blmat; /* for actual Material Data we create in Blender */ 2431c2505,2519 < return ( PyObject * ) pymat; --- > blmat = copy_material( self->material ); /* first copy 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; 2437c2525 < return ( a->material == b->material) ? 0 : -1; --- > return ( a->material == b->material) ? 0 : -1; 2441c2529 < /* Function: Material_repr */ --- > /* Function: Material_repr */ 2443c2531 < /* builds a meaninful string to represent material objects. */ --- > /* builds a meaninful string to represent material objects. */ 2447,2448c2535,2536 < return PyString_FromFormat( "[Material \"%s\"]", < self->material->id.name + 2 ); --- > return PyString_FromFormat( "[Material \"%s\"]", > self->material->id.name + 2 ); 2452c2540 < /* These functions are used here and in in Texture.c */ --- > /* These functions are used here and in in Texture.c */ 2456,2474c2544,2562 < short i; < PyObject *cbls; < PyObject *colls; < < if (!coba) < return PyList_New( 0 ); < < cbls = PyList_New( coba->tot ); < < for (i=0; i < coba->tot; i++) { < colls = PyList_New( 5 ); < PyList_SET_ITEM( colls, 0, PyFloat_FromDouble(coba->data[i].r) ); < PyList_SET_ITEM( colls, 1, PyFloat_FromDouble(coba->data[i].g) ); < PyList_SET_ITEM( colls, 2, PyFloat_FromDouble(coba->data[i].b) ); < PyList_SET_ITEM( colls, 3, PyFloat_FromDouble(coba->data[i].a) ); < PyList_SET_ITEM( colls, 4, PyFloat_FromDouble(coba->data[i].pos) ); < PyList_SET_ITEM(cbls, i, colls); < } < return cbls; --- > short i; > PyObject *cbls; > PyObject *colls; > > if (!coba) > return PyList_New( 0 ); > > cbls = PyList_New( coba->tot ); > > for (i=0; i < coba->tot; i++) { > colls = PyList_New( 5 ); > PyList_SET_ITEM( colls, 0, PyFloat_FromDouble(coba->data[i].r) ); > PyList_SET_ITEM( colls, 1, PyFloat_FromDouble(coba->data[i].g) ); > PyList_SET_ITEM( colls, 2, PyFloat_FromDouble(coba->data[i].b) ); > PyList_SET_ITEM( colls, 3, PyFloat_FromDouble(coba->data[i].a) ); > PyList_SET_ITEM( colls, 4, PyFloat_FromDouble(coba->data[i].pos) ); > PyList_SET_ITEM(cbls, i, colls); > } > return cbls; 2480,2560c2568,2648 < short totcol, i; < PyObject *colseq; < PyObject *pyflt; < float f; < < if ( !PySequence_Check( value ) ) < return ( EXPP_ReturnIntError( PyExc_TypeError, < "Colorband must be a sequence" ) ); < < totcol = PySequence_Size(value); < if ( totcol > 31) < return ( EXPP_ReturnIntError( PyExc_ValueError, < "Colorband must be between 1 and 31 in length" ) ); < < if (totcol==0) { < MEM_freeN(*coba); < *coba = NULL; < return 0; < } < < if (!*coba) < *coba = MEM_callocN( sizeof(ColorBand), "colorband"); < < for (i=0; itot = totcol; < for (i=0; idata[i].r = f; < Py_DECREF ( pyflt ); < < pyflt = PySequence_GetItem( colseq, 1 ); < f = (float)PyFloat_AsDouble( pyflt ); < CLAMP(f, 0.0, 1.0); < (*coba)->data[i].g = f; < Py_DECREF ( pyflt ); < < pyflt = PySequence_GetItem( colseq, 2 ); < f = (float)PyFloat_AsDouble( pyflt ); < CLAMP(f, 0.0, 1.0); < (*coba)->data[i].b = f; < Py_DECREF ( pyflt ); < < pyflt = PySequence_GetItem( colseq, 3 ); < f = (float)PyFloat_AsDouble( pyflt ); < CLAMP(f, 0.0, 1.0); < (*coba)->data[i].a = f; < Py_DECREF ( pyflt ); < < pyflt = PySequence_GetItem( colseq, 4 ); < f = (float)PyFloat_AsDouble( pyflt ); < CLAMP(f, 0.0, 1.0); < (*coba)->data[i].pos = f; < Py_DECREF ( pyflt ); < < Py_DECREF ( colseq ); < } < return 0; --- > short totcol, i; > PyObject *colseq; > PyObject *pyflt; > float f; > > if ( !PySequence_Check( value ) ) > return ( EXPP_ReturnIntError( PyExc_TypeError, > "Colorband must be a sequence" ) ); > > totcol = PySequence_Size(value); > if ( totcol > 31) > return ( EXPP_ReturnIntError( PyExc_ValueError, > "Colorband must be between 1 and 31 in length" ) ); > > if (totcol==0) { > MEM_freeN(*coba); > *coba = NULL; > return 0; > } > > if (!*coba) > *coba = MEM_callocN( sizeof(ColorBand), "colorband"); > > for (i=0; i colseq = PySequence_GetItem( value, i ); > if ( !PySequence_Check( colseq ) || PySequence_Size( colseq ) != 5) { > Py_DECREF ( colseq ); > return ( EXPP_ReturnIntError( PyExc_ValueError, > "Colorband colors must be sequences of 5 floats" ) ); > } > for (i=0; i<5; i++) { > pyflt = PySequence_GetItem( colseq, i ); > if (!PyNumber_Check(pyflt)) { > return ( EXPP_ReturnIntError( PyExc_ValueError, > "Colorband colors must be sequences of 5 floats" ) ); > Py_DECREF ( pyflt ); > Py_DECREF ( colseq ); > } > Py_DECREF ( pyflt ); > } > Py_DECREF ( colseq ); > } > > /* ok, continue - should check for 5 floats, will ignore non floats for now */ > (*coba)->tot = totcol; > for (i=0; i colseq = PySequence_GetItem( value, i ); > > pyflt = PySequence_GetItem( colseq, 0 ); > f = (float)PyFloat_AsDouble( pyflt ); > CLAMP(f, 0.0, 1.0); > (*coba)->data[i].r = f; > Py_DECREF ( pyflt ); > > pyflt = PySequence_GetItem( colseq, 1 ); > f = (float)PyFloat_AsDouble( pyflt ); > CLAMP(f, 0.0, 1.0); > (*coba)->data[i].g = f; > Py_DECREF ( pyflt ); > > pyflt = PySequence_GetItem( colseq, 2 ); > f = (float)PyFloat_AsDouble( pyflt ); > CLAMP(f, 0.0, 1.0); > (*coba)->data[i].b = f; > Py_DECREF ( pyflt ); > > pyflt = PySequence_GetItem( colseq, 3 ); > f = (float)PyFloat_AsDouble( pyflt ); > CLAMP(f, 0.0, 1.0); > (*coba)->data[i].a = f; > Py_DECREF ( pyflt ); > > pyflt = PySequence_GetItem( colseq, 4 ); > f = (float)PyFloat_AsDouble( pyflt ); > CLAMP(f, 0.0, 1.0); > (*coba)->data[i].pos = f; > Py_DECREF ( pyflt ); > > Py_DECREF ( colseq ); > } > return 0; 2565c2653 < /* These functions are used in NMesh.c and Object.c */ --- > /* These functions are used in NMesh.c and Object.c */ 2569,2570c2657,2658 < PyObject *list; < int i; --- > PyObject *list; > int i; 2572,2587c2660,2675 < list = PyList_New( 0 ); < if( !matlist ) < return list; < < for( i = 0; i < len; i++ ) { < Material *mat = matlist[i]; < PyObject *ob; < < if( mat ) { < ob = Material_CreatePyObject( mat ); < PyList_Append( list, ob ); < Py_DECREF( ob ); /* because Append increfs */ < } else if( all ) { /* return NULL mats (empty slots) as Py_None */ < PyList_Append( list, Py_None ); < } < } --- > list = PyList_New( 0 ); > if( !matlist ) > return list; > > for( i = 0; i < len; i++ ) { > Material *mat = matlist[i]; > PyObject *ob; > > if( mat ) { > ob = Material_CreatePyObject( mat ); > PyList_Append( list, ob ); > Py_DECREF( ob ); /* because Append increfs */ > } else if( all ) { /* return NULL mats (empty slots) as Py_None */ > PyList_Append( list, Py_None ); > } > } 2589c2677 < return list; --- > return list; 2594,2620c2682,2708 < int i, len; < BPy_Material *pymat = 0; < Material *mat; < Material **matlist; < < len = PySequence_Length( list ); < if( len > 16 ) < len = 16; < else if( len <= 0 ) < return NULL; < < matlist = EXPP_newMaterialList( len ); < < for( i = 0; i < len; i++ ) { < < pymat = ( BPy_Material * ) PySequence_GetItem( list, i ); < < if( BPy_Material_Check( ( PyObject * ) pymat ) ) { < mat = pymat->material; < matlist[i] = mat; < } else if( ( PyObject * ) pymat == Py_None ) { < matlist[i] = NULL; < } else { /* error; illegal type in material list */ < Py_DECREF( pymat ); < MEM_freeN( matlist ); < return NULL; < } --- > int i, len; > BPy_Material *pymat = 0; > Material *mat; > Material **matlist; > > len = PySequence_Length( list ); > if( len > 16 ) > len = 16; > else if( len <= 0 ) > return NULL; > > matlist = EXPP_newMaterialList( len ); > > for( i = 0; i < len; i++ ) { > > pymat = ( BPy_Material * ) PySequence_GetItem( list, i ); > > if( BPy_Material_Check( ( PyObject * ) pymat ) ) { > mat = pymat->material; > matlist[i] = mat; > } else if( ( PyObject * ) pymat == Py_None ) { > matlist[i] = NULL; > } else { /* error; illegal type in material list */ > Py_DECREF( pymat ); > MEM_freeN( matlist ); > return NULL; > } 2622,2623c2710,2711 < Py_DECREF( pymat ); < } --- > Py_DECREF( pymat ); > } 2625c2713 < return matlist; --- > return matlist; 2630,2632c2718,2720 < Material **matlist = < ( Material ** ) MEM_mallocN( len * sizeof( Material * ), < "MaterialList" ); --- > Material **matlist = > ( Material ** ) MEM_mallocN( len * sizeof( Material * ), > "MaterialList" ); 2634c2722 < return matlist; --- > return matlist; 2639,2640c2727,2728 < int i; < Material *mat; --- > int i; > Material *mat; 2642,2657c2730,2745 < if( ( len < 0 ) || ( len > MAXMAT ) ) { < printf( "illegal matindex!\n" ); < return 0; < } < < for( i = 0; i < len; i++ ) { < mat = matlist[i]; < if( mat ) { < if( ( ( ID * ) mat )->us > 0 ) < ( ( ID * ) mat )->us--; < else < printf( "FATAL: material usage=0: %s", < ( ( ID * ) mat )->name ); < } < } < MEM_freeN( matlist ); --- > if( ( len < 0 ) || ( len > MAXMAT ) ) { > printf( "illegal matindex!\n" ); > return 0; > } > > for( i = 0; i < len; i++ ) { > mat = matlist[i]; > if( mat ) { > if( ( ( ID * ) mat )->us > 0 ) > ( ( ID * ) mat )->us--; > else > printf( "FATAL: material usage=0: %s", > ( ( ID * ) mat )->name ); > } > } > MEM_freeN( matlist ); 2659c2747 < return 1; --- > return 1; 2663,2666c2751,2754 < * A pointer to the (void *) array must be passed as first argument < * The array pointer content can be NULL, in this case a new array of length < * 'newsize' is created. < */ --- > * A pointer to the (void *) array must be passed as first argument > * The array pointer content can be NULL, in this case a new array of length > * 'newsize' is created. > */ 2670c2758 < void *newarray; --- > void *newarray; 2672,2681c2760,2769 < if( newsize < oldsize ) { < return 0; < } < newarray = MEM_callocN( sizeof( void * ) * newsize, "PtrArray" ); < if( *p ) { < memcpy( newarray, *p, sizeof( void * ) * oldsize ); < MEM_freeN( *p ); < } < *p = newarray; < return 1; --- > if( newsize < oldsize ) { > return 0; > } > newarray = MEM_callocN( sizeof( void * ) * newsize, "PtrArray" ); > if( *p ) { > memcpy( newarray, *p, sizeof( void * ) * oldsize ); > MEM_freeN( *p ); > } > *p = newarray; > return 1; 2686,2702c2774,2790 < Material ***p_dataMaterials = give_matarar( object ); < short *nmaterials = give_totcolp( object ); < int result = 0; < < if( object->totcol > *nmaterials ) { < /* More object mats than data mats */ < result = expandPtrArray( ( void * ) p_dataMaterials, < *nmaterials, object->totcol ); < *nmaterials = object->totcol; < } else { < if( object->totcol < *nmaterials ) { < /* More data mats than object mats */ < result = expandPtrArray( ( void * ) &object->mat, < object->totcol, *nmaterials ); < object->totcol = (char)*nmaterials; < } < } /* else no synchronization needed, they are of equal length */ --- > Material ***p_dataMaterials = give_matarar( object ); > short *nmaterials = give_totcolp( object ); > int result = 0; > > if( object->totcol > *nmaterials ) { > /* More object mats than data mats */ > result = expandPtrArray( ( void * ) p_dataMaterials, > *nmaterials, object->totcol ); > *nmaterials = object->totcol; > } else { > if( object->totcol < *nmaterials ) { > /* More data mats than object mats */ > result = expandPtrArray( ( void * ) &object->mat, > object->totcol, *nmaterials ); > object->totcol = (char)*nmaterials; > } > } /* else no synchronization needed, they are of equal length */ 2704c2792 < return result; /* 1 if changed, 0 otherwise */ --- > return result; /* 1 if changed, 0 otherwise */ 2709,2710c2797,2801 < int i; < Material *mat; --- > int i; > Material *mat; > > if( len <= 0 ) > return; 2712,2713c2803,2807 < if( len <= 0 ) < return; --- > for( i = 0; i < len; i++ ) { > mat = matlist[i]; > if( mat ) > mat->id.us++; > } 2715,2755c2809,2843 < for( i = 0; i < len; i++ ) { < mat = matlist[i]; < if( mat ) < mat->id.us++; < } < < return; < } < < static PyObject *Material_getColorComponent( BPy_Material * self, < void * closure ) < { < switch ( GET_INT_FROM_POINTER(closure) ) { < case EXPP_MAT_COMP_R: < return PyFloat_FromDouble( ( double ) self->material->r ); < case EXPP_MAT_COMP_G: < return PyFloat_FromDouble( ( double ) self->material->g ); < case EXPP_MAT_COMP_B: < return PyFloat_FromDouble( ( double ) self->material->b ); < case EXPP_MAT_COMP_SPECR: < return PyFloat_FromDouble( ( double ) self->material->specr ); < case EXPP_MAT_COMP_SPECG: < return PyFloat_FromDouble( ( double ) self->material->specg ); < case EXPP_MAT_COMP_SPECB: < return PyFloat_FromDouble( ( double ) self->material->specb ); < case EXPP_MAT_COMP_MIRR: < return PyFloat_FromDouble( ( double ) self->material->mirr ); < case EXPP_MAT_COMP_MIRG: < return PyFloat_FromDouble( ( double ) self->material->mirg ); < case EXPP_MAT_COMP_MIRB: < return PyFloat_FromDouble( ( double ) self->material->mirb ); < case EXPP_MAT_COMP_SSSR: < return PyFloat_FromDouble( ( double ) self->material->sss_col[0] ); < case EXPP_MAT_COMP_SSSG: < return PyFloat_FromDouble( ( double ) self->material->sss_col[1] ); < case EXPP_MAT_COMP_SSSB: < return PyFloat_FromDouble( ( double ) self->material->sss_col[2] ); < default: < return EXPP_ReturnPyObjError( PyExc_RuntimeError, < "unknown color component specified" ); < } --- > return; > } > > static PyObject *Material_getColorComponent( BPy_Material * self, > void * closure ) > { > switch ( GET_INT_FROM_POINTER(closure) ) { > case EXPP_MAT_COMP_R: > return PyFloat_FromDouble( ( double ) self->material->r ); > case EXPP_MAT_COMP_G: > return PyFloat_FromDouble( ( double ) self->material->g ); > case EXPP_MAT_COMP_B: > return PyFloat_FromDouble( ( double ) self->material->b ); > case EXPP_MAT_COMP_SPECR: > return PyFloat_FromDouble( ( double ) self->material->specr ); > case EXPP_MAT_COMP_SPECG: > return PyFloat_FromDouble( ( double ) self->material->specg ); > case EXPP_MAT_COMP_SPECB: > return PyFloat_FromDouble( ( double ) self->material->specb ); > case EXPP_MAT_COMP_MIRR: > return PyFloat_FromDouble( ( double ) self->material->mirr ); > case EXPP_MAT_COMP_MIRG: > return PyFloat_FromDouble( ( double ) self->material->mirg ); > case EXPP_MAT_COMP_MIRB: > return PyFloat_FromDouble( ( double ) self->material->mirb ); > case EXPP_MAT_COMP_SSSR: > return PyFloat_FromDouble( ( double ) self->material->sss_col[0] ); > case EXPP_MAT_COMP_SSSG: > return PyFloat_FromDouble( ( double ) self->material->sss_col[1] ); > case EXPP_MAT_COMP_SSSB: > return PyFloat_FromDouble( ( double ) self->material->sss_col[2] ); > default: > return EXPP_ReturnPyObjError( PyExc_RuntimeError, > "unknown color component specified" ); > } 2760,2762c2848,2850 < switch( (long)type ) { < case 0: /* these are backwards, but that how it works */ < return EXPP_PyList_fromColorband( self->material->ramp_col ); --- > switch( (long)type ) { > case 0: /* these are backwards, but that how it works */ > return EXPP_PyList_fromColorband( self->material->ramp_col ); 2764,2766c2852,2854 < return EXPP_PyList_fromColorband( self->material->ramp_spec ); < } < Py_RETURN_NONE; --- > return EXPP_PyList_fromColorband( self->material->ramp_spec ); > } > Py_RETURN_NONE; 2771,2773c2859,2861 < switch( (long)type ) { < case 0: /* these are backwards, but that how it works */ < return EXPP_Colorband_fromPyList( &self->material->ramp_col, value ); --- > switch( (long)type ) { > case 0: /* these are backwards, but that how it works */ > return EXPP_Colorband_fromPyList( &self->material->ramp_col, value ); 2775,2777c2863,2865 < return EXPP_Colorband_fromPyList( &self->material->ramp_spec, value ); < } < return 0; --- > return EXPP_Colorband_fromPyList( &self->material->ramp_spec, value ); > } > return 0; 2784c2872 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setAdd ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setAdd ); 2789c2877 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setAlpha ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setAlpha ); 2794c2882 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setAmb ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setAmb ); 2799c2887 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setDiffuseDarkness ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setDiffuseDarkness ); 2804c2892 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setDiffuseShader ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setDiffuseShader ); 2809c2897 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setDiffuseSize ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setDiffuseSize ); 2814c2902 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setDiffuseSmooth ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setDiffuseSmooth ); 2819c2907 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setEmit ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setEmit ); 2824c2912 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFilter ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFilter ); 2829c2917 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFlareBoost ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFlareBoost ); 2834c2922 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFlareSeed ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFlareSeed ); 2839c2927 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFlareSize ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFlareSize ); 2844c2932 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFresnelMirr ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFresnelMirr ); 2848c2936 < PyObject * args ) --- > PyObject * args ) 2850c2938 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFresnelMirrFac ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFresnelMirrFac ); 2854c2942 < PyObject * args ) --- > PyObject * args ) 2856c2944 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFresnelTrans ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFresnelTrans ); 2860c2948 < PyObject * args ) --- > PyObject * args ) 2862c2950 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFresnelTransFac ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setFresnelTransFac ); 2867c2955 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setHaloSeed ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setHaloSeed ); 2872c2960 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setHaloSize ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setHaloSize ); 2877c2965 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setHardness ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setHardness ); 2882c2970 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setIOR ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setIOR ); 2887c2975 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setNFlares ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setNFlares ); 2892c2980 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setNLines ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setNLines ); 2897c2985 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setNRings ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setNRings ); 2902c2990 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setNStars ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setNStars ); 2907c2995 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setRayMirr ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setRayMirr ); 2912c3000 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setRoughness ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setRoughness ); 2917c3005 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setMirrDepth ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setMirrDepth ); 2922c3010 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setRef ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setRef ); 2927c3015 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setRefracIndex ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setRefracIndex ); 2932c3020 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setRms ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setRms ); 2937c3025 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setSpec ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setSpec ); 2942c3030 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setSpecShader ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setSpecShader ); 2947c3035 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setSpecSize ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setSpecSize ); 2952c3040 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setSpecSmooth ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setSpecSmooth ); 2957c3045 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setSpecTransp ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setSpecTransp ); 2962c3050 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setSubSize ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setSubSize ); 2967c3055 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setTranslucency ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setTranslucency ); 2972c3060 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setTransDepth ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setTransDepth ); 2977c3065 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setZOffset ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setZOffset ); 2982,2983c3070,3071 < return EXPP_setterWrapperTuple( (void *)self, args, < (setter)Material_setRGBCol ); --- > return EXPP_setterWrapperTuple( (void *)self, args, > (setter)Material_setRGBCol ); 2988,2989c3076,3077 < return EXPP_setterWrapperTuple( (void *)self, args, < (setter)Material_setSpecCol ); --- > return EXPP_setterWrapperTuple( (void *)self, args, > (setter)Material_setSpecCol ); 2994,2995c3082,3083 < return EXPP_setterWrapperTuple( (void *)self, args, < (setter)Material_setMirCol ); --- > return EXPP_setterWrapperTuple( (void *)self, args, > (setter)Material_setMirCol ); 3006,3111c3094,3199 < unsigned int i, flag = 0, ok = 0; < PyObject *value, *error; < char *m[28] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, < NULL, NULL, NULL, NULL, NULL, NULL, NULL, < NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, < NULL, NULL, NULL, NULL, NULL, NULL < }; < < /* < * check for a single integer argument; do a quick check for now < * that the value is not larger than double the highest flag bit < */ < < if ( (PySequence_Size( args ) == 1) < && PyInt_Check ( PyTuple_GET_ITEM ( args , 0 ) ) < && PyArg_ParseTuple( args, "i", &flag ) < && (flag & MA_MODE_MASK ) == flag ) { < ok = 1; < < /* < * check for either an empty argument list, or up to 28 strings < */ < < } else if( PyArg_ParseTuple( args, "|ssssssssssssssssssssssssssss", < &m[0], &m[1], &m[2], &m[3], &m[4], &m[5], &m[6], < &m[7], &m[8], &m[9], &m[10], &m[11], &m[12], < &m[13], &m[14], &m[15], &m[16], &m[17], &m[18], < &m[19], &m[20], &m[21], &m[22], &m[23], &m[24], < &m[25], &m[26], &m[27] ) ) { < for( i = 0; i < 28; i++ ) { < if( m[i] == NULL ) < break; < if( strcmp( m[i], "Traceable" ) == 0 ) < flag |= MA_TRACEBLE; < else if( strcmp( m[i], "Shadow" ) == 0 ) < flag |= MA_SHADOW; < else if( strcmp( m[i], "Shadeless" ) == 0 ) < flag |= MA_SHLESS; < else if( strcmp( m[i], "Wire" ) == 0 ) < flag |= MA_WIRE; < else if( strcmp( m[i], "VColLight" ) == 0 ) < flag |= MA_VERTEXCOL; < else if( strcmp( m[i], "VColPaint" ) == 0 ) < flag |= MA_VERTEXCOLP; < else if( strcmp( m[i], "Halo" ) == 0 ) < flag |= MA_HALO; < else if( strcmp( m[i], "ZTransp" ) == 0 ) < flag |= MA_ZTRA; < else if( strcmp( m[i], "ZInvert" ) == 0 ) < flag |= MA_ZINV; < else if( strcmp( m[i], "HaloRings" ) == 0 ) < flag |= MA_HALO_RINGS; < else if( strcmp( m[i], "HaloLines" ) == 0 ) < flag |= MA_HALO_LINES; < else if( strcmp( m[i], "OnlyShadow" ) == 0 ) < flag |= MA_ONLYSHADOW; < else if( strcmp( m[i], "HaloXAlpha" ) == 0 ) < flag |= MA_HALO_XALPHA; < else if( strcmp( m[i], "HaloStar" ) == 0 ) < flag |= MA_STAR; < else if( strcmp( m[i], "TexFace" ) == 0 ) < flag |= MA_FACETEXTURE; < else if( strcmp( m[i], "HaloTex" ) == 0 ) < flag |= MA_HALOTEX; < else if( strcmp( m[i], "HaloPuno" ) == 0 ) < flag |= MA_HALOPUNO; < else if( strcmp( m[i], "NoMist" ) == 0 ) < flag |= MA_NOMIST; < else if( strcmp( m[i], "HaloShaded" ) == 0 ) < flag |= MA_HALO_SHADE; < else if( strcmp( m[i], "HaloFlare" ) == 0 ) < flag |= MA_HALO_FLARE; < else if( strcmp( m[i], "Radio" ) == 0 ) < flag |= MA_RADIO; < /* ** Mirror ** */ < else if( strcmp( m[i], "RayMirr" ) == 0 ) < flag |= MA_RAYMIRROR; < else if( strcmp( m[i], "ZTransp" ) == 0 ) < flag |= MA_ZTRA; < else if( strcmp( m[i], "RayTransp" ) == 0 ) < flag |= MA_RAYTRANSP; < else if( strcmp( m[i], "OnlyShadow" ) == 0 ) < flag |= MA_ONLYSHADOW; < else if( strcmp( m[i], "NoMist" ) == 0 ) < flag |= MA_NOMIST; < else if( strcmp( m[i], "Env" ) == 0 ) < flag |= MA_ENV; < else < return ( EXPP_ReturnPyObjError( PyExc_AttributeError, < "unknown Material mode argument" ) ); < } < ok = 1; < } < < /* if neither input method worked, then throw an exception */ < < if ( ok == 0 ) < return ( EXPP_ReturnPyObjError < ( PyExc_AttributeError, < "expected nothing, an integer or up to 22 string argument(s)" ) ); < /* build tuple, call wrapper */ < < value = Py_BuildValue("(i)", flag); < error = EXPP_setterWrapper( (void *)self, value, (setter)Material_setMode ); < Py_DECREF ( value ); < return error; --- > unsigned int i, flag = 0, ok = 0; > PyObject *value, *error; > char *m[28] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, > NULL, NULL, NULL, NULL, NULL, NULL, NULL, > NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, > NULL, NULL, NULL, NULL, NULL, NULL > }; > > /* > * check for a single integer argument; do a quick check for now > * that the value is not larger than double the highest flag bit > */ > > if ( (PySequence_Size( args ) == 1) > && PyInt_Check ( PyTuple_GET_ITEM ( args , 0 ) ) > && PyArg_ParseTuple( args, "i", &flag ) > && (flag & MA_MODE_MASK ) == flag ) { > ok = 1; > > /* > * check for either an empty argument list, or up to 28 strings > */ > > } else if( PyArg_ParseTuple( args, "|ssssssssssssssssssssssssssss", > &m[0], &m[1], &m[2], &m[3], &m[4], &m[5], &m[6], > &m[7], &m[8], &m[9], &m[10], &m[11], &m[12], > &m[13], &m[14], &m[15], &m[16], &m[17], &m[18], > &m[19], &m[20], &m[21], &m[22], &m[23], &m[24], > &m[25], &m[26], &m[27] ) ) { > for( i = 0; i < 28; i++ ) { > if( m[i] == NULL ) > break; > if( strcmp( m[i], "Traceable" ) == 0 ) > flag |= MA_TRACEBLE; > else if( strcmp( m[i], "Shadow" ) == 0 ) > flag |= MA_SHADOW; > else if( strcmp( m[i], "Shadeless" ) == 0 ) > flag |= MA_SHLESS; > else if( strcmp( m[i], "Wire" ) == 0 ) > flag |= MA_WIRE; > else if( strcmp( m[i], "VColLight" ) == 0 ) > flag |= MA_VERTEXCOL; > else if( strcmp( m[i], "VColPaint" ) == 0 ) > flag |= MA_VERTEXCOLP; > else if( strcmp( m[i], "Halo" ) == 0 ) > flag |= MA_HALO; > else if( strcmp( m[i], "ZTransp" ) == 0 ) > flag |= MA_ZTRA; > else if( strcmp( m[i], "ZInvert" ) == 0 ) > flag |= MA_ZINV; > else if( strcmp( m[i], "HaloRings" ) == 0 ) > flag |= MA_HALO_RINGS; > else if( strcmp( m[i], "HaloLines" ) == 0 ) > flag |= MA_HALO_LINES; > else if( strcmp( m[i], "OnlyShadow" ) == 0 ) > flag |= MA_ONLYSHADOW; > else if( strcmp( m[i], "HaloXAlpha" ) == 0 ) > flag |= MA_HALO_XALPHA; > else if( strcmp( m[i], "HaloStar" ) == 0 ) > flag |= MA_STAR; > else if( strcmp( m[i], "TexFace" ) == 0 ) > flag |= MA_FACETEXTURE; > else if( strcmp( m[i], "HaloTex" ) == 0 ) > flag |= MA_HALOTEX; > else if( strcmp( m[i], "HaloPuno" ) == 0 ) > flag |= MA_HALOPUNO; > else if( strcmp( m[i], "NoMist" ) == 0 ) > flag |= MA_NOMIST; > else if( strcmp( m[i], "HaloShaded" ) == 0 ) > flag |= MA_HALO_SHADE; > else if( strcmp( m[i], "HaloFlare" ) == 0 ) > flag |= MA_HALO_FLARE; > else if( strcmp( m[i], "Radio" ) == 0 ) > flag |= MA_RADIO; > /* ** Mirror ** */ > else if( strcmp( m[i], "RayMirr" ) == 0 ) > flag |= MA_RAYMIRROR; > else if( strcmp( m[i], "ZTransp" ) == 0 ) > flag |= MA_ZTRA; > else if( strcmp( m[i], "RayTransp" ) == 0 ) > flag |= MA_RAYTRANSP; > else if( strcmp( m[i], "OnlyShadow" ) == 0 ) > flag |= MA_ONLYSHADOW; > else if( strcmp( m[i], "NoMist" ) == 0 ) > flag |= MA_NOMIST; > else if( strcmp( m[i], "Env" ) == 0 ) > flag |= MA_ENV; > else > return ( EXPP_ReturnPyObjError( PyExc_AttributeError, > "unknown Material mode argument" ) ); > } > ok = 1; > } > > /* if neither input method worked, then throw an exception */ > > if ( ok == 0 ) > return ( EXPP_ReturnPyObjError > ( PyExc_AttributeError, > "expected nothing, an integer or up to 22 string argument(s)" ) ); > /* build tuple, call wrapper */ > > value = Py_BuildValue("(i)", flag); > error = EXPP_setterWrapper( (void *)self, value, (setter)Material_setMode ); > Py_DECREF ( value ); > return error; 3116c3204 < return EXPP_setterWrapper( (void *)self, args, (setter)Material_setIpo ); --- > return EXPP_setterWrapper( (void *)self, args, (setter)Material_setIpo ); 3125c3213 < /* if Ipo defined, delete it and return true */ --- > /* if Ipo defined, delete it and return true */ 3127,3133c3215,3221 < if( self->material->ipo ) { < PyObject *value = Py_BuildValue( "(O)", Py_None ); < EXPP_setterWrapper( (void *)self, value, (setter)Material_setIpo ); < Py_DECREF ( value ); < return EXPP_incr_ret_True(); < } < return EXPP_incr_ret_False(); /* no ipo found */ --- > if( self->material->ipo ) { > PyObject *value = Py_BuildValue( "(O)", Py_None ); > EXPP_setterWrapper( (void *)self, value, (setter)Material_setIpo ); > Py_DECREF ( value ); > return EXPP_incr_ret_True(); > } > return EXPP_incr_ret_False(); /* no ipo found */ 3135a3224,3274 > //RampCol Factor: > static PyObject *Material_getColorBandDiffuseFactor( BPy_Material * self ) > { > return PyFloat_FromDouble( (double) self->material->rampfac_col); > } > static PyObject *Material_getColorBandSpecularFactor( BPy_Material * self ) > { > return PyFloat_FromDouble( (double) self->material->rampfac_spec); > } > static int Material_setColorBandDiffuseFactor ( BPy_Material * self, PyObject * value ) > { > return EXPP_setFloatClamped(value, &self->material->rampfac_col, EXPP_MAT_COLORBAND_FACTOR_MIN, EXPP_MAT_COLORBAND_FACTOR_MAX); > } > static int Material_setColorBandSpecularFactor ( BPy_Material * self, PyObject * value ) > { > return EXPP_setFloatClamped(value, &self->material->rampfac_spec, EXPP_MAT_COLORBAND_FACTOR_MIN, EXPP_MAT_COLORBAND_FACTOR_MAX); > } > //RampCol Method: > static PyObject *Material_getColorBandDiffuseMethod( BPy_Material * self ) > { > return PyInt_FromLong( (long) self->material->rampblend_col); > } > static PyObject *Material_getColorBandSpecularMethod ( BPy_Material * self ) > { > return PyInt_FromLong( (long) self->material->rampblend_spec); > } > static int Material_setColorBandDiffuseMethod ( BPy_Material * self, PyObject * value) > { > return EXPP_setIValueClamped(value, &self->material->rampblend_col, MA_RAMP_BLEND, MA_RAMP_COLOR, 'b'); > } > static int Material_setColorBandSpecularMethod ( BPy_Material * self, PyObject * value) > { > return EXPP_setIValueClamped(value, &self->material->rampblend_spec, MA_RAMP_BLEND, MA_RAMP_COLOR, 'b'); > } > //RampCol Input: > static PyObject *Material_getColorBandDiffuseInput( BPy_Material * self ) > { > return PyInt_FromLong( (long) self->material->rampin_col); > } > static PyObject *Material_getColorBandSpecularInput( BPy_Material * self ) > { > return PyInt_FromLong( (long) self->material->rampin_spec); > } > static int Material_setColorBandDiffuseInput ( BPy_Material * self, PyObject * value) > { > return EXPP_setIValueClamped(value, &self->material->rampin_col, MA_RAMP_IN_SHADER, MA_RAMP_IN_RESULT, 'b'); > } > static int Material_setColorBandSpecularInput ( BPy_Material * self, PyObject * value) > { > return EXPP_setIValueClamped(value, &self->material->rampin_spec, MA_RAMP_IN_SHADER, MA_RAMP_IN_RESULT, 'b'); > }