rna renaming FModifier & GameObjectSettings
authorCampbell Barton <ideasman42@gmail.com>
Thu, 19 Aug 2010 17:10:43 +0000 (17:10 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Thu, 19 Aug 2010 17:10:43 +0000 (17:10 +0000)
release/scripts/ui/properties_game.py
source/blender/editors/animation/fmodifier_ui.c
source/blender/editors/space_graph/graph_edit.c
source/blender/editors/space_logic/logic_window.c
source/blender/makesrna/intern/rna_fcurve.c
source/blender/makesrna/intern/rna_object.c
source/blender/makesrna/rna_cleanup/rna_properties.txt

index 1a71f4fb280524bea93876000cd16d416d8f6785..ee026a3663abf13894cd63d30d5a47604f87b753 100644 (file)
@@ -56,8 +56,8 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, bpy.types.Panel):
             col.prop(ob, "hide_render", text="Invisible") # out of place but useful
 
             col = split.column()
-            col.prop(game, "material_physics")
-            col.prop(game, "rotate_from_normal")
+            col.prop(game, "use_material_physics")
+            col.prop(game, "use_rotate_from_normal")
             col.prop(game, "use_sleep")
 
             layout.separator()
@@ -73,9 +73,9 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, bpy.types.Panel):
             col = split.column()
             sub = col.column()
             sub.active = (game.physics_type == 'RIGID_BODY')
-            sub.prop(game, "anisotropic_friction")
+            sub.prop(game, "use_anisotropic_friction")
             subsub = sub.column()
-            subsub.active = game.anisotropic_friction
+            subsub.active = game.use_anisotropic_friction
             subsub.prop(game, "friction_coefficients", text="", slider=True)
 
             split = layout.split()
@@ -83,8 +83,8 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, bpy.types.Panel):
             col = split.column()
             col.label(text="Velocity:")
             sub = col.column(align=True)
-            sub.prop(game, "minimum_velocity", text="Minimum")
-            sub.prop(game, "maximum_velocity", text="Maximum")
+            sub.prop(game, "velocity_min", text="Minimum")
+            sub.prop(game, "velocity_max", text="Maximum")
 
             col = split.column()
             col.label(text="Damping:")
@@ -98,15 +98,15 @@ class PHYSICS_PT_game_physics(PhysicsButtonsPanel, bpy.types.Panel):
 
             col = split.column()
             col.label(text="Lock Translation:")
-            col.prop(game, "lock_x_axis", text="X")
-            col.prop(game, "lock_y_axis", text="Y")
-            col.prop(game, "lock_z_axis", text="Z")
+            col.prop(game, "lock_location_x", text="X")
+            col.prop(game, "lock_location_y", text="Y")
+            col.prop(game, "lock_location_z", text="Z")
 
             col = split.column()
             col.label(text="Lock Rotation:")
-            col.prop(game, "lock_x_rot_axis", text="X")
-            col.prop(game, "lock_y_rot_axis", text="Y")
-            col.prop(game, "lock_z_rot_axis", text="Z")
+            col.prop(game, "lock_rotation_x", text="X")
+            col.prop(game, "lock_rotation_y", text="Y")
+            col.prop(game, "lock_rotation_z", text="Z")
 
         elif game.physics_type == 'SOFT_BODY':
             col = layout.column()
@@ -174,7 +174,7 @@ class PHYSICS_PT_game_collision_bounds(PhysicsButtonsPanel, bpy.types.Panel):
         game = context.active_object.game
 
         layout.active = game.use_collision_bounds
-        layout.prop(game, "collision_bounds", text="Bounds")
+        layout.prop(game, "collision_bounds_type", text="Bounds")
 
         split = layout.split()
 
@@ -182,7 +182,7 @@ class PHYSICS_PT_game_collision_bounds(PhysicsButtonsPanel, bpy.types.Panel):
         col.prop(game, "collision_margin", text="Margin", slider=True)
 
         col = split.column()
-        col.prop(game, "collision_compound", text="Compound")
+        col.prop(game, "use_collision_compound", text="Compound")
 
 
 class RenderButtonsPanel():
