Merge pull request #687 from DrabWeb/playlist

Playlist

osu.Game/Graphics/UserInterface/OsuDropdown.cs

@@ -123,6 +123,8 @@ namespace osu.Game.Graphics.UserInterface
                 set { label.Text = value; }
             }
 
+            protected readonly TextAwesome Icon;
+
             private Color4? accentColour;
             public virtual Color4 AccentColour
             {
@@ -150,7 +152,7 @@ namespace osu.Game.Graphics.UserInterface
                         Anchor = Anchor.CentreLeft,
                         Origin = Anchor.CentreLeft,
                     },
-                new TextAwesome
+                    Icon = new TextAwesome
                     {
                         Icon = FontAwesome.fa_chevron_down,
                         Anchor = Anchor.CentreRight,

osu.Game/Overlays/Music/FilterControl.cs

@@ -0,0 +1,137 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.UserInterface;
+using osu.Game.Graphics;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Screens.Select;
+using OpenTK;
+using OpenTK.Graphics;
+using System;
+
+namespace osu.Game.Overlays.Music
+{
+    internal class FilterControl : Container
+    {
+        public readonly FilterTextBox Search;
+
+        public FilterControl()
+        {
+            Children = new Drawable[]
+            {
+                new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Spacing = new Vector2(0f, 10f),
+                    Children = new Drawable[]
+                    {
+                        Search = new FilterTextBox
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Height = 40,
+                            Exit = () => ExitRequested?.Invoke(),
+                        },
+                        new CollectionsDropdown<PlaylistCollection>
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Items = new[] { new KeyValuePair<string, PlaylistCollection>(@"All", PlaylistCollection.All) },
+                        }
+                    },
+                },
+            };
+
+            Search.Current.ValueChanged += current_ValueChanged;
+        }
+
+        private void current_ValueChanged(string newValue) => FilterChanged?.Invoke(newValue);
+
+        public Action ExitRequested;
+
+        public Action<string> FilterChanged;
+
+        public class FilterTextBox : SearchTextBox
+        {
+            private Color4 backgroundColour;
+
+            protected override Color4 BackgroundUnfocused => backgroundColour;
+            protected override Color4 BackgroundFocused => backgroundColour;
+
+            public FilterTextBox()
+            {
+                Masking = true;
+                CornerRadius = 5;
+            }
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                backgroundColour = colours.Gray2;
+            }
+        }
+
+        private class CollectionsDropdown<T> : OsuDropdown<T>
+        {
+            protected override DropdownHeader CreateHeader() => new CollectionsHeader { AccentColour = AccentColour };
+            protected override Menu CreateMenu() => new CollectionsMenu();
+
+            [BackgroundDependencyLoader]
+            private void load(OsuColour colours)
+            {
+                AccentColour = colours.Gray6;
+            }
+
+            private class CollectionsHeader : OsuDropdownHeader
+            {
+                [BackgroundDependencyLoader]
+                private void load(OsuColour colours)
+                {
+                    BackgroundColour = colours.Gray4;
+                }
+
+                public CollectionsHeader()
+                {
+                    CornerRadius = 5;
+                    Height = 30;
+                    Icon.TextSize = 14;
+                    Icon.Margin = new MarginPadding(0);
+                    Foreground.Padding = new MarginPadding { Top = 4, Bottom = 4, Left = 10, Right = 10 };
+                    EdgeEffect = new EdgeEffect
+                    {
+                        Type = EdgeEffectType.Shadow,
+                        Colour = Color4.Black.Opacity(0.3f),
+                        Radius = 3,
+                        Offset = new Vector2(0f, 1f),
+                    };
+                }
+            }
+
+            private class CollectionsMenu : OsuMenu
+            {
+                [BackgroundDependencyLoader]
+                private void load(OsuColour colours)
+                {
+                    Background.Colour = colours.Gray4;
+                }
+
+                public CollectionsMenu()
+                {
+                    CornerRadius = 5;
+                    EdgeEffect = new EdgeEffect
+                    {
+                        Type = EdgeEffectType.Shadow,
+                        Colour = Color4.Black.Opacity(0.3f),
+                        Radius = 3,
+                        Offset = new Vector2(0f, 1f),
+                    };
+                }
+            }
+        }
+    }
+}

