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