h1or4dme8/osu-lazer
1
0
Fork 0
mirror of https://github.com/ppy/osu.git synced 2025-03-04 01:22:54 +08:00
Code Issues Releases Wiki Activity

Use FramedBeatmapClock in GameplayClockContainer

Browse Source
This commit is contained in:
Dean Herbert 2022-08-18 14:52:47 +09:00
parent 32e127a6fa
commit 6003afafc7
3 changed files with 113 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
osu.Game/Beatmaps/FramedBeatmapClock.cs
View File

@ -2,6 +2,7 @@
// See the LICENCE file in the repository root for full licence text. // See the LICENCE file in the repository root for full licence text.
using System; using System;
using System.Diagnostics;
using osu.Framework; using osu.Framework;
using osu.Framework.Allocation; using osu.Framework.Allocation;
using osu.Framework.Audio.Track; using osu.Framework.Audio.Track;
@ -16,6 +17,8 @@ namespace osu.Game.Beatmaps
{ {
public class FramedBeatmapClock : Component, IFrameBasedClock, IAdjustableClock, ISourceChangeableClock public class FramedBeatmapClock : Component, IFrameBasedClock, IAdjustableClock, ISourceChangeableClock
{ {
private readonly bool applyOffsets;
/// <summary> /// <summary>
/// The length of the underlying beatmap track. Will default to 60 seconds if unavailable. /// The length of the underlying beatmap track. Will default to 60 seconds if unavailable.
/// </summary> /// </summary>
@ -26,9 +29,16 @@ namespace osu.Game.Beatmaps
/// </summary> /// </summary>
public Track? Track { get; private set; } // TODO: virtual rather than null? public Track? Track { get; private set; } // TODO: virtual rather than null?
private readonly OffsetCorrectionClock userGlobalOffsetClock; /// <summary>
private readonly OffsetCorrectionClock platformOffsetClock; /// The total frequency adjustment from pause transforms. Should eventually be handled in a better way.
private readonly OffsetCorrectionClock finalOffsetClock; /// </summary>
public readonly BindableDouble ExternalPauseFrequencyAdjust = new BindableDouble(1);
private readonly OffsetCorrectionClock? userGlobalOffsetClock;
private readonly OffsetCorrectionClock? platformOffsetClock;
private readonly OffsetCorrectionClock? userBeatmapOffsetClock;
private readonly IFrameBasedClock finalClockSource;
private Bindable<double> userAudioOffset = null!; private Bindable<double> userAudioOffset = null!;
@ -36,7 +46,20 @@ namespace osu.Game.Beatmaps
private readonly DecoupleableInterpolatingFramedClock decoupledClock; private readonly DecoupleableInterpolatingFramedClock decoupledClock;
private double totalAppliedOffset => userGlobalOffsetClock.RateAdjustedOffset + finalOffsetClock.RateAdjustedOffset + platformOffsetClock.RateAdjustedOffset; private double totalAppliedOffset
{
get
{
if (!applyOffsets)
return 0;
Debug.Assert(userGlobalOffsetClock != null);
Debug.Assert(userBeatmapOffsetClock != null);
Debug.Assert(platformOffsetClock != null);
return userGlobalOffsetClock.RateAdjustedOffset + userBeatmapOffsetClock.RateAdjustedOffset + platformOffsetClock.RateAdjustedOffset;
}
}
[Resolved] [Resolved]
private OsuConfigManager config { get; set; } = null!; private OsuConfigManager config { get; set; } = null!;
@ -53,44 +76,59 @@ namespace osu.Game.Beatmaps
set => decoupledClock.IsCoupled = value; set => decoupledClock.IsCoupled = value;
} }
public FramedBeatmapClock(IClock? sourceClock = null) public FramedBeatmapClock(IClock? sourceClock = null, bool applyOffsets = false)
{ {
// TODO: Unused for now? this.applyOffsets = applyOffsets;
var pauseFreqAdjust = new BindableDouble(1);
// A decoupled clock is used to ensure precise time values even when the host audio subsystem is not reporting // A decoupled clock is used to ensure precise time values even when the host audio subsystem is not reporting
// high precision times (on windows there's generally only 5-10ms reporting intervals, as an example). // high precision times (on windows there's generally only 5-10ms reporting intervals, as an example).
decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = true }; decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = true };
decoupledClock.ChangeSource(sourceClock); decoupledClock.ChangeSource(sourceClock);
// Audio timings in general with newer BASS versions don't match stable. if (applyOffsets)
// This only seems to be required on windows. We need to eventually figure out why, with a bit of luck. {
platformOffsetClock = new OffsetCorrectionClock(decoupledClock, pauseFreqAdjust) { Offset = RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? 15 : 0 }; // Audio timings in general with newer BASS versions don't match stable.
// This only seems to be required on windows. We need to eventually figure out why, with a bit of luck.
platformOffsetClock = new OffsetCorrectionClock(decoupledClock, ExternalPauseFrequencyAdjust) { Offset = RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? 15 : 0 };
// User global offset (set in settings) should also be applied. // User global offset (set in settings) should also be applied.
userGlobalOffsetClock = new OffsetCorrectionClock(platformOffsetClock, pauseFreqAdjust); userGlobalOffsetClock = new OffsetCorrectionClock(platformOffsetClock, ExternalPauseFrequencyAdjust);
// User per-beatmap offset will be applied to this final clock. // User per-beatmap offset will be applied to this final clock.
finalOffsetClock = new OffsetCorrectionClock(userGlobalOffsetClock, pauseFreqAdjust); finalClockSource = userBeatmapOffsetClock = new OffsetCorrectionClock(userGlobalOffsetClock, ExternalPauseFrequencyAdjust);
}
else
{
finalClockSource = decoupledClock;
}
} }
protected override void LoadComplete() protected override void LoadComplete()
{ {
base.LoadComplete(); base.LoadComplete();
userAudioOffset = config.GetBindable<double>(OsuSetting.AudioOffset); if (applyOffsets)
userAudioOffset.BindValueChanged(offset => userGlobalOffsetClock.Offset = offset.NewValue, true); {
Debug.Assert(userBeatmapOffsetClock != null);
Debug.Assert(userGlobalOffsetClock != null);
beatmapOffsetSubscription = realm.SubscribeToPropertyChanged( userAudioOffset = config.GetBindable<double>(OsuSetting.AudioOffset);
r => r.Find<BeatmapInfo>(beatmap.Value.BeatmapInfo.ID)?.UserSettings, userAudioOffset.BindValueChanged(offset => userGlobalOffsetClock.Offset = offset.NewValue, true);
settings => settings.Offset,
val => finalOffsetClock.Offset = val); beatmapOffsetSubscription = realm.SubscribeToPropertyChanged(
r => r.Find<BeatmapInfo>(beatmap.Value.BeatmapInfo.ID)?.UserSettings,
settings => settings.Offset,
val =>
{
userBeatmapOffsetClock.Offset = val;
});
}
} }
protected override void Update() protected override void Update()
{ {
base.Update(); base.Update();
finalOffsetClock.ProcessFrame(); finalClockSource.ProcessFrame();
} }
protected override void Dispose(bool isDisposing) protected override void Dispose(bool isDisposing)
@ -112,25 +150,25 @@ namespace osu.Game.Beatmaps
public void Reset() public void Reset()
{ {
decoupledClock.Reset(); decoupledClock.Reset();
finalOffsetClock.ProcessFrame(); finalClockSource.ProcessFrame();
} }
public void Start() public void Start()
{ {
decoupledClock.Start(); decoupledClock.Start();
finalOffsetClock.ProcessFrame(); finalClockSource.ProcessFrame();
} }
public void Stop() public void Stop()
{ {
decoupledClock.Stop(); decoupledClock.Stop();
finalOffsetClock.ProcessFrame(); finalClockSource.ProcessFrame();
} }
public bool Seek(double position) public bool Seek(double position)
{ {
bool success = decoupledClock.Seek(position - totalAppliedOffset); bool success = decoupledClock.Seek(position - totalAppliedOffset);
finalOffsetClock.ProcessFrame(); finalClockSource.ProcessFrame();
return success; return success;
} }
@ -147,20 +185,20 @@ namespace osu.Game.Beatmaps
#region Delegation of IFrameBasedClock to clock with all offsets applied #region Delegation of IFrameBasedClock to clock with all offsets applied
public double CurrentTime => finalOffsetClock.CurrentTime; public double CurrentTime => finalClockSource.CurrentTime;
public bool IsRunning => finalOffsetClock.IsRunning; public bool IsRunning => finalClockSource.IsRunning;
public void ProcessFrame() public void ProcessFrame()
{ {
// Noop to ensure an external consumer doesn't process the internal clock an extra time. // Noop to ensure an external consumer doesn't process the internal clock an extra time.
} }
public double ElapsedFrameTime => finalOffsetClock.ElapsedFrameTime; public double ElapsedFrameTime => finalClockSource.ElapsedFrameTime;
public double FramesPerSecond => finalOffsetClock.FramesPerSecond; public double FramesPerSecond => finalClockSource.FramesPerSecond;
public FrameTimeInfo TimeInfo => finalOffsetClock.TimeInfo; public FrameTimeInfo TimeInfo => finalClockSource.TimeInfo;
#endregion #endregion
} }