osu.Game/Overlays/Music/PlaylistItem.cs

@@ -0,0 +1,119 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Game.Database;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Framework.Localisation;
+
+namespace osu.Game.Overlays.Music
+{
+    internal class PlaylistItem : Container
+    {
+        private const float fade_duration = 100;
+
+        private Color4 hoverColour;
+
+        private TextAwesome handle;
+        private OsuSpriteText title;
+
+        public readonly BeatmapSetInfo BeatmapSetInfo;
+
+        public Action<BeatmapSetInfo> OnSelect;
+
+        private bool selected;
+        public bool Selected
+        {
+            get { return selected; }
+            set
+            {
+                if (value == selected) return;
+                selected = value;
+
+                Flush(true);
+                title.FadeColour(Selected ? hoverColour : Color4.White, fade_duration);
+            }
+        }
+
+        public PlaylistItem(BeatmapSetInfo setInfo)
+        {
+            BeatmapSetInfo = setInfo;
+
+            RelativeSizeAxes = Axes.X;
+            AutoSizeAxes = Axes.Y;
+            Padding = new MarginPadding { Top = 3, Bottom = 3 };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours, LocalisationEngine localisation)
+        {
+            BeatmapMetadata metadata = BeatmapSetInfo.Metadata;
+
+            Children = new Drawable[]
+            {
+                handle = new TextAwesome
+                {
+                    Anchor = Anchor.TopLeft,
+                    Origin = Anchor.TopLeft,
+                    TextSize = 12,
+                    Colour = colours.Gray5,
+                    Icon = FontAwesome.fa_bars,
+                    Alpha = 0f,
+                    Margin = new MarginPadding { Left = 5 },
+                    Padding = new MarginPadding { Top = 2 },
+                },
+                new FillFlowContainer<OsuSpriteText>
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Padding = new MarginPadding { Left = 20 },
+                    Spacing = new Vector2(5f, 0f),
+                    Children = new []
+                    {
+                        title = new OsuSpriteText
+                        {
+                            TextSize = 16,
+                            Font = @"Exo2.0-Regular",
+                            Current = localisation.GetUnicodePreference(metadata.TitleUnicode, metadata.Title),
+                        },
+                        new OsuSpriteText
+                        {
+                            TextSize = 14,
+                            Font = @"Exo2.0-Bold",
+                            Colour = colours.Gray9,
+                            Padding = new MarginPadding { Top = 1 },
+                            Current = localisation.GetUnicodePreference(metadata.ArtistUnicode, metadata.Artist),
+                        }
+                    }
+                },
+            };
+
+            hoverColour = colours.Yellow;
+        }
+
+        protected override bool OnHover(Framework.Input.InputState state)
+        {
+            handle.FadeIn(fade_duration);
+
+            return base.OnHover(state);
+        }
+
+        protected override void OnHoverLost(Framework.Input.InputState state)
+        {
+            handle.FadeOut(fade_duration);
+        }
+
+        protected override bool OnClick(Framework.Input.InputState state)
+        {
+            OnSelect?.Invoke(BeatmapSetInfo);
+            return true;
+        }
+    }
+}

osu.Game/Overlays/Music/PlaylistList.cs

