@octane-xplat/lottie 0.0.1 → 0.10.0

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/LayerEffectNodes/DropShadowNode.swift

@@ -0,0 +1,102 @@
+// Created by Lan Xu on 2024/6/7.
+// Copyright © 2024 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - DropShadowNode
+
+final class DropShadowNode: LayerEffectNode {
+
+  // MARK: Lifecycle
+
+  init(model: DropShadowModel) {
+    properties = DropShadowNodeProperties(model: model)
+  }
+
+  // MARK: Internal
+
+  var properties: DropShadowNodeProperties
+
+  var propertyMap: any NodePropertyMap {
+    properties
+  }
+
+  func applyEffect(to layer: CALayer) {
+    if let opacity = properties.opacity?.value.cgFloatValue {
+      // Lottie animation files express opacity as a numerical percentage value
+      // (e.g. 0%, 50%, 100%) so we divide by 100 to get the decimal values
+      // expected by Core Animation (e.g. 0.0, 0.5, 1.0).
+      layer.shadowOpacity = Float(opacity / 100)
+    }
+    if
+      let angleDegrees = properties.angle?.value.cgFloatValue,
+      let distance = properties.distance?.value.cgFloatValue
+    {
+      // Lottie animation files express rotation in degrees
+      // (e.g. 90º, 180º, 360º) so we convert to radians to get the
+      // values expected by Core Animation (e.g. π/2, π, 2π)
+      let angleRadians = (angleDegrees * .pi) / 180
+
+      // Lottie animation files express the `shadowOffset` as (angle, distance) pair,
+      // which we convert to the expected x / y offset values:
+      let offsetX = distance * cos(angleRadians)
+      let offsetY = distance * sin(angleRadians)
+      layer.shadowOffset = .init(width: offsetX, height: offsetY)
+    }
+    layer.shadowColor = properties.color?.value.cgColorValue
+    layer.shadowRadius = properties.radius?.value.cgFloatValue ?? 0
+  }
+
+}
+
+// MARK: - DropShadowNodeProperties
+
+final class DropShadowNodeProperties: NodePropertyMap {
+
+  // MARK: Lifecycle
+
+  init(model: DropShadowModel) {
+    if let opacityKeyframes = model._opacity?.keyframes {
+      opacity = NodeProperty(provider: KeyframeInterpolator(keyframes: opacityKeyframes))
+      propertyMap[PropertyName.opacity.rawValue] = opacity
+    } else {
+      opacity = nil
+    }
+    if let radiusKeyframes = model._radius?.keyframes {
+      radius = NodeProperty(provider: KeyframeInterpolator(keyframes: radiusKeyframes))
+      propertyMap["Radius"] = radius
+    } else {
+      radius = nil
+    }
+    if let colorKeyFrames = model._color?.keyframes {
+      color = NodeProperty(provider: KeyframeInterpolator(keyframes: colorKeyFrames))
+      propertyMap[PropertyName.color.rawValue] = color
+    } else {
+      color = nil
+    }
+    if let angleKeyFrames = model._angle?.keyframes {
+      angle = NodeProperty(provider: KeyframeInterpolator(keyframes: angleKeyFrames))
+      propertyMap["Angle"] = angle
+    } else {
+      angle = nil
+    }
+    if let distanceKeyFrame = model._distance?.keyframes {
+      distance = NodeProperty(provider: KeyframeInterpolator(keyframes: distanceKeyFrame))
+      propertyMap["Distance"] = distance
+    } else {
+      distance = nil
+    }
+    properties = Array(propertyMap.values)
+  }
+
+  // MARK: Internal
+
+  var propertyMap = [String: AnyNodeProperty]()
+  var properties: [AnyNodeProperty]
+
+  let opacity: NodeProperty<LottieVector1D>?
+  let radius: NodeProperty<LottieVector1D>?
+  let color: NodeProperty<LottieColor>?
+  let angle: NodeProperty<LottieVector1D>?
+  let distance: NodeProperty<LottieVector1D>?
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/LayerEffectNodes/LayerEffectNode.swift

@@ -0,0 +1,25 @@
+// Created by Lan Xu on 2024/6/8.
+// Copyright © 2024 Airbnb Inc. All rights reserved.
+
+import QuartzCore
+
+// MARK: - LayerEffectNode
+
+protocol LayerEffectNode {
+  var propertyMap: NodePropertyMap { get }
+
+  func applyEffect(to layer: CALayer)
+}
+
+extension LayerEffectNode {
+
+  func updateWithFrame(layer: CALayer, frame: CGFloat) {
+    for property in propertyMap.properties {
+      if property.needsUpdate(frame: frame) {
+        property.update(frame: frame)
+      }
+    }
+    applyEffect(to: layer)
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/ModifierNodes/RoundedCornersNode.swift

@@ -0,0 +1,85 @@
+//
+//  RoundedCornersNode.swift
+//  Lottie
+//
+//  Created by Duolingo on 10/31/22.
+//
+
+import Foundation
+import QuartzCore
+
+// MARK: - RoundedCornersProperties
+
+final class RoundedCornersProperties: NodePropertyMap, KeypathSearchable {
+
+  // MARK: Lifecycle
+
+  init(roundedCorners: RoundedCorners) {
+    keypathName = roundedCorners.name
+    radius = NodeProperty(provider: KeyframeInterpolator(keyframes: roundedCorners.radius.keyframes))
+    keypathProperties = ["Radius": radius]
+    properties = Array(keypathProperties.values)
+  }
+
+  // MARK: Internal
+
+  let keypathProperties: [String: AnyNodeProperty]
+  let properties: [AnyNodeProperty]
+  let keypathName: String
+
+  let radius: NodeProperty<LottieVector1D>
+}
+
+// MARK: - RoundedCornersNode
+
+final class RoundedCornersNode: AnimatorNode {
+
+  // MARK: Lifecycle
+
+  init(parentNode: AnimatorNode?, roundedCorners: RoundedCorners, upstreamPaths: [PathOutputNode]) {
+    outputNode = PassThroughOutputNode(parent: parentNode?.outputNode)
+    self.parentNode = parentNode
+    properties = RoundedCornersProperties(roundedCorners: roundedCorners)
+    self.upstreamPaths = upstreamPaths
+  }
+
+  // MARK: Internal
+
+  let properties: RoundedCornersProperties
+
+  let parentNode: AnimatorNode?
+  let outputNode: NodeOutput
+  var hasLocalUpdates = false
+  var hasUpstreamUpdates = false
+  var lastUpdateFrame: CGFloat? = nil
+  var isEnabled = true
+
+  var propertyMap: NodePropertyMap & KeypathSearchable {
+    properties
+  }
+
+  func forceUpstreamOutputUpdates() -> Bool {
+    hasLocalUpdates || hasUpstreamUpdates
+  }
+
+  func rebuildOutputs(frame: CGFloat) {
+    for pathContainer in upstreamPaths {
+      let pathObjects = pathContainer.removePaths(updateFrame: frame)
+      for path in pathObjects {
+        let cornerRadius = properties.radius.value.cgFloatValue
+        if cornerRadius != 0 {
+          pathContainer.appendPath(
+            path.roundCorners(radius: cornerRadius),
+            updateFrame: frame
+          )
+        } else {
+          pathContainer.appendPath(path, updateFrame: frame)
+        }
+      }
+    }
+  }
+
+  // MARK: Fileprivate
+
+  fileprivate let upstreamPaths: [PathOutputNode]
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/ModifierNodes/TrimPathNode.swift

@@ -0,0 +1,281 @@
+//
+//  TrimPathNode.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/23/19.
+//
+
+import Foundation
+import QuartzCore
+
+// MARK: - TrimPathProperties
+
+final class TrimPathProperties: NodePropertyMap, KeypathSearchable {
+
+  // MARK: Lifecycle
+
+  init(trim: Trim) {
+    keypathName = trim.name
+    start = NodeProperty(provider: KeyframeInterpolator(keyframes: trim.start.keyframes))
+    end = NodeProperty(provider: KeyframeInterpolator(keyframes: trim.end.keyframes))
+    offset = NodeProperty(provider: KeyframeInterpolator(keyframes: trim.offset.keyframes))
+    type = trim.trimType
+    keypathProperties = [
+      "Start": start,
+      "End": end,
+      "Offset": offset,
+    ]
+    properties = Array(keypathProperties.values)
+  }
+
+  // MARK: Internal
+
+  let keypathProperties: [String: AnyNodeProperty]
+  let properties: [AnyNodeProperty]
+  let keypathName: String
+
+  let start: NodeProperty<LottieVector1D>
+  let end: NodeProperty<LottieVector1D>
+  let offset: NodeProperty<LottieVector1D>
+  let type: TrimType
+}
+
+// MARK: - TrimPathNode
+
+final class TrimPathNode: AnimatorNode {
+
+  // MARK: Lifecycle
+
+  init(parentNode: AnimatorNode?, trim: Trim, upstreamPaths: [PathOutputNode]) {
+    outputNode = PassThroughOutputNode(parent: parentNode?.outputNode)
+    self.parentNode = parentNode
+    properties = TrimPathProperties(trim: trim)
+    self.upstreamPaths = upstreamPaths
+  }
+
+  // MARK: Internal
+
+  let properties: TrimPathProperties
+
+  let parentNode: AnimatorNode?
+  let outputNode: NodeOutput
+  var hasLocalUpdates = false
+  var hasUpstreamUpdates = false
+  var lastUpdateFrame: CGFloat? = nil
+  var isEnabled = true
+
+  var propertyMap: NodePropertyMap & KeypathSearchable {
+    properties
+  }
+
+  func forceUpstreamOutputUpdates() -> Bool {
+    hasLocalUpdates || hasUpstreamUpdates
+  }
+
+  func rebuildOutputs(frame: CGFloat) {
+    /// Make sure there is a trim.
+    let startValue = properties.start.value.cgFloatValue * 0.01
+    let endValue = properties.end.value.cgFloatValue * 0.01
+    let start = min(startValue, endValue)
+    let end = max(startValue, endValue)
+
+    let offset = properties.offset.value.cgFloatValue.truncatingRemainder(dividingBy: 360) / 360
+
+    /// No need to trim, it's a full path
+    if start == 0, end == 1 {
+      return
+    }
+
+    /// All paths are empty.
+    if start == end {
+      for pathContainer in upstreamPaths {
+        pathContainer.removePaths(updateFrame: frame)
+      }
+      return
+    }
+
+    if properties.type == .simultaneously {
+      /// Just trim each path
+      for pathContainer in upstreamPaths {
+        let pathObjects = pathContainer.removePaths(updateFrame: frame)
+        for path in pathObjects {
+          // We are treating each compount path as an individual path. Its subpaths are treated as a whole.
+          pathContainer.appendPath(
+            path.trim(fromPosition: start, toPosition: end, offset: offset, trimSimultaneously: false),
+            updateFrame: frame
+          )
+        }
+      }
+      return
+    }
+
+    /// Individual path trimming.
+
+    /// Brace yourself for the below code.
+
+    /// Normalize lengths with offset.
+    var startPosition = (start + offset).truncatingRemainder(dividingBy: 1)
+    var endPosition = (end + offset).truncatingRemainder(dividingBy: 1)
+
+    if startPosition < 0 {
+      startPosition = 1 + startPosition
+    }
+
+    if endPosition < 0 {
+      endPosition = 1 + endPosition
+    }
+    if startPosition == 1 {
+      startPosition = 0
+    }
+    if endPosition == 0 {
+      endPosition = 1
+    }
+
+    /// First get the total length of all paths.
+    var totalLength: CGFloat = 0
+    for upstreamPath in upstreamPaths {
+      totalLength = totalLength + upstreamPath.totalLength
+    }
+
+    /// Now determine the start and end cut lengths
+    let startLength = startPosition * totalLength
+    let endLength = endPosition * totalLength
+    var pathStart: CGFloat = 0
+
+    /// Now loop through all path containers
+    for pathContainer in upstreamPaths {
+      let pathEnd = pathStart + pathContainer.totalLength
+
+      if
+        !startLength.isInRange(pathStart, pathEnd) &&
+        endLength.isInRange(pathStart, pathEnd)
+      {
+        // pathStart|=======E----------------------|pathEnd
+        // Cut path components, removing after end.
+
+        let pathCutLength = endLength - pathStart
+        let subpaths = pathContainer.removePaths(updateFrame: frame)
+        var subpathStart: CGFloat = 0
+        for path in subpaths {
+          let subpathEnd = subpathStart + path.length
+          if pathCutLength < subpathEnd {
+            /// This is the subpath that needs to be cut.
+            let cutLength = pathCutLength - subpathStart
+            let newPath = path.trim(fromPosition: 0, toPosition: cutLength / path.length, offset: 0, trimSimultaneously: false)
+            pathContainer.appendPath(newPath, updateFrame: frame)
+            break
+          } else {
+            /// Add to container and move on
+            pathContainer.appendPath(path, updateFrame: frame)
+          }
+          if pathCutLength == subpathEnd {
+            /// Right on the end. The next subpath is not included. Break.
+            break
+          }
+          subpathStart = subpathEnd
+        }
+
+      } else if
+        !endLength.isInRange(pathStart, pathEnd) &&
+        startLength.isInRange(pathStart, pathEnd)
+      {
+        // pathStart|-------S======================|pathEnd
+        //
+
+        // Cut path components, removing before beginning.
+        let pathCutLength = startLength - pathStart
+        // Clear paths from container
+        let subpaths = pathContainer.removePaths(updateFrame: frame)
+        var subpathStart: CGFloat = 0
+        for path in subpaths {
+          let subpathEnd = subpathStart + path.length
+
+          if subpathStart < pathCutLength, pathCutLength < subpathEnd {
+            /// This is the subpath that needs to be cut.
+            let cutLength = pathCutLength - subpathStart
+            let newPath = path.trim(fromPosition: cutLength / path.length, toPosition: 1, offset: 0, trimSimultaneously: false)
+            pathContainer.appendPath(newPath, updateFrame: frame)
+          } else if pathCutLength <= subpathStart {
+            pathContainer.appendPath(path, updateFrame: frame)
+          }
+          subpathStart = subpathEnd
+        }
+      } else if
+        endLength.isInRange(pathStart, pathEnd) &&
+        startLength.isInRange(pathStart, pathEnd)
+      {
+        // pathStart|-------S============E---------|endLength
+        // pathStart|=====E----------------S=======|endLength
+        // trim from path beginning to endLength.
+
+        // Cut path components, removing before beginnings.
+        let startCutLength = startLength - pathStart
+        let endCutLength = endLength - pathStart
+        // Clear paths from container
+        let subpaths = pathContainer.removePaths(updateFrame: frame)
+        var subpathStart: CGFloat = 0
+        for path in subpaths {
+          let subpathEnd = subpathStart + path.length
+
+          if
+            !startCutLength.isInRange(subpathStart, subpathEnd),
+            !endCutLength.isInRange(subpathStart, subpathEnd)
+          {
+            // The whole path is included. Add
+            // S|==============================|E
+            pathContainer.appendPath(path, updateFrame: frame)
+
+          } else if
+            startCutLength.isInRange(subpathStart, subpathEnd),
+            !endCutLength.isInRange(subpathStart, subpathEnd)
+          {
+            /// The start of the path needs to be trimmed
+            //  |-------S======================|E
+            let cutLength = startCutLength - subpathStart
+            let newPath = path.trim(fromPosition: cutLength / path.length, toPosition: 1, offset: 0, trimSimultaneously: false)
+            pathContainer.appendPath(newPath, updateFrame: frame)
+          } else if
+            !startCutLength.isInRange(subpathStart, subpathEnd),
+            endCutLength.isInRange(subpathStart, subpathEnd)
+          {
+            // S|=======E----------------------|
+            let cutLength = endCutLength - subpathStart
+            let newPath = path.trim(fromPosition: 0, toPosition: cutLength / path.length, offset: 0, trimSimultaneously: false)
+            pathContainer.appendPath(newPath, updateFrame: frame)
+            break
+          } else if
+            startCutLength.isInRange(subpathStart, subpathEnd),
+            endCutLength.isInRange(subpathStart, subpathEnd)
+          {
+            //  |-------S============E---------|
+            let cutFromLength = startCutLength - subpathStart
+            let cutToLength = endCutLength - subpathStart
+            let newPath = path.trim(
+              fromPosition: cutFromLength / path.length,
+              toPosition: cutToLength / path.length,
+              offset: 0,
+              trimSimultaneously: false
+            )
+            pathContainer.appendPath(newPath, updateFrame: frame)
+            break
+          }
+
+          subpathStart = subpathEnd
+        }
+      } else if
+        (endLength <= pathStart && pathEnd <= startLength) ||
+        (startLength <= pathStart && endLength <= pathStart) ||
+        (pathEnd <= startLength && pathEnd <= endLength)
+      {
+        /// The Path needs to be cleared
+        pathContainer.removePaths(updateFrame: frame)
+      }
+
+      pathStart = pathEnd
+    }
+  }
+
+  // MARK: Fileprivate
+
+  fileprivate let upstreamPaths: [PathOutputNode]
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/GroupOutputNode.swift

@@ -0,0 +1,74 @@
+//
+//  TransformNodeOutput.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import QuartzCore
+
+final class GroupOutputNode: NodeOutput {
+
+  // MARK: Lifecycle
+
+  init(parent: NodeOutput?, rootNode: NodeOutput?) {
+    self.parent = parent
+    self.rootNode = rootNode
+  }
+
+  // MARK: Internal
+
+  let parent: NodeOutput?
+  let rootNode: NodeOutput?
+  var isEnabled = true
+
+  private(set) var outputPath: CGPath? = nil
+  private(set) var transform: CATransform3D = CATransform3DIdentity
+
+  func setTransform(_ xform: CATransform3D, forFrame _: CGFloat) {
+    transform = xform
+    outputPath = nil
+  }
+
+  func hasOutputUpdates(_ forFrame: CGFloat) -> Bool {
+    guard isEnabled else {
+      let upstreamUpdates = parent?.hasOutputUpdates(forFrame) ?? false
+      outputPath = parent?.outputPath
+      return upstreamUpdates
+    }
+
+    let upstreamUpdates = parent?.hasOutputUpdates(forFrame) ?? false
+    if upstreamUpdates {
+      outputPath = nil
+    }
+    let rootUpdates = rootNode?.hasOutputUpdates(forFrame) ?? false
+    if rootUpdates {
+      outputPath = nil
+    }
+
+    var localUpdates = false
+    if outputPath == nil {
+      localUpdates = true
+
+      let newPath = CGMutablePath()
+      if let parentNode = parent, let parentPath = parentNode.outputPath {
+        /// First add parent path.
+        newPath.addPath(parentPath)
+      }
+      var xform = CATransform3DGetAffineTransform(transform)
+      if
+        let rootNode,
+        let rootPath = rootNode.outputPath,
+        let xformedPath = rootPath.copy(using: &xform)
+      {
+        /// Now add root path. Note root path is transformed.
+        newPath.addPath(xformedPath)
+      }
+
+      outputPath = newPath
+    }
+
+    return upstreamUpdates || localUpdates
+  }
+
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/PassThroughOutputNode.swift

@@ -0,0 +1,47 @@
+//
+//  PassThroughOutputNode.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import CoreGraphics
+
+/// Base class for pass-through nodes
+class PassThroughOutputNode: NodeOutput {
+
+  // MARK: Lifecycle
+
+  init(parent: NodeOutput?) {
+    self.parent = parent
+  }
+
+  // MARK: Internal
+
+  let parent: NodeOutput?
+
+  var hasUpdate = false
+  var isEnabled = true
+
+  var outputPath: CGPath? {
+    if let parent {
+      return parent.outputPath
+    }
+    return nil
+  }
+
+  func hasOutputUpdates(_ forFrame: CGFloat) -> Bool {
+    /// Changes to this node do not affect downstream nodes.
+    let parentUpdate = parent?.hasOutputUpdates(forFrame) ?? false
+    /// Changes to upstream nodes do, however, affect this nodes state.
+    hasUpdate = hasUpdate || parentUpdate
+    return parentUpdate
+  }
+
+  func hasRenderUpdates(_ forFrame: CGFloat) -> Bool {
+    /// Return true if there are upstream updates or if this node has updates
+    let upstreamUpdates = parent?.hasOutputUpdates(forFrame) ?? false
+    hasUpdate = hasUpdate || upstreamUpdates
+    return hasUpdate
+  }
+}

package/platforms/macos/src/vendor/Lottie/Private/MainThread/NodeRenderSystem/Nodes/OutputNodes/PathOutputNode.swift

@@ -0,0 +1,89 @@
+//
+//  PathNodeOutput.swift
+//  lottie-swift
+//
+//  Created by Brandon Withrow on 1/30/19.
+//
+
+import CoreGraphics
+
+/// A node that has an output of a BezierPath
+final class PathOutputNode: NodeOutput {
+
+  // MARK: Lifecycle
+
+  init(parent: NodeOutput?) {
+    self.parent = parent
+  }
+
+  // MARK: Internal
+
+  let parent: NodeOutput?
+
+  fileprivate(set) var outputPath: CGPath? = nil
+
+  var lastUpdateFrame: CGFloat? = nil
+  var lastPathBuildFrame: CGFloat? = nil
+  var isEnabled = true
+  fileprivate(set) var totalLength: CGFloat = 0
+  fileprivate(set) var pathObjects = [CompoundBezierPath]()
+
+  func hasOutputUpdates(_ forFrame: CGFloat) -> Bool {
+    guard isEnabled else {
+      let upstreamUpdates = parent?.hasOutputUpdates(forFrame) ?? false
+      outputPath = parent?.outputPath
+      return upstreamUpdates
+    }
+
+    /// Ask if parent was updated
+    let upstreamUpdates = parent?.hasOutputUpdates(forFrame) ?? false
+
+    /// If parent was updated and the path hasn't been built for this frame, clear the path.
+    if upstreamUpdates && lastPathBuildFrame != forFrame {
+      outputPath = nil
+    }
+
+    if outputPath == nil {
+      /// If the path is clear, build the new path.
+      lastPathBuildFrame = forFrame
+      let newPath = CGMutablePath()
+      if let parentNode = parent, let parentPath = parentNode.outputPath {
+        newPath.addPath(parentPath)
+      }
+      for path in pathObjects {
+        for subPath in path.paths {
+          newPath.addPath(subPath.cgPath())
+        }
+      }
+      outputPath = newPath
+    }
+
+    /// Return true if there were upstream updates or if this node was updated.
+    return upstreamUpdates || (lastUpdateFrame == forFrame)
+  }
+
+  @discardableResult
+  func removePaths(updateFrame: CGFloat?) -> [CompoundBezierPath] {
+    lastUpdateFrame = updateFrame
+    let returnPaths = pathObjects
+    outputPath = nil
+    totalLength = 0
+    pathObjects = []
+    return returnPaths
+  }
+
+  func setPath(_ path: BezierPath, updateFrame: CGFloat) {
+    lastUpdateFrame = updateFrame
+    outputPath = nil
+    totalLength = path.length
+    pathObjects = [CompoundBezierPath(path: path)]
+  }
+
+  func appendPath(_ path: CompoundBezierPath, updateFrame: CGFloat) {
+    lastUpdateFrame = updateFrame
+    outputPath = nil
+    totalLength = totalLength + path.length
+    pathObjects.append(path)
+  }
+
+}