index 2f91d8eee68c4d0f31d9998b9a86085fa5367ab3..191316711f44a8fb4f84d4868b380448efc3ed1a 100644 (file)
@@ -119,7 +119,7 @@ static void draw_modifier__generator(uiLayout *layout, ID *id, FModifier *fcm, s
                but= uiDefButR(block, MENU, B_FMODIFIER_REDRAW, NULL, 0, 0, width-30, UI_UNIT_Y, &ptr, "mode", -1, 0, 0, -1, -1, NULL);
                uiButSetFunc(but, validate_fmodifier_cb, fcm, NULL);
                
-               uiDefButR(block, TOG, B_FMODIFIER_REDRAW, NULL, 0, 0, width-30, UI_UNIT_Y, &ptr, "additive", -1, 0, 0, -1, -1, NULL);
+               uiDefButR(block, TOG, B_FMODIFIER_REDRAW, NULL, 0, 0, width-30, UI_UNIT_Y, &ptr, "use_additive", -1, 0, 0, -1, -1, NULL);
        uiBlockEndAlign(block);
        
        /* now add settings for individual modes */
@@ -226,7 +226,7 @@ static void draw_modifier__fn_generator(uiLayout *layout, ID *id, FModifier *fcm
        /* add the settings */
        col= uiLayoutColumn(layout, 1);
                uiItemR(col, &ptr, "function_type", 0, "", 0);
-               uiItemR(col, &ptr, "additive", UI_ITEM_R_TOGGLE, NULL, 0);
+               uiItemR(col, &ptr, "use_additive", UI_ITEM_R_TOGGLE, NULL, 0);
        
        col= uiLayoutColumn(layout, 0); // no grouping for now
                uiItemR(col, &ptr, "amplitude", 0, NULL, 0);
@@ -254,14 +254,14 @@ static void draw_modifier__cycles(uiLayout *layout, ID *id, FModifier *fcm, shor
        /* before range */
        col= uiLayoutColumn(split, 1);
                uiItemL(col, "Before:", 0);
-               uiItemR(col, &ptr, "before_mode", 0, "", 0);
-               uiItemR(col, &ptr, "before_cycles", 0, NULL, 0);
+               uiItemR(col, &ptr, "mode_before", 0, "", 0);
+               uiItemR(col, &ptr, "cycles_before", 0, NULL, 0);
                
        /* after range */
        col= uiLayoutColumn(split, 1);
                uiItemL(col, "After:", 0);
-               uiItemR(col, &ptr, "after_mode", 0, "", 0);
-               uiItemR(col, &ptr, "after_cycles", 0, NULL, 0);
+               uiItemR(col, &ptr, "mode_after", 0, "", 0);
+               uiItemR(col, &ptr, "cycles_after", 0, NULL, 0);
 }
 
 /* --------------- */
@@ -473,8 +473,8 @@ static void draw_modifier__envelope(uiLayout *layout, ID *id, FModifier *fcm, sh
                uiItemR(col, &ptr, "reference_value", 0, NULL, 0);
                
                row= uiLayoutRow(col, 1);
-                       uiItemR(row, &ptr, "default_minimum", 0, "Min", 0);
-                       uiItemR(row, &ptr, "default_maximum", 0, "Max", 0);
+                       uiItemR(row, &ptr, "default_min", 0, "Min", 0);
+                       uiItemR(row, &ptr, "default_max", 0, "Max", 0);
                        
        /* control points header */
        // TODO: move this control-point control stuff to using the new special widgets for lists
@@ -526,13 +526,13 @@ static void draw_modifier__limits(uiLayout *layout, ID *id, FModifier *fcm, shor
                
                /* x-minimum */
                col= uiLayoutColumn(split, 1);
-                       uiItemR(col, &ptr, "use_minimum_x", 0, NULL, 0);
-                       uiItemR(col, &ptr, "minimum_x", 0, NULL, 0);
+                       uiItemR(col, &ptr, "use_min_x", 0, NULL, 0);
+                       uiItemR(col, &ptr, "min_x", 0, NULL, 0);
                        
                /* y-minimum*/
                col= uiLayoutColumn(split, 1);
-                       uiItemR(col, &ptr, "use_minimum_y", 0, NULL, 0);
-                       uiItemR(col, &ptr, "minimum_y", 0, NULL, 0);
+                       uiItemR(col, &ptr, "use_min_y", 0, NULL, 0);
+                       uiItemR(col, &ptr, "min_y", 0, NULL, 0);
        }
        
        /* row 2: maximum */
@@ -544,13 +544,13 @@ static void draw_modifier__limits(uiLayout *layout, ID *id, FModifier *fcm, shor
                
                /* x-minimum */
                col= uiLayoutColumn(split, 1);
-                       uiItemR(col, &ptr, "use_maximum_x", 0, NULL, 0);
-                       uiItemR(col, &ptr, "maximum_x", 0, NULL, 0);
+                       uiItemR(col, &ptr, "use_max_x", 0, NULL, 0);
+                       uiItemR(col, &ptr, "max_x", 0, NULL, 0);
                        
                /* y-minimum*/
                col= uiLayoutColumn(split, 1);
-                       uiItemR(col, &ptr, "use_maximum_y", 0, NULL, 0);
-                       uiItemR(col, &ptr, "maximum_y", 0, NULL, 0);
+                       uiItemR(col, &ptr, "use_max_y", 0, NULL, 0);
+                       uiItemR(col, &ptr, "max_y", 0, NULL, 0);
        }
 }
 
@@ -567,8 +567,8 @@ static void draw_modifier__stepped(uiLayout *layout, ID *id, FModifier *fcm, sho
        
        /* block 1: "stepping" settings */
        col= uiLayoutColumn(layout, 0);
-               uiItemR(col, &ptr, "step_size", 0, NULL, 0);
-               uiItemR(col, &ptr, "offset", 0, NULL, 0);
+               uiItemR(col, &ptr, "frame_step", 0, NULL, 0);
+               uiItemR(col, &ptr, "frame_offset", 0, NULL, 0);
                
        /* block 2: start range settings */
        col= uiLayoutColumn(layout, 1);
index 01378d9ef85654f0f3554ee46264d277a864fe9c..5c692ba11124ecaae29966c88e720f9e6fa7807f 100644 (file)
@@ -1043,7 +1043,7 @@ static int graphkeys_sound_bake_exec(bContext *C, wmOperator *op)
                                                                          RNA_float_get(op->ptr, "release"),
                                                                          RNA_float_get(op->ptr, "threshold"),
                                                                          RNA_boolean_get(op->ptr, "accumulate"),
-                                                                         RNA_boolean_get(op->ptr, "additive"),
+                                                                         RNA_boolean_get(op->ptr, "use_additive"),
                                                                          RNA_boolean_get(op->ptr, "square"),
                                                                          RNA_float_get(op->ptr, "sthreshold"),
                                                                          FPS, &sbi.length);
@@ -1118,7 +1118,7 @@ void GRAPH_OT_sound_bake (wmOperatorType *ot)
        RNA_def_float(ot->srna, "release", 0.2, 0.0, 5.0, "Release time", "", 0.01, 0.2);
        RNA_def_float(ot->srna, "threshold", 0.0, 0.0, 1.0, "Threshold", "", 0.01, 0.1);
        RNA_def_boolean(ot->srna, "accumulate", 0, "Accumulate", "");
-       RNA_def_boolean(ot->srna, "additive", 0, "Additive", "");
+       RNA_def_boolean(ot->srna, "use_additive", 0, "Additive", "");
        RNA_def_boolean(ot->srna, "square", 0, "Square", "");
        RNA_def_float(ot->srna, "sthreshold", 0.1, 0.0, 1.0, "Square Threshold", "", 0.01, 0.1);
 }
index 334efb1479bbe9f8b52ee90236916114435d2577..8a703c510c4baa56ce77ac7383742d0192e6fd15 100644 (file)
@@ -4508,13 +4508,13 @@ static void logic_buttons_new(bContext *C, ARegion *ar)
                        subsplit= uiLayoutSplit(split, 0.85, 0);
                        col= uiLayoutColumn(subsplit, 0);
                        row= uiLayoutRow(col, 0);
-                       uiLayoutSetActive(row, RNA_boolean_get(&settings_ptr, "all_states")==0);
-                       uiTemplateLayers(row, &settings_ptr, "visible_state", &settings_ptr, "used_states", 0);
+                       uiLayoutSetActive(row, RNA_boolean_get(&settings_ptr, "use_all_states")==0);
+                       uiTemplateLayers(row, &settings_ptr, "states_visible", &settings_ptr, "used_states", 0);
                        row= uiLayoutRow(col, 0);
-                       uiTemplateLayers(row, &settings_ptr, "initial_state", &settings_ptr, "used_states", 0);
+                       uiTemplateLayers(row, &settings_ptr, "states_initial", &settings_ptr, "used_states", 0);
 
                        col= uiLayoutColumn(subsplit, 0);
-                       uiItemR(col, &settings_ptr, "all_states", UI_ITEM_R_TOGGLE, NULL, 0);
+                       uiItemR(col, &settings_ptr, "use_all_states", UI_ITEM_R_TOGGLE, NULL, 0);
                        uiItemR(col, &settings_ptr, "show_debug_state", 0, "", 0); 
                }
 
