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