- finalize scene.render module

- added some constants for the rendering module to blender module
- moved rendering functions from scene to scene.render
- rendering functions called from renderData struct instead of from scene directly
- getRenderingContext() returns rendering data struct
- deprecation of old scene functions
- some formatting/documentation of code

7 files changed, 1197 insertions, 1411 deletions

diff --git a/source/blender/python/api2_2x/Blender.c b/source/blender/python/api2_2x/Blender.c
index 4671fed9e60..09ec4764fbe 100644
--- a/source/blender/python/api2_2x/Blender.c
+++ b/source/blender/python/api2_2x/Blender.c
@@ -237,4 +237,7 @@ void M_Blender_Init (void)
 	PyDict_SetItemString (dict, "Noise",		Noise_Init());
 	PyDict_SetItemString (dict, "Mathutils",Mathutils_Init());
 	PyDict_SetItemString (dict, "Library",  Library_Init());
+
+	PyModule_AddIntConstant(module, "TRUE",  1);
+	PyModule_AddIntConstant(module, "FALSE",  0);
 }
diff --git a/source/blender/python/api2_2x/Scene.c b/source/blender/python/api2_2x/Scene.c
index 30718092391..4e978facf40 100644
--- a/source/blender/python/api2_2x/Scene.c
+++ b/source/blender/python/api2_2x/Scene.c
@@ -42,241 +42,36 @@
 
 #include "Object.h"
 #include "bpy_types.h"
+#include "constant.h"
+#include "gen_utils.h"
+#include "sceneRender.h"
 
 #include "Scene.h"
 
 static Base *EXPP_Scene_getObjectBase (Scene *scene, Object *object);
 PyObject *M_Object_Get (PyObject *self, PyObject *args); /* from Object.c */
 
-/*****************************************************************************/
-/* Python BPy_Scene defaults:												 */
-/*****************************************************************************/
+//----------------------------------- Python BPy_Scene defaults----------------------------------------------------------										
 #define EXPP_SCENE_FRAME_MAX 18000
 #define EXPP_SCENE_RENDER_WINRESOLUTION_MIN 4
 #define EXPP_SCENE_RENDER_WINRESOLUTION_MAX 10000
-
-/*****************************************************************************/
-/* Python API function prototypes for the Scene module.						*/
-/*****************************************************************************/
-static PyObject *M_Scene_New (PyObject *self, PyObject *args,
-															 PyObject *keywords);
+//-----------------------Python API function prototypes for the Scene module------------------------------------
+static PyObject *M_Scene_New (PyObject *self, PyObject *args,	 PyObject *keywords);
 static PyObject *M_Scene_Get (PyObject *self, PyObject *args);
 static PyObject *M_Scene_GetCurrent (PyObject *self);
 static PyObject *M_Scene_Unlink (PyObject *self, PyObject *arg);
-
-/*****************************************************************************/
-/* The following string definitions are used for documentation strings.		*/
-/* In Python these will be written to the console when doing a				*/
-/* Blender.Scene.__doc__													*/
-/*****************************************************************************/
+//-----------------------Scene module doc strings---------------------------------------------------------------------------
 static char M_Scene_doc[] =
 "The Blender.Scene submodule";
 static char M_Scene_New_doc[] =
 "(name = 'Scene') - Create a new Scene called 'name' in Blender.";
 static char M_Scene_Get_doc[] =
-"(name = None) - Return the scene called 'name'.\n\
-					 If 'name' is None, return a list with all Scenes.";
+"(name = None) - Return the scene called 'name'. If 'name' is None, return a list with all Scenes.";
 static char M_Scene_GetCurrent_doc[] =
 "() - Return the currently active Scene in Blender.";
 static char M_Scene_Unlink_doc[] =
-"(scene) - Unlink (delete) scene 'Scene' from Blender.\n\
-(scene) is of type Blender scene.";
-// Python BPy_Scene rendering declarations:						
-static char M_Scene_Render_doc[] =
-"() - render the scene\n";
-static char M_Scene_RenderAnim_doc[] =
-"() - render a sequence\n";
-static char M_Scene_CloseRenderWindow_doc[] =
-"() - close the rendering window\n";
-static char M_Scene_Play_doc[] =
-"() - play animation of rendered images/avi (searches Pics: field)\n";
-static char M_Scene_SetRenderPath_doc[] =
-"() - get/set the path to output the rendered images to\n";
-static char M_Scene_GetRenderPath_doc[] =
-"() - get the path to directory where rendered images will go\n";
-static char M_Scene_SetBackbufPath_doc[] =
-"() - get/set the path to a background image and load it\n";
-static char M_Scene_GetBackbufPath_doc[] =
-"() - get the path to background image file\n";
-static char M_Scene_EnableBackbuf_doc[] =
-"() - enable/disable the backbuf image\n";
-static char M_Scene_SetFtypePath_doc[] =
-"() - get/set the path to output the Ftype file\n";
-static char M_Scene_GetFtypePath_doc[] =
-"() - get the path to Ftype file\n";
-static char M_Scene_EnableExtensions_doc[] =
-"() - enable/disable windows extensions for output files\n";
-static char M_Scene_EnableSequencer_doc[] =
-"() - enable/disable Do Sequence\n";
-static char M_Scene_EnableRenderDaemon_doc[] =
-"() - enable/disable Scene daemon\n";
-static char M_Scene_SetRenderWinPos_doc[] =
-"() - position the rendering window in around the edge of the screen\n";
-static char M_Scene_EnableDispView_doc[] =
-"() - enable Sceneing in view\n";
-static char M_Scene_EnableDispWin_doc[] =
-"() - enable Sceneing in new window\n";
-static char M_Scene_EnableToonShading_doc[] =
-"() - enable/disable Edge rendering\n";
-static char M_Scene_EdgeIntensity_doc[] =
-"() - get/set edge intensity for toon shading\n";
-static char M_Scene_EnableEdgeShift_doc[] =
-"() - with the unified renderer the outlines are shifted a bit.\n";
-static char M_Scene_EnableEdgeAll_doc[] =
-"() - also consider transparent faces for edge-rendering with the unified renderer\n";
-static char M_Scene_SetEdgeColor_doc[] =
-"() - set the edge color for toon shading - Red,Green,Blue expected.\n";
-static char M_Scene_GetEdgeColor_doc[] =
-"() - get the edge color for toon shading - Red,Green,Blue expected.\n";
-static char M_Scene_EdgeAntiShift_doc[] =
-"() - with the unified renderer to reduce intensity on boundaries.\n";
-static char M_Scene_EnableOversampling_doc[] =
-"() - enable/disable oversampling (anit-aliasing).\n";
-static char M_Scene_SetOversamplingLevel_doc[] =
-"() - get/set the level of oversampling (anit-aliasing).\n";
-static char M_Scene_EnableMotionBlur_doc[] =
-"() - enable/disable MBlur.\n";
-static char M_Scene_MotionBlurLevel_doc[] =
-"() - get/set the length of shutter time for motion blur.\n";
-static char M_Scene_PartsX_doc[] =
-"() - get/set the number of parts to divide the render in the X direction\n";
-static char M_Scene_PartsY_doc[] =
-"() - get/set the number of parts to divide the render in the Y direction\n";
-static char M_Scene_EnableSky_doc[] =
-"() - enable render background with sky\n";
-static char M_Scene_EnablePremultiply_doc[] =
-"() - enable premultiply alpha\n";
-static char M_Scene_EnableKey_doc[] =
-"() - enable alpha and colour values remain unchanged\n";
-static char M_Scene_EnableShadow_doc[] =
-"() - enable/disable shadow calculation\n";
-static char M_Scene_EnableEnvironmentMap_doc[] =
-"() - enable/disable environment map rendering\n";
-static char M_Scene_EnableRayTracing_doc[] =
-"() - enable/disable ray tracing\n";
-static char M_Scene_EnableRadiosityRender_doc[] =
-"() - enable/disable radiosity rendering\n";
-static char M_Scene_EnablePanorama_doc[] =
-"() - enable/disable panorama rendering (output width is multiplied by Xparts)\n";
-static char M_Scene_SetRenderWinSize_doc[] =
-"() - get/set the size of the render window\n";
-static char M_Scene_EnableFieldRendering_doc[] =
-"() - enable/disable field rendering\n";
-static char M_Scene_EnableOddFieldFirst_doc[] =
-"() - enable/disable Odd field first rendering (Default: Even field)\n";
-static char M_Scene_EnableFieldTimeDisable_doc[] =
-"() - enable/disable time difference in field calculations\n";
-static char M_Scene_EnableGaussFilter_doc[] =
-"() - enable/disable Gauss sampling filter for antialiasing\n";
-static char M_Scene_EnableBorderRender_doc[] =
-"() - enable/disable small cut-out rendering\n";
-static char M_Scene_EnableGammaCorrection_doc[] =
-"() - enable/disable gamma correction\n";
-static char M_Scene_GaussFilterSize_doc[] =
-"() - get/sets the Gauss filter size\n";
-static char M_Scene_StartFrame_doc[] =
-"() - get/set the starting frame for sequence rendering\n";
-static char M_Scene_EndFrame_doc[] =
-"() - get/set the ending frame for sequence rendering\n";
-static char M_Scene_ImageSizeX_doc[] =
-"() - get/set the image width in pixels\n";
-static char M_Scene_ImageSizeY_doc[] =
-"() - get/set the image height in pixels\n";
-static char M_Scene_AspectRatioX_doc[] =
-"() - get/set the horizontal aspect ratio\n";
-static char M_Scene_AspectRatioY_doc[] =
-"() - get/set the vertical aspect ratio\n";
-static char M_Scene_SetRenderer_doc[] =
-"() - get/set which renderer to render the output\n";
-static char M_Scene_EnableCropping_doc[] =
-"() - enable/disable exclusion of border rendering from total image\n";
-static char M_Scene_SetImageType_doc[] =
-"() - get/set the type of image to output from the render\n";
-static char M_Scene_Quality_doc[] =
-"() - get/set quality get/setting for JPEG images, AVI Jpeg and SGI movies\n";
-static char M_Scene_FramesPerSec_doc[] =
-"() - get/set frames per second\n";
-static char M_Scene_EnableGrayscale_doc[] =
-"() - images are saved with BW (grayscale) data\n";
-static char M_Scene_EnableRGBColor_doc[] =
-"() - images are saved with RGB (color) data\n";
-static char M_Scene_EnableRGBAColor_doc[] =
-"() - images are saved with RGB and Alpha data (if supported)\n";
-static char M_Scene_SizePreset_doc[] =
-"() - get/set the render to one of a few preget/sets\n";
-static char M_Scene_EnableUnifiedRenderer_doc[] =
-"() - use the unified renderer\n";
-static char M_Scene_SetYafrayGIQuality_doc[] =
-"() - get/set yafray global Illumination quality\n";
-static char M_Scene_SetYafrayGIMethod_doc[] =
-"() - get/set yafray global Illumination method\n";
-static char M_Scene_YafrayGIPower_doc[] =
-"() - get/set GI lighting intensity scale\n";
-static char M_Scene_YafrayGIDepth_doc[] =
-"() - get/set number of bounces of the indirect light\n";
-static char M_Scene_YafrayGICDepth_doc[] =
-"() - get/set number of bounces inside objects (for caustics)\n";
-static char M_Scene_EnableYafrayGICache_doc[] =
-"() - enable/disable cache irradiance samples (faster)\n";
-static char M_Scene_EnableYafrayGIPhotons_doc[] =
-"() - enable/disable use global photons to help in GI\n";
-static char M_Scene_YafrayGIPhotonCount_doc[] =
-"() - get/set number of photons to shoot\n";
-static char M_Scene_YafrayGIPhotonRadius_doc[] =
-"() - get/set radius to search for photons to mix (blur)\n";
-static char M_Scene_YafrayGIPhotonMixCount_doc[] =
-"() - get/set number of photons to shoot\n";
-static char M_Scene_EnableYafrayGITunePhotons_doc[] =
-"() - enable/disable show the photonmap directly in the render for tuning\n";
-static char M_Scene_YafrayGIShadowQuality_doc[] =
-"() - get/set the shadow quality, keep it under 0.95\n";
-static char M_Scene_YafrayGIPixelsPerSample_doc[] =
-"() - get/set maximum number of pixels without samples, the lower the better and slower\n";
-static char M_Scene_EnableYafrayGIGradient_doc[] =
-"() - enable/disable try to smooth lighting using a gradient\n";
-static char M_Scene_YafrayGIRefinement_doc[] =
-"() - get/setthreshold to refine shadows EXPERIMENTAL. 1 = no refinement\n";
-static char M_Scene_YafrayRayBias_doc[] =
-"() - get/set shadow ray bias to avoid self shadowing\n";
-static char M_Scene_YafrayRayDepth_doc[] =
-"() - get/set maximum render ray depth from the camera\n";
-static char M_Scene_YafrayGamma_doc[] =
-"() - get/set gamma correction, 1 is off\n";
-static char M_Scene_YafrayExposure_doc[] =
-"() - get/set exposure adjustment, 0 is off\n";
-static char M_Scene_YafrayProcessorCount_doc[] =
-"() - get/set number of processors to use\n";
-static char M_Scene_EnableGameFrameStretch_doc[] =
-"() - enble stretch or squeeze the viewport to fill the display window\n";
-static char M_Scene_EnableGameFrameExpose_doc[] =
-"() - enable show the entire viewport in the display window, viewing more horizontally or vertically\n";
-static char M_Scene_EnableGameFrameBars_doc[] =
-"() - enable show the entire viewport in the display window, using bar horizontally or vertically\n";
-static char M_Scene_SetGameFrameColor_doc[] =
-"() - set the red, green, blue component of the bars\n";
-static char M_Scene_GetGameFrameColor_doc[] =
-"() - get the red, green, blue component of the bars\n";
-static char M_Scene_GammaLevel_doc[] =
-"() - get/set the gamma value for blending oversampled images (1.0 = no correction\n";
-static char M_Scene_PostProcessAdd_doc[] =
-"() - get/set post processing add\n";
-static char M_Scene_PostProcessMultiply_doc[] =
-"() - get/set post processing multiply\n";
-static char M_Scene_PostProcessGamma_doc[] =
-"() - get/set post processing gamma\n";
-static char M_Scene_SGIMaxsize_doc[] =
-"() - get/set maximum size per frame to save in an SGI movie\n";
-static char M_Scene_EnableSGICosmo_doc[] =
-"() - enable/disable attempt to save SGI movies using Cosmo hardware\n";
-static char M_Scene_OldMapValue_doc[] =
-"() - get/set specify old map value in frames\n";
-static char M_Scene_NewMapValue_doc[] =
-"() - get/set specify new map value in frames\n";
-
-
-/*****************************************************************************/
-/* Python method structure definition for Blender.Scene module:							 */
-/*****************************************************************************/
+"(scene) - Unlink (delete) scene 'Scene' from Blender. (scene) is of type Blender scene.";
+//----------------------Scene module method def---------------------------------------------------------------------------
 struct PyMethodDef M_Scene_methods[] = {
 	{"New",(PyCFunction)M_Scene_New, METH_VARARGS|METH_KEYWORDS,
 					M_Scene_New_doc},
@@ -288,47 +83,38 @@ struct PyMethodDef M_Scene_methods[] = {
 														 METH_NOARGS,  M_Scene_GetCurrent_doc},
 	{"Unlink",			M_Scene_Unlink,			 METH_VARARGS, M_Scene_Unlink_doc},
 	{"unlink",			M_Scene_Unlink,			 METH_VARARGS, M_Scene_Unlink_doc},
-	{"CloseRenderWindow",(PyCFunction)M_Render_CloseRenderWindow, METH_NOARGS,
-				M_Scene_CloseRenderWindow_doc},
-	{"EnableDispView",(PyCFunction)M_Render_EnableDispView, METH_NOARGS,
-				M_Scene_EnableDispView_doc},
-	{"EnableDispWin",(PyCFunction)M_Render_EnableDispWin, METH_NOARGS,
-				M_Scene_EnableDispWin_doc},
-	{"SetRenderWinPos",(PyCFunction)M_Render_SetRenderWinPos, METH_VARARGS,
-				M_Scene_SetRenderWinPos_doc}, 
-	{"EnableEdgeShift",(PyCFunction)M_Render_EnableEdgeShift, METH_VARARGS,
-				M_Scene_EnableEdgeShift_doc},
-	{"EnableEdgeAll",(PyCFunction)M_Render_EnableEdgeAll, METH_VARARGS,
-				M_Scene_EnableEdgeAll_doc},
 	{NULL, NULL, 0, NULL}
 };
-
-/*****************************************************************************/
-/* Python BPy_Scene methods declarations:																		 */
-/*****************************************************************************/
+//-----------------------BPy_Scene  method declarations-----------------------------------------------------------------
 static PyObject *Scene_getName(BPy_Scene *self);
 static PyObject *Scene_setName(BPy_Scene *self, PyObject *arg);
-static PyObject *Scene_getWinSize(BPy_Scene *self);
-static PyObject *Scene_setWinSize(BPy_Scene *self, PyObject *arg);
 static PyObject *Scene_copy(BPy_Scene *self, PyObject *arg);
-static PyObject *Scene_startFrame(BPy_Scene *self, PyObject *args);
-static PyObject *Scene_endFrame(BPy_Scene *self, PyObject *args);
-static PyObject *Scene_currentFrame(BPy_Scene *self, PyObject *args);
-static PyObject *Scene_frameSettings (BPy_Scene *self, PyObject *args);
 static PyObject *Scene_makeCurrent(BPy_Scene *self);
 static PyObject *Scene_update(BPy_Scene *self, PyObject *args);
 static PyObject *Scene_link(BPy_Scene *self, PyObject *args);
 static PyObject *Scene_unlink(BPy_Scene *self, PyObject *args);
-static PyObject *Scene_getRenderdir(BPy_Scene *self);
-static PyObject *Scene_getBackbufdir(BPy_Scene *self);
 static PyObject *Scene_getChildren(BPy_Scene *self);
 static PyObject *Scene_getCurrentCamera(BPy_Scene *self);
 static PyObject *Scene_setCurrentCamera(BPy_Scene *self, PyObject *args);
+static PyObject *Scene_getRenderingContext(BPy_Scene *self);
 
+//deprecated methods
+static PyObject *Scene_currentFrame(BPy_Scene *self, PyObject *args);
+static PyObject *Scene_getWinSize(BPy_Scene *self);
+static PyObject *Scene_setWinSize(BPy_Scene *self, PyObject *arg);
+static PyObject *Scene_startFrame(BPy_Scene *self, PyObject *args);
+static PyObject *Scene_endFrame(BPy_Scene *self, PyObject *args);
+static PyObject *Scene_frameSettings (BPy_Scene *self, PyObject *args);
+static PyObject *Scene_getRenderdir(BPy_Scene *self);
+static PyObject *Scene_getBackbufdir(BPy_Scene *self);
 
