lottie-ios 3.2.0 → 3.4.0

package/{lottie-swift/src/Private → Sources/Private/MainThread}/NodeRenderSystem/Nodes/PathNodes/StarNode.swift

@@ -8,43 +8,49 @@
 import Foundation
 import QuartzCore
 
+// MARK: - StarNodeProperties
+
 final class StarNodeProperties: NodePropertyMap, KeypathSearchable {
-  
-  var keypathName: String
-  
+
+  // MARK: Lifecycle
+
   init(star: Star) {
-    self.keypathName = star.name
-    self.direction = star.direction
-    self.position = NodeProperty(provider: KeyframeInterpolator(keyframes: star.position.keyframes))
-    self.outerRadius = NodeProperty(provider: KeyframeInterpolator(keyframes: star.outerRadius.keyframes))
-    self.outerRoundedness = NodeProperty(provider: KeyframeInterpolator(keyframes: star.outerRoundness.keyframes))
+    keypathName = star.name
+    direction = star.direction
+    position = NodeProperty(provider: KeyframeInterpolator(keyframes: star.position.keyframes))
+    outerRadius = NodeProperty(provider: KeyframeInterpolator(keyframes: star.outerRadius.keyframes))
+    outerRoundedness = NodeProperty(provider: KeyframeInterpolator(keyframes: star.outerRoundness.keyframes))
     if let innerRadiusKeyframes = star.innerRadius?.keyframes {
-      self.innerRadius = NodeProperty(provider: KeyframeInterpolator(keyframes: innerRadiusKeyframes))
+      innerRadius = NodeProperty(provider: KeyframeInterpolator(keyframes: innerRadiusKeyframes))
     } else {
-      self.innerRadius = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+      innerRadius = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
     }
     if let innderRoundedness = star.innerRoundness?.keyframes {
-      self.innerRoundedness = NodeProperty(provider: KeyframeInterpolator(keyframes: innderRoundedness))
+      innerRoundedness = NodeProperty(provider: KeyframeInterpolator(keyframes: innderRoundedness))
     } else {
-      self.innerRoundedness = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+      innerRoundedness = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
     }
-    self.rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: star.rotation.keyframes))
-    self.points = NodeProperty(provider: KeyframeInterpolator(keyframes: star.points.keyframes))
-    self.keypathProperties = [
+    rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: star.rotation.keyframes))
+    points = NodeProperty(provider: KeyframeInterpolator(keyframes: star.points.keyframes))
+    keypathProperties = [
       "Position" : position,
       "Outer Radius" : outerRadius,
       "Outer Roundedness" : outerRoundedness,
       "Inner Radius" : innerRadius,
       "Inner Roundedness" : innerRoundedness,
       "Rotation" : rotation,
-      "Points" : points
+      "Points" : points,
     ]
-    self.properties = Array(keypathProperties.values)
+    properties = Array(keypathProperties.values)
   }
-  
-  let keypathProperties: [String : AnyNodeProperty]
+
+  // MARK: Internal
+
+  var keypathName: String
+
+  let keypathProperties: [String: AnyNodeProperty]
   let properties: [AnyNodeProperty]
-  
+
   let direction: PathDirection
   let position: NodeProperty<Vector3D>
   let outerRadius: NodeProperty<Vector1D>
@@ -55,52 +61,81 @@ final class StarNodeProperties: NodePropertyMap, KeypathSearchable {
   let points: NodeProperty<Vector1D>
 }
 
