rna naming mainly forBoids
authorCampbell Barton <ideasman42@gmail.com>
Thu, 19 Aug 2010 15:49:30 +0000 (15:49 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Thu, 19 Aug 2010 15:49:30 +0000 (15:49 +0000)
release/scripts/io/netrender/repath.py
release/scripts/ui/properties_particle.py
release/scripts/ui/properties_physics_fluid.py
source/blender/makesrna/intern/rna_boid.c
source/blender/makesrna/intern/rna_fluidsim.c
source/blender/makesrna/intern/rna_object_force.c
source/blender/makesrna/rna_cleanup/rna_cleaner.py
source/blender/makesrna/rna_cleanup/rna_properties.txt

index e0f1c1bfdc76b584b3cf948e45b4de0d5a521d15..e7fcad836826acc4a36b956acb072f44925c3319 100644 (file)
@@ -69,7 +69,7 @@ def process(paths):
         point_cache.use_external = False
 
     def processFluid(fluid):
-        new_path = path_map.get(fluid.path, None)
+        new_path = path_map.get(fluid.filepath, None)
         if new_path:
             fluid.path = new_path
     
index 27a0a733f3fd933d442fe2563b3142600ef80619..618d8e5486e0768c187811f8fec4d6200e7542cc 100644 (file)
@@ -472,31 +472,31 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, bpy.types.Panel):
 
 
             row = layout.row()
-            row.prop(boids, "allow_flight")
-            row.prop(boids, "allow_land")
-            row.prop(boids, "allow_climb")
+            row.prop(boids, "use_flight")
+            row.prop(boids, "use_land")
+            row.prop(boids, "use_climb")
 
             split = layout.split()
 
             sub = split.column()
             col = sub.column(align=True)
-            col.active = boids.allow_flight
-            col.prop(boids, "air_max_speed")
-            col.prop(boids, "air_min_speed", slider=True)
-            col.prop(boids, "air_max_acc", slider=True)
-            col.prop(boids, "air_max_ave", slider=True)
+            col.active = boids.use_flight
+            col.prop(boids, "air_speed_max")
+            col.prop(boids, "air_speed_min", slider=True)
+            col.prop(boids, "air_acc_max", slider=True)
+            col.prop(boids, "air_ave_max", slider=True)
             col.prop(boids, "air_personal_space")
             row = col.row()
-            row.active = (boids.allow_land or boids.allow_climb) and boids.allow_flight
-            row.prop(boids, "landing_smoothness")
+            row.active = (boids.use_land or boids.allow_climb) and boids.allow_flight
+            row.prop(boids, "land_smooth")
 
             sub = split.column()
             col = sub.column(align=True)
-            col.active = boids.allow_land or boids.allow_climb
-            col.prop(boids, "land_max_speed")
+            col.active = boids.use_land or boids.allow_climb
+            col.prop(boids, "land_speed_max")
             col.prop(boids, "land_jump_speed")
-            col.prop(boids, "land_max_acc", slider=True)
-            col.prop(boids, "land_max_ave", slider=True)
+            col.prop(boids, "land_acc_max", slider=True)
+            col.prop(boids, "land_ave_max", slider=True)
             col.prop(boids, "land_personal_space")
             col.prop(boids, "land_stick_force")
 
@@ -512,7 +512,7 @@ class PARTICLE_PT_physics(ParticleButtonsPanel, bpy.types.Panel):
 
             col = row.column()
             col.label(text="Misc:")
-            col.prop(boids, "banking", slider=True)
+            col.prop(boids, "bank", slider=True)
             col.prop(boids, "height", slider=True)
 
         if part.physics_type == 'KEYED' or part.physics_type == 'BOIDS' or part.physics_type == 'FLUID':
@@ -633,26 +633,26 @@ class PARTICLE_PT_boidbrain(ParticleButtonsPanel, bpy.types.Panel):
             if rule.type == 'GOAL':
                 row.prop(rule, "object")
                 row = layout.row()
-                row.prop(rule, "predict")
+                row.prop(rule, "use_predict")
             elif rule.type == 'AVOID':
                 row.prop(rule, "object")
                 row = layout.row()
-                row.prop(rule, "predict")
+                row.prop(rule, "use_predict")
                 row.prop(rule, "fear_factor")
             elif rule.type == 'FOLLOW_PATH':
                 row.label(text="Not yet functional.")
             elif rule.type == 'AVOID_COLLISION':
-                row.prop(rule, "boids")
-                row.prop(rule, "deflectors")
+                row.prop(rule, "use_avoid")
+                row.prop(rule, "use_avoid_collision")
                 row.prop(rule, "look_ahead")
             elif rule.type == 'FOLLOW_LEADER':
                 row.prop(rule, "object", text="")
                 row.prop(rule, "distance")
                 row = layout.row()
-                row.prop(rule, "line")
+                row.prop(rule, "use_line")
                 sub = row.row()
                 sub.active = rule.line
-                sub.prop(rule, "queue_size")
+                sub.prop(rule, "queue_count")
             elif rule.type == 'AVERAGE_SPEED':
                 row.prop(rule, "speed", slider=True)
                 row.prop(rule, "wander", slider=True)