-/*****************************************************************************/
-/* Python BPy_Scene methods table:											*/
-/*****************************************************************************/
+//internal
+static void Scene_dealloc (BPy_Scene *self);
+static int Scene_setAttr (BPy_Scene *self, char *name, PyObject *v);
+static int Scene_compare (BPy_Scene *a, BPy_Scene *b);
+static PyObject *Scene_getAttr (BPy_Scene *self, char *name);
+static PyObject *Scene_repr (BPy_Scene *self);
+//-----------------------BPy_Scene method def-------------------------------------------------------------------------------
 static PyMethodDef BPy_Scene_methods[] = {
  /* name, method, flags, doc */
 	{"getName", (PyCFunction)Scene_getName, METH_NOARGS,
@@ -340,9 +126,6 @@ static PyMethodDef BPy_Scene_methods[] = {
 	"The optional argument duplicate_objects defines how the scene\n"
 	"children are duplicated:\n\t0: Link Objects\n\t1: Link Object Data"
 	"\n\t2: Full copy\n"},
-	{"currentFrame", (PyCFunction)Scene_currentFrame, METH_VARARGS,
-					"(frame) - If frame is given, the current frame is set and"
-									"\nreturned in any case"},
 	{"makeCurrent", (PyCFunction)Scene_makeCurrent, METH_NOARGS,
 					"() - Make self the current scene"},
 	{"update", (PyCFunction)Scene_update, METH_VARARGS,
@@ -359,185 +142,6 @@ static PyMethodDef BPy_Scene_methods[] = {
 					"() - Return current active Camera"},
 	{"setCurrentCamera", (PyCFunction)Scene_setCurrentCamera, METH_VARARGS,
 					"() - Set the currently active Camera"},
-	//RENDERING METHODS
-	{"render",(PyCFunction)M_Render_Render, METH_NOARGS,
-			M_Scene_Render_doc},
-	{"renderAnim",(PyCFunction)M_Render_RenderAnim, METH_NOARGS,
-				M_Scene_RenderAnim_doc},
-	{"play",(PyCFunction)M_Render_Play, METH_NOARGS,
-				M_Scene_Play_doc},
-	{"setRenderPath",(PyCFunction)M_Render_SetRenderPath, METH_VARARGS,
-				M_Scene_SetRenderPath_doc},
-	{"getRenderPath",(PyCFunction)M_Render_GetRenderPath, METH_NOARGS,
-				M_Scene_GetRenderPath_doc},
-	{"setBackbufPath",(PyCFunction)M_Render_SetBackbufPath, METH_VARARGS,
-				M_Scene_SetBackbufPath_doc},
-	{"getBackbufPath",(PyCFunction)M_Render_GetBackbufPath, METH_NOARGS,
-				M_Scene_GetBackbufPath_doc},
-	{"enableBackbuf",(PyCFunction)M_Render_EnableBackbuf, METH_VARARGS,
-				M_Scene_EnableBackbuf_doc},
-	{"setFtypePath",(PyCFunction)M_Render_SetFtypePath, METH_VARARGS,
-				M_Scene_SetFtypePath_doc},
-	{"getFtypePath",(PyCFunction)M_Render_GetFtypePath, METH_NOARGS,
-				M_Scene_GetFtypePath_doc},
-	{"enableExtensions",(PyCFunction)M_Render_EnableExtensions, METH_VARARGS,
-				M_Scene_EnableExtensions_doc},
-	{"enableSequencer",(PyCFunction)M_Render_EnableSequencer, METH_VARARGS,
-				M_Scene_EnableSequencer_doc},
-	{"enableRenderDaemon",(PyCFunction)M_Render_EnableRenderDaemon, METH_VARARGS,
-				M_Scene_EnableRenderDaemon_doc},
-	{"enableToonShading",(PyCFunction)M_Render_EnableToonShading, METH_VARARGS,
-				M_Scene_EnableToonShading_doc},
-	{"edgeIntensity",(PyCFunction)M_Render_EdgeIntensity, METH_VARARGS,
-				M_Scene_EdgeIntensity_doc},
-	{"setEdgeColor",(PyCFunction)M_Render_SetEdgeColor, METH_VARARGS,
-				M_Scene_SetEdgeColor_doc},
-	{"getEdgeColor",(PyCFunction)M_Render_GetEdgeColor, METH_VARARGS,
-				M_Scene_GetEdgeColor_doc},
-	{"edgeAntiShift",(PyCFunction)M_Render_EdgeAntiShift, METH_VARARGS,
-				M_Scene_EdgeAntiShift_doc},
-	{"enableOversampling",(PyCFunction)M_Render_EnableOversampling, METH_VARARGS,
-				M_Scene_EnableOversampling_doc},
-	{"setOversamplingLevel",(PyCFunction)M_Render_SetOversamplingLevel, METH_VARARGS,
-				M_Scene_SetOversamplingLevel_doc},
-	{"enableMotionBlur",(PyCFunction)M_Render_EnableMotionBlur, METH_VARARGS,
-				M_Scene_EnableMotionBlur_doc},
-	{"motionBlurLevel",(PyCFunction)M_Render_MotionBlurLevel, METH_VARARGS,
-				M_Scene_MotionBlurLevel_doc},
-	{"partsX",(PyCFunction)M_Render_PartsX, METH_VARARGS,
-				M_Scene_PartsX_doc},
-	{"partsY",(PyCFunction)M_Render_PartsY, METH_VARARGS,
-				M_Scene_PartsY_doc},
-	{"enableSky",(PyCFunction)M_Render_EnableSky, METH_NOARGS,
-				M_Scene_EnableSky_doc},
-	{"enablePremultiply",(PyCFunction)M_Render_EnablePremultiply, METH_NOARGS,
-				M_Scene_EnablePremultiply_doc},
-	{"enableKey",(PyCFunction)M_Render_EnableKey, METH_NOARGS,
-				M_Scene_EnableKey_doc}, 
-	{"enableShadow",(PyCFunction)M_Render_EnableShadow, METH_VARARGS,
-				M_Scene_EnableShadow_doc},
-	{"enablePanorama",(PyCFunction)M_Render_EnablePanorama, METH_VARARGS,
-				M_Scene_EnablePanorama_doc},
-	{"enableEnvironmentMap",(PyCFunction)M_Render_EnableEnvironmentMap, METH_VARARGS,
-				M_Scene_EnableEnvironmentMap_doc},
-	{"enableRayTracing",(PyCFunction)M_Render_EnableRayTracing, METH_VARARGS,
-				M_Scene_EnableRayTracing_doc},
-	{"enableRadiosityRender",(PyCFunction)M_Render_EnableRadiosityRender, METH_VARARGS,
-				M_Scene_EnableRadiosityRender_doc},
-	{"setRenderWinSize",(PyCFunction)M_Render_SetRenderWinSize, METH_VARARGS,
-				M_Scene_SetRenderWinSize_doc},
-	{"enableFieldRendering",(PyCFunction)M_Render_EnableFieldRendering, METH_VARARGS,
-				M_Scene_EnableFieldRendering_doc},
-	{"enableOddFieldFirst",(PyCFunction)M_Render_EnableOddFieldFirst, METH_VARARGS,
-				M_Scene_EnableOddFieldFirst_doc},
-	{"enableFieldTimeDisable",(PyCFunction)M_Render_EnableFieldTimeDisable, METH_VARARGS,
-				M_Scene_EnableFieldTimeDisable_doc},
-	{"enableGaussFilter",(PyCFunction)M_Render_EnableGaussFilter, METH_VARARGS,
-				M_Scene_EnableGaussFilter_doc},
-	{"enableBorderRender",(PyCFunction)M_Render_EnableBorderRender, METH_VARARGS,
-				M_Scene_EnableBorderRender_doc},
-	{"enableGammaCorrection",(PyCFunction)M_Render_EnableGammaCorrection, METH_VARARGS,
-				M_Scene_EnableGammaCorrection_doc},
-	{"gaussFilterSize",(PyCFunction)M_Render_GaussFilterSize, METH_VARARGS,
-				M_Scene_GaussFilterSize_doc},
-	{"startFrame",(PyCFunction)M_Render_StartFrame, METH_VARARGS,
-				M_Scene_StartFrame_doc},
-	{"endFrame",(PyCFunction)M_Render_EndFrame, METH_VARARGS,
-				M_Scene_EndFrame_doc},
-	{"imageSizeX",(PyCFunction)M_Render_ImageSizeX, METH_VARARGS,
-				M_Scene_ImageSizeX_doc},
-	{"imageSizeY",(PyCFunction)M_Render_ImageSizeY, METH_VARARGS,
-				M_Scene_ImageSizeY_doc},
-	{"aspectRatioX",(PyCFunction)M_Render_AspectRatioX, METH_VARARGS,
-				M_Scene_AspectRatioX_doc},
-	{"aspectRatioY",(PyCFunction)M_Render_AspectRatioY, METH_VARARGS,
-				M_Scene_AspectRatioY_doc},
-	{"setRenderer",(PyCFunction)M_Render_SetRenderer, METH_VARARGS,
-				M_Scene_SetRenderer_doc},
-	{"enableCropping",(PyCFunction)M_Render_EnableCropping, METH_VARARGS,
-				M_Scene_EnableCropping_doc},
-	{"setImageType",(PyCFunction)M_Render_SetImageType, METH_VARARGS,
-				M_Scene_SetImageType_doc},
-	{"quality",(PyCFunction)M_Render_Quality, METH_VARARGS,
-				M_Scene_Quality_doc},
-	{"framesPerSec",(PyCFunction)M_Render_FramesPerSec, METH_VARARGS,
-				M_Scene_FramesPerSec_doc},
-	{"enableGrayscale",(PyCFunction)M_Render_EnableGrayscale, METH_NOARGS,
-				M_Scene_EnableGrayscale_doc},
-	{"enableRGBColor",(PyCFunction)M_Render_EnableRGBColor, METH_NOARGS,
-				M_Scene_EnableRGBColor_doc},
-	{"enableRGBAColor",(PyCFunction)M_Render_EnableRGBAColor, METH_NOARGS,
-				M_Scene_EnableRGBAColor_doc},
-	{"sizePreset",(PyCFunction)M_Render_SizePreset, METH_VARARGS,
-				M_Scene_SizePreset_doc},
-	{"enableUnifiedRenderer",(PyCFunction)M_Render_EnableUnifiedRenderer, METH_VARARGS,
-				M_Scene_EnableUnifiedRenderer_doc},
-	{"setYafrayGIQuality",(PyCFunction)M_Render_SetYafrayGIQuality, METH_VARARGS,
-				M_Scene_SetYafrayGIQuality_doc},
-	{"setYafrayGIMethod",(PyCFunction)M_Render_SetYafrayGIMethod, METH_VARARGS,
-				M_Scene_SetYafrayGIMethod_doc},
-	{"yafrayGIPower",(PyCFunction)M_Render_YafrayGIPower, METH_VARARGS,
-				M_Scene_YafrayGIPower_doc},
-	{"yafrayGIDepth",(PyCFunction)M_Render_YafrayGIDepth, METH_VARARGS,
-				M_Scene_YafrayGIDepth_doc},
-	{"yafrayGICDepth",(PyCFunction)M_Render_YafrayGICDepth, METH_VARARGS,
-				M_Scene_YafrayGICDepth_doc},
-	{"enableYafrayGICache",(PyCFunction)M_Render_EnableYafrayGICache, METH_VARARGS,
-				M_Scene_EnableYafrayGICache_doc},
-	{"enableYafrayGIPhotons",(PyCFunction)M_Render_EnableYafrayGIPhotons, METH_VARARGS,
-				M_Scene_EnableYafrayGIPhotons_doc},
-	{"yafrayGIPhotonCount",(PyCFunction)M_Render_YafrayGIPhotonCount, METH_VARARGS,
-				M_Scene_YafrayGIPhotonCount_doc},
-	{"yafrayGIPhotonRadius",(PyCFunction)M_Render_YafrayGIPhotonRadius, METH_VARARGS,
-				M_Scene_YafrayGIPhotonRadius_doc},
-	{"yafrayGIPhotonMixCount",(PyCFunction)M_Render_YafrayGIPhotonMixCount, METH_VARARGS,
-				M_Scene_YafrayGIPhotonMixCount_doc},
-	{"enableYafrayGITunePhotons",(PyCFunction)M_Render_EnableYafrayGITunePhotons, METH_VARARGS,
-				M_Scene_EnableYafrayGITunePhotons_doc},
-	{"yafrayGIShadowQuality",(PyCFunction)M_Render_YafrayGIShadowQuality, METH_VARARGS,
-				M_Scene_YafrayGIShadowQuality_doc},
-	{"yafrayGIPixelsPerSample",(PyCFunction)M_Render_YafrayGIPixelsPerSample, METH_VARARGS,
-				M_Scene_YafrayGIPixelsPerSample_doc},
-	{"enableYafrayGIGradient",(PyCFunction)M_Render_EnableYafrayGIGradient, METH_VARARGS,
-				M_Scene_EnableYafrayGIGradient_doc},
-	{"yafrayGIRefinement",(PyCFunction)M_Render_YafrayGIRefinement, METH_VARARGS,
-				M_Scene_YafrayGIRefinement_doc},
-	{"yafrayRayBias",(PyCFunction)M_Render_YafrayRayBias, METH_VARARGS,
-				M_Scene_YafrayRayBias_doc},
-	{"yafrayRayDepth",(PyCFunction)M_Render_YafrayRayDepth, METH_VARARGS,
-				M_Scene_YafrayRayDepth_doc},
-	{"yafrayGamma",(PyCFunction)M_Render_YafrayGamma, METH_VARARGS,
-				M_Scene_YafrayGamma_doc},
-	{"yafrayExposure",(PyCFunction)M_Render_YafrayExposure, METH_VARARGS,
-				M_Scene_YafrayExposure_doc},
-	{"yafrayProcessorCount",(PyCFunction)M_Render_YafrayProcessorCount, METH_VARARGS,
-				M_Scene_YafrayProcessorCount_doc},
-	{"enableGameFrameStretch",(PyCFunction)M_Render_EnableGameFrameStretch, METH_NOARGS,
-				M_Scene_EnableGameFrameStretch_doc},
-	{"enableGameFrameExpose",(PyCFunction)M_Render_EnableGameFrameExpose, METH_NOARGS,
-				M_Scene_EnableGameFrameExpose_doc},
-	{"enableGameFrameBars",(PyCFunction)M_Render_EnableGameFrameBars, METH_NOARGS,
-				M_Scene_EnableGameFrameBars_doc},
-	{"setGameFrameColor",(PyCFunction)M_Render_SetGameFrameColor, METH_VARARGS,
-				M_Scene_SetGameFrameColor_doc},
-	{"getGameFrameColor",(PyCFunction)M_Render_GetGameFrameColor, METH_VARARGS,
-				M_Scene_GetGameFrameColor_doc},
-	{"gammaLevel",(PyCFunction)M_Render_GammaLevel, METH_VARARGS,
-				M_Scene_GammaLevel_doc},
-	{"postProcessAdd",(PyCFunction)M_Render_PostProcessAdd, METH_VARARGS,
-				M_Scene_PostProcessAdd_doc},
-	{"postProcessMultiply",(PyCFunction)M_Render_PostProcessMultiply, METH_VARARGS,
-				M_Scene_PostProcessMultiply_doc},
-	{"postProcessGamma",(PyCFunction)M_Render_PostProcessGamma, METH_VARARGS,
-				M_Scene_PostProcessGamma_doc},
- 	{"SGIMaxsize",(PyCFunction)M_Render_SGIMaxsize, METH_VARARGS,
-				M_Scene_SGIMaxsize_doc},
-	{"enableSGICosmo",(PyCFunction)M_Render_EnableSGICosmo, METH_VARARGS,
-				M_Scene_EnableSGICosmo_doc},
-	{"oldMapValue",(PyCFunction)M_Render_OldMapValue, METH_VARARGS,
-				M_Scene_OldMapValue_doc},
-	{"newMapValue",(PyCFunction)M_Render_NewMapValue, METH_VARARGS,
-				M_Scene_NewMapValue_doc},
 	//DEPRECATED
 	{"getWinSize", (PyCFunction)Scene_getWinSize, METH_NOARGS,
 			"() - Return Render window [x,y] dimensions"},
@@ -557,21 +161,14 @@ static PyMethodDef BPy_Scene_methods[] = {
 					"() - Return directory where rendered images are saved to"},
 	{"getBackbufdir", (PyCFunction)Scene_getBackbufdir, METH_NOARGS,
 					"() - Return location of the backbuffer image"},
+	{"getRenderingContext", (PyCFunction)Scene_getRenderingContext, METH_NOARGS,
+					"() - Get the rendering context for the scene and return it as a BPy_RenderData"},
+	{"currentFrame", (PyCFunction)Scene_currentFrame, METH_VARARGS,
+					"(frame) - If frame is given, the current frame is set and"
+									"\nreturned in any case"},
 	{0}
 };
-
-/*****************************************************************************/
-/* Python Scene_Type callback function prototypes:							*/
-/*****************************************************************************/
-static void Scene_dealloc (BPy_Scene *self);
-static int Scene_setAttr (BPy_Scene *self, char *name, PyObject *v);
-static int Scene_compare (BPy_Scene *a, BPy_Scene *b);
-static PyObject *Scene_getAttr (BPy_Scene *self, char *name);
-static PyObject *Scene_repr (BPy_Scene *self);
-
-/*****************************************************************************/
-/* Python Scene_Type structure definition:								     */
-/*****************************************************************************/
+//-----------------------BPy_Scene method def-------------------------------------------------------------------------
 PyTypeObject Scene_Type =
 {
 	PyObject_HEAD_INIT(NULL)
@@ -596,7 +193,160 @@ PyTypeObject Scene_Type =
 	BPy_Scene_methods,				/* tp_methods */
 	0,								/* tp_members */
 };
+//-----------------------Scene module Init())--------------------------------------------------------------------------------
+PyObject *Scene_Init (void)
+{
+	PyObject	*submodule;
+ 	PyObject *dict;
+
+	Scene_Type.ob_type = &PyType_Type;
+ 	submodule = Py_InitModule3("Blender.Scene",	M_Scene_methods, M_Scene_doc);
+
+	dict = PyModule_GetDict (submodule);
+    PyDict_SetItemString (dict, "Render", Render_Init ());
+
+	return submodule;
+}
+//-----------------------Scene module internal callbacks------------------------------------------------------------
+//-----------------------dealloc-----------------------------------------------------------------------------------------------------
+static void Scene_dealloc (BPy_Scene *self)
+{
+	PyObject_DEL (self);
+}
+//-----------------------getAttr-----------------------------------------------------------------------------------------------------
+static PyObject *Scene_getAttr (BPy_Scene *self, char *name)
+{
+	PyObject *attr = Py_None;
+
+	if (strcmp(name, "name") == 0)
+		attr = PyString_FromString(self->scene->id.name+2);
 
+	else if (strcmp(name, "__members__") == 0)
+		attr = Py_BuildValue("[s]", "name");
+
+
+	if (!attr)
+		return (EXPP_ReturnPyObjError (PyExc_MemoryError,
+											"couldn't create PyObject"));
+
+	if (attr != Py_None) return attr; /* member attribute found, return it */
+
+	/* not an attribute, search the methods table */
+	return Py_FindMethod(BPy_Scene_methods, (PyObject *)self, name);
+}
+//-----------------------setAttr-----------------------------------------------------------------------------------------------------
+static int Scene_setAttr (BPy_Scene *self, char *name, PyObject *value)
+{
+	PyObject *valtuple; 
+	PyObject *error = NULL;
+
+/* We're playing a trick on the Python API users here.	Even if they use
+ * Scene.member = val instead of Scene.setMember(val), we end up using the
+ * function anyway, since it already has error checking, clamps to the right
+ * interval and updates the Blender Scene structure when necessary. */
+
+/* First we put "value" in a tuple, because we want to pass it to functions
+ * that only accept PyTuples. Using "N" doesn't increment value's ref count */
+	valtuple = Py_BuildValue("(O)", value);
+
+	if (!valtuple) /* everything OK with our PyObject? */
+		return EXPP_ReturnIntError(PyExc_MemoryError,
+												 "SceneSetAttr: couldn't create PyTuple");
+
+/* Now we just compare "name" with all possible BPy_Scene member variables */
+	if (strcmp (name, "name") == 0)
+		error = Scene_setName (self, valtuple);
+
+	else { /* Error: no member with the given name was found */
+		Py_DECREF(valtuple);
+		return (EXPP_ReturnIntError (PyExc_AttributeError, name));
+	}
+
+/* valtuple won't be returned to the caller, so we need to DECREF it */
+	Py_DECREF(valtuple);
+
+	if (error != Py_None) return -1;
+
+/* Py_None was incref'ed by the called Scene_set* function. We probably
+ * don't need to decref Py_None (!), but since Python/C API manual tells us
+ * to treat it like any other PyObject regarding ref counting ... */
+	Py_DECREF(Py_None);
+	return 0; /* normal exit */
+}
+//-----------------------compare-----------------------------------------------------------------------------------------------------
+static int Scene_compare (BPy_Scene *a, BPy_Scene *b)
+{
+	Scene *pa = a->scene, *pb = b->scene;
+	return (pa == pb) ? 0:-1;
+}
+//----------------------repr--------------------------------------------------------------------------------------------------------------
+static PyObject *Scene_repr (BPy_Scene *self)
+{
+	return PyString_FromFormat("[Scene \"%s\"]", self->scene->id.name+2);
+}
+//-----------------------CreatePyObject----------------------------------------------------------------------------------
+PyObject *Scene_CreatePyObject (Scene *scene)
+{
+	BPy_Scene *pyscene;
+
+	pyscene = (BPy_Scene *)PyObject_NEW (BPy_Scene, &Scene_Type);
+
+	if (!pyscene)
+		return EXPP_ReturnPyObjError (PyExc_MemoryError,
+						"couldn't create BPy_Scene object");
+
+	pyscene->scene = scene;
+
+	return (PyObject *)pyscene;
+}
+//-----------------------CheckPyObject----------------------------------------------------------------------------------
+int Scene_CheckPyObject (PyObject *pyobj)
+{
+	return (pyobj->ob_type == &Scene_Type);
+}
+//-----------------------FromPyObject----------------------------------------------------------------------------------
+Scene *Scene_FromPyObject (PyObject *pyobj)
+{
+	return ((BPy_Scene *)pyobj)->scene;
+}
+//-----------------------GetSceneByName()--------------------------------------------------------------------------------------------
+/* Description: Returns the object with the name specified by the argument	name. 
+Note that the calling function has to remove the first two characters of the object name. 
+These two characters	specify the type of the object (OB, ME, WO, ...)The function 
+will return NULL when no object with the given  name is found.	 */
+Scene * GetSceneByName (char * name)
+{
+	Scene	* scene_iter;
+
+	scene_iter = G.main->scene.first;
+	while (scene_iter)
+	{
+		if (StringEqual (name, GetIdName (&(scene_iter->id))))
+		{
+			return (scene_iter);
+		}
+		scene_iter = scene_iter->id.next;
+	}
+
+	/* There is no object with the given name */
+	return (NULL);
+}
+//-----------------------EXPP_Scene_getObjectBase()--------------------------------------------------------------------------------------------
+Base *EXPP_Scene_getObjectBase(Scene *scene, Object *object)
+{
+	Base *base = scene->base.first;
+
+	while (base) {
+
+		if (object == base->object) return base; /* found it? */
+
+		base = base->next;
+	}
+
+	return NULL; /* object isn't linked to this scene */
+}
+//-----------------------Scene module function defintions----------------------------------------------------------------------
+//-----------------------Scene.New()--------------------------------------------------------------------------------------------------
 static PyObject *M_Scene_New(PyObject *self, PyObject *args, PyObject *kword)
 {
 	char		 *name = "Scene";
@@ -630,7 +380,7 @@ static PyObject *M_Scene_New(PyObject *self, PyObject *args, PyObject *kword)
 
 	return pyscene;
 }
-
+//-----------------------Scene.Get()--------------------------------------------------------------------------------------------------
 static PyObject *M_Scene_Get(PyObject *self, PyObject *args)
 {
 	char	*name = NULL;
@@ -690,12 +440,12 @@ static PyObject *M_Scene_Get(PyObject *self, PyObject *args)
 		return sce_pylist;
 	}
 }
-
+//-----------------------Scene.GetCurrent()---------------------------------------------------------------------------------------
 static PyObject *M_Scene_GetCurrent (PyObject *self)
 {
 	return Scene_CreatePyObject ((Scene *)G.scene);
 }
-
+//-----------------------Scene.Unlink()--------------------------------------------------------------------------------------------
 static PyObject *M_Scene_Unlink (PyObject *self, PyObject *args)
 { 
 	PyObject *pyobj;
@@ -716,111 +466,8 @@ static PyObject *M_Scene_Unlink (PyObject *self, PyObject *args)
 	Py_INCREF(Py_None);
 	return Py_None;
 }
-
-PyObject *Scene_Init (void)
-{
-	PyObject	*submodule;
- 	PyObject *dict;
-
-	Scene_Type.ob_type = &PyType_Type;
- 	submodule = Py_InitModule3("Blender.Scene",	M_Scene_methods, M_Scene_doc);
-	dict = PyModule_GetDict(submodule);
-
-	#define EXPP_ADDCONST(x) PyDict_SetItemString(dict, #x, PyInt_FromLong(R_##x))
-	EXPP_ADDCONST(INTERN);
-	EXPP_ADDCONST(YAFRAY);
-	EXPP_ADDCONST(AVIRAW);
-	EXPP_ADDCONST(AVIJPEG);
-#ifdef _WIN32
-	EXPP_ADDCONST(AVICODEC);
-#endif
-	EXPP_ADDCONST(QUICKTIME);
-	EXPP_ADDCONST(TARGA);
-	EXPP_ADDCONST(RAWTGA);
-	EXPP_ADDCONST(PNG);
-	EXPP_ADDCONST(BMP);
-	EXPP_ADDCONST(JPEG90);
-	EXPP_ADDCONST(HAMX);
-	EXPP_ADDCONST(IRIS);
-	EXPP_ADDCONST(IRIZ);
-	EXPP_ADDCONST(FTYPE);
-	EXPP_ADDCONST(PAL);
-	EXPP_ADDCONST(NTSC);
-	EXPP_ADDCONST(DEFAULT);
-	EXPP_ADDCONST(PREVIEW);
-	EXPP_ADDCONST(PC);
-	EXPP_ADDCONST(PAL169);
-	EXPP_ADDCONST(PANO);
-	EXPP_ADDCONST(FULL);
-
-	#undef EXPP_ADDCONST
-	#define EXPP_ADDCONST(x) PyDict_SetItemString(dict, #x, PyInt_FromLong(PY_##x))
-	EXPP_ADDCONST(NONE);
-	EXPP_ADDCONST(LOW);
-	EXPP_ADDCONST(MEDIUM);
-	EXPP_ADDCONST(HIGH);
-	EXPP_ADDCONST(HIGHER);
-	EXPP_ADDCONST(BEST);
-	EXPP_ADDCONST(SKYDOME);
-	EXPP_ADDCONST(GIFULL);
-
-	return submodule;
-}
-
-PyObject *Scene_CreatePyObject (Scene *scene)
-{
-	BPy_Scene *pyscene;
-
-	pyscene = (BPy_Scene *)PyObject_NEW (BPy_Scene, &Scene_Type);
-
-	if (!pyscene)
-		return EXPP_ReturnPyObjError (PyExc_MemoryError,
-						"couldn't create BPy_Scene object");
-
-	pyscene->scene = scene;
-
-	return (PyObject *)pyscene;
-}
-
-int Scene_CheckPyObject (PyObject *pyobj)
-{
-	return (pyobj->ob_type == &Scene_Type);
-}
-
-Scene *Scene_FromPyObject (PyObject *pyobj)
-{
-	return ((BPy_Scene *)pyobj)->scene;
-}
-
-/*****************************************************************************/
-/* Description: Returns the object with the name specified by the argument	 */
-/*							name. Note that the calling function has to remove the first */
-/*							two characters of the object name. These two characters			 */
-/*							specify the type of the object (OB, ME, WO, ...)						 */
-/*							The function will return NULL when no object with the given  */
-/*							name is found.																							 */
-/*****************************************************************************/
-Scene * GetSceneByName (char * name)
-{
-	Scene	* scene_iter;
-
-	scene_iter = G.main->scene.first;
-	while (scene_iter)
-	{
-		if (StringEqual (name, GetIdName (&(scene_iter->id))))
-		{
-			return (scene_iter);
-		}
-		scene_iter = scene_iter->id.next;
-	}
-
-	/* There is no object with the given name */
-	return (NULL);
-}
-
-/*****************************************************************************/
-/* Python BPy_Scene methods:																								 */
-/*****************************************************************************/
+//-----------------------BPy_Scene function defintions-----------------------------------------------------------------------
+//-----------------------Scene.getName()-----------------------------------------------------------------------------------------
 static PyObject *Scene_getName(BPy_Scene *self)
 {
 	PyObject *attr = PyString_FromString(self->scene->id.name+2);
@@ -830,7 +477,7 @@ static PyObject *Scene_getName(BPy_Scene *self)
 	return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
 																	 "couldn't get Scene.name attribute"));
 }
