lottie-ios 3.2.3 → 3.4.2

package/{lottie-swift/src → Sources}/Private/Utility/Interpolatable/KeyframeExtensions.swift

@@ -5,11 +5,20 @@
 //  Created by Brandon Withrow on 1/14/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
+
+extension Keyframe where T: AnyInterpolatable {
+  func interpolate(to: Keyframe<T>, progress: CGFloat) -> T {
+    value._interpolate(
+      to: to.value,
+      amount: progress,
+      spatialOutTangent: spatialOutTangent?.pointValue,
+      spatialInTangent: to.spatialInTangent?.pointValue)
+  }
+}
 
 extension Keyframe {
-  
   /// Interpolates the keyTime into a value from 0-1
   func interpolatedProgress(_ to: Keyframe, keyTime: CGFloat) -> CGFloat {
     let startTime = time
@@ -20,11 +29,11 @@ extension Keyframe {
     if endTime <= keyTime {
       return 1
     }
-    
+
     if isHold {
       return 0
     }
-    
+
     let outTanPoint = outTangent?.pointValue ?? .zero
     let inTanPoint = to.inTangent?.pointValue ?? CGPoint(x: 1, y: 1)
     var progress: CGFloat = keyTime.remap(fromLow: startTime, fromHigh: endTime, toLow: 0, toHigh: 1)
@@ -34,10 +43,4 @@ extension Keyframe {
     }
     return progress
   }
-  
-  /// Interpolates the keyframes' by a progress from 0-1
-  func interpolate(_ to: Keyframe, progress: CGFloat) -> T {
-    return value.interpolateTo(to.value, amount: progress, spatialOutTangent: spatialOutTangent?.pointValue, spatialInTangent: to.spatialInTangent?.pointValue)
-  }
-  
 }

package/Sources/Private/Utility/Interpolatable/KeyframeGroup+Extensions.swift

@@ -0,0 +1,59 @@
+//
+//  KeyframeGroup+Extensions.swift
+//  Lottie
+//
+//  Created by JT Bergman on 6/20/22.
+//
+
+import CoreGraphics
+import Foundation
+
+extension KeyframeGroup where T == Vector1D {
+  /// Manually interpolates the keyframes so that they are defined linearly
+  ///
+  /// This method uses `UnitBezier` to perform the interpolation. It will create one keyframe
+  /// for each frame of the animation. For instance, if it is given a keyframe at time 0 and a keyframe
+  /// at time 10, it will create 10 interpolated keyframes. It is currently not optimized.
+  func manuallyInterpolateKeyframes() -> ContiguousArray<Keyframe<T>> {
+    guard keyframes.count > 1 else {
+      return keyframes
+    }
+
+    var output = ContiguousArray<Keyframe<Vector1D>>()
+
+    for idx in 1 ..< keyframes.count {
+      let prev = keyframes[idx - 1]
+      let curr = keyframes[idx]
+
+      // The timing function is responsible for computing the expected progress
+      let outTangent = prev.outTangent?.pointValue ?? .zero
+      let inTangent = curr.inTangent?.pointValue ?? .init(x: 1, y: 1)
+      let timingFunction = UnitBezier(controlPoint1: outTangent, controlPoint2: inTangent)
+
+      // These values are used to compute new values in the adjusted keyframes
+      let difference = curr.value.value - prev.value.value
+      let startValue = prev.value.value
+      let startTime = prev.time
+      let duration = max(Int(curr.time - prev.time), 0)
+
+      // Create one interpolated keyframe for each time in the duration
+      for t in 0 ... duration {
+        let progress = timingFunction.value(
+          for: CGFloat(t) / CGFloat(duration),
+          epsilon: 0.005)
+        let value = startValue + Double(progress) * difference
+        output.append(
+          Keyframe<Vector1D>(
+            value: Vector1D(value),
+            time: startTime + CGFloat(t),
+            isHold: false,
+            inTangent: nil,
+            outTangent: nil,
+            spatialInTangent: nil,
+            spatialOutTangent: nil))
+      }
+    }
+
+    return output
+  }
+}

package/{lottie-swift/src/Private/NodeRenderSystem/NodeProperties/ValueProviders → Sources/Private/Utility/Interpolatable}/KeyframeInterpolator.swift

@@ -5,101 +5,117 @@
 //  Created by Brandon Withrow on 1/15/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
+
+// MARK: - KeyframeInterpolator
 
 /// A value provider that produces a value at Time from a group of keyframes
-final class KeyframeInterpolator<ValueType>: AnyValueProvider where ValueType: Interpolatable {
-  
+final class KeyframeInterpolator<ValueType>: ValueProvider where ValueType: AnyInterpolatable {
+
+  // MARK: Lifecycle
+
   init(keyframes: ContiguousArray<Keyframe<ValueType>>) {
     self.keyframes = keyframes
   }
+
+  // MARK: Internal
+
   let keyframes: ContiguousArray<Keyframe<ValueType>>
-  
+
   var valueType: Any.Type {
-    return ValueType.self
+    ValueType.self
+  }
+
+  var storage: ValueProviderStorage<ValueType> {
+    .closure { [self] frame in
+      // First set the keyframe span for the frame.
+      updateSpanIndices(frame: frame)
+      lastUpdatedFrame = frame
+      // If only one keyframe return its value
+      let progress: CGFloat
+      let value: ValueType
+
+      if
+        let leading = leadingKeyframe,
+        let trailing = trailingKeyframe
+      {
+        /// We have leading and trailing keyframe.
+        progress = leading.interpolatedProgress(trailing, keyTime: frame)
+        value = leading.interpolate(to: trailing, progress: progress)
+      } else if let leading = leadingKeyframe {
+        progress = 0
+        value = leading.value
+      } else if let trailing = trailingKeyframe {
+        progress = 1
+        value = trailing.value
+      } else {
+        /// Satisfy the compiler.
+        progress = 0
+        value = keyframes[0].value
+      }
+      return value
+    }
   }
-  
-  /**
-   Returns true to trigger a frame update for this interpolator.
-   
-   An interpolator will be asked if it needs to update every frame.
-   If the interpolator needs updating it will be asked to compute its value for
-   the given frame.
-   
-   Cases a keyframe should not be updated:
-   - If time is in span and leading keyframe is hold
-   - If time is after the last keyframe.
-   - If time is before the first keyframe
-   
-   Cases for updating a keyframe:
-   - If time is in the span, and is not a hold
-   - If time is outside of the span, and there are more keyframes
-   - If a value delegate is set
-   - If leading and trailing are both nil.
-   */
+
+  /// Returns true to trigger a frame update for this interpolator.
+  ///
+  /// An interpolator will be asked if it needs to update every frame.
+  /// If the interpolator needs updating it will be asked to compute its value for
+  /// the given frame.
+  ///
+  /// Cases a keyframe should not be updated:
+  /// - If time is in span and leading keyframe is hold
+  /// - If time is after the last keyframe.
+  /// - If time is before the first keyframe
+  ///
+  /// Cases for updating a keyframe:
+  /// - If time is in the span, and is not a hold
+  /// - If time is outside of the span, and there are more keyframes
+  /// - If a value delegate is set
+  /// - If leading and trailing are both nil.
   func hasUpdate(frame: CGFloat) -> Bool {
     if lastUpdatedFrame == nil {
       return true
     }
 
-    if let leading = leadingKeyframe,
+    if
+      let leading = leadingKeyframe,
       trailingKeyframe == nil,
-      leading.time < frame {
+      leading.time < frame
+    {
       /// Frame is after bounds of keyframes
       return false
     }
-    if let trailing = trailingKeyframe,
+    if
+      let trailing = trailingKeyframe,
       leadingKeyframe == nil,
-      frame < trailing.time {
+      frame < trailing.time
+    {
       /// Frame is before bounds of keyframes
       return false
     }
-    if let leading = leadingKeyframe,
+    if
+      let leading = leadingKeyframe,
       let trailing = trailingKeyframe,
       leading.isHold,
       leading.time < frame,
-      frame < trailing.time {
+      frame < trailing.time
+    {
       return false
     }
     return true
   }
-  
+
+  // MARK: Fileprivate
+
   fileprivate var lastUpdatedFrame: CGFloat?
-  
-  @discardableResult
-  func value(frame: CGFloat) -> Any {
-    // First set the keyframe span for the frame.
-    updateSpanIndices(frame: frame)
-    lastUpdatedFrame = frame
-    // If only one keyframe return its value
-    let progress: CGFloat
-    let value: ValueType
-    
-    if let leading = leadingKeyframe,
-      let trailing = trailingKeyframe {
-      /// We have leading and trailing keyframe.
-      progress = leading.interpolatedProgress(trailing, keyTime: frame)
-      value = leading.interpolate(trailing, progress: progress)
-    } else if let leading = leadingKeyframe {
-      progress = 0
-      value = leading.value
-    } else if let trailing = trailingKeyframe {
-      progress = 1
-      value = trailing.value
-    } else {
-      /// Satisfy the compiler.
-      progress = 0
-      value = keyframes[0].value
-    }
-    return value
-  }
-  
+
   fileprivate var leadingIndex: Int? = nil
   fileprivate var trailingIndex: Int? = nil
   fileprivate var leadingKeyframe: Keyframe<ValueType>? = nil
   fileprivate var trailingKeyframe: Keyframe<ValueType>? = nil
-  
+
   /// Finds the appropriate Leading and Trailing keyframe index for the given time.
   fileprivate func updateSpanIndices(frame: CGFloat) {
     guard keyframes.count > 0 else {
@@ -109,21 +125,19 @@ final class KeyframeInterpolator<ValueType>: AnyValueProvider where ValueType: I
       trailingKeyframe = nil
       return
     }
-    
-    /**
-     This function searches through the array to find the span of two keyframes
-     that contain the current time.
-     
-     We could use Array.first(where:) but that would search through the entire array
-     each frame.
-     Instead we track the last used index and search either forwards or
-     backwards from there. This reduces the iterations and complexity from
-     
-     O(n), where n is the length of the sequence to
-     O(n), where n is the number of items after or before the last used index.
-     
-     */
-    
+
+    // This function searches through the array to find the span of two keyframes
+    // that contain the current time.
+    //
+    // We could use Array.first(where:) but that would search through the entire array
+    // each frame.
+    // Instead we track the last used index and search either forwards or
+    // backwards from there. This reduces the iterations and complexity from
+    //
+    // O(n), where n is the length of the sequence to
+    // O(n), where n is the number of items after or before the last used index.
+    //
+
     if keyframes.count == 1 {
       /// Only one keyframe. Set it as first and move on.
       leadingIndex = 0
@@ -132,10 +146,12 @@ final class KeyframeInterpolator<ValueType>: AnyValueProvider where ValueType: I
       trailingKeyframe = nil
       return
     }
-    
+
     /// Sets the initial keyframes. This is often only needed for the first check.
-    if leadingIndex == nil &&
-      trailingIndex == nil {
+    if
+      leadingIndex == nil,
+      trailingIndex == nil
+    {
       if frame < keyframes[0].time {
         /// Time is before the first keyframe. Set it as the trailing.
         trailingIndex = 0
@@ -145,21 +161,22 @@ final class KeyframeInterpolator<ValueType>: AnyValueProvider where ValueType: I
         trailingIndex = 1
       }
     }
-    
-    if let currentTrailing = trailingIndex,
-      keyframes[currentTrailing].time <= frame {
+
+    if
+      let currentTrailing = trailingIndex,
+      keyframes[currentTrailing].time <= frame
+    {
       /// Time is after the current span. Iterate forward.
       var newLeading = currentTrailing
-      var keyframeFound: Bool = false
+      var keyframeFound = false
       while !keyframeFound {
-        
         leadingIndex = newLeading
         trailingIndex = keyframes.validIndex(newLeading + 1)
-        
+
         guard let trailing = trailingIndex else {
-            /// We have reached the end of our keyframes. Time is after the last keyframe.
-            keyframeFound = true
-            continue
+          /// We have reached the end of our keyframes. Time is after the last keyframe.
+          keyframeFound = true
+          continue
         }
         if frame < keyframes[trailing].time {
           /// Keyframe in current span.
@@ -169,23 +186,23 @@ final class KeyframeInterpolator<ValueType>: AnyValueProvider where ValueType: I
         /// Advance the array.
         newLeading = trailing
       }
-      
-    } else if let currentLeading = leadingIndex,
-      frame < keyframes[currentLeading].time {
-      
+
+    } else if
+      let currentLeading = leadingIndex,
+      frame < keyframes[currentLeading].time
+    {
       /// Time is before the current span. Iterate backwards
       var newTrailing = currentLeading
-      
-      var keyframeFound: Bool = false
+
+      var keyframeFound = false
       while !keyframeFound {
-        
         leadingIndex = keyframes.validIndex(newTrailing - 1)
         trailingIndex = newTrailing
-        
+
         guard let leading = leadingIndex else {
-            /// We have reached the end of our keyframes. Time is after the last keyframe.
-            keyframeFound = true
-            continue
+          /// We have reached the end of our keyframes. Time is after the last keyframe.
+          keyframeFound = true
+          continue
         }
         if keyframes[leading].time <= frame {
           /// Keyframe in current span.
@@ -201,7 +218,7 @@ final class KeyframeInterpolator<ValueType>: AnyValueProvider where ValueType: I
     } else {
       leadingKeyframe = nil
     }
-    
+
     if let keyFrame = trailingIndex {
       trailingKeyframe = keyframes[keyFrame]
     } else {
@@ -210,24 +227,24 @@ final class KeyframeInterpolator<ValueType>: AnyValueProvider where ValueType: I
   }
 }
 
-fileprivate extension Array {
-  
-  func validIndex(_ index: Int) -> Int? {
+extension Array {
+
+  fileprivate func validIndex(_ index: Int) -> Int? {
     if 0 <= index, index < endIndex {
       return index
     }
     return nil
   }
-  
+
 }
 
-fileprivate extension ContiguousArray {
-  
-  func validIndex(_ index: Int) -> Int? {
+extension ContiguousArray {
+
+  fileprivate func validIndex(_ index: Int) -> Int? {
     if 0 <= index, index < endIndex {
       return index
     }
     return nil
   }
-  
+
 }