Merge pull request #12448 from smoogipoo/gcc-abstraction

Make GameplayClockContainer abstract and add MasterGameplayClockContainer

osu.Game.Rulesets.Osu.Tests/TestSceneSpinnerRotation.cs

@@ -21,6 +21,7 @@ using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.Replays;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
+using osu.Game.Screens.Play;
 using osu.Game.Storyboards;
 using osu.Game.Tests.Visual;
 using osuTK;
@@ -193,7 +194,7 @@ namespace osu.Game.Rulesets.Osu.Tests
 
             addSeekStep(0);
 
-            AddStep("adjust track rate", () => Player.GameplayClockContainer.UserPlaybackRate.Value = rate);
+            AddStep("adjust track rate", () => ((MasterGameplayClockContainer)Player.GameplayClockContainer).UserPlaybackRate.Value = rate);
 
             addSeekStep(1000);
             AddAssert("progress almost same", () => Precision.AlmostEquals(expectedProgress, drawableSpinner.Progress, 0.05));

osu.Game.Tests/Gameplay/TestSceneGameplayClockContainer.cs

@@ -1,32 +0,0 @@
-// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using NUnit.Framework;
-using osu.Framework.Testing;
-using osu.Game.Rulesets.Osu;
-using osu.Game.Screens.Play;
-using osu.Game.Tests.Visual;
-
-namespace osu.Game.Tests.Gameplay
-{
-    [HeadlessTest]
-    public class TestSceneGameplayClockContainer : OsuTestScene
-    {
-        [Test]
-        public void TestStartThenElapsedTime()
-        {
-            GameplayClockContainer gcc = null;
-
-            AddStep("create container", () =>
-            {
-                var working = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
-                working.LoadTrack();
-
-                Add(gcc = new GameplayClockContainer(working, 0));
-            });
-
-            AddStep("start track", () => gcc.Start());
-            AddUntilStep("elapsed greater than zero", () => gcc.GameplayClock.ElapsedFrameTime > 0);
-        }
-    }
-}

osu.Game.Tests/Gameplay/TestSceneMasterGameplayClockContainer.cs

@@ -0,0 +1,58 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Testing;
+using osu.Game.Rulesets.Osu;
+using osu.Game.Screens.Play;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Tests.Gameplay
+{
+    [HeadlessTest]
+    public class TestSceneMasterGameplayClockContainer : OsuTestScene
+    {
+        [Test]
+        public void TestStartThenElapsedTime()
+        {
+            GameplayClockContainer gcc = null;
+
+            AddStep("create container", () =>
+            {
+                var working = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
+                working.LoadTrack();
+
+                Add(gcc = new MasterGameplayClockContainer(working, 0));
+            });
+
+            AddStep("start clock", () => gcc.Start());
+            AddUntilStep("elapsed greater than zero", () => gcc.GameplayClock.ElapsedFrameTime > 0);
+        }
+
+        [Test]
+        public void TestElapseThenReset()
+        {
+            GameplayClockContainer gcc = null;
+
+            AddStep("create container", () =>
+            {
+                var working = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
+                working.LoadTrack();
+
+                Add(gcc = new MasterGameplayClockContainer(working, 0));
+            });
+
+            AddStep("start clock", () => gcc.Start());
+            AddUntilStep("current time greater 2000", () => gcc.GameplayClock.CurrentTime > 2000);
+
+            double timeAtReset = 0;
+            AddStep("reset clock", () =>
+            {
+                timeAtReset = gcc.GameplayClock.CurrentTime;
+                gcc.Reset();
+            });
+
+            AddAssert("current time < time at reset", () => gcc.GameplayClock.CurrentTime < timeAtReset);
+        }
+    }
+}

osu.Game.Tests/Gameplay/TestSceneStoryboardSamples.cs

@@ -20,6 +20,7 @@ using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
+using osu.Game.Rulesets.UI;
 using osu.Game.Screens.Play;
 using osu.Game.Skinning;
 using osu.Game.Storyboards;
@@ -67,15 +68,17 @@ namespace osu.Game.Tests.Gameplay
                 var working = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
                 working.LoadTrack();
 
-                Add(gameplayContainer = new GameplayClockContainer(working, 0));
+                Add(gameplayContainer = new MasterGameplayClockContainer(working, 0)
-
-                gameplayContainer.Add(sample = new DrawableStoryboardSample(new StoryboardSampleInfo(string.Empty, 0, 1))
                 {
-                    Clock = gameplayContainer.GameplayClock
+                    IsPaused = { Value = true },
+                    Child = new FrameStabilityContainer
+                    {
+                        Child = sample = new DrawableStoryboardSample(new StoryboardSampleInfo(string.Empty, 0, 1))
+                    }
                 });
             });
 
