67static CLG_LogRef
LOG = {
"physics.rigidbody"};
101 rbw->
shared->
runtime = MEM_new<RigidBodyWorld_Runtime>(__func__);
126 if (
object->rigidbody_constraint) {
172 if (rbo ==
nullptr) {
189 for (
Scene *scene =
G_MAIN->scenes.first(); scene !=
nullptr;
190 scene =
static_cast<Scene *
>(scene->id.next))
222 if (rbc ==
nullptr) {
261static const Mesh *rigidbody_get_mesh(
Object *ob)
265 switch (ob->rigidbody_object->mesh_source) {
275 return (
Mesh *)ob->runtime->data_orig;
290 const float (*positions)[3] =
nullptr;
294 mesh = rigidbody_get_mesh(ob);
295 positions = (
mesh) ?
reinterpret_cast<const float (*)[3]
>(
mesh->vert_positions().data()) :
297 totvert = (
mesh) ?
mesh->verts_num : 0;
300 CLOG_ERROR(&
LOG,
"cannot make Convex Hull collision shape for non-Mesh object");
305 (
float *)positions,
sizeof(
float[3]), totvert, margin, can_embed);
308 CLOG_ERROR(&
LOG,
"no vertices to define Convex Hull collision shape with");
322 const Mesh *
mesh = rigidbody_get_mesh(ob);
323 if (
mesh ==
nullptr) {
328 const int totvert =
mesh->verts_num;
330 const int tottri = corner_tris.
size();
334 if ((totvert == 0) || (tottri == 0)) {
336 &
LOG,
"no geometry data converted for Mesh Collision Shape (ob = %s)", ob->id.
name + 2);
350 if (positions.
data()) {
351 for (i = 0; i < tottri; i++) {
353 const int3 &tri = corner_tris[i];
356 vtri[0] = corner_verts[tri[0]];
357 vtri[1] = corner_verts[tri[1]];
358 vtri[2] = corner_verts[tri[2]];
384 CLOG_ERROR(&
LOG,
"cannot make Triangular Mesh collision shape for non-Mesh object");
397 float size[3] = {1.0f, 1.0f, 1.0f};
400 float capsule_height;
401 float hull_margin = 0.0f;
402 bool can_embed =
true;
406 if (rbo ==
nullptr) {
424 radius = std::max(size[0], size[1]);
433 switch (rbo->shape) {
443 capsule_height = (height -
radius) * 2.0f;
455 has_volume = (std::min({
size[0],
size[1],
size[2]}) > 0.0f);
460 new_shape = rigidbody_get_shape_convexhull_from_mesh(ob, hull_margin, &can_embed);
462 rbo->margin = (can_embed && has_volume) ?
468 new_shape = rigidbody_get_shape_trimesh_from_mesh(ob);
473 float loc[3],
rot[4];
477 if (childObject->parent == ob) {
478 childShape = rigidbody_validate_sim_shape_helper(rbw, childObject);
491 if (new_shape ==
nullptr) {
510 if (rbo ==
nullptr) {
515 if (rbo->shared->physics_shape && !rebuild) {
520 if (ob->parent !=
nullptr && ob->parent->rigidbody_object !=
nullptr &&
526 new_shape = rigidbody_validate_sim_shape_helper(rbw, ob);
530 if (rbo->shared->physics_shape) {
533 rbo->shared->physics_shape = new_shape;
534 if (rbo->shared->physics_object) {
547 float size[3] = {1.0f, 1.0f, 1.0f};
564 radius = std::max(size[0], size[1]) * 0.5f;
573 switch (rbo->shape) {
597 const Mesh *
mesh = rigidbody_get_mesh(ob);
598 if (
mesh ==
nullptr) {
615 volume *=
fabsf(volume_scale);
637 float size[3] = {1.0f, 1.0f, 1.0f};
652 switch (rbo->shape) {
666 r_center[2] = -0.25f * height;
672 const Mesh *
mesh = rigidbody_get_mesh(ob);
673 if (
mesh ==
nullptr) {
685 mesh->corner_verts().data(),
711 if (rbo ==
nullptr) {
718 if (rbo->shared->physics_shape ==
nullptr || rebuild) {
719 rigidbody_validate_sim_shape(rbw, ob,
true);
722 if (rbo->shared->physics_object && !rebuild) {
726 static_cast<rbRigidBody *
>(rbo->shared->physics_object));
728 if (!rbo->shared->physics_object || rebuild) {
730 if (rbo->shared->physics_object) {
732 rbo->shared->physics_object =
nullptr;
735 if (ob->parent !=
nullptr && ob->parent->rigidbody_object !=
nullptr &&
754 rbo->lin_sleep_thresh,
755 rbo->ang_sleep_thresh);
777 if (rbw && rbw->shared->runtime->physics_world && rbo->shared->physics_object) {
779 static_cast<rbRigidBody *
>(rbo->shared->physics_object),
786static void rigidbody_constraint_init_spring(
RigidBodyCon *rbc,
791 set_spring(
static_cast<rbConstraint *
>(rbc->physics_constraint),
794 set_stiffness(
static_cast<rbConstraint *
>(rbc->physics_constraint),
796 rbc->spring_stiffness_x);
800 set_spring(
static_cast<rbConstraint *
>(rbc->physics_constraint),
803 set_stiffness(
static_cast<rbConstraint *
>(rbc->physics_constraint),
805 rbc->spring_stiffness_y);
809 set_spring(
static_cast<rbConstraint *
>(rbc->physics_constraint),
812 set_stiffness(
static_cast<rbConstraint *
>(rbc->physics_constraint),
814 rbc->spring_stiffness_z);
818 set_spring(
static_cast<rbConstraint *
>(rbc->physics_constraint),
821 set_stiffness(
static_cast<rbConstraint *
>(rbc->physics_constraint),
823 rbc->spring_stiffness_ang_x);
824 set_damping(
static_cast<rbConstraint *
>(rbc->physics_constraint),
826 rbc->spring_damping_ang_x);
828 set_spring(
static_cast<rbConstraint *
>(rbc->physics_constraint),
831 set_stiffness(
static_cast<rbConstraint *
>(rbc->physics_constraint),
833 rbc->spring_stiffness_ang_y);
834 set_damping(
static_cast<rbConstraint *
>(rbc->physics_constraint),
836 rbc->spring_damping_ang_y);
838 set_spring(
static_cast<rbConstraint *
>(rbc->physics_constraint),
841 set_stiffness(
static_cast<rbConstraint *
>(rbc->physics_constraint),
843 rbc->spring_stiffness_ang_z);
844 set_damping(
static_cast<rbConstraint *
>(rbc->physics_constraint),
846 rbc->spring_damping_ang_z);
849static void rigidbody_constraint_set_limits(
RigidBodyCon *rbc,
853 set_limits(
static_cast<rbConstraint *
>(rbc->physics_constraint),
855 rbc->limit_lin_x_lower,
856 rbc->limit_lin_x_upper);
863 set_limits(
static_cast<rbConstraint *
>(rbc->physics_constraint),
865 rbc->limit_lin_y_lower,
866 rbc->limit_lin_y_upper);
873 set_limits(
static_cast<rbConstraint *
>(rbc->physics_constraint),
875 rbc->limit_lin_z_lower,
876 rbc->limit_lin_z_upper);
883 set_limits(
static_cast<rbConstraint *
>(rbc->physics_constraint),
885 rbc->limit_ang_x_lower,
886 rbc->limit_ang_x_upper);
893 set_limits(
static_cast<rbConstraint *
>(rbc->physics_constraint),
895 rbc->limit_ang_y_lower,
896 rbc->limit_ang_y_upper);
903 set_limits(
static_cast<rbConstraint *
>(rbc->physics_constraint),
905 rbc->limit_ang_z_lower,
906 rbc->limit_ang_z_upper);
932 if (rbc ==
nullptr) {
936 if (
ELEM(
nullptr, rbc->ob1, rbc->ob1->rigidbody_object, rbc->ob2, rbc->ob2->rigidbody_object)) {
937 if (rbc->physics_constraint) {
941 rbc->physics_constraint =
nullptr;
946 if (rbc->physics_constraint && rebuild ==
false) {
950 if (rbc->physics_constraint ==
nullptr || rebuild) {
952 rbc->ob1->rigidbody_object->shared->physics_object);
954 rbc->ob2->rigidbody_object->shared->physics_object);
957 if (rbc->physics_constraint) {
959 rbc->physics_constraint =
nullptr;
976 rbc->limit_ang_z_lower,
977 rbc->limit_ang_z_upper);
981 static_cast<rbConstraint *
>(rbc->physics_constraint), 0.0f, -1.0f);
988 rbc->limit_lin_x_lower,
989 rbc->limit_lin_x_upper);
993 static_cast<rbConstraint *
>(rbc->physics_constraint), 0.0f, -1.0f);
999 lin_lower = rbc->limit_lin_x_lower;
1000 lin_upper = rbc->limit_lin_x_upper;
1007 ang_lower = rbc->limit_ang_x_lower;
1008 ang_upper = rbc->limit_ang_x_upper;
1024 rigidbody_constraint_init_spring(rbc,
1037 rigidbody_constraint_init_spring(rbc,
1060 rbc->motor_lin_max_impulse,
1061 rbc->motor_ang_max_impulse);
1064 rbc->motor_lin_target_velocity,
1065 rbc->motor_ang_target_velocity);
1074 if (rbc->physics_constraint ==
nullptr) {
1083 rbc->breaking_threshold);
1092 rbc->num_solver_iterations);
1100 if (rbw && rbw->shared->runtime->physics_world && rbc->physics_constraint) {
1112 if (rbw ==
nullptr) {
1117 if (rebuild || rbw->shared->runtime->physics_world ==
nullptr) {
1118 if (rbw->shared->runtime->physics_world) {
1121 rbw->shared->runtime->physics_world =
RB_dworld_new(scene->physics_settings.gravity);
1141 if (scene ==
nullptr) {
1146 rbw = MEM_new<RigidBodyWorld>(
"RigidBodyWorld");
1147 rbw->shared = MEM_new<RigidBodyWorld_Shared>(
"RigidBodyWorld_Shared");
1152 rbw->ltime = scene->playback_start();
1154 rbw->time_scale = 1.0f;
1158 rbw->substeps_per_frame = 10;
1159 rbw->num_solver_iterations = 10;
1162 rbw->shared->pointcache->step = 1;
1174 if (rbw->effector_weights) {
1176 MEM_dupalloc(rbw->effector_weights));
1188 rbw_copy->shared = MEM_new<RigidBodyWorld_Shared>(
"RigidBodyWorld_Shared");
1190 rbw_copy->shared->pointcache = rbw_copy->shared->ptcaches.first();
1194 rbw_copy->objects =
nullptr;
1195 rbw_copy->numbodies = 0;
1196 rigidbody_update_ob_array(rbw_copy);
1218 if (ob ==
nullptr) {
1221 if (ob->rigidbody_object !=
nullptr) {
1222 return ob->rigidbody_object;
1226 rbo = MEM_new<RigidBodyOb>(
"RigidBodyOb");
1227 rbo->shared = MEM_new<RigidBodyOb_Shared>(
"RigidBodyOb_Shared");
1234 rbo->friction = 0.5f;
1235 rbo->restitution = 0.0f;
1237 rbo->margin = 0.04f;
1239 rbo->lin_sleep_thresh = 0.4f;
1240 rbo->ang_sleep_thresh = 0.5f;
1242 rbo->lin_damping = 0.04f;
1243 rbo->ang_damping = 0.1f;
1245 rbo->col_groups = 1;
1280 if (ob ==
nullptr || (ob->rigidbody_constraint !=
nullptr)) {
1285 rbc = MEM_new<RigidBodyCon>(
"RigidBodyCon");
1299 rbc->breaking_threshold = 10.0f;
1300 rbc->num_solver_iterations = 10;
1302 rbc->limit_lin_x_lower = -1.0f;
1303 rbc->limit_lin_x_upper = 1.0f;
1304 rbc->limit_lin_y_lower = -1.0f;
1305 rbc->limit_lin_y_upper = 1.0f;
1306 rbc->limit_lin_z_lower = -1.0f;
1307 rbc->limit_lin_z_upper = 1.0f;
1308 rbc->limit_ang_x_lower = -
M_PI_4;
1309 rbc->limit_ang_x_upper =
M_PI_4;
1310 rbc->limit_ang_y_lower = -
M_PI_4;
1311 rbc->limit_ang_y_upper =
M_PI_4;
1312 rbc->limit_ang_z_lower = -
M_PI_4;
1313 rbc->limit_ang_z_upper =
M_PI_4;
1315 rbc->spring_damping_x = 0.5f;
1316 rbc->spring_damping_y = 0.5f;
1317 rbc->spring_damping_z = 0.5f;
1318 rbc->spring_damping_ang_x = 0.5f;
1319 rbc->spring_damping_ang_y = 0.5f;
1320 rbc->spring_damping_ang_z = 0.5f;
1321 rbc->spring_stiffness_x = 10.0f;
1322 rbc->spring_stiffness_y = 10.0f;
1323 rbc->spring_stiffness_z = 10.0f;
1324 rbc->spring_stiffness_ang_x = 10.0f;
1325 rbc->spring_stiffness_ang_y = 10.0f;
1326 rbc->spring_stiffness_ang_z = 10.0f;
1328 rbc->motor_lin_max_impulse = 1.0f;
1329 rbc->motor_lin_target_velocity = 1.0f;
1330 rbc->motor_ang_max_impulse = 1.0f;
1331 rbc->motor_ang_target_velocity = 1.0f;
1342 if (rbw->group !=
nullptr) {
1357 if (rbw->constraints !=
nullptr) {
1359 if (
object->rigidbody_constraint !=
nullptr) {
1371 for (
Scene *scene = bmain->scenes.first(); scene; scene =
static_cast<Scene *
>(scene->id.next)) {
1374 if (rbw ==
nullptr) {
1378 if (rbw->group == collection &&
object->type ==
OB_MESH &&
object->rigidbody_object ==
nullptr)
1382 if (rbw->constraints == collection &&
object->rigidbody_constraint ==
nullptr) {
1395 if (scene ==
nullptr) {
1399 return scene->rigidbody_world;
1402static bool rigidbody_add_object_to_scene(
Main *bmain,
Scene *scene,
Object *ob)
1406 if (rbw ==
nullptr) {
1408 if (rbw ==
nullptr) {
1413 scene->rigidbody_world = rbw;
1416 if (rbw->group ==
nullptr) {
1431static bool rigidbody_add_constraint_to_scene(
Main *bmain,
Scene *scene,
Object *ob)
1435 if (rbw ==
nullptr) {
1437 if (rbw ==
nullptr) {
1442 scene->rigidbody_world = rbw;
1445 if (rbw->constraints ==
nullptr) {
1462 if (ob->rigidbody_object !=
nullptr) {
1464 for (
Scene *scene = bmain->scenes.first(); scene; scene =
static_cast<Scene *
>(scene->id.next))
1467 rigidbody_add_object_to_scene(bmain, scene, ob);
1471 if (ob->rigidbody_constraint !=
nullptr) {
1473 for (
Scene *scene = bmain->scenes.first(); scene; scene =
static_cast<Scene *
>(scene->id.next))
1476 rigidbody_add_constraint_to_scene(bmain, scene, ob);
1491 if (!rigidbody_add_object_to_scene(bmain, scene, ob)) {
1497 if (ob->rigidbody_object ==
nullptr) {
1500 ob->rigidbody_object->
type = type;
1519 for (i = 0; i < rbw->numbodies; i++) {
1520 if (rbw->objects[i] == ob) {
1521 rbw->objects[i] =
nullptr;
1528 if (rbw->constraints) {
1530 if (obt && obt->rigidbody_constraint) {
1531 rbc = obt->rigidbody_constraint;
1532 if (rbc->ob1 == ob) {
1535 rigidbody_validate_sim_constraint(rbw, obt,
false);
1537 if (rbc->ob2 == ob) {
1540 rigidbody_validate_sim_constraint(rbw, obt,
false);
1581 if (rbw !=
nullptr) {
1583 if (rbw->constraints !=
nullptr) {
1589 if (rbw->shared->runtime->physics_world && rbc->physics_constraint) {
1608 if (rbw->group ==
nullptr) {
1610 rbw->objects =
static_cast<Object **
>(realloc(rbw->objects, 0));
1618 if (
object->parent ==
nullptr ||
object->parent->rigidbody_object ==
nullptr ||
1626 if (rbw->numbodies != n) {
1628 rbw->objects =
static_cast<Object **
>(
1629 realloc(rbw->objects,
sizeof(
Object *) * rbw->numbodies));
1635 if (
object->parent ==
nullptr ||
object->parent->rigidbody_object ==
nullptr ||
1638 rbw->objects[i] =
object;
1647 float adj_gravity[3];
1651 copy_v3_v3(adj_gravity, scene->physics_settings.gravity);
1653 rbw->effector_weights->global_gravity * rbw->effector_weights->weight[0]);
1663 rigidbody_update_ob_array(rbw);
1666static void rigidbody_update_sim_ob(Depsgraph *depsgraph,
Object *ob,
RigidBodyOb *rbo)
1669 if (rbo->shared->physics_object ==
nullptr) {
1682 const float (*positions)[3] =
reinterpret_cast<const float (*)[3]
>(
1684 int totvert =
mesh->verts_num;
1698 float new_scale[3], old_scale[3];
1709 std::min({new_scale[0], new_scale[1], new_scale[2]}));
1731static void rigidbody_update_simulation(Depsgraph *depsgraph,
1739 if (rebuild || rbw->shared->runtime->physics_world ==
nullptr) {
1745 rigidbody_update_sim_world(scene, rbw);
1753 if (rebuild && rbw->constraints) {
1756 if (rbc && rbc->physics_constraint) {
1760 rbc->physics_constraint =
nullptr;
1774 if (rbo ==
nullptr) {
1776 "Evaluated object part of RBW object collection without RB object data, "
1777 "should not happen.\n");
1783 rigidbody_validate_sim_object(rbw, ob,
true);
1785 rbo = ob->rigidbody_object;
1796 rigidbody_validate_sim_object(rbw, ob,
true);
1799 rigidbody_validate_sim_object(rbw, ob,
false);
1804 rigidbody_validate_sim_shape(rbw, ob,
true);
1808 if (rbo->shared->physics_object !=
nullptr && rbo->shared->physics_shape !=
nullptr) {
1810 static_cast<rbRigidBody *
>(rbo->shared->physics_object),
1818 rigidbody_update_sim_ob(depsgraph, ob, rbo);
1824 if (rbw->constraints ==
nullptr) {
1834 if (rbc ==
nullptr) {
1837 "Evaluated object part of RBW constraints collection without RB constraint data, "
1838 "should not happen.\n");
1843 rigidbody_validate_sim_constraint(rbw, ob,
true);
1845 rbc = ob->rigidbody_constraint;
1851 rigidbody_validate_sim_constraint(rbw, ob,
true);
1854 rigidbody_validate_sim_constraint(rbw, ob,
false);
1862struct KinematicSubstepData {
1873static ListBaseT<LinkData> rigidbody_create_substep_data(
RigidBodyWorld *rbw)
1876 ListBaseT<LinkData> substep_targets = {
nullptr,
nullptr};
1881 if (!rbo || rbo->shared->physics_object ==
nullptr) {
1914 return substep_targets;
1917static void rigidbody_update_kinematic_obj_substep(ListBaseT<LinkData> *substep_targets,
1920 for (
LinkData &link : *substep_targets) {
1921 KinematicSubstepData *
data =
static_cast<KinematicSubstepData *
>(link.data);
1924 float loc[3],
rot[4];
1932 if (!
data->scale_changed) {
1951static void rigidbody_update_external_forces(Depsgraph *depsgraph,
1958 if (ob->
type !=
OB_MESH || rbo->shared->physics_object ==
nullptr) {
1965 ((ob->pd ==
nullptr) || (ob->pd->forcefield ==
PFIELD_NULL)))
1969 ListBaseT<EffectorCache> *effectors;
1974 float eff_force[3] = {0.0f, 0.0f, 0.0f};
1975 float eff_loc[3], eff_vel[3];
1991 effectors,
nullptr, effector_weights, &epoint, eff_force,
nullptr,
nullptr);
1993 printf(
"\tapplying force (%f,%f,%f) to '%s'\n",
2009 printf(
"\tno forces to apply to '%s'\n", ob->id.
name + 2);
2020static void rigidbody_free_substep_data(ListBaseT<LinkData> *substep_targets)
2022 for (
LinkData &link : *substep_targets) {
2023 KinematicSubstepData *
data =
static_cast<KinematicSubstepData *
>(link.data);
2027 substep_targets->free_no_destruct();
2029static void rigidbody_update_simulation_post_step(Depsgraph *depsgraph,
RigidBodyWorld *rbw)
2040 rbo->shared->physics_object)
2056 return (rbw && (rbw->flag &
RBW_FLAG_MUTED) == 0 && ctime > rbw->shared->pointcache->startframe);
2072 float mat[4][4], size_mat[4][4],
size[3];
2082 copy_m4_m4(ob->runtime->object_to_world.ptr(), mat);
2091 Object *ob,
float loc[3],
float rot[3],
float quat[4],
float rotAxis[3],
float rotAngle)
2100 if (correct_delta) {
2104 if (ob->rotmode > 0) {
2108 if (correct_delta) {
2124 if (correct_delta) {
2135 ob->rotAngle = rotAngle;
2138 if (correct_delta) {
2148 if (rbo->shared->physics_object) {
2154 static_cast<rbRigidBody *
>(rbo->shared->physics_object), rbo->pos, rbo->orn);
2174 int startframe, endframe;
2177 std::unique_lock
lock(rbw->shared->runtime->mutex);
2181 cache = rbw->shared->pointcache;
2189 if (
object->parent ==
nullptr ||
object->parent->rigidbody_object ==
nullptr ||
2197 if (rbw->shared->runtime->physics_world ==
nullptr || rbw->numbodies != n) {
2201 if (ctime == startframe + 1 && rbw->ltime == startframe) {
2204 rigidbody_update_simulation(depsgraph, scene, rbw,
true);
2206 cache->last_exact = 0;
2217 int startframe, endframe;
2221 cache = rbw->shared->pointcache;
2223 if (ctime <= startframe) {
2224 rbw->ltime = startframe;
2228 ctime = std::min<float>(ctime, endframe);
2231 if (rbw->shared->runtime->physics_world ==
nullptr && !(cache->flag &
PTCACHE_BAKED)) {
2234 if (rbw->objects ==
nullptr) {
2235 rigidbody_update_ob_array(rbw);
2240 bool can_simulate = (ctime == rbw->ltime + 1) && !(cache->flag &
PTCACHE_BAKED);
2257 if (rbw->ltime == startframe && (cache->flag &
PTCACHE_OUTDATED || cache->last_exact == 0)) {
2261 const float frame_diff = ctime - rbw->ltime;
2263 const float timestep = 1.0f /
float(scene->frames_per_second()) * frame_diff * rbw->time_scale;
2265 const float substep = timestep / rbw->substeps_per_frame;
2267 ListBaseT<LinkData> kinematic_substep_targets = rigidbody_create_substep_data(rbw);
2269 const float interp_step = 1.0f / rbw->substeps_per_frame;
2270 float cur_interp_val = interp_step;
2273 rigidbody_update_simulation(depsgraph, scene, rbw,
false);
2275 for (
int i = 0; i < rbw->substeps_per_frame; i++) {
2276 rigidbody_update_external_forces(depsgraph, scene, rbw);
2277 rigidbody_update_kinematic_obj_substep(&kinematic_substep_targets, cur_interp_val);
2279 cur_interp_val += interp_step;
2281 rigidbody_free_substep_data(&kinematic_substep_targets);
2283 rigidbody_update_simulation_post_step(depsgraph, rbw);
2297# if defined(__GNUC__) || defined(__clang__)
2298# pragma GCC diagnostic push
2299# pragma GCC diagnostic ignored "-Wunused-parameter"
2300# elif defined(_MSC_VER)
2302# pragma warning(disable : 4100)
2352 Object *ob,
float loc[3],
float rot[3],
float quat[4],
float rotAxis[3],
float rotAngle)
2368# if defined(__GNUC__) || defined(__clang__)
2369# pragma GCC diagnostic pop
2441 rboN->
shared = MEM_new<RigidBodyOb_Shared>(
"RigidBodyOb_Shared");
2485 if (rigidbody_world !=
nullptr) {
2486 bool need_objects_update =
false;
2487 bool need_constraints_update =
false;
2492 need_objects_update =
true;
2498 need_constraints_update =
true;
2503 (need_objects_update || need_constraints_update))
2508 if (need_objects_update) {
2511 if (need_constraints_update) {
#define FOREACH_COLLECTION_OBJECT_RECURSIVE_END
#define FOREACH_COLLECTION_OBJECT_RECURSIVE_BEGIN(_collection, _object)
General operations, lookup, etc. for blender objects.
#define PTCACHE_RESET_OUTDATED
#define PTCACHE_READ_EXACT
API for Blender-side Rigid Body stuff.
#define RBO_GET_MASS(rbo)
#define RBO_GET_MARGIN(rbo)
#define CLOG_ERROR(clg_ref,...)
#define CLOG_WARN(clg_ref,...)
ID and Library types, which are fundamental for SDNA.
#define ID_REAL_USERS(id)
Object groups, one object can be in many groups at once.
Object is a sort of wrapper for general info.
Types and defines for representing Rigid Body entities.
Read Blender memory allocation and freeing.
Rigid Body API for interfacing with external Physics Engines.
struct rbCollisionShape rbCollisionShape
struct rbMeshData rbMeshData
struct rbRigidBody rbRigidBody
struct rbConstraint rbConstraint
#define BLI_assert_msg(a, msg)
constexpr const T * data() const
constexpr int64_t size() const
constexpr bool is_empty() const
float3x3 scale(float3x3 mat, float2 scale)
void free(Subdiv *subdiv)
int size(const AssetLibraryReference *library_reference)
constexpr StringRefNull radius
static void RB_dworld_remove_constraint(void *, void *)
int BKE_ptcache_read(PTCacheID *pid, float cfra, bool no_extrapolate_old)
void mat4_to_loc_quat(float loc[3], float quat[4], const float wmat[4][4])
void BKE_rigidbody_rebuild_world(struct Depsgraph *depsgraph, struct Scene *scene, float ctime)
void BKE_rigidbody_calc_volume(struct Object *ob, float *r_vol)
MINLINE int compare_ff_relative(float a, float b, float max_diff, int max_ulps)
void BKE_rigidbody_aftertrans_update(struct Object *ob, float loc[3], float rot[3], float quat[4], float rotAxis[3], float rotAngle)
@ RBW_FLAG_USE_SPLIT_IMPULSE
MINLINE void copy_v3_v3(float r[3], const float a[3])
void BKE_rigidbody_validate_sim_world(struct Scene *scene, struct RigidBodyWorld *rbw, bool rebuild)
bool DEG_is_active(const Depsgraph *depsgraph)
static void RB_body_delete(void *)
void BKE_rigidbody_calc_center_of_mass(struct Object *ob, float r_center[3])
void BKE_rigidbody_world_init_runtime(struct RigidBodyWorld *rbw)
rbDynamicsWorld * BKE_rigidbody_world_physics(struct RigidBodyWorld *rbw)
bool BKE_rigidbody_check_sim_running(struct RigidBodyWorld *rbw, float ctime)
int BKE_ptcache_id_reset(struct Scene *scene, PTCacheID *pid, int mode)
void(*) RigidbodyWorldIDFunc(struct RigidBodyWorld *rbw, struct ID **idpoin, void *userdata, LibraryForeachIDCallbackFlag cb_flag)
float normalize_qt(float q[4])
void DEG_debug_print_eval_time(Depsgraph *depsgraph, const char *function_name, const char *object_name, const void *object_address, float time)
static void RB_dworld_remove_body(void *, void *)
void axis_angle_to_quat(float r[4], const float axis[3], float angle)
struct RigidBodyOb * BKE_rigidbody_create_object(struct Scene *scene, struct Object *ob, eRigidBodyOb_Type type)
void BKE_effectors_apply(ListBaseT< EffectorCache > *effectors, ListBaseT< ColliderCache > *colliders, struct EffectorWeights *weights, struct EffectedPoint *point, float *force, float *wind_force, float *impulse)
void mul_m4_m4m4(float R[4][4], const float A[4][4], const float B[4][4])
void mul_qt_qtqt(float q[4], const float a[4], const float b[4])
@ LIB_ID_CREATE_NO_USER_REFCOUNT
@ LIB_ID_COPY_RIGID_BODY_NO_COLLECTION_HANDLING
@ LIB_ID_COPY_SET_COPIED_ON_WRITE
@ LIB_ID_CREATE_NO_DEG_TAG
void BKE_ptcache_id_from_rigidbody(PTCacheID *pid, struct Object *ob, struct RigidBodyWorld *rbw)
MINLINE void mul_v3_fl(float r[3], float f)
bool BKE_collection_has_object(Collection *collection, const Object *ob)
static void RB_shape_delete(void *)
@ RBO_FLAG_USE_DEACTIVATION
@ RBO_FLAG_NEEDS_VALIDATE
@ RBO_FLAG_START_DEACTIVATED
static RigidBodyOb * rigidbody_copy_object(const Object *ob, const int flag)
void size_to_mat4(float R[4][4], const float size[3])
ViewLayer * DEG_get_input_view_layer(const Depsgraph *graph)
VecBase< int32_t, 3 > int3
struct RigidBodyCon * BKE_rigidbody_create_constraint(struct Scene *scene, struct Object *ob, eRigidBodyCon_Type type)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void BKE_rigidbody_object_copy(struct Main *bmain, struct Object *ob_dst, const struct Object *ob_src, int flag)
void BKE_rigidbody_ensure_local_object(struct Main *bmain, struct Object *ob)
int BKE_ptcache_write(PTCacheID *pid, unsigned int cfra)
void BKE_rigidbody_cache_reset(struct RigidBodyWorld *rbw)
void copy_qt_qt(float q[4], const float a[4])
Main * DEG_get_bmain(const Depsgraph *graph)
void DEG_id_tag_update(ID *id, unsigned int flags)
void BKE_report(ReportList *reports, eReportType type, const char *message)
BMesh const char void * data
void interp_qt_qtqt(float q[4], const float a[4], const float b[4], float t)
void BKE_rigidbody_object_sync_transforms(struct Depsgraph *depsgraph, struct Scene *scene, struct Object *ob)
static void RB_constraint_delete(void *)
void BKE_object_matrix_local_get(Object *ob, float r_mat[4][4])
void BKE_rigidbody_objects_collection_validate(struct Main *bmain, struct Scene *scene, struct RigidBodyWorld *rbw)
void BKE_object_dimensions_get(const Object *ob, float r_vec[3])
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
LinkData * BLI_genericNodeN(void *data)
void BKE_ptcache_id_time(PTCacheID *pid, struct Scene *scene, float cfra, int *startframe, int *endframe, float *timescale)
bool BKE_collection_object_add(Main *bmain, Collection *collection, Object *ob)
void interp_v3_v3v3(float r[3], const float a[3], const float b[3], float t)
bool BKE_rigidbody_add_object(struct Main *bmain, struct Scene *scene, struct Object *ob, eRigidBodyOb_Type type, struct ReportList *reports)
void BKE_rigidbody_free_object(struct Object *ob, struct RigidBodyWorld *rbw)
struct RigidBodyWorld * BKE_rigidbody_world_copy(struct RigidBodyWorld *rbw, int flag)
void BKE_rigidbody_do_simulation(struct Depsgraph *depsgraph, struct Scene *scene, float ctime)
MINLINE void zero_v3(float r[3])
struct RigidBodyWorld * BKE_rigidbody_create_world(struct Scene *scene)
void BKE_rigidbody_main_collection_object_add(struct Main *bmain, struct Collection *collection, struct Object *object)
static void RB_dworld_delete(void *)
void BKE_mesh_calc_volume(const float(*vert_positions)[3], int mverts_num, const int3 *corner_tris, int corner_tris_num, const int *corner_verts, float *r_volume, float r_center[3])
void mat4_to_size(float size[3], const float M[4][4])
static RigidBodyCon * rigidbody_copy_constraint(const Object *ob, const int)
void BKE_ptcache_validate(struct PointCache *cache, int framenr)
MINLINE void add_v3_v3(float r[3], const float a[3])
void BKE_rigidbody_remove_object(struct Main *bmain, struct Scene *scene, struct Object *ob, bool free_us)
void pd_point_from_loc(struct Scene *scene, float *loc, float *vel, int index, struct EffectedPoint *point)
void BKE_ptcache_free_list(ListBaseT< PointCache > *ptcaches)
void BKE_rigidbody_free_world(struct Scene *scene)
bool BKE_collection_object_remove(Main *bmain, Collection *collection, Object *ob, bool free_us)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
MINLINE bool compare_size_v3v3(const float v1[3], const float v2[3], float limit) ATTR_WARN_UNUSED_RESULT
void eulO_to_quat(float q[4], const float e[3], short order)
ListBaseT< EffectorCache > * BKE_effectors_create(struct Depsgraph *depsgraph, struct Object *ob_src, struct ParticleSystem *psys_src, struct EffectorWeights *weights, bool use_rotation)
@ RBC_FLAG_OVERRIDE_SOLVER_ITERATIONS
@ RBC_FLAG_USE_LIMIT_LIN_X
@ RBC_FLAG_NEEDS_VALIDATE
@ RBC_FLAG_USE_LIMIT_LIN_Z
@ RBC_FLAG_USE_SPRING_ANG_X
@ RBC_FLAG_DISABLE_COLLISIONS
@ RBC_FLAG_USE_LIMIT_ANG_X
@ RBC_FLAG_USE_LIMIT_ANG_Y
@ RBC_FLAG_USE_SPRING_ANG_Z
@ RBC_FLAG_USE_LIMIT_ANG_Z
@ RBC_FLAG_USE_SPRING_ANG_Y
@ RBC_FLAG_USE_LIMIT_LIN_Y
bool BKE_scene_object_find(const Main &bmain, Scene *scene, Object *ob)
Scene * DEG_get_input_scene(const Depsgraph *graph)
void BKE_rigidbody_remove_constraint(struct Main *bmain, struct Scene *scene, struct Object *ob, bool free_us)
Base * BKE_view_layer_base_find(ViewLayer *view_layer, Object *ob)
void BKE_rigidbody_constraints_collection_validate(struct Scene *scene, struct RigidBodyWorld *rbw)
struct PointCache * BKE_ptcache_add(ListBaseT< PointCache > *ptcaches)
struct PointCache * BKE_ptcache_copy_list(ListBaseT< PointCache > *ptcaches_new, const ListBaseT< PointCache > *ptcaches_old, int flag)
void DEG_relations_tag_update(Main *bmain)
void BKE_rigidbody_eval_simulation(struct Depsgraph *depsgraph, struct Scene *scene)
void BKE_rigidbody_world_groups_relink(struct RigidBodyWorld *rbw)
std::optional< Bounds< float3 > > BKE_object_boundbox_get(const Object *ob)
MINLINE void copy_v4_v4(float r[4], const float a[4])
void BKE_rigidbody_sync_transforms(struct RigidBodyWorld *rbw, struct Object *ob, float ctime)
bool BKE_rigidbody_is_affected_by_simulation(struct Object *ob)
void copy_m4_m4(float m1[4][4], const float m2[4][4])
float mat4_to_volume_scale(const float mat[4][4])
struct RigidBodyWorld * BKE_rigidbody_get_world(struct Scene *scene)
struct EffectorWeights * BKE_effector_add_weights(struct Collection *collection)
float DEG_get_ctime(const Depsgraph *graph)
bool BKE_scene_check_rigidbody_active(const Scene *scene)
void mat4_decompose(float loc[3], float quat[4], float size[3], const float wmat[4][4])
MINLINE bool is_zero_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
void BKE_rigidbody_rebuild_sim(struct Depsgraph *depsgraph, struct Scene *scene)
void BKE_rigidbody_world_id_loop(struct RigidBodyWorld *rbw, RigidbodyWorldIDFunc func, void *userdata)
void BKE_effectors_free(ListBaseT< EffectorCache > *lb)
const Mesh * BKE_object_get_mesh_deform_eval(const Object *object)
void BKE_rigidbody_free_constraint(struct Object *ob)
void quat_to_mat4(float m[4][4], const float q[4])
Mesh * BKE_object_get_evaluated_mesh(const Object *object_eval)
Collection * BKE_collection_add(Main *bmain, Collection *collection_parent, const char *name_custom)
void RB_constraint_set_max_impulse_motor(rbConstraint *con, float max_impulse_lin, float max_impulse_ang)
void RB_dworld_set_solver_iterations(rbDynamicsWorld *world, int num_solver_iterations)
void RB_dworld_add_body(rbDynamicsWorld *world, rbRigidBody *object, int col_groups)
void RB_dworld_set_split_impulse(rbDynamicsWorld *world, int split_impulse)
rbCollisionShape * RB_shape_new_compound()
void RB_constraint_set_stiffness_6dof_spring(rbConstraint *con, int axis, float stiffness)
void RB_body_set_restitution(rbRigidBody *object, float value)
rbCollisionShape * RB_shape_new_box(float x, float y, float z)
void RB_body_set_friction(rbRigidBody *object, float value)
void RB_body_set_mass(rbRigidBody *object, float value)
rbConstraint * RB_constraint_new_fixed(float pivot[3], float orn[4], rbRigidBody *rb1, rbRigidBody *rb2)
void RB_body_set_activation_state(rbRigidBody *object, int use_deactivation)
rbConstraint * RB_constraint_new_6dof_spring(float pivot[3], float orn[4], rbRigidBody *rb1, rbRigidBody *rb2)
void RB_dworld_add_constraint(rbDynamicsWorld *world, rbConstraint *con, int disable_collisions)
void RB_constraint_set_damping_6dof_spring(rbConstraint *con, int axis, float damping)
rbCollisionShape * RB_shape_new_gimpact_mesh(rbMeshData *mesh)
rbCollisionShape * RB_shape_new_trimesh(rbMeshData *mesh)
rbConstraint * RB_constraint_new_slider(float pivot[3], float orn[4], rbRigidBody *rb1, rbRigidBody *rb2)
void RB_body_get_linear_velocity(rbRigidBody *object, float v_out[3])
void RB_constraint_set_enabled(rbConstraint *con, int enabled)
void RB_constraint_set_stiffness_6dof_spring2(rbConstraint *con, int axis, float stiffness)
void RB_constraint_set_equilibrium_6dof_spring(rbConstraint *con)
void RB_body_apply_central_force(rbRigidBody *object, const float v_in[3])
void RB_constraint_set_limits_slider(rbConstraint *con, float lower, float upper)
rbConstraint * RB_constraint_new_piston(float pivot[3], float orn[4], rbRigidBody *rb1, rbRigidBody *rb2)
void RB_constraint_set_breaking_threshold(rbConstraint *con, float threshold)
void RB_constraint_set_enable_motor(rbConstraint *con, int enable_lin, int enable_ang)
void RB_body_get_orientation(rbRigidBody *object, float v_out[4])
void RB_dworld_set_gravity(rbDynamicsWorld *world, const float g_in[3])
void RB_compound_add_child_shape(rbCollisionShape *parentShape, rbCollisionShape *shape, const float loc[3], const float rot[4])
rbDynamicsWorld * RB_dworld_new(const float gravity[3])
void RB_trimesh_add_triangle_indices(rbMeshData *mesh, int num, int index0, int index1, int index2)
rbMeshData * RB_trimesh_data_new(int num_tris, int num_verts)
void RB_trimesh_add_vertices(rbMeshData *mesh, float *vertices, int num_verts, int vert_stride)
void RB_constraint_set_limits_6dof_spring2(rbConstraint *con, int axis, float lower, float upper)
rbConstraint * RB_constraint_new_6dof(float pivot[3], float orn[4], rbRigidBody *rb1, rbRigidBody *rb2)
void RB_constraint_set_solver_iterations(rbConstraint *con, int num_solver_iterations)
rbCollisionShape * RB_shape_new_cylinder(float radius, float height)
void RB_constraint_set_damping_6dof_spring2(rbConstraint *con, int axis, float damping)
void RB_body_set_collision_shape(rbRigidBody *object, rbCollisionShape *shape)
void RB_body_set_scale(rbRigidBody *object, const float scale[3])
void RB_body_set_damping(rbRigidBody *object, float linear, float angular)
void RB_shape_trimesh_update(rbCollisionShape *shape, const float *vertices, int num_verts, int vert_stride, const float min[3], const float max[3])
void RB_constraint_set_spring_6dof_spring(rbConstraint *con, int axis, int enable)
void RB_shape_set_margin(rbCollisionShape *shape, float value)
rbRigidBody * RB_body_new(rbCollisionShape *shape, const float loc[3], const float rot[4])
void RB_body_deactivate(rbRigidBody *object)
void RB_body_set_kinematic_state(rbRigidBody *object, int kinematic)
rbConstraint * RB_constraint_new_6dof_spring2(float pivot[3], float orn[4], rbRigidBody *rb1, rbRigidBody *rb2)
rbConstraint * RB_constraint_new_hinge(float pivot[3], float orn[4], rbRigidBody *rb1, rbRigidBody *rb2)
void RB_trimesh_finish(rbMeshData *mesh)
void RB_body_get_position(rbRigidBody *object, float v_out[3])
rbCollisionShape * RB_shape_new_convex_hull(const float *verts, int stride, int count, float margin, bool *can_embed)
rbConstraint * RB_constraint_new_point(const float pivot[3], rbRigidBody *rb1, rbRigidBody *rb2)
rbCollisionShape * RB_shape_new_cone(float radius, float height)
void RB_constraint_set_limits_piston(rbConstraint *con, float lin_lower, float lin_upper, float ang_lower, float ang_upper)
void RB_constraint_set_limits_6dof(rbConstraint *con, int axis, float lower, float upper)
void RB_body_set_loc_rot(rbRigidBody *object, const float loc[3], const float rot[4])
void RB_constraint_set_limits_hinge(rbConstraint *con, float lower, float upper)
void RB_constraint_set_target_velocity_motor(rbConstraint *con, float velocity_lin, float velocity_ang)
rbCollisionShape * RB_shape_new_sphere(float radius)
void RB_body_activate(rbRigidBody *object)
void RB_body_set_linear_factor(rbRigidBody *object, float x, float y, float z)
void RB_body_set_sleep_thresh(rbRigidBody *object, float linear, float angular)
void RB_dworld_step_simulation(rbDynamicsWorld *world, float timeStep, int maxSubSteps, float timeSubStep)
void RB_constraint_set_equilibrium_6dof_spring2(rbConstraint *con)
rbCollisionShape * RB_shape_new_capsule(float radius, float height)
rbConstraint * RB_constraint_new_motor(float pivot[3], float orn[4], rbRigidBody *rb1, rbRigidBody *rb2)
void RB_body_get_scale(rbRigidBody *object, float v_out[3])
void RB_constraint_set_spring_6dof_spring2(rbConstraint *con, int axis, int enable)
void RB_body_set_angular_factor(rbRigidBody *object, float x, float y, float z)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct Collection * group
ListBaseT< Scene > scenes
struct RigidBodyOb * rigidbody_object
struct RigidBodyCon * rigidbody_constraint
void * physics_constraint
struct RigidBodyOb_Shared * shared
~RigidBodyWorld_Runtime()
rbDynamicsWorld * physics_world
struct RigidBodyWorld_Runtime * runtime
struct PointCache * pointcache
ListBaseT< PointCache > ptcaches
struct Collection * constraints
struct EffectorWeights * effector_weights
struct Collection * group
struct RigidBodyWorld_Shared * shared
struct RigidBodyWorld * rigidbody_world