lottie-ios 3.2.3 → 3.4.2

package/lottie-swift/src/Private/Model/Text/TextDocument.swift

@@ -1,70 +0,0 @@
-//
-//  TextDocument.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/9/19.
-//
-
-import Foundation
-
-enum TextJustification: Int, Codable {
-  case left
-  case right
-  case center
-}
-
-final class TextDocument: Codable {
-  
-  /// The Text
-  let text: String
-  
-  /// The Font size
-  let fontSize: Double
-  
-  /// The Font Family
-  let fontFamily: String
-  
-  /// Justification
-  let justification: TextJustification
-  
-  /// Tracking
-  let tracking: Int
-  
-  /// Line Height
-  let lineHeight: Double
-  
-  /// Baseline
-  let baseline: Double?
-  
-  /// Fill Color data
-  let fillColorData: Color?
-  
-  /// Scroke Color data
-  let strokeColorData: Color?
-  
-  /// Stroke Width
-  let strokeWidth: Double?
-  
-  /// Stroke Over Fill
-  let strokeOverFill: Bool?
-  
-  let textFramePosition: Vector3D?
-  
-  let textFrameSize: Vector3D?
-  
-  private enum CodingKeys : String, CodingKey {
-    case text = "t"
-    case fontSize = "s"
-    case fontFamily = "f"
-    case justification = "j"
-    case tracking = "tr"
-    case lineHeight = "lh"
-    case baseline = "ls"
-    case fillColorData = "fc"
-    case strokeColorData = "sc"
-    case strokeWidth = "sw"
-    case strokeOverFill = "of"
-    case textFramePosition = "ps"
-    case textFrameSize = "sz"
-  }
-}

package/lottie-swift/src/Private/NodeRenderSystem/Nodes/PathNodes/EllipseNode.swift

@@ -1,109 +0,0 @@
-//
-//  EllipseNode.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/17/19.
-//
-
-import Foundation
-import QuartzCore
-
-final class EllipseNodeProperties: NodePropertyMap, KeypathSearchable {
-  
-  var keypathName: String
-  
-  init(ellipse: Ellipse) {
-    self.keypathName = ellipse.name
-    self.direction = ellipse.direction
-    self.position = NodeProperty(provider: KeyframeInterpolator(keyframes: ellipse.position.keyframes))
-    self.size = NodeProperty(provider: KeyframeInterpolator(keyframes: ellipse.size.keyframes))
-    self.keypathProperties = [
-      "Position" : position,
-      "Size" : size
-    ]
-    self.properties = Array(keypathProperties.values)
-  }
-  
-  let direction: PathDirection
-  let position: NodeProperty<Vector3D>
-  let size: NodeProperty<Vector3D>
-  
-  let keypathProperties: [String : AnyNodeProperty]
-  let properties: [AnyNodeProperty]
-}
-
-final class EllipseNode: AnimatorNode, PathNode {
-  
-  let pathOutput: PathOutputNode
-  
-  let properties: EllipseNodeProperties
-
-  init(parentNode: AnimatorNode?, ellipse: Ellipse) {
-    self.pathOutput = PathOutputNode(parent: parentNode?.outputNode)
-    self.properties = EllipseNodeProperties(ellipse: ellipse)
-    self.parentNode = parentNode
-  }
-  
-  // MARK: Animator Node
-  
-  var propertyMap: NodePropertyMap & KeypathSearchable {
-    return properties
-  }
-  
-  let parentNode: AnimatorNode?
-  var hasLocalUpdates: Bool = false
-  var hasUpstreamUpdates: Bool = false
-  var lastUpdateFrame: CGFloat? = nil
-  var isEnabled: Bool = true {
-    didSet{
-      self.pathOutput.isEnabled = self.isEnabled
-    }
-  }
-  
-  func rebuildOutputs(frame: CGFloat) {
-    let ellipseSize = properties.size.value.sizeValue
-    let center = properties.position.value.pointValue
-    
-    // Unfortunately we HAVE to manually build out the ellipse.
-    // Every Apple method constructs an ellipse from the 3 o-clock position
-    // After effects constructs from the Noon position.
-    // After effects does clockwise, but also has a flag for reversed.
-    
-    var half = ellipseSize * 0.5
-    if properties.direction == .counterClockwise {
-      half.width = half.width * -1
-    }
-    
-    
-    let q1 = CGPoint(x: center.x, y: center.y - half.height)
-    let q2 = CGPoint(x: center.x + half.width, y: center.y)
-    let q3 = CGPoint(x: center.x, y: center.y + half.height)
-    let q4 = CGPoint(x: center.x - half.width, y: center.y)
-    
-    let cp = half * EllipseNode.ControlPointConstant
-    
-    var path = BezierPath(startPoint: CurveVertex(point: q1,
-                                                  inTangentRelative: CGPoint(x: -cp.width, y: 0),
-                                                  outTangentRelative: CGPoint(x: cp.width, y: 0)))
-    path.addVertex(CurveVertex(point: q2,
-                               inTangentRelative: CGPoint(x: 0, y: -cp.height),
-                               outTangentRelative: CGPoint(x: 0, y: cp.height)))
-    
-    path.addVertex(CurveVertex(point: q3,
-                               inTangentRelative: CGPoint(x: cp.width, y: 0),
-                               outTangentRelative: CGPoint(x: -cp.width, y: 0)))
-    
-    path.addVertex(CurveVertex(point: q4,
-                               inTangentRelative: CGPoint(x: 0, y: cp.height),
-                               outTangentRelative: CGPoint(x: 0, y: -cp.height)))
-    
-    path.addVertex(CurveVertex(point: q1,
-                               inTangentRelative: CGPoint(x: -cp.width, y: 0),
-                               outTangentRelative: CGPoint(x: cp.width, y: 0)))
-    path.close()
-    pathOutput.setPath(path, updateFrame: frame)
-  }
-
-  static let ControlPointConstant: CGFloat = 0.55228
-  
-}