@@ -0,0 +1,61 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Database;
+
+namespace osu.Game.Overlays.Music
+{
+    internal class PlaylistList : Container
+    {
+        private readonly FillFlowContainer<PlaylistItem> items;
+
+        public IEnumerable<BeatmapSetInfo> BeatmapSets
+        {
+            set
+            {
+                items.Children = value.Select(item => new PlaylistItem(item) { OnSelect = itemSelected }).ToList();
+            }
+        }
+
+        private void itemSelected(BeatmapSetInfo b)
+        {
+            OnSelect?.Invoke(b);
+        }
+
+        public Action<BeatmapSetInfo> OnSelect;
+
+        public BeatmapSetInfo SelectedItem
+        {
+            get { return items.Children.FirstOrDefault(i => i.Selected)?.BeatmapSetInfo; }
+            set
+            {
+                foreach (PlaylistItem s in items.Children)
+                    s.Selected = s.BeatmapSetInfo.ID == value?.ID;
+            }
+        }
+
+        public PlaylistList()
+        {
+            Children = new Drawable[]
+            {
+                new ScrollContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        items = new FillFlowContainer<PlaylistItem>
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                        },
+                    },
+                },
+            };
+        }
+    }
+}

osu.Game/Overlays/Music/PlaylistOverlay.cs

@@ -0,0 +1,169 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using osu.Framework.Allocation;
+using osu.Framework.Audio.Track;
+using osu.Framework.Configuration;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Beatmaps;
+using osu.Game.Database;
+using osu.Game.Graphics;
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Framework.Extensions;
+
+namespace osu.Game.Overlays.Music
+{
+    public class PlaylistOverlay : OverlayContainer
+    {
+        private const float transition_duration = 600;
+
+        private const float playlist_height = 510;
+
+        private FilterControl filter;
+        private PlaylistList list;
+
+        private TrackManager trackManager;
+        private BeatmapDatabase beatmaps;
+
+        private readonly Bindable<WorkingBeatmap> beatmapBacking = new Bindable<WorkingBeatmap>();
+
+        protected IEnumerable<BeatmapSetInfo> BeatmapSets;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuGameBase game, BeatmapDatabase beatmaps, OsuColour colours)
+        {
+            this.beatmaps = beatmaps;
+            trackManager = game.Audio.Track;
+
+            Children = new Drawable[]
+            {
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    CornerRadius = 5,
+                    Masking = true,
+                    EdgeEffect = new EdgeEffect
+                    {
+                        Type = EdgeEffectType.Shadow,
+                        Colour = Color4.Black.Opacity(40),
+                        Radius = 5,
+                    },
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Colour = colours.Gray3,
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        list = new PlaylistList
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Padding = new MarginPadding { Top = 95, Bottom = 10, Right = 10 },
+                            OnSelect = itemSelected,
+                        },
+                        filter = new FilterControl
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            ExitRequested = () => State = Visibility.Hidden,
+                            FilterChanged = filterChanged,
+                            Padding = new MarginPadding(10),
+                        },
+                    },
+                },
+            };
+
+            list.BeatmapSets = BeatmapSets = beatmaps.GetAllWithChildren<BeatmapSetInfo>().ToList();
+
+            beatmapBacking.BindTo(game.Beatmap);
+        }
+
+        private void filterChanged(string newValue)
+        {
+            // TODO: implement
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            beatmapBacking.ValueChanged += b => list.SelectedItem = b?.BeatmapSetInfo;
+            beatmapBacking.TriggerChange();
+        }
+
+        protected override void PopIn()
+        {
+            filter.Search.HoldFocus = true;
+            Schedule(() => filter.Search.TriggerFocus());
+
+            ResizeTo(new Vector2(1, playlist_height), transition_duration, EasingTypes.OutQuint);
+            FadeIn(transition_duration, EasingTypes.OutQuint);
+        }
+
+        protected override void PopOut()
+        {
+            filter.Search.HoldFocus = false;
+
+            ResizeTo(new Vector2(1, 0), transition_duration, EasingTypes.OutQuint);
+            FadeOut(transition_duration);
+        }
+
+        private void itemSelected(BeatmapSetInfo set)
+        {
+            if (set.ID == (beatmapBacking.Value?.BeatmapSetInfo?.ID ?? -1))
+            {
+                beatmapBacking.Value?.Track?.Seek(0);
+                return;
+            }
+
+            playSpecified(set.Beatmaps[0]);
+        }
+
+        public void PlayPrevious()
+        {
+            var currentID = beatmapBacking.Value?.BeatmapSetInfo.ID ?? -1;
+            var available = BeatmapSets.Reverse();
+
+            var playable = available.SkipWhile(b => b.ID != currentID).Skip(1).FirstOrDefault() ?? available.FirstOrDefault();
+
+            if (playable != null)
+                playSpecified(playable.Beatmaps[0]);
+        }
+
+        public void PlayNext()
+        {
+            var currentID = beatmapBacking.Value?.BeatmapSetInfo.ID ?? -1;
+            var available = BeatmapSets;
+
+            var playable = available.SkipWhile(b => b.ID != currentID).Skip(1).FirstOrDefault() ?? available.FirstOrDefault();
+
+            if (playable != null)
+                playSpecified(playable.Beatmaps[0]);
+        }
+
+        private void playSpecified(BeatmapInfo info)
+        {
+            beatmapBacking.Value = beatmaps.GetWorkingBeatmap(info, beatmapBacking);
+
+            Task.Run(() =>
+            {
+                var track = beatmapBacking.Value.Track;
+                trackManager.SetExclusive(track);
+                track.Start();
+            }).ContinueWith(task => Schedule(task.ThrowIfFaulted), TaskContinuationOptions.OnlyOnFaulted);
+        }
+    }
+
+    //todo: placeholder
+    public enum PlaylistCollection
+    {
+        All
+    }
+}