index 8410099979e0a3c899727fb6471e51cb4ab9c7a3..b37e5f915382224adb451c6ce636a1f4442fd0c8 100644 (file)
@@ -568,7 +568,7 @@ static void rna_def_fmodifier_generator(BlenderRNA *brna)
        RNA_def_struct_sdna_from(srna, "FMod_Generator", "data");
        
        /* define common props */
-       prop= RNA_def_property(srna, "additive", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_additive", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_GENERATOR_ADDITIVE);
        RNA_def_property_ui_text(prop, "Additive", "Values generated by this modifier are applied on top of the existing values instead of overwriting them");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
@@ -633,7 +633,7 @@ static void rna_def_fmodifier_function_generator(BlenderRNA *brna)
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
        /* flags */
-       prop= RNA_def_property(srna, "additive", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_additive", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_GENERATOR_ADDITIVE);
        RNA_def_property_ui_text(prop, "Additive", "Values generated by this modifier are applied on top of the existing values instead of overwriting them");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
@@ -701,12 +701,12 @@ static void rna_def_fmodifier_envelope(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Reference Value", "Value that envelope's influence is centered around / based on");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "default_minimum", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "default_min", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "min");
        RNA_def_property_ui_text(prop, "Default Minimum", "Lower distance from Reference Value for 1:1 default influence");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "default_maximum", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "default_max", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "max");
        RNA_def_property_ui_text(prop, "Default Maximum", "Upper distance from Reference Value for 1:1 default influence");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
@@ -731,22 +731,26 @@ static void rna_def_fmodifier_cycles(BlenderRNA *brna)
        RNA_def_struct_sdna_from(srna, "FMod_Cycles", "data");
        
        /* before */
-       prop= RNA_def_property(srna, "before_mode", PROP_ENUM, PROP_NONE);
+       prop= RNA_def_property(srna, "mode_before", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "before_mode");
        RNA_def_property_enum_items(prop, prop_type_items);
        RNA_def_property_ui_text(prop, "Before Mode", "Cycling mode to use before first keyframe");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "before_cycles", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "cycles_before", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "before_cycles");
        RNA_def_property_ui_text(prop, "Before Cycles", "Maximum number of cycles to allow before first keyframe. (0 = infinite)");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
        /* after */
-       prop= RNA_def_property(srna, "after_mode", PROP_ENUM, PROP_NONE);
+       prop= RNA_def_property(srna, "mode_after", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "after_mode");
        RNA_def_property_enum_items(prop, prop_type_items);
        RNA_def_property_ui_text(prop, "After Mode", "Cycling mode to use after last keyframe");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "after_cycles", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "cycles_after", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "after_cycles");
        RNA_def_property_ui_text(prop, "After Cycles", "Maximum number of cycles to allow after last keyframe. (0 = infinite)");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
 }
