diff options
author | Campbell Barton <ideasman42@gmail.com> | 2007-06-06 23:12:07 +0400 |
---|---|---|
committer | Campbell Barton <ideasman42@gmail.com> | 2007-06-06 23:12:07 +0400 |
commit | 25baab252c761a1ab5ed1d1ec66f9ea893a803f0 (patch) | |
tree | 8db6c8f2420c2ef139bfd0bdffca7ccb7dcac810 | |
parent | f1992aeb65a72f3436fa43196b87482853514ac1 (diff) |
yafray settings access from Py API
-rw-r--r-- | source/blender/python/api2_2x/doc/Render.py | 72 | ||||
-rw-r--r-- | source/blender/python/api2_2x/sceneRender.c | 461 |
2 files changed, 513 insertions, 20 deletions
diff --git a/source/blender/python/api2_2x/doc/Render.py b/source/blender/python/api2_2x/doc/Render.py index 9c9f58f6074..c956d0cd6ee 100644 --- a/source/blender/python/api2_2x/doc/Render.py +++ b/source/blender/python/api2_2x/doc/Render.py @@ -105,14 +105,15 @@ attribute. One of the following modes can be active: @var PAL169: Output format. Use with renderdata.sizePreset() @var B_PR_FULL: Output format. Use with renderdata.sizePreset() -@var NONE: Yafray GI Quality. Use with renderdata.setYafrayGIQuality() +@var NONE: Yafray GI Quality / Method. Use with renderdata.setYafrayGIQuality() @var LOW: Yafray GI Quality. Use with renderdata.setYafrayGIQuality() @var MEDIUM: Yafray GI Quality. Use with renderdata.setYafrayGIQuality() @var HIGH: Yafray GI Quality. Use with renderdata.setYafrayGIQuality() @var HIGHER: Yafray GI Quality. Use with renderdata.setYafrayGIQuality() @var BEST: Yafray GI Quality. Use with renderdata.setYafrayGIQuality() -@var SKYDOME: Yafray GI Quality. Use with renderdata.setYafrayGIQuality() -@var GIFULL: Yafray GI Quality. Use with renderdata.setYafrayGIQuality() +@var USEAOSETTINGS: Yafray GI Quality. Use with renderdata.setYafrayGIQuality() +@var SKYDOME: Yafray GI Method. Use with renderdata.setYafrayGIMethod() +@var GIFULL: Yafray GI Method. Use with renderdata.setYafrayGIMethod() """ def CloseRenderWindow(): @@ -324,8 +325,45 @@ class RenderData: scene or None (setting to None clears the set). The scene argument cannot cause a circular link. @type set: BPy_Scene or None + @ivar yafrayGIMethod: Global Illumination method. + Valid values are NONE (0), SKYDOME (1) or FULL (2). + @type yafrayGIMethod: int + @ivar yafrayGIQuality: Global Illumination quality. + @type yafrayGIQuality: int {NONE (0), LOW (1), MEDIUM (2), HIGH (3), HIGHER (4), BEST (5), USEAOSETTINGS (6)} + @ivar yafrayExportToXML: If true export to an xml file and call yafray instead of plugin. + @type yafrayExportToXML: boolean + @ivar yafrayAutoAntiAliasing: Automatic anti-aliasing enabled/disabled. + @type yafrayAutoAntiAliasing: boolean + @ivar yafrayClampRGB: Clamp RGB enabled/disabled. + @type yafrayClampRGB: boolean + @ivar yafrayAntiAliasingPasses: Number of anti-aliasing passes (0 is no Anti-Aliasing). + @type yafrayAntiAliasingPasses: int [0, 64] + @ivar yafrayAntiAliasingSamples: Number of samples per pass. + @type yafrayAntiAliasingSamples: int [0, 2048] + @ivar yafrayAntiAliasingPixelSize: Anti-aliasing pixel filter size. + @type yafrayAntiAliasingPixelSize: float [1.0, 2.0] + @ivar yafrayAntiAliasingThreshold: Anti-aliasing threshold. + @type yafrayAntiAliasingThreshold: float [0.05, 1.0] + @ivar yafrayNumberOfProcessors: Number of processors to use. + @type yafrayNumberOfProcessors: int [1, 8] + @ivar yafrayGIMethod: Global illumination method. + @type yafrayGIMethod: int {NONE (0), SKYDOME (1), GIFULL (2)} + @ivar yafrayGICache: Cache occlusion/irradiance samples (faster). + @type yafrayGICache: boolean + @ivar yafrayGICacheBumpNormals: Enable/disable bumpnormals for cache. + @type yafrayGICacheBumpNormals: boolean + @ivar yafrayGICacheShadowQuality: Shadow quality, keep it under 0.95 :-). + @type yafrayGICacheShadowQuality: float [0.01, 1.0] + @ivar yafrayGICachePixelsPerSample: Maximum number of pixels without samples, the lower the better and slower. + @type yafrayGICachePixelsPerSample: int [1, 50] + @ivar yafrayGICacheRefinement: Threshold to refine shadows EXPERIMENTAL. 1 = no refinement. + @type yafrayGICacheRefinement: float [0.001, 1.0] + @ivar yafrayGIPhotons: Enable/disable use of global photons to help in GI. + @type yafrayGIPhotons: boolean + @ivar yafrayGITunePhotons: If true the photonmap is shown directly in the render for tuning. + @type yafrayGITunePhotons: boolean """ - + def currentFrame(frame = None): """ Get/set the current frame. @@ -824,6 +862,21 @@ class RenderData: - HIGH - HIGHER - BEST + - USEAOSETTINGS + """ + + def getYafrayGIQuality(): + """ + Get yafray global Illumination quality. + @rtype: enum constant + @return: one of 6 constants: + - NONE + - LOW + - MEDIUM + - HIGH + - HIGHER + - BEST + - USEAOSETTINGS """ def setYafrayGIMethod(type): @@ -836,6 +889,17 @@ class RenderData: - GIFULL: Use Full method """ + def getYafrayGIMethod(): + # (dietrich) 2007/06/01 + """ + Get yafray global Illumination method. + @rtype: enum constant - + @return: Current yafray global illumination method: + - NONE: Do not use GI illumination + - SKYDOME: Use Skydome method + - GIFULL: Use Full method + """ + def yafrayGIPower(power = None): """ Get/set GI lighting intensity scale. diff --git a/source/blender/python/api2_2x/sceneRender.c b/source/blender/python/api2_2x/sceneRender.c index 89e25e790de..7b8993fe98d 100644 --- a/source/blender/python/api2_2x/sceneRender.c +++ b/source/blender/python/api2_2x/sceneRender.c @@ -25,7 +25,7 @@ * * This is a new part of Blender. * - * Contributor(s): Joseph Gilbert + * Contributor(s): Joseph Gilbert, Dietrich Bollmann * * ***** END GPL/BL DUAL LICENSE BLOCK ***** */ @@ -56,14 +56,15 @@ struct View3D; /* keep me up here */ #include "Scene.h" /* local defines */ -#define PY_NONE 0 -#define PY_LOW 1 -#define PY_MEDIUM 2 -#define PY_HIGH 3 -#define PY_HIGHER 4 -#define PY_BEST 5 -#define PY_SKYDOME 1 -#define PY_FULL 2 +#define PY_NONE 0 +#define PY_LOW 1 +#define PY_MEDIUM 2 +#define PY_HIGH 3 +#define PY_HIGHER 4 +#define PY_BEST 5 +#define PY_USEAOSETTINGS 6 +#define PY_SKYDOME 1 +#define PY_FULL 2 enum rend_constants { EXPP_RENDER_ATTR_XPARTS = 0, @@ -301,6 +302,85 @@ static void M_Render_DoSizePreset( BPy_RenderData * self, short xsch, EXPP_allqueue( REDRAWVIEWCAM, 0 ); } +/** set / get boolean */ + +static int M_Render_setBooleanShort( BPy_RenderData * self, PyObject *value, short* var ) +{ + if( !PyInt_Check( value ) ) + return EXPP_ReturnIntError( PyExc_TypeError, + "expected boolean value" ); + + *var = (PyInt_AsLong( value )) ? 1 : 0; + + EXPP_allqueue( REDRAWBUTSSCENE, 0 ); + return 0; +} + +static PyObject *M_Render_getBooleanShort( BPy_RenderData * self, short var ) +{ + return PyInt_FromLong( (long) var ); +} + +/** set / get float */ + +static int M_Render_setFloat( BPy_RenderData *self, PyObject *value, float *var, float min, float max ) +{ + float val; + char error[48]; + + if( !PyFloat_Check( value ) ) + return EXPP_ReturnIntError( PyExc_TypeError, + "expected float value" ); + + val = (float) PyFloat_AsDouble( value ); + + /* check range */ + if ( val < min || val > max ) { + sprintf( error, "out of range - expected %f to %f", min, max ); + return EXPP_ReturnIntError( PyExc_TypeError,error ); + } + + *var = val; + + EXPP_allqueue( REDRAWBUTSSCENE, 0 ); + return 0; +} + +static PyObject *M_Render_getFloat( BPy_RenderData *self, float var ) +{ + return PyFloat_FromDouble( (double) var ); +} + +/** set / get integer */ + +static int M_Render_setInt( BPy_RenderData *self, PyObject *value, int *var, int min, int max ) +{ + int val; + char error[48]; + + if( !PyInt_Check( value ) ) + return EXPP_ReturnIntError( PyExc_TypeError, + "expected integer value" ); + + val = (int) PyInt_AsLong( value ); + + /* check range */ + if ( val < min || val > max ) { + sprintf( error, "out of range - expected %d to %d", min, max ); + return EXPP_ReturnIntError( PyExc_TypeError,error ); + } + + *var = val; + + EXPP_allqueue( REDRAWBUTSSCENE, 0 ); + return 0; +} + +static PyObject *M_Render_getInt( BPy_RenderData *self, int var ) +{ + return PyInt_FromLong( (long) var ); +} + /***************************************************************************/ /* Render Module Function Definitions */ /***************************************************************************/ @@ -1038,6 +1118,8 @@ PyObject *RenderData_SizePreset( BPy_RenderData * self, PyObject * args ) Py_RETURN_NONE; } +/* + PyObject *RenderData_SetYafrayGIQuality( BPy_RenderData * self, PyObject * args ) { @@ -1077,6 +1159,276 @@ PyObject *RenderData_SetYafrayGIMethod( BPy_RenderData * self, EXPP_allqueue( REDRAWBUTSSCENE, 0 ); Py_RETURN_NONE; } +*/ + +/* (die) beg */ + +/* YafRay - Yafray GI Method */ + +static int RenderData_setYafrayGIQuality( BPy_RenderData * self, PyObject * value ) +{ + long type; + + if( !PyInt_Check( value ) ) + return EXPP_ReturnIntError( PyExc_TypeError, + "expected constant" ); + + type = PyInt_AsLong( value ); + + if( type == PY_NONE || type == PY_LOW || + type == PY_MEDIUM || type == PY_HIGH || + type == PY_HIGHER || type == PY_BEST || + type == PY_USEAOSETTINGS + ) { + self->renderContext->GIquality = (short)type; + } else { + return EXPP_ReturnIntError( PyExc_TypeError, + "expected constant NONE, LOW, MEDIUM, HIGHER or BEST" ); + } + + EXPP_allqueue( REDRAWBUTSSCENE, 0 ); + return 0; +} + +static PyObject *RenderData_getYafrayGIQuality( BPy_RenderData * self ) +{ + return PyInt_FromLong( (long) self->renderContext->GIquality ); +} + +static PyObject *RenderData_SetYafrayGIQuality( BPy_RenderData * self, + PyObject * args ) +{ + return EXPP_setterWrapper( (void*) self, args, + (setter) RenderData_setYafrayGIQuality ); +} + +static PyObject *RenderData_GetYafrayGIQuality( BPy_RenderData * self ) +{ + return RenderData_getYafrayGIQuality(self); +} + +/* YafRay - Yafray GI Method */ + +static int RenderData_setYafrayGIMethod( BPy_RenderData * self, PyObject * value ) +{ + int type; + + if( !PyInt_Check( value ) ) + return EXPP_ReturnIntError( PyExc_TypeError, + "expected constant NONE, SKYDOME or FULL" ); + + type = PyInt_AsLong( value ); + if( type == PY_NONE || type == PY_SKYDOME || type == PY_FULL ) { + self->renderContext->GImethod = (short)type; + } else { + return EXPP_ReturnIntError( PyExc_TypeError, + "expected constant NONE, SKYDOME or FULL" ); + } + + EXPP_allqueue( REDRAWBUTSSCENE, 0 ); + return 0; +} + +static PyObject *RenderData_getYafrayGIMethod( BPy_RenderData * self ) +{ + return PyInt_FromLong( (long)self->renderContext->GImethod ); +} + +static PyObject *RenderData_GetYafrayGIMethod( BPy_RenderData * self ) +{ + return RenderData_getYafrayGIMethod(self); +} + +static PyObject *RenderData_SetYafrayGIMethod( BPy_RenderData * self, + PyObject * args ) +{ + return EXPP_setterWrapper( (void *)self, args, + (setter)RenderData_setYafrayGIMethod ); +} + + +/* YafRay - Export to XML */ + +static int RenderData_setYafrayExportToXML( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setBooleanShort( self, value, &self->renderContext->YFexportxml ); +} + +static PyObject *RenderData_getYafrayExportToXML( BPy_RenderData * self ) +{ + return M_Render_getBooleanShort( self, self->renderContext->YFexportxml ); +} + +/** Auto AA */ + +static int RenderData_setYafrayAutoAntiAliasing( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setBooleanShort( self, value, &self->renderContext->YF_AA ); +} + +static PyObject *RenderData_getYafrayAutoAntiAliasing( BPy_RenderData * self ) +{ + return M_Render_getBooleanShort( self, self->renderContext->YF_AA ); +} + +/** Clamp RGB */ + +static int RenderData_setYafrayClampRGB( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setBooleanShort( self, value, &self->renderContext->YF_clamprgb ); +} + +static PyObject *RenderData_getYafrayClampRGB( BPy_RenderData * self ) +{ + return M_Render_getBooleanShort( self, self->renderContext->YF_clamprgb ); +} + +/** YafRay - Anti-Aliasing Passes */ + +static int RenderData_setYafrayAntiAliasingPasses( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setInt( self, value, &self->renderContext->YF_AApasses, 0, 64 ); +} + +static PyObject *RenderData_getYafrayAntiAliasingPasses( BPy_RenderData * self ) +{ + return M_Render_getInt( self, self->renderContext->YF_AApasses ); +} + +/** YafRay - Anti-Aliasing Samples */ + +static int RenderData_setYafrayAntiAliasingSamples( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setInt( self, value, &self->renderContext->YF_AAsamples, 0, 2048 ); +} + +static PyObject *RenderData_getYafrayAntiAliasingSamples( BPy_RenderData * self ) +{ + return M_Render_getInt( self, self->renderContext->YF_AAsamples ); +} + +/* YafRay - Anti-Aliasing Pixel Filter Size */ + +static int RenderData_setYafrayAntiAliasingPixelSize( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setFloat( self, value, &self->renderContext->YF_AApixelsize, 1.0, 2.0 ); +} + +static PyObject *RenderData_getYafrayAntiAliasingPixelSize( BPy_RenderData * self ) +{ + return M_Render_getFloat( self, self->renderContext->YF_AApixelsize ); +} + +/* YafRay - Anti-Aliasing threshold */ + +static int RenderData_setYafrayAntiAliasingThreshold( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setFloat( self, value, &self->renderContext->YF_AAthreshold, 0.05, 1.0 ); +} + +static PyObject *RenderData_getYafrayAntiAliasingThreshold( BPy_RenderData * self ) +{ + return M_Render_getFloat( self, self->renderContext->YF_AAthreshold ); +} + +/** YafRay - Number of processors to use */ + +static int RenderData_setYafrayNumberOfProcessors( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setInt( self, value, &self->renderContext->YF_numprocs, 1, 8 ); +} + +static PyObject *RenderData_getYafrayNumberOfProcessors( BPy_RenderData * self ) +{ + return M_Render_getInt( self, self->renderContext->YF_numprocs ); +} + +/* YafRay - Cache occlusion/irradiance samples (faster) */ + +static int RenderData_setYafrayGICache( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setBooleanShort( self, value, &self->renderContext->GIcache ); +} + +static PyObject *RenderData_getYafrayGICache( BPy_RenderData * self ) +{ + return M_Render_getBooleanShort( self, self->renderContext->GIcache ); +} + +/* YafRay - Enable/disable bumpnormals for cache + (faster, but no bumpmapping in total indirectly lit areas) */ + +static int RenderData_setYafrayGICacheBumpNormals( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setBooleanShort( self, value, &self->renderContext->YF_nobump ); +} + +static PyObject *RenderData_getYafrayGICacheBumpNormals( BPy_RenderData * self ) +{ + return M_Render_getBooleanShort( self, self->renderContext->YF_nobump ); +} + +/* YafRay - Shadow quality, keep it under 0.95 :-) */ + +static int RenderData_setYafrayGICacheShadowQuality( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setFloat( self, value, &self->renderContext->GIshadowquality, 0.01, 1.0 ); +} + +static PyObject *RenderData_getYafrayGICacheShadowQuality( BPy_RenderData * self ) +{ + return M_Render_getFloat( self, self->renderContext->GIshadowquality ); +} + +/* YafRay - Threshold to refine shadows EXPERIMENTAL. 1 = no refinement */ + +static int RenderData_setYafrayGICacheRefinement( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setFloat( self, value, &self->renderContext->GIrefinement, 0.001, 1.0 ); +} + +static PyObject *RenderData_getYafrayGICacheRefinement( BPy_RenderData * self ) +{ + return M_Render_getFloat( self, self->renderContext->GIrefinement ); +} + +/* YafRay - Maximum number of pixels without samples, the lower the better and slower */ + +static int RenderData_setYafrayGICachePixelsPerSample( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setInt( self, value, &self->renderContext->GIpixelspersample, 1, 50 ); +} + +static PyObject *RenderData_getYafrayGICachePixelsPerSample( BPy_RenderData * self ) +{ + return M_Render_getInt( self, self->renderContext->GIpixelspersample ); +} + +/** YafRay - Enable/disable use of global photons to help in GI */ + +static int RenderData_setYafrayGIPhotons( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setBooleanShort( self, value, &self->renderContext->GIphotons ); +} + +static PyObject *RenderData_getYafrayGIPhotons( BPy_RenderData * self ) +{ + return M_Render_getBooleanShort( self, self->renderContext->GIphotons ); +} + +/** YafRay - If true the photonmap is shown directly in the render for tuning */ + +static int RenderData_setYafrayGITunePhotons( BPy_RenderData * self, PyObject * value ) +{ + return M_Render_setBooleanShort( self, value, &self->renderContext->GIdirect ); +} + +static PyObject *RenderData_getYafrayGITunePhotons( BPy_RenderData * self ) +{ + return M_Render_getBooleanShort( self, self->renderContext->GIdirect ); +} + +/* (die) end */ PyObject *RenderData_YafrayGIPower( BPy_RenderData * self, PyObject * args ) { @@ -1103,7 +1455,7 @@ PyObject *RenderData_YafrayGIDepth( BPy_RenderData * self, PyObject * args ) if( self->renderContext->GImethod == 2 ) { return M_Render_GetSetAttributeInt( args, &self->renderContext-> - GIdepth, 1, 8 ); + GIdepth, 1, 100 ); } else return ( EXPP_ReturnPyObjError( PyExc_StandardError, "YafrayGIMethod must be set to 'FULL'" ) ); @@ -1114,7 +1466,7 @@ PyObject *RenderData_YafrayGICDepth( BPy_RenderData * self, PyObject * args ) if( self->renderContext->GImethod == 2 ) { return M_Render_GetSetAttributeInt( args, &self->renderContext-> - GIcausdepth, 1, 8 ); + GIcausdepth, 1, 100 ); } else return ( EXPP_ReturnPyObjError( PyExc_StandardError, "YafrayGIMethod must be set to 'FULL'" ) ); @@ -1151,7 +1503,7 @@ PyObject *RenderData_YafrayGIPhotonCount( BPy_RenderData * self, && self->renderContext->GIphotons == 1 ) { return M_Render_GetSetAttributeInt( args, &self->renderContext-> - GIphotoncount, 0, + GIphotoncount, 100000, 10000000 ); } else return ( EXPP_ReturnPyObjError( PyExc_StandardError, @@ -1179,7 +1531,7 @@ PyObject *RenderData_YafrayGIPhotonMixCount( BPy_RenderData * self, && self->renderContext->GIphotons == 1 ) { return M_Render_GetSetAttributeInt( args, &self->renderContext-> - GImixphotons, 0, 1000 ); + GImixphotons, 100, 1000 ); } else return ( EXPP_ReturnPyObjError( PyExc_StandardError, "YafrayGIMethod must be set to 'FULL' and GIPhotons must be enabled" ) ); @@ -2217,6 +2569,76 @@ static PyGetSetDef BPy_RenderData_getseters[] = { (getter)RenderData_getSet, (setter)RenderData_setSet, "Scene link 'set' value", NULL}, + + {"yafrayGIMethod", + (getter)RenderData_getYafrayGIMethod, (setter)RenderData_setYafrayGIMethod, + "Global illumination method", + NULL}, + {"yafrayGIQuality", + (getter)RenderData_getYafrayGIQuality, (setter)RenderData_setYafrayGIQuality, + "Global Illumination quality", + NULL}, + {"yafrayExportToXML", + (getter)RenderData_getYafrayExportToXML, (setter)RenderData_setYafrayExportToXML, + "If true export to an xml file and call yafray instead of plugin", + NULL}, + {"yafrayAutoAntiAliasing", + (getter)RenderData_getYafrayAutoAntiAliasing, (setter)RenderData_setYafrayAutoAntiAliasing, + "Automatic anti-aliasing enabled/disabled", + NULL}, + {"yafrayClampRGB", + (getter)RenderData_getYafrayClampRGB, (setter)RenderData_setYafrayClampRGB, + "Clamp RGB enabled/disabled", + NULL}, + {"yafrayAntiAliasingPasses", + (getter)RenderData_getYafrayAntiAliasingPasses, (setter)RenderData_setYafrayAntiAliasingPasses, + "Number of anti-aliasing passes (0 is no anti-aliasing)", + NULL}, + {"yafrayAntiAliasingSamples", + (getter)RenderData_getYafrayAntiAliasingSamples, (setter)RenderData_setYafrayAntiAliasingSamples, + "Number of samples per pass", + NULL}, + {"yafrayAntiAliasingPixelSize", + (getter)RenderData_getYafrayAntiAliasingPixelSize, (setter)RenderData_setYafrayAntiAliasingPixelSize, + "Anti-aliasing pixel filter size", + NULL}, + {"yafrayAntiAliasingThreshold", + (getter)RenderData_getYafrayAntiAliasingThreshold, (setter)RenderData_setYafrayAntiAliasingThreshold, + "Anti-aliasing threshold", + NULL}, + {"yafrayNumberOfProcessors", + (getter)RenderData_getYafrayNumberOfProcessors, (setter)RenderData_setYafrayNumberOfProcessors, + "Number of processors to use", + NULL}, + {"yafrayGICache", + (getter)RenderData_getYafrayGICache, (setter)RenderData_setYafrayGICache, + "Cache occlusion/irradiance samples (faster)", + NULL}, + {"yafrayGICacheBumpNormals", + (getter)RenderData_getYafrayGICacheBumpNormals, (setter)RenderData_setYafrayGICacheBumpNormals, + "Enable/disable bumpnormals for cache", + NULL}, + {"yafrayGICacheShadowQuality", + (getter)RenderData_getYafrayGICacheShadowQuality, (setter)RenderData_setYafrayGICacheShadowQuality, + "Shadow quality, keep it under 0.95 :-)", + NULL}, + {"yafrayGICachePixelsPerSample", + (getter)RenderData_getYafrayGICachePixelsPerSample, (setter)RenderData_setYafrayGICachePixelsPerSample, + "Maximum number of pixels without samples, the lower the better and slower", + NULL}, + {"yafrayGICacheRefinement", + (getter)RenderData_getYafrayGICacheRefinement, (setter)RenderData_setYafrayGICacheRefinement, + "Threshold to refine shadows EXPERIMENTAL. 1 = no refinement", + NULL}, + {"yafrayGIPhotons", + (getter)RenderData_getYafrayGIPhotons, (setter)RenderData_setYafrayGIPhotons, + "Enable/disable use of global photons to help in GI", + NULL}, + {"yafrayGITunePhotons", + (getter)RenderData_getYafrayGITunePhotons, (setter)RenderData_setYafrayGITunePhotons, + "If true the photonmap is shown directly in the render for tuning", + NULL}, + {NULL,NULL,NULL,NULL,NULL} }; @@ -2373,10 +2795,16 @@ static PyMethodDef BPy_RenderData_methods[] = { "(enum) - get/set the render to one of a few preget/sets"}, {"setYafrayGIQuality", ( PyCFunction ) RenderData_SetYafrayGIQuality, METH_VARARGS, - "(enum) - get/set yafray global Illumination quality"}, + "(enum) - set yafray global Illumination quality"}, + {"getYafrayGIQuality", ( PyCFunction ) RenderData_GetYafrayGIQuality, + METH_VARARGS, + "(enum) - get yafray global Illumination quality"}, {"setYafrayGIMethod", ( PyCFunction ) RenderData_SetYafrayGIMethod, METH_VARARGS, - "(enum) - get/set yafray global Illumination method"}, + "(enum) - set yafray global Illumination method"}, + {"getYafrayGIMethod", ( PyCFunction ) RenderData_GetYafrayGIMethod, + METH_VARARGS, + "(enum) - get yafray global Illumination method"}, {"yafrayGIPower", ( PyCFunction ) RenderData_YafrayGIPower, METH_VARARGS, "(float) - get/set GI lighting intensity scale"}, @@ -2403,7 +2831,7 @@ static PyMethodDef BPy_RenderData_methods[] = { "(float) - get/set radius to search for photons to mix (blur)"}, {"yafrayGIPhotonMixCount", ( PyCFunction ) RenderData_YafrayGIPhotonMixCount, METH_VARARGS, - "(int) - get/set number of photons to shoot"}, + "(int) - get/set number of photons to mix"}, {"enableYafrayGITunePhotons", ( PyCFunction ) RenderData_EnableYafrayGITunePhotons, METH_VARARGS, "(bool) - enable/disable show the photonmap directly in the render for tuning"}, @@ -2666,6 +3094,7 @@ PyObject *Render_Init( void ) PyModule_AddIntConstant( submodule, "HIGH", PY_HIGH ); PyModule_AddIntConstant( submodule, "HIGHER", PY_HIGHER ); PyModule_AddIntConstant( submodule, "BEST", PY_BEST ); + PyModule_AddIntConstant( submodule, "USEAOSETTINGS", PY_USEAOSETTINGS ); PyModule_AddIntConstant( submodule, "SKYDOME", PY_SKYDOME ); PyModule_AddIntConstant( submodule, "GIFULL", PY_FULL ); PyModule_AddIntConstant( submodule, "OPENEXR", R_OPENEXR ); |