index 1148a22bd95166c2076c02fa304121d5cdd55d59..35934ebfb320fd346d06d54fa1fdb6f80a970f90 100644 (file)
@@ -100,7 +100,7 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, bpy.types.Panel):
                 col.prop(fluid, "generate_speed_vectors")
                 col.prop(fluid, "reverse_frames")
 
-                layout.prop(fluid, "path", text="")
+                layout.prop(fluid, "filepath", text="")
 
             elif fluid.type == 'FLUID':
                 split = layout.split()
@@ -168,7 +168,7 @@ class PHYSICS_PT_fluid(PhysicButtonsPanel, bpy.types.Panel):
                 col.prop(fluid, "floats")
                 col.prop(fluid, "show_tracer")
 
-                layout.prop(fluid, "path", text="")
+                layout.prop(fluid, "filepath", text="")
 
             elif fluid.type == 'CONTROL':
                 split = layout.split()
index 4b705f0fb8ed4a6351cbc427e9f8d03210d86a90..3afa135d079e3f0c7511aee9a6e2982c14933750 100644 (file)
@@ -238,7 +238,7 @@ static void rna_def_boidrule_goal(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Object", "Goal object");
        RNA_def_property_update(prop, 0, "rna_Boids_reset_deps");
 
-       prop= RNA_def_property(srna, "predict", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_predict", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "options", BRULE_GOAL_AVOID_PREDICT);
        RNA_def_property_ui_text(prop, "Predict", "Predict target movement");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
@@ -259,7 +259,7 @@ static void rna_def_boidrule_avoid(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Object", "Object to avoid");
        RNA_def_property_update(prop, 0, "rna_Boids_reset_deps");
 
-       prop= RNA_def_property(srna, "predict", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_predict", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "options", BRULE_GOAL_AVOID_PREDICT);
        RNA_def_property_ui_text(prop, "Predict", "Predict target movement");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
@@ -278,12 +278,12 @@ static void rna_def_boidrule_avoid_collision(BlenderRNA *brna)
        srna= RNA_def_struct(brna, "BoidRuleAvoidCollision", "BoidRule");
        RNA_def_struct_ui_text(srna, "Avoid Collision", "");
 
-       prop= RNA_def_property(srna, "boids", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_avoid", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "options", BRULE_ACOLL_WITH_BOIDS);
        RNA_def_property_ui_text(prop, "Boids", "Avoid collision with other boids");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
-       prop= RNA_def_property(srna, "deflectors", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_avoid_collision", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "options", BRULE_ACOLL_WITH_DEFLECTORS);
        RNA_def_property_ui_text(prop, "Deflectors", "Avoid collision with deflector objects");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
@@ -313,12 +313,13 @@ static void rna_def_boidrule_follow_leader(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Distance", "Distance behind leader to follow");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
-       prop= RNA_def_property(srna, "queue_size", PROP_INT, PROP_NONE);
+       prop= RNA_def_property(srna, "queue_count", PROP_INT, PROP_NONE);
+       RNA_def_property_int_sdna(prop, NULL, "queue_size");
        RNA_def_property_range(prop, 0.0f, 100.0f);
        RNA_def_property_ui_text(prop, "Queue Size", "How many boids in a line");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
-       prop= RNA_def_property(srna, "line", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_line", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "options", BRULE_LEADER_IN_LINE);
        RNA_def_property_ui_text(prop, "Line", "Follow leader in a line");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
@@ -467,12 +468,14 @@ static void rna_def_boid_settings(BlenderRNA *brna)
        srna = RNA_def_struct(brna, "BoidSettings", NULL);
        RNA_def_struct_ui_text(srna, "Boid Settings", "Settings for boid physics");
 
-       prop= RNA_def_property(srna, "landing_smoothness", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "land_smooth", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "landing_smoothness");
        RNA_def_property_range(prop, 0.0, 10.0);
        RNA_def_property_ui_text(prop, "Landing Smoothness", "How smoothly the boids land");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
-       prop= RNA_def_property(srna, "banking", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "bank", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "banking");
        RNA_def_property_range(prop, 0.0, 2.0);
        RNA_def_property_ui_text(prop, "Banking", "Amount of rotation around velocity vector on turns");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
@@ -523,22 +526,26 @@ static void rna_def_boid_settings(BlenderRNA *brna)
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
        /* physical properties */
-       prop= RNA_def_property(srna, "air_min_speed", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "air_speed_min", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "air_min_speed");
        RNA_def_property_range(prop, 0.0, 1.0);
        RNA_def_property_ui_text(prop, "Min Air Speed", "Minimum speed in air (relative to maximum speed)");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
-       prop= RNA_def_property(srna, "air_max_speed", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "air_speed_max", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "air_max_speed");
        RNA_def_property_range(prop, 0.0, 100.0);
        RNA_def_property_ui_text(prop, "Max Air Speed", "Maximum speed in air");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
-       prop= RNA_def_property(srna, "air_max_acc", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "air_acc_max", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "air_max_acc");
        RNA_def_property_range(prop, 0.0, 1.0);
        RNA_def_property_ui_text(prop, "Max Air Acceleration", "Maximum acceleration in air (relative to maximum speed)");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
-       prop= RNA_def_property(srna, "air_max_ave", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "air_ave_max", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "air_max_ave");
        RNA_def_property_range(prop, 0.0, 1.0);
        RNA_def_property_ui_text(prop, "Max Air Angular Velocity", "Maximum angular velocity in air (relative to 180 degrees)");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
@@ -553,17 +560,20 @@ static void rna_def_boid_settings(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Jump Speed", "Maximum speed for jumping");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
-       prop= RNA_def_property(srna, "land_max_speed", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "land_speed_max", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "land_max_speed");
        RNA_def_property_range(prop, 0.0, 100.0);
        RNA_def_property_ui_text(prop, "Max Land Speed", "Maximum speed on land");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
-       prop= RNA_def_property(srna, "land_max_acc", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "land_acc_max", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "land_max_acc");
        RNA_def_property_range(prop, 0.0, 1.0);
        RNA_def_property_ui_text(prop, "Max Land Acceleration", "Maximum acceleration on land (relative to maximum speed)");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
-       prop= RNA_def_property(srna, "land_max_ave", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "land_ave_max", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "land_max_ave");
        RNA_def_property_range(prop, 0.0, 1.0);
        RNA_def_property_ui_text(prop, "Max Land Angular Velocity", "Maximum angular velocity on land (relative to 180 degrees)");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
@@ -579,17 +589,17 @@ static void rna_def_boid_settings(BlenderRNA *brna)
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
        /* options */
-       prop= RNA_def_property(srna, "allow_flight", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_flight", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "options", BOID_ALLOW_FLIGHT);
        RNA_def_property_ui_text(prop, "Allow Flight", "Allow boids to move in air");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
-       prop= RNA_def_property(srna, "allow_land", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_land", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "options", BOID_ALLOW_LAND);
        RNA_def_property_ui_text(prop, "Allow Land", "Allow boids to move on land");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
 
-       prop= RNA_def_property(srna, "allow_climb", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_climb", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "options", BOID_ALLOW_CLIMB);
        RNA_def_property_ui_text(prop, "Allow Climbing", "Allow boids to climb goal objects");
        RNA_def_property_update(prop, 0, "rna_Boids_reset");
index c267da53016e0c013e8409d46881d77b8c260cd2..6ef41830fa187237b99e84fb7cf49da144451472 100644 (file)
@@ -232,7 +232,7 @@ static void rna_def_fluidsim_domain(BlenderRNA *brna)
        RNA_def_property_boolean_sdna(prop, NULL, "flag", OB_FLUIDSIM_REVERSE);
        RNA_def_property_ui_text(prop, "Reverse Frames", "Reverse fluid frames");
 
-       prop= RNA_def_property(srna, "path", PROP_STRING, PROP_DIRPATH);
+       prop= RNA_def_property(srna, "filepath", PROP_STRING, PROP_DIRPATH);
        RNA_def_property_string_maxlength(prop, 240);
        RNA_def_property_string_sdna(prop, NULL, "surfdataPath");
        RNA_def_property_ui_text(prop, "Path", "Directory (and/or filename prefix) to store baked fluid simulation files in");
@@ -469,7 +469,7 @@ static void rna_def_fluidsim_particle(BlenderRNA *brna)
        RNA_def_property_range(prop, 0.0, 2.0);
        RNA_def_property_ui_text(prop, "Alpha Influence", "Amount of particle alpha change, inverse of size influence: 0=off (all same alpha), 1=full. (large particles get lower alphas, smaller ones higher values)");
 
-       prop= RNA_def_property(srna, "path", PROP_STRING, PROP_DIRPATH);
+       prop= RNA_def_property(srna, "filepath", PROP_STRING, PROP_DIRPATH);
        RNA_def_property_string_maxlength(prop, 240);
        RNA_def_property_string_sdna(prop, NULL, "surfdataPath");
        RNA_def_property_ui_text(prop, "Path", "Directory (and/or filename prefix) to store and load particles from");
index 9d6d3b4cd2ac35fe41140d83aa6d1fe187637648..05c3ff72ab3efd24531c204a2c72b6ef39e885c5 100644 (file)
@@ -896,7 +896,7 @@ static void rna_def_effector_weight(BlenderRNA *brna)
        RNA_def_struct_ui_icon(srna, ICON_PHYSICS);
 
        /* Flags */
-       prop= RNA_def_property(srna, "do_growing_hair", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "apply_to_hair_growing", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", EFF_WEIGHT_DO_HAIR);
        RNA_def_property_ui_text(prop, "Use For Growing Hair", "Use force fields when growing hair");
        RNA_def_property_update(prop, 0, "rna_EffectorWeight_update");
index 71a5a4eb61151669953a71c5469548050f11563f..ae17ade36d7507cc848689552ea11366f14152d6 100755 (executable)
@@ -114,14 +114,17 @@ def get_props_from_txt(input_filename):
     done = 0
     tot = 0
     
-    for line in file_lines:
+    for iii, line in enumerate(file_lines):
         
         # debug
         #print(line)
-        
+        line_strip = line.strip()
         # empty line or comment
-        if not line.strip():
+        if not line_strip:
             continue
+            
+        if line_strip == "EOF":
+            break
         
         if line.startswith("#"):
             line = line[1:]
index 313138a8172a849038b247feafd3c7d388851ea1..6940b95d82ad73f44cdc2a2ddf8f6530708b68f1 100644 (file)
 #+ * BoidRule|BoidRuleAverageSpeed.wander -> wander:   float  "How fast velocitys direction is randomized"
 #+ * BoidRule|BoidRuleAvoid.fear_factor -> fear_factor:   float  "Avoid object if danger from it is above this threshold"
 #+ * BoidRule|BoidRuleAvoid.object -> object:   pointer  "Object to avoid"
- + * BoidRule|BoidRuleAvoid.predict -> use_predict:   boolean  "Predict target movement"
+#BoidRule|BoidRuleAvoid.use_predict -> use_predict:   boolean  "Predict target movement"
 #+ * BoidRule|BoidRuleAvoidCollision.look_ahead -> look_ahead:   float  "Time to look ahead in seconds"
- + * BoidRule|BoidRuleAvoidCollision.boids -> use_avoid:   boolean  "Avoid collision with other boids"
- + * BoidRule|BoidRuleAvoidCollision.deflectors -> use_avoid_collision:   boolean  "Avoid collision with deflector objects"
+#BoidRule|BoidRuleAvoidCollision.use_avoid -> use_avoid:   boolean  "Avoid collision with other boids"
+#BoidRule|BoidRuleAvoidCollision.use_avoid_collision -> use_avoid_collision:   boolean  "Avoid collision with deflector objects"
 #+ * BoidRule|BoidRuleFight.distance -> distance:   float  "Attack boids at max this distance"
 #+ * BoidRule|BoidRuleFight.flee_distance -> flee_distance:   float  "Flee to this distance"
 #+ * BoidRule|BoidRuleFollowLeader.distance -> distance:   float  "Distance behind leader to follow"
 #+ * BoidRule|BoidRuleFollowLeader.object -> object:   pointer  "Follow this object instead of a boid"
- + * BoidRule|BoidRuleFollowLeader.queue_size -> queue_count:   int  "How many boids in a line"
- + * BoidRule|BoidRuleFollowLeader.line -> use_line:   boolean  "Follow leader in a line"
+#BoidRule|BoidRuleFollowLeader.queue_count -> queue_count:   int  "How many boids in a line"
+#BoidRule|BoidRuleFollowLeader.use_line -> use_line:   boolean  "Follow leader in a line"
 #+ * BoidRule|BoidRuleGoal.object -> object:   pointer  "Goal object"
- + * BoidRule|BoidRuleGoal.predict -> use_predict:   boolean  "Predict target movement"
+#BoidRule|BoidRuleGoal.use_predict -> use_predict:   boolean  "Predict target movement"
 #+ * BoidSettings.accuracy -> accuracy:   float  "Accuracy of attack"
 #+ * BoidSettings.active_boid_state -> active_boid_state:   pointer,  "(read-only)"
 #+ * BoidSettings.active_boid_state_index -> active_boid_state_index:   int  "NO DESCRIPTION"
 #+ * BoidSettings.aggression -> aggression:   float  "Boid will fight this times stronger enemy"
- + * BoidSettings.air_max_acc -> air_acc_max:   float  "Maximum acceleration in air (relative to maximum speed)"
- + * BoidSettings.air_max_ave -> air_ave_max:   float  "Maximum angular velocity in air (relative to 180 degrees)"
+#BoidSettings.air_acc_max -> air_acc_max:   float  "Maximum acceleration in air (relative to maximum speed)"
+#BoidSettings.air_ave_max -> air_ave_max:   float  "Maximum angular velocity in air (relative to 180 degrees)"
 #+ * BoidSettings.air_personal_space -> air_personal_space:   float  "Radius of boids personal space in air (% of particle size)"
- + * BoidSettings.air_max_speed -> air_speed_max:   float  "Maximum speed in air"
- + * BoidSettings.air_min_speed -> air_speed_min:   float  "Minimum speed in air (relative to maximum speed)"
- + * BoidSettings.banking -> bank:   float  "Amount of rotation around velocity vector on turns"
+#BoidSettings.air_speed_max -> air_speed_max:   float  "Maximum speed in air"
+#BoidSettings.air_speed_min -> air_speed_min:   float  "Minimum speed in air (relative to maximum speed)"
+#BoidSettings.bank -> bank:   float  "Amount of rotation around velocity vector on turns"
 #+ * BoidSettings.health -> health:   float  "Initial boid health when born"
 #+ * BoidSettings.height -> height:   float  "Boid height relative to particle size"
- + * BoidSettings.land_max_acc -> land_acc_max:   float  "Maximum acceleration on land (relative to maximum speed)"
- + * BoidSettings.land_max_ave -> land_ave_max:   float  "Maximum angular velocity on land (relative to 180 degrees)"
+#BoidSettings.land_acc_max -> land_acc_max:   float  "Maximum acceleration on land (relative to maximum speed)"
+#BoidSettings.land_ave_max -> land_ave_max:   float  "Maximum angular velocity on land (relative to 180 degrees)"
 #+ * BoidSettings.land_jump_speed -> land_jump_speed:   float  "Maximum speed for jumping"
 #+ * BoidSettings.land_personal_space -> land_personal_space:   float  "Radius of boids personal space on land (% of particle size)"
- + * BoidSettings.landing_smoothness -> land_smooth:   float  "How smoothly the boids land"
- + * BoidSettings.land_max_speed -> land_speed_max:   float  "Maximum speed on land"
+#BoidSettings.land_smooth -> land_smooth:   float  "How smoothly the boids land"
+#BoidSettings.land_speed_max -> land_speed_max:   float  "Maximum speed on land"
 #+ * BoidSettings.land_stick_force -> land_stick_force:   float  "How strong a force must be to start effecting a boid on land"
 #+ * BoidSettings.range -> range:   float  "The maximum distance from which a boid can attack"
 #+ * BoidSettings.states -> states:   collection,  "(read-only)"
 #+ * BoidSettings.strength -> strength:   float  "Maximum caused damage on attack per second"
- + * BoidSettings.allow_climb -> use_climb:   boolean  "Allow boids to climb goal objects"
- + * BoidSettings.allow_flight -> use_flight:   boolean  "Allow boids to move in air"
- + * BoidSettings.allow_land -> use_land:   boolean  "Allow boids to move on land"
+#BoidSettings.use_climb -> use_climb:   boolean  "Allow boids to climb goal objects"
+#BoidSettings.use_flight -> use_flight:   boolean  "Allow boids to move in air"
+#BoidSettings.use_land -> use_land:   boolean  "Allow boids to move on land"
 #+ * BoidState.active_boid_rule -> active_boid_rule:   pointer,  "(read-only)"
 #+ * BoidState.active_boid_rule_index -> active_boid_rule_index:   int  "NO DESCRIPTION"
 #+ * BoidState.falloff -> falloff:   float  "NO DESCRIPTION"
 #+ * BoidState.name -> name:   string  "Boid state name"
- + * BoidState.rule_fuzziness -> rule_fuzzy:   float  "NO DESCRIPTION"
+#BoidState.rule_fuzzy -> rule_fuzzy:   float  "NO DESCRIPTION"
 #+ * BoidState.rules -> rules:   collection,  "(read-only)"
 #+ * BoidState.ruleset_type -> ruleset_type:   enum  "How the rules in the list are evaluated"
 #+ * BoidState.volume -> volume:   float  "NO DESCRIPTION"
 #EditBone.use_inherit_scale -> use_inherit_scale:   boolean  "Bone inherits scaling from parent bone"
 #EditBone.use_local_location -> use_local_location:   boolean  "Bone location is set in local space"
 #+ * EffectorWeights.all -> all:   float  "All effectors weight"
- + * EffectorWeights.do_growing_hair -> apply_to_hair_growing:   boolean  "Use force fields when growing hair"
+#EffectorWeights.apply_to_hair_growing -> apply_to_hair_growing:   boolean  "Use force fields when growing hair"
 #+ * EffectorWeights.boid -> boid:   float  "Boid effector weight"
 #+ * EffectorWeights.charge -> charge:   float  "Charge effector weight"
- + * EffectorWeights.curveguide -> curve_guide:   float  "Curve guide effector weight"
+#EffectorWeights.curve_guide -> curve_guide:   float  "Curve guide effector weight"
 #+ * EffectorWeights.drag -> drag:   float  "Drag effector weight"
 #+ * EffectorWeights.force -> force:   float  "Force effector weight"
 #+ * EffectorWeights.gravity -> gravity:   float  "Global gravity weight"
 #+ * EnvironmentMap.clip_end -> clip_end:   float  "Objects further than this are not visible to map"
 #+ * EnvironmentMap.clip_start -> clip_start:   float  "Objects nearer than this are not visible to map"
 #+ * EnvironmentMap.depth -> depth:   int  "Number of times a map will be rendered recursively (mirror effects.)"
- + * EnvironmentMap.ignore_layers -> layers_ignore:   boolean[20]  "Hide objects on these layers when generating the Environment Map"
+#EnvironmentMap.layers_ignore -> layers_ignore:   boolean[20]  "Hide objects on these layers when generating the Environment Map"
 #+ * EnvironmentMap.mapping -> mapping:   enum  "NO DESCRIPTION"
 #+ * EnvironmentMap.resolution -> resolution:   int  "Pixel resolution of the rendered environment map"
 #+ * EnvironmentMap.source -> source:   enum  "NO DESCRIPTION"
 #+ * FluidSettings|ControlFluidSettings.velocity_strength -> velocity_strength:   float  "Force strength of how much of the control objects velocity is influencing the fluid velocity"
 #+ * FluidSettings|DomainFluidSettings.compressibility -> compressibility:   float  "Allowed compressibility due to gravitational force for standing fluid. (directly affects simulation step size)"
 #+ * FluidSettings|DomainFluidSettings.end_time -> end_time:   float  "Simulation time of the last blender frame (in seconds)"
- + * FluidSettings|DomainFluidSettings.path -> filepath:   string  "Directory (and/or filename prefix) to store baked fluid simulation files in"
+#FluidSettings|DomainFluidSettings.filepath -> filepath:   string  "Directory (and/or filename prefix) to store baked fluid simulation files in"
 #+ * FluidSettings|DomainFluidSettings.generate_particles -> generate_particles:   float  "Amount of particles to generate (0=off, 1=normal, >1=more)"
 #+ * FluidSettings|DomainFluidSettings.gravity -> gravity:   float[3]  "Gravity in X, Y and Z direction"
 #+ * FluidSettings|DomainFluidSettings.grid_levels -> grid_levels:   int  "Number of coarsened grids to use (-1 for automatic)"
  + * FluidSettings|OutflowFluidSettings.export_animated_mesh -> use_animated_mesh:   boolean  "Export this mesh as an animated one. Slower, only use if really necessary (e.g. armatures or parented objects), animated pos/rot/scale IPOs do not require it"
 #+ * FluidSettings|OutflowFluidSettings.volume_initialization -> volume_initialization:   enum  "Volume initialization type"
 #+ * FluidSettings|ParticleFluidSettings.alpha_influence -> alpha_influence:   float  "Amount of particle alpha change, inverse of size influence: 0=off (all same alpha), 1=full. (large particles get lower alphas, smaller ones higher values)"
- + * FluidSettings|ParticleFluidSettings.path -> filepath:   string  "Directory (and/or filename prefix) to store and load particles from"
+#FluidSettings|ParticleFluidSettings.filepath -> filepath:   string  "Directory (and/or filename prefix) to store and load particles from"
 #+ * FluidSettings|ParticleFluidSettings.particle_influence -> particle_influence:   float  "Amount of particle size scaling: 0=off (all same size), 1=full (range 0.2-2.0), >1=stronger"
 #FluidSettings|ParticleFluidSettings.show_tracer -> show_tracer:   boolean  "Show tracer particles"
  + * FluidSettings|ParticleFluidSettings.drops -> use_drops:   boolean  "Show drop particles"
 #+ * ID|Lamp|SpotLamp.spot_size -> spot_size:   float  "Angle of the spotlight beam in degrees"
  + * ID|Lamp|SpotLamp.auto_clip_end -> use_auto_clip_end:   boolean  "Automatic calculation of clipping-end, based on visible vertices"
  + * ID|Lamp|SpotLamp.auto_clip_start -> use_auto_clip_start:   boolean  "Automatic calculation of clipping-start, based on visible vertices"
- + * ID|Lamp|SpotLamp.halo -> use_halo:   boolean  "Renders spotlight with a volumetric halo (Buffer Shadows)"
+#ID|Lamp|SpotLamp.use_halo -> use_halo:   boolean  "Renders spotlight with a volumetric halo (Buffer Shadows)"
  + * ID|Lamp|SpotLamp.only_shadow -> use_only_shadow:   boolean  "Causes light to cast shadows only without illuminating objects"
  + * ID|Lamp|SpotLamp.shadow_layer -> use_shadow_layer:   boolean  "Causes only objects on the same layer to cast shadows"
  + * ID|Lamp|SpotLamp.sphere -> use_sphere:   boolean  "Sets light intensity to zero beyond lamp distance"
 #+ * MeshStringProperty.value -> value:   string  "NO DESCRIPTION"
 #+ * MeshStringPropertyLayer.data -> data:   collection,  "(read-only)"
 #+ * MeshStringPropertyLayer.name -> name:   string  "NO DESCRIPTION"
- + * MeshTextureFace.transp -> blend_type:   enum  "Transparency blending mode"
- + * MeshTextureFace.invisible -> hide:   boolean  "Make face invisible"
+#MeshTextureFace.blend_type -> blend_type:   enum  "Transparency blending mode"
+#MeshTextureFace.hide -> hide:   boolean  "Make face invisible"
 #+ * MeshTextureFace.image -> image:   pointer  "NO DESCRIPTION"
- + * MeshTextureFace.uv_pinned -> pin_uv:   boolean[4]  "NO DESCRIPTION"
+#MeshTextureFace.pin_uv -> pin_uv:   boolean[4]  "NO DESCRIPTION"
 #+ * MeshTextureFace.select_uv -> select_uv:   boolean[4]  "NO DESCRIPTION"
- + * MeshTextureFace.alpha_sort -> use_alpha_sort:   boolean  "Enable sorting of faces for correct alpha drawing (slow, use Clip Alpha instead when possible)"
- + * MeshTextureFace.billboard -> use_billboard:   boolean  "Billboard with Z-axis constraint"
- + * MeshTextureFace.text -> use_bitmap_text:   boolean  "Enable bitmap text on face"
- + * MeshTextureFace.shared -> use_blend_shared:   boolean  "Blend vertex colors across face when vertices are shared"
- + * MeshTextureFace.collision -> use_collision:   boolean  "Use face for collision and ray-sensor detection"
- + * MeshTextureFace.halo -> use_halo:   boolean  "Screen aligned billboard"
- + * MeshTextureFace.light -> use_light:   boolean  "Use light for face"
- + * MeshTextureFace.object_color -> use_object_color:   boolean  "Use ObColor instead of vertex colors"
- + * MeshTextureFace.shadow -> use_shadow_cast:   boolean  "Face is used for shadow"
- + * MeshTextureFace.tex -> use_texture:   boolean  "Render face with texture"
- + * MeshTextureFace.twoside -> use_twoside:   boolean  "Render face two-sided"
+#MeshTextureFace.use_alpha_sort -> use_alpha_sort:   boolean  "Enable sorting of faces for correct alpha drawing (slow, use Clip Alpha instead when possible)"
+#MeshTextureFace.use_billboard -> use_billboard:   boolean  "Billboard with Z-axis constraint"
+#MeshTextureFace.use_bitmap_text -> use_bitmap_text:   boolean  "Enable bitmap text on face"
+#MeshTextureFace.use_blend_shared -> use_blend_shared:   boolean  "Blend vertex colors across face when vertices are shared"
+#MeshTextureFace.use_collision -> use_collision:   boolean  "Use face for collision and ray-sensor detection"
+#MeshTextureFace.use_halo -> use_halo:   boolean  "Screen aligned billboard"
+#MeshTextureFace.use_light -> use_light:   boolean  "Use light for face"
+#MeshTextureFace.use_object_color -> use_object_color:   boolean  "Use ObColor instead of vertex colors"
+#MeshTextureFace.use_shadow_cast -> use_shadow_cast:   boolean  "Face is used for shadow"
+#MeshTextureFace.use_texture -> use_texture:   boolean  "Render face with texture"
+#MeshTextureFace.use_twoside -> use_twoside:   boolean  "Render face two-sided"
 #+ * MeshTextureFace.uv -> uv:   float[8]  "NO DESCRIPTION"
 #+ * MeshTextureFace.uv1 -> uv1:   float[2]  "NO DESCRIPTION"
 #+ * MeshTextureFace.uv2 -> uv2:   float[2]  "NO DESCRIPTION"
 #Modifier.show_expanded -> show_expanded:   boolean  "Set modifier expanded in the user interface"
 #Modifier.show_in_editmode -> show_in_editmode:   boolean  "Use modifier while in the edit mode"
 #Modifier.show_on_cage -> show_on_cage:   boolean  "Enable direct editing of modifier control cage"
+#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.render -> show_render:   boolean  "Use modifier during rendering"
  + * Modifier|ArmatureModifier.invert -> 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"
 #TODO SHOULD THIS BE HERE * Panel.text -> text:   string  "XXX todo"
 #+ * Particle.alive_state -> alive_state:   enum  "NO DESCRIPTION"
 #+ * Particle.angular_velocity -> angular_velocity:   float[3]  "NO DESCRIPTION"
- + * Particle.birthtime -> birth_time:   float  "NO DESCRIPTION"
+#Particle.birth_time -> birth_time:   float  "NO DESCRIPTION"
 #+ * Particle.die_time -> die_time:   float  "NO DESCRIPTION"
- + * Particle.is_existing -> is_exist:   boolean,  "(read-only)"
+#Particle.is_exist -> is_exist:   boolean,  "(read-only)"
 #Particle.is_hair -> is_hair:   collection,  "(read-only)"
 #+ * Particle.is_visible -> is_visible:   boolean,  "(read-only)"
 #+ * Particle.keys -> keys:   collection,  "(read-only)"
 #+ * ParticleSystem.vertex_group_size -> vertex_group_size:   string  "Vertex group to control size"
 #+ * ParticleSystem.vertex_group_tangent -> vertex_group_tangent:   string  "Vertex group to control tangent"
 #+ * ParticleSystem.vertex_group_velocity -> vertex_group_velocity:   string  "Vertex group to control velocity"
- + * ParticleTarget.mode -> alliance:   enum  "NO DESCRIPTION"
+#ParticleTarget.alliance -> alliance:   enum  "NO DESCRIPTION"
 #+ * ParticleTarget.duration -> duration:   float  "NO DESCRIPTION"
- + * ParticleTarget.valid -> is_valid:   boolean  "Keyed particles target is valid"
+#ParticleTarget.is_valid -> is_valid:   boolean  "Keyed particles target is valid"
 #+ * ParticleTarget.name -> name:   string,  "(read-only)    Particle target name"
 #+ * ParticleTarget.object -> object:   pointer  "The object that has the target particle system (empty if same object)"
 #+ * ParticleTarget.system -> system:   int  "The index of particle system on the target object"
 #+ * PointCache.filepath -> filepath:   string  "Cache file path"
 #+ * PointCache.frame_end -> frame_end:   int  "Frame on which the simulation stops"
 #+ * PointCache.frame_start -> frame_start:   int  "Frame on which the simulation starts"
- + * PointCache.step -> frame_step:   int  "Number of frames between cached frames"
+#PointCache.frame_step -> frame_step:   int  "Number of frames between cached frames"
 #+ * PointCache.frames_skipped -> frames_skipped:   boolean,  "(read-only)"
 #+ * PointCache.index -> index:   int  "Index number of cache files"
 #+ * PointCache.info -> info:   string,  "(read-only)    Info on current cache status"
 #PointCache.is_outdated -> is_outdated:   boolean,  "(read-only)"
 #+ * PointCache.name -> name:   string  "Cache name"
 #PointCache.point_caches -> point_caches:   collection,  "(read-only)    Point cache list"
- + * PointCache.disk_cache -> use_disk_cache:   boolean  "Save cache files to disk (.blend file must be saved first)"
- + * PointCache.external -> use_external:   boolean  "Read cache from an external location"
+#PointCache.use_disk_cache -> use_disk_cache:   boolean  "Save cache files to disk (.blend file must be saved first)"
+#PointCache.use_external -> use_external:   boolean  "Read cache from an external location"
 #+ * PointCache.use_library_path -> use_library_path:   boolean  "Use this files path when library linked into another file."
- + * PointCache.quick_cache -> use_quick_cache:   boolean  "Update simulation with cache steps"
+#PointCache.use_quick_cache -> use_quick_cache:   boolean  "Update simulation with cache steps"
 #+ * PointDensity.color_ramp -> color_ramp:   pointer,  "(read-only)"
 #+ * PointDensity.color_source -> color_source:   enum  "Data to derive color results from"
 #+ * PointDensity.falloff -> falloff:   enum  "Method of attenuating density by distance from the point"
 #+ * RenderSettings.edge_color -> edge_color:   float[3]  "NO DESCRIPTION"
 #+ * RenderSettings.edge_threshold -> edge_threshold:   int  "Threshold for drawing outlines on geometry edges"
 #+ * RenderSettings.engine -> engine:   enum  "Engine to use for rendering"
+#RenderSettings.exr_codec -> exr_codec:   enum  "Codec settings for OpenEXR"
+#RenderSettings.exr_half -> exr_half:   boolean  "Use 16 bit floats instead of 32 bit floats per channel"
+#RenderSettings.exr_preview -> exr_preview:   boolean  "When rendering animations, save JPG preview images in same directory"
+#RenderSettings.exr_zbuf -> exr_zbuf:   boolean  "Save the z-depth per pixel (32 bit unsigned int zbuffer)"
 #+ * RenderSettings.field_order -> field_order:   enum  "Order of video fields. Select which lines get rendered first, to create smooth motion for TV output"
 #+ * RenderSettings.file_extension -> file_extension:   string,  "(read-only)    The file extension used for saving renders"
 #+ * RenderSettings.file_format -> file_format:   enum  "File format to save the rendered images as"
 #+ * RenderSettings.fps_base -> fps_base:   float  "Framerate base"
 #RenderSettings.has_multiple_engines -> has_multiple_engines:   boolean,  "(read-only)    More than one rendering engine is available"
 #+ * RenderSettings.is_movie_format -> is_movie_format:   boolean,  "(read-only)    When true the format is a movie"
+#RenderSettings.jpeg2k_depth -> jpeg2k_depth:   enum  "Bit depth per channel"
+#RenderSettings.jpeg2k_preset -> jpeg2k_preset:   enum  "Use a DCI Standard preset for saving jpeg2000"
+#RenderSettings.jpeg2k_ycc -> jpeg2k_ycc:   boolean  "Save luminance-chrominance-chrominance channels instead of RGB colors"
 #+ * RenderSettings.layers -> layers:   collection,  "(read-only)"
 #+ * RenderSettings.motion_blur_samples -> motion_blur_samples:   int  "Number of scene samples to take with motion blur"
 #+ * RenderSettings.motion_blur_shutter -> motion_blur_shutter:   float  "Time taken in frames between shutter open and close"
 #+ * SmokeFlowSettings.temperature -> temperature:   float  "Temperature difference to ambient temperature"
 #SmokeFlowSettings.use_absolute -> use_absolute:   boolean  "Only allows given density value in emitter area."
  +NEGATE * SmokeFlowSettings.outflow -> use_outflow:   boolean  "Deletes smoke from simulation"
- + * SmokeFlowSettings.velocity_multiplier -> velocity_factor:   float  "Multiplier to adjust velocity passed to smoke"
+#SmokeFlowSettings.velocity_factor -> velocity_factor:   float  "Multiplier to adjust velocity passed to smoke"
 #+ * SoftBodySettings.aero -> aero:   float  "Make edges sail"
 #+ * SoftBodySettings.aerodynamics_type -> aerodynamics_type:   enum  "Method of calculating aerodynamic interaction"
 #+ * SoftBodySettings.ball_damp -> ball_damp:   float  "Blending to inelastic collision"
 #+ * TextCharacterFormat.use_small_caps -> use_small_caps:   boolean  "NO DESCRIPTION"
  + * TextCharacterFormat.underline -> use_underline:   boolean  "NO DESCRIPTION"
 #+ * TextLine.body -> body:   string  "Text in the line"
- + * TextMarker.end -> character_index_end:   int,  "(read-only)    Start position of the marker in the line"
- + * TextMarker.start -> character_index_start:   int,  "(read-only)    Start position of the marker in the line"
+#TextMarker.character_index_end -> character_index_end:   int,  "(read-only)    Start position of the marker in the line"
+#TextMarker.character_index_start -> character_index_start:   int,  "(read-only)    Start position of the marker in the line"
 #+ * TextMarker.color -> color:   float[4]  "Color to display the marker with"
 #+ * TextMarker.group -> group:   int,  "(read-only)"
 #TextMarker.is_temporary -> is_temporary:   boolean,  "(read-only)    Marker is temporary"
  + * WorldStarsSettings.color_randomization -> color_random:   float  "Randomize star colors"
  + * WorldStarsSettings.min_distance -> distance_min:   float  "Minimum distance to the camera for stars"
 #+ * WorldStarsSettings.size -> size:   float  "Average screen dimension of stars"
-#+ * WorldStarsSettings.use_stars -> use_stars:   boolean  "Enable starfield generation[651155 refs]"
+#+ * WorldStarsSettings.use_stars -> use_stars:   boolean  "Enable starfield generation"