lottie-ios 3.2.2 → 3.4.1

package/lottie-swift/src/Private/Utility/Interpolatable/InterpolatableExtensions.swift

@@ -1,170 +0,0 @@
-//
-//  InterpolatableExtensions.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/14/19.
-//
-
-import Foundation
-import CoreGraphics
-
-extension Vector1D: Interpolatable {
-  func interpolateTo(_ to: Vector1D, amount: CGFloat, spatialOutTangent: CGPoint?, spatialInTangent: CGPoint?) -> Vector1D {
-    return value.interpolateTo(to.value, amount: amount).vectorValue
-  }
-}
-
-extension Vector2D: Interpolatable {
-  func interpolateTo(_ to: Vector2D, amount: CGFloat, spatialOutTangent: CGPoint?, spatialInTangent: CGPoint?) -> Vector2D {
-    return pointValue.interpolateTo(to.pointValue, amount: CGFloat(amount), spatialOutTangent: spatialOutTangent, spatialInTangent: spatialInTangent).vector2dValue
-  }
-  
-}
-
-extension Vector3D: Interpolatable {
-  func interpolateTo(_ to: Vector3D, amount: CGFloat, spatialOutTangent: CGPoint?, spatialInTangent: CGPoint?) -> Vector3D {
-    if spatialInTangent != nil || spatialOutTangent != nil {
-      // TODO Support third dimension spatial interpolation
-      let point = pointValue.interpolateTo(to.pointValue, amount: amount, spatialOutTangent: spatialOutTangent, spatialInTangent: spatialInTangent)
-      return Vector3D(x: point.x,
-                      y: point.y,
-                      z: CGFloat(z.interpolateTo(to.z, amount: amount)))
-    }
-    return Vector3D(x: x.interpolateTo(to.x, amount: amount),
-                    y: y.interpolateTo(to.y, amount: amount),
-                    z: z.interpolateTo(to.z, amount: amount))
-  }
-}
-
-extension Color: Interpolatable {
-  
-  /// Initialize a new color with Hue Saturation and Value
-  init(h: Double, s: Double, v: Double, a: Double) {
-    
-    let i = floor(h * 6)
-    let f = h * 6 - i
-    let p = v * (1 - s);
-    let q = v * (1 - f * s)
-    let t = v * (1 - (1 - f) * s)
-    
-    switch (i.truncatingRemainder(dividingBy: 6)) {
-    case 0:
-      self.r = v
-      self.g = t
-      self.b = p
-    case 1:
-      self.r = q
-      self.g = v
-      self.b = p
-    case 2:
-      self.r = p
-      self.g = v
-      self.b = t
-    case 3:
-      self.r = p
-      self.g = q
-      self.b = v
-    case 4:
-      self.r = t
-      self.g = p
-      self.b = v
-    case 5:
-      self.r = v
-      self.g = p
-      self.b = q
-    default:
-      self.r = 0
-      self.g = 0
-      self.b = 0
-    }
-    self.a = a
-  }
-  
-  /// Hue Saturation Value of the color.
-  var hsva: (h: Double, s: Double, v: Double, a: Double) {
-    let maxValue = max(r, g, b)
-    let minValue = min(r, g, b)
-    
-    var h: Double, s: Double, v: Double = maxValue
-    
-    let d = maxValue - minValue
-    s = maxValue == 0 ? 0 : d / maxValue;
-    
-    if (maxValue == minValue) {
-      h = 0; // achromatic
-    } else {
-      switch (maxValue) {
-      case r: h = (g - b) / d + (g < b ? 6 : 0)
-      case g: h = (b - r) / d + 2
-      case b: h = (r - g) / d + 4
-      default: h = maxValue
-      }
-      h = h / 6
-    }
-    return (h: h, s: s, v: v, a: a)
-  }
-  
-  init(y: Double, u: Double, v: Double, a: Double) {
-    // From https://www.fourcc.org/fccyvrgb.php
-    self.r = y + 1.403 * v
-    self.g = y - 0.344 * u
-    self.b = y + 1.770 * u
-    self.a = a
-  }
-  
-  var yuv: (y: Double, u: Double, v: Double, a: Double) {
-    /// From https://www.fourcc.org/fccyvrgb.php
-    let y = 0.299 * r + 0.587 * g + 0.114 * b
-    let u = -0.14713 * r - 0.28886 * g + 0.436 * b
-    let v = 0.615 * r - 0.51499 * g - 0.10001 * b
-    return (y: y, u: u, v: v, a: a)
-  }
-  
-  func interpolateTo(_ to: Color, amount: CGFloat, spatialOutTangent: CGPoint?, spatialInTangent: CGPoint?) -> Color {
-    return Color(r: r.interpolateTo(to.r, amount: amount),
-                 g: g.interpolateTo(to.g, amount: amount),
-                 b: b.interpolateTo(to.b, amount: amount),
-                 a: a.interpolateTo(to.a, amount: amount))
-  }
-}
-
-extension CurveVertex: Interpolatable {
-  func interpolateTo(_ to: CurveVertex, amount: CGFloat, spatialOutTangent: CGPoint?, spatialInTangent: CGPoint?) -> CurveVertex {
-    return CurveVertex(point: point.interpolate(to.point, amount: amount),
-                       inTangent: inTangent.interpolate(to.inTangent, amount: amount),
-                       outTangent: outTangent.interpolate(to.outTangent, amount: amount))
-  }
-}
-
-extension BezierPath: Interpolatable {
-  func interpolateTo(_ to: BezierPath, amount: CGFloat, spatialOutTangent: CGPoint?, spatialInTangent: CGPoint?) -> BezierPath {
-    var newPath = BezierPath()
-    for i in 0..<min(elements.count, to.elements.count) {
-      let fromVertex = elements[i].vertex
-      let toVertex = to.elements[i].vertex
-      newPath.addVertex(fromVertex.interpolateTo(toVertex, amount: amount, spatialOutTangent: spatialOutTangent, spatialInTangent: spatialInTangent))
-    }
-    return newPath
-  }
-}
-
-extension TextDocument: Interpolatable {
-  
-  func interpolateTo(_ to: TextDocument, amount: CGFloat, spatialOutTangent: CGPoint?, spatialInTangent: CGPoint?) -> TextDocument {
-    if amount == 1 {
-      return to
-    }
-    return self
-  }
-}
-
-extension Array: Interpolatable where Element == Double {
-  func interpolateTo(_ to: Array<Element>, amount: CGFloat, spatialOutTangent: CGPoint?, spatialInTangent: CGPoint?) -> Array<Element> {
-    var returnArray = [Double]()
-    for i in 0..<self.count {
-      returnArray.append(self[i].interpolateTo(to[i], amount: amount))
-    }
-    return returnArray
-  }
-  
-}