@@ -774,45 +778,45 @@ static void rna_def_fmodifier_limits(BlenderRNA *brna)
        RNA_def_struct_ui_text(srna, "Limits F-Modifier", "Limits the time/value ranges of the modified F-Curve");
        RNA_def_struct_sdna_from(srna, "FMod_Limits", "data");
        
-       prop= RNA_def_property(srna, "use_minimum_x", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_min_x", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_XMIN);
        RNA_def_property_ui_text(prop, "Minimum X", "Use the minimum X value");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "use_minimum_y", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_min_y", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_YMIN);
        RNA_def_property_ui_text(prop, "Minimum Y", "Use the minimum Y value");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "use_maximum_x", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_max_x", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_XMAX);
        RNA_def_property_ui_text(prop, "Maximum X", "Use the maximum X value");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "use_maximum_y", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_max_y", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "flag", FCM_LIMIT_YMAX);
        RNA_def_property_ui_text(prop, "Maximum Y", "Use the maximum Y value");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "minimum_x", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "min_x", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "rect.xmin");
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifierLimits_minx_range");
        RNA_def_property_ui_text(prop, "Minimum X", "Lowest X value to allow");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "minimum_y", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "min_y", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "rect.ymin");
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifierLimits_miny_range");
        RNA_def_property_ui_text(prop, "Minimum Y", "Lowest Y value to allow");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "maximum_x", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "max_x", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "rect.xmax");
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifierLimits_maxx_range");
        RNA_def_property_ui_text(prop, "Maximum X", "Highest X value to allow");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "maximum_y", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "max_y", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "rect.ymax");
        RNA_def_property_float_funcs(prop, NULL, NULL, "rna_FModifierLimits_maxy_range");
        RNA_def_property_ui_text(prop, "Maximum Y", "Highest Y value to allow");
@@ -877,11 +881,12 @@ static void rna_def_fmodifier_stepped(BlenderRNA *brna)
        RNA_def_struct_sdna_from(srna, "FMod_Stepped", "data");
        
        /* properties */
-       prop= RNA_def_property(srna, "step_size", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "frame_step", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "step_size");
        RNA_def_property_ui_text(prop, "Step Size", "Number of frames to hold each value");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
        
-       prop= RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "frame_offset", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "offset");
        RNA_def_property_ui_text(prop, "Offset", "Reference number of frames before frames get held. Use to get hold for '1-3' vs '5-7' holding patterns");
        RNA_def_property_update(prop, NC_ANIMATION|ND_KEYFRAME|NA_EDITED, NULL);
index dad4468fb186fe2a69d7ad62aa13f824a45a85cb..5fc3e571045cc0b5901c2e08aafb9dca1cde33a6 100644 (file)
@@ -1246,40 +1246,40 @@ static void rna_def_object_game_settings(BlenderRNA *brna)
        RNA_def_property_range(prop, 0.0, 1.0);
        RNA_def_property_ui_text(prop, "Rotation Damping", "General rotation damping");
 
-       prop= RNA_def_property(srna, "minimum_velocity", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "velocity_min", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "min_vel");
        RNA_def_property_range(prop, 0.0, 1000.0);
        RNA_def_property_ui_text(prop, "Velocity Min", "Clamp velocity to this minimum speed (except when totally still)");
 
-       prop= RNA_def_property(srna, "maximum_velocity", PROP_FLOAT, PROP_NONE);
+       prop= RNA_def_property(srna, "velocity_max", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "max_vel");
        RNA_def_property_range(prop, 0.0, 1000.0);
        RNA_def_property_ui_text(prop, "Velocity Max", "Clamp velocity to this maximum speed");
 
        /* lock position */
