Fix glTF_Physics/samples/Robot_skinned scene: Add bone constraints (Copy Transforms / Child Of). Auto-wire skin joints to physics-driven ancestors.

- Per-bone constraint stack with inspector UI. Evaluated in the pose-sync loop against a new BonePoseWorld scratch buffer.
- On glTF import, bones whose joint node has a physics-driven ancestor get a Child Of constraint with InverseMatrix baked to the rest offset, so skins follow rigid bodies.
- Acceleration-mode drives with stiffness > 0 now convert to frequency/damping-ratio
- EmptyShape fallback for motion-only bodies without colliders
- skip BoneAttachment on physics-driven joint-node objects
- Fork JoltPhysics with jrouwe/JoltPhysics#1977

Author: khiner

.gitmodules

@@ -51,4 +51,4 @@
 	url = git@github.com:BinomialLLC/basis_universal.git
 [submodule "lib/JoltPhysics"]
 	path = lib/JoltPhysics
-	url = git@github.com:jrouwe/JoltPhysics.git
+	url = git@github.com:khiner/JoltPhysics.git

README.md

@@ -49,9 +49,8 @@ Noteworthy dev bits:
 
 This project supports generating an efficient physical audio model for any mesh using Linear Modal Analysis/Synthesis
 
-The physical audio modeling components were implemented as a final project for PHYS-6260 - Computational Physics at Georgia Tech during my Master's, and this is the final report. [Here is the final report paper](paper/PAMofPassiveRigidBodies.pdf).
-
-And here is a 36X48 poster:
+The physical audio modeling was originally implemented as a final project for PHYS-6260 - Computational Physics at Georgia Tech during my Master's.
+It's gotten a lot of work since then, but the details laid out in [the final report](paper/PAMofPassiveRigidBodies.pdf) are still the same, as well as this 36X48 poster:
 
 ![](paper/ProjectPoster36X48.png)
 

lib/JoltPhysics