-            AddStep("start time", () => gameplayContainer.Start());
+            AddStep("reset clock", () => gameplayContainer.Start());
 
             AddUntilStep("sample played", () => sample.RequestedPlaying);
             AddUntilStep("sample has lifetime end", () => sample.LifetimeEnd < double.MaxValue);
@@ -92,11 +95,13 @@ namespace osu.Game.Tests.Gameplay
                 var working = CreateWorkingBeatmap(new OsuRuleset().RulesetInfo);
                 working.LoadTrack();
 
-                Add(gameplayContainer = new GameplayClockContainer(working, 1000, true));
+                Add(gameplayContainer = new MasterGameplayClockContainer(working, 1000, true)
-
-                gameplayContainer.Add(sample = new DrawableStoryboardSample(new StoryboardSampleInfo(string.Empty, 0, 1))
                 {
-                    Clock = gameplayContainer.GameplayClock
+                    IsPaused = { Value = true },
+                    Child = new FrameStabilityContainer
+                    {
+                        Child = sample = new DrawableStoryboardSample(new StoryboardSampleInfo(string.Empty, 0, 1))
+                    }
                 });
             });
 
@@ -140,7 +145,7 @@ namespace osu.Game.Tests.Gameplay
 
                 var beatmapSkinSourceContainer = new BeatmapSkinProvidingContainer(Beatmap.Value.Skin);
 