-       prop= RNA_def_property(srna, "lock_x_axis", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "lock_location_x", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "gameflag2", OB_LOCK_RIGID_BODY_X_AXIS);
        RNA_def_property_ui_text(prop, "Lock X Axis", "Disable simulation of linear motion along the X axis");
        
-       prop= RNA_def_property(srna, "lock_y_axis", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "lock_location_y", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "gameflag2", OB_LOCK_RIGID_BODY_Y_AXIS);
        RNA_def_property_ui_text(prop, "Lock Y Axis", "Disable simulation of linear motion along the Y axis");
        
-       prop= RNA_def_property(srna, "lock_z_axis", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "lock_location_z", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "gameflag2", OB_LOCK_RIGID_BODY_Z_AXIS);
        RNA_def_property_ui_text(prop, "Lock Z Axis", "Disable simulation of linear motion along the Z axis");
        
        
        /* lock rotation */
-       prop= RNA_def_property(srna, "lock_x_rot_axis", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "lock_rotation_x", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "gameflag2", OB_LOCK_RIGID_BODY_X_ROT_AXIS);
        RNA_def_property_ui_text(prop, "Lock X Rotation Axis", "Disable simulation of angular  motion along the X axis");
        
-       prop= RNA_def_property(srna, "lock_y_rot_axis", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "lock_rotation_y", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "gameflag2", OB_LOCK_RIGID_BODY_Y_ROT_AXIS);
        RNA_def_property_ui_text(prop, "Lock Y Rotation Axis", "Disable simulation of angular  motion along the Y axis");
        
-       prop= RNA_def_property(srna, "lock_z_rot_axis", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "lock_rotation_z", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "gameflag2", OB_LOCK_RIGID_BODY_Z_ROT_AXIS);
        RNA_def_property_ui_text(prop, "Lock Z Rotation Axis", "Disable simulation of angular  motion along the Z axis");
        
