Merge branch 'master' into blender2.8
authorBastien Montagne <montagne29@wanadoo.fr>
Thu, 23 Feb 2017 21:09:09 +0000 (22:09 +0100)
committerBastien Montagne <montagne29@wanadoo.fr>
Thu, 23 Feb 2017 21:09:09 +0000 (22:09 +0100)
1  2 
source/blender/makesrna/intern/rna_scene.c

index 211063fa03b62310c9b3399b33da25b529229141,121e4f56a6e1fa4e7e28571522ab15be300b2426..86140eaaa05c9f23d5d5ef47b74553d96c199fee
@@@ -32,7 -32,6 +32,7 @@@
  #include "DNA_particle_types.h"
  #include "DNA_rigidbody_types.h"
  #include "DNA_scene_types.h"
 +#include "DNA_layer_types.h"
  #include "DNA_linestyle_types.h"
  #include "DNA_userdef_types.h"
  #include "DNA_world_types.h"
  #include "BKE_editmesh.h"
  #include "BKE_paint.h"
  
 +#include "ED_object.h"
 +
  #include "GPU_extensions.h"
  
 +#include "DRW_engine.h"
 +
  #include "RNA_define.h"
  #include "RNA_enum_types.h"
  
@@@ -82,8 -77,6 +82,8 @@@
  
  #include "BLI_threads.h"
  
 +#define NO_ENGINE "NO_ENGINE"
 +
  #ifdef WITH_OPENEXR
  EnumPropertyItem rna_enum_exr_codec_items[] = {
        {R_IMF_EXR_CODEC_NONE, "NONE", 0, "None", ""},
@@@ -418,7 -411,7 +418,7 @@@ EnumPropertyItem rna_enum_gpencil_inter
        /* interpolation */
        {0, "", 0, N_("Interpolation"), "Standard transitions between keyframes"},
        {GP_IPO_LINEAR,   "LINEAR", ICON_IPO_LINEAR, "Linear", "Straight-line interpolation between A and B (i.e. no ease in/out)"},
-       {GP_IPO_CURVEMAP, "CUSTOM", ICON_IPO_BEZIER, "Custom", "Custom interpolation defined using a curvemap"},
+       {GP_IPO_CURVEMAP, "CUSTOM", ICON_IPO_BEZIER, "Custom", "Custom interpolation defined using a curve map"},
        
        /* easing */
        {0, "", 0, N_("Easing (by strength)"), "Predefined inertial transitions, useful for motion graphics (from least to most ''dramatic'')"},
        {0, NULL, 0, NULL, NULL}
  };
  
 +EnumPropertyItem rna_enum_layer_collection_mode_settings_type_items[] = {
 +      {COLLECTION_MODE_OBJECT, "OBJECT", 0, "Object", ""},
 +      {COLLECTION_MODE_EDIT, "EDIT", 0, "Edit", ""},
 +      {0, NULL, 0, NULL, NULL}
 +};
 +
  #ifdef RNA_RUNTIME
  
  #include "DNA_anim_types.h"
  #include "MEM_guardedalloc.h"
  
  #include "BKE_brush.h"
 +#include "BKE_collection.h"
  #include "BKE_colortools.h"
  #include "BKE_context.h"
  #include "BKE_global.h"
  #include "BKE_image.h"
 +#include "BKE_layer.h"
  #include "BKE_main.h"
  #include "BKE_node.h"
  #include "BKE_pointcache.h"
