Add options for stablize graph on appear

Author: li3zhen1

Examples/ForceDirectedGraphExample/ForceDirectedGraphExample/MyRing.swift

@@ -12,7 +12,9 @@ import ForceSimulation
 
 struct MyRing: View {
 
-    @State var graphStates = ForceDirectedGraphState()
+    @State var graphStates = ForceDirectedGraphState(
+        ticksOnAppear: .untilStable
+    )
 
     @State var draggingNodeID: Int? = nil
 

Sources/ForceSimulation/Simulation.swift

@@ -1,7 +1,23 @@
+@usableFromInline
+package enum Ticks<Scalar: Sendable & FloatingPoint>: Sendable {
+    case untilReachingAlpha(Scalar?)
+    case iteration(Int)
+
+    @inlinable
+    public static var zero: Self {
+        .iteration(0)
+    }
+
+    @inlinable
+    public static var untilStable: Self {
+        .untilReachingAlpha(nil)
+    }
+}
+
 /// An any-dimensional force simulation.
 /// The points are placed in a space where you use a SIMD data structure
 /// to describe their coordinates.
-public final class Simulation<Vector, ForceField>
+public final class Simulation<Vector, ForceField>: @unchecked Sendable
 where Vector: SimulatableVector & L2NormCalculatable, ForceField: ForceProtocol<Vector> {
 
     @usableFromInline
@@ -89,6 +105,7 @@ where Vector: SimulatableVector & L2NormCalculatable, ForceField: ForceProtocol<
 
     /// Run a number of iterations of ticks.
     @inlinable
+    @inline(__always)
     public func tick(iterations: UInt = 1) {
         // print(self.kinetics.alpha, self.kinetics.alphaMin)
         guard self.kinetics.alpha >= self.kinetics.alphaMin else { return }
@@ -99,13 +116,29 @@ where Vector: SimulatableVector & L2NormCalculatable, ForceField: ForceProtocol<
         }
     }
 
+    /// Run a number of iterations of ticks.
+    @inlinable
+    package func tick(ticks: Ticks<Vector.Scalar>) {
+        switch ticks {
+        case .iteration(let count):
+            self.tick(iterations: UInt(count))
+        case .untilReachingAlpha(let alpha):
+            let alpha = alpha ?? self.kinetics.alphaMin
+            while self.kinetics.alpha >= alpha {
+                self.kinetics.updateAlpha()
+                self.forceField.apply(to: &self.kinetics)
+                self.kinetics.updatePositions()
+            }
+        }
+    }
+
+    @inlinable
     deinit {
         self.forceField.dispose()
     }
 
 }
 
-
 public typealias Simulation2D<ForceField> = Simulation<SIMD2<Double>, ForceField>
 where ForceField: ForceProtocol<SIMD2<Double>>
 

Sources/Grape/Views/ForceDirectedGraphModel.swift

@@ -287,6 +287,18 @@ public final class ForceDirectedGraphModel<NodeID: Hashable> {
 
     @inlinable
     func trackStateMixin() {
+        Task { @MainActor [self] in
+            switch stateMixinRef.ticksOnAppear {
+            case .iteration(let count):
+                simulationContext.storage.tick(ticks: .iteration(count))
+            case .untilReachingAlpha(let alpha):
+                simulationContext.storage.tick(ticks: .untilReachingAlpha(alpha))
+            }
+            withMutation(keyPath: \.currentFrame) {
+                currentFrame += 1
+            }
+        }
+
         if stateMixinRef.isRunning {
             start()
         } else {

Sources/Grape/Views/ForceDirectedGraphState.swift

@@ -16,8 +16,26 @@ import Observation
 //     }
 // }
 
+public enum Ticks: Sendable {
+    case untilReachingAlpha(Double?)
+    case iteration(Int)
+    
+    @inlinable
+    public static var zero: Self {
+        .iteration(0)
+    }
+    
+    @inlinable
+    public static var untilStable: Self {
+        .untilReachingAlpha(nil)
+    }
+}
+
 public class ForceDirectedGraphState: Observation.Observable {
 
+    @usableFromInline
+    internal var ticksOnAppear: Ticks
+
     @usableFromInline
     internal var _$modelTransform: ViewportTransform
 
@@ -53,11 +71,13 @@ public class ForceDirectedGraphState: Observation.Observable {
     @inlinable
     public init(
         initialIsRunning: Bool = true,
-        initialModelTransform: ViewportTransform = .identity
+        initialModelTransform: ViewportTransform = .identity,
+        ticksOnAppear: Ticks = .iteration(0)
     ) {
         self._reg = Observation.ObservationRegistrar()
         self._$modelTransform = initialModelTransform
         self._$isRunning = initialIsRunning
+        self.ticksOnAppear = ticksOnAppear
     }
 
     // MARK: - Observation