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