source/blender/makesrna/intern/rna_rigidbody.c

   1 /*
   2  * ***** BEGIN GPL LICENSE BLOCK *****
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  *
  18  * Contributor(s): Blender Foundation 2013, Joshua Leung, Sergej Reich
  19  *
  20  * ***** END GPL LICENSE BLOCK *****
  21  */
  22
  23 /** \file rna_rigidbody.c
  24  *  \ingroup rna
  25  *  \brief RNA property definitions for Rigid Body datatypes
  26  */
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30
  31 #include "RNA_define.h"
  32
  33 #include "rna_internal.h"
  34
  35 #include "DNA_group_types.h"
  36 #include "DNA_object_types.h"
  37 #include "DNA_rigidbody_types.h"
  38 #include "DNA_scene_types.h"
  39
  40 #include "BLI_utildefines.h"
  41 #include "BLI_math.h"
  42
  43 #include "WM_types.h"
  44
  45 /* roles of objects in RigidBody Sims */
  46 EnumPropertyItem rigidbody_ob_type_items[] = {
  47         {RBO_TYPE_ACTIVE, "ACTIVE", 0, "Active", "Object is directly controlled by simulation results"},
  48         {RBO_TYPE_PASSIVE, "PASSIVE", 0, "Passive", "Object is directly controlled by animation system"},
  49         {0, NULL, 0, NULL, NULL}};
  50
  51 /* collision shapes of objects in rigid body sim */
  52 EnumPropertyItem rigidbody_ob_shape_items[] = {
  53         {RB_SHAPE_BOX, "BOX", ICON_MESH_CUBE, "Box", "Box-like shapes (i.e. cubes), including planes (i.e. ground planes)"},
  54         {RB_SHAPE_SPHERE, "SPHERE", ICON_MESH_UVSPHERE, "Sphere", ""},
  55         {RB_SHAPE_CAPSULE, "CAPSULE", ICON_OUTLINER_OB_META, "Capsule", ""},
  56         {RB_SHAPE_CYLINDER, "CYLINDER", ICON_MESH_CYLINDER, "Cylinder", ""},
  57         {RB_SHAPE_CONE, "CONE", ICON_MESH_CONE, "Cone", ""},
  58         {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"},
  59         {RB_SHAPE_TRIMESH, "MESH", ICON_MESH_MONKEY, "Mesh", "Mesh consisting of triangles only, allowing for more detailed interactions than convex hulls"},
  60         {0, NULL, 0, NULL, NULL}};
  61
  62 /* collision shapes of constraints in rigid body sim */
  63 EnumPropertyItem rigidbody_con_type_items[] = {
  64         {RBC_TYPE_FIXED, "FIXED", ICON_FORCE_FORCE, "Fixed", "Glues rigid bodies together"},
  65         {RBC_TYPE_POINT, "POINT", ICON_FORCE_FORCE, "Point", "Constrains rigid bodies to move aound common pivot point"},
  66         {RBC_TYPE_HINGE, "HINGE", ICON_FORCE_FORCE, "Hinge", "Restricts rigid body rotation to one axis"},
  67         {RBC_TYPE_SLIDER, "SLIDER", ICON_FORCE_FORCE, "Slider", "Restricts rigid boddy translation to one axis"},
  68         {RBC_TYPE_PISTON, "PISTON", ICON_FORCE_FORCE, "Piston", "Restricts rigid boddy translation and rotation to one axis"},
  69         {RBC_TYPE_6DOF, "GENERIC", ICON_FORCE_FORCE, "Generic", "Restricts translation and rotation to specified axes"},
  70         {RBC_TYPE_6DOF_SPRING, "GENERIC_SPRING", ICON_FORCE_FORCE, "Generic Spring", "Restricts translation and rotation to specified axes with springs"},
  71         {0, NULL, 0, NULL, NULL}};
  72
  73
  74 #ifdef RNA_RUNTIME
  75
  76 #ifdef WITH_BULLET
  77 #  include "RBI_api.h"
  78 #endif
  79
  80 #include "BKE_depsgraph.h"
  81 #include "BKE_rigidbody.h"
  82
  83 #define RB_FLAG_SET(dest, value, flag) { \
  84         if (value) \
  85                 dest |= flag; \
  86         else \
  87                 dest &= ~flag; \
  88 }
  89
  90
  91 /* ******************************** */
  92
  93 static void rna_RigidBodyWorld_reset(Main *bmain, Scene *scene, PointerRNA *ptr)
  94 {
  95         RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data;
  96
  97         BKE_rigidbody_cache_reset(rbw);
  98 }
  99
 100 static char *rna_RigidBodyWorld_path(PointerRNA *ptr)
 101 {
 102         return BLI_sprintfN("rigidbody_world");
 103 }
 104
 105 static void rna_RigidBodyWorld_num_solver_iterations_set(PointerRNA *ptr, int value)
 106 {
 107         RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data;
 108
 109         rbw->num_solver_iterations = value;
 110
 111 #ifdef WITH_BULLET
 112         if (rbw->physics_world) {
 113                 RB_dworld_set_solver_iterations(rbw->physics_world, value);
 114         }
 115 #endif
 116 }
 117
 118 static void rna_RigidBodyWorld_split_impulse_set(PointerRNA *ptr, int value)
 119 {
 120         RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data;
 121
 122         RB_FLAG_SET(rbw->flag, value, RBW_FLAG_USE_SPLIT_IMPULSE);
 123
 124 #ifdef WITH_BULLET
 125         if (rbw->physics_world) {
 126                 RB_dworld_set_split_impulse(rbw->physics_world, value);
 127         }
 128 #endif
 129 }
 130
 131 /* ******************************** */
 132
 133 static void rna_RigidBodyOb_reset(Main *bmain, Scene *scene, PointerRNA *ptr)
 134 {
 135         RigidBodyWorld *rbw = scene->rigidbody_world;
 136
 137         BKE_rigidbody_cache_reset(rbw);
 138 }
 139
 140 static void rna_RigidBodyOb_shape_reset(Main *bmain, Scene *scene, PointerRNA *ptr)
 141 {
 142         RigidBodyWorld *rbw = scene->rigidbody_world;
 143         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
 144
 145         BKE_rigidbody_cache_reset(rbw);
 146         if (rbo->physics_shape)
 147                 rbo->flag |= RBO_FLAG_NEEDS_RESHAPE;
 148 }
 149
 150 static char *rna_RigidBodyOb_path(PointerRNA *ptr)
 151 {
 152         /* NOTE: this hardcoded path should work as long as only Objects have this */
 153         return BLI_sprintfN("rigid_body");
 154 }
 155
 156 static void rna_RigidBodyOb_type_set(PointerRNA *ptr, int value)
 157 {
 158         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
 159
 160         rbo->type = value;
 161         rbo->flag |= RBO_FLAG_NEEDS_VALIDATE;
 162
 163 #ifdef WITH_BULLET
 164         /* do physics sim updates */
 165         if (rbo->physics_object) {
 166                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
 167         }
 168 #endif
 169 }
 170
 171 static void rna_RigidBodyOb_disabled_set(PointerRNA *ptr, int value)
 172 {
 173         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
 174
 175         RB_FLAG_SET(rbo->flag, !value, RBO_FLAG_DISABLED);
 176
 177 #ifdef WITH_BULLET
 178         /* update kinematic state if necessary - only needed for active bodies */
 179         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
 180                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
 181                 RB_body_set_kinematic_state(rbo->physics_object, !value);
 182                 rbo->flag |= RBO_FLAG_NEEDS_VALIDATE;
 183         }
 184 #endif
 185 }
 186
 187 static void rna_RigidBodyOb_shape_set(PointerRNA *ptr, int value)
 188 {
 189         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
 190         Object *ob = (Object *)ptr->id.data;
 191
 192         rbo->shape = value;
 193
 194         /* force creation of new collision shape reflecting this */
 195         BKE_rigidbody_validate_sim_shape(ob, TRUE);
 196
 197 #ifdef WITH_BULLET
 198         /* now tell RB sim about it */
 199         if (rbo->physics_object && rbo->physics_shape) {
 200                 RB_body_set_collision_shape(rbo->physics_object, rbo->physics_shape);
 201         }
 202 #endif
 203 }
 204
 205
 206 static void rna_RigidBodyOb_mass_set(PointerRNA *ptr, float value)
 207 {
 208         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
 209
 210         rbo->mass = value;
 211
 212 #ifdef WITH_BULLET
 213         /* only active bodies need mass update */
 214         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
 215                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
 216         }
 217 #endif
 218 }
 219
 220 static void rna_RigidBodyOb_friction_set(PointerRNA *ptr, float value)
 221 {
 222         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
 223
 224         rbo->friction = value;
 225
 226 #ifdef WITH_BULLET
 227         if (rbo->physics_object) {
 228                 RB_body_set_friction(rbo->physics_object, value);
 229         }
 230 #endif
 231 }
 232
 233 static void rna_RigidBodyOb_restitution_set(PointerRNA *ptr, float value)
 234 {
 235         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
 236
 237         rbo->restitution = value;
 238 #ifdef WITH_BULLET
 239         if (rbo->physics_object) {
 240                 RB_body_set_restitution(rbo->physics_object, value);
 241         }
 242 #endif
 243 }
 244
 245 static void rna_RigidBodyOb_collision_margin_set(PointerRNA *ptr, float value)
 246 {
 247         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
 248
 249         rbo->margin = value;
 250
 251 #ifdef WITH_BULLET
 252         if (rbo->physics_shape) {
 253                 RB_shape_set_margin(rbo->physics_shape, RBO_GET_MARGIN(rbo));
 254         }
 255 #endif
 256 }
 257
 258 static void rna_RigidBodyOb_kinematic_state_set(PointerRNA *ptr, int value)
 259 {
 260         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
 261
 262         RB_FLAG_SET(rbo->flag, value, RBO_FLAG_KINEMATIC);
 263
 264 #ifdef WITH_BULLET
 265         /* update kinematic state if necessary */
 266         if (rbo->physics_object) {
 267                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
 268                 RB_body_set_kinematic_state(rbo->physics_object, value);
 269                 rbo->flag |= RBO_FLAG_NEEDS_VALIDATE;
 270         }
 271 #endif
 272 }
 273
 274 static void rna_RigidBodyOb_activation_state_set(PointerRNA *ptr, int value)
 275 {
 276         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
 277
 278         RB_FLAG_SET(rbo->flag, value, RBO_FLAG_USE_DEACTIVATION);
 279
 280 #ifdef WITH_BULLET
 281         /* update activation state if necessary - only active bodies can be deactivated */
 282         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
 283                 RB_body_set_activation_state(rbo->physics_object, value);
 284         }
 285 #endif
 286 }
 287
 288 static void rna_RigidBodyOb_linear_sleepThresh_set(PointerRNA *ptr, float value)
 289 {
 290         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
 291
 292         rbo->lin_sleep_thresh = value;
 293
 294 #ifdef WITH_BULLET
 295         /* only active bodies need sleep threshold update */
 296         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
 297                 RB_body_set_linear_sleep_thresh(rbo->physics_object, value);
 298         }
 299 #endif
 300 }
 301
 302 static void rna_RigidBodyOb_angular_sleepThresh_set(PointerRNA *ptr, float value)
 303 {
 304         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
 305
 306         rbo->ang_sleep_thresh = value;
 307
 308 #ifdef WITH_BULLET
 309         /* only active bodies need sleep threshold update */
 310         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
 311                 RB_body_set_angular_sleep_thresh(rbo->physics_object, value);
 312         }
 313 #endif
 314 }
 315
 316 static void rna_RigidBodyOb_linear_damping_set(PointerRNA *ptr, float value)
 317 {
 318         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
 319
 320         rbo->lin_damping = value;
 321
 322 #ifdef WITH_BULLET
 323         /* only active bodies need damping update */
 324         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
 325                 RB_body_set_linear_damping(rbo->physics_object, value);
 326         }
 327 #endif
 328 }
 329
 330 static void rna_RigidBodyOb_angular_damping_set(PointerRNA *ptr, float value)
 331 {
 332         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
 333
 334         rbo->ang_damping = value;
 335
 336 #ifdef WITH_BULLET
 337         /* only active bodies need damping update */
 338         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
 339                 RB_body_set_angular_damping(rbo->physics_object, value);
 340         }
 341 #endif
 342 }
 343
 344 static char *rna_RigidBodyCon_path(PointerRNA *ptr)
 345 {
 346         /* NOTE: this hardcoded path should work as long as only Objects have this */
 347         return BLI_sprintfN("rigid_body_constraint");
 348 }
 349
 350 static void rna_RigidBodyCon_type_set(PointerRNA *ptr, int value)
 351 {
 352         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
 353
 354         rbc->type = value;
 355         rbc->flag |= RBC_FLAG_NEEDS_VALIDATE;
 356 }
 357
 358 static void rna_RigidBodyCon_enabled_set(PointerRNA *ptr, int value)
 359 {
 360         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
 361
 362         RB_FLAG_SET(rbc->flag, value, RBC_FLAG_ENABLED);
 363
 364 #ifdef WITH_BULLET
 365         if (rbc->physics_constraint) {
 366                 RB_constraint_set_enabled(rbc->physics_constraint, value);
 367         }
 368 #endif
 369 }
 370
 371 static void rna_RigidBodyCon_disable_collisions_set(PointerRNA *ptr, int value)
 372 {
 373         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
 374
 375         RB_FLAG_SET(rbc->flag, value, RBC_FLAG_DISABLE_COLLISIONS);
 376
 377         rbc->flag |= RBC_FLAG_NEEDS_VALIDATE;
 378 }
 379
 380 static void rna_RigidBodyCon_use_breaking_set(PointerRNA *ptr, int value)
 381 {
 382         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
 383
 384         if (value) {
 385                 rbc->flag |= RBC_FLAG_USE_BREAKING;
 386 #ifdef WITH_BULLET
 387                 if (rbc->physics_constraint) {
 388                         RB_constraint_set_breaking_threshold(rbc->physics_constraint, rbc->breaking_threshold);
 389                 }
 390 #endif
 391         }
 392         else {
 393                 rbc->flag &= ~RBC_FLAG_USE_BREAKING;
 394 #ifdef WITH_BULLET
 395                 if (rbc->physics_constraint) {
 396                         RB_constraint_set_breaking_threshold(rbc->physics_constraint, FLT_MAX);
 397                 }
 398 #endif
 399         }
 400 }
 401
 402 static void rna_RigidBodyCon_breaking_threshold_set(PointerRNA *ptr, float value)
 403 {
 404         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
 405
 406         rbc->breaking_threshold = value;
 407
 408 #ifdef WITH_BULLET
 409         if (rbc->physics_constraint && (rbc->flag & RBC_FLAG_USE_BREAKING)) {
 410                 RB_constraint_set_breaking_threshold(rbc->physics_constraint, value);
 411         }
 412 #endif
 413 }
 414
 415 static void rna_RigidBodyCon_override_solver_iterations_set(PointerRNA *ptr, int value)
 416 {
 417         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
 418
 419         if (value) {
 420                 rbc->flag |= RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS;
 421 #ifdef WITH_BULLET
 422                 if (rbc->physics_constraint) {
 423                         RB_constraint_set_solver_iterations(rbc->physics_constraint, rbc->num_solver_iterations);
 424                 }
 425 #endif
 426         }
 427         else {
 428                 rbc->flag &= ~RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS;
 429 #ifdef WITH_BULLET
 430                 if (rbc->physics_constraint) {
 431                         RB_constraint_set_solver_iterations(rbc->physics_constraint, -1);
 432                 }
 433 #endif
 434         }
 435 }
 436
 437 static void rna_RigidBodyCon_num_solver_iterations_set(PointerRNA *ptr, int value)
 438 {
 439         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
 440
 441         rbc->num_solver_iterations = value;
 442
 443 #ifdef WITH_BULLET
 444         if (rbc->physics_constraint && (rbc->flag & RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS)) {
 445                 RB_constraint_set_solver_iterations(rbc->physics_constraint, value);
 446         }
 447 #endif
 448 }
 449
 450 static void rna_RigidBodyCon_spring_stiffness_x_set(PointerRNA *ptr, float value)
 451 {
 452         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
 453
 454         rbc->spring_stiffness_x = value;
 455
 456 #ifdef WITH_BULLET
 457         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_X)) {
 458                 RB_constraint_set_stiffness_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_X, value);
 459         }
 460 #endif
 461 }
 462
 463 static void rna_RigidBodyCon_spring_stiffness_y_set(PointerRNA *ptr, float value)
 464 {
 465         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
 466
 467         rbc->spring_stiffness_y = value;
 468
 469 #ifdef WITH_BULLET
 470         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_Y)) {
 471                 RB_constraint_set_stiffness_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_Y, value);
 472         }
 473 #endif
 474 }
 475
 476 static void rna_RigidBodyCon_spring_stiffness_z_set(PointerRNA *ptr, float value)
 477 {
 478         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
 479
 480         rbc->spring_stiffness_z = value;
 481
 482 #ifdef WITH_BULLET
 483         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_Z)) {
 484                 RB_constraint_set_stiffness_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_Z, value);
 485         }
 486 #endif
 487 }
 488
 489 static void rna_RigidBodyCon_spring_damping_x_set(PointerRNA *ptr, float value)
 490 {
 491         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
 492
 493         rbc->spring_damping_x = value;
 494
 495 #ifdef WITH_BULLET
 496         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_X)) {
 497                 RB_constraint_set_damping_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_X, value);
 498         }
 499 #endif
 500 }
 501
 502 static void rna_RigidBodyCon_spring_damping_y_set(PointerRNA *ptr, float value)
 503 {
 504         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
 505
 506         rbc->spring_damping_y = value;
 507 #ifdef WITH_BULLET
 508         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_Y)) {
 509                 RB_constraint_set_damping_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_Y, value);
 510         }
 511 #endif
 512 }
 513
 514 static void rna_RigidBodyCon_spring_damping_z_set(PointerRNA *ptr, float value)
 515 {
 516         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
 517
 518         rbc->spring_damping_z = value;
 519 #ifdef WITH_BULLET
 520         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_Z)) {
 521                 RB_constraint_set_damping_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_Z, value);
 522         }
 523 #endif
 524 }
 525
 526 #else
 527
 528 static void rna_def_rigidbody_world(BlenderRNA *brna)
 529 {
 530         StructRNA *srna;
 531         PropertyRNA *prop;
 532
 533         srna = RNA_def_struct(brna, "RigidBodyWorld", NULL);
 534         RNA_def_struct_sdna(srna, "RigidBodyWorld");
 535         RNA_def_struct_ui_text(srna, "Rigid Body World", "Self-contained rigid body simulation environment and settings");
 536         RNA_def_struct_path_func(srna, "rna_RigidBodyWorld_path");
 537
 538         /* groups */
 539         prop = RNA_def_property(srna, "group", PROP_POINTER, PROP_NONE);
 540         RNA_def_property_struct_type(prop, "Group");
 541         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
 542         RNA_def_property_ui_text(prop, "Group", "Group containing objects participating in this simulation");
 543         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
 544
 545         prop = RNA_def_property(srna, "constraints", PROP_POINTER, PROP_NONE);
 546         RNA_def_property_struct_type(prop, "Group");
 547         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
 548         RNA_def_property_ui_text(prop, "Constraints", "Group containing rigid body constraint objects");
 549         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
 550
 551         /* booleans */
 552         prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
 553         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", RBW_FLAG_MUTED);
 554         RNA_def_property_ui_text(prop, "Enabled", "Simulation will be evaluated");
 555         RNA_def_property_update(prop, NC_SCENE, NULL);
 556
 557         /* time scale */
 558         prop = RNA_def_property(srna, "time_scale", PROP_FLOAT, PROP_NONE);
 559         RNA_def_property_float_sdna(prop, NULL, "time_scale");
 560         RNA_def_property_range(prop, 0.0f, 100.0f);
 561         RNA_def_property_ui_range(prop, 0.0f, 10.0f, 1, 3);
 562         RNA_def_property_float_default(prop, 1.0f);
 563         RNA_def_property_ui_text(prop, "Time Scale", "Changes the speed of the simulation");
 564         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
 565
 566         /* timestep */
 567         prop = RNA_def_property(srna, "steps_per_second", PROP_INT, PROP_NONE);
 568         RNA_def_property_int_sdna(prop, NULL, "steps_per_second");
 569         RNA_def_property_range(prop, 1, SHRT_MAX);
 570         RNA_def_property_ui_range(prop, 60, 1000, 1, 0);
 571         RNA_def_property_int_default(prop, 60);
 572         RNA_def_property_ui_text(prop, "Steps Per Second", "Number of simulation steps taken per second (higher values are more accurate but slower)");
 573         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
 574
 575         /* constraint solver iterations */
 576         prop = RNA_def_property(srna, "num_solver_iterations", PROP_INT, PROP_NONE);
 577         RNA_def_property_int_sdna(prop, NULL, "num_solver_iterations");
 578         RNA_def_property_range(prop, 1, 1000);
 579         RNA_def_property_ui_range(prop, 10, 100, 1, 0);
 580         RNA_def_property_int_default(prop, 10);
 581         RNA_def_property_int_funcs(prop, NULL, "rna_RigidBodyWorld_num_solver_iterations_set", NULL);
 582         RNA_def_property_ui_text(prop, "Solver Iterations", "Number of constraint solver iterations made per simulation step (higher values are more accurate but slower)");
 583         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
 584
 585         /* split impulse */
 586         prop = RNA_def_property(srna, "use_split_impulse", PROP_BOOLEAN, PROP_NONE);
 587         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBW_FLAG_USE_SPLIT_IMPULSE);
 588         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyWorld_split_impulse_set");
 589         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)");
 590         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
 591
 592         /* cache */
 593         prop = RNA_def_property(srna, "point_cache", PROP_POINTER, PROP_NONE);
 594         RNA_def_property_flag(prop, PROP_NEVER_NULL);
 595         RNA_def_property_pointer_sdna(prop, NULL, "pointcache");
 596         RNA_def_property_ui_text(prop, "Point Cache", "");
 597
 598         /* effector weights */
 599         prop = RNA_def_property(srna, "effector_weights", PROP_POINTER, PROP_NONE);
 600         RNA_def_property_struct_type(prop, "EffectorWeights");
 601         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
 602         RNA_def_property_ui_text(prop, "Effector Weights", "");
 603 }
 604
 605 static void rna_def_rigidbody_object(BlenderRNA *brna)
 606 {
 607         StructRNA *srna;
 608         PropertyRNA *prop;
 609
 610
 611         srna = RNA_def_struct(brna, "RigidBodyObject", NULL);
 612         RNA_def_struct_sdna(srna, "RigidBodyOb");
 613         RNA_def_struct_ui_text(srna, "Rigid Body Object", "Settings for object participating in Rigid Body Simulation");
 614         RNA_def_struct_path_func(srna, "rna_RigidBodyOb_path");
 615
 616         /* Enums */
 617         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
 618         RNA_def_property_enum_sdna(prop, NULL, "type");
 619         RNA_def_property_enum_items(prop, rigidbody_ob_type_items);
 620         RNA_def_property_enum_funcs(prop, NULL, "rna_RigidBodyOb_type_set", NULL);
 621         RNA_def_property_ui_text(prop, "Type", "Role of object in Rigid Body Simulations");
 622         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 623         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 624
 625         /* booleans */
 626         prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
 627         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", RBO_FLAG_DISABLED);
 628         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_disabled_set");
 629         RNA_def_property_ui_text(prop, "Enabled", "Rigid Body actively participated in the simulation");
 630         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 631
 632         prop = RNA_def_property(srna, "collision_shape", PROP_ENUM, PROP_NONE);
 633         RNA_def_property_enum_sdna(prop, NULL, "shape");
 634         RNA_def_property_enum_items(prop, rigidbody_ob_shape_items);
 635         RNA_def_property_enum_funcs(prop, NULL, "rna_RigidBodyOb_shape_set", NULL);
 636         RNA_def_property_ui_text(prop, "Collision Shape", "Collision Shape of object in Rigid Body Simulations");
 637         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 638
 639         prop = RNA_def_property(srna, "kinematic", PROP_BOOLEAN, PROP_NONE);
 640         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_KINEMATIC);
 641         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_kinematic_state_set");
 642         RNA_def_property_ui_text(prop, "Kinematic", "Allows rigid body to be controlled by the animation system");
 643         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 644
 645         /* Physics Parameters */
 646         prop = RNA_def_property(srna, "mass", PROP_FLOAT, PROP_UNIT_MASS);
 647         RNA_def_property_float_sdna(prop, NULL, "mass");
 648         RNA_def_property_range(prop, 0.001f, FLT_MAX); // range must always be positive (and non-zero)
 649         RNA_def_property_float_default(prop, 1.0f);
 650         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_mass_set", NULL);
 651         RNA_def_property_ui_text(prop, "Mass", "How much the object 'weighs' irrespective of gravity");
 652         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 653
 654         /* Dynamics Parameters - Activation */
 655         // TODO: define and figure out how to implement these
 656
 657         /* Dynamics Parameters - Deactivation */
 658         prop = RNA_def_property(srna, "use_deactivation", PROP_BOOLEAN, PROP_NONE);
 659         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_USE_DEACTIVATION);
 660         RNA_def_property_boolean_default(prop, TRUE);
 661         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_activation_state_set");
 662         RNA_def_property_ui_text(prop, "Enable Deactivation", "Enables deactivation of resting rigid bodies (increases performance and stability but can cause glitches)");
 663         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 664
 665         prop = RNA_def_property(srna, "start_deactivated", PROP_BOOLEAN, PROP_NONE);
 666         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_START_DEACTIVATED);
 667         RNA_def_property_ui_text(prop, "Start Deactivated", "Deactivates rigid body at the start of the simulation");
 668         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 669         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 670
 671         prop = RNA_def_property(srna, "deactivate_linear_velocity", PROP_FLOAT, PROP_UNIT_VELOCITY);
 672         RNA_def_property_float_sdna(prop, NULL, "lin_sleep_thresh");
 673         RNA_def_property_range(prop, FLT_MIN, FLT_MAX); // range must always be positive (and non-zero)
 674         RNA_def_property_float_default(prop, 0.4f);
 675         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_linear_sleepThresh_set", NULL);
 676         RNA_def_property_ui_text(prop, "Linear Velocity Deactivation Threshold", "Linear Velocity below which simulation stops simulating object");
 677         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 678
 679         prop = RNA_def_property(srna, "deactivate_angular_velocity", PROP_FLOAT, PROP_UNIT_VELOCITY);
 680         RNA_def_property_float_sdna(prop, NULL, "ang_sleep_thresh");
 681         RNA_def_property_range(prop, FLT_MIN, FLT_MAX); // range must always be positive (and non-zero)
 682         RNA_def_property_float_default(prop, 0.5f);
 683         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_angular_sleepThresh_set", NULL);
 684         RNA_def_property_ui_text(prop, "Angular Velocity Deactivation Threshold", "Angular Velocity below which simulation stops simulating object");
 685         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 686
 687         /* Dynamics Parameters - Damping Parameters */
 688         prop = RNA_def_property(srna, "linear_damping", PROP_FLOAT, PROP_FACTOR);
 689         RNA_def_property_float_sdna(prop, NULL, "lin_damping");
 690         RNA_def_property_range(prop, 0.0f, 1.0f);
 691         RNA_def_property_float_default(prop, 0.04f);
 692         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_linear_damping_set", NULL);
 693         RNA_def_property_ui_text(prop, "Linear Damping", "Amount of linear velocity that is lost over time");
 694         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 695
 696         prop = RNA_def_property(srna, "angular_damping", PROP_FLOAT, PROP_FACTOR);
 697         RNA_def_property_float_sdna(prop, NULL, "ang_damping");
 698         RNA_def_property_range(prop, 0.0f, 1.0f);
 699         RNA_def_property_float_default(prop, 0.1f);
 700         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_angular_damping_set", NULL);
 701         RNA_def_property_ui_text(prop, "Angular Damping", "Amount of angular velocity that is lost over time");
 702         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 703
 704         /* Collision Parameters - Surface Parameters */
 705         prop = RNA_def_property(srna, "friction", PROP_FLOAT, PROP_FACTOR);
 706         RNA_def_property_float_sdna(prop, NULL, "friction");
 707         RNA_def_property_range(prop, 0.0f, FLT_MAX);
 708         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 1, 3);
 709         RNA_def_property_float_default(prop, 0.5f);
 710         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_friction_set", NULL);
 711         RNA_def_property_ui_text(prop, "Friction", "Resistance of object to movement");
 712         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 713
 714         prop = RNA_def_property(srna, "restitution", PROP_FLOAT, PROP_FACTOR);
 715         RNA_def_property_float_sdna(prop, NULL, "restitution");
 716         RNA_def_property_range(prop, 0.0f, FLT_MAX);
 717         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 1, 3);
 718         RNA_def_property_float_default(prop, 0.0f);
 719         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_restitution_set", NULL);
 720         RNA_def_property_ui_text(prop, "Restitution", "Tendency of object to bounce after colliding with another (0 = stays still, 1 = perfectly elastic)");
 721         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 722
 723         /* Collision Parameters - Sensitivity */
 724         prop = RNA_def_property(srna, "use_margin", PROP_BOOLEAN, PROP_NONE);
 725         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_USE_MARGIN);
 726         RNA_def_property_boolean_default(prop, FALSE);
 727         RNA_def_property_ui_text(prop, "Collision Margin", "Use custom collision margin (some shapes will have a visible gap around them)");
 728         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_shape_reset");
 729
 730         prop = RNA_def_property(srna, "collision_margin", PROP_FLOAT, PROP_UNIT_LENGTH);
 731         RNA_def_property_float_sdna(prop, NULL, "margin");
 732         RNA_def_property_range(prop, 0.0f, 1.0f);
 733         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.01, 3);
 734         RNA_def_property_float_default(prop, 0.04f);
 735         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_collision_margin_set", NULL);
 736         RNA_def_property_ui_text(prop, "Collision Margin", "Threshold of distance near surface where collisions are still considered (best results when non-zero)");
 737         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_shape_reset");
 738
 739         prop = RNA_def_property(srna, "collision_groups", PROP_BOOLEAN, PROP_LAYER_MEMBER);
 740         RNA_def_property_boolean_sdna(prop, NULL, "col_groups", 1);
 741         RNA_def_property_array(prop, 20);
 742         RNA_def_property_ui_text(prop, "Collison Groups", "Collision Groups Rigid Body belongs to");
 743         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 744         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
 745 }
 746
 747 static void rna_def_rigidbody_constraint(BlenderRNA *brna)
 748 {
 749         StructRNA *srna;
 750         PropertyRNA *prop;
 751
 752         srna = RNA_def_struct(brna, "RigidBodyConstraint", NULL);
 753         RNA_def_struct_sdna(srna, "RigidBodyCon");
 754         RNA_def_struct_ui_text(srna, "Rigid Body Constraint", "Constraint influencing Objects inside Rigid Body Simulation");
 755         RNA_def_struct_path_func(srna, "rna_RigidBodyCon_path");
 756
 757         /* Enums */
 758         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
 759         RNA_def_property_enum_sdna(prop, NULL, "type");
 760         RNA_def_property_enum_items(prop, rigidbody_con_type_items);
 761         RNA_def_property_enum_funcs(prop, NULL, "rna_RigidBodyCon_type_set", NULL);
 762         RNA_def_property_ui_text(prop, "Type", "Type of Rigid Body Constraint");
 763         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
 764         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 765
 766         prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
 767         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_ENABLED);
 768         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_enabled_set");
 769         RNA_def_property_ui_text(prop, "Enabled", "Enable this constraint");
 770         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 771
 772         prop = RNA_def_property(srna, "disable_collisions", PROP_BOOLEAN, PROP_NONE);
 773         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_DISABLE_COLLISIONS);
 774         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_disable_collisions_set");
 775         RNA_def_property_ui_text(prop, "Disable Collisions", "Disables collisions between constrained ridid bodies");
 776         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 777
 778         prop = RNA_def_property(srna, "object1", PROP_POINTER, PROP_NONE);
 779         RNA_def_property_pointer_sdna(prop, NULL, "ob1");
 780         RNA_def_property_flag(prop, PROP_EDITABLE);
 781         RNA_def_property_ui_text(prop, "Object 1", "First Rigid Body Object to be constrained");
 782         RNA_def_property_flag(prop, PROP_EDITABLE);
 783         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 784
 785         prop = RNA_def_property(srna, "object2", PROP_POINTER, PROP_NONE);
 786         RNA_def_property_pointer_sdna(prop, NULL, "ob2");
 787         RNA_def_property_flag(prop, PROP_EDITABLE);
 788         RNA_def_property_ui_text(prop, "Object 2", "Second Rigid Body Object to be constrained");
 789         RNA_def_property_flag(prop, PROP_EDITABLE);
 790         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 791
 792         /* Breaking Threshold */
 793         prop = RNA_def_property(srna, "use_breaking", PROP_BOOLEAN, PROP_NONE);
 794         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_BREAKING);
 795         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_use_breaking_set");
 796         RNA_def_property_ui_text(prop, "Breakable", "Constraint can be broaken if it receives an impulse above the threshold");
 797         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 798
 799         prop = RNA_def_property(srna, "breaking_threshold", PROP_FLOAT, PROP_NONE);
 800         RNA_def_property_float_sdna(prop, NULL, "breaking_threshold");
 801         RNA_def_property_range(prop, 0.0f, FLT_MAX);
 802         RNA_def_property_ui_range(prop, 0.0f, 1000.0f, 100.0, 2);
 803         RNA_def_property_float_default(prop, 10.0f);
 804         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_breaking_threshold_set", NULL);
 805         RNA_def_property_ui_text(prop, "Breaking Threshold", "Impulse threshold that must be reached for the constraint to break");
 806         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 807
 808         /* Solver Iterations */
 809         prop = RNA_def_property(srna, "override_solver_iterations", PROP_BOOLEAN, PROP_NONE);
 810         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS);
 811         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_override_solver_iterations_set");
 812         RNA_def_property_ui_text(prop, "Override Solver Iterations", "Overrides the number of solver iterations for this constraint");
 813         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
 814
 815         prop = RNA_def_property(srna, "num_solver_iterations", PROP_INT, PROP_NONE);
 816         RNA_def_property_int_sdna(prop, NULL, "num_solver_iterations");
 817         RNA_def_property_range(prop, 1, 1000);
 818         RNA_def_property_ui_range(prop, 1, 100, 1, 0);
 819         RNA_def_property_int_default(prop, 10);
 820         RNA_def_property_int_funcs(prop, NULL, "rna_RigidBodyCon_num_solver_iterations_set", NULL);
 821         RNA_def_property_ui_text(prop, "Solver Iterations", "Number of constraint solver iterations made per simulation step (higher values are more accurate but slower)");
 822         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
 823
 824         /* Limits */
 825         prop = RNA_def_property(srna, "use_limit_lin_x", PROP_BOOLEAN, PROP_NONE);
 826         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_LIN_X);
 827         RNA_def_property_ui_text(prop, "X Axis", "Limits translation on x axis");
 828         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 829
 830         prop = RNA_def_property(srna, "use_limit_lin_y", PROP_BOOLEAN, PROP_NONE);
 831         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_LIN_Y);
 832         RNA_def_property_ui_text(prop, "Y Axis", "Limits translation on y axis");
 833         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 834
 835         prop = RNA_def_property(srna, "use_limit_lin_z", PROP_BOOLEAN, PROP_NONE);
 836         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_LIN_Z);
 837         RNA_def_property_ui_text(prop, "Z Axis", "Limits translation on z axis");
 838         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 839
 840         prop = RNA_def_property(srna, "use_limit_ang_x", PROP_BOOLEAN, PROP_NONE);
 841         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_ANG_X);
 842         RNA_def_property_ui_text(prop, "X Angle", "Limits rotation around x axis");
 843         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 844
 845         prop = RNA_def_property(srna, "use_limit_ang_y", PROP_BOOLEAN, PROP_NONE);
 846         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_ANG_Y);
 847         RNA_def_property_ui_text(prop, "Y Angle", "Limits rotation around y axis");
 848         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 849
 850         prop = RNA_def_property(srna, "use_limit_ang_z", PROP_BOOLEAN, PROP_NONE);
 851         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_ANG_Z);
 852         RNA_def_property_ui_text(prop, "Z Angle", "Limits rotation around z axis");
 853         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 854
 855         prop = RNA_def_property(srna, "use_spring_x", PROP_BOOLEAN, PROP_NONE);
 856         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_SPRING_X);
 857         RNA_def_property_ui_text(prop, "X Spring", "Enables spring on X axis");
 858         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
 859
 860         prop = RNA_def_property(srna, "use_spring_y", PROP_BOOLEAN, PROP_NONE);
 861         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_SPRING_Y);
 862         RNA_def_property_ui_text(prop, "Y Spring", "Enables spring on Y axis");
 863         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
 864
 865         prop = RNA_def_property(srna, "use_spring_z", PROP_BOOLEAN, PROP_NONE);
 866         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_SPRING_Z);
 867         RNA_def_property_ui_text(prop, "Z Spring", "Enables spring on Z axis");
 868         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
 869
 870         prop = RNA_def_property(srna, "limit_lin_x_lower", PROP_FLOAT, PROP_UNIT_LENGTH);
 871         RNA_def_property_float_sdna(prop, NULL, "limit_lin_x_lower");
 872         RNA_def_property_float_default(prop, -1.0f);
 873         RNA_def_property_ui_text(prop, "Lower X Limit", "Lower limit of x axis translation");
 874         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 875
 876         prop = RNA_def_property(srna, "limit_lin_x_upper", PROP_FLOAT, PROP_UNIT_LENGTH);
 877         RNA_def_property_float_sdna(prop, NULL, "limit_lin_x_upper");
 878         RNA_def_property_float_default(prop, 1.0f);
 879         RNA_def_property_ui_text(prop, "Upper X Limit", "Upper limit of x axis translation");
 880         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 881
 882         prop = RNA_def_property(srna, "limit_lin_y_lower", PROP_FLOAT, PROP_UNIT_LENGTH);
 883         RNA_def_property_float_sdna(prop, NULL, "limit_lin_y_lower");
 884         RNA_def_property_float_default(prop, -1.0f);
 885         RNA_def_property_ui_text(prop, "Lower Y Limit", "Lower limit of y axis translation");
 886         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 887
 888         prop = RNA_def_property(srna, "limit_lin_y_upper", PROP_FLOAT, PROP_UNIT_LENGTH);
 889         RNA_def_property_float_sdna(prop, NULL, "limit_lin_y_upper");
 890         RNA_def_property_float_default(prop, 1.0f);
 891         RNA_def_property_ui_text(prop, "Upper Y Limit", "Upper limit of y axis translation");
 892         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 893
 894         prop = RNA_def_property(srna, "limit_lin_z_lower", PROP_FLOAT, PROP_UNIT_LENGTH);
 895         RNA_def_property_float_sdna(prop, NULL, "limit_lin_z_lower");
 896         RNA_def_property_float_default(prop, -1.0f);
 897         RNA_def_property_ui_text(prop, "Lower Z Limit", "Lower limit of z axis translation");
 898         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 899
 900         prop = RNA_def_property(srna, "limit_lin_z_upper", PROP_FLOAT, PROP_UNIT_LENGTH);
 901         RNA_def_property_float_sdna(prop, NULL, "limit_lin_z_upper");
 902         RNA_def_property_float_default(prop, 1.0f);
 903         RNA_def_property_ui_text(prop, "Upper Z Limit", "Upper limit of z axis translation");
 904         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 905
 906         prop = RNA_def_property(srna, "limit_ang_x_lower", PROP_FLOAT, PROP_ANGLE);
 907         RNA_def_property_float_sdna(prop, NULL, "limit_ang_x_lower");
 908         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
 909         RNA_def_property_float_default(prop, -M_PI_4);
 910         RNA_def_property_ui_text(prop, "Lower X Angle Limit", "Lower limit of x axis rotation");
 911         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 912
 913         prop = RNA_def_property(srna, "limit_ang_x_upper", PROP_FLOAT, PROP_ANGLE);
 914         RNA_def_property_float_sdna(prop, NULL, "limit_ang_x_upper");
 915         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
 916         RNA_def_property_float_default(prop, M_PI_4);
 917         RNA_def_property_ui_text(prop, "Upper X Angle Limit", "Upper limit of x axis rotation");
 918         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 919
 920         prop = RNA_def_property(srna, "limit_ang_y_lower", PROP_FLOAT, PROP_ANGLE);
 921         RNA_def_property_float_sdna(prop, NULL, "limit_ang_y_lower");
 922         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
 923         RNA_def_property_float_default(prop, -M_PI_4);
 924         RNA_def_property_ui_text(prop, "Lower Y Angle Limit", "Lower limit of y axis rotation");
 925         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 926
 927         prop = RNA_def_property(srna, "limit_ang_y_upper", PROP_FLOAT, PROP_ANGLE);
 928         RNA_def_property_float_sdna(prop, NULL, "limit_ang_y_upper");
 929         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
 930         RNA_def_property_float_default(prop, M_PI_4);
 931         RNA_def_property_ui_text(prop, "Upper Y Angle Limit", "Upper limit of y axis rotation");
 932         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 933
 934         prop = RNA_def_property(srna, "limit_ang_z_lower", PROP_FLOAT, PROP_ANGLE);
 935         RNA_def_property_float_sdna(prop, NULL, "limit_ang_z_lower");
 936         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
 937         RNA_def_property_float_default(prop, -M_PI_4);
 938         RNA_def_property_ui_text(prop, "Lower Z Angle Limit", "Lower limit of z axis rotation");
 939         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 940
 941         prop = RNA_def_property(srna, "limit_ang_z_upper", PROP_FLOAT, PROP_ANGLE);
 942         RNA_def_property_float_sdna(prop, NULL, "limit_ang_z_upper");
 943         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
 944         RNA_def_property_float_default(prop, M_PI_4);
 945         RNA_def_property_ui_text(prop, "Upper Z Angle Limit", "Upper limit of z axis rotation");
 946         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
 947
 948         prop = RNA_def_property(srna, "spring_stiffness_x", PROP_FLOAT, PROP_UNIT_LENGTH);
 949         RNA_def_property_float_sdna(prop, NULL, "spring_stiffness_x");
 950         RNA_def_property_range(prop, 0.0f, FLT_MAX);
 951         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3);
 952         RNA_def_property_float_default(prop, 10.0f);
 953         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_stiffness_x_set", NULL);
 954         RNA_def_property_ui_text(prop, "X Axis Stiffness", "Stiffness on the X axis");
 955         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
 956
 957         prop = RNA_def_property(srna, "spring_stiffness_y", PROP_FLOAT, PROP_UNIT_LENGTH);
 958         RNA_def_property_float_sdna(prop, NULL, "spring_stiffness_y");
 959         RNA_def_property_range(prop, 0.0f, FLT_MAX);
 960         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3);
 961         RNA_def_property_float_default(prop, 10.0f);
 962         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_stiffness_y_set", NULL);
 963         RNA_def_property_ui_text(prop, "Y Axis Stiffness", "Stiffness on the Y axis");
 964         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
 965
 966         prop = RNA_def_property(srna, "spring_stiffness_z", PROP_FLOAT, PROP_UNIT_LENGTH);
 967         RNA_def_property_float_sdna(prop, NULL, "spring_stiffness_z");
 968         RNA_def_property_range(prop, 0.0f, FLT_MAX);
 969         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3);
 970         RNA_def_property_float_default(prop, 10.0f);
 971         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_stiffness_z_set", NULL);
 972         RNA_def_property_ui_text(prop, "Z Axis Stiffness", "Stiffness on the Z axis");
 973         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
 974
 975         prop = RNA_def_property(srna, "spring_damping_x", PROP_FLOAT, PROP_FACTOR);
 976         RNA_def_property_float_sdna(prop, NULL, "spring_damping_x");
 977         RNA_def_property_range(prop, 0.0f, 1.0f);
 978         RNA_def_property_float_default(prop, 0.5f);
 979         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_damping_x_set", NULL);
 980         RNA_def_property_ui_text(prop, "Damping X", "Damping on the X axis");
 981         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
 982
 983         prop = RNA_def_property(srna, "spring_damping_y", PROP_FLOAT, PROP_FACTOR);
 984         RNA_def_property_float_sdna(prop, NULL, "spring_damping_y");
 985         RNA_def_property_range(prop, 0.0f, 1.0f);
 986         RNA_def_property_float_default(prop, 0.5f);
 987         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_damping_y_set", NULL);
 988         RNA_def_property_ui_text(prop, "Damping Y", "Damping on the Y axis");
 989         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
 990
 991         prop = RNA_def_property(srna, "spring_damping_z", PROP_FLOAT, PROP_FACTOR);
 992         RNA_def_property_float_sdna(prop, NULL, "spring_damping_z");
 993         RNA_def_property_range(prop, 0.0f, 1.0f);
 994         RNA_def_property_float_default(prop, 0.5f);
 995         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_damping_z_set", NULL);
 996         RNA_def_property_ui_text(prop, "Damping Z", "Damping on the Z axis");
 997         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
 998 }
 999
1000 void RNA_def_rigidbody(BlenderRNA *brna)
1001 {
1002         rna_def_rigidbody_world(brna);
1003         rna_def_rigidbody_object(brna);
1004         rna_def_rigidbody_constraint(brna);
1005 }
1006
1007
1008 #endif