@octane-xplat/lottie 0.0.1 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/MainThread/LayerContainers/Utility/LayerTransformNode.swift

@@ -0,0 +1,149 @@
+//
+//  LayerTransformPropertyMap.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+import QuartzCore
+
+// MARK: - LayerTransformProperties
+
+final class LayerTransformProperties: NodePropertyMap, KeypathSearchable {
+
+  // MARK: Lifecycle
+
+  init(transform: Transform) {
+    anchor = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.anchorPoint.keyframes))
+    scale = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.scale.keyframes))
+    rotationX = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.rotationX.keyframes))
+    rotationY = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.rotationY.keyframes))
+    rotationZ = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.rotationZ.keyframes))
+    opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.opacity.keyframes))
+
+    var propertyMap: [String: AnyNodeProperty] = [
+      "Anchor Point": anchor,
+      PropertyName.scale.rawValue: scale,
+      PropertyName.rotation.rawValue: rotationZ,
+      "Rotation X": rotationX,
+      "Rotation Y": rotationY,
+      "Rotation Z": rotationZ,
+      PropertyName.opacity.rawValue: opacity,
+    ]
+
+    if
+      let positionKeyframesX = transform.positionX?.keyframes,
+      let positionKeyframesY = transform.positionY?.keyframes
+    {
+      let xPosition: NodeProperty<LottieVector1D> = NodeProperty(provider: KeyframeInterpolator(keyframes: positionKeyframesX))
+      let yPosition: NodeProperty<LottieVector1D> = NodeProperty(provider: KeyframeInterpolator(keyframes: positionKeyframesY))
+      propertyMap["X Position"] = xPosition
+      propertyMap["Y Position"] = yPosition
+      positionX = xPosition
+      positionY = yPosition
+      position = nil
+    } else if let positionKeyframes = transform.position?.keyframes {
+      let position: NodeProperty<LottieVector3D> = NodeProperty(provider: KeyframeInterpolator(keyframes: positionKeyframes))
+      propertyMap[PropertyName.position.rawValue] = position
+      self.position = position
+      positionX = nil
+      positionY = nil
+    } else {
+      position = nil
+      positionY = nil
+      positionX = nil
+    }
+
+    keypathProperties = propertyMap
+    properties = Array(propertyMap.values)
+  }
+
+  // MARK: Internal
+
+  let keypathProperties: [String: AnyNodeProperty]
+  var keypathName = "Transform"
+
+  let properties: [AnyNodeProperty]
+
+  let anchor: NodeProperty<LottieVector3D>
+  let scale: NodeProperty<LottieVector3D>
+  let rotationX: NodeProperty<LottieVector1D>
+  let rotationY: NodeProperty<LottieVector1D>
+  let rotationZ: NodeProperty<LottieVector1D>
+  let position: NodeProperty<LottieVector3D>?
+  let positionX: NodeProperty<LottieVector1D>?
+  let positionY: NodeProperty<LottieVector1D>?
+  let opacity: NodeProperty<LottieVector1D>
+
+  var childKeypaths: [KeypathSearchable] {
+    []
+  }
+}
+
+// MARK: - LayerTransformNode
+
+final class LayerTransformNode: AnimatorNode {
+
+  // MARK: Lifecycle
+
+  init(transform: Transform) {
+    transformProperties = LayerTransformProperties(transform: transform)
+  }
+
+  // MARK: Internal
+
+  let outputNode: NodeOutput = PassThroughOutputNode(parent: nil)
+
+  let transformProperties: LayerTransformProperties
+
+  var parentNode: AnimatorNode?
+  var hasLocalUpdates = false
+  var hasUpstreamUpdates = false
+  var lastUpdateFrame: CGFloat? = nil
+  var isEnabled = true
+
+  var opacity: Float = 1
+  var localTransform: CATransform3D = CATransform3DIdentity
+  var globalTransform: CATransform3D = CATransform3DIdentity
+
+  var propertyMap: NodePropertyMap & KeypathSearchable {
+    transformProperties
+  }
+
+  func shouldRebuildOutputs(frame _: CGFloat) -> Bool {
+    hasLocalUpdates || hasUpstreamUpdates
+  }
+
+  func rebuildOutputs(frame _: CGFloat) {
+    opacity = Float(transformProperties.opacity.value.cgFloatValue) * 0.01
+
+    let position: CGPoint =
+      if let point = transformProperties.position?.value.pointValue {
+        point
+      } else if
+        let xPos = transformProperties.positionX?.value.cgFloatValue,
+        let yPos = transformProperties.positionY?.value.cgFloatValue
+      {
+        CGPoint(x: xPos, y: yPos)
+      } else {
+        .zero
+      }
+
+    localTransform = CATransform3D.makeTransform(
+      anchor: transformProperties.anchor.value.pointValue,
+      position: position,
+      scale: transformProperties.scale.value.sizeValue,
+      rotationX: transformProperties.rotationX.value.cgFloatValue,
+      rotationY: transformProperties.rotationY.value.cgFloatValue,
+      rotationZ: transformProperties.rotationZ.value.cgFloatValue,
+      skew: nil,
+      skewAxis: nil
+    )
+
+    if let parentNode = parentNode as? LayerTransformNode {
+      globalTransform = CATransform3DConcat(localTransform, parentNode.globalTransform)
+    } else {
+      globalTransform = localTransform
+    }
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Extensions/ItemsExtension.swift

@@ -0,0 +1,146 @@
+//
+//  ItemsExtension.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/18/19.
+//
+
+// MARK: - NodeTree
+
+final class NodeTree {
+  var rootNode: AnimatorNode? = nil
+  var transform: ShapeTransform? = nil
+  var renderContainers = [ShapeContainerLayer]()
+  var paths = [PathOutputNode]()
+  var childrenNodes = [AnimatorNode]()
+}
+
+extension [ShapeItem] {
+  func initializeNodeTree() -> NodeTree {
+    let nodeTree = NodeTree()
+
+    for item in self {
+      guard item.hidden == false, item.type != .unknown else { continue }
+      if let fill = item as? Fill {
+        let node = FillNode(parentNode: nodeTree.rootNode, fill: fill)
+        nodeTree.rootNode = node
+        nodeTree.childrenNodes.append(node)
+      } else if let stroke = item as? Stroke {
+        let node = StrokeNode(parentNode: nodeTree.rootNode, stroke: stroke)
+        nodeTree.rootNode = node
+        nodeTree.childrenNodes.append(node)
+      } else if let gradientFill = item as? GradientFill {
+        let node = GradientFillNode(parentNode: nodeTree.rootNode, gradientFill: gradientFill)
+        nodeTree.rootNode = node
+        nodeTree.childrenNodes.append(node)
+      } else if let gradientStroke = item as? GradientStroke {
+        let node = GradientStrokeNode(parentNode: nodeTree.rootNode, gradientStroke: gradientStroke)
+        nodeTree.rootNode = node
+        nodeTree.childrenNodes.append(node)
+      } else if let ellipse = item as? Ellipse {
+        let node = EllipseNode(parentNode: nodeTree.rootNode, ellipse: ellipse)
+        nodeTree.rootNode = node
+        nodeTree.childrenNodes.append(node)
+      } else if let rect = item as? Rectangle {
+        let node = RectangleNode(parentNode: nodeTree.rootNode, rectangle: rect)
+        nodeTree.rootNode = node
+        nodeTree.childrenNodes.append(node)
+      } else if let star = item as? Star {
+        switch star.starType {
+        case .none:
+          continue
+
+        case .polygon:
+          let node = PolygonNode(parentNode: nodeTree.rootNode, star: star)
+          nodeTree.rootNode = node
+          nodeTree.childrenNodes.append(node)
+
+        case .star:
+          let node = StarNode(parentNode: nodeTree.rootNode, star: star)
+          nodeTree.rootNode = node
+          nodeTree.childrenNodes.append(node)
+        }
+      } else if let shape = item as? Shape {
+        let node = ShapeNode(parentNode: nodeTree.rootNode, shape: shape)
+        nodeTree.rootNode = node
+        nodeTree.childrenNodes.append(node)
+      } else if let trim = item as? Trim {
+        let node = TrimPathNode(parentNode: nodeTree.rootNode, trim: trim, upstreamPaths: nodeTree.paths)
+        nodeTree.rootNode = node
+        nodeTree.childrenNodes.append(node)
+      } else if let roundedCorners = item as? RoundedCorners {
+        let node = RoundedCornersNode(
+          parentNode: nodeTree.rootNode,
+          roundedCorners: roundedCorners,
+          upstreamPaths: nodeTree.paths
+        )
+        nodeTree.rootNode = node
+        nodeTree.childrenNodes.append(node)
+      } else if let xform = item as? ShapeTransform {
+        nodeTree.transform = xform
+        continue
+      } else if let group = item as? Group {
+        let tree = group.items.initializeNodeTree()
+        let node = GroupNode(name: group.name, parentNode: nodeTree.rootNode, tree: tree)
+        nodeTree.rootNode = node
+        nodeTree.childrenNodes.append(node)
+        /// Now add all child paths to current tree
+        nodeTree.paths.append(contentsOf: tree.paths)
+        nodeTree.renderContainers.append(node.container)
+      } else if item is Repeater {
+        LottieLogger.shared.warn("""
+          The Main Thread rendering engine doesn't currently support repeaters.
+          To play an animation with repeaters, you can use the Core Animation rendering engine instead.
+          """)
+      }
+
+      if let pathNode = nodeTree.rootNode?.getPathNode() {
+        //// Add path container to the node tree
+        nodeTree.paths.append(pathNode.pathOutput)
+      }
+
+      if let renderNode = nodeTree.rootNode?.getRenderNode() {
+        nodeTree.renderContainers.append(ShapeRenderLayer(renderer: renderNode.renderer))
+      }
+    }
+    return nodeTree
+  }
+}
+
+extension AnimatorNode {
+  /// Helper function to avoid casting to `PathNode`
+  /// More performant replacement for `nodeTree.rootNode as? PathNode`
+  fileprivate func getPathNode() -> PathNode? {
+    switch self {
+    case let node as EllipseNode:
+      node
+    case let node as PolygonNode:
+      node
+    case let node as ShapeNode:
+      node
+    case let node as StarNode:
+      node
+    case let node as RectangleNode:
+      node
+    default:
+      nil
+    }
+  }
+
+  /// Helper function to avoid casting to `RenderNode`
+  /// More performant replacement for `nodeTree.rootNode as? RenderNode`
+  fileprivate func getRenderNode() -> RenderNode? {
+    switch self {
+    case let node as GradientFillNode:
+      node
+    case let node as StrokeNode:
+      node
+    case let node as FillNode:
+      node
+    case let node as GradientStrokeNode:
+      node
+    default:
+      nil
+    }
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/NodeProperties/NodeProperty.swift

@@ -0,0 +1,62 @@
+//
+//  NodeProperty.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import CoreGraphics
+import Foundation
+
+/// A node property that holds a reference to a T ValueProvider and a T ValueContainer.
+final class NodeProperty<T>: AnyNodeProperty {
+
+  // MARK: Lifecycle
+
+  init(provider: AnyValueProvider) {
+    valueProvider = provider
+    originalValueProvider = valueProvider
+    typedContainer = ValueContainer<T>(provider.value(frame: 0) as! T)
+    typedContainer.setNeedsUpdate()
+  }
+
+  // MARK: Internal
+
+  var valueProvider: AnyValueProvider
+  var originalValueProvider: AnyValueProvider
+
+  var valueType: Any.Type {
+    T.self
+  }
+
+  var value: T {
+    typedContainer.outputValue
+  }
+
+  var valueContainer: AnyValueContainer {
+    typedContainer
+  }
+
+  func needsUpdate(frame: CGFloat) -> Bool {
+    valueContainer.needsUpdate || valueProvider.hasUpdate(frame: frame)
+  }
+
+  func setProvider(provider: AnyValueProvider) {
+    guard provider.valueType == valueType else { return }
+    valueProvider = provider
+    valueContainer.setNeedsUpdate()
+  }
+
+  func removeProvider() {
+    valueProvider = originalValueProvider
+    valueContainer.setNeedsUpdate()
+  }
+
+  func update(frame: CGFloat) {
+    typedContainer.setValue(valueProvider.value(frame: frame), forFrame: frame)
+  }
+
+  // MARK: Fileprivate
+
+  fileprivate var typedContainer: ValueContainer<T>
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/NodeProperties/Protocols/AnyNodeProperty.swift

@@ -0,0 +1,53 @@
+//
+//  AnyNodeProperty.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import CoreGraphics
+import Foundation
+
+// MARK: - AnyNodeProperty
+
+/// A property of a node. The node property holds a provider and a container
+protocol AnyNodeProperty {
+
+  /// The stored value container for the property
+  var valueContainer: AnyValueContainer { get }
+
+  /// The value provider for the property
+  var valueProvider: AnyValueProvider { get }
+
+  /// The original value provider for the property
+  var originalValueProvider: AnyValueProvider { get }
+
+  /// The Type of the value provider
+  var valueType: Any.Type { get }
+
+  /// Returns true if the property needs to recompute its stored value
+  func needsUpdate(frame: CGFloat) -> Bool
+
+  /// Updates the property for the frame
+  func update(frame: CGFloat)
+
+  /// Sets the value provider for the property.
+  func setProvider(provider: AnyValueProvider)
+
+  /// Removes the value provider for the property.
+  func removeProvider()
+}
+
+extension AnyNodeProperty {
+
+  /// Returns the most recently computed value for the keypath, returns nil if property wasn't found
+  func getValueOfType<T>() -> T? {
+    valueContainer.value as? T
+  }
+
+  /// Returns the most recently computed value for the keypath, returns nil if property wasn't found
+  func getValue() -> Any? {
+    valueContainer.value
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/NodeProperties/Protocols/AnyValueContainer.swift

@@ -0,0 +1,26 @@
+//
+//  AnyValueContainer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import CoreGraphics
+import Foundation
+
+/// The container for the value of a property.
+protocol AnyValueContainer: AnyObject {
+
+  /// The stored value of the container
+  var value: Any { get }
+
+  /// When true the container needs to have its value updated by its provider
+  var needsUpdate: Bool { get }
+
+  /// The frame time of the last provided update
+  var lastUpdateFrame: CGFloat { get }
+
+  /// Notifies the provider that it should update its container
+  func setNeedsUpdate()
+
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/NodeProperties/Protocols/KeypathSearchable.swift

@@ -0,0 +1,23 @@
+//
+//  KeypathSettable.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 2/4/19.
+//
+
+import QuartzCore
+
+/// Protocol that provides keypath search functionality. Returns all node properties associated with a keypath.
+protocol KeypathSearchable {
+
+  /// The name of the Keypath
+  var keypathName: String { get }
+
+  /// A list of properties belonging to the keypath.
+  var keypathProperties: [String: AnyNodeProperty] { get }
+
+  /// Children Keypaths
+  var childKeypaths: [KeypathSearchable] { get }
+
+  var keypathLayer: CALayer? { get }
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/NodeProperties/Protocols/NodePropertyMap.swift

@@ -0,0 +1,43 @@
+//
+//  NodePropertyMap.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/21/19.
+//
+
+import QuartzCore
+
+// MARK: - NodePropertyMap
+
+protocol NodePropertyMap {
+  var properties: [AnyNodeProperty] { get }
+}
+
+extension NodePropertyMap {
+
+  var childKeypaths: [KeypathSearchable] {
+    []
+  }
+
+  var keypathLayer: CALayer? {
+    nil
+  }
+
+  /// Checks if the node's local contents need to be rebuilt.
+  func needsLocalUpdate(frame: CGFloat) -> Bool {
+    for property in properties {
+      if property.needsUpdate(frame: frame) {
+        return true
+      }
+    }
+    return false
+  }
+
+  /// Rebuilds only the local nodes that have an update for the frame
+  func updateNodeProperties(frame: CGFloat) {
+    for property in properties {
+      property.update(frame: frame)
+    }
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/NodeProperties/ValueContainer.swift

@@ -0,0 +1,47 @@
+//
+//  ValueContainer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import CoreGraphics
+import Foundation
+
+/// A container for a node value that is Typed to T.
+final class ValueContainer<T>: AnyValueContainer {
+
+  // MARK: Lifecycle
+
+  init(_ value: T) {
+    outputValue = value
+  }
+
+  // MARK: Internal
+
+  private(set) var lastUpdateFrame = CGFloat.infinity
+
+  fileprivate(set) var needsUpdate = true
+
+  var value: Any {
+    outputValue as Any
+  }
+
+  var outputValue: T {
+    didSet {
+      needsUpdate = false
+    }
+  }
+
+  func setValue(_ value: Any, forFrame: CGFloat) {
+    if let typedValue = value as? T {
+      needsUpdate = false
+      lastUpdateFrame = forFrame
+      outputValue = typedValue
+    }
+  }
+
+  func setNeedsUpdate() {
+    needsUpdate = true
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/NodeProperties/ValueProviders/GroupInterpolator.swift

@@ -0,0 +1,39 @@
+//
+//  KeyframeGroupInterpolator.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/22/19.
+//
+
+import CoreGraphics
+import Foundation
+
+/// A value provider that produces an array of values from an array of Keyframe Interpolators
+final class GroupInterpolator<ValueType: Interpolatable>: ValueProvider {
+
+  // MARK: Lifecycle
+
+  /// Initialize with an array of array of keyframes.
+  init(keyframeGroups: ContiguousArray<ContiguousArray<Keyframe<ValueType>>>) {
+    keyframeInterpolators = ContiguousArray(keyframeGroups.map { KeyframeInterpolator(keyframes: $0) })
+  }
+
+  // MARK: Internal
+
+  let keyframeInterpolators: ContiguousArray<KeyframeInterpolator<ValueType>>
+
+  var valueType: Any.Type {
+    [ValueType].self
+  }
+
+  var storage: ValueProviderStorage<[ValueType]> {
+    .closure { frame in
+      self.keyframeInterpolators.map { $0.value(frame: frame) as! ValueType }
+    }
+  }
+
+  func hasUpdate(frame: CGFloat) -> Bool {
+    let updated = keyframeInterpolators.first(where: { $0.hasUpdate(frame: frame) })
+    return updated != nil
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/NodeProperties/ValueProviders/SingleValueProvider.swift

@@ -0,0 +1,43 @@
+//
+//  SingleValueProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import Foundation
+import QuartzCore
+
+/// Returns a value for every frame.
+final class SingleValueProvider<ValueType: AnyInterpolatable>: ValueProvider {
+
+  // MARK: Lifecycle
+
+  init(_ value: ValueType) {
+    self.value = value
+  }
+
+  // MARK: Internal
+
+  var value: ValueType {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var storage: ValueProviderStorage<ValueType> {
+    .singleValue(value)
+  }
+
+  var valueType: Any.Type {
+    ValueType.self
+  }
+
+  func hasUpdate(frame _: CGFloat) -> Bool {
+    hasUpdate
+  }
+
+  // MARK: Private
+
+  private var hasUpdate = true
+}