-                Add(gameplayContainer = new GameplayClockContainer(Beatmap.Value, 0)
+                Add(gameplayContainer = new MasterGameplayClockContainer(Beatmap.Value, 0)
                 {
                     Child = beatmapSkinSourceContainer
                 });

osu.Game.Tests/Visual/Gameplay/TestSceneLeadIn.cs

@@ -130,9 +130,9 @@ namespace osu.Game.Tests.Visual.Gameplay
 
             public double GameplayClockTime => GameplayClockContainer.GameplayClock.CurrentTime;
 
-            protected override void UpdateAfterChildren()
+            protected override void Update()
             {
-                base.UpdateAfterChildren();
+                base.Update();
 
                 if (!FirstFrameClockTime.HasValue)
                 {

osu.Game.Tests/Visual/Gameplay/TestSceneSkipOverlay.cs

@@ -33,7 +33,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             var working = CreateWorkingBeatmap(CreateBeatmap(new OsuRuleset().RulesetInfo));
             working.LoadTrack();
 
-            Child = gameplayClockContainer = new GameplayClockContainer(working, 0)
+            Child = gameplayClockContainer = new MasterGameplayClockContainer(working, 0)
             {
                 RelativeSizeAxes = Axes.Both,
                 Children = new Drawable[]
@@ -80,7 +80,7 @@ namespace osu.Game.Tests.Visual.Gameplay
             AddStep("move mouse", () => InputManager.MoveMouseTo(skip.ScreenSpaceDrawQuad.Centre));
             AddStep("click", () =>
             {
-                increment = skip_time - gameplayClock.CurrentTime - GameplayClockContainer.MINIMUM_SKIP_TIME / 2;
+                increment = skip_time - gameplayClock.CurrentTime - MasterGameplayClockContainer.MINIMUM_SKIP_TIME / 2;
                 InputManager.Click(MouseButton.Left);
             });
             AddStep("click", () => InputManager.Click(MouseButton.Left));

osu.Game/Screens/Play/GameplayClock.cs

@@ -19,7 +19,7 @@ namespace osu.Game.Screens.Play
     /// </summary>
     public class GameplayClock : IFrameBasedClock
     {
-        private readonly IFrameBasedClock underlyingClock;
+        internal readonly IFrameBasedClock UnderlyingClock;
 
         public readonly BindableBool IsPaused = new BindableBool();
 
@@ -30,12 +30,12 @@ namespace osu.Game.Screens.Play
 
         public GameplayClock(IFrameBasedClock underlyingClock)
         {
-            this.underlyingClock = underlyingClock;
+            UnderlyingClock = underlyingClock;
         }
 
-        public double CurrentTime => underlyingClock.CurrentTime;
+        public double CurrentTime => UnderlyingClock.CurrentTime;
 
-        public double Rate => underlyingClock.Rate;
+        public double Rate => UnderlyingClock.Rate;
 
         /// <summary>
         /// The rate of gameplay when playback is at 100%.
@@ -59,19 +59,19 @@ namespace osu.Game.Screens.Play
             }
         }
 
-        public bool IsRunning => underlyingClock.IsRunning;
+        public bool IsRunning => UnderlyingClock.IsRunning;
 
         public void ProcessFrame()
         {
             // intentionally not updating the underlying clock (handled externally).
         }
 
-        public double ElapsedFrameTime => underlyingClock.ElapsedFrameTime;
+        public double ElapsedFrameTime => UnderlyingClock.ElapsedFrameTime;
 
-        public double FramesPerSecond => underlyingClock.FramesPerSecond;
+        public double FramesPerSecond => UnderlyingClock.FramesPerSecond;
 
-        public FrameTimeInfo TimeInfo => underlyingClock.TimeInfo;
+        public FrameTimeInfo TimeInfo => UnderlyingClock.TimeInfo;
 
-        public IClock Source => underlyingClock;
+        public IClock Source => UnderlyingClock;
     }
 }

osu.Game/Screens/Play/GameplayClockContainer.cs

@@ -1,300 +1,148 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using System.Threading.Tasks;
-using osu.Framework;
 using osu.Framework.Allocation;
-using osu.Framework.Audio;
-using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Timing;
-using osu.Game.Beatmaps;
-using osu.Game.Configuration;
 
 namespace osu.Game.Screens.Play
 {
     /// <summary>
-    /// Encapsulates gameplay timing logic and provides a <see cref="Play.GameplayClock"/> for children.
+    /// Encapsulates gameplay timing logic and provides a <see cref="GameplayClock"/> via DI for gameplay components to use.
     /// </summary>
-    public class GameplayClockContainer : Container
+    public abstract class GameplayClockContainer : Container
     {
-        private readonly WorkingBeatmap beatmap;
+        /// <summary>
-
+        /// The final clock which is exposed to gameplay components.
-        [NotNull]
+        /// </summary>
-        private ITrack track;
+        public GameplayClock GameplayClock { get; private set; }
 
+        /// <summary>
+        /// Whether gameplay is paused.
+        /// </summary>
         public readonly BindableBool IsPaused = new BindableBool();
 
         /// <summary>
-        /// The decoupled clock used for gameplay. Should be used for seeks and clock control.
+        /// The adjustable source clock used for gameplay. Should be used for seeks and clock control.
         /// </summary>
-        private readonly DecoupleableInterpolatingFramedClock adjustableClock;
+        protected readonly DecoupleableInterpolatingFramedClock AdjustableSource;
-
-        private readonly double gameplayStartTime;
-        private readonly bool startAtGameplayStart;
-
-        private readonly double firstHitObjectTime;
-
-        public readonly BindableNumber<double> UserPlaybackRate = new BindableDouble(1)
-        {
-            Default = 1,
-            MinValue = 0.5,
-            MaxValue = 2,
-            Precision = 0.1,
-        };
 
         /// <summary>
-        /// The final clock which is exposed to underlying components.
+        /// The source clock.
         /// </summary>
-        public GameplayClock GameplayClock => localGameplayClock;
+        protected IClock SourceClock { get; private set; }
-
-        [Cached(typeof(GameplayClock))]
-        private readonly LocalGameplayClock localGameplayClock;
-
-        private Bindable<double> userAudioOffset;
-
-        private readonly FramedOffsetClock userOffsetClock;
-
-        private readonly FramedOffsetClock platformOffsetClock;
 
         /// <summary>
         /// Creates a new <see cref="GameplayClockContainer"/>.
         /// </summary>
-        /// <param name="beatmap">The beatmap being played.</param>
+        /// <param name="sourceClock">The source <see cref="IClock"/> used for timing.</param>
-        /// <param name="gameplayStartTime">The suggested time to start gameplay at.</param>
+        protected GameplayClockContainer(IClock sourceClock)
-        /// <param name="startAtGameplayStart">
-        /// Whether <paramref name="gameplayStartTime"/> should be used regardless of when storyboard events and hitobjects are supposed to start.
-        /// </param>
-        public GameplayClockContainer(WorkingBeatmap beatmap, double gameplayStartTime, bool startAtGameplayStart = false)
         {
-            this.beatmap = beatmap;
+            SourceClock = sourceClock;
-            this.gameplayStartTime = gameplayStartTime;
-            this.startAtGameplayStart = startAtGameplayStart;
-            track = beatmap.Track;
-
-            firstHitObjectTime = beatmap.Beatmap.HitObjects.First().StartTime;
 
             RelativeSizeAxes = Axes.Both;
 
-            adjustableClock = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
+            AdjustableSource = new DecoupleableInterpolatingFramedClock { IsCoupled = false };
+            IsPaused.BindValueChanged(OnIsPausedChanged);
+        }
 
-            // Lazer's audio timings in general doesn't match stable. This is the result of user testing, albeit limited.
+        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
-            // This only seems to be required on windows. We need to eventually figure out why, with a bit of luck.
+        {
-            platformOffsetClock = new HardwareCorrectionOffsetClock(adjustableClock) { Offset = RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? 15 : 0 };
+            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-
-            // the final usable gameplay clock with user-set offsets applied.
-            userOffsetClock = new HardwareCorrectionOffsetClock(platformOffsetClock);
-
-            // the clock to be exposed via DI to children.
-            localGameplayClock = new LocalGameplayClock(userOffsetClock);
 
+            dependencies.CacheAs(GameplayClock = CreateGameplayClock(AdjustableSource));
             GameplayClock.IsPaused.BindTo(IsPaused);
 
-            IsPaused.BindValueChanged(onPauseChanged);
+            return dependencies;
         }
 
-        private void onPauseChanged(ValueChangedEvent<bool> isPaused)
-        {
-            if (isPaused.NewValue)
-                this.TransformBindableTo(pauseFreqAdjust, 0, 200, Easing.Out).OnComplete(_ => adjustableClock.Stop());
-            else
-                this.TransformBindableTo(pauseFreqAdjust, 1, 200, Easing.In);
-        }
-
-        private double totalOffset => userOffsetClock.Offset + platformOffsetClock.Offset;
-
         /// <summary>
-        /// Duration before gameplay start time required before skip button displays.
+        /// Starts gameplay.
         /// </summary>
-        public const double MINIMUM_SKIP_TIME = 1000;
+        public virtual void Start()
-
-        private readonly BindableDouble pauseFreqAdjust = new BindableDouble(1);
-
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
         {
-            userAudioOffset = config.GetBindable<double>(OsuSetting.AudioOffset);
+            // Ensure that the source clock is set.
-            userAudioOffset.BindValueChanged(offset => userOffsetClock.Offset = offset.NewValue, true);
+            ChangeSource(SourceClock);
 
-            // sane default provided by ruleset.
+            if (!AdjustableSource.IsRunning)
-            double startTime = gameplayStartTime;
-
-            if (!startAtGameplayStart)
-            {
-                startTime = Math.Min(0, startTime);
-
-                // if a storyboard is present, it may dictate the appropriate start time by having events in negative time space.
-                // this is commonly used to display an intro before the audio track start.
-                double? firstStoryboardEvent = beatmap.Storyboard.EarliestEventTime;
-                if (firstStoryboardEvent != null)
-                    startTime = Math.Min(startTime, firstStoryboardEvent.Value);
-
-                // some beatmaps specify a current lead-in time which should be used instead of the ruleset-provided value when available.
-                // this is not available as an option in the live editor but can still be applied via .osu editing.
-                if (beatmap.BeatmapInfo.AudioLeadIn > 0)
-                    startTime = Math.Min(startTime, firstHitObjectTime - beatmap.BeatmapInfo.AudioLeadIn);
-            }
-
-            Seek(startTime);
-
-            adjustableClock.ProcessFrame();
-        }
-
-        public void Restart()
-        {
-            Task.Run(() =>
-            {
-                track.Seek(0);
-                track.Stop();
-
-                Schedule(() =>
-                {
-                    adjustableClock.ChangeSource(track);
-                    updateRate();
-
-                    if (!IsPaused.Value)
-                        Start();
-                });
-            });
-        }
-
-        public void Start()
-        {
-            if (!adjustableClock.IsRunning)
             {
                 // Seeking the decoupled clock to its current time ensures that its source clock will be seeked to the same time
-                // This accounts for the audio clock source potentially taking time to enter a completely stopped state
+                // This accounts for the clock source potentially taking time to enter a completely stopped state
                 Seek(GameplayClock.CurrentTime);
 
-                adjustableClock.Start();
+                AdjustableSource.Start();
             }
 
             IsPaused.Value = false;
         }
 
-        /// <summary>
-        /// Skip forward to the next valid skip point.
-        /// </summary>
-        public void Skip()
-        {
-            if (GameplayClock.CurrentTime > gameplayStartTime - MINIMUM_SKIP_TIME)
-                return;
-
-            double skipTarget = gameplayStartTime - MINIMUM_SKIP_TIME;
-
-            if (GameplayClock.CurrentTime < 0 && skipTarget > 6000)
-                // double skip exception for storyboards with very long intros
-                skipTarget = 0;
-
-            Seek(skipTarget);
-        }
-
         /// <summary>
         /// Seek to a specific time in gameplay.
-        /// <remarks>
-        /// Adjusts for any offsets which have been applied (so the seek may not be the expected point in time on the underlying audio track).
-        /// </remarks>
         /// </summary>
         /// <param name="time">The destination time to seek to.</param>
-        public void Seek(double time)
+        public virtual void Seek(double time)
         {
-            // remove the offset component here because most of the time we want the seek to be aligned to gameplay, not the audio track.
+            AdjustableSource.Seek(time);
-            // we may want to consider reversing the application of offsets in the future as it may feel more correct.
-            adjustableClock.Seek(time - totalOffset);
 
-            // manually process frame to ensure GameplayClock is correctly updated after a seek.
+            // Manually process to make sure the gameplay clock is correctly updated after a seek.
-            userOffsetClock.ProcessFrame();
+            GameplayClock.UnderlyingClock.ProcessFrame();
-        }
-
-        public void Stop()
-        {
-            IsPaused.Value = true;
         }
 
         /// <summary>
-        /// Changes the backing clock to avoid using the originally provided track.
+        /// Stops gameplay.
         /// </summary>
-        public void StopUsingBeatmapClock()
+        public virtual void Stop() => IsPaused.Value = true;
-        {
-            removeSourceClockAdjustments();
 
-            track = new TrackVirtual(track.Length);
+        /// <summary>
-            adjustableClock.ChangeSource(track);
+        /// Resets this <see cref="GameplayClockContainer"/> and the source to an initial state ready for gameplay.
+        /// </summary>
+        public virtual void Reset()
+        {
+            Seek(0);
+
+            // Manually stop the source in order to not affect the IsPaused state.
+            AdjustableSource.Stop();
+
+            if (!IsPaused.Value)
+                Start();
         }
 
+        /// <summary>
+        /// Changes the source clock.
+        /// </summary>
+        /// <param name="sourceClock">The new source.</param>
+        protected void ChangeSource(IClock sourceClock) => AdjustableSource.ChangeSource(SourceClock = sourceClock);
+
         protected override void Update()
         {
             if (!IsPaused.Value)
-            {
+                GameplayClock.UnderlyingClock.ProcessFrame();
-                userOffsetClock.ProcessFrame();
-            }
 
             base.Update();
         }
 
-        private bool speedAdjustmentsApplied;
+        /// <summary>
-
+        /// Invoked when the value of <see cref="IsPaused"/> is changed to start or stop the <see cref="AdjustableSource"/> clock.
-        private void updateRate()
+        /// </summary>
+        /// <param name="isPaused">Whether the clock should now be paused.</param>
+        protected virtual void OnIsPausedChanged(ValueChangedEvent<bool> isPaused)
         {
-            if (speedAdjustmentsApplied)
+            if (isPaused.NewValue)
-                return;
+                AdjustableSource.Stop();
-
+            else
-            track.AddAdjustment(AdjustableProperty.Frequency, pauseFreqAdjust);
+                AdjustableSource.Start();
-            track.AddAdjustment(AdjustableProperty.Tempo, UserPlaybackRate);
-
-            localGameplayClock.MutableNonGameplayAdjustments.Add(pauseFreqAdjust);
-            localGameplayClock.MutableNonGameplayAdjustments.Add(UserPlaybackRate);
-
-            speedAdjustmentsApplied = true;
         }
 
-        protected override void Dispose(bool isDisposing)
+        /// <summary>
-        {
+        /// Creates the final <see cref="GameplayClock"/> which is exposed via DI to be used by gameplay components.
-            base.Dispose(isDisposing);
+        /// </summary>
-            removeSourceClockAdjustments();
+        /// <remarks>
-        }
+        /// Any intermediate clocks such as platform offsets should be applied here.
-
+        /// </remarks>
-        private void removeSourceClockAdjustments()
+        /// <param name="source">The <see cref="IFrameBasedClock"/> providing the source time.</param>
-        {
+        /// <returns>The final <see cref="GameplayClock"/>.</returns>
-            if (!speedAdjustmentsApplied) return;
+        protected abstract GameplayClock CreateGameplayClock(IFrameBasedClock source);
-
-            track.RemoveAdjustment(AdjustableProperty.Frequency, pauseFreqAdjust);
-            track.RemoveAdjustment(AdjustableProperty.Tempo, UserPlaybackRate);
-
-            localGameplayClock.MutableNonGameplayAdjustments.Remove(pauseFreqAdjust);
-            localGameplayClock.MutableNonGameplayAdjustments.Remove(UserPlaybackRate);
-
-            speedAdjustmentsApplied = false;
-        }
-
-        private class LocalGameplayClock : GameplayClock
-        {
-            public readonly List<Bindable<double>> MutableNonGameplayAdjustments = new List<Bindable<double>>();
-
-            public override IEnumerable<Bindable<double>> NonGameplayAdjustments => MutableNonGameplayAdjustments;
-
-            public LocalGameplayClock(FramedOffsetClock underlyingClock)
-                : base(underlyingClock)
-            {
-            }
-        }
-
-        private class HardwareCorrectionOffsetClock : FramedOffsetClock
-        {
-            // we always want to apply the same real-time offset, so it should be adjusted by the difference in playback rate (from realtime) to achieve this.
-            // base implementation already adds offset at 1.0 rate, so we only add the difference from that here.
-            public override double CurrentTime => base.CurrentTime + Offset * (Rate - 1);
-
-            public HardwareCorrectionOffsetClock(IClock source, bool processSource = true)
-                : base(source, processSource)
-            {
-            }
-        }
     }
 }

osu.Game/Screens/Play/MasterGameplayClockContainer.cs

@@ -0,0 +1,233 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Track;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Timing;
+using osu.Game.Beatmaps;
+using osu.Game.Configuration;
+
+namespace osu.Game.Screens.Play
+{
+    /// <summary>
+    /// A <see cref="GameplayClockContainer"/> which uses a <see cref="WorkingBeatmap"/> as a source.
+    /// <para>
+    /// This is the most complete <see cref="GameplayClockContainer"/> which takes into account all user and platform offsets,
+    /// and provides implementations for user actions such as skipping or adjusting playback rates that may occur during gameplay.
+    /// </para>
+    /// </summary>
+    /// <remarks>
+    /// This is intended to be used as a single controller for gameplay, or as a reference source for other <see cref="GameplayClockContainer"/>s.
+    /// </remarks>
+    public class MasterGameplayClockContainer : GameplayClockContainer
+    {
+        /// <summary>
+        /// Duration before gameplay start time required before skip button displays.
+        /// </summary>
+        public const double MINIMUM_SKIP_TIME = 1000;
+
+        protected Track Track => (Track)SourceClock;
+
+        public readonly BindableNumber<double> UserPlaybackRate = new BindableDouble(1)
+        {
+            Default = 1,
+            MinValue = 0.5,
+            MaxValue = 2,
+            Precision = 0.1,
+        };
+
+        private double totalOffset => userOffsetClock.Offset + platformOffsetClock.Offset;
+
+        private readonly BindableDouble pauseFreqAdjust = new BindableDouble(1);
+
+        private readonly WorkingBeatmap beatmap;
+        private readonly double gameplayStartTime;
+        private readonly bool startAtGameplayStart;
+        private readonly double firstHitObjectTime;
+
+        private FramedOffsetClock userOffsetClock;
+        private FramedOffsetClock platformOffsetClock;
+        private MasterGameplayClock masterGameplayClock;
+        private Bindable<double> userAudioOffset;
+        private double startOffset;
+
+        public MasterGameplayClockContainer(WorkingBeatmap beatmap, double gameplayStartTime, bool startAtGameplayStart = false)
+            : base(beatmap.Track)
+        {
+            this.beatmap = beatmap;
+            this.gameplayStartTime = gameplayStartTime;
+            this.startAtGameplayStart = startAtGameplayStart;
+
+            firstHitObjectTime = beatmap.Beatmap.HitObjects.First().StartTime;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            userAudioOffset = config.GetBindable<double>(OsuSetting.AudioOffset);
+            userAudioOffset.BindValueChanged(offset => userOffsetClock.Offset = offset.NewValue, true);
+
+            // sane default provided by ruleset.
+            startOffset = gameplayStartTime;
+
+            if (!startAtGameplayStart)
+            {
+                startOffset = Math.Min(0, startOffset);
+
+                // if a storyboard is present, it may dictate the appropriate start time by having events in negative time space.
+                // this is commonly used to display an intro before the audio track start.
+                double? firstStoryboardEvent = beatmap.Storyboard.EarliestEventTime;
+                if (firstStoryboardEvent != null)
+                    startOffset = Math.Min(startOffset, firstStoryboardEvent.Value);
+
+                // some beatmaps specify a current lead-in time which should be used instead of the ruleset-provided value when available.
+                // this is not available as an option in the live editor but can still be applied via .osu editing.
+                if (beatmap.BeatmapInfo.AudioLeadIn > 0)
+                    startOffset = Math.Min(startOffset, firstHitObjectTime - beatmap.BeatmapInfo.AudioLeadIn);
+            }
+
+            Seek(startOffset);
+        }
+
+        protected override void OnIsPausedChanged(ValueChangedEvent<bool> isPaused)
+        {
+            // The source is stopped by a frequency fade first.
+            if (isPaused.NewValue)
+                this.TransformBindableTo(pauseFreqAdjust, 0, 200, Easing.Out).OnComplete(_ => AdjustableSource.Stop());
+            else
+                this.TransformBindableTo(pauseFreqAdjust, 1, 200, Easing.In);
+        }
+
+        public override void Start()
+        {
+            addSourceClockAdjustments();
+            base.Start();
+        }
+
+        /// <summary>
+        /// Seek to a specific time in gameplay.
+        /// </summary>
+        /// <remarks>
+        /// Adjusts for any offsets which have been applied (so the seek may not be the expected point in time on the underlying audio track).
+        /// </remarks>
+        /// <param name="time">The destination time to seek to.</param>
+        public override void Seek(double time)
+        {
+            // remove the offset component here because most of the time we want the seek to be aligned to gameplay, not the audio track.
+            // we may want to consider reversing the application of offsets in the future as it may feel more correct.
+            base.Seek(time - totalOffset);
+        }
+
+        /// <summary>
+        /// Skip forward to the next valid skip point.
+        /// </summary>
+        public void Skip()
+        {
+            if (GameplayClock.CurrentTime > gameplayStartTime - MINIMUM_SKIP_TIME)
+                return;
+
+            double skipTarget = gameplayStartTime - MINIMUM_SKIP_TIME;
+
+            if (GameplayClock.CurrentTime < 0 && skipTarget > 6000)
+                // double skip exception for storyboards with very long intros
+                skipTarget = 0;
+
+            Seek(skipTarget);
+        }
+
+        public override void Reset()
+        {
+            base.Reset();
+            Seek(startOffset);
+        }
+
+        protected override GameplayClock CreateGameplayClock(IFrameBasedClock source)
+        {
+            // Lazer's audio timings in general doesn't match stable. This is the result of user testing, albeit limited.
+            // This only seems to be required on windows. We need to eventually figure out why, with a bit of luck.
+            platformOffsetClock = new HardwareCorrectionOffsetClock(source) { Offset = RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? 15 : 0 };
+
+            // the final usable gameplay clock with user-set offsets applied.
+            userOffsetClock = new HardwareCorrectionOffsetClock(platformOffsetClock);
+
+            return masterGameplayClock = new MasterGameplayClock(userOffsetClock);
+        }
+
+        /// <summary>
+        /// Changes the backing clock to avoid using the originally provided track.
+        /// </summary>
+        public void StopUsingBeatmapClock()
+        {
+            removeSourceClockAdjustments();
+            ChangeSource(new TrackVirtual(beatmap.Track.Length));
+            addSourceClockAdjustments();
+        }
+
+        private bool speedAdjustmentsApplied;
+
+        private void addSourceClockAdjustments()
+        {
+            if (speedAdjustmentsApplied)
+                return;
+
+            Track.AddAdjustment(AdjustableProperty.Frequency, pauseFreqAdjust);
+            Track.AddAdjustment(AdjustableProperty.Tempo, UserPlaybackRate);
+
+            masterGameplayClock.MutableNonGameplayAdjustments.Add(pauseFreqAdjust);
+            masterGameplayClock.MutableNonGameplayAdjustments.Add(UserPlaybackRate);
+
+            speedAdjustmentsApplied = true;
+        }
+
+        private void removeSourceClockAdjustments()
+        {
+            if (!speedAdjustmentsApplied)
+                return;
+
+            Track.RemoveAdjustment(AdjustableProperty.Frequency, pauseFreqAdjust);
+            Track.RemoveAdjustment(AdjustableProperty.Tempo, UserPlaybackRate);
+
+            masterGameplayClock.MutableNonGameplayAdjustments.Remove(pauseFreqAdjust);
+            masterGameplayClock.MutableNonGameplayAdjustments.Remove(UserPlaybackRate);
+
+            speedAdjustmentsApplied = false;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            removeSourceClockAdjustments();
+        }
+
+        private class HardwareCorrectionOffsetClock : FramedOffsetClock
+        {
+            // we always want to apply the same real-time offset, so it should be adjusted by the difference in playback rate (from realtime) to achieve this.
+            // base implementation already adds offset at 1.0 rate, so we only add the difference from that here.
+            public override double CurrentTime => base.CurrentTime + Offset * (Rate - 1);
+
+            public HardwareCorrectionOffsetClock(IClock source, bool processSource = true)
+                : base(source, processSource)
+            {
+            }
+        }
+
+        private class MasterGameplayClock : GameplayClock
+        {
+            public readonly List<Bindable<double>> MutableNonGameplayAdjustments = new List<Bindable<double>>();
+
+            public override IEnumerable<Bindable<double>> NonGameplayAdjustments => MutableNonGameplayAdjustments;
+
+            public MasterGameplayClock(FramedOffsetClock underlyingClock)
+                : base(underlyingClock)
+            {
+            }
+        }
+    }
+}

osu.Game/Screens/Play/Player.cs

@@ -295,7 +295,7 @@ namespace osu.Game.Screens.Play
             IsBreakTime.BindValueChanged(onBreakTimeChanged, true);
         }
 
-        protected virtual GameplayClockContainer CreateGameplayClockContainer(WorkingBeatmap beatmap, double gameplayStart) => new GameplayClockContainer(beatmap, gameplayStart);
+        protected virtual GameplayClockContainer CreateGameplayClockContainer(WorkingBeatmap beatmap, double gameplayStart) => new MasterGameplayClockContainer(beatmap, gameplayStart);
 
         private Drawable createUnderlayComponents() =>
             DimmableStoryboard = new DimmableStoryboard(Beatmap.Value.Storyboard) { RelativeSizeAxes = Axes.Both };
@@ -342,7 +342,6 @@ namespace osu.Game.Screens.Play
                             Action = () => PerformExit(true),
                             IsPaused = { BindTarget = GameplayClockContainer.IsPaused }
                         },
