rna renaming (manual edits)

18 files changed, 321 insertions, 309 deletions

diff --git a/source/blender/editors/space_image/image_buttons.c b/source/blender/editors/space_image/image_buttons.c
index 4f9163bc32c..054cd69443a 100644
--- a/source/blender/editors/space_image/image_buttons.c
+++ b/source/blender/editors/space_image/image_buttons.c
@@ -910,7 +910,7 @@ void uiTemplateImage(uiLayout *layout, bContext *C, PointerRNA *ptr, char *propn
 				col= uiLayoutColumn(split, 0);
 				uiItemR(col, userptr, "fields_per_frame", 0, "Fields", 0);
 				uiItemR(col, userptr, "use_auto_refresh", 0, NULL, 0);
-				uiItemR(col, userptr, "cyclic", 0, NULL, 0);
+				uiItemR(col, userptr, "use_cyclic", 0, NULL, 0);
 			}
 			else if(ima->source==IMA_SRC_GENERATED) {
 				split= uiLayoutSplit(layout, 0, 0);
diff --git a/source/blender/editors/space_nla/nla_buttons.c b/source/blender/editors/space_nla/nla_buttons.c
index 5ad21f7c9ca..fc869c4b46f 100644
--- a/source/blender/editors/space_nla/nla_buttons.c
+++ b/source/blender/editors/space_nla/nla_buttons.c
@@ -312,7 +312,7 @@ static void nla_panel_properties(const bContext *C, Panel *pa)
 		uiLayoutSetActive(column, !(RNA_boolean_get(&strip_ptr, "animated_influence") || RNA_boolean_get(&strip_ptr, "use_animated_time"))); 
 		uiItemL(column, "Playback Settings:", 0);
 		uiItemR(column, &strip_ptr, "mute", 0, NULL, 0);
-		uiItemR(column, &strip_ptr, "reversed", 0, NULL, 0);
+		uiItemR(column, &strip_ptr, "use_reverse", 0, NULL, 0);
 }
 
 
diff --git a/source/blender/editors/space_node/drawnode.c b/source/blender/editors/space_node/drawnode.c
index e3013cc2507..c1b888fcf83 100644
--- a/source/blender/editors/space_node/drawnode.c
+++ b/source/blender/editors/space_node/drawnode.c
@@ -113,7 +113,7 @@ static void node_buts_mix_rgb(uiLayout *layout, bContext *C, PointerRNA *ptr)
 	row= uiLayoutRow(layout, 1);
 	uiItemR(row, ptr, "blend_type", 0, "", 0);
 	if(ntree->type == NTREE_COMPOSIT)
-		uiItemR(row, ptr, "alpha", 0, "", ICON_IMAGE_RGB_ALPHA);
+		uiItemR(row, ptr, "use_alpha", 0, "", ICON_IMAGE_RGB_ALPHA);
 }
 
 static void node_buts_time(uiLayout *layout, bContext *C, PointerRNA *ptr)
@@ -134,8 +134,8 @@ static void node_buts_time(uiLayout *layout, bContext *C, PointerRNA *ptr)
 	uiTemplateCurveMapping(layout, ptr, "curve", 's', 0, 0);
 
 	row= uiLayoutRow(layout, 1);
-	uiItemR(row, ptr, "start", 0, "Sta", 0);
-	uiItemR(row, ptr, "end", 0, "End", 0);
+	uiItemR(row, ptr, "frame_start", 0, "Sta", 0);
+	uiItemR(row, ptr, "frame_end", 0, "End", 0);
 }
 
 static void node_buts_colorramp(uiLayout *layout, bContext *C, PointerRNA *ptr)
@@ -307,8 +307,8 @@ static void node_shader_buts_material(uiLayout *layout, bContext *C, PointerRNA
 	if(!node->id) return;
 	
 	col= uiLayoutColumn(layout, 0);
-	uiItemR(col, ptr, "diffuse", 0, NULL, 0);
-	uiItemR(col, ptr, "specular", 0, NULL, 0);
+	uiItemR(col, ptr, "use_diffuse", 0, NULL, 0);
+	uiItemR(col, ptr, "use_specular", 0, NULL, 0);
 	uiItemR(col, ptr, "invert_normal", 0, NULL, 0);
 }
 
