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