@octane-xplat/lottie 0.9.0 → 0.11.0

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/FillRenderer.swift

@@ -0,0 +1,69 @@
+//
+//  FillRenderer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import QuartzCore
+
+extension FillRule {
+  var cgFillRule: CGPathFillRule {
+    switch self {
+    case .evenOdd:
+      .evenOdd
+    default:
+      .winding
+    }
+  }
+
+  var caFillRule: CAShapeLayerFillRule {
+    switch self {
+    case .evenOdd:
+      CAShapeLayerFillRule.evenOdd
+    default:
+      CAShapeLayerFillRule.nonZero
+    }
+  }
+}
+
+// MARK: - FillRenderer
+
+/// A rendered for a Path Fill
+final class FillRenderer: PassThroughOutputNode, Renderable {
+  var shouldRenderInContext = false
+
+  var color: CGColor? {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var opacity: CGFloat = 0 {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var fillRule = FillRule.none {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  func render(_: CGContext) {
+    // do nothing
+  }
+
+  func setupSublayers(layer _: CAShapeLayer) {
+    // do nothing
+  }
+
+  func updateShapeLayer(layer: CAShapeLayer) {
+    layer.fillColor = color
+    layer.opacity = Float(opacity)
+    layer.fillRule = fillRule.caFillRule
+    hasUpdate = false
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/GradientFillRenderer.swift

@@ -0,0 +1,253 @@
+//
+//  GradientFillRenderer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import QuartzCore
+
+// MARK: - GradientFillLayer
+
+private final class GradientFillLayer: CALayer {
+
+  var start = CGPoint.zero {
+    didSet {
+      setNeedsDisplay()
+    }
+  }
+
+  var numberOfColors = 0 {
+    didSet {
+      setNeedsDisplay()
+    }
+  }
+
+  var colors = [CGFloat]() {
+    didSet {
+      setNeedsDisplay()
+    }
+  }
+
+  var end = CGPoint.zero {
+    didSet {
+      setNeedsDisplay()
+    }
+  }
+
+  var type = GradientType.none {
+    didSet {
+      setNeedsDisplay()
+    }
+  }
+
+  override func draw(in ctx: CGContext) {
+    var alphaColors = [CGColor]()
+    var alphaLocations = [CGFloat]()
+
+    var gradientColors = [CGColor]()
+    var colorLocations = [CGFloat]()
+    let maskColorSpace = CGColorSpaceCreateDeviceGray()
+    for i in 0..<numberOfColors {
+      let ix = i * 4
+      if colors.count > ix {
+        let color = CGColor.rgb(colors[ix + 1], colors[ix + 2], colors[ix + 3])
+        gradientColors.append(color)
+        colorLocations.append(colors[ix])
+      }
+    }
+
+    var drawMask = false
+    for i in stride(from: numberOfColors * 4, to: colors.endIndex, by: 2) {
+      let alpha = colors[i + 1]
+      if alpha < 1 {
+        drawMask = true
+      }
+      alphaLocations.append(colors[i])
+      alphaColors.append(.gray(alpha))
+    }
+
+    /// First draw a mask is necessary.
+    if drawMask {
+      guard
+        let maskGradient = CGGradient(
+          colorsSpace: maskColorSpace,
+          colors: alphaColors as CFArray,
+          locations: alphaLocations
+        ),
+        let maskContext = CGContext(
+          data: nil,
+          width: ctx.width,
+          height: ctx.height,
+          bitsPerComponent: 8,
+          bytesPerRow: ctx.width,
+          space: maskColorSpace,
+          bitmapInfo: 0
+        )
+      else { return }
+      let flipVertical = CGAffineTransform(a: 1, b: 0, c: 0, d: -1, tx: 0, ty: CGFloat(maskContext.height))
+      maskContext.concatenate(flipVertical)
+      maskContext.concatenate(ctx.ctm)
+      if type == .linear {
+        maskContext.drawLinearGradient(
+          maskGradient,
+          start: start,
+          end: end,
+          options: [.drawsAfterEndLocation, .drawsBeforeStartLocation]
+        )
+      } else {
+        maskContext.drawRadialGradient(
+          maskGradient,
+          startCenter: start,
+          startRadius: 0,
+          endCenter: start,
+          endRadius: start.distanceTo(end),
+          options: [.drawsAfterEndLocation, .drawsBeforeStartLocation]
+        )
+      }
+      /// Clips the gradient
+      if let alphaMask = maskContext.makeImage() {
+        ctx.clip(to: ctx.boundingBoxOfClipPath, mask: alphaMask)
+      }
+    }
+
+    /// Now draw the gradient
+    guard
+      let gradient = CGGradient(
+        colorsSpace: LottieConfiguration.shared.colorSpace,
+        colors: gradientColors as CFArray,
+        locations: colorLocations
+      )
+    else { return }
+
+    if type == .linear {
+      ctx.drawLinearGradient(gradient, start: start, end: end, options: [.drawsAfterEndLocation, .drawsBeforeStartLocation])
+    } else {
+      ctx.drawRadialGradient(
+        gradient,
+        startCenter: start,
+        startRadius: 0,
+        endCenter: start,
+        endRadius: start.distanceTo(end),
+        options: [.drawsAfterEndLocation, .drawsBeforeStartLocation]
+      )
+    }
+  }
+
+}
+
+// MARK: - GradientFillRenderer
+
+/// A rendered for a Path Fill
+final class GradientFillRenderer: PassThroughOutputNode, Renderable {
+
+  // MARK: Lifecycle
+
+  override init(parent: NodeOutput?) {
+    super.init(parent: parent)
+
+    maskLayer.fillColor = .rgb(1, 1, 1)
+    gradientLayer.mask = maskLayer
+
+    maskLayer.actions = [
+      "startPoint": NSNull(),
+      "endPoint": NSNull(),
+      "opacity": NSNull(),
+      "locations": NSNull(),
+      "colors": NSNull(),
+      "bounds": NSNull(),
+      "anchorPoint": NSNull(),
+      "isRadial": NSNull(),
+      "path": NSNull(),
+    ]
+    gradientLayer.actions = maskLayer.actions
+  }
+
+  // MARK: Internal
+
+  var shouldRenderInContext = false
+
+  var start = CGPoint.zero {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var numberOfColors = 0 {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var colors = [CGFloat]() {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var end = CGPoint.zero {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var opacity: CGFloat = 0 {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var type = GradientType.none {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var fillRule: CAShapeLayerFillRule {
+    get { maskLayer.fillRule }
+    set { maskLayer.fillRule = newValue }
+  }
+
+  func render(_: CGContext) {
+    // do nothing
+  }
+
+  func setupSublayers(layer: CAShapeLayer) {
+    layer.addSublayer(gradientLayer)
+    layer.fillColor = nil
+  }
+
+  func updateShapeLayer(layer: CAShapeLayer) {
+    hasUpdate = false
+
+    guard let path = layer.path else {
+      return
+    }
+
+    let frame = path.boundingBox
+    let anchor = CGPoint(
+      x: -frame.origin.x / frame.size.width,
+      y: -frame.origin.y / frame.size.height
+    )
+    maskLayer.path = path
+    maskLayer.bounds = path.boundingBox
+    maskLayer.anchorPoint = anchor
+
+    gradientLayer.bounds = maskLayer.bounds
+    gradientLayer.anchorPoint = anchor
+
+    // setup gradient properties
+    gradientLayer.start = start
+    gradientLayer.end = end
+    gradientLayer.numberOfColors = numberOfColors
+    gradientLayer.colors = colors
+    gradientLayer.opacity = Float(opacity)
+    gradientLayer.type = type
+  }
+
+  // MARK: Private
+
+  private let gradientLayer = GradientFillLayer()
+  private let maskLayer = CAShapeLayer()
+
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/GradientStrokeRenderer.swift

@@ -0,0 +1,64 @@
+//
+//  GradientStrokeRenderer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import QuartzCore
+
+// MARK: - Renderer
+
+final class GradientStrokeRenderer: PassThroughOutputNode, Renderable {
+
+  // MARK: Lifecycle
+
+  override init(parent: NodeOutput?) {
+    strokeRender = StrokeRenderer(parent: nil)
+    gradientRender = LegacyGradientFillRenderer(parent: nil)
+    strokeRender.color = .rgb(1, 1, 1)
+    super.init(parent: parent)
+  }
+
+  // MARK: Internal
+
+  var shouldRenderInContext = true
+
+  let strokeRender: StrokeRenderer
+  let gradientRender: LegacyGradientFillRenderer
+
+  override func hasOutputUpdates(_ forFrame: CGFloat) -> Bool {
+    let updates = super.hasOutputUpdates(forFrame)
+    return updates || strokeRender.hasUpdate || gradientRender.hasUpdate
+  }
+
+  func updateShapeLayer(layer _: CAShapeLayer) {
+    /// Not Applicable
+  }
+
+  func setupSublayers(layer _: CAShapeLayer) {
+    /// Not Applicable
+  }
+
+  func render(_ inContext: CGContext) {
+    guard inContext.path != nil, inContext.path!.isEmpty == false else {
+      return
+    }
+
+    strokeRender.hasUpdate = false
+    hasUpdate = false
+    gradientRender.hasUpdate = false
+
+    strokeRender.setupForStroke(inContext)
+
+    inContext.replacePathWithStrokedPath()
+
+    /// Now draw the gradient.
+    gradientRender.render(inContext)
+  }
+
+  func renderBoundsFor(_ boundingBox: CGRect) -> CGRect {
+    strokeRender.renderBoundsFor(boundingBox)
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/LegacyGradientFillRenderer.swift

@@ -0,0 +1,158 @@
+//
+//  LegacyGradientFillRenderer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import QuartzCore
+
+/// A rendered for a Path Fill
+final class LegacyGradientFillRenderer: PassThroughOutputNode, Renderable {
+
+  var shouldRenderInContext = true
+
+  var start = CGPoint.zero {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var numberOfColors = 0 {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var colors = [CGFloat]() {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var end = CGPoint.zero {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var opacity: CGFloat = 0 {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var type = GradientType.none {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  func updateShapeLayer(layer _: CAShapeLayer) {
+    // Not applicable
+  }
+
+  func setupSublayers(layer _: CAShapeLayer) {
+    // Not applicable
+  }
+
+  func render(_ inContext: CGContext) {
+    guard inContext.path != nil, inContext.path!.isEmpty == false else {
+      return
+    }
+    hasUpdate = false
+    var alphaColors = [CGColor]()
+    var alphaLocations = [CGFloat]()
+
+    var gradientColors = [CGColor]()
+    var colorLocations = [CGFloat]()
+    let maskColorSpace = CGColorSpaceCreateDeviceGray()
+    for i in 0..<numberOfColors {
+      let ix = i * 4
+      if colors.count > ix {
+        let color = CGColor.rgb(colors[ix + 1], colors[ix + 2], colors[ix + 3])
+        gradientColors.append(color)
+        colorLocations.append(colors[ix])
+      }
+    }
+
+    var drawMask = false
+    for i in stride(from: numberOfColors * 4, to: colors.endIndex, by: 2) {
+      let alpha = colors[i + 1]
+      if alpha < 1 {
+        drawMask = true
+      }
+      alphaLocations.append(colors[i])
+      alphaColors.append(.gray(alpha))
+    }
+
+    inContext.setAlpha(opacity)
+    inContext.clip()
+
+    /// First draw a mask is necessary.
+    if drawMask {
+      guard
+        let maskGradient = CGGradient(
+          colorsSpace: maskColorSpace,
+          colors: alphaColors as CFArray,
+          locations: alphaLocations
+        ),
+        let maskContext = CGContext(
+          data: nil,
+          width: inContext.width,
+          height: inContext.height,
+          bitsPerComponent: 8,
+          bytesPerRow: inContext.width,
+          space: maskColorSpace,
+          bitmapInfo: 0
+        )
+      else { return }
+      let flipVertical = CGAffineTransform(a: 1, b: 0, c: 0, d: -1, tx: 0, ty: CGFloat(maskContext.height))
+      maskContext.concatenate(flipVertical)
+      maskContext.concatenate(inContext.ctm)
+      if type == .linear {
+        maskContext.drawLinearGradient(
+          maskGradient,
+          start: start,
+          end: end,
+          options: [.drawsAfterEndLocation, .drawsBeforeStartLocation]
+        )
+      } else {
+        maskContext.drawRadialGradient(
+          maskGradient,
+          startCenter: start,
+          startRadius: 0,
+          endCenter: start,
+          endRadius: start.distanceTo(end),
+          options: [.drawsAfterEndLocation, .drawsBeforeStartLocation]
+        )
+      }
+      /// Clips the gradient
+      if let alphaMask = maskContext.makeImage() {
+        inContext.clip(to: inContext.boundingBoxOfClipPath, mask: alphaMask)
+      }
+    }
+
+    /// Now draw the gradient
+    guard
+      let gradient = CGGradient(
+        colorsSpace: LottieConfiguration.shared.colorSpace,
+        colors: gradientColors as CFArray,
+        locations: colorLocations
+      )
+    else { return }
+
+    if type == .linear {
+      inContext.drawLinearGradient(gradient, start: start, end: end, options: [.drawsAfterEndLocation, .drawsBeforeStartLocation])
+    } else {
+      inContext.drawRadialGradient(
+        gradient,
+        startCenter: start,
+        startRadius: 0,
+        endCenter: start,
+        endRadius: start.distanceTo(end),
+        options: [.drawsAfterEndLocation, .drawsBeforeStartLocation]
+      )
+    }
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/StrokeRenderer.swift

@@ -0,0 +1,165 @@
+//
+//  StrokeRenderer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import QuartzCore
+
+extension LineJoin {
+  var cgLineJoin: CGLineJoin {
+    switch self {
+    case .bevel:
+      .bevel
+    case .none:
+      .miter
+    case .miter:
+      .miter
+    case .round:
+      .round
+    }
+  }
+
+  var caLineJoin: CAShapeLayerLineJoin {
+    switch self {
+    case .none:
+      CAShapeLayerLineJoin.miter
+    case .miter:
+      CAShapeLayerLineJoin.miter
+    case .round:
+      CAShapeLayerLineJoin.round
+    case .bevel:
+      CAShapeLayerLineJoin.bevel
+    }
+  }
+}
+
+extension LineCap {
+  var cgLineCap: CGLineCap {
+    switch self {
+    case .none:
+      .butt
+    case .butt:
+      .butt
+    case .round:
+      .round
+    case .square:
+      .square
+    }
+  }
+
+  var caLineCap: CAShapeLayerLineCap {
+    switch self {
+    case .none:
+      CAShapeLayerLineCap.butt
+    case .butt:
+      CAShapeLayerLineCap.butt
+    case .round:
+      CAShapeLayerLineCap.round
+    case .square:
+      CAShapeLayerLineCap.square
+    }
+  }
+}
+
+// MARK: - StrokeRenderer
+
+/// A rendered that renders a stroke on a path.
+final class StrokeRenderer: PassThroughOutputNode, Renderable {
+
+  var shouldRenderInContext = false
+
+  var color: CGColor? {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var opacity: CGFloat = 0 {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var width: CGFloat = 0 {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var miterLimit: CGFloat = 0 {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var lineCap = LineCap.none {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var lineJoin = LineJoin.none {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var dashPhase: CGFloat? {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  var dashLengths: [CGFloat]? {
+    didSet {
+      hasUpdate = true
+    }
+  }
+
+  func setupSublayers(layer _: CAShapeLayer) {
+    // empty
+  }
+
+  func renderBoundsFor(_ boundingBox: CGRect) -> CGRect {
+    boundingBox.insetBy(dx: -width, dy: -width)
+  }
+
+  func setupForStroke(_ inContext: CGContext) {
+    inContext.setLineWidth(width)
+    inContext.setMiterLimit(miterLimit)
+    inContext.setLineCap(lineCap.cgLineCap)
+    inContext.setLineJoin(lineJoin.cgLineJoin)
+    if let dashPhase, let lengths = dashLengths {
+      inContext.setLineDash(phase: dashPhase, lengths: lengths)
+    } else {
+      inContext.setLineDash(phase: 0, lengths: [])
+    }
+  }
+
+  func render(_ inContext: CGContext) {
+    guard inContext.path != nil, inContext.path!.isEmpty == false else {
+      return
+    }
+    guard let color else { return }
+    hasUpdate = false
+    setupForStroke(inContext)
+    inContext.setAlpha(opacity)
+    inContext.setStrokeColor(color)
+    inContext.strokePath()
+  }
+
+  func updateShapeLayer(layer: CAShapeLayer) {
+    layer.strokeColor = color
+    layer.opacity = Float(opacity)
+    layer.lineWidth = width
+    layer.lineJoin = lineJoin.caLineJoin
+    layer.lineCap = lineCap.caLineCap
+    layer.lineDashPhase = dashPhase ?? 0
+    layer.fillColor = nil
+    if let dashPattern = dashLengths {
+      layer.lineDashPattern = dashPattern.map { NSNumber(value: Double($0)) }
+    }
+  }
+}