Merge branch 'master' into blender2.8
authorCampbell Barton <ideasman42@gmail.com>
Tue, 1 Aug 2017 00:38:36 +0000 (10:38 +1000)
committerCampbell Barton <ideasman42@gmail.com>
Tue, 1 Aug 2017 00:38:36 +0000 (10:38 +1000)
33 files changed:
1  2 
source/blender/blenkernel/intern/object_dupli.c
source/blender/editors/animation/keyframing.c
source/blender/editors/gpencil/gpencil_edit.c
source/blender/editors/interface/interface.c
source/blender/editors/space_clip/space_clip.c
source/blender/editors/space_sequencer/space_sequencer.c
source/blender/editors/transform/transform_conversions.c
source/blender/gpu/intern/gpu_buffers.c
source/blender/makesrna/RNA_enum_types.h
source/blender/makesrna/intern/CMakeLists.txt
source/blender/makesrna/intern/rna_mesh.c
source/blender/makesrna/intern/rna_nodetree.c
source/blender/makesrna/intern/rna_scene.c
source/blender/makesrna/intern/rna_sculpt_paint.c
source/blender/modifiers/intern/MOD_build.c
source/blender/modifiers/intern/MOD_collision.c
source/blender/modifiers/intern/MOD_curve.c
source/blender/modifiers/intern/MOD_dynamicpaint.c
source/blender/modifiers/intern/MOD_edgesplit.c
source/blender/modifiers/intern/MOD_explode.c
source/blender/modifiers/intern/MOD_fluidsim.c
source/blender/modifiers/intern/MOD_mask.c
source/blender/modifiers/intern/MOD_mirror.c
source/blender/modifiers/intern/MOD_multires.c
source/blender/modifiers/intern/MOD_ocean.c
source/blender/modifiers/intern/MOD_particleinstance.c
source/blender/modifiers/intern/MOD_skin.c
source/blender/modifiers/intern/MOD_smoke.c
source/blender/modifiers/intern/MOD_triangulate.c
source/blender/modifiers/intern/MOD_weightvgedit.c
source/blender/modifiers/intern/MOD_weightvgmix.c
source/blender/modifiers/intern/MOD_weightvgproximity.c
source/blender/windowmanager/intern/wm_operators.c