package/lottie-swift/src/Private/Utility/Primitives/CurveVertex.swift

@@ -1,177 +0,0 @@
-//
-//  CurveVertex.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/11/19.
-//
-
-import Foundation
-import CoreGraphics
-
-/// A single vertex with an in and out tangent
-struct CurveVertex {
-  
-  let point: CGPoint
-  
-  let inTangent: CGPoint
-  let outTangent: CGPoint
-  
-  /// Initializes a curve point with absolute values
-  init(_ inTangent: CGPoint, _ point: CGPoint, _ outTangent: CGPoint) {
-    self.point = point
-    self.inTangent = inTangent
-    self.outTangent = outTangent
-  }
-  
-  /// Initializes a curve point with relative values
-  init(point: CGPoint, inTangentRelative: CGPoint, outTangentRelative: CGPoint) {
-    self.point = point
-    self.inTangent = point.add(inTangentRelative)
-    self.outTangent = point.add(outTangentRelative)
-  }
-  
-  /// Initializes a curve point with absolute values
-  init(point: CGPoint, inTangent: CGPoint, outTangent: CGPoint) {
-    self.point = point
-    self.inTangent = inTangent
-    self.outTangent = outTangent
-  }
-  
-  var inTangentRelative: CGPoint {
-    return inTangent.subtract(point)
-  }
-  
-  var outTangentRelative: CGPoint {
-    return outTangent.subtract(point)
-  }
-  
-  func reversed() -> CurveVertex {
-    return CurveVertex(point: point, inTangent: outTangent, outTangent: inTangent)
-  }
-  
-  func translated(_ translation: CGPoint) -> CurveVertex {
-    return CurveVertex(point: point + translation, inTangent: inTangent + translation, outTangent: outTangent + translation)
-  }
-  
-  /**
-   Trims a path defined by two Vertices at a specific position, from 0 to 1
-   
-   The path can be visualized below.
-   
-   F is fromVertex.
-   V is the vertex of the receiver.
-   P is the position from 0-1.
-   O is the outTangent of fromVertex.
-   F====O=========P=======I====V
-   
-   After trimming the curve can be visualized below.
-   
-   S is the returned Start vertex.
-   E is the returned End vertex.
-   T is the trim point.
-   TI and TO are the new tangents for the trimPoint
-   NO and NI are the new tangents for the startPoint and endPoints
-   S==NO=========TI==T==TO=======NI==E
-   */
-  func splitCurve(toVertex: CurveVertex, position: CGFloat) ->
-    (start: CurveVertex, trimPoint: CurveVertex, end: CurveVertex) {
-      
-      /// If position is less than or equal to 0, trim at start.
-      if position <= 0 {
-        return (start: CurveVertex(point: point, inTangentRelative: inTangentRelative, outTangentRelative: .zero),
-                trimPoint: CurveVertex(point: point, inTangentRelative: .zero, outTangentRelative: outTangentRelative),
-                end: toVertex)
-      }
-      
-      /// If position is greater than or equal to 1, trim at end.
-      if position >= 1 {
-        return (start: self,
-                trimPoint: CurveVertex(point: toVertex.point, inTangentRelative: toVertex.inTangentRelative, outTangentRelative: .zero),
-                end: CurveVertex(point: toVertex.point, inTangentRelative: .zero, outTangentRelative: toVertex.outTangentRelative))
-      }
-      
-      if outTangentRelative.isZero && toVertex.inTangentRelative.isZero {
-        /// If both tangents are zero, then span to be trimmed is a straight line.
-        let trimPoint = point.interpolate(toVertex.point, amount: position)
-        return (start: self,
-                trimPoint: CurveVertex(point: trimPoint, inTangentRelative: .zero, outTangentRelative: .zero),
-                end: toVertex)
-      }
-      /// Cutting by amount gives incorrect length....
-      /// One option is to cut by a stride until it gets close then edge it down.
-      /// Measuring a percentage of the spans does not equal the same as measuring a percentage of length.
-      /// This is where the historical trim path bugs come from.
-      let a = point.interpolate(outTangent, amount: position)
-      let b = outTangent.interpolate(toVertex.inTangent, amount: position)
-      let c = toVertex.inTangent.interpolate(toVertex.point, amount: position)
-      let d = a.interpolate(b, amount: position)
-      let e = b.interpolate(c, amount: position)
-      let f = d.interpolate(e, amount: position)
-      return (start: CurveVertex(point: point, inTangent: inTangent, outTangent: a),
-              trimPoint: CurveVertex(point: f, inTangent: d, outTangent: e),
-              end: CurveVertex(point: toVertex.point, inTangent: c, outTangent: toVertex.outTangent))
-  }
-  
-  /**
-   Trims a curve of a known length to a specific length and returns the points.
-   
-   There is not a performant yet accurate way to cut a curve to a specific length.
-   This calls splitCurve(toVertex: position:) to split the curve and then measures
-   the length of the new curve. The function then iterates through the samples,
-   adjusting the position of the cut for a more precise cut.
-   Usually a single iteration is enough to get within 0.5 points of the desired
-   length.
-   
-   This function should probably live in PathElement, since it deals with curve
-   lengths.
-  */
-  func trimCurve(toVertex: CurveVertex, atLength: CGFloat, curveLength: CGFloat, maxSamples: Int, accuracy: CGFloat = 1) ->
-    (start: CurveVertex, trimPoint: CurveVertex, end: CurveVertex) {
-      var currentPosition = atLength / curveLength
-      var results = splitCurve(toVertex: toVertex, position: currentPosition)
-      
-      if maxSamples == 0 {
-        return results
-      }
-      
-      for _ in 1...maxSamples {
-        let length = results.start.distanceTo(results.trimPoint)
-        let lengthDiff = atLength - length
-        /// Check if length is correct.
-        if lengthDiff < accuracy {
-          return results
-        }
-        let diffPosition = max(min(((currentPosition / length) * lengthDiff), currentPosition * 0.5), currentPosition * -0.5)
-        currentPosition = diffPosition + currentPosition
-        results = splitCurve(toVertex: toVertex, position: currentPosition)
-      }
-      return results
-  }
-
-  
-  /**
-   The distance from the receiver to the provided vertex.
-   
-   For lines (zeroed tangents) the distance between the two points is measured.
-   For curves the curve is iterated over by sample count and the points are measured.
-   This is ~99% accurate at a sample count of 30
-   */
-  func distanceTo(_ toVertex: CurveVertex, sampleCount: Int = 25) -> CGFloat {
-    
-    if outTangentRelative.isZero && toVertex.inTangentRelative.isZero {
-      /// Return a linear distance.
-      return point.distanceTo(toVertex.point)
-    }
-    
-    var distance: CGFloat = 0
-    
-    var previousPoint = point
-    for i in 0..<sampleCount {
-      let pointOnCurve = splitCurve(toVertex: toVertex, position: CGFloat(i) / CGFloat(sampleCount)).trimPoint
-      distance = distance + previousPoint.distanceTo(pointOnCurve.point)
-      previousPoint = pointOnCurve.point
-    }
-    distance = distance + previousPoint.distanceTo(toVertex.point)
-    return distance
-  }
-}