-
+//-----------------------Scene.setName()-----------------------------------------------------------------------------------------
 static PyObject *Scene_setName(BPy_Scene *self, PyObject *args)
 {
 	char *name;
@@ -847,7 +494,7 @@ static PyObject *Scene_setName(BPy_Scene *self, PyObject *args)
 	Py_INCREF(Py_None);
 	return Py_None;
 }
-
+//-----------------------Scene.copy()-----------------------------------------------------------------------------------------
 static PyObject *Scene_copy (BPy_Scene *self, PyObject *args)
 {
 	short dup_objs = 1;
@@ -863,24 +510,7 @@ static PyObject *Scene_copy (BPy_Scene *self, PyObject *args)
 
 	return Scene_CreatePyObject (copy_scene (scene, dup_objs));
 }
-
-/* Blender seems to accept any positive value up to 18000 for start, end and
- * current frames, independently. */
-
-static PyObject *Scene_currentFrame (BPy_Scene *self, PyObject *args)
-{
-	short frame = -1;
-	RenderData *rd = &self->scene->r;
-
-	if (!PyArg_ParseTuple (args, "|h", &frame))
-		return EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected int argument or nothing");
-
-	if (frame > 0) rd->cfra = EXPP_ClampInt(frame, 1, EXPP_SCENE_FRAME_MAX);
-
-	return PyInt_FromLong (rd->cfra);
-}
-
+//-----------------------Scene.makeCurrent()-----------------------------------------------------------------------------------------
 static PyObject *Scene_makeCurrent (BPy_Scene *self)
 {
 	Scene *scene = self->scene;
@@ -890,7 +520,7 @@ static PyObject *Scene_makeCurrent (BPy_Scene *self)
 	Py_INCREF (Py_None);
 	return Py_None;
 }
-
+//-----------------------Scene.update()-----------------------------------------------------------------------------------------
 static PyObject *Scene_update (BPy_Scene *self, PyObject *args)
 {
 	Scene *scene = self->scene;
@@ -923,7 +553,7 @@ static PyObject *Scene_update (BPy_Scene *self, PyObject *args)
 	Py_INCREF (Py_None);
 	return Py_None;
 }
-
+//-----------------------Scene.link()-----------------------------------------------------------------------------------------------------
 static PyObject *Scene_link (BPy_Scene *self, PyObject *args)
 {
 	Scene *scene = self->scene;
@@ -975,7 +605,7 @@ static PyObject *Scene_link (BPy_Scene *self, PyObject *args)
 	Py_INCREF (Py_None);
 	return Py_None;
 }
-
+//-----------------------Scene.unlink()-----------------------------------------------------------------------------------------------------
 static PyObject *Scene_unlink (BPy_Scene *self, PyObject *args)
 { 
 	BPy_Object *bpy_obj = NULL;
@@ -1007,8 +637,7 @@ static PyObject *Scene_unlink (BPy_Scene *self, PyObject *args)
 
 	return Py_BuildValue ("i", PyInt_FromLong (retval));
 }
-
-
+//-----------------------Scene.getChildren()-----------------------------------------------------------------------------------------------------
 static PyObject *Scene_getChildren (BPy_Scene *self)
 {	
 	Scene *scene = self->scene;
@@ -1041,7 +670,7 @@ static PyObject *Scene_getChildren (BPy_Scene *self)
 
 	return pylist;
 }
-
+//-----------------------Scene.getCurrentCamera()---------------------------------------------------------------------------------------
 static PyObject *Scene_getCurrentCamera (BPy_Scene *self)
 {	
 	Object *cam_obj;
@@ -1059,7 +688,7 @@ static PyObject *Scene_getCurrentCamera (BPy_Scene *self)
 	Py_INCREF(Py_None); /* none found */
 	return Py_None;
 }
-
+//-----------------------Scene.setCurrentCamera()---------------------------------------------------------------------------------------
 static PyObject *Scene_setCurrentCamera (BPy_Scene *self, PyObject *args)
 {
 	Object *object;
@@ -1087,194 +716,63 @@ static PyObject *Scene_setCurrentCamera (BPy_Scene *self, PyObject *args)
 	Py_INCREF(Py_None);
 	return Py_None;
 }
+//-----------------------Scene.getRenderingContext()----------------------------------------------------------------------
+static PyObject *Scene_getRenderingContext (BPy_Scene *self)
+{	
+	if (!self->scene)
+		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+						"Blender Scene was deleted!");
 
-static void Scene_dealloc (BPy_Scene *self)
-{
-	PyObject_DEL (self);
-}
-
-static PyObject *Scene_getAttr (BPy_Scene *self, char *name)
-{
-	PyObject *attr = Py_None;
-
-	if (strcmp(name, "name") == 0)
-		attr = PyString_FromString(self->scene->id.name+2);
-
-	else if (strcmp(name, "__members__") == 0)
-		attr = Py_BuildValue("[s]", "name");
-
-
-	if (!attr)
-		return (EXPP_ReturnPyObjError (PyExc_MemoryError,
-											"couldn't create PyObject"));
-
-	if (attr != Py_None) return attr; /* member attribute found, return it */
-
-	/* not an attribute, search the methods table */
-	return Py_FindMethod(BPy_Scene_methods, (PyObject *)self, name);
-}
-
-static int Scene_setAttr (BPy_Scene *self, char *name, PyObject *value)
-{
-	PyObject *valtuple; 
-	PyObject *error = NULL;
-
-/* We're playing a trick on the Python API users here.	Even if they use
- * Scene.member = val instead of Scene.setMember(val), we end up using the
- * function anyway, since it already has error checking, clamps to the right
- * interval and updates the Blender Scene structure when necessary. */
-
-/* First we put "value" in a tuple, because we want to pass it to functions
- * that only accept PyTuples. Using "N" doesn't increment value's ref count */
-	valtuple = Py_BuildValue("(O)", value);
-
-	if (!valtuple) /* everything OK with our PyObject? */
-		return EXPP_ReturnIntError(PyExc_MemoryError,
-												 "SceneSetAttr: couldn't create PyTuple");
-
-/* Now we just compare "name" with all possible BPy_Scene member variables */
-	if (strcmp (name, "name") == 0)
-		error = Scene_setName (self, valtuple);
-
-	else { /* Error: no member with the given name was found */
-		Py_DECREF(valtuple);
-		return (EXPP_ReturnIntError (PyExc_AttributeError, name));
-	}
-
-/* valtuple won't be returned to the caller, so we need to DECREF it */
-	Py_DECREF(valtuple);
-
-	if (error != Py_None) return -1;
-
-/* Py_None was incref'ed by the called Scene_set* function. We probably
- * don't need to decref Py_None (!), but since Python/C API manual tells us
- * to treat it like any other PyObject regarding ref counting ... */
-	Py_DECREF(Py_None);
-	return 0; /* normal exit */
-}
-
-static int Scene_compare (BPy_Scene *a, BPy_Scene *b)
-{
-	Scene *pa = a->scene, *pb = b->scene;
-	return (pa == pb) ? 0:-1;
-}
-
-static PyObject *Scene_repr (BPy_Scene *self)
-{
-	return PyString_FromFormat("[Scene \"%s\"]", self->scene->id.name+2);
-}
-
-Base *EXPP_Scene_getObjectBase(Scene *scene, Object *object)
-{
-	Base *base = scene->base.first;
-
-	while (base) {
-
-		if (object == base->object) return base; /* found it? */
-
-		base = base->next;
-	}
-
-	return NULL; /* object isn't linked to this scene */
+	return RenderData_CreatePyObject(self->scene);
 }
-
 /*****************************************************************************/
 // DEPRECATED 	
 /*****************************************************************************/
+//-----------------------Scene.getRenderdir ()----------------------------------------------------------------------
 static PyObject *Scene_getRenderdir (BPy_Scene *self)
 {
-	if (self->scene)
-		return M_Render_GetRenderPath((PyObject*)self);
-
-	else
 		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-						"Blender Scene was deleted!");
+			"Depricated:use RenderData.getRenderPath()");
 }
-
+//-----------------------Scene.getBackbufdir ()----------------------------------------------------------------------
 static PyObject *Scene_getBackbufdir (BPy_Scene *self)
 {
-	if (self->scene)
-		return M_Render_GetBackbufPath((PyObject*)self);
-	else
 		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-						"Blender Scene already deleted");
+			"Depricated:use RenderData.getBackbufPath()");
 }
-
+//-----------------------Scene.startFrame ()----------------------------------------------------------------------
 static PyObject *Scene_startFrame (BPy_Scene *self, PyObject *args)
 {
-	short frame = -1;
-								 
-	if (!PyArg_ParseTuple (args, "|h", &frame))
-		return EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected int argument or nothing");
-
-	return M_Render_StartFrame((PyObject*)self, args);
+		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+			"Depricated:use RenderData.startFrame()");
 }
-
+//-----------------------Scene.endFrame ()----------------------------------------------------------------------
 static PyObject *Scene_endFrame (BPy_Scene *self, PyObject *args)
 {
-	short frame = -1;
-
-	if (!PyArg_ParseTuple (args, "|h", &frame))
-		return EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected int argument or nothing");
-
-	return M_Render_EndFrame((PyObject*)self, args);
+		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+			"Depricated:use RenderData.endFrame()");
 }
-
+//-----------------------Scene.getWinSize ()----------------------------------------------------------------------
 static PyObject *Scene_getWinSize(BPy_Scene *self)
 {
-	PyObject* list = PyList_New (0);
-
-	PyList_Append (list, M_Render_ImageSizeX((PyObject*)self, NULL));
-	PyList_Append (list, M_Render_ImageSizeY((PyObject*)self, NULL));
-
-	return list;
+		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+			"Depricated:use RenderData.imageSizeX() and RenderData.imageSizeY");
 }
-
+//-----------------------Scene.setWinSize()----------------------------------------------------------------------
 static PyObject *Scene_setWinSize(BPy_Scene *self, PyObject *args)
 {
-	int xres = -1, yres = -1;
-
-	if (!PyArg_ParseTuple(args, "(ii)", &xres, &yres))
-		return EXPP_ReturnPyObjError (PyExc_TypeError,
-							"expected a [x, y] list as argument");
-
-	if (xres > 0)
-		self->scene->r.xsch = EXPP_ClampInt(xres,
-										EXPP_SCENE_RENDER_WINRESOLUTION_MIN,
-										EXPP_SCENE_RENDER_WINRESOLUTION_MAX);
-	if (yres > 0)
-		self->scene->r.ysch = EXPP_ClampInt(yres,
-										EXPP_SCENE_RENDER_WINRESOLUTION_MIN,
-										EXPP_SCENE_RENDER_WINRESOLUTION_MAX);
-
-	Py_INCREF(Py_None);
-	return Py_None;
-
+		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+			"Depricated:use RenderData.imageSizeX() and RenderData.imageSizeY");
 }
-
+//-----------------------Scene.frameSettings()----------------------------------------------------------------------
 static PyObject *Scene_frameSettings (BPy_Scene *self, PyObject *args)
 {	
-	int start = -1;
-	int end = -1;
-	int current = -1;
-	RenderData *rd = NULL;
-	Scene *scene = self->scene;
-
-	if (!scene)
 		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
-						"Blender Scene was deleted!");
-
-	rd = &scene->r;
-
-	if (!PyArg_ParseTuple (args, "|iii", &start, &end, &current))
-		return EXPP_ReturnPyObjError (PyExc_TypeError,
-						"expected three ints or nothing as arguments");
-
-	if (start > 0)	 rd->sfra = EXPP_ClampInt (start, 1, EXPP_SCENE_FRAME_MAX);
-	if (end > 0)		 rd->efra = EXPP_ClampInt (end, 1, EXPP_SCENE_FRAME_MAX);
-	if (current > 0) rd->cfra = EXPP_ClampInt (current, 1, EXPP_SCENE_FRAME_MAX);
-
-	return Py_BuildValue("(iii)", rd->sfra, rd->efra, rd->cfra);
+			"Depricated:use RenderData.startFrame(),  RenderData.endFrame, RenderData.currentFrame");
+}
+//-----------------------Scene.currentFrame()-----------------------------------------------------------------------------------------
+static PyObject *Scene_currentFrame (BPy_Scene *self, PyObject *args)
+{
+		return EXPP_ReturnPyObjError (PyExc_RuntimeError,
+			"Depricated:use RenderData.currentFrame");
 }
diff --git a/source/blender/python/api2_2x/Scene.h b/source/blender/python/api2_2x/Scene.h
index db97ad891ec..ef2664f8ad0 100644
--- a/source/blender/python/api2_2x/Scene.h
+++ b/source/blender/python/api2_2x/Scene.h
@@ -35,33 +35,22 @@
 #include <Python.h>
 #include <DNA_scene_types.h>
 
-#include "constant.h"
-#include "gen_utils.h"
-#include "sceneRender.h"
-
 /* The Scene PyType Object defined in Scene.c */
 PyTypeObject Scene_Type;
 
 #define BPy_Scene_Check(v) \
-    ((v)->ob_type == &Scene_Type) /* for type checking */
+    ((v)->ob_type == &Scene_Type) 
 
-/*****************************************************************************/
-/* Python BPy_Scene structure definition:                                   */
-/*****************************************************************************/
+//---------------------------Python BPy_Scene structure definition------------------------------------------------------
 typedef struct {
   PyObject_HEAD
   Scene *scene;
-
 } BPy_Scene;
-
-/*****************************************************************************/
-/* Python Scene_Type helper functions needed by Blender (the Init function) */
-/* and Object modules.                                                       */
-/*****************************************************************************/
+//---------------------------Python BPy_Scene visible prototypes------------------------------------------------------
+// Python Scene_Type helper functions needed by Blender (the Init function) and Object modules. 
 PyObject *Scene_Init (void);
 PyObject *Scene_CreatePyObject (Scene *cam);
 Scene    *Scene_FromPyObject (PyObject *pyobj);
 int       Scene_CheckPyObject (PyObject *pyobj);
 
-
 #endif /* EXPP_SCENE_H */
diff --git a/source/blender/python/api2_2x/Types.c b/source/blender/python/api2_2x/Types.c
index 8acc3b6abbe..5705ecee415 100644
--- a/source/blender/python/api2_2x/Types.c
+++ b/source/blender/python/api2_2x/Types.c
@@ -68,6 +68,7 @@ void types_InitAll(void)
 	NMesh_Type.ob_type = &PyType_Type;
 	Object_Type.ob_type = &PyType_Type;
 	Particle_Type.ob_type = &PyType_Type;
