@octane-xplat/lottie 0.9.0 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/PathNodes/StarNode.swift

@@ -0,0 +1,224 @@
+//
+//  StarNode.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/21/19.
+//
+
+import Foundation
+import QuartzCore
+
+// MARK: - StarNodeProperties
+
+final class StarNodeProperties: NodePropertyMap, KeypathSearchable {
+
+  // MARK: Lifecycle
+
+  init(star: Star) {
+    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 {
+      innerRadius = NodeProperty(provider: KeyframeInterpolator(keyframes: innerRadiusKeyframes))
+    } else {
+      innerRadius = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
+    }
+    if let innderRoundedness = star.innerRoundness?.keyframes {
+      innerRoundedness = NodeProperty(provider: KeyframeInterpolator(keyframes: innderRoundedness))
+    } else {
+      innerRoundedness = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
+    }
+    rotation = NodeProperty(provider: KeyframeInterpolator(keyframes: star.rotation.keyframes))
+    points = NodeProperty(provider: KeyframeInterpolator(keyframes: star.points.keyframes))
+    keypathProperties = [
+      PropertyName.position.rawValue: position,
+      "Outer Radius": outerRadius,
+      "Outer Roundedness": outerRoundedness,
+      "Inner Radius": innerRadius,
+      "Inner Roundedness": innerRoundedness,
+      PropertyName.rotation.rawValue: rotation,
+      "Points": points,
+    ]
+    properties = Array(keypathProperties.values)
+  }
+
+  // MARK: Internal
+
+  var keypathName: String
+
+  let keypathProperties: [String: AnyNodeProperty]
+  let properties: [AnyNodeProperty]
+
+  let direction: PathDirection
+  let position: NodeProperty<LottieVector3D>
+  let outerRadius: NodeProperty<LottieVector1D>
+  let outerRoundedness: NodeProperty<LottieVector1D>
+  let innerRadius: NodeProperty<LottieVector1D>
+  let innerRoundedness: NodeProperty<LottieVector1D>
+  let rotation: NodeProperty<LottieVector1D>
+  let points: NodeProperty<LottieVector1D>
+}
+
+// MARK: - StarNode
+
+final class StarNode: AnimatorNode, PathNode {
+
+  // MARK: Lifecycle
+
+  init(parentNode: AnimatorNode?, 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
+
+  var propertyMap: NodePropertyMap & KeypathSearchable {
+    properties
+  }
+
+  var isEnabled = true {
+    didSet {
+      pathOutput.isEnabled = isEnabled
+    }
+  }
+
+  func rebuildOutputs(frame: CGFloat) {
+    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)
+      partialPointRadius = innerRadius + partialPointAmount * (outerRadius - innerRadius)
+      point.x = (partialPointRadius * cos(currentAngle))
+      point.y = (partialPointRadius * sin(currentAngle))
+      currentAngle += anglePerPoint * partialPointAmount / 2
+    } else {
+      point.x = (outerRadius * cos(currentAngle))
+      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(ceil(numberOfPoints) * 2)
+    for i in 0..<numPoints {
+      var radius = longSegment ? outerRadius : innerRadius
+      var dTheta = halfAnglePerPoint
+      if partialPointRadius != 0, i == numPoints - 2 {
+        dTheta = anglePerPoint * partialPointAmount / 2
+      }
+      if partialPointRadius != 0, i == numPoints - 1 {
+        radius = partialPointRadius
+      }
+      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
+        )
+        if partialPointAmount != 0 {
+          if i == 0 {
+            cp1 = cp1 * partialPointAmount
+          } else if i == numPoints - 1 {
+            cp2 = cp2 * partialPointAmount
+          }
+        }
+        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 = direction == .counterClockwise
+    if reverse {
+      vertices = vertices.reversed()
+    }
+    var path = BezierPath()
+    for vertex in vertices {
+      path.addVertex(reverse ? vertex.reversed() : vertex)
+    }
+    path.close()
+    return path
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/RenderContainers/GroupNode.swift

@@ -0,0 +1,162 @@
+//
+//  GroupNode.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/18/19.
+//
+
+import QuartzCore
+
+// MARK: - GroupNodeProperties
+
+final class GroupNodeProperties: NodePropertyMap, KeypathSearchable {
+
+  // MARK: Lifecycle
+
+  init(transform: ShapeTransform?) {
+    if let 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))
+      rotationX = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.rotationX.keyframes))
+      rotationY = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.rotationY.keyframes))
+      rotationZ = NodeProperty(provider: KeyframeInterpolator(keyframes: transform.rotationZ.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(LottieVector3D(x: CGFloat(0), y: CGFloat(0), z: CGFloat(0))))
+      position = NodeProperty(provider: SingleValueProvider(LottieVector3D(x: CGFloat(0), y: CGFloat(0), z: CGFloat(0))))
+      scale = NodeProperty(provider: SingleValueProvider(LottieVector3D(x: CGFloat(100), y: CGFloat(100), z: CGFloat(100))))
+      rotationX = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
+      rotationY = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
+      rotationZ = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
+      opacity = NodeProperty(provider: SingleValueProvider(LottieVector1D(100)))
+      skew = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
+      skewAxis = NodeProperty(provider: SingleValueProvider(LottieVector1D(0)))
+    }
+    keypathProperties = [
+      "Anchor Point": anchor,
+      PropertyName.position.rawValue: position,
+      PropertyName.scale.rawValue: scale,
+      PropertyName.rotation.rawValue: rotationZ,
+      "Rotation X": rotationX,
+      "Rotation Y": rotationY,
+      "Rotation Z": rotationZ,
+      PropertyName.opacity.rawValue: 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<LottieVector3D>
+  let position: NodeProperty<LottieVector3D>
+  let scale: NodeProperty<LottieVector3D>
+  let rotationX: NodeProperty<LottieVector1D>
+  let rotationY: NodeProperty<LottieVector1D>
+  let rotationZ: NodeProperty<LottieVector1D>
+
+  let opacity: NodeProperty<LottieVector1D>
+  let skew: NodeProperty<LottieVector1D>
+  let skewAxis: NodeProperty<LottieVector1D>
+
+  var caTransform: CATransform3D {
+    CATransform3D.makeTransform(
+      anchor: anchor.value.pointValue,
+      position: position.value.pointValue,
+      scale: scale.value.sizeValue,
+      rotationX: rotationX.value.cgFloatValue,
+      rotationY: rotationY.value.cgFloatValue,
+      rotationZ: rotationZ.value.cgFloatValue,
+      skew: skew.value.cgFloatValue,
+      skewAxis: skewAxis.value.cgFloatValue
+    )
+  }
+}
+
+// MARK: - GroupNode
+
+final class GroupNode: AnimatorNode {
+
+  // MARK: Lifecycle
+
+  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)
+    // Use direct downcasting from `AnimatorNode` to `KeypathSearchable`
+    // to avoid calling `_arrayForceCast` for performance reasons
+    var childKeypaths: [KeypathSearchable] = tree.childrenNodes.map { $0 as KeypathSearchable }
+    childKeypaths.append(properties)
+    self.childKeypaths = childKeypaths
+
+    for childContainer in tree.renderContainers {
+      container.insertRenderLayer(childContainer)
+    }
+  }
+
+  // MARK: Internal
+
+  let groupOutput: GroupOutputNode
+
+  let properties: GroupNodeProperties
+
+  let rootNode: AnimatorNode?
+
+  var container = ShapeContainerLayer()
+
+  let keypathName: String
+
+  let childKeypaths: [KeypathSearchable]
+
+  let parentNode: AnimatorNode?
+  var hasLocalUpdates = false
+  var hasUpstreamUpdates = false
+  var lastUpdateFrame: CGFloat? = nil
+
+  var keypathLayer: CALayer? {
+    container
+  }
+
+  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/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/FillNode.swift