package/lottie-swift/src/Private/NodeRenderSystem/Nodes/PathNodes/PolygonNode.swift

@@ -1,132 +0,0 @@
-//
-//  PolygonNode.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/21/19.
-//
-
-import Foundation
-import QuartzCore
-
-final class PolygonNodeProperties: NodePropertyMap, KeypathSearchable {
-  
-  var keypathName: String
-
-  var childKeypaths: [KeypathSearchable] = []
-  
-  init(star: Star) {
-    self.keypathName = star.name
-    self.direction = star.direction
-    self.position = NodeProperty(provider: KeyframeInterpolator(keyframes: star.position.keyframes))
-    self.outerRadius = NodeProperty(provider: KeyframeInterpolator(keyframes: star.outerRadius.keyframes))
-    self.outerRoundedness = NodeProperty(provider: KeyframeInterpolator(keyframes: star.outerRoundness.keyframes))
-    self.rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: star.rotation.keyframes))
-    self.points = NodeProperty(provider: KeyframeInterpolator(keyframes: star.points.keyframes))
-    self.keypathProperties = [
-      "Position" : position,
-      "Outer Radius" : outerRadius,
-      "Outer Roundedness" : outerRoundedness,
-      "Rotation" : rotation,
-      "Points" : points
-    ]
-    self.properties = Array(keypathProperties.values)
-  }
-  
-  let keypathProperties: [String : AnyNodeProperty]
-  let properties: [AnyNodeProperty]
-  
-  let direction: PathDirection
-  let position: NodeProperty<Vector3D>
-  let outerRadius: NodeProperty<Vector1D>
-  let outerRoundedness: NodeProperty<Vector1D>
-  let rotation: NodeProperty<Vector1D>
-  let points: NodeProperty<Vector1D>
-}
-
-final class PolygonNode: AnimatorNode, PathNode {
-  
-  let properties: PolygonNodeProperties
-  
-  let pathOutput: PathOutputNode
-  
-  init(parentNode: AnimatorNode?, star: Star) {
-    self.pathOutput = PathOutputNode(parent: parentNode?.outputNode)
-    self.properties = PolygonNodeProperties(star: star)
-    self.parentNode = parentNode
-  }
-  
-  // MARK: Animator Node
-
-  var propertyMap: NodePropertyMap & KeypathSearchable {
-    return properties
-  }
-  
-  let parentNode: AnimatorNode?
-  var hasLocalUpdates: Bool = false
-  var hasUpstreamUpdates: Bool = false
-  var lastUpdateFrame: CGFloat? = nil
-  var isEnabled: Bool = true {
-    didSet{
-      self.pathOutput.isEnabled = self.isEnabled
-    }
-  }
-  
-  /// Magic number needed for constructing path.
-  static let PolygonConstant: CGFloat = 0.25
-  
-  func rebuildOutputs(frame: CGFloat) {
-    let outerRadius = properties.outerRadius.value.cgFloatValue
-    let outerRoundedness = properties.outerRoundedness.value.cgFloatValue * 0.01
-    let numberOfPoints = properties.points.value.cgFloatValue
-    let rotation = properties.rotation.value.cgFloatValue
-    let position = properties.position.value.pointValue
-  
-    var currentAngle = (rotation - 90).toRadians()
-    let anglePerPoint = ((2 * CGFloat.pi) / numberOfPoints)
-    
-    var point = CGPoint(x: (outerRadius * cos(currentAngle)),
-                        y: (outerRadius * sin(currentAngle)))
-    var vertices = [CurveVertex(point: point + position, inTangentRelative: .zero, outTangentRelative: .zero)]
-    
-    var previousPoint = point
-    currentAngle += anglePerPoint;
-    for _ in 0..<Int(ceil(numberOfPoints)) {
-      previousPoint = point
-      point = CGPoint(x: (outerRadius * cos(currentAngle)),
-                      y: (outerRadius * sin(currentAngle)))
-      
-      if outerRoundedness != 0 {
-        let cp1Theta = (atan2(previousPoint.y, previousPoint.x) - CGFloat.pi / 2)
-        let cp1Dx = cos(cp1Theta);
-        let cp1Dy = sin(cp1Theta);
-        
-        let cp2Theta = (atan2(point.y, point.x) - CGFloat.pi / 2)
-        let cp2Dx = cos(cp2Theta)
-        let cp2Dy = sin(cp2Theta)
-        
-        let cp1 = CGPoint(x: outerRadius * outerRoundedness * PolygonNode.PolygonConstant * cp1Dx,
-                          y: outerRadius * outerRoundedness * PolygonNode.PolygonConstant * cp1Dy)
-        let cp2 = CGPoint(x: outerRadius * outerRoundedness * PolygonNode.PolygonConstant * cp2Dx,
-                          y: outerRadius * outerRoundedness * PolygonNode.PolygonConstant * cp2Dy)
-
-        let previousVertex = vertices[vertices.endIndex-1]
-        vertices[vertices.endIndex-1] = CurveVertex(previousVertex.inTangent, previousVertex.point, previousVertex.point - cp1 + position)
-        vertices.append(CurveVertex(point: point + position, inTangentRelative: cp2, outTangentRelative: .zero))
-      } else {
-        vertices.append(CurveVertex(point: point + position, inTangentRelative: .zero, outTangentRelative: .zero))
-      }
-      currentAngle += anglePerPoint;
-    }
-    let reverse = properties.direction == .counterClockwise
-    if reverse {
-      vertices = vertices.reversed()
-    }
-    var path = BezierPath()
-    for vertex in vertices {
-      path.addVertex(reverse ? vertex.reversed() : vertex)
-    }
-    path.close()
-    pathOutput.setPath(path, updateFrame: frame)
-  }
-  
-}

