lottie-ios 3.2.3 → 3.4.2

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/Nodes/RenderNodes/GradientFillNode.swift

@@ -8,83 +8,98 @@
 import Foundation
 import QuartzCore
 
+// MARK: - GradientFillProperties
+
 final class GradientFillProperties: NodePropertyMap, KeypathSearchable {
-  
+
+  // MARK: Lifecycle
+
   init(gradientfill: GradientFill) {
-    self.keypathName = gradientfill.name
-    self.opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientfill.opacity.keyframes))
-    self.startPoint = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientfill.startPoint.keyframes))
-    self.endPoint = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientfill.endPoint.keyframes))
-    self.colors = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientfill.colors.keyframes))
-    self.gradientType = gradientfill.gradientType
-    self.numberOfColors = gradientfill.numberOfColors
-    self.keypathProperties = [
+    keypathName = gradientfill.name
+    opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientfill.opacity.keyframes))
+    startPoint = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientfill.startPoint.keyframes))
+    endPoint = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientfill.endPoint.keyframes))
+    colors = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientfill.colors.keyframes))
+    gradientType = gradientfill.gradientType
+    numberOfColors = gradientfill.numberOfColors
+    fillRule = gradientfill.fillRule
+    keypathProperties = [
       "Opacity" : opacity,
       "Start Point" : startPoint,
       "End Point" : endPoint,
-      "Colors" : colors
+      "Colors" : colors,
     ]
-    self.properties = Array(keypathProperties.values)
+    properties = Array(keypathProperties.values)
   }
-  
+
+  // MARK: Internal
+
   var keypathName: String
-  
+
   let opacity: NodeProperty<Vector1D>
   let startPoint: NodeProperty<Vector3D>
   let endPoint: NodeProperty<Vector3D>
   let colors: NodeProperty<[Double]>
-  
+
   let gradientType: GradientType
   let numberOfColors: Int
-  
-  
-  let keypathProperties: [String : AnyNodeProperty]
+  let fillRule: FillRule
+
+  let keypathProperties: [String: AnyNodeProperty]
   let properties: [AnyNodeProperty]
-  
+
 }
 
+// MARK: - GradientFillNode
+
 final class GradientFillNode: AnimatorNode, RenderNode {
-  
-  let fillRender: GradientFillRenderer
-  
-  var renderer: NodeOutput & Renderable {
-    return fillRender
-  }
-  
-  let fillProperties: GradientFillProperties
-  
+
+  // MARK: Lifecycle
+
   init(parentNode: AnimatorNode?, gradientFill: GradientFill) {
-    self.fillRender = GradientFillRenderer(parent: parentNode?.outputNode)
-    self.fillProperties = GradientFillProperties(gradientfill: gradientFill)
+    fillRender = GradientFillRenderer(parent: parentNode?.outputNode)
+    fillProperties = GradientFillProperties(gradientfill: gradientFill)
     self.parentNode = parentNode
   }
-  
+
+  // MARK: Internal
+
+  let fillRender: GradientFillRenderer
+
+  let fillProperties: GradientFillProperties
+
+  let parentNode: AnimatorNode?
+  var hasLocalUpdates = false
+  var hasUpstreamUpdates = false
+  var lastUpdateFrame: CGFloat? = nil
+
+  var renderer: NodeOutput & Renderable {
+    fillRender
+  }
+
   // MARK: Animator Node Protocol
-  
+
   var propertyMap: NodePropertyMap & KeypathSearchable {
-    return fillProperties
+    fillProperties
   }
-  
-  let parentNode: AnimatorNode?
-  var hasLocalUpdates: Bool = false
-  var hasUpstreamUpdates: Bool = false
-  var lastUpdateFrame: CGFloat? = nil
-  var isEnabled: Bool = true {
+
+  var isEnabled = true {
     didSet {
       fillRender.isEnabled = isEnabled
     }
   }
-  
+
   func localUpdatesPermeateDownstream() -> Bool {
-    return false
+    false
   }
-  
-  func rebuildOutputs(frame: CGFloat) {
+
+  func rebuildOutputs(frame _: CGFloat) {
     fillRender.start = fillProperties.startPoint.value.pointValue
     fillRender.end = fillProperties.endPoint.value.pointValue
     fillRender.opacity = fillProperties.opacity.value.cgFloatValue * 0.01
     fillRender.colors = fillProperties.colors.value.map { CGFloat($0) }
     fillRender.type = fillProperties.gradientType
     fillRender.numberOfColors = fillProperties.numberOfColors
+    fillRender.fillRule = fillProperties.fillRule.caFillRule
   }
 }

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/Nodes/RenderNodes/GradientStrokeNode.swift

@@ -5,28 +5,28 @@
 //  Created by Brandon Withrow on 1/23/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
 
-// MARK: - Properties
+// MARK: - GradientStrokeProperties
 
 final class GradientStrokeProperties: NodePropertyMap, KeypathSearchable {
-  
-  var keypathName: String
-  
+
+  // MARK: Lifecycle
+
   init(gradientStroke: GradientStroke) {
-    self.keypathName = gradientStroke.name
-    self.opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientStroke.opacity.keyframes))
-    self.startPoint = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientStroke.startPoint.keyframes))
-    self.endPoint = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientStroke.endPoint.keyframes))
-    self.colors = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientStroke.colors.keyframes))
-    self.gradientType = gradientStroke.gradientType
-    self.numberOfColors = gradientStroke.numberOfColors
-    self.width = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientStroke.width.keyframes))
-    self.miterLimit = CGFloat(gradientStroke.miterLimit)
-    self.lineCap = gradientStroke.lineCap
-    self.lineJoin = gradientStroke.lineJoin
-    
+    keypathName = gradientStroke.name
+    opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientStroke.opacity.keyframes))
+    startPoint = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientStroke.startPoint.keyframes))
+    endPoint = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientStroke.endPoint.keyframes))
+    colors = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientStroke.colors.keyframes))
+    gradientType = gradientStroke.gradientType
+    numberOfColors = gradientStroke.numberOfColors
+    width = NodeProperty(provider: KeyframeInterpolator(keyframes: gradientStroke.width.keyframes))
+    miterLimit = CGFloat(gradientStroke.miterLimit)
+    lineCap = gradientStroke.lineCap
+    lineJoin = gradientStroke.lineJoin
+
     if let dashes = gradientStroke.dashPattern {
       var dashPatterns = ContiguousArray<ContiguousArray<Keyframe<Vector1D>>>()
       var dashPhase = ContiguousArray<Keyframe<Vector1D>>()
@@ -37,84 +37,92 @@ final class GradientStrokeProperties: NodePropertyMap, KeypathSearchable {
           dashPatterns.append(dash.value.keyframes)
         }
       }