+// MARK: - StarNode
+
 final class StarNode: AnimatorNode, PathNode {
-  
-  let properties: StarNodeProperties
 
-  let pathOutput: PathOutputNode
+  // MARK: Lifecycle
 
   init(parentNode: AnimatorNode?, star: Star) {
-    self.pathOutput = PathOutputNode(parent: parentNode?.outputNode)
-    self.properties = StarNodeProperties(star: star)
+    pathOutput = PathOutputNode(parent: parentNode?.outputNode)
+    properties = StarNodeProperties(star: star)
     self.parentNode = parentNode
   }
-  
+
+  // MARK: Internal
+
+  /// Magic number needed for building path data
+  static let PolystarConstant: CGFloat = 0.47829
+
+  let properties: StarNodeProperties
+
+  let pathOutput: PathOutputNode
+
+  let parentNode: AnimatorNode?
+  var hasLocalUpdates = false
+  var hasUpstreamUpdates = false
+  var lastUpdateFrame: CGFloat? = nil
+
   // MARK: Animator Node
   var propertyMap: NodePropertyMap & KeypathSearchable {
-    return properties
+    properties
   }
-  
-  let parentNode: AnimatorNode?
-  var hasLocalUpdates: Bool = false
-  var hasUpstreamUpdates: Bool = false
-  var lastUpdateFrame: CGFloat? = nil
-  var isEnabled: Bool = true {
-    didSet{
-      self.pathOutput.isEnabled = self.isEnabled
+
+  var isEnabled = true {
+    didSet {
+      pathOutput.isEnabled = isEnabled
     }
   }
-  
-  /// Magic number needed for building path data
-  static let PolystarConstant: CGFloat = 0.47829
-  
+
   func rebuildOutputs(frame: CGFloat) {
-    let outerRadius = properties.outerRadius.value.cgFloatValue
-    let innerRadius = properties.innerRadius.value.cgFloatValue
-    let outerRoundedness = properties.outerRoundedness.value.cgFloatValue * 0.01
-    let innerRoundedness = properties.innerRoundedness.value.cgFloatValue * 0.01
-    let numberOfPoints = properties.points.value.cgFloatValue
-    let rotation = properties.rotation.value.cgFloatValue
-    let position = properties.position.value.pointValue
-    
+    let path = BezierPath.star(
+      position: properties.position.value.pointValue,
+      outerRadius: properties.outerRadius.value.cgFloatValue,
+      innerRadius: properties.innerRadius.value.cgFloatValue,
+      outerRoundedness: properties.outerRoundedness.value.cgFloatValue,
+      innerRoundedness: properties.innerRoundedness.value.cgFloatValue,
+      numberOfPoints: properties.points.value.cgFloatValue,
+      rotation: properties.rotation.value.cgFloatValue,
+      direction: properties.direction)
+
+    pathOutput.setPath(path, updateFrame: frame)
+  }
+
+}
+
+extension BezierPath {
+  /// Constructs a `BezierPath` in the shape of a star
+  static func star(
+    position: CGPoint,
+    outerRadius: CGFloat,
+    innerRadius: CGFloat,
+    outerRoundedness inoutOuterRoundedness: CGFloat,
+    innerRoundedness inputInnerRoundedness: CGFloat,
+    numberOfPoints: CGFloat,
+    rotation: CGFloat,
+    direction: PathDirection)
+    -> BezierPath
+  {
     var currentAngle = (rotation - 90).toRadians()
     let anglePerPoint = (2 * CGFloat.pi) / numberOfPoints
     let halfAnglePerPoint = anglePerPoint / 2.0
     let partialPointAmount = numberOfPoints - floor(numberOfPoints)
-    
+    let outerRoundedness = inoutOuterRoundedness * 0.01
+    let innerRoundedness = inputInnerRoundedness * 0.01
+
     var point: CGPoint = .zero
-    
+
     var partialPointRadius: CGFloat = 0
     if partialPointAmount != 0 {
       currentAngle += halfAnglePerPoint * (1 - partialPointAmount)
@@ -113,13 +148,13 @@ final class StarNode: AnimatorNode, PathNode {
       point.y = (outerRadius * sin(currentAngle))
       currentAngle += halfAnglePerPoint
     }
-    
+
     var vertices = [CurveVertex]()
     vertices.append(CurveVertex(point: point + position, inTangentRelative: .zero, outTangentRelative: .zero))
-    
+
     var previousPoint = point
     var longSegment = false
-    let numPoints: Int = Int(ceil(numberOfPoints) * 2)
+    let numPoints = Int(ceil(numberOfPoints) * 2)
     for i in 0..<numPoints {
       var radius = longSegment ? outerRadius : innerRadius
       var dTheta = halfAnglePerPoint
@@ -132,27 +167,29 @@ final class StarNode: AnimatorNode, PathNode {
       previousPoint = point
       point.x = (radius * cos(currentAngle))
       point.y = (radius * sin(currentAngle))
-      
+
       if innerRoundedness == 0 && outerRoundedness == 0 {
         vertices.append(CurveVertex(point: point + position, inTangentRelative: .zero, outTangentRelative: .zero))
       } else {
         let cp1Theta = (atan2(previousPoint.y, previousPoint.x) - CGFloat.pi / 2)
         let cp1Dx = cos(cp1Theta)
         let cp1Dy = sin(cp1Theta)
-        
+
         let cp2Theta = (atan2(point.y, point.x) - CGFloat.pi / 2)
         let cp2Dx = cos(cp2Theta)
         let cp2Dy = sin(cp2Theta)
-        
+
         let cp1Roundedness = longSegment ? innerRoundedness : outerRoundedness
         let cp2Roundedness = longSegment ? outerRoundedness : innerRoundedness
         let cp1Radius = longSegment ? innerRadius : outerRadius
         let cp2Radius = longSegment ? outerRadius : innerRadius
-        
-        var cp1 = CGPoint(x: cp1Radius * cp1Roundedness * StarNode.PolystarConstant * cp1Dx,
-                          y: cp1Radius * cp1Roundedness * StarNode.PolystarConstant * cp1Dy)
-        var cp2 = CGPoint(x: cp2Radius * cp2Roundedness * StarNode.PolystarConstant * cp2Dx,
-                          y: cp2Radius * cp2Roundedness * StarNode.PolystarConstant * cp2Dy)
+
+        var cp1 = CGPoint(
+          x: cp1Radius * cp1Roundedness * StarNode.PolystarConstant * cp1Dx,
+          y: cp1Radius * cp1Roundedness * StarNode.PolystarConstant * cp1Dy)
+        var cp2 = CGPoint(
+          x: cp2Radius * cp2Roundedness * StarNode.PolystarConstant * cp2Dx,
+          y: cp2Radius * cp2Roundedness * StarNode.PolystarConstant * cp2Dy)
         if partialPointAmount != 0 {
           if i == 0 {
             cp1 = cp1 * partialPointAmount
@@ -160,15 +197,18 @@ final class StarNode: AnimatorNode, PathNode {
             cp2 = cp2 * partialPointAmount
           }
         }
-        let previousVertex = vertices[vertices.endIndex-1]
-        vertices[vertices.endIndex-1] = CurveVertex(previousVertex.inTangent, previousVertex.point, previousVertex.point - cp1 + position)
+        let previousVertex = vertices[vertices.endIndex - 1]
+        vertices[vertices.endIndex - 1] = CurveVertex(
+          previousVertex.inTangent,
+          previousVertex.point,
+          previousVertex.point - cp1)
         vertices.append(CurveVertex(point: point + position, inTangentRelative: cp2, outTangentRelative: .zero))
       }
       currentAngle += dTheta
       longSegment = !longSegment
     }
-    
-    let reverse = properties.direction == .counterClockwise
+
+    let reverse = direction == .counterClockwise
     if reverse {
       vertices = vertices.reversed()
     }
@@ -177,7 +217,6 @@ final class StarNode: AnimatorNode, PathNode {
       path.addVertex(reverse ? vertex.reversed() : vertex)
     }
     path.close()
-    pathOutput.setPath(path, updateFrame: frame)
+    return path
   }
-  
 }

package/Sources/Private/MainThread/NodeRenderSystem/Nodes/RenderContainers/GroupNode.swift

@@ -0,0 +1,155 @@
+//
+//  GroupNode.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/18/19.
+//
+
+import CoreGraphics
+import Foundation
+import QuartzCore
+
+// MARK: - GroupNodeProperties
+
+final class GroupNodeProperties: NodePropertyMap, KeypathSearchable {
+
+  // MARK: Lifecycle
+
+  init(transform: ShapeTransform?) {
+    if let transform = transform {
+      anchor = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.anchor.keyframes))
+      position = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.position.keyframes))
+      scale = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.scale.keyframes))
+      rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.rotation.keyframes))
+      opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.opacity.keyframes))
+      skew = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.skew.keyframes))
+      skewAxis = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.skewAxis.keyframes))
+    } else {
+      /// Transform node missing. Default to empty transform.
+      anchor = NodeProperty(provider: SingleValueProvider(Vector3D(x: CGFloat(0), y: CGFloat(0), z: CGFloat(0))))
+      position = NodeProperty(provider: SingleValueProvider(Vector3D(x: CGFloat(0), y: CGFloat(0), z: CGFloat(0))))
+      scale = NodeProperty(provider: SingleValueProvider(Vector3D(x: CGFloat(100), y: CGFloat(100), z: CGFloat(100))))
+      rotation = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+      opacity = NodeProperty(provider: SingleValueProvider(Vector1D(100)))
+      skew = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+      skewAxis = NodeProperty(provider: SingleValueProvider(Vector1D(0)))
+    }
+    keypathProperties = [
+      "Anchor Point" : anchor,
+      "Position" : position,
+      "Scale" : scale,
+      "Rotation" : rotation,
+      "Opacity" : opacity,
+      "Skew" : skew,
+      "Skew Axis" : skewAxis,
+    ]
+    properties = Array(keypathProperties.values)
+  }
+
+  // MARK: Internal
+
+  var keypathName = "Transform"
+
+  var childKeypaths: [KeypathSearchable] = []
+
+  let keypathProperties: [String: AnyNodeProperty]
+  let properties: [AnyNodeProperty]
+
+  let anchor: NodeProperty<Vector3D>
+  let position: NodeProperty<Vector3D>
+  let scale: NodeProperty<Vector3D>
+  let rotation: NodeProperty<Vector1D>
+  let opacity: NodeProperty<Vector1D>
+  let skew: NodeProperty<Vector1D>
+  let skewAxis: NodeProperty<Vector1D>
+
+  var caTransform: CATransform3D {
+    CATransform3D.makeTransform(
+      anchor: anchor.value.pointValue,
+      position: position.value.pointValue,
+      scale: scale.value.sizeValue,
+      rotation: rotation.value.cgFloatValue,
+      skew: skew.value.cgFloatValue,
+      skewAxis: skewAxis.value.cgFloatValue)
+  }
+}
+
+// MARK: - GroupNode
+
+final class GroupNode: AnimatorNode {
+
+  // MARK: Lifecycle
+
+  // MARK: Initializer
+  init(name: String, parentNode: AnimatorNode?, tree: NodeTree) {
+    self.parentNode = parentNode
+    keypathName = name
+    rootNode = tree.rootNode
+    properties = GroupNodeProperties(transform: tree.transform)
+    groupOutput = GroupOutputNode(parent: parentNode?.outputNode, rootNode: rootNode?.outputNode)
+    var childKeypaths: [KeypathSearchable] = tree.childrenNodes
+    childKeypaths.append(properties)
+    self.childKeypaths = childKeypaths
+
+    for childContainer in tree.renderContainers {
+      container.insertRenderLayer(childContainer)
+    }
+  }
+
+  // MARK: Internal
+
+  // MARK: Properties
+  let groupOutput: GroupOutputNode
+
+  let properties: GroupNodeProperties
+
+  let rootNode: AnimatorNode?
+
+  var container = ShapeContainerLayer()
+
+  // MARK: Keypath Searchable
+
+  let keypathName: String
+
+  let childKeypaths: [KeypathSearchable]
+
+  let parentNode: AnimatorNode?
+  var hasLocalUpdates = false
+  var hasUpstreamUpdates = false
+  var lastUpdateFrame: CGFloat? = nil
+
+  var keypathLayer: CALayer? {
+    container
+  }
+
+  // MARK: Animator Node Protocol
+
+  var propertyMap: NodePropertyMap & KeypathSearchable {
+    properties
+  }
+
+  var outputNode: NodeOutput {
+    groupOutput
+  }
+
+  var isEnabled = true {
+    didSet {
+      container.isHidden = !isEnabled
+    }
+  }
+
+  func performAdditionalLocalUpdates(frame: CGFloat, forceLocalUpdate: Bool) -> Bool {
+    rootNode?.updateContents(frame, forceLocalUpdate: forceLocalUpdate) ?? false
+  }
+
+  func performAdditionalOutputUpdates(_ frame: CGFloat, forceOutputUpdate: Bool) {
+    rootNode?.updateOutputs(frame, forceOutputUpdate: forceOutputUpdate)
+  }
+
+  func rebuildOutputs(frame: CGFloat) {
+    container.opacity = Float(properties.opacity.value.cgFloatValue) * 0.01
+    container.transform = properties.caTransform
+    groupOutput.setTransform(container.transform, forFrame: frame)
+  }
+
+}

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

