lottie-ios 3.2.2 → 3.4.1

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
+  }
+}