@@ -478,10 +478,10 @@ static void node_composit_buts_image(uiLayout *layout, bContext *C, PointerRNA *
 	
 	if (ELEM(RNA_enum_get(&imaptr, "source"), IMA_SRC_SEQUENCE, IMA_SRC_MOVIE)) {
 		col= uiLayoutColumn(layout, 1);
-		uiItemR(col, ptr, "frames", 0, NULL, 0);
-		uiItemR(col, ptr, "start", 0, NULL, 0);
-		uiItemR(col, ptr, "offset", 0, NULL, 0);
-		uiItemR(col, ptr, "cyclic", 0, NULL, 0);
+		uiItemR(col, ptr, "frame_duration", 0, NULL, 0);
+		uiItemR(col, ptr, "frame_start", 0, NULL, 0);
+		uiItemR(col, ptr, "frame_offset", 0, NULL, 0);
+		uiItemR(col, ptr, "use_cyclic", 0, NULL, 0);
 		uiItemR(col, ptr, "use_auto_refresh", UI_ITEM_R_ICON_ONLY, NULL, 0);
 	}
 
@@ -532,13 +532,13 @@ static void node_composit_buts_blur(uiLayout *layout, bContext *C, PointerRNA *p
 	
 	uiItemR(col, ptr, "filter_type", 0, "", 0);
 	if (RNA_enum_get(ptr, "filter_type")!= R_FILTER_FAST_GAUSS) {
-		uiItemR(col, ptr, "bokeh", 0, NULL, 0);
-		uiItemR(col, ptr, "gamma", 0, NULL, 0);
+		uiItemR(col, ptr, "use_bokeh", 0, NULL, 0);
+		uiItemR(col, ptr, "use_gamma_correction", 0, NULL, 0);
 	}
 	
-	uiItemR(col, ptr, "relative", 0, NULL, 0);
+	uiItemR(col, ptr, "use_relative", 0, NULL, 0);
 	col= uiLayoutColumn(layout, 1);
-	if (RNA_boolean_get(ptr, "relative")) {
+	if (RNA_boolean_get(ptr, "use_relative")) {
 		uiItemR(col, ptr, "factor_x", 0, "X", 0);
 		uiItemR(col, ptr, "factor_y", 0, "Y", 0);
 	}
@@ -672,8 +672,8 @@ static void node_composit_buts_lensdist(uiLayout *layout, bContext *C, PointerRN
 
 	col = uiLayoutColumn(col, 0);
 	uiLayoutSetActive(col, RNA_boolean_get(ptr, "use_projector")==0);
-	uiItemR(col, ptr, "jitter", 0, NULL, 0);
-	uiItemR(col, ptr, "fit", 0, NULL, 0);
+	uiItemR(col, ptr, "use_jitter", 0, NULL, 0);
+	uiItemR(col, ptr, "use_fit", 0, NULL, 0);
 }
 
 static void node_composit_buts_vecblur(uiLayout *layout, bContext *C, PointerRNA *ptr)
@@ -689,7 +689,7 @@ static void node_composit_buts_vecblur(uiLayout *layout, bContext *C, PointerRNA
 	uiItemR(col, ptr, "speed_min", 0, "Min", 0);
 	uiItemR(col, ptr, "speed_max", 0, "Max", 0);
 
-	uiItemR(layout, ptr, "curved", 0, NULL, 0);
+	uiItemR(layout, ptr, "use_curved", 0, NULL, 0);
 }
 
 static void node_composit_buts_filter(uiLayout *layout, bContext *C, PointerRNA *ptr)
@@ -820,7 +820,7 @@ static void node_composit_buts_chroma_matte(uiLayout *layout, bContext *C, Point
 	
 	col= uiLayoutColumn(layout, 0);
 	uiItemR(col, ptr, "tolerance", 0, NULL, 0);
-	uiItemR(col, ptr, "cutoff", 0, NULL, 0);
+	uiItemR(col, ptr, "threshold", 0, NULL, 0);
 	
 	col= uiLayoutColumn(layout, 1);
    /*uiItemR(col, ptr, "lift", UI_ITEM_R_SLIDER, NULL, 0);  Removed for now */
@@ -833,9 +833,9 @@ static void node_composit_buts_color_matte(uiLayout *layout, bContext *C, Pointe
 	uiLayout *col;
 	
 	col= uiLayoutColumn(layout, 1);
-	uiItemR(col, ptr, "h", UI_ITEM_R_SLIDER, NULL, 0);
-	uiItemR(col, ptr, "s", UI_ITEM_R_SLIDER, NULL, 0);
-	uiItemR(col, ptr, "v", UI_ITEM_R_SLIDER, NULL, 0);
+	uiItemR(col, ptr, "color_hue", UI_ITEM_R_SLIDER, NULL, 0);
+	uiItemR(col, ptr, "color_saturation", UI_ITEM_R_SLIDER, NULL, 0);
+	uiItemR(col, ptr, "color_value", UI_ITEM_R_SLIDER, NULL, 0);
 }
 
 static void node_composit_buts_channel_matte(uiLayout *layout, bContext *C, PointerRNA *ptr)
@@ -849,7 +849,7 @@ static void node_composit_buts_channel_matte(uiLayout *layout, bContext *C, Poin
    col=uiLayoutColumn(layout, 0);  
    uiItemL(col, "Key Channel:", 0);
 	row= uiLayoutRow(col, 0);
-	uiItemR(row, ptr, "channel", UI_ITEM_R_EXPAND, NULL, 0);
+	uiItemR(row, ptr, "matte_channel", UI_ITEM_R_EXPAND, NULL, 0);
 
 	col =uiLayoutColumn(layout, 0);
 
@@ -860,8 +860,8 @@ static void node_composit_buts_channel_matte(uiLayout *layout, bContext *C, Poin
 	  uiItemR(row, ptr, "limit_channel", UI_ITEM_R_EXPAND, NULL, 0);
    }
    
-	uiItemR(col, ptr, "high", UI_ITEM_R_SLIDER, NULL, 0);
-	uiItemR(col, ptr, "low", UI_ITEM_R_SLIDER, NULL, 0);
+	uiItemR(col, ptr, "limit_max", UI_ITEM_R_SLIDER, NULL, 0);
+	uiItemR(col, ptr, "limit_min", UI_ITEM_R_SLIDER, NULL, 0);
 }
 
 static void node_composit_buts_luma_matte(uiLayout *layout, bContext *C, PointerRNA *ptr)
@@ -869,8 +869,8 @@ static void node_composit_buts_luma_matte(uiLayout *layout, bContext *C, Pointer
 	uiLayout *col;
 	
 	col= uiLayoutColumn(layout, 1);
-	uiItemR(col, ptr, "high", UI_ITEM_R_SLIDER, NULL, 0);
-	uiItemR(col, ptr, "low", UI_ITEM_R_SLIDER, NULL, 0);
+	uiItemR(col, ptr, "limit_max", UI_ITEM_R_SLIDER, NULL, 0);
+	uiItemR(col, ptr, "limit_min", UI_ITEM_R_SLIDER, NULL, 0);
 }
 
 static void node_composit_buts_map_uv(uiLayout *layout, bContext *C, PointerRNA *ptr)
@@ -915,7 +915,7 @@ static void node_composit_buts_scale(uiLayout *layout, bContext *C, PointerRNA *
 
 static void node_composit_buts_rotate(uiLayout *layout, bContext *C, PointerRNA *ptr)
 {
-   uiItemR(layout, ptr, "filter", 0, "", 0);
+   uiItemR(layout, ptr, "filter_type", 0, "", 0);
 }
 
 static void node_composit_buts_invert(uiLayout *layout, bContext *C, PointerRNA *ptr)
@@ -923,8 +923,8 @@ static void node_composit_buts_invert(uiLayout *layout, bContext *C, PointerRNA
 	uiLayout *col;
 	
 	col= uiLayoutColumn(layout, 0);
-	uiItemR(col, ptr, "rgb", 0, NULL, 0);
-	uiItemR(col, ptr, "alpha", 0, NULL, 0);
+	uiItemR(col, ptr, "invert_rgb", 0, NULL, 0);
+	uiItemR(col, ptr, "invert_alpha", 0, NULL, 0);
 }
 
 static void node_composit_buts_premulkey(uiLayout *layout, bContext *C, PointerRNA *ptr)
@@ -1209,7 +1209,7 @@ static void node_texture_buts_image(uiLayout *layout, bContext *C, PointerRNA *p
 
 static void node_texture_buts_output(uiLayout *layout, bContext *C, PointerRNA *ptr)
 {
-	uiItemR(layout, ptr, "output_name", 0, "", 0);
+	uiItemR(layout, ptr, "filepath", 0, "", 0);
 }
 
 /* only once called */
diff --git a/source/blender/makesrna/intern/rna_constraint.c b/source/blender/makesrna/intern/rna_constraint.c
index 38242628fd1..a58807902d8 100644
--- a/source/blender/makesrna/intern/rna_constraint.c
+++ b/source/blender/makesrna/intern/rna_constraint.c
@@ -638,13 +638,13 @@ static void rna_def_constraint_track_to(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Sub-Target", "");
 	RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
 
-	prop= RNA_def_property(srna, "track", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "track_axis", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "reserved1");
 	RNA_def_property_enum_items(prop, track_items);
 	RNA_def_property_ui_text(prop, "Track Axis", "Axis that points to the target object");
 	RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-	prop= RNA_def_property(srna, "up", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "up_axis", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "reserved2");
 	RNA_def_property_enum_items(prop, up_items);
 	RNA_def_property_ui_text(prop, "Up Axis", "Axis that points upward");
@@ -832,7 +832,7 @@ static void rna_def_constraint_same_volume(BlenderRNA *brna)
 	RNA_def_struct_ui_text(srna, "Maintain Volume Constraint", "Maintains a constant volume along a single scaling axis");
 	RNA_def_struct_sdna_from(srna, "bSameVolumeConstraint", "data");
 
-	prop= RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "free_axis", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "flag");
 	RNA_def_property_enum_items(prop, volume_items);
 	RNA_def_property_ui_text(prop, "Free Axis", "The free scaling axis of the object");
@@ -906,7 +906,7 @@ static void rna_def_constraint_minmax(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Floor Location", "Location of target that object will not pass through");
 	RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-	prop= RNA_def_property(srna, "sticky", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_sticky", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MINMAX_STICKY);
 	RNA_def_property_ui_text(prop, "Sticky", "Immobilize object while constrained");
 	RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
@@ -1028,13 +1028,13 @@ static void rna_def_constraint_locked_track(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Sub-Target", "");
 	RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
 
-	prop= RNA_def_property(srna, "track", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "track_axis", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "trackflag");
 	RNA_def_property_enum_items(prop, locktrack_items);
 	RNA_def_property_ui_text(prop, "Track Axis", "Axis that points to the target object");
 	RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-	prop= RNA_def_property(srna, "lock", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "lock_axis", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "lockflag");
 	RNA_def_property_enum_items(prop, lock_items);
 	RNA_def_property_ui_text(prop, "Locked Axis", "Axis that points upward");
@@ -1083,13 +1083,13 @@ static void rna_def_constraint_follow_path(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Offset Factor", "Percentage value defining target position along length of bone");
 	RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-	prop= RNA_def_property(srna, "forward", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "forward_axis", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "trackflag");
 	RNA_def_property_enum_items(prop, forwardpath_items);
 	RNA_def_property_ui_text(prop, "Forward Axis", "Axis that points forward along the path");
 	RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-	prop= RNA_def_property(srna, "up", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "up_axis", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "upflag");
 	RNA_def_property_enum_items(prop, pathup_items);
 	RNA_def_property_ui_text(prop, "Up Axis", "Axis that points upward");
@@ -1286,7 +1286,7 @@ static void rna_def_constraint_clamp_to(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Main Axis", "Main axis of movement");
 	RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
 
-	prop= RNA_def_property(srna, "cyclic", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag2", CLAMPTO_CYCLIC);
 	RNA_def_property_ui_text(prop, "Cyclic", "Treat curve as cyclic curve (no clamping to curve bounding box");
 	RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_update");
@@ -1772,7 +1772,7 @@ static void rna_def_constraint_damped_track(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Sub-Target", "");
 	RNA_def_property_update(prop, NC_OBJECT|ND_CONSTRAINT, "rna_Constraint_dependency_update");
 
-	prop= RNA_def_property(srna, "track", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "track_axis", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "trackflag");
 	RNA_def_property_enum_items(prop, damptrack_items);
 	RNA_def_property_ui_text(prop, "Track Axis", "Axis that points to the target object");
@@ -1950,9 +1950,9 @@ void RNA_def_constraint(BlenderRNA *brna)
 	RNA_def_property_ui_icon(prop, ICON_TRIA_RIGHT, 1);
 
 		// XXX this is really an internal flag, but it may be useful for some tools to be able to access this...
-	prop= RNA_def_property(srna, "disabled", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "is_valid", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
-	RNA_def_property_boolean_sdna(prop, NULL, "flag", CONSTRAINT_DISABLE);
+	RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", CONSTRAINT_DISABLE);
 	RNA_def_property_ui_text(prop, "Disabled", "Constraint has invalid settings and will not be evaluated");
 	
 		// TODO: setting this to true must ensure that all others in stack are turned off too...
diff --git a/source/blender/makesrna/intern/rna_image.c b/source/blender/makesrna/intern/rna_image.c
index ea4821be9d9..bd121724413 100644
--- a/source/blender/makesrna/intern/rna_image.c
+++ b/source/blender/makesrna/intern/rna_image.c
@@ -229,17 +229,19 @@ static void rna_def_imageuser(BlenderRNA *brna)
 	RNA_def_property_update(prop, 0, "rna_ImageUser_update");
 
 	/* animation */
-	prop= RNA_def_property(srna, "cyclic", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "cycl", 0);
 	RNA_def_property_ui_text(prop, "Cyclic", "Cycle the images in the movie");
 	RNA_def_property_update(prop, 0, "rna_ImageUser_update");
 
-	prop= RNA_def_property(srna, "frames", PROP_INT, PROP_NONE);
+	prop= RNA_def_property(srna, "frame_duration", PROP_INT, PROP_NONE);
+	RNA_def_property_int_sdna(prop, NULL, "frames");
 	RNA_def_property_range(prop, 0, MAXFRAMEF);
 	RNA_def_property_ui_text(prop, "Frames", "Sets the number of images of a movie to use");
 	RNA_def_property_update(prop, 0, "rna_ImageUser_update");
 
-	prop= RNA_def_property(srna, "offset", PROP_INT, PROP_NONE);
+	prop= RNA_def_property(srna, "frame_offset", PROP_INT, PROP_NONE);
+	RNA_def_property_int_sdna(prop, NULL, "offset");
 	RNA_def_property_range(prop, -MAXFRAMEF, MAXFRAMEF);
 	RNA_def_property_ui_text(prop, "Offset", "Offsets the number of the frame to use in the animation");
 	RNA_def_property_update(prop, 0, "rna_ImageUser_update");
@@ -405,7 +407,7 @@ static void rna_def_image(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Animation Speed", "Speed of the animation in frames per second");
 	RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
 
-	prop= RNA_def_property(srna, "tiles", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_tiles", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "tpageflag", IMA_TILES);
 	RNA_def_property_ui_text(prop, "Tiles", "Use of tilemode for faces (default shift-LMB to pick the tile for selected faces)");
 	RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
diff --git a/source/blender/makesrna/intern/rna_lamp.c b/source/blender/makesrna/intern/rna_lamp.c
index 861593e4462..c6660450914 100644
--- a/source/blender/makesrna/intern/rna_lamp.c
+++ b/source/blender/makesrna/intern/rna_lamp.c
@@ -362,22 +362,22 @@ static void rna_def_lamp(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Color", "Light color");
 	RNA_def_property_update(prop, 0, "rna_Lamp_draw_update");
 
-	prop= RNA_def_property(srna, "layer", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_own_layer", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "mode", LA_LAYER);
 	RNA_def_property_ui_text(prop, "Layer", "Illuminates objects only on the same layer the lamp is on");
 	RNA_def_property_update(prop, 0, "rna_Lamp_update");
 
-	prop= RNA_def_property(srna, "negative", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_negative", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "mode", LA_NEG);
 	RNA_def_property_ui_text(prop, "Negative", "Lamp casts negative light");
 	RNA_def_property_update(prop, 0, "rna_Lamp_update");
 
-	prop= RNA_def_property(srna, "specular", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_specular", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_negative_sdna(prop, NULL, "mode", LA_NO_SPEC);
 	RNA_def_property_ui_text(prop, "Specular", "Lamp creates specular highlights");
 	RNA_def_property_update(prop, 0, "rna_Lamp_update");
 
-	prop= RNA_def_property(srna, "diffuse", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_diffuse", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_negative_sdna(prop, NULL, "mode", LA_NO_DIFF);
 	RNA_def_property_ui_text(prop, "Diffuse", "Lamp does diffuse shading");
 	RNA_def_property_update(prop, 0, "rna_Lamp_update");
@@ -546,12 +546,12 @@ static void rna_def_area_lamp(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Umbra", "Emphasize parts that are fully shadowed (Constant Jittered sampling)");
 	RNA_def_property_update(prop, 0, "rna_Lamp_update");
 
-	prop= RNA_def_property(srna, "dither", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_dither", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "ray_samp_type", LA_SAMP_DITHER);
 	RNA_def_property_ui_text(prop, "Dither", "Use 2x2 dithering for sampling  (Constant Jittered sampling)");
 	RNA_def_property_update(prop, 0, "rna_Lamp_update");
 
-	prop= RNA_def_property(srna, "jitter", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_jitter", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "ray_samp_type", LA_SAMP_JITTER);
 	RNA_def_property_ui_text(prop, "Jitter", "Use noise for sampling  (Constant Jittered sampling)");
 	RNA_def_property_update(prop, 0, "rna_Lamp_update");
@@ -613,7 +613,7 @@ static void rna_def_spot_lamp(BlenderRNA *brna)
 	rna_def_lamp_falloff(srna);
 	rna_def_lamp_shadow(srna, 1, 0);
 
-	prop= RNA_def_property(srna, "square", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_square", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "mode", LA_SQUARE);
 	RNA_def_property_ui_text(prop, "Square", "Casts a square spot light shape");
 	RNA_def_property_update(prop, 0, "rna_Lamp_draw_update");
diff --git a/source/blender/makesrna/intern/rna_material.c b/source/blender/makesrna/intern/rna_material.c
index a98e9a81443..46a89ccce40 100644
--- a/source/blender/makesrna/intern/rna_material.c
+++ b/source/blender/makesrna/intern/rna_material.c
@@ -947,7 +947,7 @@ static void rna_def_material_raytra(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Filter", "Amount to blend in the material's diffuse color in raytraced transparency (simulating absorption)");
 	RNA_def_property_update(prop, 0, "rna_Material_update");
 	
-	prop= RNA_def_property(srna, "limit", PROP_FLOAT, PROP_DISTANCE);
+	prop= RNA_def_property(srna, "depth_max", PROP_FLOAT, PROP_DISTANCE);
 	RNA_def_property_float_sdna(prop, NULL, "tx_limit");
 	RNA_def_property_range(prop, 0.0f, 100.0f);
 	RNA_def_property_ui_text(prop, "Limit", "Maximum depth for light to travel through the transparent material before becoming fully filtered (0.0 is disabled)");
@@ -1191,22 +1191,22 @@ static void rna_def_material_halo(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Flares Sub", "Sets the number of subflares");
 	RNA_def_property_update(prop, 0, "rna_Material_update");
 	
-	prop= RNA_def_property(srna, "ring", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_ring", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_RINGS);
 	RNA_def_property_ui_text(prop, "Rings", "Renders rings over halo");
 	RNA_def_property_update(prop, 0, "rna_Material_update");
 	
-	prop= RNA_def_property(srna, "lines", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_lines", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_LINES);
 	RNA_def_property_ui_text(prop, "Lines", "Renders star shaped lines over halo");
 	RNA_def_property_update(prop, 0, "rna_Material_update");
 	
-	prop= RNA_def_property(srna, "star", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_star", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_STAR);
 	RNA_def_property_ui_text(prop, "Star", "Renders halo as a star");
 	RNA_def_property_update(prop, 0, "rna_Material_update");
 	
-	prop= RNA_def_property(srna, "texture", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_texture", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALOTEX);
 	RNA_def_property_ui_text(prop, "Texture", "Gives halo a texture");
 	RNA_def_property_update(prop, 0, "rna_Material_update");
@@ -1221,12 +1221,12 @@ static void rna_def_material_halo(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Extreme Alpha", "Uses extreme alpha");
 	RNA_def_property_update(prop, 0, "rna_Material_update");
 	
-	prop= RNA_def_property(srna, "show_shaded", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_shaded", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_SHADE);
 	RNA_def_property_ui_text(prop, "Shaded", "Lets halo receive light and shadows from external objects");
 	RNA_def_property_update(prop, 0, "rna_Material_update");
 	
-	prop= RNA_def_property(srna, "soft", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_soft", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_HALO_SOFT);
 	RNA_def_property_ui_text(prop, "Soft", "Softens the edges of halos at intersections with other geometry");
 	RNA_def_property_update(prop, 0, "rna_Material_update");
@@ -1465,7 +1465,7 @@ static void rna_def_material_physics(BlenderRNA *brna)
 	RNA_def_property_range(prop, 0, 20);
 	RNA_def_property_ui_text(prop, "Distance", "Distance of the physics area");
 	
-	prop= RNA_def_property(srna, "damp", PROP_FLOAT, PROP_NONE);
+	prop= RNA_def_property(srna, "damping", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "xyfrict");
 	RNA_def_property_range(prop, 0, 1);
 	RNA_def_property_ui_text(prop, "Damping", "Damping of the spring force, when inside the physics distance area");
@@ -1543,7 +1543,7 @@ void RNA_def_material(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Translucency", "Amount of diffuse shading on the back side");
 	RNA_def_property_update(prop, 0, "rna_Material_update");
 		
-	prop= RNA_def_property(srna, "cubic", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_cubic", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "shade_flag", MA_CUBIC);
 	RNA_def_property_ui_text(prop, "Cubic Interpolation", "Use cubic interpolation for diffuse values, for smoother transitions");
 	RNA_def_property_update(prop, 0, "rna_Material_update");
@@ -1588,7 +1588,7 @@ void RNA_def_material(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Traceable", "Include this material and geometry that uses it in ray tracing calculations");
 	RNA_def_property_update(prop, 0, "rna_Material_update");
 	
-	prop= RNA_def_property(srna, "shadows", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_shadows", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "mode", MA_SHADOW);
 	RNA_def_property_ui_text(prop, "Shadows", "Allows this material to receive shadows");
 	RNA_def_property_update(prop, 0, "rna_Material_update");
diff --git a/source/blender/makesrna/intern/rna_modifier.c b/source/blender/makesrna/intern/rna_modifier.c
index ccf6f2c1c3b..a7266b17821 100644
--- a/source/blender/makesrna/intern/rna_modifier.c
+++ b/source/blender/makesrna/intern/rna_modifier.c
@@ -725,12 +725,14 @@ static void rna_def_modifier_build(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Start", "Specify the start frame of the effect");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "length", PROP_FLOAT, PROP_TIME);
+	prop= RNA_def_property(srna, "frame_duration", PROP_FLOAT, PROP_TIME);
+	RNA_def_property_float_sdna(prop, NULL, "length");
 	RNA_def_property_range(prop, 1, MAXFRAMEF);
 	RNA_def_property_ui_text(prop, "Length", "Specify the total time the build effect requires");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "randomize", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_random_order", PROP_BOOLEAN, PROP_NONE);
+	RNA_def_property_boolean_sdna(prop, NULL, "randomize", 1);
 	RNA_def_property_ui_text(prop, "Randomize", "Randomize the faces or edges during build");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
@@ -750,22 +752,22 @@ static void rna_def_modifier_mirror(BlenderRNA *brna)
 	RNA_def_struct_sdna(srna, "MirrorModifierData");
 	RNA_def_struct_ui_icon(srna, ICON_MOD_MIRROR);
 
-	prop= RNA_def_property(srna, "x", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_x", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MIR_AXIS_X);
 	RNA_def_property_ui_text(prop, "X", "Enable X axis mirror");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "y", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_y", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MIR_AXIS_Y);
 	RNA_def_property_ui_text(prop, "Y", "Enable Y axis mirror");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "z", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_z", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MIR_AXIS_Z);
 	RNA_def_property_ui_text(prop, "Z", "Enable Z axis mirror");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "clip", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_clip", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MIR_CLIPPING);
 	RNA_def_property_ui_text(prop, "Clip", "Prevents vertices from going through the mirror during transform");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -838,22 +840,22 @@ static void rna_def_modifier_wave(BlenderRNA *brna)
 	RNA_def_struct_sdna(srna, "WaveModifierData");
 	RNA_def_struct_ui_icon(srna, ICON_MOD_WAVE);
 
-	prop= RNA_def_property(srna, "x", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_x", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WAVE_X);
 	RNA_def_property_ui_text(prop, "X", "X axis motion");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "y", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_y", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WAVE_Y);
 	RNA_def_property_ui_text(prop, "Y", "Y axis motion");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "cyclic", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WAVE_CYCL);
 	RNA_def_property_ui_text(prop, "Cyclic", "Cyclic wave effect");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "normals", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_normal", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_WAVE_NORM);
 	RNA_def_property_ui_text(prop, "Normals", "Displace along normals");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -995,7 +997,7 @@ static void rna_def_modifier_armature(BlenderRNA *brna)
 	RNA_def_property_string_funcs(prop, NULL, NULL, "rna_ArmatureModifier_vgroup_set");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "invert_vertex_group", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_INVERT_VGROUP);
 	RNA_def_property_ui_text(prop, "Invert", "Invert vertex group influence");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -1010,7 +1012,7 @@ static void rna_def_modifier_armature(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Use Bone Envelopes", "");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "quaternion", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_deform_preserve_volume", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "deformflag", ARM_DEF_QUATERNION);
 	RNA_def_property_ui_text(prop, "Quaternion", "Deform rotation interpolation with quaternions");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -1138,7 +1140,8 @@ static void rna_def_modifier_array(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Count",  "Number of duplicates to make");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "length", PROP_FLOAT, PROP_DISTANCE);
+	prop= RNA_def_property(srna, "fit_length", PROP_FLOAT, PROP_DISTANCE);
+	RNA_def_property_float_sdna(prop, NULL, "length");
 	RNA_def_property_range(prop, 0, INT_MAX);
 	RNA_def_property_ui_range(prop, 0, 10000, 10, 2);
 	RNA_def_property_ui_text(prop, "Length", "Length to fit array within");
@@ -1404,17 +1407,17 @@ static void rna_def_modifier_smooth(BlenderRNA *brna)
 	RNA_def_struct_sdna(srna, "SmoothModifierData");
 	RNA_def_struct_ui_icon(srna, ICON_MOD_SMOOTH);
 
-	prop= RNA_def_property(srna, "x", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "ise_x", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_SMOOTH_X);
 	RNA_def_property_ui_text(prop, "X", "");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "y", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "ise_y", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_SMOOTH_Y);
 	RNA_def_property_ui_text(prop, "Y", "");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "z", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "ise_z", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_SMOOTH_Z);
 	RNA_def_property_ui_text(prop, "Z", "");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -1426,7 +1429,8 @@ static void rna_def_modifier_smooth(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Factor", "");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "repeat", PROP_INT, PROP_NONE);
+	prop= RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
+	RNA_def_property_int_sdna(prop, NULL, "repeat");
 	RNA_def_property_ui_range(prop, 0, 30, 1, 0);
 	RNA_def_property_ui_text(prop, "Repeat", "");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -1466,17 +1470,17 @@ static void rna_def_modifier_cast(BlenderRNA *brna)
 	RNA_def_property_flag(prop, PROP_EDITABLE|PROP_ID_SELF_CHECK);
 	RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
 
-	prop= RNA_def_property(srna, "x", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_x", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_CAST_X);
 	RNA_def_property_ui_text(prop, "X", "");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "y", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_y", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_CAST_Y);
 	RNA_def_property_ui_text(prop, "Y", "");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "z", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_z", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_CAST_Z);
 	RNA_def_property_ui_text(prop, "Z", "");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -1544,7 +1548,7 @@ static void rna_def_modifier_meshdeform(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Bound", "Whether geometry has been bound to control cage");
 	RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 	
-	prop= RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "invert_vertex_group", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MDEF_INVERT_VGROUP);
 	RNA_def_property_ui_text(prop, "Invert", "Invert vertex group influence");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -1561,7 +1565,7 @@ static void rna_def_modifier_meshdeform(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Precision", "The grid size for binding");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "dynamic", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_dynamic_bind", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MDEF_DYNAMIC_BIND);
 	RNA_def_property_ui_text(prop, "Dynamic", "Recompute binding dynamically on top of other deformers (slower and more memory consuming.)");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -1625,12 +1629,12 @@ static void rna_def_modifier_particleinstance(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Axis", "Pole axis for rotation");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 	
-	prop= RNA_def_property(srna, "normal", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_normal", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", eParticleInstanceFlag_Parents);
 	RNA_def_property_ui_text(prop, "Normal", "Create instances from normal particles");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "children", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_children", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", eParticleInstanceFlag_Children);
 	RNA_def_property_ui_text(prop, "Children", "Create instances from child particles");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -1660,7 +1664,7 @@ static void rna_def_modifier_particleinstance(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Keep Shape", "Don't stretch the object");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "size", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_size", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", eParticleInstanceFlag_UseSize);
 	RNA_def_property_ui_text(prop, "Size", "Use particle size to scale the instances");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -1717,7 +1721,7 @@ static void rna_def_modifier_explode(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Dead", "Show mesh when particles are dead");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "size", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_size", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", eExplodeFlag_PaSize);
 	RNA_def_property_ui_text(prop, "Size", "Use particle size for the shrapnel");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -1847,7 +1851,7 @@ static void rna_def_modifier_bevel(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Edge Weight Method", "What edge weight to use for weighting a vertex");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "angle", PROP_FLOAT, PROP_NONE);
+	prop= RNA_def_property(srna, "angle_limit", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "bevel_angle");
 	RNA_def_property_range(prop, 0, 180);
 	RNA_def_property_ui_range(prop, 0, 180, 100, 2);
@@ -1871,7 +1875,7 @@ static void rna_def_modifier_shrinkwrap(BlenderRNA *brna)
 	RNA_def_struct_sdna(srna, "ShrinkwrapModifierData");
 	RNA_def_struct_ui_icon(srna, ICON_MOD_SHRINKWRAP);
 
-	prop= RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "wrap_method", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "shrinkType");
 	RNA_def_property_enum_items(prop, shrink_type_items);
 	RNA_def_property_ui_text(prop, "Mode", "");
@@ -1903,17 +1907,17 @@ static void rna_def_modifier_shrinkwrap(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Offset", "Distance to keep from the target");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "x", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_project_x", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "projAxis", MOD_SHRINKWRAP_PROJECT_OVER_X_AXIS);
 	RNA_def_property_ui_text(prop, "X", "");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "y", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_project_y", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "projAxis", MOD_SHRINKWRAP_PROJECT_OVER_Y_AXIS);
 	RNA_def_property_ui_text(prop, "Y", "");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "z", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_project_z", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "projAxis", MOD_SHRINKWRAP_PROJECT_OVER_Z_AXIS);
 	RNA_def_property_ui_text(prop, "Z", "");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -1925,12 +1929,12 @@ static void rna_def_modifier_shrinkwrap(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Subsurf Levels", "Number of subdivisions that must be performed before extracting vertices' positions and normals");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "negative", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_negative_direction", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "shrinkOpts", MOD_SHRINKWRAP_PROJECT_ALLOW_NEG_DIR);
 	RNA_def_property_ui_text(prop, "Negative", "Allow vertices to move in the negative direction of axis");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "positive", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_positive_direction", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "shrinkOpts", MOD_SHRINKWRAP_PROJECT_ALLOW_POS_DIR);
 	RNA_def_property_ui_text(prop, "Positive", "Allow vertices to move in the positive direction of axis");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -2000,7 +2004,7 @@ static void rna_def_modifier_mask(BlenderRNA *brna)
 	RNA_def_property_string_funcs(prop, NULL, NULL, "rna_MaskModifier_vgroup_set");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "invert_vertex_group", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_MASK_INV);
 	RNA_def_property_ui_text(prop, "Invert", "Use vertices that are not part of region defined");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -2023,7 +2027,8 @@ static void rna_def_modifier_simpledeform(BlenderRNA *brna)
 	RNA_def_struct_sdna(srna, "SimpleDeformModifierData");
 	RNA_def_struct_ui_icon(srna, ICON_MOD_SIMPLEDEFORM);
 
-	prop= RNA_def_property(srna, "mode", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "deform_method", PROP_ENUM, PROP_NONE);
+	RNA_def_property_enum_sdna(prop, NULL, "mode");
 	RNA_def_property_enum_items(prop, simple_deform_mode_items);
 	RNA_def_property_ui_text(prop, "Mode", "");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -2039,7 +2044,7 @@ static void rna_def_modifier_simpledeform(BlenderRNA *brna)
 	RNA_def_property_flag(prop, PROP_EDITABLE|PROP_ID_SELF_CHECK);
 	RNA_def_property_update(prop, 0, "rna_Modifier_dependency_update");
 
-	prop= RNA_def_property(srna, "relative", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_relative", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "originOpts", MOD_SIMPLEDEFORM_ORIGIN_LOCAL);
 	RNA_def_property_ui_text(prop, "Relative", "Sets the origin of deform space to be relative to the object");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
@@ -2150,7 +2155,7 @@ static void rna_def_modifier_solidify(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "High Quality Normals", "Calculate normals which result in more even thickness (slow, disable when not needed)");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
-	prop= RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "invert_vertex_group", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", MOD_SOLIDIFY_VGROUP_INV);
 	RNA_def_property_ui_text(prop, "Vertex Group Invert", "Invert the vertex group influence");
 	RNA_def_property_update(prop, 0, "rna_Modifier_update");
diff --git a/source/blender/makesrna/intern/rna_nla.c b/source/blender/makesrna/intern/rna_nla.c
index a812169e951..15c8608e523 100644
--- a/source/blender/makesrna/intern/rna_nla.c
+++ b/source/blender/makesrna/intern/rna_nla.c
@@ -430,7 +430,7 @@ static void rna_def_nlastrip(BlenderRNA *brna)
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_MUTED);
 	RNA_def_property_ui_text(prop, "Muted", "NLA Strip is not evaluated");
 	
-	prop= RNA_def_property(srna, "reversed", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_reverse", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_REVERSE);
 	RNA_def_property_ui_text(prop, "Reversed", "NLA Strip is played back in reverse order (only when timing is automatically determined)");
 	
diff --git a/source/blender/makesrna/intern/rna_nodetree.c b/source/blender/makesrna/intern/rna_nodetree.c
index e0507fc5401..0fb79de8c65 100644
--- a/source/blender/makesrna/intern/rna_nodetree.c
+++ b/source/blender/makesrna/intern/rna_nodetree.c
@@ -656,12 +656,12 @@ static void def_time(StructRNA *srna)
 	RNA_def_property_ui_text(prop, "Curve", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "start", PROP_INT, PROP_NONE);
+	prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_NONE);
 	RNA_def_property_int_sdna(prop, NULL, "custom1");
 	RNA_def_property_ui_text(prop, "Start Frame", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "end", PROP_INT, PROP_NONE);
+	prop = RNA_def_property(srna, "frame_end", PROP_INT, PROP_NONE);
 	RNA_def_property_int_sdna(prop, NULL, "custom2");
 	RNA_def_property_ui_text(prop, "End Frame", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
@@ -688,7 +688,7 @@ static void def_mix_rgb(StructRNA *srna)
 	RNA_def_property_ui_text(prop, "Blend Type", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "alpha", PROP_BOOLEAN, PROP_NONE);
+	prop = RNA_def_property(srna, "use_alpha", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "custom2", 1);
 	RNA_def_property_ui_text(prop, "Alpha", "Include alpha of second input in this operation");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
@@ -725,12 +725,12 @@ static void def_sh_material(StructRNA *srna)
 	RNA_def_property_ui_text(prop, "Material", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 
-	prop = RNA_def_property(srna, "diffuse", PROP_BOOLEAN, PROP_NONE);
+	prop = RNA_def_property(srna, "use_diffuse", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_DIFF);
 	RNA_def_property_ui_text(prop, "Diffuse", "Material Node outputs Diffuse");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 
-	prop = RNA_def_property(srna, "specular", PROP_BOOLEAN, PROP_NONE);
+	prop = RNA_def_property(srna, "use_specular", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "custom1", SH_NODE_MAT_SPEC);
 	RNA_def_property_ui_text(prop, "Specular", "Material Node outputs Specular");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
@@ -833,19 +833,19 @@ static void def_cmp_hue_saturation(StructRNA *srna)
 
 	RNA_def_struct_sdna_from(srna, "NodeHueSat", "storage");
 	
-	prop = RNA_def_property(srna, "hue", PROP_FLOAT, PROP_NONE);
+	prop = RNA_def_property(srna, "color_hue", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "hue");
 	RNA_def_property_range(prop, 0.0f, 1.0f);
 	RNA_def_property_ui_text(prop, "Hue", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "sat", PROP_FLOAT, PROP_NONE);
+	prop = RNA_def_property(srna, "color_saturation", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "sat");
 	RNA_def_property_range(prop, 0.0f, 2.0f);
 	RNA_def_property_ui_text(prop, "Saturation", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "val", PROP_FLOAT, PROP_NONE);
+	prop = RNA_def_property(srna, "color_value", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "val");
 	RNA_def_property_range(prop, 0.0f, 2.0f);
 	RNA_def_property_ui_text(prop, "Value", "");
@@ -881,7 +881,7 @@ static void def_cmp_blur(StructRNA *srna)
 	RNA_def_property_ui_text(prop, "Size Y", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 
-	prop = RNA_def_property(srna, "relative", PROP_BOOLEAN, PROP_NONE);
+	prop = RNA_def_property(srna, "use_relative", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "relative", 1);
 	RNA_def_property_ui_text(prop, "Relative", "Use relative (percent) values to define blur radius");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
@@ -910,12 +910,12 @@ static void def_cmp_blur(StructRNA *srna)
 	RNA_def_property_ui_text(prop, "Filter Type", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "bokeh", PROP_BOOLEAN, PROP_NONE);
+	prop = RNA_def_property(srna, "use_bokeh", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "bokeh", 1);
 	RNA_def_property_ui_text(prop, "Bokeh", "Uses circular filter (slower)");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "gamma", PROP_BOOLEAN, PROP_NONE);
+	prop = RNA_def_property(srna, "use_gamma_correction", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "gamma", 1);
 	RNA_def_property_ui_text(prop, "Gamma", "Applies filter on gamma corrected values");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
@@ -1008,7 +1008,7 @@ static void def_cmp_vector_blur(StructRNA *srna)
 	RNA_def_property_ui_text(prop, "Blur Factor", "Scaling factor for motion vectors; actually 'shutter speed' in frames");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "curved", PROP_BOOLEAN, PROP_NONE);
+	prop = RNA_def_property(srna, "use_curved", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "curved", 1);
 	RNA_def_property_ui_text(prop, "Curved", "Interpolate between frames in a bezier curve, rather than linearly");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
@@ -1055,25 +1055,25 @@ static void def_cmp_image(StructRNA *srna)
 	
 	RNA_def_struct_sdna_from(srna, "ImageUser", "storage");
 	
-	prop = RNA_def_property(srna, "frames", PROP_INT, PROP_NONE);
+	prop = RNA_def_property(srna, "frame_duration", PROP_INT, PROP_NONE);
 	RNA_def_property_int_sdna(prop, NULL, "frames");
 	RNA_def_property_range(prop, 1, MAXFRAMEF);
 	RNA_def_property_ui_text(prop, "Frames", "Number of images used in animation");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "start", PROP_INT, PROP_NONE);
+	prop = RNA_def_property(srna, "frame_start", PROP_INT, PROP_NONE);
 	RNA_def_property_int_sdna(prop, NULL, "sfra");
 	RNA_def_property_range(prop, 1, MAXFRAMEF);
 	RNA_def_property_ui_text(prop, "Start Frame", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "offset", PROP_INT, PROP_NONE);
+	prop = RNA_def_property(srna, "frame_offset", PROP_INT, PROP_NONE);
 	RNA_def_property_int_sdna(prop, NULL, "offset");
 	RNA_def_property_range(prop, MINAFRAMEF, MAXFRAMEF);
 	RNA_def_property_ui_text(prop, "Offset", "Offsets the number of the frame to use in the animation");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "cyclic", PROP_BOOLEAN, PROP_NONE);
+	prop = RNA_def_property(srna, "use_cyclic", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "cycl", 1);
 	RNA_def_property_ui_text(prop, "Cyclic", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
@@ -1219,7 +1219,7 @@ static void def_cmp_rotate(StructRNA *srna)
 		{2, "BICUBIC", 0, "Bicubic", ""},
 		{0, NULL, 0, NULL, NULL}};
 	
-	prop = RNA_def_property(srna, "filter", PROP_ENUM, PROP_NONE);
+	prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "custom1");
 	RNA_def_property_enum_items(prop, rotate_items);
 	RNA_def_property_ui_text(prop, "Filter", "Method to use to filter rotation");
@@ -1253,19 +1253,19 @@ static void def_cmp_color_matte(StructRNA *srna)
 	
 	RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
 
-	prop = RNA_def_property(srna, "h", PROP_FLOAT, PROP_NONE);
+	prop = RNA_def_property(srna, "color_hue", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "t1");
 	RNA_def_property_range(prop, 0.0f, 1.0f);
 	RNA_def_property_ui_text(prop, "H", "Hue tolerance for colors to be considered a keying color");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "s", PROP_FLOAT, PROP_NONE);
+	prop = RNA_def_property(srna, "color_saturation", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "t2");
 	RNA_def_property_range(prop, 0.0f, 1.0f);
 	RNA_def_property_ui_text(prop, "S", "Saturation Tolerance for the color");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "v", PROP_FLOAT, PROP_NONE);
+	prop = RNA_def_property(srna, "color_value", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "t3");
 	RNA_def_property_range(prop, 0.0f, 1.0f);
 	RNA_def_property_ui_text(prop, "V", "Value Tolerance for the color");
@@ -1370,14 +1370,14 @@ static void def_cmp_luma_matte(StructRNA *srna)
 	
 	RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
 	
-	prop = RNA_def_property(srna, "high", PROP_FLOAT, PROP_NONE);
+	prop = RNA_def_property(srna, "limit_max", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "t1");
 	RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t1_set", NULL);
 	RNA_def_property_range(prop, 0.0f, 1.0f);
 	RNA_def_property_ui_text(prop, "High", "Values higher than this setting are 100% opaque");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "low", PROP_FLOAT, PROP_NONE);
+	prop = RNA_def_property(srna, "limit_min", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "t2");
 	RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t2_set", NULL);
 	RNA_def_property_range(prop, 0.0f, 1.0f);
@@ -1398,7 +1398,7 @@ static void def_cmp_chroma_matte(StructRNA *srna)
 	RNA_def_property_ui_text(prop, "Acceptance", "Tolerance for a color to be considered a keying color");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "cutoff", PROP_FLOAT, PROP_NONE);
+	prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "t2");
 	RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t2_set", NULL);
 	RNA_def_property_range(prop, 0.0f, 30.0f);
@@ -1446,7 +1446,7 @@ static void def_cmp_channel_matte(StructRNA *srna)
 	RNA_def_property_ui_text(prop, "Color Space", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop= RNA_def_property(srna, "channel", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "matte_channel", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "custom2");
 	RNA_def_property_enum_items(prop, prop_tri_channel_items);
 	RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Node_channel_itemf");
@@ -1468,14 +1468,14 @@ static void def_cmp_channel_matte(StructRNA *srna)
 	RNA_def_property_ui_text(prop, "Limit Channel", "Limit by this channels value");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "high", PROP_FLOAT, PROP_NONE);
+	prop = RNA_def_property(srna, "limit_max", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "t1");
 	RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t1_set", NULL);
 	RNA_def_property_range(prop, 0.0f, 1.0f);
 	RNA_def_property_ui_text(prop, "High", "Values higher than this setting are 100% opaque");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "low", PROP_FLOAT, PROP_NONE);
+	prop = RNA_def_property(srna, "limit_min", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "t2");
 	RNA_def_property_float_funcs(prop, NULL, "rna_Matte_t2_set", NULL);
 	RNA_def_property_range(prop, 0.0f, 1.0f);
@@ -1591,7 +1591,7 @@ static void def_cmp_defocus(StructRNA *srna)
 	RNA_def_property_ui_text(prop, "Threshold", "CoC radius threshold, prevents background bleed on in-focus midground, 0=off");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "preview", PROP_BOOLEAN, PROP_NONE);
+	prop = RNA_def_property(srna, "use_preview", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "preview", 1);
 	RNA_def_property_ui_text(prop, "Preview", "Enable sampling mode, useful for preview when using low samplecounts");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
@@ -1618,12 +1618,12 @@ static void def_cmp_invert(StructRNA *srna)
 {
 	PropertyRNA *prop;
 	
-	prop = RNA_def_property(srna, "rgb", PROP_BOOLEAN, PROP_NONE);
+	prop = RNA_def_property(srna, "invert_rgb", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "custom1", CMP_CHAN_RGB);
 	RNA_def_property_ui_text(prop, "RGB", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "alpha", PROP_BOOLEAN, PROP_NONE);
+	prop = RNA_def_property(srna, "invert_alpha", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "custom1", CMP_CHAN_A);
 	RNA_def_property_ui_text(prop, "Alpha", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
@@ -1677,7 +1677,7 @@ static void def_cmp_dblur(StructRNA *srna)
 	RNA_def_property_ui_text(prop, "Iterations", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "wrap", PROP_BOOLEAN, PROP_NONE);
+	prop = RNA_def_property(srna, "use_wrap", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "wrap", 1);
 	RNA_def_property_ui_text(prop, "Wrap", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
@@ -1919,12 +1919,12 @@ static void def_cmp_lensdist(StructRNA *srna)
 	RNA_def_property_ui_text(prop, "Projector", "Enable/disable projector mode. Effect is applied in horizontal direction only");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "jitter", PROP_BOOLEAN, PROP_NONE);
+	prop = RNA_def_property(srna, "use_jitter", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "jit", 1);
 	RNA_def_property_ui_text(prop, "Jitter", "Enable/disable jittering; faster, but also noisier");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
 	
-	prop = RNA_def_property(srna, "fit", PROP_BOOLEAN, PROP_NONE);
+	prop = RNA_def_property(srna, "use_fit", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "fit", 1);
 	RNA_def_property_ui_text(prop, "Fit", "For positive distortion factor only: scale image such that black areas are not visible");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
@@ -2017,7 +2017,7 @@ static void def_tex_output(StructRNA *srna)
 
 	RNA_def_struct_sdna_from(srna, "TexNodeOutput", "storage");
 	
-	prop = RNA_def_property(srna, "output_name", PROP_STRING, PROP_NONE);
+	prop = RNA_def_property(srna, "filepath", PROP_STRING, PROP_NONE);
 	RNA_def_property_string_sdna(prop, NULL, "name");
 	RNA_def_property_ui_text(prop, "Output Name", "");
 	RNA_def_property_update(prop, NC_NODE|NA_EDITED, "rna_Node_update");
diff --git a/source/blender/makesrna/intern/rna_object_force.c b/source/blender/makesrna/intern/rna_object_force.c
index ded74c88dfb..1eadd0e7676 100644
--- a/source/blender/makesrna/intern/rna_object_force.c
+++ b/source/blender/makesrna/intern/rna_object_force.c
@@ -1530,7 +1530,7 @@ static void rna_def_softbody(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Push", "Edge spring stiffness when shorter than rest length");
 	RNA_def_property_update(prop, 0, "rna_softbody_update");
 	
-	prop= RNA_def_property(srna, "damp", PROP_FLOAT, PROP_NONE);
+	prop= RNA_def_property(srna, "damping", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "infrict");
 	RNA_def_property_range(prop, 0.0f, 50.0f);
 	RNA_def_property_ui_text(prop, "Damp", "Edge spring friction");
diff --git a/source/blender/makesrna/intern/rna_particle.c b/source/blender/makesrna/intern/rna_particle.c
index dd8f7196fb0..1151215f5f7 100644
--- a/source/blender/makesrna/intern/rna_particle.c
+++ b/source/blender/makesrna/intern/rna_particle.c
@@ -1156,7 +1156,7 @@ static void rna_def_particle_settings(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Died", "Show particles after they have died");
 	RNA_def_property_update(prop, 0, "rna_Particle_redo");
 
-	prop= RNA_def_property(srna, "trand", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_emit_random", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", PART_TRAND);
 	RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 	RNA_def_property_ui_text(prop, "Random", "Emit in random order of elements");
@@ -1294,7 +1294,7 @@ static void rna_def_particle_settings(BlenderRNA *brna)
 	RNA_def_property_update(prop, 0, "rna_Particle_reset");
 
 	/*draw flag*/
-	prop= RNA_def_property(srna, "velocity", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "show_velocity", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_VEL);
 	RNA_def_property_ui_text(prop, "Velocity", "Show particle velocity");
 	RNA_def_property_update(prop, 0, "rna_Particle_redo");
@@ -1304,7 +1304,7 @@ static void rna_def_particle_settings(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Size", "Show particle size");
 	RNA_def_property_update(prop, 0, "rna_Particle_redo");
 
-	prop= RNA_def_property(srna, "emitter", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_render_emitter", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_EMITTER);
 	RNA_def_property_ui_text(prop, "Emitter", "Render emitter Object also");
 	RNA_def_property_update(prop, 0, "rna_Particle_redo");
@@ -1324,7 +1324,7 @@ static void rna_def_particle_settings(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Lock Billboard", "Lock the billboards align axis");
 	RNA_def_property_update(prop, 0, "rna_Particle_redo");
 
-	prop= RNA_def_property(srna, "parent", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_parent_particles", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "draw", PART_DRAW_PARENT);
 	RNA_def_property_ui_text(prop, "Parents", "Render parent particles");
 	RNA_def_property_update(prop, 0, "rna_Particle_redo");
@@ -1434,7 +1434,7 @@ static void rna_def_particle_settings(BlenderRNA *brna)
 	RNA_def_property_range(prop, 0, 50);
 	RNA_def_property_ui_text(prop, "Pixel", "How many pixels path has to cover to make another render segment");
 
-	prop= RNA_def_property(srna, "display", PROP_INT, PROP_NONE);
+	prop= RNA_def_property(srna, "draw_percentage", PROP_INT, PROP_NONE);
 	RNA_def_property_int_sdna(prop, NULL, "disp");
 	RNA_def_property_range(prop, 0, 100);
 	RNA_def_property_ui_text(prop, "Display", "Percentage of particles to display in 3D view");
@@ -1518,7 +1518,7 @@ static void rna_def_particle_settings(BlenderRNA *brna)
 	RNA_def_property_boolean_sdna(prop, NULL, "simplify_flag", PART_SIMPLIFY_ENABLE);
 	RNA_def_property_ui_text(prop, "Child Simplification", "Remove child strands as the object becomes smaller on the screen");
 
-	prop= RNA_def_property(srna, "viewport", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_simplify_viewport", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "simplify_flag", PART_SIMPLIFY_VIEWPORT);
 	RNA_def_property_ui_text(prop, "Viewport", "");
 
@@ -1593,7 +1593,7 @@ static void rna_def_particle_settings(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Stiffness", "Hair stiffness for effectors");
 	RNA_def_property_update(prop, 0, "rna_Particle_redo");
 
-	prop= RNA_def_property(srna, "amount", PROP_INT, PROP_UNSIGNED);
+	prop= RNA_def_property(srna, "count", PROP_INT, PROP_UNSIGNED);
 	RNA_def_property_int_sdna(prop, NULL, "totpart");
 	RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 	/* This limit is for those freaks who have the machine power to handle it. */
diff --git a/source/blender/makesrna/intern/rna_property.c b/source/blender/makesrna/intern/rna_property.c
index 7bcb58ea28d..13f913b978b 100644
--- a/source/blender/makesrna/intern/rna_property.c
+++ b/source/blender/makesrna/intern/rna_property.c
@@ -121,7 +121,7 @@ void RNA_def_gameproperty(BlenderRNA *brna)
 	RNA_def_property_enum_funcs(prop, NULL, "rna_GameProperty_type_set", NULL);
 	RNA_def_property_update(prop, NC_LOGIC, NULL);
 
-	prop= RNA_def_property(srna, "debug", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "show_debug", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", PROP_DEBUG);
 	RNA_def_property_ui_text(prop, "Debug", "Print debug information for this property");
 	RNA_def_property_update(prop, NC_LOGIC, NULL);
diff --git a/source/blender/makesrna/intern/rna_sculpt_paint.c b/source/blender/makesrna/intern/rna_sculpt_paint.c
index 866df006447..3b83ec2d3ad 100644
--- a/source/blender/makesrna/intern/rna_sculpt_paint.c
+++ b/source/blender/makesrna/intern/rna_sculpt_paint.c
@@ -254,8 +254,8 @@ static void rna_def_vertex_paint(BlenderRNA *brna)
 	prop= RNA_def_property(srna, "use_all_faces", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", VP_AREA);
 	RNA_def_property_ui_text(prop, "All Faces", "Paint on all faces inside brush");
-		
-	prop= RNA_def_property(srna, "normals", PROP_BOOLEAN, PROP_NONE);
+
+	prop= RNA_def_property(srna, "use_normal", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", VP_NORMALS);
 	RNA_def_property_ui_text(prop, "Normals", "Applies the vertex normal before painting");
 	
diff --git a/source/blender/makesrna/intern/rna_sequencer.c b/source/blender/makesrna/intern/rna_sequencer.c
index 89c7c5f37b0..d3207f14e24 100644
--- a/source/blender/makesrna/intern/rna_sequencer.c
+++ b/source/blender/makesrna/intern/rna_sequencer.c
@@ -671,22 +671,26 @@ static void rna_def_strip_crop(BlenderRNA *brna)
 	RNA_def_struct_ui_text(srna, "Sequence Crop", "Cropping parameters for a sequence strip");
 	RNA_def_struct_sdna(srna, "StripCrop");
 
-	prop= RNA_def_property(srna, "top", PROP_INT, PROP_UNSIGNED);
+	prop= RNA_def_property(srna, "max_y", PROP_INT, PROP_UNSIGNED);
+	RNA_def_property_int_sdna(prop, NULL, "top");
 	RNA_def_property_ui_text(prop, "Top", "");
 	RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
 	RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
 	
-	prop= RNA_def_property(srna, "bottom", PROP_INT, PROP_UNSIGNED);
+	prop= RNA_def_property(srna, "min_x", PROP_INT, PROP_UNSIGNED);
+	RNA_def_property_int_sdna(prop, NULL, "bottom");
 	RNA_def_property_ui_text(prop, "Bottom", "");
 	RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
 	RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
 	
-	prop= RNA_def_property(srna, "left", PROP_INT, PROP_UNSIGNED);
+	prop= RNA_def_property(srna, "min_y", PROP_INT, PROP_UNSIGNED);
+	RNA_def_property_int_sdna(prop, NULL, "left");
 	RNA_def_property_ui_text(prop, "Left", "");
 	RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
 	RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
 
-	prop= RNA_def_property(srna, "right", PROP_INT, PROP_UNSIGNED);
+	prop= RNA_def_property(srna, "max_x", PROP_INT, PROP_UNSIGNED);
+	RNA_def_property_int_sdna(prop, NULL, "right");
 	RNA_def_property_ui_text(prop, "Right", "");
 	RNA_def_property_ui_range(prop, 0, 4096, 1, 0);
 	RNA_def_property_update(prop, NC_SCENE|ND_SEQUENCER, "rna_Sequence_update");
diff --git a/source/blender/makesrna/intern/rna_texture.c b/source/blender/makesrna/intern/rna_texture.c
index 731a7b62213..567166fd15f 100644
--- a/source/blender/makesrna/intern/rna_texture.c
+++ b/source/blender/makesrna/intern/rna_texture.c
@@ -464,7 +464,8 @@ static void rna_def_mtex(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Offset", "Fine tunes texture mapping X, Y and Z locations");
 	RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
 
-	prop= RNA_def_property(srna, "size", PROP_FLOAT, PROP_XYZ);
+	prop= RNA_def_property(srna, "scale", PROP_FLOAT, PROP_XYZ);
+	RNA_def_property_float_sdna(prop, NULL, "size");
 	RNA_def_property_ui_range(prop, -100, 100, 10, 2);
 	RNA_def_property_ui_text(prop, "Size", "Sets scaling for the texture's X, Y and Z sizes");
 	RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
@@ -486,7 +487,7 @@ static void rna_def_mtex(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Stencil", "Use this texture as a blending value on the next texture");
 	RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
 
-	prop= RNA_def_property(srna, "negate", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "invert", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "texflag", MTEX_NEGATIVE);
 	RNA_def_property_ui_text(prop, "Negate", "Inverts the values of the texture to reverse its effect");
 	RNA_def_property_update(prop, 0, "rna_TextureSlot_update");
@@ -514,7 +515,7 @@ static void rna_def_filter_common(StructRNA *srna)
 {
 	PropertyRNA *prop;
 	
-	prop= RNA_def_property(srna, "mipmap", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_mipmap", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "imaflag", TEX_MIPMAP);
 	RNA_def_property_boolean_funcs(prop, NULL, "rna_ImageTexture_mipmap_set");
 	RNA_def_property_ui_text(prop, "MIP Map", "Uses auto-generated MIP maps for the image");
@@ -525,7 +526,7 @@ static void rna_def_filter_common(StructRNA *srna)
 	RNA_def_property_ui_text(prop, "MIP Map Gaussian filter", "Uses Gauss filter to sample down MIP maps");
 	RNA_def_property_update(prop, 0, "rna_Texture_update");
 	
-	prop= RNA_def_property(srna, "filter", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "texfilter");
 	RNA_def_property_enum_items(prop, texture_filter_items);
 	RNA_def_property_ui_text(prop, "Filter", "Texture filter to use for sampling image");
@@ -692,7 +693,7 @@ static void rna_def_texture_clouds(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Noise Type", "");
 	RNA_def_property_update(prop, 0, "rna_Texture_nodes_update");
 
-	prop= RNA_def_property(srna, "stype", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "cloud_type", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "stype");
 	RNA_def_property_enum_items(prop, prop_clouds_stype);
 	RNA_def_property_ui_text(prop, "Color", "");
@@ -753,7 +754,7 @@ static void rna_def_texture_wood(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Noise Type", "");
 	RNA_def_property_update(prop, 0, "rna_Texture_nodes_update");
 
-	prop= RNA_def_property(srna, "stype", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "wood_type", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "stype");
 	RNA_def_property_enum_items(prop, prop_wood_stype);
 	RNA_def_property_ui_text(prop, "Pattern", "");
@@ -821,7 +822,7 @@ static void rna_def_texture_marble(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Noise Type", "");
 	RNA_def_property_update(prop, 0, "rna_Texture_nodes_update");
 
-	prop= RNA_def_property(srna, "stype", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "marble_type", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "stype");
 	RNA_def_property_enum_items(prop, prop_marble_stype);
 	RNA_def_property_ui_text(prop, "Pattern", "");
@@ -950,7 +951,7 @@ static void rna_def_texture_stucci(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Noise Type", "");
 	RNA_def_property_update(prop, 0, "rna_Texture_update");
 
-	prop= RNA_def_property(srna, "stype", PROP_ENUM, PROP_NONE);
+	prop= RNA_def_property(srna, "stucci_type", PROP_ENUM, PROP_NONE);
 	RNA_def_property_enum_sdna(prop, NULL, "stype");
 	RNA_def_property_enum_items(prop, prop_stucci_stype);
 	RNA_def_property_ui_text(prop, "Pattern", "");
@@ -990,7 +991,7 @@ static void rna_def_texture_image(BlenderRNA *brna)
 	RNA_def_struct_ui_text(srna, "Image Texture", "");
 	RNA_def_struct_sdna(srna, "Tex");
 
-	prop= RNA_def_property(srna, "interpolation", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_interpolation", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "imaflag", TEX_INTERPOL);
 	RNA_def_property_ui_text(prop, "Interpolation", "Interpolates pixels using Area filter");
 	RNA_def_property_update(prop, 0, "rna_Texture_update");
@@ -1624,7 +1625,7 @@ static void rna_def_texture_voxeldata(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Resolution", "Resolution of the voxel grid");
 	RNA_def_property_update(prop, 0, "rna_Texture_voxeldata_update");
 	
-	prop= RNA_def_property(srna, "still", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_still_frame", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "flag", TEX_VD_STILL);
 	RNA_def_property_ui_text(prop, "Still Frame Only", "Always render a still frame from the voxel data sequence");
 	RNA_def_property_update(prop, 0, "rna_Texture_voxeldata_update");
@@ -1696,7 +1697,7 @@ static void rna_def_texture(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Color Ramp", "");
 	RNA_def_property_update(prop, 0, "rna_Texture_update");
 
-	prop= RNA_def_property(srna, "brightness", PROP_FLOAT, PROP_NONE);
+	prop= RNA_def_property(srna, "intensity", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "bright");
 	RNA_def_property_range(prop, 0, 2);
 	RNA_def_property_ui_text(prop, "Brightness", "");
diff --git a/source/blender/makesrna/intern/rna_world.c b/source/blender/makesrna/intern/rna_world.c
index 421044f68d6..f792f13258f 100644
--- a/source/blender/makesrna/intern/rna_world.c
+++ b/source/blender/makesrna/intern/rna_world.c
@@ -324,7 +324,7 @@ static void rna_def_lighting(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Correction", "Ad-hoc correction for over-occlusion due to the approximation (for Approximate)");
 	RNA_def_property_update(prop, 0, "rna_World_update");
 
-	prop= RNA_def_property(srna, "falloff", PROP_BOOLEAN, PROP_NONE);
+	prop= RNA_def_property(srna, "use_falloff", PROP_BOOLEAN, PROP_NONE);
 	RNA_def_property_boolean_sdna(prop, NULL, "aomode", WO_AODIST);
 	RNA_def_property_ui_text(prop, "Falloff", "");
 	RNA_def_property_update(prop, 0, "rna_World_update");
@@ -502,7 +502,7 @@ void RNA_def_world(BlenderRNA *brna)
 	RNA_def_property_ui_text(prop, "Exposure", "Amount of exponential color correction for light");
 	RNA_def_property_update(prop, 0, "rna_World_update");
 
-	prop= RNA_def_property(srna, "range", PROP_FLOAT, PROP_NONE);
+	prop= RNA_def_property(srna, "color_range", PROP_FLOAT, PROP_NONE);
 	RNA_def_property_float_sdna(prop, NULL, "range");
 	RNA_def_property_range(prop, 0.2, 5.0);
 	RNA_def_property_ui_text(prop, "Range", "The color range that will be mapped to 0-1");
@@ -525,19 +525,19 @@ void RNA_def_world(BlenderRNA *brna)
 	RNA_def_property_update(prop, 0, "rna_World_update");
 
 	/* nested structs */
-	prop= RNA_def_property(srna, "lighting", PROP_POINTER, PROP_NONE);
+	prop= RNA_def_property(srna, "light_settings", PROP_POINTER, PROP_NONE);
 	RNA_def_property_flag(prop, PROP_NEVER_NULL);
 	RNA_def_property_struct_type(prop, "WorldLighting");
 	RNA_def_property_pointer_funcs(prop, "rna_World_lighting_get", NULL, NULL, NULL);
 	RNA_def_property_ui_text(prop, "Lighting", "World lighting settings");
 
-	prop= RNA_def_property(srna, "mist", PROP_POINTER, PROP_NONE);
+	prop= RNA_def_property(srna, "mist_settings", PROP_POINTER, PROP_NONE);
 	RNA_def_property_flag(prop, PROP_NEVER_NULL);
 	RNA_def_property_struct_type(prop, "WorldMistSettings");
 	RNA_def_property_pointer_funcs(prop, "rna_World_mist_get", NULL, NULL, NULL);
 	RNA_def_property_ui_text(prop, "Mist", "World mist settings");
 
-	prop= RNA_def_property(srna, "stars", PROP_POINTER, PROP_NONE);
+	prop= RNA_def_property(srna, "star_settings", PROP_POINTER, PROP_NONE);
 	RNA_def_property_flag(prop, PROP_NEVER_NULL);
 	RNA_def_property_struct_type(prop, "WorldStarsSettings");
 	RNA_def_property_pointer_funcs(prop, "rna_World_stars_get", NULL, NULL, NULL);
diff --git a/source/blender/makesrna/rna_cleanup/rna_properties.txt b/source/blender/makesrna/rna_cleanup/rna_properties.txt
index 18f6af11876..b319ce15ba1 100644
--- a/source/blender/makesrna/rna_cleanup/rna_properties.txt
+++ b/source/blender/makesrna/rna_cleanup/rna_properties.txt
@@ -370,7 +370,7 @@
 #Constraint.error_rotation -> error_rotation:   float,  "(read-only)    Amount of residual error in radiant for constraints that work on orientation"
 #+ * Constraint.influence -> influence:   float  "Amount of influence constraint will have on the final solution"
 #Constraint.is_proxy_local -> is_proxy_local:   boolean  "Constraint was added in this proxy instance (i.e. did not belong to source Armature)"
- + * Constraint.disabled -> is_valid:   boolean,  "(read-only)    Constraint has invalid settings and will not be evaluated"
+#Constraint.is_valid -> is_valid:   boolean,  "(read-only)    Constraint has invalid settings and will not be evaluated"
 #+ * Constraint.mute -> mute:   boolean  "Enable/Disable Constraint"
 #+ * Constraint.name -> name:   string  "Constraint name"
 #+ * Constraint.owner_space -> owner_space:   enum  "Space that owner is evaluated in"
@@ -400,7 +400,7 @@
 #+ * Constraint|ChildOfConstraint.use_scale_z -> use_scale_z:   boolean  "Use Z Scale of Parent"
 #+ * Constraint|ClampToConstraint.main_axis -> main_axis:   enum  "Main axis of movement"
 #+ * Constraint|ClampToConstraint.target -> target:   pointer  "Target Object"
- + * Constraint|ClampToConstraint.cyclic -> use_cyclic:   boolean  "Treat curve as cyclic curve (no clamping to curve bounding box"
+#Constraint|ClampToConstraint.use_cyclic -> use_cyclic:   boolean  "Treat curve as cyclic curve (no clamping to curve bounding box"
 #+ * Constraint|CopyLocationConstraint.head_tail -> head_tail:   float  "Target along length of bone: Head=0, Tail=1"
 #+ * Constraint|CopyLocationConstraint.invert_x -> invert_x:   boolean  "Invert the X location"
 #+ * Constraint|CopyLocationConstraint.invert_y -> invert_y:   boolean  "Invert the Y location"
@@ -431,18 +431,18 @@
 #+ * Constraint|CopyTransformsConstraint.target -> target:   pointer  "Target Object"
 #+ * Constraint|DampedTrackConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
 #+ * Constraint|DampedTrackConstraint.target -> target:   pointer  "Target Object"
- + * Constraint|DampedTrackConstraint.track -> track_axis:   enum  "Axis that points to the target object"
+#Constraint|DampedTrackConstraint.track_axis -> track_axis:   enum  "Axis that points to the target object"
 #+ * Constraint|FloorConstraint.floor_location -> floor_location:   enum  "Location of target that object will not pass through"
 #+ * Constraint|FloorConstraint.offset -> offset:   float  "Offset of floor from object origin"
 #+ * Constraint|FloorConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
 #+ * Constraint|FloorConstraint.target -> target:   pointer  "Target Object"
 #+ * Constraint|FloorConstraint.use_rotation -> use_rotation:   boolean  "Use the targets rotation to determine floor"
- + * Constraint|FloorConstraint.sticky -> use_sticky:   boolean  "Immobilize object while constrained"
- + * Constraint|FollowPathConstraint.forward -> forward_axis:   enum  "Axis that points forward along the path"
+#Constraint|FloorConstraint.use_sticky -> use_sticky:   boolean  "Immobilize object while constrained"
+#Constraint|FollowPathConstraint.forward_axis -> forward_axis:   enum  "Axis that points forward along the path"
 #+ * Constraint|FollowPathConstraint.offset -> offset:   int  "Offset from the position corresponding to the time frame"
 #+ * Constraint|FollowPathConstraint.offset_factor -> offset_factor:   float  "Percentage value defining target position along length of bone"
 #+ * Constraint|FollowPathConstraint.target -> target:   pointer  "Target Object"
- + * Constraint|FollowPathConstraint.up -> up_axis:   enum  "Axis that points upward"
+#Constraint|FollowPathConstraint.up_axis -> up_axis:   enum  "Axis that points upward"
 #+ * Constraint|FollowPathConstraint.use_curve_follow -> use_curve_follow:   boolean  "Object will follow the heading and banking of the curve"
 #+ * Constraint|FollowPathConstraint.use_curve_radius -> use_curve_radius:   boolean  "Objects scale by the curve radius"
 #Constraint|FollowPathConstraint.use_fixed_location -> use_fixed_location:   boolean  "Object will stay locked to a single point somewhere along the length of the curve regardless of time"
@@ -510,11 +510,11 @@
 #Constraint|LimitScaleConstraint.use_min_y -> use_min_y:   boolean  "Use the minimum Y value"
 #Constraint|LimitScaleConstraint.use_min_z -> use_min_z:   boolean  "Use the minimum Z value"
 #Constraint|LimitScaleConstraint.use_transform_limit -> use_transform_limit:   boolean  "Transforms are affected by this constraint as well"
- + * Constraint|LockedTrackConstraint.lock -> lock_axis:   enum  "Axis that points upward"
+#Constraint|LockedTrackConstraint.lock_axis -> lock_axis:   enum  "Axis that points upward"
 #+ * Constraint|LockedTrackConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
 #+ * Constraint|LockedTrackConstraint.target -> target:   pointer  "Target Object"
- + * Constraint|LockedTrackConstraint.track -> track_axis:   enum  "Axis that points to the target object"
- + * Constraint|MaintainVolumeConstraint.axis -> free_axis:   enum  "The free scaling axis of the object"
+#Constraint|LockedTrackConstraint.track_axis -> track_axis:   enum  "Axis that points to the target object"
+#Constraint|MaintainVolumeConstraint.free_axis -> free_axis:   enum  "The free scaling axis of the object"
 #+ * Constraint|MaintainVolumeConstraint.volume -> volume:   float  "Volume of the bone at rest"
 #+ * Constraint|PivotConstraint.head_tail -> head_tail:   float  "Target along length of bone: Head=0, Tail=1"
 #+ * Constraint|PivotConstraint.offset -> offset:   float[3]  "Offset of pivot from target (when set), or from owners location (when Fixed Position is off), or the absolute pivot point"
@@ -562,8 +562,8 @@
 #+ * Constraint|TrackToConstraint.head_tail -> head_tail:   float  "Target along length of bone: Head=0, Tail=1"
 #+ * Constraint|TrackToConstraint.subtarget -> subtarget:   string  "NO DESCRIPTION"
 #+ * Constraint|TrackToConstraint.target -> target:   pointer  "Target Object"
- + * Constraint|TrackToConstraint.track -> track_axis:   enum  "Axis that points to the target object"
- + * Constraint|TrackToConstraint.up -> up_axis:   enum  "Axis that points upward"
+#Constraint|TrackToConstraint.track_axis -> track_axis:   enum  "Axis that points to the target object"
+#Constraint|TrackToConstraint.up_axis -> up_axis:   enum  "Axis that points upward"
 #Constraint|TrackToConstraint.use_target_z -> use_target_z:   boolean  "Targets Z axis, not World Z axis, will constraint the Up direction"
 #+ * Constraint|TransformConstraint.from_max_x -> from_max_x:   float  "Top range of X axis source motion"
 #+ * Constraint|TransformConstraint.from_max_y -> from_max_y:   float  "Top range of Y axis source motion"
@@ -981,7 +981,7 @@
 #GameObjectSettings.velocity_max -> velocity_max:   float  "Clamp velocity to this maximum speed"
 #GameObjectSettings.velocity_min -> velocity_min:   float  "Clamp velocity to this minimum speed (except when totally still)"
 #+ * GameProperty.name -> name:   string  "Available as GameObject attributes in the game engines python API"
- + * GameProperty.debug -> show_debug:   boolean  "Print debug information for this property"
+#GameProperty.show_debug -> show_debug:   boolean  "Print debug information for this property"
 #+ * GameProperty.type -> type:   enum  "NO DESCRIPTION"
 #+ * GameProperty|GameBooleanProperty.value -> value:   boolean  "Property value"
 #+ * GameProperty|GameFloatProperty.value -> value:   float  "Property value"
@@ -1251,7 +1251,7 @@
 #ID|Image.use_clamp_y -> use_clamp_y:   boolean  "Disable texture repeating vertically"
 #ID|Image.use_fields -> use_fields:   boolean  "Use fields of the image"
 #ID|Image.use_premultiply -> use_premultiply:   boolean  "Convert RGB from key alpha to premultiplied alpha"
- + * ID|Image.tiles -> use_tiles:   boolean  "Use of tilemode for faces (default shift-LMB to pick the tile for selected faces)"
+#ID|Image.use_tiles -> use_tiles:   boolean  "Use of tilemode for faces (default shift-LMB to pick the tile for selected faces)"
 #+ * ID|Key.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
 #+ * ID|Key.keys -> keys:   collection,  "(read-only)    Shape keys"
 #+ * ID|Key.reference_key -> reference_key:   pointer,  "(read-only)"
@@ -1266,10 +1266,10 @@
 #+ * ID|Lamp.energy -> energy:   float  "Amount of light that the lamp emits"
 #+ * ID|Lamp.texture_slots -> texture_slots:   collection,  "(read-only)    Texture slots defining the mapping and influence of textures"
 #+ * ID|Lamp.type -> type:   enum  "Type of Lamp"
- + * ID|Lamp.diffuse -> use_diffuse:   boolean  "Lamp does diffuse shading"
- + * ID|Lamp.negative -> use_negative:   boolean  "Lamp casts negative light"
- + * ID|Lamp.layer -> use_own_layer:   boolean  "Illuminates objects only on the same layer the lamp is on"
- + * ID|Lamp.specular -> use_specular:   boolean  "Lamp creates specular highlights"
+#ID|Lamp.use_diffuse -> use_diffuse:   boolean  "Lamp does diffuse shading"
+#ID|Lamp.use_negative -> use_negative:   boolean  "Lamp casts negative light"
+#ID|Lamp.use_own_layer -> use_own_layer:   boolean  "Illuminates objects only on the same layer the lamp is on"
+#ID|Lamp.use_specular -> use_specular:   boolean  "Lamp creates specular highlights"
 #+ * ID|Lamp|AreaLamp.gamma -> gamma:   float  "Light gamma correction value"
 #+ * ID|Lamp|AreaLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:   float  "Threshold for Adaptive Sampling (Raytraced shadows)"
 #+ * ID|Lamp|AreaLamp.shadow_color -> shadow_color:   float[3]  "Color of shadows cast by the lamp"
@@ -1281,8 +1281,8 @@
 #+ * ID|Lamp|AreaLamp.shape -> shape:   enum  "Shape of the area lamp"
 #+ * ID|Lamp|AreaLamp.size -> size:   float  "Size of the area of the area Lamp, X direction size for Rectangle shapes"
 #+ * ID|Lamp|AreaLamp.size_y -> size_y:   float  "Size of the area of the area Lamp in the Y direction for Rectangle shapes"
- + * ID|Lamp|AreaLamp.dither -> use_dither:   boolean  "Use 2x2 dithering for sampling  (Constant Jittered sampling)"
- + * ID|Lamp|AreaLamp.jitter -> use_jitter:   boolean  "Use noise for sampling  (Constant Jittered sampling)"
+#ID|Lamp|AreaLamp.use_dither -> use_dither:   boolean  "Use 2x2 dithering for sampling  (Constant Jittered sampling)"
+#ID|Lamp|AreaLamp.use_jitter -> use_jitter:   boolean  "Use noise for sampling  (Constant Jittered sampling)"
 #ID|Lamp|AreaLamp.use_only_shadow -> use_only_shadow:   boolean  "Causes light to cast shadows only without illuminating objects"
 #ID|Lamp|AreaLamp.use_shadow_layer -> use_shadow_layer:   boolean  "Causes only objects on the same layer to cast shadows"
 #ID|Lamp|AreaLamp.use_umbra -> use_umbra:   boolean  "Emphasize parts that are fully shadowed (Constant Jittered sampling)"
@@ -1330,7 +1330,7 @@
 #ID|Lamp|SpotLamp.use_only_shadow -> use_only_shadow:   boolean  "Causes light to cast shadows only without illuminating objects"
 #ID|Lamp|SpotLamp.use_shadow_layer -> use_shadow_layer:   boolean  "Causes only objects on the same layer to cast shadows"
 #ID|Lamp|SpotLamp.use_sphere -> use_sphere:   boolean  "Sets light intensity to zero beyond lamp distance"
- + * ID|Lamp|SpotLamp.square -> use_square:   boolean  "Casts a square spot light shape"
+#ID|Lamp|SpotLamp.use_square -> use_square:   boolean  "Casts a square spot light shape"
 #+ * ID|Lamp|SunLamp.shadow_adaptive_threshold -> shadow_adaptive_threshold:   float  "Threshold for Adaptive Sampling (Raytraced shadows)"
 #+ * ID|Lamp|SunLamp.shadow_color -> shadow_color:   float[3]  "Color of shadows cast by the lamp"
 #+ * ID|Lamp|SunLamp.shadow_method -> shadow_method:   enum  "Method to compute lamp shadow with"
@@ -1407,7 +1407,7 @@
 #ID|Material.use_cast_approximate -> use_cast_approximate:   boolean  "Allow this material to cast shadows when using approximate ambient occlusion."
 #ID|Material.use_cast_buffer_shadows -> use_cast_buffer_shadows:   boolean  "Allow this material to cast shadows from shadow buffer lamps"
 #ID|Material.use_cast_shadows_only -> use_cast_shadows_only:   boolean  "Makes objects with this material appear invisible, only casting shadows (not rendered)"
- + * ID|Material.cubic -> use_cubic:   boolean  "Use cubic interpolation for diffuse values, for smoother transitions"
+#ID|Material.use_cubic -> use_cubic:   boolean  "Use cubic interpolation for diffuse values, for smoother transitions"
 #+ * ID|Material.use_diffuse_ramp -> use_diffuse_ramp:   boolean  "Toggle diffuse ramp operations"
 #ID|Material.use_face_texture -> use_face_texture:   boolean  "Replaces the objects base color with color from face assigned image textures"
 #ID|Material.use_face_texture_alpha -> use_face_texture_alpha:   boolean  "Replaces the objects base alpha value with alpha from face assigned image textures"
@@ -1420,7 +1420,7 @@
 #ID|Material.use_ray_shadow_bias -> use_ray_shadow_bias:   boolean  "Prevents raytraced shadow errors on surfaces with smooth shaded normals (terminator problem)"
 #ID|Material.use_raytrace -> use_raytrace:   boolean  "Include this material and geometry that uses it in ray tracing calculations"
 #ID|Material.use_shadeless -> use_shadeless:   boolean  "Makes this material insensitive to light or shadow"
- + * ID|Material.shadows -> use_shadows:   boolean  "Allows this material to receive shadows"
+#ID|Material.use_shadows -> use_shadows:   boolean  "Allows this material to receive shadows"
 #+ * ID|Material.use_sky -> use_sky:   boolean  "Renders this material with zero alpha, with sky background in place (scanline only)"
 #+ * ID|Material.use_specular_ramp -> use_specular_ramp:   boolean  "Toggle specular ramp operations"
 #ID|Material.use_tangent_shading -> use_tangent_shading:   boolean  "Use the materials tangent vector instead of the normal for shading - for anisotropic shading effects"
@@ -1611,12 +1611,12 @@
 #+ * ID|ParticleSettings.child_type -> child_type:   enum  "Create child particles"
 #+ * ID|ParticleSettings.clump_factor -> clump_factor:   float  "Amount of clumping"
 #ID|ParticleSettings.clump_shape -> clump_shape:   float  "Shape of clumping"
- + * ID|ParticleSettings.amount -> count:   int  "Total number of particles"
+#ID|ParticleSettings.count -> count:   int  "Total number of particles"
 #ID|ParticleSettings.damping -> damping:   float  "Specify the amount of damping"
 #+ * ID|ParticleSettings.distribution -> distribution:   enum  "How to distribute particles on selected element"
 #+ * ID|ParticleSettings.drag_factor -> drag_factor:   float  "Specify the amount of air-drag"
 #ID|ParticleSettings.draw_method -> draw_method:   enum  "How particles are drawn in viewport"
- + * ID|ParticleSettings.display -> draw_percentage:   int  "Percentage of particles to display in 3D view"
+#ID|ParticleSettings.draw_percentage -> draw_percentage:   int  "Percentage of particles to display in 3D view"
 #+ * ID|ParticleSettings.draw_size -> draw_size:   int  "Size of particles on viewport in pixels (0=default)"
 #+ * ID|ParticleSettings.draw_step -> draw_step:   int  "How many steps paths are drawn with (power of 2)"
 #+ * ID|ParticleSettings.dupli_group -> dupli_group:   pointer  "Show Objects in this Group in place of particles"
@@ -1682,7 +1682,7 @@
 #ID|ParticleSettings.show_number -> show_number:   boolean  "Show particle number"
 #+ * ID|ParticleSettings.show_size -> show_size:   boolean  "Show particle size"
 #ID|ParticleSettings.show_unborn -> show_unborn:   boolean  "Show particles before they are emitted"
- + * ID|ParticleSettings.velocity -> show_velocity:   boolean  "Show particle velocity"
+#ID|ParticleSettings.show_velocity -> show_velocity:   boolean  "Show particle velocity"
 #+ * ID|ParticleSettings.simplify_rate -> simplify_rate:   float  "Speed of simplification"
 #+ * ID|ParticleSettings.simplify_refsize -> simplify_refsize:   int  "Reference size in pixels, after which simplification begins"
 #+ * ID|ParticleSettings.simplify_transition -> simplify_transition:   float  "Transition period for fading out strands"
@@ -1700,21 +1700,21 @@
 #ID|ParticleSettings.use_dead -> use_dead:   boolean  "Show particles after they have died"
 #ID|ParticleSettings.use_die_on_collision -> use_die_on_collision:   boolean  "Particles die when they collide with a deflector object"
 #ID|ParticleSettings.use_dynamic_rotation -> use_dynamic_rotation:   boolean  "Sets rotation to dynamic/constant"
- + * ID|ParticleSettings.trand -> use_emit_random:   boolean  "Emit in random order of elements"
+#ID|ParticleSettings.use_emit_random -> use_emit_random:   boolean  "Emit in random order of elements"
 #ID|ParticleSettings.use_even_distribution -> use_even_distribution:   boolean  "Use even distribution from faces based on face areas or edge lengths"
 #+ * ID|ParticleSettings.use_global_dupli -> use_global_dupli:   boolean  "Use objects global coordinates for duplication"
 #+ * ID|ParticleSettings.use_group_count -> use_group_count:   boolean  "Use object multiple times in the same group"
 #ID|ParticleSettings.use_group_pick_random -> use_group_pick_random:   boolean  "Pick objects from group randomly"
 #ID|ParticleSettings.use_hair_bspline -> use_hair_bspline:   boolean  "Interpolate hair using B-Splines"
 #ID|ParticleSettings.use_multiply_size_mass -> use_multiply_size_mass:   boolean  "Multiply mass by particle size"
- + * ID|ParticleSettings.parent -> use_parent_particles:   boolean  "Render parent particles"
+#ID|ParticleSettings.use_parent_particles -> use_parent_particles:   boolean  "Render parent particles"
 #ID|ParticleSettings.use_react_multiple -> use_react_multiple:   boolean  "React multiple times"
 #ID|ParticleSettings.use_react_start_end -> use_react_start_end:   boolean  "Give birth to unreacted particles eventually"
 #ID|ParticleSettings.use_render_adaptive -> use_render_adaptive:   boolean  "Draw steps of the particle path"
- + * ID|ParticleSettings.emitter -> use_render_emitter:   boolean  "Render emitter Object also"
+#ID|ParticleSettings.use_render_emitter -> use_render_emitter:   boolean  "Render emitter Object also"
 #ID|ParticleSettings.use_self_effect -> use_self_effect:   boolean  "Particle effectors effect themselves"
 #ID|ParticleSettings.use_simplify -> use_simplify:   boolean  "Remove child strands as the object becomes smaller on the screen"
- + * ID|ParticleSettings.viewport -> use_simplify_viewport:   boolean  "NO DESCRIPTION"
+#ID|ParticleSettings.use_simplify_viewport -> use_simplify_viewport:   boolean  "NO DESCRIPTION"
 #ID|ParticleSettings.use_size_deflect -> use_size_deflect:   boolean  "Use particles size in deflection"
 #ID|ParticleSettings.use_strand_primitive -> use_strand_primitive:   boolean  "Use the strand primitive for rendering"
 #ID|ParticleSettings.use_symmetric_branching -> use_symmetric_branching:   boolean  "Start and end points are the same"
@@ -1790,7 +1790,7 @@
 #+TODO MAKE COLOR * ID|Texture.factor_blue -> factor_blue:   float  "NO DESCRIPTION"
 #+TODO MAKE COLOR * ID|Texture.factor_green -> factor_green:   float  "NO DESCRIPTION"
 #+TODO MAKE COLOR * ID|Texture.factor_red -> factor_red:   float  "NO DESCRIPTION"
- + * ID|Texture.brightness -> intensity:   float  "NO DESCRIPTION"
+#ID|Texture.intensity -> intensity:   float  "NO DESCRIPTION"
 #+ * ID|Texture.node_tree -> node_tree:   pointer,  "(read-only)    Node tree for node-based textures"
 #+ * ID|Texture.saturation -> saturation:   float  "NO DESCRIPTION"
 #+ * ID|Texture.type -> type:   enum  "NO DESCRIPTION"
@@ -1799,7 +1799,7 @@
 #+ * ID|Texture.use_preview_alpha -> use_preview_alpha:   boolean  "Show Alpha in Preview Render"
 #+ * ID|Texture|BlendTexture.progression -> progression:   enum  "Sets the style of the color blending"
 #ID|Texture|BlendTexture.use_flip_axis -> use_flip_axis:   enum  "Flips the textures X and Y axis"
- + * ID|Texture|CloudsTexture.stype -> cloud_type:   enum  "NO DESCRIPTION"
+#ID|Texture|CloudsTexture.cloud_type -> cloud_type:   enum  "NO DESCRIPTION"
 #+ * ID|Texture|CloudsTexture.nabla -> nabla:   float  "Size of derivative offset used for calculating normal"
 #+ * ID|Texture|CloudsTexture.noise_basis -> noise_basis:   enum  "Sets the noise basis used for turbulence"
 #+ * ID|Texture|CloudsTexture.noise_depth -> noise_depth:   int  "Sets the depth of the cloud calculation"
@@ -1814,11 +1814,11 @@
 #+ * ID|Texture|EnvironmentMapTexture.filter_eccentricity -> filter_eccentricity:   int  "Maximum eccentricity. Higher gives less blur at distant/oblique angles, but is also slower"
 #+ * ID|Texture|EnvironmentMapTexture.filter_probes -> filter_probes:   int  "Maximum number of samples. Higher gives less blur at distant/oblique angles, but is also slower"
 #+ * ID|Texture|EnvironmentMapTexture.filter_size -> filter_size:   float  "Multiplies the filter size used by MIP Map and Interpolation"
- + * ID|Texture|EnvironmentMapTexture.filter -> filter_type:   enum  "Texture filter to use for sampling image"
+#ID|Texture|EnvironmentMapTexture.filter_type -> filter_type:   enum  "Texture filter to use for sampling image"
 #+ * ID|Texture|EnvironmentMapTexture.image -> image:   pointer  "Source image file to read the environment map from"
 #+ * ID|Texture|EnvironmentMapTexture.image_user -> image_user:   pointer,  "(read-only)    Parameters defining which layer, pass and frame of the image is displayed"
 #ID|Texture|EnvironmentMapTexture.use_filter_size_min -> use_filter_size_min:   boolean  "Use Filter Size as a minimal filter value in pixels"
- + * ID|Texture|EnvironmentMapTexture.mipmap -> use_mipmap:   boolean  "Uses auto-generated MIP maps for the image"
+#ID|Texture|EnvironmentMapTexture.use_mipmap -> use_mipmap:   boolean  "Uses auto-generated MIP maps for the image"
 #ID|Texture|EnvironmentMapTexture.use_mipmap_gauss -> use_mipmap_gauss:   boolean  "Uses Gauss filter to sample down MIP maps"
 #+ * ID|Texture|ImageTexture.checker_distance -> checker_distance:   float  "Sets distance between checker tiles"
 #+ * ID|Texture|ImageTexture.crop_max_x -> crop_max_x:   float  "Sets maximum X value to crop the image"
@@ -1829,7 +1829,7 @@
 #+ * ID|Texture|ImageTexture.filter_eccentricity -> filter_eccentricity:   int  "Maximum eccentricity. Higher gives less blur at distant/oblique angles, but is also slower"
 #+ * ID|Texture|ImageTexture.filter_probes -> filter_probes:   int  "Maximum number of samples. Higher gives less blur at distant/oblique angles, but is also slower"
 #+ * ID|Texture|ImageTexture.filter_size -> filter_size:   float  "Multiplies the filter size used by MIP Map and Interpolation"
- + * ID|Texture|ImageTexture.filter -> filter_type:   enum  "Texture filter to use for sampling image"
+#ID|Texture|ImageTexture.filter_type -> filter_type:   enum  "Texture filter to use for sampling image"
 #+ * ID|Texture|ImageTexture.image -> image:   pointer  "NO DESCRIPTION"
 #+ * ID|Texture|ImageTexture.image_user -> image_user:   pointer,  "(read-only)    Parameters defining which layer, pass and frame of the image is displayed"
 #+ * ID|Texture|ImageTexture.invert_alpha -> invert_alpha:   boolean  "Inverts all the alpha values in the image"
@@ -1842,15 +1842,15 @@
 #ID|Texture|ImageTexture.use_checker_odd -> use_checker_odd:   boolean  "Sets odd checker tiles"
 #ID|Texture|ImageTexture.use_filter_size_min -> use_filter_size_min:   boolean  "Use Filter Size as a minimal filter value in pixels"
 #ID|Texture|ImageTexture.use_flip_axis -> use_flip_axis:   boolean  "Flips the textures X and Y axis"
- + * ID|Texture|ImageTexture.interpolation -> use_interpolation:   boolean  "Interpolates pixels using Area filter"
- + * ID|Texture|ImageTexture.mipmap -> use_mipmap:   boolean  "Uses auto-generated MIP maps for the image"
+#ID|Texture|ImageTexture.use_interpolation -> use_interpolation:   boolean  "Interpolates pixels using Area filter"
+#ID|Texture|ImageTexture.use_mipmap -> use_mipmap:   boolean  "Uses auto-generated MIP maps for the image"
 #ID|Texture|ImageTexture.use_mipmap_gauss -> use_mipmap_gauss:   boolean  "Uses Gauss filter to sample down MIP maps"
 #ID|Texture|ImageTexture.use_mirror_x -> use_mirror_x:   boolean  "Mirrors the image repetition on the X direction"
 #ID|Texture|ImageTexture.use_mirror_y -> use_mirror_y:   boolean  "Mirrors the image repetition on the Y direction"
 #ID|Texture|ImageTexture.use_normal_map -> use_normal_map:   boolean  "Uses image RGB values for normal mapping"
 #+ * ID|Texture|MagicTexture.noise_depth -> noise_depth:   int  "Sets the depth of the cloud calculation"
 #+ * ID|Texture|MagicTexture.turbulence -> turbulence:   float  "Sets the turbulence of the bandnoise and ringnoise types"
- + * ID|Texture|MarbleTexture.stype -> marble_type:   enum  "NO DESCRIPTION"
+#ID|Texture|MarbleTexture.marble_type -> marble_type:   enum  "NO DESCRIPTION"
 #+ * ID|Texture|MarbleTexture.nabla -> nabla:   float  "Size of derivative offset used for calculating normal"
 #+ * ID|Texture|MarbleTexture.noise_basis -> noise_basis:   enum  "Sets the noise basis used for turbulence"
 #+ * ID|Texture|MarbleTexture.noise_depth -> noise_depth:   int  "Sets the depth of the cloud calculation"
@@ -1872,7 +1872,7 @@
 #+ * ID|Texture|StucciTexture.noise_basis -> noise_basis:   enum  "Sets the noise basis used for turbulence"
 #ID|Texture|StucciTexture.noise_scale -> noise_scale:   float  "Sets scaling for noise input"
 #+ * ID|Texture|StucciTexture.noise_type -> noise_type:   enum  "NO DESCRIPTION"
- + * ID|Texture|StucciTexture.stype -> stucci_type:   enum  "NO DESCRIPTION"
+#ID|Texture|StucciTexture.stucci_type -> stucci_type:   enum  "NO DESCRIPTION"
 #+ * ID|Texture|StucciTexture.turbulence -> turbulence:   float  "Sets the turbulence of the bandnoise and ringnoise types"
 #ID|Texture|VoronoiTexture.color_mode -> color_mode:   enum  "NO DESCRIPTION"
 #+ * ID|Texture|VoronoiTexture.distance_metric -> distance_metric:   enum  "NO DESCRIPTION"
@@ -1893,7 +1893,7 @@
 #+ * ID|Texture|WoodTexture.noise_type -> noise_type:   enum  "NO DESCRIPTION"
 #ID|Texture|WoodTexture.noisebasis_2 -> noisebasis_2:   enum  "NO DESCRIPTION"
 #+ * ID|Texture|WoodTexture.turbulence -> turbulence:   float  "Sets the turbulence of the bandnoise and ringnoise types"
- + * ID|Texture|WoodTexture.stype -> wood_type:   enum  "NO DESCRIPTION"
+#ID|Texture|WoodTexture.wood_type -> wood_type:   enum  "NO DESCRIPTION"
 #+ * ID|VectorFont.filepath -> filepath:   string,  "(read-only)"
 #+ * ID|VectorFont.packed_file -> packed_file:   pointer,  "(read-only)"
 #TODO, move into collectin * ID|WindowManager.active_keyconfig -> active_keyconfig:   pointer  "NO DESCRIPTION"
@@ -1905,12 +1905,12 @@
 #+ * ID|World.active_texture_index -> active_texture_index:   int  "Index of active texture slot"
 #+ * ID|World.ambient_color -> ambient_color:   float[3]  "NO DESCRIPTION"
 #+ * ID|World.animation_data -> animation_data:   pointer,  "(read-only)    Animation data for this datablock"
- + * ID|World.range -> color_range:   float  "The color range that will be mapped to 0-1"
+#ID|World.color_range -> color_range:   float  "The color range that will be mapped to 0-1"
 #+ * ID|World.exposure -> exposure:   float  "Amount of exponential color correction for light"
 #+ * ID|World.horizon_color -> horizon_color:   float[3]  "Color at the horizon"
- + * ID|World.lighting -> light_settings:   pointer,  "(read-only)    World lighting settings"
- + * ID|World.mist -> mist_settings:   pointer,  "(read-only)    World mist settings"
- + * ID|World.stars -> star_settings:   pointer,  "(read-only)    World stars settings"
+#ID|World.light_settings -> light_settings:   pointer,  "(read-only)    World lighting settings"
+#ID|World.mist_settings -> mist_settings:   pointer,  "(read-only)    World mist settings"
+#ID|World.star_settings -> star_settings:   pointer,  "(read-only)    World stars settings"
 #+ * ID|World.texture_slots -> texture_slots:   collection,  "(read-only)    Texture slots defining the mapping and influence of textures"
 #ID|World.use_sky_blend -> use_sky_blend:   boolean  "Render background with natural progression from horizon to zenith"
 #ID|World.use_sky_paper -> use_sky_paper:   boolean  "Flatten blend or texture coordinates"
@@ -1931,13 +1931,13 @@
 #IKParam|Itasc.use_auto_step -> use_auto_step:   boolean  "Automatically determine the optimal number of steps for best performance/accuracy trade off"
 #IKParam|Itasc.velocity_max -> velocity_max:   float  "Maximum joint velocity in rad/s. Default=50"
 #+ * ImageUser.fields_per_frame -> fields_per_frame:   int  "The number of fields per rendered frame (2 fields is 1 image)"
- + * ImageUser.frames -> frame_duration:   int  "Sets the number of images of a movie to use"
- + * ImageUser.offset -> frame_offset:   int  "Offsets the number of the frame to use in the animation"
+#ImageUser.frame_duration -> frame_duration:   int  "Sets the number of images of a movie to use"
+#ImageUser.frame_offset -> frame_offset:   int  "Offsets the number of the frame to use in the animation"
 #+ * ImageUser.frame_start -> frame_start:   int  "Sets the global starting frame of the movie"
 #+ * ImageUser.multilayer_layer -> multilayer_layer:   int,  "(read-only)    Layer in multilayer image"
 #+ * ImageUser.multilayer_pass -> multilayer_pass:   int,  "(read-only)    Pass in multilayer image"
 #ImageUser.use_auto_refresh -> use_auto_refresh:   boolean  "Always refresh image on frame changes"
- + * ImageUser.cyclic -> use_cyclic:   boolean  "Cycle the images in the movie"
+#ImageUser.use_cyclic -> use_cyclic:   boolean  "Cycle the images in the movie"
 #KeyConfig.is_user_defined -> is_user_defined:   boolean,  "(read-only)    Indicates that a keyconfig was defined by the user"
 #+ * KeyConfig.keymaps -> keymaps:   collection,  "(read-only)    Key maps configured as part of this configuration"
 #+ * KeyConfig.name -> name:   string  "Name of the key configuration"
@@ -2004,7 +2004,7 @@
 #+ * LampSkySettings.atmosphere_inscattering -> atmosphere_inscattering:   float  "Scatter contribution factor"
 #+ * LampSkySettings.atmosphere_turbidity -> atmosphere_turbidity:   float  "Sky turbidity"
 #+ * LampSkySettings.backscattered_light -> backscattered_light:   float  "Backscattered light"
- + * LampSkySettings.horizon_brightness -> horizon_intensity:   float  "Horizon brightness"
+#+ * LampSkySettings.horizon_brightness -> horizon_brightness:   float  "Horizon brightness"
 #+ * LampSkySettings.sky_blend -> sky_blend:   float  "Blend factor with sky"
 #+ * LampSkySettings.sky_blend_type -> sky_blend_type:   enum  "Blend mode for combining sun sky with world sky"
 #+ * LampSkySettings.sky_color_space -> sky_color_space:   enum  "Color space to use for internal XYZ->RGB color conversion"
@@ -2068,13 +2068,13 @@
 #MaterialHalo.star_tip_count -> star_tip_count:   int  "Sets the number of points on the star shaped halo"
 #MaterialHalo.use_extreme_alpha -> use_extreme_alpha:   boolean  "Uses extreme alpha"
 #MaterialHalo.use_flare_mode -> use_flare_mode:   boolean  "Renders halo as a lensflare"
- + * MaterialHalo.lines -> use_lines:   boolean  "Renders star shaped lines over halo"
- + * MaterialHalo.ring -> use_ring:   boolean  "Renders rings over halo"
- + * MaterialHalo.soft -> use_soft:   boolean  "Softens the edges of halos at intersections with other geometry"
- + * MaterialHalo.star -> use_star:   boolean  "Renders halo as a star"
- + * MaterialHalo.texture -> use_texture:   boolean  "Gives halo a texture"
+#MaterialHalo.use_lines -> use_lines:   boolean  "Renders star shaped lines over halo"
+#MaterialHalo.use_ring -> use_ring:   boolean  "Renders rings over halo"
+#MaterialHalo.use_soft -> use_soft:   boolean  "Softens the edges of halos at intersections with other geometry"
+#MaterialHalo.use_star -> use_star:   boolean  "Renders halo as a star"
+#MaterialHalo.use_texture -> use_texture:   boolean  "Gives halo a texture"
 #MaterialHalo.use_vertex_normal -> use_vertex_normal:   boolean  "Uses the vertex normal to specify the dimension of the halo"
- + * MaterialPhysics.damp -> damping:   float  "Damping of the spring force, when inside the physics distance area"
+#MaterialPhysics.damping -> damping:   float  "Damping of the spring force, when inside the physics distance area"
 #+ * MaterialPhysics.distance -> distance:   float  "Distance of the physics area"
 #+ * MaterialPhysics.elasticity -> elasticity:   float  "Elasticity of collisions"
 #+ * MaterialPhysics.force -> force:   float  "Upward spring force, when inside the physics distance area"
@@ -2092,7 +2092,7 @@
 #+ * MaterialRaytraceMirror.reflect_factor -> reflect_factor:   float  "Sets the amount mirror reflection for raytrace"
 #+ * MaterialRaytraceMirror.use -> use:   boolean  "Enable raytraced reflections"
 #+ * MaterialRaytraceTransparency.depth -> depth:   int  "Maximum allowed number of light inter-refractions"
- + * MaterialRaytraceTransparency.limit -> depth_max:   float  "Maximum depth for light to travel through the transparent material before becoming fully filtered (0.0 is disabled)"
+#MaterialRaytraceTransparency.depth_max -> depth_max:   float  "Maximum depth for light to travel through the transparent material before becoming fully filtered (0.0 is disabled)"
 #+ * MaterialRaytraceTransparency.falloff -> falloff:   float  "Falloff power for transmissivity filter effect (1.0 is linear)"
 #+ * MaterialRaytraceTransparency.filter -> filter:   float  "Amount to blend in the materials diffuse color in raytraced transparency (simulating absorption)"
 #+ * MaterialRaytraceTransparency.fresnel -> fresnel:   float  "Power of Fresnel for transparency (Ray or ZTransp)"
@@ -2236,10 +2236,10 @@
 #Modifier.show_render -> show_render:   boolean  "Use modifier during rendering"
 #Modifier.show_viewport -> show_viewport:   boolean  "Realtime display of a modifier"
 #+ * Modifier.type -> type:   enum,  "(read-only)"
- + * Modifier|ArmatureModifier.invert -> invert_vertex_group:   boolean  "Invert vertex group influence"
+#Modifier|ArmatureModifier.invert_vertex_group -> invert_vertex_group:   boolean  "Invert vertex group influence"
 #+ * Modifier|ArmatureModifier.object -> object:   pointer  "Armature object to deform with"
 #+ * Modifier|ArmatureModifier.use_bone_envelopes -> use_bone_envelopes:   boolean  "NO DESCRIPTION"
- + * Modifier|ArmatureModifier.quaternion -> use_deform_preserve_volume:   boolean  "Deform rotation interpolation with quaternions"
+#Modifier|ArmatureModifier.use_deform_preserve_volume -> use_deform_preserve_volume:   boolean  "Deform rotation interpolation with quaternions"
 #Modifier|ArmatureModifier.use_multi_modifier -> use_multi_modifier:   boolean  "Use same input as previous modifier, and mix results using overall vgroup"
 #+ * Modifier|ArmatureModifier.use_vertex_groups -> use_vertex_groups:   boolean  "NO DESCRIPTION"
 #+ * Modifier|ArmatureModifier.vertex_group -> vertex_group:   string  "Vertex group name"
@@ -2247,7 +2247,7 @@
 #+ * Modifier|ArrayModifier.count -> count:   int  "Number of duplicates to make"
 #+ * Modifier|ArrayModifier.curve -> curve:   pointer  "Curve object to fit array length to"
 #+ * Modifier|ArrayModifier.end_cap -> end_cap:   pointer  "Mesh object to use as an end cap"
- + * Modifier|ArrayModifier.length -> fit_length:   float  "Length to fit array within"
+#Modifier|ArrayModifier.fit_length -> fit_length:   float  "Length to fit array within"
 #+ * Modifier|ArrayModifier.fit_type -> fit_type:   enum  "Array length calculation method"
 #Modifier|ArrayModifier.merge_threshold -> merge_threshold:   float  "Limit below which to merge vertices"
 #+ * Modifier|ArrayModifier.offset_object -> offset_object:   pointer  "NO DESCRIPTION"
@@ -2258,17 +2258,17 @@
 #Modifier|ArrayModifier.use_merge_vertices_cap -> use_merge_vertices_cap:   boolean  "Merge vertices in first and last duplicates"
 #Modifier|ArrayModifier.use_object_offset -> use_object_offset:   boolean  "Add another objects transformation to the total offset"
 #Modifier|ArrayModifier.use_relative_offset -> use_relative_offset:   boolean  "Add an offset relative to the objects bounding box"
- + * Modifier|BevelModifier.angle -> angle_limit:   float  "Angle above which to bevel edges"
+#Modifier|BevelModifier.angle_limit -> angle_limit:   float  "Angle above which to bevel edges"
 #+ * Modifier|BevelModifier.edge_weight_method -> edge_weight_method:   enum  "What edge weight to use for weighting a vertex"
 #+ * Modifier|BevelModifier.limit_method -> limit_method:   enum  "NO DESCRIPTION"
 #Modifier|BevelModifier.use_only_vertices -> use_only_vertices:   boolean  "Bevel verts/corners, not edges"
 #+ * Modifier|BevelModifier.width -> width:   float  "Bevel value/amount"
 #+ * Modifier|BooleanModifier.object -> object:   pointer  "Mesh object to use for Boolean operation"
 #+ * Modifier|BooleanModifier.operation -> operation:   enum  "NO DESCRIPTION"
- + * Modifier|BuildModifier.length -> frame_duration:   float  "Specify the total time the build effect requires"
+#Modifier|BuildModifier.frame_duration -> frame_duration:   float  "Specify the total time the build effect requires"
 #+ * Modifier|BuildModifier.frame_start -> frame_start:   float  "Specify the start frame of the effect"
 #+ * Modifier|BuildModifier.seed -> seed:   int  "Specify the seed for random if used"
- + * Modifier|BuildModifier.randomize -> use_random_order:   boolean  "Randomize the faces or edges during build"
+#Modifier|BuildModifier.use_random_order -> use_random_order:   boolean  "Randomize the faces or edges during build"
 #+ * Modifier|CastModifier.cast_type -> cast_type:   enum  "NO DESCRIPTION"
 #+ * Modifier|CastModifier.factor -> factor:   float  "NO DESCRIPTION"
 #+ * Modifier|CastModifier.object -> object:   pointer  "Control object: if available, its location determines the center of the effect"
@@ -2276,9 +2276,9 @@
 #+ * Modifier|CastModifier.size -> size:   float  "Size of projection shape (leave as 0 for auto.)"
 #Modifier|CastModifier.use_radius_as_size -> use_radius_as_size:   boolean  "Use radius as size of projection shape (0 = auto)"
 #+ * Modifier|CastModifier.use_transform -> use_transform:   boolean  "Use object transform to control projection shape"
- + * Modifier|CastModifier.x -> use_x:   boolean  "NO DESCRIPTION"
- + * Modifier|CastModifier.y -> use_y:   boolean  "NO DESCRIPTION"
- + * Modifier|CastModifier.z -> use_z:   boolean  "NO DESCRIPTION"
+#Modifier|CastModifier.use_x -> use_x:   boolean  "NO DESCRIPTION"
+#Modifier|CastModifier.use_y -> use_y:   boolean  "NO DESCRIPTION"
+#Modifier|CastModifier.use_z -> use_z:   boolean  "NO DESCRIPTION"
 #+ * Modifier|CastModifier.vertex_group -> vertex_group:   string  "Vertex group name"
 #+ * Modifier|ClothModifier.collision_settings -> collision_settings:   pointer,  "(read-only)"
 #+ * Modifier|ClothModifier.point_cache -> point_cache:   pointer,  "(read-only)"
@@ -2305,7 +2305,7 @@
 #Modifier|ExplodeModifier.show_dead -> show_dead:   boolean  "Show mesh when particles are dead"
 #Modifier|ExplodeModifier.show_unborn -> show_unborn:   boolean  "Show mesh when particles are unborn"
 #Modifier|ExplodeModifier.use_edge_split -> use_edge_split:   boolean  "Split face edges for nicer shrapnel"
- + * Modifier|ExplodeModifier.size -> use_size:   boolean  "Use particle size for the shrapnel"
+#Modifier|ExplodeModifier.use_size -> use_size:   boolean  "Use particle size for the shrapnel"
 #+ * Modifier|ExplodeModifier.vertex_group -> vertex_group:   string  "NO DESCRIPTION"
 #+ * Modifier|FluidSimulationModifier.settings -> settings:   pointer,  "(read-only)    Settings for how this object is used in the fluid simulation"
 #+ * Modifier|HookModifier.falloff -> falloff:   float  "If not zero, the distance from the hook where influence ends"
@@ -2316,24 +2316,24 @@
 #+ * Modifier|LatticeModifier.object -> object:   pointer  "Lattice object to deform with"
 #+ * Modifier|LatticeModifier.vertex_group -> vertex_group:   string  "Vertex group name"
 #+ * Modifier|MaskModifier.armature -> armature:   pointer  "Armature to use as source of bones to mask"
- + * Modifier|MaskModifier.invert -> invert_vertex_group:   boolean  "Use vertices that are not part of region defined"
+#Modifier|MaskModifier.invert_vertex_group -> invert_vertex_group:   boolean  "Use vertices that are not part of region defined"
 #+ * Modifier|MaskModifier.mode -> mode:   enum  "NO DESCRIPTION"
 #+ * Modifier|MaskModifier.vertex_group -> vertex_group:   string  "Vertex group name"
- + * Modifier|MeshDeformModifier.invert -> invert_vertex_group:   boolean  "Invert vertex group influence"
+#Modifier|MeshDeformModifier.invert_vertex_group -> invert_vertex_group:   boolean  "Invert vertex group influence"
 #+ * Modifier|MeshDeformModifier.is_bound -> is_bound:   boolean,  "(read-only)    Whether geometry has been bound to control cage"
 #+ * Modifier|MeshDeformModifier.object -> object:   pointer  "Mesh object to deform with"
 #+ * Modifier|MeshDeformModifier.precision -> precision:   int  "The grid size for binding"
- + * Modifier|MeshDeformModifier.dynamic -> use_dynamic_bind:   boolean  "Recompute binding dynamically on top of other deformers (slower and more memory consuming.)"
+#Modifier|MeshDeformModifier.use_dynamic_bind -> use_dynamic_bind:   boolean  "Recompute binding dynamically on top of other deformers (slower and more memory consuming.)"
 #+ * Modifier|MeshDeformModifier.vertex_group -> vertex_group:   string  "Vertex group name"
 #Modifier|MirrorModifier.merge_threshold -> merge_threshold:   float  "Distance from axis within which mirrored vertices are merged"
 #+ * Modifier|MirrorModifier.mirror_object -> mirror_object:   pointer  "Object to use as mirror"
- + * Modifier|MirrorModifier.clip -> use_clip:   boolean  "Prevents vertices from going through the mirror during transform"
+#Modifier|MirrorModifier.use_clip -> use_clip:   boolean  "Prevents vertices from going through the mirror during transform"
 #Modifier|MirrorModifier.use_mirror_u -> use_mirror_u:   boolean  "Mirror the U texture coordinate around the 0.5 point"
 #Modifier|MirrorModifier.use_mirror_v -> use_mirror_v:   boolean  "Mirror the V texture coordinate around the 0.5 point"
 #Modifier|MirrorModifier.use_mirror_vertex_groups -> use_mirror_vertex_groups:   boolean  "Mirror vertex groups (e.g. .R->.L)"
- + * Modifier|MirrorModifier.x -> use_x:   boolean  "Enable X axis mirror"
- + * Modifier|MirrorModifier.y -> use_y:   boolean  "Enable Y axis mirror"
- + * Modifier|MirrorModifier.z -> use_z:   boolean  "Enable Z axis mirror"
+#Modifier|MirrorModifier.use_x -> use_x:   boolean  "Enable X axis mirror"
+#Modifier|MirrorModifier.use_y -> use_y:   boolean  "Enable Y axis mirror"
+#Modifier|MirrorModifier.use_z -> use_z:   boolean  "Enable Z axis mirror"
 #+ * Modifier|MultiresModifier.filepath -> filepath:   string  "Path to external displacements file"
 #Modifier|MultiresModifier.is_external -> is_external:   boolean,  "(read-only)    Store multires displacements outside the .blend file, to save memory"
 #+ * Modifier|MultiresModifier.levels -> levels:   int  "Number of subdivisions to use in the viewport"
@@ -2350,11 +2350,11 @@
 #Modifier|ParticleInstanceModifier.show_alive -> show_alive:   boolean  "Show instances when particles are alive"
 #Modifier|ParticleInstanceModifier.show_dead -> show_dead:   boolean  "Show instances when particles are dead"
 #Modifier|ParticleInstanceModifier.show_unborn -> show_unborn:   boolean  "Show instances when particles are unborn"
- + * Modifier|ParticleInstanceModifier.children -> use_children:   boolean  "Create instances from child particles"
- + * Modifier|ParticleInstanceModifier.normal -> use_normal:   boolean  "Create instances from normal particles"
+#Modifier|ParticleInstanceModifier.use_children -> use_children:   boolean  "Create instances from child particles"
+#Modifier|ParticleInstanceModifier.use_normal -> use_normal:   boolean  "Create instances from normal particles"
 #+ * Modifier|ParticleInstanceModifier.use_path -> use_path:   boolean  "Create instances along particle paths"
 #Modifier|ParticleInstanceModifier.use_preserve_shape -> use_preserve_shape:   boolean  "Dont stretch the object"
- + * Modifier|ParticleInstanceModifier.size -> use_size:   boolean  "Use particle size to scale the instances"
+#Modifier|ParticleInstanceModifier.use_size -> use_size:   boolean  "Use particle size to scale the instances"
 #+ * Modifier|ParticleSystemModifier.particle_system -> particle_system:   pointer,  "(read-only)    Particle System that this modifier controls"
 #+ * Modifier|ScrewModifier.angle -> angle:   float  "Angle of revolution"
 #+ * Modifier|ScrewModifier.axis -> axis:   enum  "Screw axis"
@@ -2373,37 +2373,37 @@
 #Modifier|ShrinkwrapModifier.use_cull_back_faces -> use_cull_back_faces:   boolean  "Stop vertices from projecting to a back face on the target"
 #Modifier|ShrinkwrapModifier.use_cull_front_faces -> use_cull_front_faces:   boolean  "Stop vertices from projecting to a front face on the target"
 #Modifier|ShrinkwrapModifier.use_keep_above_surface -> use_keep_above_surface:   boolean  "NO DESCRIPTION"
- + * Modifier|ShrinkwrapModifier.negative -> use_negative_direction:   boolean  "Allow vertices to move in the negative direction of axis"
- + * Modifier|ShrinkwrapModifier.positive -> use_positive_direction:   boolean  "Allow vertices to move in the positive direction of axis"
- + * Modifier|ShrinkwrapModifier.x -> use_project_x:   boolean  "NO DESCRIPTION"
- + * Modifier|ShrinkwrapModifier.y -> use_project_y:   boolean  "NO DESCRIPTION"
- + * Modifier|ShrinkwrapModifier.z -> use_project_z:   boolean  "NO DESCRIPTION"
+#Modifier|ShrinkwrapModifier.use_negative_direction -> use_negative_direction:   boolean  "Allow vertices to move in the negative direction of axis"
+#Modifier|ShrinkwrapModifier.use_positive_direction -> use_positive_direction:   boolean  "Allow vertices to move in the positive direction of axis"
+#Modifier|ShrinkwrapModifier.use_project_x -> use_project_x:   boolean  "NO DESCRIPTION"
+#Modifier|ShrinkwrapModifier.use_project_y -> use_project_y:   boolean  "NO DESCRIPTION"
+#Modifier|ShrinkwrapModifier.use_project_z -> use_project_z:   boolean  "NO DESCRIPTION"
 #+ * Modifier|ShrinkwrapModifier.vertex_group -> vertex_group:   string  "Vertex group name"
- + * Modifier|ShrinkwrapModifier.mode -> wrap_method:   enum  "NO DESCRIPTION"
- + * Modifier|SimpleDeformModifier.mode -> deform_method:   enum  "NO DESCRIPTION"
+#Modifier|ShrinkwrapModifier.wrap_method -> wrap_method:   enum  "NO DESCRIPTION"
+#Modifier|SimpleDeformModifier.deform_method -> deform_method:   enum  "NO DESCRIPTION"
 #+ * Modifier|SimpleDeformModifier.factor -> factor:   float  "NO DESCRIPTION"
 #+ * Modifier|SimpleDeformModifier.limits -> limits:   float[2]  "Lower/Upper limits for deform"
 #Modifier|SimpleDeformModifier.lock_x -> lock_x:   boolean  "NO DESCRIPTION"
 #Modifier|SimpleDeformModifier.lock_y -> lock_y:   boolean  "NO DESCRIPTION"
 #+ * Modifier|SimpleDeformModifier.origin -> origin:   pointer  "Origin of modifier space coordinates"
- + * Modifier|SimpleDeformModifier.relative -> use_relative:   boolean  "Sets the origin of deform space to be relative to the object"
+#Modifier|SimpleDeformModifier.use_relative -> use_relative:   boolean  "Sets the origin of deform space to be relative to the object"
 #+ * Modifier|SimpleDeformModifier.vertex_group -> vertex_group:   string  "Vertex group name"
 #+ * Modifier|SmokeModifier.coll_settings -> coll_settings:   pointer,  "(read-only)"
 #+ * Modifier|SmokeModifier.domain_settings -> domain_settings:   pointer,  "(read-only)"
 #+ * Modifier|SmokeModifier.flow_settings -> flow_settings:   pointer,  "(read-only)"
 #Modifier|SmokeModifier.smoke_type -> smoke_type:   enum  "NO DESCRIPTION"
 #+ * Modifier|SmoothModifier.factor -> factor:   float  "NO DESCRIPTION"
- + * Modifier|SmoothModifier.repeat -> iterations:   int  "NO DESCRIPTION"
- + * Modifier|SmoothModifier.x -> use_x:   boolean  "NO DESCRIPTION"
- + * Modifier|SmoothModifier.y -> use_y:   boolean  "NO DESCRIPTION"
- + * Modifier|SmoothModifier.z -> use_z:   boolean  "NO DESCRIPTION"
+#Modifier|SmoothModifier.ise_x -> ise_x:   boolean  "NO DESCRIPTION"
+#Modifier|SmoothModifier.ise_y -> ise_y:   boolean  "NO DESCRIPTION"
+#Modifier|SmoothModifier.ise_z -> ise_z:   boolean  "NO DESCRIPTION"
+#Modifier|SmoothModifier.iterations -> iterations:   int  "NO DESCRIPTION"
 #+ * Modifier|SmoothModifier.vertex_group -> vertex_group:   string  "Vertex group name"
 #+ * Modifier|SoftBodyModifier.point_cache -> point_cache:   pointer,  "(read-only)"
 #+ * Modifier|SoftBodyModifier.settings -> settings:   pointer,  "(read-only)"
 #+ * Modifier|SolidifyModifier.edge_crease_inner -> edge_crease_inner:   float  "Assign a crease to inner edges"
 #+ * Modifier|SolidifyModifier.edge_crease_outer -> edge_crease_outer:   float  "Assign a crease to outer edges"
 #+ * Modifier|SolidifyModifier.edge_crease_rim -> edge_crease_rim:   float  "Assign a crease to the edges making up the rim"
- + * Modifier|SolidifyModifier.invert -> invert_vertex_group:   boolean  "Invert the vertex group influence"
+#Modifier|SolidifyModifier.invert_vertex_group -> invert_vertex_group:   boolean  "Invert the vertex group influence"
 #+ * Modifier|SolidifyModifier.offset -> offset:   float  "Offset the thickness from the center"
 #+ * Modifier|SolidifyModifier.thickness -> thickness:   float  "Thickness of the shell"
 #+ * Modifier|SolidifyModifier.use_even_offset -> use_even_offset:   boolean  "Maintain thickness by adjusting for sharp corners (slow, disable when not needed)"
@@ -2438,13 +2438,13 @@
 #Modifier|WaveModifier.texture_coords -> texture_coords:   enum  "Texture coordinates used for modulating input"
 #Modifier|WaveModifier.texture_coords_object -> texture_coords_object:   pointer  "NO DESCRIPTION"
 #+ * Modifier|WaveModifier.time_offset -> time_offset:   float  "Either the starting frame (for positive speed) or ending frame (for negative speed.)"
- + * Modifier|WaveModifier.cyclic -> use_cyclic:   boolean  "Cyclic wave effect"
- + * Modifier|WaveModifier.normals -> use_normal:   boolean  "Displace along normals"
+#Modifier|WaveModifier.use_cyclic -> use_cyclic:   boolean  "Cyclic wave effect"
+#Modifier|WaveModifier.use_normal -> use_normal:   boolean  "Displace along normals"
 #Modifier|WaveModifier.use_normal_x -> use_normal_x:   boolean  "Enable displacement along the X normal"
 #Modifier|WaveModifier.use_normal_y -> use_normal_y:   boolean  "Enable displacement along the Y normal"
 #Modifier|WaveModifier.use_normal_z -> use_normal_z:   boolean  "Enable displacement along the Z normal"
- + * Modifier|WaveModifier.x -> use_x:   boolean  "X axis motion"
- + * Modifier|WaveModifier.y -> use_y:   boolean  "Y axis motion"
+#Modifier|WaveModifier.use_x -> use_x:   boolean  "X axis motion"
+#Modifier|WaveModifier.use_y -> use_y:   boolean  "Y axis motion"
 #+ * Modifier|WaveModifier.uv_layer -> uv_layer:   string  "UV layer name"
 #+ * Modifier|WaveModifier.vertex_group -> vertex_group:   string  "Vertex group name for modulating the wave"
 #+ * Modifier|WaveModifier.width -> width:   float  "NO DESCRIPTION"
@@ -2481,7 +2481,7 @@
 #NlaStrip.use_animated_time -> use_animated_time:   boolean  "Strip time is controlled by an F-Curve rather than automatically determined"
 #NlaStrip.use_animated_time_cyclic -> use_animated_time_cyclic:   boolean  "Cycle the animated time within the action start & end"
 #NlaStrip.use_auto_blend -> use_auto_blend:   boolean  "Number of frames for Blending In/Out is automatically determined from overlapping strips"
- + * NlaStrip.reversed -> use_reverse:   boolean  "NLA Strip is played back in reverse order (only when timing is automatically determined)"
+#NlaStrip.use_reverse -> use_reverse:   boolean  "NLA Strip is played back in reverse order (only when timing is automatically determined)"
 #+ * NlaTrack.active -> active:   boolean,  "(read-only)    NLA Track is active"
 #NlaTrack.is_solo -> is_solo:   boolean,  "(read-only)    NLA Track is evaluated itself (i.e. active Action and all other NLA Tracks in the same AnimData block are disabled)"
 #+ * NlaTrack.lock -> lock:   boolean  "NLA Track is locked"
@@ -2505,19 +2505,19 @@
 #+ * Node|CompositorNode|CompositorNodeBlur.filter_type -> filter_type:   enum  "NO DESCRIPTION"
 #Node|CompositorNode|CompositorNodeBlur.size_x -> size_x:   int  "NO DESCRIPTION"
 #Node|CompositorNode|CompositorNodeBlur.size_y -> size_y:   int  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeBlur.bokeh -> use_bokeh:   boolean  "Uses circular filter (slower)"
- + * Node|CompositorNode|CompositorNodeBlur.gamma -> use_gamma_correction:   boolean  "Applies filter on gamma corrected values"
- + * Node|CompositorNode|CompositorNodeBlur.relative -> use_relative:   boolean  "Use relative (percent) values to define blur radius"
+#Node|CompositorNode|CompositorNodeBlur.use_bokeh -> use_bokeh:   boolean  "Uses circular filter (slower)"
+#Node|CompositorNode|CompositorNodeBlur.use_gamma_correction -> use_gamma_correction:   boolean  "Applies filter on gamma corrected values"
+#Node|CompositorNode|CompositorNodeBlur.use_relative -> use_relative:   boolean  "Use relative (percent) values to define blur radius"
 #+ * Node|CompositorNode|CompositorNodeChannelMatte.color_space -> color_space:   enum  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeChannelMatte.limit_channel -> limit_channel:   enum  "Limit by this channels value"
- + * Node|CompositorNode|CompositorNodeChannelMatte.high -> limit_max:   float  "Values higher than this setting are 100% opaque"
+#Node|CompositorNode|CompositorNodeChannelMatte.limit_max -> limit_max:   float  "Values higher than this setting are 100% opaque"
 #Node|CompositorNode|CompositorNodeChannelMatte.limit_method -> limit_method:   enum  "Algorithm to use to limit channel"
- + * Node|CompositorNode|CompositorNodeChannelMatte.low -> limit_min:   float  "Values lower than this setting are 100% keyed"
- + * Node|CompositorNode|CompositorNodeChannelMatte.channel -> matte_channel:   enum  "Channel used to determine matte"
+#Node|CompositorNode|CompositorNodeChannelMatte.limit_min -> limit_min:   float  "Values lower than this setting are 100% keyed"
+#Node|CompositorNode|CompositorNodeChannelMatte.matte_channel -> matte_channel:   enum  "Channel used to determine matte"
 #+ * Node|CompositorNode|CompositorNodeChromaMatte.gain -> gain:   float  "Alpha gain"
 #+ * Node|CompositorNode|CompositorNodeChromaMatte.lift -> lift:   float  "Alpha lift"
 #+ * Node|CompositorNode|CompositorNodeChromaMatte.shadow_adjust -> shadow_adjust:   float  "Adjusts the brightness of any shadows captured"
- + * Node|CompositorNode|CompositorNodeChromaMatte.cutoff -> threshold:   float  "Tolerance below which colors will be considered as exact matches"
+#Node|CompositorNode|CompositorNodeChromaMatte.threshold -> threshold:   float  "Tolerance below which colors will be considered as exact matches"
 #Node|CompositorNode|CompositorNodeChromaMatte.tolerance -> tolerance:   float  "Tolerance for a color to be considered a keying color"
 #Node|CompositorNode|CompositorNodeColorBalance.correction_method -> correction_method:   enum  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeColorBalance.gain -> gain:   float[3]  "Correction for Highlights"
@@ -2526,9 +2526,9 @@
 #+ * Node|CompositorNode|CompositorNodeColorBalance.offset -> offset:   float[3]  "Correction for Shadows"
 #+ * Node|CompositorNode|CompositorNodeColorBalance.power -> power:   float[3]  "Correction for Midtones"
 #+ * Node|CompositorNode|CompositorNodeColorBalance.slope -> slope:   float[3]  "Correction for Highlights"
- + * Node|CompositorNode|CompositorNodeColorMatte.h -> color_hue:   float  "Hue tolerance for colors to be considered a keying color"
- + * Node|CompositorNode|CompositorNodeColorMatte.s -> color_saturation:   float  "Saturation Tolerance for the color"
- + * Node|CompositorNode|CompositorNodeColorMatte.v -> color_value:   float  "Value Tolerance for the color"
+#Node|CompositorNode|CompositorNodeColorMatte.color_hue -> color_hue:   float  "Hue tolerance for colors to be considered a keying color"
+#Node|CompositorNode|CompositorNodeColorMatte.color_saturation -> color_saturation:   float  "Saturation Tolerance for the color"
+#Node|CompositorNode|CompositorNodeColorMatte.color_value -> color_value:   float  "Value Tolerance for the color"
 #+ * Node|CompositorNode|CompositorNodeColorSpill.channel -> channel:   enum  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeColorSpill.limit_channel -> limit_channel:   enum  "NO DESCRIPTION"
 #Node|CompositorNode|CompositorNodeColorSpill.limit_method -> limit_method:   enum  "NO DESCRIPTION"
@@ -2550,7 +2550,7 @@
 #+ * Node|CompositorNode|CompositorNodeDBlur.distance -> distance:   float  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeDBlur.iterations -> iterations:   int  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeDBlur.spin -> spin:   float  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeDBlur.wrap -> use_wrap:   boolean  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeDBlur.use_wrap -> use_wrap:   boolean  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeDBlur.zoom -> zoom:   float  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeDefocus.angle -> angle:   int  "Bokeh shape rotation offset in degrees"
 #Node|CompositorNode|CompositorNodeDefocus.blur_max -> blur_max:   float  "blur limit, maximum CoC radius, 0=no limit"
@@ -2559,7 +2559,7 @@
 #+ * Node|CompositorNode|CompositorNodeDefocus.samples -> samples:   int  "Number of samples (16=grainy, higher=less noise)"
 #+ * Node|CompositorNode|CompositorNodeDefocus.threshold -> threshold:   float  "CoC radius threshold, prevents background bleed on in-focus midground, 0=off"
 #Node|CompositorNode|CompositorNodeDefocus.use_gamma_correction -> use_gamma_correction:   boolean  "Enable gamma correction before and after main process"
- + * Node|CompositorNode|CompositorNodeDefocus.preview -> use_preview:   boolean  "Enable sampling mode, useful for preview when using low samplecounts"
+#Node|CompositorNode|CompositorNodeDefocus.use_preview -> use_preview:   boolean  "Enable sampling mode, useful for preview when using low samplecounts"
 #+ * Node|CompositorNode|CompositorNodeDefocus.use_zbuffer -> use_zbuffer:   boolean  "Disable when using an image as input instead of actual zbuffer (auto enabled if node not image based, eg. time node)"
 #+ * Node|CompositorNode|CompositorNodeDefocus.z_scale -> z_scale:   float  "Scales the Z input when not using a zbuffer, controls maximum blur designated by the color white or input value 1"
 #+ * Node|CompositorNode|CompositorNodeDiffMatte.falloff -> falloff:   float  "Color distances below this additional threshold are partially keyed"
@@ -2581,25 +2581,25 @@
 #+ * Node|CompositorNode|CompositorNodeGlare.threshold -> threshold:   float  "The glare filter will only be applied to pixels brighter than this value"
 #Node|CompositorNode|CompositorNodeGlare.use_rotate_45 -> use_rotate_45:   boolean  "Simple star filter: add 45 degree rotation offset"
 #+ * Node|CompositorNode|CompositorNodeHueCorrect.mapping -> mapping:   pointer,  "(read-only)"
- + * Node|CompositorNode|CompositorNodeHueSat.hue -> color_hue:   float  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeHueSat.sat -> color_saturation:   float  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeHueSat.val -> color_value:   float  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeHueSat.color_hue -> color_hue:   float  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeHueSat.color_saturation -> color_saturation:   float  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeHueSat.color_value -> color_value:   float  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeIDMask.index -> index:   int  "Pass index number to convert to alpha"
- + * Node|CompositorNode|CompositorNodeImage.frames -> frame_duration:   int  "Number of images used in animation"
- + * Node|CompositorNode|CompositorNodeImage.offset -> frame_offset:   int  "Offsets the number of the frame to use in the animation"
- + * Node|CompositorNode|CompositorNodeImage.start -> frame_start:   int  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeImage.frame_duration -> frame_duration:   int  "Number of images used in animation"
+#Node|CompositorNode|CompositorNodeImage.frame_offset -> frame_offset:   int  "Offsets the number of the frame to use in the animation"
+#Node|CompositorNode|CompositorNodeImage.frame_start -> frame_start:   int  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeImage.image -> image:   pointer  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeImage.layer -> layer:   enum  "NO DESCRIPTION"
 #Node|CompositorNode|CompositorNodeImage.use_auto_refresh -> use_auto_refresh:   boolean  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeImage.cyclic -> use_cyclic:   boolean  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeInvert.alpha -> invert_alpha:   boolean  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeInvert.rgb -> invert_rgb:   boolean  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeLensdist.fit -> use_fit:   boolean  "For positive distortion factor only: scale image such that black areas are not visible"
- + * Node|CompositorNode|CompositorNodeLensdist.jitter -> use_jitter:   boolean  "Enable/disable jittering; faster, but also noisier"
+#Node|CompositorNode|CompositorNodeImage.use_cyclic -> use_cyclic:   boolean  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeInvert.invert_alpha -> invert_alpha:   boolean  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeInvert.invert_rgb -> invert_rgb:   boolean  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeLensdist.use_fit -> use_fit:   boolean  "For positive distortion factor only: scale image such that black areas are not visible"
+#Node|CompositorNode|CompositorNodeLensdist.use_jitter -> use_jitter:   boolean  "Enable/disable jittering; faster, but also noisier"
 #Node|CompositorNode|CompositorNodeLensdist.use_projector -> use_projector:   boolean  "Enable/disable projector mode. Effect is applied in horizontal direction only"
 #+ * Node|CompositorNode|CompositorNodeLevels.channel -> channel:   enum  "NO DESCRIPTION"
-#+ * Node|CompositorNode|CompositorNodeLumaMatte.high -> high:   float  "Values higher than this setting are 100% opaque"
-#+ * Node|CompositorNode|CompositorNodeLumaMatte.low -> low:   float  "Values lower than this setting are 100% keyed"
+#Node|CompositorNode|CompositorNodeLumaMatte.limit_max -> limit_max:   float  "Values higher than this setting are 100% opaque"
+#Node|CompositorNode|CompositorNodeLumaMatte.limit_min -> limit_min:   float  "Values lower than this setting are 100% keyed"
 #+ * Node|CompositorNode|CompositorNodeMapUV.alpha -> alpha:   int  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeMapValue.max -> max:   float[1]  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeMapValue.min -> min:   float[1]  "NO DESCRIPTION"
@@ -2609,7 +2609,7 @@
 #+ * Node|CompositorNode|CompositorNodeMapValue.use_min -> use_min:   boolean  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeMath.operation -> operation:   enum  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeMixRGB.blend_type -> blend_type:   enum  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeMixRGB.alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
+#Node|CompositorNode|CompositorNodeMixRGB.use_alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
 #+ * Node|CompositorNode|CompositorNodeOutputFile.exr_codec -> exr_codec:   enum  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeOutputFile.filepath -> filepath:   string  "Output path for the image, same functionality as render output."
 #+ * Node|CompositorNode|CompositorNodeOutputFile.frame_end -> frame_end:   int  "NO DESCRIPTION"
@@ -2620,15 +2620,15 @@
 #+ * Node|CompositorNode|CompositorNodePremulKey.mapping -> mapping:   enum  "Conversion between premultiplied alpha and key alpha"
 #+ * Node|CompositorNode|CompositorNodeRLayers.layer -> layer:   enum  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeRLayers.scene -> scene:   pointer  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeRotate.filter -> filter_type:   enum  "Method to use to filter rotation"
+#Node|CompositorNode|CompositorNodeRotate.filter_type -> filter_type:   enum  "Method to use to filter rotation"
 #+ * Node|CompositorNode|CompositorNodeScale.space -> space:   enum  "Coordinate space to scale relative to"
 #+ * Node|CompositorNode|CompositorNodeSplitViewer.axis -> axis:   enum  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeSplitViewer.factor -> factor:   int  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeTexture.node_output -> node_output:   int  "For node-based textures, which output node to use"
 #+ * Node|CompositorNode|CompositorNodeTexture.texture -> texture:   pointer  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeTime.curve -> curve:   pointer,  "(read-only)"
- + * Node|CompositorNode|CompositorNodeTime.end -> frame_end:   int  "NO DESCRIPTION"
- + * Node|CompositorNode|CompositorNodeTime.start -> frame_start:   int  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeTime.frame_end -> frame_end:   int  "NO DESCRIPTION"
+#Node|CompositorNode|CompositorNodeTime.frame_start -> frame_start:   int  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeTonemap.adaptation -> adaptation:   float  "If 0, global; if 1, based on pixel intensity"
 #+ * Node|CompositorNode|CompositorNodeTonemap.contrast -> contrast:   float  "Set to 0 to use estimate from input image"
 #+ * Node|CompositorNode|CompositorNodeTonemap.correction -> correction:   float  "If 0, same for all channels; if 1, each independent"
@@ -2636,19 +2636,19 @@
 #+ * Node|CompositorNode|CompositorNodeTonemap.intensity -> intensity:   float  "If less than zero, darkens image; otherwise, makes it brighter"
 #+ * Node|CompositorNode|CompositorNodeTonemap.key -> key:   float  "The value the average luminance is mapped to"
 #+ * Node|CompositorNode|CompositorNodeTonemap.offset -> offset:   float  "Normally always 1, but can be used as an extra control to alter the brightness curve"
- + * Node|CompositorNode|CompositorNodeTonemap.tonemap_type -> type:   enum  "NO DESCRIPTION"
+#+ * Node|CompositorNode|CompositorNodeTonemap.tonemap_type -> tonemap_type:   enum  "NO DESCRIPTION"
 #+ * Node|CompositorNode|CompositorNodeValToRGB.color_ramp -> color_ramp:   pointer,  "(read-only)"
 #+ * Node|CompositorNode|CompositorNodeVecBlur.factor -> factor:   float  "Scaling factor for motion vectors; actually shutter speed in frames"
 #+ * Node|CompositorNode|CompositorNodeVecBlur.samples -> samples:   int  "NO DESCRIPTION"
 #Node|CompositorNode|CompositorNodeVecBlur.speed_max -> speed_max:   int  "Maximum speed, or zero for none"
 #Node|CompositorNode|CompositorNodeVecBlur.speed_min -> speed_min:   int  "Minimum speed for a pixel to be blurred; used to separate background from foreground"
- + * Node|CompositorNode|CompositorNodeVecBlur.curved -> use_curved:   boolean  "Interpolate between frames in a bezier curve, rather than linearly"
+#Node|CompositorNode|CompositorNodeVecBlur.use_curved -> use_curved:   boolean  "Interpolate between frames in a bezier curve, rather than linearly"
 #+ * Node|NodeGroup.nodetree -> nodetree:   pointer  "NO DESCRIPTION"
 #+ * Node|ShaderNode.type -> type:   enum,  "(read-only)"
 #+ * Node|ShaderNode|ShaderNodeExtendedMaterial.invert_normal -> invert_normal:   boolean  "Material Node uses inverted normal"
 #+ * Node|ShaderNode|ShaderNodeExtendedMaterial.material -> material:   pointer  "NO DESCRIPTION"
- + * Node|ShaderNode|ShaderNodeExtendedMaterial.diffuse -> use_diffuse:   boolean  "Material Node outputs Diffuse"
- + * Node|ShaderNode|ShaderNodeExtendedMaterial.specular -> use_specular:   boolean  "Material Node outputs Specular"
+#Node|ShaderNode|ShaderNodeExtendedMaterial.use_diffuse -> use_diffuse:   boolean  "Material Node outputs Diffuse"
+#Node|ShaderNode|ShaderNodeExtendedMaterial.use_specular -> use_specular:   boolean  "Material Node outputs Specular"
 #+ * Node|ShaderNode|ShaderNodeGeometry.color_layer -> color_layer:   string  "NO DESCRIPTION"
 #+ * Node|ShaderNode|ShaderNodeGeometry.uv_layer -> uv_layer:   string  "NO DESCRIPTION"
 #+ * Node|ShaderNode|ShaderNodeMapping.location -> location:   float[3]  "Location offset for the input coordinate"
@@ -2660,11 +2660,11 @@
 #Node|ShaderNode|ShaderNodeMapping.use_min -> use_min:   boolean  "Clamp the output coordinate to a minimum value"
 #+ * Node|ShaderNode|ShaderNodeMaterial.invert_normal -> invert_normal:   boolean  "Material Node uses inverted normal"
 #+ * Node|ShaderNode|ShaderNodeMaterial.material -> material:   pointer  "NO DESCRIPTION"
- + * Node|ShaderNode|ShaderNodeMaterial.diffuse -> use_diffuse:   boolean  "Material Node outputs Diffuse"
- + * Node|ShaderNode|ShaderNodeMaterial.specular -> use_specular:   boolean  "Material Node outputs Specular"
+#Node|ShaderNode|ShaderNodeMaterial.use_diffuse -> use_diffuse:   boolean  "Material Node outputs Diffuse"
+#Node|ShaderNode|ShaderNodeMaterial.use_specular -> use_specular:   boolean  "Material Node outputs Specular"
 #+ * Node|ShaderNode|ShaderNodeMath.operation -> operation:   enum  "NO DESCRIPTION"
 #+ * Node|ShaderNode|ShaderNodeMixRGB.blend_type -> blend_type:   enum  "NO DESCRIPTION"
- + * Node|ShaderNode|ShaderNodeMixRGB.alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
+#Node|ShaderNode|ShaderNodeMixRGB.use_alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
 #+ * Node|ShaderNode|ShaderNodeRGBCurve.mapping -> mapping:   pointer,  "(read-only)"
 #+ * Node|ShaderNode|ShaderNodeTexture.node_output -> node_output:   int  "For node-based textures, which output node to use"
 #+ * Node|ShaderNode|ShaderNodeTexture.texture -> texture:   pointer  "NO DESCRIPTION"
@@ -2678,13 +2678,13 @@
 #+ * Node|TextureNode|TextureNodeBricks.squash_frequency -> squash_frequency:   int  "Squash every N rows"
 #+ * Node|TextureNode|TextureNodeCurveRGB.mapping -> mapping:   pointer,  "(read-only)"
 #+ * Node|TextureNode|TextureNodeCurveTime.curve -> curve:   pointer,  "(read-only)"
- + * Node|TextureNode|TextureNodeCurveTime.end -> frame_end:   int  "NO DESCRIPTION"
- + * Node|TextureNode|TextureNodeCurveTime.start -> frame_start:   int  "NO DESCRIPTION"
+#Node|TextureNode|TextureNodeCurveTime.frame_end -> frame_end:   int  "NO DESCRIPTION"
+#Node|TextureNode|TextureNodeCurveTime.frame_start -> frame_start:   int  "NO DESCRIPTION"
 #+ * Node|TextureNode|TextureNodeImage.image -> image:   pointer  "NO DESCRIPTION"
 #+ * Node|TextureNode|TextureNodeMath.operation -> operation:   enum  "NO DESCRIPTION"
 #+ * Node|TextureNode|TextureNodeMixRGB.blend_type -> blend_type:   enum  "NO DESCRIPTION"
- + * Node|TextureNode|TextureNodeMixRGB.alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
- + * Node|TextureNode|TextureNodeOutput.output_name -> filepath:   string  "NO DESCRIPTION"
+#Node|TextureNode|TextureNodeMixRGB.use_alpha -> use_alpha:   boolean  "Include alpha of second input in this operation"
+#Node|TextureNode|TextureNodeOutput.filepath -> filepath:   string  "NO DESCRIPTION"
 #+ * Node|TextureNode|TextureNodeTexture.node_output -> node_output:   int  "For node-based textures, which output node to use"
 #+ * Node|TextureNode|TextureNodeTexture.texture -> texture:   pointer  "NO DESCRIPTION"
 #+ * Node|TextureNode|TextureNodeValToRGB.color_ramp -> color_ramp:   pointer,  "(read-only)"
@@ -2728,7 +2728,7 @@
 #Paint|Sculpt.use_symmetry_z -> use_symmetry_z:   boolean  "Mirror brush across the Z axis"
 #Paint|Sculpt.use_threaded -> use_threaded:   boolean  "Take advantage of multiple CPU cores to improve sculpting performance"
 #Paint|VertexPaint.use_all_faces -> use_all_faces:   boolean  "Paint on all faces inside brush"
- + * Paint|VertexPaint.normals -> use_normal:   boolean  "Applies the vertex normal before painting"
+#Paint|VertexPaint.use_normal -> use_normal:   boolean  "Applies the vertex normal before painting"
 #Paint|VertexPaint.use_spray -> use_spray:   boolean  "Keep applying paint effect while holding mouse"
 #+ * Panel.bl_context -> bl_context:   string  "The context in which the panel belongs to. (TODO: explain the possible combinations bl_context/bl_region_type/bl_space_type)"
 #+ * Panel.bl_idname -> bl_idname:   string  "If this is set, the panel gets a custom ID, otherwise it takes the name of the class used to define the panel. For example, if the class name is OBJECT_PT_hello, and bl_idname is not set by the script, then bl_idname = OBJECT_PT_hello"
@@ -2747,7 +2747,7 @@
 #Particle.is_hair -> is_hair:   collection,  "(read-only)"
 #+ * Particle.is_visible -> is_visible:   boolean,  "(read-only)"
 #+ * Particle.keys -> keys:   collection,  "(read-only)"
- + * Particle.lifetime -> life_time:   float  "NO DESCRIPTION"
+#+ * Particle.lifetime -> lifetime:   float  "NO DESCRIPTION"
 #+ * Particle.location -> location:   float[3]  "NO DESCRIPTION"
 #+ * Particle.prev_angular_velocity -> prev_angular_velocity:   float[3]  "NO DESCRIPTION"
 #+ * Particle.prev_location -> prev_location:   float[3]  "NO DESCRIPTION"
@@ -3344,10 +3344,10 @@
 #SequenceColorBalance.invert_gamma -> invert_gamma:   boolean  "NO DESCRIPTION"
 #SequenceColorBalance.invert_lift -> invert_lift:   boolean  "NO DESCRIPTION"
 #+ * SequenceColorBalance.lift -> lift:   float[3]  "Color balance lift (shadows)"
- + * SequenceCrop.right -> max_x:   int  "NO DESCRIPTION"
- + * SequenceCrop.top -> max_y:   int  "NO DESCRIPTION"
- + * SequenceCrop.bottom -> min_x:   int  "NO DESCRIPTION"
- + * SequenceCrop.left -> min_y:   int  "NO DESCRIPTION"
+#SequenceCrop.max_x -> max_x:   int  "NO DESCRIPTION"
+#SequenceCrop.max_y -> max_y:   int  "NO DESCRIPTION"
+#SequenceCrop.min_x -> min_x:   int  "NO DESCRIPTION"
+#SequenceCrop.min_y -> min_y:   int  "NO DESCRIPTION"
 #+ * SequenceEditor.active_strip -> active_strip:   pointer  "NO DESCRIPTION"
 #+ * SequenceEditor.meta_stack -> meta_stack:   collection,  "(read-only)    Meta strip stack, last is currently edited meta strip"
 #+ * SequenceEditor.overlay_frame -> overlay_frame:   int  "Sequencers active strip"
@@ -3576,7 +3576,7 @@
 #SoftBodySettings.bend -> bend:   float  "Bending Stiffness"
 #+ * SoftBodySettings.choke -> choke:   int  "Viscosity inside collision target"
 #+ * SoftBodySettings.collision_type -> collision_type:   enum  "Choose Collision Type"
- + * SoftBodySettings.damp -> damping:   float  "Edge spring friction"
+#SoftBodySettings.damping -> damping:   float  "Edge spring friction"
 #+ * SoftBodySettings.effector_weights -> effector_weights:   pointer,  "(read-only)"
 #SoftBodySettings.error_threshold -> error_threshold:   float  "The Runge-Kutta ODE solver error limit, low value gives more precision, high values speed"
 #+ * SoftBodySettings.friction -> friction:   float  "General media friction for point movements"
@@ -3855,11 +3855,11 @@
 #+ * TextureSlot.blend_type -> blend_type:   enum  "NO DESCRIPTION"
 #+ * TextureSlot.color -> color:   float[3]  "The default color for textures that dont return RGB"
 #+ * TextureSlot.default_value -> default_value:   float  "Value to use for Ref, Spec, Amb, Emit, Alpha, RayMir, TransLu and Hard"
- + * TextureSlot.negate -> invert:   boolean  "Inverts the values of the texture to reverse its effect"
+#TextureSlot.invert -> invert:   boolean  "Inverts the values of the texture to reverse its effect"
 #+ * TextureSlot.name -> name:   string,  "(read-only)    Texture slot name"
 #+ * TextureSlot.offset -> offset:   float[3]  "Fine tunes texture mapping X, Y and Z locations"
 #+ * TextureSlot.output_node -> output_node:   enum  "Which output node to use, for node-based textures"
- + * TextureSlot.size -> scale:   float[3]  "Sets scaling for the textures X, Y and Z sizes"
+#TextureSlot.scale -> scale:   float[3]  "Sets scaling for the textures X, Y and Z sizes"
 #+ * TextureSlot.texture -> texture:   pointer  "Texture datablock used by this texture slot"
 #TextureSlot.use_rgb_to_intensity -> use_rgb_to_intensity:   boolean  "Converts texture RGB values to intensity (gray) values"
 #TextureSlot.use_stencil -> use_stencil:   boolean  "Use this texture as a blending value on the next texture"
@@ -4575,7 +4575,7 @@
 #+ * VoxelData.resolution -> resolution:   int[3]  "Resolution of the voxel grid"
 #+ * VoxelData.smoke_data_type -> smoke_data_type:   enum  "Simulation value to be used as a texture"
 #VoxelData.still_frame -> still_frame:   int  "The frame number to always use"
- + * VoxelData.still -> use_still_frame:   boolean  "Always render a still frame from the voxel data sequence"
+#VoxelData.use_still_frame -> use_still_frame:   boolean  "Always render a still frame from the voxel data sequence"
 #+ * Window.screen -> screen:   pointer  "Active screen showing in the window"
 #+ * WorldLighting.adapt_to_speed -> adapt_to_speed:   float  "Use the speed vector pass to reduce AO samples in fast moving pixels. Higher values result in more aggressive sample reduction. Requires Vec pass enabled (for Raytrace Adaptive QMC)"
 #WorldLighting.ao_blend_type -> ao_blend_type:   enum  "Defines how AO mixes with material shading"
@@ -4597,7 +4597,7 @@
 #+ * WorldLighting.use_ambient_occlusion -> use_ambient_occlusion:   boolean  "Use Ambient Occlusion to add shadowing based on distance between objects"
 #WorldLighting.use_cache -> use_cache:   boolean  "Cache AO results in pixels and interpolate over neighbouring pixels for speedup (for Approximate)"
 #WorldLighting.use_environment_light -> use_environment_light:   boolean  "Add light coming from the environment"
- + * WorldLighting.falloff -> use_falloff:   boolean  "NO DESCRIPTION"
+#WorldLighting.use_falloff -> use_falloff:   boolean  "NO DESCRIPTION"
 #WorldLighting.use_indirect_light -> use_indirect_light:   boolean  "Add indirect light bouncing of surrounding objects"
 #+ * WorldMistSettings.depth -> depth:   float  "The distance over which the mist effect fades in"
 #+ * WorldMistSettings.falloff -> falloff:   enum  "Type of transition used to fade mist"