@@ -5,70 +5,84 @@
 //  Created by Brandon Withrow on 1/17/19.
 //
 
-import Foundation
 import CoreGraphics
+import Foundation
+
+// MARK: - FillNodeProperties
 
 final class FillNodeProperties: NodePropertyMap, KeypathSearchable {
-  
-  var keypathName: String
-  
+
+  // MARK: Lifecycle
+
   init(fill: Fill) {
-    self.keypathName = fill.name
-    self.color = NodeProperty(provider: KeyframeInterpolator(keyframes: fill.color.keyframes))
-    self.opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: fill.opacity.keyframes))
-    self.type = fill.fillRule
-    self.keypathProperties = [
+    keypathName = fill.name
+    color = NodeProperty(provider: KeyframeInterpolator(keyframes: fill.color.keyframes))
+    opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: fill.opacity.keyframes))
+    type = fill.fillRule
+    keypathProperties = [
       "Opacity" : opacity,
-      "Color" : color
+      PropertyName.color.rawValue : color,
     ]
-    self.properties = Array(keypathProperties.values)
+    properties = Array(keypathProperties.values)
   }
-  
+
+  // MARK: Internal
+
+  var keypathName: String
+
   let opacity: NodeProperty<Vector1D>
   let color: NodeProperty<Color>
   let type: FillRule