@@ -0,0 +1,88 @@
+//
+//  FillNode.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/17/19.
+//
+
+import CoreGraphics
+import Foundation
+
+// MARK: - FillNodeProperties
+
+final class FillNodeProperties: NodePropertyMap, KeypathSearchable {
+
+  // MARK: Lifecycle
+
+  init(fill: Fill) {
+    keypathName = fill.name
+    color = NodeProperty(provider: KeyframeInterpolator(keyframes: fill.color.keyframes))
+    opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: fill.opacity.keyframes))
+    type = fill.fillRule
+    keypathProperties = [
+      PropertyName.opacity.rawValue: opacity,
+      PropertyName.color.rawValue: color,
+    ]
+    properties = Array(keypathProperties.values)
+  }
+
+  // MARK: Internal
+
+  var keypathName: String
+
+  let opacity: NodeProperty<LottieVector1D>
+  let color: NodeProperty<LottieColor>
+  let type: FillRule
+
+  let keypathProperties: [String: AnyNodeProperty]
+  let properties: [AnyNodeProperty]
+
+}
+
+// MARK: - FillNode
+
+final class FillNode: AnimatorNode, RenderNode {
+
+  // MARK: Lifecycle
+
+  init(parentNode: AnimatorNode?, 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
+  }
+
+  var propertyMap: NodePropertyMap & KeypathSearchable {
+    fillProperties
+  }
+
+  var isEnabled = true {
+    didSet {
+      fillRender.isEnabled = isEnabled
+    }
+  }
+
+  func localUpdatesPermeateDownstream() -> Bool {
+    false
+  }
+
+  func rebuildOutputs(frame _: CGFloat) {
+    fillRender.color = fillProperties.color.value.cgColorValue
+    fillRender.opacity = fillProperties.opacity.value.cgFloatValue * 0.01
+    fillRender.fillRule = fillProperties.type
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/RenderNodes/GradientFillNode.swift

@@ -0,0 +1,103 @@
+//
+//  GradientFillNode.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/22/19.
+//
+
+import Foundation
+import QuartzCore
+
+// MARK: - GradientFillProperties
+
+final class GradientFillProperties: NodePropertyMap, KeypathSearchable {
+
+  // MARK: Lifecycle
+
+  init(gradientfill: GradientFill) {
+    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 = [
+      PropertyName.opacity.rawValue: opacity,
+      "Start Point": startPoint,
+      "End Point": endPoint,
+      PropertyName.gradientColors.rawValue: colors,
+    ]
+    properties = Array(keypathProperties.values)
+  }
+
+  // MARK: Internal
+
+  var keypathName: String
+
+  let opacity: NodeProperty<LottieVector1D>
+  let startPoint: NodeProperty<LottieVector3D>
+  let endPoint: NodeProperty<LottieVector3D>
+  let colors: NodeProperty<[Double]>
+
+  let gradientType: GradientType
+  let numberOfColors: Int
+  let fillRule: FillRule
+
+  let keypathProperties: [String: AnyNodeProperty]
+  let properties: [AnyNodeProperty]
+
+}
+
+// MARK: - GradientFillNode
+
+final class GradientFillNode: AnimatorNode, RenderNode {
+
+  // MARK: Lifecycle
+
+  init(parentNode: AnimatorNode?, 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
+  }
+
+  var propertyMap: NodePropertyMap & KeypathSearchable {
+    fillProperties
+  }
+
+  var isEnabled = true {
+    didSet {
+      fillRender.isEnabled = isEnabled
+    }
+  }
+
+  func localUpdatesPermeateDownstream() -> Bool {
+    false
+  }
+
+  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
+  }
+}