Add Cycle through animations in glTF files

application/testing/CMakeLists.txt

@@ -671,6 +671,7 @@ f3d_test(NAME TestInteractionMisc DATA cow.vtp NO_BASELINE INTERACTION) #KK
 f3d_test(NAME TestInteractionCycleCell DATA waveletArrays.vti INTERACTION DEFAULT_LIGHTS) #VCCC
 f3d_test(NAME TestInteractionCycleComp DATA dragon.vtu INTERACTION DEFAULT_LIGHTS) #SYYYY
 f3d_test(NAME TestInteractionCycleScalars DATA dragon.vtu INTERACTION DEFAULT_LIGHTS) #BSSSS
+f3d_test(NAME TestInteractionCycleAnimation DATA InterpolationTest.glb INTERACTION DEFAULT_LIGHTS) #WWWWWWWWWWW;Space;Space;
 f3d_test(NAME TestInteractionVolumeInverse DATA HeadMRVolume.mhd ARGS --camera-position=127.5,-400,127.5 --camera-view-up=0,0,1 INTERACTION DEFAULT_LIGHTS) #VI
 f3d_test(NAME TestInteractionPointCloud DATA pointsCloud.vtp ARGS --point-size=20 INTERACTION DEFAULT_LIGHTS) #O
 f3d_test(NAME TestInteractionDirectory DATA mb INTERACTION ARGS --scalars DEFAULT_LIGHTS) #Right;Right;Right;Left;Up;

doc/CHANGELOG.md

@@ -5,6 +5,8 @@
 For F3D users:
 - Added a new option `--point-type` used to specify how to display points sprites
 - Add support for 3D Gaussians Splatting in binary .splat format
+- Added ability to cycle through available animations by pressing "W" hotkey
+- Added display of current animation name within cheatsheet
 
 For libf3d users:
 - Added a new option `model.point-sprites.type` used to specify how to display points (only if `model.point-sprites.enable` is true)

doc/user/INTERACTIONS.md