+	RenderData_Type.ob_type = &PyType_Type;
 	Scene_Type.ob_type = &PyType_Type;
 	Text_Type.ob_type = &PyType_Type;
 	Texture_Type.ob_type = &PyType_Type;
@@ -100,6 +101,7 @@ PyObject *Types_Init (void)
 	/* Blender Object Data Types */
 
 	PyDict_SetItemString(dict, "SceneType",		(PyObject *)&Scene_Type);
+	PyDict_SetItemString(dict, "RenderDataType", (PyObject *)&RenderData_Type);
 
 	PyDict_SetItemString(dict, "NMeshType",		 (PyObject *)&NMesh_Type);
 	PyDict_SetItemString(dict, "NMFaceType",	 (PyObject *)&NMFace_Type);
diff --git a/source/blender/python/api2_2x/Types.h b/source/blender/python/api2_2x/Types.h
index 87d45fa7795..b78dfc7db1b 100644
--- a/source/blender/python/api2_2x/Types.h
+++ b/source/blender/python/api2_2x/Types.h
@@ -44,7 +44,7 @@ extern PyTypeObject Material_Type, Metaball_Type, MTex_Type;
 extern PyTypeObject NMFace_Type, NMVert_Type, NMCol_Type, NMesh_Type;
 extern PyTypeObject Object_Type;
 extern PyTypeObject Particle_Type;
-extern PyTypeObject Scene_Type;
+extern PyTypeObject Scene_Type, RenderData_Type;
 extern PyTypeObject Text_Type, Texture_Type;
 extern PyTypeObject Wave_Type, World_Type;
 
diff --git a/source/blender/python/api2_2x/sceneRender.c b/source/blender/python/api2_2x/sceneRender.c
index 17bed9a4aa8..ab1b77a7be1 100644
--- a/source/blender/python/api2_2x/sceneRender.c
+++ b/source/blender/python/api2_2x/sceneRender.c
@@ -29,104 +29,469 @@
  * ***** END GPL/BL DUAL LICENSE BLOCK *****
 */
 
+#include <BIF_renderwin.h>
+#include <BKE_utildefines.h>
+#include <BKE_global.h>
+#include <DNA_image_types.h>
+#include <BIF_drawscene.h>
+#include <BLI_blenlib.h>
+#include <BKE_image.h>
+#include <BIF_space.h>
+#include <DNA_scene_types.h>
+#include <DNA_space_types.h>
+#include <mydevice.h>
+#include <butspace.h>
+#include <BKE_bad_level_calls.h>
 #include "sceneRender.h"
-
-RE_Render R;
-
-
-/*****************************************************************************/
-// Python funciton definitions for Render module		
-/*****************************************************************************/
-
-PyObject *M_Render_Render(PyObject *self)
-{
-	Scene* oldsce;
-
-	oldsce= G.scene;
-	set_scene(((BPy_Scene*)self)->scene);
-	BIF_do_render(0);
-	set_scene(oldsce);
- 	return EXPP_incr_ret(Py_None);
-}
-
-PyObject *M_Render_RenderAnim(PyObject *self)
-{
-	Scene* oldsce;
-
-	oldsce= G.scene;
-	set_scene(((BPy_Scene*)self)->scene);
-	BIF_do_render(1);
-	set_scene(oldsce);
- 	return EXPP_incr_ret(Py_None);
-}
-
-PyObject *M_Render_CloseRenderWindow(PyObject *self)
-{
-	BIF_close_render_display();
-	return EXPP_incr_ret(Py_None);
-}
-
-PyObject *M_Render_Play(PyObject *self)
-{
-	char file[FILE_MAXDIR+FILE_MAXFILE];
-	extern char bprogname[];
-	char str[FILE_MAXDIR+FILE_MAXFILE];
-	int pos[2], size[2];
-	char txt[64];
-
-#ifdef WITH_QUICKTIME
-	if(((BPy_Scene*)self)->scene->r.imtype == R_QUICKTIME){
-
-		strcpy(file, ((BPy_Scene*)self)->scene->r.pic);
-		BLI_convertstringcode(file, ((BPy_Scene*)self)->scene, ((BPy_Scene*)self)->scene->r.cfra);
- 		RE_make_existing_file(file);
-  		if (strcasecmp(file + strlen(file) - 4, ".mov")) {
-			sprintf(txt, "%04d_%04d.mov", (((BPy_Scene*)self)->scene->r.sfra) , 
-				(((BPy_Scene*)self)->scene->r.efra));
-			strcat(file, txt);
-		}
-	}else
+#include "render_types.h"
+#include "blendef.h"
+#include "Scene.h"
+#include "gen_utils.h"
+#include "modules.h"
+
+#ifdef HAVE_CONFIG_H
+	#include <config.h>
 #endif
-	{
 
-		strcpy(file, ((BPy_Scene*)self)->scene->r.pic);
-		BLI_convertstringcode(file, G.sce, ((BPy_Scene*)self)->scene->r.cfra);
-		RE_make_existing_file(file);
-  		if (strcasecmp(file + strlen(file) - 4, ".avi")) {
-			sprintf(txt, "%04d_%04d.avi", (((BPy_Scene*)self)->scene->r.sfra) , 
-				(((BPy_Scene*)self)->scene->r.efra) );
-			strcat(file, txt);
-		}
-	}
-	if(BLI_exist(file)) {
-		calc_renderwin_rectangle(R.winpos, pos, size);
-		sprintf(str, "%s -a -p %d %d \"%s\"", bprogname, pos[0], pos[1], file);
-		system(str);
-	}
-	else {
-		makepicstring(file, ((BPy_Scene*)self)->scene->r.sfra);
-		if(BLI_exist(file)) {
-			calc_renderwin_rectangle(R.winpos, pos, size);
-			sprintf(str, "%s -a -p %d %d \"%s\"", bprogname, pos[0], pos[1], file);
-			system(str);
-		}
-		else sprintf("Can't find image: %s", file);
-	}
+//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
 
-	return EXPP_incr_ret(Py_None);
-}
+RE_Render R;
 
