@octane-xplat/lottie 0.9.0 → 0.10.0

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

@@ -0,0 +1,103 @@
+//
+//  CompositionLayersInitializer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/25/19.
+//
+
+import CoreGraphics
+import Foundation
+
+extension [LayerModel] {
+
+  func initializeCompositionLayers(
+    assetLibrary: AssetLibrary?,
+    layerImageProvider: LayerImageProvider,
+    layerTextProvider: LayerTextProvider,
+    layerFontProvider: LayerFontProvider,
+    textProvider: AnimationKeypathTextProvider,
+    fontProvider: AnimationFontProvider,
+    frameRate: CGFloat,
+    rootAnimationLayer: MainThreadAnimationLayer?
+  ) -> [CompositionLayer] {
+    var compositionLayers = [CompositionLayer]()
+    var layerMap = [Int: CompositionLayer]()
+
+    /// Organize the assets into a dictionary of [ID : ImageAsset]
+    var childLayers = [LayerModel]()
+
+    for layer in self {
+      if layer.hidden == true {
+        let genericLayer = NullCompositionLayer(layer: layer)
+        compositionLayers.append(genericLayer)
+        layerMap[layer.index] = genericLayer
+      } else if let shapeLayer = layer as? ShapeLayerModel {
+        let shapeContainer = ShapeCompositionLayer(shapeLayer: shapeLayer)
+        compositionLayers.append(shapeContainer)
+        layerMap[layer.index] = shapeContainer
+      } else if let solidLayer = layer as? SolidLayerModel {
+        let solidContainer = SolidCompositionLayer(solid: solidLayer)
+        compositionLayers.append(solidContainer)
+        layerMap[layer.index] = solidContainer
+      } else if
+        let precompLayer = layer as? PreCompLayerModel,
+        let assetLibrary,
+        let precompAsset = assetLibrary.precompAssets[precompLayer.referenceID]
+      {
+        let precompContainer = PreCompositionLayer(
+          precomp: precompLayer,
+          asset: precompAsset,
+          layerImageProvider: layerImageProvider,
+          layerTextProvider: layerTextProvider,
+          layerFontProvider: layerFontProvider,
+          textProvider: textProvider,
+          fontProvider: fontProvider,
+          assetLibrary: assetLibrary,
+          frameRate: frameRate,
+          rootAnimationLayer: rootAnimationLayer
+        )
+        compositionLayers.append(precompContainer)
+        layerMap[layer.index] = precompContainer
+      } else if
+        let imageLayer = layer as? ImageLayerModel,
+        let assetLibrary,
+        let imageAsset = assetLibrary.imageAssets[imageLayer.referenceID]
+      {
+        let imageContainer = ImageCompositionLayer(
+          imageLayer: imageLayer,
+          size: CGSize(width: imageAsset.width, height: imageAsset.height)
+        )
+        compositionLayers.append(imageContainer)
+        layerMap[layer.index] = imageContainer
+      } else if let textLayer = layer as? TextLayerModel {
+        let textContainer = TextCompositionLayer(
+          textLayer: textLayer,
+          textProvider: textProvider,
+          fontProvider: fontProvider,
+          rootAnimationLayer: rootAnimationLayer
+        )
+        compositionLayers.append(textContainer)
+        layerMap[layer.index] = textContainer
+      } else {
+        let genericLayer = NullCompositionLayer(layer: layer)
+        compositionLayers.append(genericLayer)
+        layerMap[layer.index] = genericLayer
+      }
+      if layer.parent != nil {
+        childLayers.append(layer)
+      }
+    }
+
+    /// Now link children with their parents
+    for layerModel in childLayers {
+      if let parentID = layerModel.parent {
+        let childLayer = layerMap[layerModel.index]
+        let parentLayer = layerMap[parentID]
+        childLayer?.transformNode.parentNode = parentLayer?.transformNode
+      }
+    }
+
+    return compositionLayers
+  }
+
+}

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

