diff options
Diffstat (limited to 'source/blender/makesrna/intern/rna_rigidbody.c')
-rw-r--r-- | source/blender/makesrna/intern/rna_rigidbody.c | 1008 |
1 files changed, 1008 insertions, 0 deletions
diff --git a/source/blender/makesrna/intern/rna_rigidbody.c b/source/blender/makesrna/intern/rna_rigidbody.c new file mode 100644 index 00000000000..c1eb3b9b000 --- /dev/null +++ b/source/blender/makesrna/intern/rna_rigidbody.c @@ -0,0 +1,1008 @@ +/* + * ***** BEGIN GPL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + * Contributor(s): Blender Foundation 2013, Joshua Leung, Sergej Reich + * + * ***** END GPL LICENSE BLOCK ***** + */ + +/** \file rna_rigidbody.c + * \ingroup rna + * \brief RNA property definitions for Rigid Body datatypes + */ + +#include <stdlib.h> +#include <string.h> + +#include "RNA_define.h" + +#include "rna_internal.h" + +#include "DNA_group_types.h" +#include "DNA_object_types.h" +#include "DNA_rigidbody_types.h" +#include "DNA_scene_types.h" + +#include "BLI_utildefines.h" +#include "BLI_math.h" + +#include "WM_types.h" + +/* roles of objects in RigidBody Sims */ +EnumPropertyItem rigidbody_ob_type_items[] = { + {RBO_TYPE_ACTIVE, "ACTIVE", 0, "Active", "Object is directly controlled by simulation results"}, + {RBO_TYPE_PASSIVE, "PASSIVE", 0, "Passive", "Object is directly controlled by animation system"}, + {0, NULL, 0, NULL, NULL}}; + +/* collision shapes of objects in rigid body sim */ +EnumPropertyItem rigidbody_ob_shape_items[] = { + {RB_SHAPE_BOX, "BOX", ICON_MESH_CUBE, "Box", "Box-like shapes (i.e. cubes), including planes (i.e. ground planes)"}, + {RB_SHAPE_SPHERE, "SPHERE", ICON_MESH_UVSPHERE, "Sphere", ""}, + {RB_SHAPE_CAPSULE, "CAPSULE", ICON_OUTLINER_OB_META, "Capsule", ""}, + {RB_SHAPE_CYLINDER, "CYLINDER", ICON_MESH_CYLINDER, "Cylinder", ""}, + {RB_SHAPE_CONE, "CONE", ICON_MESH_CONE, "Cone", ""}, + {RB_SHAPE_CONVEXH, "CONVEX_HULL", ICON_MESH_ICOSPHERE, "Convex Hull", "A mesh-like surface encompassing (i.e. shrinkwrap over) all verts. Best results with fewer vertices"}, + {RB_SHAPE_TRIMESH, "MESH", ICON_MESH_MONKEY, "Mesh", "Mesh consisting of triangles only, allowing for more detailed interactions than convex hulls"}, + {0, NULL, 0, NULL, NULL}}; + +/* collision shapes of constraints in rigid body sim */ +EnumPropertyItem rigidbody_con_type_items[] = { + {RBC_TYPE_FIXED, "FIXED", ICON_FORCE_FORCE, "Fixed", "Glues rigid bodies together"}, + {RBC_TYPE_POINT, "POINT", ICON_FORCE_FORCE, "Point", "Constrains rigid bodies to move aound common pivot point"}, + {RBC_TYPE_HINGE, "HINGE", ICON_FORCE_FORCE, "Hinge", "Restricts rigid body rotation to one axis"}, + {RBC_TYPE_SLIDER, "SLIDER", ICON_FORCE_FORCE, "Slider", "Restricts rigid boddy translation to one axis"}, + {RBC_TYPE_PISTON, "PISTON", ICON_FORCE_FORCE, "Piston", "Restricts rigid boddy translation and rotation to one axis"}, + {RBC_TYPE_6DOF, "GENERIC", ICON_FORCE_FORCE, "Generic", "Restricts translation and rotation to specified axes"}, + {RBC_TYPE_6DOF_SPRING, "GENERIC_SPRING", ICON_FORCE_FORCE, "Generic Spring", "Restricts translation and rotation to specified axes with springs"}, + {0, NULL, 0, NULL, NULL}}; + + +#ifdef RNA_RUNTIME + +#ifdef WITH_BULLET +# include "RBI_api.h" +#endif + +#include "BKE_depsgraph.h" +#include "BKE_rigidbody.h" + +#define RB_FLAG_SET(dest, value, flag) { \ + if (value) \ + dest |= flag; \ + else \ + dest &= ~flag; \ +} + + +/* ******************************** */ + +static void rna_RigidBodyWorld_reset(Main *bmain, Scene *scene, PointerRNA *ptr) +{ + RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data; + + BKE_rigidbody_cache_reset(rbw); +} + +static char *rna_RigidBodyWorld_path(PointerRNA *ptr) +{ + return BLI_sprintfN("rigidbody_world"); +} + +static void rna_RigidBodyWorld_num_solver_iterations_set(PointerRNA *ptr, int value) +{ + RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data; + + rbw->num_solver_iterations = value; + +#ifdef WITH_BULLET + if (rbw->physics_world) { + RB_dworld_set_solver_iterations(rbw->physics_world, value); + } +#endif +} + +static void rna_RigidBodyWorld_split_impulse_set(PointerRNA *ptr, int value) +{ + RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data; + + RB_FLAG_SET(rbw->flag, value, RBW_FLAG_USE_SPLIT_IMPULSE); + +#ifdef WITH_BULLET + if (rbw->physics_world) { + RB_dworld_set_split_impulse(rbw->physics_world, value); + } +#endif +} + +/* ******************************** */ + +static void rna_RigidBodyOb_reset(Main *bmain, Scene *scene, PointerRNA *ptr) +{ + RigidBodyWorld *rbw = scene->rigidbody_world; + + BKE_rigidbody_cache_reset(rbw); +} + +static void rna_RigidBodyOb_shape_reset(Main *bmain, Scene *scene, PointerRNA *ptr) +{ + RigidBodyWorld *rbw = scene->rigidbody_world; + RigidBodyOb *rbo = (RigidBodyOb *)ptr->data; + + BKE_rigidbody_cache_reset(rbw); + if (rbo->physics_shape) + rbo->flag |= RBO_FLAG_NEEDS_RESHAPE; +} + +static char *rna_RigidBodyOb_path(PointerRNA *ptr) +{ + /* NOTE: this hardcoded path should work as long as only Objects have this */ + return BLI_sprintfN("rigid_body"); +} + +static void rna_RigidBodyOb_type_set(PointerRNA *ptr, int value) +{ + RigidBodyOb *rbo = (RigidBodyOb *)ptr->data; + + rbo->type = value; + rbo->flag |= RBO_FLAG_NEEDS_VALIDATE; + +#ifdef WITH_BULLET + /* do physics sim updates */ + if (rbo->physics_object) { + RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo)); + } +#endif +} + +static void rna_RigidBodyOb_disabled_set(PointerRNA *ptr, int value) +{ + RigidBodyOb *rbo = (RigidBodyOb *)ptr->data; + + RB_FLAG_SET(rbo->flag, !value, RBO_FLAG_DISABLED); + +#ifdef WITH_BULLET + /* update kinematic state if necessary - only needed for active bodies */ + if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) { + RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo)); + RB_body_set_kinematic_state(rbo->physics_object, !value); + rbo->flag |= RBO_FLAG_NEEDS_VALIDATE; + } +#endif +} + +static void rna_RigidBodyOb_shape_set(PointerRNA *ptr, int value) +{ + RigidBodyOb *rbo = (RigidBodyOb *)ptr->data; + Object *ob = (Object *)ptr->id.data; + + rbo->shape = value; + + /* force creation of new collision shape reflecting this */ + BKE_rigidbody_validate_sim_shape(ob, TRUE); + +#ifdef WITH_BULLET + /* now tell RB sim about it */ + if (rbo->physics_object && rbo->physics_shape) { + RB_body_set_collision_shape(rbo->physics_object, rbo->physics_shape); + } +#endif +} + + +static void rna_RigidBodyOb_mass_set(PointerRNA *ptr, float value) +{ + RigidBodyOb *rbo = (RigidBodyOb *)ptr->data; + + rbo->mass = value; + +#ifdef WITH_BULLET + /* only active bodies need mass update */ + if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) { + RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo)); + } +#endif +} + +static void rna_RigidBodyOb_friction_set(PointerRNA *ptr, float value) +{ + RigidBodyOb *rbo = (RigidBodyOb *)ptr->data; + + rbo->friction = value; + +#ifdef WITH_BULLET + if (rbo->physics_object) { + RB_body_set_friction(rbo->physics_object, value); + } +#endif +} + +static void rna_RigidBodyOb_restitution_set(PointerRNA *ptr, float value) +{ + RigidBodyOb *rbo = (RigidBodyOb *)ptr->data; + + rbo->restitution = value; +#ifdef WITH_BULLET + if (rbo->physics_object) { + RB_body_set_restitution(rbo->physics_object, value); + } +#endif +} + +static void rna_RigidBodyOb_collision_margin_set(PointerRNA *ptr, float value) +{ + RigidBodyOb *rbo = (RigidBodyOb *)ptr->data; + + rbo->margin = value; + +#ifdef WITH_BULLET + if (rbo->physics_shape) { + RB_shape_set_margin(rbo->physics_shape, RBO_GET_MARGIN(rbo)); + } +#endif +} + +static void rna_RigidBodyOb_kinematic_state_set(PointerRNA *ptr, int value) +{ + RigidBodyOb *rbo = (RigidBodyOb *)ptr->data; + + RB_FLAG_SET(rbo->flag, value, RBO_FLAG_KINEMATIC); + +#ifdef WITH_BULLET + /* update kinematic state if necessary */ + if (rbo->physics_object) { + RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo)); + RB_body_set_kinematic_state(rbo->physics_object, value); + rbo->flag |= RBO_FLAG_NEEDS_VALIDATE; + } +#endif +} + +static void rna_RigidBodyOb_activation_state_set(PointerRNA *ptr, int value) +{ + RigidBodyOb *rbo = (RigidBodyOb *)ptr->data; + + RB_FLAG_SET(rbo->flag, value, RBO_FLAG_USE_DEACTIVATION); + +#ifdef WITH_BULLET + /* update activation state if necessary - only active bodies can be deactivated */ + if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) { + RB_body_set_activation_state(rbo->physics_object, value); + } +#endif +} + +static void rna_RigidBodyOb_linear_sleepThresh_set(PointerRNA *ptr, float value) +{ + RigidBodyOb *rbo = (RigidBodyOb *)ptr->data; + + rbo->lin_sleep_thresh = value; + +#ifdef WITH_BULLET + /* only active bodies need sleep threshold update */ + if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) { + RB_body_set_linear_sleep_thresh(rbo->physics_object, value); + } +#endif +} + +static void rna_RigidBodyOb_angular_sleepThresh_set(PointerRNA *ptr, float value) +{ + RigidBodyOb *rbo = (RigidBodyOb *)ptr->data; + + rbo->ang_sleep_thresh = value; + +#ifdef WITH_BULLET + /* only active bodies need sleep threshold update */ + if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) { + RB_body_set_angular_sleep_thresh(rbo->physics_object, value); + } +#endif +} + +static void rna_RigidBodyOb_linear_damping_set(PointerRNA *ptr, float value) +{ + RigidBodyOb *rbo = (RigidBodyOb *)ptr->data; + + rbo->lin_damping = value; + +#ifdef WITH_BULLET + /* only active bodies need damping update */ + if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) { + RB_body_set_linear_damping(rbo->physics_object, value); + } +#endif +} + +static void rna_RigidBodyOb_angular_damping_set(PointerRNA *ptr, float value) +{ + RigidBodyOb *rbo = (RigidBodyOb *)ptr->data; + + rbo->ang_damping = value; + +#ifdef WITH_BULLET + /* only active bodies need damping update */ + if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) { + RB_body_set_angular_damping(rbo->physics_object, value); + } +#endif +} + +static char *rna_RigidBodyCon_path(PointerRNA *ptr) +{ + /* NOTE: this hardcoded path should work as long as only Objects have this */ + return BLI_sprintfN("rigid_body_constraint"); +} + +static void rna_RigidBodyCon_type_set(PointerRNA *ptr, int value) +{ + RigidBodyCon *rbc = (RigidBodyCon *)ptr->data; + + rbc->type = value; + rbc->flag |= RBC_FLAG_NEEDS_VALIDATE; +} + +static void rna_RigidBodyCon_enabled_set(PointerRNA *ptr, int value) +{ + RigidBodyCon *rbc = (RigidBodyCon *)ptr->data; + + RB_FLAG_SET(rbc->flag, value, RBC_FLAG_ENABLED); + +#ifdef WITH_BULLET + if (rbc->physics_constraint) { + RB_constraint_set_enabled(rbc->physics_constraint, value); + } +#endif +} + +static void rna_RigidBodyCon_disable_collisions_set(PointerRNA *ptr, int value) +{ + RigidBodyCon *rbc = (RigidBodyCon *)ptr->data; + + RB_FLAG_SET(rbc->flag, value, RBC_FLAG_DISABLE_COLLISIONS); + + rbc->flag |= RBC_FLAG_NEEDS_VALIDATE; +} + +static void rna_RigidBodyCon_use_breaking_set(PointerRNA *ptr, int value) +{ + RigidBodyCon *rbc = (RigidBodyCon *)ptr->data; + + if (value) { + rbc->flag |= RBC_FLAG_USE_BREAKING; +#ifdef WITH_BULLET + if (rbc->physics_constraint) { + RB_constraint_set_breaking_threshold(rbc->physics_constraint, rbc->breaking_threshold); + } +#endif + } + else { + rbc->flag &= ~RBC_FLAG_USE_BREAKING; +#ifdef WITH_BULLET + if (rbc->physics_constraint) { + RB_constraint_set_breaking_threshold(rbc->physics_constraint, FLT_MAX); + } +#endif + } +} + +static void rna_RigidBodyCon_breaking_threshold_set(PointerRNA *ptr, float value) +{ + RigidBodyCon *rbc = (RigidBodyCon *)ptr->data; + + rbc->breaking_threshold = value; + +#ifdef WITH_BULLET + if (rbc->physics_constraint && (rbc->flag & RBC_FLAG_USE_BREAKING)) { + RB_constraint_set_breaking_threshold(rbc->physics_constraint, value); + } +#endif +} + +static void rna_RigidBodyCon_override_solver_iterations_set(PointerRNA *ptr, int value) +{ + RigidBodyCon *rbc = (RigidBodyCon *)ptr->data; + + if (value) { + rbc->flag |= RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS; +#ifdef WITH_BULLET + if (rbc->physics_constraint) { + RB_constraint_set_solver_iterations(rbc->physics_constraint, rbc->num_solver_iterations); + } +#endif + } + else { + rbc->flag &= ~RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS; +#ifdef WITH_BULLET + if (rbc->physics_constraint) { + RB_constraint_set_solver_iterations(rbc->physics_constraint, -1); + } +#endif + } +} + +static void rna_RigidBodyCon_num_solver_iterations_set(PointerRNA *ptr, int value) +{ + RigidBodyCon *rbc = (RigidBodyCon *)ptr->data; + + rbc->num_solver_iterations = value; + +#ifdef WITH_BULLET + if (rbc->physics_constraint && (rbc->flag & RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS)) { + RB_constraint_set_solver_iterations(rbc->physics_constraint, value); + } +#endif +} + +static void rna_RigidBodyCon_spring_stiffness_x_set(PointerRNA *ptr, float value) +{ + RigidBodyCon *rbc = (RigidBodyCon *)ptr->data; + + rbc->spring_stiffness_x = value; + +#ifdef WITH_BULLET + if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_X)) { + RB_constraint_set_stiffness_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_X, value); + } +#endif +} + +static void rna_RigidBodyCon_spring_stiffness_y_set(PointerRNA *ptr, float value) +{ + RigidBodyCon *rbc = (RigidBodyCon *)ptr->data; + + rbc->spring_stiffness_y = value; + +#ifdef WITH_BULLET + if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_Y)) { + RB_constraint_set_stiffness_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_Y, value); + } +#endif +} + +static void rna_RigidBodyCon_spring_stiffness_z_set(PointerRNA *ptr, float value) +{ + RigidBodyCon *rbc = (RigidBodyCon *)ptr->data; + + rbc->spring_stiffness_z = value; + +#ifdef WITH_BULLET + if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_Z)) { + RB_constraint_set_stiffness_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_Z, value); + } +#endif +} + +static void rna_RigidBodyCon_spring_damping_x_set(PointerRNA *ptr, float value) +{ + RigidBodyCon *rbc = (RigidBodyCon *)ptr->data; + + rbc->spring_damping_x = value; + +#ifdef WITH_BULLET + if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_X)) { + RB_constraint_set_damping_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_X, value); + } +#endif +} + +static void rna_RigidBodyCon_spring_damping_y_set(PointerRNA *ptr, float value) +{ + RigidBodyCon *rbc = (RigidBodyCon *)ptr->data; + + rbc->spring_damping_y = value; +#ifdef WITH_BULLET + if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_Y)) { + RB_constraint_set_damping_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_Y, value); + } +#endif +} + +static void rna_RigidBodyCon_spring_damping_z_set(PointerRNA *ptr, float value) +{ + RigidBodyCon *rbc = (RigidBodyCon *)ptr->data; + + rbc->spring_damping_z = value; +#ifdef WITH_BULLET + if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_Z)) { + RB_constraint_set_damping_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_Z, value); + } +#endif +} + +#else + +static void rna_def_rigidbody_world(BlenderRNA *brna) +{ + StructRNA *srna; + PropertyRNA *prop; + + srna = RNA_def_struct(brna, "RigidBodyWorld", NULL); + RNA_def_struct_sdna(srna, "RigidBodyWorld"); + RNA_def_struct_ui_text(srna, "Rigid Body World", "Self-contained rigid body simulation environment and settings"); + RNA_def_struct_path_func(srna, "rna_RigidBodyWorld_path"); + + /* groups */ + prop = RNA_def_property(srna, "group", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(prop, "Group"); + RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK); + RNA_def_property_ui_text(prop, "Group", "Group containing objects participating in this simulation"); + RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset"); + + prop = RNA_def_property(srna, "constraints", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(prop, "Group"); + RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK); + RNA_def_property_ui_text(prop, "Constraints", "Group containing rigid body constraint objects"); + RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset"); + + /* booleans */ + prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", RBW_FLAG_MUTED); + RNA_def_property_ui_text(prop, "Enabled", "Simulation will be evaluated"); + RNA_def_property_update(prop, NC_SCENE, NULL); + + /* time scale */ + prop = RNA_def_property(srna, "time_scale", PROP_FLOAT, PROP_NONE); + RNA_def_property_float_sdna(prop, NULL, "time_scale"); + RNA_def_property_range(prop, 0.0f, 100.0f); + RNA_def_property_ui_range(prop, 0.0f, 10.0f, 1, 3); + RNA_def_property_float_default(prop, 1.0f); + RNA_def_property_ui_text(prop, "Time Scale", "Changes the speed of the simulation"); + RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset"); + + /* timestep */ + prop = RNA_def_property(srna, "steps_per_second", PROP_INT, PROP_NONE); + RNA_def_property_int_sdna(prop, NULL, "steps_per_second"); + RNA_def_property_range(prop, 1, SHRT_MAX); + RNA_def_property_ui_range(prop, 60, 1000, 1, 0); + RNA_def_property_int_default(prop, 60); + RNA_def_property_ui_text(prop, "Steps Per Second", "Number of simulation steps taken per second (higher values are more accurate but slower)"); + RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset"); + + /* constraint solver iterations */ + prop = RNA_def_property(srna, "num_solver_iterations", PROP_INT, PROP_NONE); + RNA_def_property_int_sdna(prop, NULL, "num_solver_iterations"); + RNA_def_property_range(prop, 1, 1000); + RNA_def_property_ui_range(prop, 10, 100, 1, 0); + RNA_def_property_int_default(prop, 10); + RNA_def_property_int_funcs(prop, NULL, "rna_RigidBodyWorld_num_solver_iterations_set", NULL); + RNA_def_property_ui_text(prop, "Solver Iterations", "Number of constraint solver iterations made per simulation step (higher values are more accurate but slower)"); + RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset"); + + /* split impulse */ + prop = RNA_def_property(srna, "use_split_impulse", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBW_FLAG_USE_SPLIT_IMPULSE); + RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyWorld_split_impulse_set"); + RNA_def_property_ui_text(prop, "Split Impulse", "Reduces extra velocity that can build up when objects collide (lowers simulation stabilty a litte so use only when necessary)"); + RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset"); + + /* cache */ + prop = RNA_def_property(srna, "point_cache", PROP_POINTER, PROP_NONE); + RNA_def_property_flag(prop, PROP_NEVER_NULL); + RNA_def_property_pointer_sdna(prop, NULL, "pointcache"); + RNA_def_property_ui_text(prop, "Point Cache", ""); + + /* effector weights */ + prop = RNA_def_property(srna, "effector_weights", PROP_POINTER, PROP_NONE); + RNA_def_property_struct_type(prop, "EffectorWeights"); + RNA_def_property_clear_flag(prop, PROP_EDITABLE); + RNA_def_property_ui_text(prop, "Effector Weights", ""); +} + +static void rna_def_rigidbody_object(BlenderRNA *brna) +{ + StructRNA *srna; + PropertyRNA *prop; + + + srna = RNA_def_struct(brna, "RigidBodyObject", NULL); + RNA_def_struct_sdna(srna, "RigidBodyOb"); + RNA_def_struct_ui_text(srna, "Rigid Body Object", "Settings for object participating in Rigid Body Simulation"); + RNA_def_struct_path_func(srna, "rna_RigidBodyOb_path"); + + /* Enums */ + prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "type"); + RNA_def_property_enum_items(prop, rigidbody_ob_type_items); + RNA_def_property_enum_funcs(prop, NULL, "rna_RigidBodyOb_type_set", NULL); + RNA_def_property_ui_text(prop, "Type", "Role of object in Rigid Body Simulations"); + RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + /* booleans */ + prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", RBO_FLAG_DISABLED); + RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_disabled_set"); + RNA_def_property_ui_text(prop, "Enabled", "Rigid Body actively participated in the simulation"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "collision_shape", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "shape"); + RNA_def_property_enum_items(prop, rigidbody_ob_shape_items); + RNA_def_property_enum_funcs(prop, NULL, "rna_RigidBodyOb_shape_set", NULL); + RNA_def_property_ui_text(prop, "Collision Shape", "Collision Shape of object in Rigid Body Simulations"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "kinematic", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_KINEMATIC); + RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_kinematic_state_set"); + RNA_def_property_ui_text(prop, "Kinematic", "Allows rigid body to be controlled by the animation system"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + /* Physics Parameters */ + prop = RNA_def_property(srna, "mass", PROP_FLOAT, PROP_UNIT_MASS); + RNA_def_property_float_sdna(prop, NULL, "mass"); + RNA_def_property_range(prop, 0.001f, FLT_MAX); // range must always be positive (and non-zero) + RNA_def_property_float_default(prop, 1.0f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_mass_set", NULL); + RNA_def_property_ui_text(prop, "Mass", "How much the object 'weighs' irrespective of gravity"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + /* Dynamics Parameters - Activation */ + // TODO: define and figure out how to implement these + + /* Dynamics Parameters - Deactivation */ + prop = RNA_def_property(srna, "use_deactivation", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_USE_DEACTIVATION); + RNA_def_property_boolean_default(prop, TRUE); + RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_activation_state_set"); + RNA_def_property_ui_text(prop, "Enable Deactivation", "Enables deactivation of resting rigid bodies (increases performance and stability but can cause glitches)"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "start_deactivated", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_START_DEACTIVATED); + RNA_def_property_ui_text(prop, "Start Deactivated", "Deactivates rigid body at the start of the simulation"); + RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "deactivate_linear_velocity", PROP_FLOAT, PROP_UNIT_VELOCITY); + RNA_def_property_float_sdna(prop, NULL, "lin_sleep_thresh"); + RNA_def_property_range(prop, FLT_MIN, FLT_MAX); // range must always be positive (and non-zero) + RNA_def_property_float_default(prop, 0.4f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_linear_sleepThresh_set", NULL); + RNA_def_property_ui_text(prop, "Linear Velocity Deactivation Threshold", "Linear Velocity below which simulation stops simulating object"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "deactivate_angular_velocity", PROP_FLOAT, PROP_UNIT_VELOCITY); + RNA_def_property_float_sdna(prop, NULL, "ang_sleep_thresh"); + RNA_def_property_range(prop, FLT_MIN, FLT_MAX); // range must always be positive (and non-zero) + RNA_def_property_float_default(prop, 0.5f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_angular_sleepThresh_set", NULL); + RNA_def_property_ui_text(prop, "Angular Velocity Deactivation Threshold", "Angular Velocity below which simulation stops simulating object"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + /* Dynamics Parameters - Damping Parameters */ + prop = RNA_def_property(srna, "linear_damping", PROP_FLOAT, PROP_FACTOR); + RNA_def_property_float_sdna(prop, NULL, "lin_damping"); + RNA_def_property_range(prop, 0.0f, 1.0f); + RNA_def_property_float_default(prop, 0.04f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_linear_damping_set", NULL); + RNA_def_property_ui_text(prop, "Linear Damping", "Amount of linear velocity that is lost over time"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "angular_damping", PROP_FLOAT, PROP_FACTOR); + RNA_def_property_float_sdna(prop, NULL, "ang_damping"); + RNA_def_property_range(prop, 0.0f, 1.0f); + RNA_def_property_float_default(prop, 0.1f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_angular_damping_set", NULL); + RNA_def_property_ui_text(prop, "Angular Damping", "Amount of angular velocity that is lost over time"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + /* Collision Parameters - Surface Parameters */ + prop = RNA_def_property(srna, "friction", PROP_FLOAT, PROP_FACTOR); + RNA_def_property_float_sdna(prop, NULL, "friction"); + RNA_def_property_range(prop, 0.0f, FLT_MAX); + RNA_def_property_ui_range(prop, 0.0f, 1.0f, 1, 3); + RNA_def_property_float_default(prop, 0.5f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_friction_set", NULL); + RNA_def_property_ui_text(prop, "Friction", "Resistance of object to movement"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "restitution", PROP_FLOAT, PROP_FACTOR); + RNA_def_property_float_sdna(prop, NULL, "restitution"); + RNA_def_property_range(prop, 0.0f, FLT_MAX); + RNA_def_property_ui_range(prop, 0.0f, 1.0f, 1, 3); + RNA_def_property_float_default(prop, 0.0f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_restitution_set", NULL); + RNA_def_property_ui_text(prop, "Restitution", "Tendency of object to bounce after colliding with another (0 = stays still, 1 = perfectly elastic)"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + /* Collision Parameters - Sensitivity */ + prop = RNA_def_property(srna, "use_margin", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_USE_MARGIN); + RNA_def_property_boolean_default(prop, FALSE); + RNA_def_property_ui_text(prop, "Collision Margin", "Use custom collision margin (some shapes will have a visible gap around them)"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_shape_reset"); + + prop = RNA_def_property(srna, "collision_margin", PROP_FLOAT, PROP_UNIT_LENGTH); + RNA_def_property_float_sdna(prop, NULL, "margin"); + RNA_def_property_range(prop, 0.0f, 1.0f); + RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.01, 3); + RNA_def_property_float_default(prop, 0.04f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_collision_margin_set", NULL); + RNA_def_property_ui_text(prop, "Collision Margin", "Threshold of distance near surface where collisions are still considered (best results when non-zero)"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_shape_reset"); + + prop = RNA_def_property(srna, "collision_groups", PROP_BOOLEAN, PROP_LAYER_MEMBER); + RNA_def_property_boolean_sdna(prop, NULL, "col_groups", 1); + RNA_def_property_array(prop, 20); + RNA_def_property_ui_text(prop, "Collison Groups", "Collision Groups Rigid Body belongs to"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + RNA_def_property_flag(prop, PROP_LIB_EXCEPTION); +} + +static void rna_def_rigidbody_constraint(BlenderRNA *brna) +{ + StructRNA *srna; + PropertyRNA *prop; + + srna = RNA_def_struct(brna, "RigidBodyConstraint", NULL); + RNA_def_struct_sdna(srna, "RigidBodyCon"); + RNA_def_struct_ui_text(srna, "Rigid Body Constraint", "Constraint influencing Objects inside Rigid Body Simulation"); + RNA_def_struct_path_func(srna, "rna_RigidBodyCon_path"); + + /* Enums */ + prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE); + RNA_def_property_enum_sdna(prop, NULL, "type"); + RNA_def_property_enum_items(prop, rigidbody_con_type_items); + RNA_def_property_enum_funcs(prop, NULL, "rna_RigidBodyCon_type_set", NULL); + RNA_def_property_ui_text(prop, "Type", "Type of Rigid Body Constraint"); + RNA_def_property_clear_flag(prop, PROP_ANIMATABLE); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_ENABLED); + RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_enabled_set"); + RNA_def_property_ui_text(prop, "Enabled", "Enable this constraint"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "disable_collisions", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_DISABLE_COLLISIONS); + RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_disable_collisions_set"); + RNA_def_property_ui_text(prop, "Disable Collisions", "Disables collisions between constrained ridid bodies"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "object1", PROP_POINTER, PROP_NONE); + RNA_def_property_pointer_sdna(prop, NULL, "ob1"); + RNA_def_property_flag(prop, PROP_EDITABLE); + RNA_def_property_ui_text(prop, "Object 1", "First Rigid Body Object to be constrained"); + RNA_def_property_flag(prop, PROP_EDITABLE); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "object2", PROP_POINTER, PROP_NONE); + RNA_def_property_pointer_sdna(prop, NULL, "ob2"); + RNA_def_property_flag(prop, PROP_EDITABLE); + RNA_def_property_ui_text(prop, "Object 2", "Second Rigid Body Object to be constrained"); + RNA_def_property_flag(prop, PROP_EDITABLE); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + /* Breaking Threshold */ + prop = RNA_def_property(srna, "use_breaking", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_BREAKING); + RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_use_breaking_set"); + RNA_def_property_ui_text(prop, "Breakable", "Constraint can be broaken if it receives an impulse above the threshold"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "breaking_threshold", PROP_FLOAT, PROP_NONE); + RNA_def_property_float_sdna(prop, NULL, "breaking_threshold"); + RNA_def_property_range(prop, 0.0f, FLT_MAX); + RNA_def_property_ui_range(prop, 0.0f, 1000.0f, 100.0, 2); + RNA_def_property_float_default(prop, 10.0f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_breaking_threshold_set", NULL); + RNA_def_property_ui_text(prop, "Breaking Threshold", "Impulse threshold that must be reached for the constraint to break"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + /* Solver Iterations */ + prop = RNA_def_property(srna, "override_solver_iterations", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS); + RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_override_solver_iterations_set"); + RNA_def_property_ui_text(prop, "Override Solver Iterations", "Overrides the number of solver iterations for this constraint"); + RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "num_solver_iterations", PROP_INT, PROP_NONE); + RNA_def_property_int_sdna(prop, NULL, "num_solver_iterations"); + RNA_def_property_range(prop, 1, 1000); + RNA_def_property_ui_range(prop, 1, 100, 1, 0); + RNA_def_property_int_default(prop, 10); + RNA_def_property_int_funcs(prop, NULL, "rna_RigidBodyCon_num_solver_iterations_set", NULL); + RNA_def_property_ui_text(prop, "Solver Iterations", "Number of constraint solver iterations made per simulation step (higher values are more accurate but slower)"); + RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset"); + + /* Limits */ + prop = RNA_def_property(srna, "use_limit_lin_x", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_LIN_X); + RNA_def_property_ui_text(prop, "X Axis", "Limits translation on x axis"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "use_limit_lin_y", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_LIN_Y); + RNA_def_property_ui_text(prop, "Y Axis", "Limits translation on y axis"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "use_limit_lin_z", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_LIN_Z); + RNA_def_property_ui_text(prop, "Z Axis", "Limits translation on z axis"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "use_limit_ang_x", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_ANG_X); + RNA_def_property_ui_text(prop, "X Angle", "Limits rotation around x axis"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "use_limit_ang_y", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_ANG_Y); + RNA_def_property_ui_text(prop, "Y Angle", "Limits rotation around y axis"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "use_limit_ang_z", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_ANG_Z); + RNA_def_property_ui_text(prop, "Z Angle", "Limits rotation around z axis"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "use_spring_x", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_SPRING_X); + RNA_def_property_ui_text(prop, "X Spring", "Enables spring on X axis"); + RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "use_spring_y", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_SPRING_Y); + RNA_def_property_ui_text(prop, "Y Spring", "Enables spring on Y axis"); + RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "use_spring_z", PROP_BOOLEAN, PROP_NONE); + RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_SPRING_Z); + RNA_def_property_ui_text(prop, "Z Spring", "Enables spring on Z axis"); + RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "limit_lin_x_lower", PROP_FLOAT, PROP_UNIT_LENGTH); + RNA_def_property_float_sdna(prop, NULL, "limit_lin_x_lower"); + RNA_def_property_float_default(prop, -1.0f); + RNA_def_property_ui_text(prop, "Lower X Limit", "Lower limit of x axis translation"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "limit_lin_x_upper", PROP_FLOAT, PROP_UNIT_LENGTH); + RNA_def_property_float_sdna(prop, NULL, "limit_lin_x_upper"); + RNA_def_property_float_default(prop, 1.0f); + RNA_def_property_ui_text(prop, "Upper X Limit", "Upper limit of x axis translation"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "limit_lin_y_lower", PROP_FLOAT, PROP_UNIT_LENGTH); + RNA_def_property_float_sdna(prop, NULL, "limit_lin_y_lower"); + RNA_def_property_float_default(prop, -1.0f); + RNA_def_property_ui_text(prop, "Lower Y Limit", "Lower limit of y axis translation"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "limit_lin_y_upper", PROP_FLOAT, PROP_UNIT_LENGTH); + RNA_def_property_float_sdna(prop, NULL, "limit_lin_y_upper"); + RNA_def_property_float_default(prop, 1.0f); + RNA_def_property_ui_text(prop, "Upper Y Limit", "Upper limit of y axis translation"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "limit_lin_z_lower", PROP_FLOAT, PROP_UNIT_LENGTH); + RNA_def_property_float_sdna(prop, NULL, "limit_lin_z_lower"); + RNA_def_property_float_default(prop, -1.0f); + RNA_def_property_ui_text(prop, "Lower Z Limit", "Lower limit of z axis translation"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "limit_lin_z_upper", PROP_FLOAT, PROP_UNIT_LENGTH); + RNA_def_property_float_sdna(prop, NULL, "limit_lin_z_upper"); + RNA_def_property_float_default(prop, 1.0f); + RNA_def_property_ui_text(prop, "Upper Z Limit", "Upper limit of z axis translation"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "limit_ang_x_lower", PROP_FLOAT, PROP_ANGLE); + RNA_def_property_float_sdna(prop, NULL, "limit_ang_x_lower"); + RNA_def_property_range(prop, -M_PI * 2, M_PI * 2); + RNA_def_property_float_default(prop, -M_PI_4); + RNA_def_property_ui_text(prop, "Lower X Angle Limit", "Lower limit of x axis rotation"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "limit_ang_x_upper", PROP_FLOAT, PROP_ANGLE); + RNA_def_property_float_sdna(prop, NULL, "limit_ang_x_upper"); + RNA_def_property_range(prop, -M_PI * 2, M_PI * 2); + RNA_def_property_float_default(prop, M_PI_4); + RNA_def_property_ui_text(prop, "Upper X Angle Limit", "Upper limit of x axis rotation"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "limit_ang_y_lower", PROP_FLOAT, PROP_ANGLE); + RNA_def_property_float_sdna(prop, NULL, "limit_ang_y_lower"); + RNA_def_property_range(prop, -M_PI * 2, M_PI * 2); + RNA_def_property_float_default(prop, -M_PI_4); + RNA_def_property_ui_text(prop, "Lower Y Angle Limit", "Lower limit of y axis rotation"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "limit_ang_y_upper", PROP_FLOAT, PROP_ANGLE); + RNA_def_property_float_sdna(prop, NULL, "limit_ang_y_upper"); + RNA_def_property_range(prop, -M_PI * 2, M_PI * 2); + RNA_def_property_float_default(prop, M_PI_4); + RNA_def_property_ui_text(prop, "Upper Y Angle Limit", "Upper limit of y axis rotation"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "limit_ang_z_lower", PROP_FLOAT, PROP_ANGLE); + RNA_def_property_float_sdna(prop, NULL, "limit_ang_z_lower"); + RNA_def_property_range(prop, -M_PI * 2, M_PI * 2); + RNA_def_property_float_default(prop, -M_PI_4); + RNA_def_property_ui_text(prop, "Lower Z Angle Limit", "Lower limit of z axis rotation"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "limit_ang_z_upper", PROP_FLOAT, PROP_ANGLE); + RNA_def_property_float_sdna(prop, NULL, "limit_ang_z_upper"); + RNA_def_property_range(prop, -M_PI * 2, M_PI * 2); + RNA_def_property_float_default(prop, M_PI_4); + RNA_def_property_ui_text(prop, "Upper Z Angle Limit", "Upper limit of z axis rotation"); + RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "spring_stiffness_x", PROP_FLOAT, PROP_UNIT_LENGTH); + RNA_def_property_float_sdna(prop, NULL, "spring_stiffness_x"); + RNA_def_property_range(prop, 0.0f, FLT_MAX); + RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3); + RNA_def_property_float_default(prop, 10.0f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_stiffness_x_set", NULL); + RNA_def_property_ui_text(prop, "X Axis Stiffness", "Stiffness on the X axis"); + RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "spring_stiffness_y", PROP_FLOAT, PROP_UNIT_LENGTH); + RNA_def_property_float_sdna(prop, NULL, "spring_stiffness_y"); + RNA_def_property_range(prop, 0.0f, FLT_MAX); + RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3); + RNA_def_property_float_default(prop, 10.0f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_stiffness_y_set", NULL); + RNA_def_property_ui_text(prop, "Y Axis Stiffness", "Stiffness on the Y axis"); + RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "spring_stiffness_z", PROP_FLOAT, PROP_UNIT_LENGTH); + RNA_def_property_float_sdna(prop, NULL, "spring_stiffness_z"); + RNA_def_property_range(prop, 0.0f, FLT_MAX); + RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3); + RNA_def_property_float_default(prop, 10.0f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_stiffness_z_set", NULL); + RNA_def_property_ui_text(prop, "Z Axis Stiffness", "Stiffness on the Z axis"); + RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "spring_damping_x", PROP_FLOAT, PROP_FACTOR); + RNA_def_property_float_sdna(prop, NULL, "spring_damping_x"); + RNA_def_property_range(prop, 0.0f, 1.0f); + RNA_def_property_float_default(prop, 0.5f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_damping_x_set", NULL); + RNA_def_property_ui_text(prop, "Damping X", "Damping on the X axis"); + RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "spring_damping_y", PROP_FLOAT, PROP_FACTOR); + RNA_def_property_float_sdna(prop, NULL, "spring_damping_y"); + RNA_def_property_range(prop, 0.0f, 1.0f); + RNA_def_property_float_default(prop, 0.5f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_damping_y_set", NULL); + RNA_def_property_ui_text(prop, "Damping Y", "Damping on the Y axis"); + RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset"); + + prop = RNA_def_property(srna, "spring_damping_z", PROP_FLOAT, PROP_FACTOR); + RNA_def_property_float_sdna(prop, NULL, "spring_damping_z"); + RNA_def_property_range(prop, 0.0f, 1.0f); + RNA_def_property_float_default(prop, 0.5f); + RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_damping_z_set", NULL); + RNA_def_property_ui_text(prop, "Damping Z", "Damping on the Z axis"); + RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset"); +} + +void RNA_def_rigidbody(BlenderRNA *brna) +{ + rna_def_rigidbody_world(brna); + rna_def_rigidbody_object(brna); + rna_def_rigidbody_constraint(brna); +} + + +#endif |