Add "argon" variant of song progress display

osu.Game.Tests/Skins/SkinDeserialisationTest.cs

@@ -41,6 +41,8 @@ public class SkinDeserialisationTest
             "Archives/modified-default-20220818.osk",
             // Covers longest combo counter
             "Archives/modified-default-20221012.osk",
+            // Covers Argon variant of song progress bar
+            "Archives/modified-argon-20221024.osk",
             // Covers TextElement and BeatmapInfoDrawable
             "Archives/modified-default-20221102.osk",
             // Covers BPM counter.

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

@@ -20,7 +20,9 @@ public void SetUp() => Schedule(() =>
             {
                 var implementation = skin is LegacySkin
                     ? CreateLegacyImplementation()
-                    : CreateDefaultImplementation();
+                    : skin is ArgonSkin
+                        ? CreateArgonImplementation()
+                        : CreateDefaultImplementation();
 
                 implementation.Anchor = Anchor.Centre;
                 implementation.Origin = Anchor.Centre;
@@ -29,6 +31,7 @@ public void SetUp() => Schedule(() =>
         });
 
         protected abstract Drawable CreateDefaultImplementation();
+        protected virtual Drawable CreateArgonImplementation() => CreateDefaultImplementation();
         protected abstract Drawable CreateLegacyImplementation();
     }
 }

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

@@ -188,7 +188,7 @@ public void TestHoldForMenuDoesWorkWhenHidden()
         [Test]
         public void TestInputDoesntWorkWhenHUDHidden()
         {
-            SongProgressBar? getSongProgress() => hudOverlay.ChildrenOfType<SongProgressBar>().SingleOrDefault();
+            ArgonSongProgress? getSongProgress() => hudOverlay.ChildrenOfType<ArgonSongProgress>().SingleOrDefault();
 
             bool seeked = false;
 
@@ -204,8 +204,8 @@ public void TestInputDoesntWorkWhenHUDHidden()
 
                 Debug.Assert(progress != null);
 
-                progress.ShowHandle = true;
-                progress.OnSeek += _ => seeked = true;
+                progress.Interactive.Value = true;
+                progress.ChildrenOfType<ArgonSongProgressBar>().Single().OnSeek += _ => seeked = true;
             });
 
             AddStep("set showhud false", () => hudOverlay.ShowHud.Value = false);

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

@@ -54,10 +54,10 @@ public void TestToggleSeeking()
             void applyToDefaultProgress(Action<DefaultSongProgress> action) =>
                 this.ChildrenOfType<DefaultSongProgress>().ForEach(action);
 
-            AddStep("allow seeking", () => applyToDefaultProgress(s => s.AllowSeeking.Value = true));
+            AddStep("allow seeking", () => applyToDefaultProgress(s => s.Interactive.Value = true));
             AddStep("hide graph", () => applyToDefaultProgress(s => s.ShowGraph.Value = false));
-            AddStep("disallow seeking", () => applyToDefaultProgress(s => s.AllowSeeking.Value = false));
-            AddStep("allow seeking", () => applyToDefaultProgress(s => s.AllowSeeking.Value = true));
+            AddStep("disallow seeking", () => applyToDefaultProgress(s => s.Interactive.Value = false));
+            AddStep("allow seeking", () => applyToDefaultProgress(s => s.Interactive.Value = true));
             AddStep("show graph", () => applyToDefaultProgress(s => s.ShowGraph.Value = true));
         }
 
@@ -72,6 +72,8 @@ private void setHitObjects()
 
         protected override Drawable CreateDefaultImplementation() => new DefaultSongProgress();
 
+        protected override Drawable CreateArgonImplementation() => new ArgonSongProgress();
+
         protected override Drawable CreateLegacyImplementation() => new LegacySongProgress();
     }
 }

osu.Game.Tests/Visual/Multiplayer/TestSceneMultiSpectatorScreen.cs

@@ -121,7 +121,7 @@ public void TestSpectatorPlayerInteractiveElementsHidden()
             AddUntilStep("all interactive elements removed", () => this.ChildrenOfType<Player>().All(p =>
                 !p.ChildrenOfType<PlayerSettingsOverlay>().Any() &&
                 !p.ChildrenOfType<HoldForMenuButton>().Any() &&
-                p.ChildrenOfType<SongProgressBar>().SingleOrDefault()?.ShowHandle == false));
+                p.ChildrenOfType<ArgonSongProgressBar>().SingleOrDefault()?.Interactive == false));
 
             AddStep("restore config hud visibility", () => config.SetValue(OsuSetting.HUDVisibilityMode, originalConfigValue));
         }