index 23907db522e31d2bb6a65e06e3def5fb6d54c13d,8dd991a768b89f9a39af96633dbbcecb32d13036..5f9d312fd4acaefd95db3dad4c0189f3a7e57b49
@@@ -3213,1266 -3233,334 +3213,1266 @@@ static void rna_def_gpencil_brush(Blend
        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);
  
 -      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");
 -}
 +      /* 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);
  
 -static void rna_def_unit_settings(BlenderRNA  *brna)
 -{
 -      StructRNA *srna;
 -      PropertyRNA *prop;
 +      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);
  
 -      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, "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);
  
 -      srna = RNA_def_struct(brna, "UnitSettings", NULL);
 -      RNA_def_struct_ui_text(srna, "Unit Settings", "");
 +      /* 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);
  
 -      /* 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_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, "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_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, "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)
 +/* Grease Pencil Drawing Brushes API */
 +static void rna_def_gpencil_brushes(BlenderRNA *brna, PropertyRNA *cprop)
  {
 +      StructRNA *srna;
        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);
 +      FunctionRNA *func;
 +      PropertyRNA *parm;
  
 -      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_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");
  
 -      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);
 +      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);
  
 -      /* 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);
 +      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, "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, "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, "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);
 +      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");
 +}
  
 -      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);
 +static void rna_def_tool_settings(BlenderRNA  *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
  
 -              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 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}
 +      };
  
 -      /* 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 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, "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);
 +      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}
 +      };
  
 -      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);
 +      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}
 +      };
  
 -      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);
 +      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_flag(prop, PROP_CONTEXT_UPDATE);
 +      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_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_multipaint", PROP_BOOLEAN, PROP_NONE);
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      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, "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, "vertex_group_user", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      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_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, "vertex_group_subset", PROP_ENUM, PROP_NONE);
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      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_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, "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_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, "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_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, "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_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", 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_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, "particle_edit", PROP_POINTER, PROP_NONE);
 +      RNA_def_property_pointer_sdna(prop, NULL, "particle");
 +      RNA_def_property_ui_text(prop, "Particle Edit", "");
  
 -      /* 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_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_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_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_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, "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");
  
 -      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, "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_enum_items(prop, rna_enum_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_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, "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_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);
 +      /* 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_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_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_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_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, "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, "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, "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);
 +
 +      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_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, "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, "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, "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 */
 +
 +      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, "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, "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 */
 +
 +      /* 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, "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");
 +
 +      /* 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);
 +
 +      /* 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);
 +
 +      /* 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);
 +
 +      
 +      /* 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_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, "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);
 +
 +      /* 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_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, 0, "rna_Scene_editmesh_select_mode_update");
 +
 +      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");
 +
 +      /* 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, "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");
 +
 +      /* 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);
 +
 +      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");
 +
 +      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");
 +
 +      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')");
 +
 +      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')");
 +
 +      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, "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, "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);
 +
 +      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);
 +
 +      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_unified_paint_settings(BlenderRNA  *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      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");
 +
 +      /* 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");
 +
 +      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");
 +
 +      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");
 +
 +      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");
 +
 +      /* 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_flag(prop, PROP_CONTEXT_UPDATE);
 +      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");
 +
 +      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_flag(prop, PROP_CONTEXT_UPDATE);
 +      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");
 +
 +      prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_FACTOR);
 +      RNA_def_property_float_sdna(prop, NULL, "alpha");
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      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");
 +
 +      prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_FACTOR);
 +      RNA_def_property_float_sdna(prop, NULL, "weight");
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      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");
 +
 +      prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      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, "secondary_color", PROP_FLOAT, PROP_COLOR_GAMMA);
 +      RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
 +      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, "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, "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, "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");
 +}
 +
 +
 +static void rna_def_curve_paint_settings(BlenderRNA  *brna)
 +{
 +      StructRNA *srna;
 +      PropertyRNA *prop;
 +
 +      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", "");
 +
 +      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, "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, "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, "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, "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, "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, "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, "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, "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}};
 +
 +      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");
 +
 +      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, "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");
 +}
 +
 +static void rna_def_statvis(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", "");
 +
 +      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_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_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_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_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_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_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_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +
 +
 +      /* 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_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +
 +      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_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_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_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_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_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +
 +      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_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +
 +      /* 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_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +
 +      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_flag(prop, PROP_CONTEXT_UPDATE);
 +      RNA_def_property_update(prop, 0, "rna_EditMesh_update");
 +}
 +
 +static void rna_def_unit_settings(BlenderRNA  *brna)
 +{
 +      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}
 +      };
 +
 +      srna = RNA_def_struct(brna, "UnitSettings", NULL);
 +      RNA_def_struct_ui_text(srna, "Unit Settings", "");
 +
 +      /* 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, "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);
index ae6417bf80796bd715ff8d063c477ac0a9c9d5f6,c9a910d769b9a4f9e07d29613c2704119629a89c..c232a32fe008b3cb37cf0b096b8999f295004c39
  #include "BKE_library_query.h"
  #include "BKE_modifier.h"
  
 -#include "depsgraph_private.h"
 +#include "DEG_depsgraph.h"
  #include "DEG_depsgraph_build.h"
  
+ #include "MOD_modifiertypes.h"
  static void initData(ModifierData *md)
  {
        CurveModifierData *cmd = (CurveModifierData *) md;
index 7f54fae06a741744904e2d5a1fc5a082ec772249,eec978280918dcd1a1c7abe6722b0bda95ce97bc..3c5afc6bb690392e91bf7db1b6494bb24fbe4d9d
  #include "BKE_library_query.h"
  #include "BKE_modifier.h"
  
 -#include "depsgraph_private.h"
 +#include "DEG_depsgraph.h"
 +
  #include "DEG_depsgraph_build.h"
  
+ #include "MOD_modifiertypes.h"
  
  static void initData(ModifierData *md) 
  {
index 8cdc740dba149b4e492fc10cd65a6a0697d7c5f7,18caf4a39f40ac51eec06006e9fc5e673dfe11bf..b66007b8a872505776c26d694f12d1b38c17f48e
  #include "BKE_modifier.h"
  #include "BKE_deform.h"
  
 -#include "depsgraph_private.h"
  #include "DEG_depsgraph_build.h"
  
+ #include "MOD_modifiertypes.h"
  #include "BLI_strict_flags.h"
  
  static void copyData(ModifierData *md, ModifierData *target)
index b8c8e12d6e38d375460476811771c48a9d0d4590,7b71e6166271de9eea9b9b3de8e8b01be657a183..a9e07fe444851b794dee36c51c9b34f20c9b4e36
  
  #include "MEM_guardedalloc.h"
  
 -#include "depsgraph_private.h"
  #include "DEG_depsgraph_build.h"
  
+ #include "MOD_modifiertypes.h"
  static void initData(ModifierData *md)
  {
        MirrorModifierData *mmd = (MirrorModifierData *) md;
index c3fe0f987e6b6e2482f44749900cb15430ef2117,0c91cb08da7a9e235e1e8e0c33064ba739dceb81..f25b6b225a54d7580006e33ba9e77b9194fbdeda
  #include "BKE_particle.h"
  #include "BKE_pointcache.h"
  
 -#include "depsgraph_private.h"
  #include "DEG_depsgraph_build.h"
  
+ #include "MOD_modifiertypes.h"
  static void initData(ModifierData *md)
  {
        ParticleInstanceModifierData *pimd = (ParticleInstanceModifierData *) md;
index 266dc6298fb9650fdcdb4c84ad6c9d46ee6e5cb2,7f2d9e42fe6a4ae063b61fe2a891c1cac2eaff84..c2a43f8b42e4652f25add3ba572ad559317fd43f
  
  #include "BLI_utildefines.h"
  
  #include "BKE_cdderivedmesh.h"
 +#include "BKE_layer.h"
  #include "BKE_library.h"
  #include "BKE_library_query.h"
  #include "BKE_main.h"
  #include "BKE_modifier.h"
  #include "BKE_smoke.h"
  
 -#include "depsgraph_private.h"
 +#include "DEG_depsgraph.h"
  #include "DEG_depsgraph_build.h"
  
+ #include "MOD_modifiertypes.h"
  static void initData(ModifierData *md) 
  {
        SmokeModifierData *smd = (SmokeModifierData *) md;