-      self.dashPattern = NodeProperty(provider: GroupInterpolator(keyframeGroups: dashPatterns))
+      dashPattern = NodeProperty(provider: GroupInterpolator(keyframeGroups: dashPatterns))
       self.dashPhase = NodeProperty(provider: KeyframeInterpolator(keyframes: dashPhase))
     } else {
-      self.dashPattern = NodeProperty(provider: SingleValueProvider([Vector1D]()))
-      self.dashPhase = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+      dashPattern = NodeProperty(provider: SingleValueProvider([Vector1D]()))
+      dashPhase = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
     }
-    self.keypathProperties = [
+    keypathProperties = [
       "Opacity" : opacity,
       "Start Point" : startPoint,
       "End Point" : endPoint,
       "Colors" : colors,
       "Stroke Width" : width,
       "Dashes" : dashPattern,
-      "Dash Phase" : dashPhase
+      "Dash Phase" : dashPhase,
     ]
-    self.properties = Array(keypathProperties.values)
+    properties = Array(keypathProperties.values)
   }
-  
+
+  // MARK: Internal
+
+  var keypathName: String
+
   let opacity: NodeProperty<Vector1D>
   let startPoint: NodeProperty<Vector3D>
   let endPoint: NodeProperty<Vector3D>
   let colors: NodeProperty<[Double]>
   let width: NodeProperty<Vector1D>
-  
+
   let dashPattern: NodeProperty<[Vector1D]>
   let dashPhase: NodeProperty<Vector1D>
-  
+
   let lineCap: LineCap
   let lineJoin: LineJoin
   let miterLimit: CGFloat
   let gradientType: GradientType
   let numberOfColors: Int
-  
-  
-  let keypathProperties: [String : AnyNodeProperty]
+
+  let keypathProperties: [String: AnyNodeProperty]
   let properties: [AnyNodeProperty]
-  
+
 }
 
