1.0

.gitignore

@@ -88,3 +88,4 @@ fastlane/test_output
 # https://github.com/johnno1962/injectionforxcode
 
 iOSInjectionProject/
+Mcrich23-Toolkit/

Example/ContentView.swift

@@ -12,40 +12,40 @@ struct ContentView: View {
     var body: some View {
         VStack(spacing: 20) {
             HStack(spacing: 20) {
-                BallPulse()
-                BallGridPulse()
-                BallClipRotate()
-                SquareSpin()
+                BallPulse(duration: 0.0)
+                BallGridPulse(duration: 0.0)
+                BallClipRotate(duration: 0.0)
+                SquareSpin(duration: 0.0)
             }
             HStack(spacing: 20) {
-                BallClipRotatePulse()
-                BallClipRotateMultiple()
-                BallRotate()
-                CubeTransition()
+                BallClipRotatePulse(duration: 0.0)
+                BallClipRotateMultiple(duration: 0.0)
+                BallRotate(duration: 0.0)
+                CubeTransition(duration: 0.0)
             }
             HStack(spacing: 20) {
-                BallZigZag()
-                BallZigZagDeflect()
-                BallTrianglePath()
-                BallScale()
+                BallZigZag(duration: 0.0)
+                BallZigZagDeflect(duration: 0.0)
+                BallTrianglePath(duration: 0.0)
+                BallScale(duration: 0.0)
             }
             HStack(spacing: 20) {
-                LineScale()
-                LineScaleParty()
-                BallPulseSync()
-                BallBeat()
+                LineScale(duration: 0.0)
+                LineScaleParty(duration: 0.0)
+                BallPulseSync(duration: 0.0)
+                BallBeat(duration: 0.0)
             }
             HStack(spacing: 20) {
-                LineScalePulseOut()
-                LineScalePulseOutRapid()
-                BallScaleRipple()
-                BallScaleRippleMultiple()
+                LineScalePulseOut(duration: 0.0)
+                LineScalePulseOutRapid(duration: 0.0)
+                BallScaleRipple(duration: 0.0)
+                BallScaleRippleMultiple(duration: 0.0)
             }
             HStack(spacing: 20) {
-                BallScaleRippleMultiple()
-                TriangleSkewSpin()
-                BallGridBeat()
-                SemiCircleSpin()
+                BallScaleRippleMultiple(duration: 0.0)
+                TriangleSkewSpin(duration: 0.0)
+                BallGridBeat(duration: 0.0)
+                SemiCircleSpin(duration: 0.0)
             }
         }
         .padding(20)

Package.swift

@@ -16,7 +16,7 @@ let package = Package(
     targets: [
         .target(
             name: "LoaderUI",
-            path: "Sources",
-            exclude: ["Exclude"]),
+            path: "Sources"
+        ),
     ]
 )

README.md

@@ -3,6 +3,8 @@ LoaderUI
 
 [NVActivityIndicatorView](https://github.com/ninjaprox/NVActivityIndicatorView) implemented in SwiftUI.
 
+For default speed, set duration to 0.0
+
 ## Demo
 
 ![Demo](https://github.com/ninjaprox/LoaderUI/blob/master/Demo.gif?raw=true)

Sources/BallBeat.swift

@@ -10,17 +10,27 @@ import SwiftUI
 
 public struct BallBeat: View {
     private let beginTimes = [0.35, 0, 0.35]
-    private let duration = 0.7
+    private let duration: Double
+    private let defaultDuration = 0.7
     private let timingFunction = TimingFunction.linear
-    private let keyTimes = [0, 0.5, 1]
+    private var keyTimes = [0, 0.5, 1]
     private let scaleValues: [CGFloat] = [1, 0.75, 1]
     private let opacityValues = [1, 0.2, 1]
 
     public var body: some View {
         GeometryReader(content: self.render)
     }
 
-    public init() { }
+    public init(duration: Double) {
+        if duration <= defaultDuration {
+            self.duration = defaultDuration
+        } else {
+            self.duration = duration
+        }
+        if duration > defaultDuration {
+            keyTimes = [0, 0.5*duration, duration]
+        }
+    }
 
     func render(geometry: GeometryProxy) -> some View {
         let dimension = min(geometry.size.width, geometry.size.height)
@@ -45,6 +55,6 @@ public struct BallBeat: View {
 
 struct BallBeat_Previews: PreviewProvider {
     static var previews: some View {
-        BallBeat()
+        BallBeat(duration: 0.7)
     }
 }

Sources/BallClipRotate.swift

@@ -26,17 +26,27 @@ fileprivate struct BallClip: Shape {
 }
 
 public struct BallClipRotate: View {
-    private let duration = 0.75
+    private let duration: Double
+    private let defaultDuration = 0.75
     private let timingFunction = TimingFunction.linear
-    private let keyTimes = [0, 0.5, 1]
+    private var keyTimes = [0, 0.5, 1]
     private let scaleValues: [CGFloat] = [1, 0.6, 1]
     private let rotationValues = [0.0, .pi, 2 * .pi]
 
     public var body: some View {
         GeometryReader(content: self.render)
     }
 
-    public init() { }
+    public init(duration: Double) {
+        if duration <= defaultDuration {
+            self.duration = defaultDuration
+        } else {
+            self.duration = duration
+        }
+        if duration > defaultDuration {
+            keyTimes = [0, 0.5*duration, duration]
+        }
+    }
 
     func render(geometry: GeometryProxy) -> some View {
         let dimension = min(geometry.size.width, geometry.size.height)
@@ -55,7 +65,7 @@ public struct BallClipRotate: View {
 
     struct BallClipRotate_Previews: PreviewProvider {
         static var previews: some View {
-            BallClipRotate()
+            BallClipRotate(duration: 0.75)
         }
     }
 }

Sources/BallClipRotateMultiple.swift

@@ -34,11 +34,45 @@ struct HorizontalRing: Shape {
 }
 
 public struct BallClipRotateMultiple: View {
+    private var duration: Double
+    private var defaultDuration = 1.0
+    private var keyTimes: Array<Double> = []
+    private var rotationValues: Array<Double> = []
+    private var scaleValues: Array<CGFloat> = [1, 0.95, 0.90, 0.85, 0.80, 0.75, 0.70, 0.65, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1]
     public var body: some View {
         GeometryReader(content: self.render)
     }
 
-    public init() { }
+    public init(duration: Double) {
+        rotationValues.append(-2 * -.pi)
+        if duration <= defaultDuration {
+            self.duration = defaultDuration
+            rotationValues.append(-.pi)
+            keyTimes.append(contentsOf: [1, 0.5])
+
+        } else {
+            self.duration = duration
+        }
+        if duration > defaultDuration {
+            let topNum = Int(duration.rounded() + 1)
+            for num in 1...topNum {
+//                print("ballClipRotateMultiple.num = \(num)")
+                let finalValue = 1/Double(num)
+                keyTimes.append(finalValue)
+            }
+            for num in 1...topNum-1 {
+                let finalValue = 1/Double(num)
+                rotationValues.append(.pi * -finalValue)
+            }
+        }
+//        print("ballClipRotateMultiple.scaleValues = \(scaleValues)")
+        rotationValues.append(0)
+        rotationValues.reverse()
+//        print("ballClipRotateMultiple.rotationValues = \(rotationValues)")
+        keyTimes.append(0)
+        keyTimes.reverse()
+//        print("ballClipRotateMultiple.keyTimes = \(keyTimes)")
+    }
 
     func render(geometry: GeometryProxy) -> some View {
         let dimension = min(geometry.size.width, geometry.size.height)
@@ -50,11 +84,11 @@ public struct BallClipRotateMultiple: View {
     }
 
     func renderMyBigRing() -> some View {
-        let duration = 1.0
+        let duration = duration
         let timingFunction = TimingFunction.easeInOut
-        let keyTimes = [0, 0.5, 1]
-        let scaleValues: [CGFloat] = [1, 0.6, 1]
-        let rotationValues = [0.0, .pi, 2 * .pi]
+        let keyTimes = keyTimes
+        let scaleValues: [CGFloat] = scaleValues
+        let rotationValues = rotationValues
         let timingFunctions = Array(repeating: timingFunction, count: keyTimes.count - 1)
 
         return KeyframeAnimationController(beginTime: 0,
@@ -68,11 +102,11 @@ public struct BallClipRotateMultiple: View {
     }
 
     func renderMySmallRing() -> some View {
-        let duration = 1.0
+        let duration = duration
         let timingFunction = TimingFunction.easeInOut
-        let keyTimes = [0, 0.5, 1]
-        let scaleValues: [CGFloat] = [1, 0.6, 1]
-        let rotationValues = [0.0, -.pi, -2 * .pi]
+        let keyTimes = keyTimes
+        let scaleValues: [CGFloat] = scaleValues
+        let rotationValues = rotationValues
         let timingFunctions = Array(repeating: timingFunction, count: keyTimes.count - 1)
 
         return KeyframeAnimationController(beginTime: 0,
@@ -89,6 +123,6 @@ public struct BallClipRotateMultiple: View {
 
 struct BallClipRotateMultiple_Previews: PreviewProvider {
     static var previews: some View {
-        BallClipRotateMultiple()
+        BallClipRotateMultiple(duration: 1.0)
     }
 }

Sources/BallClipRotatePulse.swift

@@ -34,11 +34,53 @@ struct VerticalRing: Shape {
 }
 
 public struct BallClipRotatePulse: View {
+    private var duration: Double
+    private var defaultDuration = 1.0
+    private var ringKeyTimes: Array<Double> = []
+    private var ringScaleValues: Array<CGFloat> = [1, 0.95, 0.90, 0.85, 0.80, 0.75, 0.70, 0.65, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1]
+    private var ringRotationValues: Array<Double> = []
+    private var ballKeyTimes: Array<Double> = []
+    private var ballScaleValues: Array<CGFloat> = [1, 0.95, 0.90, 0.85, 0.80, 0.75, 0.70, 0.65, 0.60, 0.55, 0.50, 0.45, 0.40, 0.35, 0.30, 0.35, 0.40, 0.45, 0.50, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95, 1]
     public var body: some View {
         GeometryReader(content: self.render)
     }
 
-    public init() { }
+    public init(duration: Double) {
+        ringRotationValues.append(-2 * -.pi)
+        if duration <= defaultDuration {
+            self.duration = defaultDuration
+            ringRotationValues.append(-.pi)
+            ringKeyTimes.append(contentsOf: [1, 0.5])
+            ballKeyTimes.append(contentsOf: [1, 0.5])
+        } else {
+            self.duration = duration
+        }
+        if duration > defaultDuration {
+//            ringKeyTimes = [0, 0.5*duration, duration]
+//            ballKeyTimes = [0, 0.3*duration, duration]
+            let topNum = Int(duration.rounded() + 1)
+            for num in 1...topNum {
+                print("BallClipRotatePulse.num = \(num)")
+                ballKeyTimes.append(0.3 * Double(num))
+                ringKeyTimes.append(0.5 * Double(num))
+            }
+            for num in 1...topNum-1 {
+                let finalValue = 1/Double(num)
+                ringRotationValues.append(.pi * -finalValue)
+            }
+        }
+        ringRotationValues.append(0)
+        ringRotationValues.reverse()
+//        print("BallClipRotatePulse.ringRotationValues = \(ringRotationValues)")
+        ringKeyTimes.reverse()
+        ringKeyTimes.append(0)
+        ringKeyTimes.reverse()
+//        print("BallClipRotatePulse.ringKeyTimes = \(ringKeyTimes)")
+        ballKeyTimes.reverse()
+        ballKeyTimes.append(0)
+        ballKeyTimes.reverse()
+//        print("BallClipRotatePulse.ballKeyTimes = \(ballKeyTimes)")
+    }
 
     func render(geometry: GeometryProxy) -> some View {
         let dimension = min(geometry.size.width, geometry.size.height)
@@ -50,11 +92,11 @@ public struct BallClipRotatePulse: View {
     }
 
     func renderMyRing() -> some View {
-        let duration = 1.0
+        let duration = duration
         let timingFunction = TimingFunction.timingCurve(c0x: 0.09, c0y: 0.57, c1x: 0.49, c1y: 0.9)
-        let keyTimes = [0, 0.5, 1]
-        let scaleValues: [CGFloat] = [1, 0.6, 1]
-        let rotationValues = [0.0, .pi, 2 * .pi]
+        let keyTimes = ringKeyTimes
+        let scaleValues: [CGFloat] = ringScaleValues
+        let rotationValues = ringRotationValues
         let timingFunctions = Array(repeating: timingFunction, count: keyTimes.count - 1)
 
         return KeyframeAnimationController(beginTime: 0,
@@ -68,10 +110,10 @@ public struct BallClipRotatePulse: View {
     }
 
     func renderBall() -> some View {
-        let duration = 1.0
+        let duration = duration
         let timingFunction = TimingFunction.timingCurve(c0x: 0.09, c0y: 0.57, c1x: 0.49, c1y: 0.9)
-        let keyTimes = [0, 0.3, 1]
-        let values: [CGFloat] = [1, 0.3, 1]
+        let keyTimes = ballKeyTimes
+        let values: [CGFloat] = ballScaleValues
         let timingFunctions = Array(repeating: timingFunction, count: keyTimes.count - 1)
 
         return KeyframeAnimationController(beginTime: 0,
@@ -87,6 +129,6 @@ public struct BallClipRotatePulse: View {
 
 struct BallClipRotatePulse_Previews: PreviewProvider {
     static var previews: some View {
-        BallClipRotatePulse()
+        BallClipRotatePulse(duration: 1.0)
     }
 }

Sources/BallPulse.swift

@@ -10,16 +10,26 @@ import SwiftUI
 
 public struct BallPulse: View {
     private let beginTimes = [0.12, 0.24, 0.36]
-    private let duration = 0.75
+    private let duration: Double
+    private let defaultDuration = 0.75
     private let timingFunction = TimingFunction.timingCurve(c0x: 0.2, c0y: 0.68, c1x: 0.18, c1y: 1.08)
-    private let keyTimes = [0, 0.3, 1]
+    private var keyTimes: Array<Double> = [0, 0.3, 1]
     private let values: [CGFloat] = [1, 0.3, 1]
 
     public var body: some View {
         GeometryReader(content: self.render)
     }
 
-    public init() { }
+    public init(duration: Double) {
+        if duration <= defaultDuration {
+            self.duration = defaultDuration
+        } else {
+            self.duration = duration
+        }
+        if duration > defaultDuration {
+            keyTimes = [0, (0.3*duration), duration]
+        }
+    }
 
     func render(geometry: GeometryProxy) -> some View {
         let dimension = min(geometry.size.width, geometry.size.height)
@@ -42,6 +52,6 @@ public struct BallPulse: View {
 
 struct BallPulse_Previews: PreviewProvider {
     static var previews: some View {
-        BallPulse()
+        BallPulse(duration: 0.75)
     }
 }