[Impeller Scene] Use std::chrono for animation durations

Author: bdero

impeller/scene/animation/animation.cc

@@ -117,7 +117,7 @@ const std::vector<Animation::Channel>& Animation::GetChannels() const {
   return channels_;
 }
 
-Scalar Animation::GetEndTime() const {
+std::chrono::duration<Scalar> Animation::GetEndTime() const {
   return end_time_;
 }
 

impeller/scene/animation/animation.h

@@ -60,14 +60,14 @@ class Animation final {
 
   const std::vector<Channel>& GetChannels() const;
 
-  Scalar GetEndTime() const;
+  std::chrono::duration<Scalar> GetEndTime() const;
 
  private:
   Animation();
 
   std::string name_;
   std::vector<Channel> channels_;
-  Scalar end_time_ = 0;
+  std::chrono::duration<Scalar> end_time_;
 
   FML_DISALLOW_COPY_AND_ASSIGN(Animation);
 };

impeller/scene/animation/animation_clip.cc

@@ -5,6 +5,7 @@
 #include "impeller/scene/animation/animation_clip.h"
 
 #include <algorithm>
+#include <chrono>
 #include <cmath>
 #include <memory>
 #include <valarray>
@@ -43,7 +44,7 @@ void AnimationClip::Pause() {
 
 void AnimationClip::Stop() {
   SetPlaying(false);
-  Seek(0);
+  Seek(std::chrono::duration<Scalar>::zero());
 }
 
 bool AnimationClip::GetLoop() const {
@@ -70,39 +71,46 @@ void AnimationClip::SetWeight(Scalar weight) {
   weight_ = weight;
 }
 
-Scalar AnimationClip::GetPlaybackTime() const {
+std::chrono::duration<Scalar> AnimationClip::GetPlaybackTime() const {
   return playback_time_;
 }
 
-void AnimationClip::Seek(Scalar time) {
-  playback_time_ = std::clamp(time, 0.0f, animation_->GetEndTime());
+void AnimationClip::Seek(std::chrono::duration<Scalar> time) {
+  playback_time_ = std::clamp(time, std::chrono::duration<Scalar>::zero(),
+                              animation_->GetEndTime());
 }
 
-void AnimationClip::Advance(Scalar delta_time) {
-  if (!playing_ || delta_time <= 0) {
+void AnimationClip::Advance(std::chrono::duration<Scalar> delta_time) {
+  if (!playing_ || delta_time <= std::chrono::duration<Scalar>::zero()) {
     return;
   }
   delta_time *= playback_time_scale_;
   playback_time_ += delta_time;
 
   /// Handle looping behavior.
 
-  Scalar end_time = animation_->GetEndTime();
-  if (end_time == 0) {
-    playback_time_ = 0;
+  auto end_time = animation_->GetEndTime();
+  if (end_time == std::chrono::duration<Scalar>::zero()) {
+    playback_time_ = std::chrono::duration<Scalar>::zero();
     return;
   }
-  if (!loop_ && (playback_time_ < 0 || playback_time_ > end_time)) {
+  if (!loop_ && (playback_time_ < std::chrono::duration<Scalar>::zero() ||
+                 playback_time_ > end_time)) {
     // If looping is disabled, clamp to the end (or beginning, if playing in
     // reverse) and pause.
     Pause();
-    playback_time_ = std::clamp(playback_time_, 0.0f, end_time);
+    playback_time_ = std::clamp(
+        playback_time_, std::chrono::duration<Scalar>::zero(), end_time);
   } else if (/* loop && */ playback_time_ > end_time) {
     // If looping is enabled and we ran off the end, loop to the beginning.
-    playback_time_ = std::fmod(std::abs(playback_time_), end_time);
-  } else if (/* loop && */ playback_time_ < 0) {
+    playback_time_ = std::chrono::duration<Scalar>(
+        std::fmod(std::abs(playback_time_.count()), end_time.count()));
+  } else if (/* loop && */ playback_time_ <
+             std::chrono::duration<Scalar>::zero()) {
     // If looping is enabled and we ran off the beginning, loop to the end.
-    playback_time_ = end_time - std::fmod(std::abs(playback_time_), end_time);
+    playback_time_ =
+        end_time - std::chrono::duration<Scalar>(std::fmod(
+                       std::abs(playback_time_.count()), end_time.count()));
   }
 }
 

impeller/scene/animation/animation_clip.h

@@ -49,15 +49,15 @@ class AnimationClip final {
   void SetWeight(Scalar weight);
 
   /// @brief  Get the current playback time of the animation.
-  Scalar GetPlaybackTime() const;
+  std::chrono::duration<Scalar> GetPlaybackTime() const;
 
   /// @brief  Move the animation to the specified time. The given `time` is
   ///         clamped to the animation's playback range.
-  void Seek(Scalar time);
+  void Seek(std::chrono::duration<Scalar> time);
 
   /// @brief  Advance the animation by `delta_time` seconds. Negative
   ///         `delta_time` values do nothing.
-  void Advance(Scalar delta_time);
+  void Advance(std::chrono::duration<Scalar> delta_time);
 
   /// @brief  Applies the animation to all binded properties in the scene.
   void ApplyToBindings() const;
@@ -73,7 +73,7 @@ class AnimationClip final {
   std::shared_ptr<Animation> animation_;
   std::vector<ChannelBinding> bindings_;
 
-  Scalar playback_time_ = 0;
+  std::chrono::duration<Scalar> playback_time_;
   Scalar playback_time_scale_ = 1;  // Seconds multiplier, can be negative.
   Scalar weight_ = 1;
   bool playing_ = false;

impeller/scene/animation/animation_player.cc

@@ -4,6 +4,7 @@
 
 #include "impeller/scene/animation/animation_player.h"
 
+#include <chrono>
 #include <memory>
 
 #include "flutter/fml/time/time_point.h"
@@ -36,10 +37,10 @@ AnimationClip& AnimationPlayer::AddAnimation(
 
 void AnimationPlayer::Update() {
   if (!previous_time_.has_value()) {
-    previous_time_ = fml::TimePoint::Now().ToEpochDelta();
+    previous_time_ = std::chrono::high_resolution_clock::now();
   }
-  auto new_time = fml::TimePoint::Now().ToEpochDelta();
-  Scalar delta_time = (new_time - previous_time_.value()).ToSecondsF();
+  auto new_time = std::chrono::high_resolution_clock::now();
+  auto delta_time = new_time - previous_time_.value();
   previous_time_ = new_time;
 
   Reset();

impeller/scene/animation/animation_player.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <chrono>
 #include <memory>
 #include <optional>
 #include <unordered_set>
@@ -42,7 +43,8 @@ class AnimationPlayer final {
 
   std::vector<AnimationClip> clips_;
 
-  std::optional<fml::TimeDelta> previous_time_;
+  std::optional<std::chrono::time_point<std::chrono::high_resolution_clock>>
+      previous_time_;
 
   FML_DISALLOW_COPY_AND_ASSIGN(AnimationPlayer);
 };

impeller/scene/animation/property_resolver.cc

@@ -51,35 +51,36 @@ PropertyResolver::~PropertyResolver() = default;
 
 TimelineResolver::~TimelineResolver() = default;
 
-Scalar TimelineResolver::GetEndTime() {
+std::chrono::duration<Scalar> TimelineResolver::GetEndTime() {
   if (times_.empty()) {
-    return 0;
+    return std::chrono::duration<Scalar>::zero();
   }
-  return times_.back();
+  return std::chrono::duration<Scalar>(times_.back());
 }
 
-TimelineResolver::TimelineKey TimelineResolver::GetTimelineKey(Scalar time) {
-  if (times_.size() <= 1 || time <= times_.front()) {
+TimelineResolver::TimelineKey TimelineResolver::GetTimelineKey(
+    std::chrono::duration<Scalar> time) {
+  if (times_.size() <= 1 || time.count() <= times_.front()) {
     return {.index = 0, .lerp = 1};
   }
-  if (time >= times_.back()) {
+  if (time.count() >= times_.back()) {
     return {.index = times_.size() - 1, .lerp = 1};
   }
-  auto it = std::lower_bound(times_.begin(), times_.end(), time);
+  auto it = std::lower_bound(times_.begin(), times_.end(), time.count());
   size_t index = std::distance(times_.begin(), it);
 
   Scalar previous_time = *(it - 1);
   Scalar next_time = *it;
   return {.index = index,
-          .lerp = (time - previous_time) / (next_time - previous_time)};
+          .lerp = (time.count() - previous_time) / (next_time - previous_time)};
 }
 
 TranslationTimelineResolver::TranslationTimelineResolver() = default;
 
 TranslationTimelineResolver::~TranslationTimelineResolver() = default;
 
 void TranslationTimelineResolver::Apply(Node& target,
-                                        Scalar time,
+                                        std::chrono::duration<Scalar> time,
                                         Scalar weight) {
   if (values_.empty()) {
     return;
@@ -97,7 +98,9 @@ RotationTimelineResolver::RotationTimelineResolver() = default;
 
 RotationTimelineResolver::~RotationTimelineResolver() = default;
 
-void RotationTimelineResolver::Apply(Node& target, Scalar time, Scalar weight) {
+void RotationTimelineResolver::Apply(Node& target,
+                                     std::chrono::duration<Scalar> time,
+                                     Scalar weight) {
   if (values_.empty()) {
     return;
   }
@@ -114,7 +117,9 @@ ScaleTimelineResolver::ScaleTimelineResolver() = default;
 
 ScaleTimelineResolver::~ScaleTimelineResolver() = default;
 
-void ScaleTimelineResolver::Apply(Node& target, Scalar time, Scalar weight) {
+void ScaleTimelineResolver::Apply(Node& target,
+                                  std::chrono::duration<Scalar> time,
+                                  Scalar weight) {
   if (values_.empty()) {
     return;
   }

impeller/scene/animation/property_resolver.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <chrono>
 #include <memory>
 #include <string>
 #include <vector>
@@ -38,22 +39,24 @@ class PropertyResolver {
 
   virtual ~PropertyResolver();
 
-  virtual Scalar GetEndTime() = 0;
+  virtual std::chrono::duration<Scalar> GetEndTime() = 0;
 
   /// @brief  Resolve and apply the property value to a target node. This
   ///         operation is additive; a given node property may be amended by
   ///         many different PropertyResolvers prior to rendering. For example,
   ///         an AnimationPlayer may blend multiple Animations together by
   ///         applying several AnimationClips.
-  virtual void Apply(Node& target, Scalar time, Scalar weight) = 0;
+  virtual void Apply(Node& target,
+                     std::chrono::duration<Scalar> time,
+                     Scalar weight) = 0;
 };
 
 class TimelineResolver : public PropertyResolver {
  public:
   virtual ~TimelineResolver();
 
   // |Resolver|
-  Scalar GetEndTime();
+  std::chrono::duration<Scalar> GetEndTime();
 
  protected:
   struct TimelineKey {
@@ -63,7 +66,7 @@ class TimelineResolver : public PropertyResolver {
     /// and `timeline_index`. The range of this value should always be `0>N>=1`.
     Scalar lerp = 1;
   };
-  TimelineKey GetTimelineKey(Scalar time);
+  TimelineKey GetTimelineKey(std::chrono::duration<Scalar> time);
 
   std::vector<Scalar> times_;
 };
@@ -73,7 +76,9 @@ class TranslationTimelineResolver final : public TimelineResolver {
   ~TranslationTimelineResolver();
 
   // |Resolver|
-  void Apply(Node& target, Scalar time, Scalar weight) override;
+  void Apply(Node& target,
+             std::chrono::duration<Scalar> time,
+             Scalar weight) override;
 
  private:
   TranslationTimelineResolver();
@@ -90,7 +95,9 @@ class RotationTimelineResolver final : public TimelineResolver {
   ~RotationTimelineResolver();
 
   // |Resolver|
-  void Apply(Node& target, Scalar time, Scalar weight) override;
+  void Apply(Node& target,
+             std::chrono::duration<Scalar> time,
+             Scalar weight) override;
 
  private:
   RotationTimelineResolver();
@@ -107,7 +114,9 @@ class ScaleTimelineResolver final : public TimelineResolver {
   ~ScaleTimelineResolver();
 
   // |Resolver|
-  void Apply(Node& target, Scalar time, Scalar weight) override;
+  void Apply(Node& target,
+             std::chrono::duration<Scalar> time,
+             Scalar weight) override;
 
  private:
   ScaleTimelineResolver();