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