@@@ -621,11 -606,11 +621,11 @@@ static void rna_SpaceImageEditor_uv_scu
  static int rna_Scene_object_bases_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr)
  {
        Scene *scene = (Scene *)ptr->data;
 -      Base *base;
 +      BaseLegacy *base;
  
        for (base = scene->base.first; base; base = base->next) {
                if (STREQLEN(base->object->id.name + 2, key, sizeof(base->object->id.name) - 2)) {
 -                      *r_ptr = rna_pointer_inherit_refine(ptr, &RNA_ObjectBase, base);
 +                      *r_ptr = rna_pointer_inherit_refine(ptr, &RNA_ObjectBaseLegacy, base);
                        return true;
                }
        }
@@@ -638,13 -623,13 +638,13 @@@ static PointerRNA rna_Scene_objects_get
        ListBaseIterator *internal = &iter->internal.listbase;
  
        /* we are actually iterating a Base list, so override get */
 -      return rna_pointer_inherit_refine(&iter->parent, &RNA_Object, ((Base *)internal->link)->object);
 +      return rna_pointer_inherit_refine(&iter->parent, &RNA_Object, ((BaseLegacy *)internal->link)->object);
  }
  
 -static Base *rna_Scene_object_link(Scene *scene, bContext *C, ReportList *reports, Object *ob)
 +static BaseLegacy *rna_Scene_object_link(Scene *scene, bContext *C, ReportList *reports, Object *ob)
  {
        Scene *scene_act = CTX_data_scene(C);
 -      Base *base;
 +      BaseLegacy *base;
  
        if (BKE_scene_base_find(scene, ob)) {
                BKE_reportf(reports, RPT_ERROR, "Object '%s' is already in scene '%s'", ob->id.name + 2, scene->id.name + 2);
  
  static void rna_Scene_object_unlink(Scene *scene, ReportList *reports, Object *ob)
  {
 -      Base *base = BKE_scene_base_find(scene, ob);
 +      BaseLegacy *base = BKE_scene_base_find(scene, ob);
        if (!base) {
                BKE_reportf(reports, RPT_ERROR, "Object '%s' is not in this scene '%s'", ob->id.name + 2, scene->id.name + 2);
                return;
@@@ -1743,7 -1728,7 +1743,7 @@@ static void rna_Scene_use_nodes_update(
  static void rna_Physics_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
  {
        Scene *scene = (Scene *)ptr->id.data;
 -      Base *base;
 +      BaseLegacy *base;
  
        for (base = scene->base.first; base; base = base->next)
                BKE_ptcache_object_reset(scene, base->object, PTCACHE_RESET_DEPSGRAPH);
@@@ -1814,7 -1799,7 +1814,7 @@@ static void rna_Scene_use_simplify_upda
  {
        Scene *sce = ptr->id.data;
        Scene *sce_iter;
 -      Base *base;
 +      BaseLegacy *base;
  
        BKE_main_id_tag_listbase(&bmain->object, LIB_TAG_DOIT, true);
        for (SETLOOPER(sce, sce_iter, base))
@@@ -1903,43 -1888,6 +1903,43 @@@ static void rna_GameSettings_exit_key_s
                gm->exitkey = value;
  }
  
 +static StructRNA *rna_RenderEngineSettings_refine(PointerRNA *ptr)
 +{
 +#ifdef WITH_CLAY_ENGINE
 +      RenderEngineSettings *res = (RenderEngineSettings *)ptr->data;
 +
 +      if (STREQ(res->name, RE_engine_id_BLENDER_CLAY)) {
 +              return  &RNA_RenderEngineSettingsClay;
 +      }
 +#endif
 +      return &RNA_RenderEngineSettings;
 +}
 +
 +static PointerRNA rna_RenderEngineSettings_active_get(PointerRNA *ptr)
 +{
 +      Scene *scene = (Scene *)ptr->data;
 +      RenderEngineSettings *res;
 +
 +      /* Ensure settings exists */
 +      DRW_render_settings_get(scene, scene->r.engine);
 +
 +      res = BLI_findstring(&scene->engines_settings, scene->r.engine, offsetof(RenderEngineSettings, name));
 +
 +      return rna_pointer_inherit_refine(ptr, &RNA_RenderEngineSettings, res);
 +}
 +
 +static void rna_RenderEngineSettings_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
 +{
 +      Scene *sce = (Scene *)ptr->id.data;
 +      MaterialEngineSettingsClay *res;
 +
 +      res = (MaterialEngineSettingsClay *)DRW_render_settings_get(sce, sce->r.engine);
 +
 +      res->flag = CLAY_OUTDATED;
 +
 +      WM_main_add_notifier(NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +}
 +
  static TimeMarker *rna_TimeLine_add(Scene *scene, const char name[], int frame)
  {
        TimeMarker *marker = MEM_callocN(sizeof(TimeMarker), "TimeMarker");
@@@ -2258,4095 -2206,2867 +2258,4095 @@@ static int rna_gpu_is_hq_supported_get(
        return GPU_instanced_drawing_support() && GPU_geometry_shader_support();
  }
  
 -#else
 +static void rna_SceneCollection_name_set(PointerRNA *ptr, const char *value)
 +{
 +      Scene *scene = (Scene *)ptr->id.data;
 +      SceneCollection *sc = (SceneCollection *)ptr->data;
 +      SceneCollection *sc_master = BKE_collection_master(scene);
  
 -/* Grease Pencil Interpolation tool settings */
 -static void rna_def_gpencil_interpolate(BlenderRNA *brna)
 +      BLI_strncpy_utf8(sc->name, value, sizeof(sc->name));
 +      BLI_uniquename(&sc_master->scene_collections, sc, DATA_("SceneCollection"), '.', offsetof(SceneCollection, name), sizeof(sc->name));
 +}
 +
 +static void rna_SceneCollection_filter_set(PointerRNA *ptr, const char *value)
  {
 -      StructRNA *srna;
 -      PropertyRNA *prop;
 -      
 -      srna = RNA_def_struct(brna, "GPencilInterpolateSettings", NULL);
 -      RNA_def_struct_sdna(srna, "GP_Interpolate_Settings");
 -      RNA_def_struct_path_func(srna, "rna_GPencilInterpolateSettings_path");
 -      RNA_def_struct_ui_text(srna, "Grease Pencil Interpolate Settings",
 -                             "Settings for Grease Pencil interpolation tools");
 -      
 -      /* flags */
 -      prop = RNA_def_property(srna, "interpolate_all_layers", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TOOLFLAG_INTERPOLATE_ALL_LAYERS);
 -      RNA_def_property_ui_text(prop, "Interpolate All Layers", "Interpolate all layers, not only active");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 +      Scene *scene = (Scene *)ptr->id.data;
 +      SceneCollection *sc = (SceneCollection *)ptr->data;
 +      BLI_strncpy_utf8(sc->filter, value, sizeof(sc->filter));
  
 -      prop = RNA_def_property(srna, "interpolate_selected_only", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TOOLFLAG_INTERPOLATE_ONLY_SELECTED);
 -      RNA_def_property_ui_text(prop, "Interpolate Selected Strokes", "Interpolate only selected strokes in the original frame");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 -      
 -      /* interpolation type */
 -      prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "type");
 -      RNA_def_property_enum_items(prop, rna_enum_gpencil_interpolation_mode_items);
 -      RNA_def_property_enum_funcs(prop, NULL, "rna_GPencilInterpolateSettings_type_set", NULL);
 -      RNA_def_property_ui_text(prop, "Type",
 -                               "Interpolation method to use the next time 'Interpolate Sequence' is run");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 -      
 -      /* easing */
 -      prop = RNA_def_property(srna, "easing", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "easing");
 -      RNA_def_property_enum_items(prop, rna_enum_beztriple_interpolation_easing_items);
 -      RNA_def_property_ui_text(prop, "Easing", 
 -                               "Which ends of the segment between the preceding and following grease pencil frames "
 -                               "easing interpolation is applied to");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 -      
 -      /* easing options */
 -      prop = RNA_def_property(srna, "back", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "back");
 -      RNA_def_property_ui_text(prop, "Back", "Amount of overshoot for 'back' easing");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 -      
 -      prop = RNA_def_property(srna, "amplitude", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "amplitude");
 -      RNA_def_property_range(prop, 0.0f, FLT_MAX); /* only positive values... */
 -      RNA_def_property_ui_text(prop, "Amplitude", "Amount to boost elastic bounces for 'elastic' easing");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 -      
 -      prop = RNA_def_property(srna, "period", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "period");
 -      RNA_def_property_ui_text(prop, "Period", "Time between bounces for elastic easing");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 -      
 -      /* custom curvemap */
 -      prop = RNA_def_property(srna, "interpolation_curve", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "custom_ipo");
 -      RNA_def_property_struct_type(prop, "CurveMapping");
 -      RNA_def_property_ui_text(prop, "Interpolation Curve", 
 -                               "Custom curve to control 'sequence' interpolation between Grease Pencil frames");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 +      TODO_LAYER_SYNC_FILTER;
 +      (void)scene;
  }
  
 -/* Grease Pencil Drawing Brushes */
 -static void rna_def_gpencil_brush(BlenderRNA *brna)
 +static PointerRNA rna_SceneCollection_objects_get(CollectionPropertyIterator *iter)
  {
 -      StructRNA *srna;
 -      PropertyRNA *prop;
 +      ListBaseIterator *internal = &iter->internal.listbase;
  
 -      srna = RNA_def_struct(brna, "GPencilBrush", NULL);
 -      RNA_def_struct_sdna(srna, "bGPDbrush");
 -      RNA_def_struct_ui_text(srna, "Grease Pencil Brush",
 -                             "Collection of brushes being used to control the line style of new strokes");
 -      RNA_def_struct_ui_icon(srna, ICON_BRUSH_DATA);
 +      /* we are actually iterating a LinkData list, so override get */
 +      return rna_pointer_inherit_refine(&iter->parent, &RNA_Object, ((LinkData *)internal->link)->data);
 +}
  
 -      /* Name */
 -      prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
 -      RNA_def_property_string_sdna(prop, NULL, "info");
 -      RNA_def_property_ui_text(prop, "Name", "Brush name");
 -      RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilBrush_name_set");
 -      RNA_def_struct_name_property(srna, prop);
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +static SceneCollection *rna_SceneCollection_new(ID *id, SceneCollection *sc_parent, const char *name)
 +{
 +      Scene *scene = (Scene *)id;
 +      SceneCollection *sc = BKE_collection_add(scene, sc_parent, name);
  
 -      /* Line Thickness */
 -      prop = RNA_def_property(srna, "line_width", PROP_INT, PROP_PIXEL);
 -      RNA_def_property_int_sdna(prop, NULL, "thickness");
 -      RNA_def_property_range(prop, 1, 300);
 -      RNA_def_property_ui_range(prop, 1, 10, 1, 0);
 -      RNA_def_property_ui_text(prop, "Thickness", "Thickness of strokes (in pixels)");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      DAG_id_tag_update(&scene->id, 0);
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
  
 -      /* Sensitivity factor for new strokes */
 -      prop = RNA_def_property(srna, "pen_sensitivity_factor", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "draw_sensitivity");
 -      RNA_def_property_range(prop, 0.1f, 3.0f);
 -      RNA_def_property_ui_text(prop, "Sensitivity", "Pressure sensitivity factor for new strokes");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      return sc;
 +}
  
 -      /* Strength factor for new strokes */
 -      prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "draw_strength");
 -      RNA_def_property_range(prop, 0.0f, 1.0f);
 -      RNA_def_property_ui_text(prop, "Strength", "Color strength for new strokes (affect alpha factor of color)");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +static void rna_SceneCollection_remove(
 +        ID *id, SceneCollection *sc_parent, ReportList *reports, PointerRNA *sc_ptr)
 +{
 +      Scene *scene = (Scene *)id;
 +      SceneCollection *sc = sc_ptr->data;
  
 -      /* Jitter factor for new strokes */
 -      prop = RNA_def_property(srna, "jitter", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "draw_jitter");
 -      RNA_def_property_range(prop, 0.0f, 1.0f);
 -      RNA_def_property_ui_text(prop, "Jitter", "Jitter factor for new strokes");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      const int index = BLI_findindex(&sc_parent->scene_collections, sc);
 +      if (index == -1) {
 +              BKE_reportf(reports, RPT_ERROR, "Collection '%s' is not a sub-collection of '%s'",
 +                          sc->name, sc_parent->name);
 +              return;
 +      }
  
 -      /* Randomnes factor for sensitivity and strength */
 -      prop = RNA_def_property(srna, "random_press", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "draw_random_press");
 -      RNA_def_property_range(prop, 0.0f, 1.0f);
 -      RNA_def_property_ui_text(prop, "Randomness", "Randomness factor for pressure and strength in new strokes");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      if (!BKE_collection_remove(scene, sc)) {
 +              BKE_reportf(reports, RPT_ERROR, "Collection '%s' could not be removed from collection '%s'",
 +                          sc->name, sc_parent->name);
 +              return;
 +      }
  
 -      /* Randomnes factor for subdivision */
 -      prop = RNA_def_property(srna, "random_subdiv", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "draw_random_sub");
 -      RNA_def_property_range(prop, 0.0f, 1.0f);
 -      RNA_def_property_ui_text(prop, "Random Subdivision", "Randomness factor for new strokes after subdivision");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      RNA_POINTER_INVALIDATE(sc_ptr);
  
 -      /* Angle when brush is full size */
 -      prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
 -      RNA_def_property_float_sdna(prop, NULL, "draw_angle");
 -      RNA_def_property_range(prop, -M_PI_2, M_PI_2);
 -      RNA_def_property_ui_text(prop, "Angle",
 -                               "Direction of the stroke at which brush gives maximal thickness "
 -                               "(0° for horizontal)");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      DAG_id_tag_update(&scene->id, 0);
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
 +}
  
 -      /* Factor to change brush size depending of angle */
 -      prop = RNA_def_property(srna, "angle_factor", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "draw_angle_factor");
 -      RNA_def_property_range(prop, 0.0f, 1.0f);
 -      RNA_def_property_ui_text(prop, "Angle Factor",
 -                               "Reduce brush thickness by this factor when stroke is perpendicular to 'Angle' direction");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +static int rna_SceneCollection_objects_active_index_get(PointerRNA *ptr)
 +{
 +      SceneCollection *sc = (SceneCollection *)ptr->data;
 +      return sc->active_object_index;
 +}
  
 -      /* Smoothing factor for new strokes */
 -      prop = RNA_def_property(srna, "pen_smooth_factor", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "draw_smoothfac");
 -      RNA_def_property_range(prop, 0.0, 2.0f);
 -      RNA_def_property_ui_text(prop, "Smooth",
 -                               "Amount of smoothing to apply to newly created strokes, to reduce jitter/noise");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +static void rna_SceneCollection_objects_active_index_set(PointerRNA *ptr, int value)
 +{
 +      SceneCollection *sc = (SceneCollection *)ptr->data;
 +      sc->active_object_index = value;
 +}
  
 -      /* Iterations of the Smoothing factor */
 -      prop = RNA_def_property(srna, "pen_smooth_steps", PROP_INT, PROP_NONE);
 -      RNA_def_property_int_sdna(prop, NULL, "draw_smoothlvl");
 -      RNA_def_property_range(prop, 1, 3);
 -      RNA_def_property_ui_text(prop, "Iterations",
 -                               "Number of times to smooth newly created strokes");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +static void rna_SceneCollection_objects_active_index_range(
 +        PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
 +{
 +      SceneCollection *sc = (SceneCollection *)ptr->data;
 +      *min = 0;
 +      *max = max_ii(0, BLI_listbase_count(&sc->objects) - 1);
 +}
  
 -      /* Subdivision level for new strokes */
 -      prop = RNA_def_property(srna, "pen_subdivision_steps", PROP_INT, PROP_NONE);
 -      RNA_def_property_int_sdna(prop, NULL, "sublevel");
 -      RNA_def_property_range(prop, 0, 3);
 -      RNA_def_property_ui_text(prop, "Subdivision Steps",
 -                               "Number of times to subdivide newly created strokes, for less jagged strokes");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +void rna_SceneCollection_object_link(
 +        ID *id, SceneCollection *sc, Main *bmain, ReportList *reports, Object *ob)
 +{
 +      Scene *scene = (Scene *)id;
  
 -      /* Curves for pressure */
 -      prop = RNA_def_property(srna, "curve_sensitivity", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "cur_sensitivity");
 -      RNA_def_property_struct_type(prop, "CurveMapping");
 -      RNA_def_property_ui_text(prop, "Curve Sensitivity", "Curve used for the sensitivity");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      if (BLI_findptr(&sc->objects, ob, offsetof(LinkData, data))) {
 +              BKE_reportf(reports, RPT_ERROR, "Object '%s' is already in collection '%s'", ob->id.name + 2, sc->name);
 +              return;
 +      }
  
 -      prop = RNA_def_property(srna, "curve_strength", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "cur_strength");
 -      RNA_def_property_struct_type(prop, "CurveMapping");
 -      RNA_def_property_ui_text(prop, "Curve Strength", "Curve used for the strength");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      BKE_collection_object_add(scene, sc, ob);
  
 -      prop = RNA_def_property(srna, "curve_jitter", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "cur_jitter");
 -      RNA_def_property_struct_type(prop, "CurveMapping");
 -      RNA_def_property_ui_text(prop, "Curve Jitter", "Curve used for the jitter effect");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      /* TODO(sergey): Only update relations for the current scene. */
 +      DAG_relations_tag_update(bmain);
 +      DAG_id_tag_update(&ob->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
  
 -      /* Flags */
 -      prop = RNA_def_property(srna, "use_pressure", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_PRESSURE);
 -      RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
 -      RNA_def_property_ui_text(prop, "Use Pressure", "Use tablet pressure");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER | ND_OB_ACTIVE, scene);
 +}
  
 -      prop = RNA_def_property(srna, "use_strength_pressure", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_STENGTH_PRESSURE);
 -      RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
 -      RNA_def_property_ui_text(prop, "Use Pressure Strength", "Use tablet pressure for color strength");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +static void rna_SceneCollection_object_unlink(
 +        ID *id, SceneCollection *sc, Main *bmain, ReportList *reports, Object *ob)
 +{
 +      Scene *scene = (Scene *)id;
  
 -      prop = RNA_def_property(srna, "use_jitter_pressure", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_JITTER_PRESSURE);
 -      RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
 -      RNA_def_property_ui_text(prop, "Use Pressure Jitter", "Use tablet pressure for jitter");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      if (!BLI_findptr(&sc->objects, ob, offsetof(LinkData, data))) {
 +              BKE_reportf(reports, RPT_ERROR, "Object '%s' is not in collection '%s'", ob->id.name + 2, sc->name);
 +              return;
 +      }
  
 -      prop = RNA_def_property(srna, "use_random_pressure", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_RANDOM_PRESSURE);
 -      RNA_def_property_ui_icon(prop, ICON_PARTICLES, 0);
 -      RNA_def_property_ui_text(prop, "Random Pressure", "Use random value for pressure");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      BKE_collection_object_remove(bmain, scene, sc, ob, false);
  
 -      prop = RNA_def_property(srna, "use_random_strength", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_RANDOM_STRENGTH);
 -      RNA_def_property_ui_icon(prop, ICON_PARTICLES, 0);
 -      RNA_def_property_ui_text(prop, "Random Strength", "Use random value for strength");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      /* needed otherwise the depgraph will contain freed objects which can crash, see [#20958] */
 +      DAG_relations_tag_update(bmain);
  
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER | ND_OB_ACTIVE, scene);
  }
  
 -/* Grease Pencil Drawing Brushes API */
 -static void rna_def_gpencil_brushes(BlenderRNA *brna, PropertyRNA *cprop)
 +/****** layer collection engine settings *******/
 +
 +static StructRNA *rna_CollectionEngineSettings_refine(struct PointerRNA *ptr)
  {
 -      StructRNA *srna;
 -      PropertyRNA *prop;
 +      CollectionEngineSettings *ces = (CollectionEngineSettings *)ptr->data;
  
 -      FunctionRNA *func;
 -      PropertyRNA *parm;
 +      if (STREQ(ces->name, "BLENDER_CLAY")) {
 +              return &RNA_CollectionEngineSettingsClay;
 +      }
  
 -      RNA_def_property_srna(cprop, "GreasePencilBrushes");
 -      srna = RNA_def_struct(brna, "GreasePencilBrushes", NULL);
 -      RNA_def_struct_sdna(srna, "ToolSettings");
 -      RNA_def_struct_ui_text(srna, "Grease Pencil Brushes", "Collection of grease pencil brushes");
 +      /* TODO - handle other engines */
 +      TODO_LAYER;
 +      (void) ces;
  
 -      func = RNA_def_function(srna, "new", "rna_GPencil_brush_new");
 -      RNA_def_function_ui_description(func, "Add a new grease pencil brush");
 -      parm = RNA_def_string(func, "name", "GPencilBrush", MAX_NAME, "Name", "Name of the brush");
 -      RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
 -      RNA_def_boolean(func, "set_active", 0, "Set Active", "Set the newly created brush to the active brush");
 -      parm = RNA_def_pointer(func, "palette", "GPencilBrush", "", "The newly created brush");
 -      RNA_def_function_return(func, parm);
 +      return &RNA_CollectionEngineSettings;
 +}
  
 -      func = RNA_def_function(srna, "remove", "rna_GPencil_brush_remove");
 -      RNA_def_function_ui_description(func, "Remove a grease pencil brush");
 -      RNA_def_function_flag(func, FUNC_USE_REPORTS);
 -      parm = RNA_def_pointer(func, "brush", "GPencilBrush", "", "The brush to remove");
 -      RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
 -      RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
 +static StructRNA *rna_CollectionModeSettings_refine(struct PointerRNA *ptr)
 +{
 +      CollectionEngineSettings *ces = (CollectionEngineSettings *)ptr->data;
  
 -      prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_struct_type(prop, "GPencilBrush");
 -      RNA_def_property_pointer_funcs(prop, "rna_GPencilBrushes_active_get", "rna_GPencilBrushes_active_set", NULL, NULL);
 -      RNA_def_property_flag(prop, PROP_EDITABLE);
 -      RNA_def_property_ui_text(prop, "Active Brush", "Current active brush");
 +      switch(ces->type) {
 +              case COLLECTION_MODE_OBJECT:
 +                      return &RNA_CollectionModeSettingsObject;
 +                      break;
 +              case COLLECTION_MODE_EDIT:
 +                      return &RNA_CollectionModeSettingsEdit;
 +                      break;
 +      }
  
 -      prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
 -      RNA_def_property_int_funcs(prop,
 -              "rna_GPencilBrushes_index_get",
 -              "rna_GPencilBrushes_index_set",
 -              "rna_GPencilBrushes_index_range");
 -      RNA_def_property_ui_text(prop, "Active Brush Index", "Index of active brush");
 +      return &RNA_CollectionModeSettings;
  }
  
 -static void rna_def_transform_orientation(BlenderRNA *brna)
 -{
 -      StructRNA *srna;
 -      PropertyRNA *prop;
 -      
 -      srna = RNA_def_struct(brna, "TransformOrientation", NULL);
 -      
 -      prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
 -      RNA_def_property_float_sdna(prop, NULL, "mat");
 -      RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_3x3);
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 -      
 -      prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
 -      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);
 -}
 +/****** clay engine settings *******/
  
 -static void rna_def_tool_settings(BlenderRNA  *brna)
 -{
 -      StructRNA *srna;
 -      PropertyRNA *prop;
 +#define RNA_LAYER_ENGINE_USE_GET_SET(_ENGINE_, _NAME_)                                 \
 +      static int rna_LayerEngineSettings_##_ENGINE_##_##_NAME_##_use_get(PointerRNA *ptr) \
 +    {                                                                                  \
 +          CollectionEngineSettings *ces = (CollectionEngineSettings *)ptr->data;         \
 +          return BKE_collection_engine_property_use_get(ces, #_NAME_) ? 1 : 0;           \
 +      }                                                                                  \
 +                                                                                         \
 +      static void rna_LayerEngineSettings_##_ENGINE_##_##_NAME_##_use_set(PointerRNA *ptr, int value) \
 +    {                                                                                  \
 +          CollectionEngineSettings *ces = (CollectionEngineSettings *)ptr->data;         \
 +          BKE_collection_engine_property_use_set(ces, #_NAME_, value? true : false);     \
 +      }
  
 -      static EnumPropertyItem uv_select_mode_items[] = {
 -              {UV_SELECT_VERTEX, "VERTEX", ICON_UV_VERTEXSEL, "Vertex", "Vertex selection mode"},
 -              {UV_SELECT_EDGE, "EDGE", ICON_UV_EDGESEL, "Edge", "Edge selection mode"},
 -              {UV_SELECT_FACE, "FACE", ICON_UV_FACESEL, "Face", "Face selection mode"},
 -              {UV_SELECT_ISLAND, "ISLAND", ICON_UV_ISLANDSEL, "Island", "Island selection mode"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 -      
 -      /* the construction of this enum is quite special - everything is stored as bitflags,
 -       * with 1st position only for for on/off (and exposed as boolean), while others are mutually
 -       * exclusive options but which will only have any effect when autokey is enabled
 -       */
 -      static EnumPropertyItem auto_key_items[] = {
 -              {AUTOKEY_MODE_NORMAL & ~AUTOKEY_ON, "ADD_REPLACE_KEYS", 0, "Add & Replace", ""},
 -              {AUTOKEY_MODE_EDITKEYS & ~AUTOKEY_ON, "REPLACE_KEYS", 0, "Replace", ""},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +#define RNA_LAYER_ENGINE_GET_SET(_TYPE_, _ENGINE_, _MODE_, _NAME_)                 \
 +static _TYPE_ rna_LayerEngineSettings_##_ENGINE_##_##_NAME_##_get(PointerRNA *ptr)   \
 +{                                                                                  \
 +      CollectionEngineSettings *ces = (CollectionEngineSettings *)ptr->data;         \
 +      return BKE_collection_engine_property_value_get_##_TYPE_(ces, #_NAME_);        \
 +}                                                                                  \
 +                                                                                     \
 +static void rna_LayerEngineSettings_##_ENGINE_##_##_NAME_##_set(PointerRNA *ptr, _TYPE_ value)  \
 +{                                                                                  \
 +      CollectionEngineSettings *ces = (CollectionEngineSettings *)ptr->data;         \
 +      BKE_collection_engine_property_value_set_##_TYPE_(ces, #_NAME_, value);        \
 +}                                                                                  \
 +      RNA_LAYER_ENGINE_USE_GET_SET(_ENGINE_, _NAME_)
  
 -      static EnumPropertyItem retarget_roll_items[] = {
 -              {SK_RETARGET_ROLL_NONE, "NONE", 0, "None", "Don't adjust roll"},
 -              {SK_RETARGET_ROLL_VIEW, "VIEW", 0, "View", "Roll bones to face the view"},
 -              {SK_RETARGET_ROLL_JOINT, "JOINT", 0, "Joint", "Roll bone to original joint plane offset"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 -      
 -      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_RETARGET, "RETARGET", 0, "Retarget", "Retarget template bone chain to stroke"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +#define RNA_LAYER_ENGINE_CLAY_GET_SET_FLOAT(_NAME_) \
 +      RNA_LAYER_ENGINE_GET_SET(float, Clay, COLLECTION_MODE_NONE, _NAME_)
  
 -      static EnumPropertyItem edge_tag_items[] = {
 -              {EDGE_MODE_SELECT, "SELECT", 0, "Select", ""},
 -              {EDGE_MODE_TAG_SEAM, "SEAM", 0, "Tag Seam", ""},
 -              {EDGE_MODE_TAG_SHARP, "SHARP", 0, "Tag Sharp", ""},
 -              {EDGE_MODE_TAG_CREASE, "CREASE", 0, "Tag Crease", ""},
 -              {EDGE_MODE_TAG_BEVEL, "BEVEL", 0, "Tag Bevel", ""},
 -              {EDGE_MODE_TAG_FREESTYLE, "FREESTYLE", 0, "Tag Freestyle Edge Mark", ""},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +#define RNA_LAYER_ENGINE_CLAY_GET_SET_INT(_NAME_) \
 +      RNA_LAYER_ENGINE_GET_SET(int, Clay, COLLECTION_MODE_NONE, _NAME_)
  
 -      static EnumPropertyItem draw_groupuser_items[] = {
 -              {OB_DRAW_GROUPUSER_NONE, "NONE", 0, "None", ""},
 -              {OB_DRAW_GROUPUSER_ACTIVE, "ACTIVE", 0, "Active", "Show vertices with no weights in the active group"},
 -              {OB_DRAW_GROUPUSER_ALL, "ALL", 0, "All", "Show vertices with no weights in any group"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +#define RNA_LAYER_ENGINE_CLAY_GET_SET_BOOL(_NAME_) \
 +      RNA_LAYER_ENGINE_GET_SET(bool, Clay, COLLECTION_MODE_NONE, _NAME_)
  
 -      static EnumPropertyItem vertex_group_select_items[] = {
 -              {WT_VGROUP_ALL, "ALL", 0, "All", "All Vertex Groups"},
 -              {WT_VGROUP_BONE_DEFORM, "BONE_DEFORM", 0, "Deform", "Vertex Groups assigned to Deform Bones"},
 -              {WT_VGROUP_BONE_DEFORM_OFF, "OTHER_DEFORM", 0, "Other", "Vertex Groups assigned to non Deform Bones"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 -      
 -      static EnumPropertyItem gpencil_source_3d_items[] = {
 -              {GP_TOOL_SOURCE_SCENE, "SCENE", 0, "Scene",
 -               "Grease Pencil data attached to the current scene is used, "
 -               "unless the active object already has Grease Pencil data (i.e. for old files)"},
 -              {GP_TOOL_SOURCE_OBJECT, "OBJECT", 0, "Object",
 -               "Grease Pencil data-blocks attached to the active object are used "
 -               "(required when using pre 2.73 add-ons, e.g. BSurfaces)"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 -      
 -      static EnumPropertyItem gpencil_stroke_placement_items[] = {
 -              {GP_PROJECT_VIEWSPACE, "CURSOR", 0, "Cursor", "Draw stroke at the 3D cursor"},
 -              {0, "VIEW", 0, "View", "Stick stroke to the view "}, /* weird, GP_PROJECT_VIEWALIGN is inverted */
 -              {GP_PROJECT_VIEWSPACE | GP_PROJECT_DEPTH_VIEW, "SURFACE", 0, "Surface", "Stick stroke to surfaces"},
 -              {GP_PROJECT_VIEWSPACE | GP_PROJECT_DEPTH_STROKE, "STROKE", 0, "Stroke", "Stick stroke to other strokes"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 -      
 -      
 -      srna = RNA_def_struct(brna, "ToolSettings", NULL);
 -      RNA_def_struct_path_func(srna, "rna_ToolSettings_path");
 -      RNA_def_struct_ui_text(srna, "Tool Settings", "");
 -      
 -      prop = RNA_def_property(srna, "sculpt", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_struct_type(prop, "Sculpt");
 -      RNA_def_property_ui_text(prop, "Sculpt", "");
 -      
 -      prop = RNA_def_property(srna, "use_auto_normalize", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "auto_normalize", 1);
 -      RNA_def_property_ui_text(prop, "WPaint Auto-Normalize",
 -                               "Ensure all bone-deforming vertex groups add up "
 -                               "to 1.0 while weight painting");
 -      RNA_def_property_update(prop, 0, "rna_Scene_update_active_object_data");
 +/* mode engines */
  
 -      prop = RNA_def_property(srna, "use_multipaint", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "multipaint", 1);
 -      RNA_def_property_ui_text(prop, "WPaint Multi-Paint",
 -                               "Paint across the weights of all selected bones, "
 -                               "maintaining their relative influence");
 -      RNA_def_property_update(prop, 0, "rna_Scene_update_active_object_data");
 +#define RNA_LAYER_MODE_OBJECT_GET_SET_FLOAT(_NAME_) \
 +      RNA_LAYER_ENGINE_GET_SET(float, ObjectMode, COLLECTION_MODE_OBJECT, _NAME_)
  
 -      prop = RNA_def_property(srna, "vertex_group_user", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "weightuser");
 -      RNA_def_property_enum_items(prop, draw_groupuser_items);
 -      RNA_def_property_ui_text(prop, "Mask Non-Group Vertices", "Display unweighted vertices");
 -      RNA_def_property_update(prop, 0, "rna_Scene_update_active_object_data");
 +#define RNA_LAYER_MODE_OBJECT_GET_SET_INT(_NAME_) \
 +      RNA_LAYER_ENGINE_GET_SET(int, ObjectMode, COLLECTION_MODE_OBJECT, _NAME_)
  
 -      prop = RNA_def_property(srna, "vertex_group_subset", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "vgroupsubset");
 -      RNA_def_property_enum_items(prop, vertex_group_select_items);
 -      RNA_def_property_ui_text(prop, "Subset", "Filter Vertex groups for Display");
 -      RNA_def_property_update(prop, 0, "rna_Scene_update_active_object_data");
 +#define RNA_LAYER_MODE_OBJECT_GET_SET_BOOL(_NAME_) \
 +      RNA_LAYER_ENGINE_GET_SET(bool, ObjectMode, COLLECTION_MODE_OBJECT, _NAME_)
  
 -      prop = RNA_def_property(srna, "vertex_paint", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "vpaint");    RNA_def_property_ui_text(prop, "Vertex Paint", "");
 +#define RNA_LAYER_MODE_EDIT_GET_SET_FLOAT(_NAME_) \
 +      RNA_LAYER_ENGINE_GET_SET(float, EditMode, COLLECTION_MODE_EDIT, _NAME_)
  
 -      prop = RNA_def_property(srna, "weight_paint", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "wpaint");
 -      RNA_def_property_ui_text(prop, "Weight Paint", "");
 +#define RNA_LAYER_MODE_EDIT_GET_SET_INT(_NAME_) \
 +      RNA_LAYER_ENGINE_GET_SET(int, EditMode, COLLECTION_MODE_EDIT, _NAME_)
  
 -      prop = RNA_def_property(srna, "image_paint", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "imapaint");
 -      RNA_def_property_ui_text(prop, "Image Paint", "");
 +#define RNA_LAYER_MODE_EDIT_GET_SET_BOOL(_NAME_) \
 +      RNA_LAYER_ENGINE_GET_SET(bool, EditMode, COLLECTION_MODE_EDIT, _NAME_)
  
 -      prop = RNA_def_property(srna, "uv_sculpt", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "uvsculpt");
 -      RNA_def_property_ui_text(prop, "UV Sculpt", "");
 +/* clay engine */
 +RNA_LAYER_ENGINE_CLAY_GET_SET_INT(type)
 +RNA_LAYER_ENGINE_CLAY_GET_SET_INT(matcap_icon)
 +RNA_LAYER_ENGINE_CLAY_GET_SET_FLOAT(matcap_rotation)
 +RNA_LAYER_ENGINE_CLAY_GET_SET_FLOAT(matcap_hue)
 +RNA_LAYER_ENGINE_CLAY_GET_SET_FLOAT(matcap_saturation)
 +RNA_LAYER_ENGINE_CLAY_GET_SET_FLOAT(matcap_value)
 +RNA_LAYER_ENGINE_CLAY_GET_SET_FLOAT(ssao_factor_cavity)
 +RNA_LAYER_ENGINE_CLAY_GET_SET_FLOAT(ssao_factor_edge)
 +RNA_LAYER_ENGINE_CLAY_GET_SET_FLOAT(ssao_distance)
 +RNA_LAYER_ENGINE_CLAY_GET_SET_FLOAT(ssao_attenuation)
  
 -      prop = RNA_def_property(srna, "particle_edit", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "particle");
 -      RNA_def_property_ui_text(prop, "Particle Edit", "");
 +/* object engine */
 +RNA_LAYER_MODE_OBJECT_GET_SET_BOOL(show_wire)
 +RNA_LAYER_MODE_OBJECT_GET_SET_BOOL(show_backface_culling)
  
 -      prop = RNA_def_property(srna, "use_uv_sculpt", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "use_uv_sculpt", 1);
 -      RNA_def_property_ui_text(prop, "UV Sculpt", "Enable brush for UV sculpting");
 -      RNA_def_property_ui_icon(prop, ICON_TPAINT_HLT, 0);
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_SpaceImageEditor_uv_sculpt_update");
 +/* mesh engine */
 +RNA_LAYER_MODE_EDIT_GET_SET_BOOL(show_occlude_wire)
  
 -      prop = RNA_def_property(srna, "uv_sculpt_lock_borders", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "uv_sculpt_settings", UV_SCULPT_LOCK_BORDERS);
 -      RNA_def_property_ui_text(prop, "Lock Borders", "Disable editing of boundary edges");
 +#undef RNA_LAYER_ENGINE_GET_SET
 +#undef RNA_LAYER_ENGINE_USE_GET_SET
  
 -      prop = RNA_def_property(srna, "uv_sculpt_all_islands", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "uv_sculpt_settings", UV_SCULPT_ALL_ISLANDS);
 -      RNA_def_property_ui_text(prop, "Sculpt All Islands", "Brush operates on all islands");
 +static void rna_CollectionEngineSettings_update(bContext *C, PointerRNA *UNUSED(ptr))
 +{
 +      SceneLayer *sl = CTX_data_scene_layer(C);
 +      LayerCollection *lc = CTX_data_layer_collection(C);
 +      BKE_scene_layer_engine_settings_collection_recalculate(sl, lc);
 +}
  
 -      prop = RNA_def_property(srna, "uv_sculpt_tool", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "uv_sculpt_tool");
 -      RNA_def_property_enum_items(prop, uv_sculpt_tool_items);
 -      RNA_def_property_ui_text(prop, "UV Sculpt Tools", "Select Tools for the UV sculpt brushes");
 +/***********************************/
  
 -      prop = RNA_def_property(srna, "uv_relax_method", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "uv_relax_method");
 -      RNA_def_property_enum_items(prop, uv_sculpt_relaxation_items);
 -      RNA_def_property_ui_text(prop, "Relaxation Method", "Algorithm used for UV relaxation");
 +static void rna_LayerCollection_name_get(PointerRNA *ptr, char *value)
 +{
 +      SceneCollection *sc = ((LayerCollection *)ptr->data)->scene_collection;
 +      strcpy(value, sc->name);
 +}
  
 -      /* Transform */
 -      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, rna_enum_proportional_editing_items);
 -      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 */
 +static int rna_LayerCollection_name_length(PointerRNA *ptr)
 +{
 +      SceneCollection *sc = ((LayerCollection *)ptr->data)->scene_collection;
 +      return strnlen(sc->name, sizeof(sc->name));
 +}
  
 -      prop = RNA_def_property(srna, "use_proportional_edit_objects", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "proportional_objects", 0);
 -      RNA_def_property_ui_text(prop, "Proportional Editing Objects", "Proportional editing object mode");
 -      RNA_def_property_ui_icon(prop, ICON_PROP_OFF, 1);
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +static void rna_LayerCollection_name_set(PointerRNA *ptr, const char *value)
 +{
 +      Scene *scene = (Scene *)ptr->id.data;
 +      SceneCollection *sc = ((LayerCollection *)ptr->data)->scene_collection;
 +      SceneCollection *sc_master = BKE_collection_master(scene);
  
 -      prop = RNA_def_property(srna, "use_proportional_edit_mask", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "proportional_mask", 0);
 -      RNA_def_property_ui_text(prop, "Proportional Editing Objects", "Proportional editing mask mode");
 -      RNA_def_property_ui_icon(prop, ICON_PROP_OFF, 1);
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +      BLI_strncpy_utf8(sc->name, value, sizeof(sc->name));
 +      BLI_uniquename(&sc_master->scene_collections, sc, DATA_("SceneCollection"), '.', offsetof(SceneCollection, name), sizeof(sc->name));
 +}
  
 -      prop = RNA_def_property(srna, "use_proportional_action", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "proportional_action", 0);
 -      RNA_def_property_ui_text(prop, "Proportional Editing Actions", "Proportional editing in action editor");
 -      RNA_def_property_ui_icon(prop, ICON_PROP_OFF, 1);
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +static PointerRNA rna_LayerCollection_objects_get(CollectionPropertyIterator *iter)
 +{
 +      ListBaseIterator *internal = &iter->internal.listbase;
 +      Base *base = ((LinkData *)internal->link)->data;
 +      return rna_pointer_inherit_refine(&iter->parent, &RNA_Object, base->object);
 +}
  
 -      prop = RNA_def_property(srna, "use_proportional_fcurve", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "proportional_fcurve", 0);
 -      RNA_def_property_ui_text(prop, "Proportional Editing FCurves", "Proportional editing in FCurve editor");
 -      RNA_def_property_ui_icon(prop, ICON_PROP_OFF, 1);
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +static PointerRNA rna_LayerCollection_engine_settings_get(ID *UNUSED(id), LayerCollection *lc, bContext *C, const char *engine)
 +{
 +      Scene *scene = CTX_data_scene(C);
 +      const char *engine_name;
  
 -      prop = RNA_def_property(srna, "lock_markers", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "lock_markers", 0);
 -      RNA_def_property_ui_text(prop, "Lock Markers", "Prevent marker editing");
 +      if (STREQ(engine, NO_ENGINE)) {
 +              RenderData *rd = &scene->r;
 +              engine_name = rd->engine;
 +      }
 +      else {
 +              engine_name = engine;
 +      }
  
 -      prop = RNA_def_property(srna, "proportional_edit_falloff", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "prop_mode");
 -      RNA_def_property_enum_items(prop, rna_enum_proportional_falloff_items);
 -      RNA_def_property_ui_text(prop, "Proportional Editing Falloff", "Falloff type for proportional editing mode");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +      PointerRNA ptr;
 +      CollectionEngineSettings *ces = BKE_layer_collection_engine_get(lc, COLLECTION_MODE_NONE, engine_name);
 +      RNA_pointer_create(NULL, &RNA_CollectionEngineSettings, ces, &ptr);
 +      return rna_pointer_inherit_refine(&ptr, &RNA_CollectionEngineSettings, ces);
 +}
  
 -      prop = RNA_def_property(srna, "proportional_size", PROP_FLOAT, PROP_DISTANCE);
 -      RNA_def_property_float_sdna(prop, NULL, "proportional_size");
 -      RNA_def_property_ui_text(prop, "Proportional Size", "Display size for proportional editing circle");
 -      RNA_def_property_range(prop, 0.00001, 5000.0);
 -      
 -      prop = RNA_def_property(srna, "normal_size", PROP_FLOAT, PROP_DISTANCE);
 -      RNA_def_property_float_sdna(prop, NULL, "normalsize");
 -      RNA_def_property_ui_text(prop, "Normal Size", "Display size for normals in the 3D view");
 -      RNA_def_property_range(prop, 0.00001, 1000.0);
 -      RNA_def_property_ui_range(prop, 0.01, 10.0, 10.0, 2);
 -      RNA_def_property_update(prop, NC_GEOM | ND_DATA, NULL);
 -
 -      prop = RNA_def_property(srna, "double_threshold", PROP_FLOAT, PROP_DISTANCE);
 -      RNA_def_property_float_sdna(prop, NULL, "doublimit");
 -      RNA_def_property_ui_text(prop, "Double Threshold", "Limit for removing duplicates and 'Auto Merge'");
 -      RNA_def_property_range(prop, 0.0, 1.0);
 -      RNA_def_property_ui_range(prop, 0.0, 0.1, 0.01, 6);
 +static PointerRNA rna_LayerCollection_mode_settings_get(ID *UNUSED(id), LayerCollection *lc, bContext *C, int type)
 +{
 +      if (type == COLLECTION_MODE_NONE) {
 +              /* temporarily get mode from active object */
 +              Object *ob = CTX_data_active_object(C);
  
 -      prop = RNA_def_property(srna, "use_mesh_automerge", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "automerge", 0);
 -      RNA_def_property_ui_text(prop, "AutoMerge Editing", "Automatically merge vertices moved to the same location");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +              if (ob) {
 +                      switch (ob->mode) {
 +                              case OB_MODE_OBJECT:
 +                                      type = COLLECTION_MODE_OBJECT;
 +                                      break;
 +                              case OB_MODE_EDIT:
 +                                      type = COLLECTION_MODE_EDIT;
 +                                      break;
 +                      }
 +              }
 +      }
  
 -      prop = RNA_def_property(srna, "use_snap", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "snap_flag", SCE_SNAP);
 -      RNA_def_property_ui_text(prop, "Snap", "Snap during transform");
 -      RNA_def_property_ui_icon(prop, ICON_SNAP_OFF, 1);
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +      PointerRNA ptr;
 +      CollectionEngineSettings *ces = BKE_layer_collection_engine_get(lc, type, "");
 +      RNA_pointer_create(NULL, &RNA_CollectionEngineSettings, ces, &ptr);
 +      return rna_pointer_inherit_refine(&ptr, &RNA_CollectionModeSettings, ces);
 +}
  
 -      prop = RNA_def_property(srna, "use_snap_align_rotation", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "snap_flag", SCE_SNAP_ROTATE);
 -      RNA_def_property_ui_text(prop, "Snap Align Rotation", "Align rotation with the snapping target");
 -      RNA_def_property_ui_icon(prop, ICON_SNAP_NORMAL, 0);
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +static void rna_LayerCollection_hide_update(bContext *C, PointerRNA *ptr)
 +{
 +      Scene *scene = CTX_data_scene(C);
 +      LayerCollection *lc = ptr->data;
 +      SceneLayer *sl = BKE_scene_layer_find_from_collection(scene, lc);
  
 -      prop = RNA_def_property(srna, "use_snap_grid_absolute", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "snap_flag", SCE_SNAP_ABS_GRID);
 -      RNA_def_property_ui_text(prop, "Absolute Grid Snap",
 -                               "Absolute grid alignment while translating (based on the pivot center)");
 -      RNA_def_property_ui_icon(prop, ICON_SNAP_GRID, 0);
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +      /* hide and deselect bases that are directly influenced by this LayerCollection */
 +      BKE_scene_layer_base_flag_recalculate(sl);
 +      BKE_scene_layer_engine_settings_collection_recalculate(sl, lc);
 +      WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
 +}
  
 -      prop = RNA_def_property(srna, "snap_element", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "snap_mode");
 -      RNA_def_property_enum_items(prop, rna_enum_snap_element_items);
 -      RNA_def_property_ui_text(prop, "Snap Element", "Type of element to snap to");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 -      
 -      /* node editor uses own set of snap modes */
 -      prop = RNA_def_property(srna, "snap_node_element", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "snap_node_mode");
 -      RNA_def_property_enum_items(prop, rna_enum_snap_node_element_items);
 -      RNA_def_property_ui_text(prop, "Snap Node Element", "Type of element to snap to");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 -      
 -      /* image editor uses own set of snap modes */
 -      prop = RNA_def_property(srna, "snap_uv_element", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "snap_uv_mode");
 -      RNA_def_property_enum_items(prop, snap_uv_element_items);
 -      RNA_def_property_ui_text(prop, "Snap UV Element", "Type of element to snap to");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +static void rna_LayerCollection_hide_select_update(bContext *C, PointerRNA *ptr)
 +{
 +      LayerCollection *lc = ptr->data;
  
 -      prop = RNA_def_property(srna, "snap_target", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "snap_target");
 -      RNA_def_property_enum_items(prop, rna_enum_snap_target_items);
 -      RNA_def_property_ui_text(prop, "Snap Target", "Which part to snap onto the target");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +      if ((lc->flag & COLLECTION_SELECTABLE) == 0) {
 +              Scene *scene = CTX_data_scene(C);
 +              SceneLayer *sl = BKE_scene_layer_find_from_collection(scene, lc);
  
 -      prop = RNA_def_property(srna, "use_snap_peel_object", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "snap_flag", SCE_SNAP_PEEL_OBJECT);
 -      RNA_def_property_ui_text(prop, "Snap Peel Object", "Consider objects as whole when finding volume center");
 -      RNA_def_property_ui_icon(prop, ICON_SNAP_PEEL_OBJECT, 0);
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 -      
 -      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_icon(prop, ICON_RETOPO, 0);
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +              /* deselect bases that are directly influenced by this LayerCollection */
 +              BKE_scene_layer_base_flag_recalculate(sl);
 +              WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, CTX_data_scene(C));
 +      }
 +}
  
 -      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 itself (editmode)");
 -      RNA_def_property_ui_icon(prop, ICON_ORTHO, 0);
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +static int rna_LayerCollections_active_collection_index_get(PointerRNA *ptr)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      return sl->active_collection;
 +}
  
 -      /* Grease Pencil */
 -      prop = RNA_def_property(srna, "use_gpencil_continuous_drawing", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "gpencil_flags", GP_TOOL_FLAG_PAINTSESSIONS_ON);
 -      RNA_def_property_ui_text(prop, "Use Continuous Drawing",
 -                               "Allow drawing multiple strokes at a time with Grease Pencil");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* xxx: need toolbar to be redrawn... */
 -      
 -      prop = RNA_def_property(srna, "use_gpencil_additive_drawing", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "gpencil_flags", GP_TOOL_FLAG_RETAIN_LAST);
 -      RNA_def_property_ui_text(prop, "Use Additive Drawing",
 -                               "When creating new frames, the strokes from the previous/active frame "
 -                               "are included as the basis for the new one");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 -      
 -      prop = RNA_def_property(srna, "use_gpencil_draw_onback", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "gpencil_flags", GP_TOOL_FLAG_PAINT_ONBACK);
 -      RNA_def_property_ui_text(prop, "Draw Strokes on Back",
 -              "When draw new strokes, the new stroke is drawn below of all strokes in the layer");
 -      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 +static void rna_LayerCollections_active_collection_index_set(PointerRNA *ptr, int value)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      int num_collections = BKE_layer_collection_count(sl);
 +      sl->active_collection = min_ff(value, num_collections - 1);
 +}
  
 -      prop = RNA_def_property(srna, "grease_pencil_source", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_src");
 -      RNA_def_property_enum_items(prop, gpencil_source_3d_items);
 -      RNA_def_property_ui_text(prop, "Grease Pencil Source",
 -                               "Data-block where active Grease Pencil data is found from");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 -      
 -      prop = RNA_def_property(srna, "gpencil_sculpt", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "gp_sculpt");
 -      RNA_def_property_struct_type(prop, "GPencilSculptSettings");
 -      RNA_def_property_ui_text(prop, "Grease Pencil Sculpt",
 -                               "Settings for stroke sculpting tools and brushes");
 -      
 -      prop = RNA_def_property(srna, "gpencil_interpolate", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "gp_interpolate");
 -      RNA_def_property_struct_type(prop, "GPencilInterpolateSettings");
 -      RNA_def_property_ui_text(prop, "Grease Pencil Interpolate", 
 -                              "Settings for Grease Pencil Interpolation tools");
 +static void rna_LayerCollections_active_collection_index_range(
 +        PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      *min = 0;
 +      *max = max_ii(0, BKE_layer_collection_count(sl) - 1);
 +}
  
 -      /* Grease Pencil - Drawing brushes */
 -      prop = RNA_def_property(srna, "gpencil_brushes", PROP_COLLECTION, PROP_NONE);
 -      RNA_def_property_collection_sdna(prop, NULL, "gp_brushes", NULL);
 -      RNA_def_property_struct_type(prop, "GPencilBrush");
 -      RNA_def_property_ui_text(prop, "Grease Pencil Brushes", "Grease Pencil drawing brushes");
 -      rna_def_gpencil_brushes(brna, prop);
 +static PointerRNA rna_LayerCollections_active_collection_get(PointerRNA *ptr)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      LayerCollection *lc = BKE_layer_collection_active(sl);
 +      return rna_pointer_inherit_refine(ptr, &RNA_LayerCollection, lc);
 +}
  
 -      /* Grease Pencil - 3D View Stroke Placement */
 -      prop = RNA_def_property(srna, "gpencil_stroke_placement_view3d", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_v3d_align");
 -      RNA_def_property_enum_items(prop, gpencil_stroke_placement_items);
 -      RNA_def_property_ui_text(prop, "Stroke Placement (3D View)", "");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 -      
 -      prop = RNA_def_property(srna, "use_gpencil_stroke_endpoints", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "gpencil_v3d_align", GP_PROJECT_DEPTH_STROKE_ENDPOINTS);
 -      RNA_def_property_ui_text(prop, "Only Endpoints", "Only use the first and last parts of the stroke for snapping");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 -      
 -      /* Grease Pencil - 2D Views Stroke Placement */
 -      prop = RNA_def_property(srna, "gpencil_stroke_placement_view2d", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_v2d_align");
 -      RNA_def_property_enum_items(prop, gpencil_stroke_placement_items);
 -      RNA_def_property_ui_text(prop, "Stroke Placement (2D View)", "");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +static void rna_LayerCollections_active_collection_set(PointerRNA *ptr, PointerRNA value)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      LayerCollection *lc = (LayerCollection *)value.data;
 +      const int index = BKE_layer_collection_findindex(sl, lc);
 +      if (index != -1) sl->active_collection = index;
 +}
  
 -      /* Grease Pencil - Sequencer Preview Stroke Placement */
 -      prop = RNA_def_property(srna, "gpencil_stroke_placement_sequencer_preview", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_seq_align");
 -      RNA_def_property_enum_items(prop, gpencil_stroke_placement_items);
 -      RNA_def_property_ui_text(prop, "Stroke Placement (Sequencer Preview)", "");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 -      
 -      /* Grease Pencil - Image Editor Stroke Placement */
 -      prop = RNA_def_property(srna, "gpencil_stroke_placement_image_editor", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_ima_align");
 -      RNA_def_property_enum_items(prop, gpencil_stroke_placement_items);
 -      RNA_def_property_ui_text(prop, "Stroke Placement (Image Editor)", "");
 -      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +LayerCollection * rna_SceneLayer_collection_link(
 +        ID *id, SceneLayer *sl, Main *bmain, SceneCollection *sc)
 +{
 +      Scene *scene = (Scene *)id;
 +      LayerCollection *lc = BKE_collection_link(sl, sc);
  
 -      
 -      /* Auto Keying */
 -      prop = RNA_def_property(srna, "use_keyframe_insert_auto", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "autokey_mode", AUTOKEY_ON);
 -      RNA_def_property_ui_text(prop, "Auto Keying", "Automatic keyframe insertion for Objects and Bones");
 -      RNA_def_property_ui_icon(prop, ICON_REC, 0);
 -      
 -      prop = RNA_def_property(srna, "auto_keying_mode", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "autokey_mode");
 -      RNA_def_property_enum_items(prop, auto_key_items);
 -      RNA_def_property_ui_text(prop, "Auto-Keying Mode", "Mode of automatic keyframe insertion for Objects and Bones");
 -      
 -      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");
 -      
 -      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_icon(prop, ICON_KEYINGSET, 0);
 -      
 -      /* Keyframing */
 -      prop = RNA_def_property(srna, "keyframe_type", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "keyframe_type");
 -      RNA_def_property_enum_items(prop, rna_enum_beztriple_keyframe_type_items);
 -      RNA_def_property_ui_text(prop, "New Keyframe Type", "Type of keyframes to create when inserting keyframes");
 -      
 -      /* UV */
 -      prop = RNA_def_property(srna, "uv_select_mode", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "uv_selectmode");
 -      RNA_def_property_enum_items(prop, uv_select_mode_items);
 -      RNA_def_property_ui_text(prop, "UV Selection Mode", "UV selection and display mode");
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, NULL);
 +      /* TODO(sergey/dfelinto): Only update relations for the current scenelayer. */
 +      DAG_relations_tag_update(bmain);
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER, scene);
  
 -      prop = RNA_def_property(srna, "use_uv_select_sync", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "uv_flag", UV_SYNC_SELECTION);
 -      RNA_def_property_ui_text(prop, "UV Sync Selection", "Keep UV and edit mode mesh selection in sync");
 -      RNA_def_property_ui_icon(prop, ICON_EDIT, 0);
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, NULL);
 +      return lc;
 +}
  
 -      prop = RNA_def_property(srna, "show_uv_local_view", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "uv_flag", UV_SHOW_SAME_IMAGE);
 -      RNA_def_property_ui_text(prop, "UV Local View", "Draw only faces with the currently displayed image assigned");
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, NULL);
 +static void rna_SceneLayer_collection_unlink(
 +        ID *id, SceneLayer *sl, Main *bmain, ReportList *reports, LayerCollection *lc)
 +{
 +      Scene *scene = (Scene *)id;
  
 -      /* Mesh */
 -      prop = RNA_def_property(srna, "mesh_select_mode", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "selectmode", 1);
 -      RNA_def_property_array(prop, 3);
 -      RNA_def_property_boolean_funcs(prop, NULL, "rna_Scene_editmesh_select_mode_set");
 -      RNA_def_property_ui_text(prop, "Mesh Selection Mode", "Which mesh elements selection works on");
 -      RNA_def_property_update(prop, 0, "rna_Scene_editmesh_select_mode_update");
 +      if (BLI_findindex(&sl->layer_collections, lc) == -1) {
 +              BKE_reportf(reports, RPT_ERROR, "Layer collection '%s' is not in '%s'", lc->scene_collection->name, sl->name);
 +              return;
 +      }
  
 -      prop = RNA_def_property(srna, "vertex_group_weight", PROP_FLOAT, PROP_FACTOR);
 -      RNA_def_property_float_sdna(prop, NULL, "vgroup_weight");
 -      RNA_def_property_ui_text(prop, "Vertex Group Weight", "Weight to assign in vertex groups");
 +      BKE_collection_unlink(sl, lc);
  
 -      /* use with MESH_OT_shortest_path_pick */
 -      prop = RNA_def_property(srna, "edge_path_mode", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "edge_mode");
 -      RNA_def_property_enum_items(prop, edge_tag_items);
 -      RNA_def_property_ui_text(prop, "Edge Tag Mode", "The edge flag to tag when selecting the shortest path");
 +      /* needed otherwise the depgraph will contain freed objects which can crash, see [#20958] */
 +      /* TODO(sergey/dfelinto): Only update relations for the current scenelayer. */
 +      DAG_relations_tag_update(bmain);
  
 -      prop = RNA_def_property(srna, "edge_path_live_unwrap", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "edge_mode_live_unwrap", 1);
 -      RNA_def_property_ui_text(prop, "Live Unwrap", "Changing edges seam re-calculates UV unwrap");
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER | ND_OB_ACTIVE, scene);
 +}
  
 -      /* etch-a-ton */
 -      prop = RNA_def_property(srna, "use_bone_sketching", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "bone_sketching", BONE_SKETCHING);
 -      RNA_def_property_ui_text(prop, "Use Bone Sketching", "Use sketching to create and edit bones");
 -/*    RNA_def_property_ui_icon(prop, ICON_EDIT, 0); */
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +static PointerRNA rna_LayerObjects_active_object_get(PointerRNA *ptr)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      return rna_pointer_inherit_refine(ptr, &RNA_Object, sl->basact ? sl->basact->object : NULL);
 +}
  
 -      prop = RNA_def_property(srna, "use_etch_quick", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "bone_sketching", BONE_SKETCHING_QUICK);
 -      RNA_def_property_ui_text(prop, "Quick Sketching", "Automatically convert and delete on stroke end");
 +static void rna_LayerObjects_active_object_set(PointerRNA *ptr, PointerRNA value)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      if (value.data)
 +              sl->basact = BKE_scene_layer_base_find(sl, (Object *)value.data);
 +      else
 +              sl->basact = NULL;
 +}
  
 -      prop = RNA_def_property(srna, "use_etch_overdraw", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "bone_sketching", BONE_SKETCHING_ADJUST);
 -      RNA_def_property_ui_text(prop, "Overdraw Sketching", "Adjust strokes by drawing near them");
 -      
 -      prop = RNA_def_property(srna, "use_etch_autoname", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "skgen_retarget_options", SK_RETARGET_AUTONAME);
 -      RNA_def_property_ui_text(prop, "Autoname Bones",
 -                               "Automatically generate values to replace &N and &S suffix placeholders in template names");
 +static void rna_SceneLayer_name_set(PointerRNA *ptr, const char *value)
 +{
 +      Scene *scene = (Scene *)ptr->id.data;
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      char oldname[sizeof(sl->name)];
  
 -      prop = RNA_def_property(srna, "etch_number", PROP_STRING, PROP_NONE);
 -      RNA_def_property_string_sdna(prop, NULL, "skgen_num_string");
 -      RNA_def_property_ui_text(prop, "Number", "Text to replace &N with (e.g. 'Finger.&N' -> 'Finger.1' or 'Finger.One')");
 +      BLI_strncpy(oldname, sl->name, sizeof(sl->name));
  
 -      prop = RNA_def_property(srna, "etch_side", PROP_STRING, PROP_NONE);
 -      RNA_def_property_string_sdna(prop, NULL, "skgen_num_string");
 -      RNA_def_property_ui_text(prop, "Side", "Text to replace &S with (e.g. 'Arm.&S' -> 'Arm.R' or 'Arm.Right')");
 +      BLI_strncpy_utf8(sl->name, value, sizeof(sl->name));
 +      BLI_uniquename(&scene->render_layers, sl, DATA_("SceneLayer"), '.', offsetof(SceneLayer, name), sizeof(sl->name));
  
 -      prop = RNA_def_property(srna, "etch_template", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "skgen_template");
 -      RNA_def_property_flag(prop, PROP_EDITABLE);
 -      RNA_def_property_struct_type(prop, "Object");
 -      RNA_def_property_pointer_funcs(prop, NULL, "rna_Scene_skgen_etch_template_set", NULL, NULL);
 -      RNA_def_property_ui_text(prop, "Template", "Template armature that will be retargeted to the stroke");
 +      if (scene->nodetree) {
 +              bNode *node;
 +              int index = BLI_findindex(&scene->render_layers, sl);
  
 -      prop = RNA_def_property(srna, "etch_subdivision_number", PROP_INT, PROP_NONE);
 -      RNA_def_property_int_sdna(prop, NULL, "skgen_subdivision_number");
 -      RNA_def_property_range(prop, 1, 255);
 -      RNA_def_property_ui_text(prop, "Subdivisions", "Number of bones in the subdivided stroke");
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +              for (node = scene->nodetree->nodes.first; node; node = node->next) {
 +                      if (node->type == CMP_NODE_R_LAYERS && node->id == NULL) {
 +                              if (node->custom1 == index)
 +                                      BLI_strncpy(node->name, sl->name, NODE_MAXSTR);
 +                      }
 +              }
 +      }
 +}
  
 -      prop = RNA_def_property(srna, "etch_adaptive_limit", PROP_FLOAT, PROP_FACTOR);
 -      RNA_def_property_float_sdna(prop, NULL, "skgen_correlation_limit");
 -      RNA_def_property_range(prop, 0.00001, 1.0);
 -      RNA_def_property_ui_range(prop, 0.01, 1.0, 0.01, 2);
 -      RNA_def_property_ui_text(prop, "Limit", "Correlation threshold for number of bones in the subdivided stroke");
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +static PointerRNA rna_SceneLayer_objects_get(CollectionPropertyIterator *iter)
 +{
 +      ListBaseIterator *internal = &iter->internal.listbase;
  
 -      prop = RNA_def_property(srna, "etch_length_limit", PROP_FLOAT, PROP_DISTANCE);
 -      RNA_def_property_float_sdna(prop, NULL, "skgen_length_limit");
 -      RNA_def_property_range(prop, 0.00001, 100000.0);
 -      RNA_def_property_ui_range(prop, 0.001, 100.0, 0.1, 3);
 -      RNA_def_property_ui_text(prop, "Length", "Maximum length of the subdivided bones");
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +      /* we are actually iterating a ObjectBase list, so override get */
 +      Base *base = (Base *)internal->link;
 +      return rna_pointer_inherit_refine(&iter->parent, &RNA_Object, base->object);
 +}
  
 -      prop = RNA_def_property(srna, "etch_roll_mode", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "skgen_retarget_roll");
 -      RNA_def_property_enum_items(prop, retarget_roll_items);
 -      RNA_def_property_ui_text(prop, "Retarget roll mode", "Method used to adjust the roll of bones when retargeting");
 -      
 -      prop = RNA_def_property(srna, "etch_convert_mode", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "bone_sketching_convert");
 -      RNA_def_property_enum_items(prop, sketch_convert_items);
 -      RNA_def_property_ui_text(prop, "Stroke conversion method", "Method used to convert stroke to bones");
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +static int rna_SceneLayer_objects_selected_skip(CollectionPropertyIterator *iter, void *UNUSED(data))
 +{
 +      ListBaseIterator *internal = &iter->internal.listbase;
 +      Base *base = (Base *)internal->link;
  
 -      /* Unified Paint Settings */
 -      prop = RNA_def_property(srna, "unified_paint_settings", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_flag(prop, PROP_NEVER_NULL);
 -      RNA_def_property_struct_type(prop, "UnifiedPaintSettings");
 -      RNA_def_property_ui_text(prop, "Unified Paint Settings", NULL);
 +      if ((base->flag & BASE_SELECTED) != 0) {
 +                      return 0;
 +      }
  
 -      /* Curve Paint Settings */
 -      prop = RNA_def_property(srna, "curve_paint_settings", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_flag(prop, PROP_NEVER_NULL);
 -      RNA_def_property_struct_type(prop, "CurvePaintSettings");
 -      RNA_def_property_ui_text(prop, "Curve Paint Settings", NULL);
 +      return 1;
 +};
  
 -      /* Mesh Statistics */
 -      prop = RNA_def_property(srna, "statvis", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_flag(prop, PROP_NEVER_NULL);
 -      RNA_def_property_struct_type(prop, "MeshStatVis");
 -      RNA_def_property_ui_text(prop, "Mesh Statistics Visualization", NULL);
 +static void rna_LayerObjects_selected_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      rna_iterator_listbase_begin(iter, &sl->object_bases, rna_SceneLayer_objects_selected_skip);
  }
  
 -static void rna_def_unified_paint_settings(BlenderRNA  *brna)
 +static void rna_SceneLayer_engine_set(PointerRNA *ptr, int value)
  {
 -      StructRNA *srna;
 -      PropertyRNA *prop;
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      RenderEngineType *type = BLI_findlink(&R_engines, value);
  
 -      srna = RNA_def_struct(brna, "UnifiedPaintSettings", NULL);
 -      RNA_def_struct_path_func(srna, "rna_UnifiedPaintSettings_path");
 -      RNA_def_struct_ui_text(srna, "Unified Paint Settings", "Overrides for some of the active brush's settings");
 +      if (type)
 +              BKE_scene_layer_engine_set(sl, type->idname);
 +}
  
 -      /* high-level flags to enable or disable unified paint settings */
 -      prop = RNA_def_property(srna, "use_unified_size", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_SIZE);
 -      RNA_def_property_ui_text(prop, "Use Unified Radius",
 -                               "Instead of per-brush radius, the radius is shared across brushes");
 +static EnumPropertyItem *rna_SceneLayer_engine_itemf(
 +        bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
 +{
 +      RenderEngineType *type;
 +      EnumPropertyItem *item = NULL;
 +      EnumPropertyItem tmp = {0, "", 0, "", ""};
 +      int a = 0, totitem = 0;
  
 -      prop = RNA_def_property(srna, "use_unified_strength", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_ALPHA);
 -      RNA_def_property_ui_text(prop, "Use Unified Strength",
 -                               "Instead of per-brush strength, the strength is shared across brushes");
 +      for (type = R_engines.first; type; type = type->next, a++) {
 +              tmp.value = a;
 +              tmp.identifier = type->idname;
 +              tmp.name = type->name;
 +              RNA_enum_item_add(&item, &totitem, &tmp);
 +      }
  
 -      prop = RNA_def_property(srna, "use_unified_weight", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_WEIGHT);
 -      RNA_def_property_ui_text(prop, "Use Unified Weight",
 -                               "Instead of per-brush weight, the weight is shared across brushes");
 +      RNA_enum_item_end(&item, &totitem);
 +      *r_free = true;
  
 -      prop = RNA_def_property(srna, "use_unified_color", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_COLOR);
 -      RNA_def_property_ui_text(prop, "Use Unified Color",
 -                               "Instead of per-brush color, the color is shared across brushes");
 +      return item;
 +}
  
 -      /* unified paint settings that override the equivalent settings
 -       * from the active brush */
 -      prop = RNA_def_property(srna, "size", PROP_INT, PROP_PIXEL);
 -      RNA_def_property_int_funcs(prop, NULL, "rna_UnifiedPaintSettings_size_set", NULL);
 -      RNA_def_property_range(prop, 1, MAX_BRUSH_PIXEL_RADIUS * 10);
 -      RNA_def_property_ui_range(prop, 1, MAX_BRUSH_PIXEL_RADIUS, 1, -1);
 -      RNA_def_property_ui_text(prop, "Radius", "Radius of the brush");
 -      RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_radius_update");
 +static int rna_SceneLayer_engine_get(PointerRNA *ptr)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      RenderEngineType *type;
 +      int a = 0;
  
 -      prop = RNA_def_property(srna, "unprojected_radius", PROP_FLOAT, PROP_DISTANCE);
 -      RNA_def_property_float_funcs(prop, NULL, "rna_UnifiedPaintSettings_unprojected_radius_set", NULL);
 -      RNA_def_property_range(prop, 0.001, FLT_MAX);
 -      RNA_def_property_ui_range(prop, 0.001, 1, 0, -1);
 -      RNA_def_property_ui_text(prop, "Unprojected Radius", "Radius of brush in Blender units");
 -      RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_radius_update");
 +      for (type = R_engines.first; type; type = type->next, a++)
 +              if (STREQ(type->idname, sl->engine))
 +                      return a;
  
 -      prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_FACTOR);
 -      RNA_def_property_float_sdna(prop, NULL, "alpha");
 -      RNA_def_property_float_default(prop, 0.5f);
 -      RNA_def_property_range(prop, 0.0f, 10.0f);
 -      RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
 -      RNA_def_property_ui_text(prop, "Strength", "How powerful the effect of the brush is when applied");
 -      RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_update");
 +      return 0;
 +}
  
 -      prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_FACTOR);
 -      RNA_def_property_float_sdna(prop, NULL, "weight");
 -      RNA_def_property_float_default(prop, 0.5f);
 -      RNA_def_property_range(prop, 0.0f, 1.0f);
 -      RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
 -      RNA_def_property_ui_text(prop, "Weight", "Weight to assign in vertex groups");
 -      RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_update");
 +static void rna_SceneLayer_engine_update(Main *bmain, Scene *UNUSED(unused), PointerRNA *UNUSED(ptr))
 +{
 +      ED_render_engine_changed(bmain);
 +}
  
 -      prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
 -      RNA_def_property_range(prop, 0.0, 1.0);
 -      RNA_def_property_float_sdna(prop, NULL, "rgb");
 -      RNA_def_property_ui_text(prop, "Color", "");
 -      RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_update");
 +static int rna_SceneLayer_multiple_engines_get(PointerRNA *UNUSED(ptr))
 +{
 +      return (BLI_listbase_count(&R_engines) > 1);
 +}
  
 -      prop = RNA_def_property(srna, "secondary_color", PROP_FLOAT, PROP_COLOR_GAMMA);
 -      RNA_def_property_range(prop, 0.0, 1.0);
 -      RNA_def_property_float_sdna(prop, NULL, "secondary_rgb");
 -      RNA_def_property_ui_text(prop, "Secondary Color", "");
 -      RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_update");
 +static int rna_SceneLayer_active_layer_index_get(PointerRNA *ptr)
 +{
 +      Scene *scene = (Scene *)ptr->data;
 +      return scene->active_layer;
 +}
  
 -      prop = RNA_def_property(srna, "use_pressure_size", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_BRUSH_SIZE_PRESSURE);
 -      RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
 -      RNA_def_property_ui_text(prop, "Size Pressure", "Enable tablet pressure sensitivity for size");
 +static void rna_SceneLayer_active_layer_index_set(PointerRNA *ptr, int value)
 +{
 +      Scene *scene = (Scene *)ptr->data;
 +      int num_layers = BLI_listbase_count(&scene->render_layers);
 +      scene->active_layer = min_ff(value, num_layers - 1);
 +}
  
 -      prop = RNA_def_property(srna, "use_pressure_strength", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_BRUSH_ALPHA_PRESSURE);
 -      RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
 -      RNA_def_property_ui_text(prop, "Strength Pressure", "Enable tablet pressure sensitivity for strength");
 +static void rna_SceneLayer_active_layer_index_range(
 +        PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
 +{
 +      Scene *scene = (Scene *)ptr->data;
  
 -      prop = RNA_def_property(srna, "use_locked_size", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_BRUSH_LOCK_SIZE);
 -      RNA_def_property_ui_text(prop, "Use Blender Units",
 -                               "When locked brush stays same size relative to object; "
 -                               "when unlocked brush size is given in pixels");
 +      *min = 0;
 +      *max = max_ii(0, BLI_listbase_count(&scene->render_layers) - 1);
  }
  
 -
 -static void rna_def_curve_paint_settings(BlenderRNA  *brna)
 +static PointerRNA rna_SceneLayer_active_layer_get(PointerRNA *ptr)
  {
 -      StructRNA *srna;
 -      PropertyRNA *prop;
 +      Scene *scene = (Scene *)ptr->data;
 +      SceneLayer *sl = BLI_findlink(&scene->render_layers, scene->active_layer);
  
 -      srna = RNA_def_struct(brna, "CurvePaintSettings", NULL);
 -      RNA_def_struct_path_func(srna, "rna_CurvePaintSettings_path");
 -      RNA_def_struct_ui_text(srna, "Curve Paint Settings", "");
 +      return rna_pointer_inherit_refine(ptr, &RNA_SceneLayer, sl);
 +}
  
 -      static EnumPropertyItem curve_type_items[] = {
 -              {CU_POLY, "POLY", 0, "Poly", ""},
 -              {CU_BEZIER, "BEZIER", 0, "Bezier", ""},
 -              {0, NULL, 0, NULL, NULL}};
 +static void rna_SceneLayer_active_layer_set(PointerRNA *ptr, PointerRNA value)
 +{
 +      Scene *scene = (Scene *)ptr->data;
 +      SceneLayer *sl = (SceneLayer *)value.data;
 +      const int index = BLI_findindex(&scene->render_layers, sl);
 +      if (index != -1) scene->active_layer = index;
 +}
  
 -      prop = RNA_def_property(srna, "curve_type", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "curve_type");
 -      RNA_def_property_enum_items(prop, curve_type_items);
 -      RNA_def_property_ui_text(prop, "Type", "Type of curve to use for new strokes");
 +static SceneLayer *rna_SceneLayer_new(ID *id, Scene *UNUSED(sce), const char *name)
 +{
 +      Scene *scene = (Scene *)id;
 +      SceneLayer *sl = BKE_scene_layer_add(scene, name);
  
 -      prop = RNA_def_property(srna, "use_corners_detect", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", CURVE_PAINT_FLAG_CORNERS_DETECT);
 -      RNA_def_property_ui_text(prop, "Detect Corners", "Detect corners and use non-aligned handles");
 +      DAG_id_tag_update(&scene->id, 0);
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
  
 -      prop = RNA_def_property(srna, "use_pressure_radius", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", CURVE_PAINT_FLAG_PRESSURE_RADIUS);
 -      RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
 -      RNA_def_property_ui_text(prop, "Use Pressure", "Map tablet pressure to curve radius");
 +      return sl;
 +}
  
 -      prop = RNA_def_property(srna, "use_stroke_endpoints", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", CURVE_PAINT_FLAG_DEPTH_STROKE_ENDPOINTS);
 -      RNA_def_property_ui_text(prop, "Only First", "Use the start of the stroke for the depth");
 +static void rna_SceneLayer_remove(
 +        ID *id, Scene *UNUSED(sce), Main *bmain, ReportList *reports, PointerRNA *sl_ptr)
 +{
 +      Scene *scene = (Scene *)id;
 +      SceneLayer *sl = sl_ptr->data;
  
 -      prop = RNA_def_property(srna, "use_offset_absolute", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", CURVE_PAINT_FLAG_DEPTH_STROKE_OFFSET_ABS);
 -      RNA_def_property_ui_text(prop, "Absolute Offset", "Apply a fixed offset (don't scale by the radius)");
 +      if (!BKE_scene_layer_remove(bmain, scene, sl)) {
 +              BKE_reportf(reports, RPT_ERROR, "Render layer '%s' could not be removed from scene '%s'",
 +                          sl->name, scene->id.name + 2);
 +              return;
 +      }
  
 -      prop = RNA_def_property(srna, "error_threshold", PROP_INT, PROP_PIXEL);
 -      RNA_def_property_range(prop, 1, 100);
 -      RNA_def_property_ui_text(prop, "Tolerance", "Allow deviation for a smoother, less precise line");
 +      RNA_POINTER_INVALIDATE(sl_ptr);
  
 -      prop = RNA_def_property(srna, "fit_method", PROP_ENUM, PROP_PIXEL);
 -      RNA_def_property_enum_sdna(prop, NULL, "fit_method");
 -      RNA_def_property_enum_items(prop, rna_enum_curve_fit_method_items);
 -      RNA_def_property_ui_text(prop, "Method", "Curve fitting method");
 +      DAG_id_tag_update(&scene->id, 0);
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
 +}
  
 -      prop = RNA_def_property(srna, "corner_angle", PROP_FLOAT, PROP_ANGLE);
 -      RNA_def_property_range(prop, 0, M_PI);
 -      RNA_def_property_ui_text(prop, "Corner Angle", "Angles above this are considered corners");
 -
 -      prop = RNA_def_property(srna, "radius_min", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_range(prop, 0.0, 100.0);
 -      RNA_def_property_ui_range(prop, 0.0f, 10.0, 10, 2);
 -      RNA_def_property_ui_text(prop, "Radius Min",
 -                               "Minimum radius when the minimum pressure is applied (also the minimum when tapering)");
 -
 -      prop = RNA_def_property(srna, "radius_max", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_range(prop, 0.0, 100.0);
 -      RNA_def_property_ui_range(prop, 0.0f, 10.0, 10, 2);
 -      RNA_def_property_ui_text(prop, "Radius Max",
 -                               "Radius to use when the maximum pressure is applied (or when a tablet isn't used)");
 -
 -      prop = RNA_def_property(srna, "radius_taper_start", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_range(prop, 0.0, 1.0);
 -      RNA_def_property_ui_range(prop, 0.0f, 1.0, 1, 2);
 -      RNA_def_property_ui_text(prop, "Radius Min", "Taper factor for the radius of each point along the curve");
 -
 -      prop = RNA_def_property(srna, "radius_taper_end", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_range(prop, 0.0, 10.0);
 -      RNA_def_property_ui_range(prop, 0.0f, 1.0, 1, 2);
 -      RNA_def_property_ui_text(prop, "Radius Max", "Taper factor for the radius of each point along the curve");
 -
 -      prop = RNA_def_property(srna, "surface_offset", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_range(prop, -10.0, 10.0);
 -      RNA_def_property_ui_range(prop, -1.0f, 1.0, 1, 2);
 -      RNA_def_property_ui_text(prop, "Offset", "Offset the stroke from the surface");
 -
 -      static EnumPropertyItem depth_mode_items[] = {
 -              {CURVE_PAINT_PROJECT_CURSOR,  "CURSOR",  0, "Cursor",  ""},
 -              {CURVE_PAINT_PROJECT_SURFACE, "SURFACE", 0, "Surface", ""},
 -              {0, NULL, 0, NULL, NULL}};
 +static void rna_ObjectBase_select_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
 +{
 +      Base *base = (Base *)ptr->data;
 +      short mode = (base->flag & BASE_SELECTED) ? BA_SELECT : BA_DESELECT;
 +      ED_object_base_select(base, mode);
 +}
  
 -      prop = RNA_def_property(srna, "depth_mode", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "depth_mode");
 -      RNA_def_property_enum_items(prop, depth_mode_items);
 -      RNA_def_property_ui_text(prop, "Depth", "Method of projecting depth");
 +#else
  
 -      static EnumPropertyItem surface_plane_items[] = {
 -              {CURVE_PAINT_SURFACE_PLANE_NORMAL_VIEW,  "NORMAL_VIEW", 0, "Normal/View", "Draw perpendicular to the surface"},
 -              {CURVE_PAINT_SURFACE_PLANE_NORMAL_SURFACE, "NORMAL_SURFACE", 0, "Normal/Surface", "Draw aligned to the surface"},
 -              {CURVE_PAINT_SURFACE_PLANE_VIEW, "VIEW", 0, "View", "Draw aligned to the viewport"},
 -              {0, NULL, 0, NULL, NULL}};
 +/* Grease Pencil Interpolation tool settings */
 +static void rna_def_gpencil_interpolate(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +      
 +      srna = RNA_def_struct(brna, "GPencilInterpolateSettings", NULL);
 +      RNA_def_struct_sdna(srna, "GP_Interpolate_Settings");
 +      RNA_def_struct_path_func(srna, "rna_GPencilInterpolateSettings_path");
 +      RNA_def_struct_ui_text(srna, "Grease Pencil Interpolate Settings",
 +                             "Settings for Grease Pencil interpolation tools");
 +      
 +      /* flags */
 +      prop = RNA_def_property(srna, "interpolate_all_layers", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TOOLFLAG_INTERPOLATE_ALL_LAYERS);
 +      RNA_def_property_ui_text(prop, "Interpolate All Layers", "Interpolate all layers, not only active");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
  
 -      prop = RNA_def_property(srna, "surface_plane", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "surface_plane");
 -      RNA_def_property_enum_items(prop, surface_plane_items);
 -      RNA_def_property_ui_text(prop, "Plane", "Plane for projected stroke");
 +      prop = RNA_def_property(srna, "interpolate_selected_only", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TOOLFLAG_INTERPOLATE_ONLY_SELECTED);
 +      RNA_def_property_ui_text(prop, "Interpolate Selected Strokes", "Interpolate only selected strokes in the original frame");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 +      
 +      /* interpolation type */
 +      prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "type");
 +      RNA_def_property_enum_items(prop, rna_enum_gpencil_interpolation_mode_items);
 +      RNA_def_property_enum_funcs(prop, NULL, "rna_GPencilInterpolateSettings_type_set", NULL);
 +      RNA_def_property_ui_text(prop, "Type",
 +                               "Interpolation method to use the next time 'Interpolate Sequence' is run");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 +      
 +      /* easing */
 +      prop = RNA_def_property(srna, "easing", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "easing");
 +      RNA_def_property_enum_items(prop, rna_enum_beztriple_interpolation_easing_items);
 +      RNA_def_property_ui_text(prop, "Easing", 
 +                               "Which ends of the segment between the preceding and following grease pencil frames "
 +                               "easing interpolation is applied to");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 +      
 +      /* easing options */
 +      prop = RNA_def_property(srna, "back", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "back");
 +      RNA_def_property_ui_text(prop, "Back", "Amount of overshoot for 'back' easing");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 +      
 +      prop = RNA_def_property(srna, "amplitude", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "amplitude");
 +      RNA_def_property_range(prop, 0.0f, FLT_MAX); /* only positive values... */
 +      RNA_def_property_ui_text(prop, "Amplitude", "Amount to boost elastic bounces for 'elastic' easing");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 +      
 +      prop = RNA_def_property(srna, "period", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "period");
 +      RNA_def_property_ui_text(prop, "Period", "Time between bounces for elastic easing");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 +      
 +      /* custom curvemap */
 +      prop = RNA_def_property(srna, "interpolation_curve", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "custom_ipo");
 +      RNA_def_property_struct_type(prop, "CurveMapping");
 +      RNA_def_property_ui_text(prop, "Interpolation Curve", 
 +                               "Custom curve to control 'sequence' interpolation between Grease Pencil frames");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
  }
  
 -static void rna_def_statvis(BlenderRNA  *brna)
 +/* Grease Pencil Drawing Brushes */
 +static void rna_def_gpencil_brush(BlenderRNA *brna)
  {
        StructRNA *srna;
        PropertyRNA *prop;
  
 -      static EnumPropertyItem stat_type[] = {
 -              {SCE_STATVIS_OVERHANG,  "OVERHANG",  0, "Overhang",  ""},
 -              {SCE_STATVIS_THICKNESS, "THICKNESS", 0, "Thickness", ""},
 -              {SCE_STATVIS_INTERSECT, "INTERSECT", 0, "Intersect", ""},
 -              {SCE_STATVIS_DISTORT,   "DISTORT",   0, "Distortion", ""},
 -              {SCE_STATVIS_SHARP, "SHARP", 0, "Sharp", ""},
 -              {0, NULL, 0, NULL, NULL}};
 -
 -      srna = RNA_def_struct(brna, "MeshStatVis", NULL);
 -      RNA_def_struct_path_func(srna, "rna_MeshStatVis_path");
 -      RNA_def_struct_ui_text(srna, "Mesh Visualize Statistics", "");
 +      srna = RNA_def_struct(brna, "GPencilBrush", NULL);
 +      RNA_def_struct_sdna(srna, "bGPDbrush");
 +      RNA_def_struct_ui_text(srna, "Grease Pencil Brush",
 +                             "Collection of brushes being used to control the line style of new strokes");
 +      RNA_def_struct_ui_icon(srna, ICON_BRUSH_DATA);
  
 -      prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_items(prop, stat_type);
 -      RNA_def_property_ui_text(prop, "Type", "Type of data to visualize/check");
 -      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +      /* Name */
 +      prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
 +      RNA_def_property_string_sdna(prop, NULL, "info");
 +      RNA_def_property_ui_text(prop, "Name", "Brush name");
 +      RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilBrush_name_set");
 +      RNA_def_struct_name_property(srna, prop);
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
  
 +      /* Line Thickness */
 +      prop = RNA_def_property(srna, "line_width", PROP_INT, PROP_PIXEL);
 +      RNA_def_property_int_sdna(prop, NULL, "thickness");
 +      RNA_def_property_range(prop, 1, 300);
 +      RNA_def_property_ui_range(prop, 1, 10, 1, 0);
 +      RNA_def_property_ui_text(prop, "Thickness", "Thickness of strokes (in pixels)");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
  
 -      /* overhang */
 -      prop = RNA_def_property(srna, "overhang_min", PROP_FLOAT, PROP_ANGLE);
 -      RNA_def_property_float_sdna(prop, NULL, "overhang_min");
 -      RNA_def_property_float_default(prop, 0.5f);
 -      RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
 -      RNA_def_property_ui_range(prop, 0.0f, DEG2RADF(180.0f), 0.001, 3);
 -      RNA_def_property_ui_text(prop, "Overhang Min", "Minimum angle to display");
 -      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +      /* Sensitivity factor for new strokes */
 +      prop = RNA_def_property(srna, "pen_sensitivity_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "draw_sensitivity");
 +      RNA_def_property_range(prop, 0.1f, 3.0f);
 +      RNA_def_property_ui_text(prop, "Sensitivity", "Pressure sensitivity factor for new strokes");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
  
 -      prop = RNA_def_property(srna, "overhang_max", PROP_FLOAT, PROP_ANGLE);
 -      RNA_def_property_float_sdna(prop, NULL, "overhang_max");
 -      RNA_def_property_float_default(prop, 0.5f);
 -      RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
 -      RNA_def_property_ui_range(prop, 0.0f, DEG2RADF(180.0f), 10, 3);
 -      RNA_def_property_ui_text(prop, "Overhang Max", "Maximum angle to display");
 -      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +      /* Strength factor for new strokes */
 +      prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "draw_strength");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Strength", "Color strength for new strokes (affect alpha factor of color)");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
  
 -      prop = RNA_def_property(srna, "overhang_axis", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "overhang_axis");
 -      RNA_def_property_enum_items(prop, rna_enum_object_axis_items);
 -      RNA_def_property_ui_text(prop, "Axis", "");
 -      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +      /* Jitter factor for new strokes */
 +      prop = RNA_def_property(srna, "jitter", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "draw_jitter");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Jitter", "Jitter factor for new strokes");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
  
 +      /* Randomnes factor for sensitivity and strength */
 +      prop = RNA_def_property(srna, "random_press", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "draw_random_press");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Randomness", "Randomness factor for pressure and strength in new strokes");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
  
 -      /* thickness */
 -      prop = RNA_def_property(srna, "thickness_min", PROP_FLOAT, PROP_DISTANCE);
 -      RNA_def_property_float_sdna(prop, NULL, "thickness_min");
 -      RNA_def_property_float_default(prop, 0.5f);
 -      RNA_def_property_range(prop, 0.0f, 1000.0);
 -      RNA_def_property_ui_range(prop, 0.0f, 100.0, 0.001, 3);
 -      RNA_def_property_ui_text(prop, "Thickness Min", "Minimum for measuring thickness");
 -      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +      /* Randomnes factor for subdivision */
 +      prop = RNA_def_property(srna, "random_subdiv", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "draw_random_sub");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Random Subdivision", "Randomness factor for new strokes after subdivision");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
  
 -      prop = RNA_def_property(srna, "thickness_max", PROP_FLOAT, PROP_DISTANCE);
 -      RNA_def_property_float_sdna(prop, NULL, "thickness_max");
 -      RNA_def_property_float_default(prop, 0.5f);
 -      RNA_def_property_range(prop, 0.0f, 1000.0);
 -      RNA_def_property_ui_range(prop, 0.0f, 100.0, 0.001, 3);
 -      RNA_def_property_ui_text(prop, "Thickness Max", "Maximum for measuring thickness");
 -      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +      /* Angle when brush is full size */
 +      prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_ANGLE);
 +      RNA_def_property_float_sdna(prop, NULL, "draw_angle");
 +      RNA_def_property_range(prop, -M_PI_2, M_PI_2);
 +      RNA_def_property_ui_text(prop, "Angle",
 +                               "Direction of the stroke at which brush gives maximal thickness "
 +                               "(0° for horizontal)");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
  
 -      prop = RNA_def_property(srna, "thickness_samples", PROP_INT, PROP_UNSIGNED);
 -      RNA_def_property_int_sdna(prop, NULL, "thickness_samples");
 -      RNA_def_property_range(prop, 1, 32);
 -      RNA_def_property_ui_text(prop, "Samples", "Number of samples to test per face");
 -      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +      /* Factor to change brush size depending of angle */
 +      prop = RNA_def_property(srna, "angle_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "draw_angle_factor");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Angle Factor",
 +                               "Reduce brush thickness by this factor when stroke is perpendicular to 'Angle' direction");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
  
 -      /* distort */
 -      prop = RNA_def_property(srna, "distort_min", PROP_FLOAT, PROP_ANGLE);
 -      RNA_def_property_float_sdna(prop, NULL, "distort_min");
 -      RNA_def_property_float_default(prop, 0.5f);
 -      RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
 -      RNA_def_property_ui_range(prop, 0.0f, DEG2RADF(180.0f), 10, 3);
 -      RNA_def_property_ui_text(prop, "Distort Min", "Minimum angle to display");
 -      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +      /* Smoothing factor for new strokes */
 +      prop = RNA_def_property(srna, "pen_smooth_factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "draw_smoothfac");
 +      RNA_def_property_range(prop, 0.0, 2.0f);
 +      RNA_def_property_ui_text(prop, "Smooth",
 +                               "Amount of smoothing to apply to newly created strokes, to reduce jitter/noise");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
  
 -      prop = RNA_def_property(srna, "distort_max", PROP_FLOAT, PROP_ANGLE);
 -      RNA_def_property_float_sdna(prop, NULL, "distort_max");
 -      RNA_def_property_float_default(prop, 0.5f);
 -      RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
 -      RNA_def_property_ui_range(prop, 0.0f, DEG2RADF(180.0f), 10, 3);
 -      RNA_def_property_ui_text(prop, "Distort Max", "Maximum angle to display");
 -      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +      /* Iterations of the Smoothing factor */
 +      prop = RNA_def_property(srna, "pen_smooth_steps", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "draw_smoothlvl");
 +      RNA_def_property_range(prop, 1, 3);
 +      RNA_def_property_ui_text(prop, "Iterations",
 +                               "Number of times to smooth newly created strokes");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
  
 -      /* sharp */
 -      prop = RNA_def_property(srna, "sharp_min", PROP_FLOAT, PROP_ANGLE);
 -      RNA_def_property_float_sdna(prop, NULL, "sharp_min");
 -      RNA_def_property_float_default(prop, 0.5f);
 -      RNA_def_property_range(prop, -DEG2RADF(180.0f), DEG2RADF(180.0f));
 -      RNA_def_property_ui_range(prop, -DEG2RADF(180.0f), DEG2RADF(180.0f), 10, 3);
 -      RNA_def_property_ui_text(prop, "Distort Min", "Minimum angle to display");
 -      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +      /* Subdivision level for new strokes */
 +      prop = RNA_def_property(srna, "pen_subdivision_steps", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "sublevel");
 +      RNA_def_property_range(prop, 0, 3);
 +      RNA_def_property_ui_text(prop, "Subdivision Steps",
 +                               "Number of times to subdivide newly created strokes, for less jagged strokes");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +
 +      /* Curves for pressure */
 +      prop = RNA_def_property(srna, "curve_sensitivity", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "cur_sensitivity");
 +      RNA_def_property_struct_type(prop, "CurveMapping");
 +      RNA_def_property_ui_text(prop, "Curve Sensitivity", "Curve used for the sensitivity");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +
 +      prop = RNA_def_property(srna, "curve_strength", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "cur_strength");
 +      RNA_def_property_struct_type(prop, "CurveMapping");
 +      RNA_def_property_ui_text(prop, "Curve Strength", "Curve used for the strength");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +
 +      prop = RNA_def_property(srna, "curve_jitter", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "cur_jitter");
 +      RNA_def_property_struct_type(prop, "CurveMapping");
 +      RNA_def_property_ui_text(prop, "Curve Jitter", "Curve used for the jitter effect");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +
 +      /* Flags */
 +      prop = RNA_def_property(srna, "use_pressure", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_PRESSURE);
 +      RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
 +      RNA_def_property_ui_text(prop, "Use Pressure", "Use tablet pressure");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +
 +      prop = RNA_def_property(srna, "use_strength_pressure", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_STENGTH_PRESSURE);
 +      RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
 +      RNA_def_property_ui_text(prop, "Use Pressure Strength", "Use tablet pressure for color strength");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +
 +      prop = RNA_def_property(srna, "use_jitter_pressure", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_JITTER_PRESSURE);
 +      RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
 +      RNA_def_property_ui_text(prop, "Use Pressure Jitter", "Use tablet pressure for jitter");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +
 +      prop = RNA_def_property(srna, "use_random_pressure", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_RANDOM_PRESSURE);
 +      RNA_def_property_ui_icon(prop, ICON_PARTICLES, 0);
 +      RNA_def_property_ui_text(prop, "Random Pressure", "Use random value for pressure");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +
 +      prop = RNA_def_property(srna, "use_random_strength", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_BRUSH_USE_RANDOM_STRENGTH);
 +      RNA_def_property_ui_icon(prop, ICON_PARTICLES, 0);
 +      RNA_def_property_ui_text(prop, "Random Strength", "Use random value for strength");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
  
 -      prop = RNA_def_property(srna, "sharp_max", PROP_FLOAT, PROP_ANGLE);
 -      RNA_def_property_float_sdna(prop, NULL, "sharp_max");
 -      RNA_def_property_float_default(prop, 0.5f);
 -      RNA_def_property_range(prop, -DEG2RADF(180.0f), DEG2RADF(180.0f));
 -      RNA_def_property_ui_range(prop, -DEG2RADF(180.0f), DEG2RADF(180.0f), 10, 3);
 -      RNA_def_property_ui_text(prop, "Distort Max", "Maximum angle to display");
 -      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
  }
  
 -static void rna_def_unit_settings(BlenderRNA  *brna)
 +/* Grease Pencil Drawing Brushes API */
 +static void rna_def_gpencil_brushes(BlenderRNA *brna, PropertyRNA *cprop)
  {
        StructRNA *srna;
        PropertyRNA *prop;
  
 -      static EnumPropertyItem unit_systems[] = {
 -              {USER_UNIT_NONE, "NONE", 0, "None", ""},
 -              {USER_UNIT_METRIC, "METRIC", 0, "Metric", ""},
 -              {USER_UNIT_IMPERIAL, "IMPERIAL", 0, "Imperial", ""},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 -      
 -      static EnumPropertyItem rotation_units[] = {
 -              {0, "DEGREES", 0, "Degrees", "Use degrees for measuring angles and rotations"},
 -              {USER_UNIT_ROT_RADIANS, "RADIANS", 0, "Radians", ""},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +      FunctionRNA *func;
 +      PropertyRNA *parm;
  
 -      srna = RNA_def_struct(brna, "UnitSettings", NULL);
 -      RNA_def_struct_ui_text(srna, "Unit Settings", "");
 +      RNA_def_property_srna(cprop, "GreasePencilBrushes");
 +      srna = RNA_def_struct(brna, "GreasePencilBrushes", NULL);
 +      RNA_def_struct_sdna(srna, "ToolSettings");
 +      RNA_def_struct_ui_text(srna, "Grease Pencil Brushes", "Collection of grease pencil brushes");
  
 -      /* Units */
 -      prop = RNA_def_property(srna, "system", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_items(prop, unit_systems);
 -      RNA_def_property_ui_text(prop, "Unit System", "The unit system to use for button display");
 -      RNA_def_property_update(prop, NC_WINDOW, NULL);
 -      
 -      prop = RNA_def_property(srna, "system_rotation", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_items(prop, rotation_units);
 -      RNA_def_property_ui_text(prop, "Rotation Units", "Unit to use for displaying/editing rotation values");
 -      RNA_def_property_update(prop, NC_WINDOW, NULL);
 +      func = RNA_def_function(srna, "new", "rna_GPencil_brush_new");
 +      RNA_def_function_ui_description(func, "Add a new grease pencil brush");
 +      parm = RNA_def_string(func, "name", "GPencilBrush", MAX_NAME, "Name", "Name of the brush");
 +      RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
 +      RNA_def_boolean(func, "set_active", 0, "Set Active", "Set the newly created brush to the active brush");
 +      parm = RNA_def_pointer(func, "palette", "GPencilBrush", "", "The newly created brush");
 +      RNA_def_function_return(func, parm);
  
 -      prop = RNA_def_property(srna, "scale_length", PROP_FLOAT, PROP_UNSIGNED);
 -      RNA_def_property_ui_text(prop, "Unit Scale", "Scale to use when converting between blender units and dimensions");
 -      RNA_def_property_range(prop, 0.00001, 100000.0);
 -      RNA_def_property_ui_range(prop, 0.001, 100.0, 0.1, 6);
 -      RNA_def_property_update(prop, NC_WINDOW, NULL);
 +      func = RNA_def_function(srna, "remove", "rna_GPencil_brush_remove");
 +      RNA_def_function_ui_description(func, "Remove a grease pencil brush");
 +      RNA_def_function_flag(func, FUNC_USE_REPORTS);
 +      parm = RNA_def_pointer(func, "brush", "GPencilBrush", "", "The brush to remove");
 +      RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
 +      RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
  
 -      prop = RNA_def_property(srna, "use_separate", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", USER_UNIT_OPT_SPLIT);
 -      RNA_def_property_ui_text(prop, "Separate Units", "Display units in pairs (e.g. 1m 0cm)");
 -      RNA_def_property_update(prop, NC_WINDOW, NULL);
 +      prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_struct_type(prop, "GPencilBrush");
 +      RNA_def_property_pointer_funcs(prop, "rna_GPencilBrushes_active_get", "rna_GPencilBrushes_active_set", NULL, NULL);
 +      RNA_def_property_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_ui_text(prop, "Active Brush", "Current active brush");
 +
 +      prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
 +      RNA_def_property_int_funcs(prop,
 +              "rna_GPencilBrushes_index_get",
 +              "rna_GPencilBrushes_index_set",
 +              "rna_GPencilBrushes_index_range");
 +      RNA_def_property_ui_text(prop, "Active Brush Index", "Index of active brush");
  }
  
 -void rna_def_render_layer_common(StructRNA *srna, int scene)
 +static void rna_def_transform_orientation(BlenderRNA *brna)
  {
 +      StructRNA *srna;
        PropertyRNA *prop;
 -
 +      
 +      srna = RNA_def_struct(brna, "TransformOrientation", NULL);
 +      
 +      prop = RNA_def_property(srna, "matrix", PROP_FLOAT, PROP_MATRIX);
 +      RNA_def_property_float_sdna(prop, NULL, "mat");
 +      RNA_def_property_multi_array(prop, 2, rna_matrix_dimsize_3x3);
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +      
        prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
 -      if (scene) RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SceneRenderLayer_name_set");
 -      else RNA_def_property_string_sdna(prop, NULL, "name");
 -      RNA_def_property_ui_text(prop, "Name", "Render layer name");
        RNA_def_struct_name_property(srna, prop);
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 -
 -      prop = RNA_def_property(srna, "material_override", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "mat_override");
 -      RNA_def_property_struct_type(prop, "Material");
 -      RNA_def_property_flag(prop, PROP_EDITABLE);
 -      RNA_def_property_ui_text(prop, "Material Override",
 -                               "Material to override all other materials in this render layer");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_ui_text(prop, "Name", "Name of the custom transform orientation");
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +}
  
 -      prop = RNA_def_property(srna, "light_override", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "light_override");
 -      RNA_def_property_struct_type(prop, "Group");
 -      RNA_def_property_flag(prop, PROP_EDITABLE);
 -      RNA_def_property_ui_text(prop, "Light Override", "Group to override all other lights in this render layer");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +static void rna_def_tool_settings(BlenderRNA  *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
  
 -      /* layers */
 -      prop = RNA_def_property(srna, "layers", PROP_BOOLEAN, PROP_LAYER_MEMBER);
 -      RNA_def_property_boolean_sdna(prop, NULL, "lay", 1);
 -      RNA_def_property_array(prop, 20);
 -      RNA_def_property_ui_text(prop, "Visible Layers", "Scene layers included in this render layer");
 -      if (scene) RNA_def_property_boolean_funcs(prop, NULL, "rna_SceneRenderLayer_layer_set");
 -      else RNA_def_property_boolean_funcs(prop, NULL, "rna_RenderLayer_layer_set");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 -      /* this seems to be too much trouble with depsgraph updates/etc. currently (20140423) */
 -      RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 +      static EnumPropertyItem uv_select_mode_items[] = {
 +              {UV_SELECT_VERTEX, "VERTEX", ICON_UV_VERTEXSEL, "Vertex", "Vertex selection mode"},
 +              {UV_SELECT_EDGE, "EDGE", ICON_UV_EDGESEL, "Edge", "Edge selection mode"},
 +              {UV_SELECT_FACE, "FACE", ICON_UV_FACESEL, "Face", "Face selection mode"},
 +              {UV_SELECT_ISLAND, "ISLAND", ICON_UV_ISLANDSEL, "Island", "Island selection mode"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +      
 +      /* the construction of this enum is quite special - everything is stored as bitflags,
 +       * with 1st position only for for on/off (and exposed as boolean), while others are mutually
 +       * exclusive options but which will only have any effect when autokey is enabled
 +       */
 +      static EnumPropertyItem auto_key_items[] = {
 +              {AUTOKEY_MODE_NORMAL & ~AUTOKEY_ON, "ADD_REPLACE_KEYS", 0, "Add & Replace", ""},
 +              {AUTOKEY_MODE_EDITKEYS & ~AUTOKEY_ON, "REPLACE_KEYS", 0, "Replace", ""},
 +              {0, NULL, 0, NULL, NULL}
 +      };
  
 -      prop = RNA_def_property(srna, "layers_zmask", PROP_BOOLEAN, PROP_LAYER);
 -      RNA_def_property_boolean_sdna(prop, NULL, "lay_zmask", 1);
 -      RNA_def_property_array(prop, 20);
 -      RNA_def_property_ui_text(prop, "Zmask Layers", "Zmask scene layers for solid faces");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      static EnumPropertyItem retarget_roll_items[] = {
 +              {SK_RETARGET_ROLL_NONE, "NONE", 0, "None", "Don't adjust roll"},
 +              {SK_RETARGET_ROLL_VIEW, "VIEW", 0, "View", "Roll bones to face the view"},
 +              {SK_RETARGET_ROLL_JOINT, "JOINT", 0, "Joint", "Roll bone to original joint plane offset"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +      
 +      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_RETARGET, "RETARGET", 0, "Retarget", "Retarget template bone chain to stroke"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
  
 -      prop = RNA_def_property(srna, "layers_exclude", PROP_BOOLEAN, PROP_LAYER);
 -      RNA_def_property_boolean_sdna(prop, NULL, "lay_exclude", 1);
 -      RNA_def_property_array(prop, 20);
 -      RNA_def_property_ui_text(prop, "Exclude Layers", "Exclude scene layers from having any influence");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      static EnumPropertyItem edge_tag_items[] = {
 +              {EDGE_MODE_SELECT, "SELECT", 0, "Select", ""},
 +              {EDGE_MODE_TAG_SEAM, "SEAM", 0, "Tag Seam", ""},
 +              {EDGE_MODE_TAG_SHARP, "SHARP", 0, "Tag Sharp", ""},
 +              {EDGE_MODE_TAG_CREASE, "CREASE", 0, "Tag Crease", ""},
 +              {EDGE_MODE_TAG_BEVEL, "BEVEL", 0, "Tag Bevel", ""},
 +              {EDGE_MODE_TAG_FREESTYLE, "FREESTYLE", 0, "Tag Freestyle Edge Mark", ""},
 +              {0, NULL, 0, NULL, NULL}
 +      };
  
 -      if (scene) {
 -              prop = RNA_def_property(srna, "samples", PROP_INT, PROP_UNSIGNED);
 -              RNA_def_property_ui_text(prop, "Samples", "Override number of render samples for this render layer, "
 -                                                        "0 will use the scene setting");
 -              RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 -
 -              prop = RNA_def_property(srna, "pass_alpha_threshold", PROP_FLOAT, PROP_FACTOR);
 -              RNA_def_property_ui_text(prop, "Alpha Threshold",
 -                                       "Z, Index, normal, UV and vector passes are only affected by surfaces with "
 -                                       "alpha transparency equal to or higher than this threshold");
 -              RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 -      }
 +      static EnumPropertyItem draw_groupuser_items[] = {
 +              {OB_DRAW_GROUPUSER_NONE, "NONE", 0, "None", ""},
 +              {OB_DRAW_GROUPUSER_ACTIVE, "ACTIVE", 0, "Active", "Show vertices with no weights in the active group"},
 +              {OB_DRAW_GROUPUSER_ALL, "ALL", 0, "All", "Show vertices with no weights in any group"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
  
 -      /* layer options */
 -      prop = RNA_def_property(srna, "use", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_negative_sdna(prop, NULL, "layflag", SCE_LAY_DISABLE);
 -      RNA_def_property_ui_text(prop, "Enabled", "Disable or enable the render layer");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      static EnumPropertyItem vertex_group_select_items[] = {
 +              {WT_VGROUP_ALL, "ALL", 0, "All", "All Vertex Groups"},
 +              {WT_VGROUP_BONE_DEFORM, "BONE_DEFORM", 0, "Deform", "Vertex Groups assigned to Deform Bones"},
 +              {WT_VGROUP_BONE_DEFORM_OFF, "OTHER_DEFORM", 0, "Other", "Vertex Groups assigned to non Deform Bones"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +      
 +      static EnumPropertyItem gpencil_source_3d_items[] = {
 +              {GP_TOOL_SOURCE_SCENE, "SCENE", 0, "Scene",
 +               "Grease Pencil data attached to the current scene is used, "
 +               "unless the active object already has Grease Pencil data (i.e. for old files)"},
 +              {GP_TOOL_SOURCE_OBJECT, "OBJECT", 0, "Object",
 +               "Grease Pencil data-blocks attached to the active object are used "
 +               "(required when using pre 2.73 add-ons, e.g. BSurfaces)"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +      
 +      static EnumPropertyItem gpencil_stroke_placement_items[] = {
 +              {GP_PROJECT_VIEWSPACE, "CURSOR", 0, "Cursor", "Draw stroke at the 3D cursor"},
 +              {0, "VIEW", 0, "View", "Stick stroke to the view "}, /* weird, GP_PROJECT_VIEWALIGN is inverted */
 +              {GP_PROJECT_VIEWSPACE | GP_PROJECT_DEPTH_VIEW, "SURFACE", 0, "Surface", "Stick stroke to surfaces"},
 +              {GP_PROJECT_VIEWSPACE | GP_PROJECT_DEPTH_STROKE, "STROKE", 0, "Stroke", "Stick stroke to other strokes"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +      
 +      
 +      srna = RNA_def_struct(brna, "ToolSettings", NULL);
 +      RNA_def_struct_path_func(srna, "rna_ToolSettings_path");
 +      RNA_def_struct_ui_text(srna, "Tool Settings", "");
 +      
 +      prop = RNA_def_property(srna, "sculpt", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_struct_type(prop, "Sculpt");
 +      RNA_def_property_ui_text(prop, "Sculpt", "");
 +      
 +      prop = RNA_def_property(srna, "use_auto_normalize", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "auto_normalize", 1);
 +      RNA_def_property_ui_text(prop, "WPaint Auto-Normalize",
 +                               "Ensure all bone-deforming vertex groups add up "
 +                               "to 1.0 while weight painting");
 +      RNA_def_property_update(prop, 0, "rna_Scene_update_active_object_data");
  
 -      prop = RNA_def_property(srna, "use_zmask", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_ZMASK);
 -      RNA_def_property_ui_text(prop, "Zmask", "Only render what's in front of the solid z values");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "use_multipaint", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "multipaint", 1);
 +      RNA_def_property_ui_text(prop, "WPaint Multi-Paint",
 +                               "Paint across the weights of all selected bones, "
 +                               "maintaining their relative influence");
 +      RNA_def_property_update(prop, 0, "rna_Scene_update_active_object_data");
  
 -      prop = RNA_def_property(srna, "invert_zmask", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_NEG_ZMASK);
 -      RNA_def_property_ui_text(prop, "Zmask Negate",
 -                               "For Zmask, only render what is behind solid z values instead of in front");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "vertex_group_user", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "weightuser");
 +      RNA_def_property_enum_items(prop, draw_groupuser_items);
 +      RNA_def_property_ui_text(prop, "Mask Non-Group Vertices", "Display unweighted vertices");
 +      RNA_def_property_update(prop, 0, "rna_Scene_update_active_object_data");
  
 -      prop = RNA_def_property(srna, "use_all_z", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_ALL_Z);
 -      RNA_def_property_ui_text(prop, "All Z", "Fill in Z values for solid faces in invisible layers, for masking");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "vertex_group_subset", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "vgroupsubset");
 +      RNA_def_property_enum_items(prop, vertex_group_select_items);
 +      RNA_def_property_ui_text(prop, "Subset", "Filter Vertex groups for Display");
 +      RNA_def_property_update(prop, 0, "rna_Scene_update_active_object_data");
  
 -      prop = RNA_def_property(srna, "use_solid", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_SOLID);
 -      RNA_def_property_ui_text(prop, "Solid", "Render Solid faces in this Layer");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "vertex_paint", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "vpaint");    RNA_def_property_ui_text(prop, "Vertex Paint", "");
  
 -      prop = RNA_def_property(srna, "use_halo", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_HALO);
 -      RNA_def_property_ui_text(prop, "Halo", "Render Halos in this Layer (on top of Solid)");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "weight_paint", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "wpaint");
 +      RNA_def_property_ui_text(prop, "Weight Paint", "");
  
 -      prop = RNA_def_property(srna, "use_ztransp", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_ZTRA);
 -      RNA_def_property_ui_text(prop, "ZTransp", "Render Z-Transparent faces in this Layer (on top of Solid and Halos)");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "image_paint", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "imapaint");
 +      RNA_def_property_ui_text(prop, "Image Paint", "");
  
 -      prop = RNA_def_property(srna, "use_sky", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_SKY);
 -      RNA_def_property_ui_text(prop, "Sky", "Render Sky in this Layer");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "uv_sculpt", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "uvsculpt");
 +      RNA_def_property_ui_text(prop, "UV Sculpt", "");
  
 -      prop = RNA_def_property(srna, "use_ao", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_AO);
 -      RNA_def_property_ui_text(prop, "AO", "Render AO in this Layer");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "particle_edit", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "particle");
 +      RNA_def_property_ui_text(prop, "Particle Edit", "");
  
 -      prop = RNA_def_property(srna, "use_edge_enhance", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_EDGE);
 -      RNA_def_property_ui_text(prop, "Edge", "Render Edge-enhance in this Layer (only works for Solid faces)");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "use_uv_sculpt", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "use_uv_sculpt", 1);
 +      RNA_def_property_ui_text(prop, "UV Sculpt", "Enable brush for UV sculpting");
 +      RNA_def_property_ui_icon(prop, ICON_TPAINT_HLT, 0);
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, "rna_SpaceImageEditor_uv_sculpt_update");
  
 -      prop = RNA_def_property(srna, "use_strand", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_STRAND);
 -      RNA_def_property_ui_text(prop, "Strand", "Render Strands in this Layer");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "uv_sculpt_lock_borders", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "uv_sculpt_settings", UV_SCULPT_LOCK_BORDERS);
 +      RNA_def_property_ui_text(prop, "Lock Borders", "Disable editing of boundary edges");
  
 -      prop = RNA_def_property(srna, "use_freestyle", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_FRS);
 -      RNA_def_property_ui_text(prop, "Freestyle", "Render stylized strokes in this Layer");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "uv_sculpt_all_islands", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "uv_sculpt_settings", UV_SCULPT_ALL_ISLANDS);
 +      RNA_def_property_ui_text(prop, "Sculpt All Islands", "Brush operates on all islands");
  
 -      /* passes */
 -      prop = RNA_def_property(srna, "use_pass_combined", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_COMBINED);
 -      RNA_def_property_ui_text(prop, "Combined", "Deliver full combined RGBA buffer");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "uv_sculpt_tool", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "uv_sculpt_tool");
 +      RNA_def_property_enum_items(prop, uv_sculpt_tool_items);
 +      RNA_def_property_ui_text(prop, "UV Sculpt Tools", "Select Tools for the UV sculpt brushes");
  
 -      prop = RNA_def_property(srna, "use_pass_z", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_Z);
 -      RNA_def_property_ui_text(prop, "Z", "Deliver Z values pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 -      
 -      prop = RNA_def_property(srna, "use_pass_vector", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_VECTOR);
 -      RNA_def_property_ui_text(prop, "Vector", "Deliver speed vector pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "uv_relax_method", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "uv_relax_method");
 +      RNA_def_property_enum_items(prop, uv_sculpt_relaxation_items);
 +      RNA_def_property_ui_text(prop, "Relaxation Method", "Algorithm used for UV relaxation");
  
 -      prop = RNA_def_property(srna, "use_pass_normal", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_NORMAL);
 -      RNA_def_property_ui_text(prop, "Normal", "Deliver normal pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      /* Transform */
 +      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, rna_enum_proportional_editing_items);
 +      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_pass_uv", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_UV);
 -      RNA_def_property_ui_text(prop, "UV", "Deliver texture UV pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "use_proportional_edit_objects", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "proportional_objects", 0);
 +      RNA_def_property_ui_text(prop, "Proportional Editing Objects", "Proportional editing object mode");
 +      RNA_def_property_ui_icon(prop, ICON_PROP_OFF, 1);
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
  
 -      prop = RNA_def_property(srna, "use_pass_mist", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_MIST);
 -      RNA_def_property_ui_text(prop, "Mist", "Deliver mist factor pass (0.0-1.0)");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "use_proportional_edit_mask", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "proportional_mask", 0);
 +      RNA_def_property_ui_text(prop, "Proportional Editing Objects", "Proportional editing mask mode");
 +      RNA_def_property_ui_icon(prop, ICON_PROP_OFF, 1);
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
  
 -      prop = RNA_def_property(srna, "use_pass_object_index", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_INDEXOB);
 -      RNA_def_property_ui_text(prop, "Object Index", "Deliver object index pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "use_proportional_action", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "proportional_action", 0);
 +      RNA_def_property_ui_text(prop, "Proportional Editing Actions", "Proportional editing in action editor");
 +      RNA_def_property_ui_icon(prop, ICON_PROP_OFF, 1);
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
  
 -      prop = RNA_def_property(srna, "use_pass_material_index", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_INDEXMA);
 -      RNA_def_property_ui_text(prop, "Material Index", "Deliver material index pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "use_proportional_fcurve", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "proportional_fcurve", 0);
 +      RNA_def_property_ui_text(prop, "Proportional Editing FCurves", "Proportional editing in FCurve editor");
 +      RNA_def_property_ui_icon(prop, ICON_PROP_OFF, 1);
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
  
 -      prop = RNA_def_property(srna, "use_pass_color", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_RGBA);
 -      RNA_def_property_ui_text(prop, "Color", "Deliver shade-less color pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "lock_markers", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "lock_markers", 0);
 +      RNA_def_property_ui_text(prop, "Lock Markers", "Prevent marker editing");
  
 -      prop = RNA_def_property(srna, "use_pass_diffuse", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_DIFFUSE);
 -      RNA_def_property_ui_text(prop, "Diffuse", "Deliver diffuse pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "proportional_edit_falloff", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "prop_mode");
 +      RNA_def_property_enum_items(prop, rna_enum_proportional_falloff_items);
 +      RNA_def_property_ui_text(prop, "Proportional Editing Falloff", "Falloff type for proportional editing mode");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
  
 -      prop = RNA_def_property(srna, "use_pass_specular", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SPEC);
 -      RNA_def_property_ui_text(prop, "Specular", "Deliver specular pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 -
 -      prop = RNA_def_property(srna, "use_pass_shadow", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SHADOW);
 -      RNA_def_property_ui_text(prop, "Shadow", "Deliver shadow pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 -
 -      prop = RNA_def_property(srna, "use_pass_ambient_occlusion", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_AO);
 -      RNA_def_property_ui_text(prop, "AO", "Deliver AO pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "proportional_size", PROP_FLOAT, PROP_DISTANCE);
 +      RNA_def_property_float_sdna(prop, NULL, "proportional_size");
 +      RNA_def_property_ui_text(prop, "Proportional Size", "Display size for proportional editing circle");
 +      RNA_def_property_range(prop, 0.00001, 5000.0);
        
 -      prop = RNA_def_property(srna, "use_pass_reflection", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_REFLECT);
 -      RNA_def_property_ui_text(prop, "Reflection", "Deliver raytraced reflection pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 -
 -      prop = RNA_def_property(srna, "use_pass_refraction", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_REFRACT);
 -      RNA_def_property_ui_text(prop, "Refraction", "Deliver raytraced refraction pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "normal_size", PROP_FLOAT, PROP_DISTANCE);
 +      RNA_def_property_float_sdna(prop, NULL, "normalsize");
 +      RNA_def_property_ui_text(prop, "Normal Size", "Display size for normals in the 3D view");
 +      RNA_def_property_range(prop, 0.00001, 1000.0);
 +      RNA_def_property_ui_range(prop, 0.01, 10.0, 10.0, 2);
 +      RNA_def_property_update(prop, NC_GEOM | ND_DATA, NULL);
  
 -      prop = RNA_def_property(srna, "use_pass_emit", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_EMIT);
 -      RNA_def_property_ui_text(prop, "Emit", "Deliver emission pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "double_threshold", PROP_FLOAT, PROP_DISTANCE);
 +      RNA_def_property_float_sdna(prop, NULL, "doublimit");
 +      RNA_def_property_ui_text(prop, "Double Threshold", "Limit for removing duplicates and 'Auto Merge'");
 +      RNA_def_property_range(prop, 0.0, 1.0);
 +      RNA_def_property_ui_range(prop, 0.0, 0.1, 0.01, 6);
  
 -      prop = RNA_def_property(srna, "use_pass_environment", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_ENVIRONMENT);
 -      RNA_def_property_ui_text(prop, "Environment", "Deliver environment lighting pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "use_mesh_automerge", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "automerge", 0);
 +      RNA_def_property_ui_text(prop, "AutoMerge Editing", "Automatically merge vertices moved to the same location");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
  
 -      prop = RNA_def_property(srna, "use_pass_indirect", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_INDIRECT);
 -      RNA_def_property_ui_text(prop, "Indirect", "Deliver indirect lighting pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "use_snap", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "snap_flag", SCE_SNAP);
 +      RNA_def_property_ui_text(prop, "Snap", "Snap during transform");
 +      RNA_def_property_ui_icon(prop, ICON_SNAP_OFF, 1);
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
  
 -      prop = RNA_def_property(srna, "exclude_specular", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_SPEC);
 -      RNA_def_property_ui_text(prop, "Specular Exclude", "Exclude specular pass from combined");
 -      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "use_snap_align_rotation", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "snap_flag", SCE_SNAP_ROTATE);
 +      RNA_def_property_ui_text(prop, "Snap Align Rotation", "Align rotation with the snapping target");
 +      RNA_def_property_ui_icon(prop, ICON_SNAP_NORMAL, 0);
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
  
 -      prop = RNA_def_property(srna, "exclude_shadow", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_SHADOW);
 -      RNA_def_property_ui_text(prop, "Shadow Exclude", "Exclude shadow pass from combined");
 -      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "use_snap_grid_absolute", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "snap_flag", SCE_SNAP_ABS_GRID);
 +      RNA_def_property_ui_text(prop, "Absolute Grid Snap",
 +                               "Absolute grid alignment while translating (based on the pivot center)");
 +      RNA_def_property_ui_icon(prop, ICON_SNAP_GRID, 0);
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
  
 -      prop = RNA_def_property(srna, "exclude_ambient_occlusion", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_AO);
 -      RNA_def_property_ui_text(prop, "AO Exclude", "Exclude AO pass from combined");
 -      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "snap_element", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "snap_mode");
 +      RNA_def_property_enum_items(prop, rna_enum_snap_element_items);
 +      RNA_def_property_ui_text(prop, "Snap Element", "Type of element to snap to");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
        
 -      prop = RNA_def_property(srna, "exclude_reflection", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_REFLECT);
 -      RNA_def_property_ui_text(prop, "Reflection Exclude", "Exclude raytraced reflection pass from combined");
 -      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      /* node editor uses own set of snap modes */
 +      prop = RNA_def_property(srna, "snap_node_element", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "snap_node_mode");
 +      RNA_def_property_enum_items(prop, rna_enum_snap_node_element_items);
 +      RNA_def_property_ui_text(prop, "Snap Node Element", "Type of element to snap to");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +      
 +      /* image editor uses own set of snap modes */
 +      prop = RNA_def_property(srna, "snap_uv_element", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "snap_uv_mode");
 +      RNA_def_property_enum_items(prop, snap_uv_element_items);
 +      RNA_def_property_ui_text(prop, "Snap UV Element", "Type of element to snap to");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
  
 -      prop = RNA_def_property(srna, "exclude_refraction", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_REFRACT);
 -      RNA_def_property_ui_text(prop, "Refraction Exclude", "Exclude raytraced refraction pass from combined");
 -      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "snap_target", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "snap_target");
 +      RNA_def_property_enum_items(prop, rna_enum_snap_target_items);
 +      RNA_def_property_ui_text(prop, "Snap Target", "Which part to snap onto the target");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
  
 -      prop = RNA_def_property(srna, "exclude_emit", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_EMIT);
 -      RNA_def_property_ui_text(prop, "Emit Exclude", "Exclude emission pass from combined");
 -      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "use_snap_peel_object", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "snap_flag", SCE_SNAP_PEEL_OBJECT);
 +      RNA_def_property_ui_text(prop, "Snap Peel Object", "Consider objects as whole when finding volume center");
 +      RNA_def_property_ui_icon(prop, ICON_SNAP_PEEL_OBJECT, 0);
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
 +      
 +      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_icon(prop, ICON_RETOPO, 0);
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
  
 -      prop = RNA_def_property(srna, "exclude_environment", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_ENVIRONMENT);
 -      RNA_def_property_ui_text(prop, "Environment Exclude", "Exclude environment pass from combined");
 -      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      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 itself (editmode)");
 +      RNA_def_property_ui_icon(prop, ICON_ORTHO, 0);
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* header redraw */
  
 -      prop = RNA_def_property(srna, "exclude_indirect", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_INDIRECT);
 -      RNA_def_property_ui_text(prop, "Indirect Exclude", "Exclude indirect pass from combined");
 -      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      /* Grease Pencil */
 +      prop = RNA_def_property(srna, "use_gpencil_continuous_drawing", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "gpencil_flags", GP_TOOL_FLAG_PAINTSESSIONS_ON);
 +      RNA_def_property_ui_text(prop, "Use Continuous Drawing",
 +                               "Allow drawing multiple strokes at a time with Grease Pencil");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL); /* xxx: need toolbar to be redrawn... */
 +      
 +      prop = RNA_def_property(srna, "use_gpencil_additive_drawing", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "gpencil_flags", GP_TOOL_FLAG_RETAIN_LAST);
 +      RNA_def_property_ui_text(prop, "Use Additive Drawing",
 +                               "When creating new frames, the strokes from the previous/active frame "
 +                               "are included as the basis for the new one");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
 +      
 +      prop = RNA_def_property(srna, "use_gpencil_draw_onback", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "gpencil_flags", GP_TOOL_FLAG_PAINT_ONBACK);
 +      RNA_def_property_ui_text(prop, "Draw Strokes on Back",
 +              "When draw new strokes, the new stroke is drawn below of all strokes in the layer");
 +      RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
  
 -      prop = RNA_def_property(srna, "use_pass_diffuse_direct", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_DIFFUSE_DIRECT);
 -      RNA_def_property_ui_text(prop, "Diffuse Direct", "Deliver diffuse direct pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "grease_pencil_source", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_src");
 +      RNA_def_property_enum_items(prop, gpencil_source_3d_items);
 +      RNA_def_property_ui_text(prop, "Grease Pencil Source",
 +                               "Data-block where active Grease Pencil data is found from");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      
 +      prop = RNA_def_property(srna, "gpencil_sculpt", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "gp_sculpt");
 +      RNA_def_property_struct_type(prop, "GPencilSculptSettings");
 +      RNA_def_property_ui_text(prop, "Grease Pencil Sculpt",
 +                               "Settings for stroke sculpting tools and brushes");
 +      
 +      prop = RNA_def_property(srna, "gpencil_interpolate", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "gp_interpolate");
 +      RNA_def_property_struct_type(prop, "GPencilInterpolateSettings");
 +      RNA_def_property_ui_text(prop, "Grease Pencil Interpolate", 
 +                              "Settings for Grease Pencil Interpolation tools");
  
 -      prop = RNA_def_property(srna, "use_pass_diffuse_indirect", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_DIFFUSE_INDIRECT);
 -      RNA_def_property_ui_text(prop, "Diffuse Indirect", "Deliver diffuse indirect pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      /* Grease Pencil - Drawing brushes */
 +      prop = RNA_def_property(srna, "gpencil_brushes", PROP_COLLECTION, PROP_NONE);
 +      RNA_def_property_collection_sdna(prop, NULL, "gp_brushes", NULL);
 +      RNA_def_property_struct_type(prop, "GPencilBrush");
 +      RNA_def_property_ui_text(prop, "Grease Pencil Brushes", "Grease Pencil drawing brushes");
 +      rna_def_gpencil_brushes(brna, prop);
  
 -      prop = RNA_def_property(srna, "use_pass_diffuse_color", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_DIFFUSE_COLOR);
 -      RNA_def_property_ui_text(prop, "Diffuse Color", "Deliver diffuse color pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      /* Grease Pencil - 3D View Stroke Placement */
 +      prop = RNA_def_property(srna, "gpencil_stroke_placement_view3d", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_v3d_align");
 +      RNA_def_property_enum_items(prop, gpencil_stroke_placement_items);
 +      RNA_def_property_ui_text(prop, "Stroke Placement (3D View)", "");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      
 +      prop = RNA_def_property(srna, "use_gpencil_stroke_endpoints", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "gpencil_v3d_align", GP_PROJECT_DEPTH_STROKE_ENDPOINTS);
 +      RNA_def_property_ui_text(prop, "Only Endpoints", "Only use the first and last parts of the stroke for snapping");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      
 +      /* Grease Pencil - 2D Views Stroke Placement */
 +      prop = RNA_def_property(srna, "gpencil_stroke_placement_view2d", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_v2d_align");
 +      RNA_def_property_enum_items(prop, gpencil_stroke_placement_items);
 +      RNA_def_property_ui_text(prop, "Stroke Placement (2D View)", "");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
  
 -      prop = RNA_def_property(srna, "use_pass_glossy_direct", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_GLOSSY_DIRECT);
 -      RNA_def_property_ui_text(prop, "Glossy Direct", "Deliver glossy direct pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      /* Grease Pencil - Sequencer Preview Stroke Placement */
 +      prop = RNA_def_property(srna, "gpencil_stroke_placement_sequencer_preview", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_seq_align");
 +      RNA_def_property_enum_items(prop, gpencil_stroke_placement_items);
 +      RNA_def_property_ui_text(prop, "Stroke Placement (Sequencer Preview)", "");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
 +      
 +      /* Grease Pencil - Image Editor Stroke Placement */
 +      prop = RNA_def_property(srna, "gpencil_stroke_placement_image_editor", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "gpencil_ima_align");
 +      RNA_def_property_enum_items(prop, gpencil_stroke_placement_items);
 +      RNA_def_property_ui_text(prop, "Stroke Placement (Image Editor)", "");
 +      RNA_def_property_update(prop, NC_GPENCIL | ND_DATA, NULL);
  
 -      prop = RNA_def_property(srna, "use_pass_glossy_indirect", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_GLOSSY_INDIRECT);
 -      RNA_def_property_ui_text(prop, "Glossy Indirect", "Deliver glossy indirect pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      
 +      /* Auto Keying */
 +      prop = RNA_def_property(srna, "use_keyframe_insert_auto", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "autokey_mode", AUTOKEY_ON);
 +      RNA_def_property_ui_text(prop, "Auto Keying", "Automatic keyframe insertion for Objects and Bones");
 +      RNA_def_property_ui_icon(prop, ICON_REC, 0);
 +      
 +      prop = RNA_def_property(srna, "auto_keying_mode", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "autokey_mode");
 +      RNA_def_property_enum_items(prop, auto_key_items);
 +      RNA_def_property_ui_text(prop, "Auto-Keying Mode", "Mode of automatic keyframe insertion for Objects and Bones");
 +      
 +      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");
 +      
 +      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_icon(prop, ICON_KEYINGSET, 0);
 +      
 +      /* Keyframing */
 +      prop = RNA_def_property(srna, "keyframe_type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "keyframe_type");
 +      RNA_def_property_enum_items(prop, rna_enum_beztriple_keyframe_type_items);
 +      RNA_def_property_ui_text(prop, "New Keyframe Type", "Type of keyframes to create when inserting keyframes");
 +      
 +      /* UV */
 +      prop = RNA_def_property(srna, "uv_select_mode", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "uv_selectmode");
 +      RNA_def_property_enum_items(prop, uv_select_mode_items);
 +      RNA_def_property_ui_text(prop, "UV Selection Mode", "UV selection and display mode");
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, NULL);
  
 -      prop = RNA_def_property(srna, "use_pass_glossy_color", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_GLOSSY_COLOR);
 -      RNA_def_property_ui_text(prop, "Glossy Color", "Deliver glossy color pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "use_uv_select_sync", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "uv_flag", UV_SYNC_SELECTION);
 +      RNA_def_property_ui_text(prop, "UV Sync Selection", "Keep UV and edit mode mesh selection in sync");
 +      RNA_def_property_ui_icon(prop, ICON_EDIT, 0);
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, NULL);
  
 -      prop = RNA_def_property(srna, "use_pass_transmission_direct", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_TRANSM_DIRECT);
 -      RNA_def_property_ui_text(prop, "Transmission Direct", "Deliver transmission direct pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "show_uv_local_view", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "uv_flag", UV_SHOW_SAME_IMAGE);
 +      RNA_def_property_ui_text(prop, "UV Local View", "Draw only faces with the currently displayed image assigned");
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_IMAGE, NULL);
  
 -      prop = RNA_def_property(srna, "use_pass_transmission_indirect", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_TRANSM_INDIRECT);
 -      RNA_def_property_ui_text(prop, "Transmission Indirect", "Deliver transmission indirect pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      /* Mesh */
 +      prop = RNA_def_property(srna, "mesh_select_mode", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "selectmode", 1);
 +      RNA_def_property_array(prop, 3);
 +      RNA_def_property_boolean_funcs(prop, NULL, "rna_Scene_editmesh_select_mode_set");
 +      RNA_def_property_ui_text(prop, "Mesh Selection Mode", "Which mesh elements selection works on");
 +      RNA_def_property_update(prop, 0, "rna_Scene_editmesh_select_mode_update");
  
 -      prop = RNA_def_property(srna, "use_pass_transmission_color", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_TRANSM_COLOR);
 -      RNA_def_property_ui_text(prop, "Transmission Color", "Deliver transmission color pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 -      
 -      prop = RNA_def_property(srna, "use_pass_subsurface_direct", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SUBSURFACE_DIRECT);
 -      RNA_def_property_ui_text(prop, "Subsurface Direct", "Deliver subsurface direct pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "vertex_group_weight", PROP_FLOAT, PROP_FACTOR);
 +      RNA_def_property_float_sdna(prop, NULL, "vgroup_weight");
 +      RNA_def_property_ui_text(prop, "Vertex Group Weight", "Weight to assign in vertex groups");
  
 -      prop = RNA_def_property(srna, "use_pass_subsurface_indirect", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SUBSURFACE_INDIRECT);
 -      RNA_def_property_ui_text(prop, "Subsurface Indirect", "Deliver subsurface indirect pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      /* use with MESH_OT_shortest_path_pick */
 +      prop = RNA_def_property(srna, "edge_path_mode", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "edge_mode");
 +      RNA_def_property_enum_items(prop, edge_tag_items);
 +      RNA_def_property_ui_text(prop, "Edge Tag Mode", "The edge flag to tag when selecting the shortest path");
  
 -      prop = RNA_def_property(srna, "use_pass_subsurface_color", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SUBSURFACE_COLOR);
 -      RNA_def_property_ui_text(prop, "Subsurface Color", "Deliver subsurface color pass");
 -      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 -      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 -}
 +      prop = RNA_def_property(srna, "edge_path_live_unwrap", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "edge_mode_live_unwrap", 1);
 +      RNA_def_property_ui_text(prop, "Live Unwrap", "Changing edges seam re-calculates UV unwrap");
  
 -static void rna_def_freestyle_modules(BlenderRNA *brna, PropertyRNA *cprop)
 -{
 -      StructRNA *srna;
 -      FunctionRNA *func;
 -      PropertyRNA *parm;
 +      /* etch-a-ton */
 +      prop = RNA_def_property(srna, "use_bone_sketching", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "bone_sketching", BONE_SKETCHING);
 +      RNA_def_property_ui_text(prop, "Use Bone Sketching", "Use sketching to create and edit bones");
 +/*    RNA_def_property_ui_icon(prop, ICON_EDIT, 0); */
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
  
 -      RNA_def_property_srna(cprop, "FreestyleModules");
 -      srna = RNA_def_struct(brna, "FreestyleModules", NULL);
 -      RNA_def_struct_sdna(srna, "FreestyleSettings");
 -      RNA_def_struct_ui_text(srna, "Style Modules", "A list of style modules (to be applied from top to bottom)");
 +      prop = RNA_def_property(srna, "use_etch_quick", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "bone_sketching", BONE_SKETCHING_QUICK);
 +      RNA_def_property_ui_text(prop, "Quick Sketching", "Automatically convert and delete on stroke end");
  
 -      func = RNA_def_function(srna, "new", "rna_FreestyleSettings_module_add");
 -      RNA_def_function_ui_description(func, "Add a style module to scene render layer Freestyle settings");
 -      RNA_def_function_flag(func, FUNC_USE_SELF_ID);
 -      parm = RNA_def_pointer(func, "module", "FreestyleModuleSettings", "", "Newly created style module");
 -      RNA_def_function_return(func, parm);
 +      prop = RNA_def_property(srna, "use_etch_overdraw", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "bone_sketching", BONE_SKETCHING_ADJUST);
 +      RNA_def_property_ui_text(prop, "Overdraw Sketching", "Adjust strokes by drawing near them");
 +      
 +      prop = RNA_def_property(srna, "use_etch_autoname", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "skgen_retarget_options", SK_RETARGET_AUTONAME);
 +      RNA_def_property_ui_text(prop, "Autoname Bones",
 +                               "Automatically generate values to replace &N and &S suffix placeholders in template names");
  
 -      func = RNA_def_function(srna, "remove", "rna_FreestyleSettings_module_remove");
 -      RNA_def_function_ui_description(func, "Remove a style module from scene render layer Freestyle settings");
 -      RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_REPORTS);
 -      parm = RNA_def_pointer(func, "module", "FreestyleModuleSettings", "", "Style module to remove");
 -      RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
 -      RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
 -}
 +      prop = RNA_def_property(srna, "etch_number", PROP_STRING, PROP_NONE);
 +      RNA_def_property_string_sdna(prop, NULL, "skgen_num_string");
 +      RNA_def_property_ui_text(prop, "Number", "Text to replace &N with (e.g. 'Finger.&N' -> 'Finger.1' or 'Finger.One')");
  
 -static void rna_def_freestyle_linesets(BlenderRNA *brna, PropertyRNA *cprop)
 -{
 -      StructRNA *srna;
 -      PropertyRNA *prop;
 -      FunctionRNA *func;
 -      PropertyRNA *parm;
 +      prop = RNA_def_property(srna, "etch_side", PROP_STRING, PROP_NONE);
 +      RNA_def_property_string_sdna(prop, NULL, "skgen_num_string");
 +      RNA_def_property_ui_text(prop, "Side", "Text to replace &S with (e.g. 'Arm.&S' -> 'Arm.R' or 'Arm.Right')");
  
 -      RNA_def_property_srna(cprop, "Linesets");
 -      srna = RNA_def_struct(brna, "Linesets", NULL);
 -      RNA_def_struct_sdna(srna, "FreestyleSettings");
 -      RNA_def_struct_ui_text(srna, "Line Sets", "Line sets for associating lines and style parameters");
 +      prop = RNA_def_property(srna, "etch_template", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "skgen_template");
 +      RNA_def_property_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_struct_type(prop, "Object");
 +      RNA_def_property_pointer_funcs(prop, NULL, "rna_Scene_skgen_etch_template_set", NULL, NULL);
 +      RNA_def_property_ui_text(prop, "Template", "Template armature that will be retargeted to the stroke");
  
 -      prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_struct_type(prop, "FreestyleLineSet");
 -      RNA_def_property_pointer_funcs(prop, "rna_FreestyleSettings_active_lineset_get", NULL, NULL, NULL);
 -      RNA_def_property_ui_text(prop, "Active Line Set", "Active line set being displayed");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "etch_subdivision_number", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "skgen_subdivision_number");
 +      RNA_def_property_range(prop, 1, 255);
 +      RNA_def_property_ui_text(prop, "Subdivisions", "Number of bones in the subdivided stroke");
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
  
 -      prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
 -      RNA_def_property_int_funcs(prop, "rna_FreestyleSettings_active_lineset_index_get",
 -                                 "rna_FreestyleSettings_active_lineset_index_set",
 -                                 "rna_FreestyleSettings_active_lineset_index_range");
 -      RNA_def_property_ui_text(prop, "Active Line Set Index", "Index of active line set slot");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "etch_adaptive_limit", PROP_FLOAT, PROP_FACTOR);
 +      RNA_def_property_float_sdna(prop, NULL, "skgen_correlation_limit");
 +      RNA_def_property_range(prop, 0.00001, 1.0);
 +      RNA_def_property_ui_range(prop, 0.01, 1.0, 0.01, 2);
 +      RNA_def_property_ui_text(prop, "Limit", "Correlation threshold for number of bones in the subdivided stroke");
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
  
 -      func = RNA_def_function(srna, "new", "rna_FreestyleSettings_lineset_add");
 -      RNA_def_function_ui_description(func, "Add a line set to scene render layer Freestyle settings");
 -      RNA_def_function_flag(func, FUNC_USE_MAIN | FUNC_USE_SELF_ID);
 -      parm = RNA_def_string(func, "name", "LineSet", 0, "", "New name for the line set (not unique)");
 -      RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
 -      parm = RNA_def_pointer(func, "lineset", "FreestyleLineSet", "", "Newly created line set");
 -      RNA_def_function_return(func, parm);
 +      prop = RNA_def_property(srna, "etch_length_limit", PROP_FLOAT, PROP_DISTANCE);
 +      RNA_def_property_float_sdna(prop, NULL, "skgen_length_limit");
 +      RNA_def_property_range(prop, 0.00001, 100000.0);
 +      RNA_def_property_ui_range(prop, 0.001, 100.0, 0.1, 3);
 +      RNA_def_property_ui_text(prop, "Length", "Maximum length of the subdivided bones");
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
  
 -      func = RNA_def_function(srna, "remove", "rna_FreestyleSettings_lineset_remove");
 -      RNA_def_function_ui_description(func, "Remove a line set from scene render layer Freestyle settings");
 -      RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_REPORTS);
 -      parm = RNA_def_pointer(func, "lineset", "FreestyleLineSet", "", "Line set to remove");
 -      RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
 -      RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
 +      prop = RNA_def_property(srna, "etch_roll_mode", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "skgen_retarget_roll");
 +      RNA_def_property_enum_items(prop, retarget_roll_items);
 +      RNA_def_property_ui_text(prop, "Retarget roll mode", "Method used to adjust the roll of bones when retargeting");
 +      
 +      prop = RNA_def_property(srna, "etch_convert_mode", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "bone_sketching_convert");
 +      RNA_def_property_enum_items(prop, sketch_convert_items);
 +      RNA_def_property_ui_text(prop, "Stroke conversion method", "Method used to convert stroke to bones");
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +
 +      /* Unified Paint Settings */
 +      prop = RNA_def_property(srna, "unified_paint_settings", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_flag(prop, PROP_NEVER_NULL);
 +      RNA_def_property_struct_type(prop, "UnifiedPaintSettings");
 +      RNA_def_property_ui_text(prop, "Unified Paint Settings", NULL);
 +
 +      /* Curve Paint Settings */
 +      prop = RNA_def_property(srna, "curve_paint_settings", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_flag(prop, PROP_NEVER_NULL);
 +      RNA_def_property_struct_type(prop, "CurvePaintSettings");
 +      RNA_def_property_ui_text(prop, "Curve Paint Settings", NULL);
 +
 +      /* Mesh Statistics */
 +      prop = RNA_def_property(srna, "statvis", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_flag(prop, PROP_NEVER_NULL);
 +      RNA_def_property_struct_type(prop, "MeshStatVis");
 +      RNA_def_property_ui_text(prop, "Mesh Statistics Visualization", NULL);
  }
  
 -static void rna_def_freestyle_settings(BlenderRNA *brna)
 +static void rna_def_unified_paint_settings(BlenderRNA  *brna)
  {
        StructRNA *srna;
        PropertyRNA *prop;
  
 -      static EnumPropertyItem edge_type_negation_items[] = {
 -              {0, "INCLUSIVE", 0, "Inclusive", "Select feature edges satisfying the given edge type conditions"},
 -              {FREESTYLE_LINESET_FE_NOT, "EXCLUSIVE", 0, "Exclusive",
 -                                         "Select feature edges not satisfying the given edge type conditions"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +      srna = RNA_def_struct(brna, "UnifiedPaintSettings", NULL);
 +      RNA_def_struct_path_func(srna, "rna_UnifiedPaintSettings_path");
 +      RNA_def_struct_ui_text(srna, "Unified Paint Settings", "Overrides for some of the active brush's settings");
  
 -      static EnumPropertyItem edge_type_combination_items[] = {
 -              {0, "OR", 0, "Logical OR", "Select feature edges satisfying at least one of edge type conditions"},
 -              {FREESTYLE_LINESET_FE_AND, "AND", 0, "Logical AND",
 -                                         "Select feature edges satisfying all edge type conditions"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +      /* high-level flags to enable or disable unified paint settings */
 +      prop = RNA_def_property(srna, "use_unified_size", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_SIZE);
 +      RNA_def_property_ui_text(prop, "Use Unified Radius",
 +                               "Instead of per-brush radius, the radius is shared across brushes");
  
 -      static EnumPropertyItem group_negation_items[] = {
 -              {0, "INCLUSIVE", 0, "Inclusive", "Select feature edges belonging to some object in the group"},
 -              {FREESTYLE_LINESET_GR_NOT, "EXCLUSIVE", 0, "Exclusive",
 -                                         "Select feature edges not belonging to any object in the group"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +      prop = RNA_def_property(srna, "use_unified_strength", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_ALPHA);
 +      RNA_def_property_ui_text(prop, "Use Unified Strength",
 +                               "Instead of per-brush strength, the strength is shared across brushes");
  
 -      static EnumPropertyItem face_mark_negation_items[] = {
 -              {0, "INCLUSIVE", 0, "Inclusive", "Select feature edges satisfying the given face mark conditions"},
 -              {FREESTYLE_LINESET_FM_NOT, "EXCLUSIVE", 0, "Exclusive",
 -                                         "Select feature edges not satisfying the given face mark conditions"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +      prop = RNA_def_property(srna, "use_unified_weight", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_WEIGHT);
 +      RNA_def_property_ui_text(prop, "Use Unified Weight",
 +                               "Instead of per-brush weight, the weight is shared across brushes");
  
 -      static EnumPropertyItem face_mark_condition_items[] = {
 -              {0, "ONE", 0, "One Face", "Select a feature edge if either of its adjacent faces is marked"},
 -              {FREESTYLE_LINESET_FM_BOTH, "BOTH", 0, "Both Faces",
 -                                          "Select a feature edge if both of its adjacent faces are marked"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +      prop = RNA_def_property(srna, "use_unified_color", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_COLOR);
 +      RNA_def_property_ui_text(prop, "Use Unified Color",
 +                               "Instead of per-brush color, the color is shared across brushes");
  
 -      static EnumPropertyItem freestyle_ui_mode_items[] = {
 -              {FREESTYLE_CONTROL_SCRIPT_MODE, "SCRIPT", 0, "Python Scripting Mode",
 -                                              "Advanced mode for using style modules written in Python"},
 -              {FREESTYLE_CONTROL_EDITOR_MODE, "EDITOR", 0, "Parameter Editor Mode",
 -                                              "Basic mode for interactive style parameter editing"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +      /* unified paint settings that override the equivalent settings
 +       * from the active brush */
 +      prop = RNA_def_property(srna, "size", PROP_INT, PROP_PIXEL);
 +      RNA_def_property_int_funcs(prop, NULL, "rna_UnifiedPaintSettings_size_set", NULL);
 +      RNA_def_property_range(prop, 1, MAX_BRUSH_PIXEL_RADIUS * 10);
 +      RNA_def_property_ui_range(prop, 1, MAX_BRUSH_PIXEL_RADIUS, 1, -1);
 +      RNA_def_property_ui_text(prop, "Radius", "Radius of the brush");
 +      RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_radius_update");
  
 -      static EnumPropertyItem visibility_items[] = {
 -              {FREESTYLE_QI_VISIBLE, "VISIBLE", 0, "Visible", "Select visible feature edges"},
 -              {FREESTYLE_QI_HIDDEN, "HIDDEN", 0, "Hidden", "Select hidden feature edges"},
 -              {FREESTYLE_QI_RANGE, "RANGE", 0, "QI Range",
 -                                   "Select feature edges within a range of quantitative invisibility (QI) values"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +      prop = RNA_def_property(srna, "unprojected_radius", PROP_FLOAT, PROP_DISTANCE);
 +      RNA_def_property_float_funcs(prop, NULL, "rna_UnifiedPaintSettings_unprojected_radius_set", NULL);
 +      RNA_def_property_range(prop, 0.001, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.001, 1, 0, -1);
 +      RNA_def_property_ui_text(prop, "Unprojected Radius", "Radius of brush in Blender units");
 +      RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_radius_update");
  
 -      /* FreestyleLineSet */
 +      prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_FACTOR);
 +      RNA_def_property_float_sdna(prop, NULL, "alpha");
 +      RNA_def_property_float_default(prop, 0.5f);
 +      RNA_def_property_range(prop, 0.0f, 10.0f);
 +      RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
 +      RNA_def_property_ui_text(prop, "Strength", "How powerful the effect of the brush is when applied");
 +      RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_update");
  
 -      srna = RNA_def_struct(brna, "FreestyleLineSet", NULL);
 -      RNA_def_struct_ui_text(srna, "Freestyle Line Set", "Line set for associating lines and style parameters");
 +      prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_FACTOR);
 +      RNA_def_property_float_sdna(prop, NULL, "weight");
 +      RNA_def_property_float_default(prop, 0.5f);
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.001, 3);
 +      RNA_def_property_ui_text(prop, "Weight", "Weight to assign in vertex groups");
 +      RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_update");
  
 -      /* access to line style settings is redirected through functions
 -       * to allow proper id-buttons functionality
 -       */
 -      prop = RNA_def_property(srna, "linestyle", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_struct_type(prop, "FreestyleLineStyle");
 -      RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
 -      RNA_def_property_pointer_funcs(prop, "rna_FreestyleLineSet_linestyle_get",
 -                                     "rna_FreestyleLineSet_linestyle_set", NULL, NULL);
 -      RNA_def_property_ui_text(prop, "Line Style", "Line style settings");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
 +      RNA_def_property_range(prop, 0.0, 1.0);
 +      RNA_def_property_float_sdna(prop, NULL, "rgb");
 +      RNA_def_property_ui_text(prop, "Color", "");
 +      RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_update");
  
 -      prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
 -      RNA_def_property_string_sdna(prop, NULL, "name");
 -      RNA_def_property_ui_text(prop, "Line Set Name", "Line set name");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 -      RNA_def_struct_name_property(srna, prop);
 +      prop = RNA_def_property(srna, "secondary_color", PROP_FLOAT, PROP_COLOR_GAMMA);
 +      RNA_def_property_range(prop, 0.0, 1.0);
 +      RNA_def_property_float_sdna(prop, NULL, "secondary_rgb");
 +      RNA_def_property_ui_text(prop, "Secondary Color", "");
 +      RNA_def_property_update(prop, 0, "rna_UnifiedPaintSettings_update");
  
 -      prop = RNA_def_property(srna, "show_render", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_LINESET_ENABLED);
 -      RNA_def_property_ui_text(prop, "Render", "Enable or disable this line set during stroke rendering");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "use_pressure_size", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_BRUSH_SIZE_PRESSURE);
 +      RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
 +      RNA_def_property_ui_text(prop, "Size Pressure", "Enable tablet pressure sensitivity for size");
  
 -      prop = RNA_def_property(srna, "select_by_visibility", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "selection", FREESTYLE_SEL_VISIBILITY);
 -      RNA_def_property_ui_text(prop, "Selection by Visibility", "Select feature edges based on visibility");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "use_pressure_strength", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_BRUSH_ALPHA_PRESSURE);
 +      RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
 +      RNA_def_property_ui_text(prop, "Strength Pressure", "Enable tablet pressure sensitivity for strength");
  
 -      prop = RNA_def_property(srna, "select_by_edge_types", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "selection", FREESTYLE_SEL_EDGE_TYPES);
 -      RNA_def_property_ui_text(prop, "Selection by Edge Types", "Select feature edges based on edge types");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "use_locked_size", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", UNIFIED_PAINT_BRUSH_LOCK_SIZE);
 +      RNA_def_property_ui_text(prop, "Use Blender Units",
 +                               "When locked brush stays same size relative to object; "
 +                               "when unlocked brush size is given in pixels");
 +}
  
 -      prop = RNA_def_property(srna, "select_by_group", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "selection", FREESTYLE_SEL_GROUP);
 -      RNA_def_property_ui_text(prop, "Selection by Group", "Select feature edges based on a group of objects");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
  
 -      prop = RNA_def_property(srna, "select_by_image_border", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "selection", FREESTYLE_SEL_IMAGE_BORDER);
 -      RNA_def_property_ui_text(prop, "Selection by Image Border",
 -                               "Select feature edges by image border (less memory consumption)");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +static void rna_def_curve_paint_settings(BlenderRNA  *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
  
 -      prop = RNA_def_property(srna, "select_by_face_marks", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "selection", FREESTYLE_SEL_FACE_MARK);
 -      RNA_def_property_ui_text(prop, "Selection by Face Marks", "Select feature edges by face marks");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      srna = RNA_def_struct(brna, "CurvePaintSettings", NULL);
 +      RNA_def_struct_path_func(srna, "rna_CurvePaintSettings_path");
 +      RNA_def_struct_ui_text(srna, "Curve Paint Settings", "");
  
 -      prop = RNA_def_property(srna, "edge_type_negation", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
 -      RNA_def_property_enum_items(prop, edge_type_negation_items);
 -      RNA_def_property_ui_text(prop, "Edge Type Negation",
 -                               "Specify either inclusion or exclusion of feature edges selected by edge types");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      static EnumPropertyItem curve_type_items[] = {
 +              {CU_POLY, "POLY", 0, "Poly", ""},
 +              {CU_BEZIER, "BEZIER", 0, "Bezier", ""},
 +              {0, NULL, 0, NULL, NULL}};
  
 -      prop = RNA_def_property(srna, "edge_type_combination", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
 -      RNA_def_property_enum_items(prop, edge_type_combination_items);
 -      RNA_def_property_ui_text(prop, "Edge Type Combination",
 -                               "Specify a logical combination of selection conditions on feature edge types");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "curve_type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "curve_type");
 +      RNA_def_property_enum_items(prop, curve_type_items);
 +      RNA_def_property_ui_text(prop, "Type", "Type of curve to use for new strokes");
  
 -      prop = RNA_def_property(srna, "group", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "group");
 -      RNA_def_property_struct_type(prop, "Group");
 -      RNA_def_property_flag(prop, PROP_EDITABLE);
 -      RNA_def_property_ui_text(prop, "Group", "A group of objects based on which feature edges are selected");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "use_corners_detect", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", CURVE_PAINT_FLAG_CORNERS_DETECT);
 +      RNA_def_property_ui_text(prop, "Detect Corners", "Detect corners and use non-aligned handles");
  
 -      prop = RNA_def_property(srna, "group_negation", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
 -      RNA_def_property_enum_items(prop, group_negation_items);
 -      RNA_def_property_ui_text(prop, "Group Negation",
 -                               "Specify either inclusion or exclusion of feature edges belonging to a group of objects");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "use_pressure_radius", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", CURVE_PAINT_FLAG_PRESSURE_RADIUS);
 +      RNA_def_property_ui_icon(prop, ICON_STYLUS_PRESSURE, 0);
 +      RNA_def_property_ui_text(prop, "Use Pressure", "Map tablet pressure to curve radius");
  
 -      prop = RNA_def_property(srna, "face_mark_negation", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
 -      RNA_def_property_enum_items(prop, face_mark_negation_items);
 -      RNA_def_property_ui_text(prop, "Face Mark Negation",
 -                               "Specify either inclusion or exclusion of feature edges selected by face marks");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "use_stroke_endpoints", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", CURVE_PAINT_FLAG_DEPTH_STROKE_ENDPOINTS);
 +      RNA_def_property_ui_text(prop, "Only First", "Use the start of the stroke for the depth");
  
 -      prop = RNA_def_property(srna, "face_mark_condition", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
 -      RNA_def_property_enum_items(prop, face_mark_condition_items);
 -      RNA_def_property_ui_text(prop, "Face Mark Condition",
 -                               "Specify a feature edge selection condition based on face marks");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "use_offset_absolute", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", CURVE_PAINT_FLAG_DEPTH_STROKE_OFFSET_ABS);
 +      RNA_def_property_ui_text(prop, "Absolute Offset", "Apply a fixed offset (don't scale by the radius)");
  
 -      prop = RNA_def_property(srna, "select_silhouette", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_SILHOUETTE);
 -      RNA_def_property_ui_text(prop, "Silhouette",
 -                               "Select silhouettes (edges at the boundary of visible and hidden faces)");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "error_threshold", PROP_INT, PROP_PIXEL);
 +      RNA_def_property_range(prop, 1, 100);
 +      RNA_def_property_ui_text(prop, "Tolerance", "Allow deviation for a smoother, less precise line");
  
 -      prop = RNA_def_property(srna, "select_border", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_BORDER);
 -      RNA_def_property_ui_text(prop, "Border", "Select border edges (open mesh edges)");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "fit_method", PROP_ENUM, PROP_PIXEL);
 +      RNA_def_property_enum_sdna(prop, NULL, "fit_method");
 +      RNA_def_property_enum_items(prop, rna_enum_curve_fit_method_items);
 +      RNA_def_property_ui_text(prop, "Method", "Curve fitting method");
  
 -      prop = RNA_def_property(srna, "select_crease", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_CREASE);
 -      RNA_def_property_ui_text(prop, "Crease",
 -                               "Select crease edges (those between two faces making an angle smaller than the Crease Angle)");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "corner_angle", PROP_FLOAT, PROP_ANGLE);
 +      RNA_def_property_range(prop, 0, M_PI);
 +      RNA_def_property_ui_text(prop, "Corner Angle", "Angles above this are considered corners");
  
 -      prop = RNA_def_property(srna, "select_ridge_valley", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_RIDGE_VALLEY);
 -      RNA_def_property_ui_text(prop, "Ridge & Valley",
 -                               "Select ridges and valleys (boundary lines between convex and concave areas of surface)");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "radius_min", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, 0.0, 100.0);
 +      RNA_def_property_ui_range(prop, 0.0f, 10.0, 10, 2);
 +      RNA_def_property_ui_text(prop, "Radius Min",
 +                               "Minimum radius when the minimum pressure is applied (also the minimum when tapering)");
  
 -      prop = RNA_def_property(srna, "select_suggestive_contour", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_SUGGESTIVE_CONTOUR);
 -      RNA_def_property_ui_text(prop, "Suggestive Contour", "Select suggestive contours (almost silhouette/contour edges)");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "radius_max", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, 0.0, 100.0);
 +      RNA_def_property_ui_range(prop, 0.0f, 10.0, 10, 2);
 +      RNA_def_property_ui_text(prop, "Radius Max",
 +                               "Radius to use when the maximum pressure is applied (or when a tablet isn't used)");
  
 -      prop = RNA_def_property(srna, "select_material_boundary", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_MATERIAL_BOUNDARY);
 -      RNA_def_property_ui_text(prop, "Material Boundary", "Select edges at material boundaries");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "radius_taper_start", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, 0.0, 1.0);
 +      RNA_def_property_ui_range(prop, 0.0f, 1.0, 1, 2);
 +      RNA_def_property_ui_text(prop, "Radius Min", "Taper factor for the radius of each point along the curve");
  
 -      prop = RNA_def_property(srna, "select_contour", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_CONTOUR);
 -      RNA_def_property_ui_text(prop, "Contour", "Select contours (outer silhouettes of each object)");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "radius_taper_end", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, 0.0, 10.0);
 +      RNA_def_property_ui_range(prop, 0.0f, 1.0, 1, 2);
 +      RNA_def_property_ui_text(prop, "Radius Max", "Taper factor for the radius of each point along the curve");
  
 -      prop = RNA_def_property(srna, "select_external_contour", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_EXTERNAL_CONTOUR);
 -      RNA_def_property_ui_text(prop, "External Contour",
 -                               "Select external contours (outer silhouettes of occluding and occluded objects)");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "surface_offset", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, -10.0, 10.0);
 +      RNA_def_property_ui_range(prop, -1.0f, 1.0, 1, 2);
 +      RNA_def_property_ui_text(prop, "Offset", "Offset the stroke from the surface");
  
 -      prop = RNA_def_property(srna, "select_edge_mark", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_EDGE_MARK);
 -      RNA_def_property_ui_text(prop, "Edge Mark", "Select edge marks (edges annotated by Freestyle edge marks)");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      static EnumPropertyItem depth_mode_items[] = {
 +              {CURVE_PAINT_PROJECT_CURSOR,  "CURSOR",  0, "Cursor",  ""},
 +              {CURVE_PAINT_PROJECT_SURFACE, "SURFACE", 0, "Surface", ""},
 +              {0, NULL, 0, NULL, NULL}};
  
 -      prop = RNA_def_property(srna, "exclude_silhouette", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_SILHOUETTE);
 -      RNA_def_property_ui_text(prop, "Silhouette", "Exclude silhouette edges");
 -      RNA_def_property_ui_icon(prop, ICON_X, 0);
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "depth_mode", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "depth_mode");
 +      RNA_def_property_enum_items(prop, depth_mode_items);
 +      RNA_def_property_ui_text(prop, "Depth", "Method of projecting depth");
  
 -      prop = RNA_def_property(srna, "exclude_border", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_BORDER);
 -      RNA_def_property_ui_text(prop, "Border", "Exclude border edges");
 -      RNA_def_property_ui_icon(prop, ICON_X, 0);
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      static EnumPropertyItem surface_plane_items[] = {
 +              {CURVE_PAINT_SURFACE_PLANE_NORMAL_VIEW,  "NORMAL_VIEW", 0, "Normal/View", "Draw perpendicular to the surface"},
 +              {CURVE_PAINT_SURFACE_PLANE_NORMAL_SURFACE, "NORMAL_SURFACE", 0, "Normal/Surface", "Draw aligned to the surface"},
 +              {CURVE_PAINT_SURFACE_PLANE_VIEW, "VIEW", 0, "View", "Draw aligned to the viewport"},
 +              {0, NULL, 0, NULL, NULL}};
  
 -      prop = RNA_def_property(srna, "exclude_crease", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_CREASE);
 -      RNA_def_property_ui_text(prop, "Crease", "Exclude crease edges");
 -      RNA_def_property_ui_icon(prop, ICON_X, 0);
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "surface_plane", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "surface_plane");
 +      RNA_def_property_enum_items(prop, surface_plane_items);
 +      RNA_def_property_ui_text(prop, "Plane", "Plane for projected stroke");
 +}
  
 -      prop = RNA_def_property(srna, "exclude_ridge_valley", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_RIDGE_VALLEY);
 -      RNA_def_property_ui_text(prop, "Ridge & Valley", "Exclude ridges and valleys");
 -      RNA_def_property_ui_icon(prop, ICON_X, 0);
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +static void rna_def_statvis(BlenderRNA  *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
  
 -      prop = RNA_def_property(srna, "exclude_suggestive_contour", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_SUGGESTIVE_CONTOUR);
 -      RNA_def_property_ui_text(prop, "Suggestive Contour", "Exclude suggestive contours");
 -      RNA_def_property_ui_icon(prop, ICON_X, 0);
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      static EnumPropertyItem stat_type[] = {
 +              {SCE_STATVIS_OVERHANG,  "OVERHANG",  0, "Overhang",  ""},
 +              {SCE_STATVIS_THICKNESS, "THICKNESS", 0, "Thickness", ""},
 +              {SCE_STATVIS_INTERSECT, "INTERSECT", 0, "Intersect", ""},
 +              {SCE_STATVIS_DISTORT,   "DISTORT",   0, "Distortion", ""},
 +              {SCE_STATVIS_SHARP, "SHARP", 0, "Sharp", ""},
 +              {0, NULL, 0, NULL, NULL}};
  
 -      prop = RNA_def_property(srna, "exclude_material_boundary", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_MATERIAL_BOUNDARY);
 -      RNA_def_property_ui_text(prop, "Material Boundary", "Exclude edges at material boundaries");
 -      RNA_def_property_ui_icon(prop, ICON_X, 0);
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      srna = RNA_def_struct(brna, "MeshStatVis", NULL);
 +      RNA_def_struct_path_func(srna, "rna_MeshStatVis_path");
 +      RNA_def_struct_ui_text(srna, "Mesh Visualize Statistics", "");
  
 -      prop = RNA_def_property(srna, "exclude_contour", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_CONTOUR);
 -      RNA_def_property_ui_text(prop, "Contour", "Exclude contours");
 -      RNA_def_property_ui_icon(prop, ICON_X, 0);
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_items(prop, stat_type);
 +      RNA_def_property_ui_text(prop, "Type", "Type of data to visualize/check");
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
  
 -      prop = RNA_def_property(srna, "exclude_external_contour", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_EXTERNAL_CONTOUR);
 -      RNA_def_property_ui_text(prop, "External Contour", "Exclude external contours");
 -      RNA_def_property_ui_icon(prop, ICON_X, 0);
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
  
 -      prop = RNA_def_property(srna, "exclude_edge_mark", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_EDGE_MARK);
 -      RNA_def_property_ui_text(prop, "Edge Mark", "Exclude edge marks");
 -      RNA_def_property_ui_icon(prop, ICON_X, 0);
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      /* overhang */
 +      prop = RNA_def_property(srna, "overhang_min", PROP_FLOAT, PROP_ANGLE);
 +      RNA_def_property_float_sdna(prop, NULL, "overhang_min");
 +      RNA_def_property_float_default(prop, 0.5f);
 +      RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
 +      RNA_def_property_ui_range(prop, 0.0f, DEG2RADF(180.0f), 0.001, 3);
 +      RNA_def_property_ui_text(prop, "Overhang Min", "Minimum angle to display");
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
  
 -      prop = RNA_def_property(srna, "visibility", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "qi");
 -      RNA_def_property_enum_items(prop, visibility_items);
 -      RNA_def_property_ui_text(prop, "Visibility", "Determine how to use visibility for feature edge selection");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "overhang_max", PROP_FLOAT, PROP_ANGLE);
 +      RNA_def_property_float_sdna(prop, NULL, "overhang_max");
 +      RNA_def_property_float_default(prop, 0.5f);
 +      RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
 +      RNA_def_property_ui_range(prop, 0.0f, DEG2RADF(180.0f), 10, 3);
 +      RNA_def_property_ui_text(prop, "Overhang Max", "Maximum angle to display");
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
  
 -      prop = RNA_def_property(srna, "qi_start", PROP_INT, PROP_UNSIGNED);
 -      RNA_def_property_int_sdna(prop, NULL, "qi_start");
 -      RNA_def_property_range(prop, 0, INT_MAX);
 -      RNA_def_property_ui_text(prop, "Start", "First QI value of the QI range");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "overhang_axis", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "overhang_axis");
 +      RNA_def_property_enum_items(prop, rna_enum_object_axis_items);
 +      RNA_def_property_ui_text(prop, "Axis", "");
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
  
 -      prop = RNA_def_property(srna, "qi_end", PROP_INT, PROP_UNSIGNED);
 -      RNA_def_property_int_sdna(prop, NULL, "qi_end");
 -      RNA_def_property_range(prop, 0, INT_MAX);
 -      RNA_def_property_ui_text(prop, "End", "Last QI value of the QI range");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
  
 -      /* FreestyleModuleSettings */
 +      /* thickness */
 +      prop = RNA_def_property(srna, "thickness_min", PROP_FLOAT, PROP_DISTANCE);
 +      RNA_def_property_float_sdna(prop, NULL, "thickness_min");
 +      RNA_def_property_float_default(prop, 0.5f);
 +      RNA_def_property_range(prop, 0.0f, 1000.0);
 +      RNA_def_property_ui_range(prop, 0.0f, 100.0, 0.001, 3);
 +      RNA_def_property_ui_text(prop, "Thickness Min", "Minimum for measuring thickness");
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
  
 -      srna = RNA_def_struct(brna, "FreestyleModuleSettings", NULL);
 -      RNA_def_struct_sdna(srna, "FreestyleModuleConfig");
 -      RNA_def_struct_ui_text(srna, "Freestyle Module", "Style module configuration for specifying a style module");
 +      prop = RNA_def_property(srna, "thickness_max", PROP_FLOAT, PROP_DISTANCE);
 +      RNA_def_property_float_sdna(prop, NULL, "thickness_max");
 +      RNA_def_property_float_default(prop, 0.5f);
 +      RNA_def_property_range(prop, 0.0f, 1000.0);
 +      RNA_def_property_ui_range(prop, 0.0f, 100.0, 0.001, 3);
 +      RNA_def_property_ui_text(prop, "Thickness Max", "Maximum for measuring thickness");
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
  
 -      prop = RNA_def_property(srna, "script", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_struct_type(prop, "Text");
 -      RNA_def_property_flag(prop, PROP_EDITABLE);
 -      RNA_def_property_ui_text(prop, "Style Module", "Python script to define a style module");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "thickness_samples", PROP_INT, PROP_UNSIGNED);
 +      RNA_def_property_int_sdna(prop, NULL, "thickness_samples");
 +      RNA_def_property_range(prop, 1, 32);
 +      RNA_def_property_ui_text(prop, "Samples", "Number of samples to test per face");
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
  
 -      prop = RNA_def_property(srna, "use", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "is_displayed", 1);
 -      RNA_def_property_ui_text(prop, "Use", "Enable or disable this style module during stroke rendering");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      /* distort */
 +      prop = RNA_def_property(srna, "distort_min", PROP_FLOAT, PROP_ANGLE);
 +      RNA_def_property_float_sdna(prop, NULL, "distort_min");
 +      RNA_def_property_float_default(prop, 0.5f);
 +      RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
 +      RNA_def_property_ui_range(prop, 0.0f, DEG2RADF(180.0f), 10, 3);
 +      RNA_def_property_ui_text(prop, "Distort Min", "Minimum angle to display");
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
  
 -      /* FreestyleSettings */
 +      prop = RNA_def_property(srna, "distort_max", PROP_FLOAT, PROP_ANGLE);
 +      RNA_def_property_float_sdna(prop, NULL, "distort_max");
 +      RNA_def_property_float_default(prop, 0.5f);
 +      RNA_def_property_range(prop, 0.0f, DEG2RADF(180.0f));
 +      RNA_def_property_ui_range(prop, 0.0f, DEG2RADF(180.0f), 10, 3);
 +      RNA_def_property_ui_text(prop, "Distort Max", "Maximum angle to display");
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
  
 -      srna = RNA_def_struct(brna, "FreestyleSettings", NULL);
 -      RNA_def_struct_sdna(srna, "FreestyleConfig");
 -      RNA_def_struct_nested(brna, srna, "SceneRenderLayer");
 -      RNA_def_struct_ui_text(srna, "Freestyle Settings", "Freestyle settings for a SceneRenderLayer data-block");
 +      /* sharp */
 +      prop = RNA_def_property(srna, "sharp_min", PROP_FLOAT, PROP_ANGLE);
 +      RNA_def_property_float_sdna(prop, NULL, "sharp_min");
 +      RNA_def_property_float_default(prop, 0.5f);
 +      RNA_def_property_range(prop, -DEG2RADF(180.0f), DEG2RADF(180.0f));
 +      RNA_def_property_ui_range(prop, -DEG2RADF(180.0f), DEG2RADF(180.0f), 10, 3);
 +      RNA_def_property_ui_text(prop, "Distort Min", "Minimum angle to display");
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
  
 -      prop = RNA_def_property(srna, "modules", PROP_COLLECTION, PROP_NONE);
 -      RNA_def_property_collection_sdna(prop, NULL, "modules", NULL);
 -      RNA_def_property_struct_type(prop, "FreestyleModuleSettings");
 -      RNA_def_property_ui_text(prop, "Style Modules", "A list of style modules (to be applied from top to bottom)");
 -      rna_def_freestyle_modules(brna, prop);
 +      prop = RNA_def_property(srna, "sharp_max", PROP_FLOAT, PROP_ANGLE);
 +      RNA_def_property_float_sdna(prop, NULL, "sharp_max");
 +      RNA_def_property_float_default(prop, 0.5f);
 +      RNA_def_property_range(prop, -DEG2RADF(180.0f), DEG2RADF(180.0f));
 +      RNA_def_property_ui_range(prop, -DEG2RADF(180.0f), DEG2RADF(180.0f), 10, 3);
 +      RNA_def_property_ui_text(prop, "Distort Max", "Maximum angle to display");
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +}
  
 -      prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "mode");
 -      RNA_def_property_enum_items(prop, freestyle_ui_mode_items);
 -      RNA_def_property_ui_text(prop, "Control Mode", "Select the Freestyle control mode");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +static void rna_def_unit_settings(BlenderRNA  *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
  
 -      prop = RNA_def_property(srna, "use_culling", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_CULLING);
 -      RNA_def_property_ui_text(prop, "Culling", "If enabled, out-of-view edges are ignored");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      static EnumPropertyItem unit_systems[] = {
 +              {USER_UNIT_NONE, "NONE", 0, "None", ""},
 +              {USER_UNIT_METRIC, "METRIC", 0, "Metric", ""},
 +              {USER_UNIT_IMPERIAL, "IMPERIAL", 0, "Imperial", ""},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +      
 +      static EnumPropertyItem rotation_units[] = {
 +              {0, "DEGREES", 0, "Degrees", "Use degrees for measuring angles and rotations"},
 +              {USER_UNIT_ROT_RADIANS, "RADIANS", 0, "Radians", ""},
 +              {0, NULL, 0, NULL, NULL}
 +      };
  
 -      prop = RNA_def_property(srna, "use_suggestive_contours", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_SUGGESTIVE_CONTOURS_FLAG);
 -      RNA_def_property_ui_text(prop, "Suggestive Contours", "Enable suggestive contours");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      srna = RNA_def_struct(brna, "UnitSettings", NULL);
 +      RNA_def_struct_ui_text(srna, "Unit Settings", "");
  
 -      prop = RNA_def_property(srna, "use_ridges_and_valleys", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_RIDGES_AND_VALLEYS_FLAG);
 -      RNA_def_property_ui_text(prop, "Ridges and Valleys", "Enable ridges and valleys");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      /* Units */
 +      prop = RNA_def_property(srna, "system", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_items(prop, unit_systems);
 +      RNA_def_property_ui_text(prop, "Unit System", "The unit system to use for button display");
 +      RNA_def_property_update(prop, NC_WINDOW, NULL);
 +      
 +      prop = RNA_def_property(srna, "system_rotation", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_items(prop, rotation_units);
 +      RNA_def_property_ui_text(prop, "Rotation Units", "Unit to use for displaying/editing rotation values");
 +      RNA_def_property_update(prop, NC_WINDOW, NULL);
  
 -      prop = RNA_def_property(srna, "use_material_boundaries", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_MATERIAL_BOUNDARIES_FLAG);
 +      prop = RNA_def_property(srna, "scale_length", PROP_FLOAT, PROP_UNSIGNED);
 +      RNA_def_property_ui_text(prop, "Unit Scale", "Scale to use when converting between blender units and dimensions");
 +      RNA_def_property_range(prop, 0.00001, 100000.0);
 +      RNA_def_property_ui_range(prop, 0.001, 100.0, 0.1, 6);
 +      RNA_def_property_update(prop, NC_WINDOW, NULL);
 +
 +      prop = RNA_def_property(srna, "use_separate", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", USER_UNIT_OPT_SPLIT);
 +      RNA_def_property_ui_text(prop, "Separate Units", "Display units in pairs (e.g. 1m 0cm)");
 +      RNA_def_property_update(prop, NC_WINDOW, NULL);
 +}
 +
 +void rna_def_render_layer_common(StructRNA *srna, int scene)
 +{
 +      PropertyRNA *prop;
 +
 +      prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
 +      if (scene) RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SceneRenderLayer_name_set");
 +      else RNA_def_property_string_sdna(prop, NULL, "name");
 +      RNA_def_property_ui_text(prop, "Name", "Render layer name");
 +      RNA_def_struct_name_property(srna, prop);
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "material_override", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "mat_override");
 +      RNA_def_property_struct_type(prop, "Material");
 +      RNA_def_property_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_ui_text(prop, "Material Override",
 +                               "Material to override all other materials in this render layer");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "light_override", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "light_override");
 +      RNA_def_property_struct_type(prop, "Group");
 +      RNA_def_property_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_ui_text(prop, "Light Override", "Group to override all other lights in this render layer");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      /* layers */
 +      prop = RNA_def_property(srna, "layers", PROP_BOOLEAN, PROP_LAYER_MEMBER);
 +      RNA_def_property_boolean_sdna(prop, NULL, "lay", 1);
 +      RNA_def_property_array(prop, 20);
 +      RNA_def_property_ui_text(prop, "Visible Layers", "Scene layers included in this render layer");
 +      if (scene) RNA_def_property_boolean_funcs(prop, NULL, "rna_SceneRenderLayer_layer_set");
 +      else RNA_def_property_boolean_funcs(prop, NULL, "rna_RenderLayer_layer_set");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      /* this seems to be too much trouble with depsgraph updates/etc. currently (20140423) */
 +      RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 +
 +      prop = RNA_def_property(srna, "layers_zmask", PROP_BOOLEAN, PROP_LAYER);
 +      RNA_def_property_boolean_sdna(prop, NULL, "lay_zmask", 1);
 +      RNA_def_property_array(prop, 20);
 +      RNA_def_property_ui_text(prop, "Zmask Layers", "Zmask scene layers for solid faces");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "layers_exclude", PROP_BOOLEAN, PROP_LAYER);
 +      RNA_def_property_boolean_sdna(prop, NULL, "lay_exclude", 1);
 +      RNA_def_property_array(prop, 20);
 +      RNA_def_property_ui_text(prop, "Exclude Layers", "Exclude scene layers from having any influence");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      if (scene) {
 +              prop = RNA_def_property(srna, "samples", PROP_INT, PROP_UNSIGNED);
 +              RNA_def_property_ui_text(prop, "Samples", "Override number of render samples for this render layer, "
 +                                                        "0 will use the scene setting");
 +              RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +              prop = RNA_def_property(srna, "pass_alpha_threshold", PROP_FLOAT, PROP_FACTOR);
 +              RNA_def_property_ui_text(prop, "Alpha Threshold",
 +                                       "Z, Index, normal, UV and vector passes are only affected by surfaces with "
 +                                       "alpha transparency equal to or higher than this threshold");
 +              RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      }
 +
 +      /* layer options */
 +      prop = RNA_def_property(srna, "use", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "layflag", SCE_LAY_DISABLE);
 +      RNA_def_property_ui_text(prop, "Enabled", "Disable or enable the render layer");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_zmask", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_ZMASK);
 +      RNA_def_property_ui_text(prop, "Zmask", "Only render what's in front of the solid z values");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "invert_zmask", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_NEG_ZMASK);
 +      RNA_def_property_ui_text(prop, "Zmask Negate",
 +                               "For Zmask, only render what is behind solid z values instead of in front");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_all_z", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_ALL_Z);
 +      RNA_def_property_ui_text(prop, "All Z", "Fill in Z values for solid faces in invisible layers, for masking");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_solid", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_SOLID);
 +      RNA_def_property_ui_text(prop, "Solid", "Render Solid faces in this Layer");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_halo", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_HALO);
 +      RNA_def_property_ui_text(prop, "Halo", "Render Halos in this Layer (on top of Solid)");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_ztransp", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_ZTRA);
 +      RNA_def_property_ui_text(prop, "ZTransp", "Render Z-Transparent faces in this Layer (on top of Solid and Halos)");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_sky", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_SKY);
 +      RNA_def_property_ui_text(prop, "Sky", "Render Sky in this Layer");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_ao", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_AO);
 +      RNA_def_property_ui_text(prop, "AO", "Render AO in this Layer");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_glsl_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_edge_enhance", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_EDGE);
 +      RNA_def_property_ui_text(prop, "Edge", "Render Edge-enhance in this Layer (only works for Solid faces)");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_strand", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_STRAND);
 +      RNA_def_property_ui_text(prop, "Strand", "Render Strands in this Layer");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_freestyle", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "layflag", SCE_LAY_FRS);
 +      RNA_def_property_ui_text(prop, "Freestyle", "Render stylized strokes in this Layer");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      /* passes */
 +      prop = RNA_def_property(srna, "use_pass_combined", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_COMBINED);
 +      RNA_def_property_ui_text(prop, "Combined", "Deliver full combined RGBA buffer");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_z", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_Z);
 +      RNA_def_property_ui_text(prop, "Z", "Deliver Z values pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      
 +      prop = RNA_def_property(srna, "use_pass_vector", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_VECTOR);
 +      RNA_def_property_ui_text(prop, "Vector", "Deliver speed vector pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_normal", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_NORMAL);
 +      RNA_def_property_ui_text(prop, "Normal", "Deliver normal pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_uv", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_UV);
 +      RNA_def_property_ui_text(prop, "UV", "Deliver texture UV pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_mist", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_MIST);
 +      RNA_def_property_ui_text(prop, "Mist", "Deliver mist factor pass (0.0-1.0)");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_object_index", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_INDEXOB);
 +      RNA_def_property_ui_text(prop, "Object Index", "Deliver object index pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_material_index", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_INDEXMA);
 +      RNA_def_property_ui_text(prop, "Material Index", "Deliver material index pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_color", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_RGBA);
 +      RNA_def_property_ui_text(prop, "Color", "Deliver shade-less color pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_diffuse", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_DIFFUSE);
 +      RNA_def_property_ui_text(prop, "Diffuse", "Deliver diffuse pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_specular", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SPEC);
 +      RNA_def_property_ui_text(prop, "Specular", "Deliver specular pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_shadow", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SHADOW);
 +      RNA_def_property_ui_text(prop, "Shadow", "Deliver shadow pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_ambient_occlusion", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_AO);
 +      RNA_def_property_ui_text(prop, "AO", "Deliver AO pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      
 +      prop = RNA_def_property(srna, "use_pass_reflection", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_REFLECT);
 +      RNA_def_property_ui_text(prop, "Reflection", "Deliver raytraced reflection pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_refraction", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_REFRACT);
 +      RNA_def_property_ui_text(prop, "Refraction", "Deliver raytraced refraction pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_emit", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_EMIT);
 +      RNA_def_property_ui_text(prop, "Emit", "Deliver emission pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_environment", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_ENVIRONMENT);
 +      RNA_def_property_ui_text(prop, "Environment", "Deliver environment lighting pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_indirect", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_INDIRECT);
 +      RNA_def_property_ui_text(prop, "Indirect", "Deliver indirect lighting pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "exclude_specular", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_SPEC);
 +      RNA_def_property_ui_text(prop, "Specular Exclude", "Exclude specular pass from combined");
 +      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "exclude_shadow", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_SHADOW);
 +      RNA_def_property_ui_text(prop, "Shadow Exclude", "Exclude shadow pass from combined");
 +      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "exclude_ambient_occlusion", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_AO);
 +      RNA_def_property_ui_text(prop, "AO Exclude", "Exclude AO pass from combined");
 +      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      
 +      prop = RNA_def_property(srna, "exclude_reflection", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_REFLECT);
 +      RNA_def_property_ui_text(prop, "Reflection Exclude", "Exclude raytraced reflection pass from combined");
 +      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "exclude_refraction", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_REFRACT);
 +      RNA_def_property_ui_text(prop, "Refraction Exclude", "Exclude raytraced refraction pass from combined");
 +      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "exclude_emit", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_EMIT);
 +      RNA_def_property_ui_text(prop, "Emit Exclude", "Exclude emission pass from combined");
 +      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "exclude_environment", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_ENVIRONMENT);
 +      RNA_def_property_ui_text(prop, "Environment Exclude", "Exclude environment pass from combined");
 +      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "exclude_indirect", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_xor", SCE_PASS_INDIRECT);
 +      RNA_def_property_ui_text(prop, "Indirect Exclude", "Exclude indirect pass from combined");
 +      RNA_def_property_ui_icon(prop, ICON_RESTRICT_RENDER_OFF, 1);
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_diffuse_direct", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_DIFFUSE_DIRECT);
 +      RNA_def_property_ui_text(prop, "Diffuse Direct", "Deliver diffuse direct pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_diffuse_indirect", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_DIFFUSE_INDIRECT);
 +      RNA_def_property_ui_text(prop, "Diffuse Indirect", "Deliver diffuse indirect pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_diffuse_color", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_DIFFUSE_COLOR);
 +      RNA_def_property_ui_text(prop, "Diffuse Color", "Deliver diffuse color pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_glossy_direct", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_GLOSSY_DIRECT);
 +      RNA_def_property_ui_text(prop, "Glossy Direct", "Deliver glossy direct pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_glossy_indirect", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_GLOSSY_INDIRECT);
 +      RNA_def_property_ui_text(prop, "Glossy Indirect", "Deliver glossy indirect pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_glossy_color", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_GLOSSY_COLOR);
 +      RNA_def_property_ui_text(prop, "Glossy Color", "Deliver glossy color pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_transmission_direct", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_TRANSM_DIRECT);
 +      RNA_def_property_ui_text(prop, "Transmission Direct", "Deliver transmission direct pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_transmission_indirect", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_TRANSM_INDIRECT);
 +      RNA_def_property_ui_text(prop, "Transmission Indirect", "Deliver transmission indirect pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_transmission_color", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_TRANSM_COLOR);
 +      RNA_def_property_ui_text(prop, "Transmission Color", "Deliver transmission color pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      
 +      prop = RNA_def_property(srna, "use_pass_subsurface_direct", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SUBSURFACE_DIRECT);
 +      RNA_def_property_ui_text(prop, "Subsurface Direct", "Deliver subsurface direct pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_subsurface_indirect", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SUBSURFACE_INDIRECT);
 +      RNA_def_property_ui_text(prop, "Subsurface Indirect", "Deliver subsurface indirect pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      prop = RNA_def_property(srna, "use_pass_subsurface_color", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "passflag", SCE_PASS_SUBSURFACE_COLOR);
 +      RNA_def_property_ui_text(prop, "Subsurface Color", "Deliver subsurface color pass");
 +      if (scene) RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_SceneRenderLayer_pass_update");
 +      else RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +}
 +
 +static void rna_def_freestyle_modules(BlenderRNA *brna, PropertyRNA *cprop)
 +{
 +      StructRNA *srna;
 +      FunctionRNA *func;
 +      PropertyRNA *parm;
 +
 +      RNA_def_property_srna(cprop, "FreestyleModules");
 +      srna = RNA_def_struct(brna, "FreestyleModules", NULL);
 +      RNA_def_struct_sdna(srna, "FreestyleSettings");
 +      RNA_def_struct_ui_text(srna, "Style Modules", "A list of style modules (to be applied from top to bottom)");
 +
 +      func = RNA_def_function(srna, "new", "rna_FreestyleSettings_module_add");
 +      RNA_def_function_ui_description(func, "Add a style module to scene render layer Freestyle settings");
 +      RNA_def_function_flag(func, FUNC_USE_SELF_ID);
 +      parm = RNA_def_pointer(func, "module", "FreestyleModuleSettings", "", "Newly created style module");
 +      RNA_def_function_return(func, parm);
 +
 +      func = RNA_def_function(srna, "remove", "rna_FreestyleSettings_module_remove");
 +      RNA_def_function_ui_description(func, "Remove a style module from scene render layer Freestyle settings");
 +      RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_REPORTS);
 +      parm = RNA_def_pointer(func, "module", "FreestyleModuleSettings", "", "Style module to remove");
 +      RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
 +      RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
 +}
 +
 +static void rna_def_freestyle_linesets(BlenderRNA *brna, PropertyRNA *cprop)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +      FunctionRNA *func;
 +      PropertyRNA *parm;
 +
 +      RNA_def_property_srna(cprop, "Linesets");
 +      srna = RNA_def_struct(brna, "Linesets", NULL);
 +      RNA_def_struct_sdna(srna, "FreestyleSettings");
 +      RNA_def_struct_ui_text(srna, "Line Sets", "Line sets for associating lines and style parameters");
 +
 +      prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_struct_type(prop, "FreestyleLineSet");
 +      RNA_def_property_pointer_funcs(prop, "rna_FreestyleSettings_active_lineset_get", NULL, NULL, NULL);
 +      RNA_def_property_ui_text(prop, "Active Line Set", "Active line set being displayed");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
 +      RNA_def_property_int_funcs(prop, "rna_FreestyleSettings_active_lineset_index_get",
 +                                 "rna_FreestyleSettings_active_lineset_index_set",
 +                                 "rna_FreestyleSettings_active_lineset_index_range");
 +      RNA_def_property_ui_text(prop, "Active Line Set Index", "Index of active line set slot");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      func = RNA_def_function(srna, "new", "rna_FreestyleSettings_lineset_add");
 +      RNA_def_function_ui_description(func, "Add a line set to scene render layer Freestyle settings");
 +      RNA_def_function_flag(func, FUNC_USE_MAIN | FUNC_USE_SELF_ID);
 +      parm = RNA_def_string(func, "name", "LineSet", 0, "", "New name for the line set (not unique)");
 +      RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
 +      parm = RNA_def_pointer(func, "lineset", "FreestyleLineSet", "", "Newly created line set");
 +      RNA_def_function_return(func, parm);
 +
 +      func = RNA_def_function(srna, "remove", "rna_FreestyleSettings_lineset_remove");
 +      RNA_def_function_ui_description(func, "Remove a line set from scene render layer Freestyle settings");
 +      RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_REPORTS);
 +      parm = RNA_def_pointer(func, "lineset", "FreestyleLineSet", "", "Line set to remove");
 +      RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
 +      RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
 +}
 +
 +static void rna_def_freestyle_settings(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem edge_type_negation_items[] = {
 +              {0, "INCLUSIVE", 0, "Inclusive", "Select feature edges satisfying the given edge type conditions"},
 +              {FREESTYLE_LINESET_FE_NOT, "EXCLUSIVE", 0, "Exclusive",
 +                                         "Select feature edges not satisfying the given edge type conditions"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      static EnumPropertyItem edge_type_combination_items[] = {
 +              {0, "OR", 0, "Logical OR", "Select feature edges satisfying at least one of edge type conditions"},
 +              {FREESTYLE_LINESET_FE_AND, "AND", 0, "Logical AND",
 +                                         "Select feature edges satisfying all edge type conditions"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      static EnumPropertyItem group_negation_items[] = {
 +              {0, "INCLUSIVE", 0, "Inclusive", "Select feature edges belonging to some object in the group"},
 +              {FREESTYLE_LINESET_GR_NOT, "EXCLUSIVE", 0, "Exclusive",
 +                                         "Select feature edges not belonging to any object in the group"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      static EnumPropertyItem face_mark_negation_items[] = {
 +              {0, "INCLUSIVE", 0, "Inclusive", "Select feature edges satisfying the given face mark conditions"},
 +              {FREESTYLE_LINESET_FM_NOT, "EXCLUSIVE", 0, "Exclusive",
 +                                         "Select feature edges not satisfying the given face mark conditions"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      static EnumPropertyItem face_mark_condition_items[] = {
 +              {0, "ONE", 0, "One Face", "Select a feature edge if either of its adjacent faces is marked"},
 +              {FREESTYLE_LINESET_FM_BOTH, "BOTH", 0, "Both Faces",
 +                                          "Select a feature edge if both of its adjacent faces are marked"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      static EnumPropertyItem freestyle_ui_mode_items[] = {
 +              {FREESTYLE_CONTROL_SCRIPT_MODE, "SCRIPT", 0, "Python Scripting Mode",
 +                                              "Advanced mode for using style modules written in Python"},
 +              {FREESTYLE_CONTROL_EDITOR_MODE, "EDITOR", 0, "Parameter Editor Mode",
 +                                              "Basic mode for interactive style parameter editing"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      static EnumPropertyItem visibility_items[] = {
 +              {FREESTYLE_QI_VISIBLE, "VISIBLE", 0, "Visible", "Select visible feature edges"},
 +              {FREESTYLE_QI_HIDDEN, "HIDDEN", 0, "Hidden", "Select hidden feature edges"},
 +              {FREESTYLE_QI_RANGE, "RANGE", 0, "QI Range",
 +                                   "Select feature edges within a range of quantitative invisibility (QI) values"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      /* FreestyleLineSet */
 +
 +      srna = RNA_def_struct(brna, "FreestyleLineSet", NULL);
 +      RNA_def_struct_ui_text(srna, "Freestyle Line Set", "Line set for associating lines and style parameters");
 +
 +      /* access to line style settings is redirected through functions
 +       * to allow proper id-buttons functionality
 +       */
 +      prop = RNA_def_property(srna, "linestyle", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_struct_type(prop, "FreestyleLineStyle");
 +      RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
 +      RNA_def_property_pointer_funcs(prop, "rna_FreestyleLineSet_linestyle_get",
 +                                     "rna_FreestyleLineSet_linestyle_set", NULL, NULL);
 +      RNA_def_property_ui_text(prop, "Line Style", "Line style settings");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
 +      RNA_def_property_string_sdna(prop, NULL, "name");
 +      RNA_def_property_ui_text(prop, "Line Set Name", "Line set name");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      RNA_def_struct_name_property(srna, prop);
 +
 +      prop = RNA_def_property(srna, "show_render", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_LINESET_ENABLED);
 +      RNA_def_property_ui_text(prop, "Render", "Enable or disable this line set during stroke rendering");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "select_by_visibility", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "selection", FREESTYLE_SEL_VISIBILITY);
 +      RNA_def_property_ui_text(prop, "Selection by Visibility", "Select feature edges based on visibility");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "select_by_edge_types", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "selection", FREESTYLE_SEL_EDGE_TYPES);
 +      RNA_def_property_ui_text(prop, "Selection by Edge Types", "Select feature edges based on edge types");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "select_by_group", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "selection", FREESTYLE_SEL_GROUP);
 +      RNA_def_property_ui_text(prop, "Selection by Group", "Select feature edges based on a group of objects");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "select_by_image_border", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "selection", FREESTYLE_SEL_IMAGE_BORDER);
 +      RNA_def_property_ui_text(prop, "Selection by Image Border",
 +                               "Select feature edges by image border (less memory consumption)");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "select_by_face_marks", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "selection", FREESTYLE_SEL_FACE_MARK);
 +      RNA_def_property_ui_text(prop, "Selection by Face Marks", "Select feature edges by face marks");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "edge_type_negation", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
 +      RNA_def_property_enum_items(prop, edge_type_negation_items);
 +      RNA_def_property_ui_text(prop, "Edge Type Negation",
 +                               "Specify either inclusion or exclusion of feature edges selected by edge types");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "edge_type_combination", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
 +      RNA_def_property_enum_items(prop, edge_type_combination_items);
 +      RNA_def_property_ui_text(prop, "Edge Type Combination",
 +                               "Specify a logical combination of selection conditions on feature edge types");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "group", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "group");
 +      RNA_def_property_struct_type(prop, "Group");
 +      RNA_def_property_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_ui_text(prop, "Group", "A group of objects based on which feature edges are selected");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "group_negation", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
 +      RNA_def_property_enum_items(prop, group_negation_items);
 +      RNA_def_property_ui_text(prop, "Group Negation",
 +                               "Specify either inclusion or exclusion of feature edges belonging to a group of objects");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "face_mark_negation", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
 +      RNA_def_property_enum_items(prop, face_mark_negation_items);
 +      RNA_def_property_ui_text(prop, "Face Mark Negation",
 +                               "Specify either inclusion or exclusion of feature edges selected by face marks");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "face_mark_condition", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "flags");
 +      RNA_def_property_enum_items(prop, face_mark_condition_items);
 +      RNA_def_property_ui_text(prop, "Face Mark Condition",
 +                               "Specify a feature edge selection condition based on face marks");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "select_silhouette", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_SILHOUETTE);
 +      RNA_def_property_ui_text(prop, "Silhouette",
 +                               "Select silhouettes (edges at the boundary of visible and hidden faces)");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "select_border", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_BORDER);
 +      RNA_def_property_ui_text(prop, "Border", "Select border edges (open mesh edges)");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "select_crease", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_CREASE);
 +      RNA_def_property_ui_text(prop, "Crease",
 +                               "Select crease edges (those between two faces making an angle smaller than the Crease Angle)");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "select_ridge_valley", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_RIDGE_VALLEY);
 +      RNA_def_property_ui_text(prop, "Ridge & Valley",
 +                               "Select ridges and valleys (boundary lines between convex and concave areas of surface)");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "select_suggestive_contour", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_SUGGESTIVE_CONTOUR);
 +      RNA_def_property_ui_text(prop, "Suggestive Contour", "Select suggestive contours (almost silhouette/contour edges)");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "select_material_boundary", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_MATERIAL_BOUNDARY);
 +      RNA_def_property_ui_text(prop, "Material Boundary", "Select edges at material boundaries");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "select_contour", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_CONTOUR);
 +      RNA_def_property_ui_text(prop, "Contour", "Select contours (outer silhouettes of each object)");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "select_external_contour", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_EXTERNAL_CONTOUR);
 +      RNA_def_property_ui_text(prop, "External Contour",
 +                               "Select external contours (outer silhouettes of occluding and occluded objects)");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "select_edge_mark", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "edge_types", FREESTYLE_FE_EDGE_MARK);
 +      RNA_def_property_ui_text(prop, "Edge Mark", "Select edge marks (edges annotated by Freestyle edge marks)");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "exclude_silhouette", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_SILHOUETTE);
 +      RNA_def_property_ui_text(prop, "Silhouette", "Exclude silhouette edges");
 +      RNA_def_property_ui_icon(prop, ICON_X, 0);
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "exclude_border", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_BORDER);
 +      RNA_def_property_ui_text(prop, "Border", "Exclude border edges");
 +      RNA_def_property_ui_icon(prop, ICON_X, 0);
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "exclude_crease", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_CREASE);
 +      RNA_def_property_ui_text(prop, "Crease", "Exclude crease edges");
 +      RNA_def_property_ui_icon(prop, ICON_X, 0);
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "exclude_ridge_valley", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_RIDGE_VALLEY);
 +      RNA_def_property_ui_text(prop, "Ridge & Valley", "Exclude ridges and valleys");
 +      RNA_def_property_ui_icon(prop, ICON_X, 0);
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "exclude_suggestive_contour", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_SUGGESTIVE_CONTOUR);
 +      RNA_def_property_ui_text(prop, "Suggestive Contour", "Exclude suggestive contours");
 +      RNA_def_property_ui_icon(prop, ICON_X, 0);
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "exclude_material_boundary", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_MATERIAL_BOUNDARY);
 +      RNA_def_property_ui_text(prop, "Material Boundary", "Exclude edges at material boundaries");
 +      RNA_def_property_ui_icon(prop, ICON_X, 0);
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "exclude_contour", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_CONTOUR);
 +      RNA_def_property_ui_text(prop, "Contour", "Exclude contours");
 +      RNA_def_property_ui_icon(prop, ICON_X, 0);
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "exclude_external_contour", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_EXTERNAL_CONTOUR);
 +      RNA_def_property_ui_text(prop, "External Contour", "Exclude external contours");
 +      RNA_def_property_ui_icon(prop, ICON_X, 0);
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "exclude_edge_mark", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "exclude_edge_types", FREESTYLE_FE_EDGE_MARK);
 +      RNA_def_property_ui_text(prop, "Edge Mark", "Exclude edge marks");
 +      RNA_def_property_ui_icon(prop, ICON_X, 0);
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "visibility", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "qi");
 +      RNA_def_property_enum_items(prop, visibility_items);
 +      RNA_def_property_ui_text(prop, "Visibility", "Determine how to use visibility for feature edge selection");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "qi_start", PROP_INT, PROP_UNSIGNED);
 +      RNA_def_property_int_sdna(prop, NULL, "qi_start");
 +      RNA_def_property_range(prop, 0, INT_MAX);
 +      RNA_def_property_ui_text(prop, "Start", "First QI value of the QI range");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "qi_end", PROP_INT, PROP_UNSIGNED);
 +      RNA_def_property_int_sdna(prop, NULL, "qi_end");
 +      RNA_def_property_range(prop, 0, INT_MAX);
 +      RNA_def_property_ui_text(prop, "End", "Last QI value of the QI range");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      /* FreestyleModuleSettings */
 +
 +      srna = RNA_def_struct(brna, "FreestyleModuleSettings", NULL);
 +      RNA_def_struct_sdna(srna, "FreestyleModuleConfig");
 +      RNA_def_struct_ui_text(srna, "Freestyle Module", "Style module configuration for specifying a style module");
 +
 +      prop = RNA_def_property(srna, "script", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_struct_type(prop, "Text");
 +      RNA_def_property_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_ui_text(prop, "Style Module", "Python script to define a style module");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "use", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "is_displayed", 1);
 +      RNA_def_property_ui_text(prop, "Use", "Enable or disable this style module during stroke rendering");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      /* FreestyleSettings */
 +
 +      srna = RNA_def_struct(brna, "FreestyleSettings", NULL);
 +      RNA_def_struct_sdna(srna, "FreestyleConfig");
 +      RNA_def_struct_nested(brna, srna, "SceneRenderLayer");
 +      RNA_def_struct_ui_text(srna, "Freestyle Settings", "Freestyle settings for a SceneRenderLayer data-block");
 +
 +      prop = RNA_def_property(srna, "modules", PROP_COLLECTION, PROP_NONE);
 +      RNA_def_property_collection_sdna(prop, NULL, "modules", NULL);
 +      RNA_def_property_struct_type(prop, "FreestyleModuleSettings");
 +      RNA_def_property_ui_text(prop, "Style Modules", "A list of style modules (to be applied from top to bottom)");
 +      rna_def_freestyle_modules(brna, prop);
 +
 +      prop = RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "mode");
 +      RNA_def_property_enum_items(prop, freestyle_ui_mode_items);
 +      RNA_def_property_ui_text(prop, "Control Mode", "Select the Freestyle control mode");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "use_culling", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_CULLING);
 +      RNA_def_property_ui_text(prop, "Culling", "If enabled, out-of-view edges are ignored");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "use_suggestive_contours", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_SUGGESTIVE_CONTOURS_FLAG);
 +      RNA_def_property_ui_text(prop, "Suggestive Contours", "Enable suggestive contours");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "use_ridges_and_valleys", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_RIDGES_AND_VALLEYS_FLAG);
 +      RNA_def_property_ui_text(prop, "Ridges and Valleys", "Enable ridges and valleys");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "use_material_boundaries", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_MATERIAL_BOUNDARIES_FLAG);
        RNA_def_property_ui_text(prop, "Material Boundaries", "Enable material boundaries");
        RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
  
 -      prop = RNA_def_property(srna, "use_smoothness", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_FACE_SMOOTHNESS_FLAG);
 -      RNA_def_property_ui_text(prop, "Face Smoothness", "Take face smoothness into account in view map calculation");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "use_smoothness", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_FACE_SMOOTHNESS_FLAG);
 +      RNA_def_property_ui_text(prop, "Face Smoothness", "Take face smoothness into account in view map calculation");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "use_advanced_options", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_ADVANCED_OPTIONS_FLAG);
 +      RNA_def_property_ui_text(prop, "Advanced Options",
 +                               "Enable advanced edge detection options (sphere radius and Kr derivative epsilon)");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "use_view_map_cache", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_VIEW_MAP_CACHE);
 +      RNA_def_property_ui_text(prop, "View Map Cache",
 +                               "Keep the computed view map and avoid re-calculating it if mesh geometry is unchanged");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_use_view_map_cache_update");
 +
 +      prop = RNA_def_property(srna, "sphere_radius", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "sphere_radius");
 +      RNA_def_property_range(prop, 0.0, 1000.0);
 +      RNA_def_property_ui_text(prop, "Sphere Radius", "Sphere radius for computing curvatures");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "kr_derivative_epsilon", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "dkr_epsilon");
 +      RNA_def_property_range(prop, -1000.0, 1000.0);
 +      RNA_def_property_ui_text(prop, "Kr Derivative Epsilon", "Kr derivative epsilon for computing suggestive contours");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "crease_angle", PROP_FLOAT, PROP_ANGLE);
 +      RNA_def_property_float_sdna(prop, NULL, "crease_angle");
 +      RNA_def_property_range(prop, 0.0, DEG2RAD(180.0));
 +      RNA_def_property_ui_text(prop, "Crease Angle", "Angular threshold for detecting crease edges");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +
 +      prop = RNA_def_property(srna, "linesets", PROP_COLLECTION, PROP_NONE);
 +      RNA_def_property_collection_sdna(prop, NULL, "linesets", NULL);
 +      RNA_def_property_struct_type(prop, "FreestyleLineSet");
 +      RNA_def_property_ui_text(prop, "Line Sets", "");
 +      rna_def_freestyle_linesets(brna, prop);
 +}
 +
 +static void rna_def_scene_game_recast_data(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem rna_enum_partitioning_items[] = {
 +              {RC_PARTITION_WATERSHED, "WATERSHED", 0, "Watershed", "Classic Recast partitioning method generating the nicest tessellation"},
 +              {RC_PARTITION_MONOTONE, "MONOTONE", 0, "Monotone", "Fastest navmesh generation method, may create long thin polygons"},
 +              {RC_PARTITION_LAYERS, "LAYERS", 0, "Layers", "Reasonably fast method that produces better triangles than monotone partitioning"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      srna = RNA_def_struct(brna, "SceneGameRecastData", NULL);
 +      RNA_def_struct_sdna(srna, "RecastData");
 +      RNA_def_struct_nested(brna, srna, "Scene");
 +      RNA_def_struct_ui_text(srna, "Recast Data", "Recast data for a Game data-block");
 +
 +      prop = RNA_def_property(srna, "cell_size", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "cellsize");
 +      RNA_def_property_ui_range(prop, 0.1, 1, 1, 2);
 +      RNA_def_property_float_default(prop, 0.3f);
 +      RNA_def_property_ui_text(prop, "Cell Size", "Rasterized cell size");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "cell_height", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "cellheight");
 +      RNA_def_property_ui_range(prop, 0.1, 1, 1, 2);
 +      RNA_def_property_float_default(prop, 0.2f);
 +      RNA_def_property_ui_text(prop, "Cell Height", "Rasterized cell height");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "agent_height", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "agentheight");
 +      RNA_def_property_ui_range(prop, 0.1, 5, 1, 2);
 +      RNA_def_property_float_default(prop, 2.0f);
 +      RNA_def_property_ui_text(prop, "Agent Height", "Minimum height where the agent can still walk");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "agent_radius", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "agentradius");
 +      RNA_def_property_ui_range(prop, 0.1, 5, 1, 2);
 +      RNA_def_property_float_default(prop, 0.6f);
 +      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, "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_float_default(prop, 0.9f);
 +      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, "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_float_default(prop, M_PI_4);
 +      RNA_def_property_ui_text(prop, "Max Slope", "Maximum walkable slope angle");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +
 +      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_float_default(prop, 8.0f);
 +      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_float_default(prop, 20.0f);
 +      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, "partitioning", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "partitioning");
 +      RNA_def_property_enum_items(prop, rna_enum_partitioning_items);
 +      RNA_def_property_enum_default(prop, RC_PARTITION_WATERSHED);
 +      RNA_def_property_ui_text(prop, "Partitioning", "Choose partitioning method");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "edge_max_len", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "edgemaxlen");
 +      RNA_def_property_ui_range(prop, 0, 50, 1, 2);
 +      RNA_def_property_float_default(prop, 12.0f);
 +      RNA_def_property_ui_text(prop, "Max Edge Length", "Maximum contour edge length");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "edge_max_error", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "edgemaxerror");
 +      RNA_def_property_ui_range(prop, 0.1, 3.0, 1, 2);
 +      RNA_def_property_float_default(prop, 1.3f);
 +      RNA_def_property_ui_text(prop, "Max Edge Error", "Maximum distance error from contour to cells");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "verts_per_poly", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "vertsperpoly");
 +      RNA_def_property_ui_range(prop, 3, 12, 1, -1);
 +      RNA_def_property_int_default(prop, 6);
 +      RNA_def_property_ui_text(prop, "Verts Per Poly", "Max number of vertices per polygon");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "sample_dist", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "detailsampledist");
 +      RNA_def_property_ui_range(prop, 0.0, 16.0, 1, 2);
 +      RNA_def_property_float_default(prop, 6.0f);
 +      RNA_def_property_ui_text(prop, "Sample Distance", "Detail mesh sample spacing");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "sample_max_error", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "detailsamplemaxerror");
 +      RNA_def_property_ui_range(prop, 0.0, 16.0, 1, 2);
 +      RNA_def_property_float_default(prop, 1.0f);
 +      RNA_def_property_ui_text(prop, "Max Sample Error", "Detail mesh simplification max sample error");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +}
 +
 +
 +static void rna_def_bake_data(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      srna = RNA_def_struct(brna, "BakeSettings", NULL);
 +      RNA_def_struct_sdna(srna, "BakeData");
 +      RNA_def_struct_nested(brna, srna, "RenderSettings");
 +      RNA_def_struct_ui_text(srna, "Bake Data", "Bake data for a Scene data-block");
 +
 +      prop = RNA_def_property(srna, "cage_object", PROP_STRING, PROP_NONE);
 +      RNA_def_property_string_sdna(prop, NULL, "cage");
 +      RNA_def_property_ui_text(prop, "Cage Object", "Object to use as cage "
 +                               "instead of calculating the cage from the active object with cage extrusion");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
 +      RNA_def_property_ui_text(prop, "File Path", "Image filepath to use when saving externally");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "width", PROP_INT, PROP_PIXEL);
 +      RNA_def_property_range(prop, 4, 10000);
 +      RNA_def_property_ui_text(prop, "Width", "Horizontal dimension of the baking map");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "height", PROP_INT, PROP_PIXEL);
 +      RNA_def_property_range(prop, 4, 10000);
 +      RNA_def_property_ui_text(prop, "Height", "Vertical dimension of the baking map");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "margin", PROP_INT, PROP_PIXEL);
 +      RNA_def_property_range(prop, 0, SHRT_MAX);
 +      RNA_def_property_ui_range(prop, 0, 64, 1, 1);
 +      RNA_def_property_ui_text(prop, "Margin", "Extends the baked result as a post process filter");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "cage_extrusion", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_range(prop, 0.0, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.0, 1.0, 1, 3);
 +      RNA_def_property_ui_text(prop, "Cage Extrusion",
 +                               "Distance to use for the inward ray cast when using selected to active");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "normal_space", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "normal_space");
 +      RNA_def_property_enum_items(prop, rna_enum_normal_space_items);
 +      RNA_def_property_ui_text(prop, "Normal Space", "Choose normal space for baking");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "normal_r", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "normal_swizzle[0]");
 +      RNA_def_property_enum_items(prop, rna_enum_normal_swizzle_items);
 +      RNA_def_property_ui_text(prop, "Normal Space", "Axis to bake in red channel");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "normal_g", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "normal_swizzle[1]");
 +      RNA_def_property_enum_items(prop, rna_enum_normal_swizzle_items);
 +      RNA_def_property_ui_text(prop, "Normal Space", "Axis to bake in green channel");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "normal_b", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "normal_swizzle[2]");
 +      RNA_def_property_enum_items(prop, rna_enum_normal_swizzle_items);
 +      RNA_def_property_ui_text(prop, "Normal Space", "Axis to bake in blue channel");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      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, "save_mode", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_bitflag_sdna(prop, NULL, "save_mode");
 +      RNA_def_property_enum_items(prop, rna_enum_bake_save_mode_items);
 +      RNA_def_property_ui_text(prop, "Save Mode", "Choose how to save the baking map");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      /* flags */
 +      prop = RNA_def_property(srna, "use_selected_to_active", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "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_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "use_clear", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", R_BAKE_CLEAR);
 +      RNA_def_property_ui_text(prop, "Clear",
 +                               "Clear Images before baking (internal only)");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "use_split_materials", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", R_BAKE_SPLIT_MAT);
 +      RNA_def_property_ui_text(prop, "Split Materials",
 +                               "Split external images per material (external only)");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "use_automatic_name", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", R_BAKE_AUTO_NAME);
 +      RNA_def_property_ui_text(prop, "Automatic Name",
 +                               "Automatically name the output file with the pass type (external only)");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "use_cage", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", R_BAKE_CAGE);
 +      RNA_def_property_ui_text(prop, "Cage",
 +                               "Cast rays to active object from a cage");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      /* custom passes flags */
 +      prop = RNA_def_property(srna, "use_pass_ambient_occlusion", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_AO);
 +      RNA_def_property_ui_text(prop, "AO", "Add ambient occlusion contribution");
 +
 +      prop = RNA_def_property(srna, "use_pass_emit", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_EMIT);
 +      RNA_def_property_ui_text(prop, "Emit", "Add emission contribution");
 +
 +      prop = RNA_def_property(srna, "use_pass_direct", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_DIRECT);
 +      RNA_def_property_ui_text(prop, "Direct", "Add direct lighting contribution");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "use_pass_indirect", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_INDIRECT);
 +      RNA_def_property_ui_text(prop, "Indirect", "Add indirect lighting contribution");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "use_pass_color", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_COLOR);
 +      RNA_def_property_ui_text(prop, "Color", "Color the pass");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "use_pass_diffuse", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_DIFFUSE);
 +      RNA_def_property_ui_text(prop, "Diffuse", "Add diffuse contribution");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "use_pass_glossy", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_GLOSSY);
 +      RNA_def_property_ui_text(prop, "Glossy", "Add glossy contribution");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "use_pass_transmission", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_TRANSM);
 +      RNA_def_property_ui_text(prop, "Transmission", "Add transmission contribution");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "use_pass_subsurface", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_SUBSURFACE);
 +      RNA_def_property_ui_text(prop, "Subsurface", "Add subsurface contribution");
 +      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +
 +      prop = RNA_def_property(srna, "pass_filter", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "pass_filter");
 +      RNA_def_property_enum_items(prop, rna_enum_bake_pass_filter_type_items);
 +      RNA_def_property_flag(prop, PROP_ENUM_FLAG);
 +      RNA_def_property_ui_text(prop, "Pass Filter",  "Passes to include in the active baking pass");
 +      RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +}
 +
 +static void rna_def_scene_game_data(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      static EnumPropertyItem aasamples_items[] = {
 +              {0, "SAMPLES_0", 0, "Off", ""},
 +              {2, "SAMPLES_2", 0, "2x", ""},
 +              {4, "SAMPLES_4", 0, "4x", ""},
 +              {8, "SAMPLES_8", 0, "8x", ""},
 +              {16, "SAMPLES_16", 0, "16x", ""},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      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_SCALE, "SCALE", 0, "Scale", "Stretch or squeeze the viewport to fill the display window"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      static EnumPropertyItem dome_modes_items[] = {
 +              {DOME_FISHEYE, "FISHEYE", 0, "Fisheye", ""},
 +              {DOME_TRUNCATED_FRONT, "TRUNCATED_FRONT", 0, "Front-Truncated", ""},
 +              {DOME_TRUNCATED_REAR, "TRUNCATED_REAR", 0, "Rear-Truncated", ""},
 +              {DOME_ENVMAP, "ENVMAP", 0, "Cube Map", ""},
 +              {DOME_PANORAM_SPH, "PANORAM_SPH", 0, "Spherical Panoramic", ""},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +              
 +      static EnumPropertyItem stereo_modes_items[] = {
 +              {STEREO_QUADBUFFERED, "QUADBUFFERED", 0, "Quad-Buffer", ""},
 +              {STEREO_ABOVEBELOW, "ABOVEBELOW", 0, "Above-Below", ""},
 +              {STEREO_INTERLACED, "INTERLACED", 0, "Interlaced", ""},
 +              {STEREO_ANAGLYPH, "ANAGLYPH", 0, "Anaglyph", ""},
 +              {STEREO_SIDEBYSIDE, "SIDEBYSIDE", 0, "Side-by-side", ""},
 +              {STEREO_VINTERLACE, "VINTERLACE", 0, "Vinterlace", ""},
 +              {STEREO_3DTVTOPBOTTOM, "3DTVTOPBOTTOM", 0, "3DTV Top-Bottom", ""},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +              
 +      static EnumPropertyItem stereo_items[] = {
 +              {STEREO_NOSTEREO, "NONE", 0, "None", "Disable Stereo and Dome environments"},
 +              {STEREO_ENABLED, "STEREO", 0, "Stereo", "Enable Stereo environment"},
 +              {STEREO_DOME, "DOME", 0, "Dome", "Enable Dome environment"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      static EnumPropertyItem physics_engine_items[] = {
 +              {WOPHY_NONE, "NONE", 0, "None", "Don't use a physics engine"},
 +              {WOPHY_BULLET, "BULLET", 0, "Bullet", "Use the Bullet physics engine"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      static EnumPropertyItem material_items[] = {
 +              {GAME_MAT_MULTITEX, "MULTITEXTURE", 0, "Multitexture", "Multitexture materials"},
 +              {GAME_MAT_GLSL, "GLSL", 0, "GLSL", "OpenGL shading language shaders"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      static EnumPropertyItem obstacle_simulation_items[] = {
 +              {OBSTSIMULATION_NONE, "NONE", 0, "None", ""},
 +              {OBSTSIMULATION_TOI_rays, "RVO_RAYS", 0, "RVO (rays)", ""},
 +              {OBSTSIMULATION_TOI_cells, "RVO_CELLS", 0, "RVO (cells)", ""},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      static EnumPropertyItem vsync_items[] = {
 +              {VSYNC_OFF, "OFF", 0, "Off", "Disable vsync"},
 +              {VSYNC_ON, "ON", 0, "On", "Enable vsync"},
 +              {VSYNC_ADAPTIVE, "ADAPTIVE", 0, "Adaptive", "Enable adaptive vsync (if supported)"},
 +              {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      static EnumPropertyItem storage_items[] = {
 +              {RAS_STORE_AUTO, "AUTO", 0, "Auto Select", "Choose the best supported mode"},
 +              {RAS_STORE_VA, "VERTEX_ARRAY", 0, "Vertex Arrays", "Usually the best choice (good performance with display lists)"},
 +              {RAS_STORE_VBO, "VERTEX_BUFFER_OBJECT", 0, "Vertex Buffer Objects",
 +                              "Typically slower than vertex arrays with display lists, requires at least OpenGL 1.4"},
 +              {0, NULL, 0, NULL, NULL}};
 +
 +      srna = RNA_def_struct(brna, "SceneGameData", NULL);
 +      RNA_def_struct_sdna(srna, "GameData");
 +      RNA_def_struct_nested(brna, srna, "Scene");
 +      RNA_def_struct_ui_text(srna, "Game Data", "Game data for a Scene data-block");
 +      
 +      prop = RNA_def_property(srna, "resolution_x", PROP_INT, PROP_PIXEL);
 +      RNA_def_property_int_sdna(prop, NULL, "xplay");
 +      RNA_def_property_range(prop, 4, 10000);
 +      RNA_def_property_int_default(prop, 640);
 +      RNA_def_property_ui_text(prop, "Resolution X", "Number of horizontal pixels in the screen");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      
 +      prop = RNA_def_property(srna, "resolution_y", PROP_INT, PROP_PIXEL);
 +      RNA_def_property_int_sdna(prop, NULL, "yplay");
 +      RNA_def_property_range(prop, 4, 10000);
 +      RNA_def_property_int_default(prop, 480);
 +      RNA_def_property_ui_text(prop, "Resolution Y", "Number of vertical pixels in the screen");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "vsync", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "vsync");
 +      RNA_def_property_enum_items(prop, vsync_items);
 +      RNA_def_property_ui_text(prop, "Vsync", "Change vsync settings");
 +      
 +      prop = RNA_def_property(srna, "samples", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "aasamples");
 +      RNA_def_property_enum_items(prop, aasamples_items);
 +      RNA_def_property_ui_text(prop, "AA Samples", "The number of AA Samples to use for MSAA");
 +      
 +      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_int_default(prop, 32);
 +      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, rna_enum_event_type_items);
 +      RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_UI_EVENTS);
 +      RNA_def_property_enum_default(prop, ESCKEY);
 +      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);
 +      
 +      prop = RNA_def_property(srna, "raster_storage", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "raster_storage");
 +      RNA_def_property_enum_items(prop, storage_items);
 +      RNA_def_property_ui_text(prop, "Storage", "Set the storage mode used by the rasterizer");
 +      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_int_default(prop, 60);
 +      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, "playerflag", GAME_PLAYER_FULLSCREEN);
 +      RNA_def_property_ui_text(prop, "Fullscreen", "Start player in a new fullscreen display");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "use_desktop", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "playerflag", GAME_PLAYER_DESKTOP_RESOLUTION);
 +      RNA_def_property_ui_text(prop, "Desktop", "Use the current desktop resolution in fullscreen mode");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      /* Framing */
 +      prop = RNA_def_property(srna, "frame_type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "framing.type");
 +      RNA_def_property_enum_items(prop, framing_types_items);
 +      RNA_def_property_ui_text(prop, "Framing Types", "Select the type of Framing you want");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "frame_color", PROP_FLOAT, PROP_COLOR);
 +      RNA_def_property_float_sdna(prop, NULL, "framing.col");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_array(prop, 3);
 +      RNA_def_property_ui_text(prop, "Framing Color", "Set color of the bars");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      
 +      /* Stereo */
 +      prop = RNA_def_property(srna, "stereo", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "stereoflag");
 +      RNA_def_property_enum_items(prop, stereo_items);
 +      RNA_def_property_ui_text(prop, "Stereo Options", "");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "stereo_mode", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "stereomode");
 +      RNA_def_property_enum_items(prop, stereo_modes_items);
 +      RNA_def_property_enum_default(prop, STEREO_ANAGLYPH);
 +      RNA_def_property_ui_text(prop, "Stereo Mode", "Stereographic techniques");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      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_float_default(prop, 0.1f);
 +      RNA_def_property_ui_text(prop, "Eye Separation",
 +                               "Set the distance between the eyes - the camera focal distance/30 should be fine");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      
 +      /* Dome */
 +      prop = RNA_def_property(srna, "dome_mode", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "dome.mode");
 +      RNA_def_property_enum_items(prop, dome_modes_items);
 +      RNA_def_property_ui_text(prop, "Dome Mode", "Dome physical configurations");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      
 +      prop = RNA_def_property(srna, "dome_tessellation", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "dome.res");
 +      RNA_def_property_ui_range(prop, 1, 8, 1, 1);
 +      RNA_def_property_int_default(prop, 4);
 +      RNA_def_property_ui_text(prop, "Tessellation", "Tessellation level - check the generated mesh in wireframe mode");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      
 +      prop = RNA_def_property(srna, "dome_buffer_resolution", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "dome.resbuf");
 +      RNA_def_property_ui_range(prop, 0.1, 1.0, 0.1, 2);
 +      RNA_def_property_float_default(prop, 1.0f);
 +      RNA_def_property_ui_text(prop, "Buffer Resolution", "Buffer Resolution - decrease it to increase speed");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      
 +      prop = RNA_def_property(srna, "dome_angle", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "dome.angle");
 +      RNA_def_property_ui_range(prop, 90, 250, 1, 1);
 +      RNA_def_property_int_default(prop, 180);
 +      RNA_def_property_ui_text(prop, "Angle", "Field of View of the Dome - it only works in mode Fisheye and Truncated");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      
 +      prop = RNA_def_property(srna, "dome_tilt", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "dome.tilt");
 +      RNA_def_property_ui_range(prop, -180, 180, 1, 1);
 +      RNA_def_property_ui_text(prop, "Tilt", "Camera rotation in horizontal axis");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      
 +      prop = RNA_def_property(srna, "dome_text", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "dome.warptext");
 +      RNA_def_property_struct_type(prop, "Text");
 +      RNA_def_property_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_ui_text(prop, "Warp Data", "Custom Warp Mesh data file");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      
 +      /* physics */
 +      prop = RNA_def_property(srna, "physics_engine", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "physicsEngine");
 +      RNA_def_property_enum_items(prop, physics_engine_items);
 +      RNA_def_property_enum_default(prop, WOPHY_BULLET);
 +      RNA_def_property_ui_text(prop, "Physics Engine", "Physics engine used for physics simulation in the game engine");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "physics_gravity", PROP_FLOAT, PROP_ACCELERATION);
 +      RNA_def_property_float_sdna(prop, NULL, "gravity");
 +      RNA_def_property_ui_range(prop, 0.0, 25.0, 1, 2);
 +      RNA_def_property_range(prop, 0.0, 10000.0);
 +      RNA_def_property_float_default(prop, 9.8f);
 +      RNA_def_property_ui_text(prop, "Physics Gravity",
 +                               "Gravitational constant used for physics simulation in the game engine");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "occlusion_culling_resolution", PROP_INT, PROP_PIXEL);
 +      RNA_def_property_int_sdna(prop, NULL, "occlusionRes");
 +      RNA_def_property_range(prop, 128.0, 1024.0);
 +      RNA_def_property_int_default(prop, 128);
 +      RNA_def_property_ui_text(prop, "Occlusion Resolution",
 +                               "Size of the occlusion buffer, 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, 10000);
 +      RNA_def_property_int_default(prop, 60);
 +      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_range(prop, 1, 10000);
 +      RNA_def_property_ui_range(prop, 1, 50, 1, 1);
 +      RNA_def_property_int_default(prop, 5);
 +      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_range(prop, 1, 10000);
 +      RNA_def_property_ui_range(prop, 1, 50, 1, 1);
 +      RNA_def_property_int_default(prop, 5);
 +      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_range(prop, 1, 50);
 +      RNA_def_property_ui_range(prop, 1, 5, 1, 1);
 +      RNA_def_property_int_default(prop, 1);
 +      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);
 +
 +      prop = RNA_def_property(srna, "deactivation_linear_threshold", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "lineardeactthreshold");
 +      RNA_def_property_ui_range(prop, 0.001, 10000.0, 2, 3);
 +      RNA_def_property_range(prop, 0.001, 10000.0);
 +      RNA_def_property_float_default(prop, 0.8f);
 +      RNA_def_property_ui_text(prop, "Deactivation Linear Threshold",
 +                               "Linear velocity that an object must be below before the deactivation timer can start");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
 +
 +      prop = RNA_def_property(srna, "deactivation_angular_threshold", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "angulardeactthreshold");
 +      RNA_def_property_ui_range(prop, 0.001, 10000.0, 2, 3);
 +      RNA_def_property_range(prop, 0.001, 10000.0);
 +      RNA_def_property_float_default(prop, 1.0f);
 +      RNA_def_property_ui_text(prop, "Deactivation Angular Threshold",
 +                               "Angular velocity that an object must be below before the deactivation timer can start");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
  
 -      prop = RNA_def_property(srna, "use_advanced_options", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_ADVANCED_OPTIONS_FLAG);
 -      RNA_def_property_ui_text(prop, "Advanced Options",
 -                               "Enable advanced edge detection options (sphere radius and Kr derivative epsilon)");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      prop = RNA_def_property(srna, "deactivation_time", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_sdna(prop, NULL, "deactivationtime");
 +      RNA_def_property_ui_range(prop, 0.0, 60.0, 1, 1);
 +      RNA_def_property_range(prop, 0.0, 60.0);
 +      RNA_def_property_ui_text(prop, "Deactivation Time",
 +                               "Amount of time (in seconds) after which objects with a velocity less than the given "
 +                               "threshold will deactivate (0.0 means no deactivation)");
 +      RNA_def_property_update(prop, NC_SCENE, NULL);
  
 -      prop = RNA_def_property(srna, "use_view_map_cache", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flags", FREESTYLE_VIEW_MAP_CACHE);
 -      RNA_def_property_ui_text(prop, "View Map Cache",
 -                               "Keep the computed view map and avoid re-calculating it if mesh geometry is unchanged");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_use_view_map_cache_update");
 +      /* mode */
 +      /* not used  *//* deprecated !!!!!!!!!!!!! */
 +      prop = RNA_def_property(srna, "use_occlusion_culling", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", WO_DBVT_CULLING);
 +      RNA_def_property_ui_text(prop, "DBVT Culling",
 +                               "Use optimized Bullet DBVT tree for view frustum and occlusion culling (more efficient, "
 +                               "but it can waste unnecessary CPU if the scene doesn't have occluder objects)");
 +      
 +      /* not used  *//* deprecated !!!!!!!!!!!!! */
 +      prop = RNA_def_property(srna, "use_activity_culling", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "mode", WO_ACTIVITY_CULLING);
 +      RNA_def_property_ui_text(prop, "Activity Culling", "Activity culling is enabled");
  
 -      prop = RNA_def_property(srna, "sphere_radius", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "sphere_radius");
 +      /* not used  *//* deprecated !!!!!!!!!!!!! */
 +      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, "Sphere Radius", "Sphere radius for computing curvatures");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      RNA_def_property_ui_text(prop, "Box Radius",
 +                               "Radius of the activity bubble, in Manhattan length "
 +                               "(objects outside the box are activity-culled)");
  
 -      prop = RNA_def_property(srna, "kr_derivative_epsilon", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "dkr_epsilon");
 -      RNA_def_property_range(prop, -1000.0, 1000.0);
 -      RNA_def_property_ui_text(prop, "Kr Derivative Epsilon", "Kr derivative epsilon for computing suggestive contours");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      /* booleans */
 +      prop = RNA_def_property(srna, "show_debug_properties", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_SHOW_DEBUG_PROPS);
 +      RNA_def_property_ui_text(prop, "Show Debug Properties",
 +                               "Show properties marked for debugging while the game runs");
  
 -      prop = RNA_def_property(srna, "crease_angle", PROP_FLOAT, PROP_ANGLE);
 -      RNA_def_property_float_sdna(prop, NULL, "crease_angle");
 -      RNA_def_property_range(prop, 0.0, DEG2RAD(180.0));
 -      RNA_def_property_ui_text(prop, "Crease Angle", "Angular threshold for detecting crease edges");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, "rna_Scene_freestyle_update");
 +      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");
  
 -      prop = RNA_def_property(srna, "linesets", PROP_COLLECTION, PROP_NONE);
 -      RNA_def_property_collection_sdna(prop, NULL, "linesets", NULL);
 -      RNA_def_property_struct_type(prop, "FreestyleLineSet");
 -      RNA_def_property_ui_text(prop, "Line Sets", "");
 -      rna_def_freestyle_linesets(brna, prop);
 -}
 +      prop = RNA_def_property(srna, "show_physics_visualization", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_SHOW_PHYSICS);
 +      RNA_def_property_ui_text(prop, "Show Physics Visualization",
 +                               "Show a visualization of physics bounds and interactions");
  
 -static void rna_def_scene_game_recast_data(BlenderRNA *brna)
 -{
 -      StructRNA *srna;
 -      PropertyRNA *prop;
 +      prop = RNA_def_property(srna, "show_mouse", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_SHOW_MOUSE);
 +      RNA_def_property_ui_text(prop, "Show Mouse", "Start player with a visible mouse cursor");
  
 -      static EnumPropertyItem rna_enum_partitioning_items[] = {
 -              {RC_PARTITION_WATERSHED, "WATERSHED", 0, "Watershed", "Classic Recast partitioning method generating the nicest tessellation"},
 -              {RC_PARTITION_MONOTONE, "MONOTONE", 0, "Monotone", "Fastest navmesh generation method, may create long thin polygons"},
 -              {RC_PARTITION_LAYERS, "LAYERS", 0, "Layers", "Reasonably fast method that produces better triangles than monotone partitioning"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +      prop = RNA_def_property(srna, "use_frame_rate", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_ENABLE_ALL_FRAMES);
 +      RNA_def_property_ui_text(prop, "Use Frame Rate",
 +                               "Respect the frame rate from the Physics panel in the world properties "
 +                               "rather than rendering as many frames as possible");
  
 -      srna = RNA_def_struct(brna, "SceneGameRecastData", NULL);
 -      RNA_def_struct_sdna(srna, "RecastData");
 -      RNA_def_struct_nested(brna, srna, "Scene");
 -      RNA_def_struct_ui_text(srna, "Recast Data", "Recast data for a Game data-block");
 +      prop = RNA_def_property(srna, "use_display_lists", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_DISPLAY_LISTS);
 +      RNA_def_property_ui_text(prop, "Display Lists",
 +                               "Use display lists to speed up rendering by keeping geometry on the GPU");
  
 -      prop = RNA_def_property(srna, "cell_size", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "cellsize");
 -      RNA_def_property_ui_range(prop, 0.1, 1, 1, 2);
 -      RNA_def_property_float_default(prop, 0.3f);
 -      RNA_def_property_ui_text(prop, "Cell Size", "Rasterized cell size");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      prop = RNA_def_property(srna, "use_deprecation_warnings", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_IGNORE_DEPRECATION_WARNINGS);
 +      RNA_def_property_ui_text(prop, "Deprecation Warnings",
 +                               "Print warnings when using deprecated features in the python API");
  
 -      prop = RNA_def_property(srna, "cell_height", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "cellheight");
 -      RNA_def_property_ui_range(prop, 0.1, 1, 1, 2);
 -      RNA_def_property_float_default(prop, 0.2f);
 -      RNA_def_property_ui_text(prop, "Cell Height", "Rasterized cell height");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      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 F-Curves");
  
 -      prop = RNA_def_property(srna, "agent_height", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "agentheight");
 -      RNA_def_property_ui_range(prop, 0.1, 5, 1, 2);
 -      RNA_def_property_float_default(prop, 2.0f);
 -      RNA_def_property_ui_text(prop, "Agent Height", "Minimum height where the agent can still walk");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      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");
 +      RNA_def_property_ui_text(prop, "Auto Start", "Automatically start game at load time");
  
 -      prop = RNA_def_property(srna, "agent_radius", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "agentradius");
 -      RNA_def_property_ui_range(prop, 0.1, 5, 1, 2);
 -      RNA_def_property_float_default(prop, 0.6f);
 -      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, "use_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)");
 +      
 +      /* materials */
 +      prop = RNA_def_property(srna, "material_mode", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "matmode");
 +      RNA_def_property_enum_items(prop, material_items);
 +      RNA_def_property_ui_text(prop, "Material Mode", "Material mode to use for rendering");
 +      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, NULL);
  
 -      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_float_default(prop, 0.9f);
 -      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, "use_glsl_lights", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_LIGHTS);
 +      RNA_def_property_ui_text(prop, "GLSL Lights", "Use lights for GLSL rendering");
 +      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
  
 -      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_float_default(prop, M_PI_4);
 -      RNA_def_property_ui_text(prop, "Max Slope", "Maximum walkable slope angle");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      prop = RNA_def_property(srna, "use_glsl_shaders", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_SHADERS);
 +      RNA_def_property_ui_text(prop, "GLSL Shaders", "Use shaders for GLSL rendering");
 +      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
  
 +      prop = RNA_def_property(srna, "use_glsl_shadows", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_SHADOWS);
 +      RNA_def_property_ui_text(prop, "GLSL Shadows", "Use shadows for GLSL rendering");
 +      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
  
 -      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_float_default(prop, 8.0f);
 -      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, "use_glsl_ramps", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_RAMPS);
 +      RNA_def_property_ui_text(prop, "GLSL Ramps", "Use ramps for GLSL rendering");
 +      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
  
 -      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_float_default(prop, 20.0f);
 -      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, "use_glsl_nodes", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_NODES);
 +      RNA_def_property_ui_text(prop, "GLSL Nodes", "Use nodes for GLSL rendering");
 +      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
  
 -      prop = RNA_def_property(srna, "partitioning", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "partitioning");
 -      RNA_def_property_enum_items(prop, rna_enum_partitioning_items);
 -      RNA_def_property_enum_default(prop, RC_PARTITION_WATERSHED);
 -      RNA_def_property_ui_text(prop, "Partitioning", "Choose partitioning method");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      prop = RNA_def_property(srna, "use_glsl_color_management", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_COLOR_MANAGEMENT);
 +      RNA_def_property_ui_text(prop, "GLSL Color Management", "Use color management for GLSL rendering");
 +      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
  
 -      prop = RNA_def_property(srna, "edge_max_len", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "edgemaxlen");
 -      RNA_def_property_ui_range(prop, 0, 50, 1, 2);
 -      RNA_def_property_float_default(prop, 12.0f);
 -      RNA_def_property_ui_text(prop, "Max Edge Length", "Maximum contour edge length");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      prop = RNA_def_property(srna, "use_glsl_extra_textures", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_EXTRA_TEX);
 +      RNA_def_property_ui_text(prop, "GLSL Extra Textures",
 +                               "Use extra textures like normal or specular maps for GLSL rendering");
 +      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
  
 -      prop = RNA_def_property(srna, "edge_max_error", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "edgemaxerror");
 -      RNA_def_property_ui_range(prop, 0.1, 3.0, 1, 2);
 -      RNA_def_property_float_default(prop, 1.3f);
 -      RNA_def_property_ui_text(prop, "Max Edge Error", "Maximum distance error from contour to cells");
 +      prop = RNA_def_property(srna, "use_glsl_environment_lighting", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_ENV_LIGHTING);
 +      RNA_def_property_ui_text(prop, "GLSL Environment Lighting", "Use environment lighting for GLSL rendering");
 +      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
 +
 +      prop = RNA_def_property(srna, "use_material_caching", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_NO_MATERIAL_CACHING);
 +      RNA_def_property_ui_text(prop, "Use Material Caching",
 +                               "Cache materials in the converter (this is faster, but can cause problems with older "
 +                               "Singletexture and Multitexture games)");
 +
 +      /* obstacle simulation */
 +      prop = RNA_def_property(srna, "obstacle_simulation", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "obstacleSimulation");
 +      RNA_def_property_enum_items(prop, obstacle_simulation_items);
 +      RNA_def_property_ui_text(prop, "Obstacle simulation", "Simulation used for obstacle avoidance in the game engine");
        RNA_def_property_update(prop, NC_SCENE, NULL);
  
 -      prop = RNA_def_property(srna, "verts_per_poly", PROP_INT, PROP_NONE);
 -      RNA_def_property_int_sdna(prop, NULL, "vertsperpoly");
 -      RNA_def_property_ui_range(prop, 3, 12, 1, -1);
 -      RNA_def_property_int_default(prop, 6);
 -      RNA_def_property_ui_text(prop, "Verts Per Poly", "Max number of vertices per polygon");
 +      prop = RNA_def_property(srna, "level_height", PROP_FLOAT, PROP_ACCELERATION);
 +      RNA_def_property_float_sdna(prop, NULL, "levelHeight");
 +      RNA_def_property_range(prop, 0.0f, 200.0f);
 +      RNA_def_property_float_default(prop, 2.0f);
 +      RNA_def_property_ui_text(prop, "Level height",
 +                               "Max difference in heights of obstacles to enable their interaction");
        RNA_def_property_update(prop, NC_SCENE, NULL);
  
 -      prop = RNA_def_property(srna, "sample_dist", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "detailsampledist");
 -      RNA_def_property_ui_range(prop, 0.0, 16.0, 1, 2);
 -      RNA_def_property_float_default(prop, 6.0f);
 -      RNA_def_property_ui_text(prop, "Sample Distance", "Detail mesh sample spacing");
 +      prop = RNA_def_property(srna, "show_obstacle_simulation", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_SHOW_OBSTACLE_SIMULATION);
 +      RNA_def_property_ui_text(prop, "Visualization", "Enable debug visualization for obstacle simulation");
 +
 +      /* Recast Settings */
 +      prop = RNA_def_property(srna, "recast_data", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_flag(prop, PROP_NEVER_NULL);
 +      RNA_def_property_pointer_sdna(prop, NULL, "recastData");
 +      RNA_def_property_struct_type(prop, "SceneGameRecastData");
 +      RNA_def_property_ui_text(prop, "Recast Data", "");
 +
 +      /* Nestled Data  */
 +      rna_def_scene_game_recast_data(brna);
 +
 +      /* LoD */
 +      prop = RNA_def_property(srna, "use_scene_hysteresis", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "lodflag", SCE_LOD_USE_HYST);
 +      RNA_def_property_ui_text(prop, "Hysteresis", "Use LoD Hysteresis setting for the scene");
        RNA_def_property_update(prop, NC_SCENE, NULL);
  
 -      prop = RNA_def_property(srna, "sample_max_error", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "detailsamplemaxerror");
 -      RNA_def_property_ui_range(prop, 0.0, 16.0, 1, 2);
 -      RNA_def_property_float_default(prop, 1.0f);
 -      RNA_def_property_ui_text(prop, "Max Sample Error", "Detail mesh simplification max sample error");
 +      prop = RNA_def_property(srna, "scene_hysteresis_percentage", PROP_INT, PROP_PERCENTAGE);
 +      RNA_def_property_int_sdna(prop, NULL, "scehysteresis");
 +      RNA_def_property_range(prop, 0, 100);
 +      RNA_def_property_ui_range(prop, 0, 100, 10, 1);
 +      RNA_def_property_int_default(prop, 10);
 +      RNA_def_property_ui_text(prop, "Hysteresis %",
 +                               "Minimum distance change required to transition to the previous level of detail");
        RNA_def_property_update(prop, NC_SCENE, NULL);
  }
  
 -
 -static void rna_def_bake_data(BlenderRNA *brna)
 +static void rna_def_gpu_dof_fx(BlenderRNA *brna)
  {
        StructRNA *srna;
        PropertyRNA *prop;
  
 -      srna = RNA_def_struct(brna, "BakeSettings", NULL);
 -      RNA_def_struct_sdna(srna, "BakeData");
 -      RNA_def_struct_nested(brna, srna, "RenderSettings");
 -      RNA_def_struct_ui_text(srna, "Bake Data", "Bake data for a Scene data-block");
 -
 -      prop = RNA_def_property(srna, "cage_object", PROP_STRING, PROP_NONE);
 -      RNA_def_property_string_sdna(prop, NULL, "cage");
 -      RNA_def_property_ui_text(prop, "Cage Object", "Object to use as cage "
 -                               "instead of calculating the cage from the active object with cage extrusion");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 -
 -      prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_FILEPATH);
 -      RNA_def_property_ui_text(prop, "File Path", "Image filepath to use when saving externally");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 -
 -      prop = RNA_def_property(srna, "width", PROP_INT, PROP_PIXEL);
 -      RNA_def_property_range(prop, 4, 10000);
 -      RNA_def_property_ui_text(prop, "Width", "Horizontal dimension of the baking map");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 -
 -      prop = RNA_def_property(srna, "height", PROP_INT, PROP_PIXEL);
 -      RNA_def_property_range(prop, 4, 10000);
 -      RNA_def_property_ui_text(prop, "Height", "Vertical dimension of the baking map");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      srna = RNA_def_struct(brna, "GPUDOFSettings", NULL);
 +      RNA_def_struct_ui_text(srna, "GPU DOF", "Settings for GPU based depth of field");
 +      RNA_def_struct_ui_icon(srna, ICON_RENDERLAYERS);
 +      RNA_def_struct_path_func(srna, "rna_GPUDOF_path");
  
 -      prop = RNA_def_property(srna, "margin", PROP_INT, PROP_PIXEL);
 -      RNA_def_property_range(prop, 0, SHRT_MAX);
 -      RNA_def_property_ui_range(prop, 0, 64, 1, 1);
 -      RNA_def_property_ui_text(prop, "Margin", "Extends the baked result as a post process filter");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "focus_distance", PROP_FLOAT, PROP_DISTANCE);
 +      RNA_def_property_ui_text(prop, "Focus distance", "Viewport depth of field focus distance");
 +      RNA_def_property_range(prop, 0.0f, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.0f, 5000.0f, 1, 2);
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
  
 -      prop = RNA_def_property(srna, "cage_extrusion", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_range(prop, 0.0, FLT_MAX);
 -      RNA_def_property_ui_range(prop, 0.0, 1.0, 1, 3);
 -      RNA_def_property_ui_text(prop, "Cage Extrusion",
 -                               "Distance to use for the inward ray cast when using selected to active");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "focal_length", PROP_FLOAT, PROP_DISTANCE_CAMERA);
 +      RNA_def_property_ui_text(prop, "Focal Length", "Focal length for dof effect");
 +      RNA_def_property_range(prop, 1.0f, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 1.0f, 5000.0f, 1, 2);
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
  
 -      prop = RNA_def_property(srna, "normal_space", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "normal_space");
 -      RNA_def_property_enum_items(prop, rna_enum_normal_space_items);
 -      RNA_def_property_ui_text(prop, "Normal Space", "Choose normal space for baking");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "sensor", PROP_FLOAT, PROP_DISTANCE_CAMERA);
 +      RNA_def_property_ui_text(prop, "Sensor", "Size of sensor");
 +      RNA_def_property_range(prop, 1.0f, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 1.0f, 5000.0f, 1, 2);
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
  
 -      prop = RNA_def_property(srna, "normal_r", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "normal_swizzle[0]");
 -      RNA_def_property_enum_items(prop, rna_enum_normal_swizzle_items);
 -      RNA_def_property_ui_text(prop, "Normal Space", "Axis to bake in red channel");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "fstop", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_ui_text(prop, "F-stop", "F-stop for dof effect");
 +      RNA_def_property_range(prop, 0.0f, FLT_MAX);
 +      RNA_def_property_ui_range(prop, 0.1f, 128.0f, 10, 1);
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
  
 -      prop = RNA_def_property(srna, "normal_g", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "normal_swizzle[1]");
 -      RNA_def_property_enum_items(prop, rna_enum_normal_swizzle_items);
 -      RNA_def_property_ui_text(prop, "Normal Space", "Axis to bake in green channel");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "blades", PROP_INT, PROP_NONE);
 +      RNA_def_property_int_sdna(prop, NULL, "num_blades");
 +      RNA_def_property_ui_text(prop, "Blades", "Blades for dof effect");
 +      RNA_def_property_range(prop, 0, 16);
 +      RNA_def_property_int_funcs(prop, NULL, "rna_GPUDOFSettings_blades_set", NULL);
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
  
 -      prop = RNA_def_property(srna, "normal_b", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "normal_swizzle[2]");
 -      RNA_def_property_enum_items(prop, rna_enum_normal_swizzle_items);
 -      RNA_def_property_ui_text(prop, "Normal Space", "Axis to bake in blue channel");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "use_high_quality", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "high_quality", 1);
 +      RNA_def_property_ui_text(prop, "High Quality", "Use high quality depth of field");
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
  
 -      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, "is_hq_supported", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_funcs(prop, "rna_gpu_is_hq_supported_get", NULL);
 +      RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      RNA_def_property_ui_text(prop, "High Quality", "Use high quality depth of field");
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +}
  
 -      prop = RNA_def_property(srna, "save_mode", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_bitflag_sdna(prop, NULL, "save_mode");
 -      RNA_def_property_enum_items(prop, rna_enum_bake_save_mode_items);
 -      RNA_def_property_ui_text(prop, "Save Mode", "Choose how to save the baking map");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +static void rna_def_gpu_ssao_fx(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
  
 -      /* flags */
 -      prop = RNA_def_property(srna, "use_selected_to_active", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "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_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      srna = RNA_def_struct(brna, "GPUSSAOSettings", NULL);
 +      RNA_def_struct_ui_text(srna, "GPU SSAO", "Settings for GPU based screen space ambient occlusion");
 +      RNA_def_struct_ui_icon(srna, ICON_RENDERLAYERS);
  
 -      prop = RNA_def_property(srna, "use_clear", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", R_BAKE_CLEAR);
 -      RNA_def_property_ui_text(prop, "Clear",
 -                               "Clear Images before baking (internal only)");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_ui_text(prop, "Strength", "Strength of the SSAO effect");
 +      RNA_def_property_range(prop, 0.0f, 250.0f);
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
  
 -      prop = RNA_def_property(srna, "use_split_materials", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", R_BAKE_SPLIT_MAT);
 -      RNA_def_property_ui_text(prop, "Split Materials",
 -                               "Split external images per material (external only)");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "distance_max", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_ui_text(prop, "Distance", "Distance of object that contribute to the SSAO effect");
 +      RNA_def_property_range(prop, 0.0f, 100000.0f);
 +      RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3);
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
  
 -      prop = RNA_def_property(srna, "use_automatic_name", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", R_BAKE_AUTO_NAME);
 -      RNA_def_property_ui_text(prop, "Automatic Name",
 -                               "Automatically name the output file with the pass type (external only)");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "attenuation", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_ui_text(prop, "Attenuation", "Attenuation constant");
 +      RNA_def_property_range(prop, 1.0f, 100000.0f);
 +      RNA_def_property_ui_range(prop, 1.0f, 100.0f, 1, 3);
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
  
 -      prop = RNA_def_property(srna, "use_cage", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", R_BAKE_CAGE);
 -      RNA_def_property_ui_text(prop, "Cage",
 -                               "Cast rays to active object from a cage");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "samples", PROP_INT, PROP_NONE);
 +      RNA_def_property_ui_text(prop, "Samples", "Number of samples");
 +      RNA_def_property_range(prop, 1, 500);
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
  
 -      /* custom passes flags */
 -      prop = RNA_def_property(srna, "use_pass_ambient_occlusion", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_AO);
 -      RNA_def_property_ui_text(prop, "AO", "Add ambient occlusion contribution");
 +      prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
 +      RNA_def_property_ui_text(prop, "Color", "Color for screen space ambient occlusion effect");
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +}
  
 -      prop = RNA_def_property(srna, "use_pass_emit", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_EMIT);
 -      RNA_def_property_ui_text(prop, "Emit", "Add emission contribution");
  
 -      prop = RNA_def_property(srna, "use_pass_direct", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_DIRECT);
 -      RNA_def_property_ui_text(prop, "Direct", "Add direct lighting contribution");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +static void rna_def_gpu_fx(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
  
 -      prop = RNA_def_property(srna, "use_pass_indirect", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_INDIRECT);
 -      RNA_def_property_ui_text(prop, "Indirect", "Add indirect lighting contribution");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      rna_def_gpu_ssao_fx(brna);
 +      rna_def_gpu_dof_fx(brna);
  
 -      prop = RNA_def_property(srna, "use_pass_color", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_COLOR);
 -      RNA_def_property_ui_text(prop, "Color", "Color the pass");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      srna = RNA_def_struct(brna, "GPUFXSettings", NULL);
 +      RNA_def_struct_ui_text(srna, "GPU FX Settings", "Settings for GPU based compositing");
 +      RNA_def_struct_ui_icon(srna, ICON_RENDERLAYERS);
  
 -      prop = RNA_def_property(srna, "use_pass_diffuse", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_DIFFUSE);
 -      RNA_def_property_ui_text(prop, "Diffuse", "Add diffuse contribution");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "dof", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_flag(prop, PROP_NEVER_NULL);
 +      RNA_def_property_struct_type(prop, "GPUDOFSettings");
 +      RNA_def_property_ui_text(prop, "Depth Of Field settings", "");
  
 -      prop = RNA_def_property(srna, "use_pass_glossy", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_GLOSSY);
 -      RNA_def_property_ui_text(prop, "Glossy", "Add glossy contribution");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "use_dof", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "fx_flag", GPU_FX_FLAG_DOF);
 +      RNA_def_property_ui_text(prop, "Depth Of Field",
 +                               "Use depth of field on viewport using the values from active camera");
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_GPUFXSettings_fx_update");
  
 -      prop = RNA_def_property(srna, "use_pass_transmission", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_TRANSM);
 -      RNA_def_property_ui_text(prop, "Transmission", "Add transmission contribution");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
  
 -      prop = RNA_def_property(srna, "use_pass_subsurface", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "pass_filter", R_BAKE_PASS_FILTER_SUBSURFACE);
 -      RNA_def_property_ui_text(prop, "Subsurface", "Add subsurface contribution");
 -      RNA_def_property_update(prop, NC_SCENE | ND_RENDER_OPTIONS, NULL);
 +      prop = RNA_def_property(srna, "ssao", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_flag(prop, PROP_NEVER_NULL);
 +      RNA_def_property_struct_type(prop, "GPUSSAOSettings");
 +      RNA_def_property_ui_text(prop, "Screen Space Ambient Occlusion settings", "");
  
 -      prop = RNA_def_property(srna, "pass_filter", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "pass_filter");
 -      RNA_def_property_enum_items(prop, rna_enum_bake_pass_filter_type_items);
 -      RNA_def_property_flag(prop, PROP_ENUM_FLAG);
 -      RNA_def_property_ui_text(prop, "Pass Filter",  "Passes to include in the active baking pass");
 -      RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      prop = RNA_def_property(srna, "use_ssao", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "fx_flag", GPU_FX_FLAG_SSAO);
 +      RNA_def_property_ui_text(prop, "SSAO", "Use screen space ambient occlusion of field on viewport");
 +      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_GPUFXSettings_fx_update");
  }
  
 -static void rna_def_scene_game_data(BlenderRNA *brna)
 +/* Render Layers and Collections */
 +
 +static void rna_def_scene_collections(BlenderRNA *brna, PropertyRNA *cprop)
  {
        StructRNA *srna;
 -      PropertyRNA *prop;
 -
 -      static EnumPropertyItem aasamples_items[] = {
 -              {0, "SAMPLES_0", 0, "Off", ""},
 -              {2, "SAMPLES_2", 0, "2x", ""},
 -              {4, "SAMPLES_4", 0, "4x", ""},
 -              {8, "SAMPLES_8", 0, "8x", ""},
 -              {16, "SAMPLES_16", 0, "16x", ""},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 -
 -      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_SCALE, "SCALE", 0, "Scale", "Stretch or squeeze the viewport to fill the display window"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 -
 -      static EnumPropertyItem dome_modes_items[] = {
 -              {DOME_FISHEYE, "FISHEYE", 0, "Fisheye", ""},
 -              {DOME_TRUNCATED_FRONT, "TRUNCATED_FRONT", 0, "Front-Truncated", ""},
 -              {DOME_TRUNCATED_REAR, "TRUNCATED_REAR", 0, "Rear-Truncated", ""},
 -              {DOME_ENVMAP, "ENVMAP", 0, "Cube Map", ""},
 -              {DOME_PANORAM_SPH, "PANORAM_SPH", 0, "Spherical Panoramic", ""},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 -              
 -      static EnumPropertyItem stereo_modes_items[] = {
 -              {STEREO_QUADBUFFERED, "QUADBUFFERED", 0, "Quad-Buffer", ""},
 -              {STEREO_ABOVEBELOW, "ABOVEBELOW", 0, "Above-Below", ""},
 -              {STEREO_INTERLACED, "INTERLACED", 0, "Interlaced", ""},
 -              {STEREO_ANAGLYPH, "ANAGLYPH", 0, "Anaglyph", ""},
 -              {STEREO_SIDEBYSIDE, "SIDEBYSIDE", 0, "Side-by-side", ""},
 -              {STEREO_VINTERLACE, "VINTERLACE", 0, "Vinterlace", ""},
 -              {STEREO_3DTVTOPBOTTOM, "3DTVTOPBOTTOM", 0, "3DTV Top-Bottom", ""},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 -              
 -      static EnumPropertyItem stereo_items[] = {
 -              {STEREO_NOSTEREO, "NONE", 0, "None", "Disable Stereo and Dome environments"},
 -              {STEREO_ENABLED, "STEREO", 0, "Stereo", "Enable Stereo environment"},
 -              {STEREO_DOME, "DOME", 0, "Dome", "Enable Dome environment"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +      FunctionRNA *func;
 +      PropertyRNA *parm;
  
 -      static EnumPropertyItem physics_engine_items[] = {
 -              {WOPHY_NONE, "NONE", 0, "None", "Don't use a physics engine"},
 -              {WOPHY_BULLET, "BULLET", 0, "Bullet", "Use the Bullet physics engine"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +      RNA_def_property_srna(cprop, "SceneCollections");
 +      srna = RNA_def_struct(brna, "SceneCollections", NULL);
 +      RNA_def_struct_sdna(srna, "SceneCollection");
 +      RNA_def_struct_ui_text(srna, "Scene Collection", "Collection of scene collections");
  
 -      static EnumPropertyItem material_items[] = {
 -              {GAME_MAT_MULTITEX, "MULTITEXTURE", 0, "Multitexture", "Multitexture materials"},
 -              {GAME_MAT_GLSL, "GLSL", 0, "GLSL", "OpenGL shading language shaders"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +      func = RNA_def_function(srna, "new", "rna_SceneCollection_new");
 +      RNA_def_function_ui_description(func, "Add a collection to scene");
 +      RNA_def_function_flag(func, FUNC_USE_SELF_ID);
 +      parm = RNA_def_string(func, "name", "SceneCollection", 0, "", "New name for the collection (not unique)");
 +      RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
 +      parm = RNA_def_pointer(func, "result", "SceneCollection", "", "Newly created collection");
 +      RNA_def_function_return(func, parm);
  
 -      static EnumPropertyItem obstacle_simulation_items[] = {
 -              {OBSTSIMULATION_NONE, "NONE", 0, "None", ""},
 -              {OBSTSIMULATION_TOI_rays, "RVO_RAYS", 0, "RVO (rays)", ""},
 -              {OBSTSIMULATION_TOI_cells, "RVO_CELLS", 0, "RVO (cells)", ""},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +      func = RNA_def_function(srna, "remove", "rna_SceneCollection_remove");
 +      RNA_def_function_ui_description(func, "Remove a collection layer");
 +      RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
 +      parm = RNA_def_pointer(func, "layer", "SceneCollection", "", "Collection to remove");
 +      RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
 +      RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
 +}
  
 -      static EnumPropertyItem vsync_items[] = {
 -              {VSYNC_OFF, "OFF", 0, "Off", "Disable vsync"},
 -              {VSYNC_ON, "ON", 0, "On", "Enable vsync"},
 -              {VSYNC_ADAPTIVE, "ADAPTIVE", 0, "Adaptive", "Enable adaptive vsync (if supported)"},
 -              {0, NULL, 0, NULL, NULL}
 -      };
 +static void rna_def_collection_objects(BlenderRNA *brna, PropertyRNA *cprop)
 +{
 +      StructRNA *srna;
 +      FunctionRNA *func;
 +      PropertyRNA *parm;
 +      PropertyRNA *prop;
  
 -      static EnumPropertyItem storage_items[] = {
 -              {RAS_STORE_AUTO, "AUTO", 0, "Auto Select", "Choose the best supported mode"},
 -              {RAS_STORE_VA, "VERTEX_ARRAY", 0, "Vertex Arrays", "Usually the best choice (good performance with display lists)"},
 -              {RAS_STORE_VBO, "VERTEX_BUFFER_OBJECT", 0, "Vertex Buffer Objects",
 -                              "Typically slower than vertex arrays with display lists, requires at least OpenGL 1.4"},
 -              {0, NULL, 0, NULL, NULL}};
 +      RNA_def_property_srna(cprop, "CollectionObjects");
 +      srna = RNA_def_struct(brna, "CollectionObjects", NULL);
 +      RNA_def_struct_sdna(srna, "SceneCollection");
 +      RNA_def_struct_ui_text(srna, "Collection Objects", "Objects of a collection");
  
 -      srna = RNA_def_struct(brna, "SceneGameData", NULL);
 -      RNA_def_struct_sdna(srna, "GameData");
 -      RNA_def_struct_nested(brna, srna, "Scene");
 -      RNA_def_struct_ui_text(srna, "Game Data", "Game data for a Scene data-block");
 -      
 -      prop = RNA_def_property(srna, "resolution_x", PROP_INT, PROP_PIXEL);
 -      RNA_def_property_int_sdna(prop, NULL, "xplay");
 -      RNA_def_property_range(prop, 4, 10000);
 -      RNA_def_property_int_default(prop, 640);
 -      RNA_def_property_ui_text(prop, "Resolution X", "Number of horizontal pixels in the screen");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 -      
 -      prop = RNA_def_property(srna, "resolution_y", PROP_INT, PROP_PIXEL);
 -      RNA_def_property_int_sdna(prop, NULL, "yplay");
 -      RNA_def_property_range(prop, 4, 10000);
 -      RNA_def_property_int_default(prop, 480);
 -      RNA_def_property_ui_text(prop, "Resolution Y", "Number of vertical pixels in the screen");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
 +      RNA_def_property_int_funcs(prop, "rna_SceneCollection_objects_active_index_get",
 +                                 "rna_SceneCollection_objects_active_index_set",
 +                                 "rna_SceneCollection_objects_active_index_range");
 +      RNA_def_property_ui_text(prop, "Active Object Index", "Active index in collection objects array");
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, NULL);
 +
 +      func = RNA_def_function(srna, "link", "rna_SceneCollection_object_link");
 +      RNA_def_function_ui_description(func, "Link an object to collection");
 +      RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN | FUNC_USE_REPORTS);
 +      parm = RNA_def_pointer(func, "object", "Object", "", "Object to add to collection");
 +      RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
  
 -      prop = RNA_def_property(srna, "vsync", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "vsync");
 -      RNA_def_property_enum_items(prop, vsync_items);
 -      RNA_def_property_ui_text(prop, "Vsync", "Change vsync settings");
 -      
 -      prop = RNA_def_property(srna, "samples", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "aasamples");
 -      RNA_def_property_enum_items(prop, aasamples_items);
 -      RNA_def_property_ui_text(prop, "AA Samples", "The number of AA Samples to use for MSAA");
 -      
 -      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_int_default(prop, 32);
 -      RNA_def_property_ui_text(prop, "Bits", "Display bit depth of full screen display");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      func = RNA_def_function(srna, "unlink", "rna_SceneCollection_object_unlink");
 +      RNA_def_function_ui_description(func, "Unlink object from collection");
 +      RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN | FUNC_USE_REPORTS);
 +      parm = RNA_def_pointer(func, "object", "Object", "", "Object to remove from collection");
 +      RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
 +}
  
 -      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, rna_enum_event_type_items);
 -      RNA_def_property_translation_context(prop, BLT_I18NCONTEXT_UI_EVENTS);
 -      RNA_def_property_enum_default(prop, ESCKEY);
 -      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);
 -      
 -      prop = RNA_def_property(srna, "raster_storage", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "raster_storage");
 -      RNA_def_property_enum_items(prop, storage_items);
 -      RNA_def_property_ui_text(prop, "Storage", "Set the storage mode used by the rasterizer");
 -      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_int_default(prop, 60);
 -      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, "playerflag", GAME_PLAYER_FULLSCREEN);
 -      RNA_def_property_ui_text(prop, "Fullscreen", "Start player in a new fullscreen display");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +static void rna_def_scene_collection(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
  
 -      prop = RNA_def_property(srna, "use_desktop", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "playerflag", GAME_PLAYER_DESKTOP_RESOLUTION);
 -      RNA_def_property_ui_text(prop, "Desktop", "Use the current desktop resolution in fullscreen mode");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      srna = RNA_def_struct(brna, "SceneCollection", NULL);
 +      RNA_def_struct_ui_text(srna, "Scene Collection", "Collection");
  
 -      /* Framing */
 -      prop = RNA_def_property(srna, "frame_type", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "framing.type");
 -      RNA_def_property_enum_items(prop, framing_types_items);
 -      RNA_def_property_ui_text(prop, "Framing Types", "Select the type of Framing you want");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
 +      RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SceneCollection_name_set");
 +      RNA_def_property_ui_text(prop, "Name", "Collection name");
 +      RNA_def_struct_name_property(srna, prop);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, NULL);
  
 -      prop = RNA_def_property(srna, "frame_color", PROP_FLOAT, PROP_COLOR);
 -      RNA_def_property_float_sdna(prop, NULL, "framing.col");
 -      RNA_def_property_range(prop, 0.0f, 1.0f);
 -      RNA_def_property_array(prop, 3);
 -      RNA_def_property_ui_text(prop, "Framing Color", "Set color of the bars");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 -      
 -      /* Stereo */
 -      prop = RNA_def_property(srna, "stereo", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "stereoflag");
 -      RNA_def_property_enum_items(prop, stereo_items);
 -      RNA_def_property_ui_text(prop, "Stereo Options", "");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      prop = RNA_def_property(srna, "filter", PROP_STRING, PROP_NONE);
 +      RNA_def_property_string_funcs(prop, NULL, NULL, "rna_SceneCollection_filter_set");
 +      RNA_def_property_ui_text(prop, "Filter", "Filter to dynamically include objects based on their names (e.g., CHAR_*)");
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, NULL);
  
 -      prop = RNA_def_property(srna, "stereo_mode", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "stereomode");
 -      RNA_def_property_enum_items(prop, stereo_modes_items);
 -      RNA_def_property_enum_default(prop, STEREO_ANAGLYPH);
 -      RNA_def_property_ui_text(prop, "Stereo Mode", "Stereographic techniques");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      prop = RNA_def_property(srna, "collections", PROP_COLLECTION, PROP_NONE);
 +      RNA_def_property_collection_sdna(prop, NULL, "scene_collections", NULL);
 +      RNA_def_property_struct_type(prop, "SceneCollection");
 +      RNA_def_property_ui_text(prop, "SceneCollections", "");
 +      rna_def_scene_collections(brna, prop);
  
 -      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_float_default(prop, 0.1f);
 -      RNA_def_property_ui_text(prop, "Eye Separation",
 -                               "Set the distance between the eyes - the camera focal distance/30 should be fine");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 -      
 -      /* Dome */
 -      prop = RNA_def_property(srna, "dome_mode", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "dome.mode");
 -      RNA_def_property_enum_items(prop, dome_modes_items);
 -      RNA_def_property_ui_text(prop, "Dome Mode", "Dome physical configurations");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 -      
 -      prop = RNA_def_property(srna, "dome_tessellation", PROP_INT, PROP_NONE);
 -      RNA_def_property_int_sdna(prop, NULL, "dome.res");
 -      RNA_def_property_ui_range(prop, 1, 8, 1, 1);
 -      RNA_def_property_int_default(prop, 4);
 -      RNA_def_property_ui_text(prop, "Tessellation", "Tessellation level - check the generated mesh in wireframe mode");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 -      
 -      prop = RNA_def_property(srna, "dome_buffer_resolution", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "dome.resbuf");
 -      RNA_def_property_ui_range(prop, 0.1, 1.0, 0.1, 2);
 -      RNA_def_property_float_default(prop, 1.0f);
 -      RNA_def_property_ui_text(prop, "Buffer Resolution", "Buffer Resolution - decrease it to increase speed");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 -      
 -      prop = RNA_def_property(srna, "dome_angle", PROP_INT, PROP_NONE);
 -      RNA_def_property_int_sdna(prop, NULL, "dome.angle");
 -      RNA_def_property_ui_range(prop, 90, 250, 1, 1);
 -      RNA_def_property_int_default(prop, 180);
 -      RNA_def_property_ui_text(prop, "Angle", "Field of View of the Dome - it only works in mode Fisheye and Truncated");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 -      
 -      prop = RNA_def_property(srna, "dome_tilt", PROP_INT, PROP_NONE);
 -      RNA_def_property_int_sdna(prop, NULL, "dome.tilt");
 -      RNA_def_property_ui_range(prop, -180, 180, 1, 1);
 -      RNA_def_property_ui_text(prop, "Tilt", "Camera rotation in horizontal axis");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 -      
 -      prop = RNA_def_property(srna, "dome_text", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_pointer_sdna(prop, NULL, "dome.warptext");
 -      RNA_def_property_struct_type(prop, "Text");
 -      RNA_def_property_flag(prop, PROP_EDITABLE);
 -      RNA_def_property_ui_text(prop, "Warp Data", "Custom Warp Mesh data file");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 -      
 -      /* physics */
 -      prop = RNA_def_property(srna, "physics_engine", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "physicsEngine");
 -      RNA_def_property_enum_items(prop, physics_engine_items);
 -      RNA_def_property_enum_default(prop, WOPHY_BULLET);
 -      RNA_def_property_ui_text(prop, "Physics Engine", "Physics engine used for physics simulation in the game engine");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      prop = RNA_def_property(srna, "objects", PROP_COLLECTION, PROP_NONE);
 +      RNA_def_property_collection_sdna(prop, NULL, "objects", NULL);
 +      RNA_def_property_struct_type(prop, "Object");
 +      RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, "rna_SceneCollection_objects_get", NULL, NULL, NULL, NULL);
 +      RNA_def_property_ui_text(prop, "Objects", "All the objects directly added to this collection (not including sub-collection objects)");
 +      rna_def_collection_objects(brna, prop);
  
 -      prop = RNA_def_property(srna, "physics_gravity", PROP_FLOAT, PROP_ACCELERATION);
 -      RNA_def_property_float_sdna(prop, NULL, "gravity");
 -      RNA_def_property_ui_range(prop, 0.0, 25.0, 1, 2);
 -      RNA_def_property_range(prop, 0.0, 10000.0);
 -      RNA_def_property_float_default(prop, 9.8f);
 -      RNA_def_property_ui_text(prop, "Physics Gravity",
 -                               "Gravitational constant used for physics simulation in the game engine");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      prop = RNA_def_property(srna, "filters_objects", PROP_COLLECTION, PROP_NONE);
 +      RNA_def_property_collection_sdna(prop, NULL, "filter_objects", NULL);
 +      RNA_def_property_struct_type(prop, "Object");
 +      RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, "rna_SceneCollection_objects_get", NULL, NULL, NULL, NULL);
 +      RNA_def_property_ui_text(prop, "Filter Objects", "All the objects dynamically added to this collection via the filter");
 +}
  
 -      prop = RNA_def_property(srna, "occlusion_culling_resolution", PROP_INT, PROP_PIXEL);
 -      RNA_def_property_int_sdna(prop, NULL, "occlusionRes");
 -      RNA_def_property_range(prop, 128.0, 1024.0);
 -      RNA_def_property_int_default(prop, 128);
 -      RNA_def_property_ui_text(prop, "Occlusion Resolution",
 -                               "Size of the occlusion buffer, use higher value for better precision (slower)");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +static void rna_def_layer_collection_override(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
  
 -      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, 10000);
 -      RNA_def_property_int_default(prop, 60);
 -      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);
 +      srna = RNA_def_struct(brna, "LayerCollectionOverride", NULL);
 +      RNA_def_struct_sdna(srna, "CollectionOverride");
 +      RNA_def_struct_ui_text(srna, "Collection Override", "Collection Override");
  
 -      prop = RNA_def_property(srna, "logic_step_max", PROP_INT, PROP_NONE);
 -      RNA_def_property_int_sdna(prop, NULL, "maxlogicstep");
 -      RNA_def_property_range(prop, 1, 10000);
 -      RNA_def_property_ui_range(prop, 1, 50, 1, 1);
 -      RNA_def_property_int_default(prop, 5);
 -      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, "name", PROP_STRING, PROP_NONE);
 +      RNA_def_property_ui_text(prop, "Name", "Collection name");
 +      RNA_def_struct_name_property(srna, prop);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, NULL);
 +}
  
 -      prop = RNA_def_property(srna, "physics_step_max", PROP_INT, PROP_NONE);
 -      RNA_def_property_int_sdna(prop, NULL, "maxphystep");
 -      RNA_def_property_range(prop, 1, 10000);
 -      RNA_def_property_ui_range(prop, 1, 50, 1, 1);
 -      RNA_def_property_int_default(prop, 5);
 -      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);
 +#define RNA_LAYER_ENGINE_USE(_ENGINE_, _NAME_)                              \
 +      prop = RNA_def_property(srna, #_NAME_"_use", PROP_BOOLEAN, PROP_NONE);    \
 +      RNA_def_property_boolean_funcs(prop,                                      \
 +          "rna_LayerEngineSettings_"#_ENGINE_"_"#_NAME_"_use_get",              \
 +          "rna_LayerEngineSettings_"#_ENGINE_"_"#_NAME_"_use_set");             \
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);                         \
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_CollectionEngineSettings_update");
  
 -      prop = RNA_def_property(srna, "physics_step_sub", PROP_INT, PROP_NONE);
 -      RNA_def_property_int_sdna(prop, NULL, "physubstep");
 -      RNA_def_property_range(prop, 1, 50);
 -      RNA_def_property_ui_range(prop, 1, 5, 1, 1);
 -      RNA_def_property_int_default(prop, 1);
 -      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);
 +#define RNA_LAYER_ENGINE_CLAY_USE(_NAME_) \
 +      RNA_LAYER_ENGINE_USE(Clay, _NAME_)
  
 -      prop = RNA_def_property(srna, "deactivation_linear_threshold", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "lineardeactthreshold");
 -      RNA_def_property_ui_range(prop, 0.001, 10000.0, 2, 3);
 -      RNA_def_property_range(prop, 0.001, 10000.0);
 -      RNA_def_property_float_default(prop, 0.8f);
 -      RNA_def_property_ui_text(prop, "Deactivation Linear Threshold",
 -                               "Linear velocity that an object must be below before the deactivation timer can start");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +#define RNA_LAYER_MODE_OBJECT_USE(_NAME_) \
 +      RNA_LAYER_ENGINE_USE(ObjectMode, _NAME_)
  
 -      prop = RNA_def_property(srna, "deactivation_angular_threshold", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "angulardeactthreshold");
 -      RNA_def_property_ui_range(prop, 0.001, 10000.0, 2, 3);
 -      RNA_def_property_range(prop, 0.001, 10000.0);
 -      RNA_def_property_float_default(prop, 1.0f);
 -      RNA_def_property_ui_text(prop, "Deactivation Angular Threshold",
 -                               "Angular velocity that an object must be below before the deactivation timer can start");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +#define RNA_LAYER_MODE_EDIT_USE(_NAME_) \
 +      RNA_LAYER_ENGINE_USE(EditMode, _NAME_)
  
 -      prop = RNA_def_property(srna, "deactivation_time", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_float_sdna(prop, NULL, "deactivationtime");
 -      RNA_def_property_ui_range(prop, 0.0, 60.0, 1, 1);
 -      RNA_def_property_range(prop, 0.0, 60.0);
 -      RNA_def_property_ui_text(prop, "Deactivation Time",
 -                               "Amount of time (in seconds) after which objects with a velocity less than the given "
 -                               "threshold will deactivate (0.0 means no deactivation)");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +static void rna_def_layer_collection_engine_settings_clay(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
  
 -      /* mode */
 -      /* not used  *//* deprecated !!!!!!!!!!!!! */
 -      prop = RNA_def_property(srna, "use_occlusion_culling", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "mode", WO_DBVT_CULLING);
 -      RNA_def_property_ui_text(prop, "DBVT Culling",
 -                               "Use optimized Bullet DBVT tree for view frustum and occlusion culling (more efficient, "
 -                               "but it can waste unnecessary CPU if the scene doesn't have occluder objects)");
 -      
 -      /* not used  *//* deprecated !!!!!!!!!!!!! */
 -      prop = RNA_def_property(srna, "use_activity_culling", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "mode", WO_ACTIVITY_CULLING);
 -      RNA_def_property_ui_text(prop, "Activity Culling", "Activity culling is enabled");
 +      static EnumPropertyItem clay_matcap_items[] = {
 +          {ICON_MATCAP_01, "01", ICON_MATCAP_01, "", ""},
 +          {ICON_MATCAP_02, "02", ICON_MATCAP_02, "", ""},
 +          {ICON_MATCAP_03, "03", ICON_MATCAP_03, "", ""},
 +          {ICON_MATCAP_04, "04", ICON_MATCAP_04, "", ""},
 +          {ICON_MATCAP_05, "05", ICON_MATCAP_05, "", ""},
 +          {ICON_MATCAP_06, "06", ICON_MATCAP_06, "", ""},
 +          {ICON_MATCAP_07, "07", ICON_MATCAP_07, "", ""},
 +          {ICON_MATCAP_08, "08", ICON_MATCAP_08, "", ""},
 +          {ICON_MATCAP_09, "09", ICON_MATCAP_09, "", ""},
 +          {ICON_MATCAP_10, "10", ICON_MATCAP_10, "", ""},
 +          {ICON_MATCAP_11, "11", ICON_MATCAP_11, "", ""},
 +          {ICON_MATCAP_12, "12", ICON_MATCAP_12, "", ""},
 +          {ICON_MATCAP_13, "13", ICON_MATCAP_13, "", ""},
 +          {ICON_MATCAP_14, "14", ICON_MATCAP_14, "", ""},
 +          {ICON_MATCAP_15, "15", ICON_MATCAP_15, "", ""},
 +          {ICON_MATCAP_16, "16", ICON_MATCAP_16, "", ""},
 +          {ICON_MATCAP_17, "17", ICON_MATCAP_17, "", ""},
 +          {ICON_MATCAP_18, "18", ICON_MATCAP_18, "", ""},
 +          {ICON_MATCAP_19, "19", ICON_MATCAP_19, "", ""},
 +          {ICON_MATCAP_20, "20", ICON_MATCAP_20, "", ""},
 +          {ICON_MATCAP_21, "21", ICON_MATCAP_21, "", ""},
 +          {ICON_MATCAP_22, "22", ICON_MATCAP_22, "", ""},
 +          {ICON_MATCAP_23, "23", ICON_MATCAP_23, "", ""},
 +          {ICON_MATCAP_24, "24", ICON_MATCAP_24, "", ""},
 +          {0, NULL, 0, NULL, NULL}
 +      };
  
 -      /* not used  *//* deprecated !!!!!!!!!!!!! */
 -      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)");
 +      static EnumPropertyItem clay_matcap_type[] = {
 +          {CLAY_MATCAP_NONE, "NONE", 0, "Scene", "Use default scene matcap"},
 +          {CLAY_MATCAP_SIMPLE, "SIMPLE", 0, "Simple", "Let you choose the texture to use with the default settings"},
 +          {CLAY_MATCAP_COMPLETE, "COMPLETE", 0, "Complete", "Expose all settings"},
 +          {0, NULL, 0, NULL, NULL}
 +      };
  
 -      /* booleans */
 -      prop = RNA_def_property(srna, "show_debug_properties", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_SHOW_DEBUG_PROPS);
 -      RNA_def_property_ui_text(prop, "Show Debug Properties",
 -                               "Show properties marked for debugging while the game runs");
 +      srna = RNA_def_struct(brna, "CollectionEngineSettingsClay", NULL);
 +      RNA_def_struct_sdna(srna, "CollectionEngineSettings");
 +      RNA_def_struct_ui_text(srna, "Collections Clay Engine Settings", "Engine specific settings for this collection");
  
 -      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");
 +      prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
 +      RNA_def_property_ui_text(prop, "Name", "Engine name");
 +      RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      RNA_def_struct_name_property(srna, prop);
  
 -      prop = RNA_def_property(srna, "show_physics_visualization", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_SHOW_PHYSICS);
 -      RNA_def_property_ui_text(prop, "Show Physics Visualization",
 -                               "Show a visualization of physics bounds and interactions");
 +      /* see RNA_LAYER_ENGINE_GET_SET macro */
  
 -      prop = RNA_def_property(srna, "show_mouse", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_SHOW_MOUSE);
 -      RNA_def_property_ui_text(prop, "Show Mouse", "Start player with a visible mouse cursor");
 +      prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_funcs(prop, "rna_LayerEngineSettings_Clay_type_get", "rna_LayerEngineSettings_Clay_type_set", NULL);
 +      RNA_def_property_enum_items(prop, clay_matcap_type);
 +      RNA_def_property_ui_text(prop, "Settings Type", "What settings to use for this material");
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_CollectionEngineSettings_update");
 +      RNA_LAYER_ENGINE_CLAY_USE(type)
  
 -      prop = RNA_def_property(srna, "use_frame_rate", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_ENABLE_ALL_FRAMES);
 -      RNA_def_property_ui_text(prop, "Use Frame Rate",
 -                               "Respect the frame rate from the Physics panel in the world properties "
 -                               "rather than rendering as many frames as possible");
 +      prop = RNA_def_property(srna, "matcap_icon", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_funcs(prop, "rna_LayerEngineSettings_Clay_matcap_icon_get", "rna_LayerEngineSettings_Clay_matcap_icon_set", NULL);
 +      RNA_def_property_enum_items(prop, clay_matcap_items);
 +      RNA_def_property_ui_text(prop, "Matcap", "Image to use for Material Capture by this material");
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_CollectionEngineSettings_update");
 +      RNA_LAYER_ENGINE_CLAY_USE(matcap_icon)
  
 -      prop = RNA_def_property(srna, "use_display_lists", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_DISPLAY_LISTS);
 -      RNA_def_property_ui_text(prop, "Display Lists",
 -                               "Use display lists to speed up rendering by keeping geometry on the GPU");
 +      prop = RNA_def_property(srna, "matcap_rotation", PROP_FLOAT, PROP_FACTOR);
 +      RNA_def_property_float_funcs(prop, "rna_LayerEngineSettings_Clay_matcap_rotation_get", "rna_LayerEngineSettings_Clay_matcap_rotation_set", NULL);
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Matcap Rotation", "Orientation of the matcap on the model");
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_CollectionEngineSettings_update");
 +      RNA_LAYER_ENGINE_CLAY_USE(matcap_rotation)
  
 -      prop = RNA_def_property(srna, "use_deprecation_warnings", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_IGNORE_DEPRECATION_WARNINGS);
 -      RNA_def_property_ui_text(prop, "Deprecation Warnings",
 -                               "Print warnings when using deprecated features in the python API");
 +      prop = RNA_def_property(srna, "matcap_hue", PROP_FLOAT, PROP_FACTOR);
 +      RNA_def_property_float_funcs(prop, "rna_LayerEngineSettings_Clay_matcap_hue_get", "rna_LayerEngineSettings_Clay_matcap_hue_set", NULL);
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Matcap Hue shift", "Hue correction of the matcap");
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_CollectionEngineSettings_update");
 +      RNA_LAYER_ENGINE_CLAY_USE(matcap_hue)
  
 -      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 F-Curves");
 +      prop = RNA_def_property(srna, "matcap_saturation", PROP_FLOAT, PROP_FACTOR);
 +      RNA_def_property_float_funcs(prop, "rna_LayerEngineSettings_Clay_matcap_saturation_get", "rna_LayerEngineSettings_Clay_matcap_saturation_set", NULL);
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Matcap Saturation", "Saturation correction of the matcap");
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_CollectionEngineSettings_update");
 +      RNA_LAYER_ENGINE_CLAY_USE(matcap_saturation)
  
 -      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");
 -      RNA_def_property_ui_text(prop, "Auto Start", "Automatically start game at load time");
 +      prop = RNA_def_property(srna, "matcap_value", PROP_FLOAT, PROP_FACTOR);
 +      RNA_def_property_float_funcs(prop, "rna_LayerEngineSettings_Clay_matcap_value_get", "rna_LayerEngineSettings_Clay_matcap_value_set", NULL);
 +      RNA_def_property_range(prop, 0.0f, 1.0f);
 +      RNA_def_property_ui_text(prop, "Matcap Value", "Value correction of the matcap");
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_CollectionEngineSettings_update");
 +      RNA_LAYER_ENGINE_CLAY_USE(matcap_value)
  
 -      prop = RNA_def_property(srna, "use_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)");
 -      
 -      /* materials */
 -      prop = RNA_def_property(srna, "material_mode", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "matmode");
 -      RNA_def_property_enum_items(prop, material_items);
 -      RNA_def_property_ui_text(prop, "Material Mode", "Material mode to use for rendering");
 -      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, NULL);
 +      prop = RNA_def_property(srna, "ssao_factor_cavity", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_funcs(prop, "rna_LayerEngineSettings_Clay_ssao_factor_cavity_get", "rna_LayerEngineSettings_Clay_ssao_factor_cavity_set", NULL);
 +      RNA_def_property_ui_text(prop, "Cavity Strength", "Strength of the Cavity effect");
 +      RNA_def_property_range(prop, 0.0f, 250.0f);
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_CollectionEngineSettings_update");
 +      RNA_LAYER_ENGINE_CLAY_USE(ssao_factor_cavity)
  
 -      prop = RNA_def_property(srna, "use_glsl_lights", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_LIGHTS);
 -      RNA_def_property_ui_text(prop, "GLSL Lights", "Use lights for GLSL rendering");
 -      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
 +      prop = RNA_def_property(srna, "ssao_factor_edge", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_funcs(prop, "rna_LayerEngineSettings_Clay_ssao_factor_edge_get", "rna_LayerEngineSettings_Clay_ssao_factor_edge_set", NULL);
 +      RNA_def_property_ui_text(prop, "Edge Strength", "Strength of the Edge effect");
 +      RNA_def_property_range(prop, 0.0f, 250.0f);
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_CollectionEngineSettings_update");
 +      RNA_LAYER_ENGINE_CLAY_USE(ssao_factor_edge)
  
 -      prop = RNA_def_property(srna, "use_glsl_shaders", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_SHADERS);
 -      RNA_def_property_ui_text(prop, "GLSL Shaders", "Use shaders for GLSL rendering");
 -      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
 +      prop = RNA_def_property(srna, "ssao_distance", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_funcs(prop, "rna_LayerEngineSettings_Clay_ssao_distance_get", "rna_LayerEngineSettings_Clay_ssao_distance_set", NULL);
 +      RNA_def_property_ui_text(prop, "Distance", "Distance of object that contribute to the Cavity/Edge effect");
 +      RNA_def_property_range(prop, 0.0f, 100000.0f);
 +      RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3);
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_CollectionEngineSettings_update");
 +      RNA_LAYER_ENGINE_CLAY_USE(ssao_distance)
  
 -      prop = RNA_def_property(srna, "use_glsl_shadows", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_SHADOWS);
 -      RNA_def_property_ui_text(prop, "GLSL Shadows", "Use shadows for GLSL rendering");
 -      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
 +      prop = RNA_def_property(srna, "ssao_attenuation", PROP_FLOAT, PROP_NONE);
 +      RNA_def_property_float_funcs(prop, "rna_LayerEngineSettings_Clay_ssao_attenuation_get", "rna_LayerEngineSettings_Clay_ssao_attenuation_set", NULL);
 +      RNA_def_property_ui_text(prop, "Attenuation", "Attenuation constant");
 +      RNA_def_property_range(prop, 1.0f, 100000.0f);
 +      RNA_def_property_ui_range(prop, 1.0f, 100.0f, 1, 3);
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_CollectionEngineSettings_update");
 +      RNA_LAYER_ENGINE_CLAY_USE(ssao_attenuation)
 +}
  
 -      prop = RNA_def_property(srna, "use_glsl_ramps", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_RAMPS);
 -      RNA_def_property_ui_text(prop, "GLSL Ramps", "Use ramps for GLSL rendering");
 -      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
 +static void rna_def_layer_collection_engine_settings(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
  
 -      prop = RNA_def_property(srna, "use_glsl_nodes", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_NODES);
 -      RNA_def_property_ui_text(prop, "GLSL Nodes", "Use nodes for GLSL rendering");
 -      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
 +      srna = RNA_def_struct(brna, "CollectionEngineSettings", NULL);
 +      RNA_def_struct_ui_text(srna, "Collections Engine Settings", "Engine specific settings for this collection");
 +      RNA_def_struct_refine_func(srna, "rna_CollectionEngineSettings_refine");
  
 -      prop = RNA_def_property(srna, "use_glsl_color_management", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_COLOR_MANAGEMENT);
 -      RNA_def_property_ui_text(prop, "GLSL Color Management", "Use color management for GLSL rendering");
 -      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
 +      prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
 +      RNA_def_property_ui_text(prop, "Name", "Engine name");
 +      RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +      RNA_def_struct_name_property(srna, prop);
  
 -      prop = RNA_def_property(srna, "use_glsl_extra_textures", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_EXTRA_TEX);
 -      RNA_def_property_ui_text(prop, "GLSL Extra Textures",
 -                               "Use extra textures like normal or specular maps for GLSL rendering");
 -      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
 +      /* the engine specific structs */
 +      rna_def_layer_collection_engine_settings_clay(brna);
 +}
  
 -      prop = RNA_def_property(srna, "use_glsl_environment_lighting", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_GLSL_NO_ENV_LIGHTING);
 -      RNA_def_property_ui_text(prop, "GLSL Environment Lighting", "Use environment lighting for GLSL rendering");
 -      RNA_def_property_update(prop, NC_SCENE | NA_EDITED, "rna_Scene_glsl_update");
 +static void rna_def_layer_collection_mode_settings_object(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
  
 -      prop = RNA_def_property(srna, "use_material_caching", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GAME_NO_MATERIAL_CACHING);
 -      RNA_def_property_ui_text(prop, "Use Material Caching",
 -                               "Cache materials in the converter (this is faster, but can cause problems with older "
 -                               "Singletexture and Multitexture games)");
 +      srna = RNA_def_struct(brna, "CollectionModeSettingsObject", NULL);
 +      RNA_def_struct_sdna(srna, "CollectionEngineSettings");
 +      RNA_def_struct_ui_text(srna, "Collections Object Mode Settings", "Object Mode specific settings for this collection");
 +
 +      /* see RNA_LAYER_ENGINE_GET_SET macro */
 +
 +      prop = RNA_def_property(srna, "show_wire", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_ui_text(prop, "Wire", "Add the object's wireframe over solid drawing");
 +      RNA_def_property_boolean_funcs(prop, "rna_LayerEngineSettings_ObjectMode_show_wire_get", "rna_LayerEngineSettings_ObjectMode_show_wire_set");
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_CollectionEngineSettings_update");
 +      RNA_LAYER_MODE_OBJECT_USE(show_wire)
 +
 +      prop = RNA_def_property(srna, "show_backface_culling", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_ui_text(prop, "Backface Culling", "");
 +      RNA_def_property_boolean_funcs(prop, "rna_LayerEngineSettings_ObjectMode_show_backface_culling_get", "rna_LayerEngineSettings_ObjectMode_show_backface_culling_set");
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_CollectionEngineSettings_update");
 +      RNA_LAYER_MODE_OBJECT_USE(show_backface_culling)
 +}
 +
 +static void rna_def_layer_collection_mode_settings_edit(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      srna = RNA_def_struct(brna, "CollectionModeSettingsEdit", NULL);
 +      RNA_def_struct_sdna(srna, "CollectionEngineSettings");
 +      RNA_def_struct_ui_text(srna, "Collections Edit Mode Settings", "Edit Mode specific settings for this collection");
 +
 +      /* see RNA_LAYER_ENGINE_GET_SET macro */
 +
 +      prop = RNA_def_property(srna, "show_occlude_wire", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_ui_text(prop, "Hidden Wire", "");
 +      RNA_def_property_boolean_funcs(prop, "rna_LayerEngineSettings_EditMode_show_occlude_wire_get", "rna_LayerEngineSettings_EditMode_show_occlude_wire_set");
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_CollectionEngineSettings_update");
 +      RNA_LAYER_MODE_EDIT_USE(show_occlude_wire)
 +}
 +
 +static void rna_def_layer_collection_mode_settings(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      srna = RNA_def_struct(brna, "CollectionModeSettings", NULL);
 +      RNA_def_struct_sdna(srna, "CollectionEngineSettings");
 +      RNA_def_struct_ui_text(srna, "Collections Mode Settings", "Mode specific settings for this collection");
 +      RNA_def_struct_refine_func(srna, "rna_CollectionModeSettings_refine");
 +
 +      prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_enum_sdna(prop, NULL, "type");
 +      RNA_def_property_enum_items(prop, rna_enum_layer_collection_mode_settings_type_items);
 +      RNA_def_property_ui_text(prop, "Type", "");
 +      RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 +
 +      /* the modes specific structs */
 +      rna_def_layer_collection_mode_settings_object(brna);
 +      rna_def_layer_collection_mode_settings_edit(brna);
 +}
 +
 +#undef RNA_LAYER_MODE_EDIT_USE
 +#undef RNA_LAYER_MODE_OBJECT_USE
 +#undef RNA_LAYER_ENGINE_CLAY_USE
 +#undef RNA_LAYER_ENGINE_USE
  
 -      /* obstacle simulation */
 -      prop = RNA_def_property(srna, "obstacle_simulation", PROP_ENUM, PROP_NONE);
 -      RNA_def_property_enum_sdna(prop, NULL, "obstacleSimulation");
 -      RNA_def_property_enum_items(prop, obstacle_simulation_items);
 -      RNA_def_property_ui_text(prop, "Obstacle simulation", "Simulation used for obstacle avoidance in the game engine");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +static void rna_def_layer_collection(BlenderRNA *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
  
 -      prop = RNA_def_property(srna, "level_height", PROP_FLOAT, PROP_ACCELERATION);
 -      RNA_def_property_float_sdna(prop, NULL, "levelHeight");
 -      RNA_def_property_range(prop, 0.0f, 200.0f);
 -      RNA_def_property_float_default(prop, 2.0f);
 -      RNA_def_property_ui_text(prop, "Level height",
 -                               "Max difference in heights of obstacles to enable their interaction");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      FunctionRNA *func;
 +      PropertyRNA *parm;
  
 -      prop = RNA_def_property(srna, "show_obstacle_simulation", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "flag", GAME_SHOW_OBSTACLE_SIMULATION);
 -      RNA_def_property_ui_text(prop, "Visualization", "Enable debug visualization for obstacle simulation");
 +      srna = RNA_def_struct(brna, "LayerCollection", NULL);
 +      RNA_def_struct_ui_text(srna, "Layer Collection", "Layer collection");
  
 -      /* Recast Settings */
 -      prop = RNA_def_property(srna, "recast_data", PROP_POINTER, PROP_NONE);
 +      prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
 +      RNA_def_property_string_funcs(prop, "rna_LayerCollection_name_get", "rna_LayerCollection_name_length", "rna_LayerCollection_name_set");
 +      RNA_def_property_ui_text(prop, "Name", "Collection name");
 +      RNA_def_struct_name_property(srna, prop);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, NULL);
 +
 +      prop = RNA_def_property(srna, "collection", PROP_POINTER, PROP_NONE);
        RNA_def_property_flag(prop, PROP_NEVER_NULL);
 -      RNA_def_property_pointer_sdna(prop, NULL, "recastData");
 -      RNA_def_property_struct_type(prop, "SceneGameRecastData");
 -      RNA_def_property_ui_text(prop, "Recast Data", "");
 +      RNA_def_property_pointer_sdna(prop, NULL, "scene_collection");
 +      RNA_def_property_struct_type(prop, "SceneCollection");
 +      RNA_def_property_ui_text(prop, "Collection", "Collection this layer collection is wrapping");
  
 -      /* Nestled Data  */
 -      rna_def_scene_game_recast_data(brna);
 +      prop = RNA_def_property(srna, "collections", PROP_COLLECTION, PROP_NONE);
 +      RNA_def_property_collection_sdna(prop, NULL, "layer_collections", NULL);
 +      RNA_def_property_struct_type(prop, "LayerCollection");
 +      RNA_def_property_ui_text(prop, "Layer Collections", "");
  
 -      /* LoD */
 -      prop = RNA_def_property(srna, "use_scene_hysteresis", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "lodflag", SCE_LOD_USE_HYST);
 -      RNA_def_property_ui_text(prop, "Hysteresis", "Use LoD Hysteresis setting for the scene");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      prop = RNA_def_property(srna, "objects", PROP_COLLECTION, PROP_NONE);
 +      RNA_def_property_collection_sdna(prop, NULL, "object_bases", NULL);
 +      RNA_def_property_struct_type(prop, "Object");
 +      RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, "rna_LayerCollection_objects_get", NULL, NULL, NULL, NULL);
 +      RNA_def_property_ui_text(prop, "Objects", "All the objects directly or indirectly added to this collection (not including sub-collection objects)");
 +
 +      prop = RNA_def_property(srna, "overrides", PROP_COLLECTION, PROP_NONE);
 +      RNA_def_property_collection_sdna(prop, NULL, "overrides", NULL);
 +      RNA_def_property_struct_type(prop, "LayerCollectionOverride");
 +      RNA_def_property_ui_text(prop, "Collection Overrides", "");
 +
 +      func = RNA_def_function(srna, "get_engine_settings", "rna_LayerCollection_engine_settings_get");
 +      RNA_def_function_ui_description(func, "Return the engine settings for this collection");
 +      RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_CONTEXT);
 +      parm = RNA_def_string(func, "engine", NO_ENGINE, MAX_NAME, "Engine", "use context one by default");
 +      RNA_def_parameter_clear_flags(parm, 0, PARM_REQUIRED);
 +      parm = RNA_def_pointer(func, "result", "CollectionEngineSettings", "", "");
 +      RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
 +      RNA_def_function_return(func, parm);
  
 -      prop = RNA_def_property(srna, "scene_hysteresis_percentage", PROP_INT, PROP_PERCENTAGE);
 -      RNA_def_property_int_sdna(prop, NULL, "scehysteresis");
 -      RNA_def_property_range(prop, 0, 100);
 -      RNA_def_property_ui_range(prop, 0, 100, 10, 1);
 -      RNA_def_property_int_default(prop, 10);
 -      RNA_def_property_ui_text(prop, "Hysteresis %",
 -                               "Minimum distance change required to transition to the previous level of detail");
 -      RNA_def_property_update(prop, NC_SCENE, NULL);
 +      func = RNA_def_function(srna, "get_mode_settings", "rna_LayerCollection_mode_settings_get");
 +      RNA_def_function_ui_description(func, "Return the mode settings for this collection");
 +      RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_CONTEXT);
 +      parm = RNA_def_enum(func, "type", rna_enum_layer_collection_mode_settings_type_items, COLLECTION_MODE_NONE, "Mode", "use context one by default");
 +      RNA_def_parameter_clear_flags(parm, 0, PARM_REQUIRED);
 +      parm = RNA_def_pointer(func, "result", "CollectionEngineSettings", "", "");
 +      RNA_def_parameter_flags(parm, 0, PARM_RNAPTR);
 +      RNA_def_function_return(func, parm);
 +
 +      /* Flags */
 +      prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", COLLECTION_VISIBLE);
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_ui_icon(prop, ICON_RESTRICT_VIEW_OFF, 1);
 +      RNA_def_property_ui_text(prop, "Hide", "Restrict visiblity");
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_LayerCollection_hide_update");
 +
 +      prop = RNA_def_property(srna, "hide_select", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", COLLECTION_SELECTABLE);
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_ui_icon(prop, ICON_RESTRICT_SELECT_OFF, 1);
 +      RNA_def_property_ui_text(prop, "Hide Selectable", "Restrict selection");
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_LayerCollection_hide_select_update");
 +
 +      prop = RNA_def_property(srna, "is_unfolded", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", COLLECTION_FOLDED);
 +      RNA_def_property_ui_icon(prop, ICON_RIGHTARROW, 1);
 +      RNA_def_property_ui_text(prop, "Folded", "Folded collection");
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, NULL);
 +
 +      /* TODO_LAYER_OVERRIDE */
  }
  
 -static void rna_def_gpu_dof_fx(BlenderRNA *brna)
 +static void rna_def_layer_collections(BlenderRNA *brna, PropertyRNA *cprop)
  {
        StructRNA *srna;
 +      FunctionRNA *func;
        PropertyRNA *prop;
 +      PropertyRNA *parm;
  
 -      srna = RNA_def_struct(brna, "GPUDOFSettings", NULL);
 -      RNA_def_struct_ui_text(srna, "GPU DOF", "Settings for GPU based depth of field");
 -      RNA_def_struct_ui_icon(srna, ICON_RENDERLAYERS);
 -      RNA_def_struct_path_func(srna, "rna_GPUDOF_path");
 +      RNA_def_property_srna(cprop, "LayerCollections");
 +      srna = RNA_def_struct(brna, "LayerCollections", NULL);
 +      RNA_def_struct_sdna(srna, "SceneLayer");
 +      RNA_def_struct_ui_text(srna, "Layer Collections", "Collections of render layer");
  
 -      prop = RNA_def_property(srna, "focus_distance", PROP_FLOAT, PROP_DISTANCE);
 -      RNA_def_property_ui_text(prop, "Focus distance", "Viewport depth of field focus distance");
 -      RNA_def_property_range(prop, 0.0f, FLT_MAX);
 -      RNA_def_property_ui_range(prop, 0.0f, 5000.0f, 1, 2);
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +      prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
 +      RNA_def_property_int_sdna(prop, NULL, "active_collection");
 +      RNA_def_property_int_funcs(prop, "rna_LayerCollections_active_collection_index_get",
 +                                 "rna_LayerCollections_active_collection_index_set",
 +                                 "rna_LayerCollections_active_collection_index_range");
 +      RNA_def_property_ui_text(prop, "Active Collection Index", "Active index in layer collection array");
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER, NULL);
  
 -      prop = RNA_def_property(srna, "focal_length", PROP_FLOAT, PROP_DISTANCE_CAMERA);
 -      RNA_def_property_ui_text(prop, "Focal Length", "Focal length for dof effect");
 -      RNA_def_property_range(prop, 1.0f, FLT_MAX);
 -      RNA_def_property_ui_range(prop, 1.0f, 5000.0f, 1, 2);
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +      prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_struct_type(prop, "LayerCollection");
 +      RNA_def_property_pointer_funcs(prop, "rna_LayerCollections_active_collection_get",
 +                                     "rna_LayerCollections_active_collection_set", NULL, NULL);
 +      RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_NULL);
 +      RNA_def_property_ui_text(prop, "Active Layer Collection", "Active Layer Collection");
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER, NULL);
  
 -      prop = RNA_def_property(srna, "sensor", PROP_FLOAT, PROP_DISTANCE_CAMERA);
 -      RNA_def_property_ui_text(prop, "Sensor", "Size of sensor");
 -      RNA_def_property_range(prop, 1.0f, FLT_MAX);
 -      RNA_def_property_ui_range(prop, 1.0f, 5000.0f, 1, 2);
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +      func = RNA_def_function(srna, "link", "rna_SceneLayer_collection_link");
 +      RNA_def_function_ui_description(func, "Link a collection to render layer");
 +      RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN);
 +      parm = RNA_def_pointer(func, "scene_collection", "SceneCollection", "", "Collection to add to render layer");
 +      RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
 +      parm = RNA_def_pointer(func, "result", "LayerCollection", "", "Newly created layer collection");
 +      RNA_def_function_return(func, parm);
  
 -      prop = RNA_def_property(srna, "fstop", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_ui_text(prop, "F-stop", "F-stop for dof effect");
 -      RNA_def_property_range(prop, 0.0f, FLT_MAX);
 -      RNA_def_property_ui_range(prop, 0.1f, 128.0f, 10, 1);
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +      func = RNA_def_function(srna, "unlink", "rna_SceneLayer_collection_unlink");
 +      RNA_def_function_ui_description(func, "Unlink a collection from render layer");
 +      RNA_def_function_flag(func, FUNC_USE_SELF_ID | FUNC_USE_MAIN | FUNC_USE_REPORTS);
 +      parm = RNA_def_pointer(func, "layer_collection", "LayerCollection", "", "Layer collection to remove from render layer");
 +      RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
 +}
  
 -      prop = RNA_def_property(srna, "blades", PROP_INT, PROP_NONE);
 -      RNA_def_property_int_sdna(prop, NULL, "num_blades");
 -      RNA_def_property_ui_text(prop, "Blades", "Blades for dof effect");
 -      RNA_def_property_range(prop, 0, 16);
 -      RNA_def_property_int_funcs(prop, NULL, "rna_GPUDOFSettings_blades_set", NULL);
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +static void rna_def_layer_objects(BlenderRNA *brna, PropertyRNA *cprop)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
  
 -      prop = RNA_def_property(srna, "use_high_quality", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "high_quality", 1);
 -      RNA_def_property_ui_text(prop, "High Quality", "Use high quality depth of field");
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +      RNA_def_property_srna(cprop, "LayerObjects");
 +      srna = RNA_def_struct(brna, "LayerObjects", NULL);
 +      RNA_def_struct_sdna(srna, "SceneLayer");
 +      RNA_def_struct_ui_text(srna, "Layer Objects", "Collections of objects");
  
 -      prop = RNA_def_property(srna, "is_hq_supported", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_funcs(prop, "rna_gpu_is_hq_supported_get", NULL);
 -      RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 -      RNA_def_property_ui_text(prop, "High Quality", "Use high quality depth of field");
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +      prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_struct_type(prop, "Object");
 +      RNA_def_property_pointer_funcs(prop, "rna_LayerObjects_active_object_get", "rna_LayerObjects_active_object_set", NULL, NULL);
 +      RNA_def_property_flag(prop, PROP_EDITABLE | PROP_NEVER_UNLINK);
 +      RNA_def_property_ui_text(prop, "Active Object", "Active object for this layer");
 +      /* Could call: ED_base_object_activate(C, rl->basact);
 +       * but would be a bad level call and it seems the notifier is enough */
 +      RNA_def_property_update(prop, NC_SCENE | ND_OB_ACTIVE, NULL);
 +
 +      prop = RNA_def_property(srna, "selected", PROP_COLLECTION, PROP_NONE);
 +      RNA_def_property_collection_sdna(prop, NULL, "object_bases", NULL);
 +      RNA_def_property_struct_type(prop, "Object");
 +      RNA_def_property_collection_funcs(prop, "rna_LayerObjects_selected_begin", "rna_iterator_listbase_next",
 +                                        "rna_iterator_listbase_end", "rna_SceneLayer_objects_get",
 +                                        NULL, NULL, NULL, NULL);
 +      RNA_def_property_ui_text(prop, "Selected Objects", "All the selected objects of this layer");
  }
  
 -static void rna_def_gpu_ssao_fx(BlenderRNA *brna)
 +static void rna_def_scene_layer(BlenderRNA *brna)
  {
        StructRNA *srna;
        PropertyRNA *prop;
  
 -      srna = RNA_def_struct(brna, "GPUSSAOSettings", NULL);
 -      RNA_def_struct_ui_text(srna, "GPU SSAO", "Settings for GPU based screen space ambient occlusion");
 +      static EnumPropertyItem engine_items[] = {
 +          {0, "BLENDER_RENDER", 0, "Blender Render", "Use the Blender internal rendering engine for rendering"},
 +          {0, NULL, 0, NULL, NULL}
 +      };
 +
 +      srna = RNA_def_struct(brna, "SceneLayer", NULL);
 +      RNA_def_struct_ui_text(srna, "Render Layer", "Render layer");
        RNA_def_struct_ui_icon(srna, ICON_RENDERLAYERS);
  
 -      prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_ui_text(prop, "Strength", "Strength of the SSAO effect");
 -      RNA_def_property_range(prop, 0.0f, 250.0f);
 -      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_funcs(prop, NULL, NULL, "rna_SceneLayer_name_set");
 +      RNA_def_property_ui_text(prop, "Name", "Render layer name");
 +      RNA_def_struct_name_property(srna, prop);
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, NULL);
  
 -      prop = RNA_def_property(srna, "distance_max", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_ui_text(prop, "Distance", "Distance of object that contribute to the SSAO effect");
 -      RNA_def_property_range(prop, 0.0f, 100000.0f);
 -      RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3);
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +      prop = RNA_def_property(srna, "collections", PROP_COLLECTION, PROP_NONE);
 +      RNA_def_property_collection_sdna(prop, NULL, "layer_collections", NULL);
 +      RNA_def_property_struct_type(prop, "LayerCollection");
 +      RNA_def_property_ui_text(prop, "Layer Collections", "");
 +      rna_def_layer_collections(brna, prop);
  
 -      prop = RNA_def_property(srna, "attenuation", PROP_FLOAT, PROP_NONE);
 -      RNA_def_property_ui_text(prop, "Attenuation", "Attenuation constant");
 -      RNA_def_property_range(prop, 1.0f, 100000.0f);
 -      RNA_def_property_ui_range(prop, 1.0f, 100.0f, 1, 3);
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +      prop = RNA_def_property(srna, "objects", PROP_COLLECTION, PROP_NONE);
 +      RNA_def_property_collection_sdna(prop, NULL, "object_bases", NULL);
 +      RNA_def_property_struct_type(prop, "Object");
 +      RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, "rna_SceneLayer_objects_get", NULL, NULL, NULL, NULL);
 +      RNA_def_property_ui_text(prop, "Objects", "All the objects in this layer");
 +      rna_def_layer_objects(brna, prop);
  
 -      prop = RNA_def_property(srna, "samples", PROP_INT, PROP_NONE);
 -      RNA_def_property_ui_text(prop, "Samples", "Number of samples");
 -      RNA_def_property_range(prop, 1, 500);
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 +      /* layer options */
 +      prop = RNA_def_property(srna, "use", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_sdna(prop, NULL, "flag", SCENE_LAYER_RENDER);
 +      RNA_def_property_ui_text(prop, "Enabled", "Disable or enable the render layer");
 +      RNA_def_property_update(prop, NC_SCENE | ND_LAYER, NULL);
  
 -      prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
 -      RNA_def_property_ui_text(prop, "Color", "Color for screen space ambient occlusion effect");
 -      RNA_def_property_range(prop, 0.0f, 1.0f);
 -      RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
 -}
 +      /* 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_SceneLayer_engine_get", "rna_SceneLayer_engine_set",
 +                                  "rna_SceneLayer_engine_itemf");
 +      RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 +      RNA_def_property_ui_text(prop, "Engine", "Engine to use for rendering");
 +      RNA_def_property_update(prop, NC_WINDOW, "rna_SceneLayer_engine_update");
  
 +      prop = RNA_def_property(srna, "has_multiple_engines", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_boolean_funcs(prop, "rna_SceneLayer_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");
 +}
  
 -static void rna_def_gpu_fx(BlenderRNA *brna)
 +static void rna_def_scene_layers(BlenderRNA *brna, PropertyRNA *cprop)
  {
        StructRNA *srna;
 +      FunctionRNA *func;
 +      PropertyRNA *parm;
        PropertyRNA *prop;
  
 -      rna_def_gpu_ssao_fx(brna);
 -      rna_def_gpu_dof_fx(brna);
 +      RNA_def_property_srna(cprop, "SceneLayers");
 +      srna = RNA_def_struct(brna, "SceneLayers", NULL);
 +      RNA_def_struct_sdna(srna, "Scene");
 +      RNA_def_struct_ui_text(srna, "Render Layers", "Collection of render layers");
  
 -      srna = RNA_def_struct(brna, "GPUFXSettings", NULL);
 -      RNA_def_struct_ui_text(srna, "GPU FX Settings", "Settings for GPU based compositing");
 -      RNA_def_struct_ui_icon(srna, ICON_RENDERLAYERS);
 +      prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
 +      RNA_def_property_int_sdna(prop, NULL, "active_layer");
 +      RNA_def_property_int_funcs(prop, "rna_SceneLayer_active_layer_index_get",
 +                                 "rna_SceneLayer_active_layer_index_set",
 +                                 "rna_SceneLayer_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_LAYER, NULL);
  
 -      prop = RNA_def_property(srna, "dof", PROP_POINTER, PROP_NONE);
 -      RNA_def_property_flag(prop, PROP_NEVER_NULL);
 -      RNA_def_property_struct_type(prop, "GPUDOFSettings");
 -      RNA_def_property_ui_text(prop, "Depth Of Field settings", "");
 +      prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_struct_type(prop, "SceneLayer");
 +      RNA_def_property_pointer_funcs(prop, "rna_SceneLayer_active_layer_get",
 +                                     "rna_SceneLayer_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_LAYER, NULL);
  
 -      prop = RNA_def_property(srna, "use_dof", PROP_BOOLEAN, PROP_NONE);
 -      RNA_def_property_boolean_sdna(prop, NULL, "fx_flag", GPU_FX_FLAG_DOF);
 -      RNA_def_property_ui_text(prop, "Depth Of Field",
 -                               "Use depth of field on viewport using the values from active