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