Merge branch 'master' into blender2.8
[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 #include "RNA_enum_types.h"
33
34 #include "rna_internal.h"
35
36 #include "DNA_group_types.h"
37 #include "DNA_object_types.h"
38 #include "DNA_rigidbody_types.h"
39 #include "DNA_scene_types.h"
40
41 #include "BLI_utildefines.h"
42 #include "BLI_math.h"
43
44 #include "WM_types.h"
45
46 /* roles of objects in RigidBody Sims */
47 EnumPropertyItem rna_enum_rigidbody_object_type_items[] = {
48         {RBO_TYPE_ACTIVE, "ACTIVE", 0, "Active", "Object is directly controlled by simulation results"},
49         {RBO_TYPE_PASSIVE, "PASSIVE", 0, "Passive", "Object is directly controlled by animation system"},
50         {0, NULL, 0, NULL, NULL}};
51
52 /* collision shapes of objects in rigid body sim */
53 EnumPropertyItem rna_enum_rigidbody_object_shape_items[] = {
54         {RB_SHAPE_BOX, "BOX", ICON_MESH_CUBE, "Box", "Box-like shapes (i.e. cubes), including planes (i.e. ground planes)"},
55         {RB_SHAPE_SPHERE, "SPHERE", ICON_MESH_UVSPHERE, "Sphere", ""},
56         {RB_SHAPE_CAPSULE, "CAPSULE", ICON_MESH_CAPSULE, "Capsule", ""},
57         {RB_SHAPE_CYLINDER, "CYLINDER", ICON_MESH_CYLINDER, "Cylinder", ""},
58         {RB_SHAPE_CONE, "CONE", ICON_MESH_CONE, "Cone", ""},
59         {RB_SHAPE_CONVEXH, "CONVEX_HULL", ICON_MESH_ICOSPHERE, "Convex Hull",
60                            "A mesh-like surface encompassing (i.e. shrinkwrap over) all vertices (best results with "
61                            "fewer vertices)"},
62         {RB_SHAPE_TRIMESH, "MESH", ICON_MESH_MONKEY, "Mesh",
63                            "Mesh consisting of triangles only, allowing for more detailed interactions than convex hulls"},
64         {0, NULL, 0, NULL, NULL}};
65
66 /* collision shapes of constraints in rigid body sim */
67 EnumPropertyItem rna_enum_rigidbody_constraint_type_items[] = {
68         {RBC_TYPE_FIXED, "FIXED", ICON_NONE, "Fixed", "Glue rigid bodies together"},
69         {RBC_TYPE_POINT, "POINT", ICON_NONE, "Point", "Constrain rigid bodies to move around common pivot point"},
70         {RBC_TYPE_HINGE, "HINGE", ICON_NONE, "Hinge", "Restrict rigid body rotation to one axis"},
71         {RBC_TYPE_SLIDER, "SLIDER", ICON_NONE, "Slider", "Restrict rigid body translation to one axis"},
72         {RBC_TYPE_PISTON, "PISTON", ICON_NONE, "Piston", "Restrict rigid body translation and rotation to one axis"},
73         {RBC_TYPE_6DOF, "GENERIC", ICON_NONE, "Generic", "Restrict translation and rotation to specified axes"},
74         {RBC_TYPE_6DOF_SPRING, "GENERIC_SPRING", ICON_NONE, "Generic Spring",
75                                "Restrict translation and rotation to specified axes with springs"},
76         {RBC_TYPE_MOTOR, "MOTOR", ICON_NONE, "Motor", "Drive rigid body around or along an axis"},
77         {0, NULL, 0, NULL, NULL}};
78
79 #ifndef RNA_RUNTIME
80 /* mesh source for collision shape creation */
81 static EnumPropertyItem rigidbody_mesh_source_items[] = {
82         {RBO_MESH_BASE, "BASE", 0, "Base", "Base mesh"},
83         {RBO_MESH_DEFORM, "DEFORM", 0, "Deform", "Deformations (shape keys, deform modifiers)"},
84         {RBO_MESH_FINAL, "FINAL", 0, "Final", "All modifiers"},
85         {0, NULL, 0, NULL, NULL}};
86 #endif
87
88 #ifdef RNA_RUNTIME
89
90 #ifdef WITH_BULLET
91 #  include "RBI_api.h"
92 #endif
93
94 #include "BKE_rigidbody.h"
95
96 #include "WM_api.h"
97
98 #define RB_FLAG_SET(dest, value, flag) { \
99         if (value) \
100                 dest |= flag; \
101         else \
102                 dest &= ~flag; \
103 }
104
105
106 /* ******************************** */
107
108 static void rna_RigidBodyWorld_reset(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
109 {
110         RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data;
111         
112         BKE_rigidbody_cache_reset(rbw);
113 }
114
115 static char *rna_RigidBodyWorld_path(PointerRNA *UNUSED(ptr))
116 {       
117         return BLI_sprintfN("rigidbody_world");
118 }
119
120 static void rna_RigidBodyWorld_num_solver_iterations_set(PointerRNA *ptr, int value)
121 {
122         RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data;
123         
124         rbw->num_solver_iterations = value;
125
126 #ifdef WITH_BULLET
127         if (rbw->physics_world) {
128                 RB_dworld_set_solver_iterations(rbw->physics_world, value);
129         }
130 #endif
131 }
132
133 static void rna_RigidBodyWorld_split_impulse_set(PointerRNA *ptr, int value)
134 {
135         RigidBodyWorld *rbw = (RigidBodyWorld *)ptr->data;
136         
137         RB_FLAG_SET(rbw->flag, value, RBW_FLAG_USE_SPLIT_IMPULSE);
138
139 #ifdef WITH_BULLET
140         if (rbw->physics_world) {
141                 RB_dworld_set_split_impulse(rbw->physics_world, value);
142         }
143 #endif
144 }
145
146 /* ******************************** */
147
148 static void rna_RigidBodyOb_reset(Main *UNUSED(bmain), Scene *scene, PointerRNA *UNUSED(ptr))
149 {
150         RigidBodyWorld *rbw = scene->rigidbody_world;
151         
152         BKE_rigidbody_cache_reset(rbw);
153 }
154
155 static void rna_RigidBodyOb_shape_update(Main *bmain, Scene *scene, PointerRNA *ptr)
156 {
157         Object *ob = ptr->id.data;
158         
159         rna_RigidBodyOb_reset(bmain, scene, ptr);
160         
161         WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
162 }
163
164 static void rna_RigidBodyOb_shape_reset(Main *UNUSED(bmain), Scene *scene, PointerRNA *ptr)
165 {
166         RigidBodyWorld *rbw = scene->rigidbody_world;
167         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
168         
169         BKE_rigidbody_cache_reset(rbw);
170         if (rbo->physics_shape)
171                 rbo->flag |= RBO_FLAG_NEEDS_RESHAPE;
172 }
173
174 static char *rna_RigidBodyOb_path(PointerRNA *UNUSED(ptr))
175 {
176         /* NOTE: this hardcoded path should work as long as only Objects have this */
177         return BLI_sprintfN("rigid_body");
178 }
179
180 static void rna_RigidBodyOb_type_set(PointerRNA *ptr, int value)
181 {
182         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
183         
184         rbo->type = value;
185         rbo->flag |= RBO_FLAG_NEEDS_VALIDATE;
186 }
187
188 static void rna_RigidBodyOb_shape_set(PointerRNA *ptr, int value)
189 {
190         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
191
192         rbo->shape = value;
193         rbo->flag |= RBO_FLAG_NEEDS_VALIDATE;
194 }
195
196 static void rna_RigidBodyOb_disabled_set(PointerRNA *ptr, int value)
197 {
198         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
199         
200         RB_FLAG_SET(rbo->flag, !value, RBO_FLAG_DISABLED);
201
202 #ifdef WITH_BULLET
203         /* update kinematic state if necessary - only needed for active bodies */
204         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
205                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
206                 RB_body_set_kinematic_state(rbo->physics_object, !value);
207                 rbo->flag |= RBO_FLAG_NEEDS_VALIDATE;
208         }
209 #endif
210 }
211
212 static void rna_RigidBodyOb_mass_set(PointerRNA *ptr, float value)
213 {
214         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
215         
216         rbo->mass = value;
217
218 #ifdef WITH_BULLET
219         /* only active bodies need mass update */
220         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
221                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
222         }
223 #endif
224 }
225
226 static void rna_RigidBodyOb_friction_set(PointerRNA *ptr, float value)
227 {
228         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
229         
230         rbo->friction = value;
231
232 #ifdef WITH_BULLET
233         if (rbo->physics_object) {
234                 RB_body_set_friction(rbo->physics_object, value);
235         }
236 #endif
237 }
238
239 static void rna_RigidBodyOb_restitution_set(PointerRNA *ptr, float value)
240 {
241         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
242         
243         rbo->restitution = value;
244 #ifdef WITH_BULLET
245         if (rbo->physics_object) {
246                 RB_body_set_restitution(rbo->physics_object, value);
247         }
248 #endif
249 }
250
251 static void rna_RigidBodyOb_collision_margin_set(PointerRNA *ptr, float value)
252 {
253         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
254         
255         rbo->margin = value;
256
257 #ifdef WITH_BULLET
258         if (rbo->physics_shape) {
259                 RB_shape_set_margin(rbo->physics_shape, RBO_GET_MARGIN(rbo));
260         }
261 #endif
262 }
263
264 static void rna_RigidBodyOb_collision_groups_set(PointerRNA *ptr, const int *values)
265 {
266         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
267         int i;
268
269         for (i = 0; i < 20; i++) {
270                 if (values[i])
271                         rbo->col_groups |= (1 << i);
272                 else
273                         rbo->col_groups &= ~(1 << i);
274         }
275         rbo->flag |= RBO_FLAG_NEEDS_VALIDATE;
276 }
277
278 static void rna_RigidBodyOb_kinematic_state_set(PointerRNA *ptr, int value)
279 {
280         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
281         
282         RB_FLAG_SET(rbo->flag, value, RBO_FLAG_KINEMATIC);
283
284 #ifdef WITH_BULLET
285         /* update kinematic state if necessary */
286         if (rbo->physics_object) {
287                 RB_body_set_mass(rbo->physics_object, RBO_GET_MASS(rbo));
288                 RB_body_set_kinematic_state(rbo->physics_object, value);
289                 rbo->flag |= RBO_FLAG_NEEDS_VALIDATE;
290         }
291 #endif
292 }
293
294 static void rna_RigidBodyOb_activation_state_set(PointerRNA *ptr, int value)
295 {
296         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
297         
298         RB_FLAG_SET(rbo->flag, value, RBO_FLAG_USE_DEACTIVATION);
299
300 #ifdef WITH_BULLET
301         /* update activation state if necessary - only active bodies can be deactivated */
302         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
303                 RB_body_set_activation_state(rbo->physics_object, value);
304         }
305 #endif
306 }
307
308 static void rna_RigidBodyOb_linear_sleepThresh_set(PointerRNA *ptr, float value)
309 {
310         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
311         
312         rbo->lin_sleep_thresh = value;
313
314 #ifdef WITH_BULLET
315         /* only active bodies need sleep threshold update */
316         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
317                 RB_body_set_linear_sleep_thresh(rbo->physics_object, value);
318         }
319 #endif
320 }
321
322 static void rna_RigidBodyOb_angular_sleepThresh_set(PointerRNA *ptr, float value)
323 {
324         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
325         
326         rbo->ang_sleep_thresh = value;
327
328 #ifdef WITH_BULLET
329         /* only active bodies need sleep threshold update */
330         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
331                 RB_body_set_angular_sleep_thresh(rbo->physics_object, value);
332         }
333 #endif
334 }
335
336 static void rna_RigidBodyOb_linear_damping_set(PointerRNA *ptr, float value)
337 {
338         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
339         
340         rbo->lin_damping = value;
341
342 #ifdef WITH_BULLET
343         /* only active bodies need damping update */
344         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
345                 RB_body_set_linear_damping(rbo->physics_object, value);
346         }
347 #endif
348 }
349
350 static void rna_RigidBodyOb_angular_damping_set(PointerRNA *ptr, float value)
351 {
352         RigidBodyOb *rbo = (RigidBodyOb *)ptr->data;
353         
354         rbo->ang_damping = value;
355
356 #ifdef WITH_BULLET
357         /* only active bodies need damping update */
358         if ((rbo->physics_object) && (rbo->type == RBO_TYPE_ACTIVE)) {
359                 RB_body_set_angular_damping(rbo->physics_object, value);
360         }
361 #endif
362 }
363
364 static char *rna_RigidBodyCon_path(PointerRNA *UNUSED(ptr))
365 {
366         /* NOTE: this hardcoded path should work as long as only Objects have this */
367         return BLI_sprintfN("rigid_body_constraint");
368 }
369
370 static void rna_RigidBodyCon_type_set(PointerRNA *ptr, int value)
371 {
372         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
373
374         rbc->type = value;
375         rbc->flag |= RBC_FLAG_NEEDS_VALIDATE;
376 }
377
378 static void rna_RigidBodyCon_enabled_set(PointerRNA *ptr, int value)
379 {
380         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
381
382         RB_FLAG_SET(rbc->flag, value, RBC_FLAG_ENABLED);
383
384 #ifdef WITH_BULLET
385         if (rbc->physics_constraint) {
386                 RB_constraint_set_enabled(rbc->physics_constraint, value);
387         }
388 #endif
389 }
390
391 static void rna_RigidBodyCon_disable_collisions_set(PointerRNA *ptr, int value)
392 {
393         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
394
395         RB_FLAG_SET(rbc->flag, value, RBC_FLAG_DISABLE_COLLISIONS);
396
397         rbc->flag |= RBC_FLAG_NEEDS_VALIDATE;
398 }
399
400 static void rna_RigidBodyCon_use_breaking_set(PointerRNA *ptr, int value)
401 {
402         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
403
404         if (value) {
405                 rbc->flag |= RBC_FLAG_USE_BREAKING;
406 #ifdef WITH_BULLET
407                 if (rbc->physics_constraint) {
408                         RB_constraint_set_breaking_threshold(rbc->physics_constraint, rbc->breaking_threshold);
409                 }
410 #endif
411         }
412         else {
413                 rbc->flag &= ~RBC_FLAG_USE_BREAKING;
414 #ifdef WITH_BULLET
415                 if (rbc->physics_constraint) {
416                         RB_constraint_set_breaking_threshold(rbc->physics_constraint, FLT_MAX);
417                 }
418 #endif
419         }
420 }
421
422 static void rna_RigidBodyCon_breaking_threshold_set(PointerRNA *ptr, float value)
423 {
424         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
425
426         rbc->breaking_threshold = value;
427
428 #ifdef WITH_BULLET
429         if (rbc->physics_constraint && (rbc->flag & RBC_FLAG_USE_BREAKING)) {
430                 RB_constraint_set_breaking_threshold(rbc->physics_constraint, value);
431         }
432 #endif
433 }
434
435 static void rna_RigidBodyCon_override_solver_iterations_set(PointerRNA *ptr, int value)
436 {
437         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
438
439         if (value) {
440                 rbc->flag |= RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS;
441 #ifdef WITH_BULLET
442                 if (rbc->physics_constraint) {
443                         RB_constraint_set_solver_iterations(rbc->physics_constraint, rbc->num_solver_iterations);
444                 }
445 #endif
446         }
447         else {
448                 rbc->flag &= ~RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS;
449 #ifdef WITH_BULLET
450                 if (rbc->physics_constraint) {
451                         RB_constraint_set_solver_iterations(rbc->physics_constraint, -1);
452                 }
453 #endif
454         }
455 }
456
457 static void rna_RigidBodyCon_num_solver_iterations_set(PointerRNA *ptr, int value)
458 {
459         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
460
461         rbc->num_solver_iterations = value;
462
463 #ifdef WITH_BULLET
464         if (rbc->physics_constraint && (rbc->flag & RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS)) {
465                 RB_constraint_set_solver_iterations(rbc->physics_constraint, value);
466         }
467 #endif
468 }
469
470 static void rna_RigidBodyCon_spring_stiffness_x_set(PointerRNA *ptr, float value)
471 {
472         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
473
474         rbc->spring_stiffness_x = value;
475
476 #ifdef WITH_BULLET
477         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_X)) {
478                 RB_constraint_set_stiffness_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_X, value);
479         }
480 #endif
481 }
482
483 static void rna_RigidBodyCon_spring_stiffness_y_set(PointerRNA *ptr, float value)
484 {
485         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
486
487         rbc->spring_stiffness_y = value;
488
489 #ifdef WITH_BULLET
490         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_Y)) {
491                 RB_constraint_set_stiffness_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_Y, value);
492         }
493 #endif
494 }
495
496 static void rna_RigidBodyCon_spring_stiffness_z_set(PointerRNA *ptr, float value)
497 {
498         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
499
500         rbc->spring_stiffness_z = value;
501
502 #ifdef WITH_BULLET
503         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_Z)) {
504                 RB_constraint_set_stiffness_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_Z, value);
505         }
506 #endif
507 }
508
509 static void rna_RigidBodyCon_spring_stiffness_ang_x_set(PointerRNA *ptr, float value)
510 {
511         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
512
513         rbc->spring_stiffness_ang_x = value;
514
515 #ifdef WITH_BULLET
516         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_ANG_X)) {
517                 RB_constraint_set_stiffness_6dof_spring(rbc->physics_constraint, RB_LIMIT_ANG_X, value);
518         }
519 #endif
520 }
521
522 static void rna_RigidBodyCon_spring_stiffness_ang_y_set(PointerRNA *ptr, float value)
523 {
524         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
525
526         rbc->spring_stiffness_ang_y = value;
527
528 #ifdef WITH_BULLET
529         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_ANG_Y)) {
530                 RB_constraint_set_stiffness_6dof_spring(rbc->physics_constraint, RB_LIMIT_ANG_Y, value);
531         }
532 #endif
533 }
534
535 static void rna_RigidBodyCon_spring_stiffness_ang_z_set(PointerRNA *ptr, float value)
536 {
537         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
538
539         rbc->spring_stiffness_ang_z = value;
540
541 #ifdef WITH_BULLET
542         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_ANG_Z)) {
543                 RB_constraint_set_stiffness_6dof_spring(rbc->physics_constraint, RB_LIMIT_ANG_Z, value);
544         }
545 #endif
546 }
547
548 static void rna_RigidBodyCon_spring_damping_x_set(PointerRNA *ptr, float value)
549 {
550         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
551
552         rbc->spring_damping_x = value;
553
554 #ifdef WITH_BULLET
555         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_X)) {
556                 RB_constraint_set_damping_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_X, value);
557         }
558 #endif
559 }
560
561 static void rna_RigidBodyCon_spring_damping_y_set(PointerRNA *ptr, float value)
562 {
563         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
564
565         rbc->spring_damping_y = value;
566 #ifdef WITH_BULLET
567         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_Y)) {
568                 RB_constraint_set_damping_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_Y, value);
569         }
570 #endif
571 }
572
573 static void rna_RigidBodyCon_spring_damping_z_set(PointerRNA *ptr, float value)
574 {
575         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
576
577         rbc->spring_damping_z = value;
578 #ifdef WITH_BULLET
579         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_Z)) {
580                 RB_constraint_set_damping_6dof_spring(rbc->physics_constraint, RB_LIMIT_LIN_Z, value);
581         }
582 #endif
583 }
584
585 static void rna_RigidBodyCon_spring_damping_ang_x_set(PointerRNA *ptr, float value)
586 {
587         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
588
589         rbc->spring_damping_ang_x = value;
590
591 #ifdef WITH_BULLET
592         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_ANG_X)) {
593                 RB_constraint_set_damping_6dof_spring(rbc->physics_constraint, RB_LIMIT_ANG_X, value);
594         }
595 #endif
596 }
597
598 static void rna_RigidBodyCon_spring_damping_ang_y_set(PointerRNA *ptr, float value)
599 {
600         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
601
602         rbc->spring_damping_ang_y = value;
603 #ifdef WITH_BULLET
604         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_ANG_Y)) {
605                 RB_constraint_set_damping_6dof_spring(rbc->physics_constraint, RB_LIMIT_ANG_Y, value);
606         }
607 #endif
608 }
609
610 static void rna_RigidBodyCon_spring_damping_ang_z_set(PointerRNA *ptr, float value)
611 {
612         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
613
614         rbc->spring_damping_ang_z = value;
615 #ifdef WITH_BULLET
616         if (rbc->physics_constraint && rbc->type == RBC_TYPE_6DOF_SPRING && (rbc->flag & RBC_FLAG_USE_SPRING_ANG_Z)) {
617                 RB_constraint_set_damping_6dof_spring(rbc->physics_constraint, RB_LIMIT_ANG_Z, value);
618         }
619 #endif
620 }
621
622 static void rna_RigidBodyCon_motor_lin_max_impulse_set(PointerRNA *ptr, float value)
623 {
624         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
625
626         rbc->motor_lin_max_impulse = value;
627
628 #ifdef WITH_BULLET
629         if (rbc->physics_constraint && rbc->type == RBC_TYPE_MOTOR) {
630                 RB_constraint_set_max_impulse_motor(rbc->physics_constraint, value, rbc->motor_ang_max_impulse);
631         }
632 #endif
633 }
634
635 static void rna_RigidBodyCon_use_motor_lin_set(PointerRNA *ptr, int value)
636 {
637         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
638
639         RB_FLAG_SET(rbc->flag, value, RBC_FLAG_USE_MOTOR_LIN);
640
641 #ifdef WITH_BULLET
642         if (rbc->physics_constraint) {
643                 RB_constraint_set_enable_motor(rbc->physics_constraint, rbc->flag & RBC_FLAG_USE_MOTOR_LIN, rbc->flag & RBC_FLAG_USE_MOTOR_ANG);
644         }
645 #endif
646 }
647
648 static void rna_RigidBodyCon_use_motor_ang_set(PointerRNA *ptr, int value)
649 {
650         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
651
652         RB_FLAG_SET(rbc->flag, value, RBC_FLAG_USE_MOTOR_ANG);
653
654 #ifdef WITH_BULLET
655         if (rbc->physics_constraint) {
656                 RB_constraint_set_enable_motor(rbc->physics_constraint, rbc->flag & RBC_FLAG_USE_MOTOR_LIN, rbc->flag & RBC_FLAG_USE_MOTOR_ANG);
657         }
658 #endif
659 }
660
661 static void rna_RigidBodyCon_motor_lin_target_velocity_set(PointerRNA *ptr, float value)
662 {
663         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
664
665         rbc->motor_lin_target_velocity = value;
666
667 #ifdef WITH_BULLET
668         if (rbc->physics_constraint && rbc->type == RBC_TYPE_MOTOR) {
669                 RB_constraint_set_target_velocity_motor(rbc->physics_constraint, value, rbc->motor_ang_target_velocity);
670         }
671 #endif
672 }
673
674 static void rna_RigidBodyCon_motor_ang_max_impulse_set(PointerRNA *ptr, float value)
675 {
676         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
677
678         rbc->motor_ang_max_impulse = value;
679
680 #ifdef WITH_BULLET
681         if (rbc->physics_constraint && rbc->type == RBC_TYPE_MOTOR) {
682                 RB_constraint_set_max_impulse_motor(rbc->physics_constraint, rbc->motor_lin_max_impulse, value);
683         }
684 #endif
685 }
686
687 static void rna_RigidBodyCon_motor_ang_target_velocity_set(PointerRNA *ptr, float value)
688 {
689         RigidBodyCon *rbc = (RigidBodyCon *)ptr->data;
690
691         rbc->motor_ang_target_velocity = value;
692
693 #ifdef WITH_BULLET
694         if (rbc->physics_constraint && rbc->type == RBC_TYPE_MOTOR) {
695                 RB_constraint_set_target_velocity_motor(rbc->physics_constraint, rbc->motor_lin_target_velocity, value);
696         }
697 #endif
698 }
699
700 /* Sweep test */
701 static void rna_RigidBodyWorld_convex_sweep_test(
702         RigidBodyWorld *rbw, ReportList *reports,
703         Object *object, float ray_start[3], float ray_end[3],
704         float r_location[3], float r_hitpoint[3], float r_normal[3], int *r_hit)
705 {
706 #ifdef WITH_BULLET
707         RigidBodyOb *rob = object->rigidbody_object;
708
709         if (rbw->physics_world != NULL && rob->physics_object != NULL) {
710                 RB_world_convex_sweep_test(rbw->physics_world, rob->physics_object, ray_start, ray_end,
711                                            r_location, r_hitpoint, r_normal, r_hit);
712                 if (*r_hit == -2) {
713                         BKE_report(reports, RPT_ERROR,
714                                    "A non convex collision shape was passed to the function, use only convex collision shapes");
715                 }
716         }
717         else {
718                 *r_hit = -1;
719                 BKE_report(reports, RPT_ERROR, "Rigidbody world was not properly initialized, need to step the simulation first");
720         }
721 #else
722         UNUSED_VARS(rbw, reports, object, ray_start, ray_end, r_location, r_hitpoint, r_normal, r_hit);
723 #endif
724 }
725
726 #else
727
728 static void rna_def_rigidbody_world(BlenderRNA *brna)
729 {
730         StructRNA *srna;
731         PropertyRNA *prop;
732
733         FunctionRNA *func;
734         PropertyRNA *parm;
735
736         srna = RNA_def_struct(brna, "RigidBodyWorld", NULL);
737         RNA_def_struct_sdna(srna, "RigidBodyWorld");
738         RNA_def_struct_ui_text(srna, "Rigid Body World", "Self-contained rigid body simulation environment and settings");
739         RNA_def_struct_path_func(srna, "rna_RigidBodyWorld_path");
740         
741         /* groups */
742         prop = RNA_def_property(srna, "group", PROP_POINTER, PROP_NONE);
743         RNA_def_property_struct_type(prop, "Group");
744         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
745         RNA_def_property_ui_text(prop, "Group", "Group containing objects participating in this simulation");
746         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
747
748         prop = RNA_def_property(srna, "constraints", PROP_POINTER, PROP_NONE);
749         RNA_def_property_struct_type(prop, "Group");
750         RNA_def_property_flag(prop, PROP_EDITABLE | PROP_ID_SELF_CHECK);
751         RNA_def_property_ui_text(prop, "Constraints", "Group containing rigid body constraint objects");
752         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
753         
754         /* booleans */
755         prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
756         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", RBW_FLAG_MUTED);
757         RNA_def_property_ui_text(prop, "Enabled", "Simulation will be evaluated");
758         RNA_def_property_update(prop, NC_SCENE, NULL);
759         
760         /* time scale */
761         prop = RNA_def_property(srna, "time_scale", PROP_FLOAT, PROP_NONE);
762         RNA_def_property_float_sdna(prop, NULL, "time_scale");
763         RNA_def_property_range(prop, 0.0f, 100.0f);
764         RNA_def_property_ui_range(prop, 0.0f, 10.0f, 1, 3);
765         RNA_def_property_float_default(prop, 1.0f);
766         RNA_def_property_ui_text(prop, "Time Scale", "Change the speed of the simulation");
767         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
768         
769         /* timestep */
770         prop = RNA_def_property(srna, "steps_per_second", PROP_INT, PROP_NONE);
771         RNA_def_property_int_sdna(prop, NULL, "steps_per_second");
772         RNA_def_property_range(prop, 1, SHRT_MAX);
773         RNA_def_property_ui_range(prop, 60, 1000, 1, -1);
774         RNA_def_property_int_default(prop, 60);
775         RNA_def_property_ui_text(prop, "Steps Per Second",
776                                  "Number of simulation steps taken per second (higher values are more accurate "
777                                  "but slower)");
778         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
779         
780         /* constraint solver iterations */
781         prop = RNA_def_property(srna, "solver_iterations", PROP_INT, PROP_NONE);
782         RNA_def_property_int_sdna(prop, NULL, "num_solver_iterations");
783         RNA_def_property_range(prop, 1, 1000);
784         RNA_def_property_ui_range(prop, 10, 100, 1, -1);
785         RNA_def_property_int_default(prop, 10);
786         RNA_def_property_int_funcs(prop, NULL, "rna_RigidBodyWorld_num_solver_iterations_set", NULL);
787         RNA_def_property_ui_text(prop, "Solver Iterations",
788                                  "Number of constraint solver iterations made per simulation step (higher values are more "
789                                  "accurate but slower)");
790         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
791         
792         /* split impulse */
793         prop = RNA_def_property(srna, "use_split_impulse", PROP_BOOLEAN, PROP_NONE);
794         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBW_FLAG_USE_SPLIT_IMPULSE);
795         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyWorld_split_impulse_set");
796         RNA_def_property_ui_text(prop, "Split Impulse",
797                                  "Reduce extra velocity that can build up when objects collide (lowers simulation "
798                                  "stability a little so use only when necessary)");
799         RNA_def_property_update(prop, NC_SCENE, "rna_RigidBodyWorld_reset");
800
801         /* cache */
802         prop = RNA_def_property(srna, "point_cache", PROP_POINTER, PROP_NONE);
803         RNA_def_property_flag(prop, PROP_NEVER_NULL);
804         RNA_def_property_pointer_sdna(prop, NULL, "pointcache");
805         RNA_def_property_ui_text(prop, "Point Cache", "");
806
807         /* effector weights */
808         prop = RNA_def_property(srna, "effector_weights", PROP_POINTER, PROP_NONE);
809         RNA_def_property_struct_type(prop, "EffectorWeights");
810         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
811         RNA_def_property_ui_text(prop, "Effector Weights", "");
812
813         /* Sweep test */
814         func = RNA_def_function(srna, "convex_sweep_test", "rna_RigidBodyWorld_convex_sweep_test");
815         RNA_def_function_ui_description(func, "Sweep test convex rigidbody against the current rigidbody world");
816         RNA_def_function_flag(func, FUNC_USE_REPORTS);
817         parm = RNA_def_pointer(func, "object", "Object", "", "Rigidbody object with a convex collision shape");
818         RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED);
819         RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);
820         /* ray start and end */
821         parm = RNA_def_float_vector(func, "start", 3, NULL, -FLT_MAX, FLT_MAX, "", "", -1e4, 1e4);
822         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
823         parm = RNA_def_float_vector(func, "end", 3, NULL, -FLT_MAX, FLT_MAX, "", "", -1e4, 1e4);
824         RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
825         parm = RNA_def_float_vector(func, "object_location", 3, NULL, -FLT_MAX, FLT_MAX, "Location",
826                                     "The hit location of this sweep test", -1e4, 1e4);
827         RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
828         RNA_def_function_output(func, parm);
829         parm = RNA_def_float_vector(func, "hitpoint", 3, NULL, -FLT_MAX, FLT_MAX, "Hitpoint",
830                                     "The hit location of this sweep test", -1e4, 1e4);
831         RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
832         RNA_def_function_output(func, parm);
833         parm = RNA_def_float_vector(func, "normal", 3, NULL, -FLT_MAX, FLT_MAX, "Normal",
834                                     "The face normal at the sweep test hit location", -1e4, 1e4);
835         RNA_def_parameter_flags(parm, PROP_THICK_WRAP, 0);
836         RNA_def_function_output(func, parm);
837         parm = RNA_def_int(func, "has_hit", 0, 0, 0, "", "If the function has found collision point, value is 1, otherwise 0", 0, 0);
838         RNA_def_function_output(func, parm);
839 }
840
841 static void rna_def_rigidbody_object(BlenderRNA *brna)
842 {
843         StructRNA *srna;
844         PropertyRNA *prop;
845         
846         
847         srna = RNA_def_struct(brna, "RigidBodyObject", NULL);
848         RNA_def_struct_sdna(srna, "RigidBodyOb");
849         RNA_def_struct_ui_text(srna, "Rigid Body Object", "Settings for object participating in Rigid Body Simulation");
850         RNA_def_struct_path_func(srna, "rna_RigidBodyOb_path");
851         
852         /* Enums */
853         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
854         RNA_def_property_enum_sdna(prop, NULL, "type");
855         RNA_def_property_enum_items(prop, rna_enum_rigidbody_object_type_items);
856         RNA_def_property_enum_funcs(prop, NULL, "rna_RigidBodyOb_type_set", NULL);
857         RNA_def_property_ui_text(prop, "Type", "Role of object in Rigid Body Simulations");
858         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
859         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
860         
861         prop = RNA_def_property(srna, "mesh_source", PROP_ENUM, PROP_NONE);
862         RNA_def_property_enum_sdna(prop, NULL, "mesh_source");
863         RNA_def_property_enum_items(prop, rigidbody_mesh_source_items);
864         RNA_def_property_ui_text(prop, "Mesh Source", "Source of the mesh used to create collision shape");
865         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
866         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
867         
868         /* booleans */
869         prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
870         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", RBO_FLAG_DISABLED);
871         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_disabled_set");
872         RNA_def_property_ui_text(prop, "Enabled", "Rigid Body actively participates to the simulation");
873         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
874         
875         prop = RNA_def_property(srna, "collision_shape", PROP_ENUM, PROP_NONE);
876         RNA_def_property_enum_sdna(prop, NULL, "shape");
877         RNA_def_property_enum_items(prop, rna_enum_rigidbody_object_shape_items);
878         RNA_def_property_enum_funcs(prop, NULL, "rna_RigidBodyOb_shape_set", NULL);
879         RNA_def_property_ui_text(prop, "Collision Shape", "Collision Shape of object in Rigid Body Simulations");
880         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
881         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_shape_update");
882         
883         prop = RNA_def_property(srna, "kinematic", PROP_BOOLEAN, PROP_NONE);
884         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_KINEMATIC);
885         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_kinematic_state_set");
886         RNA_def_property_ui_text(prop, "Kinematic", "Allow rigid body to be controlled by the animation system");
887         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
888         
889         prop = RNA_def_property(srna, "use_deform", PROP_BOOLEAN, PROP_NONE);
890         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_USE_DEFORM);
891         RNA_def_property_ui_text(prop, "Deforming", "Rigid body deforms during simulation");
892         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
893         
894         /* Physics Parameters */
895         prop = RNA_def_property(srna, "mass", PROP_FLOAT, PROP_UNIT_MASS);
896         RNA_def_property_float_sdna(prop, NULL, "mass");
897         RNA_def_property_range(prop, 0.001f, FLT_MAX); // range must always be positive (and non-zero)
898         RNA_def_property_float_default(prop, 1.0f);
899         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_mass_set", NULL);
900         RNA_def_property_ui_text(prop, "Mass", "How much the object 'weighs' irrespective of gravity");
901         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
902         
903         /* Dynamics Parameters - Activation */
904         // TODO: define and figure out how to implement these
905         
906         /* Dynamics Parameters - Deactivation */
907         prop = RNA_def_property(srna, "use_deactivation", PROP_BOOLEAN, PROP_NONE);
908         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_USE_DEACTIVATION);
909         RNA_def_property_boolean_default(prop, true);
910         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_activation_state_set");
911         RNA_def_property_ui_text(prop, "Enable Deactivation",
912                                  "Enable deactivation of resting rigid bodies (increases performance and stability "
913                                  "but can cause glitches)");
914         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
915         
916         prop = RNA_def_property(srna, "use_start_deactivated", PROP_BOOLEAN, PROP_NONE);
917         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_START_DEACTIVATED);
918         RNA_def_property_ui_text(prop, "Start Deactivated", "Deactivate rigid body at the start of the simulation");
919         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
920         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
921         
922         prop = RNA_def_property(srna, "deactivate_linear_velocity", PROP_FLOAT, PROP_UNIT_VELOCITY);
923         RNA_def_property_float_sdna(prop, NULL, "lin_sleep_thresh");
924         RNA_def_property_range(prop, FLT_MIN, FLT_MAX); // range must always be positive (and non-zero)
925         RNA_def_property_float_default(prop, 0.4f);
926         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_linear_sleepThresh_set", NULL);
927         RNA_def_property_ui_text(prop, "Linear Velocity Deactivation Threshold",
928                                  "Linear Velocity below which simulation stops simulating object");
929         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
930         
931         prop = RNA_def_property(srna, "deactivate_angular_velocity", PROP_FLOAT, PROP_UNIT_VELOCITY);
932         RNA_def_property_float_sdna(prop, NULL, "ang_sleep_thresh");
933         RNA_def_property_range(prop, FLT_MIN, FLT_MAX); // range must always be positive (and non-zero)
934         RNA_def_property_float_default(prop, 0.5f);
935         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_angular_sleepThresh_set", NULL);
936         RNA_def_property_ui_text(prop, "Angular Velocity Deactivation Threshold",
937                                  "Angular Velocity below which simulation stops simulating object");
938         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
939         
940         /* Dynamics Parameters - Damping Parameters */
941         prop = RNA_def_property(srna, "linear_damping", PROP_FLOAT, PROP_FACTOR);
942         RNA_def_property_float_sdna(prop, NULL, "lin_damping");
943         RNA_def_property_range(prop, 0.0f, 1.0f);
944         RNA_def_property_float_default(prop, 0.04f);
945         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_linear_damping_set", NULL);
946         RNA_def_property_ui_text(prop, "Linear Damping", "Amount of linear velocity that is lost over time");
947         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
948         
949         prop = RNA_def_property(srna, "angular_damping", PROP_FLOAT, PROP_FACTOR);
950         RNA_def_property_float_sdna(prop, NULL, "ang_damping");
951         RNA_def_property_range(prop, 0.0f, 1.0f);
952         RNA_def_property_float_default(prop, 0.1f);
953         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_angular_damping_set", NULL);
954         RNA_def_property_ui_text(prop, "Angular Damping", "Amount of angular velocity that is lost over time");
955         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
956         
957         /* Collision Parameters - Surface Parameters */
958         prop = RNA_def_property(srna, "friction", PROP_FLOAT, PROP_FACTOR);
959         RNA_def_property_float_sdna(prop, NULL, "friction");
960         RNA_def_property_range(prop, 0.0f, FLT_MAX);
961         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 1, 3);
962         RNA_def_property_float_default(prop, 0.5f);
963         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_friction_set", NULL);
964         RNA_def_property_ui_text(prop, "Friction", "Resistance of object to movement");
965         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
966         
967         prop = RNA_def_property(srna, "restitution", PROP_FLOAT, PROP_FACTOR);
968         RNA_def_property_float_sdna(prop, NULL, "restitution");
969         RNA_def_property_range(prop, 0.0f, FLT_MAX);
970         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 1, 3);
971         RNA_def_property_float_default(prop, 0.0f);
972         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_restitution_set", NULL);
973         RNA_def_property_ui_text(prop, "Restitution",
974                                  "Tendency of object to bounce after colliding with another "
975                                  "(0 = stays still, 1 = perfectly elastic)");
976         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
977         
978         /* Collision Parameters - Sensitivity */
979         prop = RNA_def_property(srna, "use_margin", PROP_BOOLEAN, PROP_NONE);
980         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBO_FLAG_USE_MARGIN);
981         RNA_def_property_boolean_default(prop, false);
982         RNA_def_property_ui_text(prop, "Collision Margin",
983                                  "Use custom collision margin (some shapes will have a visible gap around them)");
984         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_shape_reset");
985         
986         prop = RNA_def_property(srna, "collision_margin", PROP_FLOAT, PROP_UNIT_LENGTH);
987         RNA_def_property_float_sdna(prop, NULL, "margin");
988         RNA_def_property_range(prop, 0.0f, 1.0f);
989         RNA_def_property_ui_range(prop, 0.0f, 1.0f, 0.01, 3);
990         RNA_def_property_float_default(prop, 0.04f);
991         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyOb_collision_margin_set", NULL);
992         RNA_def_property_ui_text(prop, "Collision Margin",
993                                  "Threshold of distance near surface where collisions are still considered "
994                                  "(best results when non-zero)");
995         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_shape_reset");
996         
997         prop = RNA_def_property(srna, "collision_groups", PROP_BOOLEAN, PROP_LAYER_MEMBER);
998         RNA_def_property_boolean_sdna(prop, NULL, "col_groups", 1);
999         RNA_def_property_array(prop, 20);
1000         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyOb_collision_groups_set");
1001         RNA_def_property_ui_text(prop, "Collision Groups", "Collision Groups Rigid Body belongs to");
1002         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
1003         RNA_def_property_flag(prop, PROP_LIB_EXCEPTION);
1004 }
1005
1006 static void rna_def_rigidbody_constraint(BlenderRNA *brna)
1007 {
1008         StructRNA *srna;
1009         PropertyRNA *prop;
1010
1011         srna = RNA_def_struct(brna, "RigidBodyConstraint", NULL);
1012         RNA_def_struct_sdna(srna, "RigidBodyCon");
1013         RNA_def_struct_ui_text(srna, "Rigid Body Constraint",
1014                                "Constraint influencing Objects inside Rigid Body Simulation");
1015         RNA_def_struct_path_func(srna, "rna_RigidBodyCon_path");
1016
1017         /* Enums */
1018         prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1019         RNA_def_property_enum_sdna(prop, NULL, "type");
1020         RNA_def_property_enum_items(prop, rna_enum_rigidbody_constraint_type_items);
1021         RNA_def_property_enum_funcs(prop, NULL, "rna_RigidBodyCon_type_set", NULL);
1022         RNA_def_property_ui_text(prop, "Type", "Type of Rigid Body Constraint");
1023         RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
1024         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
1025
1026         prop = RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
1027         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_ENABLED);
1028         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_enabled_set");
1029         RNA_def_property_ui_text(prop, "Enabled", "Enable this constraint");
1030         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
1031
1032         prop = RNA_def_property(srna, "disable_collisions", PROP_BOOLEAN, PROP_NONE);
1033         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_DISABLE_COLLISIONS);
1034         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_disable_collisions_set");
1035         RNA_def_property_ui_text(prop, "Disable Collisions", "Disable collisions between constrained rigid bodies");
1036         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
1037
1038         prop = RNA_def_property(srna, "object1", PROP_POINTER, PROP_NONE);
1039         RNA_def_property_pointer_sdna(prop, NULL, "ob1");
1040         RNA_def_property_flag(prop, PROP_EDITABLE);
1041         RNA_def_property_ui_text(prop, "Object 1", "First Rigid Body Object to be constrained");
1042         RNA_def_property_flag(prop, PROP_EDITABLE);
1043         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
1044
1045         prop = RNA_def_property(srna, "object2", PROP_POINTER, PROP_NONE);
1046         RNA_def_property_pointer_sdna(prop, NULL, "ob2");
1047         RNA_def_property_flag(prop, PROP_EDITABLE);
1048         RNA_def_property_ui_text(prop, "Object 2", "Second Rigid Body Object to be constrained");
1049         RNA_def_property_flag(prop, PROP_EDITABLE);
1050         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
1051
1052         /* Breaking Threshold */
1053         prop = RNA_def_property(srna, "use_breaking", PROP_BOOLEAN, PROP_NONE);
1054         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_BREAKING);
1055         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_use_breaking_set");
1056         RNA_def_property_ui_text(prop, "Breakable",
1057                                  "Constraint can be broken if it receives an impulse above the threshold");
1058         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
1059
1060         prop = RNA_def_property(srna, "breaking_threshold", PROP_FLOAT, PROP_NONE);
1061         RNA_def_property_float_sdna(prop, NULL, "breaking_threshold");
1062         RNA_def_property_range(prop, 0.0f, FLT_MAX);
1063         RNA_def_property_ui_range(prop, 0.0f, 1000.0f, 100.0, 2);
1064         RNA_def_property_float_default(prop, 10.0f);
1065         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_breaking_threshold_set", NULL);
1066         RNA_def_property_ui_text(prop, "Breaking Threshold",
1067                                  "Impulse threshold that must be reached for the constraint to break");
1068         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
1069
1070         /* Solver Iterations */
1071         prop = RNA_def_property(srna, "use_override_solver_iterations", PROP_BOOLEAN, PROP_NONE);
1072         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS);
1073         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_override_solver_iterations_set");
1074         RNA_def_property_ui_text(prop, "Override Solver Iterations",
1075                                  "Override the number of solver iterations for this constraint");
1076         RNA_def_property_update(prop, NC_OBJECT | ND_POINTCACHE, "rna_RigidBodyOb_reset");
1077
1078         prop = RNA_def_property(srna, "solver_iterations", PROP_INT, PROP_NONE);
1079         RNA_def_property_int_sdna(prop, NULL, "num_solver_iterations");
1080         RNA_def_property_range(prop, 1, 1000);
1081         RNA_def_property_ui_range(prop, 1, 100, 1, -1);
1082         RNA_def_property_int_default(prop, 10);
1083         RNA_def_property_int_funcs(prop, NULL, "rna_RigidBodyCon_num_solver_iterations_set", NULL);
1084         RNA_def_property_ui_text(prop, "Solver Iterations",
1085                                  "Number of constraint solver iterations made per simulation step (higher values are more "
1086                                  "accurate but slower)");
1087         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1088
1089         /* Limits */
1090         prop = RNA_def_property(srna, "use_limit_lin_x", PROP_BOOLEAN, PROP_NONE);
1091         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_LIN_X);
1092         RNA_def_property_ui_text(prop, "X Axis", "Limit translation on X axis");
1093         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1094
1095         prop = RNA_def_property(srna, "use_limit_lin_y", PROP_BOOLEAN, PROP_NONE);
1096         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_LIN_Y);
1097         RNA_def_property_ui_text(prop, "Y Axis", "Limit translation on Y axis");
1098         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1099
1100         prop = RNA_def_property(srna, "use_limit_lin_z", PROP_BOOLEAN, PROP_NONE);
1101         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_LIN_Z);
1102         RNA_def_property_ui_text(prop, "Z Axis", "Limit translation on Z axis");
1103         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1104
1105         prop = RNA_def_property(srna, "use_limit_ang_x", PROP_BOOLEAN, PROP_NONE);
1106         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_ANG_X);
1107         RNA_def_property_ui_text(prop, "X Angle", "Limit rotation around X axis");
1108         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1109
1110         prop = RNA_def_property(srna, "use_limit_ang_y", PROP_BOOLEAN, PROP_NONE);
1111         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_ANG_Y);
1112         RNA_def_property_ui_text(prop, "Y Angle", "Limit rotation around Y axis");
1113         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1114
1115         prop = RNA_def_property(srna, "use_limit_ang_z", PROP_BOOLEAN, PROP_NONE);
1116         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_LIMIT_ANG_Z);
1117         RNA_def_property_ui_text(prop, "Z Angle", "Limit rotation around Z axis");
1118         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1119
1120         prop = RNA_def_property(srna, "use_spring_x", PROP_BOOLEAN, PROP_NONE);
1121         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_SPRING_X);
1122         RNA_def_property_ui_text(prop, "X Spring", "Enable spring on X axis");
1123         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1124
1125         prop = RNA_def_property(srna, "use_spring_y", PROP_BOOLEAN, PROP_NONE);
1126         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_SPRING_Y);
1127         RNA_def_property_ui_text(prop, "Y Spring", "Enable spring on Y axis");
1128         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1129
1130         prop = RNA_def_property(srna, "use_spring_z", PROP_BOOLEAN, PROP_NONE);
1131         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_SPRING_Z);
1132         RNA_def_property_ui_text(prop, "Z Spring", "Enable spring on Z axis");
1133         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1134
1135         prop = RNA_def_property(srna, "use_spring_ang_x", PROP_BOOLEAN, PROP_NONE);
1136         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_SPRING_ANG_X);
1137         RNA_def_property_ui_text(prop, "X Angle Spring", "Enable spring on X rotational axis");
1138         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1139
1140         prop = RNA_def_property(srna, "use_spring_ang_y", PROP_BOOLEAN, PROP_NONE);
1141         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_SPRING_ANG_Y);
1142         RNA_def_property_ui_text(prop, "Y Angle Spring", "Enable spring on Y rotational axis");
1143         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1144
1145         prop = RNA_def_property(srna, "use_spring_ang_z", PROP_BOOLEAN, PROP_NONE);
1146         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_SPRING_ANG_Z);
1147         RNA_def_property_ui_text(prop, "Z Angle Spring", "Enable spring on Z rotational axis");
1148         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1149
1150         prop = RNA_def_property(srna, "use_motor_lin", PROP_BOOLEAN, PROP_NONE);
1151         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_MOTOR_LIN);
1152         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_use_motor_lin_set");
1153         RNA_def_property_ui_text(prop, "Linear Motor", "Enable linear motor");
1154         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1155
1156         prop = RNA_def_property(srna, "use_motor_ang", PROP_BOOLEAN, PROP_NONE);
1157         RNA_def_property_boolean_sdna(prop, NULL, "flag", RBC_FLAG_USE_MOTOR_ANG);
1158         RNA_def_property_boolean_funcs(prop, NULL, "rna_RigidBodyCon_use_motor_ang_set");
1159         RNA_def_property_ui_text(prop, "Angular Motor", "Enable angular motor");
1160         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1161
1162         prop = RNA_def_property(srna, "limit_lin_x_lower", PROP_FLOAT, PROP_UNIT_LENGTH);
1163         RNA_def_property_float_sdna(prop, NULL, "limit_lin_x_lower");
1164         RNA_def_property_float_default(prop, -1.0f);
1165         RNA_def_property_ui_text(prop, "Lower X Limit", "Lower limit of X axis translation");
1166         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1167
1168         prop = RNA_def_property(srna, "limit_lin_x_upper", PROP_FLOAT, PROP_UNIT_LENGTH);
1169         RNA_def_property_float_sdna(prop, NULL, "limit_lin_x_upper");
1170         RNA_def_property_float_default(prop, 1.0f);
1171         RNA_def_property_ui_text(prop, "Upper X Limit", "Upper limit of X axis translation");
1172         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1173
1174         prop = RNA_def_property(srna, "limit_lin_y_lower", PROP_FLOAT, PROP_UNIT_LENGTH);
1175         RNA_def_property_float_sdna(prop, NULL, "limit_lin_y_lower");
1176         RNA_def_property_float_default(prop, -1.0f);
1177         RNA_def_property_ui_text(prop, "Lower Y Limit", "Lower limit of Y axis translation");
1178         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1179
1180         prop = RNA_def_property(srna, "limit_lin_y_upper", PROP_FLOAT, PROP_UNIT_LENGTH);
1181         RNA_def_property_float_sdna(prop, NULL, "limit_lin_y_upper");
1182         RNA_def_property_float_default(prop, 1.0f);
1183         RNA_def_property_ui_text(prop, "Upper Y Limit", "Upper limit of Y axis translation");
1184         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1185
1186         prop = RNA_def_property(srna, "limit_lin_z_lower", PROP_FLOAT, PROP_UNIT_LENGTH);
1187         RNA_def_property_float_sdna(prop, NULL, "limit_lin_z_lower");
1188         RNA_def_property_float_default(prop, -1.0f);
1189         RNA_def_property_ui_text(prop, "Lower Z Limit", "Lower limit of Z axis translation");
1190         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1191
1192         prop = RNA_def_property(srna, "limit_lin_z_upper", PROP_FLOAT, PROP_UNIT_LENGTH);
1193         RNA_def_property_float_sdna(prop, NULL, "limit_lin_z_upper");
1194         RNA_def_property_float_default(prop, 1.0f);
1195         RNA_def_property_ui_text(prop, "Upper Z Limit", "Upper limit of Z axis translation");
1196         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1197
1198         prop = RNA_def_property(srna, "limit_ang_x_lower", PROP_FLOAT, PROP_ANGLE);
1199         RNA_def_property_float_sdna(prop, NULL, "limit_ang_x_lower");
1200         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
1201         RNA_def_property_float_default(prop, -M_PI_4);
1202         RNA_def_property_ui_text(prop, "Lower X Angle Limit", "Lower limit of X axis rotation");
1203         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1204
1205         prop = RNA_def_property(srna, "limit_ang_x_upper", PROP_FLOAT, PROP_ANGLE);
1206         RNA_def_property_float_sdna(prop, NULL, "limit_ang_x_upper");
1207         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
1208         RNA_def_property_float_default(prop, M_PI_4);
1209         RNA_def_property_ui_text(prop, "Upper X Angle Limit", "Upper limit of X axis rotation");
1210         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1211
1212         prop = RNA_def_property(srna, "limit_ang_y_lower", PROP_FLOAT, PROP_ANGLE);
1213         RNA_def_property_float_sdna(prop, NULL, "limit_ang_y_lower");
1214         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
1215         RNA_def_property_float_default(prop, -M_PI_4);
1216         RNA_def_property_ui_text(prop, "Lower Y Angle Limit", "Lower limit of Y axis rotation");
1217         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1218
1219         prop = RNA_def_property(srna, "limit_ang_y_upper", PROP_FLOAT, PROP_ANGLE);
1220         RNA_def_property_float_sdna(prop, NULL, "limit_ang_y_upper");
1221         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
1222         RNA_def_property_float_default(prop, M_PI_4);
1223         RNA_def_property_ui_text(prop, "Upper Y Angle Limit", "Upper limit of Y axis rotation");
1224         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1225
1226         prop = RNA_def_property(srna, "limit_ang_z_lower", PROP_FLOAT, PROP_ANGLE);
1227         RNA_def_property_float_sdna(prop, NULL, "limit_ang_z_lower");
1228         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
1229         RNA_def_property_float_default(prop, -M_PI_4);
1230         RNA_def_property_ui_text(prop, "Lower Z Angle Limit", "Lower limit of Z axis rotation");
1231         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1232
1233         prop = RNA_def_property(srna, "limit_ang_z_upper", PROP_FLOAT, PROP_ANGLE);
1234         RNA_def_property_float_sdna(prop, NULL, "limit_ang_z_upper");
1235         RNA_def_property_range(prop, -M_PI * 2, M_PI * 2);
1236         RNA_def_property_float_default(prop, M_PI_4);
1237         RNA_def_property_ui_text(prop, "Upper Z Angle Limit", "Upper limit of Z axis rotation");
1238         RNA_def_property_update(prop, NC_OBJECT | ND_DRAW, "rna_RigidBodyOb_reset");
1239
1240         prop = RNA_def_property(srna, "spring_stiffness_x", PROP_FLOAT, PROP_NONE);
1241         RNA_def_property_float_sdna(prop, NULL, "spring_stiffness_x");
1242         RNA_def_property_range(prop, 0.0f, FLT_MAX);
1243         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3);
1244         RNA_def_property_float_default(prop, 10.0f);
1245         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_stiffness_x_set", NULL);
1246         RNA_def_property_ui_text(prop, "X Axis Stiffness", "Stiffness on the X axis");
1247         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1248
1249         prop = RNA_def_property(srna, "spring_stiffness_y", PROP_FLOAT, PROP_NONE);
1250         RNA_def_property_float_sdna(prop, NULL, "spring_stiffness_y");
1251         RNA_def_property_range(prop, 0.0f, FLT_MAX);
1252         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3);
1253         RNA_def_property_float_default(prop, 10.0f);
1254         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_stiffness_y_set", NULL);
1255         RNA_def_property_ui_text(prop, "Y Axis Stiffness", "Stiffness on the Y axis");
1256         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1257
1258         prop = RNA_def_property(srna, "spring_stiffness_z", PROP_FLOAT, PROP_NONE);
1259         RNA_def_property_float_sdna(prop, NULL, "spring_stiffness_z");
1260         RNA_def_property_range(prop, 0.0f, FLT_MAX);
1261         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3);
1262         RNA_def_property_float_default(prop, 10.0f);
1263         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_stiffness_z_set", NULL);
1264         RNA_def_property_ui_text(prop, "Z Axis Stiffness", "Stiffness on the Z axis");
1265         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1266
1267         prop = RNA_def_property(srna, "spring_stiffness_ang_x", PROP_FLOAT, PROP_NONE);
1268         RNA_def_property_float_sdna(prop, NULL, "spring_stiffness_ang_x");
1269         RNA_def_property_range(prop, 0.0f, FLT_MAX);
1270         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3);
1271         RNA_def_property_float_default(prop, 10.0f);
1272         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_stiffness_ang_x_set", NULL);
1273         RNA_def_property_ui_text(prop, "X Angle Stiffness", "Stiffness on the X rotational axis");
1274         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1275
1276         prop = RNA_def_property(srna, "spring_stiffness_ang_y", PROP_FLOAT, PROP_NONE);
1277         RNA_def_property_float_sdna(prop, NULL, "spring_stiffness_ang_y");
1278         RNA_def_property_range(prop, 0.0f, FLT_MAX);
1279         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3);
1280         RNA_def_property_float_default(prop, 10.0f);
1281         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_stiffness_ang_y_set", NULL);
1282         RNA_def_property_ui_text(prop, "Y Angle Stiffness", "Stiffness on the Y rotational axis");
1283         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1284
1285         prop = RNA_def_property(srna, "spring_stiffness_ang_z", PROP_FLOAT, PROP_NONE);
1286         RNA_def_property_float_sdna(prop, NULL, "spring_stiffness_ang_z");
1287         RNA_def_property_range(prop, 0.0f, FLT_MAX);
1288         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3);
1289         RNA_def_property_float_default(prop, 10.0f);
1290         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_stiffness_ang_z_set", NULL);
1291         RNA_def_property_ui_text(prop, "Z Angle Stiffness", "Stiffness on the Z rotational axis");
1292         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1293
1294         prop = RNA_def_property(srna, "spring_damping_x", PROP_FLOAT, PROP_FACTOR);
1295         RNA_def_property_float_sdna(prop, NULL, "spring_damping_x");
1296         RNA_def_property_range(prop, 0.0f, 1.0f);
1297         RNA_def_property_float_default(prop, 0.5f);
1298         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_damping_x_set", NULL);
1299         RNA_def_property_ui_text(prop, "Damping X", "Damping on the X axis");
1300         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1301
1302         prop = RNA_def_property(srna, "spring_damping_y", PROP_FLOAT, PROP_FACTOR);
1303         RNA_def_property_float_sdna(prop, NULL, "spring_damping_y");
1304         RNA_def_property_range(prop, 0.0f, 1.0f);
1305         RNA_def_property_float_default(prop, 0.5f);
1306         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_damping_y_set", NULL);
1307         RNA_def_property_ui_text(prop, "Damping Y", "Damping on the Y axis");
1308         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1309
1310         prop = RNA_def_property(srna, "spring_damping_z", PROP_FLOAT, PROP_FACTOR);
1311         RNA_def_property_float_sdna(prop, NULL, "spring_damping_z");
1312         RNA_def_property_range(prop, 0.0f, 1.0f);
1313         RNA_def_property_float_default(prop, 0.5f);
1314         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_damping_z_set", NULL);
1315         RNA_def_property_ui_text(prop, "Damping Z", "Damping on the Z axis");
1316         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1317
1318         prop = RNA_def_property(srna, "spring_damping_ang_x", PROP_FLOAT, PROP_FACTOR);
1319         RNA_def_property_float_sdna(prop, NULL, "spring_damping_ang_x");
1320         RNA_def_property_range(prop, 0.0f, 1.0f);
1321         RNA_def_property_float_default(prop, 0.5f);
1322         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_damping_ang_x_set", NULL);
1323         RNA_def_property_ui_text(prop, "Damping X Angle", "Damping on the X rotational axis");
1324         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1325
1326         prop = RNA_def_property(srna, "spring_damping_ang_y", PROP_FLOAT, PROP_FACTOR);
1327         RNA_def_property_float_sdna(prop, NULL, "spring_damping_ang_y");
1328         RNA_def_property_range(prop, 0.0f, 1.0f);
1329         RNA_def_property_float_default(prop, 0.5f);
1330         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_damping_ang_y_set", NULL);
1331         RNA_def_property_ui_text(prop, "Damping Y Angle", "Damping on the Y rotational axis");
1332         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1333
1334         prop = RNA_def_property(srna, "spring_damping_ang_z", PROP_FLOAT, PROP_FACTOR);
1335         RNA_def_property_float_sdna(prop, NULL, "spring_damping_ang_z");
1336         RNA_def_property_range(prop, 0.0f, 1.0f);
1337         RNA_def_property_float_default(prop, 0.5f);
1338         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_spring_damping_ang_z_set", NULL);
1339         RNA_def_property_ui_text(prop, "Damping Z Angle", "Damping on the Z rotational axis");
1340         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1341
1342         prop = RNA_def_property(srna, "motor_lin_target_velocity", PROP_FLOAT, PROP_UNIT_VELOCITY);
1343         RNA_def_property_float_sdna(prop, NULL, "motor_lin_target_velocity");
1344         RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
1345         RNA_def_property_ui_range(prop, -100.0f, 100.0f, 1, 3);
1346         RNA_def_property_float_default(prop, 1.0f);
1347         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_motor_lin_target_velocity_set", NULL);
1348         RNA_def_property_ui_text(prop, "Target Velocity", "Target linear motor velocity");
1349         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1350
1351         prop = RNA_def_property(srna, "motor_lin_max_impulse", PROP_FLOAT, PROP_NONE);
1352         RNA_def_property_float_sdna(prop, NULL, "motor_lin_max_impulse");
1353         RNA_def_property_range(prop, 0.0f, FLT_MAX);
1354         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3);
1355         RNA_def_property_float_default(prop, 1.0f);
1356         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_motor_lin_max_impulse_set", NULL);
1357         RNA_def_property_ui_text(prop, "Max Impulse", "Maximum linear motor impulse");
1358         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1359
1360         prop = RNA_def_property(srna, "motor_ang_target_velocity", PROP_FLOAT, PROP_NONE);
1361         RNA_def_property_float_sdna(prop, NULL, "motor_ang_target_velocity");
1362         RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);
1363         RNA_def_property_ui_range(prop, -100.0f, 100.0f, 1, 3);
1364         RNA_def_property_float_default(prop, 1.0f);
1365         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_motor_ang_target_velocity_set", NULL);
1366         RNA_def_property_ui_text(prop, "Target Velocity", "Target angular motor velocity");
1367         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1368
1369         prop = RNA_def_property(srna, "motor_ang_max_impulse", PROP_FLOAT, PROP_NONE);
1370         RNA_def_property_float_sdna(prop, NULL, "motor_ang_max_impulse");
1371         RNA_def_property_range(prop, 0.0f, FLT_MAX);
1372         RNA_def_property_ui_range(prop, 0.0f, 100.0f, 1, 3);
1373         RNA_def_property_float_default(prop, 1.0f);
1374         RNA_def_property_float_funcs(prop, NULL, "rna_RigidBodyCon_motor_ang_max_impulse_set", NULL);
1375         RNA_def_property_ui_text(prop, "Max Impulse", "Maximum angular motor impulse");
1376         RNA_def_property_update(prop, NC_OBJECT, "rna_RigidBodyOb_reset");
1377 }
1378
1379 void RNA_def_rigidbody(BlenderRNA *brna)
1380 {
1381         rna_def_rigidbody_world(brna);
1382         rna_def_rigidbody_object(brna);
1383         rna_def_rigidbody_constraint(brna);
1384 }
1385
1386
1387 #endif