osu.Game/Overlays/MusicController.cs

@@ -2,15 +2,12 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
-using System.Collections.Generic;
 using System.Diagnostics;
 using System.Threading.Tasks;
 using OpenTK;
 using OpenTK.Graphics;
 using osu.Framework.Allocation;
-using osu.Framework.Audio.Track;
 using osu.Framework.Configuration;
-using osu.Framework.Extensions;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -19,43 +16,45 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Input;
 using osu.Framework.Localisation;
-using osu.Framework.MathUtils;
 using osu.Game.Beatmaps;
 using osu.Game.Database;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
+using osu.Framework.Threading;
+using osu.Game.Overlays.Music;
 
 namespace osu.Game.Overlays
 {
     public class MusicController : FocusedOverlayContainer
     {
-        private Drawable currentBackground;
-        private DragBar progress;
-        private Button playButton;
-        private SpriteText title, artist;
+        private const float player_height = 130;
 
-        private List<BeatmapSetInfo> playList;
-        private readonly List<BeatmapInfo> playHistory = new List<BeatmapInfo>();
-        private int playListIndex;
-        private int playHistoryIndex = -1;
-
-        private TrackManager trackManager;
-        private Bindable<WorkingBeatmap> beatmapSource;
-        private WorkingBeatmap current;
-        private BeatmapDatabase beatmaps;
-        private LocalisationEngine localisation;
-
-        private Container dragContainer;
+        private const float transition_length = 800;
 
         private const float progress_height = 10;
 
         private const float bottom_black_area_height = 55;
 
+        private Drawable currentBackground;
+        private DragBar progressBar;
+
+        private Button playButton;
+        private Button playlistButton;
+
+        private SpriteText title, artist;
+
+        private PlaylistOverlay playlist;
+
+        private LocalisationEngine localisation;
+
+        private readonly Bindable<WorkingBeatmap> beatmapBacking = new Bindable<WorkingBeatmap>();
+
+        private Container dragContainer;
+        private Container playerContainer;
+
         public MusicController()
         {
             Width = 400;
-            Height = 130;
-
             Margin = new MarginPadding(10);
         }
 
@@ -81,14 +80,29 @@ namespace osu.Game.Overlays
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuGameBase game, BeatmapDatabase beatmaps, OsuColour colours, LocalisationEngine localisation)
+        private void load(OsuGameBase game, OsuColour colours, LocalisationEngine localisation)
         {
+            this.localisation = localisation;
+
             Children = new Drawable[]
             {
                 dragContainer = new Container
                 {
                     Anchor = Anchor.Centre,
                     Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Children = new Drawable[]
+                    {
+                        playlist = new PlaylistOverlay
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Y = player_height + 10,
+                        },
+                        playerContainer = new Container
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            Height = player_height,
                             Masking = true,
                             CornerRadius = 5,
                             EdgeEffect = new EdgeEffect
@@ -97,9 +111,9 @@ namespace osu.Game.Overlays
                                 Colour = Color4.Black.Opacity(40),
                                 Radius = 5,
                             },
-                    RelativeSizeAxes = Axes.Both,
-                    Children = new Drawable[]
+                            Children = new[]
                             {
+                                currentBackground = new Background(),
                                 title = new OsuSpriteText
                                 {
                                     Origin = Anchor.BottomCentre,
@@ -147,14 +161,7 @@ namespace osu.Game.Overlays
                                                 {
                                                     Scale = new Vector2(1.4f),
                                                     IconScale = new Vector2(1.4f),
-                                            Action = () =>
-                                            {
-                                                if (current?.Track == null) return;
-                                                if (current.Track.IsRunning)
-                                                    current.Track.Stop();
-                                                else
-                                                    current.Track.Start();
-                                            },
+                                                    Action = play,
                                                     Icon = FontAwesome.fa_play_circle_o,
                                                 },
                                                 new Button
@@ -164,16 +171,17 @@ namespace osu.Game.Overlays
                                                 },
                                             }
                                         },
-                                new Button
+                                        playlistButton = new Button
                                         {
                                             Origin = Anchor.Centre,
                                             Anchor = Anchor.CentreRight,
                                             Position = new Vector2(-bottom_black_area_height / 2, 0),
                                             Icon = FontAwesome.fa_bars,
+                                            Action = () => playlist.ToggleVisibility(),
                                         },
                                     }
                                 },