@@ -0,0 +1,424 @@
+//
+//  TextLayer.swift
+//  Pods
+//
+//  Created by Brandon Withrow on 8/3/20.
+//
+
+import CoreGraphics
+import CoreText
+import Foundation
+import QuartzCore
+/// Needed for NSMutableParagraphStyle...
+#if os(OSX)
+import AppKit
+#else
+import UIKit
+#endif
+
+// MARK: - CoreTextRenderLayer
+
+/// A CALayer subclass that renders text content using CoreText
+final class CoreTextRenderLayer: CALayer {
+
+  // MARK: Internal
+
+  var text: String? {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  var font: CTFont? {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  var alignment = NSTextAlignment.left {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  var lineHeight: CGFloat = 0 {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  var tracking: CGFloat = 0 {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  var fillColor: CGColor? {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  var strokeColor: CGColor? {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  var strokeWidth: CGFloat = 0 {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  var strokeOnTop = false {
+    didSet {
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  var preferredSize: CGSize? {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  var start: Int? {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  var end: Int? {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  /// The type of unit to use when computing the `start` / `end` range within the text string
+  var textRangeUnit: TextRangeUnit? {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  /// The opacity to apply to the range between `start` and `end`
+  var selectedRangeOpacity: CGFloat? {
+    didSet {
+      needsContentUpdate = true
+      setNeedsLayout()
+      setNeedsDisplay()
+    }
+  }
+
+  func sizeToFit() {
+    updateTextContent()
+    bounds = drawingRect
+    anchorPoint = drawingAnchor
+    setNeedsLayout()
+    setNeedsDisplay()
+  }
+
+  override func action(forKey _: String) -> CAAction? {
+    nil
+  }
+
+  override func draw(in ctx: CGContext) {
+    guard let attributedString else { return }
+    updateTextContent()
+    guard fillFrameSetter != nil || strokeFrameSetter != nil else { return }
+
+    ctx.textMatrix = .identity
+    ctx.setAllowsAntialiasing(true)
+    ctx.setAllowsFontSubpixelPositioning(true)
+    ctx.setAllowsFontSubpixelQuantization(true)
+
+    ctx.setShouldAntialias(true)
+    ctx.setShouldSubpixelPositionFonts(true)
+    ctx.setShouldSubpixelQuantizeFonts(true)
+
+    if contentsAreFlipped() {
+      ctx.translateBy(x: 0, y: drawingRect.height)
+      ctx.scaleBy(x: 1.0, y: -1.0)
+    }
+
+    let drawingPath = CGPath(rect: drawingRect, transform: nil)
+    if preferredSize == nil {
+      let horizontalOffset: CGFloat =
+        switch alignment {
+        case .left:
+          compensationPadding
+        case .right:
+          -compensationPadding
+        default:
+          0
+        }
+      ctx.translateBy(x: horizontalOffset, y: 0)
+    }
+
+    let fillFrame: CTFrame? =
+      if let setter = fillFrameSetter {
+        CTFramesetterCreateFrame(setter, CFRangeMake(0, attributedString.length), drawingPath, nil)
+      } else {
+        nil
+      }
+
+    let strokeFrame: CTFrame? =
+      if let setter = strokeFrameSetter {
+        CTFramesetterCreateFrame(setter, CFRangeMake(0, attributedString.length), drawingPath, nil)
+      } else {
+        nil
+      }
+
+    // This fixes a vertical padding issue that arises when drawing some fonts.
+    // For some reason some fonts, such as Helvetica draw with an ascender that is greater than the one reported by CTFontGetAscender.
+    // I suspect this is actually an issue with the Attributed string, but cannot reproduce.
+
+    if let fillFrame {
+      ctx.adjustWithLineOrigins(in: fillFrame, with: font)
+    } else if let strokeFrame {
+      ctx.adjustWithLineOrigins(in: strokeFrame, with: font)
+    }
+
+    if !strokeOnTop, let strokeFrame {
+      CTFrameDraw(strokeFrame, ctx)
+    }
+
+    if let fillFrame {
+      CTFrameDraw(fillFrame, ctx)
+    }
+
+    if strokeOnTop, let strokeFrame {
+      CTFrameDraw(strokeFrame, ctx)
+    }
+  }
+
+  // MARK: Private
+
+  private var drawingRect = CGRect.zero
+  private var drawingAnchor = CGPoint.zero
+  private var fillFrameSetter: CTFramesetter?
+  private var attributedString: NSAttributedString?
+  private var strokeFrameSetter: CTFramesetter?
+  private var needsContentUpdate = false
+
+  /// Horizontal compensation padding for the fonts that report wrong geometry.
+  ///
+  /// Some fonts have symbols that are drawn beyond the suggested frame
+  /// that CoreText returns, especially calligraphy fonts. This padding tries to compensate for that.
+  /// Because we can't know for sure the real size of the text,
+  /// the 20% value was experimentally chosen to account for most such cases.
+  private var compensationPadding: CGFloat {
+    (font.map(CTFontGetSize) ?? 0) * 0.2
+  }
+
+  private func updateTextContent() {
+    guard needsContentUpdate else { return }
+    needsContentUpdate = false
+    guard let font, let text, text.count > 0, fillColor != nil || strokeColor != nil else {
+      drawingRect = .zero
+      drawingAnchor = .zero
+      attributedString = nil
+      fillFrameSetter = nil
+      strokeFrameSetter = nil
+      return
+    }
+
+    // Get Font properties
+    let ascent = CTFontGetAscent(font)
+    let descent = CTFontGetDescent(font)
+    let capHeight = CTFontGetCapHeight(font)
+    let leading = CTFontGetLeading(font)
+    let minLineHeight = -(ascent + descent + leading)
+
+    // Calculate line spacing
+    let lineSpacing = max(CGFloat(minLineHeight) + lineHeight, CGFloat(minLineHeight))
+    // Build Attributes
+    let paragraphStyle = NSMutableParagraphStyle()
+    paragraphStyle.lineSpacing = lineSpacing
+    paragraphStyle.lineHeightMultiple = 1
+    paragraphStyle.maximumLineHeight = ascent + descent + leading
+    paragraphStyle.alignment = alignment
+    paragraphStyle.lineBreakMode = NSLineBreakMode.byWordWrapping
+    var attributes: [NSAttributedString.Key: Any] = [
+      NSAttributedString.Key.ligature: 0,
+      NSAttributedString.Key.font: font,
+      NSAttributedString.Key.kern: tracking,
+      NSAttributedString.Key.paragraphStyle: paragraphStyle,
+    ]
+
+    if let fillColor {
+      attributes[NSAttributedString.Key.foregroundColor] = fillColor
+    }
+
+    let attrString = NSMutableAttributedString(string: text, attributes: attributes)
+
+    // Apply the text animator within between the `start` and `end` indices
+    if let selectedRangeOpacity {
+      // The start and end of a text animator refer to the portions of the text
+      // where that animator is applies. In the schema these can be represented
+      // in absolute index value, or as percentages relative to the dynamic string length.
+      var startIndex: Int
+      var endIndex: Int
+
+      switch textRangeUnit ?? .percentage {
+      case .index:
+        startIndex = start ?? 0
+        endIndex = end ?? text.count
+
+      case .percentage:
+        let startPercentage = Double(start ?? 0) / 100
+        let endPercentage = Double(end ?? 100) / 100
+
+        startIndex = Int(round(Double(attrString.length) * startPercentage))
+        endIndex = Int(round(Double(attrString.length) * endPercentage))
+      }
+
+      // Carefully cap the indices, since passing invalid indices
+      // to `NSAttributedString` will crash the app.
+      startIndex = startIndex.clamp(0, attrString.length)
+      endIndex = endIndex.clamp(0, attrString.length)
+
+      // Make sure the end index actually comes after the start index
+      if endIndex < startIndex {
+        swap(&startIndex, &endIndex)
+      }
+
+      // Apply the `selectedRangeOpacity` to the current `fillColor` if provided
+      let textRangeColor: CGColor
+      if let fillColor {
+        if let (r, g, b) = fillColor.rgb {
+          textRangeColor = .rgba(r, g, b, selectedRangeOpacity)
+        } else {
+          LottieLogger.shared.warn("Could not convert color \(fillColor) to RGB values.")
+          textRangeColor = .rgba(0, 0, 0, selectedRangeOpacity)
+        }
+      } else {
+        textRangeColor = .rgba(0, 0, 0, selectedRangeOpacity)
+      }
+
+      attrString.addAttribute(
+        NSAttributedString.Key.foregroundColor,
+        value: textRangeColor,
+        range: NSRange(location: startIndex, length: endIndex - startIndex)
+      )
+    }
+
+    attributedString = attrString
+
+    if fillColor != nil {
+      let setter = CTFramesetterCreateWithAttributedString(attrString as CFAttributedString)
+      fillFrameSetter = setter
+    } else {
+      fillFrameSetter = nil
+    }
+
+    if let strokeColor {
+      attributes[NSAttributedString.Key.foregroundColor] = nil
+      attributes[NSAttributedString.Key.strokeWidth] = strokeWidth
+      attributes[NSAttributedString.Key.strokeColor] = strokeColor
+      let strokeAttributedString = NSAttributedString(string: text, attributes: attributes)
+      strokeFrameSetter = CTFramesetterCreateWithAttributedString(strokeAttributedString as CFAttributedString)
+    } else {
+      strokeFrameSetter = nil
+      strokeWidth = 0
+    }
+
+    guard let setter = fillFrameSetter ?? strokeFrameSetter else {
+      return
+    }
+
+    // Calculate drawing size and anchor offset
+    let textAnchor: CGPoint
+    if let preferredSize {
+      drawingRect = CGRect(origin: .zero, size: preferredSize)
+      drawingRect.size.height += (ascent - capHeight)
+      drawingRect.size.height += descent
+      textAnchor = CGPoint(x: 0, y: ascent - capHeight)
+    } else {
+      let size = CTFramesetterSuggestFrameSizeWithConstraints(
+        setter,
+        CFRange(location: 0, length: attrString.length),
+        nil,
+        CGSize(width: CGFloat.greatestFiniteMagnitude, height: CGFloat.greatestFiniteMagnitude),
+        nil
+      )
+
+      // Suggested size + horizontal compensation for fonts with inaccurate geometry.
+      let adjustedSize = CGSize(width: size.width + compensationPadding * 2, height: size.height)
+
+      switch alignment {
+      case .left:
+        textAnchor = CGPoint(x: compensationPadding, y: ascent)
+      case .right:
+        textAnchor = CGPoint(x: adjustedSize.width - compensationPadding, y: ascent)
+      case .center:
+        textAnchor = CGPoint(x: adjustedSize.width * 0.5, y: ascent)
+      default:
+        textAnchor = .zero
+      }
+      drawingRect = CGRect(
+        x: 0,
+        y: 0,
+        width: ceil(adjustedSize.width),
+        height: ceil(adjustedSize.height)
+      )
+    }
+
+    // Now Calculate Anchor
+    drawingAnchor = CGPoint(
+      x: textAnchor.x.remap(fromLow: 0, fromHigh: drawingRect.size.width, toLow: 0, toHigh: 1),
+      y: textAnchor.y.remap(fromLow: 0, fromHigh: drawingRect.size.height, toLow: 0, toHigh: 1)
+    )
+
+    if fillFrameSetter != nil, strokeFrameSetter != nil {
+      drawingRect.size.width += strokeWidth
+      drawingRect.size.height += strokeWidth
+    }
+  }
+
+}
+
+extension CGContext {
+
+  fileprivate func adjustWithLineOrigins(in frame: CTFrame, with font: CTFont?) {
+    guard let font else { return }
+
+    let count = CFArrayGetCount(CTFrameGetLines(frame))
+
+    guard count > 0 else { return }
+
+    var o = [CGPoint](repeating: .zero, count: 1)
+    CTFrameGetLineOrigins(frame, CFRange(location: count - 1, length: 1), &o)
+
+    let diff = CTFontGetDescent(font) - o[0].y
+    if diff > 0 {
+      translateBy(x: 0, y: diff)
+    }
+  }
+}

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

@@ -0,0 +1,55 @@
+//
+//  InvertedMatteLayer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/28/19.
+//
+
+import QuartzCore
+
+/// A layer that inverses the alpha output of its input layer.
+///
+/// WARNING: This is experimental and probably not very performant.
+final class InvertedMatteLayer: CALayer, CompositionLayerDelegate {
+
+  // MARK: Lifecycle
+
+  init(inputMatte: CompositionLayer) {
+    self.inputMatte = inputMatte
+    super.init()
+    inputMatte.layerDelegate = self
+    anchorPoint = .zero
+    bounds = inputMatte.bounds
+    setNeedsDisplay()
+  }
+
+  override init(layer: Any) {
+    guard let layer = layer as? InvertedMatteLayer else {
+      fatalError("init(layer:) wrong class.")
+    }
+    inputMatte = nil
+    super.init(layer: layer)
+  }
+
+  required init?(coder _: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+
+  // MARK: Internal
+
+  let inputMatte: CompositionLayer?
+
+  func frameUpdated(frame _: CGFloat) {
+    setNeedsDisplay()
+    displayIfNeeded()
+  }
+
+  override func draw(in ctx: CGContext) {
+    guard let inputMatte else { return }
+    ctx.setFillColor(.rgb(0, 0, 0))
+    ctx.fill(bounds)
+    ctx.setBlendMode(.destinationOut)
+    inputMatte.render(in: ctx)
+  }
+
+}

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

@@ -0,0 +1,39 @@
+//
+//  LayerFontProvider.swift
+//  Lottie
+//
+//  Created by Brandon Withrow on 8/5/20.
+//  Copyright © 2020 YurtvilleProds. All rights reserved.
+//
+
+/// Connects a LottieFontProvider to a group of text layers
+final class LayerFontProvider {
+
+  // MARK: Lifecycle
+
+  init(fontProvider: AnimationFontProvider) {
+    self.fontProvider = fontProvider
+    textLayers = []
+    reloadTexts()
+  }
+
+  // MARK: Internal
+
+  private(set) var textLayers: [TextCompositionLayer]
+
+  var fontProvider: AnimationFontProvider {
+    didSet {
+      reloadTexts()
+    }
+  }
+
+  func addTextLayers(_ layers: [TextCompositionLayer]) {
+    textLayers += layers
+  }
+
+  func reloadTexts() {
+    for textLayer in textLayers {
+      textLayer.fontProvider = fontProvider
+    }
+  }
+}

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

@@ -0,0 +1,52 @@
+//
+//  LayerImageProvider.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/25/19.
+//
+
+/// Connects a LottieImageProvider to a group of image layers
+final class LayerImageProvider {
+
+  // MARK: Lifecycle
+
+  init(imageProvider: AnimationImageProvider, assets: [String: ImageAsset]?) {
+    self.imageProvider = imageProvider
+    imageLayers = [ImageCompositionLayer]()
+    if let assets {
+      imageAssets = assets
+    } else {
+      imageAssets = [:]
+    }
+    reloadImages()
+  }
+
+  // MARK: Internal
+
+  private(set) var imageLayers: [ImageCompositionLayer]
+  let imageAssets: [String: ImageAsset]
+
+  var imageProvider: AnimationImageProvider {
+    didSet {
+      reloadImages()
+    }
+  }
+
+  func addImageLayers(_ layers: [ImageCompositionLayer]) {
+    for layer in layers {
+      if imageAssets[layer.imageReferenceID] != nil {
+        /// Found a linking asset in our asset library. Add layer
+        imageLayers.append(layer)
+      }
+    }
+  }
+
+  func reloadImages() {
+    for imageLayer in imageLayers {
+      if let asset = imageAssets[imageLayer.imageReferenceID] {
+        imageLayer.image = imageProvider.imageForAsset(asset: asset)
+        imageLayer.imageContentsGravity = imageProvider.contentsGravity(for: asset)
+      }
+    }
+  }
+}

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

@@ -0,0 +1,38 @@
+//
+//  LayerTextProvider.swift
+//  lottie-ios-iOS
+//
+//  Created by Alexandr Goncharov on 07/06/2019.
+//
+
+/// Connects a LottieTextProvider to a group of text layers
+final class LayerTextProvider {
+
+  // MARK: Lifecycle
+
+  init(textProvider: AnimationKeypathTextProvider) {
+    self.textProvider = textProvider
+    textLayers = []
+    reloadTexts()
+  }
+
+  // MARK: Internal
+
+  private(set) var textLayers: [TextCompositionLayer]
+
+  var textProvider: AnimationKeypathTextProvider {
+    didSet {
+      reloadTexts()
+    }
+  }
+
+  func addTextLayers(_ layers: [TextCompositionLayer]) {
+    textLayers += layers
+  }
+
+  func reloadTexts() {
+    for textLayer in textLayers {
+      textLayer.textProvider = textProvider
+    }
+  }
+}