Add a 'ducking' effect to the currently playing track when changing ruleset

osu.Game/Collections/ManageCollectionsDialog.cs

@@ -1,17 +1,17 @@
 // 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 osu.Framework.Allocation;
-using osu.Framework.Audio;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Game.Audio.Effects;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Overlays;
 using osuTK;
 
 namespace osu.Game.Collections
@@ -21,11 +21,14 @@ public partial class ManageCollectionsDialog : OsuFocusedOverlayContainer
         private const double enter_duration = 500;
         private const double exit_duration = 200;
 
-        private AudioFilter lowPassFilter = null!;
-
         protected override string PopInSampleName => @"UI/overlay-big-pop-in";
         protected override string PopOutSampleName => @"UI/overlay-big-pop-out";
 
+        private IDisposable? audioDucker;
+
+        [Resolved]
+        private MusicController? musicController { get; set; }
+
         public ManageCollectionsDialog()
         {
             Anchor = Anchor.Centre;
@@ -39,7 +42,7 @@ public ManageCollectionsDialog()
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours, AudioManager audio)
+        private void load(OsuColour colours)
         {
             Children = new Drawable[]
             {
@@ -110,19 +113,20 @@ private void load(OsuColour colours, AudioManager audio)
                             },
                         }
                     }
-                },
-                lowPassFilter = new AudioFilter(audio.TrackMixer)
+                }
             };
         }
 
-        public override bool IsPresent => base.IsPresent
-                                          // Safety for low pass filter potentially getting stuck in applied state due to
-                                          // transforms on `this` causing children to no longer be updated.
-                                          || lowPassFilter.IsAttached;
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            audioDucker?.Dispose();
+        }
 
         protected override void PopIn()
         {
-            lowPassFilter.CutoffTo(300, 100, Easing.OutCubic);
+            audioDucker = musicController?.Duck(100, 1f, unduckDuration: 100);
+
             this.FadeIn(enter_duration, Easing.OutQuint);
             this.ScaleTo(0.9f).Then().ScaleTo(1f, enter_duration, Easing.OutQuint);
         }
@@ -131,7 +135,7 @@ protected override void PopOut()
         {
             base.PopOut();
 
-            lowPassFilter.CutoffTo(AudioFilter.MAX_LOWPASS_CUTOFF, 100, Easing.InCubic);
+            audioDucker?.Dispose();
 
             this.FadeOut(exit_duration, Easing.OutQuint);
             this.ScaleTo(0.9f, exit_duration);

osu.Game/Overlays/Dialog/PopupDialogDangerousButton.cs

@@ -3,15 +3,13 @@
 
 #nullable disable
 
-using System;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
 using osu.Framework.Audio.Sample;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
-using osu.Game.Audio.Effects;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 
@@ -57,16 +55,13 @@ public DangerousConfirmContainer()
             private Sample tickSample;
             private Sample confirmSample;
             private double lastTickPlaybackTime;
-            private AudioFilter lowPassFilter = null!;
             private bool mouseDown;
 
             [BackgroundDependencyLoader]
             private void load(AudioManager audio)
             {
                 tickSample = audio.Samples.Get(@"UI/dialog-dangerous-tick");
                 confirmSample = audio.Samples.Get(@"UI/dialog-dangerous-select");
-
-                AddInternal(lowPassFilter = new AudioFilter(audio.SampleMixer));
             }
 
             protected override void LoadComplete()
@@ -75,15 +70,8 @@ protected override void LoadComplete()
                 Progress.BindValueChanged(progressChanged, true);
             }
 
-            protected override void AbortConfirm()
-            {
-                lowPassFilter.CutoffTo(AudioFilter.MAX_LOWPASS_CUTOFF);
-                base.AbortConfirm();
-            }
-
             protected override void Confirm()
             {
-                lowPassFilter.CutoffTo(AudioFilter.MAX_LOWPASS_CUTOFF);
                 confirmSample?.Play();
                 base.Confirm();
             }
