Adjust transition further to avoid brief "jumpscare" display of metadata

osu.Game/Screens/Play/PlayerLoader.cs

@@ -10,6 +10,7 @@ using osu.Framework.Audio;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Transforms;
 using osu.Framework.Input;
@@ -88,9 +89,13 @@ namespace osu.Game.Screens.Play
 
         private SkinnableSound sampleRestart = null!;
 
+        private Box? quickRestartBlackLayer;
+
         [Cached]
         private OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Purple);
 
+        private const double quick_restart_initial_delay = 500;
+
         protected bool BackgroundBrightnessReduction
         {
             set
@@ -307,6 +312,9 @@ namespace osu.Game.Screens.Play
         {
             base.OnSuspending(e);
 
+            quickRestartBlackLayer?.FadeOut(500, Easing.OutQuint);
+            quickRestartBlackLayer = null;
+
             BackgroundBrightnessReduction = false;
 
             // we're moving to player, so a period of silence is upcoming.
@@ -350,7 +358,14 @@ namespace osu.Game.Screens.Play
             if (!resuming) logo.MoveTo(new Vector2(0.5f), duration, Easing.OutQuint);
 
             logo.ScaleTo(new Vector2(0.15f), duration, Easing.OutQuint);
-            logo.FadeIn(350);
+
+            if (quickRestart)
+            {
+                logo.Delay(quick_restart_initial_delay)
+                    .FadeIn(350);
+            }
+            else
+                logo.FadeIn(350);
 
             Scheduler.AddDelayed(() =>
             {
@@ -456,17 +471,33 @@ namespace osu.Game.Screens.Play
         {
             MetadataInfo.Loading = true;
 
-            content.FadeInFromZero(500, Easing.OutQuint);
-
             if (quickRestart)
             {
-                // A slight delay is added here to avoid an awkward stutter during the initial animation.
+                // A quick restart starts by triggering a fade to black
-                Scheduler.AddDelayed(prepareNewPlayer, 100);
+                AddInternal(quickRestartBlackLayer = new Box
-                content.ScaleTo(1);
+                {
+                    Colour = Color4.Black,
+                    RelativeSizeAxes = Axes.Both,
+                    Depth = float.MaxValue
+                });
+
+                quickRestartBlackLayer
+                    .Delay(50)
+                    .FadeOut(5000, Easing.OutQuint);
+
+                prepareNewPlayer();
+
+                content
+                    .Delay(quick_restart_initial_delay)
+                    .ScaleTo(1)
+                    .FadeInFromZero(500, Easing.OutQuint);
             }
             else
             {
+                content.FadeInFromZero(500, Easing.OutQuint);
+
                 content
+                    .ScaleTo(0.7f)
                     .ScaleTo(1, 650, Easing.OutQuint)
                     .Then()
                     .Schedule(prepareNewPlayer);
@@ -542,33 +573,36 @@ namespace osu.Game.Screens.Play
             highPerformanceSession ??= highPerformanceSessionManager?.BeginSession();
 
             scheduledPushPlayer = Scheduler.AddDelayed(() =>
-            {
-                // ensure that once we have reached this "point of no return", readyForPush will be false for all future checks (until a new player instance is prepared).
-                var consumedPlayer = consumePlayer();
-
-                ContentOut();
-
-                TransformSequence<PlayerLoader> pushSequence = this.Delay(0);
-
-                // This goes hand-in-hand with the restoration of low pass filter in contentOut().
-                this.TransformBindableTo(volumeAdjustment, 0, CONTENT_OUT_DURATION, Easing.OutCubic);
-
-                pushSequence.Schedule(() =>
                 {
-                    if (!this.IsCurrentScreen()) return;
+                    // ensure that once we have reached this "point of no return", readyForPush will be false for all future checks (until a new player instance is prepared).
+                    var consumedPlayer = consumePlayer();
 
-                    LoadTask = null;
+                    ContentOut();
 
-                    // By default, we want to load the player and never be returned to.
+                    TransformSequence<PlayerLoader> pushSequence = this.Delay(0);
-                    // Note that this may change if the player we load requested a re-run.
-                    ValidForResume = false;
 
-                    if (consumedPlayer.LoadedBeatmapSuccessfully)
+                    // This goes hand-in-hand with the restoration of low pass filter in contentOut().
-                        this.Push(consumedPlayer);
+                    this.TransformBindableTo(volumeAdjustment, 0, CONTENT_OUT_DURATION, Easing.OutCubic);
-                    else
+
-                        this.Exit();
+                    pushSequence.Schedule(() =>
-                });
+                    {
-            }, quickRestart ? 0 : 500);
+                        if (!this.IsCurrentScreen()) return;
+
+                        LoadTask = null;
+
+                        // By default, we want to load the player and never be returned to.
+                        // Note that this may change if the player we load requested a re-run.
+                        ValidForResume = false;
+
+                        if (consumedPlayer.LoadedBeatmapSuccessfully)
+                            this.Push(consumedPlayer);
+                        else
+                            this.Exit();
+                    });
+                },
+                // When a quick restart is activated, the metadata content will display some time later if it's taking too long.
+                // To avoid it appearing too briefly, if it begins to fade in let's induce a standard delay.
+                quickRestart && content.Alpha == 0 ? 0 : 500);
         }
 
         private void cancelLoad()