+//----------------------------------------------Render prototypes---------------------------------------------------------------
+static PyObject *M_Render_CloseRenderWindow (PyObject *self);
+static PyObject *M_Render_EnableDispView (PyObject *self);
+static PyObject *M_Render_EnableDispWin (PyObject *self);
+static PyObject *M_Render_SetRenderWinPos (PyObject *self, PyObject *args);
+static PyObject *M_Render_EnableEdgeShift (PyObject *self, PyObject *args);
+static PyObject *M_Render_EnableEdgeAll (PyObject *self, PyObject *args);
+//----------------------------------------------Render doc strings--------------------------------------------------------------
+static char M_Render_doc[] = "The Blender Render module";
+//----------------------------------------------Render method def--------------------------------------------------------------
+struct PyMethodDef M_Render_methods[] = {
+	{"CloseRenderWindow",(PyCFunction)M_Render_CloseRenderWindow, METH_NOARGS,
+				"() - close the rendering window\n"},
+	{"EnableDispView",(PyCFunction)M_Render_EnableDispView, METH_NOARGS,
+				"(bool) - enable Sceneing in view\n"},
+	{"EnableDispWin",(PyCFunction)M_Render_EnableDispWin, METH_NOARGS,
+				"(bool) - enable Sceneing in new window\n"},
+	{"SetRenderWinPos",(PyCFunction)M_Render_SetRenderWinPos, METH_VARARGS,
+				"([string list]) - position the rendering window in around the edge of the screen\n"}, 
+	{"EnableEdgeShift",(PyCFunction)M_Render_EnableEdgeShift, METH_VARARGS,
+				"(bool) - with the unified renderer the outlines are shifted a bit.\n"},
+	{"EnableEdgeAll",(PyCFunction)M_Render_EnableEdgeAll, METH_VARARGS,
+				"(bool) - also consider transparent faces for edge-rendering with the unified renderer\n"},
+  {NULL, NULL, 0, NULL}
+};
+//------------------------------------BPy_RenderData methods/callbacks--------------------------------------------------
+static PyObject *RenderData_Render (BPy_RenderData *self);
+static PyObject *RenderData_RenderAnim (BPy_RenderData *self);
+static PyObject *RenderData_Play (BPy_RenderData *self);
+static PyObject *RenderData_SetRenderPath (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_GetRenderPath (BPy_RenderData *self);
+static PyObject *RenderData_SetBackbufPath (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_GetBackbufPath (BPy_RenderData *self);
+static PyObject *RenderData_EnableBackbuf (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_SetFtypePath (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_GetFtypePath (BPy_RenderData *self);
+static PyObject *RenderData_EnableExtensions (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_EnableSequencer (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableRenderDaemon (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_EnableToonShading (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_EdgeIntensity (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_SetEdgeColor (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_GetEdgeColor(BPy_RenderData *self);
+static PyObject *RenderData_EdgeAntiShift (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableOversampling (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_SetOversamplingLevel (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_EnableMotionBlur (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_MotionBlurLevel (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_PartsX (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_PartsY (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_EnableSky (BPy_RenderData *self);
+static PyObject *RenderData_EnablePremultiply (BPy_RenderData *self);
+static PyObject *RenderData_EnableKey (BPy_RenderData *self);
+static PyObject *RenderData_EnableShadow (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_EnablePanorama (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_EnableEnvironmentMap (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_EnableRayTracing (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableRadiosityRender (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_SetRenderWinSize (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_EnableFieldRendering (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableOddFieldFirst (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableFieldTimeDisable (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableGaussFilter (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_EnableBorderRender (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_EnableGammaCorrection (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_GaussFilterSize (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_StartFrame (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_CurrentFrame (BPy_RenderData*self, PyObject *args);
+static PyObject *RenderData_EndFrame (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_ImageSizeX (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_ImageSizeY (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_AspectRatioX (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_AspectRatioY (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_SetRenderer (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableCropping (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_SetImageType (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_Quality (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_FramesPerSec (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableGrayscale (BPy_RenderData *self);
+static PyObject *RenderData_EnableRGBColor (BPy_RenderData *self);
+static PyObject *RenderData_EnableRGBAColor (BPy_RenderData *self);
+static PyObject *RenderData_SizePreset(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableUnifiedRenderer (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_SetYafrayGIQuality (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_SetYafrayGIMethod (BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_YafrayGIPower(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_YafrayGIDepth(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_YafrayGICDepth(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableYafrayGICache(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableYafrayGIPhotons(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_YafrayGIPhotonCount(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_YafrayGIPhotonRadius(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_YafrayGIPhotonMixCount(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableYafrayGITunePhotons(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_YafrayGIShadowQuality(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_YafrayGIPixelsPerSample(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableYafrayGIGradient(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_YafrayGIRefinement(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_YafrayRayBias(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_YafrayRayDepth(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_YafrayGamma(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_YafrayExposure(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_YafrayProcessorCount(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableGameFrameStretch(BPy_RenderData *self);
+static PyObject *RenderData_EnableGameFrameExpose(BPy_RenderData *self);
+static PyObject *RenderData_EnableGameFrameBars(BPy_RenderData *self);
+static PyObject *RenderData_SetGameFrameColor(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_GetGameFrameColor(BPy_RenderData *self);
+static PyObject *RenderData_GammaLevel(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_PostProcessAdd(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_PostProcessMultiply(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_PostProcessGamma(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_SGIMaxsize(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_EnableSGICosmo(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_OldMapValue(BPy_RenderData *self, PyObject *args);
+static PyObject *RenderData_NewMapValue(BPy_RenderData *self, PyObject *args);
+
+static void RenderData_dealloc (BPy_RenderData * self);
+static PyObject *RenderData_getAttr (BPy_RenderData * self, char *name);
+static PyObject *RenderData_repr (BPy_RenderData * self);
+//------------------------------------BPy_RenderData  method def-----------------------------------------------------------
+static PyMethodDef BPy_RenderData_methods[] = {
+	{"render",(PyCFunction)RenderData_Render, METH_NOARGS,
+				"() - render the scene\n"},
+	{"renderAnim",(PyCFunction)RenderData_RenderAnim, METH_NOARGS,
+				"() - render a sequence from start frame to end frame\n"},
+	{"play",(PyCFunction)RenderData_Play, METH_NOARGS,
+				"() - play animation of rendered images/avi (searches Pics: field)\n"},
+	{"setRenderPath",(PyCFunction)RenderData_SetRenderPath, METH_VARARGS,
+				"(string) - get/set the path to output the rendered images to\n"},
+	{"getRenderPath",(PyCFunction)RenderData_GetRenderPath, METH_NOARGS,
+				"() - get the path to directory where rendered images will go\n"},
+	{"setBackbufPath",(PyCFunction)RenderData_SetBackbufPath, METH_VARARGS,
+				"(string) - get/set the path to a background image and load it\n"},
+	{"getBackbufPath",(PyCFunction)RenderData_GetBackbufPath, METH_NOARGS,
+				"() - get the path to background image file\n"},
+	{"enableBackbuf",(PyCFunction)RenderData_EnableBackbuf, METH_VARARGS,
+				"(bool) - enable/disable the backbuf image\n"},
+	{"setFtypePath",(PyCFunction)RenderData_SetFtypePath, METH_VARARGS,
+				"(string) - get/set the path to output the Ftype file\n"},
+	{"getFtypePath",(PyCFunction)RenderData_GetFtypePath, METH_NOARGS,
+				"() - get the path to Ftype file\n"},
+	{"enableExtensions",(PyCFunction)RenderData_EnableExtensions, METH_VARARGS,
+				"(bool) - enable/disable windows extensions for output files\n"},
+	{"enableSequencer",(PyCFunction)RenderData_EnableSequencer, METH_VARARGS,
+				"(bool) - enable/disable Do Sequence\n"},
+	{"enableRenderDaemon",(PyCFunction)RenderData_EnableRenderDaemon, METH_VARARGS,
+				"(bool) - enable/disable Scene daemon\n"},
+	{"enableToonShading",(PyCFunction)RenderData_EnableToonShading, METH_VARARGS,
+				"(bool) - enable/disable Edge rendering\n"},
+	{"edgeIntensity",(PyCFunction)RenderData_EdgeIntensity, METH_VARARGS,
+				"(int) - get/set edge intensity for toon shading\n"},
+	{"setEdgeColor",(PyCFunction)RenderData_SetEdgeColor, METH_VARARGS,
+				"(f,f,f) - set the edge color for toon shading - Red,Green,Blue expected.\n"},
+	{"getEdgeColor",(PyCFunction)RenderData_GetEdgeColor, METH_VARARGS,
+				"() - get the edge color for toon shading - Red,Green,Blue expected.\n"},
+	{"edgeAntiShift",(PyCFunction)RenderData_EdgeAntiShift, METH_VARARGS,
+				"(int) - with the unified renderer to reduce intensity on boundaries.\n"},
+	{"enableOversampling",(PyCFunction)RenderData_EnableOversampling, METH_VARARGS,
+				"(bool) - enable/disable oversampling (anit-aliasing).\n"},
+	{"setOversamplingLevel",(PyCFunction)RenderData_SetOversamplingLevel, METH_VARARGS,
+				"(enum) - get/set the level of oversampling (anit-aliasing).\n"},
+	{"enableMotionBlur",(PyCFunction)RenderData_EnableMotionBlur, METH_VARARGS,
+				"(bool) - enable/disable MBlur.\n"},
+	{"motionBlurLevel",(PyCFunction)RenderData_MotionBlurLevel, METH_VARARGS,
+				"(float) - get/set the length of shutter time for motion blur.\n"},
+	{"partsX",(PyCFunction)RenderData_PartsX, METH_VARARGS,
+				"(int) - get/set the number of parts to divide the render in the X direction\n"},
+	{"partsY",(PyCFunction)RenderData_PartsY, METH_VARARGS,
+				"(int) - get/set the number of parts to divide the render in the Y direction\n"},
+	{"enableSky",(PyCFunction)RenderData_EnableSky, METH_NOARGS,
+				"() - enable render background with sky\n"},
+	{"enablePremultiply",(PyCFunction)RenderData_EnablePremultiply, METH_NOARGS,
+				"() - enable premultiply alpha\n"},
+	{"enableKey",(PyCFunction)RenderData_EnableKey, METH_NOARGS,
+				"() - enable alpha and colour values remain unchanged\n"}, 
+	{"enableShadow",(PyCFunction)RenderData_EnableShadow, METH_VARARGS,
+				"(bool) - enable/disable shadow calculation\n"},
+	{"enablePanorama",(PyCFunction)RenderData_EnablePanorama, METH_VARARGS,
+				"(bool) - enable/disable panorama rendering (output width is multiplied by Xparts)\n"},
+	{"enableEnvironmentMap",(PyCFunction)RenderData_EnableEnvironmentMap, METH_VARARGS,
+				"(bool) - enable/disable environment map rendering\n"},
+	{"enableRayTracing",(PyCFunction)RenderData_EnableRayTracing, METH_VARARGS,
+				"(bool) - enable/disable ray tracing\n"},
+	{"enableRadiosityRender",(PyCFunction)RenderData_EnableRadiosityRender, METH_VARARGS,
+				"(bool) - enable/disable radiosity rendering\n"},
+	{"setRenderWinSize",(PyCFunction)RenderData_SetRenderWinSize, METH_VARARGS,
+				"(enum) - get/set the size of the render window\n"},
+	{"enableFieldRendering",(PyCFunction)RenderData_EnableFieldRendering, METH_VARARGS,
+				"(bool) - enable/disable field rendering\n"},
+	{"enableOddFieldFirst",(PyCFunction)RenderData_EnableOddFieldFirst, METH_VARARGS,
+				"(bool) - enable/disable Odd field first rendering (Default: Even field)\n"},
+	{"enableFieldTimeDisable",(PyCFunction)RenderData_EnableFieldTimeDisable, METH_VARARGS,
+				"(bool) - enable/disable time difference in field calculations\n"},
+	{"enableGaussFilter",(PyCFunction)RenderData_EnableGaussFilter, METH_VARARGS,
+				"(bool) - enable/disable Gauss sampling filter for antialiasing\n"},
+	{"enableBorderRender",(PyCFunction)RenderData_EnableBorderRender, METH_VARARGS,
+				"(bool) - enable/disable small cut-out rendering\n"},
+	{"enableGammaCorrection",(PyCFunction)RenderData_EnableGammaCorrection, METH_VARARGS,
+				"(bool) - enable/disable gamma correction\n"},
+	{"gaussFilterSize",(PyCFunction)RenderData_GaussFilterSize, METH_VARARGS,
+				"(float) - get/sets the Gauss filter size\n"},
+	{"startFrame",(PyCFunction)RenderData_StartFrame, METH_VARARGS,
+				"(int) - get/set the starting frame for rendering\n"},
+	{"currentFrame",(PyCFunction)RenderData_CurrentFrame, METH_VARARGS,
+				"(int) - get/set the current frame for rendering\n"},
+	{"endFrame",(PyCFunction)RenderData_EndFrame, METH_VARARGS,
+				"(int) - get/set the ending frame for rendering\n"},
+	{"imageSizeX",(PyCFunction)RenderData_ImageSizeX, METH_VARARGS,
+				"(int) - get/set the image width in pixels\n"},
+	{"imageSizeY",(PyCFunction)RenderData_ImageSizeY, METH_VARARGS,
+				"(int) - get/set the image height in pixels\n"},
+	{"aspectRatioX",(PyCFunction)RenderData_AspectRatioX, METH_VARARGS,
+				"(int) - get/set the horizontal aspect ratio\n"},
+	{"aspectRatioY",(PyCFunction)RenderData_AspectRatioY, METH_VARARGS,
+				"(int) - get/set the vertical aspect ratio\n"},
+	{"setRenderer",(PyCFunction)RenderData_SetRenderer, METH_VARARGS,
+				"(enum) - get/set which renderer to render the output\n"},
+	{"enableCropping",(PyCFunction)RenderData_EnableCropping, METH_VARARGS,
+				"(bool) - enable/disable exclusion of border rendering from total image\n"},
+	{"setImageType",(PyCFunction)RenderData_SetImageType, METH_VARARGS,
+				"(enum) - get/set the type of image to output from the render\n"},
+	{"quality",(PyCFunction)RenderData_Quality, METH_VARARGS,
+				"(int) - get/set quality get/setting for JPEG images, AVI Jpeg and SGI movies\n"},
+	{"framesPerSec",(PyCFunction)RenderData_FramesPerSec, METH_VARARGS,
+				"(int) - get/set frames per second\n"},
+	{"enableGrayscale",(PyCFunction)RenderData_EnableGrayscale, METH_NOARGS,
+				"() - images are saved with BW (grayscale) data\n"},
+	{"enableRGBColor",(PyCFunction)RenderData_EnableRGBColor, METH_NOARGS,
+				"() - images are saved with RGB (color) data\n"},
+	{"enableRGBAColor",(PyCFunction)RenderData_EnableRGBAColor, METH_NOARGS,
+				"() - images are saved with RGB and Alpha data (if supported)\n"},
+	{"sizePreset",(PyCFunction)RenderData_SizePreset, METH_VARARGS,
+				"(enum) - get/set the render to one of a few preget/sets\n"},
+	{"enableUnifiedRenderer",(PyCFunction)RenderData_EnableUnifiedRenderer, METH_VARARGS,
+				"(bool) - use the unified renderer\n"},
+	{"setYafrayGIQuality",(PyCFunction)RenderData_SetYafrayGIQuality, METH_VARARGS,
+				"(enum) - get/set yafray global Illumination quality\n"},
+	{"setYafrayGIMethod",(PyCFunction)RenderData_SetYafrayGIMethod, METH_VARARGS,
+				"(enum) - get/set yafray global Illumination method\n"},
+	{"yafrayGIPower",(PyCFunction)RenderData_YafrayGIPower, METH_VARARGS,
+				"(float) - get/set GI lighting intensity scale\n"},
+	{"yafrayGIDepth",(PyCFunction)RenderData_YafrayGIDepth, METH_VARARGS,
+			    "(int) - get/set number of bounces of the indirect light\n"},
+	{"yafrayGICDepth",(PyCFunction)RenderData_YafrayGICDepth, METH_VARARGS,
+				"(int) - get/set number of bounces inside objects (for caustics)\n"},
+	{"enableYafrayGICache",(PyCFunction)RenderData_EnableYafrayGICache, METH_VARARGS,
+				"(bool) - enable/disable cache irradiance samples (faster)\n"},
+	{"enableYafrayGIPhotons",(PyCFunction)RenderData_EnableYafrayGIPhotons, METH_VARARGS,
+				"(bool) - enable/disable use global photons to help in GI\n"},
+	{"yafrayGIPhotonCount",(PyCFunction)RenderData_YafrayGIPhotonCount, METH_VARARGS,
+				"(int) - get/set number of photons to shoot\n"},
+	{"yafrayGIPhotonRadius",(PyCFunction)RenderData_YafrayGIPhotonRadius, METH_VARARGS,
+				"(float) - get/set radius to search for photons to mix (blur)\n"},
+	{"yafrayGIPhotonMixCount",(PyCFunction)RenderData_YafrayGIPhotonMixCount, METH_VARARGS,
+				"(int) - get/set number of photons to shoot\n"},
+	{"enableYafrayGITunePhotons",(PyCFunction)RenderData_EnableYafrayGITunePhotons, METH_VARARGS,
+				"(bool) - enable/disable show the photonmap directly in the render for tuning\n"},
+	{"yafrayGIShadowQuality",(PyCFunction)RenderData_YafrayGIShadowQuality, METH_VARARGS,
+				"(float) - get/set the shadow quality, keep it under 0.95\n"},
+	{"yafrayGIPixelsPerSample",(PyCFunction)RenderData_YafrayGIPixelsPerSample, METH_VARARGS,
+				"(int) - get/set maximum number of pixels without samples, the lower the better and slower\n"},
+	{"enableYafrayGIGradient",(PyCFunction)RenderData_EnableYafrayGIGradient, METH_VARARGS,
+				"(bool) - enable/disable try to smooth lighting using a gradient\n"},
+	{"yafrayGIRefinement",(PyCFunction)RenderData_YafrayGIRefinement, METH_VARARGS,
+				"(float) - get/setthreshold to refine shadows EXPERIMENTAL. 1 = no refinement\n"},
+	{"yafrayRayBias",(PyCFunction)RenderData_YafrayRayBias, METH_VARARGS,
+				"(float) - get/set shadow ray bias to avoid self shadowing\n"},
+	{"yafrayRayDepth",(PyCFunction)RenderData_YafrayRayDepth, METH_VARARGS,
+				"(int) - get/set maximum render ray depth from the camera\n"},
+	{"yafrayGamma",(PyCFunction)RenderData_YafrayGamma, METH_VARARGS,
+				"(float) - get/set gamma correction, 1 is off\n"},
+	{"yafrayExposure",(PyCFunction)RenderData_YafrayExposure, METH_VARARGS,
+				"(float) - get/set exposure adjustment, 0 is off\n"},
+	{"yafrayProcessorCount",(PyCFunction)RenderData_YafrayProcessorCount, METH_VARARGS,
+				"(int) - get/set number of processors to use\n"},
+	{"enableGameFrameStretch",(PyCFunction)RenderData_EnableGameFrameStretch, METH_NOARGS,
+				"(l) - enble stretch or squeeze the viewport to fill the display window\n"},
+	{"enableGameFrameExpose",(PyCFunction)RenderData_EnableGameFrameExpose, METH_NOARGS,
+				"(l) - enable show the entire viewport in the display window, viewing more horizontally or vertically\n"},
+	{"enableGameFrameBars",(PyCFunction)RenderData_EnableGameFrameBars, METH_NOARGS,
+				"() - enable show the entire viewport in the display window, using bar horizontally or vertically\n"},
+	{"setGameFrameColor",(PyCFunction)RenderData_SetGameFrameColor, METH_VARARGS,
+				"(f,f,f) - set the red, green, blue component of the bars\n"},
+	{"getGameFrameColor",(PyCFunction)RenderData_GetGameFrameColor, METH_VARARGS,
+				"() - get the red, green, blue component of the bars\n"},
+	{"gammaLevel",(PyCFunction)RenderData_GammaLevel, METH_VARARGS,
+				"(float) - get/set the gamma value for blending oversampled images (1.0 = no correction\n"},
+	{"postProcessAdd",(PyCFunction)RenderData_PostProcessAdd, METH_VARARGS,
+				"(float) - get/set post processing add\n"},
+	{"postProcessMultiply",(PyCFunction)RenderData_PostProcessMultiply, METH_VARARGS,
+				"(float) - get/set post processing multiply\n"},
+	{"postProcessGamma",(PyCFunction)RenderData_PostProcessGamma, METH_VARARGS,
+				"(float) - get/set post processing gamma\n"},
+ 	{"SGIMaxsize",(PyCFunction)RenderData_SGIMaxsize, METH_VARARGS,
+				"(int) - get/set maximum size per frame to save in an SGI movie\n"},
+	{"enableSGICosmo",(PyCFunction)RenderData_EnableSGICosmo, METH_VARARGS,
+				"(bool) - enable/disable attempt to save SGI movies using Cosmo hardware\n"},
+	{"oldMapValue",(PyCFunction)RenderData_OldMapValue, METH_VARARGS,
+				"(int) - get/set specify old map value in frames\n"},
+	{"newMapValue",(PyCFunction)RenderData_NewMapValue, METH_VARARGS,
+				"(int) - get/set specify new map value in frames\n"},
+  {NULL, NULL, 0, NULL}
+};
+//------------------------------------BPy_RenderData Type defintion--------------------------------------------------------
+PyTypeObject RenderData_Type = {
+  PyObject_HEAD_INIT (NULL) 0,	  /* ob_size */
+  "Blender RenderData",		                          /* tp_name */
+  sizeof (BPy_RenderData),		                  /* tp_basicsize */
+  0,				                                          /* tp_itemsize */
+  /* methods */
+  (destructor) RenderData_dealloc,	          /* tp_dealloc */
+  0,				                                         /* tp_print */
+  (getattrfunc) RenderData_getAttr,	         /* tp_getattr */
+  0,	         /* tp_setattr */
+  0,	                                                     /* tp_compare */
+  (reprfunc) RenderData_repr,		             /* tp_repr */
+  0,				                                         /* tp_as_number */
+  0,				                                         /* tp_as_sequence */
+  0,				                                         /* tp_as_mapping */
+  0,				                                         /* tp_as_hash */
+  0, 0, 0, 0, 0, 0,
+  0,				                                         /* tp_doc */
+  0, 0, 0, 0, 0, 0,
+  BPy_RenderData_methods,		             /* tp_methods */
+  0,				                                         /* tp_members */
+};
+//---------------------------------------------------Render Module Init--------------------------------------------------
+PyObject *
+Render_Init (void)
+{
+  PyObject *submodule;
+
+  RenderData_Type.ob_type = &PyType_Type;
+
+  submodule = Py_InitModule3 ("Blender.Scene.Render",
+			      M_Render_methods, M_Render_doc);
+
+  PyModule_AddIntConstant(submodule, "INTERNAL",  R_INTERN);
+  PyModule_AddIntConstant(submodule, "YAFRAY",  R_YAFRAY);
+  PyModule_AddIntConstant(submodule, "AVIRAW",  R_AVIRAW);
+  PyModule_AddIntConstant(submodule, "AVIJPEG",  R_AVIJPEG);
+  PyModule_AddIntConstant(submodule, "AVICODEC",  R_AVICODEC);
+  PyModule_AddIntConstant(submodule, "QUICKTIME",  R_QUICKTIME);
+  PyModule_AddIntConstant(submodule, "TARGA",  R_TARGA);
+  PyModule_AddIntConstant(submodule, "RAWTGA",  R_RAWTGA);
+  PyModule_AddIntConstant(submodule, "PNG",  R_PNG);
+  PyModule_AddIntConstant(submodule, "BMP",  R_BMP);
+  PyModule_AddIntConstant(submodule, "JPEG",  R_JPEG90);
+  PyModule_AddIntConstant(submodule, "HAMX",  R_HAMX);
+  PyModule_AddIntConstant(submodule, "IRIS",  R_IRIS);
+  PyModule_AddIntConstant(submodule, "IRISZ",  R_IRIZ);
+  PyModule_AddIntConstant(submodule, "FTYPE",  R_FTYPE);
+  PyModule_AddIntConstant(submodule, "PAL",  B_PR_PAL);
+  PyModule_AddIntConstant(submodule, "NTSC",  B_PR_NTSC);
+  PyModule_AddIntConstant(submodule, "DEFAULT",  B_PR_PRESET);
+  PyModule_AddIntConstant(submodule, "PREVIEW",  B_PR_PRV);
+  PyModule_AddIntConstant(submodule, "PC",  B_PR_PC);
+  PyModule_AddIntConstant(submodule, "PAL169",  B_PR_PAL169);
+  PyModule_AddIntConstant(submodule, "PANO",  B_PR_PANO);
+  PyModule_AddIntConstant(submodule, "FULL",  B_PR_FULL);
+   PyModule_AddIntConstant(submodule, "NONE",  PY_NONE);
+   PyModule_AddIntConstant(submodule, "LOW",  PY_LOW);
+   PyModule_AddIntConstant(submodule, "MEDIUM",  PY_MEDIUM);
+   PyModule_AddIntConstant(submodule, "HIGH",  PY_HIGH);
+   PyModule_AddIntConstant(submodule, "HIGHER",  PY_HIGHER);
+   PyModule_AddIntConstant(submodule, "BEST",  PY_BEST);
+   PyModule_AddIntConstant(submodule, "SKYDOME",  PY_SKYDOME);
+   PyModule_AddIntConstant(submodule, "GIFULL",  PY_FULL);
+
+   return (submodule);
+}
+//-----------------------------------BPy_RenderData Internal Protocols---------------------------------------------------
+//-------------------------------------------------dealloc-----------------------------------------------------------------
+static void
+RenderData_dealloc (BPy_RenderData * self)
+{
+    PyObject_DEL (self);
+}
+//-------------------------------------------------getAttr-------------------------------------------------------------------
+static PyObject *
+RenderData_getAttr (BPy_RenderData * self, char *name)
+{
+  return Py_FindMethod (BPy_RenderData_methods, (PyObject *) self, name);
+}
+//-------------------------------------------------repr---------------------------------------------------------------------
+static PyObject *
+RenderData_repr (BPy_RenderData * self)
+{
+  if (self->renderContext)
+    return PyString_FromFormat ("[RenderData \"%s\"]", self->scene->id.name + 2);
+  else
+    return PyString_FromString ("NULL");
+}
+//------------------------------BPy_RenderData Callbacks--------------------------------------------------------------
+//--------------------------------------CreatePyObject-----------------------------------------------------------------------
+PyObject *
+RenderData_CreatePyObject (struct Scene * scene)
+{
+  BPy_RenderData *py_renderdata;
+
+  py_renderdata = (BPy_RenderData *) PyObject_NEW (BPy_RenderData, &RenderData_Type);
+
+  if (py_renderdata == NULL) {
+      return (NULL);
+  }
+  py_renderdata->renderContext = &scene->r;
+  py_renderdata->scene = scene;
+
+  return ((PyObject *) py_renderdata);
+}
+//------------------------------CheckPyObject--------------------------------------------------------------------------------
+int
+RenderData_CheckPyObject (PyObject * py_obj)
+{
+  return (py_obj->ob_type == &RenderData_Type);
+}
+//------------------------------------BitToggleInt---------------------------------------------------------------------------------
 static PyObject *M_Render_BitToggleInt(PyObject *args, int setting, int *structure)
 {
 	int flag;
 
 	if (!PyArg_ParseTuple(args, "i", &flag))
-		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-						"expected int"));
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError, "expected TRUE or FALSE (1 or 0)"));
 
 	if(flag < 0 || flag > 1)
-		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-						"expected 0 or 1"));
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError, "expected TRUE or FALSE (1 or 0)"));
 
 	if(flag)
 		*structure |= setting;
@@ -137,18 +502,16 @@ static PyObject *M_Render_BitToggleInt(PyObject *args, int setting, int *structu
 	return EXPP_incr_ret(Py_None);
 
 }
-
+//------------------------------------BitToggleShort---------------------------------------------------------------------------------
 static PyObject *M_Render_BitToggleShort(PyObject *args, short setting, short *structure)
 {
 	int flag;
 
 	if (!PyArg_ParseTuple(args, "i", &flag))
-		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-						"expected int"));
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError, "expected TRUE or FALSE (1 or 0)"));
 
 	if(flag < 0 || flag > 1)
-		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-						"expected 0 or 1"));
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError, "expected TRUE or FALSE (1 or 0)"));
 
 	if(flag)
 		*structure |= setting;
@@ -159,15 +522,14 @@ static PyObject *M_Render_BitToggleShort(PyObject *args, short setting, short *s
 	return EXPP_incr_ret(Py_None);
 
 }
-
+//------------------------------------GetSetAttributeFloat------------------------------------------------------------------------
 static PyObject *M_Render_GetSetAttributeFloat(PyObject *args, float *structure, float min, float max)
 {
 	float property = -10.0f;
 	char error[48];
 
 	if (!PyArg_ParseTuple(args, "|f", &property))
-		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-						"expected float"));
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError, 	"expected float"));
 
 	if(property != -10.0f){
 		if(property < min || property > max){
@@ -181,7 +543,7 @@ static PyObject *M_Render_GetSetAttributeFloat(PyObject *args, float *structure,
 	}else
 		return Py_BuildValue("f", *structure);	
 }
-
+//------------------------------------GetSetAttributeShort------------------------------------------------------------------------
 static PyObject *M_Render_GetSetAttributeShort(PyObject *args, short *structure, int min, int max)
 {
 	short property = -10;
@@ -203,7 +565,7 @@ static PyObject *M_Render_GetSetAttributeShort(PyObject *args, short *structure,
 	}else
 		return Py_BuildValue("h", *structure);	
 }
-
+//------------------------------------GetSetAttributeInt------------------------------------------------------------------------
 static PyObject *M_Render_GetSetAttributeInt(PyObject *args, int *structure, int min, int max)
 {
 	int property = -10;
@@ -225,108 +587,32 @@ static PyObject *M_Render_GetSetAttributeInt(PyObject *args, int *structure, int
 	}else
 		return Py_BuildValue("i", *structure);	
 }
-
-PyObject *M_Render_SetRenderPath(PyObject *self, PyObject *args)
-{
-	char *name;
-
-	if (!PyArg_ParseTuple(args, "s", &name))
-		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-						"expected a string"));
-
-	if(strlen(name) > 160)
- 		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-						"path is too long (SetRenderPath)"));
-
-	strcpy(((BPy_Scene*)self)->scene->r.pic, name);
-	allqueue(REDRAWBUTSSCENE, 0);
-
- 	return EXPP_incr_ret(Py_None);
-}
-
-PyObject *M_Render_GetRenderPath(PyObject *self)
-{
-	return Py_BuildValue("s", ((BPy_Scene*)self)->scene->r.pic);
-}
-
-PyObject *M_Render_SetBackbufPath(PyObject *self, PyObject *args)
-{
-	char *name;
-	Image *ima;
-
-	if (!PyArg_ParseTuple(args, "s", &name))
-		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-						"expected a string"));
-
-	if(strlen(name) > 160)
- 		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-						"path is too long (SetBackbufPath)"));
-
-	strcpy(((BPy_Scene*)self)->scene->r.backbuf, name);
-	allqueue(REDRAWBUTSSCENE, 0);
-
-	ima= add_image(name);
-	if(ima) {
-		free_image_buffers(ima);	
-		ima->ok= 1;
-	}
-
- 	return EXPP_incr_ret(Py_None);
-}
-
-PyObject *M_Render_GetBackbufPath(PyObject *self)
-{
-	return Py_BuildValue("s", ((BPy_Scene*)self)->scene->r.backbuf);
-}
-
-PyObject *M_Render_EnableBackbuf(PyObject *self, PyObject *args)
-{
-	M_Render_BitToggleShort(args, 1, &((BPy_Scene*)self)->scene->r.bufflag);
-	return EXPP_incr_ret(Py_None);
-}
-
-PyObject *M_Render_SetFtypePath(PyObject *self, PyObject *args)
-{
-	char *name;
-
-	if (!PyArg_ParseTuple(args, "s", &name))
-		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-						"expected a string"));
-
-	if(strlen(name) > 160)
- 		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
-						"path is too long (SetFtypePath)"));
-
-	strcpy(((BPy_Scene*)self)->scene->r.ftype, name);
-	allqueue(REDRAWBUTSSCENE, 0);
-
- 	return EXPP_incr_ret(Py_None);
-}
-
-PyObject *M_Render_GetFtypePath(PyObject *self)
-{
-	return Py_BuildValue("s", ((BPy_Scene*)self)->scene->r.ftype);
-}
-
-
-PyObject *M_Render_EnableExtensions(PyObject *self, PyObject *args)
+//------------------------------------DoSizePrese ---------------------------------------------------------------------------------
+static void M_Render_DoSizePreset(BPy_RenderData *self, short xsch, short ysch, short xasp,
+									   short yasp, short size, short xparts, short yparts,
+									   short frames, float a, float b, float c, float d)
 {
-	M_Render_BitToggleShort(args, R_EXTENSION, &((BPy_Scene*)self)->scene->r.scemode);
-	return EXPP_incr_ret(Py_None);
-}
+		self->renderContext->xsch= xsch;
+		self->renderContext->ysch= ysch;
+		self->renderContext->xasp= xasp;
+		self->renderContext->yasp= yasp;
+		self->renderContext->size= size;
+		self->renderContext->frs_sec= frames;
+		self->renderContext->xparts= xparts;
+		self->renderContext->yparts= yparts;
 
-PyObject *M_Render_EnableSequencer(PyObject *self, PyObject *args)
-{
-	M_Render_BitToggleShort(args, R_DOSEQ, &((BPy_Scene*)self)->scene->r.scemode);
-	return EXPP_incr_ret(Py_None);
+		BLI_init_rctf(&self->renderContext->safety, a, b, c, d);
+		allqueue(REDRAWBUTSSCENE, 0);
+		allqueue(REDRAWVIEWCAM, 0);
 }
-
-PyObject *M_Render_EnableRenderDaemon(PyObject *self, PyObject *args)
+//------------------------------------Render Module Function Definitions-----------------------------------------------
+//------------------------------------Render.CloseRenderWindow() -------------------------------------------------------
+PyObject *M_Render_CloseRenderWindow(PyObject *self)
 {
-	M_Render_BitToggleShort(args, R_BG_RENDER, &((BPy_Scene*)self)->scene->r.scemode);
+	BIF_close_render_display();
 	return EXPP_incr_ret(Py_None);
 }
-
+//------------------------------------Render.SetRenderWinPos() -------------------------------------------------------
 PyObject *M_Render_SetRenderWinPos(PyObject *self, PyObject *args)
 {
 	PyObject *list = NULL;
@@ -369,7 +655,7 @@ PyObject *M_Render_SetRenderWinPos(PyObject *self, PyObject *args)
 
 	return EXPP_incr_ret(Py_None);
 }
-
+//------------------------------------Render.EnableDispView() -------------------------------------------------------------------------
 PyObject *M_Render_EnableDispView(PyObject *self)
 {
 	R.displaymode = R_DISPLAYVIEW;
@@ -377,7 +663,7 @@ PyObject *M_Render_EnableDispView(PyObject *self)
 
 	return EXPP_incr_ret(Py_None);
 }
-
+//------------------------------------Render.EnableDispWin() -------------------------------------------------------------------------
 PyObject *M_Render_EnableDispWin(PyObject *self)
 {
 	R.displaymode = R_DISPLAYWIN;
@@ -385,31 +671,197 @@ PyObject *M_Render_EnableDispWin(PyObject *self)
 
 	return EXPP_incr_ret(Py_None);
 }
+//------------------------------------Render.EnableEdgeShift() -------------------------------------------------------------------------
+PyObject *M_Render_EnableEdgeShift(PyObject *self, PyObject *args)
+{
+	return M_Render_BitToggleInt(args, 1, &G.compat);
+}
+//------------------------------------Render.EnableEdgeAll() -------------------------------------------------------------------------
+PyObject *M_Render_EnableEdgeAll(PyObject *self, PyObject *args)
+{
+	return M_Render_BitToggleInt(args, 1, &G.notonlysolid);
+}
+//------------------------------------BPy_RenderData Function Definitions-----------------------------------------------
+//------------------------------------RenderData.Render() -------------------------------------------------------------------------
+PyObject *RenderData_Render(BPy_RenderData *self)
+{
+	Scene* oldsce;
+
+	oldsce= G.scene;
+	set_scene(self->scene);
+	BIF_do_render(0);
+	set_scene(oldsce);
+ 	return EXPP_incr_ret(Py_None);
+}
+//------------------------------------RenderData.RenderAnim() ------------------------------------------------------------------
+PyObject *RenderData_RenderAnim(BPy_RenderData *self)
+{
+	Scene* oldsce;
 
-PyObject *M_Render_EnableToonShading(PyObject *self, PyObject *args)
+	oldsce= G.scene;
+	set_scene(self->scene);
+	BIF_do_render(1);
+	set_scene(oldsce);
+ 	return EXPP_incr_ret(Py_None);
+}
+//------------------------------------RenderData.Play() -------------------------------------------------------------------------
+PyObject *RenderData_Play(BPy_RenderData *self)
 {
-	M_Render_BitToggleInt(args, R_EDGE, &((BPy_Scene*)self)->scene->r.mode);
+	char file[FILE_MAXDIR+FILE_MAXFILE];
+	extern char bprogname[];
+	char str[FILE_MAXDIR+FILE_MAXFILE];
+	int pos[2], size[2];
+	char txt[64];
+
+#ifdef WITH_QUICKTIME
+	if(self->renderContext->imtype == R_QUICKTIME){
+
+		strcpy(file, self->renderContext->pic);
+		BLI_convertstringcode(file, self->scene, self->renderContext->cfra);
+ 		RE_make_existing_file(file);
+  		if (strcasecmp(file + strlen(file) - 4, ".mov")) {
+			sprintf(txt, "%04d_%04d.mov", (self->renderContext->sfra) , 
+				(self->renderContext->efra));
+			strcat(file, txt);
+		}
+	}else
+#endif
+	{
+
+		strcpy(file, self->renderContext->pic);
+		BLI_convertstringcode(file, G.sce, self->renderContext->cfra);
+		RE_make_existing_file(file);
+  		if (strcasecmp(file + strlen(file) - 4, ".avi")) {
+			sprintf(txt, "%04d_%04d.avi", (self->renderContext->sfra) , 
+				(self->renderContext->efra) );
+			strcat(file, txt);
+		}
+	}
+	if(BLI_exist(file)) {
+		calc_renderwin_rectangle(R.winpos, pos, size);
+		sprintf(str, "%s -a -p %d %d \"%s\"", bprogname, pos[0], pos[1], file);
+		system(str);
+	}
+	else {
+		makepicstring(file, self->renderContext->sfra);
+		if(BLI_exist(file)) {
+			calc_renderwin_rectangle(R.winpos, pos, size);
+			sprintf(str, "%s -a -p %d %d \"%s\"", bprogname, pos[0], pos[1], file);
+			system(str);
+		}
+		else sprintf("Can't find image: %s", file);
+	}
+
 	return EXPP_incr_ret(Py_None);
 }
+//------------------------------------RenderData.StRenderPath() ---------------------------------------------------------
+PyObject *RenderData_SetRenderPath(BPy_RenderData *self, PyObject *args)
+{
+	char *name;
 
-PyObject *M_Render_EdgeIntensity(PyObject *self, PyObject *args)
+	if (!PyArg_ParseTuple(args, "s", &name))
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"expected a string"));
+
+	if(strlen(name) > 160)
+ 		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"path is too long (SetRenderPath)"));
+
+	strcpy(self->renderContext->pic, name);
+	allqueue(REDRAWBUTSSCENE, 0);
+
+ 	return EXPP_incr_ret(Py_None);
+}
+//------------------------------------RenderData.GetRenderPath() -------------------------------------------------------
+PyObject *RenderData_GetRenderPath(BPy_RenderData *self)
 {
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.edgeint, 0, 255);
+	return Py_BuildValue("s", self->renderContext->pic);
 }
+//------------------------------------RenderData.SetBackbufPath() -------------------------------------------------------
+PyObject *RenderData_SetBackbufPath(BPy_RenderData *self, PyObject *args)
+{
+	char *name;
+	Image *ima;
 
-PyObject *M_Render_EnableEdgeShift(PyObject *self, PyObject *args)
+	if (!PyArg_ParseTuple(args, "s", &name))
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"expected a string"));
+
+	if(strlen(name) > 160)
+ 		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"path is too long (SetBackbufPath)"));
+
+	strcpy(self->renderContext->backbuf, name);
+	allqueue(REDRAWBUTSSCENE, 0);
+
+	ima= add_image(name);
+	if(ima) {
+		free_image_buffers(ima);	
+		ima->ok= 1;
+	}
+
+ 	return EXPP_incr_ret(Py_None);
+}
+//------------------------------------RenderData.GetBackbufPath() --------------------------------------------------------------
+PyObject *RenderData_GetBackbufPath(BPy_RenderData *self)
 {
-	M_Render_BitToggleInt(args, 1, &G.compat);
-	return EXPP_incr_ret(Py_None);
+	return Py_BuildValue("s", self->renderContext->backbuf);
 }
-
-PyObject *M_Render_EnableEdgeAll(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableBackbuf() ----------------------------------------------------------------
+PyObject *RenderData_EnableBackbuf(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, 1, &G.notonlysolid);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleShort(args, 1, &self->renderContext->bufflag);
 }
+//------------------------------------RenderData.SetFtypePath() ------------------------------------------------------------------
+PyObject *RenderData_SetFtypePath(BPy_RenderData *self, PyObject *args)
+{
+	char *name;
+
+	if (!PyArg_ParseTuple(args, "s", &name))
+		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"expected a string"));
+
+	if(strlen(name) > 160)
+ 		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
+						"path is too long (SetFtypePath)"));
+
+	strcpy(self->renderContext->ftype, name);
+	allqueue(REDRAWBUTSSCENE, 0);
 
-PyObject *M_Render_SetEdgeColor(PyObject *self, PyObject *args)
+ 	return EXPP_incr_ret(Py_None);
+}
+//------------------------------------RenderData.GetFtypePath() --------------------------------------------------------
+PyObject *RenderData_GetFtypePath(BPy_RenderData *self)
+{
+	return Py_BuildValue("s", self->renderContext->ftype);
+}
+//------------------------------------RenderData.EnableExtensions() --------------------------------------------------
+PyObject *RenderData_EnableExtensions(BPy_RenderData *self, PyObject *args)
+{
+	return M_Render_BitToggleShort(args, R_EXTENSION, &self->renderContext->scemode);
+}
+//------------------------------------RenderData.EnableSequencer() --------------------------------------------------
+PyObject *RenderData_EnableSequencer(BPy_RenderData *self, PyObject *args)
+{
+	return M_Render_BitToggleShort(args, R_DOSEQ, &self->renderContext->scemode);
+}
+//------------------------------------RenderData.EnableRenderDaemon() ------------------------------------------
+PyObject *RenderData_EnableRenderDaemon(BPy_RenderData *self, PyObject *args)
+{
+	return M_Render_BitToggleShort(args, R_BG_RENDER, &self->renderContext->scemode);
+}
+//------------------------------------RenderData.EnableToonShading() ------------------------------------------
+PyObject *RenderData_EnableToonShading(BPy_RenderData *self, PyObject *args)
+{
+	return M_Render_BitToggleInt(args, R_EDGE, &self->renderContext->mode);
+}
+//------------------------------------RenderData.EdgeIntensity() --------------------------------------------------------
+PyObject *RenderData_EdgeIntensity(BPy_RenderData *self, PyObject *args)
+{
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->edgeint, 0, 255);
+}
+//------------------------------------RenderData.SetEdgeColor() ------------------------------------------------------
+PyObject *RenderData_SetEdgeColor(BPy_RenderData *self, PyObject *args)
 {
 	float red = 0.0f;
 	float green = 0.0f;
@@ -429,34 +881,33 @@ PyObject *M_Render_SetEdgeColor(PyObject *self, PyObject *args)
  		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"value out of range 0.000 - 1.000 (blue)"));
 
-	((BPy_Scene*)self)->scene->r.edgeR = red;
-	((BPy_Scene*)self)->scene->r.edgeG = green;
-	((BPy_Scene*)self)->scene->r.edgeB = blue;
+	self->renderContext->edgeR = red;
+	self->renderContext->edgeG = green;
+	self->renderContext->edgeB = blue;
 
 	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_GetEdgeColor(PyObject *self)
+//------------------------------------RenderData.GetEdgeColor() -----------------------------------------------------
+PyObject *RenderData_GetEdgeColor(BPy_RenderData *self)
 {
 	char rgb[24];
 
-	sprintf(rgb, "[%.3f,%.3f,%.3f]\n", ((BPy_Scene*)self)->scene->r.edgeR,
-		((BPy_Scene*)self)->scene->r.edgeG, ((BPy_Scene*)self)->scene->r.edgeB);
+	sprintf(rgb, "[%.3f,%.3f,%.3f]\n", self->renderContext->edgeR,
+		self->renderContext->edgeG, self->renderContext->edgeB);
 	return PyString_FromString (rgb);
 }
-
-PyObject *M_Render_EdgeAntiShift(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EdgeAntiShift() -------------------------------------------------------
+PyObject *RenderData_EdgeAntiShift(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.same_mat_redux, 0, 255);
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->same_mat_redux, 0, 255);
 }
-
-PyObject *M_Render_EnableOversampling(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableOversampling() ------------------------------------------
+PyObject *RenderData_EnableOversampling(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_OSA, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_OSA, &self->renderContext->mode);
 }
-
-PyObject *M_Render_SetOversamplingLevel(PyObject *self, PyObject *args)
+//------------------------------------RenderData.SetOversamplingLevel() ------------------------------------------
+PyObject *RenderData_SetOversamplingLevel(BPy_RenderData *self, PyObject *args)
 {
 	int level;
 
@@ -468,88 +919,82 @@ PyObject *M_Render_SetOversamplingLevel(PyObject *self, PyObject *args)
 		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"expected 5,8,11, or 16"));
 
-	((BPy_Scene*)self)->scene->r.osa = level;
+	self->renderContext->osa = level;
 	allqueue(REDRAWBUTSSCENE, 0);
   
 	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_EnableMotionBlur(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableMotionBlur() -------------------------------------------------
+PyObject *RenderData_EnableMotionBlur(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_MBLUR, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_MBLUR, &self->renderContext->mode);
 }
-
-PyObject *M_Render_MotionBlurLevel(PyObject *self, PyObject *args)
+//------------------------------------RenderData.MotionBlurLevel() ----------------------------------------------------
+PyObject *RenderData_MotionBlurLevel(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeFloat(args, &((BPy_Scene*)self)->scene->r.blurfac, 0.01f, 5.0f);
+	return M_Render_GetSetAttributeFloat(args, &self->renderContext->blurfac, 0.01f, 5.0f);
 }
-
-PyObject *M_Render_PartsX(PyObject *self, PyObject *args)
+//------------------------------------RenderData.PartsX() ------------------------------------------------------------
+PyObject *RenderData_PartsX(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.xparts, 1, 64);
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->xparts, 1, 64);
 }
-
-PyObject *M_Render_PartsY(PyObject *self, PyObject *args)
+//------------------------------------RenderData.PartsY() -------------------------------------------------------------
+PyObject *RenderData_PartsY(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.yparts, 1, 64);
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->yparts, 1, 64);
 }
-
-PyObject *M_Render_EnableSky(PyObject *self)
+//------------------------------------RenderData.EnableSky() ------------------------------------------------------
+PyObject *RenderData_EnableSky(BPy_RenderData *self)
 {
-	((BPy_Scene*)self)->scene->r.alphamode = R_ADDSKY;
+	self->renderContext->alphamode = R_ADDSKY;
 	allqueue(REDRAWBUTSSCENE, 0);
 
  	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_EnablePremultiply(PyObject *self)
+//------------------------------------RenderData.EnablePremultiply() ------------------------------------------
+PyObject *RenderData_EnablePremultiply(BPy_RenderData *self)
 {
-	((BPy_Scene*)self)->scene->r.alphamode = R_ALPHAPREMUL;
+	self->renderContext->alphamode = R_ALPHAPREMUL;
 	allqueue(REDRAWBUTSSCENE, 0);
 
   	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_EnableKey(PyObject *self)
+//------------------------------------RenderData.EnableKey() ----------------------------------------------------
+PyObject *RenderData_EnableKey(BPy_RenderData *self)
 {
-	((BPy_Scene*)self)->scene->r.alphamode = R_ALPHAKEY;
+	self->renderContext->alphamode = R_ALPHAKEY;
 	allqueue(REDRAWBUTSSCENE, 0);
 
    	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_EnableShadow(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableShadow() ------------------------------------------
+PyObject *RenderData_EnableShadow(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_SHADOW, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_SHADOW, &self->renderContext->mode);
 }
-
-PyObject *M_Render_EnableEnvironmentMap(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnvironmentMap() ------------------------------------------
+PyObject *RenderData_EnableEnvironmentMap(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_ENVMAP, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_ENVMAP, &self->renderContext->mode);
 }
-
-PyObject *M_Render_EnablePanorama(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnablePanorama() ------------------------------------------
+PyObject *RenderData_EnablePanorama(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_PANORAMA, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_PANORAMA, &self->renderContext->mode);
 }
-
-PyObject *M_Render_EnableRayTracing(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableRayTracing() ------------------------------------------
+PyObject *RenderData_EnableRayTracing(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_RAYTRACE, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_RAYTRACE, &self->renderContext->mode);
 }
-
-PyObject *M_Render_EnableRadiosityRender(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableRadiosityRender() ------------------------------------------
+PyObject *RenderData_EnableRadiosityRender(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_RADIO, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_RADIO, &self->renderContext->mode);
 }
-
-PyObject *M_Render_SetRenderWinSize(PyObject *self, PyObject *args)
+//------------------------------------RenderData.SetRenderWinSize() ------------------------------------------
+PyObject *RenderData_SetRenderWinSize(BPy_RenderData *self, PyObject *args)
 {
 	int size;
 
@@ -561,84 +1006,83 @@ PyObject *M_Render_SetRenderWinSize(PyObject *self, PyObject *args)
  		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"expected 25, 50, 75, or 100"));
 
-	((BPy_Scene*)self)->scene->r.size = size;
+	self->renderContext->size = size;
 	allqueue(REDRAWBUTSSCENE, 0);
   
 	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_EnableFieldRendering(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableFieldRendering() ------------------------------------------
+PyObject *RenderData_EnableFieldRendering(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_FIELDS, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_FIELDS, &self->renderContext->mode);
 }
-
-PyObject *M_Render_EnableOddFieldFirst(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableOddFieldFirst() ------------------------------------------
+PyObject *RenderData_EnableOddFieldFirst(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_ODDFIELD, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_ODDFIELD, &self->renderContext->mode);
 }
-
-PyObject *M_Render_EnableFieldTimeDisable(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableFieldTimeDisable() ------------------------------------------
+PyObject *RenderData_EnableFieldTimeDisable(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_FIELDSTILL, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_FIELDSTILL, &self->renderContext->mode);
 }
-
-PyObject *M_Render_EnableGaussFilter(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableGaussFilter() ------------------------------------------
+PyObject *RenderData_EnableGaussFilter(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_GAUSS, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_GAUSS, &self->renderContext->mode);
 }
-
-PyObject *M_Render_EnableBorderRender(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableBorderRender() ------------------------------------------
+PyObject *RenderData_EnableBorderRender(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_BORDER, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_BORDER, &self->renderContext->mode);
 }
-
-PyObject *M_Render_EnableGammaCorrection(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableGammaCorrection() ------------------------------------------
+PyObject *RenderData_EnableGammaCorrection(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_GAMMA, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_GAMMA, &self->renderContext->mode);
 }
-
-PyObject *M_Render_GaussFilterSize(PyObject *self, PyObject *args)
+//------------------------------------RenderData.GaussFilterSize() ------------------------------------------------------
+PyObject *RenderData_GaussFilterSize(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeFloat(args, &((BPy_Scene*)self)->scene->r.gauss, 0.5f, 1.5f);
+	return M_Render_GetSetAttributeFloat(args, &self->renderContext->gauss, 0.5f, 1.5f);
 }
-
-PyObject *M_Render_StartFrame(PyObject *self, PyObject *args)
+//------------------------------------RenderData.StartFrame() --------------------------------------------------------
+PyObject *RenderData_StartFrame(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.sfra, 1, 18000);
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->sfra, 1, 18000);
 }
-
-PyObject *M_Render_EndFrame(PyObject *self, PyObject *args)
+//------------------------------------RenderData.CurrentFrame() --------------------------------------------------------
+PyObject *RenderData_CurrentFrame(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.efra, 1, 18000);
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->cfra, 1, 18000);
 }
- 
-PyObject *M_Render_ImageSizeX(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EndFrame() ---------------------------------------------------------
+PyObject *RenderData_EndFrame(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.xsch, 4, 10000);
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->efra, 1, 18000);
 }
-
-PyObject *M_Render_ImageSizeY(PyObject *self, PyObject *args)
+ //------------------------------------RenderData.ImageSizeX() ---------------------------------------------------------
+PyObject *RenderData_ImageSizeX(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.ysch, 4, 10000);
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->xsch, 4, 10000);
 }
-
-PyObject *M_Render_AspectRatioX(PyObject *self, PyObject *args)
+//------------------------------------RenderData.ImageSizeY() -------------------------------------------------------
+PyObject *RenderData_ImageSizeY(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.xasp, 1, 200);
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->ysch, 4, 10000);
 }
-
-PyObject *M_Render_AspectRatioY(PyObject *self, PyObject *args)
+//------------------------------------RenderData.AspectRatioX() ----------------------------------------------------
+PyObject *RenderData_AspectRatioX(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.yasp, 1, 200);
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->xasp, 1, 200);
 }
-
-PyObject *M_Render_SetRenderer(PyObject *self, PyObject *args)
+//------------------------------------RenderData.AspectRatioY() ----------------------------------------------------
+PyObject *RenderData_AspectRatioY(BPy_RenderData *self, PyObject *args)
+{
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->yasp, 1, 200);
+}
+//------------------------------------RenderData.SetRenderer() ----------------------------------------------------
+PyObject *RenderData_SetRenderer(BPy_RenderData *self, PyObject *args)
 {
 	int type;
 
@@ -647,9 +1091,9 @@ PyObject *M_Render_SetRenderer(PyObject *self, PyObject *args)
 						"expected constant INTERN or YAFRAY"));
 
 	if(type == R_INTERN)
-		((BPy_Scene*)self)->scene->r.renderer = R_INTERN;
+		self->renderContext->renderer = R_INTERN;
 	else if (type == R_YAFRAY)
-		((BPy_Scene*)self)->scene->r.renderer = R_YAFRAY;
+		self->renderContext->renderer = R_YAFRAY;
 	else
  		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"expected INTERN or YAFRAY"));
@@ -657,14 +1101,13 @@ PyObject *M_Render_SetRenderer(PyObject *self, PyObject *args)
 	allqueue(REDRAWBUTSSCENE, 0);
  	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_EnableCropping(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableCropping() ----------------------------------------------------
+PyObject *RenderData_EnableCropping(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_MOVIECROP, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_MOVIECROP, &self->renderContext->mode);
 }
-
-PyObject *M_Render_SetImageType(PyObject *self, PyObject *args)
+//------------------------------------RenderData.SetImageType() ----------------------------------------------------
+PyObject *RenderData_SetImageType(BPy_RenderData *self, PyObject *args)
 {
 	int type;
 
@@ -673,33 +1116,33 @@ PyObject *M_Render_SetImageType(PyObject *self, PyObject *args)
 						"expected constant"));
 
 	if(type == R_AVIRAW)
-		((BPy_Scene*)self)->scene->r.imtype = R_AVIRAW;
+		self->renderContext->imtype = R_AVIRAW;
 	else if (type == R_AVIJPEG)
-		((BPy_Scene*)self)->scene->r.imtype = R_AVIJPEG;
+		self->renderContext->imtype = R_AVIJPEG;
 #ifdef _WIN32
 	else if (type == R_AVICODEC)
-		((BPy_Scene*)self)->scene->r.imtype = R_AVICODEC;
+		self->renderContext->imtype = R_AVICODEC;
 #endif
 	else if (type == R_QUICKTIME && G.have_quicktime)
-		((BPy_Scene*)self)->scene->r.imtype = R_QUICKTIME;
+		self->renderContext->imtype = R_QUICKTIME;
 	else if (type == R_TARGA)
-		((BPy_Scene*)self)->scene->r.imtype = R_TARGA;
+		self->renderContext->imtype = R_TARGA;
 	else if (type == R_RAWTGA)
-		((BPy_Scene*)self)->scene->r.imtype = R_RAWTGA;
+		self->renderContext->imtype = R_RAWTGA;
 	else if (type == R_PNG)
-		((BPy_Scene*)self)->scene->r.imtype = R_PNG;
+		self->renderContext->imtype = R_PNG;
 	else if (type == R_BMP)
-		((BPy_Scene*)self)->scene->r.imtype = R_BMP;
+		self->renderContext->imtype = R_BMP;
 	else if (type == R_JPEG90)
-		((BPy_Scene*)self)->scene->r.imtype = R_JPEG90;
+		self->renderContext->imtype = R_JPEG90;
 	else if (type == R_HAMX)
-		((BPy_Scene*)self)->scene->r.imtype = R_HAMX;
+		self->renderContext->imtype = R_HAMX;
 	else if (type == R_IRIS)
-		((BPy_Scene*)self)->scene->r.imtype = R_IRIS;
+		self->renderContext->imtype = R_IRIS;
 	else if (type == R_IRIZ)
-		((BPy_Scene*)self)->scene->r.imtype = R_IRIZ;
+		self->renderContext->imtype = R_IRIZ;
 	else if (type == R_FTYPE)
-		((BPy_Scene*)self)->scene->r.imtype = R_FTYPE;
+		self->renderContext->imtype = R_FTYPE;
 	else
  		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"unknown constant - see modules dict for help"));
@@ -707,60 +1150,42 @@ PyObject *M_Render_SetImageType(PyObject *self, PyObject *args)
 	allqueue(REDRAWBUTSSCENE, 0);
  	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_Quality(PyObject *self, PyObject *args)
+//------------------------------------RenderData.Quality() ----------------------------------------------------
+PyObject *RenderData_Quality(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.quality, 10, 100);
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->quality, 10, 100);
 }
-
-PyObject *M_Render_FramesPerSec(PyObject *self, PyObject *args)
+//------------------------------------RenderData.FramesPerSec() ----------------------------------------------------
+PyObject *RenderData_FramesPerSec(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.frs_sec, 1, 120);
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->frs_sec, 1, 120);
 }
-
-PyObject *M_Render_EnableGrayscale(PyObject *self)
+//------------------------------------RenderData.EnableGrayscale() ----------------------------------------------------
+PyObject *RenderData_EnableGrayscale(BPy_RenderData *self)
 {
-	((BPy_Scene*)self)->scene->r.planes = R_PLANESBW;
+	self->renderContext->planes = R_PLANESBW;
 	allqueue(REDRAWBUTSSCENE, 0);
 
  	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_EnableRGBColor(PyObject *self)
+//------------------------------------RenderData.EnableRGBColor() ----------------------------------------------------
+PyObject *RenderData_EnableRGBColor(BPy_RenderData *self)
 {
-	((BPy_Scene*)self)->scene->r.planes = R_PLANES24;
+	self->renderContext->planes = R_PLANES24;
 	allqueue(REDRAWBUTSSCENE, 0);
 
   	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_EnableRGBAColor(PyObject *self)
+//------------------------------------RenderData.EnableRGBAColor() ----------------------------------------------------
+PyObject *RenderData_EnableRGBAColor(BPy_RenderData *self)
 {
-	((BPy_Scene*)self)->scene->r.planes = R_PLANES32;
+	self->renderContext->planes = R_PLANES32;
 	allqueue(REDRAWBUTSSCENE, 0);
 
    	return EXPP_incr_ret(Py_None);
 }
-
-static void M_Render_DoSizePreset(PyObject *self, short xsch, short ysch, short xasp,
-									   short yasp, short size, short xparts, short yparts,
-									   short frames, float a, float b, float c, float d)
-{
-		((BPy_Scene*)self)->scene->r.xsch= xsch;
-		((BPy_Scene*)self)->scene->r.ysch= ysch;
-		((BPy_Scene*)self)->scene->r.xasp= xasp;
-		((BPy_Scene*)self)->scene->r.yasp= yasp;
-		((BPy_Scene*)self)->scene->r.size= size;
-		((BPy_Scene*)self)->scene->r.frs_sec= frames;
-		((BPy_Scene*)self)->scene->r.xparts= xparts;
-		((BPy_Scene*)self)->scene->r.yparts= yparts;
-
-		BLI_init_rctf(&((BPy_Scene*)self)->scene->r.safety, a, b, c, d);
-		allqueue(REDRAWBUTSSCENE, 0);
-		allqueue(REDRAWVIEWCAM, 0);
-}
-
-PyObject *M_Render_SizePreset(PyObject *self, PyObject *args)
+//------------------------------------RenderData.SizePreset() ----------------------------------------------------------------
+PyObject *RenderData_SizePreset(BPy_RenderData *self, PyObject *args)
 {
 	int type;
 
@@ -768,39 +1193,39 @@ PyObject *M_Render_SizePreset(PyObject *self, PyObject *args)
 		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"expected constant"));
 
-	if(type == R_PAL){
-		M_Render_DoSizePreset(self,720,576,54,51,100, ((BPy_Scene*)self)->scene->r.xparts,
-					  ((BPy_Scene*)self)->scene->r.yparts, 25, 0.1, 0.9, 0.1, 0.9);
-		((BPy_Scene*)self)->scene->r.mode &= ~R_PANORAMA;
-	}else if (type == R_NTSC){
+	if(type == B_PR_PAL){
+		M_Render_DoSizePreset(self,720,576,54,51,100, self->renderContext->xparts,
+					  self->renderContext->yparts, 25, 0.1, 0.9, 0.1, 0.9);
+		self->renderContext->mode &= ~R_PANORAMA;
+	}else if (type == B_PR_NTSC){
 		M_Render_DoSizePreset(self,720,480,10,11,100, 1, 1, 
 			30, 0.1, 0.9, 0.1, 0.9);
-		((BPy_Scene*)self)->scene->r.mode &= ~R_PANORAMA;
-	}else if (type == R_DEFAULT){
+		self->renderContext->mode &= ~R_PANORAMA;
+	}else if (type == B_PR_PRESET){
 		M_Render_DoSizePreset(self,720,576,54,51,100, 1, 1, 
-			((BPy_Scene*)self)->scene->r.frs_sec, 0.1, 0.9, 0.1, 0.9);
-		((BPy_Scene*)self)->scene->r.mode= R_OSA+R_SHADOW+R_FIELDS;
-		((BPy_Scene*)self)->scene->r.imtype= R_TARGA;
-	}else if (type == R_PREVIEW){
+			self->renderContext->frs_sec, 0.1, 0.9, 0.1, 0.9);
+		self->renderContext->mode= R_OSA+R_SHADOW+R_FIELDS;
+		self->renderContext->imtype= R_TARGA;
+	}else if (type == B_PR_PRV){
 		M_Render_DoSizePreset(self,640,512,1,1,50, 1, 1, 
-			((BPy_Scene*)self)->scene->r.frs_sec, 0.1, 0.9, 0.1, 0.9);
-		((BPy_Scene*)self)->scene->r.mode &= ~R_PANORAMA;
-	}else if (type == R_PC){
+			self->renderContext->frs_sec, 0.1, 0.9, 0.1, 0.9);
+		self->renderContext->mode &= ~R_PANORAMA;
+	}else if (type == B_PR_PC){
 		M_Render_DoSizePreset(self,640,480,100,100,100, 1, 1, 
-			((BPy_Scene*)self)->scene->r.frs_sec, 0.0, 1.0, 0.0, 1.0);
-		((BPy_Scene*)self)->scene->r.mode &= ~R_PANORAMA;
-	}else if (type == R_PAL169){
+			self->renderContext->frs_sec, 0.0, 1.0, 0.0, 1.0);
+		self->renderContext->mode &= ~R_PANORAMA;
+	}else if (type == B_PR_PAL169){
 		M_Render_DoSizePreset(self,720,576,64,45,100, 1, 1, 
 			25, 0.1, 0.9, 0.1, 0.9);
-		((BPy_Scene*)self)->scene->r.mode &= ~R_PANORAMA;
-	}else if (type == R_PANO){
+		self->renderContext->mode &= ~R_PANORAMA;
+	}else if (type == B_PR_PANO){
 		M_Render_DoSizePreset(self,36,176,115,100,100, 16, 1, 
-			((BPy_Scene*)self)->scene->r.frs_sec, 0.1, 0.9, 0.1, 0.9);
-		((BPy_Scene*)self)->scene->r.mode |= R_PANORAMA;
-	}else if (type == R_FULL){
+			self->renderContext->frs_sec, 0.1, 0.9, 0.1, 0.9);
+		self->renderContext->mode |= R_PANORAMA;
+	}else if (type == B_PR_FULL){
 		M_Render_DoSizePreset(self,1280,1024,1,1,100, 1, 1, 
-			((BPy_Scene*)self)->scene->r.frs_sec, 0.1, 0.9, 0.1, 0.9);
-		((BPy_Scene*)self)->scene->r.mode &= ~R_PANORAMA;
+			self->renderContext->frs_sec, 0.1, 0.9, 0.1, 0.9);
+		self->renderContext->mode &= ~R_PANORAMA;
 	}else
  		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"unknown constant - see modules dict for help"));
