Merge pull request #6629 from peppy/adjustable-drift-recovery

Author: peppy

osu.Framework/Timing/InterpolatingFramedClock.cs

@@ -21,6 +21,30 @@ public sealed class InterpolatingFramedClock : IFrameBasedClock, ISourceChangeab
         /// </remarks>
         public double AllowableErrorMilliseconds { get; set; } = 1000.0 / 60 * 2;
 
+        /// <summary>
+        /// Drift recovery half-life in milliseconds. Defaults to 50 ms.
+        /// </summary>
+        /// <remarks>
+        /// The time error decays exponentially toward the source.
+        /// Every <see cref="DriftRecoveryHalfLife"/> ms, the remaining error halves.
+        ///
+        /// An example, starting at 10 ms error with an 50 ms half-life:
+        ///
+        /// - at 0 ms, error is 10 ms.
+        /// - at 50 ms, error is 5 ms.
+        /// - at 100 ms, error is 2.5 ms.
+        /// - at 150 ms, error is 1.25 ms.
+        /// ...
+        ///
+        /// To an observer, it will look like time has a temporary ramp applied to it:
+        ///
+        /// - If source is ahead, time will speed up and gradually approach original speed.
+        /// - If source is behind, time will slow down and gradually approach original speed.
+        ///
+        /// Only applies when the error is within <see cref="AllowableErrorMilliseconds"/>.
+        /// </remarks>
+        public double DriftRecoveryHalfLife { get; set; } = 50;
+
         /// <summary>
         /// Whether interpolation was applied at the last processed frame.
         /// </summary>
@@ -107,9 +131,8 @@ public void ProcessFrame()
                     // Then check the post-interpolated time.
                     // If we differ from the current time of the source, gradually approach the ground truth.
                     //
-                    // The remaining error halves every halfTime ms.
-                    // This may need further tweaking to be less discernible by users (upwards, likely?).
-                    currentTime = Interpolation.DampContinuously(currentTime, framedSourceClock.CurrentTime, 50, realtimeClock.ElapsedFrameTime);
+                    // The remaining error halves every half-life ms.
+                    currentTime = Interpolation.DampContinuously(currentTime, framedSourceClock.CurrentTime, DriftRecoveryHalfLife, realtimeClock.ElapsedFrameTime);
 
                     bool withinAllowableError = Math.Abs(framedSourceClock.CurrentTime - currentTime) <= AllowableErrorMilliseconds * Rate;