package/lottie-swift/src/Private/NodeRenderSystem/Nodes/RenderContainers/GroupNode.swift

@@ -1,141 +0,0 @@
-//
-//  GroupNode.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/18/19.
-//
-
-import Foundation
-import QuartzCore
-import CoreGraphics
-
-final class GroupNodeProperties: NodePropertyMap, KeypathSearchable {
-  
-  var keypathName: String = "Transform"
-  
-  var childKeypaths: [KeypathSearchable] = []
-  
-  init(transform: ShapeTransform?) {
-    if let transform = transform {
-      self.anchor = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.anchor.keyframes))
-      self.position = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.position.keyframes))
-      self.scale = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.scale.keyframes))
-      self.rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.rotation.keyframes))
-      self.opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.opacity.keyframes))
-      self.skew = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.skew.keyframes))
-      self.skewAxis = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.skewAxis.keyframes))
-    } else {
-      /// Transform node missing. Default to empty transform.
-      self.anchor = NodeProperty(provider: SingleValueProvider(Vector3D(x: CGFloat(0), y: CGFloat(0), z: CGFloat(0))))
-      self.position = NodeProperty(provider: SingleValueProvider(Vector3D(x: CGFloat(0), y: CGFloat(0), z: CGFloat(0))))
-      self.scale = NodeProperty(provider: SingleValueProvider(Vector3D(x: CGFloat(1), y: CGFloat(1), z: CGFloat(1))))
-      self.rotation = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
-      self.opacity = NodeProperty(provider: SingleValueProvider(Vector1D(1)))
-      self.skew = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
-      self.skewAxis = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
-    }
-    self.keypathProperties = [
-      "Anchor Point" : anchor,
-      "Position" : position,
-      "Scale" : scale,
-      "Rotation" : rotation,
-      "Opacity" : opacity,
-      "Skew" : skew,
-      "Skew Axis" : skewAxis
-    ]
-    self.properties = Array(keypathProperties.values)
-  }
-  
-  let keypathProperties: [String : AnyNodeProperty]
-  let properties: [AnyNodeProperty]
-  
-  let anchor: NodeProperty<Vector3D>
-  let position: NodeProperty<Vector3D>
-  let scale: NodeProperty<Vector3D>
-  let rotation: NodeProperty<Vector1D>
-  let opacity: NodeProperty<Vector1D>
-  let skew: NodeProperty<Vector1D>
-  let skewAxis: NodeProperty<Vector1D>
-  
-  var caTransform: CATransform3D {
-    return CATransform3D.makeTransform(anchor: anchor.value.pointValue,
-                                       position: position.value.pointValue,
-                                       scale: scale.value.sizeValue,
-                                       rotation: rotation.value.cgFloatValue,
-                                       skew: skew.value.cgFloatValue,
-                                       skewAxis: skewAxis.value.cgFloatValue)
-  }
-}
-
-final class GroupNode: AnimatorNode {
-  
-  // MARK: Properties
-  let groupOutput: GroupOutputNode
-  
-  let properties: GroupNodeProperties
-
-  let rootNode: AnimatorNode?
-  
-  var container: ShapeContainerLayer = ShapeContainerLayer()
-
-  // MARK: Initializer
-  init(name: String, parentNode: AnimatorNode?, tree: NodeTree) {
-    self.parentNode = parentNode
-    self.keypathName = name
-    self.rootNode = tree.rootNode
-    self.properties = GroupNodeProperties(transform: tree.transform)
-    self.groupOutput = GroupOutputNode(parent: parentNode?.outputNode, rootNode: rootNode?.outputNode)
-    var childKeypaths: [KeypathSearchable] = tree.childrenNodes
-    childKeypaths.append(properties)
-    self.childKeypaths = childKeypaths
-    
-    for childContainer in tree.renderContainers {
-      container.insertRenderLayer(childContainer)
-    }
-  }
-  
-  // MARK: Keypath Searchable
-  
-  let keypathName: String
-  
-  let childKeypaths: [KeypathSearchable]
-  
-  var keypathLayer: CALayer? {
-    return container
-  }
-  
-  // MARK: Animator Node Protocol
-  
-  var propertyMap: NodePropertyMap & KeypathSearchable {
-    return properties
-  }
-  
-  var outputNode: NodeOutput {
-    return groupOutput
-  }
-  
-  let parentNode: AnimatorNode?
-  var hasLocalUpdates: Bool = false
-  var hasUpstreamUpdates: Bool = false
-  var lastUpdateFrame: CGFloat? = nil
-  var isEnabled: Bool = true {
-    didSet {
-      container.isHidden = !isEnabled
-    }
-  }
-  
-  func performAdditionalLocalUpdates(frame: CGFloat, forceLocalUpdate: Bool) -> Bool {
-    return rootNode?.updateContents(frame, forceLocalUpdate: forceLocalUpdate) ?? false
-  }
-  
-  func performAdditionalOutputUpdates(_ frame: CGFloat, forceOutputUpdate: Bool) {
-    rootNode?.updateOutputs(frame, forceOutputUpdate: forceOutputUpdate)
-  }
-  
-  func rebuildOutputs(frame: CGFloat) {
-    container.opacity = Float(properties.opacity.value.cgFloatValue) * 0.01
-    container.transform = properties.caTransform
-    groupOutput.setTransform(container.transform, forFrame: frame)
-  }
-  
-}