-  
-  let keypathProperties: [String : AnyNodeProperty]
+
+  let keypathProperties: [String: AnyNodeProperty]
   let properties: [AnyNodeProperty]
-  
+
 }
 
+// MARK: - FillNode
+
 final class FillNode: AnimatorNode, RenderNode {
-  
-  let fillRender: FillRenderer
-  var renderer: NodeOutput & Renderable {
-    return fillRender
-  }
-  
-  let fillProperties: FillNodeProperties
+
+  // MARK: Lifecycle
 
   init(parentNode: AnimatorNode?, fill: Fill) {
-    self.fillRender = FillRenderer(parent: parentNode?.outputNode)
-    self.fillProperties = FillNodeProperties(fill: fill)
+    fillRender = FillRenderer(parent: parentNode?.outputNode)
+    fillProperties = FillNodeProperties(fill: fill)
     self.parentNode = parentNode
   }
-  
+
+  // MARK: Internal
+
+  let fillRender: FillRenderer
+
+  let fillProperties: FillNodeProperties
+
+  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.color = fillProperties.color.value.cgColorValue
     fillRender.opacity = fillProperties.opacity.value.cgFloatValue * 0.01
     fillRender.fillRule = fillProperties.type

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

@@ -8,78 +8,90 @@
 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
+    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 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