Unroll fixed stepDelta time updates

Author: STREGA

Sources/GateEngine/Game.swift

@@ -106,32 +106,37 @@ public final class Game {
 
     #if GATEENGINE_PLATFORM_EVENT_DRIVEN
     @MainActor internal func eventLoop(completion: @escaping () -> Void) {
-        guard let highPrecisionDeltaTime = deltaTimeHelper.getDeltaTime() else {
+        guard let fixedStepDeltaTime = deltaTimeHelper.getFixedStepDeltaTime() else {
             completion()
             return
         }
 
         // Add a high priority Task so we can jump the line if other Tasks were started
         Task(priority: .high) { @MainActor in
-            let deltaTime = Float(highPrecisionDeltaTime)
-            self.resourceManager.update(withTimePassed: deltaTime)
-            await windowManager.updateWindows(deltaTime: deltaTime)
-            self.windowManager.drawWindows()
-            if await self.ecs.shouldRenderAfterUpdate(
-                withTimePassed: Float(deltaTime)
-            ) {
+            var shouldRender = false
+            for _ in 0 ..< fixedStepDeltaTime.steps {
+                let deltaTime = Float(fixedStepDeltaTime.deltaTime)
+                self.resourceManager.update(withTimePassed: deltaTime)
+                await windowManager.updateWindows(deltaTime: deltaTime)
+                if await self.ecs.shouldRenderAfterUpdate(withTimePassed: deltaTime) {
+                    shouldRender = true
+                }else{
+                    break
+                }
+            }
+            if shouldRender {
                 self.windowManager.drawWindows()
-                completion()
-            } else {
+            }else{
                 #if GATEENGINE_DEBUG_RENDERING
                 Log.warn("Frame Dropped", "DeltaTime:", deltaTime)
                 #endif
-                completion()
             }
+            completion()
         }
     }
     #else
     internal func gameLoop() {
+        #error("Needs to rewritten to match EventDriven!")
         guard let deltaTime = getNextDeltaTime() else {
             Task(priority: .high) { @MainActor in
                 self.gameLoop()

Sources/GateEngine/Helpers/DeltaTimeHelper.swift

@@ -5,81 +5,84 @@
  * http://stregasgate.com
  */
 
+/// Assits in creating fixed step deltaTime values
 internal struct DeltaTimeHelper {
     internal let name: String
-    private var accumulator: Double = 0
     private var previousTime: Double = .nan
 
     private static let preferredFrameRate: Int = Platform.current.prefferedFrameRate()
-    private static let simulationStepDuration: Double = 1 / Double(preferredFrameRate) / 2
+    private static let simulationStepDuration: Double = 1 / Double(preferredFrameRate) / 4.10
     private static let maxSimulationSteps: Int = 4
 
     internal init(name: String) {
         self.name = name
         self.reset()
     }
 
-    mutating func reset() {
-        self.accumulator = 0
+    /**
+     Revert to initial state.
+     
+     `DeltaTimeHelper` stores time to compute deltaTime.
+     Use this function to clear the stored time when it is known to be stale.
+     */
+    @inlinable mutating func reset() {
         self.previousTime = .nan
     }
 
+    /**
+     Computes a fixed step deltaTime based on the current platfo
+     - returns A fixed step deltaTime, or nil if the number of steps was zero.
+     */
     @MainActor
-    @inlinable
-    mutating func getDeltaTime() -> Double? {
+    @inlinable mutating func getFixedStepDeltaTime() -> (steps: Int, deltaTime: Double)? {
         let currentTime = Platform.current.systemTime()
 
         // Determine the new accumulator value
-        let newAccumulator: Double = self.accumulator + (currentTime - self.previousTime)
+        let literalDeltaTime: Double = currentTime - self.previousTime
 
         // If our accumulated time is less than a single step, bail
-        if newAccumulator < Self.simulationStepDuration {
+        if literalDeltaTime < Self.simulationStepDuration {
             return nil
         }
 
         // Update previousTime if we get this far
         self.previousTime = currentTime
 
         // If our accumulated time is not a number, bail
-        if newAccumulator.isFinite == false {
+        if literalDeltaTime.isFinite == false {
             return nil
         }
 
-        // Update the accumulator
-        self.accumulator = newAccumulator
-        
         // The number of steps that currently fit in the accumulator
-        let stepsRequired = Int(accumulator / Self.simulationStepDuration)
+        let stepsRequired = Int(literalDeltaTime / Self.simulationStepDuration)
 
-        // If stepsRequired is greater than maxSimulationSteps, return only that
-        // Erase the accumulator as this is likely a spike from a CPU hang
+        // If stepsRequired is greater than maxSimulationSteps, then truncate.
         if stepsRequired > Self.maxSimulationSteps {
-            // Anytime we return from here, the simulation will run slower.
+            #if !DEBUG && !DISTRIBUTE
+            // Anytime we return from here, the simulation is running slower.
             // This is similar in severity to a dropped frame and will happen if the simulation is lagging.
             // To reduce occurances of this, do less work.
-            // Try spreading complex tasks out across multiple updates.
-            let message = "\(name) deltaTime attempted to use \(stepsRequired) steps, and was truncated to \(Self.maxSimulationSteps)."
-            if stepsRequired > 15 {
+            // Try spreading work out across multiple updates.
+            let message = "\(name) needed \(stepsRequired) steps, and was truncated to \(Self.maxSimulationSteps)."
+            if stepsRequired > Self.maxSimulationSteps * 2 {
                 Log.warn(message, "This is a \(String(format: "%0.3f", Self.simulationStepDuration * Double(stepsRequired))) second hang!")
-            }else{
-                Log.debug(message, "This is a minor performance issue.")
             }
-            
-            let maxSimulationSteps = Double(Self.maxSimulationSteps)
-            
-            // Zero the accumulator to give the next update the maximum time, becuase we just had a hang
-            self.accumulator = 0
+            #endif
 
             // Return the maximum allowed deltaTime
-            return Self.simulationStepDuration * maxSimulationSteps
+            return (Self.maxSimulationSteps, Self.simulationStepDuration)
         }
-        
-        // Calculate fixed step deltaTime
-        let deltaTime = Self.simulationStepDuration * Double(stepsRequired)
-        
-        // Remove the used time from the accumulator
-        self.accumulator -= deltaTime
-        
-        return deltaTime
+ 
+        return (stepsRequired, Self.simulationStepDuration)
+    }
+    
+    /**
+     Computes a fixed step deltaTime based on the current platfo
+     - returns A fixed step deltaTime, or nil if the number of steps was zero.
+     */
+    @MainActor
+    @inlinable mutating func getDeltaTime() -> Double? {
+        guard let fixedStepDeltaTime = self.getFixedStepDeltaTime() else {return nil}
+        return fixedStepDeltaTime.deltaTime * Double(fixedStepDeltaTime.steps)
     }
 }