Fixed some access permission issues

- Added convenience inits for Path classes to remove the need to pass in a PathState manually
- Added setupPerformanceMode convenience method to Path classes (which call PathState's method internally)

Author: poetmountain

Examples/MotionExamples/Classes/PathMotionContiguousViewController.swift

@@ -26,6 +26,14 @@ class PathMotionContiguousViewController: UIViewController, ButtonsViewDelegate
         return view
     }()
 
+    lazy var label: UILabel = {
+        let label = UILabel()
+        label.font = .systemFont(ofSize: 12.0)
+        label.isUserInteractionEnabled = false
+        label.text = "contiguousEdges edge behavior allows motions to seamlessly travel beyond one edge of the path to the other."
+        label.numberOfLines = 4
+        return label
+    }()
 
     lazy var pathView: PathView = {
         return PathView()
@@ -64,11 +72,9 @@ class PathMotionContiguousViewController: UIViewController, ButtonsViewDelegate
         let rect: CGRect = CGRect(x: 0, y: 0, width: 320, height: 320).insetBy(dx: lineWidth, dy: lineWidth)
         let radius: CGFloat = rect.width * 0.25
         let rectPath = UIBezierPath(roundedRect: rect, cornerRadius: radius)
-        let pathState = PathState(path: rectPath.cgPath)
-        self.pathState = pathState
         pathView.path = rectPath
 
-        motion = PathMotion(path: pathState, duration: 2.5, endPosition: 1.0, easing: EasingElastic.easeInOut(), edgeBehavior: .contiguousEdges)
+        motion = PathMotion(path: rectPath.cgPath, duration: 2, endPosition: 1.0, easing: EasingElastic.easeInOut(), edgeBehavior: .contiguousEdges)
         .repeats()
         .reverses(withEasing: EasingBack.easeInOut())
 
@@ -97,7 +103,13 @@ class PathMotionContiguousViewController: UIViewController, ButtonsViewDelegate
         } else {
           top_anchor = margins.bottomAnchor
         }
-
+        
+        self.view.addSubview(label)
+        label.translatesAutoresizingMaskIntoConstraints = false
+        label.topAnchor.constraint(equalTo: top_anchor, constant: 30.0).isActive = true
+        label.leadingAnchor.constraint(equalTo: margins.leadingAnchor, constant: 30).isActive = true
+        label.trailingAnchor.constraint(equalTo: margins.trailingAnchor, constant: -30).isActive = true
+        
         view.addSubview(buttonsView)
         buttonsView.delegate = self
         buttonsView.translatesAutoresizingMaskIntoConstraints = false
@@ -106,7 +118,7 @@ class PathMotionContiguousViewController: UIViewController, ButtonsViewDelegate
 
         self.view.addSubview(pathView)
         pathView.translatesAutoresizingMaskIntoConstraints = false
-        pathView.topAnchor.constraint(equalTo: top_anchor, constant: 50.0).isActive = true
+        pathView.topAnchor.constraint(equalTo: label.bottomAnchor, constant: 30.0).isActive = true
         pathView.centerXAnchor.constraint(equalTo: self.view.centerXAnchor, constant: 0.0).isActive = true
         pathView.widthAnchor.constraint(equalToConstant: 320.0).isActive = true
         pathView.heightAnchor.constraint(equalToConstant: 320.0).isActive = true

Examples/MotionExamples/Classes/PathMotionViewController.swift