-                        progress = new DragBar
+                                progressBar = new DragBar
                                 {
                                     Origin = Anchor.BottomCentre,
                                     Anchor = Anchor.BottomCentre,
@@ -181,129 +189,98 @@ namespace osu.Game.Overlays
                                     Colour = colours.Yellow,
                                     SeekRequested = seek
                                 }
+                            },
+                        },
                     }
                 }
             };
 
-            this.beatmaps = beatmaps;
-            trackManager = game.Audio.Track;
-            this.localisation = localisation;
+            beatmapBacking.BindTo(game.Beatmap);
 
-            beatmapSource = game.Beatmap ?? new Bindable<WorkingBeatmap>();
-            playList = beatmaps.GetAllWithChildren<BeatmapSetInfo>();
-
-            currentBackground = new MusicControllerBackground();
-            dragContainer.Add(currentBackground);
+            playlist.StateChanged += (c, s) => playlistButton.FadeColour(s == Visibility.Visible ? colours.Yellow : Color4.White, 200, EasingTypes.OutQuint);
         }
 
         protected override void LoadComplete()
         {
-            beatmapSource.ValueChanged += workingChanged;
-            beatmapSource.TriggerChange();
+            beatmapBacking.ValueChanged += beatmapChanged;
+            beatmapBacking.TriggerChange();
 
             base.LoadComplete();
         }
 