-// MARK: - Node
+// MARK: - GradientStrokeNode
 
 final class GradientStrokeNode: AnimatorNode, RenderNode {
-  
-  let strokeRender: GradientStrokeRenderer
-  
-  var renderer: NodeOutput & Renderable {
-    return strokeRender
-  }
-  
-  let strokeProperties: GradientStrokeProperties
-  
+
+  // MARK: Lifecycle
+
   init(parentNode: AnimatorNode?, gradientStroke: GradientStroke) {
-    self.strokeRender = GradientStrokeRenderer(parent: parentNode?.outputNode)
-    self.strokeProperties = GradientStrokeProperties(gradientStroke: gradientStroke)
+    strokeRender = GradientStrokeRenderer(parent: parentNode?.outputNode)
+    strokeProperties = GradientStrokeProperties(gradientStroke: gradientStroke)
     self.parentNode = parentNode
   }
-  
+
+  // MARK: Internal
+
+  let strokeRender: GradientStrokeRenderer
+
+  let strokeProperties: GradientStrokeProperties
+
+  let parentNode: AnimatorNode?
+  var hasLocalUpdates = false
+  var hasUpstreamUpdates = false
+  var lastUpdateFrame: CGFloat? = nil
+
+  var renderer: NodeOutput & Renderable {
+    strokeRender
+  }
+
   // MARK: Animator Node Protocol
-  
+
   var propertyMap: NodePropertyMap & KeypathSearchable {
-    return strokeProperties
+    strokeProperties
   }
-  
-  let parentNode: AnimatorNode?
-  var hasLocalUpdates: Bool = false
-  var hasUpstreamUpdates: Bool = false
-  var lastUpdateFrame: CGFloat? = nil
-  var isEnabled: Bool = true {
+
+  var isEnabled = true {
     didSet {
       strokeRender.isEnabled = isEnabled
     }
   }
-  
+
   func localUpdatesPermeateDownstream() -> Bool {
-    return false
+    false
   }
-  
-  func rebuildOutputs(frame: CGFloat) {
+
+  func rebuildOutputs(frame _: CGFloat) {
     /// Update gradient properties
     strokeRender.gradientRender.start = strokeProperties.startPoint.value.pointValue
     strokeRender.gradientRender.end = strokeProperties.endPoint.value.pointValue
@@ -122,17 +130,17 @@ final class GradientStrokeNode: AnimatorNode, RenderNode {
     strokeRender.gradientRender.colors = strokeProperties.colors.value.map { CGFloat($0) }
     strokeRender.gradientRender.type = strokeProperties.gradientType
     strokeRender.gradientRender.numberOfColors = strokeProperties.numberOfColors
-    
+
     /// Now update stroke properties
     strokeRender.strokeRender.opacity = strokeProperties.opacity.value.cgFloatValue
     strokeRender.strokeRender.width = strokeProperties.width.value.cgFloatValue
     strokeRender.strokeRender.miterLimit = strokeProperties.miterLimit
     strokeRender.strokeRender.lineCap = strokeProperties.lineCap
     strokeRender.strokeRender.lineJoin = strokeProperties.lineJoin
-    
+
     /// Get dash lengths
     let dashLengths = strokeProperties.dashPattern.value.map { $0.cgFloatValue }
-    if dashLengths.count > 0 {
+    if dashLengths.count > 0, !dashLengths.allSatisfy({ $0.isZero }) {
       strokeRender.strokeRender.dashPhase = strokeProperties.dashPhase.value.cgFloatValue
       strokeRender.strokeRender.dashLengths = dashLengths
     } else {

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/StrokeNode.swift

@@ -0,0 +1,169 @@
+//
+//  StrokeNode.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/22/19.
+//
+
+import Foundation
+import QuartzCore
+
+// MARK: - StrokeNodeProperties
+
+final class StrokeNodeProperties: NodePropertyMap, KeypathSearchable {
+
+  // MARK: Lifecycle
+
+  init(stroke: Stroke) {
+    keypathName = stroke.name
+    color = NodeProperty(provider: KeyframeInterpolator(keyframes: stroke.color.keyframes))
+    opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: stroke.opacity.keyframes))
+    width = NodeProperty(provider: KeyframeInterpolator(keyframes: stroke.width.keyframes))
+    miterLimit = CGFloat(stroke.miterLimit)
+    lineCap = stroke.lineCap
+    lineJoin = stroke.lineJoin
+
+    if let dashes = stroke.dashPattern {
+      let (dashPatterns, dashPhase) = dashes.shapeLayerConfiguration
+      dashPattern = NodeProperty(provider: GroupInterpolator(keyframeGroups: dashPatterns))
+      if dashPhase.count == 0 {
+        self.dashPhase = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+      } else {
+        self.dashPhase = NodeProperty(provider: KeyframeInterpolator(keyframes: dashPhase))
+      }
+    } else {
+      dashPattern = NodeProperty(provider: SingleValueProvider([Vector1D]()))
+      dashPhase = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+    }
+    keypathProperties = [
+      "Opacity" : opacity,
+      PropertyName.color.rawValue : color,
+      "Stroke Width" : width,
+      "Dashes" : dashPattern,
+      "Dash Phase" : dashPhase,
+    ]
+    properties = Array(keypathProperties.values)
+  }
+
+  // MARK: Internal
+
+  let keypathName: String
+  let keypathProperties: [String: AnyNodeProperty]
+  let properties: [AnyNodeProperty]
+
+  let opacity: NodeProperty<Vector1D>
+  let color: NodeProperty<Color>
+  let width: NodeProperty<Vector1D>
+
+  let dashPattern: NodeProperty<[Vector1D]>
+  let dashPhase: NodeProperty<Vector1D>
+
+  let lineCap: LineCap
+  let lineJoin: LineJoin
+  let miterLimit: CGFloat
+
+}
+
+// MARK: - StrokeNode
+
+/// Node that manages stroking a path
+final class StrokeNode: AnimatorNode, RenderNode {
+
+  // MARK: Lifecycle
+
+  init(parentNode: AnimatorNode?, stroke: Stroke) {
+    strokeRender = StrokeRenderer(parent: parentNode?.outputNode)
+    strokeProperties = StrokeNodeProperties(stroke: stroke)
+    self.parentNode = parentNode
+  }
+
+  // MARK: Internal
+
+  let strokeRender: StrokeRenderer
+
+  let strokeProperties: StrokeNodeProperties
+
+  let parentNode: AnimatorNode?
+  var hasLocalUpdates = false
+  var hasUpstreamUpdates = false
+  var lastUpdateFrame: CGFloat? = nil
+
+  var renderer: NodeOutput & Renderable {
+    strokeRender
+  }
+
+  // MARK: Animator Node Protocol
+
+  var propertyMap: NodePropertyMap & KeypathSearchable {
+    strokeProperties
+  }
+
+  var isEnabled = true {
+    didSet {
+      strokeRender.isEnabled = isEnabled
+    }
+  }
+
+  func localUpdatesPermeateDownstream() -> Bool {
+    false
+  }
+
+  func rebuildOutputs(frame _: CGFloat) {
+    strokeRender.color = strokeProperties.color.value.cgColorValue
+    strokeRender.opacity = strokeProperties.opacity.value.cgFloatValue * 0.01
+    strokeRender.width = strokeProperties.width.value.cgFloatValue
+    strokeRender.miterLimit = strokeProperties.miterLimit
+    strokeRender.lineCap = strokeProperties.lineCap
+    strokeRender.lineJoin = strokeProperties.lineJoin
+
+    /// Get dash lengths
+    let dashLengths = strokeProperties.dashPattern.value.map { $0.cgFloatValue }
+    if dashLengths.count > 0, !dashLengths.allSatisfy({ $0.isZero }) {
+      strokeRender.dashPhase = strokeProperties.dashPhase.value.cgFloatValue
+      strokeRender.dashLengths = dashLengths
+    } else {
+      strokeRender.dashLengths = nil
+      strokeRender.dashPhase = nil
+    }
+  }
+
+}
+
+// MARK: - [DashElement] + shapeLayerConfiguration
+
+extension Array where Element == DashElement {
+  typealias ShapeLayerConfiguration = (
+    dashPatterns: ContiguousArray<ContiguousArray<Keyframe<Vector1D>>>,
+    dashPhase: ContiguousArray<Keyframe<Vector1D>>)
+
+  /// Converts the `[DashElement]` data model into `lineDashPattern` and `lineDashPhase`
+  /// representations usable in a `CAShapeLayer`
+  var shapeLayerConfiguration: ShapeLayerConfiguration {
+    var dashPatterns = ContiguousArray<ContiguousArray<Keyframe<Vector1D>>>()
+    var dashPhase = ContiguousArray<Keyframe<Vector1D>>()
+    for dash in self {
+      if dash.type == .offset {
+        dashPhase = dash.value.keyframes
+      } else {
+        dashPatterns.append(dash.value.keyframes)
+      }
+    }
+
+    dashPatterns = ContiguousArray(dashPatterns.map { pattern in
+      ContiguousArray(pattern.map { keyframe -> Keyframe<Vector1D> in
+        // The recommended way to create a stroke of round dots, in theory,
+        // is to use a value of 0 followed by the stroke width, but for
+        // some reason Core Animation incorrectly (?) renders these as pills
+        // instead of circles. As a workaround, for parity with Lottie on other
+        // platforms, we can change `0`s to `0.01`: https://stackoverflow.com/a/38036486
+        if keyframe.value.cgFloatValue == 0 {
+          return keyframe.withValue(Vector1D(0.01))
+        } else {
+          return keyframe
+        }
+      })
+    })
+
+    return (dashPatterns, dashPhase)
+  }
+}