86
osu.Game/Screens/Play/GameplayClockContainer.cs
View File

@ -11,12 +11,14 @@ using osu.Framework.Graphics.Containers;
using osu.Framework.Logging; using osu.Framework.Logging;
using osu.Framework.Timing; using osu.Framework.Timing;
using osu.Framework.Utils; using osu.Framework.Utils;
using osu.Game.Beatmaps;
namespace osu.Game.Screens.Play namespace osu.Game.Screens.Play
{ {
/// <summary> /// <summary>
/// Encapsulates gameplay timing logic and provides a <see cref="IGameplayClock"/> via DI for gameplay components to use. /// Encapsulates gameplay timing logic and provides a <see cref="IGameplayClock"/> via DI for gameplay components to use.
/// </summary> /// </summary>
[Cached(typeof(IGameplayClock))]
public class GameplayClockContainer : Container, IAdjustableClock, IGameplayClock public class GameplayClockContainer : Container, IAdjustableClock, IGameplayClock
{ {
/// <summary> /// <summary>
@ -45,44 +47,34 @@ namespace osu.Game.Screens.Play
public virtual IEnumerable<double> NonGameplayAdjustments => Enumerable.Empty<double>(); public virtual IEnumerable<double> NonGameplayAdjustments => Enumerable.Empty<double>();
/// <summary>
/// The final clock which is exposed to gameplay components.
/// </summary>
protected IFrameBasedClock FramedClock { get; private set; }
private readonly BindableBool isPaused = new BindableBool(true); private readonly BindableBool isPaused = new BindableBool(true);
/// <summary> /// <summary>
/// The adjustable source 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.
/// This is the final clock exposed to gameplay components as an <see cref="IGameplayClock"/>.
/// </summary> /// </summary>
private readonly DecoupleableInterpolatingFramedClock decoupledClock; protected readonly FramedBeatmapClock GameplayClock;
protected override Container<Drawable> Content { get; } = new Container { RelativeSizeAxes = Axes.Both };
/// <summary> /// <summary>
/// Creates a new <see cref="GameplayClockContainer"/>. /// Creates a new <see cref="GameplayClockContainer"/>.
/// </summary> /// </summary>
/// <param name="sourceClock">The source <see cref="IClock"/> used for timing.</param> /// <param name="sourceClock">The source <see cref="IClock"/> used for timing.</param>
public GameplayClockContainer(IClock sourceClock) /// <param name="applyOffsets">Whether to apply platform, user and beatmap offsets to the mix.</param>
public GameplayClockContainer(IClock sourceClock, bool applyOffsets = false)
{ {
SourceClock = sourceClock; SourceClock = sourceClock;
RelativeSizeAxes = Axes.Both; RelativeSizeAxes = Axes.Both;
decoupledClock = new DecoupleableInterpolatingFramedClock { IsCoupled = false }; InternalChildren = new Drawable[]
{
GameplayClock = new FramedBeatmapClock(sourceClock, applyOffsets) { IsCoupled = false },
Content
};
IsPaused.BindValueChanged(OnIsPausedChanged); IsPaused.BindValueChanged(OnIsPausedChanged);
// this will be replaced during load, but non-null for tests which don't add this component to the hierarchy.
FramedClock = new FramedClock();
}
protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
{
var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
FramedClock = CreateGameplayClock(decoupledClock);
dependencies.CacheAs<IGameplayClock>(this);
return dependencies;
} }
/// <summary> /// <summary>
@ -92,13 +84,13 @@ namespace osu.Game.Screens.Play
{ {
ensureSourceClockSet(); ensureSourceClockSet();
if (!decoupledClock.IsRunning) if (!GameplayClock.IsRunning)
{ {
// Seeking the decoupled clock to its current time ensures that its source clock will be seeked to the same time // Seeking the decoupled clock to its current time ensures that its source clock will be seeked to the same time
// This accounts for the 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(FramedClock.CurrentTime); Seek(GameplayClock.CurrentTime);
decoupledClock.Start(); GameplayClock.Start();
} }
isPaused.Value = false; isPaused.Value = false;
@ -112,10 +104,10 @@ namespace osu.Game.Screens.Play
{ {
Logger.Log($"{nameof(GameplayClockContainer)} seeking to {time}"); Logger.Log($"{nameof(GameplayClockContainer)} seeking to {time}");
decoupledClock.Seek(time); GameplayClock.Seek(time);
// Manually process to make sure the gameplay clock is correctly updated after a seek. // Manually process to make sure the gameplay clock is correctly updated after a seek.
FramedClock.ProcessFrame(); GameplayClock.ProcessFrame();
OnSeek?.Invoke(); OnSeek?.Invoke();
} }
@ -132,7 +124,7 @@ namespace osu.Game.Screens.Play
public void Reset(bool startClock = false) public void Reset(bool startClock = false)
{ {
// Manually stop the source in order to not affect the IsPaused state. // Manually stop the source in order to not affect the IsPaused state.
decoupledClock.Stop(); GameplayClock.Stop();
if (!IsPaused.Value || startClock) if (!IsPaused.Value || startClock)
Start(); Start();
@ -145,10 +137,10 @@ namespace osu.Game.Screens.Play
/// Changes the source clock. /// Changes the source clock.
/// </summary> /// </summary>
/// <param name="sourceClock">The new source.</param> /// <param name="sourceClock">The new source.</param>
protected void ChangeSource(IClock sourceClock) => decoupledClock.ChangeSource(SourceClock = sourceClock); protected void ChangeSource(IClock sourceClock) => GameplayClock.ChangeSource(SourceClock = sourceClock);
/// <summary> /// <summary>
/// Ensures that the <see cref="decoupledClock"/> is set to <see cref="SourceClock"/>, if it hasn't been given a source yet. /// Ensures that the <see cref="GameplayClock"/> is set to <see cref="SourceClock"/>, if it hasn't been given a source yet.
/// This is usually done before a seek to avoid accidentally seeking only the adjustable source in decoupled mode, /// This is usually done before a seek to avoid accidentally seeking only the adjustable source in decoupled mode,
/// but not the actual source clock. /// but not the actual source clock.
/// That will pretty much only happen on the very first call of this method, as the source clock is passed in the constructor, /// That will pretty much only happen on the very first call of this method, as the source clock is passed in the constructor,
@ -156,40 +148,30 @@ namespace osu.Game.Screens.Play
/// </summary> /// </summary>
private void ensureSourceClockSet() private void ensureSourceClockSet()
{ {
if (decoupledClock.Source == null) if (GameplayClock.Source == null)
ChangeSource(SourceClock); ChangeSource(SourceClock);
} }
protected override void Update() protected override void Update()
{ {
if (!IsPaused.Value) if (!IsPaused.Value)
FramedClock.ProcessFrame(); GameplayClock.ProcessFrame();
base.Update(); base.Update();
} }
/// <summary> /// <summary>
/// Invoked when the value of <see cref="IsPaused"/> is changed to start or stop the <see cref="decoupledClock"/> clock. /// Invoked when the value of <see cref="IsPaused"/> is changed to start or stop the <see cref="GameplayClock"/> clock.
/// </summary> /// </summary>
/// <param name="isPaused">Whether the clock should now be paused.</param> /// <param name="isPaused">Whether the clock should now be paused.</param>
protected virtual void OnIsPausedChanged(ValueChangedEvent<bool> isPaused) protected virtual void OnIsPausedChanged(ValueChangedEvent<bool> isPaused)
{ {
if (isPaused.NewValue) if (isPaused.NewValue)
decoupledClock.Stop(); GameplayClock.Stop();
else else
decoupledClock.Start(); GameplayClock.Start();
} }
/// <summary>
/// Creates the final <see cref="FramedClock"/> which is exposed via DI to be used by gameplay components.
/// </summary>
/// <remarks>
/// Any intermediate clocks such as platform offsets should be applied here.
/// </remarks>
/// <param name="source">The <see cref="IFrameBasedClock"/> providing the source time.</param>
/// <returns>The final <see cref="FramedClock"/>.</returns>
protected virtual IFrameBasedClock CreateGameplayClock(IFrameBasedClock source) => source;
#region IAdjustableClock #region IAdjustableClock
bool IAdjustableClock.Seek(double position) bool IAdjustableClock.Seek(double position)
@ -204,15 +186,15 @@ namespace osu.Game.Screens.Play
double IAdjustableClock.Rate double IAdjustableClock.Rate
{ {
get => FramedClock.Rate; get => GameplayClock.Rate;
set => throw new NotSupportedException(); set => throw new NotSupportedException();
} }
public double Rate => FramedClock.Rate; public double Rate => GameplayClock.Rate;
public double CurrentTime => FramedClock.CurrentTime; public double CurrentTime => GameplayClock.CurrentTime;
public bool IsRunning => FramedClock.IsRunning; public bool IsRunning => GameplayClock.IsRunning;
#endregion #endregion
@ -221,11 +203,11 @@ namespace osu.Game.Screens.Play
// Handled via update. Don't process here to safeguard from external usages potentially processing frames additional times. // Handled via update. Don't process here to safeguard from external usages potentially processing frames additional times.
} }
public double ElapsedFrameTime => FramedClock.ElapsedFrameTime; public double ElapsedFrameTime => GameplayClock.ElapsedFrameTime;
public double FramesPerSecond => FramedClock.FramesPerSecond; public double FramesPerSecond => GameplayClock.FramesPerSecond;
public FrameTimeInfo TimeInfo => FramedClock.TimeInfo; public FrameTimeInfo TimeInfo => GameplayClock.TimeInfo;
public double TrueGameplayRate public double TrueGameplayRate
{ {

78
osu.Game/Screens/Play/MasterGameplayClockContainer.cs
View File

@ -4,8 +4,6 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using osu.Framework;
using osu.Framework.Allocation;
using osu.Framework.Audio; using osu.Framework.Audio;
using osu.Framework.Audio.Track; using osu.Framework.Audio.Track;
using osu.Framework.Bindables; using osu.Framework.Bindables;
@ -13,8 +11,6 @@ using osu.Framework.Graphics;
using osu.Framework.Timing; using osu.Framework.Timing;
using osu.Game.Beatmaps; using osu.Game.Beatmaps;
using osu.Game.Beatmaps.ControlPoints; using osu.Game.Beatmaps.ControlPoints;
using osu.Game.Configuration;
using osu.Game.Database;
namespace osu.Game.Screens.Play namespace osu.Game.Screens.Play
{ {
@ -43,28 +39,10 @@ namespace osu.Game.Screens.Play
Precision = 0.1, Precision = 0.1,
}; };
private double totalAppliedOffset => userBeatmapOffsetClock.RateAdjustedOffset + userGlobalOffsetClock.RateAdjustedOffset + platformOffsetClock.RateAdjustedOffset;
private readonly BindableDouble pauseFreqAdjust = new BindableDouble(); // Important that this starts at zero, matching the paused state of the clock.
private readonly WorkingBeatmap beatmap; private readonly WorkingBeatmap beatmap;
private OffsetCorrectionClock userGlobalOffsetClock = null!;
private OffsetCorrectionClock userBeatmapOffsetClock = null!;
private OffsetCorrectionClock platformOffsetClock = null!;
private Bindable<double> userAudioOffset = null!;
private IDisposable? beatmapOffsetSubscription;
private readonly double skipTargetTime; private readonly double skipTargetTime;
[Resolved]
private RealmAccess realm { get; set; } = null!;
[Resolved]
private OsuConfigManager config { get; set; } = null!;
private readonly List<Bindable<double>> nonGameplayAdjustments = new List<Bindable<double>>(); private readonly List<Bindable<double>> nonGameplayAdjustments = new List<Bindable<double>>();
public override IEnumerable<double> NonGameplayAdjustments => nonGameplayAdjustments.Select(b => b.Value); public override IEnumerable<double> NonGameplayAdjustments => nonGameplayAdjustments.Select(b => b.Value);
@ -75,7 +53,7 @@ namespace osu.Game.Screens.Play
/// <param name="beatmap">The beatmap to be used for time and metadata references.</param> /// <param name="beatmap">The beatmap to be used for time and metadata references.</param>
/// <param name="skipTargetTime">The latest time which should be used when introducing gameplay. Will be used when skipping forward.</param> /// <param name="skipTargetTime">The latest time which should be used when introducing gameplay. Will be used when skipping forward.</param>
public MasterGameplayClockContainer(WorkingBeatmap beatmap, double skipTargetTime) public MasterGameplayClockContainer(WorkingBeatmap beatmap, double skipTargetTime)
: base(beatmap.Track) : base(beatmap.Track, true)
{ {
this.beatmap = beatmap; this.beatmap = beatmap;
this.skipTargetTime = skipTargetTime; this.skipTargetTime = skipTargetTime;
@ -85,14 +63,6 @@ namespace osu.Game.Screens.Play
{ {
base.LoadComplete(); base.LoadComplete();
userAudioOffset = config.GetBindable<double>(OsuSetting.AudioOffset);
userAudioOffset.BindValueChanged(offset => userGlobalOffsetClock.Offset = offset.NewValue, true);
beatmapOffsetSubscription = realm.SubscribeToPropertyChanged(
r => r.Find<BeatmapInfo>(beatmap.BeatmapInfo.ID)?.UserSettings,
settings => settings.Offset,
val => userBeatmapOffsetClock.Offset = val);
// Reset may have been called externally before LoadComplete. // Reset may have been called externally before LoadComplete.
// If it was, and the clock is in a playing state, we want to ensure that it isn't stopped here. // If it was, and the clock is in a playing state, we want to ensure that it isn't stopped here.
bool isStarted = !IsPaused.Value; bool isStarted = !IsPaused.Value;
@ -133,14 +103,14 @@ namespace osu.Game.Screens.Play
// During normal operation, the source is stopped after performing a frequency ramp. // During normal operation, the source is stopped after performing a frequency ramp.
if (isPaused.NewValue) if (isPaused.NewValue)
{ {
this.TransformBindableTo(pauseFreqAdjust, 0, 200, Easing.Out).OnComplete(_ => this.TransformBindableTo(GameplayClock.ExternalPauseFrequencyAdjust, 0, 200, Easing.Out).OnComplete(_ =>
{ {
if (IsPaused.Value == isPaused.NewValue) if (IsPaused.Value == isPaused.NewValue)
base.OnIsPausedChanged(isPaused); base.OnIsPausedChanged(isPaused);
}); });
} }
else else
this.TransformBindableTo(pauseFreqAdjust, 1, 200, Easing.In); this.TransformBindableTo(GameplayClock.ExternalPauseFrequencyAdjust, 1, 200, Easing.In);
} }
else else
{ {
@ -148,11 +118,11 @@ namespace osu.Game.Screens.Play
base.OnIsPausedChanged(isPaused); base.OnIsPausedChanged(isPaused);
// If not yet loaded, we still want to ensure relevant state is correct, as it is used for offset calculations. // If not yet loaded, we still want to ensure relevant state is correct, as it is used for offset calculations.
pauseFreqAdjust.Value = isPaused.NewValue ? 0 : 1; GameplayClock.ExternalPauseFrequencyAdjust.Value = isPaused.NewValue ? 0 : 1;
// We must also process underlying gameplay clocks to update rate-adjusted offsets with the new frequency adjustment. // We must also process underlying gameplay clocks to update rate-adjusted offsets with the new frequency adjustment.
// Without doing this, an initial seek may be performed with the wrong offset. // Without doing this, an initial seek may be performed with the wrong offset.
FramedClock.ProcessFrame(); GameplayClock.ProcessFrame();
} }
} }
@ -162,48 +132,23 @@ namespace osu.Game.Screens.Play
base.Start(); 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 - totalAppliedOffset);
}
/// <summary> /// <summary>
/// Skip forward to the next valid skip point. /// Skip forward to the next valid skip point.
/// </summary> /// </summary>
public void Skip() public void Skip()
{ {
if (FramedClock.CurrentTime > skipTargetTime - MINIMUM_SKIP_TIME) if (GameplayClock.CurrentTime > skipTargetTime - MINIMUM_SKIP_TIME)
return; return;
double skipTarget = skipTargetTime - MINIMUM_SKIP_TIME; double skipTarget = skipTargetTime - MINIMUM_SKIP_TIME;
if (FramedClock.CurrentTime < 0 && skipTarget > 6000) if (GameplayClock.CurrentTime < 0 && skipTarget > 6000)
// double skip exception for storyboards with very long intros // double skip exception for storyboards with very long intros
skipTarget = 0; skipTarget = 0;
Seek(skipTarget); Seek(skipTarget);
} }
protected override IFrameBasedClock 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 OffsetCorrectionClock(source, pauseFreqAdjust) { Offset = RuntimeInfo.OS == RuntimeInfo.Platform.Windows ? 15 : 0 };
// the final usable gameplay clock with user-set offsets applied.
userGlobalOffsetClock = new OffsetCorrectionClock(platformOffsetClock, pauseFreqAdjust);
return userBeatmapOffsetClock = new OffsetCorrectionClock(userGlobalOffsetClock, pauseFreqAdjust);
}
/// <summary> /// <summary>
/// Changes the backing clock to avoid using the originally provided track. /// Changes the backing clock to avoid using the originally provided track.
/// </summary> /// </summary>
@ -224,10 +169,10 @@ namespace osu.Game.Screens.Play
if (SourceClock is not Track track) if (SourceClock is not Track track)
return; return;
track.AddAdjustment(AdjustableProperty.Frequency, pauseFreqAdjust); track.AddAdjustment(AdjustableProperty.Frequency, GameplayClock.ExternalPauseFrequencyAdjust);
track.AddAdjustment(AdjustableProperty.Tempo, UserPlaybackRate); track.AddAdjustment(AdjustableProperty.Tempo, UserPlaybackRate);
nonGameplayAdjustments.Add(pauseFreqAdjust); nonGameplayAdjustments.Add(GameplayClock.ExternalPauseFrequencyAdjust);
nonGameplayAdjustments.Add(UserPlaybackRate); nonGameplayAdjustments.Add(UserPlaybackRate);
speedAdjustmentsApplied = true; speedAdjustmentsApplied = true;
@ -241,10 +186,10 @@ namespace osu.Game.Screens.Play
if (SourceClock is not Track track) if (SourceClock is not Track track)
return; return;
track.RemoveAdjustment(AdjustableProperty.Frequency, pauseFreqAdjust); track.RemoveAdjustment(AdjustableProperty.Frequency, GameplayClock.ExternalPauseFrequencyAdjust);
track.RemoveAdjustment(AdjustableProperty.Tempo, UserPlaybackRate); track.RemoveAdjustment(AdjustableProperty.Tempo, UserPlaybackRate);
nonGameplayAdjustments.Remove(pauseFreqAdjust); nonGameplayAdjustments.Remove(GameplayClock.ExternalPauseFrequencyAdjust);
nonGameplayAdjustments.Remove(UserPlaybackRate); nonGameplayAdjustments.Remove(UserPlaybackRate);
speedAdjustmentsApplied = false; speedAdjustmentsApplied = false;
@ -253,7 +198,6 @@ namespace osu.Game.Screens.Play
protected override void Dispose(bool isDisposing) protected override void Dispose(bool isDisposing)
{ {
base.Dispose(isDisposing); base.Dispose(isDisposing);
beatmapOffsetSubscription?.Dispose();
removeSourceClockAdjustments(); removeSourceClockAdjustments();
} }