1 files changed, 35 insertions, 31 deletions
diff --git a/world/src/animation.rs b/world/src/animation.rs
index 3473371..ee6028e 100644
--- a/world/src/animation.rs
+++ b/world/src/animation.rs
@@ -15,7 +15,7 @@
     along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */
 use anyhow::Result;
-use glam::Quat;
+use glam::{Quat, vec3a};
 use gltf::{
     Animation,
     animation::{Property, util::ReadOutputs},
@@ -33,6 +33,7 @@ use weareshared::{
 pub fn import_animation<'a>(
     a: Animation<'a>,
     store: &ResourceStore,
+    transform: Affine3A,
     joint_index_to_ibm: &BTreeMap<usize, Affine3A>,
     joint_index_to_arm_index: &BTreeMap<usize, usize>,
     node_to_meshes: &BTreeMap<usize, Vec<usize>>,
@@ -44,36 +45,39 @@ pub fn import_animation<'a>(
         let node = c.target().node().index();
         let reader = c.reader(|i| Some(&buffers[i.index()].0));
         let inputs: Vec<f32> = reader.read_inputs().unwrap().collect::<Vec<f32>>();
-        let outputs: Vec<f32> = if let Some(ibm) = joint_index_to_ibm.get(&node) {
-            debug!("pre-applying inverse bind matricies");
-            let ibm = ibm.inverse();
-            // eprintln!("{:#?}", ibm);
-            let (_, ibm_rot, _) = ibm.to_scale_rotation_translation();
-            match reader.read_outputs().unwrap() {
-                // ReadOutputs::Translations(iter) => iter
-                //     .flat_map(|[x, y, z]| (ibm.matrix3 * vec3a(x, y, z)).to_array())
-                //     .collect(),
-                ReadOutputs::Rotations(iter) => iter
-                    .into_f32()
-                    .map(Quat::from_array)
-                    .map(|q| ibm_rot.mul_quat(q))
-                    .map(|q| q.to_array())
-                    .flatten()
-                    .collect(),
-                // ReadOutputs::Scales(iter) => iter
-                //     .flat_map(|[x, y, z]| (ibm.matrix3 * vec3a(x, y, z)).to_array())
-                //     .collect(),
-                ReadOutputs::MorphTargetWeights(iter) => iter.into_f32().collect(),
-                _ => continue,
-            }
-        } else {
-            match reader.read_outputs().unwrap() {
-                ReadOutputs::Translations(iter) => iter.flatten().collect(),
-                ReadOutputs::Rotations(iter) => iter.into_f32().flatten().collect(),
-                ReadOutputs::Scales(iter) => iter.flatten().collect(),
-                ReadOutputs::MorphTargetWeights(iter) => iter.into_f32().collect(),
-            }
-        };
+        let outputs: Vec<f32> =
+            if joint_index_to_ibm.contains_key(&node) || transform != Affine3A::IDENTITY {
+                let t = transform
+                    * joint_index_to_ibm
+                        .get(&node)
+                        .copied()
+                        .unwrap_or_default()
+                        .inverse();
+                let (_, rot, _) = t.to_scale_rotation_translation();
+                match reader.read_outputs().unwrap() {
+                    ReadOutputs::Translations(iter) => iter
+                        .flat_map(|[x, y, z]| (t.matrix3 * vec3a(x, y, z)).to_array())
+                        .collect(),
+                    ReadOutputs::Rotations(iter) => iter
+                        .into_f32()
+                        .map(Quat::from_array)
+                        .map(|q| rot.mul_quat(q))
+                        .map(|q| q.to_array())
+                        .flatten()
+                        .collect(),
+                    ReadOutputs::Scales(iter) => iter
+                        .flat_map(|[x, y, z]| (t.matrix3 * vec3a(x, y, z)).to_array())
+                        .collect(),
+                    ReadOutputs::MorphTargetWeights(iter) => iter.into_f32().collect(),
+                }
+            } else {
+                match reader.read_outputs().unwrap() {
+                    ReadOutputs::Translations(iter) => iter.flatten().collect(),
+                    ReadOutputs::Rotations(iter) => iter.into_f32().flatten().collect(),
+                    ReadOutputs::Scales(iter) => iter.flatten().collect(),
+                    ReadOutputs::MorphTargetWeights(iter) => iter.into_f32().collect(),
+                }
+            };
         for x in &inputs {
             max_time = max_time.max(*x)
         }