Bugfix for [#29684] Output video presets messed up
[blender.git] / source / blender / makesrna / intern / rna_scene.c
index a946042..5426772 100644 (file)
@@ -1,6 +1,4 @@
 /*
- * $Id$
- *
  * ***** BEGIN GPL LICENSE BLOCK *****
  *
  * This program is free software; you can redistribute it and/or
@@ -42,6 +40,7 @@
 #include "BLI_math.h"
 
 /* Include for Bake Options */
+#include "RE_engine.h"
 #include "RE_pipeline.h"
 
 #ifdef WITH_QUICKTIME
@@ -57,6 +56,8 @@
 #include <libavformat/avformat.h>
 #endif
 
+#include "ED_render.h"
+
 #include "WM_api.h"
 #include "WM_types.h"
 
@@ -75,7 +76,7 @@ EnumPropertyItem proportional_falloff_items[] ={
        {PROP_ROOT, "ROOT", ICON_ROOTCURVE, "Root", "Root falloff"},
        {PROP_SHARP, "SHARP", ICON_SHARPCURVE, "Sharp", "Sharp falloff"},
        {PROP_LIN, "LINEAR", ICON_LINCURVE, "Linear", "Linear falloff"},
-       {PROP_CONST, "CONSTANT", ICON_NOCURVE, "Constant", "Consant falloff"},
+       {PROP_CONST, "CONSTANT", ICON_NOCURVE, "Constant", "Constant falloff"},
        {PROP_RANDOM, "RANDOM", ICON_RNDCURVE, "Random", "Random falloff"},
        {0, NULL, 0, NULL, NULL}};
 
@@ -101,65 +102,132 @@ EnumPropertyItem snap_element_items[] = {
        {SCE_SNAP_MODE_VOLUME, "VOLUME", ICON_SNAP_VOLUME, "Volume", "Snap to volume"},
        {0, NULL, 0, NULL, NULL}};
 
-EnumPropertyItem image_type_items[] = {
-       {0, "", 0, "Image", NULL},
-       {R_BMP, "BMP", ICON_FILE_IMAGE, "BMP", "Output image in bitmap format"},
+
+/* workaround for duplice enums,
+ * have each enum line as a defne then conditionally set it or not
+ */
+
+#define R_IMF_ENUM_BMP      {R_IMF_IMTYPE_BMP, "BMP", ICON_FILE_IMAGE, "BMP", "Output image in bitmap format"},
+#define R_IMF_ENUM_IRIS     {R_IMF_IMTYPE_IRIS, "IRIS", ICON_FILE_IMAGE, "Iris", "Output image in (old!) SGI IRIS format"},
+#define R_IMF_ENUM_PNG      {R_IMF_IMTYPE_PNG, "PNG", ICON_FILE_IMAGE, "PNG", "Output image in PNG format"},
+#define R_IMF_ENUM_JPEG     {R_IMF_IMTYPE_JPEG90, "JPEG", ICON_FILE_IMAGE, "JPEG", "Output image in JPEG format"},
+#define R_IMF_ENUM_TAGA     {R_IMF_IMTYPE_TARGA, "TARGA", ICON_FILE_IMAGE, "Targa", "Output image in Targa format"},
+#define R_IMF_ENUM_TAGA_RAW {R_IMF_IMTYPE_RAWTGA, "TARGA_RAW", ICON_FILE_IMAGE, "Targa Raw", "Output image in uncompressed Targa format"},
+
+
 #ifdef WITH_DDS
-       {R_DDS, "DDS", ICON_FILE_IMAGE, "DDS", "Output image in DDS format"},
+#  define R_IMF_ENUM_DDS {R_IMF_IMTYPE_DDS, "DDS", ICON_FILE_IMAGE, "DDS", "Output image in DDS format"},
+#else
+#  define R_IMF_ENUM_DDS
 #endif
-       {R_IRIS, "IRIS", ICON_FILE_IMAGE, "Iris", "Output image in (old!) SGI IRIS format"},
-       {R_PNG, "PNG", ICON_FILE_IMAGE, "PNG", "Output image in PNG format"},
-       {R_JPEG90, "JPEG", ICON_FILE_IMAGE, "JPEG", "Output image in JPEG format"},
+
 #ifdef WITH_OPENJPEG
-       {R_JP2, "JPEG2000", ICON_FILE_IMAGE, "JPEG 2000", "Output image in JPEG 2000 format"},
+#  define R_IMF_ENUM_JPEG2K {R_IMF_IMTYPE_JP2, "JPEG2000", ICON_FILE_IMAGE, "JPEG 2000", "Output image in JPEG 2000 format"},
+#else
+#  define R_IMF_ENUM_JPEG2K
 #endif
-       {R_TARGA, "TARGA", ICON_FILE_IMAGE, "Targa", "Output image in Targa format"},
-       {R_RAWTGA, "TARGA_RAW", ICON_FILE_IMAGE, "Targa Raw", "Output image in uncompressed Targa format"},
-       {0, "", 0, " ", NULL},
+
 #ifdef WITH_CINEON
-       {R_CINEON, "CINEON", ICON_FILE_IMAGE, "Cineon", "Output image in Cineon format"},
-       {R_DPX, "DPX",ICON_FILE_IMAGE, "DPX", "Output image in DPX format"},
+#  define R_IMF_ENUM_CINEON {R_IMF_IMTYPE_CINEON, "CINEON", ICON_FILE_IMAGE, "Cineon", "Output image in Cineon format"},
+#  define R_IMF_ENUM_DPX    {R_IMF_IMTYPE_DPX, "DPX",ICON_FILE_IMAGE, "DPX", "Output image in DPX format"},
+#else
+#  define R_IMF_ENUM_CINEON
+#  define R_IMF_ENUM_DPX
 #endif
+
 #ifdef WITH_OPENEXR
-       {R_MULTILAYER, "MULTILAYER", ICON_FILE_IMAGE, "MultiLayer", "Output image in multilayer OpenEXR format"},
-       {R_OPENEXR, "OPEN_EXR", ICON_FILE_IMAGE, "OpenEXR", "Output image in OpenEXR format"},
+#  define R_IMF_ENUM_EXR_MULTI  {R_IMF_IMTYPE_MULTILAYER, "MULTILAYER", ICON_FILE_IMAGE, "MultiLayer", "Output image in multilayer OpenEXR format"},
+#  define R_IMF_ENUM_EXR        {R_IMF_IMTYPE_OPENEXR, "OPEN_EXR", ICON_FILE_IMAGE, "OpenEXR", "Output image in OpenEXR format"},
+#else
+#  define R_IMF_ENUM_EXR_MULTI
+#  define R_IMF_ENUM_EXR
 #endif
+
 #ifdef WITH_HDR
-       {R_RADHDR, "HDR", ICON_FILE_IMAGE, "Radiance HDR", "Output image in Radiance HDR format"},
+#  define R_IMF_ENUM_HDR  {R_IMF_IMTYPE_RADHDR, "HDR", ICON_FILE_IMAGE, "Radiance HDR", "Output image in Radiance HDR format"},
+#else
+#  define R_IMF_ENUM_HDR
 #endif
+
 #ifdef WITH_TIFF
-       {R_TIFF, "TIFF", ICON_FILE_IMAGE, "TIFF", "Output image in TIFF format"},
+#  define R_IMF_ENUM_TIFF {R_IMF_IMTYPE_TIFF, "TIFF", ICON_FILE_IMAGE, "TIFF", "Output image in TIFF format"},
+#else
+#  define R_IMF_ENUM_TIFF
 #endif
+
+
+#define IMAGE_TYPE_ITEMS_IMAGE_ONLY                                           \
+       R_IMF_ENUM_BMP                                                            \
+       R_IMF_ENUM_DDS                                                            \
+       R_IMF_ENUM_IRIS                                                           \
+       R_IMF_ENUM_PNG                                                            \
+       R_IMF_ENUM_JPEG                                                           \
+       R_IMF_ENUM_JPEG2K                                                         \
+       R_IMF_ENUM_TAGA                                                           \
+       R_IMF_ENUM_TAGA_RAW                                                       \
+       {0, "", 0, " ", NULL},                                                    \
+       R_IMF_ENUM_CINEON                                                         \
+       R_IMF_ENUM_DPX                                                            \
+       R_IMF_ENUM_EXR_MULTI                                                      \
+       R_IMF_ENUM_EXR                                                            \
+       R_IMF_ENUM_HDR                                                            \
+       R_IMF_ENUM_TIFF                                                           \
+
+
+EnumPropertyItem image_only_type_items[] = {
+
+       IMAGE_TYPE_ITEMS_IMAGE_ONLY
+
+    {0, NULL, 0, NULL, NULL}};
+
+EnumPropertyItem image_type_items[] = {
+       {0, "", 0, "Image", NULL},
+
+       IMAGE_TYPE_ITEMS_IMAGE_ONLY
+
        {0, "", 0, "Movie", NULL},
 #ifdef _WIN32
-       {R_AVICODEC, "AVICODEC", ICON_FILE_MOVIE, "AVI Codec", "Output video in AVI format"}, // XXX Missing codec menu
+       {R_IMF_IMTYPE_AVICODEC, "AVICODEC", ICON_FILE_MOVIE, "AVI Codec", "Output video in AVI format"}, // XXX Missing codec menu
 #endif
-       {R_AVIJPEG, "AVI_JPEG", ICON_FILE_MOVIE, "AVI JPEG", "Output video in AVI JPEG format"},
-       {R_AVIRAW, "AVI_RAW", ICON_FILE_MOVIE, "AVI Raw", "Output video in AVI Raw format"},
+       {R_IMF_IMTYPE_AVIJPEG, "AVI_JPEG", ICON_FILE_MOVIE, "AVI JPEG", "Output video in AVI JPEG format"},
+       {R_IMF_IMTYPE_AVIRAW, "AVI_RAW", ICON_FILE_MOVIE, "AVI Raw", "Output video in AVI Raw format"},
 #ifdef WITH_FRAMESERVER
-       {R_FRAMESERVER, "FRAMESERVER", ICON_FILE_SCRIPT, "Frame Server", "Output image to a frameserver"},
+       {R_IMF_IMTYPE_FRAMESERVER, "FRAMESERVER", ICON_FILE_SCRIPT, "Frame Server", "Output image to a frameserver"},
 #endif
 #ifdef WITH_FFMPEG
-       {R_H264, "H264", ICON_FILE_MOVIE, "H.264", "Output video in H.264 format"},
-       {R_FFMPEG, "FFMPEG", ICON_FILE_MOVIE, "MPEG", "Output video in MPEG format"},
-       {R_THEORA, "THEORA", ICON_FILE_MOVIE, "Ogg Theora", "Output video in Ogg format"},
+       {R_IMF_IMTYPE_H264, "H264", ICON_FILE_MOVIE, "H.264", "Output video in H.264 format"},
+       {R_IMF_IMTYPE_FFMPEG, "FFMPEG", ICON_FILE_MOVIE, "MPEG", "Output video in MPEG format"},
+       {R_IMF_IMTYPE_THEORA, "THEORA", ICON_FILE_MOVIE, "Ogg Theora", "Output video in Ogg format"},
 #endif
 #ifdef WITH_QUICKTIME
 #      ifdef USE_QTKIT
-       {R_QUICKTIME, "QUICKTIME_QTKIT", ICON_FILE_MOVIE, "QuickTime", "Output video in Quicktime format"},
+       {R_IMF_IMTYPE_QUICKTIME, "QUICKTIME_QTKIT", ICON_FILE_MOVIE, "QuickTime", "Output video in Quicktime format"},
 #      else
-       {R_QUICKTIME, "QUICKTIME_CARBON", ICON_FILE_MOVIE, "QuickTime", "Output video in Quicktime format"},
+       {R_IMF_IMTYPE_QUICKTIME, "QUICKTIME_CARBON", ICON_FILE_MOVIE, "QuickTime", "Output video in Quicktime format"},
 #      endif
 #endif
 #ifdef WITH_FFMPEG
-       {R_XVID, "XVID", ICON_FILE_MOVIE, "Xvid", "Output video in Xvid format"},
+       {R_IMF_IMTYPE_XVID, "XVID", ICON_FILE_MOVIE, "Xvid", "Output video in Xvid format"},
 #endif
        {0, NULL, 0, NULL, NULL}};
 
 EnumPropertyItem image_color_mode_items[] ={
-       {R_PLANESBW, "BW", 0, "BW", "Images get saved in 8 bits grayscale (only PNG, JPEG, TGA, TIF)"},
-       {R_PLANES24, "RGB", 0, "RGB", "Images are saved with RGB (color) data"},
-       {R_PLANES32, "RGBA", 0, "RGBA", "Images are saved with RGB and Alpha data (if supported)"},
+       {R_IMF_PLANES_BW, "BW", 0, "BW", "Images get saved in 8 bits grayscale (only PNG, JPEG, TGA, TIF)"},
+       {R_IMF_PLANES_RGB, "RGB", 0, "RGB", "Images are saved with RGB (color) data"},
+       {R_IMF_PLANES_RGBA, "RGBA", 0, "RGBA", "Images are saved with RGB and Alpha data (if supported)"},
+       {0, NULL, 0, NULL, NULL}};
+
+#define IMAGE_COLOR_MODE_BW   image_color_mode_items[0]
+#define IMAGE_COLOR_MODE_RGB  image_color_mode_items[1]
+#define IMAGE_COLOR_MODE_RGBA image_color_mode_items[2]
+
+EnumPropertyItem image_color_depth_items[] = {
+       /* 1 (monochrome) not used */
+       {R_IMF_CHAN_DEPTH_8,   "8", 0, "8",  "8 bit color channels"},
+       {R_IMF_CHAN_DEPTH_12, "12", 0, "12", "12 bit color channels"},
+       {R_IMF_CHAN_DEPTH_16, "16", 0, "16", "16 bit color channels"},
+       /* 24 not used */
+       {R_IMF_CHAN_DEPTH_32, "32", 0, "32", "32 bit color channels"},
        {0, NULL, 0, NULL, NULL}};
 
 #ifdef RNA_RUNTIME
@@ -175,7 +243,6 @@ EnumPropertyItem image_color_mode_items[] ={
 
 #include "BLI_threads.h"
 #include "BLI_editVert.h"
-#include "BLI_blenlib.h"
 
 #include "BKE_context.h"
 #include "BKE_global.h"
@@ -200,7 +267,7 @@ EnumPropertyItem image_color_mode_items[] ={
 #include "ED_mesh.h"
 #include "ED_keyframing.h"
 
-#include "RE_pipeline.h"
+#include "RE_engine.h"
 
 static int rna_Scene_object_bases_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
 {
@@ -529,7 +596,7 @@ static int rna_RenderSettings_threads_get(PointerRNA *ptr)
 static int rna_RenderSettings_is_movie_fomat_get(PointerRNA *ptr)
 {
        RenderData *rd= (RenderData*)ptr->data;
-       return BKE_imtype_is_movie(rd->imtype);
+       return BKE_imtype_is_movie(rd->im_format.imtype);
 }
 
 static int rna_RenderSettings_save_buffers_get(PointerRNA *ptr)
@@ -548,70 +615,175 @@ static int rna_RenderSettings_full_sample_get(PointerRNA *ptr)
        return (rd->scemode & R_FULL_SAMPLE) && !(rd->mode & R_BORDER);
 }
 
-static void rna_RenderSettings_file_format_set(PointerRNA *ptr, int value)
+static void rna_ImageFormatSettings_file_format_set(PointerRNA *ptr, int value)
 {
-       RenderData *rd= (RenderData*)ptr->data;
+       ImageFormatData *imf= (ImageFormatData *)ptr->data;
+       ID *id= ptr->id.data;
+       const char is_render= (id && GS(id->name) == ID_SCE);
+       /* see note below on why this is */
+       const char chan_flag= BKE_imtype_valid_channels(imf->imtype) | (is_render ? IMA_CHAN_FLAG_BW : 0);
+
+       imf->imtype= value;
+
+       /* ensure depth and color settings match */
+       if ( ((imf->planes == R_IMF_PLANES_BW) &&   !(chan_flag & IMA_CHAN_FLAG_BW)) ||
+            ((imf->planes == R_IMF_PLANES_RGBA) && !(chan_flag & IMA_CHAN_FLAG_ALPHA)))
+       {
+               imf->planes= R_IMF_PLANES_RGB;
+       }
 
-       rd->imtype= value;
+       /* ensure usable depth */
+       {
+               const int depth_ok= BKE_imtype_valid_depths(imf->imtype);
+               if ((imf->depth & depth_ok) == 0) {
+                       /* set first available depth */
+                       char depth_ls[]= {R_IMF_CHAN_DEPTH_32,
+                                         R_IMF_CHAN_DEPTH_24,
+                                         R_IMF_CHAN_DEPTH_16,
+                                         R_IMF_CHAN_DEPTH_12,
+                                         R_IMF_CHAN_DEPTH_8,
+                                         R_IMF_CHAN_DEPTH_1,
+                                         0};
+                       int i;
+
+                       for (i= 0; depth_ls[i]; i++) {
+                               if (depth_ok & depth_ls[i]) {
+                                       imf->depth= depth_ls[i];
+                                       break;
+                               }
+                       }
+               }
+       }
+
+       if (id && GS(id->name) == ID_SCE) {
+               Scene *scene= ptr->id.data;
+               RenderData *rd= &scene->r;
 #ifdef WITH_FFMPEG
-       ffmpeg_verify_image_type(rd);
+               ffmpeg_verify_image_type(rd, imf);
 #endif
 #ifdef WITH_QUICKTIME
-       quicktime_verify_image_type(rd);
+               quicktime_verify_image_type(rd, imf);
 #endif
+               (void)rd;
+       }
 }
 
-static int rna_SceneRender_file_ext_length(PointerRNA *ptr)
+static EnumPropertyItem *rna_ImageFormatSettings_file_format_itemf(bContext *C, PointerRNA *ptr,
+                                                                   PropertyRNA *UNUSED(prop), int *free)
 {
-       RenderData *rd= (RenderData*)ptr->data;
-       char ext[8];
-       ext[0]= '\0';
-       BKE_add_image_extension(ext, rd->imtype);
-       return strlen(ext);
+       ID *id= ptr->id.data;
+       if (id && GS(id->name) == ID_SCE) {
+               return image_type_items;
+       }
+       else {
+               return image_only_type_items;
+       }
 }
 
-static void rna_SceneRender_file_ext_get(PointerRNA *ptr, char *str)
+static EnumPropertyItem *rna_ImageFormatSettings_color_mode_itemf(bContext *C, PointerRNA *ptr,
+                                                                  PropertyRNA *UNUSED(prop), int *free)
 {
-       RenderData *rd= (RenderData*)ptr->data;
-       BKE_add_image_extension(str, rd->imtype);
+       ImageFormatData *imf= (ImageFormatData *)ptr->data;
+       ID *id= ptr->id.data;
+       const char is_render= (id && GS(id->name) == ID_SCE);
+
+       /* note, we need to act differently for render
+        * where 'BW' will force greyscale even if the output format writes
+        * as RGBA, this is age old blender convention and not sure how useful
+        * it really is but keep it for now - campbell */
+       const char chan_flag= BKE_imtype_valid_channels(imf->imtype) | (is_render ? IMA_CHAN_FLAG_BW : 0);
+
+       if (chan_flag == (IMA_CHAN_FLAG_BW|IMA_CHAN_FLAG_RGB|IMA_CHAN_FLAG_ALPHA)) {
+               return image_color_mode_items;
+       }
+       else {
+               int totitem= 0;
+               EnumPropertyItem *item= NULL;
+
+               if (chan_flag & IMA_CHAN_FLAG_BW)    RNA_enum_item_add(&item, &totitem, &IMAGE_COLOR_MODE_BW);
+               if (chan_flag & IMA_CHAN_FLAG_RGB)   RNA_enum_item_add(&item, &totitem, &IMAGE_COLOR_MODE_RGB);
+               if (chan_flag & IMA_CHAN_FLAG_ALPHA) RNA_enum_item_add(&item, &totitem, &IMAGE_COLOR_MODE_RGBA);
+
+               RNA_enum_item_end(&item, &totitem);
+               *free= 1;
+
+               return item;
+       }
 }
 
-void rna_RenderSettings_jpeg2k_preset_update(RenderData *rd)
+static EnumPropertyItem *rna_ImageFormatSettings_color_depth_itemf(bContext *C, PointerRNA *ptr,
+                                                                  PropertyRNA *UNUSED(prop), int *free)
 {
-       rd->subimtype &= ~(R_JPEG2K_12BIT|R_JPEG2K_16BIT | R_JPEG2K_CINE_PRESET|R_JPEG2K_CINE_48FPS);
-       
-       switch(rd->jp2_depth) {
-       case 8:         break;
-       case 12:        rd->subimtype |= R_JPEG2K_12BIT; break;
-       case 16:        rd->subimtype |= R_JPEG2K_16BIT; break;
+       ImageFormatData *imf= (ImageFormatData *)ptr->data;
+
+       if (imf == NULL) {
+               return image_color_depth_items;
        }
-       
-       switch(rd->jp2_preset) {
-       case 1: rd->subimtype |= R_JPEG2K_CINE_PRESET;                                          break;
-       case 2: rd->subimtype |= R_JPEG2K_CINE_PRESET|R_JPEG2K_CINE_48FPS;      break;
-       case 3: rd->subimtype |= R_JPEG2K_CINE_PRESET;                                          break;
-       case 4: rd->subimtype |= R_JPEG2K_CINE_PRESET;                                          break;
-       case 5: rd->subimtype |= R_JPEG2K_CINE_PRESET|R_JPEG2K_CINE_48FPS;      break;
-       case 6: rd->subimtype |= R_JPEG2K_CINE_PRESET;                                          break;
-       case 7: rd->subimtype |= R_JPEG2K_CINE_PRESET|R_JPEG2K_CINE_48FPS;      break;
+       else {
+               const int depth_ok= BKE_imtype_valid_depths(imf->imtype);
+               const int is_float= ELEM3(imf->imtype, R_IMF_IMTYPE_RADHDR, R_IMF_IMTYPE_OPENEXR, R_IMF_IMTYPE_MULTILAYER);
+
+               EnumPropertyItem *item_8bit=  &image_color_depth_items[0];
+               EnumPropertyItem *item_12bit= &image_color_depth_items[1];
+               EnumPropertyItem *item_16bit= &image_color_depth_items[2];
+               EnumPropertyItem *item_32bit= &image_color_depth_items[3];
+
+               int totitem= 0;
+               EnumPropertyItem *item= NULL;
+               EnumPropertyItem tmp = {0, "", 0, "", ""};
+
+               if (depth_ok & R_IMF_CHAN_DEPTH_8) {
+                       RNA_enum_item_add(&item, &totitem, item_8bit);
+               }
+
+               if (depth_ok & R_IMF_CHAN_DEPTH_12) {
+                       RNA_enum_item_add(&item, &totitem, item_12bit);
+               }
+
+               if (depth_ok & R_IMF_CHAN_DEPTH_16) {
+                       if (is_float) {
+                               tmp= *item_16bit;
+                               tmp.name= "Float (Half)";
+                               RNA_enum_item_add(&item, &totitem, &tmp);
+                       }
+                       else {
+                               RNA_enum_item_add(&item, &totitem, item_16bit);
+                       }
+               }
+
+               if (depth_ok & R_IMF_CHAN_DEPTH_32) {
+                       if (is_float) {
+                               tmp= *item_32bit;
+                               tmp.name= "Float (Full)";
+                               RNA_enum_item_add(&item, &totitem, &tmp);
+                       }
+                       else {
+                               RNA_enum_item_add(&item, &totitem, item_32bit);
+                       }
+               }
+
+               RNA_enum_item_end(&item, &totitem);
+               *free= 1;
+
+               return item;
        }
 }
 
-#ifdef WITH_OPENJPEG
-static void rna_RenderSettings_jpeg2k_preset_set(PointerRNA *ptr, int value)
+static int rna_SceneRender_file_ext_length(PointerRNA *ptr)
 {
        RenderData *rd= (RenderData*)ptr->data;
-       rd->jp2_preset= value;
-       rna_RenderSettings_jpeg2k_preset_update(rd);
+       char ext[8];
+       ext[0]= '\0';
+       BKE_add_image_extension(ext, rd->im_format.imtype);
+       return strlen(ext);
 }
 
-static void rna_RenderSettings_jpeg2k_depth_set(PointerRNA *ptr, int value)
+static void rna_SceneRender_file_ext_get(PointerRNA *ptr, char *str)
 {
        RenderData *rd= (RenderData*)ptr->data;
-       rd->jp2_depth= value;
-       rna_RenderSettings_jpeg2k_preset_update(rd);
+       str[0]= '\0';
+       BKE_add_image_extension(str, rd->im_format.imtype);
 }
-#endif
 
 #ifdef WITH_QUICKTIME
 static int rna_RenderSettings_qtcodecsettings_codecType_get(PointerRNA *ptr)
@@ -628,7 +800,8 @@ static void rna_RenderSettings_qtcodecsettings_codecType_set(PointerRNA *ptr, in
        rd->qtcodecsettings.codecType = quicktime_videocodecType_from_rnatmpvalue(value);
 }
 
-static EnumPropertyItem *rna_RenderSettings_qtcodecsettings_codecType_itemf(bContext *C, PointerRNA *ptr, PropertyRNA *UNUSED(prop), int *free)
+static EnumPropertyItem *rna_RenderSettings_qtcodecsettings_codecType_itemf(bContext *C, PointerRNA *ptr,
+                                                                            PropertyRNA *UNUSED(prop), int *free)
 {
        EnumPropertyItem *item= NULL;
        EnumPropertyItem tmp = {0, "", 0, "", ""};
@@ -669,7 +842,8 @@ static void rna_RenderSettings_qtcodecsettings_audiocodecType_set(PointerRNA *pt
        rd->qtcodecsettings.audiocodecType = quicktime_audiocodecType_from_rnatmpvalue(value);
 }
 
-static EnumPropertyItem *rna_RenderSettings_qtcodecsettings_audiocodecType_itemf(bContext *C, PointerRNA *ptr, PropertyRNA *UNUSED(prop), int *free)
+static EnumPropertyItem *rna_RenderSettings_qtcodecsettings_audiocodecType_itemf(bContext *C, PointerRNA *ptr,
+                                                                                 PropertyRNA *UNUSED(prop), int *free)
 {
        EnumPropertyItem *item= NULL;
        EnumPropertyItem tmp = {0, "", 0, "", ""};
@@ -731,6 +905,28 @@ static void rna_RenderSettings_active_layer_set(PointerRNA *ptr, PointerRNA valu
        if (index != -1) rd->actlay= index;
 }
 
+static SceneRenderLayer *rna_RenderLayer_new(ID *id, RenderData *UNUSED(rd), const char *name)
+{
+       Scene *scene= (Scene *)id;
+       SceneRenderLayer *srl= scene_add_render_layer(scene, name);
+
+       WM_main_add_notifier(NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       return srl;
+}
+
+static void rna_RenderLayer_remove(ID *id, RenderData *UNUSED(rd), Main *bmain, ReportList *reports, SceneRenderLayer *srl)
+{
+       Scene *scene= (Scene *)id;
+
+       if (!scene_remove_render_layer(bmain, scene, srl)) {
+               BKE_reportf(reports, RPT_ERROR, "RenderLayer '%s' could not be removed from scene '%s'", srl->name, scene->id.name+2);
+       }
+       else {
+               WM_main_add_notifier(NC_SCENE|ND_RENDER_OPTIONS, NULL);
+       }
+}
+
 static void rna_RenderSettings_engine_set(PointerRNA *ptr, int value)
 {
        RenderData *rd= (RenderData*)ptr->data;
@@ -740,7 +936,8 @@ static void rna_RenderSettings_engine_set(PointerRNA *ptr, int value)
                BLI_strncpy_utf8(rd->engine, type->idname, sizeof(rd->engine));
 }
 
-static EnumPropertyItem *rna_RenderSettings_engine_itemf(bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), int *free)
+static EnumPropertyItem *rna_RenderSettings_engine_itemf(bContext *UNUSED(C), PointerRNA *UNUSED(ptr),
+                                                         PropertyRNA *UNUSED(prop), int *free)
 {
        RenderEngineType *type;
        EnumPropertyItem *item= NULL;
@@ -773,6 +970,11 @@ static int rna_RenderSettings_engine_get(PointerRNA *ptr)
        return 0;
 }
 
+static void rna_RenderSettings_engine_update(Main *bmain, Scene *UNUSED(unused), PointerRNA *UNUSED(ptr))
+{
+       ED_render_engine_changed(bmain);
+}
+
 static void rna_Scene_glsl_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
 {
        Scene *scene= (Scene*)ptr->id.data;
@@ -809,8 +1011,8 @@ static void rna_SceneRenderLayer_name_set(PointerRNA *ptr, const char *value)
 {
        Scene *scene= (Scene*)ptr->id.data;
        SceneRenderLayer *rl= (SceneRenderLayer*)ptr->data;
-
        BLI_strncpy_utf8(rl->name, value, sizeof(rl->name));
+       BLI_uniquename(&scene->r.layers, rl, "RenderLayer", '.', offsetof(SceneRenderLayer, name), sizeof(rl->name));
 
        if(scene->nodetree) {
                bNode *node;
@@ -830,6 +1032,12 @@ static int rna_RenderSettings_multiple_engines_get(PointerRNA *UNUSED(ptr))
        return (BLI_countlist(&R_engines) > 1);
 }
 
+static int rna_RenderSettings_use_shading_nodes_get(PointerRNA *ptr)
+{
+       Scene *scene= (Scene*)ptr->id.data;
+       return scene_use_new_shading_nodes(scene);
+}
+
 static int rna_RenderSettings_use_game_engine_get(PointerRNA *ptr)
 {
        RenderData *rd= (RenderData*)ptr->data;
@@ -1005,6 +1213,13 @@ static void rna_GameSettings_auto_start_set(PointerRNA *UNUSED(ptr), int value)
                G.fileflags &= ~G_FILE_AUTOPLAY;
 }
 
+static void rna_GameSettings_exit_key_set(PointerRNA *ptr, int value)
+{
+       GameData *gm = (GameData*)ptr->data;
+
+       if(ISKEYBOARD(value))
+               gm->exitkey=value;
+}
 
 static TimeMarker *rna_TimeLine_add(Scene *scene, const char name[])
 {
@@ -1013,6 +1228,10 @@ static TimeMarker *rna_TimeLine_add(Scene *scene, const char name[])
        marker->frame= 1;
        BLI_strncpy_utf8(marker->name, name, sizeof(marker->name));
        BLI_addtail(&scene->markers, marker);
+
+       WM_main_add_notifier(NC_SCENE|ND_MARKERS, NULL);
+       WM_main_add_notifier(NC_ANIMATION|ND_MARKERS, NULL);
+
        return marker;
 }
 
@@ -1025,6 +1244,17 @@ static void rna_TimeLine_remove(Scene *scene, ReportList *reports, TimeMarker *m
 
        /* XXX, invalidates PyObject */
        MEM_freeN(marker);
+
+       WM_main_add_notifier(NC_SCENE|ND_MARKERS, NULL);
+       WM_main_add_notifier(NC_ANIMATION|ND_MARKERS, NULL);
+}
+
+static void rna_TimeLine_clear(Scene *scene)
+{
+       BLI_freelistN(&scene->markers);
+
+       WM_main_add_notifier(NC_SCENE|ND_MARKERS, NULL);
+       WM_main_add_notifier(NC_ANIMATION|ND_MARKERS, NULL);
 }
 
 static KeyingSet *rna_Scene_keying_set_new(Scene *sce, ReportList *reports, const char name[])
@@ -1051,7 +1281,7 @@ static KeyingSet *rna_Scene_keying_set_new(Scene *sce, ReportList *reports, cons
  * is not for general use and only for the few cases where changing scene
  * settings and NOT for general purpose updates, possibly this should be
  * given its own notifier. */
-static void rna_Scene_update_active_object_data(Main *bmain, Scene *scene, PointerRNA *ptr)
+static void rna_Scene_update_active_object_data(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
 {
        Object *ob= OBACT;
        if(ob) {
@@ -1060,6 +1290,15 @@ static void rna_Scene_update_active_object_data(Main *bmain, Scene *scene, Point
        }
 }
 
+static void rna_SceneCamera_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
+{
+       Scene *scene= (Scene*)ptr->id.data;
+       Object *camera= scene->camera;
+
+       if(camera)
+               DAG_id_tag_update(&camera->id, 0);
+}
+
 #else
 
 static void rna_def_transform_orientation(BlenderRNA *brna)
@@ -1077,8 +1316,8 @@ static void rna_def_transform_orientation(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL);
        
        prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
-       RNA_def_property_string_sdna(prop, NULL, "name");
        RNA_def_struct_name_property(srna, prop);
+       RNA_def_property_ui_text(prop, "Name", "Name of the custom transform orientation");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL);
 }
 
@@ -1112,7 +1351,8 @@ static void rna_def_tool_settings(BlenderRNA  *brna)
        static EnumPropertyItem sketch_convert_items[] = {
                {SK_CONVERT_CUT_FIXED, "FIXED", 0, "Fixed", "Subdivide stroke in fixed number of bones"},
                {SK_CONVERT_CUT_LENGTH, "LENGTH", 0, "Length", "Subdivide stroke in bones of specific length"},
-               {SK_CONVERT_CUT_ADAPTATIVE, "ADAPTIVE", 0, "Adaptive", "Subdivide stroke adaptively, with more subdivision in curvier parts"},
+               {SK_CONVERT_CUT_ADAPTATIVE, "ADAPTIVE", 0, "Adaptive",
+                                           "Subdivide stroke adaptively, with more subdivision in curvier parts"},
                {SK_CONVERT_RETARGET, "RETARGET", 0, "Retarget", "Retarget template bone chain to stroke"},
                {0, NULL, 0, NULL, NULL}};
 
@@ -1165,7 +1405,8 @@ static void rna_def_tool_settings(BlenderRNA  *brna)
        prop= RNA_def_property(srna, "proportional_edit", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "proportional");
        RNA_def_property_enum_items(prop, proportional_editing_items);
-       RNA_def_property_ui_text(prop, "Proportional Editing", "Proportional Editing mode, allows transforms with distance fall-off");
+       RNA_def_property_ui_text(prop, "Proportional Editing",
+                                "Proportional Editing mode, allows transforms with distance fall-off");
        RNA_def_property_update(prop, NC_SCENE|ND_TOOLSETTINGS, NULL); /* header redraw */
 
        prop= RNA_def_property(srna, "use_proportional_edit_objects", PROP_BOOLEAN, PROP_NONE);
@@ -1228,13 +1469,14 @@ static void rna_def_tool_settings(BlenderRNA  *brna)
        
        prop= RNA_def_property(srna, "use_snap_project", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "snap_flag", SCE_SNAP_PROJECT);
-       RNA_def_property_ui_text(prop, "Project Individual Elements", "Project individual elements on the surface of other objects");
+       RNA_def_property_ui_text(prop, "Project Individual Elements",
+                                "Project individual elements on the surface of other objects");
        RNA_def_property_ui_icon(prop, ICON_RETOPO, 0);
        RNA_def_property_update(prop, NC_SCENE|ND_TOOLSETTINGS, NULL); /* header redraw */
 
        prop= RNA_def_property(srna, "use_snap_self", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_negative_sdna(prop, NULL, "snap_flag", SCE_SNAP_NO_SELF);
-       RNA_def_property_ui_text(prop, "Project to Self", "Snap onto its self (editmode)");
+       RNA_def_property_ui_text(prop, "Project to Self", "Snap onto itself (editmode)");
        RNA_def_property_ui_icon(prop, ICON_ORTHO, 0);
        RNA_def_property_update(prop, NC_SCENE|ND_TOOLSETTINGS, NULL); /* header redraw */
        
@@ -1257,11 +1499,14 @@ static void rna_def_tool_settings(BlenderRNA  *brna)
        
        prop= RNA_def_property(srna, "use_record_with_nla", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "autokey_flag", ANIMRECORD_FLAG_WITHNLA);
-       RNA_def_property_ui_text(prop, "Layered", "Add a new NLA Track + Strip for every loop/pass made over the animation to allow non-destructive tweaking");
+       RNA_def_property_ui_text(prop, "Layered",
+                                "Add a new NLA Track + Strip for every loop/pass made over the animation "
+                                "to allow non-destructive tweaking");
        
        prop= RNA_def_property(srna, "use_keyframe_insert_keyingset", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "autokey_flag", AUTOKEY_FLAG_ONLYKEYINGSET);
-       RNA_def_property_ui_text(prop, "Auto Keyframe Insert Keying Set", "Automatic keyframe insertion using active Keying Set only");
+       RNA_def_property_ui_text(prop, "Auto Keyframe Insert Keying Set",
+                                "Automatic keyframe insertion using active Keying Set only");
        RNA_def_property_ui_icon(prop, ICON_KEYINGSET, 0);
        
        /* UV */
@@ -1372,11 +1617,13 @@ static void rna_def_tool_settings(BlenderRNA  *brna)
 
        prop= RNA_def_property(srna, "sculpt_paint_use_unified_size", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "sculpt_paint_settings", SCULPT_PAINT_USE_UNIFIED_SIZE);
-       RNA_def_property_ui_text(prop, "Sculpt/Paint Use Unified Radius", "Instead of per brush radius, the radius is shared across brushes");
+       RNA_def_property_ui_text(prop, "Sculpt/Paint Use Unified Radius",
+                                "Instead of per brush radius, the radius is shared across brushes");
 
        prop= RNA_def_property(srna, "sculpt_paint_use_unified_strength", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "sculpt_paint_settings", SCULPT_PAINT_USE_UNIFIED_ALPHA);
-       RNA_def_property_ui_text(prop, "Sculpt/Paint Use Unified Strength", "Instead of per brush strength, the strength is shared across brushes");
+       RNA_def_property_ui_text(prop, "Sculpt/Paint Use Unified Strength",
+                                "Instead of per brush strength, the strength is shared across brushes");
 }
 
 
@@ -1728,13 +1975,13 @@ static void rna_def_scene_game_recast_data(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Agent Radius", "Radius of the agent");
        RNA_def_property_update(prop, NC_SCENE, NULL);
 
-       prop= RNA_def_property(srna, "max_climb", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "climb_max", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "agentmaxclimb");
        RNA_def_property_ui_range(prop, 0.1, 5, 1, 2);
        RNA_def_property_ui_text(prop, "Max Climb", "Maximum height between grid cells the agent can climb");
        RNA_def_property_update(prop, NC_SCENE, NULL);
 
-       prop= RNA_def_property(srna, "max_slope", PROP_FLOAT, PROP_ANGLE);
+       prop= RNA_def_property(srna, "slope_max", PROP_FLOAT, PROP_ANGLE);
        RNA_def_property_float_sdna(prop, NULL, "agentmaxslope");
        RNA_def_property_range(prop, 0, M_PI/2);
        RNA_def_property_ui_text(prop, "Max Slope", "Maximum walkable slope angle in degrees");
@@ -1744,13 +1991,13 @@ static void rna_def_scene_game_recast_data(BlenderRNA *brna)
        prop= RNA_def_property(srna, "region_min_size", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "regionminsize");
        RNA_def_property_ui_range(prop, 0, 150, 1, 2);
-       RNA_def_property_ui_text(prop, "Min Region Size", "Minimum regions size. Smaller regions will be deleted");
+       RNA_def_property_ui_text(prop, "Min Region Size", "Minimum regions size (smaller regions will be deleted)");
        RNA_def_property_update(prop, NC_SCENE, NULL);
 
        prop= RNA_def_property(srna, "region_merge_size", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "regionmergesize");
        RNA_def_property_ui_range(prop, 0, 150, 1, 2);
-       RNA_def_property_ui_text(prop, "Merged Region Size", "Minimum regions size. Smaller regions will be merged");
+       RNA_def_property_ui_text(prop, "Merged Region Size", "Minimum regions size (smaller regions will be merged)");
        RNA_def_property_update(prop, NC_SCENE, NULL);
 
        prop= RNA_def_property(srna, "edge_max_len", PROP_FLOAT, PROP_NONE);
@@ -1790,8 +2037,10 @@ static void rna_def_scene_game_data(BlenderRNA *brna)
        PropertyRNA *prop;
 
        static EnumPropertyItem framing_types_items[] ={
-               {SCE_GAMEFRAMING_BARS, "LETTERBOX", 0, "Letterbox", "Show the entire viewport in the display window, using bar horizontally or vertically"},
-               {SCE_GAMEFRAMING_EXTEND, "EXTEND", 0, "Extend", "Show the entire viewport in the display window, viewing more horizontally or vertically"},
+               {SCE_GAMEFRAMING_BARS, "LETTERBOX", 0, "Letterbox",
+                                      "Show the entire viewport in the display window, using bar horizontally or vertically"},
+               {SCE_GAMEFRAMING_EXTEND, "EXTEND", 0, "Extend",
+                                        "Show the entire viewport in the display window, viewing more horizontally or vertically"},
                {SCE_GAMEFRAMING_SCALE, "SCALE", 0, "Scale", "Stretch or squeeze the viewport to fill the display window"},
                {0, NULL, 0, NULL, NULL}};
 
@@ -1859,19 +2108,26 @@ static void rna_def_scene_game_data(BlenderRNA *brna)
        prop= RNA_def_property(srna, "depth", PROP_INT, PROP_UNSIGNED);
        RNA_def_property_int_sdna(prop, NULL, "depth");
        RNA_def_property_range(prop, 8, 32);
-       RNA_def_property_ui_text(prop, "Bits", "Displays bit depth of full screen display");
+       RNA_def_property_ui_text(prop, "Bits", "Display bit depth of full screen display");
+       RNA_def_property_update(prop, NC_SCENE, NULL);
+
+       prop= RNA_def_property(srna, "exit_key", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "exitkey");
+       RNA_def_property_enum_items(prop, event_type_items);
+       RNA_def_property_enum_funcs(prop, NULL, "rna_GameSettings_exit_key_set", NULL);
+       RNA_def_property_ui_text(prop, "Exit Key",  "The key that exits the Game Engine");
        RNA_def_property_update(prop, NC_SCENE, NULL);
        
        // Do we need it here ? (since we already have it in World
        prop= RNA_def_property(srna, "frequency", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "freqplay");
        RNA_def_property_range(prop, 4, 2000);
-       RNA_def_property_ui_text(prop, "Freq", "Displays clock frequency of fullscreen display");
+       RNA_def_property_ui_text(prop, "Freq", "Display clock frequency of fullscreen display");
        RNA_def_property_update(prop, NC_SCENE, NULL);
        
        prop= RNA_def_property(srna, "show_fullscreen", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "fullscreen", 1.0);
-       RNA_def_property_ui_text(prop, "Fullscreen", "Starts player in a new fullscreen display");
+       RNA_def_property_ui_text(prop, "Fullscreen", "Start player in a new fullscreen display");
        RNA_def_property_update(prop, NC_SCENE, NULL);
 
        /* Framing */
@@ -1904,7 +2160,8 @@ static void rna_def_scene_game_data(BlenderRNA *brna)
        prop= RNA_def_property(srna, "stereo_eye_separation", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "eyeseparation");
        RNA_def_property_range(prop, 0.01, 5.0);
-       RNA_def_property_ui_text(prop, "Eye Separation", "Set the distance between the eyes - the camera focal length/30 should be fine");
+       RNA_def_property_ui_text(prop, "Eye Separation",
+                                "Set the distance between the eyes - the camera focal length/30 should be fine");
        RNA_def_property_update(prop, NC_SCENE, NULL);
        
        /* Dome */
@@ -1962,35 +2219,44 @@ static void rna_def_scene_game_data(BlenderRNA *brna)
        prop= RNA_def_property(srna, "occlusion_culling_resolution", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "occlusionRes");
        RNA_def_property_range(prop, 128.0, 1024.0);
-       RNA_def_property_ui_text(prop, "Occlusion Resolution", "The size of the occlusion buffer in pixel, use higher value for better precision (slower)");
+       RNA_def_property_ui_text(prop, "Occlusion Resolution",
+                                "Size of the occlusion buffer in pixel, use higher value for better precision (slower)");
        RNA_def_property_update(prop, NC_SCENE, NULL);
 
        prop= RNA_def_property(srna, "fps", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "ticrate");
        RNA_def_property_ui_range(prop, 1, 60, 1, 1);
        RNA_def_property_range(prop, 1, 250);
-       RNA_def_property_ui_text(prop, "Frames Per Second", "The nominal number of game frames per second. Physics fixed timestep = 1/fps, independently of actual frame rate");
+       RNA_def_property_ui_text(prop, "Frames Per Second",
+                                "Nominal number of game frames per second "
+                                "(physics fixed timestep = 1/fps, independently of actual frame rate)");
        RNA_def_property_update(prop, NC_SCENE, NULL);
 
        prop= RNA_def_property(srna, "logic_step_max", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "maxlogicstep");
        RNA_def_property_ui_range(prop, 1, 5, 1, 1);
        RNA_def_property_range(prop, 1, 5);
-       RNA_def_property_ui_text(prop, "Max Logic Steps", "Sets the maximum number of logic frame per game frame if graphics slows down the game, higher value allows better synchronization with physics");
+       RNA_def_property_ui_text(prop, "Max Logic Steps",
+                                "Maximum number of logic frame per game frame if graphics slows down the game, "
+                                "higher value allows better synchronization with physics");
        RNA_def_property_update(prop, NC_SCENE, NULL);
 
        prop= RNA_def_property(srna, "physics_step_max", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "maxphystep");
        RNA_def_property_ui_range(prop, 1, 5, 1, 1);
        RNA_def_property_range(prop, 1, 5);
-       RNA_def_property_ui_text(prop, "Max Physics Steps", "Sets the maximum number of physics step per game frame if graphics slows down the game, higher value allows physics to keep up with realtime");
+       RNA_def_property_ui_text(prop, "Max Physics Steps",
+                                "Maximum number of physics step per game frame if graphics slows down the game, "
+                                "higher value allows physics to keep up with realtime");
        RNA_def_property_update(prop, NC_SCENE, NULL);
 
        prop= RNA_def_property(srna, "physics_step_sub", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "physubstep");
        RNA_def_property_ui_range(prop, 1, 5, 1, 1);
        RNA_def_property_range(prop, 1, 5);
-       RNA_def_property_ui_text(prop, "Physics Sub Steps", "Sets the number of simulation substep per physic timestep, higher value give better physics precision");
+       RNA_def_property_ui_text(prop, "Physics Sub Steps",
+                                "Number of simulation substep per physic timestep, "
+                                "higher value give better physics precision");
        RNA_def_property_update(prop, NC_SCENE, NULL);
 
        /* mode */
@@ -2007,7 +2273,9 @@ static void rna_def_scene_game_data(BlenderRNA *brna)
        prop= RNA_def_property(srna, "activity_culling_box_radius", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "activityBoxRadius");
        RNA_def_property_range(prop, 0.0, 1000.0);
-       RNA_def_property_ui_text(prop, "box radius", "Radius of the activity bubble, in Manhattan length. Objects outside the box are activity-culled");
+       RNA_def_property_ui_text(prop, "box radius",
+                                "Radius of the activity bubble, in Manhattan length "
+                                "(objects outside the box are activity-culled)");
 
        /* booleans */
        prop= RNA_def_property(srna, "show_debug_properties", PROP_BOOLEAN, PROP_NONE);
@@ -2016,7 +2284,8 @@ static void rna_def_scene_game_data(BlenderRNA *brna)
 
        prop= RNA_def_property(srna, "show_framerate_profile", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_SHOW_FRAMERATE);
-       RNA_def_property_ui_text(prop, "Show Framerate and Profile", "Show framerate and profiling information while the game runs");
+       RNA_def_property_ui_text(prop, "Show Framerate and Profile",
+                                "Show framerate and profiling information while the game runs");
 
        prop= RNA_def_property(srna, "show_physics_visualization", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_SHOW_PHYSICS);
@@ -2040,7 +2309,7 @@ static void rna_def_scene_game_data(BlenderRNA *brna)
 
        prop= RNA_def_property(srna, "use_animation_record", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_ENABLE_ANIMATION_RECORD);
-       RNA_def_property_ui_text(prop, "Record Animation", "Record animation to fcurves");
+       RNA_def_property_ui_text(prop, "Record Animation", "Record animation to F-Curves");
 
        prop= RNA_def_property(srna, "use_auto_start", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_funcs(prop, "rna_GameSettings_auto_start_get", "rna_GameSettings_auto_start_set");
@@ -2049,8 +2318,8 @@ static void rna_def_scene_game_data(BlenderRNA *brna)
        prop= RNA_def_property(srna, "restrict_animation_updates", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_RESTRICT_ANIM_UPDATES);
        RNA_def_property_ui_text(prop, "Restrict Animation Updates",
-                                "Restrict the number of animation updates to the animation FPS. This is "
-                                "better for performance, but can cause issues with smooth playback");
+                                "Restrict the number of animation updates to the animation FPS (this is "
+                                "better for performance, but can cause issues with smooth playback)");
        
        /* materials */
        prop= RNA_def_property(srna, "material_mode", PROP_ENUM, PROP_NONE);
@@ -2139,8 +2408,8 @@ static void rna_def_render_layers(BlenderRNA *brna, PropertyRNA *cprop)
        StructRNA *srna;
        PropertyRNA *prop;
 
-       // FunctionRNA *func;
-       // PropertyRNA *parm; 
+       FunctionRNA *func;
+       PropertyRNA *parm;
 
        RNA_def_property_srna(cprop, "RenderLayers");
        srna= RNA_def_struct(brna, "RenderLayers", NULL);
@@ -2149,17 +2418,164 @@ static void rna_def_render_layers(BlenderRNA *brna, PropertyRNA *cprop)
 
        prop= RNA_def_property(srna, "active_index", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "actlay");
-       RNA_def_property_int_funcs(prop, "rna_RenderSettings_active_layer_index_get", "rna_RenderSettings_active_layer_index_set", "rna_RenderSettings_active_layer_index_range");
+       RNA_def_property_int_funcs(prop, "rna_RenderSettings_active_layer_index_get", "rna_RenderSettings_active_layer_index_set",
+                                  "rna_RenderSettings_active_layer_index_range");
        RNA_def_property_ui_text(prop, "Active Layer Index", "Active index in render layer array");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_UNSIGNED);
        RNA_def_property_struct_type(prop, "SceneRenderLayer");
-       RNA_def_property_pointer_funcs(prop, "rna_RenderSettings_active_layer_get", "rna_RenderSettings_active_layer_set", NULL, NULL);
+       RNA_def_property_pointer_funcs(prop, "rna_RenderSettings_active_layer_get",
+                                      "rna_RenderSettings_active_layer_set", NULL, NULL);
        RNA_def_property_flag(prop, PROP_EDITABLE|PROP_NEVER_NULL);
        RNA_def_property_ui_text(prop, "Active Render Layer", "Active Render Layer");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 
+       func= RNA_def_function(srna, "new", "rna_RenderLayer_new");
+       RNA_def_function_ui_description(func, "Add a render layer to scene");
+       RNA_def_function_flag(func, FUNC_USE_SELF_ID);
+       parm= RNA_def_string(func, "name", "RenderLayer", 0, "", "New name for the marker (not unique)");
+       RNA_def_property_flag(parm, PROP_REQUIRED);
+       parm= RNA_def_pointer(func, "result", "SceneRenderLayer", "", "Newly created render layer");
+       RNA_def_function_return(func, parm);
+
+       func= RNA_def_function(srna, "remove", "rna_RenderLayer_remove");
+       RNA_def_function_ui_description(func, "Remove a render layer");
+       RNA_def_function_flag(func, FUNC_USE_MAIN|FUNC_USE_REPORTS|FUNC_USE_SELF_ID);
+       parm= RNA_def_pointer(func, "layer", "SceneRenderLayer", "", "Timeline marker to remove");
+       RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
+}
+
+/* use for render output and image save operator,
+ * note: there are some cases where the members act differently when this is
+ * used from a scene, video formats can only be selected for render output
+ * for example, this is checked by seeing if the ptr->id.data is a Scene id */
+
+static void rna_def_scene_image_format_data(BlenderRNA *brna)
+{
+#ifdef WITH_OPENEXR
+       static EnumPropertyItem exr_codec_items[] = {
+               {R_IMF_EXR_CODEC_NONE, "NONE", 0, "None", ""},
+               {R_IMF_EXR_CODEC_PXR24, "PXR24", 0, "Pxr24 (lossy)", ""},
+               {R_IMF_EXR_CODEC_ZIP, "ZIP", 0, "ZIP (lossless)", ""},
+               {R_IMF_EXR_CODEC_PIZ, "PIZ", 0, "PIZ (lossless)", ""},
+               {R_IMF_EXR_CODEC_RLE, "RLE", 0, "RLE (lossless)", ""},
+               {0, NULL, 0, NULL, NULL}};
+#endif
+
+       StructRNA *srna;
+       PropertyRNA *prop;
+
+       srna= RNA_def_struct(brna, "ImageFormatSettings", NULL);
+       RNA_def_struct_sdna(srna, "ImageFormatData");
+       RNA_def_struct_nested(brna, srna, "Scene");
+       // RNA_def_struct_path_func(srna, "rna_RenderSettings_path"); // no need for the path, its not animated!
+       RNA_def_struct_ui_text(srna, "Image Format", "Settings for image formats");
+
+       prop= RNA_def_property(srna, "file_format", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "imtype");
+       RNA_def_property_enum_items(prop, image_type_items);
+       RNA_def_property_enum_funcs(prop, NULL, "rna_ImageFormatSettings_file_format_set", "rna_ImageFormatSettings_file_format_itemf");
+       RNA_def_property_ui_text(prop, "File Format", "File format to save the rendered images as");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "color_mode", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_bitflag_sdna(prop, NULL, "planes");
+       RNA_def_property_enum_items(prop, image_color_mode_items);
+       RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_ImageFormatSettings_color_mode_itemf");
+       RNA_def_property_ui_text(prop, "Color Mode",
+                                "Choose BW for saving greyscale images, RGB for saving red, green and blue channels, "
+                                "and RGBA for saving red, green, blue and alpha channels");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "color_depth", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_bitflag_sdna(prop, NULL, "depth");
+       RNA_def_property_enum_items(prop, image_color_depth_items);
+       RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_ImageFormatSettings_color_depth_itemf");
+       RNA_def_property_ui_text(prop, "Color Depth", "Bit depth per channel");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       /* was 'file_quality' */
+       prop= RNA_def_property(srna, "quality", PROP_INT, PROP_PERCENTAGE);
+       RNA_def_property_int_sdna(prop, NULL, "quality");
+       RNA_def_property_range(prop, 0, 100); /* 0 is needed for compression. */
+       RNA_def_property_ui_text(prop, "Quality", "Quality for image formats that support lossy compression");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       /* was shared with file_quality */
+       prop= RNA_def_property(srna, "compression", PROP_INT, PROP_PERCENTAGE);
+       RNA_def_property_int_sdna(prop, NULL, "compress");
+       RNA_def_property_range(prop, 0, 100); /* 0 is needed for compression. */
+       RNA_def_property_ui_text(prop, "Compression", "Compression level for formats that support lossless compression");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       /* flag */
+       prop= RNA_def_property(srna, "use_zbuffer", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", R_IMF_FLAG_ZBUF);
+       RNA_def_property_ui_text(prop, "Z Buffer", "Save the z-depth per pixel (32 bit unsigned int z-buffer)");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "use_preview", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", R_IMF_FLAG_PREVIEW_JPG);
+       RNA_def_property_ui_text(prop, "Preview", "When rendering animations, save JPG preview images in same directory");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       /* format spesific */
+
+#ifdef WITH_OPENEXR
+       /* OpenEXR */
+
+       prop= RNA_def_property(srna, "exr_codec", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "exr_codec");
+       RNA_def_property_enum_items(prop, exr_codec_items);
+       RNA_def_property_ui_text(prop, "Codec", "Codec settings for OpenEXR");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+#endif
+
+
+#ifdef WITH_OPENJPEG
+       /* Jpeg 2000 */
+       prop= RNA_def_property(srna, "use_jpeg2k_ycc", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "jp2_flag", R_IMF_JP2_FLAG_YCC);
+       RNA_def_property_ui_text(prop, "YCC", "Save luminance-chrominance-chrominance channels instead of RGB colors");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "use_jpeg2k_cinema_preset", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "jp2_flag", R_IMF_JP2_FLAG_CINE_PRESET);
+       RNA_def_property_ui_text(prop, "Cinema", "Use Openjpeg Cinema Preset");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "use_jpeg2k_cinema_48", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "jp2_flag", R_IMF_JP2_FLAG_CINE_48);
+       RNA_def_property_ui_text(prop, "Cinema (48)", "Use Openjpeg Cinema Preset (48fps)");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+#endif
+
+       /* Cineon and DPX */
+
+       prop= RNA_def_property(srna, "use_cineon_log", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "cineon_flag", R_CINEON_LOG);
+       RNA_def_property_ui_text(prop, "Log", "Convert to logarithmic color space");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "cineon_black", PROP_INT, PROP_NONE);
+       RNA_def_property_int_sdna(prop, NULL, "cineon_black");
+       RNA_def_property_range(prop, 0, 1024);
+       RNA_def_property_ui_text(prop, "B", "Log conversion reference blackpoint");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "cineon_white", PROP_INT, PROP_NONE);
+       RNA_def_property_int_sdna(prop, NULL, "cineon_white");
+       RNA_def_property_range(prop, 0, 1024);
+       RNA_def_property_ui_text(prop, "W", "Log conversion reference whitepoint");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       prop= RNA_def_property(srna, "cineon_gamma", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "cineon_gamma");
+       RNA_def_property_range(prop, 0.0f, 10.0f);
+       RNA_def_property_ui_text(prop, "G", "Log conversion gamma");
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 }
 
 static void rna_def_scene_render_data(BlenderRNA *brna)
@@ -2252,35 +2668,6 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
                {0, "AUTO", 0, "Auto-detect", "Automatically determine the number of threads, based on CPUs"},
                {R_FIXED_THREADS, "FIXED", 0, "Fixed", "Manually determine the number of threads"},
                {0, NULL, 0, NULL, NULL}};
-               
-#ifdef WITH_OPENEXR    
-       static EnumPropertyItem exr_codec_items[] = {
-               {0, "NONE", 0, "None", ""},
-               {1, "PXR24", 0, "Pxr24 (lossy)", ""},
-               {2, "ZIP", 0, "ZIP (lossless)", ""},
-               {3, "PIZ", 0, "PIZ (lossless)", ""},
-               {4, "RLE", 0, "RLE (lossless)", ""},
-               {0, NULL, 0, NULL, NULL}};
-#endif
-
-#ifdef WITH_OPENJPEG
-       static EnumPropertyItem jp2_preset_items[] = {
-               {0, "NO_PRESET", 0, "No Preset", ""},
-               {1, "CINE_24FPS", 0, "Cinema 24fps 2048x1080", ""},
-               {2, "CINE_48FPS", 0, "Cinema 48fps 2048x1080", ""},
-               {3, "CINE_24FPS_4K", 0, "Cinema 24fps 4096x2160", ""},
-               {4, "CINE_SCOPE_24FPS", 0, "Cine-Scope 24fps 2048x858", ""},
-               {5, "CINE_SCOPE_48FPS", 0, "Cine-Scope 48fps 2048x858", ""},
-               {6, "CINE_FLAT_24FPS", 0, "Cine-Flat 24fps 1998x1080", ""},
-               {7, "CINE_FLAT_48FPS", 0, "Cine-Flat 48fps 1998x1080", ""},
-               {0, NULL, 0, NULL, NULL}};
-               
-       static EnumPropertyItem jp2_depth_items[] = {
-               {8, "8", 0, "8", "8 bit color channels"},
-               {12, "12", 0, "12", "12 bit color channels"},
-               {16, "16", 0, "16", "16 bit color channels"},
-               {0, NULL, 0, NULL, NULL}};
-#endif
        
 #ifdef WITH_QUICKTIME
        static EnumPropertyItem quicktime_codec_type_items[] = {
@@ -2376,26 +2763,25 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        RNA_def_struct_nested(brna, srna, "Scene");
        RNA_def_struct_path_func(srna, "rna_RenderSettings_path");
        RNA_def_struct_ui_text(srna, "Render Data", "Rendering settings for a Scene datablock");
-       
-       prop= RNA_def_property(srna, "color_mode", PROP_ENUM, PROP_NONE);
-       RNA_def_property_enum_bitflag_sdna(prop, NULL, "planes");
-       RNA_def_property_enum_items(prop, image_color_mode_items);
-       RNA_def_property_ui_text(prop, "Color Mode",
-                                "Choose BW for saving greyscale images, RGB for saving red, green and blue channels, "
-                                "and RGBA for saving red, green, blue and alpha channels");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+
+       /* Render Data */
+       prop= RNA_def_property(srna, "image_settings", PROP_POINTER, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_NEVER_NULL);
+       RNA_def_property_pointer_sdna(prop, NULL, "im_format");
+       RNA_def_property_struct_type(prop, "ImageFormatSettings");
+       RNA_def_property_ui_text(prop, "Image Format", "");
 
        prop= RNA_def_property(srna, "resolution_x", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "xsch");
        RNA_def_property_range(prop, 4, 10000);
        RNA_def_property_ui_text(prop, "Resolution X", "Number of horizontal pixels in the rendered image");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneCamera_update");
        
        prop= RNA_def_property(srna, "resolution_y", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "ysch");
        RNA_def_property_range(prop, 4, 10000);
        RNA_def_property_ui_text(prop, "Resolution Y", "Number of vertical pixels in the rendered image");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneCamera_update");
        
        prop= RNA_def_property(srna, "resolution_percentage", PROP_INT, PROP_PERCENTAGE);
        RNA_def_property_int_sdna(prop, NULL, "size");
@@ -2420,101 +2806,13 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        RNA_def_property_float_sdna(prop, NULL, "xasp");
        RNA_def_property_range(prop, 1.0f, 200.0f);
        RNA_def_property_ui_text(prop, "Pixel Aspect X", "Horizontal aspect ratio - for anamorphic or non-square pixel output");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneCamera_update");
        
        prop= RNA_def_property(srna, "pixel_aspect_y", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "yasp");
        RNA_def_property_range(prop, 1.0f, 200.0f);
        RNA_def_property_ui_text(prop, "Pixel Aspect Y", "Vertical aspect ratio - for anamorphic or non-square pixel output");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       
-       /* JPEG and AVI JPEG */
-       
-       prop= RNA_def_property(srna, "file_quality", PROP_INT, PROP_PERCENTAGE);
-       RNA_def_property_int_sdna(prop, NULL, "quality");
-       RNA_def_property_range(prop, 0, 100); /* 0 is needed for compression. */
-       RNA_def_property_ui_text(prop, "Quality", "Quality of JPEG images, AVI Jpeg and SGI movies, compression for PNG's");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       
-       /* Tiff */
-       
-       prop= RNA_def_property(srna, "use_tiff_16bit", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_boolean_sdna(prop, NULL, "subimtype", R_TIFF_16BIT);
-       RNA_def_property_ui_text(prop, "16 Bit", "Save TIFF with 16 bits per channel");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       
-       /* Cineon and DPX */
-       
-       prop= RNA_def_property(srna, "use_cineon_log", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_boolean_sdna(prop, NULL, "subimtype", R_CINEON_LOG);
-       RNA_def_property_ui_text(prop, "Log", "Convert to logarithmic color space");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       
-       prop= RNA_def_property(srna, "cineon_black", PROP_INT, PROP_NONE);
-       RNA_def_property_int_sdna(prop, NULL, "cineonblack");
-       RNA_def_property_range(prop, 0, 1024);
-       RNA_def_property_ui_text(prop, "B", "Log conversion reference blackpoint");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       
-       prop= RNA_def_property(srna, "cineon_white", PROP_INT, PROP_NONE);
-       RNA_def_property_int_sdna(prop, NULL, "cineonwhite");
-       RNA_def_property_range(prop, 0, 1024);
-       RNA_def_property_ui_text(prop, "W", "Log conversion reference whitepoint");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       
-       prop= RNA_def_property(srna, "cineon_gamma", PROP_FLOAT, PROP_NONE);
-       RNA_def_property_float_sdna(prop, NULL, "cineongamma");
-       RNA_def_property_range(prop, 0.0f, 10.0f);
-       RNA_def_property_ui_text(prop, "G", "Log conversion gamma");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-
-#ifdef WITH_OPENEXR    
-       /* OpenEXR */
-
-       prop= RNA_def_property(srna, "exr_codec", PROP_ENUM, PROP_NONE);
-       RNA_def_property_enum_bitflag_sdna(prop, NULL, "quality");
-       RNA_def_property_enum_items(prop, exr_codec_items);
-       RNA_def_property_ui_text(prop, "Codec", "Codec settings for OpenEXR");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       
-       prop= RNA_def_property(srna, "use_exr_half", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_boolean_sdna(prop, NULL, "subimtype", R_OPENEXR_HALF);
-       RNA_def_property_ui_text(prop, "Half", "Use 16 bit floats instead of 32 bit floats per channel");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       
-       prop= RNA_def_property(srna, "exr_zbuf", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_boolean_sdna(prop, NULL, "subimtype", R_OPENEXR_ZBUF);
-       RNA_def_property_ui_text(prop, "Zbuf", "Save the z-depth per pixel (32 bit unsigned int z-buffer)");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       
-       prop= RNA_def_property(srna, "exr_preview", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_boolean_sdna(prop, NULL, "subimtype", R_PREVIEW_JPG);
-       RNA_def_property_ui_text(prop, "Preview", "When rendering animations, save JPG preview images in same directory");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-#endif
-
-#ifdef WITH_OPENJPEG
-       /* Jpeg 2000 */
-
-       prop= RNA_def_property(srna, "jpeg2k_preset", PROP_ENUM, PROP_NONE);
-       RNA_def_property_enum_sdna(prop, NULL, "jp2_preset");
-       RNA_def_property_enum_items(prop, jp2_preset_items);
-       RNA_def_property_enum_funcs(prop, NULL, "rna_RenderSettings_jpeg2k_preset_set", NULL);
-       RNA_def_property_ui_text(prop, "Preset", "Use a DCI Standard preset for saving jpeg2000");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       
-       prop= RNA_def_property(srna, "jpeg2k_depth", PROP_ENUM, PROP_NONE);
-       RNA_def_property_enum_bitflag_sdna(prop, NULL, "jp2_depth");
-       RNA_def_property_enum_items(prop, jp2_depth_items);
-       RNA_def_property_enum_funcs(prop, NULL, "rna_RenderSettings_jpeg2k_depth_set", NULL);
-       RNA_def_property_ui_text(prop, "Depth", "Bit depth per channel");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       
-       prop= RNA_def_property(srna, "jpeg2k_ycc", PROP_BOOLEAN, PROP_NONE);
-       RNA_def_property_boolean_sdna(prop, NULL, "subimtype", R_JPEG2K_YCC);
-       RNA_def_property_ui_text(prop, "YCC", "Save luminance-chrominance-chrominance channels instead of RGB colors");
-       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-#endif
+       RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, "rna_SceneCamera_update");
 
 #ifdef WITH_QUICKTIME
        /* QuickTime */
@@ -2692,21 +2990,22 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        RNA_def_property_int_sdna(prop, NULL, "framapto");
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        RNA_def_property_range(prop, 1, 900);
-       RNA_def_property_ui_text(prop, "Frame Map Old", "Specify old mapping value in frames");
+       RNA_def_property_ui_text(prop, "Frame Map Old", "Old mapping value in frames");
        RNA_def_property_update(prop, NC_SCENE|ND_FRAME, "rna_Scene_framelen_update");
        
        prop= RNA_def_property(srna, "frame_map_new", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "images");
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        RNA_def_property_range(prop, 1, 900);
-       RNA_def_property_ui_text(prop, "Frame Map New", "Specify how many frames the Map Old will last");
+       RNA_def_property_ui_text(prop, "Frame Map New", "How many frames the Map Old will last");
        RNA_def_property_update(prop, NC_SCENE|ND_FRAME, "rna_Scene_framelen_update");
 
        
        prop= RNA_def_property(srna, "dither_intensity", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "dither_intensity");
        RNA_def_property_range(prop, 0.0f, 2.0f);
-       RNA_def_property_ui_text(prop, "Dither Intensity", "Amount of dithering noise added to the rendered image to break up banding");
+       RNA_def_property_ui_text(prop, "Dither Intensity",
+                                "Amount of dithering noise added to the rendered image to break up banding");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "pixel_filter_type", PROP_ENUM, PROP_NONE);
@@ -2730,7 +3029,8 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        prop= RNA_def_property(srna, "octree_resolution", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "ocres");
        RNA_def_property_enum_items(prop, octree_resolution_items);
-       RNA_def_property_ui_text(prop, "Octree Resolution", "Resolution of raytrace accelerator. Use higher resolutions for larger scenes");
+       RNA_def_property_ui_text(prop, "Octree Resolution",
+                                "Resolution of raytrace accelerator, use higher resolutions for larger scenes");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 
        prop= RNA_def_property(srna, "raytrace_method", PROP_ENUM, PROP_NONE);
@@ -2741,12 +3041,15 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
 
        prop= RNA_def_property(srna, "use_instances", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "raytrace_options", R_RAYTRACE_USE_INSTANCES);
-       RNA_def_property_ui_text(prop, "Use Instances", "Instance support leads to effective memory reduction when using duplicates");
+       RNA_def_property_ui_text(prop, "Use Instances",
+                                "Instance support leads to effective memory reduction when using duplicates");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 
        prop= RNA_def_property(srna, "use_local_coords", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "raytrace_options", R_RAYTRACE_USE_LOCAL_COORDS);
-       RNA_def_property_ui_text(prop, "Use Local Coords", "Vertex coordinates are stored localy on each primitive. Increases memory usage, but may have impact on speed");
+       RNA_def_property_ui_text(prop, "Use Local Coords",
+                                "Vertex coordinates are stored localy on each primitive "
+                                "(increases memory usage, but may have impact on speed)");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 
        prop= RNA_def_property(srna, "use_antialiasing", PROP_BOOLEAN, PROP_NONE);
@@ -2768,7 +3071,9 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        prop= RNA_def_property(srna, "field_order", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_bitflag_sdna(prop, NULL, "mode");
        RNA_def_property_enum_items(prop, field_order_items);
-       RNA_def_property_ui_text(prop, "Field Order", "Order of video fields. Select which lines get rendered first, to create smooth motion for TV output");
+       RNA_def_property_ui_text(prop, "Field Order",
+                                "Order of video fields (select which lines get rendered first, "
+                                "to create smooth motion for TV output)");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "use_fields_still", PROP_BOOLEAN, PROP_NONE);
@@ -2829,7 +3134,8 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        RNA_def_property_int_sdna(prop, NULL, "threads");
        RNA_def_property_range(prop, 1, BLENDER_MAX_THREADS);
        RNA_def_property_int_funcs(prop, "rna_RenderSettings_threads_get", NULL, NULL);
-       RNA_def_property_ui_text(prop, "Threads", "Number of CPU threads to use simultaneously while rendering (for multi-core/CPU systems)");
+       RNA_def_property_ui_text(prop, "Threads",
+                                "Number of CPU threads to use simultaneously while rendering (for multi-core/CPU systems)");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "threads_mode", PROP_ENUM, PROP_NONE);
@@ -2860,31 +3166,33 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        /* border */
        prop= RNA_def_property(srna, "use_border", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", R_BORDER);
-       RNA_def_property_ui_text(prop, "Border", "Render a user-defined border region, within the frame size. Note, this disables save_buffers and full_sample");
+       RNA_def_property_ui_text(prop, "Border",
+                                "Render a user-defined border region, within the frame size "
+                                "(note that this disables save_buffers and full_sample)");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 
        prop= RNA_def_property(srna, "border_min_x", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "border.xmin");
        RNA_def_property_range(prop, 0.0f, 1.0f);
-       RNA_def_property_ui_text(prop, "Border Minimum X", "Sets minimum X value to for the render border");
+       RNA_def_property_ui_text(prop, "Border Minimum X", "Minimum X value to for the render border");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 
        prop= RNA_def_property(srna, "border_min_y", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "border.ymin");
        RNA_def_property_range(prop, 0.0f, 1.0f);
-       RNA_def_property_ui_text(prop, "Border Minimum Y", "Sets minimum Y value for the render border");
+       RNA_def_property_ui_text(prop, "Border Minimum Y", "Minimum Y value for the render border");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 
        prop= RNA_def_property(srna, "border_max_x", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "border.xmax");
        RNA_def_property_range(prop, 0.0f, 1.0f);
-       RNA_def_property_ui_text(prop, "Border Maximum X", "Sets maximum X value for the render border");
+       RNA_def_property_ui_text(prop, "Border Maximum X", "Maximum X value for the render border");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 
        prop= RNA_def_property(srna, "border_max_y", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "border.ymax");
        RNA_def_property_range(prop, 0.0f, 1.0f);
-       RNA_def_property_ui_text(prop, "Border Maximum Y", "Sets maximum Y value for the render border");
+       RNA_def_property_ui_text(prop, "Border Maximum Y", "Maximum Y value for the render border");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "use_crop_to_border", PROP_BOOLEAN, PROP_NONE);
@@ -2894,7 +3202,8 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        
        prop= RNA_def_property(srna, "use_placeholder", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "mode", R_TOUCH);
-       RNA_def_property_ui_text(prop, "Placeholders", "Create empty placeholder files while rendering frames (similar to Unix 'touch')");
+       RNA_def_property_ui_text(prop, "Placeholders",
+                                "Create empty placeholder files while rendering frames (similar to Unix 'touch')");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "use_overwrite", PROP_BOOLEAN, PROP_NONE);
@@ -2904,12 +3213,15 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        
        prop= RNA_def_property(srna, "use_compositing", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "scemode", R_DOCOMP);
-       RNA_def_property_ui_text(prop, "Compositing", "Process the render result through the compositing pipeline, if compositing nodes are enabled");
+       RNA_def_property_ui_text(prop, "Compositing",
+                                "Process the render result through the compositing pipeline, if compositing nodes are enabled");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "use_sequencer", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "scemode", R_DOSEQ);
-       RNA_def_property_ui_text(prop, "Sequencer", "Process the render (and composited) result through the video sequence editor pipeline, if sequencer strips exist");
+       RNA_def_property_ui_text(prop, "Sequencer",
+                                "Process the render (and composited) result through the video sequence "
+                                "editor pipeline, if sequencer strips exist");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "use_color_management", PROP_BOOLEAN, PROP_NONE);
@@ -2920,15 +3232,18 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        
        prop= RNA_def_property(srna, "use_file_extension", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "scemode", R_EXTENSION);
-       RNA_def_property_ui_text(prop, "File Extensions", "Add the file format extensions to the rendered file name (eg: filename + .jpg)");
+       RNA_def_property_ui_text(prop, "File Extensions",
+                                "Add the file format extensions to the rendered file name (eg: filename + .jpg)");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
-       
+
+#if 0 /* moved */
        prop= RNA_def_property(srna, "file_format", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "imtype");
        RNA_def_property_enum_items(prop, image_type_items);
        RNA_def_property_enum_funcs(prop, NULL, "rna_RenderSettings_file_format_set", NULL);
        RNA_def_property_ui_text(prop, "File Format", "File format to save the rendered images as");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
+#endif
 
        prop= RNA_def_property(srna, "file_extension", PROP_STRING, PROP_NONE);
        RNA_def_property_string_funcs(prop, "rna_SceneRender_file_ext_get", "rna_SceneRender_file_ext_length", NULL);
@@ -2942,7 +3257,8 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
 
        prop= RNA_def_property(srna, "use_free_image_textures", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "scemode", R_FREE_IMAGE);
-       RNA_def_property_ui_text(prop, "Free Image Textures", "Free all image texture from memory after render, to save memory before compositing");
+       RNA_def_property_ui_text(prop, "Free Image Textures",
+                                "Free all image texture from memory after render, to save memory before compositing");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 
        prop= RNA_def_property(srna, "use_free_unused_nodes", PROP_BOOLEAN, PROP_NONE);
@@ -2953,13 +3269,17 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        prop= RNA_def_property(srna, "use_save_buffers", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "scemode", R_EXR_TILE_FILE);
        RNA_def_property_boolean_funcs(prop, "rna_RenderSettings_save_buffers_get", NULL);
-       RNA_def_property_ui_text(prop, "Save Buffers","Save tiles for all RenderLayers and SceneNodes to files in the temp directory (saves memory, required for Full Sample)");
+       RNA_def_property_ui_text(prop, "Save Buffers",
+                                "Save tiles for all RenderLayers and SceneNodes to files in the temp directory "
+                                "(saves memory, required for Full Sample)");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "use_full_sample", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "scemode", R_FULL_SAMPLE);
-        RNA_def_property_boolean_funcs(prop, "rna_RenderSettings_full_sample_get", NULL);
-       RNA_def_property_ui_text(prop, "Full Sample","Save for every anti-aliasing sample the entire RenderLayer results. This solves anti-aliasing issues with compositing");
+       RNA_def_property_boolean_funcs(prop, "rna_RenderSettings_full_sample_get", NULL);
+       RNA_def_property_ui_text(prop, "Full Sample",
+                                "Save for every anti-aliasing sample the entire RenderLayer results "
+                                "(this solves anti-aliasing issues with compositing)");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 
        prop= RNA_def_property(srna, "display_mode", PROP_ENUM, PROP_NONE);
@@ -2970,7 +3290,9 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        
        prop= RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
        RNA_def_property_string_sdna(prop, NULL, "pic");
-       RNA_def_property_ui_text(prop, "Output Path", "Directory/name to save animations, # characters defines the position and length of frame numbers");
+       RNA_def_property_ui_text(prop, "Output Path",
+                                "Directory/name to save animations, # characters defines the position "
+                                "and length of frame numbers");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 
        /* Bake */
@@ -2996,11 +3318,14 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        
        prop= RNA_def_property(srna, "use_bake_selected_to_active", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "bake_flag", R_BAKE_TO_ACTIVE);
-       RNA_def_property_ui_text(prop, "Selected to Active", "Bake shading on the surface of selected objects to the active object");
+       RNA_def_property_ui_text(prop, "Selected to Active",
+                                "Bake shading on the surface of selected objects to the active object");
        
        prop= RNA_def_property(srna, "use_bake_normalize", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "bake_flag", R_BAKE_NORMALIZE);
-       RNA_def_property_ui_text(prop, "Normalized", "With displacement normalize to the distance, with ambient occlusion normalize without using material settings");
+       RNA_def_property_ui_text(prop, "Normalized",
+                                "With displacement normalize to the distance, with ambient occlusion "
+                                "normalize without using material settings");
        
        prop= RNA_def_property(srna, "use_bake_clear", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "bake_flag", R_BAKE_CLEAR);
@@ -3018,7 +3343,7 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        prop= RNA_def_property(srna, "bake_distance", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "bake_maxdist");
        RNA_def_property_range(prop, 0.0, 1000.0);
-       RNA_def_property_ui_text(prop, "Distance", "Maximum distance from active object to other object (in blender units");
+       RNA_def_property_ui_text(prop, "Distance", "Maximum distance from active object to other object (in blender units)");
        
        prop= RNA_def_property(srna, "bake_bias", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "bake_biasdist");
@@ -3037,7 +3362,7 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        
        prop= RNA_def_property(srna, "use_stamp_time", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "stamp", R_STAMP_TIME);
-       RNA_def_property_ui_text(prop, "Stamp Time", "Include the render frame as HH:MM:SS.FF in image metadata");
+       RNA_def_property_ui_text(prop, "Stamp Time", "Include the rendered frame timecode as HH:MM:SS.FF in image metadata");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "use_stamp_date", PROP_BOOLEAN, PROP_NONE);
@@ -3057,7 +3382,7 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
 
        prop= RNA_def_property(srna, "use_stamp_lens", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "stamp", R_STAMP_CAMERALENS);
-       RNA_def_property_ui_text(prop, "Stamp Lens", "Include the name of the active cameras lens in image metadata");
+       RNA_def_property_ui_text(prop, "Stamp Lens", "Include the active camera's lens in image metadata");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "use_stamp_scene", PROP_BOOLEAN, PROP_NONE);
@@ -3077,17 +3402,18 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        
        prop= RNA_def_property(srna, "use_stamp_filename", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "stamp", R_STAMP_FILENAME);
-       RNA_def_property_ui_text(prop, "Stamp Filename", "Include the filename of the .blend file in image metadata");
+       RNA_def_property_ui_text(prop, "Stamp Filename", "Include the .blend filename in image metadata");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "use_stamp_sequencer_strip", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "stamp", R_STAMP_SEQSTRIP);
-       RNA_def_property_ui_text(prop, "Stamp Sequence Strip", "Include the name of the foreground sequence strip in image metadata");
+       RNA_def_property_ui_text(prop, "Stamp Sequence Strip",
+                                "Include the name of the foreground sequence strip in image metadata");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
 
        prop= RNA_def_property(srna, "use_stamp_render_time", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "stamp", R_STAMP_RENDERTIME);
-       RNA_def_property_ui_text(prop, "Stamp Render Time", "Include the render time in the stamp image");
+       RNA_def_property_ui_text(prop, "Stamp Render Time", "Include the render time in image metadata");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        prop= RNA_def_property(srna, "stamp_note_text", PROP_STRING, PROP_NONE);
@@ -3142,14 +3468,13 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Sequencer Preview Shading", "Method to draw in the sequencer view");
 
        /* layers */
-       
        prop= RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
        RNA_def_property_collection_sdna(prop, NULL, "layers", NULL);
        RNA_def_property_struct_type(prop, "SceneRenderLayer");
        RNA_def_property_ui_text(prop, "Render Layers", "");
        rna_def_render_layers(brna, prop);
 
-       
+
        prop= RNA_def_property(srna, "use_single_layer", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "scemode", R_SINGLE_LAYER);
        RNA_def_property_ui_text(prop, "Single Layer", "Only render the active layer");
@@ -3159,15 +3484,21 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
        /* engine */
        prop= RNA_def_property(srna, "engine", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_items(prop, engine_items);
-       RNA_def_property_enum_funcs(prop, "rna_RenderSettings_engine_get", "rna_RenderSettings_engine_set", "rna_RenderSettings_engine_itemf");
+       RNA_def_property_enum_funcs(prop, "rna_RenderSettings_engine_get", "rna_RenderSettings_engine_set",
+                                   "rna_RenderSettings_engine_itemf");
        RNA_def_property_ui_text(prop, "Engine", "Engine to use for rendering");
-       RNA_def_property_update(prop, NC_WINDOW, NULL);
+       RNA_def_property_update(prop, NC_WINDOW, "rna_RenderSettings_engine_update");
 
        prop= RNA_def_property(srna, "has_multiple_engines", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_funcs(prop, "rna_RenderSettings_multiple_engines_get", NULL);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
        RNA_def_property_ui_text(prop, "Multiple Engines", "More than one rendering engine is available");
 
+       prop= RNA_def_property(srna, "use_shading_nodes", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_funcs(prop, "rna_RenderSettings_use_shading_nodes_get", NULL);
+       RNA_def_property_clear_flag(prop, PROP_EDITABLE);
+       RNA_def_property_ui_text(prop, "Use Shading Nodes", "Active render engine uses new shading nodes system");
+
        prop= RNA_def_property(srna, "use_game_engine", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_funcs(prop, "rna_RenderSettings_use_game_engine_get", NULL);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
@@ -3198,7 +3529,7 @@ static void rna_def_scene_render_data(BlenderRNA *brna)
 
        prop= RNA_def_property(srna, "simplify_ao_sss", PROP_FLOAT, PROP_FACTOR);
        RNA_def_property_float_sdna(prop, NULL, "simplify_aosss");
-       RNA_def_property_ui_text(prop, "Simplify AO and SSS", "Global approximate AA and SSS quality factor");
+       RNA_def_property_ui_text(prop, "Simplify AO and SSS", "Global approximate AO and SSS quality factor");
        RNA_def_property_update(prop, 0, "rna_Scene_simplify_update");
 
        prop= RNA_def_property(srna, "use_simplify_triangulate", PROP_BOOLEAN, PROP_NONE);
@@ -3297,6 +3628,9 @@ static void rna_def_timeline_markers(BlenderRNA *brna, PropertyRNA *cprop)
        RNA_def_function_flag(func, FUNC_USE_REPORTS);
        parm= RNA_def_pointer(func, "marker", "TimelineMarker", "", "Timeline marker to remove");
        RNA_def_property_flag(parm, PROP_REQUIRED|PROP_NEVER_NULL);
+
+       func= RNA_def_function(srna, "clear", "rna_TimeLine_clear");
+       RNA_def_function_ui_description(func, "Remove all timeline markers");
 }
 
 /* scene.keying_sets */
@@ -3334,7 +3668,8 @@ static void rna_def_scene_keying_sets(BlenderRNA *brna, PropertyRNA *cprop)
        prop= RNA_def_property(srna, "active_index", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "active_keyingset");
        RNA_def_property_int_funcs(prop, "rna_Scene_active_keying_set_index_get", "rna_Scene_active_keying_set_index_set", NULL);
-       RNA_def_property_ui_text(prop, "Active Keying Set Index", "Current Keying Set index (negative for 'builtin' and positive for 'absolute')");
+       RNA_def_property_ui_text(prop, "Active Keying Set Index",
+                                "Current Keying Set index (negative for 'builtin' and positive for 'absolute')");
        RNA_def_property_update(prop, NC_SCENE|ND_KEYINGSET, NULL);
 }
 
@@ -3360,7 +3695,8 @@ static void rna_def_scene_keying_sets_all(BlenderRNA *brna, PropertyRNA *cprop)
        prop= RNA_def_property(srna, "active_index", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "active_keyingset");
        RNA_def_property_int_funcs(prop, "rna_Scene_active_keying_set_index_get", "rna_Scene_active_keying_set_index_set", NULL);
-       RNA_def_property_ui_text(prop, "Active Keying Set Index", "Current Keying Set index (negative for 'builtin' and positive for 'absolute')");
+       RNA_def_property_ui_text(prop, "Active Keying Set Index",
+                                "Current Keying Set index (negative for 'builtin' and positive for 'absolute')");
        RNA_def_property_update(prop, NC_SCENE|ND_KEYINGSET, NULL);
 }
 
@@ -3388,7 +3724,8 @@ void RNA_def_scene(BlenderRNA *brna)
 
        /* Struct definition */
        srna= RNA_def_struct(brna, "Scene", "ID");
-       RNA_def_struct_ui_text(srna, "Scene", "Scene consisting objects and defining time and render related settings");
+       RNA_def_struct_ui_text(srna, "Scene",
+                              "Scene data block, consisting in objects and defining time and render related settings");
        RNA_def_struct_ui_icon(srna, ICON_SCENE_DATA);
        RNA_def_struct_clear_flag(srna, STRUCT_ID_REFCOUNT);
        
@@ -3396,7 +3733,7 @@ void RNA_def_scene(BlenderRNA *brna)
        prop= RNA_def_property(srna, "camera", PROP_POINTER, PROP_NONE);
        RNA_def_property_flag(prop, PROP_EDITABLE);
        RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Camera_object_poll");
-       RNA_def_property_ui_text(prop, "Camera", "Active camera used for rendering the scene");
+       RNA_def_property_ui_text(prop, "Camera", "Active camera, used for rendering the scene");
        RNA_def_property_update(prop, NC_SCENE|NA_EDITED, "rna_Scene_view3d_update");
 
        prop= RNA_def_property(srna, "background_set", PROP_POINTER, PROP_NONE);
@@ -3423,14 +3760,14 @@ void RNA_def_scene(BlenderRNA *brna)
        RNA_def_property_collection_sdna(prop, NULL, "base", NULL);
        RNA_def_property_struct_type(prop, "ObjectBase");
        RNA_def_property_ui_text(prop, "Bases", "");
-       RNA_def_property_collection_funcs(prop, 0, 0, 0, 0, 0, 0, "rna_Scene_object_bases_lookup_string");
+       RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, NULL, NULL, NULL, "rna_Scene_object_bases_lookup_string", NULL);
        rna_def_scene_bases(brna, prop);
 
        prop= RNA_def_property(srna, "objects", PROP_COLLECTION, PROP_NONE);
        RNA_def_property_collection_sdna(prop, NULL, "base", NULL);
        RNA_def_property_struct_type(prop, "Object");
        RNA_def_property_ui_text(prop, "Objects", "");
-       RNA_def_property_collection_funcs(prop, 0, 0, 0, "rna_Scene_objects_get", 0, 0, 0);
+       RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, "rna_Scene_objects_get", NULL, NULL, NULL, NULL);
        rna_def_scene_objects(brna, prop);
 
        /* Layers */
@@ -3485,7 +3822,8 @@ void RNA_def_scene(BlenderRNA *brna)
        RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
        RNA_def_property_boolean_sdna(prop, NULL, "r.flag", SCER_PRV_RANGE);
        RNA_def_property_boolean_funcs(prop, NULL, "rna_Scene_use_preview_range_set");
-       RNA_def_property_ui_text(prop, "Use Preview Range", "Use an alternative start/end frame for UI playback, rather than the scene start/end frame");
+       RNA_def_property_ui_text(prop, "Use Preview Range",
+                                "Use an alternative start/end frame for UI playback, rather than the scene start/end frame");
        RNA_def_property_update(prop, NC_SCENE|ND_FRAME, NULL);
        RNA_def_property_ui_icon(prop, ICON_PREVIEW_RANGE, 0);
        
@@ -3506,7 +3844,7 @@ void RNA_def_scene(BlenderRNA *brna)
        /* Stamp */
        prop= RNA_def_property(srna, "use_stamp_note", PROP_STRING, PROP_NONE);
        RNA_def_property_string_sdna(prop, NULL, "r.stamp_udata");
-       RNA_def_property_ui_text(prop, "Stamp Note", "User define note for the render stamping");
+       RNA_def_property_ui_text(prop, "Stamp Note", "User defined note for the render stamping");
        RNA_def_property_update(prop, NC_SCENE|ND_RENDER_OPTIONS, NULL);
        
        /* Animation Data (for Scene) */
@@ -3516,7 +3854,8 @@ void RNA_def_scene(BlenderRNA *brna)
        prop= RNA_def_property(srna, "is_nla_tweakmode", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", SCE_NLA_EDIT_ON);
        RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* DO NOT MAKE THIS EDITABLE, OR NLA EDITOR BREAKS */
-       RNA_def_property_ui_text(prop, "NLA TweakMode", "Indicates whether there is any action referenced by NLA being edited. Strictly read-only");
+       RNA_def_property_ui_text(prop, "NLA TweakMode",
+                                "Whether there is any action referenced by NLA being edited (strictly read-only)");
        RNA_def_property_update(prop, NC_SPACE|ND_SPACE_GRAPH, NULL);
        
        /* Frame dropping flag for playback and sync enum */
@@ -3558,9 +3897,10 @@ void RNA_def_scene(BlenderRNA *brna)
        rna_def_scene_keying_sets(brna, prop);
        
        prop= RNA_def_property(srna, "keying_sets_all", PROP_COLLECTION, PROP_NONE);
-       RNA_def_property_collection_funcs(prop, "rna_Scene_all_keyingsets_begin", "rna_Scene_all_keyingsets_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", 0, 0, 0);
+       RNA_def_property_collection_funcs(prop, "rna_Scene_all_keyingsets_begin", "rna_Scene_all_keyingsets_next", "rna_iterator_listbase_end", "rna_iterator_listbase_get", NULL, NULL, NULL, NULL);
        RNA_def_property_struct_type(prop, "KeyingSet");
-       RNA_def_property_ui_text(prop, "All Keying Sets", "All Keying Sets available for use (Builtins and Absolute Keying Sets for this Scene)");
+       RNA_def_property_ui_text(prop, "All Keying Sets",
+                                "All Keying Sets available for use (Builtins and Absolute Keying Sets for this Scene)");
        RNA_def_property_update(prop, NC_SCENE|ND_KEYINGSET, NULL);
        rna_def_scene_keying_sets_all(brna, prop);
        
@@ -3613,7 +3953,8 @@ void RNA_def_scene(BlenderRNA *brna)
 
        prop= RNA_def_property(srna, "use_audio_sync", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "audio.flag", AUDIO_SYNC);
-       RNA_def_property_ui_text(prop, "Audio Sync", "Play back and sync with audio clock, dropping frames if frame display is too slow");
+       RNA_def_property_ui_text(prop, "Audio Sync",
+                                "Play back and sync with audio clock, dropping frames if frame display is too slow");
        RNA_def_property_update(prop, NC_SCENE, NULL);
 
        prop= RNA_def_property(srna, "use_audio_scrub", PROP_BOOLEAN, PROP_NONE);
@@ -3675,9 +4016,18 @@ void RNA_def_scene(BlenderRNA *brna)
        RNA_def_property_struct_type(prop, "TransformOrientation");
        RNA_def_property_ui_text(prop, "Transform Orientations", "");
 
+       /* active MovieClip */
+       prop= RNA_def_property(srna, "active_clip", PROP_POINTER, PROP_NONE);
+       RNA_def_property_pointer_sdna(prop, NULL, "clip");
+       RNA_def_property_flag(prop, PROP_EDITABLE);
+       RNA_def_property_struct_type(prop, "MovieClip");
+       RNA_def_property_ui_text(prop, "Active Movie Clip", "Active movie clip used for constraints and viewport drawing");
+       RNA_def_property_update(prop, NC_SPACE|ND_SPACE_VIEW3D, NULL);
+
        /* Nestled Data  */
        rna_def_tool_settings(brna);
        rna_def_unit_settings(brna);
+       rna_def_scene_image_format_data(brna);
        rna_def_scene_render_data(brna);
        rna_def_scene_game_data(brna);
        rna_def_scene_render_layer(brna);