@@ -808,14 +1233,13 @@ PyObject *M_Render_SizePreset(PyObject *self, PyObject *args)
 	allqueue(REDRAWBUTSSCENE, 0);
 	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_EnableUnifiedRenderer(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableUnifiedRenderer() ----------------------------------------------------
+PyObject *RenderData_EnableUnifiedRenderer(BPy_RenderData *self, PyObject *args)
 {
-	M_Render_BitToggleInt(args, R_UNIFIED, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return M_Render_BitToggleInt(args, R_UNIFIED, &self->renderContext->mode);
 }
-
-PyObject *M_Render_SetYafrayGIQuality(PyObject *self, PyObject *args)
+//------------------------------------RenderData.SetYafrayGIQuality() ----------------------------------------------------
+PyObject *RenderData_SetYafrayGIQuality(BPy_RenderData *self, PyObject *args)
 {
 	int type;
 
@@ -826,7 +1250,7 @@ PyObject *M_Render_SetYafrayGIQuality(PyObject *self, PyObject *args)
 	if( type == PY_NONE   || type == PY_LOW  ||
 		type == PY_MEDIUM || type == PY_HIGH ||
 		type == PY_HIGHER || type == PY_BEST){
-		((BPy_Scene*)self)->scene->r.GIquality = type;
+		self->renderContext->GIquality = type;
 	}else
  		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"unknown constant - see modules dict for help"));
@@ -834,8 +1258,8 @@ PyObject *M_Render_SetYafrayGIQuality(PyObject *self, PyObject *args)
 	allqueue(REDRAWBUTSSCENE, 0);
 	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_SetYafrayGIMethod(PyObject *self, PyObject *args)
+//------------------------------------RenderData.SetYafrayGIMethod() ----------------------------------------------------
+PyObject *RenderData_SetYafrayGIMethod(BPy_RenderData *self, PyObject *args)
 {
 	int type;
 
@@ -843,8 +1267,8 @@ PyObject *M_Render_SetYafrayGIMethod(PyObject *self, PyObject *args)
 		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"expected constant"));
 