package/lottie-swift/src/Private/Utility/Primitives/PathElement.swift

@@ -1,68 +0,0 @@
-//
-//  PathElement.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/11/19.
-//
-
-import Foundation
-import CoreGraphics
-
-/**
- A path section, containing one point and its length to the previous point.
- 
- The relationship between this path element and the previous is implicit.
- Ideally a path section would be defined by two vertices and a length.
- We don't do this however, as it would effectively double the memory footprint
- of path data.
- 
- */
-struct PathElement {
-  /// The absolute Length of the path element.
-  let length: CGFloat
-  
-  /// The vertex of the element
-  let vertex: CurveVertex
-  
-  /// Returns a new path element define the span from the receiver to the new vertex.
-  func pathElementTo(_ toVertex: CurveVertex) -> PathElement {
-    return PathElement(length: vertex.distanceTo(toVertex), vertex: toVertex)
-  }
-  
-  /// Initializes a new path with length of 0
-  init(vertex: CurveVertex) {
-    self.length = 0
-    self.vertex = vertex
-  }
-  
-  /// Initializes a new path with length
-  fileprivate init(length: CGFloat, vertex: CurveVertex) {
-    self.length = length
-    self.vertex = vertex
-  }
-  
-  func updateVertex(newVertex: CurveVertex) -> PathElement {
-    return PathElement(length: length, vertex: newVertex)
-  }
-  
-  /// Splits an element span defined by the receiver and fromElement to a position 0-1
-  func splitElementAtPosition(fromElement: PathElement, atLength: CGFloat) ->
-    (leftSpan: (start: PathElement, end: PathElement), rightSpan: (start: PathElement, end: PathElement)) {
-      /// Trim the span. Start and trim go into the first, trim and end go into second.
-      let trimResults = fromElement.vertex.trimCurve(toVertex: vertex, atLength: atLength, curveLength: length, maxSamples: 3)
-
-      /// Create the elements for the break
-      let spanAStart = PathElement(length: fromElement.length,
-                                   vertex: CurveVertex(point: fromElement.vertex.point,
-                                                       inTangent: fromElement.vertex.inTangent,
-                                                       outTangent: trimResults.start.outTangent))
-      /// Recalculating the length here is a waste as the trimCurve function also accurately calculates this length.
-      let spanAEnd = spanAStart.pathElementTo(trimResults.trimPoint)
-      
-      let spanBStart = PathElement(vertex: trimResults.trimPoint)
-      let spanBEnd = spanBStart.pathElementTo(trimResults.end)
-      return (leftSpan: (start: spanAStart, end: spanAEnd),
-              rightSpan: (start: spanBStart, end: spanBEnd))
-  }
-  
-}

