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