@@ -61,11 +61,9 @@ class PathMotionViewController: UIViewController, ButtonsViewDelegate {
        let path = UIBezierPath(arcCenter: CGPoint(x: 20, y: 20), radius: 200, startAngle: 0.087, endAngle: 1.66, clockwise: true)
         path.addQuadCurve(to: CGPoint(x: 20, y: 50), controlPoint: CGPoint(x: 100, y: 45))
 
-        let pathState = PathState(path: path.cgPath)
-        self.pathState = pathState
         pathView.path = path
 
-        motion = PathMotion(path: pathState,
+        motion = PathMotion(path: path.cgPath,
                         duration: 2.0,
                           easing: EasingQuadratic.easeInOut())
         .reverses(withEasing: EasingQuartic.easeInOut())

Examples/MotionExamples/Classes/PathPhysicsMotionViewController.swift

@@ -60,12 +60,10 @@ class PathPhysicsMotionViewController: UIViewController, ButtonsViewDelegate {
         let path = UIBezierPath(arcCenter: CGPoint(x: 20, y: 20), radius: 200, startAngle: 0.087, endAngle: 1.66, clockwise: true)
         path.addQuadCurve(to: CGPoint(x: 20, y: 50), controlPoint: CGPoint(x: 100, y: 45))
 
-        let pathState = PathState(path: path.cgPath)
-        self.pathState = pathState
         pathView.path = path
 
         let config = PhysicsConfiguration(velocity: 800, friction: 0.4, restitution: 0.7)
-        motion = PathPhysicsMotion(path: pathState, configuration: config)
+        motion = PathPhysicsMotion(path: path.cgPath, configuration: config)
         motion?.updated({ [weak pathView, weak view, weak motionView] (motion, currentPoint) in
             if let view, let adjustedPoint = pathView?.convert(currentPoint, to: view) {
                 motionView?.center = adjustedPoint

Guides/MoveableClasses.md

@@ -135,8 +135,7 @@ let motion = PhysicsMotion(target: view,
 Here's a basic example. We've supplied the `PathMotion` with a basic CGPath via a `PathState` object, an easing equation, and we've told it to reverse back to the beginning once it travels to the end. Notice though how we've defined a `startPosition` and `endPosition`. This tells the `PathMotion` it should start the animation at a point 10% from the beginning of the path and end the animation at a point 80% along the path's length. If you leave these parameters out it will travel the full distance.
 ```swift
 let path = UIBezierPath(rect: CGRect(x: 0, y: 0, width: 100, height: 100))
-let pathState = PathState(path: path.cgPath)
-motion = PathMotion(path: pathState,
+motion = PathMotion(path: path.cgPath,
                 duration: 1.0,
            startPosition: 0.1,
              endPosition: 0.8,
@@ -148,8 +147,7 @@ motion.start()
 In this example note that we've added an `edgeBehavior` parameter to the `PathMotion` initializer. There are two types of edge behaviors – `stopAtEdges` (the default), which simply stops motion once the animated point gets to either specified edge point, and `contiguousEdges`, which tells the `PathMotion` that the path's starting and ending edges should be treated as connected, contiguous points. If the animated point travels beyond the path's edge, as can happen with some easing equation classes like `EasingElastic` and `EasingBack`, the motion will continue in the current direction at the beginning of the other edge. This behavior type is useful with closed paths like polygonal shapes to create a seamless animation.
 ```swift
 let path = UIBezierPath(rect: CGRect(x: 0, y: 0, width: 100, height: 100))
-let pathState = PathState(path: path.cgPath)
-motion = PathMotion(path: pathState,
+motion = PathMotion(path: path.cgPath,
                 duration: 1.0,
                   easing: EasingElastic.easeInOut(),
             edgeBehavior: .contiguousEdges)
@@ -160,8 +158,7 @@ motion = PathMotion(path: pathState,
 The `startPosition` and `endPosition` values can also be flipped. Doing so will make the point travel along the path from the end of the path towards the beginning in its forward motion. In this example, the motion point will start at 80% along the path and travel "backwards" to 20%. If you added a `reverses` option, then at the end of the motion it would reverse along the path back to 80%.
 ```swift
 let path = UIBezierPath(rect: CGRect(x: 0, y: 0, width: 100, height: 100))
-let pathState = PathState(path: path.cgPath)
-motion = PathMotion(path: pathState,
+motion = PathMotion(path: path.cgPath,
                 duration: 1.0,
            startPosition: 0.8,
              endPosition: 0.2,
@@ -170,10 +167,10 @@ motion.start()
 ```
 
 > [!IMPORTANT]
-> Note that because it is mathematically complex to find all points on a CGPath, large, complex paths can present performance challenges for `PathMotion` to animate along. Fortunately, `PathMotion` comes with a performance mode. When this mode is activated, `PathState` generates a lookup table which it uses to find points on the path in O(n) time. While this increases setup time, it significantly improves performance while the motion is running, for instance from 10% down to 1% CPU usage. To use performance mode, call the async method `setupPerformanceMode()` on the `PathState` instance before starting the `PathMotion`. This method will run the lookup table generation code on a background queue and return when complete. For most reasonably large paths this should take under a second.
+> Note that because it is mathematically complex to find all points on a CGPath, large, complex paths can present performance challenges for `PathMotion` to animate along. Fortunately, `PathMotion` comes with a performance mode. When this mode is activated, `PathState` generates a lookup table which it uses to find points on the path in O(n) time. While this increases setup time, it significantly improves performance while the motion is running, for instance from 10% down to 1% CPU usage. To use performance mode, call the async method `setupPerformanceMode()` before starting the `PathMotion`, as shown in the below example. This method will run the lookup table generation code on a background queue and return when complete. For most reasonably large paths this should take under a second.
 ```swift
 Task {
-    await pathState?.setupPerformanceMode()
+    await motion?.setupPerformanceMode()
     motion?.start()
 }
 ```
@@ -185,9 +182,8 @@ Task {
 Here's a basic example. We've supplied the `PathPhysicsMotion` with a basic CGPath via a `PathState` object, an easing equation, and we've told it to reverse back to the beginning once it travels to the end. Notice though how we've defined a `startPosition` and `endPosition`. This tells the `PathPhysicsMotion` it should start the animation at a point 10% from the beginning of the path and end the animation at a point 80% along the path's length. If you leave these parameters out it will have the full length of the path to travel along.
 ```swift
 let path = UIBezierPath(arcCenter: CGPoint(x: 20, y: 20), radius: 100, startAngle: 0.087, endAngle: 1.66, clockwise: true)
-let pathState = PathState(path: path.cgPath)
 let config = PhysicsConfiguration(velocity: 500, friction: 0.4)
-motion = PathPhysicsMotion(path: pathState, 
+motion = PathPhysicsMotion(path: path.cgPath, 
                   configuration: config,
                   startPosition: 0.1, 
                     endPosition: 0.8)
@@ -197,19 +193,17 @@ motion.start()
 In this second example we're going to turn on collision detection and add a `restitution` value. Technically, collisions are turned on any time the `stopAtEdges` edge behavior is chosen, but adding a `restitution` value will cause a change in the motion. This value enables the object to collide and "bounce" off the starting and ending points when a point reaches them. The `restitution` value determines the elasticity of the object, which in effect determines how much velocity the object retains after colliding with an edge. A `restitution` value of 0.0 (the default if no value is provided) results in no bouncing at all, while a value of 1.0 results in no energy being lost in the collision. By default the collision points are at the start and end of the path, but if you specify your own start and end points those will be used instead.
 ```swift
 let path = UIBezierPath(arcCenter: CGPoint(x: 20, y: 20), radius: 100, startAngle: 0.087, endAngle: 1.66, clockwise: true)
-let pathState = PathState(path: path.cgPath)
 let config = PhysicsConfiguration(velocity: 600, friction: 0.4, restitution: 0.8)
-motion = PathPhysicsMotion(path: pathState, 
+motion = PathPhysicsMotion(path: path.cgPath, 
                   configuration: config)
 motion.start()
 ```
 
 Although `PathPhysicsMotion` uses a physics simulation instead of specifying discrete ending values, we can still apply `repeats` and `reverses` options. Repeating and reversing act in the same way as `Motion` and interacts with `MoveableCollection` classes as you would expect.
 ```swift
 let path = UIBezierPath(arcCenter: CGPoint(x: 20, y: 20), radius: 100, startAngle: 0.087, endAngle: 1.66, clockwise: true)
-let pathState = PathState(path: path.cgPath)
 let config = PhysicsConfiguration(velocity: 500, friction: 0.4)
-motion = PathPhysicsMotion(path: pathState, 
+motion = PathPhysicsMotion(path: path.cgPath, 
                   configuration: config)
 .reverses()
 .repeats(1)
@@ -219,20 +213,19 @@ motion = PathPhysicsMotion(path: pathState,
 The `startPosition` and `endPosition` values can also be flipped. Doing so will make the point travel along the path from the end of the path towards the beginning in its forward motion. Be aware that if you do this, the velocity should also be a negative value in order for the point to travel in the correct direction. In this example, the motion point will start at 80% along the path and travel "backwards" to 20%.
 ```swift
 let path = UIBezierPath(arcCenter: CGPoint(x: 20, y: 20), radius: 100, startAngle: 0.087, endAngle: 1.66, clockwise: true)
-let pathState = PathState(path: path.cgPath)
 let config = PhysicsConfiguration(velocity: -600, friction: 0.4, restitution: 0.8)
-motion = PathPhysicsMotion(path: pathState, 
+motion = PathPhysicsMotion(path: path.cgPath, 
                   configuration: config,
                   startPosition: 0.8, 
                     endPosition: 0.2)
 motion.start()
 ```
 
 > [!IMPORTANT]
-> Note that because it is mathematically complex to find all points on a CGPath, large, complex paths can present performance challenges for `PathPhysicsMotion` to animate along. Fortunately, `PathPhysicsMotion` comes with a performance mode. When this mode is activated, the `PathState` object generates a lookup table which it uses to find points on the path in O(n) time. While this increases setup time, it significantly improves performance while the motion is running, for instance from 10% down to 1% CPU usage. To use performance mode, call the async method `setupPerformanceMode()` on the `PathState` instance before starting the `PathPhysicsMotion`. This method will run the lookup table generation code on a background queue and return when complete. For most reasonably large paths this should take under a second.
+> Note that because it is mathematically complex to find all points on a CGPath, large, complex paths can present performance challenges for `PathPhysicsMotion` to animate along. Fortunately, `PathPhysicsMotion` comes with a performance mode. When this mode is activated, the `PathState` object generates a lookup table which it uses to find points on the path in O(n) time. While this increases setup time, it significantly improves performance while the motion is running, for instance from 10% down to 1% CPU usage. To use performance mode, call the async method `setupPerformanceMode()` before starting the `PathPhysicsMotion`, as shown in the below example. This method will run the lookup table generation code on a background queue and return when complete. For most reasonably large paths this should take under a second.
 ```swift
 Task {
-    await pathState?.setupPerformanceMode()
+    await motion?.setupPerformanceMode()
     motion?.start()
 }
 ```

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version: 5.5
+// swift-tools-version: 5.10
 
 //  Package.swift
 //  MotionMachine

README.md

@@ -1,6 +1,6 @@
 ![MotionMachine logo](Guides/mmlogo.png)
 
-![swift](https://img.shields.io/badge/Swift-5.5%20%7C%206.0-005AA5.svg)
+![swift](https://img.shields.io/badge/Swift-5.10%20%7C%206.0-005AA5.svg)
 ![platforms](https://img.shields.io/badge/platforms-iOS%20%7C%20tvOS-005AA5.svg) ![license](https://img.shields.io/badge/license-MIT-005AA5.svg)
 
 MotionMachine provides a modular, powerful, and generic platform for manipulating values, whether that be animating UI elements or interpolating property values in your own classes. It offers sensible default functionality that abstracts most of the hard work away, allowing you to focus on your work. While it is type-agnostic, MotionMachine does support most major UIKit types out of the box and provides syntactic sugar to easily manipulate them. But it's also easy to dive in and modify for your own needs, whether that be custom motion classes, supporting custom value types, or new easing equations.
@@ -166,7 +166,7 @@ You can add MotionMachine to an Xcode project by adding it as a Swift package de
 ## Compatibility
 
 MotionMachine currently requires:
-* Swift 5.5 or above
+* Swift 5.10 or above
 * Xcode 16+
 * iOS 13.0 or later, tvOS 13.0 or later
 
@@ -182,7 +182,7 @@ MotionMachine currently requires:
 
 ## Credits
 
-MotionMachine was created by [Brett Walker](https://twitter.com/petsound). It is loosely based on the author's Objective-C library [PMTween](https://github.com/poetmountain/PMTween).
+MotionMachine was created by [Brett Walker](https://bsky.app/profile/petsound.bsky.social). It is loosely based on the author's Objective-C library [PMTween](https://github.com/poetmountain/PMTween).
 
 
 ## License