-                        PlayerSettingsOverlay = { PlaybackSettings = { UserPlaybackRate = { BindTarget = GameplayClockContainer.UserPlaybackRate } } },
                         KeyCounter =
                         {
                             AlwaysVisible = { BindTarget = DrawableRuleset.HasReplayLoaded },
@@ -386,6 +385,9 @@ namespace osu.Game.Screens.Play
                 }
             };
 
+            if (GameplayClockContainer is MasterGameplayClockContainer master)
+                HUDOverlay.PlayerSettingsOverlay.PlaybackSettings.UserPlaybackRate.BindTarget = master.UserPlaybackRate;
+
             if (!Configuration.AllowSkippingIntro)
                 skipOverlay.Expire();
 
@@ -533,7 +535,8 @@ namespace osu.Game.Screens.Play
             // user requested skip
             // disable sample playback to stop currently playing samples and perform skip
             samplePlaybackDisabled.Value = true;
-            GameplayClockContainer.Skip();
+
+            (GameplayClockContainer as MasterGameplayClockContainer)?.Skip();
 
             // return samplePlaybackDisabled.Value to what is defined by the beatmap's current state
             updateSampleDisabledState();
@@ -808,7 +811,7 @@ namespace osu.Game.Screens.Play
             if (GameplayClockContainer.GameplayClock.IsRunning)
                 throw new InvalidOperationException($"{nameof(StartGameplay)} should not be called when the gameplay clock is already running");
 