@@ -123,8 +111,6 @@ protected override void OnHoverLost(HoverLostEvent e)
 
             private void progressChanged(ValueChangedEvent<double> progress)
             {
-                lowPassFilter.Cutoff = Math.Max(1, (int)(progress.NewValue * AudioFilter.MAX_LOWPASS_CUTOFF * 0.5));
-
                 if (progress.NewValue < progress.OldValue)
                     return;
 

osu.Game/Overlays/DialogOverlay.cs

@@ -3,16 +3,16 @@
 
 #nullable disable
 
+using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Overlays.Dialog;
 using osu.Game.Graphics.Containers;
 using osu.Game.Input.Bindings;
 using System.Linq;
+using JetBrains.Annotations;
 using osu.Framework.Allocation;
-using osu.Framework.Audio;
 using osu.Framework.Input.Events;
-using osu.Game.Audio.Effects;
 
 namespace osu.Game.Overlays
 {
@@ -23,15 +23,16 @@ public partial class DialogOverlay : OsuFocusedOverlayContainer, IDialogOverlay
         protected override string PopInSampleName => "UI/dialog-pop-in";
         protected override string PopOutSampleName => "UI/dialog-pop-out";
 
-        private AudioFilter lowPassFilter;
+        [Resolved]
+        private MusicController musicController { get; set; }
 
         public PopupDialog CurrentDialog { get; private set; }
 
         public override bool IsPresent => Scheduler.HasPendingTasks
-                                          || dialogContainer.Children.Count > 0
-                                          // Safety for low pass filter potentially getting stuck in applied state due to
-                                          // transforms on `this` causing children to no longer be updated.
-                                          || lowPassFilter.IsAttached;
+                                          || dialogContainer.Children.Count > 0;
+
+        [CanBeNull]
+        private IDisposable audioDucker;
 
         public DialogOverlay()
         {
@@ -49,10 +50,10 @@ public DialogOverlay()
             Origin = Anchor.Centre;
         }
 
-        [BackgroundDependencyLoader]
-        private void load(AudioManager audio)
+        protected override void Dispose(bool isDisposing)
         {
-            AddInternal(lowPassFilter = new AudioFilter(audio.TrackMixer));
+            base.Dispose(isDisposing);
+            audioDucker?.Dispose();
         }
 
         public void Push(PopupDialog dialog)
@@ -105,13 +106,13 @@ void dismiss()
 
         protected override void PopIn()
         {
-            lowPassFilter.CutoffTo(300, 100, Easing.OutCubic);
+            audioDucker = musicController.Duck(100, 1f, unduckDuration: 100);
         }
 
         protected override void PopOut()
         {
             base.PopOut();
-            lowPassFilter.CutoffTo(AudioFilter.MAX_LOWPASS_CUTOFF, 100, Easing.InCubic);
+            audioDucker?.Dispose();
 
             // PopOut gets called initially, but we only want to hide dialog when we have been loaded and are present.
             if (IsLoaded && CurrentDialog?.State.Value == Visibility.Visible)

osu.Game/Overlays/MusicController.cs

@@ -11,11 +11,13 @@
 using osu.Framework.Audio;
 using osu.Framework.Audio.Track;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Audio;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Logging;
 using osu.Framework.Threading;
+using osu.Game.Audio.Effects;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Rulesets.Mods;
@@ -63,6 +65,17 @@ public partial class MusicController : CompositeDrawable
         [Resolved]
         private RealmAccess realm { get; set; }
 
+        private AudioFilter audioDuckFilter;
+        private readonly BindableDouble audioDuckVolume = new BindableDouble(1);
+        private bool audioDuckActive;
+
+        [BackgroundDependencyLoader]
+        private void load(AudioManager audio)
+        {
+            AddInternal(audioDuckFilter = new AudioFilter(audio.TrackMixer));
+            audio.Tracks.AddAdjustment(AdjustableProperty.Volume, audioDuckVolume);
+        }
+
         protected override void LoadComplete()
         {
             base.LoadComplete();
@@ -243,6 +256,63 @@ public void NextTrack(Action onSuccess = null) => Schedule(() =>
                 onSuccess?.Invoke();
         });
 
+        /// <summary>
+        /// Attenuates the volume and/or filters the currently playing track.
+        /// </summary>
+        /// <param name="duration">Duration of the ducking transition, in ms.</param>
+        /// <param name="duckVolumeTo">Level to drop volume to (1.0 = 100%).</param>
+        /// <param name="duckCutoffTo">Cutoff frequency to drop `AudioFilter` to. Use `null` to skip filter effect.</param>
+        /// <param name="easing">Easing for the ducking transition.</param>
+        /// <param name="unduckDuration">Duration of the unducking transition, in ms.</param>
+        /// <param name="unduckEasing">Easing for the unducking transition.</param>
+        public IDisposable Duck(int duration = 0, float duckVolumeTo = 0.25f, int? duckCutoffTo = 300, Easing easing = Easing.OutCubic, int unduckDuration = 500, Easing unduckEasing = Easing.InCubic)
+        {
+            if (audioDuckActive) return null;
+
+            audioDuckActive = true;
+
+            Schedule(() =>
+            {
+                if (duckCutoffTo.IsNotNull())
+                    audioDuckFilter?.CutoffTo((int)duckCutoffTo, duration, easing);
+
+                this.TransformBindableTo(audioDuckVolume, duckVolumeTo, duration, easing);
+            });
+
+            return new InvokeOnDisposal(() => unduck(unduckDuration, unduckEasing));
+        }
+
+        /// <summary>
+        /// A convenience method that ducks the currently playing track, then after a delay, unducks it.
+        /// </summary>
+        /// <param name="delay">Delay after audio is ducked before unducking begins, in ms.</param>
+        /// <param name="unduckDuration">Duration of the unducking transition, in ms.</param>
+        /// <param name="unduckEasing">Easing for the unducking transition.</param>
+        /// <param name="duckVolumeTo">Level to drop volume to (1.0 = 100%).</param>
+        /// <param name="duckCutoffTo">Cutoff frequency to drop `AudioFilter` to. Use `null` to skip filter effect.</param>
+        /// <param name="duckDuration">Duration of the ducking transition, in ms.</param>
+        /// <param name="duckEasing">Easing for the ducking transition.</param>
+        public void TimedDuck(int delay, int unduckDuration = 500, Easing unduckEasing = Easing.InCubic, float duckVolumeTo = 0.25f, int? duckCutoffTo = 300, int duckDuration = 0, Easing duckEasing = Easing.OutCubic)
+        {
+            if (audioDuckActive) return;
+
+            Duck(duckDuration, duckVolumeTo, duckCutoffTo, duckEasing);
+            Scheduler.AddDelayed(() => unduck(unduckDuration, unduckEasing), delay);
+        }
+
+        private void unduck(int duration, Easing easing)
+        {
+            if (!audioDuckActive) return;
+
+            audioDuckActive = false;
+
+            Schedule(() =>
+            {
+                audioDuckFilter?.CutoffTo(AudioFilter.MAX_LOWPASS_CUTOFF, duration, easing);
+                this.TransformBindableTo(audioDuckVolume, 1, duration, easing);
+            });
+        }
+
         private bool next()
         {
             if (beatmap.Disabled || !AllowTrackControl.Value)

osu.Game/Overlays/Toolbar/ToolbarRulesetSelector.cs

@@ -3,8 +3,12 @@
 
 #nullable disable
 
+using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Sample;
+using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -21,14 +25,21 @@ public partial class ToolbarRulesetSelector : RulesetSelector
     {
         protected Drawable ModeButtonLine { get; private set; }
 
+        [Resolved]
+        private MusicController musicController { get; set; }
+
+        private readonly Dictionary<RulesetInfo, Sample> rulesetSelectionSample = new Dictionary<RulesetInfo, Sample>();
+        private readonly Dictionary<RulesetInfo, SampleChannel> rulesetSelectionChannel = new Dictionary<RulesetInfo, SampleChannel>();
+        private Sample defaultSelectSample;
+
         public ToolbarRulesetSelector()
         {
             RelativeSizeAxes = Axes.Y;
             AutoSizeAxes = Axes.X;
         }
 
         [BackgroundDependencyLoader]
-        private void load()
+        private void load(AudioManager audio)
         {
             AddRangeInternal(new[]
             {
@@ -54,6 +65,13 @@ private void load()
                     }
                 },
             });
+
+            foreach (var r in Rulesets.AvailableRulesets)
+                rulesetSelectionSample[r] = audio.Samples.Get($@"UI/ruleset-select-{r.ShortName}");
+
+            defaultSelectSample = audio.Samples.Get(@"UI/default-select");
+
+            Current.ValueChanged += playRulesetSelectionSample;
         }
 
         protected override void LoadComplete()
@@ -84,6 +102,29 @@ private void moveLineToCurrent()
             }
         }
 
+        private void playRulesetSelectionSample(ValueChangedEvent<RulesetInfo> r)
+        {
+            // Don't play sample on first setting of value
+            if (r.OldValue == null)
+                return;
+
+            var channel = rulesetSelectionSample[r.NewValue]?.GetChannel();
+
+            // Skip sample choking and ducking for the default/fallback sample
+            if (channel == null)
+            {
+                defaultSelectSample.Play();
+                return;
+            }
+
+            foreach (var pair in rulesetSelectionChannel)
+                pair.Value?.Stop();
+
+            rulesetSelectionChannel[r.NewValue] = channel;
+            channel.Play();
+            musicController?.TimedDuck(600);
+        }
+
         public override bool HandleNonPositionalInput => !Current.Disabled && base.HandleNonPositionalInput;
 
         public override bool HandlePositionalInput => !Current.Disabled && base.HandlePositionalInput;