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