package/lottie-swift/src/Private/NodeRenderSystem/Nodes/RenderNodes/StrokeNode.swift

@@ -1,127 +0,0 @@
-//
-//  StrokeNode.swift
-//  lottie-swift
-//
-//  Created by Brandon Withrow on 1/22/19.
-//
-
-import Foundation
-import QuartzCore
-// MARK: - Properties
-
-final class StrokeNodeProperties: NodePropertyMap, KeypathSearchable {
-  
-  init(stroke: Stroke) {
-    self.keypathName = stroke.name
-    self.color = NodeProperty(provider: KeyframeInterpolator(keyframes: stroke.color.keyframes))
-    self.opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: stroke.opacity.keyframes))
-    self.width = NodeProperty(provider: KeyframeInterpolator(keyframes: stroke.width.keyframes))
-    self.miterLimit = CGFloat(stroke.miterLimit)
-    self.lineCap = stroke.lineCap
-    self.lineJoin = stroke.lineJoin
-    
-    if let dashes = stroke.dashPattern {
-      var dashPatterns = ContiguousArray<ContiguousArray<Keyframe<Vector1D>>>()
-      var dashPhase = ContiguousArray<Keyframe<Vector1D>>()
-      for dash in dashes {
-        if dash.type == .offset {
-          dashPhase = dash.value.keyframes
-        } else {
-          dashPatterns.append(dash.value.keyframes)
-        }
-      }
-      self.dashPattern = NodeProperty(provider: GroupInterpolator(keyframeGroups: dashPatterns))
-      if dashPhase.count == 0 {
-        self.dashPhase = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
-      } else {
-        self.dashPhase = NodeProperty(provider: KeyframeInterpolator(keyframes: dashPhase))
-      }
-    } else {
-      self.dashPattern = NodeProperty(provider: SingleValueProvider([Vector1D]()))
-      self.dashPhase = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
-    }
-    self.keypathProperties = [
-      "Opacity" : opacity,
-      "Color" : color,
-      "Stroke Width" : width,
-      "Dashes" : dashPattern,
-      "Dash Phase" : dashPhase
-    ]
-    self.properties = Array(keypathProperties.values)
-  }
-  
-  let keypathName: String
-  let keypathProperties: [String : AnyNodeProperty]
-  let properties: [AnyNodeProperty]
-  
-  let opacity: NodeProperty<Vector1D>
-  let color: NodeProperty<Color>
-  let width: NodeProperty<Vector1D>
-  
-  let dashPattern: NodeProperty<[Vector1D]>
-  let dashPhase: NodeProperty<Vector1D>
-  
-  let lineCap: LineCap
-  let lineJoin: LineJoin
-  let miterLimit: CGFloat
-  
-}
-
-// MARK: - Node
-
-/// Node that manages stroking a path
-final class StrokeNode: AnimatorNode, RenderNode {
-  
-  let strokeRender: StrokeRenderer
-  var renderer: NodeOutput & Renderable {
-    return strokeRender
-  }
-  
-  let strokeProperties: StrokeNodeProperties
-  
-  init(parentNode: AnimatorNode?, stroke: Stroke) {
-    self.strokeRender = StrokeRenderer(parent: parentNode?.outputNode)
-    self.strokeProperties = StrokeNodeProperties(stroke: stroke)
-    self.parentNode = parentNode
-  }
-  
-  // MARK: Animator Node Protocol
-  
-  var propertyMap: NodePropertyMap & KeypathSearchable {
-    return strokeProperties
-  }
-  
-  let parentNode: AnimatorNode?
-  var hasLocalUpdates: Bool = false
-  var hasUpstreamUpdates: Bool = false
-  var lastUpdateFrame: CGFloat? = nil
-  var isEnabled: Bool = true {
-    didSet {
-      strokeRender.isEnabled = isEnabled
-    }
-  }
-  
-  func localUpdatesPermeateDownstream() -> Bool {
-    return false
-  }
-  
-  func rebuildOutputs(frame: CGFloat) {
-    strokeRender.color = strokeProperties.color.value.cgColorValue
-    strokeRender.opacity = strokeProperties.opacity.value.cgFloatValue * 0.01
-    strokeRender.width = strokeProperties.width.value.cgFloatValue
-    strokeRender.miterLimit = strokeProperties.miterLimit
-    strokeRender.lineCap = strokeProperties.lineCap
-    strokeRender.lineJoin = strokeProperties.lineJoin
-    
-    /// Get dash lengths
-    let dashLengths = strokeProperties.dashPattern.value.map { $0.cgFloatValue }
-    if dashLengths.count > 0 {
-      strokeRender.dashPhase = strokeProperties.dashPhase.value.cgFloatValue
-      strokeRender.dashLengths = dashLengths
-    } else {
-      strokeRender.dashLengths = nil
-      strokeRender.dashPhase = nil
-    }
-  }
-  
-}