@@ -1289,11 +1289,11 @@ static void rna_def_object_game_settings(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Lock Z Rotation Axis", "Disable simulation of angular  motion along the Z axis");       
        
 
-       prop= RNA_def_property(srna, "material_physics", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_material_physics", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "gameflag", OB_DO_FH);
        RNA_def_property_ui_text(prop, "Use Material Physics", "Use physics settings in materials");
 
-       prop= RNA_def_property(srna, "rotate_from_normal", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_rotate_from_normal", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "gameflag", OB_ROT_FH);
        RNA_def_property_ui_text(prop, "Rotate From Normal", "Use face normal to rotate object, so that it points away from the surface");
 
@@ -1302,7 +1302,7 @@ static void rna_def_object_game_settings(BlenderRNA *brna)
        RNA_def_property_range(prop, 0.0, 1.0);
        RNA_def_property_ui_text(prop, "Form Factor", "Form factor scales the inertia tensor");
 
-       prop= RNA_def_property(srna, "anisotropic_friction", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_anisotropic_friction", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "gameflag", OB_ANISOTROPIC_FRICTION);
        RNA_def_property_ui_text(prop, "Anisotropic Friction", "Enable anisotropic friction");
 
@@ -1315,14 +1315,14 @@ static void rna_def_object_game_settings(BlenderRNA *brna)
        RNA_def_property_boolean_sdna(prop, NULL, "gameflag", OB_BOUNDS);
        RNA_def_property_ui_text(prop, "Use Collision Bounds", "Specify a collision bounds type other than the default");
 
-       prop= RNA_def_property(srna, "collision_bounds", PROP_ENUM, PROP_NONE);
+       prop= RNA_def_property(srna, "collision_bounds_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "boundtype");
        RNA_def_property_enum_items(prop, collision_bounds_items);
        RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_Object_collision_bounds_itemf");
        RNA_def_property_ui_text(prop, "Collision Bounds",  "Selects the collision type");
        RNA_def_property_update(prop, NC_OBJECT|ND_DRAW, NULL);
 
-       prop= RNA_def_property(srna, "collision_compound", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_collision_compound", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "gameflag", OB_CHILD);
        RNA_def_property_ui_text(prop, "Collision Compound", "Add children to form a compound collision object");
 
@@ -1337,7 +1337,7 @@ static void rna_def_object_game_settings(BlenderRNA *brna)
 
        /* state */
 
-       prop= RNA_def_property(srna, "visible_state", PROP_BOOLEAN, PROP_LAYER_MEMBER);
+       prop= RNA_def_property(srna, "states_visible", PROP_BOOLEAN, PROP_LAYER_MEMBER);
        RNA_def_property_boolean_sdna(prop, NULL, "state", 1);
        RNA_def_property_array(prop, OB_MAX_STATES);
        RNA_def_property_ui_text(prop, "State", "State determining which controllers are displayed");
@@ -1349,7 +1349,7 @@ static void rna_def_object_game_settings(BlenderRNA *brna)
        RNA_def_property_clear_flag(prop, PROP_EDITABLE);
        RNA_def_property_boolean_funcs(prop, "rna_GameObjectSettings_used_state_get", NULL);
        
-       prop= RNA_def_property(srna, "initial_state", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "states_initial", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "init_state", 1);
        RNA_def_property_array(prop, OB_MAX_STATES);
        RNA_def_property_ui_text(prop, "Initial State", "Initial state when the game starts");
@@ -1359,7 +1359,7 @@ static void rna_def_object_game_settings(BlenderRNA *brna)
        RNA_def_property_ui_text(prop, "Debug State", "Print state debug info in the game engine");
        RNA_def_property_ui_icon(prop, ICON_INFO, 0);
 
-       prop= RNA_def_property(srna, "all_states", PROP_BOOLEAN, PROP_NONE);
+       prop= RNA_def_property(srna, "use_all_states", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "scaflag", OB_ALLSTATE);
        RNA_def_property_ui_text(prop, "All", "Set all state bits");
 
index 6940b95d82ad73f44cdc2a2ddf8f6530708b68f1..7d5bc5a9570c4e5f58ceaef53e0dd76b731b1976 100644 (file)
 #+ * FModifierEnvelopeControlPoint.frame -> frame:   float  "Frame this control-point occurs on"
 #FModifierEnvelopeControlPoint.max -> max:   float  "Upper bound of envelope at this control-point"
 #FModifierEnvelopeControlPoint.min -> min:   float  "Lower bound of envelope at this control-point"
- + * FModifier|FModifierCycles.after_cycles -> cycles_after:   float  "Maximum number of cycles to allow after last keyframe. (0 = infinite)"
- + * FModifier|FModifierCycles.before_cycles -> cycles_before:   float  "Maximum number of cycles to allow before first keyframe. (0 = infinite)"
- + * FModifier|FModifierCycles.after_mode -> mode_after:   enum  "Cycling mode to use after last keyframe"
- + * FModifier|FModifierCycles.before_mode -> mode_before:   enum  "Cycling mode to use before first keyframe"
+#FModifier|FModifierCycles.cycles_after -> cycles_after:   float  "Maximum number of cycles to allow after last keyframe. (0 = infinite)"
+#FModifier|FModifierCycles.cycles_before -> cycles_before:   float  "Maximum number of cycles to allow before first keyframe. (0 = infinite)"
+#FModifier|FModifierCycles.mode_after -> mode_after:   enum  "Cycling mode to use after last keyframe"
+#FModifier|FModifierCycles.mode_before -> mode_before:   enum  "Cycling mode to use before first keyframe"
 #+ * FModifier|FModifierEnvelope.control_points -> control_points:   collection,  "(read-only)    Control points defining the shape of the envelope"
- + * FModifier|FModifierEnvelope.default_maximum -> default_max:   float  "Upper distance from Reference Value for 1:1 default influence"
- + * FModifier|FModifierEnvelope.default_minimum -> default_min:   float  "Lower distance from Reference Value for 1:1 default influence"
+#FModifier|FModifierEnvelope.default_max -> default_max:   float  "Upper distance from Reference Value for 1:1 default influence"
+#FModifier|FModifierEnvelope.default_min -> default_min:   float  "Lower distance from Reference Value for 1:1 default influence"
 #+ * FModifier|FModifierEnvelope.reference_value -> reference_value:   float  "Value that envelopes influence is centered around / based on"
 #+ * FModifier|FModifierFunctionGenerator.amplitude -> amplitude:   float  "Scale factor determining the maximum/minimum values"
 #+ * FModifier|FModifierFunctionGenerator.function_type -> function_type:   enum  "Type of built-in function to use"
 #+ * FModifier|FModifierFunctionGenerator.phase_multiplier -> phase_multiplier:   float  "Scale factor determining the speed of the function"
 #+ * FModifier|FModifierFunctionGenerator.phase_offset -> phase_offset:   float  "Constant factor to offset time by for function"
- + * FModifier|FModifierFunctionGenerator.additive -> use_additive:   boolean  "Values generated by this modifier are applied on top of the existing values instead of overwriting them"
+#FModifier|FModifierFunctionGenerator.use_additive -> use_additive:   boolean  "Values generated by this modifier are applied on top of the existing values instead of overwriting them"
 #+ * FModifier|FModifierFunctionGenerator.value_offset -> value_offset:   float  "Constant factor to offset values by"
 #+ * FModifier|FModifierGenerator.coefficients -> coefficients:   float[32]  "Coefficients for x (starting from lowest power of x^0)"
 #+ * FModifier|FModifierGenerator.mode -> mode:   enum  "Type of generator to use"
 #+ * FModifier|FModifierGenerator.poly_order -> poly_order:   int  "The highest power of x for this polynomial. (number of coefficients - 1)"
- + * FModifier|FModifierGenerator.additive -> use_additive:   boolean  "Values generated by this modifier are applied on top of the existing values instead of overwriting them"
- + * FModifier|FModifierLimits.maximum_x -> max_x:   float  "Highest X value to allow"
- + * FModifier|FModifierLimits.maximum_y -> max_y:   float  "Highest Y value to allow"
- + * FModifier|FModifierLimits.minimum_x -> min_x:   float  "Lowest X value to allow"
- + * FModifier|FModifierLimits.minimum_y -> min_y:   float  "Lowest Y value to allow"
- + * FModifier|FModifierLimits.use_maximum_x -> use_max_x:   boolean  "Use the maximum X value"
- + * FModifier|FModifierLimits.use_maximum_y -> use_max_y:   boolean  "Use the maximum Y value"
- + * FModifier|FModifierLimits.use_minimum_x -> use_min_x:   boolean  "Use the minimum X value"
- + * FModifier|FModifierLimits.use_minimum_y -> use_min_y:   boolean  "Use the minimum Y value"
+#FModifier|FModifierGenerator.use_additive -> use_additive:   boolean  "Values generated by this modifier are applied on top of the existing values instead of overwriting them"
+#FModifier|FModifierLimits.max_x -> max_x:   float  "Highest X value to allow"
+#FModifier|FModifierLimits.max_y -> max_y:   float  "Highest Y value to allow"
+#FModifier|FModifierLimits.min_x -> min_x:   float  "Lowest X value to allow"
+#FModifier|FModifierLimits.min_y -> min_y:   float  "Lowest Y value to allow"
+#FModifier|FModifierLimits.use_max_x -> use_max_x:   boolean  "Use the maximum X value"
+#FModifier|FModifierLimits.use_max_y -> use_max_y:   boolean  "Use the maximum Y value"
+#FModifier|FModifierLimits.use_min_x -> use_min_x:   boolean  "Use the minimum X value"
+#FModifier|FModifierLimits.use_min_y -> use_min_y:   boolean  "Use the minimum Y value"
 #FModifier|FModifierNoise.blend_type -> blend_type:   enum  "Method of modifying the existing F-Curve"
 #+ * FModifier|FModifierNoise.depth -> depth:   int  "Amount of fine level detail present in the noise"
 #+ * FModifier|FModifierNoise.phase -> phase:   float  "A random seed for the noise effect"
 #FModifier|FModifierNoise.scale -> scale:   float  "Scaling (in time) of the noise"
 #+ * FModifier|FModifierNoise.strength -> strength:   float  "Amplitude of the noise - the amount that it modifies the underlying curve"
 #+ * FModifier|FModifierStepped.frame_end -> frame_end:   float  "Frame that modifiers influence ends (if applicable)"
- + * FModifier|FModifierStepped.offset -> frame_offset:   float  "Reference number of frames before frames get held. Use to get hold for 1-3 vs 5-7 holding patterns"
+#FModifier|FModifierStepped.frame_offset -> frame_offset:   float  "Reference number of frames before frames get held. Use to get hold for 1-3 vs 5-7 holding patterns"
 #+ * FModifier|FModifierStepped.frame_start -> frame_start:   float  "Frame that modifiers influence starts (if applicable)"
- + * FModifier|FModifierStepped.step_size -> frame_step:   float  "Number of frames to hold each value"
+#FModifier|FModifierStepped.frame_step -> frame_step:   float  "Number of frames to hold each value"
 #+ * FModifier|FModifierStepped.use_frame_end -> use_frame_end:   boolean  "Restrict modifier to only act before its end frame"
 #+ * FModifier|FModifierStepped.use_frame_start -> use_frame_start:   boolean  "Restrict modifier to only act after its start frame"
  + * FieldSettings.do_location -> apply_to_location:   boolean  "Effect particles location"
 #+ * GPencilStrokePoint.co -> co:   float[3]  "NO DESCRIPTION"
 #+ * GPencilStrokePoint.pressure -> pressure:   float  "Pressure of tablet at point when drawing it"
 #+ * GameObjectSettings.actuators -> actuators:   collection,  "(read-only)    Game engine actuators to act on events"
- + * GameObjectSettings.collision_bounds -> collision_bounds_type:   enum  "Selects the collision type"
+#GameObjectSettings.collision_bounds_type -> collision_bounds_type:   enum  "Selects the collision type"
 #+ * GameObjectSettings.collision_margin -> collision_margin:   float  "Extra margin around object for collision detection, small amount required for stability"
 #+ * GameObjectSettings.controllers -> controllers:   collection,  "(read-only)    Game engine controllers to process events, connecting sensor to actuators"
 #+ * GameObjectSettings.damping -> damping:   float  "General movement damping"
 #+ * GameObjectSettings.form_factor -> form_factor:   float  "Form factor scales the inertia tensor"
 #+ * GameObjectSettings.friction_coefficients -> friction_coefficients:   float[3]  "Relative friction coefficient in the in the X, Y and Z directions, when anisotropic friction is enabled"
- + * GameObjectSettings.lock_x_axis -> lock_location_x:   boolean  "Disable simulation of linear motion along the X axis"
- + * GameObjectSettings.lock_y_axis -> lock_location_y:   boolean  "Disable simulation of linear motion along the Y axis"
- + * GameObjectSettings.lock_z_axis -> lock_location_z:   boolean  "Disable simulation of linear motion along the Z axis"
- + * GameObjectSettings.lock_x_rot_axis -> lock_rotation_x:   boolean  "Disable simulation of angular  motion along the X axis"
- + * GameObjectSettings.lock_y_rot_axis -> lock_rotation_y:   boolean  "Disable simulation of angular  motion along the Y axis"
- + * GameObjectSettings.lock_z_rot_axis -> lock_rotation_z:   boolean  "Disable simulation of angular  motion along the Z axis"
+#GameObjectSettings.lock_location_x -> lock_location_x:   boolean  "Disable simulation of linear motion along the X axis"
+#GameObjectSettings.lock_location_y -> lock_location_y:   boolean  "Disable simulation of linear motion along the Y axis"
+#GameObjectSettings.lock_location_z -> lock_location_z:   boolean  "Disable simulation of linear motion along the Z axis"
+#GameObjectSettings.lock_rotation_x -> lock_rotation_x:   boolean  "Disable simulation of angular  motion along the X axis"
+#GameObjectSettings.lock_rotation_y -> lock_rotation_y:   boolean  "Disable simulation of angular  motion along the Y axis"
+#GameObjectSettings.lock_rotation_z -> lock_rotation_z:   boolean  "Disable simulation of angular  motion along the Z axis"
 #+ * GameObjectSettings.mass -> mass:   float  "Mass of the object"
 #+ * GameObjectSettings.physics_type -> physics_type:   enum  "Selects the type of physical representation"
 #+ * GameObjectSettings.properties -> properties:   collection,  "(read-only)    Game engine properties"
 #+ * GameObjectSettings.show_sensors -> show_sensors:   boolean  "Shows sensors for this object in the user interface"
 #+ * GameObjectSettings.show_state_panel -> show_state_panel:   boolean  "Show state panel"
 #+ * GameObjectSettings.soft_body -> soft_body:   pointer,  "(read-only)    Settings for Bullet soft body simulation"
- + * GameObjectSettings.initial_state -> states_initial:   boolean[30]  "Initial state when the game starts"
- + * GameObjectSettings.visible_state -> states_visible:   boolean[30]  "State determining which controllers are displayed"
+#GameObjectSettings.states_initial -> states_initial:   boolean[30]  "Initial state when the game starts"
+#GameObjectSettings.states_visible -> states_visible:   boolean[30]  "State determining which controllers are displayed"
 #+ * GameObjectSettings.use_activity_culling -> use_activity_culling:   boolean  "Disable simulation of angular  motion along the Z axis"
 #GameObjectSettings.use_actor -> use_actor:   boolean  "Object is detected by the Near and Radar sensor"
- + * GameObjectSettings.all_states -> use_all_states:   boolean  "Set all state bits"
- + * GameObjectSettings.anisotropic_friction -> use_anisotropic_friction:   boolean  "Enable anisotropic friction"
+#GameObjectSettings.use_all_states -> use_all_states:   boolean  "Set all state bits"
+#GameObjectSettings.use_anisotropic_friction -> use_anisotropic_friction:   boolean  "Enable anisotropic friction"
 #+ * GameObjectSettings.use_collision_bounds -> use_collision_bounds:   boolean  "Specify a collision bounds type other than the default"
- + * GameObjectSettings.collision_compound -> use_collision_compound:   boolean  "Add children to form a compound collision object"
+#GameObjectSettings.use_collision_compound -> use_collision_compound:   boolean  "Add children to form a compound collision object"
 #GameObjectSettings.use_ghost -> use_ghost:   boolean  "Object does not restitute collisions, like a ghost"
- + * GameObjectSettings.material_physics -> use_material_physics:   boolean  "Use physics settings in materials"
- + * GameObjectSettings.rotate_from_normal -> use_rotate_from_normal:   boolean  "Use face normal to rotate object, so that it points away from the surface"
+#GameObjectSettings.use_material_physics -> use_material_physics:   boolean  "Use physics settings in materials"
+#GameObjectSettings.use_rotate_from_normal -> use_rotate_from_normal:   boolean  "Use face normal to rotate object, so that it points away from the surface"
 #GameObjectSettings.use_sleep -> use_sleep:   boolean  "Disable auto (de)activation in physics simulation"
 #GameObjectSettings.used_states -> used_states:   boolean[30],  "(read-only)    States which are being used by controllers"
- + * GameObjectSettings.maximum_velocity -> velocity_max:   float  "Clamp velocity to this maximum speed"
- + * GameObjectSettings.minimum_velocity -> velocity_min:   float  "Clamp velocity to this minimum speed (except when totally still)"
+#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.type -> type:   enum  "NO DESCRIPTION"