lottie-ios 3.2.2 → 3.4.1

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/GradientFillRenderer.swift

@@ -0,0 +1,242 @@
+//
+//  GradientFillRenderer.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import Foundation
+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 colorSpace = CGColorSpaceCreateDeviceRGB()
+    let maskColorSpace = CGColorSpaceCreateDeviceGray()
+    for i in 0..<numberOfColors {
+      let ix = i * 4
+      if
+        colors.count > ix, let color = CGColor(
+          colorSpace: colorSpace,
+          components: [colors[ix + 1], colors[ix + 2], colors[ix + 3], 1])
+      {
+        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
+      }
+      if let color = CGColor(colorSpace: maskColorSpace, components: [alpha, 1]) {
+        alphaLocations.append(colors[i])
+        alphaColors.append(color)
+      }
+    }
+
+    /// 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: 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 = CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [1, 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
+    }
+  }
+
+  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/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/Nodes/OutputNodes/Renderables/GradientStrokeRenderer.swift

@@ -11,49 +11,55 @@ 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 = CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [1, 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
   }
-  
-  var shouldRenderInContext: Bool = true
-  
-  func updateShapeLayer(layer: CAShapeLayer) {
+
+  func updateShapeLayer(layer _: CAShapeLayer) {
     /// Not Applicable
   }
-  
-  let strokeRender: StrokeRenderer
-  let gradientRender: GradientFillRenderer
-  
-  override init(parent: NodeOutput?) {
-    self.strokeRender  = StrokeRenderer(parent: nil)
-    self.gradientRender = GradientFillRenderer(parent: nil)
-    self.strokeRender.color = CGColor(colorSpace: CGColorSpaceCreateDeviceRGB(), components: [1, 1, 1, 1])
-    super.init(parent: parent)
+
+  func setupSublayers(layer _: CAShapeLayer) {
+    /// Not Applicable
   }
-  
+
   func render(_ inContext: CGContext) {
-    guard inContext.path != nil && inContext.path!.isEmpty == false else {
+    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 {
-    return strokeRender.renderBoundsFor(boundingBox)
+    strokeRender.renderBoundsFor(boundingBox)
   }
-  
-  
+
 }

package/{lottie-swift/src/Private/NodeRenderSystem/Nodes/OutputNodes/Renderables/GradientFillRenderer.swift → Sources/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/Renderables/LegacyGradientFillRenderer.swift}

@@ -1,5 +1,5 @@
 //
-//  GradientFillRenderer.swift
+//  LegacyGradientFillRenderer.swift
 //  lottie-swift
 //
 //  Created by Brandon Withrow on 1/30/19.
@@ -9,36 +9,80 @@ import Foundation
 import QuartzCore
 
 /// A rendered for a Path Fill
-final class GradientFillRenderer: PassThroughOutputNode, Renderable {
-  
-  var shouldRenderInContext: Bool = true
-  
-  func updateShapeLayer(layer: CAShapeLayer) {
+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 {
+    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 colorSpace = CGColorSpaceCreateDeviceRGB()
     let maskColorSpace = CGColorSpaceCreateDeviceGray()
     for i in 0..<numberOfColors {
       let ix = i * 4
-        if colors.count > ix, let color = CGColor(colorSpace: colorSpace, components: [colors[ix + 1], colors[ix + 2], colors[ix + 3], 1]) {
+      if
+        colors.count > ix, let color = CGColor(
+          colorSpace: colorSpace,
+          components: [colors[ix + 1], colors[ix + 2], colors[ix + 3], 1])
+      {
         gradientColors.append(color)
         colorLocations.append(colors[ix])
       }
     }
-    
+
     var drawMask = false
-    for i in stride(from: (numberOfColors * 4), to: colors.endIndex, by: 2) {
+    for i in stride(from: numberOfColors * 4, to: colors.endIndex, by: 2) {
       let alpha = colors[i + 1]
       if alpha < 1 {
         drawMask = true
@@ -48,79 +92,62 @@ final class GradientFillRenderer: PassThroughOutputNode, Renderable {
         alphaColors.append(color)
       }
     }
-    
+
     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 }
+      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])
+        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])
+        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: colorSpace, colors: gradientColors as CFArray, locations: colorLocations) else { return }
+    guard let gradient = CGGradient(colorsSpace: 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])
-    }
-  }
-  
-  var start: CGPoint = .zero {
-    didSet {
-      hasUpdate = true
-    }
-  }
-  
-  var numberOfColors: Int = 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
+      inContext.drawRadialGradient(
+        gradient,
+        startCenter: start,
+        startRadius: 0,
+        endCenter: start,
+        endRadius: start.distanceTo(end),
+        options: [.drawsAfterEndLocation, .drawsBeforeStartLocation])
     }
   }
-  
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/Nodes/OutputNodes/Renderables/StrokeRenderer.swift

@@ -21,7 +21,7 @@ extension LineJoin {
       return .round
     }
   }
-  
+
   var caLineJoin: CAShapeLayerLineJoin {
     switch self {
     case .none:
@@ -49,7 +49,7 @@ extension LineCap {
       return .square
     }
   }
-  
+
   var caLineCap: CAShapeLayerLineCap {
     switch self {
     case .none:
@@ -64,65 +64,69 @@ extension LineCap {
   }
 }
 
-// MARK: - Renderer
+// MARK: - StrokeRenderer
 
 /// A rendered that renders a stroke on a path.
 final class StrokeRenderer: PassThroughOutputNode, Renderable {
-  
-  var shouldRenderInContext: Bool = false
-  
+
+  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 {
-    return boundingBox.insetBy(dx: -width, dy: -width)
+    boundingBox.insetBy(dx: -width, dy: -width)
   }
-  
+
   func setupForStroke(_ inContext: CGContext) {
     inContext.setLineWidth(width)
     inContext.setMiterLimit(miterLimit)
@@ -134,9 +138,9 @@ final class StrokeRenderer: PassThroughOutputNode, Renderable {
       inContext.setLineDash(phase: 0, lengths: [])
     }
   }
-  
+
   func render(_ inContext: CGContext) {
-    guard inContext.path != nil && inContext.path!.isEmpty == false else {
+    guard inContext.path != nil, inContext.path!.isEmpty == false else {
       return
     }
     guard let color = color else { return }
@@ -146,7 +150,7 @@ final class StrokeRenderer: PassThroughOutputNode, Renderable {
     inContext.setStrokeColor(color)
     inContext.strokePath()
   }
-  
+
   func updateShapeLayer(layer: CAShapeLayer) {
     layer.strokeColor = color
     layer.opacity = Float(opacity)