Merge branch 'master' into blender2.8
[blender.git] / source / blender / makesrna / intern / rna_scene.c
index 121e4f56a6e1fa4e7e28571522ab15be300b2426..86140eaaa05c9f23d5d5ef47b74553d96c199fee 100644 (file)
@@ -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"
 
@@ -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", ""},
@@ -431,6 +438,12 @@ EnumPropertyItem rna_enum_gpencil_interpolation_mode_items[] = {
        {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"
@@ -445,10 +458,12 @@ EnumPropertyItem rna_enum_gpencil_interpolation_mode_items[] = {
 #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"
@@ -606,11 +621,11 @@ static void rna_SpaceImageEditor_uv_sculpt_update(Main *bmain, Scene *scene, Poi
 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;
                }
        }
@@ -623,13 +638,13 @@ static PointerRNA rna_Scene_objects_get(CollectionPropertyIterator *iter)
        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);
@@ -660,7 +675,7 @@ static Base *rna_Scene_object_link(Scene *scene, bContext *C, ReportList *report
 
 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;
@@ -1728,7 +1743,7 @@ static void rna_Scene_use_nodes_update(bContext *C, PointerRNA *ptr)
 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);
@@ -1799,7 +1814,7 @@ static void rna_Scene_use_simplify_update(Main *bmain, Scene *UNUSED(scene), Poi
 {
        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))
@@ -1888,6 +1903,43 @@ static void rna_GameSettings_exit_key_set(PointerRNA *ptr, int value)
                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");
@@ -2206,2867 +2258,4095 @@ static int rna_gpu_is_hq_supported_get(PointerRNA *UNUSED(ptr))
        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 camera");
-       RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, "rna_GPUFXSettings_fx_update");
+       func = RNA_def_function(srna, "new", "rna_SceneLayer_new");
+       RNA_def_function_ui_description(func, "Add a render layer to scene");
+       RNA_def_function_flag(func, FUNC_USE_SELF_ID);
+       parm = RNA_def_string(func, "name", "SceneLayer", 0, "", "New name for the render layer (not unique)");
+       RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
+       parm = RNA_def_pointer(func, "result", "SceneLayer", "", "Newly created render layer");
+       RNA_def_function_return(func, parm);
+
+       func = RNA_def_function(srna, "remove", "rna_SceneLayer_remove");
+       RNA_def_function_ui_description(func, "Remove a render layer");
+       RNA_def_function_flag(func, FUNC_USE_MAIN | FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
+       parm = RNA_def_pointer(func, "layer", "SceneLayer", "", "Render layer 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_object_base(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
 
-       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", "");
+       srna = RNA_def_struct(brna, "ObjectBase", NULL);
+       RNA_def_struct_sdna(srna, "Base");
+       RNA_def_struct_ui_text(srna, "Object Base", "An object instance in a render layer");
+       RNA_def_struct_ui_icon(srna, ICON_OBJECT_DATA);
 
-       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");
+       prop = RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
+       RNA_def_property_pointer_sdna(prop, NULL, "object");
+       RNA_def_property_ui_text(prop, "Object", "Object this base links to");
+
+       prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", BASE_SELECTED);
+       RNA_def_property_ui_text(prop, "Select", "Object base selection state");
+       RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_ObjectBase_select_update");
 }
 
+/* TODO LAYERS: legacy SceneRenderLayers, to be removed */
 
 static void rna_def_scene_render_layer(BlenderRNA *brna)
 {
@@ -5795,6 +7075,115 @@ static void rna_def_scene_quicktime_settings(BlenderRNA *brna)
 }
 #endif
 
+#ifdef WITH_CLAY_ENGINE
+static void rna_def_render_engine_settings_clay(BlenderRNA *brna)
+{
+       StructRNA *srna;
+       PropertyRNA *prop;
+       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, "", ""},
+             &nbs