osu.Game/Graphics/UserInterface/SegmentedGraph.cs

@@ -48,17 +48,14 @@ public T[] Values
             }
         }
 
-        private Colour4[] tierColours;
+        private IReadOnlyList<Colour4> tierColours;
 
-        public Colour4[] TierColours
+        public IReadOnlyList<Colour4> TierColours
         {
             get => tierColours;
             set
             {
-                if (value.Length == 0 || value == tierColours)
-                    return;
-
-                tierCount = value.Length;
+                tierCount = value.Count;
                 tierColours = value;
 
                 graphNeedsUpdate = true;

osu.Game/Screens/Play/HUD/ArgonSongProgress.cs

@@ -0,0 +1,127 @@
+// 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.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Timing;
+using osu.Game.Configuration;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.UI;
+
+namespace osu.Game.Screens.Play.HUD
+{
+    public partial class ArgonSongProgress : SongProgress
+    {
+        private readonly SongProgressInfo info;
+        private readonly ArgonSongProgressGraph graph;
+        private readonly ArgonSongProgressBar bar;
+        private readonly Container graphContainer;
+
+        private const float bar_height = 10;
+
+        [SettingSource("Show difficulty graph", "Whether a graph displaying difficulty throughout the beatmap should be shown")]
+        public Bindable<bool> ShowGraph { get; } = new BindableBool(true);
+
+        [Resolved]
+        private DrawableRuleset? drawableRuleset { get; set; }
+
+        // Even though `FrameStabilityContainer` caches as a `GameplayClock`, we need to check it directly via `drawableRuleset`
+        // as this calculator is not contained within the `FrameStabilityContainer` and won't see the dependency.
+        private IClock referenceClock => drawableRuleset?.FrameStableClock ?? GameplayClock;
+
+        [Resolved]
+        private Player? player { get; set; }
+
+        public ArgonSongProgress()
+        {
+            Anchor = Anchor.BottomCentre;
+            Origin = Anchor.BottomCentre;
+            Masking = true;
+            CornerRadius = 5;
+            Children = new Drawable[]
+            {
+                info = new SongProgressInfo
+                {
+                    Origin = Anchor.TopLeft,
+                    Name = "Info",
+                    Anchor = Anchor.TopLeft,
+                    RelativeSizeAxes = Axes.X,
+                    ShowProgress = false
+                },
+                bar = new ArgonSongProgressBar(bar_height)
+                {
+                    Name = "Seek bar",
+                    Origin = Anchor.BottomLeft,
+                    Anchor = Anchor.BottomLeft,
+                    OnSeek = time => player?.Seek(time),
+                },
+                graphContainer = new Container
+                {
+                    Anchor = Anchor.BottomLeft,
+                    Origin = Anchor.BottomLeft,
+                    Masking = true,
+                    CornerRadius = 5,
+                    Child = graph = new ArgonSongProgressGraph
+                    {
+                        Name = "Difficulty graph",
+                        RelativeSizeAxes = Axes.Both,
+                        Blending = BlendingParameters.Additive
+                    },
+                    RelativeSizeAxes = Axes.X,
+                },
+            };
+            RelativeSizeAxes = Axes.X;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            info.ShowProgress = false;
+            info.TextColour = Colour4.White;
+            info.Font = OsuFont.Torus.With(size: 18, weight: FontWeight.Bold);
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Interactive.BindValueChanged(_ => bar.Interactive = Interactive.Value, true);
+            ShowGraph.BindValueChanged(_ => updateGraphVisibility(), true);
+        }
+
+        protected override void UpdateObjects(IEnumerable<HitObject> objects)
+        {
+            graph.Objects = objects;
+
+            info.StartTime = bar.StartTime = FirstHitTime;
+            info.EndTime = bar.EndTime = LastHitTime;
+        }
+
+        private void updateGraphVisibility()
+        {
+            graph.FadeTo(ShowGraph.Value ? 1 : 0, 200, Easing.In);
+            bar.ShowBackground = !ShowGraph.Value;
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+            Height = bar.Height + bar_height + info.Height;
+            graphContainer.Height = bar.Height;
+        }
+
+        protected override void UpdateProgress(double progress, bool isIntro)
+        {
+            bar.ReferenceTime = GameplayClock.CurrentTime;
+
+            if (isIntro)
+                bar.CurrentTime = 0;
+            else
+                bar.CurrentTime = referenceClock.CurrentTime;
+        }
+    }
+}