@@ -28,6 +28,7 @@ See the [coloring cycle](#cycling-coloring) section for more info.
 
 Other options can be toggled directly by pressing the following hotkeys:
 
+* <kbd>W</kbd>: cycle animations.
 * <kbd>B</kbd>: display of the scalar bar, only when coloring and not using direct scalars.
 * <kbd>V</kbd>: volume rendering.
 * <kbd>I</kbd>: opacity function inversion during volume rendering.

doc/user/USAGE.md

@@ -51,7 +51,7 @@ to modify this behavior. For file formats that do not support it, **a default sc
 F3D can play animations for a number of file formats (.ex2/.e/.exo/.g, .gltf/.glb, .fbx, .dae, .x, .usd) if the file contains an animation.
 It is possible to select the animation to play using `--animation-index`, or to play all animations at once using `--animation-index=-1` (.gltf/.glb only).
 When F3D plays an animation, it assumes the time unit is in seconds to show accurate speed of animation. Use `--animation-speed-factor` if
-an adjustment is needed. By default, F3D will try update the scene 60 times per seconds, use `--animation-frame-rate` to change that if needed.
+an adjustment is needed. By default, F3D will try update the scene 60 times per seconds, use `--animation-frame-rate` to change that if needed. Press "W" hotkey to cycle through available animations.
 
 ## Plugins
 

library/private/animationManager.h

@@ -46,6 +46,15 @@ class animationManager
   void ToggleAnimation();
   void StartAnimation();
   void StopAnimation();
+  void CycleAnimation();
+  void EnableOnlyCurrentAnimation();
+  int GetAnimationIndex();
+
+  /**
+   * Return the current animation name if any
+   * Can be called before initialization safely
+   */
+  std::string GetAnimationName();
 
   /**
    * Return true if the animation manager is playing the animation
@@ -85,6 +94,8 @@ class animationManager
   unsigned long CallBackId = 0;
   double CurrentTime = 0;
   bool CurrentTimeSet = false;
+  int AnimationIndex = 0;
+  int AvailAnimations = 0;
   std::chrono::steady_clock::time_point PreviousTick;
 
   vtkSmartPointer<vtkProgressBarWidget> ProgressWidget;

library/private/window_impl.h

@@ -47,6 +47,7 @@ class window_impl : public window
   image renderToImage(bool noBackground = false) override;
   int getWidth() const override;
   int getHeight() const override;
+  window& setAnimationNameInfo(const std::string& name);
   window& setSize(int width, int height) override;
   window& setPosition(int x, int y) override;
   window& setIcon(const unsigned char* icon, size_t iconSize) override;

library/src/animationManager.cxx

@@ -19,20 +19,21 @@ namespace f3d::detail
 bool animationManager::Initialize(
   const options* options, window* window, interactor_impl* interactor, vtkImporter* importer)
 {
+  assert(importer);
   this->HasAnimation = false;
   this->Playing = false;
   this->CurrentTime = 0;
   this->CurrentTimeSet = false;
-
+  this->AnimationIndex = 0;
   this->Options = options;
   this->Interactor = interactor;
   this->Window = window;
   this->Importer = importer;
 
   // This can be -1 if animation support is not implemented in the importer
-  vtkIdType availAnimations = this->Importer->GetNumberOfAnimations();
+  this->AvailAnimations = this->Importer->GetNumberOfAnimations();
 
-  if (availAnimations > 0 && interactor)
+  if (this->AvailAnimations > 0 && interactor)
   {
     this->ProgressWidget = vtkSmartPointer<vtkProgressBarWidget>::New();
     interactor->SetInteractorOn(this->ProgressWidget);
@@ -48,7 +49,6 @@ bool animationManager::Initialize(
     progressRep->DrawBackgroundOff();
     progressRep->DragableOff();
     progressRep->SetShowBorderToOff();
-
 // Complete vtkProgressBarRepresentation needs
 // https://gitlab.kitware.com/vtk/vtk/-/merge_requests/7359
 #if VTK_VERSION_NUMBER >= VTK_VERSION_CHECK(9, 0, 20201027)
@@ -66,7 +66,7 @@ bool animationManager::Initialize(
   int animationIndex = options->getAsInt("scene.animation.index");
   double animationTime = options->getAsDouble("scene.animation.time");
 
-  if (availAnimations <= 0)
+  if (this->AvailAnimations <= 0)
   {
     log::debug("No animation available in this file");
     if (animationIndex > 0)
@@ -85,36 +85,35 @@ bool animationManager::Initialize(
   {
     log::debug("Animation(s) available in this file are:");
   }
-  for (int i = 0; i < availAnimations; i++)
+  for (int i = 0; i < this->AvailAnimations; i++)
   {
     log::debug(i, ": ", this->Importer->GetAnimationName(i));
   }
   log::debug("");
 
-  if (animationIndex > 0 && animationIndex >= availAnimations)
+  this->AnimationIndex = options->getAsInt("scene.animation.index");
+
+  if (this->AnimationIndex != 0 && this->AvailAnimations <= 0)
+  {
+    log::warn("An animation index has been specified but there are no animation available.");
+  }
+  else if (this->AnimationIndex > 0 && this->AnimationIndex >= this->AvailAnimations)
   {
     log::warn(
       "Specified animation index is greater than the highest possible animation index, enabling "
       "the first animation.");
 
     this->Importer->EnableAnimation(0);
   }
-  else if (animationIndex <= -1)
-  {
-    for (int i = 0; i < availAnimations; i++)
-    {
-      this->Importer->EnableAnimation(i);
-    }
-  }
   else
   {
-    this->Importer->EnableAnimation(animationIndex);
+    this->EnableOnlyCurrentAnimation();
   }
 
   // Recover time ranges for all enabled animations
   this->TimeRange[0] = std::numeric_limits<double>::infinity();
   this->TimeRange[1] = -std::numeric_limits<double>::infinity();
-  for (vtkIdType animIndex = 0; animIndex < availAnimations; animIndex++)
+  for (vtkIdType animIndex = 0; animIndex < this->AvailAnimations; animIndex++)
   {
     if (this->Importer->IsAnimationEnabled(animIndex))
     {
@@ -255,6 +254,7 @@ void animationManager::Tick()
 //----------------------------------------------------------------------------
 bool animationManager::LoadAtTime(double timeValue)
 {
+  assert(this->Importer);
   if (!this->HasAnimation)
   {
     return false;
@@ -265,7 +265,6 @@ bool animationManager::LoadAtTime(double timeValue)
       this->TimeRange[0], ", ", this->TimeRange[1], "] .");
     return false;
   }
-
   this->CurrentTime = timeValue;
   this->CurrentTimeSet = true;
   this->Importer->UpdateTimeStep(this->CurrentTime);
@@ -283,10 +282,83 @@ bool animationManager::LoadAtTime(double timeValue)
   return true;
 }
 
+// ---------------------------------------------------------------------------------
+void animationManager::CycleAnimation()
+{
+  assert(this->Importer);
+  if (this->AvailAnimations <= 0)
+  {
+    return;
+  }
+
+  this->AnimationIndex += 1;
+
+  if (this->AnimationIndex == this->AvailAnimations)
+  {
+    this->AnimationIndex = -1;
+  }
+
+  this->EnableOnlyCurrentAnimation();
+  this->LoadAtTime(this->TimeRange[0]);
+}
+
+// ---------------------------------------------------------------------------------
+int animationManager::GetAnimationIndex()
+{
+  return this->AnimationIndex;
+}
+
+// ---------------------------------------------------------------------------------
+std::string animationManager::GetAnimationName()
+{
+  if (!this->Importer)
+  {
+    return "";
+  }
+
+  if (this->AnimationIndex == -1)
+  {
+    return "All Animations";
+  }
+  return this->Importer->GetAnimationName(this->AnimationIndex);
+}
+
+//----------------------------------------------------------------------------
+void animationManager::EnableOnlyCurrentAnimation()
+{
+  assert(this->Importer);
+  if (this->AnimationIndex - 1 == -1)
+  {
+    this->AnimationIndex = this->AnimationIndex - 1;
+    for (int i = 0; i < this->AvailAnimations; i++)
+    {
+      this->Importer->DisableAnimation(i);
+    }
+    this->AnimationIndex = this->AnimationIndex + 1;
+  }
+  else
+  {
+    this->Importer->DisableAnimation(this->AnimationIndex - 1);
+  }
+
+  if (this->AnimationIndex == -1)
+  {
+    for (int i = 0; i < this->AvailAnimations; i++)
+    {
+      this->Importer->EnableAnimation(i);
+    }
+  }
+  else
+  {
+    this->Importer->EnableAnimation(this->AnimationIndex);
+  }
+}
+
 //----------------------------------------------------------------------------
 void animationManager::GetTimeRange(double timeRange[2])
 {
   timeRange[0] = this->TimeRange[0];
   timeRange[1] = this->TimeRange[1];
 }
+
 }

library/src/interactor_impl.cxx

@@ -167,9 +167,15 @@ class interactor_impl::internals
     bool checkColoring = false;
     bool render = false;
 
-    // Available keycodes: W
+    // Available keycodes: None
     switch (keyCode)
     {
+      case 'W':
+        self->AnimationManager->CycleAnimation();
+        self->Options.set("scene.animation.index", self->AnimationManager->GetAnimationIndex());
+        ren->SetAnimationnameInfo(self->AnimationManager->GetAnimationName());
+        render = true;
+        break;
       case 'C':
         if (renWithColor)
         {
@@ -356,6 +362,7 @@ class interactor_impl::internals
       self->Options.set("model.scivis.array-name", renWithColor->GetColoringArrayName());
       self->Options.set("model.scivis.component", renWithColor->GetColoringComponent());
     }
+
     if (render)
     {
       self->Window.render();

library/src/loader_impl.cxx

@@ -163,6 +163,9 @@ class loader_impl::internals
       }
     }
 
+    // Set the name for animation
+    this->Window.setAnimationNameInfo(this->AnimationManager.GetAnimationName());
+
     // Display the importer description
     loader_impl::internals::DisplayImporterDescription(this->GenericImporter);
 
@@ -232,7 +235,6 @@ loader& loader_impl::loadGeometry(const std::string& filePath, bool reset)
     throw loader::load_failure_exception(
       filePath + " is not a file of a supported 3D geometry file format for default scene");
   }
-
   // Read the file
   log::debug("Loading 3D geometry: ", filePath, "\n");
 
@@ -324,6 +326,9 @@ loader& loader_impl::loadScene(const std::string& filePath)
       this->Internals->AnimationManager.LoadAtTime(animationTime);
     }
   }
+
+  // Set the name for animation
+  this->Internals->Window.setAnimationNameInfo(this->Internals->AnimationManager.GetAnimationName());
 
   // Display output description
   loader_impl::internals::DisplayImporterDescription(this->Internals->CurrentFullSceneImporter);

library/src/window_impl.cxx

@@ -216,6 +216,13 @@ int window_impl::getHeight() const
   return this->Internals->RenWin->GetSize()[1];
 }
 
+//----------------------------------------------------------------------------
+window& window_impl::setAnimationNameInfo(const std::string& name)
+{
+  this->Internals->Renderer->SetAnimationnameInfo(name);
+  return *this;
+}
+
 //----------------------------------------------------------------------------
 window& window_impl::setSize(int width, int height)
 {