@octane-xplat/lottie 0.0.1 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/CoreAnimation/Layers/BaseCompositionLayer.swift

@@ -0,0 +1,120 @@
+// Created by Cal Stephens on 12/20/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - BaseCompositionLayer
+
+/// The base type of `AnimationLayer` that can contain other `AnimationLayer`s
+class BaseCompositionLayer: BaseAnimationLayer {
+
+  // MARK: Lifecycle
+
+  init(layerModel: LayerModel) {
+    baseLayerModel = layerModel
+    super.init()
+
+    setupSublayers()
+    compositingFilter = layerModel.blendMode.filterName
+    name = layerModel.name
+    contentsLayer.name = "\(layerModel.name) (Content)"
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  /// Called by CoreAnimation to create a shadow copy of this layer
+  /// More details: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
+  override init(layer: Any) {
+    guard let typedLayer = layer as? Self else {
+      fatalError("\(Self.self).init(layer:) incorrectly called with \(type(of: layer))")
+    }
+
+    baseLayerModel = typedLayer.baseLayerModel
+    super.init(layer: typedLayer)
+  }
+
+  // MARK: Internal
+
+  /// The layer that content / sublayers should be rendered in.
+  /// This is the layer that transform animations are applied to.
+  let contentsLayer = BaseAnimationLayer()
+
+  /// Whether or not this layer render should render any visible content
+  var renderLayerContents: Bool {
+    true
+  }
+
+  /// Sets up the base `LayerModel` animations for this layer,
+  /// and all child `AnimationLayer`s.
+  ///  - Can be overridden by subclasses, which much call `super`.
+  override func setupAnimations(context: LayerAnimationContext) throws {
+    let layerContext = context.addingKeypathComponent(baseLayerModel.name)
+    let childContext = renderLayerContents ? layerContext : context
+
+    try setupLayerAnimations(context: layerContext)
+    try setupChildAnimations(context: childContext)
+  }
+
+  func setupLayerAnimations(context: LayerAnimationContext) throws {
+    let transformContext = context.addingKeypathComponent("Transform")
+
+    try contentsLayer.addTransformAnimations(for: baseLayerModel.transform, context: transformContext)
+
+    if renderLayerContents {
+      try contentsLayer.addOpacityAnimation(for: baseLayerModel.transform, context: transformContext)
+
+      try contentsLayer.addVisibilityAnimation(
+        inFrame: CGFloat(baseLayerModel.inFrame),
+        outFrame: CGFloat(baseLayerModel.outFrame),
+        context: context
+      )
+
+      // There are two different drop shadow schemas, either using `DropShadowEffect` or `DropShadowStyle`.
+      // If both happen to be present, prefer the `DropShadowEffect` (which is the drop shadow schema
+      // supported on other platforms).
+      let dropShadowEffect = baseLayerModel.effects.first(where: { $0 is DropShadowEffect }) as? DropShadowModel
+      let dropShadowStyle = baseLayerModel.styles.first(where: { $0 is DropShadowStyle }) as? DropShadowModel
+      if let dropShadowModel = dropShadowEffect ?? dropShadowStyle {
+        try contentsLayer.addDropShadowAnimations(for: dropShadowModel, context: context)
+      }
+
+      // Set up mask animations with the layer's own context (parent timeline).
+      // Mask keyframes are defined in the parent's global timeline, not the precomp's
+      // local timeline, so the mask must not receive the time-remapped child context.
+      if let maskLayer = contentsLayer.mask as? AnimationLayer {
+        try maskLayer.setupAnimations(context: context)
+      }
+    }
+  }
+
+  func setupChildAnimations(context: LayerAnimationContext) throws {
+    try super.setupAnimations(context: context)
+  }
+
+  override func addSublayer(_ layer: CALayer) {
+    if layer === contentsLayer {
+      super.addSublayer(contentsLayer)
+    } else {
+      contentsLayer.addSublayer(layer)
+    }
+  }
+
+  // MARK: Private
+
+  private let baseLayerModel: LayerModel
+
+  private func setupSublayers() {
+    addSublayer(contentsLayer)
+
+    if
+      renderLayerContents,
+      let masks = baseLayerModel.masks?.filter({ $0.mode != .none }),
+      !masks.isEmpty
+    {
+      contentsLayer.mask = MaskCompositionLayer(masks: masks)
+    }
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/CoreAnimation/Layers/CALayer+setupLayerHierarchy.swift

@@ -0,0 +1,169 @@
+// Created by Cal Stephens on 1/11/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+extension CALayer {
+
+  // MARK: Internal
+
+  /// Sets up an `AnimationLayer` / `CALayer` hierarchy in this layer,
+  /// using the given list of layers.
+  @nonobjc
+  func setupLayerHierarchy(
+    for layers: [LayerModel],
+    context: LayerContext
+  ) throws {
+    // A `LottieAnimation`'s `LayerModel`s are listed from front to back,
+    // but `CALayer.sublayers` are listed from back to front.
+    // We reverse the layer ordering to match what Core Animation expects.
+    // The final view hierarchy must display the layers in this exact order.
+    let layersInZAxisOrder = layers.reversed()
+
+    let layersByIndex = Dictionary(grouping: layersInZAxisOrder, by: \.index)
+      .compactMapValues(\.first)
+
+    /// Layers specify a `parent` layer. Child layers inherit the `transform` of their parent.
+    ///  - We can't add the child as a sublayer of the parent `CALayer`, since that would
+    ///    break the ordering specified in `layersInZAxisOrder`.
+    ///  - Instead, we create an invisible `TransformLayer` to handle the parent
+    ///    transform animations, and add the child layer to that `TransformLayer`.
+    func makeParentTransformLayer(
+      childLayerModel: LayerModel,
+      childLayer: CALayer,
+      name: (LayerModel) -> String
+    ) -> CALayer {
+      guard
+        let parentIndex = childLayerModel.parent,
+        let parentLayerModel = layersByIndex[parentIndex]
+      else { return childLayer }
+
+      let parentLayer = TransformLayer(layerModel: parentLayerModel)
+      parentLayer.name = name(parentLayerModel)
+      parentLayer.addSublayer(childLayer)
+
+      return makeParentTransformLayer(
+        childLayerModel: parentLayerModel,
+        childLayer: parentLayer,
+        name: name
+      )
+    }
+
+    // Create an `AnimationLayer` for each `LayerModel`
+    for (layerModel, mask) in try layersInZAxisOrder.pairedLayersAndMasks() {
+      guard let layer = try layerModel.makeAnimationLayer(context: context) else {
+        continue
+      }
+
+      // If this layer has a `parent`, we create an invisible `TransformLayer`
+      // to handle displaying / animating the parent transform.
+      let parentTransformLayer = makeParentTransformLayer(
+        childLayerModel: layerModel,
+        childLayer: layer,
+        name: { parentLayerModel in
+          "\(layerModel.name) (parent, \(parentLayerModel.name))"
+        }
+      )
+
+      // Create the `mask` layer for this layer, if it has a `MatteType`
+      if
+        let mask,
+        let maskLayer = try maskLayer(for: mask.model, type: mask.matteType, context: context)
+      {
+        let maskParentTransformLayer = makeParentTransformLayer(
+          childLayerModel: mask.model,
+          childLayer: maskLayer,
+          name: { parentLayerModel in
+            "\(mask.model.name) (mask of \(layerModel.name)) (parent, \(parentLayerModel.name))"
+          }
+        )
+
+        // Set up a parent container to host both the layer
+        // and its mask in the same coordinate space
+        let maskContainer = BaseAnimationLayer()
+        maskContainer.name = "\(layerModel.name) (parent, masked)"
+        maskContainer.addSublayer(parentTransformLayer)
+
+        // Core Animation will silently fail to apply a mask if a `mask` layer
+        // itself _also_ has a `mask`. As a workaround, we can wrap this layer's
+        // mask in an additional container layer which never has its own `mask`.
+        let additionalMaskParent = BaseAnimationLayer()
+        additionalMaskParent.addSublayer(maskParentTransformLayer)
+        maskContainer.mask = additionalMaskParent
+
+        addSublayer(maskContainer)
+      }
+
+      else {
+        addSublayer(parentTransformLayer)
+      }
+    }
+  }
+
+  // MARK: Fileprivate
+
+  /// Creates a mask `CALayer` from the given matte layer model, using the `MatteType`
+  /// from the layer that is being masked.
+  fileprivate func maskLayer(
+    for matteLayerModel: LayerModel,
+    type: MatteType,
+    context: LayerContext
+  ) throws -> CALayer? {
+    switch type {
+    case .add:
+      return try matteLayerModel.makeAnimationLayer(context: context)
+
+    case .invert:
+      guard let maskLayer = try matteLayerModel.makeAnimationLayer(context: context) else {
+        return nil
+      }
+
+      // We can invert the mask layer by having a large solid black layer with the
+      // given mask layer subtracted out using the `xor` blend mode. When applied to the
+      // layer being masked, this creates an inverted mask where only areas _outside_
+      // of the mask layer are visible.
+      // https://developer.apple.com/documentation/coregraphics/cgblendmode/xor
+      //  - The inverted mask is supposed to expand infinitely around the shape,
+      //    so we use `InfiniteOpaqueAnimationLayer`
+      let base = InfiniteOpaqueAnimationLayer()
+      base.backgroundColor = .rgb(0, 0, 0)
+      base.addSublayer(maskLayer)
+      maskLayer.compositingFilter = "xor"
+      return base
+
+    case .none, .unknown:
+      return nil
+    }
+  }
+
+}
+
+extension Collection<LayerModel> {
+  /// Pairs each `LayerModel` within this array with
+  /// a `LayerModel` to use as its mask, if applicable
+  /// based on the layer's `MatteType` configuration.
+  ///  - Assumes the layers are sorted in z-axis order.
+  fileprivate func pairedLayersAndMasks() throws
+    -> [(layer: LayerModel, mask: (model: LayerModel, matteType: MatteType)?)]
+  {
+    var layersAndMasks = [(layer: LayerModel, mask: (model: LayerModel, matteType: MatteType)?)]()
+    var unprocessedLayers = reversed()
+
+    while let layer = unprocessedLayers.popLast() {
+      /// If a layer has a `MatteType`, then the next layer will be used as its `mask`
+      if
+        let matteType = layer.matte,
+        matteType != .none,
+        let maskLayer = unprocessedLayers.popLast()
+      {
+        layersAndMasks.append((layer: layer, mask: (model: maskLayer, matteType: matteType)))
+      }
+
+      else {
+        layersAndMasks.append((layer: layer, mask: nil))
+      }
+    }
+
+    return layersAndMasks
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/CoreAnimation/Layers/GradientRenderLayer.swift

@@ -0,0 +1,101 @@
+// Created by Cal Stephens on 1/10/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - GradientRenderLayer
+
+/// A `CAGradientLayer` subclass used to render a gradient _outside_ the normal layer bounds
+///
+///  - `GradientFill.startPoint` and `GradientFill.endPoint` are expressed
+///    with respect to the `bounds` of the `ShapeItemLayer`.
+///
+///  - The gradient itself is supposed to be rendered infinitely in all directions
+///    (e.g. including outside of `bounds`). This is because `ShapeItemLayer` paths
+///    don't necessarily sit within the layer's `bounds`.
+///
+///  - To support this, `GradientRenderLayer` tracks a `gradientReferenceBounds`
+///    that `startPoint` / `endPoint` are calculated relative to.
+///    The _actual_ `bounds` of this layer is padded by a large amount so that
+///    the gradient can be drawn outside of the `gradientReferenceBounds`.
+///
+final class GradientRenderLayer: CAGradientLayer {
+
+  // MARK: Internal
+
+  /// The reference bounds within this layer that the gradient's
+  /// `startPoint` and `endPoint` should be calculated relative to
+  var gradientReferenceBounds = CGRect.zero {
+    didSet {
+      if oldValue != gradientReferenceBounds {
+        updateLayout()
+      }
+    }
+  }
+
+  /// Converts the given `CGPoint` within `gradientReferenceBounds`
+  /// to a percentage value relative to the full `bounds` of this layer
+  ///  - This converts absolute `startPoint` and `endPoint` values into
+  ///    the percent-based values expected by Core Animation,
+  ///    with respect to the custom bounds geometry used by this layer type.
+  func percentBasedPointInBounds(from referencePoint: CGPoint) -> CGPoint {
+    guard bounds.width > 0, bounds.height > 0 else {
+      LottieLogger.shared.assertionFailure("Size must be non-zero before an animation can be played")
+      return .zero
+    }
+
+    let pointInBounds = CGPoint(
+      x: referencePoint.x + CALayer.veryLargeLayerPadding,
+      y: referencePoint.y + CALayer.veryLargeLayerPadding
+    )
+
+    return CGPoint(
+      x: CGFloat(pointInBounds.x) / bounds.width,
+      y: CGFloat(pointInBounds.y) / bounds.height
+    )
+  }
+
+  // MARK: Private
+
+  private func updateLayout() {
+    anchorPoint = .zero
+
+    bounds = CGRect(
+      x: gradientReferenceBounds.origin.x,
+      y: gradientReferenceBounds.origin.y,
+      width: CALayer.veryLargeLayerPadding + gradientReferenceBounds.width + CALayer.veryLargeLayerPadding,
+      height: CALayer.veryLargeLayerPadding + gradientReferenceBounds.height + CALayer.veryLargeLayerPadding
+    )
+
+    // Align the center of this layer to be at the center point of its parent layer
+    let superlayerSize = superlayer?.frame.size ?? gradientReferenceBounds.size
+
+    transform = CATransform3DMakeTranslation(
+      (superlayerSize.width - bounds.width) / 2,
+      (superlayerSize.height - bounds.height) / 2,
+      0
+    )
+  }
+
+}
+
+// MARK: CustomLayoutLayer
+
+extension GradientRenderLayer: CustomLayoutLayer {
+  func layout(superlayerBounds: CGRect) {
+    gradientReferenceBounds = superlayerBounds
+
+    if let gradientMask = mask as? GradientRenderLayer {
+      gradientMask.layout(superlayerBounds: superlayerBounds)
+    }
+  }
+}
+
+extension CALayer {
+  /// Extra padding to add around layers that should be very large or "infinite" in size.
+  /// Examples include `GradientRenderLayer` and `InfiniteOpaqueAnimationLayer`.
+  ///  - This specific value is arbitrary and can be increased if necessary.
+  ///  - Theoretically this should be "infinite", to match the behavior of
+  ///    `CGContext.drawLinearGradient` with `[.drawsAfterEndLocation, .drawsBeforeStartLocation]` etc.
+  static let veryLargeLayerPadding: CGFloat = 10_000
+}

package/platforms/macos/src/vendor/Lottie/Private/CoreAnimation/Layers/ImageLayer.swift

@@ -0,0 +1,81 @@
+// Created by Cal Stephens on 1/10/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - ImageLayer
+
+/// The `CALayer` type responsible for rendering `ImageLayerModel`s
+final class ImageLayer: BaseCompositionLayer {
+
+  // MARK: Lifecycle
+
+  init(
+    imageLayer: ImageLayerModel,
+    context: LayerContext
+  ) {
+    self.imageLayer = imageLayer
+    super.init(layerModel: imageLayer)
+    setupImage(context: context)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  /// Called by CoreAnimation to create a shadow copy of this layer
+  /// More details: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
+  override init(layer: Any) {
+    guard let typedLayer = layer as? Self else {
+      fatalError("\(Self.self).init(layer:) incorrectly called with \(type(of: layer))")
+    }
+
+    imageLayer = typedLayer.imageLayer
+    super.init(layer: typedLayer)
+  }
+
+  // MARK: Internal
+
+  func setupImage(context: LayerContext) {
+    guard
+      let imageAsset = context.animation.assetLibrary?.imageAssets[imageLayer.referenceID],
+      let image = context.imageProvider.imageForAsset(asset: imageAsset)
+    else {
+      self.imageAsset = nil
+      contentsLayer.contents = nil
+      return
+    }
+
+    self.imageAsset = imageAsset
+    contentsLayer.contents = image
+    contentsLayer.contentsGravity = context.imageProvider.contentsGravity(for: imageAsset)
+    setNeedsLayout()
+  }
+
+  // MARK: Private
+
+  private let imageLayer: ImageLayerModel
+  private var imageAsset: ImageAsset?
+
+}
+
+// MARK: CustomLayoutLayer
+
+extension ImageLayer: CustomLayoutLayer {
+  func layout(superlayerBounds: CGRect) {
+    anchorPoint = .zero
+
+    guard let imageAsset else {
+      bounds = superlayerBounds
+      return
+    }
+
+    // Image layers specifically need to use the size of the image itself
+    bounds = CGRect(
+      x: superlayerBounds.origin.x,
+      y: superlayerBounds.origin.y,
+      width: CGFloat(imageAsset.width),
+      height: CGFloat(imageAsset.height)
+    )
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/CoreAnimation/Layers/InfiniteOpaqueAnimationLayer.swift

@@ -0,0 +1,57 @@
+// Created by Cal Stephens on 10/10/22.
+// Copyright © 2022 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - ExpandedAnimationLayer
+
+/// A `BaseAnimationLayer` subclass that renders its background color
+/// as if the layer is infinitely large, without affecting its bounds
+/// or the bounds of its sublayers
+final class InfiniteOpaqueAnimationLayer: BaseAnimationLayer {
+
+  // MARK: Lifecycle
+
+  override init() {
+    super.init()
+    addSublayer(additionalPaddingLayer)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  /// Called by CoreAnimation to create a shadow copy of this layer
+  /// More details: https://developer.apple.com/documentation/quartzcore/calayer/1410842-init
+  override init(layer: Any) {
+    super.init(layer: layer)
+  }
+
+  // MARK: Internal
+
+  override func layoutSublayers() {
+    super.layoutSublayers()
+
+    masksToBounds = false
+    additionalPaddingLayer.backgroundColor = backgroundColor
+
+    // Scale `additionalPaddingLayer` to be larger than this layer
+    // by `additionalPadding` at each size, and centered at the center
+    // of this layer. Since `additionalPadding` is very large, this has
+    // the affect of making `additionalPaddingLayer` appear infinite.
+    let scaleRatioX = (bounds.width + (CALayer.veryLargeLayerPadding * 2)) / bounds.width
+    let scaleRatioY = (bounds.height + (CALayer.veryLargeLayerPadding * 2)) / bounds.height
+
+    additionalPaddingLayer.transform = CATransform3DScale(
+      CATransform3DMakeTranslation(-CALayer.veryLargeLayerPadding, -CALayer.veryLargeLayerPadding, 0),
+      scaleRatioX,
+      scaleRatioY,
+      1
+    )
+  }
+
+  // MARK: Private
+
+  private let additionalPaddingLayer = CALayer()
+
+}

package/platforms/macos/src/vendor/Lottie/Private/CoreAnimation/Layers/LayerModel+makeAnimationLayer.swift

@@ -0,0 +1,59 @@
+// Created by Cal Stephens on 12/20/21.
+// Copyright © 2021 Airbnb Inc. All rights reserved.
+
+// MARK: - LayerContext
+
+/// Context available when constructing an `AnimationLayer`
+struct LayerContext {
+  let animation: LottieAnimation
+  let imageProvider: AnimationImageProvider
+  let textProvider: AnimationKeypathTextProvider
+  let fontProvider: AnimationFontProvider
+  let compatibilityTracker: CompatibilityTracker
+  var layerName: String
+
+  func forLayer(_ layer: LayerModel) -> LayerContext {
+    var context = self
+    context.layerName = layer.name
+    return context
+  }
+}
+
+// MARK: - LayerModel + makeAnimationLayer
+
+extension LayerModel {
+  /// Constructs an `AnimationLayer` / `CALayer` that represents this `LayerModel`
+  func makeAnimationLayer(context: LayerContext) throws -> BaseCompositionLayer? {
+    let context = context.forLayer(self)
+
+    if hidden {
+      return TransformLayer(layerModel: self)
+    }
+
+    switch (type, self) {
+    case (.precomp, let preCompLayerModel as PreCompLayerModel):
+      let preCompLayer = PreCompLayer(preCompLayer: preCompLayerModel)
+      try preCompLayer.setup(context: context)
+      return preCompLayer
+
+    case (.solid, let solidLayerModel as SolidLayerModel):
+      return SolidLayer(solidLayerModel)
+
+    case (.shape, let shapeLayerModel as ShapeLayerModel):
+      return try ShapeLayer(shapeLayer: shapeLayerModel, context: context)
+
+    case (.image, let imageLayerModel as ImageLayerModel):
+      return ImageLayer(imageLayer: imageLayerModel, context: context)
+
+    case (.text, let textLayerModel as TextLayerModel):
+      return try TextLayer(textLayerModel: textLayerModel, context: context)
+
+    case (.null, _):
+      return TransformLayer(layerModel: self)
+
+    case (.unknown, _), (.precomp, _), (.solid, _), (.image, _), (.shape, _), (.text, _):
+      return nil
+    }
+  }
+
+}