+        protected override void UpdateAfterChildren()
+        {
+            base.UpdateAfterChildren();
+            Height = dragContainer.Height;
+        }
+
         protected override void Update()
         {
             base.Update();
 
-            if (pendingBeatmapSwitch != null)
-            {
-                pendingBeatmapSwitch();
-                pendingBeatmapSwitch = null;
-            }
-
             if (current?.TrackLoaded ?? false)
             {
-                progress.UpdatePosition(current.Track.Length == 0 ? 0 : (float)(current.Track.CurrentTime / current.Track.Length));
-                playButton.Icon = current.Track.IsRunning ? FontAwesome.fa_pause_circle_o : FontAwesome.fa_play_circle_o;
+                var track = current.Track;
 
-                if (current.Track.HasCompleted && !current.Track.Looping) next();
+                progressBar.UpdatePosition(track.Length == 0 ? 0 : (float)(track.CurrentTime / track.Length));
+                playButton.Icon = track.IsRunning ? FontAwesome.fa_pause_circle_o : FontAwesome.fa_play_circle_o;
+
+                if (track.HasCompleted && !track.Looping) next();
             }
             else
                 playButton.Icon = FontAwesome.fa_play_circle_o;
         }
 
-        private void workingChanged(WorkingBeatmap beatmap)
+        private void play()
         {
-            progress.IsEnabled = beatmap != null;
-            if (beatmap == current) return;
-            bool audioEquals = current?.BeatmapInfo?.AudioEquals(beatmap?.BeatmapInfo) ?? false;
-            current = beatmap;
-            updateDisplay(current, audioEquals ? TransformDirection.None : TransformDirection.Next);
-            appendToHistory(current?.BeatmapInfo);
-        }
+            var track = current?.Track;
 
-        private void appendToHistory(BeatmapInfo beatmap)
+            if (track == null)
             {
-            if (beatmap == null) return;
-
-            if (playHistoryIndex >= 0)
-            {
-                if (beatmap.AudioEquals(playHistory[playHistoryIndex]))
+                playlist.PlayNext();
                 return;
-                if (playHistoryIndex < playHistory.Count - 1)
-                    playHistory.RemoveRange(playHistoryIndex + 1, playHistory.Count - playHistoryIndex - 1);
             }
-            playHistory.Insert(++playHistoryIndex, beatmap);
+
+            if (track.IsRunning)
+                track.Stop();
+            else
+                track.Start();
         }
 
         private void prev()
         {
-            if (playHistoryIndex > 0)
-                play(playHistory[--playHistoryIndex], false);
+            queuedDirection = TransformDirection.Prev;
+            playlist.PlayPrevious();
         }
 
         private void next()
         {
-            if (playHistoryIndex < playHistory.Count - 1)
-                play(playHistory[++playHistoryIndex], true);
-            else
-            {
-                if (playList.Count == 0) return;
-                if (current != null && playList.Count == 1) return;
-                //shuffle
-                BeatmapInfo nextToPlay;
-                do
-                {
-                    int j = RNG.Next(playListIndex, playList.Count);
-                    if (j != playListIndex)
-                    {
-                        BeatmapSetInfo temp = playList[playListIndex];
-                        playList[playListIndex] = playList[j];
-                        playList[j] = temp;
+            queuedDirection = TransformDirection.Next;
+            playlist.PlayNext();
         }
 
-                    nextToPlay = playList[playListIndex++].Beatmaps[0];
-                    if (playListIndex == playList.Count) playListIndex = 0;
-                }
-                while (nextToPlay.AudioEquals(current?.BeatmapInfo));
+        private WorkingBeatmap current;
+        private TransformDirection queuedDirection;
 
-                play(nextToPlay, true);
-                appendToHistory(nextToPlay);
-            }
-        }
-
-        private void play(BeatmapInfo info, bool isNext)
+        private void beatmapChanged(WorkingBeatmap beatmap)
         {
-            current = beatmaps.GetWorkingBeatmap(info, current);
-            Task.Run(() =>
-            {
-                trackManager.SetExclusive(current.Track);
-                current.Track.Start();
-                beatmapSource.Value = current;
-            }).ContinueWith(task => Schedule(task.ThrowIfFaulted), TaskContinuationOptions.OnlyOnFaulted);
-            updateDisplay(current, isNext ? TransformDirection.Next : TransformDirection.Prev);
+            progressBar.IsEnabled = beatmap != null;
+
+            bool audioEquals = beatmapBacking.Value?.BeatmapInfo?.AudioEquals(current?.BeatmapInfo) ?? false;
+            current = beatmapBacking.Value;
+
+            updateDisplay(beatmapBacking, audioEquals ? TransformDirection.None : queuedDirection);
         }
 