-            GameplayClockContainer.Restart();
+            GameplayClockContainer.Reset();
         }
 
         public override void OnSuspending(IScreen next)
@@ -832,7 +835,7 @@ namespace osu.Game.Screens.Play
 
             // GameplayClockContainer performs seeks / start / stop operations on the beatmap's track.
             // as we are no longer the current screen, we cannot guarantee the track is still usable.
-            GameplayClockContainer?.StopUsingBeatmapClock();
+            (GameplayClockContainer as MasterGameplayClockContainer)?.StopUsingBeatmapClock();
 
             musicController.ResetTrackAdjustments();
 

osu.Game/Screens/Play/SkipOverlay.cs

@@ -90,7 +90,7 @@ namespace osu.Game.Screens.Play
 
         private const double fade_time = 300;
 
-        private double fadeOutBeginTime => startTime - GameplayClockContainer.MINIMUM_SKIP_TIME;
+        private double fadeOutBeginTime => startTime - MasterGameplayClockContainer.MINIMUM_SKIP_TIME;
 
         protected override void LoadComplete()
         {

osu.Game/Screens/Play/SpectatorPlayer.cs

@@ -61,7 +61,7 @@ namespace osu.Game.Screens.Play
             if (firstFrameTime == null || firstFrameTime <= gameplayStart + 5000)
                 return base.CreateGameplayClockContainer(beatmap, gameplayStart);
 
-            return new GameplayClockContainer(beatmap, firstFrameTime.Value, true);
+            return new MasterGameplayClockContainer(beatmap, firstFrameTime.Value, true);
         }
 
         public override bool OnExiting(IScreen next)