rework deterministic lockstep for 144hz compatabily

src/Engines/engine.ts

@@ -366,7 +366,7 @@ export class Engine extends ThinEngine {
     public onCanvasFocusObservable = new Observable<Engine>();
 
     /**
-     * Observable event triggered each time the canvas receives pointerout event
+     * Observable event triggered each time the canvas receives pointerout evet
      */
     public onCanvasPointerOutObservable = new Observable<PointerEvent>();
 
@@ -427,6 +427,7 @@ export class Engine extends ThinEngine {
     // Deterministic lockstepMaxSteps
     private _deterministicLockstep: boolean = false;
     private _lockstepMaxSteps: number = 4;
+    private _timeStep: number = 1 / 60;
 
     protected get _supportsHardwareTextureRescaling() {
         return !!Engine._RescalePostProcessFactory;
@@ -586,6 +587,8 @@ export class Engine extends ThinEngine {
 
             this._deterministicLockstep = !!options.deterministicLockstep;
             this._lockstepMaxSteps = options.lockstepMaxSteps || 0;
+            this._timeStep = options.timeStep || 1 / 60;
+
         }
 
         // Load WebVR Devices
@@ -667,6 +670,14 @@ export class Engine extends ThinEngine {
     }
 
     /**
+     * Returns the time in ms between steps when using deterministic lock step.
+     * @returns time step in (ms)
+     */
+    public getTimeStep(): number {
+        return this._timeStep * 1000;
+    }
+
+    /**
      * Force the mipmap generation for the given render target texture
      * @param texture defines the render target texture to use
      */

src/Engines/thinEngine.ts

@@ -88,10 +88,13 @@ export interface EngineOptions extends WebGLContextAttributes {
     deterministicLockstep?: boolean;
     /** Defines the maximum steps to use with deterministic lock step mode */
     lockstepMaxSteps?: number;
+    /** Defines the seconds between each deterministic lock step */
+    timeStep?: number;
     /**
      * Defines that engine should ignore context lost events
      * If this event happens when this parameter is true, you will have to reload the page to restore rendering
      */
+
     doNotHandleContextLost?: boolean;
     /**
      * Defines that engine should ignore modifying touch action attribute and style
@@ -483,6 +486,10 @@ export class ThinEngine {
                 options.lockstepMaxSteps = 4;
             }
 
+            if (options.timeStep === undefined) {
+                options.timeStep = 1 / 60;
+            }
+
             if (options.preserveDrawingBuffer === undefined) {
                 options.preserveDrawingBuffer = false;
             }

src/scene.ts

@@ -3739,6 +3739,7 @@ export class Scene extends AbstractScene implements IAnimatable {
      * User updatable function that will return a deterministic frame time when engine is in deterministic lock step mode
      */
     public getDeterministicFrameTime: () => number = () => {
+        // return this._engine.getTimeStep();
         return 1000.0 / 60.0; // frame time in ms
     }
 
@@ -3752,18 +3753,17 @@ export class Scene extends AbstractScene implements IAnimatable {
         if (this._engine.isDeterministicLockStep()) {
             var deltaTime = Math.max(Scene.MinDeltaTime, Math.min(this._engine.getDeltaTime(), Scene.MaxDeltaTime)) + this._timeAccumulator;
 
-            var defaultFPS = (60.0 / 1000.0);
-
-            let defaultFrameTime = this.getDeterministicFrameTime();
+            let defaultFrameTime = this._engine.getTimeStep();
+            var defaultFPS = (1000.0 / defaultFrameTime) / 1000.0;
 
             let stepsTaken = 0;
 
             var maxSubSteps = this._engine.getLockstepMaxSteps();
 
-            var internalSteps = Math.floor(deltaTime / (1000 * defaultFPS));
+            var internalSteps = Math.floor(deltaTime / defaultFrameTime);
             internalSteps = Math.min(internalSteps, maxSubSteps);
 
-            do {
+            while (deltaTime > 0 && stepsTaken < internalSteps) {
                 this.onBeforeStepObservable.notifyObservers(this);
 
                 // Animations
@@ -3780,10 +3780,31 @@ export class Scene extends AbstractScene implements IAnimatable {
                 stepsTaken++;
                 deltaTime -= defaultFrameTime;
 
-            } while (deltaTime > 0 && stepsTaken < internalSteps);
+            }
 
             this._timeAccumulator = deltaTime < 0 ? 0 : deltaTime;
 
+            // var internalSteps = Math.floor(deltaTime / (1000 * defaultFPS));
+            // internalSteps = Math.min(internalSteps, maxSubSteps);
+            // do {
+            //     this.onBeforeStepObservable.notifyObservers(this);
+
+            //     // Animations
+            //     this._animationRatio = defaultFrameTime * defaultFPS;
+            //     this._animate();
+            //     this.onAfterAnimationsObservable.notifyObservers(this);
+
+            //     // Physics
+            //     this._advancePhysicsEngineStep(defaultFrameTime);
+
+            //     this.onAfterStepObservable.notifyObservers(this);
+            //     this._currentStepId++;
+
+            //     stepsTaken++;
+            //     deltaTime -= defaultFrameTime;
+
+            // } while (deltaTime > 0 && stepsTaken < internalSteps);
+
         }
         else {
             // Animations