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