-	if( type == PY_NONE   || type == PY_SKYDOME  || type == PY_GIFULL){
-		((BPy_Scene*)self)->scene->r.GImethod = type;
+	if( type == PY_NONE   || type == PY_SKYDOME  || type == PY_FULL){
+		self->renderContext->GImethod = type;
 	}else
  		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"unknown constant - see modules dict for help"));
@@ -852,176 +1276,168 @@ PyObject *M_Render_SetYafrayGIMethod(PyObject *self, PyObject *args)
 	allqueue(REDRAWBUTSSCENE, 0);
 	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_YafrayGIPower(PyObject *self, PyObject *args)
+//------------------------------------RenderData.YafrayGIPower() ----------------------------------------------------
+PyObject *RenderData_YafrayGIPower(BPy_RenderData *self, PyObject *args)
 {
-	if (((BPy_Scene*)self)->scene->r.GImethod>0) {
-		return M_Render_GetSetAttributeFloat(args, &((BPy_Scene*)self)->scene->r.GIpower, 0.01f, 100.00f);
+	if (self->renderContext->GImethod>0) {
+		return M_Render_GetSetAttributeFloat(args, &self->renderContext->GIpower, 0.01f, 100.00f);
 	}else
 		return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"YafrayGIMethod must be set to 'SKYDOME' or 'FULL'"));
 }
-
-PyObject *M_Render_YafrayGIDepth(PyObject *self, PyObject *args)
+//------------------------------------RenderData.YafrayGIDepth() ----------------------------------------------------
+PyObject *RenderData_YafrayGIDepth(BPy_RenderData *self, PyObject *args)
 {
-	if (((BPy_Scene*)self)->scene->r.GImethod==2) {
-		return M_Render_GetSetAttributeInt(args, &((BPy_Scene*)self)->scene->r.GIdepth, 1, 8);
+	if (self->renderContext->GImethod==2) {
+		return M_Render_GetSetAttributeInt(args, &self->renderContext->GIdepth, 1, 8);
 	}else
 		return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"YafrayGIMethod must be set to 'FULL'"));
 }
-
-PyObject *M_Render_YafrayGICDepth(PyObject *self, PyObject *args)
+//------------------------------------RenderData.afrayGICDepth() ----------------------------------------------------
+PyObject *RenderData_YafrayGICDepth(BPy_RenderData *self, PyObject *args)
 {
-	if (((BPy_Scene*)self)->scene->r.GImethod==2) {
-		return M_Render_GetSetAttributeInt(args, &((BPy_Scene*)self)->scene->r.GIcausdepth, 1, 8);
+	if (self->renderContext->GImethod==2) {
+		return M_Render_GetSetAttributeInt(args, &self->renderContext->GIcausdepth, 1, 8);
 	}else
 		return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"YafrayGIMethod must be set to 'FULL'"));
 }
-
-PyObject *M_Render_EnableYafrayGICache(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableYafrayGICache() ----------------------------------------------------
+PyObject *RenderData_EnableYafrayGICache(BPy_RenderData *self, PyObject *args)
 {
-	if (((BPy_Scene*)self)->scene->r.GImethod==2) {
-		M_Render_BitToggleShort(args, 1, &((BPy_Scene*)self)->scene->r.GIcache);
+	if (self->renderContext->GImethod==2) {
+		return  M_Render_BitToggleShort(args, 1, &self->renderContext->GIcache);
 	}else
 		return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"YafrayGIMethod must be set to 'FULL'"));
-	
-	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_EnableYafrayGIPhotons(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableYafrayGIPhotons() ----------------------------------------------------
+PyObject *RenderData_EnableYafrayGIPhotons(BPy_RenderData *self, PyObject *args)
 {
-	if (((BPy_Scene*)self)->scene->r.GImethod==2) {
-		M_Render_BitToggleShort(args, 1, &((BPy_Scene*)self)->scene->r.GIphotons);;
+	if (self->renderContext->GImethod==2) {
+		return  M_Render_BitToggleShort(args, 1, &self->renderContext->GIphotons);;
 	}else
 		return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"YafrayGIMethod must be set to 'FULL'"));
-
-	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_YafrayGIPhotonCount(PyObject *self, PyObject *args)
+//------------------------------------RenderData.YafrayGIPhotonCount() ----------------------------------------------------
+PyObject *RenderData_YafrayGIPhotonCount(BPy_RenderData *self, PyObject *args)
 {
-	if (((BPy_Scene*)self)->scene->r.GImethod==2 && ((BPy_Scene*)self)->scene->r.GIphotons==1) {
-		return M_Render_GetSetAttributeInt(args, &((BPy_Scene*)self)->scene->r.GIphotoncount, 0, 10000000);
+	if (self->renderContext->GImethod==2 && self->renderContext->GIphotons==1) {
+		return M_Render_GetSetAttributeInt(args, &self->renderContext->GIphotoncount, 0, 10000000);
 	}else
 		return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"YafrayGIMethod must be set to 'FULL' and GIPhotons must be enabled\n"));
 }
-
-PyObject *M_Render_YafrayGIPhotonRadius(PyObject *self, PyObject *args)
+//------------------------------------RenderData.YafrayGIPhotonRadius() ----------------------------------------------------
+PyObject *RenderData_YafrayGIPhotonRadius(BPy_RenderData *self, PyObject *args)
 {
-	if (((BPy_Scene*)self)->scene->r.GImethod==2 && ((BPy_Scene*)self)->scene->r.GIphotons==1) {
-		return M_Render_GetSetAttributeFloat(args, &((BPy_Scene*)self)->scene->r.GIphotonradius, 0.00001f, 100.0f);
+	if (self->renderContext->GImethod==2 && self->renderContext->GIphotons==1) {
+		return M_Render_GetSetAttributeFloat(args, &self->renderContext->GIphotonradius, 0.00001f, 100.0f);
 	}else
 		return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"YafrayGIMethod must be set to 'FULL' and GIPhotons must be enabled\n"));
 }
-
-PyObject *M_Render_YafrayGIPhotonMixCount(PyObject *self, PyObject *args)
+//------------------------------------RenderData.YafrayGIPhotonMixCount() ----------------------------------------------------
+PyObject *RenderData_YafrayGIPhotonMixCount(BPy_RenderData *self, PyObject *args)
 {
-	if (((BPy_Scene*)self)->scene->r.GImethod==2 && ((BPy_Scene*)self)->scene->r.GIphotons==1) {
-		return M_Render_GetSetAttributeInt(args, &((BPy_Scene*)self)->scene->r.GImixphotons, 0, 1000);
+	if (self->renderContext->GImethod==2 && self->renderContext->GIphotons==1) {
+		return M_Render_GetSetAttributeInt(args, &self->renderContext->GImixphotons, 0, 1000);
 	}else
 		return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"YafrayGIMethod must be set to 'FULL' and GIPhotons must be enabled\n"));
 }
-
-PyObject *M_Render_EnableYafrayGITunePhotons(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableYafrayGITunePhotons() ----------------------------------------------------
+PyObject *RenderData_EnableYafrayGITunePhotons(BPy_RenderData *self, PyObject *args)
 {
-	if (((BPy_Scene*)self)->scene->r.GImethod==2 && ((BPy_Scene*)self)->scene->r.GIphotons==1) {
-		M_Render_BitToggleShort(args, 1, &((BPy_Scene*)self)->scene->r.GIdirect);;
+	if (self->renderContext->GImethod==2 && self->renderContext->GIphotons==1) {
+		return  M_Render_BitToggleShort(args, 1, &self->renderContext->GIdirect);;
 	}else
 		return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"YafrayGIMethod must be set to 'FULL' and GIPhotons must be enabled"));
-
-	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_YafrayGIShadowQuality(PyObject *self, PyObject *args)
+//------------------------------------RenderData.YafrayGIShadowQuality() ----------------------------------------------------
+PyObject *RenderData_YafrayGIShadowQuality(BPy_RenderData *self, PyObject *args)
 {
-	if (((BPy_Scene*)self)->scene->r.GImethod==2 && ((BPy_Scene*)self)->scene->r.GIcache==1) {
-		return M_Render_GetSetAttributeFloat(args, &((BPy_Scene*)self)->scene->r.GIshadowquality, 0.01f, 1.0f);
+	if (self->renderContext->GImethod==2 && self->renderContext->GIcache==1) {
+		return M_Render_GetSetAttributeFloat(args, &self->renderContext->GIshadowquality, 0.01f, 1.0f);
 	}else
 		return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"YafrayGIMethod must be set to 'FULL' and GICache must be enabled\n"));
 }
