Cleanup: style, use braces for blenkernel
[blender.git] / source / blender / blenkernel / intern / rigidbody.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2013 Blender Foundation
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup blenkernel
22  * \brief Blender-side interface and methods for dealing with Rigid Body simulations
23  */
24
25 #include <stdio.h>
26 #include <string.h>
27 #include <stddef.h>
28 #include <float.h>
29 #include <math.h>
30 #include <limits.h>
31
32 #include "CLG_log.h"
33
34 #include "MEM_guardedalloc.h"
35
36 #include "BLI_math.h"
37
38 #ifdef WITH_BULLET
39 #  include "RBI_api.h"
40 #endif
41
42 #include "DNA_ID.h"
43 #include "DNA_collection_types.h"
44 #include "DNA_mesh_types.h"
45 #include "DNA_meshdata_types.h"
46 #include "DNA_object_types.h"
47 #include "DNA_object_force_types.h"
48 #include "DNA_rigidbody_types.h"
49 #include "DNA_scene_types.h"
50
51 #include "BKE_collection.h"
52 #include "BKE_effect.h"
53 #include "BKE_layer.h"
54 #include "BKE_main.h"
55 #include "BKE_mesh.h"
56 #include "BKE_mesh_runtime.h"
57 #include "BKE_object.h"
58 #include "BKE_pointcache.h"
59 #include "BKE_rigidbody.h"
60 #include "BKE_scene.h"
61 #ifdef WITH_BULLET
62 #  include "BKE_global.h"
63 #  include "BKE_library.h"
64 #  include "BKE_library_query.h"
65 #endif
66
67 #include "DEG_depsgraph.h"
68 #include "DEG_depsgraph_query.h"
69
70 #ifdef WITH_BULLET
71 static CLG_LogRef LOG = {"bke.rigidbody"};
72 #endif
73
74 /* ************************************** */
75 /* Memory Management */
76
77 /* Freeing Methods --------------------- */
78
79 #ifdef WITH_BULLET
80 static void rigidbody_update_ob_array(RigidBodyWorld *rbw);
81
82 #else
83 static void RB_dworld_remove_constraint(void *UNUSED(world), void *UNUSED(con))
84 {
85 }
86 static void RB_dworld_remove_body(void *UNUSED(world), void *UNUSED(body))
87 {
88 }
89 static void RB_dworld_delete(void *UNUSED(world))
90 {
91 }
92 static void RB_body_delete(void *UNUSED(body))
93 {
94 }
95 static void RB_shape_delete(void *UNUSED(shape))
96 {
97 }
98 static void RB_constraint_delete(void *UNUSED(con))
99 {
100 }
101
102 #endif
103
104 /* Free rigidbody world */
105 void BKE_rigidbody_free_world(Scene *scene)
106 {
107   bool is_orig = (scene->id.tag & LIB_TAG_COPIED_ON_WRITE) == 0;
108   RigidBodyWorld *rbw = scene->rigidbody_world;
109   scene->rigidbody_world = NULL;
110
111   /* sanity check */
112   if (!rbw) {
113     return;
114   }
115
116   if (is_orig && rbw->shared->physics_world) {
117     /* free physics references, we assume that all physics objects in will have been added to the world */
118     if (rbw->constraints) {
119       FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (rbw->constraints, object) {
120         if (object->rigidbody_constraint) {
121           RigidBodyCon *rbc = object->rigidbody_constraint;
122           if (rbc->physics_constraint) {
123             RB_dworld_remove_constraint(rbw->shared->physics_world, rbc->physics_constraint);
124           }
125         }
126       }
127       FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
128     }
129
130     if (rbw->group) {
131       FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (rbw->group, object) {
132         BKE_rigidbody_free_object(object, rbw);
133       }
134       FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
135     }
136     /* free dynamics world */
137     RB_dworld_delete(rbw->shared->physics_world);
138   }
139   if (rbw->objects) {
140     free(rbw->objects);
141   }
142
143   if (is_orig) {
144     /* free cache */
145     BKE_ptcache_free_list(&(rbw->shared->ptcaches));
146     rbw->shared->pointcache = NULL;
147
148     MEM_freeN(rbw->shared);
149   }
150
151   /* free effector weights */
152   if (rbw->effector_weights) {
153     MEM_freeN(rbw->effector_weights);
154   }
155
156   /* free rigidbody world itself */
157   MEM_freeN(rbw);
158 }
159
160 /* Free RigidBody settings and sim instances */
161 void BKE_rigidbody_free_object(Object *ob, RigidBodyWorld *rbw)
162 {
163   bool is_orig = (ob->id.tag & LIB_TAG_COPIED_ON_WRITE) == 0;
164   RigidBodyOb *rbo = ob->rigidbody_object;
165
166   /* sanity check */
167   if (rbo == NULL) {
168     return;
169   }
170
171   /* free physics references */
172   if (is_orig) {
173     if (rbo->shared->physics_object) {
174       BLI_assert(rbw);
175       if (rbw) {
176         /* We can only remove the body from the world if the world is known.
177          * The world is generally only unknown if it's an evaluated copy of
178          * an object that's being freed, in which case this code isn't run anyway. */
179         RB_dworld_remove_body(rbw->shared->physics_world, rbo->shared->physics_object);
180       }
181
182       RB_body_delete(rbo->shared->physics_object);
183       rbo->shared->physics_object = NULL;
184     }
185
186     if (rbo->shared->physics_shape) {
187       RB_shape_delete(rbo->shared->physics_shape);
188       rbo->shared->physics_shape = NULL;
189     }
190
191     MEM_freeN(rbo->shared);
192   }
193
194   /* free data itself */
195   MEM_freeN(rbo);
196   ob->rigidbody_object = NULL;
197 }
198
199 /* Free RigidBody constraint and sim instance */
200 void BKE_rigidbody_free_constraint(Object *ob)
201 {
202   RigidBodyCon *rbc = (ob) ? ob->rigidbody_constraint : NULL;
203
204   /* sanity check */
205   if (rbc == NULL) {
206     return;
207   }
208
209   /* free physics reference */
210   if (rbc->physics_constraint) {
211     RB_constraint_delete(rbc->physics_constraint);
212     rbc->physics_constraint = NULL;
213   }
214
215   /* free data itself */
216   MEM_freeN(rbc);
217   ob->rigidbody_constraint = NULL;
218 }
219
220 #ifdef WITH_BULLET
221
222 /* Copying Methods --------------------- */
223
224 /* These just copy the data, clearing out references to physics objects.
225  * Anything that uses them MUST verify that the copied object will
226  * be added to relevant groups later...
227  */
228
229 RigidBodyOb *BKE_rigidbody_copy_object(const Object *ob, const int flag)
230 {
231   RigidBodyOb *rboN = NULL;
232
233   if (ob->rigidbody_object) {
234     /* just duplicate the whole struct first (to catch all the settings) */
235     rboN = MEM_dupallocN(ob->rigidbody_object);
236
237     if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) {
238       /* This is a regular copy, and not a CoW copy for depsgraph evaluation */
239       rboN->shared = MEM_callocN(sizeof(*rboN->shared), "RigidBodyOb_Shared");
240     }
241
242     /* tag object as needing to be verified */
243     rboN->flag |= RBO_FLAG_NEEDS_VALIDATE;
244   }
245
246   /* return new copy of settings */
247   return rboN;
248 }
249
250 RigidBodyCon *BKE_rigidbody_copy_constraint(const Object *ob, const int UNUSED(flag))
251 {
252   RigidBodyCon *rbcN = NULL;
253
254   if (ob->rigidbody_constraint) {
255     /* just duplicate the whole struct first (to catch all the settings) */
256     rbcN = MEM_dupallocN(ob->rigidbody_constraint);
257
258     /* tag object as needing to be verified */
259     rbcN->flag |= RBC_FLAG_NEEDS_VALIDATE;
260
261     /* clear out all the fields which need to be revalidated later */
262     rbcN->physics_constraint = NULL;
263   }
264
265   /* return new copy of settings */
266   return rbcN;
267 }
268
269 /* ************************************** */
270 /* Setup Utilities - Validate Sim Instances */
271
272 /* get the appropriate evaluated mesh based on rigid body mesh source */
273 static Mesh *rigidbody_get_mesh(Object *ob)
274 {
275   switch (ob->rigidbody_object->mesh_source) {
276     case RBO_MESH_DEFORM:
277       return ob->runtime.mesh_deform_eval;
278     case RBO_MESH_FINAL:
279       return ob->runtime.mesh_eval;
280     case RBO_MESH_BASE:
281       /* This mesh may be used for computing looptris, which should be done
282        * on the original; otherwise every time the CoW is recreated it will
283        * have to be recomputed. */
284       BLI_assert(ob->rigidbody_object->mesh_source == RBO_MESH_BASE);
285       return ob->runtime.mesh_orig;
286   }
287
288   /* Just return something sensible so that at least Blender won't crash. */
289   BLI_assert(!"Unknown mesh source");
290   return ob->runtime.mesh_eval;
291 }
292
293 /* create collision shape of mesh - convex hull */
294 static rbCollisionShape *rigidbody_get_shape_convexhull_from_mesh(Object *ob,
295                                                                   float margin,
296                                                                   bool *can_embed)
297 {
298   rbCollisionShape *shape = NULL;
299   Mesh *mesh = NULL;
300   MVert *mvert = NULL;
301   int totvert = 0;
302
303   if (ob->type == OB_MESH && ob->data) {
304     mesh = rigidbody_get_mesh(ob);
305     mvert = (mesh) ? mesh->mvert : NULL;
306     totvert = (mesh) ? mesh->totvert : 0;
307   }
308   else {
309     CLOG_ERROR(&LOG, "cannot make Convex Hull collision shape for non-Mesh object");
310   }
311
312   if (totvert) {
313     shape = RB_shape_new_convex_hull((float *)mvert, sizeof(MVert), totvert, margin, can_embed);
314   }
315   else {
316     CLOG_ERROR(&LOG, "no vertices to define Convex Hull collision shape with");
317   }
318
319   return shape;
320 }
321
322 /* create collision shape of mesh - triangulated mesh
323  * returns NULL if creation fails.
324  */
325 static rbCollisionShape *rigidbody_get_shape_trimesh_from_mesh(Object *ob)
326 {
327   rbCollisionShape *shape = NULL;
328
329   if (ob->type == OB_MESH) {
330     Mesh *mesh = NULL;
331     MVert *mvert;
332     const MLoopTri *looptri;
333     int totvert;
334     int tottri;
335     const MLoop *mloop;
336
337     mesh = rigidbody_get_mesh(ob);
338
339     /* ensure mesh validity, then grab data */
340     if (mesh == NULL) {
341       return NULL;
342     }
343
344     mvert = mesh->mvert;
345     totvert = mesh->totvert;
346     looptri = BKE_mesh_runtime_looptri_ensure(mesh);
347     tottri = mesh->runtime.looptris.len;
348     mloop = mesh->mloop;
349
350     /* sanity checking - potential case when no data will be present */
351     if ((totvert == 0) || (tottri == 0)) {
352       CLOG_WARN(
353           &LOG, "no geometry data converted for Mesh Collision Shape (ob = %s)", ob->id.name + 2);
354     }
355     else {
356       rbMeshData *mdata;
357       int i;
358
359       /* init mesh data for collision shape */
360       mdata = RB_trimesh_data_new(tottri, totvert);
361
362       RB_trimesh_add_vertices(mdata, (float *)mvert, totvert, sizeof(MVert));
363
364       /* loop over all faces, adding them as triangles to the collision shape
365        * (so for some faces, more than triangle will get added)
366        */
367       if (mvert && looptri) {
368         for (i = 0; i < tottri; i++) {
369           /* add first triangle - verts 1,2,3 */
370           const MLoopTri *lt = &looptri[i];
371           int vtri[3];
372
373           vtri[0] = mloop[lt->tri[0]].v;
374           vtri[1] = mloop[lt->tri[1]].v;
375           vtri[2] = mloop[lt->tri[2]].v;
376
377           RB_trimesh_add_triangle_indices(mdata, i, UNPACK3(vtri));
378         }
379       }
380
381       RB_trimesh_finish(mdata);
382
383       /* construct collision shape
384        *
385        * These have been chosen to get better speed/accuracy tradeoffs with regards
386        * to limitations of each:
387        *    - BVH-Triangle Mesh: for passive objects only. Despite having greater
388        *                         speed/accuracy, they cannot be used for moving objects.
389        *    - GImpact Mesh:      for active objects. These are slower and less stable,
390        *                         but are more flexible for general usage.
391        */
392       if (ob->rigidbody_object->type == RBO_TYPE_PASSIVE) {
393         shape = RB_shape_new_trimesh(mdata);
394       }
395       else {
396         shape = RB_shape_new_gimpact_mesh(mdata);
397       }
398     }
399   }
400   else {
401     CLOG_ERROR(&LOG, "cannot make Triangular Mesh collision shape for non-Mesh object");
402   }
403
404   return shape;
405 }
406
407 /* Create new physics sim collision shape for object and store it,
408  * or remove the existing one first and replace...
409  */
410 static void rigidbody_validate_sim_shape(Object *ob, bool rebuild)
411 {
412   RigidBodyOb *rbo = ob->rigidbody_object;
413   rbCollisionShape *new_shape = NULL;
414   BoundBox *bb = NULL;
415   float size[3] = {1.0f, 1.0f, 1.0f};
416   float radius = 1.0f;
417   float height = 1.0f;
418   float capsule_height;
419   float hull_margin = 0.0f;
420   bool can_embed = true;
421   bool has_volume;
422
423   /* sanity check */
424   if (rbo == NULL) {
425     return;
426   }
427
428   /* don't create a new shape if we already have one and don't want to rebuild it */
429   if (rbo->shared->physics_shape && !rebuild) {
430     return;
431   }
432
433   /* if automatically determining dimensions, use the Object's boundbox
434    * - assume that all quadrics are standing upright on local z-axis
435    * - assume even distribution of mass around the Object's pivot
436    *   (i.e. Object pivot is centralized in boundbox)
437    */
438   // XXX: all dimensions are auto-determined now... later can add stored settings for this
439   /* get object dimensions without scaling */
440   bb = BKE_object_boundbox_get(ob);
441   if (bb) {
442     size[0] = (bb->vec[4][0] - bb->vec[0][0]);
443     size[1] = (bb->vec[2][1] - bb->vec[0][1]);
444     size[2] = (bb->vec[1][2] - bb->vec[0][2]);
445   }
446   mul_v3_fl(size, 0.5f);
447
448   if (ELEM(rbo->shape, RB_SHAPE_CAPSULE, RB_SHAPE_CYLINDER, RB_SHAPE_CONE)) {
449     /* take radius as largest x/y dimension, and height as z-dimension */
450     radius = MAX2(size[0], size[1]);
451     height = size[2];
452   }
453   else if (rbo->shape == RB_SHAPE_SPHERE) {
454     /* take radius to the largest dimension to try and encompass everything */
455     radius = MAX3(size[0], size[1], size[2]);
456   }
457
458   /* create new shape */
459   switch (rbo->shape) {
460     case RB_SHAPE_BOX:
461       new_shape = RB_shape_new_box(size[0], size[1], size[2]);
462       break;
463
464     case RB_SHAPE_SPHERE:
465       new_shape = RB_shape_new_sphere(radius);
466       break;
467
468     case RB_SHAPE_CAPSULE:
469       capsule_height = (height - radius) * 2.0f;
470       new_shape = RB_shape_new_capsule(radius, (capsule_height > 0.0f) ? capsule_height : 0.0f);
471       break;
472     case RB_SHAPE_CYLINDER:
473       new_shape = RB_shape_new_cylinder(radius, height);
474       break;
475     case RB_SHAPE_CONE:
476       new_shape = RB_shape_new_cone(radius, height * 2.0f);
477       break;
478
479     case RB_SHAPE_CONVEXH:
480       /* try to emged collision margin */
481       has_volume = (MIN3(size[0], size[1], size[2]) > 0.0f);
482
483       if (!(rbo->flag & RBO_FLAG_USE_MARGIN) && has_volume) {
484         hull_margin = 0.04f;
485       }
486       new_shape = rigidbody_get_shape_convexhull_from_mesh(ob, hull_margin, &can_embed);
487       if (!(rbo->flag & RBO_FLAG_USE_MARGIN)) {
488         rbo->margin = (can_embed && has_volume) ?
489                           0.04f :
490                           0.0f; /* RB_TODO ideally we shouldn't directly change the margin here */
491       }
492       break;
493     case RB_SHAPE_TRIMESH:
494       new_shape = rigidbody_get_shape_trimesh_from_mesh(ob);
495       break;
496   }
497   /* use box shape if we can't fall back to old shape */
498   if (new_shape == NULL && rbo->shared->physics_shape == NULL) {
499     new_shape = RB_shape_new_box(size[0], size[1], size[2]);
500   }
501   /* assign new collision shape if creation was successful */
502   if (new_shape) {
503     if (rbo->shared->physics_shape) {
504       RB_shape_delete(rbo->shared->physics_shape);
505     }
506     rbo->shared->physics_shape = new_shape;
507     RB_shape_set_margin(rbo->shared->physics_shape, RBO_GET_MARGIN(rbo));
508   }
509 }
510
511 /* --------------------- */
512
513 /* helper function to calculate volume of rigidbody object */
514 // TODO: allow a parameter to specify method used to calculate this?
515 void BKE_rigidbody_calc_volume(Object *ob, float *r_vol)
516 {
517   RigidBodyOb *rbo = ob->rigidbody_object;
518
519   float size[3] = {1.0f, 1.0f, 1.0f};
520   float radius = 1.0f;
521   float height = 1.0f;
522
523   float volume = 0.0f;
524
525   /* if automatically determining dimensions, use the Object's boundbox
526    * - assume that all quadrics are standing upright on local z-axis
527    * - assume even distribution of mass around the Object's pivot
528    *   (i.e. Object pivot is centralized in boundbox)
529    * - boundbox gives full width
530    */
531   // XXX: all dimensions are auto-determined now... later can add stored settings for this
532   BKE_object_dimensions_get(ob, size);
533
534   if (ELEM(rbo->shape, RB_SHAPE_CAPSULE, RB_SHAPE_CYLINDER, RB_SHAPE_CONE)) {
535     /* take radius as largest x/y dimension, and height as z-dimension */
536     radius = MAX2(size[0], size[1]) * 0.5f;
537     height = size[2];
538   }
539   else if (rbo->shape == RB_SHAPE_SPHERE) {
540     /* take radius to the largest dimension to try and encompass everything */
541     radius = max_fff(size[0], size[1], size[2]) * 0.5f;
542   }
543
544   /* calculate volume as appropriate  */
545   switch (rbo->shape) {
546     case RB_SHAPE_BOX:
547       volume = size[0] * size[1] * size[2];
548       break;
549
550     case RB_SHAPE_SPHERE:
551       volume = 4.0f / 3.0f * (float)M_PI * radius * radius * radius;
552       break;
553
554     /* for now, assume that capsule is close enough to a cylinder... */
555     case RB_SHAPE_CAPSULE:
556     case RB_SHAPE_CYLINDER:
557       volume = (float)M_PI * radius * radius * height;
558       break;
559
560     case RB_SHAPE_CONE:
561       volume = (float)M_PI / 3.0f * radius * radius * height;
562       break;
563
564     case RB_SHAPE_CONVEXH:
565     case RB_SHAPE_TRIMESH: {
566       if (ob->type == OB_MESH) {
567         Mesh *mesh = rigidbody_get_mesh(ob);
568         MVert *mvert;
569         const MLoopTri *lt = NULL;
570         int totvert, tottri = 0;
571         const MLoop *mloop = NULL;
572
573         /* ensure mesh validity, then grab data */
574         if (mesh == NULL) {
575           return;
576         }
577
578         mvert = mesh->mvert;
579         totvert = mesh->totvert;
580         lt = BKE_mesh_runtime_looptri_ensure(mesh);
581         tottri = mesh->runtime.looptris.len;
582         mloop = mesh->mloop;
583
584         if (totvert > 0 && tottri > 0) {
585           BKE_mesh_calc_volume(mvert, totvert, lt, tottri, mloop, &volume, NULL);
586         }
587       }
588       else {
589         /* rough estimate from boundbox as fallback */
590         /* XXX could implement other types of geometry here (curves, etc.) */
591         volume = size[0] * size[1] * size[2];
592       }
593       break;
594     }
595   }
596
597   /* return the volume calculated */
598   if (r_vol) {
599     *r_vol = volume;
600   }
601 }
602
603 void BKE_rigidbody_calc_center_of_mass(Object *ob, float r_center[3])
604 {
605   RigidBodyOb *rbo = ob->rigidbody_object;
606
607   float size[3] = {1.0f, 1.0f, 1.0f};
608   float height = 1.0f;
609
610   zero_v3(r_center);
611
612   /* if automatically determining dimensions, use the Object's boundbox
613    * - assume that all quadrics are standing upright on local z-axis
614    * - assume even distribution of mass around the Object's pivot
615    *   (i.e. Object pivot is centralized in boundbox)
616    * - boundbox gives full width
617    */
618   // XXX: all dimensions are auto-determined now... later can add stored settings for this
619   BKE_object_dimensions_get(ob, size);
620
621   /* calculate volume as appropriate  */
622   switch (rbo->shape) {
623     case RB_SHAPE_BOX:
624     case RB_SHAPE_SPHERE:
625     case RB_SHAPE_CAPSULE:
626     case RB_SHAPE_CYLINDER:
627       break;
628
629     case RB_SHAPE_CONE:
630       /* take radius as largest x/y dimension, and height as z-dimension */
631       height = size[2];
632       /* cone is geometrically centered on the median,
633        * center of mass is 1/4 up from the base
634        */
635       r_center[2] = -0.25f * height;
636       break;
637
638     case RB_SHAPE_CONVEXH:
639     case RB_SHAPE_TRIMESH: {
640       if (ob->type == OB_MESH) {
641         Mesh *mesh = rigidbody_get_mesh(ob);
642         MVert *mvert;
643         const MLoopTri *looptri;
644         int totvert, tottri;
645         const MLoop *mloop;
646
647         /* ensure mesh validity, then grab data */
648         if (mesh == NULL) {
649           return;
650         }
651
652         mvert = mesh->mvert;
653         totvert = mesh->totvert;
654         looptri = BKE_mesh_runtime_looptri_ensure(mesh);
655         tottri = mesh->runtime.looptris.len;
656         mloop = mesh->mloop;
657
658         if (totvert > 0 && tottri > 0) {
659           BKE_mesh_calc_volume(mvert, totvert, looptri, tottri, mloop, NULL, r_center);
660         }
661       }
662       break;
663     }
664   }
665 }
666
667 /* --------------------- */
668
669 /**
670  * Create physics sim representation of object given RigidBody settings
671  *
672  * \param rebuild: Even if an instance already exists, replace it
673  */
674 static void rigidbody_validate_sim_object(RigidBodyWorld *rbw, Object *ob, bool rebuild)
675 {
676   RigidBodyOb *rbo = (ob) ? ob->rigidbody_object : NULL;
677   float loc[3];
678   float rot[4];
679
680   /* sanity checks:
681    * - object doesn't have RigidBody info already: then why is it here?
682    */
683   if (rbo == NULL) {
684     return;
685   }
686
687   /* make sure collision shape exists */
688   /* FIXME we shouldn't always have to rebuild collision shapes when rebuilding objects, but it's needed for constraints to update correctly */
689   if (rbo->shared->physics_shape == NULL || rebuild) {
690     rigidbody_validate_sim_shape(ob, true);
691   }
692
693   if (rbo->shared->physics_object) {
694     RB_dworld_remove_body(rbw->shared->physics_world, rbo->shared->physics_object);
695   }
696   if (!rbo->shared->physics_object || rebuild) {
697     /* remove rigid body if it already exists before creating a new one */
698     if (rbo->shared->physics_object) {
699       RB_body_delete(rbo->shared->physics_object);
700     }
701
702     mat4_to_loc_quat(loc, rot, ob->obmat);
703
704     rbo->shared->physics_object = RB_body_new(rbo->shared->physics_shape, loc, rot);
705
706     RB_body_set_friction(rbo->shared->physics_object, rbo->friction);
707     RB_body_set_restitution(rbo->shared->physics_object, rbo->restitution);
708
709     RB_body_set_damping(rbo->shared->physics_object, rbo->lin_damping, rbo->ang_damping);
710     RB_body_set_sleep_thresh(
711         rbo->shared->physics_object, rbo->lin_sleep_thresh, rbo->ang_sleep_thresh);
712     RB_body_set_activation_state(rbo->shared->physics_object,
713                                  rbo->flag & RBO_FLAG_USE_DEACTIVATION);
714
715     if (rbo->type == RBO_TYPE_PASSIVE || rbo->flag & RBO_FLAG_START_DEACTIVATED) {
716       RB_body_deactivate(rbo->shared->physics_object);
717     }
718
719     RB_body_set_linear_factor(rbo->shared->physics_object,
720                               (ob->protectflag & OB_LOCK_LOCX) == 0,
721                               (ob->protectflag & OB_LOCK_LOCY) == 0,
722                               (ob->protectflag & OB_LOCK_LOCZ) == 0);
723     RB_body_set_angular_factor(rbo->shared->physics_object,
724                                (ob->protectflag & OB_LOCK_ROTX) == 0,
725                                (ob->protectflag & OB_LOCK_ROTY) == 0,
726                                (ob->protectflag & OB_LOCK_ROTZ) == 0);
727
728     RB_body_set_mass(rbo->shared->physics_object, RBO_GET_MASS(rbo));
729     RB_body_set_kinematic_state(rbo->shared->physics_object,
730                                 rbo->flag & RBO_FLAG_KINEMATIC || rbo->flag & RBO_FLAG_DISABLED);
731   }
732
733   if (rbw && rbw->shared->physics_world) {
734     RB_dworld_add_body(rbw->shared->physics_world, rbo->shared->physics_object, rbo->col_groups);
735   }
736 }
737
738 /* --------------------- */
739
740 static void rigidbody_constraint_init_spring(RigidBodyCon *rbc,
741                                              void (*set_spring)(rbConstraint *, int, int),
742                                              void (*set_stiffness)(rbConstraint *, int, float),
743                                              void (*set_damping)(rbConstraint *, int, float))
744 {
745   set_spring(rbc->physics_constraint, RB_LIMIT_LIN_X, rbc->flag & RBC_FLAG_USE_SPRING_X);
746   set_stiffness(rbc->physics_constraint, RB_LIMIT_LIN_X, rbc->spring_stiffness_x);
747   set_damping(rbc->physics_constraint, RB_LIMIT_LIN_X, rbc->spring_damping_x);
748
749   set_spring(rbc->physics_constraint, RB_LIMIT_LIN_Y, rbc->flag & RBC_FLAG_USE_SPRING_Y);
750   set_stiffness(rbc->physics_constraint, RB_LIMIT_LIN_Y, rbc->spring_stiffness_y);
751   set_damping(rbc->physics_constraint, RB_LIMIT_LIN_Y, rbc->spring_damping_y);
752
753   set_spring(rbc->physics_constraint, RB_LIMIT_LIN_Z, rbc->flag & RBC_FLAG_USE_SPRING_Z);
754   set_stiffness(rbc->physics_constraint, RB_LIMIT_LIN_Z, rbc->spring_stiffness_z);
755   set_damping(rbc->physics_constraint, RB_LIMIT_LIN_Z, rbc->spring_damping_z);
756
757   set_spring(rbc->physics_constraint, RB_LIMIT_ANG_X, rbc->flag & RBC_FLAG_USE_SPRING_ANG_X);
758   set_stiffness(rbc->physics_constraint, RB_LIMIT_ANG_X, rbc->spring_stiffness_ang_x);
759   set_damping(rbc->physics_constraint, RB_LIMIT_ANG_X, rbc->spring_damping_ang_x);
760
761   set_spring(rbc->physics_constraint, RB_LIMIT_ANG_Y, rbc->flag & RBC_FLAG_USE_SPRING_ANG_Y);
762   set_stiffness(rbc->physics_constraint, RB_LIMIT_ANG_Y, rbc->spring_stiffness_ang_y);
763   set_damping(rbc->physics_constraint, RB_LIMIT_ANG_Y, rbc->spring_damping_ang_y);
764
765   set_spring(rbc->physics_constraint, RB_LIMIT_ANG_Z, rbc->flag & RBC_FLAG_USE_SPRING_ANG_Z);
766   set_stiffness(rbc->physics_constraint, RB_LIMIT_ANG_Z, rbc->spring_stiffness_ang_z);
767   set_damping(rbc->physics_constraint, RB_LIMIT_ANG_Z, rbc->spring_damping_ang_z);
768 }
769
770 static void rigidbody_constraint_set_limits(RigidBodyCon *rbc,
771                                             void (*set_limits)(rbConstraint *, int, float, float))
772 {
773   if (rbc->flag & RBC_FLAG_USE_LIMIT_LIN_X) {
774     set_limits(
775         rbc->physics_constraint, RB_LIMIT_LIN_X, rbc->limit_lin_x_lower, rbc->limit_lin_x_upper);
776   }
777   else {
778     set_limits(rbc->physics_constraint, RB_LIMIT_LIN_X, 0.0f, -1.0f);
779   }
780
781   if (rbc->flag & RBC_FLAG_USE_LIMIT_LIN_Y) {
782     set_limits(
783         rbc->physics_constraint, RB_LIMIT_LIN_Y, rbc->limit_lin_y_lower, rbc->limit_lin_y_upper);
784   }
785   else {
786     set_limits(rbc->physics_constraint, RB_LIMIT_LIN_Y, 0.0f, -1.0f);
787   }
788
789   if (rbc->flag & RBC_FLAG_USE_LIMIT_LIN_Z) {
790     set_limits(
791         rbc->physics_constraint, RB_LIMIT_LIN_Z, rbc->limit_lin_z_lower, rbc->limit_lin_z_upper);
792   }
793   else {
794     set_limits(rbc->physics_constraint, RB_LIMIT_LIN_Z, 0.0f, -1.0f);
795   }
796
797   if (rbc->flag & RBC_FLAG_USE_LIMIT_ANG_X) {
798     set_limits(
799         rbc->physics_constraint, RB_LIMIT_ANG_X, rbc->limit_ang_x_lower, rbc->limit_ang_x_upper);
800   }
801   else {
802     set_limits(rbc->physics_constraint, RB_LIMIT_ANG_X, 0.0f, -1.0f);
803   }
804
805   if (rbc->flag & RBC_FLAG_USE_LIMIT_ANG_Y) {
806     set_limits(
807         rbc->physics_constraint, RB_LIMIT_ANG_Y, rbc->limit_ang_y_lower, rbc->limit_ang_y_upper);
808   }
809   else {
810     set_limits(rbc->physics_constraint, RB_LIMIT_ANG_Y, 0.0f, -1.0f);
811   }
812
813   if (rbc->flag & RBC_FLAG_USE_LIMIT_ANG_Z) {
814     set_limits(
815         rbc->physics_constraint, RB_LIMIT_ANG_Z, rbc->limit_ang_z_lower, rbc->limit_ang_z_upper);
816   }
817   else {
818     set_limits(rbc->physics_constraint, RB_LIMIT_ANG_Z, 0.0f, -1.0f);
819   }
820 }
821
822 /**
823  * Create physics sim representation of constraint given rigid body constraint settings
824  *
825  * \param rebuild: Even if an instance already exists, replace it
826  */
827 static void rigidbody_validate_sim_constraint(RigidBodyWorld *rbw, Object *ob, bool rebuild)
828 {
829   RigidBodyCon *rbc = (ob) ? ob->rigidbody_constraint : NULL;
830   float loc[3];
831   float rot[4];
832   float lin_lower;
833   float lin_upper;
834   float ang_lower;
835   float ang_upper;
836
837   /* sanity checks:
838    * - object should have a rigid body constraint
839    * - rigid body constraint should have at least one constrained object
840    */
841   if (rbc == NULL) {
842     return;
843   }
844
845   if (ELEM(NULL, rbc->ob1, rbc->ob1->rigidbody_object, rbc->ob2, rbc->ob2->rigidbody_object)) {
846     if (rbc->physics_constraint) {
847       RB_dworld_remove_constraint(rbw->shared->physics_world, rbc->physics_constraint);
848       RB_constraint_delete(rbc->physics_constraint);
849       rbc->physics_constraint = NULL;
850     }
851     return;
852   }
853
854   if (rbc->physics_constraint && rebuild == false) {
855     RB_dworld_remove_constraint(rbw->shared->physics_world, rbc->physics_constraint);
856   }
857   if (rbc->physics_constraint == NULL || rebuild) {
858     rbRigidBody *rb1 = rbc->ob1->rigidbody_object->shared->physics_object;
859     rbRigidBody *rb2 = rbc->ob2->rigidbody_object->shared->physics_object;
860
861     /* remove constraint if it already exists before creating a new one */
862     if (rbc->physics_constraint) {
863       RB_constraint_delete(rbc->physics_constraint);
864       rbc->physics_constraint = NULL;
865     }
866
867     mat4_to_loc_quat(loc, rot, ob->obmat);
868
869     if (rb1 && rb2) {
870       switch (rbc->type) {
871         case RBC_TYPE_POINT:
872           rbc->physics_constraint = RB_constraint_new_point(loc, rb1, rb2);
873           break;
874         case RBC_TYPE_FIXED:
875           rbc->physics_constraint = RB_constraint_new_fixed(loc, rot, rb1, rb2);
876           break;
877         case RBC_TYPE_HINGE:
878           rbc->physics_constraint = RB_constraint_new_hinge(loc, rot, rb1, rb2);
879           if (rbc->flag & RBC_FLAG_USE_LIMIT_ANG_Z) {
880             RB_constraint_set_limits_hinge(
881                 rbc->physics_constraint, rbc->limit_ang_z_lower, rbc->limit_ang_z_upper);
882           }
883           else {
884             RB_constraint_set_limits_hinge(rbc->physics_constraint, 0.0f, -1.0f);
885           }
886           break;
887         case RBC_TYPE_SLIDER:
888           rbc->physics_constraint = RB_constraint_new_slider(loc, rot, rb1, rb2);
889           if (rbc->flag & RBC_FLAG_USE_LIMIT_LIN_X) {
890             RB_constraint_set_limits_slider(
891                 rbc->physics_constraint, rbc->limit_lin_x_lower, rbc->limit_lin_x_upper);
892           }
893           else {
894             RB_constraint_set_limits_slider(rbc->physics_constraint, 0.0f, -1.0f);
895           }
896           break;
897         case RBC_TYPE_PISTON:
898           rbc->physics_constraint = RB_constraint_new_piston(loc, rot, rb1, rb2);
899           if (rbc->flag & RBC_FLAG_USE_LIMIT_LIN_X) {
900             lin_lower = rbc->limit_lin_x_lower;
901             lin_upper = rbc->limit_lin_x_upper;
902           }
903           else {
904             lin_lower = 0.0f;
905             lin_upper = -1.0f;
906           }
907           if (rbc->flag & RBC_FLAG_USE_LIMIT_ANG_X) {
908             ang_lower = rbc->limit_ang_x_lower;
909             ang_upper = rbc->limit_ang_x_upper;
910           }
911           else {
912             ang_lower = 0.0f;
913             ang_upper = -1.0f;
914           }
915           RB_constraint_set_limits_piston(
916               rbc->physics_constraint, lin_lower, lin_upper, ang_lower, ang_upper);
917           break;
918         case RBC_TYPE_6DOF_SPRING:
919           if (rbc->spring_type == RBC_SPRING_TYPE2) {
920             rbc->physics_constraint = RB_constraint_new_6dof_spring2(loc, rot, rb1, rb2);
921
922             rigidbody_constraint_init_spring(rbc,
923                                              RB_constraint_set_spring_6dof_spring2,
924                                              RB_constraint_set_stiffness_6dof_spring2,
925                                              RB_constraint_set_damping_6dof_spring2);
926
927             RB_constraint_set_equilibrium_6dof_spring2(rbc->physics_constraint);
928
929             rigidbody_constraint_set_limits(rbc, RB_constraint_set_limits_6dof_spring2);
930           }
931           else {
932             rbc->physics_constraint = RB_constraint_new_6dof_spring(loc, rot, rb1, rb2);
933
934             rigidbody_constraint_init_spring(rbc,
935                                              RB_constraint_set_spring_6dof_spring,
936                                              RB_constraint_set_stiffness_6dof_spring,
937                                              RB_constraint_set_damping_6dof_spring);
938
939             RB_constraint_set_equilibrium_6dof_spring(rbc->physics_constraint);
940
941             rigidbody_constraint_set_limits(rbc, RB_constraint_set_limits_6dof);
942           }
943           break;
944         case RBC_TYPE_6DOF:
945           rbc->physics_constraint = RB_constraint_new_6dof(loc, rot, rb1, rb2);
946
947           rigidbody_constraint_set_limits(rbc, RB_constraint_set_limits_6dof);
948           break;
949         case RBC_TYPE_MOTOR:
950           rbc->physics_constraint = RB_constraint_new_motor(loc, rot, rb1, rb2);
951
952           RB_constraint_set_enable_motor(rbc->physics_constraint,
953                                          rbc->flag & RBC_FLAG_USE_MOTOR_LIN,
954                                          rbc->flag & RBC_FLAG_USE_MOTOR_ANG);
955           RB_constraint_set_max_impulse_motor(
956               rbc->physics_constraint, rbc->motor_lin_max_impulse, rbc->motor_ang_max_impulse);
957           RB_constraint_set_target_velocity_motor(rbc->physics_constraint,
958                                                   rbc->motor_lin_target_velocity,
959                                                   rbc->motor_ang_target_velocity);
960           break;
961       }
962     }
963     else { /* can't create constraint without both rigid bodies */
964       return;
965     }
966
967     RB_constraint_set_enabled(rbc->physics_constraint, rbc->flag & RBC_FLAG_ENABLED);
968
969     if (rbc->flag & RBC_FLAG_USE_BREAKING) {
970       RB_constraint_set_breaking_threshold(rbc->physics_constraint, rbc->breaking_threshold);
971     }
972     else {
973       RB_constraint_set_breaking_threshold(rbc->physics_constraint, FLT_MAX);
974     }
975
976     if (rbc->flag & RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS) {
977       RB_constraint_set_solver_iterations(rbc->physics_constraint, rbc->num_solver_iterations);
978     }
979     else {
980       RB_constraint_set_solver_iterations(rbc->physics_constraint, -1);
981     }
982   }
983
984   if (rbw && rbw->shared->physics_world && rbc->physics_constraint) {
985     RB_dworld_add_constraint(rbw->shared->physics_world,
986                              rbc->physics_constraint,
987                              rbc->flag & RBC_FLAG_DISABLE_COLLISIONS);
988   }
989 }
990
991 /* --------------------- */
992
993 /* Create physics sim world given RigidBody world settings */
994 // NOTE: this does NOT update object references that the scene uses, in case those aren't ready yet!
995 void BKE_rigidbody_validate_sim_world(Scene *scene, RigidBodyWorld *rbw, bool rebuild)
996 {
997   /* sanity checks */
998   if (rbw == NULL) {
999     return;
1000   }
1001
1002   /* create new sim world */
1003   if (rebuild || rbw->shared->physics_world == NULL) {
1004     if (rbw->shared->physics_world) {
1005       RB_dworld_delete(rbw->shared->physics_world);
1006     }
1007     rbw->shared->physics_world = RB_dworld_new(scene->physics_settings.gravity);
1008   }
1009
1010   RB_dworld_set_solver_iterations(rbw->shared->physics_world, rbw->num_solver_iterations);
1011   RB_dworld_set_split_impulse(rbw->shared->physics_world, rbw->flag & RBW_FLAG_USE_SPLIT_IMPULSE);
1012 }
1013
1014 /* ************************************** */
1015 /* Setup Utilities - Create Settings Blocks */
1016
1017 /* Set up RigidBody world */
1018 RigidBodyWorld *BKE_rigidbody_create_world(Scene *scene)
1019 {
1020   /* try to get whatever RigidBody world that might be representing this already */
1021   RigidBodyWorld *rbw;
1022
1023   /* sanity checks
1024    * - there must be a valid scene to add world to
1025    * - there mustn't be a sim world using this group already
1026    */
1027   if (scene == NULL) {
1028     return NULL;
1029   }
1030
1031   /* create a new sim world */
1032   rbw = MEM_callocN(sizeof(RigidBodyWorld), "RigidBodyWorld");
1033   rbw->shared = MEM_callocN(sizeof(*rbw->shared), "RigidBodyWorld_Shared");
1034
1035   /* set default settings */
1036   rbw->effector_weights = BKE_effector_add_weights(NULL);
1037
1038   rbw->ltime = PSFRA;
1039
1040   rbw->time_scale = 1.0f;
1041
1042   rbw->steps_per_second = 60;      /* Bullet default (60 Hz) */
1043   rbw->num_solver_iterations = 10; /* 10 is bullet default */
1044
1045   rbw->shared->pointcache = BKE_ptcache_add(&(rbw->shared->ptcaches));
1046   rbw->shared->pointcache->step = 1;
1047
1048   /* return this sim world */
1049   return rbw;
1050 }
1051
1052 RigidBodyWorld *BKE_rigidbody_world_copy(RigidBodyWorld *rbw, const int flag)
1053 {
1054   RigidBodyWorld *rbw_copy = MEM_dupallocN(rbw);
1055
1056   if (rbw->effector_weights) {
1057     rbw_copy->effector_weights = MEM_dupallocN(rbw->effector_weights);
1058   }
1059   if ((flag & LIB_ID_CREATE_NO_USER_REFCOUNT) == 0) {
1060     id_us_plus((ID *)rbw_copy->group);
1061     id_us_plus((ID *)rbw_copy->constraints);
1062   }
1063
1064   if ((flag & LIB_ID_CREATE_NO_MAIN) == 0) {
1065     /* This is a regular copy, and not a CoW copy for depsgraph evaluation */
1066     rbw_copy->shared = MEM_callocN(sizeof(*rbw_copy->shared), "RigidBodyWorld_Shared");
1067     BKE_ptcache_copy_list(&rbw_copy->shared->ptcaches, &rbw->shared->ptcaches, LIB_ID_COPY_CACHES);
1068     rbw_copy->shared->pointcache = rbw_copy->shared->ptcaches.first;
1069   }
1070
1071   rbw_copy->objects = NULL;
1072   rbw_copy->numbodies = 0;
1073   rigidbody_update_ob_array(rbw_copy);
1074
1075   return rbw_copy;
1076 }
1077
1078 void BKE_rigidbody_world_groups_relink(RigidBodyWorld *rbw)
1079 {
1080   ID_NEW_REMAP(rbw->group);
1081   ID_NEW_REMAP(rbw->constraints);
1082   ID_NEW_REMAP(rbw->effector_weights->group);
1083 }
1084
1085 void BKE_rigidbody_world_id_loop(RigidBodyWorld *rbw, RigidbodyWorldIDFunc func, void *userdata)
1086 {
1087   func(rbw, (ID **)&rbw->group, userdata, IDWALK_CB_NOP);
1088   func(rbw, (ID **)&rbw->constraints, userdata, IDWALK_CB_NOP);
1089   func(rbw, (ID **)&rbw->effector_weights->group, userdata, IDWALK_CB_NOP);
1090
1091   if (rbw->objects) {
1092     int i;
1093     for (i = 0; i < rbw->numbodies; i++) {
1094       func(rbw, (ID **)&rbw->objects[i], userdata, IDWALK_CB_NOP);
1095     }
1096   }
1097 }
1098
1099 /* Add rigid body settings to the specified object */
1100 RigidBodyOb *BKE_rigidbody_create_object(Scene *scene, Object *ob, short type)
1101 {
1102   RigidBodyOb *rbo;
1103   RigidBodyWorld *rbw = scene->rigidbody_world;
1104
1105   /* sanity checks
1106    * - rigidbody world must exist
1107    * - object must exist
1108    * - cannot add rigid body if it already exists
1109    */
1110   if (ob == NULL || (ob->rigidbody_object != NULL)) {
1111     return NULL;
1112   }
1113
1114   /* create new settings data, and link it up */
1115   rbo = MEM_callocN(sizeof(RigidBodyOb), "RigidBodyOb");
1116   rbo->shared = MEM_callocN(sizeof(*rbo->shared), "RigidBodyOb_Shared");
1117
1118   /* set default settings */
1119   rbo->type = type;
1120
1121   rbo->mass = 1.0f;
1122
1123   rbo->friction = 0.5f;    /* best when non-zero. 0.5 is Bullet default */
1124   rbo->restitution = 0.0f; /* best when zero. 0.0 is Bullet default */
1125
1126   rbo->margin = 0.04f; /* 0.04 (in meters) is Bullet default */
1127
1128   rbo->lin_sleep_thresh = 0.4f; /* 0.4 is half of Bullet default */
1129   rbo->ang_sleep_thresh = 0.5f; /* 0.5 is half of Bullet default */
1130
1131   rbo->lin_damping = 0.04f;
1132   rbo->ang_damping = 0.1f;
1133
1134   rbo->col_groups = 1;
1135
1136   /* use triangle meshes for passive objects
1137    * use convex hulls for active objects since dynamic triangle meshes are very unstable
1138    */
1139   if (type == RBO_TYPE_ACTIVE) {
1140     rbo->shape = RB_SHAPE_CONVEXH;
1141   }
1142   else {
1143     rbo->shape = RB_SHAPE_TRIMESH;
1144   }
1145
1146   rbo->mesh_source = RBO_MESH_DEFORM;
1147
1148   /* set initial transform */
1149   mat4_to_loc_quat(rbo->pos, rbo->orn, ob->obmat);
1150
1151   /* flag cache as outdated */
1152   BKE_rigidbody_cache_reset(rbw);
1153   rbo->flag |= (RBO_FLAG_NEEDS_VALIDATE | RBO_FLAG_NEEDS_RESHAPE);
1154
1155   /* return this object */
1156   return rbo;
1157 }
1158
1159 /* Add rigid body constraint to the specified object */
1160 RigidBodyCon *BKE_rigidbody_create_constraint(Scene *scene, Object *ob, short type)
1161 {
1162   RigidBodyCon *rbc;
1163   RigidBodyWorld *rbw = scene->rigidbody_world;
1164
1165   /* sanity checks
1166    * - rigidbody world must exist
1167    * - object must exist
1168    * - cannot add constraint if it already exists
1169    */
1170   if (ob == NULL || (ob->rigidbody_constraint != NULL)) {
1171     return NULL;
1172   }
1173
1174   /* create new settings data, and link it up */
1175   rbc = MEM_callocN(sizeof(RigidBodyCon), "RigidBodyCon");
1176
1177   /* set default settings */
1178   rbc->type = type;
1179
1180   rbc->ob1 = NULL;
1181   rbc->ob2 = NULL;
1182
1183   rbc->flag |= RBC_FLAG_ENABLED;
1184   rbc->flag |= RBC_FLAG_DISABLE_COLLISIONS;
1185   rbc->flag |= RBC_FLAG_NEEDS_VALIDATE;
1186
1187   rbc->spring_type = RBC_SPRING_TYPE2;
1188
1189   rbc->breaking_threshold = 10.0f; /* no good default here, just use 10 for now */
1190   rbc->num_solver_iterations = 10; /* 10 is Bullet default */
1191
1192   rbc->limit_lin_x_lower = -1.0f;
1193   rbc->limit_lin_x_upper = 1.0f;
1194   rbc->limit_lin_y_lower = -1.0f;
1195   rbc->limit_lin_y_upper = 1.0f;
1196   rbc->limit_lin_z_lower = -1.0f;
1197   rbc->limit_lin_z_upper = 1.0f;
1198   rbc->limit_ang_x_lower = -M_PI_4;
1199   rbc->limit_ang_x_upper = M_PI_4;
1200   rbc->limit_ang_y_lower = -M_PI_4;
1201   rbc->limit_ang_y_upper = M_PI_4;
1202   rbc->limit_ang_z_lower = -M_PI_4;
1203   rbc->limit_ang_z_upper = M_PI_4;
1204
1205   rbc->spring_damping_x = 0.5f;
1206   rbc->spring_damping_y = 0.5f;
1207   rbc->spring_damping_z = 0.5f;
1208   rbc->spring_damping_ang_x = 0.5f;
1209   rbc->spring_damping_ang_y = 0.5f;
1210   rbc->spring_damping_ang_z = 0.5f;
1211   rbc->spring_stiffness_x = 10.0f;
1212   rbc->spring_stiffness_y = 10.0f;
1213   rbc->spring_stiffness_z = 10.0f;
1214   rbc->spring_stiffness_ang_x = 10.0f;
1215   rbc->spring_stiffness_ang_y = 10.0f;
1216   rbc->spring_stiffness_ang_z = 10.0f;
1217
1218   rbc->motor_lin_max_impulse = 1.0f;
1219   rbc->motor_lin_target_velocity = 1.0f;
1220   rbc->motor_ang_max_impulse = 1.0f;
1221   rbc->motor_ang_target_velocity = 1.0f;
1222
1223   /* flag cache as outdated */
1224   BKE_rigidbody_cache_reset(rbw);
1225
1226   /* return this object */
1227   return rbc;
1228 }
1229
1230 void BKE_rigidbody_objects_collection_validate(Scene *scene, RigidBodyWorld *rbw)
1231 {
1232   if (rbw->group != NULL) {
1233     FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (rbw->group, object) {
1234       if (object->type != OB_MESH || object->rigidbody_object != NULL) {
1235         continue;
1236       }
1237       object->rigidbody_object = BKE_rigidbody_create_object(scene, object, RBO_TYPE_ACTIVE);
1238     }
1239     FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
1240   }
1241 }
1242
1243 void BKE_rigidbody_constraints_collection_validate(Scene *scene, RigidBodyWorld *rbw)
1244 {
1245   if (rbw->constraints != NULL) {
1246     FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (rbw->constraints, object) {
1247       if (object->rigidbody_constraint != NULL) {
1248         continue;
1249       }
1250       object->rigidbody_constraint = BKE_rigidbody_create_constraint(
1251           scene, object, RBC_TYPE_FIXED);
1252     }
1253     FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
1254   }
1255 }
1256
1257 void BKE_rigidbody_main_collection_object_add(Main *bmain, Collection *collection, Object *object)
1258 {
1259   for (Scene *scene = bmain->scenes.first; scene; scene = scene->id.next) {
1260     RigidBodyWorld *rbw = scene->rigidbody_world;
1261
1262     if (rbw == NULL) {
1263       continue;
1264     }
1265
1266     if (rbw->group == collection && object->type == OB_MESH && object->rigidbody_object == NULL) {
1267       object->rigidbody_object = BKE_rigidbody_create_object(scene, object, RBO_TYPE_ACTIVE);
1268     }
1269     if (rbw->constraints == collection && object->rigidbody_constraint == NULL) {
1270       object->rigidbody_constraint = BKE_rigidbody_create_constraint(
1271           scene, object, RBC_TYPE_FIXED);
1272     }
1273   }
1274 }
1275
1276 /* ************************************** */
1277 /* Utilities API */
1278
1279 /* Get RigidBody world for the given scene, creating one if needed
1280  *
1281  * \param scene: Scene to find active Rigid Body world for
1282  */
1283 RigidBodyWorld *BKE_rigidbody_get_world(Scene *scene)
1284 {
1285   /* sanity check */
1286   if (scene == NULL) {
1287     return NULL;
1288   }
1289
1290   return scene->rigidbody_world;
1291 }
1292
1293 void BKE_rigidbody_remove_object(struct Main *bmain, Scene *scene, Object *ob)
1294 {
1295   RigidBodyWorld *rbw = scene->rigidbody_world;
1296   RigidBodyCon *rbc;
1297   int i;
1298
1299   if (rbw) {
1300
1301     /* remove object from array */
1302     if (rbw && rbw->objects) {
1303       for (i = 0; i < rbw->numbodies; i++) {
1304         if (rbw->objects[i] == ob) {
1305           rbw->objects[i] = NULL;
1306           break;
1307         }
1308       }
1309     }
1310
1311     /* remove object from rigid body constraints */
1312     if (rbw->constraints) {
1313       FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (rbw->constraints, obt) {
1314         if (obt && obt->rigidbody_constraint) {
1315           rbc = obt->rigidbody_constraint;
1316           if (ELEM(ob, rbc->ob1, rbc->ob2)) {
1317             BKE_rigidbody_remove_constraint(scene, obt);
1318           }
1319         }
1320       }
1321       FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
1322     }
1323     BKE_collection_object_remove(bmain, rbw->group, ob, false);
1324   }
1325
1326   /* remove object's settings */
1327   BKE_rigidbody_free_object(ob, rbw);
1328
1329   /* flag cache as outdated */
1330   BKE_rigidbody_cache_reset(rbw);
1331 }
1332
1333 void BKE_rigidbody_remove_constraint(Scene *scene, Object *ob)
1334 {
1335   RigidBodyWorld *rbw = scene->rigidbody_world;
1336   RigidBodyCon *rbc = ob->rigidbody_constraint;
1337
1338   /* remove from rigidbody world, free object won't do this */
1339   if (rbw && rbw->shared->physics_world && rbc->physics_constraint) {
1340     RB_dworld_remove_constraint(rbw->shared->physics_world, rbc->physics_constraint);
1341   }
1342   /* remove object's settings */
1343   BKE_rigidbody_free_constraint(ob);
1344
1345   /* flag cache as outdated */
1346   BKE_rigidbody_cache_reset(rbw);
1347 }
1348
1349 /* ************************************** */
1350 /* Simulation Interface - Bullet */
1351
1352 /* Update object array and rigid body count so they're in sync with the rigid body group */
1353 static void rigidbody_update_ob_array(RigidBodyWorld *rbw)
1354 {
1355   if (rbw->group == NULL) {
1356     rbw->numbodies = 0;
1357     rbw->objects = realloc(rbw->objects, 0);
1358     return;
1359   }
1360
1361   int n = 0;
1362   FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (rbw->group, object) {
1363     (void)object;
1364     n++;
1365   }
1366   FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
1367
1368   if (rbw->numbodies != n) {
1369     rbw->numbodies = n;
1370     rbw->objects = realloc(rbw->objects, sizeof(Object *) * rbw->numbodies);
1371   }
1372
1373   int i = 0;
1374   FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (rbw->group, object) {
1375     rbw->objects[i] = object;
1376     i++;
1377   }
1378   FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
1379 }
1380
1381 static void rigidbody_update_sim_world(Scene *scene, RigidBodyWorld *rbw)
1382 {
1383   float adj_gravity[3];
1384
1385   /* adjust gravity to take effector weights into account */
1386   if (scene->physics_settings.flag & PHYS_GLOBAL_GRAVITY) {
1387     copy_v3_v3(adj_gravity, scene->physics_settings.gravity);
1388     mul_v3_fl(adj_gravity,
1389               rbw->effector_weights->global_gravity * rbw->effector_weights->weight[0]);
1390   }
1391   else {
1392     zero_v3(adj_gravity);
1393   }
1394
1395   /* update gravity, since this RNA setting is not part of RigidBody settings */
1396   RB_dworld_set_gravity(rbw->shared->physics_world, adj_gravity);
1397
1398   /* update object array in case there are changes */
1399   rigidbody_update_ob_array(rbw);
1400 }
1401
1402 static void rigidbody_update_sim_ob(
1403     Depsgraph *depsgraph, Scene *scene, RigidBodyWorld *rbw, Object *ob, RigidBodyOb *rbo)
1404 {
1405   float loc[3];
1406   float rot[4];
1407   float scale[3];
1408
1409   /* only update if rigid body exists */
1410   if (rbo->shared->physics_object == NULL) {
1411     return;
1412   }
1413
1414   if (rbo->shape == RB_SHAPE_TRIMESH && rbo->flag & RBO_FLAG_USE_DEFORM) {
1415     Mesh *mesh = ob->runtime.mesh_deform_eval;
1416     if (mesh) {
1417       MVert *mvert = mesh->mvert;
1418       int totvert = mesh->totvert;
1419       BoundBox *bb = BKE_object_boundbox_get(ob);
1420
1421       RB_shape_trimesh_update(rbo->shared->physics_shape,
1422                               (float *)mvert,
1423                               totvert,
1424                               sizeof(MVert),
1425                               bb->vec[0],
1426                               bb->vec[6]);
1427     }
1428   }
1429
1430   mat4_decompose(loc, rot, scale, ob->obmat);
1431
1432   /* update scale for all objects */
1433   RB_body_set_scale(rbo->shared->physics_object, scale);
1434   /* compensate for embedded convex hull collision margin */
1435   if (!(rbo->flag & RBO_FLAG_USE_MARGIN) && rbo->shape == RB_SHAPE_CONVEXH) {
1436     RB_shape_set_margin(rbo->shared->physics_shape,
1437                         RBO_GET_MARGIN(rbo) * MIN3(scale[0], scale[1], scale[2]));
1438   }
1439
1440   /* make transformed objects temporarily kinmatic so that they can be moved by the user during simulation */
1441   if (ob->flag & SELECT && G.moving & G_TRANSFORM_OBJ) {
1442     RB_body_set_kinematic_state(rbo->shared->physics_object, true);
1443     RB_body_set_mass(rbo->shared->physics_object, 0.0f);
1444   }
1445
1446   /* update rigid body location and rotation for kinematic bodies */
1447   if (rbo->flag & RBO_FLAG_KINEMATIC || (ob->flag & SELECT && G.moving & G_TRANSFORM_OBJ)) {
1448     RB_body_activate(rbo->shared->physics_object);
1449     RB_body_set_loc_rot(rbo->shared->physics_object, loc, rot);
1450   }
1451   /* update influence of effectors - but don't do it on an effector */
1452   /* only dynamic bodies need effector update */
1453   else if (rbo->type == RBO_TYPE_ACTIVE &&
1454            ((ob->pd == NULL) || (ob->pd->forcefield == PFIELD_NULL))) {
1455     EffectorWeights *effector_weights = rbw->effector_weights;
1456     EffectedPoint epoint;
1457     ListBase *effectors;
1458
1459     /* get effectors present in the group specified by effector_weights */
1460     effectors = BKE_effectors_create(depsgraph, ob, NULL, effector_weights);
1461     if (effectors) {
1462       float eff_force[3] = {0.0f, 0.0f, 0.0f};
1463       float eff_loc[3], eff_vel[3];
1464
1465       /* create dummy 'point' which represents last known position of object as result of sim */
1466       // XXX: this can create some inaccuracies with sim position, but is probably better than using unsimulated vals?
1467       RB_body_get_position(rbo->shared->physics_object, eff_loc);
1468       RB_body_get_linear_velocity(rbo->shared->physics_object, eff_vel);
1469
1470       pd_point_from_loc(scene, eff_loc, eff_vel, 0, &epoint);
1471
1472       /* calculate net force of effectors, and apply to sim object
1473        * - we use 'central force' since apply force requires a "relative position" which we don't have...
1474        */
1475       BKE_effectors_apply(effectors, NULL, effector_weights, &epoint, eff_force, NULL);
1476       if (G.f & G_DEBUG) {
1477         printf("\tapplying force (%f,%f,%f) to '%s'\n",
1478                eff_force[0],
1479                eff_force[1],
1480                eff_force[2],
1481                ob->id.name + 2);
1482       }
1483       /* activate object in case it is deactivated */
1484       if (!is_zero_v3(eff_force)) {
1485         RB_body_activate(rbo->shared->physics_object);
1486       }
1487       RB_body_apply_central_force(rbo->shared->physics_object, eff_force);
1488     }
1489     else if (G.f & G_DEBUG) {
1490       printf("\tno forces to apply to '%s'\n", ob->id.name + 2);
1491     }
1492
1493     /* cleanup */
1494     BKE_effectors_free(effectors);
1495   }
1496   /* NOTE: passive objects don't need to be updated since they don't move */
1497
1498   /* NOTE: no other settings need to be explicitly updated here,
1499    * since RNA setters take care of the rest :)
1500    */
1501 }
1502
1503 /**
1504  * Updates and validates world, bodies and shapes.
1505  *
1506  * \param rebuild: Rebuild entire simulation
1507  */
1508 static void rigidbody_update_simulation(Depsgraph *depsgraph,
1509                                         Scene *scene,
1510                                         RigidBodyWorld *rbw,
1511                                         bool rebuild)
1512 {
1513   float ctime = DEG_get_ctime(depsgraph);
1514
1515   /* update world */
1516   if (rebuild) {
1517     BKE_rigidbody_validate_sim_world(scene, rbw, true);
1518   }
1519   rigidbody_update_sim_world(scene, rbw);
1520
1521   /* XXX TODO For rebuild: remove all constraints first.
1522    * Otherwise we can end up deleting objects that are still
1523    * referenced by constraints, corrupting bullet's internal list.
1524    *
1525    * Memory management needs redesign here, this is just a dirty workaround.
1526    */
1527   if (rebuild && rbw->constraints) {
1528     FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (rbw->constraints, ob) {
1529       RigidBodyCon *rbc = ob->rigidbody_constraint;
1530       if (rbc && rbc->physics_constraint) {
1531         RB_dworld_remove_constraint(rbw->shared->physics_world, rbc->physics_constraint);
1532         RB_constraint_delete(rbc->physics_constraint);
1533         rbc->physics_constraint = NULL;
1534       }
1535     }
1536     FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
1537   }
1538
1539   /* update objects */
1540   FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (rbw->group, ob) {
1541     if (ob->type == OB_MESH) {
1542       /* validate that we've got valid object set up here... */
1543       RigidBodyOb *rbo = ob->rigidbody_object;
1544       /* update transformation matrix of the object so we don't get a frame of lag for simple animations */
1545       BKE_object_where_is_calc_time(depsgraph, scene, ob, ctime);
1546
1547       /* TODO remove this whole block once we are sure we never get NULL rbo here anymore. */
1548       /* This cannot be done in CoW evaluation context anymore... */
1549       if (rbo == NULL) {
1550         BLI_assert(!"CoW object part of RBW object collection without RB object data, should not happen.\n");
1551         /* Since this object is included in the sim group but doesn't have
1552          * rigid body settings (perhaps it was added manually), add!
1553          * - assume object to be active? That is the default for newly added settings...
1554          */
1555         ob->rigidbody_object = BKE_rigidbody_create_object(scene, ob, RBO_TYPE_ACTIVE);
1556         rigidbody_validate_sim_object(rbw, ob, true);
1557
1558         rbo = ob->rigidbody_object;
1559       }
1560       else {
1561         /* perform simulation data updates as tagged */
1562         /* refresh object... */
1563         if (rebuild) {
1564           /* World has been rebuilt so rebuild object */
1565           /* TODO(Sybren): rigidbody_validate_sim_object() can call rigidbody_validate_sim_shape(),
1566            * but neither resets the RBO_FLAG_NEEDS_RESHAPE flag nor calls RB_body_set_collision_shape().
1567            * This results in the collision shape being created twice, which is unnecessary. */
1568           rigidbody_validate_sim_object(rbw, ob, true);
1569         }
1570         else if (rbo->flag & RBO_FLAG_NEEDS_VALIDATE) {
1571           rigidbody_validate_sim_object(rbw, ob, false);
1572         }
1573         /* refresh shape... */
1574         if (rbo->flag & RBO_FLAG_NEEDS_RESHAPE) {
1575           /* mesh/shape data changed, so force shape refresh */
1576           rigidbody_validate_sim_shape(ob, true);
1577           /* now tell RB sim about it */
1578           // XXX: we assume that this can only get applied for active/passive shapes that will be included as rigidbodies
1579           RB_body_set_collision_shape(rbo->shared->physics_object, rbo->shared->physics_shape);
1580         }
1581       }
1582       rbo->flag &= ~(RBO_FLAG_NEEDS_VALIDATE | RBO_FLAG_NEEDS_RESHAPE);
1583
1584       /* update simulation object... */
1585       rigidbody_update_sim_ob(depsgraph, scene, rbw, ob, rbo);
1586     }
1587   }
1588   FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
1589
1590   /* update constraints */
1591   if (rbw->constraints == NULL) { /* no constraints, move on */
1592     return;
1593   }
1594
1595   FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (rbw->constraints, ob) {
1596     /* validate that we've got valid object set up here... */
1597     RigidBodyCon *rbc = ob->rigidbody_constraint;
1598     /* update transformation matrix of the object so we don't get a frame of lag for simple animations */
1599     BKE_object_where_is_calc_time(depsgraph, scene, ob, ctime);
1600
1601     /* TODO remove this whole block once we are sure we never get NULL rbo here anymore. */
1602     /* This cannot be done in CoW evaluation context anymore... */
1603     if (rbc == NULL) {
1604       BLI_assert(!"CoW object part of RBW constraints collection without RB constraint data, should not happen.\n");
1605       /* Since this object is included in the group but doesn't have
1606        * constraint settings (perhaps it was added manually), add!
1607        */
1608       ob->rigidbody_constraint = BKE_rigidbody_create_constraint(scene, ob, RBC_TYPE_FIXED);
1609       rigidbody_validate_sim_constraint(rbw, ob, true);
1610
1611       rbc = ob->rigidbody_constraint;
1612     }
1613     else {
1614       /* perform simulation data updates as tagged */
1615       if (rebuild) {
1616         /* World has been rebuilt so rebuild constraint */
1617         rigidbody_validate_sim_constraint(rbw, ob, true);
1618       }
1619       else if (rbc->flag & RBC_FLAG_NEEDS_VALIDATE) {
1620         rigidbody_validate_sim_constraint(rbw, ob, false);
1621       }
1622     }
1623     rbc->flag &= ~RBC_FLAG_NEEDS_VALIDATE;
1624   }
1625   FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
1626 }
1627
1628 static void rigidbody_update_simulation_post_step(Depsgraph *depsgraph, RigidBodyWorld *rbw)
1629 {
1630   ViewLayer *view_layer = DEG_get_input_view_layer(depsgraph);
1631
1632   FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (rbw->group, ob) {
1633     Base *base = BKE_view_layer_base_find(view_layer, ob);
1634     RigidBodyOb *rbo = ob->rigidbody_object;
1635     /* Reset kinematic state for transformed objects. */
1636     if (rbo && base && (base->flag & BASE_SELECTED) && (G.moving & G_TRANSFORM_OBJ)) {
1637       RB_body_set_kinematic_state(rbo->shared->physics_object,
1638                                   rbo->flag & RBO_FLAG_KINEMATIC || rbo->flag & RBO_FLAG_DISABLED);
1639       RB_body_set_mass(rbo->shared->physics_object, RBO_GET_MASS(rbo));
1640       /* Deactivate passive objects so they don't interfere with deactivation of active objects. */
1641       if (rbo->type == RBO_TYPE_PASSIVE) {
1642         RB_body_deactivate(rbo->shared->physics_object);
1643       }
1644     }
1645   }
1646   FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
1647 }
1648
1649 bool BKE_rigidbody_check_sim_running(RigidBodyWorld *rbw, float ctime)
1650 {
1651   return (rbw && (rbw->flag & RBW_FLAG_MUTED) == 0 && ctime > rbw->shared->pointcache->startframe);
1652 }
1653
1654 /* Sync rigid body and object transformations */
1655 void BKE_rigidbody_sync_transforms(RigidBodyWorld *rbw, Object *ob, float ctime)
1656 {
1657   RigidBodyOb *rbo = ob->rigidbody_object;
1658
1659   /* keep original transform for kinematic and passive objects */
1660   if (ELEM(NULL, rbw, rbo) || rbo->flag & RBO_FLAG_KINEMATIC || rbo->type == RBO_TYPE_PASSIVE) {
1661     return;
1662   }
1663
1664   /* use rigid body transform after cache start frame if objects is not being transformed */
1665   if (BKE_rigidbody_check_sim_running(rbw, ctime) &&
1666       !(ob->flag & SELECT && G.moving & G_TRANSFORM_OBJ)) {
1667     float mat[4][4], size_mat[4][4], size[3];
1668
1669     normalize_qt(rbo->orn);  // RB_TODO investigate why quaternion isn't normalized at this point
1670     quat_to_mat4(mat, rbo->orn);
1671     copy_v3_v3(mat[3], rbo->pos);
1672
1673     mat4_to_size(size, ob->obmat);
1674     size_to_mat4(size_mat, size);
1675     mul_m4_m4m4(mat, mat, size_mat);
1676
1677     copy_m4_m4(ob->obmat, mat);
1678   }
1679   /* otherwise set rigid body transform to current obmat */
1680   else {
1681     mat4_to_loc_quat(rbo->pos, rbo->orn, ob->obmat);
1682   }
1683 }
1684
1685 /* Used when canceling transforms - return rigidbody and object to initial states */
1686 void BKE_rigidbody_aftertrans_update(
1687     Object *ob, float loc[3], float rot[3], float quat[4], float rotAxis[3], float rotAngle)
1688 {
1689   RigidBodyOb *rbo = ob->rigidbody_object;
1690   bool correct_delta = !(rbo->flag & RBO_FLAG_KINEMATIC || rbo->type == RBO_TYPE_PASSIVE);
1691
1692   /* return rigid body and object to their initial states */
1693   copy_v3_v3(rbo->pos, ob->loc);
1694   copy_v3_v3(ob->loc, loc);
1695
1696   if (correct_delta) {
1697     add_v3_v3(rbo->pos, ob->dloc);
1698   }
1699
1700   if (ob->rotmode > 0) {
1701     float qt[4];
1702     eulO_to_quat(qt, ob->rot, ob->rotmode);
1703
1704     if (correct_delta) {
1705       float dquat[4];
1706       eulO_to_quat(dquat, ob->drot, ob->rotmode);
1707
1708       mul_qt_qtqt(rbo->orn, dquat, qt);
1709     }
1710     else {
1711       copy_qt_qt(rbo->orn, qt);
1712     }
1713
1714     copy_v3_v3(ob->rot, rot);
1715   }
1716   else if (ob->rotmode == ROT_MODE_AXISANGLE) {
1717     float qt[4];
1718     axis_angle_to_quat(qt, ob->rotAxis, ob->rotAngle);
1719
1720     if (correct_delta) {
1721       float dquat[4];
1722       axis_angle_to_quat(dquat, ob->drotAxis, ob->drotAngle);
1723
1724       mul_qt_qtqt(rbo->orn, dquat, qt);
1725     }
1726     else {
1727       copy_qt_qt(rbo->orn, qt);
1728     }
1729
1730     copy_v3_v3(ob->rotAxis, rotAxis);
1731     ob->rotAngle = rotAngle;
1732   }
1733   else {
1734     if (correct_delta) {
1735       mul_qt_qtqt(rbo->orn, ob->dquat, ob->quat);
1736     }
1737     else {
1738       copy_qt_qt(rbo->orn, ob->quat);
1739     }
1740
1741     copy_qt_qt(ob->quat, quat);
1742   }
1743
1744   if (rbo->shared->physics_object) {
1745     /* allow passive objects to return to original transform */
1746     if (rbo->type == RBO_TYPE_PASSIVE) {
1747       RB_body_set_kinematic_state(rbo->shared->physics_object, true);
1748     }
1749     RB_body_set_loc_rot(rbo->shared->physics_object, rbo->pos, rbo->orn);
1750   }
1751   // RB_TODO update rigid body physics object's loc/rot for dynamic objects here as well (needs to be done outside bullet's update loop)
1752 }
1753
1754 void BKE_rigidbody_cache_reset(RigidBodyWorld *rbw)
1755 {
1756   if (rbw) {
1757     rbw->shared->pointcache->flag |= PTCACHE_OUTDATED;
1758   }
1759 }
1760
1761 /* ------------------ */
1762
1763 /* Rebuild rigid body world */
1764 /* NOTE: this needs to be called before frame update to work correctly */
1765 void BKE_rigidbody_rebuild_world(Depsgraph *depsgraph, Scene *scene, float ctime)
1766 {
1767   RigidBodyWorld *rbw = scene->rigidbody_world;
1768   PointCache *cache;
1769   PTCacheID pid;
1770   int startframe, endframe;
1771
1772   BKE_ptcache_id_from_rigidbody(&pid, NULL, rbw);
1773   BKE_ptcache_id_time(&pid, scene, ctime, &startframe, &endframe, NULL);
1774   cache = rbw->shared->pointcache;
1775
1776   /* flag cache as outdated if we don't have a world or number of objects in the simulation has changed */
1777   int n = 0;
1778   FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN (rbw->group, object) {
1779     (void)object;
1780     n++;
1781   }
1782   FOREACH_COLLECTION_OBJECT_RECURSIVE_END;
1783
1784   if (rbw->shared->physics_world == NULL || rbw->numbodies != n) {
1785     cache->flag |= PTCACHE_OUTDATED;
1786   }
1787
1788   if (ctime == startframe + 1 && rbw->ltime == startframe) {
1789     if (cache->flag & PTCACHE_OUTDATED) {
1790       BKE_ptcache_id_reset(scene, &pid, PTCACHE_RESET_OUTDATED);
1791       rigidbody_update_simulation(depsgraph, scene, rbw, true);
1792       BKE_ptcache_validate(cache, (int)ctime);
1793       cache->last_exact = 0;
1794       cache->flag &= ~PTCACHE_REDO_NEEDED;
1795     }
1796   }
1797 }
1798
1799 /* Run RigidBody simulation for the specified physics world */
1800 void BKE_rigidbody_do_simulation(Depsgraph *depsgraph, Scene *scene, float ctime)
1801 {
1802   float timestep;
1803   RigidBodyWorld *rbw = scene->rigidbody_world;
1804   PointCache *cache;
1805   PTCacheID pid;
1806   int startframe, endframe;
1807
1808   BKE_ptcache_id_from_rigidbody(&pid, NULL, rbw);
1809   BKE_ptcache_id_time(&pid, scene, ctime, &startframe, &endframe, NULL);
1810   cache = rbw->shared->pointcache;
1811
1812   if (ctime <= startframe) {
1813     rbw->ltime = startframe;
1814     return;
1815   }
1816   /* make sure we don't go out of cache frame range */
1817   else if (ctime > endframe) {
1818     ctime = endframe;
1819   }
1820
1821   /* don't try to run the simulation if we don't have a world yet but allow reading baked cache */
1822   if (rbw->shared->physics_world == NULL && !(cache->flag & PTCACHE_BAKED)) {
1823     return;
1824   }
1825   else if (rbw->objects == NULL) {
1826     rigidbody_update_ob_array(rbw);
1827   }
1828
1829   /* try to read from cache */
1830   // RB_TODO deal with interpolated, old and baked results
1831   bool can_simulate = (ctime == rbw->ltime + 1) && !(cache->flag & PTCACHE_BAKED);
1832
1833   if (BKE_ptcache_read(&pid, ctime, can_simulate) == PTCACHE_READ_EXACT) {
1834     BKE_ptcache_validate(cache, (int)ctime);
1835     rbw->ltime = ctime;
1836     return;
1837   }
1838
1839   if (!DEG_is_active(depsgraph)) {
1840     /* When the depsgraph is inactive we should neither write to the cache
1841      * nor run the simulation. */
1842     return;
1843   }
1844
1845   /* advance simulation, we can only step one frame forward */
1846   if (compare_ff_relative(ctime, rbw->ltime + 1, FLT_EPSILON, 64)) {
1847     /* write cache for first frame when on second frame */
1848     if (rbw->ltime == startframe && (cache->flag & PTCACHE_OUTDATED || cache->last_exact == 0)) {
1849       BKE_ptcache_write(&pid, startframe);
1850     }
1851
1852     /* update and validate simulation */
1853     rigidbody_update_simulation(depsgraph, scene, rbw, false);
1854
1855     /* calculate how much time elapsed since last step in seconds */
1856     timestep = 1.0f / (float)FPS * (ctime - rbw->ltime) * rbw->time_scale;
1857     /* step simulation by the requested timestep, steps per second are adjusted to take time scale into account */
1858     RB_dworld_step_simulation(rbw->shared->physics_world,
1859                               timestep,
1860                               INT_MAX,
1861                               1.0f / (float)rbw->steps_per_second * min_ff(rbw->time_scale, 1.0f));
1862
1863     rigidbody_update_simulation_post_step(depsgraph, rbw);
1864
1865     /* write cache for current frame */
1866     BKE_ptcache_validate(cache, (int)ctime);
1867     BKE_ptcache_write(&pid, (unsigned int)ctime);
1868
1869     rbw->ltime = ctime;
1870   }
1871 }
1872 /* ************************************** */
1873
1874 #else /* WITH_BULLET */
1875
1876 /* stubs */
1877 #  if defined(__GNUC__) || defined(__clang__)
1878 #    pragma GCC diagnostic push
1879 #    pragma GCC diagnostic ignored "-Wunused-parameter"
1880 #  endif
1881
1882 struct RigidBodyOb *BKE_rigidbody_copy_object(const Object *ob, const int flag)
1883 {
1884   return NULL;
1885 }
1886 struct RigidBodyCon *BKE_rigidbody_copy_constraint(const Object *ob, const int flag)
1887 {
1888   return NULL;
1889 }
1890 void BKE_rigidbody_validate_sim_world(Scene *scene, RigidBodyWorld *rbw, bool rebuild)
1891 {
1892 }
1893 void BKE_rigidbody_calc_volume(Object *ob, float *r_vol)
1894 {
1895   if (r_vol) {
1896     *r_vol = 0.0f;
1897   }
1898 }
1899 void BKE_rigidbody_calc_center_of_mass(Object *ob, float r_center[3])
1900 {
1901   zero_v3(r_center);
1902 }
1903 struct RigidBodyWorld *BKE_rigidbody_create_world(Scene *scene)
1904 {
1905   return NULL;
1906 }
1907 struct RigidBodyWorld *BKE_rigidbody_world_copy(RigidBodyWorld *rbw, const int flag)
1908 {
1909   return NULL;
1910 }
1911 void BKE_rigidbody_world_groups_relink(struct RigidBodyWorld *rbw)
1912 {
1913 }
1914 void BKE_rigidbody_world_id_loop(struct RigidBodyWorld *rbw,
1915                                  RigidbodyWorldIDFunc func,
1916                                  void *userdata)
1917 {
1918 }
1919 struct RigidBodyOb *BKE_rigidbody_create_object(Scene *scene, Object *ob, short type)
1920 {
1921   return NULL;
1922 }
1923 struct RigidBodyCon *BKE_rigidbody_create_constraint(Scene *scene, Object *ob, short type)
1924 {
1925   return NULL;
1926 }
1927 struct RigidBodyWorld *BKE_rigidbody_get_world(Scene *scene)
1928 {
1929   return NULL;
1930 }
1931 void BKE_rigidbody_remove_object(struct Main *bmain, Scene *scene, Object *ob)
1932 {
1933 }
1934 void BKE_rigidbody_remove_constraint(Scene *scene, Object *ob)
1935 {
1936 }
1937 void BKE_rigidbody_sync_transforms(RigidBodyWorld *rbw, Object *ob, float ctime)
1938 {
1939 }
1940 void BKE_rigidbody_aftertrans_update(
1941     Object *ob, float loc[3], float rot[3], float quat[4], float rotAxis[3], float rotAngle)
1942 {
1943 }
1944 bool BKE_rigidbody_check_sim_running(RigidBodyWorld *rbw, float ctime)
1945 {
1946   return false;
1947 }
1948 void BKE_rigidbody_cache_reset(RigidBodyWorld *rbw)
1949 {
1950 }
1951 void BKE_rigidbody_rebuild_world(Depsgraph *depsgraph, Scene *scene, float ctime)
1952 {
1953 }
1954 void BKE_rigidbody_do_simulation(Depsgraph *depsgraph, Scene *scene, float ctime)
1955 {
1956 }
1957 void BKE_rigidbody_objects_collection_validate(Scene *scene, RigidBodyWorld *rbw)
1958 {
1959 }
1960 void BKE_rigidbody_constraints_collection_validate(Scene *scene, RigidBodyWorld *rbw)
1961 {
1962 }
1963 void BKE_rigidbody_main_collection_object_add(Main *bmain, Collection *collection, Object *object)
1964 {
1965 }
1966
1967 #  if defined(__GNUC__) || defined(__clang__)
1968 #    pragma GCC diagnostic pop
1969 #  endif
1970
1971 #endif /* WITH_BULLET */
1972
1973 /* -------------------- */
1974 /* Depsgraph evaluation */
1975
1976 void BKE_rigidbody_rebuild_sim(Depsgraph *depsgraph, Scene *scene)
1977 {
1978   float ctime = DEG_get_ctime(depsgraph);
1979   DEG_debug_print_eval_time(depsgraph, __func__, scene->id.name, scene, ctime);
1980   /* rebuild sim data (i.e. after resetting to start of timeline) */
1981   if (BKE_scene_check_rigidbody_active(scene)) {
1982     BKE_rigidbody_rebuild_world(depsgraph, scene, ctime);
1983   }
1984 }
1985
1986 void BKE_rigidbody_eval_simulation(Depsgraph *depsgraph, Scene *scene)
1987 {
1988   float ctime = DEG_get_ctime(depsgraph);
1989   DEG_debug_print_eval_time(depsgraph, __func__, scene->id.name, scene, ctime);
1990
1991   /* evaluate rigidbody sim */
1992   if (!BKE_scene_check_rigidbody_active(scene)) {
1993     return;
1994   }
1995   BKE_rigidbody_do_simulation(depsgraph, scene, ctime);
1996 }
1997
1998 void BKE_rigidbody_object_sync_transforms(Depsgraph *depsgraph, Scene *scene, Object *ob)
1999 {
2000   RigidBodyWorld *rbw = scene->rigidbody_world;
2001   float ctime = DEG_get_ctime(depsgraph);
2002   DEG_debug_print_eval_time(depsgraph, __func__, ob->id.name, ob, ctime);
2003   /* read values pushed into RBO from sim/cache... */
2004   BKE_rigidbody_sync_transforms(rbw, ob, ctime);
2005 }