@octane-xplat/lottie 0.9.0 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/MainThread/LayerContainers/CompLayers/ImageCompositionLayer.swift

@@ -0,0 +1,54 @@
+//
+//  ImageCompositionLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/25/19.
+//
+
+import QuartzCore
+
+final class ImageCompositionLayer: CompositionLayer {
+
+  // MARK: Lifecycle
+
+  init(imageLayer: ImageLayerModel, size: CGSize) {
+    imageReferenceID = imageLayer.referenceID
+    super.init(layer: imageLayer, size: size)
+    contentsLayer.masksToBounds = true
+    contentsLayer.contentsGravity = CALayerContentsGravity.resize
+  }
+
+  override init(layer: Any) {
+    /// Used for creating shadow model layers. Read More here: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
+    guard let layer = layer as? ImageCompositionLayer else {
+      fatalError("init(layer:) Wrong Layer Class")
+    }
+    imageReferenceID = layer.imageReferenceID
+    image = nil
+    super.init(layer: layer)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  // MARK: Internal
+
+  let imageReferenceID: String
+
+  var image: CGImage? = nil {
+    didSet {
+      if let image {
+        contentsLayer.contents = image
+      } else {
+        contentsLayer.contents = nil
+      }
+    }
+  }
+
+  var imageContentsGravity = CALayerContentsGravity.resize {
+    didSet {
+      contentsLayer.contentsGravity = imageContentsGravity
+    }
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/LayerContainers/CompLayers/MaskContainerLayer.swift

@@ -0,0 +1,191 @@
+//
+//  MaskContainerLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/25/19.
+//
+
+import QuartzCore
+
+extension MaskMode {
+  var usableMode: MaskMode {
+    switch self {
+    case .add:
+      .add
+    case .subtract:
+      .subtract
+    case .intersect:
+      .intersect
+    case .lighten:
+      .add
+    case .darken:
+      .darken
+    case .difference:
+      .intersect
+    case .none:
+      .none
+    }
+  }
+}
+
+// MARK: - MaskContainerLayer
+
+final class MaskContainerLayer: CALayer {
+
+  // MARK: Lifecycle
+
+  init(masks: [Mask]) {
+    super.init()
+    anchorPoint = .zero
+    var containerLayer = CALayer()
+    var firstObject = true
+    for mask in masks {
+      let maskLayer = MaskLayer(mask: mask)
+      maskLayers.append(maskLayer)
+      if mask.mode.usableMode == .none {
+        continue
+      } else if mask.mode.usableMode == .add || firstObject {
+        firstObject = false
+        containerLayer.addSublayer(maskLayer)
+      } else {
+        containerLayer.mask = maskLayer
+        let newContainer = CALayer()
+        newContainer.addSublayer(containerLayer)
+        containerLayer = newContainer
+      }
+    }
+    addSublayer(containerLayer)
+  }
+
+  override init(layer: Any) {
+    /// Used for creating shadow model layers. Read More here: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
+    guard let layer = layer as? MaskContainerLayer else {
+      fatalError("init(layer:) Wrong Layer Class")
+    }
+    super.init(layer: layer)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  // MARK: Internal
+
+  func updateWithFrame(frame: CGFloat, forceUpdates: Bool) {
+    for maskLayer in maskLayers {
+      maskLayer.updateWithFrame(frame: frame, forceUpdates: forceUpdates)
+    }
+  }
+
+  // MARK: Fileprivate
+
+  fileprivate var maskLayers = [MaskLayer]()
+}
+
+extension CGRect {
+  static var veryLargeRect: CGRect {
+    CGRect(
+      x: -10_000_000,
+      y: -10_000_000,
+      width: 20_000_000,
+      height: 20_000_000
+    )
+  }
+}
+
+// MARK: - MaskLayer
+
+private final class MaskLayer: CALayer {
+
+  // MARK: Lifecycle
+
+  init(mask: Mask) {
+    properties = MaskNodeProperties(mask: mask)
+    super.init()
+    addSublayer(maskLayer)
+    anchorPoint = .zero
+    maskLayer.fillColor = mask.mode == .add
+      ? .rgb(1, 0, 0)
+      : .rgb(0, 1, 0)
+    maskLayer.fillRule = CAShapeLayerFillRule.evenOdd
+    actions = [
+      "opacity": NSNull()
+    ]
+  }
+
+  override init(layer: Any) {
+    properties = nil
+    super.init(layer: layer)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  // MARK: Internal
+
+  let properties: MaskNodeProperties?
+
+  let maskLayer = CAShapeLayer()
+
+  func updateWithFrame(frame: CGFloat, forceUpdates: Bool) {
+    guard let properties else { return }
+    if properties.opacity.needsUpdate(frame: frame) || forceUpdates {
+      properties.opacity.update(frame: frame)
+      opacity = Float(properties.opacity.value.cgFloatValue)
+    }
+
+    if properties.shape.needsUpdate(frame: frame) || forceUpdates {
+      properties.shape.update(frame: frame)
+      properties.expansion.update(frame: frame)
+
+      let shapePath = properties.shape.value.cgPath()
+      var path = shapePath
+      if
+        properties.mode.usableMode == .subtract && !properties.inverted ||
+        (properties.mode.usableMode == .add && properties.inverted)
+      {
+        /// Add a bounds rect to invert the mask
+        let newPath = CGMutablePath()
+        newPath.addRect(CGRect.veryLargeRect)
+        newPath.addPath(shapePath)
+        path = newPath
+      }
+      maskLayer.path = path
+    }
+  }
+}
+
+// MARK: - MaskNodeProperties
+
+private final class MaskNodeProperties: NodePropertyMap {
+
+  // MARK: Lifecycle
+
+  init(mask: Mask) {
+    mode = mask.mode
+    inverted = mask.inverted
+    opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.opacity.keyframes))
+    shape = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.shape.keyframes))
+    expansion = NodeProperty(provider: KeyframeInterpolator(keyframes: mask.expansion.keyframes))
+    propertyMap = [
+      PropertyName.opacity.rawValue: opacity,
+      "Shape": shape,
+      "Expansion": expansion,
+    ]
+    properties = Array(propertyMap.values)
+  }
+
+  // MARK: Internal
+
+  var propertyMap: [String: AnyNodeProperty]
+
+  var properties: [AnyNodeProperty]
+
+  let mode: MaskMode
+  let inverted: Bool
+
+  let opacity: NodeProperty<LottieVector1D>
+  let shape: NodeProperty<BezierPath>
+  let expansion: NodeProperty<LottieVector1D>
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/LayerContainers/CompLayers/NullCompositionLayer.swift

@@ -0,0 +1,28 @@
+//
+//  NullCompositionLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/25/19.
+//
+
+import Foundation
+
+final class NullCompositionLayer: CompositionLayer {
+
+  init(layer: LayerModel) {
+    super.init(layer: layer, size: .zero)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  override init(layer: Any) {
+    /// Used for creating shadow model layers. Read More here: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
+    guard let layer = layer as? NullCompositionLayer else {
+      fatalError("init(layer:) Wrong Layer Class")
+    }
+    super.init(layer: layer)
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/LayerContainers/CompLayers/PreCompositionLayer.swift

@@ -0,0 +1,137 @@
+//
+//  PreCompositionLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/25/19.
+//
+
+import QuartzCore
+
+final class PreCompositionLayer: CompositionLayer {
+
+  // MARK: Lifecycle
+
+  init(
+    precomp: PreCompLayerModel,
+    asset: PrecompAsset,
+    layerImageProvider: LayerImageProvider,
+    layerTextProvider: LayerTextProvider,
+    layerFontProvider: LayerFontProvider,
+    textProvider: AnimationKeypathTextProvider,
+    fontProvider: AnimationFontProvider,
+    assetLibrary: AssetLibrary?,
+    frameRate: CGFloat,
+    rootAnimationLayer: MainThreadAnimationLayer?
+  ) {
+    animationLayers = []
+    if let keyframes = precomp.timeRemapping?.keyframes {
+      remappingNode = NodeProperty(provider: KeyframeInterpolator(keyframes: keyframes))
+    } else {
+      remappingNode = nil
+    }
+    self.frameRate = frameRate
+    super.init(layer: precomp, size: CGSize(width: precomp.width, height: precomp.height))
+    bounds = CGRect(origin: .zero, size: CGSize(width: precomp.width, height: precomp.height))
+    contentsLayer.masksToBounds = true
+    contentsLayer.bounds = bounds
+
+    let layers = asset.layers.initializeCompositionLayers(
+      assetLibrary: assetLibrary,
+      layerImageProvider: layerImageProvider,
+      layerTextProvider: layerTextProvider,
+      layerFontProvider: layerFontProvider,
+      textProvider: textProvider,
+      fontProvider: fontProvider,
+      frameRate: frameRate,
+      rootAnimationLayer: rootAnimationLayer
+    )
+
+    var imageLayers = [ImageCompositionLayer]()
+    var textLayers = [TextCompositionLayer]()
+
+    var mattedLayer: CompositionLayer? = nil
+
+    for layer in layers.reversed() {
+      layer.bounds = bounds
+      animationLayers.append(layer)
+      if let imageLayer = layer as? ImageCompositionLayer {
+        imageLayers.append(imageLayer)
+      }
+      if let textLayer = layer as? TextCompositionLayer {
+        textLayers.append(textLayer)
+      }
+      if let matte = mattedLayer {
+        /// The previous layer requires this layer to be its matte
+        matte.matteLayer = layer
+        mattedLayer = nil
+        continue
+      }
+      if
+        let matte = layer.matteType,
+        matte == .add || matte == .invert
+      {
+        /// We have a layer that requires a matte.
+        mattedLayer = layer
+      }
+      contentsLayer.addSublayer(layer)
+    }
+
+    childKeypaths.append(contentsOf: layers)
+
+    layerImageProvider.addImageLayers(imageLayers)
+    layerTextProvider.addTextLayers(textLayers)
+    layerFontProvider.addTextLayers(textLayers)
+  }
+
+  override init(layer: Any) {
+    /// Used for creating shadow model layers. Read More here: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
+    guard let layer = layer as? PreCompositionLayer else {
+      fatalError("init(layer:) Wrong Layer Class")
+    }
+    frameRate = layer.frameRate
+    remappingNode = nil
+    animationLayers = []
+
+    super.init(layer: layer)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  // MARK: Internal
+
+  let frameRate: CGFloat
+  let remappingNode: NodeProperty<LottieVector1D>?
+
+  override var keypathProperties: [String: AnyNodeProperty] {
+    guard let remappingNode else {
+      return super.keypathProperties
+    }
+    return ["Time Remap": remappingNode]
+  }
+
+  override func displayContentsWithFrame(frame: CGFloat, forceUpdates: Bool) {
+    let localFrame: CGFloat
+    if let remappingNode {
+      remappingNode.update(frame: frame)
+      localFrame = remappingNode.value.cgFloatValue * frameRate
+    } else {
+      localFrame = (frame - startFrame) / timeStretch
+    }
+    for animationLayer in animationLayers {
+      animationLayer.displayWithFrame(frame: localFrame, forceUpdates: forceUpdates)
+    }
+  }
+
+  override func updateRenderScale() {
+    super.updateRenderScale()
+    for animationLayer in animationLayers {
+      animationLayer.renderScale = renderScale
+    }
+  }
+
+  // MARK: Fileprivate
+
+  fileprivate var animationLayers: [CompositionLayer]
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/LayerContainers/CompLayers/ShapeCompositionLayer.swift

@@ -0,0 +1,60 @@
+//
+//  ShapeLayerContainer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/22/19.
+//
+
+import CoreGraphics
+import Foundation
+
+/// A CompositionLayer responsible for initializing and rendering shapes
+final class ShapeCompositionLayer: CompositionLayer {
+
+  // MARK: Lifecycle
+
+  init(shapeLayer: ShapeLayerModel) {
+    let results = shapeLayer.items.initializeNodeTree()
+    let renderContainer = ShapeContainerLayer()
+    self.renderContainer = renderContainer
+    rootNode = results.rootNode
+    super.init(layer: shapeLayer, size: .zero)
+    contentsLayer.addSublayer(renderContainer)
+    for container in results.renderContainers {
+      renderContainer.insertRenderLayer(container)
+    }
+    rootNode?.updateTree(0, forceUpdates: true)
+    // Use direct downcasting from `AnimatorNode` to `KeypathSearchable`
+    // to avoid calling `_arrayForceCast` for performance reasons
+    childKeypaths.append(contentsOf: results.childrenNodes.map { $0 as KeypathSearchable })
+  }
+
+  override init(layer: Any) {
+    guard let layer = layer as? ShapeCompositionLayer else {
+      fatalError("init(layer:) wrong class.")
+    }
+    rootNode = nil
+    renderContainer = nil
+    super.init(layer: layer)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  // MARK: Internal
+
+  let rootNode: AnimatorNode?
+  let renderContainer: ShapeContainerLayer?
+
+  override func displayContentsWithFrame(frame: CGFloat, forceUpdates: Bool) {
+    rootNode?.updateTree(frame, forceUpdates: forceUpdates)
+    renderContainer?.markRenderUpdates(forFrame: frame)
+  }
+
+  override func updateRenderScale() {
+    super.updateRenderScale()
+    renderContainer?.renderScale = renderScale
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/LayerContainers/CompLayers/SolidCompositionLayer.swift

@@ -0,0 +1,57 @@
+//
+//  SolidCompositionLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/25/19.
+//
+
+import QuartzCore
+
+final class SolidCompositionLayer: CompositionLayer {
+
+  // MARK: Lifecycle
+
+  init(solid: SolidLayerModel) {
+    let components = solid.colorHex.hexColorComponents()
+    colorProperty =
+      NodeProperty(provider: SingleValueProvider(LottieColor(
+        r: Double(components.red),
+        g: Double(components.green),
+        b: Double(components.blue),
+        a: 1
+      )))
+
+    super.init(layer: solid, size: .zero)
+    solidShape.path = CGPath(rect: CGRect(x: 0, y: 0, width: solid.width, height: solid.height), transform: nil)
+    contentsLayer.addSublayer(solidShape)
+  }
+
+  override init(layer: Any) {
+    /// Used for creating shadow model layers. Read More here: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
+    guard let layer = layer as? SolidCompositionLayer else {
+      fatalError("init(layer:) Wrong Layer Class")
+    }
+    colorProperty = layer.colorProperty
+    super.init(layer: layer)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  // MARK: Internal
+
+  let colorProperty: NodeProperty<LottieColor>?
+  let solidShape = CAShapeLayer()
+
+  override var keypathProperties: [String: AnyNodeProperty] {
+    guard let colorProperty else { return super.keypathProperties }
+    return [PropertyName.color.rawValue: colorProperty]
+  }
+
+  override func displayContentsWithFrame(frame: CGFloat, forceUpdates _: Bool) {
+    guard let colorProperty else { return }
+    colorProperty.update(frame: frame)
+    solidShape.fillColor = colorProperty.value.cgColorValue
+  }
+}