-
-PyObject *M_Render_YafrayGIPixelsPerSample(PyObject *self, PyObject *args)
+//------------------------------------RenderData.YafrayGIPixelsPerSample() ----------------------------------------------------
+PyObject *RenderData_YafrayGIPixelsPerSample(BPy_RenderData *self, PyObject *args)
 {
-	if (((BPy_Scene*)self)->scene->r.GImethod==2 && ((BPy_Scene*)self)->scene->r.GIcache==1) {
-		return M_Render_GetSetAttributeInt(args, &((BPy_Scene*)self)->scene->r.GIpixelspersample, 1, 50);
+	if (self->renderContext->GImethod==2 && self->renderContext->GIcache==1) {
+		return M_Render_GetSetAttributeInt(args, &self->renderContext->GIpixelspersample, 1, 50);
 	}else
 		return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"YafrayGIMethod must be set to 'FULL' and GICache must be enabled\n"));
 }
-
-PyObject *M_Render_EnableYafrayGIGradient(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableYafrayGIGradient() ----------------------------------------------------
+PyObject *RenderData_EnableYafrayGIGradient(BPy_RenderData *self, PyObject *args)
 {
-	if (((BPy_Scene*)self)->scene->r.GImethod==2 && ((BPy_Scene*)self)->scene->r.GIcache==1) {
-		M_Render_BitToggleShort(args, 1, &((BPy_Scene*)self)->scene->r.GIgradient);;
+	if (self->renderContext->GImethod==2 && self->renderContext->GIcache==1) {
+		return  M_Render_BitToggleShort(args, 1, &self->renderContext->GIgradient);;
 	}else
 		return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"YafrayGIMethod must be set to 'FULL' and GICache must be enabled"));
-
-	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_YafrayGIRefinement(PyObject *self, PyObject *args)
+//------------------------------------RenderData.YafrayGIRefinement() ----------------------------------------------------
+PyObject *RenderData_YafrayGIRefinement(BPy_RenderData *self, PyObject *args)
 {
-	if (((BPy_Scene*)self)->scene->r.GImethod==2 && ((BPy_Scene*)self)->scene->r.GIcache==1) {
-		return M_Render_GetSetAttributeFloat(args, &((BPy_Scene*)self)->scene->r.GIrefinement, 0.001f, 1.0f);
+	if (self->renderContext->GImethod==2 && self->renderContext->GIcache==1) {
+		return M_Render_GetSetAttributeFloat(args, &self->renderContext->GIrefinement, 0.001f, 1.0f);
 	}else
 		return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"YafrayGIMethod must be set to 'FULL' and GICache must be enabled\n"));
 }
-
-PyObject *M_Render_YafrayRayBias(PyObject *self, PyObject *args)
+//------------------------------------RenderData.YafrayRayBias() -------------------------------------------------------------
+PyObject *RenderData_YafrayRayBias(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeFloat(args, &((BPy_Scene*)self)->scene->r.YF_raybias, 0.0f, 10.0f);
+	return M_Render_GetSetAttributeFloat(args, &self->renderContext->YF_raybias, 0.0f, 10.0f);
 }
-
-PyObject *M_Render_YafrayRayDepth(PyObject *self, PyObject *args)
+//------------------------------------RenderData.YafrayRayDepth() -----------------------------------------------------------
+PyObject *RenderData_YafrayRayDepth(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeInt(args, &((BPy_Scene*)self)->scene->r.YF_raydepth, 1, 80);
+	return M_Render_GetSetAttributeInt(args, &self->renderContext->YF_raydepth, 1, 80);
 }
-
-PyObject *M_Render_YafrayGamma(PyObject *self, PyObject *args)
+//------------------------------------RenderData.YafrayGamma() -----------------------------------------------------------
+PyObject *RenderData_YafrayGamma(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeFloat(args, &((BPy_Scene*)self)->scene->r.YF_gamma, 0.001f, 5.0f);
+	return M_Render_GetSetAttributeFloat(args, &self->renderContext->YF_gamma, 0.001f, 5.0f);
 }
-
-PyObject *M_Render_YafrayExposure(PyObject *self, PyObject *args)
+//------------------------------------RenderData.YafrayExposure() -----------------------------------------------------------
+PyObject *RenderData_YafrayExposure(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeFloat(args, &((BPy_Scene*)self)->scene->r.YF_exposure, 0.0f, 10.0f);
+	return M_Render_GetSetAttributeFloat(args, &self->renderContext->YF_exposure, 0.0f, 10.0f);
 }
-
-PyObject *M_Render_YafrayProcessorCount(PyObject *self, PyObject *args)
+//------------------------------------RenderData.YafrayProcessorCount() -----------------------------------------------------------
+PyObject *RenderData_YafrayProcessorCount(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeInt(args, &((BPy_Scene*)self)->scene->r.YF_numprocs, 1, 8);
+	return M_Render_GetSetAttributeInt(args, &self->renderContext->YF_numprocs, 1, 8);
 }
-
-PyObject *M_Render_EnableGameFrameStretch(PyObject *self)
+//------------------------------------RenderData.EnableGameFrameStretch() -----------------------------------------------------------
+PyObject *RenderData_EnableGameFrameStretch(BPy_RenderData *self)
 {
-	((BPy_Scene*)self)->scene->framing.type = SCE_GAMEFRAMING_SCALE;
+	self->scene->framing.type = SCE_GAMEFRAMING_SCALE;
  	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_EnableGameFrameExpose(PyObject *self)
+//------------------------------------RenderData.EnableGameFrameExpose() -----------------------------------------------------------
+PyObject *RenderData_EnableGameFrameExpose(BPy_RenderData *self)
 {
-	((BPy_Scene*)self)->scene->framing.type = SCE_GAMEFRAMING_EXTEND;
+	self->scene->framing.type = SCE_GAMEFRAMING_EXTEND;
   	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_EnableGameFrameBars(PyObject *self)
+//------------------------------------RenderData.EnableGameFrameBars() -----------------------------------------------------------
+PyObject *RenderData_EnableGameFrameBars(BPy_RenderData *self)
 {
-	((BPy_Scene*)self)->scene->framing.type = SCE_GAMEFRAMING_BARS;
+	self->scene->framing.type = SCE_GAMEFRAMING_BARS;
    	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_SetGameFrameColor(PyObject *self, PyObject *args)
+//------------------------------------RenderData.SetGameFrameColor() -----------------------------------------------------------
+PyObject *RenderData_SetGameFrameColor(BPy_RenderData *self, PyObject *args)
 {
 	float red = 0.0f;
 	float green = 0.0f;
@@ -1041,88 +1457,86 @@ PyObject *M_Render_SetGameFrameColor(PyObject *self, PyObject *args)
  		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"value out of range 0.000 - 1.000 (blue)"));
 
-	((BPy_Scene*)self)->scene->framing.col[0] = red;
-	((BPy_Scene*)self)->scene->framing.col[1] = green;
-	((BPy_Scene*)self)->scene->framing.col[2] = blue;
+	self->scene->framing.col[0] = red;
+	self->scene->framing.col[1] = green;
+	self->scene->framing.col[2] = blue;
 
 	return EXPP_incr_ret(Py_None);
 }
-
-PyObject *M_Render_GetGameFrameColor(PyObject *self)
+//------------------------------------RenderData.GetGameFrameColor() -----------------------------------------------------------
+PyObject *RenderData_GetGameFrameColor(BPy_RenderData *self)
 {
 	char rgb[24];
 
-	sprintf(rgb, "[%.3f,%.3f,%.3f]\n", ((BPy_Scene*)self)->scene->framing.col[0],
-		((BPy_Scene*)self)->scene->framing.col[1], ((BPy_Scene*)self)->scene->framing.col[2]);
+	sprintf(rgb, "[%.3f,%.3f,%.3f]\n", self->scene->framing.col[0],
+		self->scene->framing.col[1], self->scene->framing.col[2]);
 	return PyString_FromString (rgb);
 }
-
-
-PyObject *M_Render_GammaLevel(PyObject *self, PyObject *args)
+//------------------------------------RenderData.GammaLevel() -----------------------------------------------------------
+PyObject *RenderData_GammaLevel(BPy_RenderData *self, PyObject *args)
 {
-	if(((BPy_Scene*)self)->scene->r.mode & R_UNIFIED){
-		return M_Render_GetSetAttributeFloat(args, &((BPy_Scene*)self)->scene->r.gamma, 0.2f, 5.0f);
+	if(self->renderContext->mode & R_UNIFIED){
+		return M_Render_GetSetAttributeFloat(args, &self->renderContext->gamma, 0.2f, 5.0f);
 	}else
   		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"Unified Render must be enabled"));
 }
-
-PyObject *M_Render_PostProcessAdd(PyObject *self, PyObject *args)
+//------------------------------------RenderData.PostProcessAdd() -----------------------------------------------------------
+PyObject *RenderData_PostProcessAdd(BPy_RenderData *self, PyObject *args)
 {
-	if(((BPy_Scene*)self)->scene->r.mode & R_UNIFIED){
-		return M_Render_GetSetAttributeFloat(args, &((BPy_Scene*)self)->scene->r.postadd, -1.0f, 1.0f);
+	if(self->renderContext->mode & R_UNIFIED){
+		return M_Render_GetSetAttributeFloat(args, &self->renderContext->postadd, -1.0f, 1.0f);
 	}else
   		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"Unified Render must be enabled"));
 }
-
-PyObject *M_Render_PostProcessMultiply(PyObject *self, PyObject *args)
+//------------------------------------RenderData.PostProcessMultiply() -----------------------------------------------------------
+PyObject *RenderData_PostProcessMultiply(BPy_RenderData *self, PyObject *args)
 {
-	if(((BPy_Scene*)self)->scene->r.mode & R_UNIFIED){
-		return M_Render_GetSetAttributeFloat(args, &((BPy_Scene*)self)->scene->r.postmul, 0.01f, 4.0f);
+	if(self->renderContext->mode & R_UNIFIED){
+		return M_Render_GetSetAttributeFloat(args, &self->renderContext->postmul, 0.01f, 4.0f);
 	}else
   		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"Unified Render must be enabled"));
 }
-
-PyObject *M_Render_PostProcessGamma(PyObject *self, PyObject *args)
+//------------------------------------RenderData.PostProcessGamma() -----------------------------------------------------------
+PyObject *RenderData_PostProcessGamma(BPy_RenderData *self, PyObject *args)
 {
-	if(((BPy_Scene*)self)->scene->r.mode & R_UNIFIED){
-		return M_Render_GetSetAttributeFloat(args, &((BPy_Scene*)self)->scene->r.postgamma, 0.2f, 2.0f);
+	if(self->renderContext->mode & R_UNIFIED){
+		return M_Render_GetSetAttributeFloat(args, &self->renderContext->postgamma, 0.2f, 2.0f);
 	}else
   		return (EXPP_ReturnPyObjError (PyExc_AttributeError,
 						"Unified Render must be enabled"));
 }
-
-PyObject *M_Render_SGIMaxsize(PyObject *self, PyObject *args)
+//------------------------------------RenderData.SGIMaxsize() -----------------------------------------------------------
+PyObject *RenderData_SGIMaxsize(BPy_RenderData *self, PyObject *args)
 {
 #ifdef __sgi
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.maximsize, 0, 500);
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->maximsize, 0, 500);
 #else
   	return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"SGI is not defined on this machine"));
 #endif
 }
-
-PyObject *M_Render_EnableSGICosmo(PyObject *self, PyObject *args)
+//------------------------------------RenderData.EnableSGICosmo() -----------------------------------------------------------
+PyObject *RenderData_EnableSGICosmo(BPy_RenderData *self, PyObject *args)
 {
 #ifdef __sgi
-	M_Render_BitToggleInt(args, R_COSMO, &((BPy_Scene*)self)->scene->r.mode);
-	return EXPP_incr_ret(Py_None);
+	return  M_Render_BitToggleInt(args, R_COSMO, &self->renderContext->mode);
 #else
   	return (EXPP_ReturnPyObjError (PyExc_StandardError,
 						"SGI is not defined on this machine"));
 #endif
 }
-
-PyObject *M_Render_OldMapValue(PyObject *self, PyObject *args)
+//------------------------------------RenderData.OldMapValue() -----------------------------------------------------------
+PyObject *RenderData_OldMapValue(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.framapto, 1, 900);
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->framapto, 1, 900);
 }
-
-PyObject *M_Render_NewMapValue(PyObject *self, PyObject *args)
+//------------------------------------RenderData.NewMapValue() -----------------------------------------------------------
+PyObject *RenderData_NewMapValue(BPy_RenderData *self, PyObject *args)
 {
-	return M_Render_GetSetAttributeShort(args, &((BPy_Scene*)self)->scene->r.images, 1, 900);
+	return M_Render_GetSetAttributeShort(args, &self->renderContext->images, 1, 900);
 }
 
 
diff --git a/source/blender/python/api2_2x/sceneRender.h b/source/blender/python/api2_2x/sceneRender.h
index fef168967d7..965e7b8ce78 100644
--- a/source/blender/python/api2_2x/sceneRender.h
+++ b/source/blender/python/api2_2x/sceneRender.h
@@ -33,139 +33,19 @@
 #define EXPP_SCENERENDER_H
 
 #include <Python.h>
-#include "mydevice.h"
-#include "render_types.h"
-#include "blendef.h"
-#include "Scene.h"
-#include "BIF_renderwin.h"
-#include "BKE_utildefines.h"
-#include "BKE_global.h"
-#include "DNA_scene_types.h"
-#include "DNA_image_types.h"
-#include "BIF_drawscene.h"
-#include "BLI_blenlib.h"
-#include "BKE_image.h"
-#include "BIF_space.h"
+#include <DNA_scene_types.h>
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+//------------------------------------Struct definitions----------------------------------------------------------------------
+typedef struct
+{
+  PyObject_HEAD
+  struct RenderData *renderContext;
+  Scene *scene;
+}BPy_RenderData;
+//------------------------------------Visible prototypes-------------------------------------------------------------------
+PyObject *Render_Init (void);
 
-//local defines
-#define R_PAL		1608
-#define R_FULL		1609
-#define R_PREVIEW	1610
-#define R_PAL169	1612
-#define R_DEFAULT	1618
-#define R_PANO		1619
-#define R_NTSC		1620
-#define R_PC		1624
-#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_GIFULL	2
-
-/*****************************************************************************/
-// Python API function prototypes for the Render module.												
-/*****************************************************************************/
-PyObject *M_Render_Render (PyObject *self);
-PyObject *M_Render_RenderAnim (PyObject *self);
-PyObject *M_Render_CloseRenderWindow (PyObject *self);
-PyObject *M_Render_Play (PyObject *self);
-PyObject *M_Render_SetRenderPath (PyObject *self, PyObject *args);
-PyObject *M_Render_GetRenderPath (PyObject *self);
-PyObject *M_Render_SetBackbufPath (PyObject *self, PyObject *args);
-PyObject *M_Render_GetBackbufPath (PyObject *self);
-PyObject *M_Render_EnableBackbuf (PyObject *self, PyObject *args);
-PyObject *M_Render_SetFtypePath (PyObject *self, PyObject *args);
-PyObject *M_Render_GetFtypePath (PyObject *self);
-PyObject *M_Render_EnableExtensions (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableSequencer (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableRenderDaemon (PyObject *self, PyObject *args);
-PyObject *M_Render_SetRenderWinPos (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableDispView (PyObject *self);
-PyObject *M_Render_EnableDispWin (PyObject *self);
-PyObject *M_Render_EnableToonShading (PyObject *self, PyObject *args);
-PyObject *M_Render_EdgeIntensity (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableEdgeShift (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableEdgeAll (PyObject *self, PyObject *args);
-PyObject *M_Render_SetEdgeColor (PyObject *self, PyObject *args);
-PyObject *M_Render_GetEdgeColor(PyObject *self);
-PyObject *M_Render_EdgeAntiShift (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableOversampling (PyObject *self, PyObject *args);
-PyObject *M_Render_SetOversamplingLevel (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableMotionBlur (PyObject *self, PyObject *args);
-PyObject *M_Render_MotionBlurLevel (PyObject *self, PyObject *args);
-PyObject *M_Render_PartsX (PyObject *self, PyObject *args);
-PyObject *M_Render_PartsY (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableSky (PyObject *self);
-PyObject *M_Render_EnablePremultiply (PyObject *self);
-PyObject *M_Render_EnableKey (PyObject *self);
-PyObject *M_Render_EnableShadow (PyObject *self, PyObject *args);
-PyObject *M_Render_EnablePanorama (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableEnvironmentMap (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableRayTracing (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableRadiosityRender (PyObject *self, PyObject *args);
-PyObject *M_Render_SetRenderWinSize (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableFieldRendering (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableOddFieldFirst (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableFieldTimeDisable (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableGaussFilter (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableBorderRender (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableGammaCorrection (PyObject *self, PyObject *args);
-PyObject *M_Render_GaussFilterSize (PyObject *self, PyObject *args);
-PyObject *M_Render_StartFrame (PyObject *self, PyObject *args);
-PyObject *M_Render_EndFrame (PyObject *self, PyObject *args);
-PyObject *M_Render_ImageSizeX (PyObject *self, PyObject *args);
-PyObject *M_Render_ImageSizeY (PyObject *self, PyObject *args);
-PyObject *M_Render_AspectRatioX (PyObject *self, PyObject *args);
-PyObject *M_Render_AspectRatioY (PyObject *self, PyObject *args);
-PyObject *M_Render_SetRenderer (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableCropping (PyObject *self, PyObject *args);
-PyObject *M_Render_SetImageType (PyObject *self, PyObject *args);
-PyObject *M_Render_Quality (PyObject *self, PyObject *args);
-PyObject *M_Render_FramesPerSec (PyObject *self, PyObject *args);
-PyObject *M_Render_EnableGrayscale (PyObject *self);
-PyObject *M_Render_EnableRGBColor (PyObject *self);
-PyObject *M_Render_EnableRGBAColor (PyObject *self);
-PyObject *M_Render_SizePreset(PyObject *self, PyObject *args);
-PyObject *M_Render_EnableUnifiedRenderer (PyObject *self, PyObject *args);
-PyObject *M_Render_SetYafrayGIQuality (PyObject *self, PyObject *args);
-PyObject *M_Render_SetYafrayGIMethod (PyObject *self, PyObject *args);
-PyObject *M_Render_YafrayGIPower(PyObject *self, PyObject *args);
-PyObject *M_Render_YafrayGIDepth(PyObject *self, PyObject *args);
-PyObject *M_Render_YafrayGICDepth(PyObject *self, PyObject *args);
-PyObject *M_Render_EnableYafrayGICache(PyObject *self, PyObject *args);
-PyObject *M_Render_EnableYafrayGIPhotons(PyObject *self, PyObject *args);
-PyObject *M_Render_YafrayGIPhotonCount(PyObject *self, PyObject *args);
-PyObject *M_Render_YafrayGIPhotonRadius(PyObject *self, PyObject *args);
-PyObject *M_Render_YafrayGIPhotonMixCount(PyObject *self, PyObject *args);
-PyObject *M_Render_EnableYafrayGITunePhotons(PyObject *self, PyObject *args);
-PyObject *M_Render_YafrayGIShadowQuality(PyObject *self, PyObject *args);
-PyObject *M_Render_YafrayGIPixelsPerSample(PyObject *self, PyObject *args);
-PyObject *M_Render_EnableYafrayGIGradient(PyObject *self, PyObject *args);
-PyObject *M_Render_YafrayGIRefinement(PyObject *self, PyObject *args);
-PyObject *M_Render_YafrayRayBias(PyObject *self, PyObject *args);
-PyObject *M_Render_YafrayRayDepth(PyObject *self, PyObject *args);
-PyObject *M_Render_YafrayGamma(PyObject *self, PyObject *args);
-PyObject *M_Render_YafrayExposure(PyObject *self, PyObject *args);
-PyObject *M_Render_YafrayProcessorCount(PyObject *self, PyObject *args);
-PyObject *M_Render_EnableGameFrameStretch(PyObject *self);
-PyObject *M_Render_EnableGameFrameExpose(PyObject *self);
-PyObject *M_Render_EnableGameFrameBars(PyObject *self);
-PyObject *M_Render_SetGameFrameColor(PyObject *self, PyObject *args);
-PyObject *M_Render_GetGameFrameColor(PyObject *self);
-PyObject *M_Render_GammaLevel(PyObject *self, PyObject *args);
-PyObject *M_Render_PostProcessAdd(PyObject *self, PyObject *args);
-PyObject *M_Render_PostProcessMultiply(PyObject *self, PyObject *args);
-PyObject *M_Render_PostProcessGamma(PyObject *self, PyObject *args);
-PyObject *M_Render_SGIMaxsize(PyObject *self, PyObject *args);
-PyObject *M_Render_EnableSGICosmo(PyObject *self, PyObject *args);
-PyObject *M_Render_OldMapValue(PyObject *self, PyObject *args);
-PyObject *M_Render_NewMapValue(PyObject *self, PyObject *args);
+PyObject *RenderData_CreatePyObject (struct Scene * scene);
+int RenderData_CheckPyObject (PyObject * py_obj);
 
 #endif /* EXPP_SCENERENDER_H */