-        private Action pendingBeatmapSwitch;
+        private ScheduledDelegate pendingBeatmapSwitch;
 
         private void updateDisplay(WorkingBeatmap beatmap, TransformDirection direction)
         {
             //we might be off-screen when this update comes in.
             //rather than Scheduling, manually handle this to avoid possible memory contention.
-            pendingBeatmapSwitch = () =>
+            pendingBeatmapSwitch?.Cancel();
+
+            pendingBeatmapSwitch = Schedule(delegate
             {
                 Task.Run(() =>
                 {
@@ -323,7 +300,7 @@ namespace osu.Game.Overlays
                     }
                 });
 
-                dragContainer.Add(new AsyncLoadWrapper(new MusicControllerBackground(beatmap)
+                playerContainer.Add(new AsyncLoadWrapper(new Background(beatmap)
                 {
                     OnLoadComplete = d =>
                     {
@@ -347,17 +324,15 @@ namespace osu.Game.Overlays
                 {
                     Depth = float.MaxValue,
                 });
-            };
+            });
         }
 
         private void seek(float position)
         {
-            current?.Track?.Seek(current.Track.Length * position);
-            current?.Track?.Start();
+            var track = current?.Track;
+            track?.Seek(track.Length * position);
         }
 
-        private const float transition_length = 800;
-
         protected override void PopIn()
         {
             base.PopIn();
@@ -374,14 +349,19 @@ namespace osu.Game.Overlays
             dragContainer.ScaleTo(0.9f, transition_length, EasingTypes.OutQuint);
         }
 
-        private enum TransformDirection { None, Next, Prev }
+        private enum TransformDirection
+        {
+            None,
+            Next,
+            Prev
+        }
 
-        private class MusicControllerBackground : BufferedContainer
+        private class Background : BufferedContainer
         {
             private readonly Sprite sprite;
             private readonly WorkingBeatmap beatmap;
 
-            public MusicControllerBackground(WorkingBeatmap beatmap = null)
+            public Background(WorkingBeatmap beatmap = null)
             {
                 this.beatmap = beatmap;
                 CacheDrawnFrameBuffer = true;

osu.Game/osu.Game.csproj

@@ -75,6 +75,9 @@
     <Compile Include="Beatmaps\Drawables\BeatmapBackgroundSprite.cs" />
     <Compile Include="Beatmaps\DifficultyCalculator.cs" />
     <Compile Include="Online\API\Requests\PostMessageRequest.cs" />
+    <Compile Include="Overlays\Music\FilterControl.cs" />
+    <Compile Include="Overlays\Music\PlaylistItem.cs" />
+    <Compile Include="Overlays\Music\PlaylistList.cs" />
     <Compile Include="Overlays\Toolbar\ToolbarChatButton.cs" />
     <Compile Include="Rulesets\Beatmaps\BeatmapConverter.cs" />
     <Compile Include="Rulesets\Beatmaps\BeatmapProcessor.cs" />
@@ -421,6 +424,7 @@
     <Compile Include="Screens\Select\BeatmapDetailArea.cs" />
     <Compile Include="Graphics\UserInterface\OsuTabControlCheckbox.cs" />
     <Compile Include="Screens\Select\BeatmapDetailAreaTabControl.cs" />
+    <Compile Include="Overlays\Music\PlaylistOverlay.cs" />
     <Compile Include="Rulesets\Replays\IAutoGenerator.cs" />
     <Compile Include="Rulesets\Replays\AutoGenerator.cs" />
   </ItemGroup>