@@ -329,31 +329,38 @@ void BoneMat3ToVecRoll(const mat3 &m, vec3 &direction, float &roll) {
 // co-located transforms and the spec ignores skinned mesh node transforms.
 void ComputeDeformMatrices(
     const Armature &data,
-    std::span<const Transform> pose_deltas, std::span<const Transform> user_offsets, std::span<const mat4> inverse_bind_matrices, std::span<mat4> out_deform_matrices
+    std::span<const mat4> bone_pose_world, std::span<const mat4> inverse_bind_matrices, std::span<mat4> out_deform_matrices
 ) {
     if (!data.ImportedSkin || data.Bones.empty()) return;
 
-    // Compute posed world transforms in parent-before-child order (bones are already sorted this way)
-    std::vector<mat4> pose_world(data.Bones.size());
-    for (uint32_t i = 0; i < data.Bones.size(); ++i) {
-        const auto combined = ComposeWithDelta(pose_deltas[i], user_offsets[i]);
-        const auto local = ToMatrix(ComposeWithDelta(data.Bones[i].RestLocal, combined));
-        const auto parent = data.Bones[i].ParentIndex;
-        pose_world[i] = (parent == InvalidBoneIndex) ? local : pose_world[parent] * local;
-    }
-
-    // For each joint in the skin's ordering, compute the deform matrix using the precomputed index mapping.
     for (uint32_t j = 0; j < data.JointOrderToBoneIndex.size() && j < out_deform_matrices.size(); ++j) {
         const auto bone_index = data.JointOrderToBoneIndex[j];
-        if (bone_index == InvalidBoneIndex || bone_index >= pose_world.size()) {
+        if (bone_index == InvalidBoneIndex || bone_index >= bone_pose_world.size()) {
             out_deform_matrices[j] = I4;
             continue;
         }
         const auto &ibm = (j < inverse_bind_matrices.size()) ? inverse_bind_matrices[j] : I4;
-        out_deform_matrices[j] = pose_world[bone_index] * ibm;
+        out_deform_matrices[j] = bone_pose_world[bone_index] * ibm;
     }
 }
 
+Transform ApplyBoneConstraint(
+    const BoneConstraint &c, const Transform &pre_local,
+    const mat4 &parent_pose_world, const mat4 &armature_world_inv, const mat4 &target_world
+) {
+    const mat4 effective_target = std::visit(
+        [&]<typename T>(const T &d) -> mat4 {
+            if constexpr (std::is_same_v<T, ChildOfData>) return target_world * d.InverseMatrix;
+            else return target_world;
+        },
+        c.Data
+    );
+    const mat4 constrained_local = glm::inverse(parent_pose_world) * (armature_world_inv * effective_target);
+    const Transform tl{vec3(constrained_local[3]), glm::normalize(glm::quat_cast(mat3(constrained_local))), pre_local.S};
+    if (c.Influence >= 1.f) return tl;
+    return {glm::mix(pre_local.P, tl.P, c.Influence), glm::slerp(pre_local.R, tl.R, c.Influence), pre_local.S};
+}
+
 float ComputeBoneDisplayScale(const Armature &armature, uint32_t bone_index) {
     static constexpr float MinBoneLength = 0.004f;
     float min_child_dist = std::numeric_limits<float>::max();
@@ -379,6 +386,7 @@ void RebuildArmatureStructure(entt::registry &r, entt::entity arm_data_entity) {
     if (auto *ps = r.try_get<ArmaturePoseState>(arm_data_entity)) {
         ps->BonePoseDelta.assign(armature.Bones.size(), identity);
         ps->BoneUserOffset.assign(armature.Bones.size(), identity);
+        ps->BonePoseWorld.assign(armature.Bones.size(), I4);
     }
     if (auto *anim = r.try_get<ArmatureAnimation>(arm_data_entity)) {
         for (auto &clip : anim->Clips) armature.ResolveAnimationIndices(clip);

src/Armature.cpp

@@ -13,6 +13,7 @@
 #include <string>
 #include <string_view>
 #include <unordered_map>
+#include <variant>
 #include <vector>
 
 inline constexpr uint32_t InvalidBoneIndex{std::numeric_limits<uint32_t>::max()};
@@ -134,10 +135,27 @@ struct BoneAttachment {
     BoneId Bone;
 };
 
+// Pose constraint stack on bone entities.
+struct CopyTransformsData {};
+struct ChildOfData {
+    mat4 InverseMatrix{I4}; // Stored "parent-inverse" like Blender's Child Of: inverse(target_world) * owner_world at bind time.
+};
+
+struct BoneConstraint {
+    entt::entity TargetEntity{null_entity};
+    float Influence{1.f};
+    std::variant<CopyTransformsData, ChildOfData> Data{CopyTransformsData{}};
+};
+
+struct BoneConstraints {
+    std::vector<BoneConstraint> Stack;
+};
+
 // Component on armature data entities with imported skin data.
 struct ArmaturePoseState {
     std::vector<Transform> BonePoseDelta; // Animation delta from rest (identity = at rest). Persistent across frames.
     std::vector<Transform> BoneUserOffset; // Additive user offset per bone (identity = no offset). Applied on top of animation.
+    std::vector<mat4> BonePoseWorld; // Per-bone pose world in armature-local space, post-constraint. Scratch, reused across frames.
     Range GpuDeformRange; // Allocation in shared ArmatureDeformBuffer arena. Count == 0 means not yet allocated.
 };
 
@@ -203,9 +221,14 @@ Transform AbsoluteToDelta(const Transform &rest, const Transform &absolute);
 // keyframe value and converts to a rest-relative delta. Unkeyed components are left unchanged.
 void EvaluateAnimationDeltas(const AnimationClip &, float time, std::span<const ArmatureBone>, std::span<Transform> deltas);
 
-// Compute final deform matrices from rest poses + pose deltas + user offsets + inverse bind matrices.
-// Effective delta per bone = ComposeWithDelta(pose_delta, user_offset). Writes directly into `out` (mapped GPU memory).
-void ComputeDeformMatrices(const Armature &, std::span<const Transform> pose_deltas, std::span<const Transform> user_offsets, std::span<const mat4> inverse_bind, std::span<mat4> out);
+// Gather per-joint deform matrices from pre-composed bone pose-world matrices + inverse binds.
+// Pose-sync owns FK (it needs per-bone world for constraint eval), so this is only the joint-order gather.
+// Writes directly into `out` (mapped GPU memory).
+void ComputeDeformMatrices(const Armature &, std::span<const mat4> bone_pose_world, std::span<const mat4> inverse_bind, std::span<mat4> out);
+
+// Blend `pre_local` toward the transform implied by `target_world` at `c.Influence`.
+// Math is armature-local; `armature_world_inv` converts target from world. Scale is preserved from `pre_local`.
+Transform ApplyBoneConstraint(const BoneConstraint &c, const Transform &pre_local, const mat4 &parent_pose_world, const mat4 &armature_world_inv, const mat4 &target_world);
 
 // Non-leaf: minimum distance to any child (ignoring near-zero). Leaf: inherit parent's scale, or 1.0.
 float ComputeBoneDisplayScale(const Armature &, uint32_t bone_index);

src/Armature.h

@@ -919,8 +919,11 @@ Scene::RenderRequest Scene::ProcessComponentEvents() {
             auto &pose_state = R.get<ArmaturePoseState>(arm_data_entity);
             const auto &armature = R.get<const Armature>(arm_data_entity);
             pose_state.GpuDeformRange = Buffers->ArmatureDeformBuffer.Allocate(armature.ImportedSkin->OrderedJointNodeIndices.size());
+            for (uint32_t i = 0; i < armature.Bones.size() && i < pose_state.BonePoseWorld.size(); ++i) {
+                pose_state.BonePoseWorld[i] = armature.Bones[i].RestWorld;
+            }
             ComputeDeformMatrices(
-                armature, pose_state.BonePoseDelta, pose_state.BoneUserOffset,
+                armature, pose_state.BonePoseWorld,
                 armature.ImportedSkin->InverseBindMatrices,
                 Buffers->ArmatureDeformBuffer.GetMutable(pose_state.GpuDeformRange)
             );
@@ -1534,8 +1537,13 @@ Scene::RenderRequest Scene::ProcessComponentEvents() {
                 auto &armature = R.get<Armature>(arm_obj_comp.Entity);
                 if (!armature.ImportedSkin) continue;
 
-                // Skip armatures with no dirty bones unless a global refresh is needed.
-                if (!bones_need_refresh) {
+                // Constraints can depend on external targets (e.g. physics bodies), so we can't early-out on bone-dirty alone.
+                const bool has_any_constraint = std::any_of(
+                    arm_obj_comp.BoneEntities.begin(), arm_obj_comp.BoneEntities.end(),
+                    [&](auto e) { return R.all_of<BoneConstraints>(e); }
+                );
+
+                if (!bones_need_refresh && !has_any_constraint) {
                     bool has_dirty = false;
                     for (const auto b : arm_obj_comp.BoneEntities) {
                         if (local_changes.contains(b) || transform_end.contains(b)) {
@@ -1546,19 +1554,25 @@ Scene::RenderRequest Scene::ProcessComponentEvents() {
                     if (!has_dirty) continue;
                 }
 
-                bool need_sync{false}, rest_pose_edited{false};
+                const mat4 armature_world_inv = has_any_constraint ? glm::inverse(ToMatrix(R.get<const WorldTransform>(arm_obj_entity))) : I4;
+
+                bool need_sync = has_any_constraint;
+                bool rest_pose_edited = false;
                 for (uint32_t i = 0; i < arm_obj_comp.BoneEntities.size(); ++i) {
                     const auto b = arm_obj_comp.BoneEntities[i];
                     if (i >= pose_state->BonePoseDelta.size()) continue;
                     const auto &rest = armature.Bones[i].RestLocal;
+                    const auto &bt = R.get<const Transform>(b);
+                    Transform local{bt.P, bt.R, rest.S}; // Default; branches that recompute overwrite it.
+                    bool should_patch = false;
                     if (is_edit_mode) {
                         if (mode_changed) {
                             // Entering Edit mode: snap to rest pose.
-                            R.patch<Transform>(b, [&](auto &t) { t.P = rest.P; t.R = rest.R; });
+                            local = {rest.P, rest.R, rest.S};
+                            should_patch = true;
                             need_sync = true;
                         } else if (transform_end.contains(b) || (local_changes.contains(b) && !R.all_of<StartTransform>(b))) {
                             // Commit Edit mode transform (gizmo drag end or UI slider edit).
-                            const auto &bt = R.get<const Transform>(b);
                             armature.Bones[i].RestLocal.P = bt.P;
                             armature.Bones[i].RestLocal.R = bt.R;
                             rest_pose_edited = true;
@@ -1575,32 +1589,50 @@ Scene::RenderRequest Scene::ProcessComponentEvents() {
                                 .S = st->T.S / pd.S,
                             }
                         );
-                        const auto &bt = R.get<const Transform>(b);
                         const Transform gizmo_local{bt.P, bt.R, rest.S};
                         pose_state->BoneUserOffset[i] = AbsoluteToDelta(grab_delta, AbsoluteToDelta(rest, gizmo_local));
-                        const auto local = ComposeWithDelta(rest, ComposeWithDelta(pose_state->BonePoseDelta[i], pose_state->BoneUserOffset[i]));
-                        R.patch<Transform>(b, [&](auto &t) { t.P = local.P; t.R = local.R; });
+                        local = ComposeWithDelta(rest, ComposeWithDelta(pose_state->BonePoseDelta[i], pose_state->BoneUserOffset[i]));
+                        should_patch = true;
                         need_sync = true;
                     } else if (transform_end.contains(b)) {
                         // Commit drag: bake current P/R into delta, clear offset.
-                        const auto &cbt = R.get<const Transform>(b);
-                        pose_state->BonePoseDelta[i] = AbsoluteToDelta(rest, {cbt.P, cbt.R, rest.S});
+                        pose_state->BonePoseDelta[i] = AbsoluteToDelta(rest, {bt.P, bt.R, rest.S});
                         pose_state->BoneUserOffset[i] = {};
                         need_sync = true;
                     } else if (bones_need_refresh) {
                         // Animation advanced or leaving Edit mode: recompute entity P/R from deltas.
-                        const auto local = ComposeWithDelta(rest, ComposeWithDelta(pose_state->BonePoseDelta[i], pose_state->BoneUserOffset[i]));
-                        R.patch<Transform>(b, [&](auto &t) { t.P = local.P; t.R = local.R; });
+                        local = ComposeWithDelta(rest, ComposeWithDelta(pose_state->BonePoseDelta[i], pose_state->BoneUserOffset[i]));
+                        should_patch = true;
                         need_sync = true;
                     } else if (local_changes.contains(b)) {
                         // Manual transform: bake if position actually changed.
                         const auto expected = ComposeWithDelta(rest, ComposeWithDelta(pose_state->BonePoseDelta[i], pose_state->BoneUserOffset[i]));
-                        const auto &bt = R.get<const Transform>(b);
-                        if (bt.P == expected.P && bt.R == expected.R) continue;
-                        pose_state->BonePoseDelta[i] = AbsoluteToDelta(rest, {bt.P, bt.R, rest.S});
-                        pose_state->BoneUserOffset[i] = {};
-                        need_sync = true;
+                        if (bt.P != expected.P || bt.R != expected.R) {
+                            pose_state->BonePoseDelta[i] = AbsoluteToDelta(rest, {bt.P, bt.R, rest.S});
+                            pose_state->BoneUserOffset[i] = {};
+                            need_sync = true;
+                        }
+                    }
+
+                    const uint32_t parent_idx = armature.Bones[i].ParentIndex;
+                    const mat4 parent_pose_world = (parent_idx == InvalidBoneIndex) ? I4 : pose_state->BonePoseWorld[parent_idx];
+
+                    // Apply bone constraints. Skipped in edit mode (rest-pose edits bypass pose constraints).
+                    if (!is_edit_mode) {
+                        if (const auto *cs = R.try_get<const BoneConstraints>(b); cs && !cs->Stack.empty()) {
+                            const auto before = local;
+                            for (const auto &c : cs->Stack) {
+                                if (c.TargetEntity == null_entity || !R.valid(c.TargetEntity)) continue;
+                                const auto *twt = R.try_get<const WorldTransform>(c.TargetEntity);
+                                if (!twt) continue;
+                                local = ApplyBoneConstraint(c, local, parent_pose_world, armature_world_inv, ToMatrix(*twt));
+                            }
+                            if (local.P != before.P || local.R != before.R) should_patch = true;
+                        }
                     }
+
+                    if (should_patch) R.patch<Transform>(b, [&](auto &t) { t.P = local.P; t.R = local.R; });
+                    pose_state->BonePoseWorld[i] = parent_pose_world * RestLocalToMatrix(local);
                 }
                 if (rest_pose_edited) {
                     // Recompute RestWorld in topological order, preserving world positions of untransformed bones.
@@ -1626,7 +1658,7 @@ Scene::RenderRequest Scene::ProcessComponentEvents() {
                 if (need_sync) {
                     if (!is_edit_mode) {
                         ComputeDeformMatrices(
-                            armature, pose_state->BonePoseDelta, pose_state->BoneUserOffset,
+                            armature, pose_state->BonePoseWorld,
                             armature.ImportedSkin->InverseBindMatrices,
                             Buffers->ArmatureDeformBuffer.GetMutable(pose_state->GpuDeformRange)
                         );

src/Scene.cpp

@@ -503,6 +503,7 @@ std::expected<std::pair<entt::entity, entt::entity>, std::string> Scene::AddGltf
             if (const auto object_it = object_entities_by_node.find(joint.JointNodeIndex);
                 object_it != object_entities_by_node.end() &&
                 R.all_of<Instance>(object_it->second) &&
+                !R.all_of<PhysicsMotion>(object_it->second) &&
                 !R.all_of<BoneAttachment>(object_it->second)) {
                 R.emplace<BoneAttachment>(object_it->second, armature_data_entity, bone_id);
             }
@@ -555,9 +556,44 @@ std::expected<std::pair<entt::entity, entt::entity>, std::string> Scene::AddGltf
             const Transform identity_delta{vec3{0}, quat{1, 0, 0, 0}, vec3{1}};
             pose_state.BonePoseDelta.resize(armature.Bones.size(), identity_delta);
             pose_state.BoneUserOffset.resize(armature.Bones.size(), identity_delta);
+            pose_state.BonePoseWorld.resize(armature.Bones.size(), I4);
             R.emplace<ArmaturePoseState>(armature_data_entity, std::move(pose_state));
         }
         CreateBoneInstances(armature_entity, armature_data_entity);
+
+        // Auto-wire Child Of on bones whose joint node has a physics-driven ancestor object,
+        // so the skin follows simulated motion when an asset pairs rigid bodies with skinning via the scene graph.
+        // Target is the nearest ancestor object with PhysicsMotion; InverseMatrix bakes the rest offset.
+        {
+            const auto find_physics_ancestor_entity = [&](uint32_t node_index) -> entt::entity {
+                for (std::optional<uint32_t> cur = node_index; cur;) {
+                    if (const auto oit = object_entities_by_node.find(*cur);
+                        oit != object_entities_by_node.end() && R.all_of<PhysicsMotion>(oit->second)) return oit->second;
+                    const auto nit = scene_nodes_by_index.find(*cur);
+                    if (nit == scene_nodes_by_index.end()) break;
+                    cur = nit->second->ParentNodeIndex;
+                }
+                return entt::null;
+            };
+            const auto &arm_obj = R.get<const ArmatureObject>(armature_entity);
+            const mat4 armature_world = ToMatrix(R.get<const WorldTransform>(armature_entity));
+            for (uint32_t i = 0; i < armature.Bones.size(); ++i) {
+                const auto &bone = armature.Bones[i];
+                if (!bone.JointNodeIndex) continue;
+                const auto target = find_physics_ancestor_entity(*bone.JointNodeIndex);
+                if (target == entt::null) continue;
+                R.emplace<BoneConstraints>(
+                    arm_obj.BoneEntities[i],
+                    BoneConstraints{
+                        .Stack = {BoneConstraint{
+                            .TargetEntity = target,
+                            .Influence = 1.f,
+                            .Data = ChildOfData{.InverseMatrix = glm::inverse(ToMatrix(R.get<const WorldTransform>(target))) * (armature_world * bone.RestWorld)},
+                        }}
+                    }
+                );
+            }
+        }
     }
 
     std::unordered_set<uint32_t> joint_node_indices;