package/lottie-swift/src/Private/Utility/Primitives/VectorsExtensions.swift

@@ -1,218 +0,0 @@
-//
-//  Vector.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/7/19.
-//
-
-import Foundation
-import CoreGraphics
-import QuartzCore
-
-/**
- Single value container. Needed because lottie sometimes wraps a Double in an array.
- */
-extension Vector1D: Codable {
-
-  public init(from decoder: Decoder) throws {
-    /// Try to decode an array of doubles
-    do {
-      var container = try decoder.unkeyedContainer()
-      self.value = try container.decode(Double.self)
-    } catch {
-      self.value = try decoder.singleValueContainer().decode(Double.self)
-    }
-  }
-  
-  public func encode(to encoder: Encoder) throws {
-    var container = encoder.singleValueContainer()
-    try container.encode(value)
-  }
-  
-  var cgFloatValue: CGFloat {
-    return CGFloat(value)
-  }
-  
-}
-
-extension Double {
-  var vectorValue: Vector1D {
-    return Vector1D(self)
-  }
-}
-
-/**
- Needed for decoding json {x: y:} to a CGPoint
- */
-struct Vector2D: Codable {
-  
-  var x: Double
-  var y: Double
-  
-  init(x: Double, y: Double) {
-    self.x = x
-    self.y = y
-  }
-  
-  private enum CodingKeys : String, CodingKey {
-    case x = "x"
-    case y = "y"
-  }
-  
-  init(from decoder: Decoder) throws {
-    let container = try decoder.container(keyedBy: Vector2D.CodingKeys.self)
-    
-    do {
-      let xValue: [Double] = try container.decode([Double].self, forKey: .x)
-      self.x = xValue[0]
-    } catch {
-      self.x = try container.decode(Double.self, forKey: .x)
-    }
-    
-    do {
-      let yValue: [Double] = try container.decode([Double].self, forKey: .y)
-      self.y = yValue[0]
-    } catch {
-      self.y = try container.decode(Double.self, forKey: .y)
-    }
-  }
-  
-  func encode(to encoder: Encoder) throws {
-    var container = encoder.container(keyedBy: Vector2D.CodingKeys.self)
-    try container.encode(x, forKey: .x)
-    try container.encode(y, forKey: .y)
-  }
-  
-  var pointValue: CGPoint {
-    return CGPoint(x: x, y: y)
-  }
-}
-
-extension Vector2D {
-  
-}
-
-extension CGPoint {
-  var vector2dValue: Vector2D {
-    return Vector2D(x: Double(x), y: Double(y))
-  }
-}
-
-/**
- A three dimensional vector.
- These vectors are encoded and decoded from [Double]
- */
-
-extension Vector3D: Codable {
-
-  init(x: CGFloat, y: CGFloat, z: CGFloat) {
-    self.x = Double(x)
-    self.y = Double(y)
-    self.z = Double(z)
-  }
-  
-  public init(from decoder: Decoder) throws {
-    var container = try decoder.unkeyedContainer()
-    
-    if !container.isAtEnd {
-      self.x = try container.decode(Double.self)
-    } else {
-      self.x = 0
-    }
-    
-    if !container.isAtEnd {
-      self.y = try container.decode(Double.self)
-    } else {
-      self.y = 0
-    }
-    
-    if !container.isAtEnd {
-      self.z = try container.decode(Double.self)
-    } else {
-      self.z = 0
-    }
-  }
-  
-  public func encode(to encoder: Encoder) throws {
-    var container = encoder.unkeyedContainer()
-    try container.encode(x)
-    try container.encode(y)
-    try container.encode(z)
-  }
-  
-}
-
-public extension Vector3D {
-  var pointValue: CGPoint {
-    return CGPoint(x: x, y: y)
-  }
-  
-  var sizeValue: CGSize {
-    return CGSize(width: x, height: y)
-  }
-}
-
-extension CGPoint {
-  var vector3dValue: Vector3D {
-    return Vector3D(x: x, y: y, z: 0)
-  }
-}
-
-extension CGSize {
-  var vector3dValue: Vector3D {
-    return Vector3D(x: width, y: height, z: 1)
-  }
-}
-
-extension CATransform3D {
-  
-  func rotated(_ degrees: CGFloat) -> CATransform3D {
-    return CATransform3DRotate(self, degrees.toRadians(), 0, 0, 1)
-  }
-  
-  func translated(_ translation: CGPoint) -> CATransform3D {
-    return CATransform3DTranslate(self, translation.x, translation.y, 0)
-  }
-  
-  func scaled(_ scale: CGSize) -> CATransform3D {
-    return CATransform3DScale(self, scale.width, scale.height, 1)
-  }
-  
-  func skewed(skew: CGFloat, skewAxis: CGFloat) -> CATransform3D {
-    return CATransform3DConcat(CATransform3D.makeSkew(skew: skew, skewAxis: skewAxis), self)
-  }
-  
-  static func makeSkew(skew: CGFloat, skewAxis: CGFloat) -> CATransform3D {
-    let mCos = cos(skewAxis.toRadians())
-    let mSin = sin(skewAxis.toRadians())
-    let aTan = tan(skew.toRadians())
-    
-    let transform1 = CATransform3D(m11: mCos, m12: mSin, m13: 0, m14: 0,
-                                   m21: -mSin, m22: mCos, m23: 0, m24: 0,
-                                   m31: 0, m32: 0, m33: 1, m34: 0,
-                                   m41: 0, m42: 0, m43: 0, m44: 1)
-    
-    let transform2 = CATransform3D(m11: 1, m12: 0, m13: 0, m14: 0,
-                                   m21: aTan, m22: 1, m23: 0, m24: 0,
-                                   m31: 0, m32: 0, m33: 1, m34: 0,
-                                   m41: 0, m42: 0, m43: 0, m44: 1)
-    
-    let transform3 = CATransform3D(m11: mCos, m12: -mSin, m13: 0, m14: 0,
-                                   m21: mSin, m22: mCos, m23: 0, m24: 0,
-                                   m31: 0, m32: 0, m33: 1, m34: 0,
-                                   m41: 0, m42: 0, m43: 0, m44: 1)
-    return CATransform3DConcat(transform3, CATransform3DConcat(transform2, transform1))
-  }
-  
-  static func makeTransform(anchor: CGPoint,
-                            position: CGPoint,
-                            scale: CGSize,
-                            rotation: CGFloat,
-                            skew: CGFloat?,
-                            skewAxis: CGFloat?) -> CATransform3D {
-    if let skew = skew, let skewAxis = skewAxis {
-      return CATransform3DMakeTranslation(position.x, position.y, 0).rotated(rotation).skewed(skew: -skew, skewAxis: skewAxis).scaled(scale * 0.01).translated(anchor * -1)
-    }
-    return CATransform3DMakeTranslation(position.x, position.y, 0).rotated(rotation).scaled(scale * 0.01).translated(anchor * -1)
-  }
-}