WIP transition to using sync track based synchronisation.

src/AnimNodes/AnimSamplerNode.cc

@@ -8,7 +8,7 @@
 
 #include "../SkinnedMesh.h"
 
-void AnimSamplerNode::SetAnimation(ozz::animation::Animation* animation) {
+void AnimSamplerNode::SetAnimation(ozz::animation::Animation* animation, const SyncTrack& sync_track) {
   m_animation = animation;
 
   const SkinnedMesh* skinned_mesh = m_animation_controller->m_skinned_mesh;
@@ -16,14 +16,17 @@ void AnimSamplerNode::SetAnimation(ozz::animation::Animation* animation) {
   const int num_joints = skinned_mesh->m_skeleton.num_joints();
   m_local_matrices.resize(num_soa_joints);
   m_sampling_cache.Resize(num_joints);
+
+  m_sync_track = sync_track;
 }
 
 void AnimSamplerNode::Evaluate(
     ozz::vector<ozz::math::SoaTransform>* local_matrices) {
   ozz::animation::SamplingJob sampling_job;
+  float ratio = m_sync_track.CalcRatioFromSyncTime(m_anim_ratio);
   sampling_job.animation = m_animation;
   sampling_job.cache = &m_sampling_cache;
-  sampling_job.ratio = m_anim_ratio;
+  sampling_job.ratio = ratio;
   sampling_job.output = make_span(*local_matrices);
   if (!sampling_job.Run()) {
     ozz::log::Err() << "Error sampling animation." << std::endl;
@@ -44,8 +47,13 @@ void AnimSamplerNode::DrawDebugUi() {
 
   if (ImGui::Combo("Animation", &item_current, items, anim_count)) {
     m_animation = skinned_mesh->m_animations[item_current];
+    m_sync_track = skinned_mesh->m_animation_sync_track[item_current];
   }
+
   ImGui::Checkbox("Override", &m_override_ratio);
   ImGui::SameLine();
   ImGui::SliderFloat("Ratio", &m_anim_ratio, 0.f, 1.f);
+
+  ImGui::Text("SyncTrack");
+  m_sync_track.DrawDebugUi();
 }

src/AnimNodes/AnimSamplerNode.h

@@ -25,14 +25,13 @@ struct AnimSamplerNode : public AnimNode {
   ozz::vector<ozz::math::SoaTransform> m_local_matrices;
   ozz::animation::SamplingCache m_sampling_cache;
 
-  void SetAnimation(ozz::animation::Animation* animation);
+  void SetAnimation(ozz::animation::Animation* animation, const SyncTrack& sync_track);
 
   virtual void UpdateIsSynced(bool is_synced) override {
     m_is_time_synced = is_synced;
   }
 
-  virtual void EvalAnimDuration() override {
-    m_anim_duration = m_animation->duration();
+  virtual void UpdateSyncTrack() override {
   }
 
   virtual void UpdateTime(float dt) override {
@@ -42,8 +41,7 @@ struct AnimSamplerNode : public AnimNode {
         m_anim_ratio = fmodf((float)m_current_time, 1.0f);
         m_current_time = m_anim_ratio;
       } else {
-        const float duration = m_animation->duration();
-        m_anim_ratio = fmodf((float)m_current_time / duration, 1.0f);
+        m_anim_ratio = fmodf((float)m_current_time / m_sync_track.m_duration, 1.0f);
       }
     }
 

src/AnimNodes/BlendNode.cc

@@ -51,4 +51,7 @@ void BlendNode::Evaluate(ozz::vector<ozz::math::SoaTransform>* local_matrices) {
 void BlendNode::DrawDebugUi() {
   ImGui::SliderFloat("Weight", &m_weight, 0.f, 1.f);
   ImGui::Checkbox("Sync Inputs", &m_sync_inputs);
+
+  ImGui::Text("SyncTrack");
+  m_sync_track.DrawDebugUi();
 }

src/AnimNodes/BlendNode.h

@@ -35,9 +35,9 @@ struct BlendNode : public AnimNode {
     m_input_A->UpdateIsSynced(m_is_time_synced);
   }
 
-  virtual void EvalAnimDuration() override {
+  virtual void UpdateSyncTrack() override {
     if (m_is_time_synced) {
-      m_anim_duration = (1.0f - m_weight) * m_input_A->m_anim_duration + m_weight * m_input_B->m_anim_duration;
+      m_sync_track = SyncTrack::Blend(m_weight, m_input_A->m_sync_track, m_input_B->m_sync_track);
     } else {
       assert (false);
     }
@@ -45,11 +45,20 @@ struct BlendNode : public AnimNode {
 
   virtual void UpdateTime(float dt) {
     if (m_is_time_synced) {
-      float current_time_absolute = m_current_time * m_anim_duration + dt;
-      m_current_time = fmodf(current_time_absolute / m_anim_duration, 1.0);
+      float current_time_absolute = fmodf(m_current_time * m_sync_track.m_duration + dt, 1.0f);
+      float current_sync_time = m_sync_track.CalcSyncFromAbsTime(current_time_absolute);
+      m_current_time = m_sync_track.CalcRatioFromSyncTime(current_sync_time);
 
-      m_input_A->UpdateTime(m_current_time - m_input_A->m_current_time);
-      m_input_B->UpdateTime(m_current_time - m_input_B->m_current_time);
+      float time_absolute_A = fmodf (m_input_A->m_current_time * m_input_A->m_sync_track.m_duration, 1.0f);
+      float sync_time_A = m_input_A->m_sync_track.CalcSyncFromAbsTime(time_absolute_A);
+      float m_ratio_A = m_input_A->m_sync_track.CalcSyncFromAbsTime(sync_time_A);
+      
+      float time_absolute_B = fmodf (m_input_B->m_current_time * m_input_B->m_sync_track.m_duration, 1.0f);
+      float sync_time_B = m_input_B->m_sync_track.CalcSyncFromAbsTime(time_absolute_B);
+      float m_ratio_B = m_input_B->m_sync_track.CalcSyncFromAbsTime(sync_time_B);
+      
+      m_input_A->UpdateTime(current_sync_time);
+      m_input_B->UpdateTime(current_sync_time);
     } else {
       m_current_time += dt;
       m_input_A->UpdateTime(dt);

src/AnimNodes/LockTranslationNode.h

@@ -32,8 +32,8 @@ struct LockTranslationNode : public AnimNode {
     m_input->UpdateIsSynced(m_is_time_synced);
   }
 
-  virtual void EvalAnimDuration() override {
-    m_anim_duration = m_input->m_anim_duration;
+  virtual void UpdateSyncTrack() override {
+    m_sync_track = m_input->m_sync_track;
   }
 
   virtual void UpdateTime(float dt) { m_input->UpdateTime(dt); }

src/AnimNodes/SpeedScaleNode.h

@@ -23,9 +23,10 @@ struct SpeedScaleNode : public AnimNode {
     m_input_node->UpdateIsSynced(is_synced);
   }
 
-  virtual void EvalAnimDuration() override {
+  virtual void UpdateSyncTrack() override {
     assert(fabs(m_time_scale) >= 0.01f);
-    m_anim_duration = fabsf(m_input_node->m_anim_duration / m_time_scale);
+    m_sync_track = m_input_node->m_sync_track;
+    m_sync_track.m_duration =fabsf(m_input_node->m_sync_track.m_duration / m_time_scale);
   }
 
   virtual void UpdateTime(float dt) {