Index: README
===================================================================
--- README	(revision 64)
+++ README	(working copy)
@@ -24,7 +24,7 @@
 -------------------------------------Links--------------------------------------
 
 Getting Involved:
-http://www.blender.org/docs/get_involved.html
+http://www.blender.org/community/get-involved/
 
 Community:
 http://www.blender3d.org/Community/
Index: source/blender/python/api2_2x/doc/Render.py
===================================================================
--- source/blender/python/api2_2x/doc/Render.py	(revision 64)
+++ source/blender/python/api2_2x/doc/Render.py	(working copy)
@@ -105,14 +105,15 @@
 @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 @@
   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,8 +862,23 @@
         - 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):
     """
     Set yafray global Illumination method.
@@ -836,6 +889,17 @@
         - 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.
Index: source/blender/python/api2_2x/sceneRender.c
===================================================================
--- source/blender/python/api2_2x/sceneRender.c	(revision 64)
+++ source/blender/python/api2_2x/sceneRender.c	(working copy)
@@ -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 @@
 #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 @@
 	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 @@
 	Py_RETURN_NONE;
 }
 
+/*
+
 PyObject *RenderData_SetYafrayGIQuality( BPy_RenderData * self,
 					 PyObject * args )
 {
@@ -1077,7 +1159,277 @@
 	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 )
 {
 	if( self->renderContext->GImethod > 0 ) {
@@ -1103,7 +1455,7 @@
 	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 @@
 	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 @@
 	    && 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 @@
 	    && 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 @@
 	 (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 @@
 	 "(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 @@
 	 "(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 @@
 	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 );
Index: source/blender/src/buttons_scene.c
===================================================================
--- source/blender/src/buttons_scene.c	(revision 64)
+++ source/blender/src/buttons_scene.c	(working copy)
@@ -1677,7 +1677,8 @@
 				uiDefButI(block, NUM, B_DIFF, "Count:", 170,85,140,20, &G.scene->r.GIphotoncount, 
 						0, 10000000, 10, 10, "Number of photons to shoot");
 				if(G.scene->r.GIphotonradius==0.0) G.scene->r.GIphotonradius=1.0;
-				uiDefButF(block, NUMSLI, B_DIFF,"Radius:", 170,60,140,20,	&(G.scene->r.GIphotonradius), 
+				/* (dietrich) changed NUMSLI to NUM as there was no place to display the value */
+				uiDefButF(block, NUM /*SLI*/, B_DIFF,"Radius:", 170,60,140,20,	&(G.scene->r.GIphotonradius), 
 						0.00001, 100.0 ,0,0, "Radius to search for photons to mix (blur)");
 				if(G.scene->r.GImixphotons==0) G.scene->r.GImixphotons=100;
 				uiDefButI(block, NUM, B_DIFF, "MixCount:", 170,35,140,20, &G.scene->r.GImixphotons,