lottie-ios 3.2.2 → 3.4.1

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,14 +130,14 @@ 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 {

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

@@ -7,112 +7,115 @@
 
 import Foundation
 import QuartzCore
-// MARK: - Properties
+
+// MARK: - StrokeNodeProperties
 
 final class StrokeNodeProperties: NodePropertyMap, KeypathSearchable {
-  
+
+  // MARK: Lifecycle
+
   init(stroke: Stroke) {
-    self.keypathName = stroke.name
-    self.color = NodeProperty(provider: KeyframeInterpolator(keyframes: stroke.color.keyframes))
-    self.opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: stroke.opacity.keyframes))
-    self.width = NodeProperty(provider: KeyframeInterpolator(keyframes: stroke.width.keyframes))
-    self.miterLimit = CGFloat(stroke.miterLimit)
-    self.lineCap = stroke.lineCap
-    self.lineJoin = stroke.lineJoin
-    
+    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 {
-      var dashPatterns = ContiguousArray<ContiguousArray<Keyframe<Vector1D>>>()
-      var dashPhase = ContiguousArray<Keyframe<Vector1D>>()
-      for dash in dashes {
-        if dash.type == .offset {
-          dashPhase = dash.value.keyframes
-        } else {
-          dashPatterns.append(dash.value.keyframes)
-        }
-      }
-      self.dashPattern = NodeProperty(provider: GroupInterpolator(keyframeGroups: dashPatterns))
+      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 {
-      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,
-      "Color" : color,
+      PropertyName.color.rawValue : color,
       "Stroke Width" : width,
       "Dashes" : dashPattern,
-      "Dash Phase" : dashPhase
+      "Dash Phase" : dashPhase,
     ]
-    self.properties = Array(keypathProperties.values)
+    properties = Array(keypathProperties.values)
   }
-  
+
+  // MARK: Internal
+
   let keypathName: String
-  let keypathProperties: [String : AnyNodeProperty]
+  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: - Node
+// MARK: - StrokeNode
 
 /// Node that manages stroking a path
 final class StrokeNode: AnimatorNode, RenderNode {
-  
-  let strokeRender: StrokeRenderer
-  var renderer: NodeOutput & Renderable {
-    return strokeRender
-  }
-  
-  let strokeProperties: StrokeNodeProperties
-  
+
+  // MARK: Lifecycle
+
   init(parentNode: AnimatorNode?, stroke: Stroke) {
-    self.strokeRender = StrokeRenderer(parent: parentNode?.outputNode)
-    self.strokeProperties = StrokeNodeProperties(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 {
-    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) {
     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 {
@@ -123,5 +126,28 @@ final class StrokeNode: AnimatorNode, RenderNode {
       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)
+      }
+    }
+    return (dashPatterns, dashPhase)
+  }
 }