Merge remote-tracking branch 'ppy/master' into dropdown_keyboard_support

build/build.cake

···
 using System.Threading;
 #addin "nuget:?package=CodeFileSanity&version=0.0.21"
-#addin "nuget:?package=JetBrains.ReSharper.CommandLineTools&version=2018.3.4"
+#addin "nuget:?package=JetBrains.ReSharper.CommandLineTools&version=2019.1.1"
 #tool "nuget:?package=NVika.MSBuild&version=1.0.1"
 #tool "nuget:?package=Python&version=3.7.2"
 var nVikaToolPath = GetFiles("./tools/NVika.MSBuild.*/tools/NVika.exe").First();

osu-framework.sln.DotSettings

···
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTLINE_TYPE_PARAMETER_CONSTRAINS/@EntryValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTLINE_TYPE_PARAMETER_LIST/@EntryValue">True</s:Boolean>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ANONYMOUS_METHOD_DECLARATION_BRACES/@EntryValue">NEXT_LINE</s:String>
+	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/BLANK_LINES_BEFORE_BLOCK_STATEMENTS/@EntryValue">1</s:Int64>
+	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/BLANK_LINES_BEFORE_CASE/@EntryValue">1</s:Int64>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INITIALIZER_BRACES/@EntryValue">NEXT_LINE</s:String>
 	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/KEEP_BLANK_LINES_IN_CODE/@EntryValue">1</s:Int64>
 	<s:Int64 x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/KEEP_BLANK_LINES_IN_DECLARATIONS/@EntryValue">1</s:Int64>
···
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=MD/@EntryIndexedValue">MD5</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=NS/@EntryIndexedValue">NS</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=OS/@EntryIndexedValue">OS</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=PM/@EntryIndexedValue">PM</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=RGB/@EntryIndexedValue">RGB</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=RNG/@EntryIndexedValue">RNG</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=SHA/@EntryIndexedValue">SHA</s:String>

osu.Framework.Android/AndroidGameActivity.cs

···
 
             SetContentView(new AndroidGameView(this, CreateGame()));
         }
+
+        protected override void OnPause() {
+            base.OnPause();
+            // Because Android is not playing nice with Background - we just kill it
+            System.Diagnostics.Process.GetCurrentProcess().Kill();
+        }
     }
 }

osu.Framework.Android/AndroidGameWindow.cs

···
 
         public override void Run()
         {
+            View.Run();
         }
 
         public override void Run(double updateRate)
         {
+            View.Run(updateRate);
         }
     }
 }

osu.Framework.Android/osu.Framework.Android.csproj

···
     <Reference Include="System.Core" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osuTK.Android" Version="1.0.66" />
+    <ProjectReference Include="..\osu.Framework\osu.Framework.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="..\osu.Framework\osu.Framework.csproj" />
+    <PackageReference Include="ppy.osuTK.Android" Version="1.0.101" />
   </ItemGroup>
-</Project>
+</Project>

osu.Framework.Tests.iOS/osu.Framework.Tests.iOS.csproj

···
     <Compile Include="AppDelegate.cs" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="..\osu.Framework.Tests\**\Bindables\**\*.cs">
+    <Compile Include="..\osu.Framework.Tests\**\*.cs" Exclude="..\osu.Framework.Tests\Program.cs;..\osu.Framework.Tests\obj\**\*;..\osu.Framework.Tests\bin\**\*">
       <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
     </Compile>
-    <Compile Include="..\osu.Framework.Tests\**\Clocks\**\*.cs">
-      <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
-    </Compile>
-    <Compile Include="..\osu.Framework.Tests\**\Dependencies\**\*.cs">
-      <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
-    </Compile>
-    <Compile Include="..\osu.Framework.Tests\**\Exceptions\**\*.cs">
-      <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
-    </Compile>
-    <Compile Include="..\osu.Framework.Tests\**\IO\**\*.cs">
-      <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
-    </Compile>
-    <Compile Include="..\osu.Framework.Tests\**\Lists\**\*.cs">
-      <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
-    </Compile>
-    <Compile Include="..\osu.Framework.Tests\**\MathUtils\**\*.cs">
-      <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
-    </Compile>
-    <Compile Include="..\osu.Framework.Tests\**\Platform\**\*.cs">
-      <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
-    </Compile>
-    <Compile Include="..\osu.Framework.Tests\**\Visual\**\*.cs">
-      <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
-    </Compile>
-    <EmbeddedResource Include="..\osu.Framework.Tests\**\Resources\**\*.*">
-      <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
+    <EmbeddedResource Include="..\osu.Framework.Tests\Resources\**\*">
+      <Link>Resources\%(RecursiveDir)%(Filename)%(Extension)</Link>
     </EmbeddedResource>
-    <Compile Include="..\osu.Framework.Tests\*.cs" Exclude="**\Program.cs">
-      <Link>%(RecursiveDir)%(Filename)%(Extension)</Link>
-    </Compile>
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\osu.Framework\osu.Framework.csproj">

osu.Framework.Tests/Audio/AudioComponentTest.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Audio;
+using osu.Framework.Audio.Track;
+using osu.Framework.IO.Stores;
+using osu.Framework.Platform;
+using osu.Framework.Threading;
+
+namespace osu.Framework.Tests.Audio
+{
+    [TestFixture]
+    public class AudioComponentTest
+    {
+        private AudioThread thread;
+        private NamespacedResourceStore<byte[]> store;
+        private AudioManager manager;
+
+        [SetUp]
+        public void SetUp()
+        {
+            Architecture.SetIncludePath();
+
+            thread = new AudioThread();
+            store = new NamespacedResourceStore<byte[]>(new DllResourceStore(@"osu.Framework.dll"), @"Resources");
+
+            manager = new AudioManager(thread, store, store);
+
+            thread.Start();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            Assert.IsFalse(thread.Exited);
+
+            thread.Exit();
+
+            Thread.Sleep(500);
+
+            Assert.IsTrue(thread.Exited);
+        }
+
+        [Test]
+        public void TestNestedStoreAdjustments()
+        {
+            var customStore = manager.GetSampleStore(new ResourceStore<byte[]>());
+
+            checkAggregateVolume(manager.Samples, 1);
+            checkAggregateVolume(customStore, 1);
+
+            manager.Samples.Volume.Value = 0.5;
+
+            waitAudioFrame();
+
+            checkAggregateVolume(manager.Samples, 0.5);
+            checkAggregateVolume(customStore, 0.5);
+
+            customStore.Volume.Value = 0.5;
+
+            waitAudioFrame();
+
+            checkAggregateVolume(manager.Samples, 0.5);
+            checkAggregateVolume(customStore, 0.25);
+        }
+
+        private void checkAggregateVolume(ISampleStore store, double expected)
+        {
+            Assert.AreEqual(expected, ((IAggregateAudioAdjustment)store).AggregateVolume.Value);
+        }
+
+        [Test]
+        public void TestVirtualTrack()
+        {
+            var track = manager.Tracks.GetVirtual();
+
+            waitAudioFrame();
+
+            checkTrackCount(1);
+
+            Assert.IsFalse(track.IsRunning);
+            Assert.AreEqual(0, track.CurrentTime);
+
+            track.Start();
+            waitAudioFrame();
+
+            Assert.Greater(track.CurrentTime, 0);
+
+            track.Stop();
+            Assert.IsFalse(track.IsRunning);
+
+            track.Dispose();
+            waitAudioFrame();
+
+            checkTrackCount(0);
+        }
+
+        private void checkTrackCount(int expected)
+            => Assert.AreEqual(expected, ((TrackStore)manager.Tracks).Items.Count);
+
+        /// <summary>
+        /// Block for a specified number of audio thread frames.
+        /// </summary>
+        /// <param name="count">The number of frames to wait for. Two frames is generally considered safest.</param>
+        private void waitAudioFrame(int count = 2)
+        {
+            var cts = new TaskCompletionSource<bool>();
+
+            void runScheduled()
+            {
+                thread.Scheduler.Add(() =>
+                {
+                    if (--count > 0)
+                        runScheduled();
+                    else
+                    {
+                        cts.SetResult(true);
+                    }
+                });
+            }
+
+            runScheduled();
+
+            Task.WaitAll(cts.Task);
+        }
+    }
+}

osu.Framework.Tests/Bindables/AggregateBindableTest.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Threading;
+using NUnit.Framework;
+using osu.Framework.Bindables;
+
+namespace osu.Framework.Tests.Bindables
+{
+    [TestFixture]
+    public class AggregateBindableTest
+    {
+        [Test]
+        public void TestMultiplicationAggregate()
+        {
+            var aggregate = new AggregateBindable<double>((a, b) => a * b, new Bindable<double>(1));
+
+            Assert.AreEqual(1, aggregate.Result.Value);
+
+            var bindable1 = new BindableDouble(0.5);
+            aggregate.AddSource(bindable1);
+            Assert.AreEqual(0.5, aggregate.Result.Value);
+
+            var bindable2 = new BindableDouble(0.25);
+            aggregate.AddSource(bindable2);
+            Assert.AreEqual(0.125, aggregate.Result.Value);
+        }
+
+        [Test]
+        public void TestResultBounds()
+        {
+            var aggregate = new AggregateBindable<double>((a, b) => a * b, new BindableDouble(1)
+            {
+                Default = 1,
+                MinValue = 0,
+                MaxValue = 2
+            });
+
+            Assert.AreEqual(1, aggregate.Result.Value);
+
+            var bindable1 = new BindableDouble(-1);
+            aggregate.AddSource(bindable1);
+            Assert.AreEqual(0, aggregate.Result.Value);
+
+            var bindable2 = new BindableDouble(-4);
+            aggregate.AddSource(bindable2);
+            Assert.AreEqual(2, aggregate.Result.Value);
+        }
+
+        [Test]
+        public void TestClassAggregate()
+        {
+            var aggregate = new AggregateBindable<BoxedInt>((a, b) => new BoxedInt((a?.Value ?? 0) + (b?.Value ?? 0)));
+
+            Assert.AreEqual(null, aggregate.Result.Value);
+
+            var bindable1 = new Bindable<BoxedInt>(new BoxedInt(1));
+            aggregate.AddSource(bindable1);
+            Assert.AreEqual(1, aggregate.Result.Value.Value);
+
+            var bindable2 = new Bindable<BoxedInt>(new BoxedInt(2));
+            aggregate.AddSource(bindable2);
+            Assert.AreEqual(3, aggregate.Result.Value.Value);
+        }
+
+        private class BoxedInt
+        {
+            public readonly int Value;
+
+            public BoxedInt(int value)
+            {
+                Value = value;
+            }
+        }
+
+        [Test]
+        public void TestSourceChanged()
+        {
+            var aggregate = new AggregateBindable<double>((a, b) => a * b, new Bindable<double>(1));
+
+            var bindable1 = new BindableDouble(0.5);
+            aggregate.AddSource(bindable1);
+
+            var bindable2 = new BindableDouble(0.5);
+            aggregate.AddSource(bindable2);
+
+            Assert.AreEqual(0.25, aggregate.Result.Value);
+
+            bindable1.Value = 0.25;
+            Assert.AreEqual(0.125, aggregate.Result.Value);
+
+            bindable2.Value = 0.25;
+            Assert.AreEqual(0.0625, aggregate.Result.Value);
+        }
+
+        [Test]
+        public void TestSourceRemoved()
+        {
+            var aggregate = new AggregateBindable<double>((a, b) => a * b, new Bindable<double>(1));
+
+            var bindable1 = new BindableDouble(0.5);
+            aggregate.AddSource(bindable1);
+
+            var bindable2 = new BindableDouble(0.5);
+            aggregate.AddSource(bindable2);
+
+            Assert.AreEqual(0.25, aggregate.Result.Value);
+
+            aggregate.RemoveSource(bindable1);
+            Assert.AreEqual(0.5, aggregate.Result.Value);
+
+            aggregate.RemoveSource(bindable2);
+            Assert.AreEqual(1, aggregate.Result.Value);
+        }
+
+        [Test]
+        public void TestValueChangedFirings()
+        {
+            int aggregateResultFireCount = 0, bindable1FireCount = 0, bindable2FireCount = 0;
+
+            var aggregate = new AggregateBindable<double>((a, b) => a * b, new Bindable<double>(1));
+            aggregate.Result.BindValueChanged(_ => Interlocked.Increment(ref aggregateResultFireCount));
+
+            Assert.AreEqual(0, aggregateResultFireCount);
+
+            var bindable1 = new BindableDouble(0.5);
+            bindable1.BindValueChanged(_ => Interlocked.Increment(ref bindable1FireCount));
+            aggregate.AddSource(bindable1);
+
+            Assert.AreEqual(1, aggregateResultFireCount);
+
+            var bindable2 = new BindableDouble(0.5);
+            bindable2.BindValueChanged(_ => Interlocked.Increment(ref bindable2FireCount));
+            aggregate.AddSource(bindable2);
+
+            Assert.AreEqual(2, aggregateResultFireCount);
+
+            bindable1.Value = 0.25;
+
+            Assert.AreEqual(3, aggregateResultFireCount);
+            Assert.AreEqual(1, bindable1FireCount);
+            Assert.AreEqual(0, bindable2FireCount);
+
+            bindable2.Value = 0.25;
+
+            Assert.AreEqual(4, aggregateResultFireCount);
+            Assert.AreEqual(1, bindable1FireCount);
+            Assert.AreEqual(1, bindable2FireCount);
+
+            aggregate.RemoveSource(bindable2);
+
+            Assert.AreEqual(5, aggregateResultFireCount);
+            Assert.AreEqual(1, bindable1FireCount);
+            Assert.AreEqual(1, bindable2FireCount);
+
+            bindable2.Value = 0.5;
+
+            Assert.AreEqual(5, aggregateResultFireCount);
+            Assert.AreEqual(1, bindable1FireCount);
+            Assert.AreEqual(2, bindable2FireCount);
+        }
+    }
+}

osu.Framework.Tests/Bindables/BindableEnumTest.cs

···
             Assert.AreEqual(expected, bindable.Value);
         }
 
+        [TestCase("Value1", TestEnum.Value1)]
+        [TestCase("Value2", TestEnum.Value2)]
+        [TestCase("-1", TestEnum.Value1 - 1)]
+        [TestCase("2", TestEnum.Value2 + 1)]
+        public void TestParsingStringToNullableType(string value, TestEnum? expected)
+        {
+            var bindable = new Bindable<TestEnum?>();
+            bindable.Parse(value);
+
+            Assert.AreEqual(expected, bindable.Value);
+        }
+
         [TestCase(TestEnum.Value1)]
         [TestCase(TestEnum.Value2)]
         [TestCase(TestEnum.Value1 - 1)]
···
         public void TestParsingEnum(TestEnum value)
         {
             var bindable = new Bindable<TestEnum>();
+            bindable.Parse(value);
+
+            Assert.AreEqual(value, bindable.Value);
+        }
+
+        [TestCase(TestEnum.Value1)]
+        [TestCase(TestEnum.Value2)]
+        [TestCase(TestEnum.Value1 - 1)]
+        [TestCase(TestEnum.Value2 + 1)]
+        public void TestParsingEnumToNullableType(TestEnum value)
+        {
+            var bindable = new Bindable<TestEnum?>();
             bindable.Parse(value);
 
             Assert.AreEqual(value, bindable.Value);

osu.Framework.Tests/Clocks/InterpolatingClockTest.cs

···
 
             // test with test clock not elapsing
             double lastValue = interpolating.CurrentTime;
+
             for (int i = 0; i < 100; i++)
             {
                 interpolating.ProcessFrame();
···
 
             // test with test clock elapsing
             lastValue = interpolating.CurrentTime;
+
             for (int i = 0; i < 100; i++)
             {
                 source.CurrentTime += 50;

osu.Framework.Tests/IO/TestDesktopStorage.cs

···
         public void TestRelativePaths()
         {
             var guid = new Guid().ToString();
+
             using (var storage = new TemporaryNativeStorage(guid))
             {
                 var basePath = storage.GetFullPath(string.Empty);

osu.Framework.Tests/IO/TestWebRequest.cs

···
             List<long> startTimes = new List<long>();
 
             List<Task> running = new List<Task>();
+
             for (int i = 0; i < request_count; i++)
             {
                 var request = new DelayedWebRequest
···
             Assert.DoesNotThrow(request.Perform);
 
             var events = request.GetType().GetEvents(BindingFlags.Instance | BindingFlags.Public);
+
             foreach (var e in events)
             {
                 var field = request.GetType().GetField(e.Name, BindingFlags.Instance | BindingFlags.Public);
···
         public void TestUnbindOnDispose([Values(true, false)] bool async)
         {
             WebRequest request;
+
             using (request = new JsonWebRequest<HttpBinGetResponse>($"{default_protocol}://{host}/get")
             {
                 Method = HttpMethod.Get,
···
             }
 
             var events = request.GetType().GetEvents(BindingFlags.Instance | BindingFlags.Public);
+
             foreach (var e in events)
             {
                 var field = request.GetType().GetField(e.Name, BindingFlags.Instance | BindingFlags.Public);

osu.Framework.Tests/Lists/TestArrayExtensions.cs

···
         public void TestNonSquareJaggedWithNullRowsToRectangular()
         {
             var jagged = new int[10][];
+
             for (int i = 1; i < 10; i += 2)
             {
                 if (i % 2 == 1)

osu.Framework.Tests/Lists/TestWeakList.cs

···
             var list = new WeakList<object> { obj, obj2, obj3 };
 
             int count = 0;
+
             foreach (var item in list)
             {
                 if (count == 1)
···
             var list = new WeakList<object> { obj, obj2, obj3 };
 
             int count = 0;
+
             foreach (var item in list)
             {
                 if (count == 0)
···
             GC.WaitForPendingFinalizers();
 
             int index = 0;
+
             foreach (var obj in list)
             {
                 if (alive[index] != obj)

osu.Framework.Tests/Localisation/LocalisationTest.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
 using NUnit.Framework;
 using osu.Framework.Configuration;
···
                         {
                             default:
                                 return LOCALISABLE_STRING_EN;
+
                             case "ja":
                                 return LOCALISABLE_STRING_JA;
+
                             case "ja-JP":
                                 return LOCALISABLE_STRING_JA_JP;
                         }
···
                         {
                             default:
                                 return LOCALISABLE_FORMAT_STRING_EN;
+
                             case "ja":
                                 return LOCALISABLE_FORMAT_STRING_JA;
                         }
···
             public void Dispose()
             {
             }
+
+            public IEnumerable<string> GetAvailableResources() => Enumerable.Empty<string>();
         }
     }
 }

osu.Framework.Tests/Platform/TrackBassTest.cs osu.Framework.Tests/Audio/TrackBassTest.cs

···
 
 using System;
 using System.Threading;
-using System.Threading.Tasks;
 using ManagedBass;
 using NUnit.Framework;
 using osu.Framework.Audio.Track;
···
 
 #pragma warning disable 4014
 
-namespace osu.Framework.Tests.Platform
+namespace osu.Framework.Tests.Audio
 {
     [TestFixture]
     public class TrackBassTest
···
         public void Setup()
         {
             track = new TrackBass(resources.GetStream("Resources.Tracks.sample-track.mp3"));
-            track.Update();
+            updateTrack();
         }
 
         [Test]
         public void TestStart()
         {
             track.StartAsync();
-            track.Update();
+            updateTrack();
 
             Thread.Sleep(50);
 
-            track.Update();
+            updateTrack();
 
             Assert.IsTrue(track.IsRunning);
             Assert.Greater(track.CurrentTime, 0);
···
         {
             track.StartAsync();
             track.StopAsync();
-            track.Update();
+            updateTrack();
 
             Assert.IsFalse(track.IsRunning);
 
···
 
             Thread.Sleep(50);
 
-            track.Update();
+            updateTrack();
             track.StopAsync();
-            track.Update();
+            updateTrack();
 
             Assert.IsFalse(track.IsRunning);
             Assert.AreEqual(track.Length, track.CurrentTime);
···
         public void TestSeek()
         {
             track.SeekAsync(1000);
-            track.Update();
+            updateTrack();
 
             Assert.IsFalse(track.IsRunning);
             Assert.AreEqual(1000, track.CurrentTime);
···
         {
             track.StartAsync();
             track.SeekAsync(1000);
-            track.Update();
+            updateTrack();
 
             Assert.IsTrue(track.IsRunning);
             Assert.GreaterOrEqual(track.CurrentTime, 1000);
···
         [Test]
         public void TestSeekToEndFails()
         {
-            track.SeekAsync(track.Length);
-            track.Update();
+            bool? success = null;
+
+            runOnAudioThread(() => { success = track.Seek(track.Length); });
+            updateTrack();
 
             Assert.AreEqual(0, track.CurrentTime);
+            Assert.IsFalse(success);
         }
 
         [Test]
···
         {
             track.SeekAsync(1000);
             track.SeekAsync(0);
-            track.Update();
+            updateTrack();
 
             Thread.Sleep(50);
 
-            track.Update();
+            updateTrack();
 
             Assert.GreaterOrEqual(track.CurrentTime, 0);
             Assert.Less(track.CurrentTime, 1000);
···
 
             Thread.Sleep(50);
 
-            track.Update();
+            updateTrack();
 
             Assert.IsFalse(track.IsRunning);
             Assert.AreEqual(track.Length, track.CurrentTime);
···
 
             Thread.Sleep(50);
 
-            track.Update();
+            updateTrack();
             track.StartAsync();
-            track.Update();
+            updateTrack();
 
             Assert.AreEqual(track.Length, track.CurrentTime);
         }
···
 
             Thread.Sleep(50);
 
-            track.Update();
+            updateTrack();
             restartTrack();
 
             Assert.IsTrue(track.IsRunning);
···
 
             Thread.Sleep(50);
 
-            track.Update();
+            updateTrack();
             restartTrack();
 
             Assert.IsTrue(track.IsRunning);
···
 
             Thread.Sleep(50);
 
-            var resetEvent = new ManualResetEvent(false);
+            // The first update brings the track to its end time and restarts it
+            updateTrack();
 
-            Task.Run(() =>
-            {
-                // The restart action is invoked during the update and will block if not invoked on the audio thread.
-                // The update is always run on the audio thread in normal operation such that the restart action is always inlined.
-                // The audio thread is faked here to simulate this operation and avoid a deadlock.
-                Thread.CurrentThread.Name = GameThread.PrefixedThreadNameFor("Audio");
+            // The second update updates the IsRunning state
+            updateTrack();
 
-                track.Update();
-                resetEvent.Set();
-            });
+            // In a perfect world the track will be running after the update above, but during testing it's possible that the track is in
+            // a stalled state due to updates running on Bass' own thread, so we'll loop until the track starts running again
+            // Todo: This should be fixed in the future if/when we invoke Bass.Update() ourselves
+            int loopCount = 0;
 
-            resetEvent.WaitOne(TimeSpan.FromSeconds(10));
+            while (++loopCount < 50 && !track.IsRunning)
+            {
+                updateTrack();
+                Thread.Sleep(10);
+            }
 
-            track.Update();
+            if (loopCount == 50)
+                throw new TimeoutException("Track failed to start in time.");
 
-            Assert.IsTrue(track.IsRunning);
             Assert.LessOrEqual(track.CurrentTime, 1000);
         }
 
···
         {
             track.SeekAsync(time);
             track.StartAsync();
-            track.Update();
+            updateTrack();
         }
 
+        private void updateTrack() => runOnAudioThread(() => track.Update());
+
         private void restartTrack()
         {
-            var resetEvent = new ManualResetEventSlim(false);
-
-            Task.Run(() =>
+            runOnAudioThread(() =>
             {
                 track.Restart();
                 track.Update();
+            });
+        }
+
+        /// <summary>
+        /// Certain actions are invoked on the audio thread.
+        /// Here we simulate this process on a correctly named thread to avoid endless blocking.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        private void runOnAudioThread(Action action)
+        {
+            var resetEvent = new ManualResetEvent(false);
+
+            new Thread(() =>
+            {
+                action();
+
                 resetEvent.Set();
-            });
+            })
+            {
+                Name = GameThread.PrefixedThreadNameFor("Audio")
+            }.Start();
 
-            while (!resetEvent.IsSet)
-                track.Update();
+            if (!resetEvent.WaitOne(TimeSpan.FromSeconds(10)))
+                throw new TimeoutException();
         }
     }
 }

osu.Framework.Tests/Polygons/ConvexPolygonClippingTest.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.MathUtils.Clipping;
+using osuTK;
+
+namespace osu.Framework.Tests.Polygons
+{
+    [TestFixture]
+    public class ConvexPolygonClippingTest
+    {
+        private static readonly Vector2 origin = Vector2.Zero;
+        private static readonly Vector2 up_1 = new Vector2(0, 1);
+        private static readonly Vector2 up_2 = new Vector2(0, 2);
+        private static readonly Vector2 up_3 = new Vector2(0, 3);
+        private static readonly Vector2 down_1 = new Vector2(0, -1);
+        private static readonly Vector2 down_2 = new Vector2(0, -2);
+        private static readonly Vector2 down_3 = new Vector2(0, -3);
+        private static readonly Vector2 left_1 = new Vector2(-1, 0);
+        private static readonly Vector2 left_2 = new Vector2(-2, 0);
+        private static readonly Vector2 left_3 = new Vector2(-3, 0);
+        private static readonly Vector2 right_1 = new Vector2(1, 0);
+        private static readonly Vector2 right_2 = new Vector2(2, 0);
+        private static readonly Vector2 right_3 = new Vector2(3, 0);
+
+        private static object[] externalTestCases => new object[]
+        {
+            // Non-rotated
+            new object[] { new[] { origin, up_1, up_1 + right_1, right_1 }, new[] { up_2, up_3, up_3 + right_1, up_2 } },
+            new object[] { new[] { origin, up_1, up_1 + right_1, right_1 }, new[] { right_2, right_2 + up_1, right_3 + up_1, right_3 } },
+            new object[] { new[] { origin, up_1, up_1 + right_1, right_1 }, new[] { down_1, down_1 + right_1, down_2 + right_1, down_2 } },
+            new object[] { new[] { origin, up_1, up_1 + right_1, right_1 }, new[] { left_2, left_2 + up_1, left_1 + up_1, left_1 } },
+            // Rotated
+            new object[] { new[] { origin, up_1, up_1 + right_1, right_1 }, new[] { up_1 + right_2, up_2 + right_1, up_3 + right_2, up_2 + right_3 } },
+            new object[] { new[] { origin, up_1, up_1 + right_1, right_1 }, new[] { up_1 + right_2, down_1 + right_3, down_2 + right_2, down_1 + right_1 } },
+            new object[] { new[] { origin, up_1, up_1 + right_1, right_1 }, new[] { down_1 + right_1, down_2 + right_2, down_3 + right_1, down_2 } },
+            new object[] { new[] { origin, up_1, up_1 + right_1, right_1 }, new[] { left_1 + up_1, down_2, down_3 + left_2, left_2 } },
+        };
+
+        [TestCaseSource(nameof(externalTestCases))]
+        public void TestExternalPolygon(Vector2[] polygonVertices1, Vector2[] polygonVertices2)
+        {
+            var poly1 = new SimpleConvexPolygon(polygonVertices1);
+            var poly2 = new SimpleConvexPolygon(polygonVertices2);
+
+            Assert.That(clip(poly1, poly2).Length, Is.Zero);
+            Assert.That(clip(poly2, poly1).Length, Is.Zero);
+
+            Array.Reverse(polygonVertices1);
+            Array.Reverse(polygonVertices2);
+
+            Assert.That(clip(poly1, poly2).Length, Is.Zero);
+            Assert.That(clip(poly2, poly1).Length, Is.Zero);
+        }
+
+        private static object[] subjectFullyContainedTestCases => new object[]
+        {
+            // Same polygon
+            new object[] { new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { origin, up_2, up_2 + right_2, right_2 } },
+            new object[] { new[] { down_2, left_2, up_2, right_2 }, new[] { down_2, left_2, up_2, right_2 } },
+            // Corners
+            new object[] { new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { origin, up_1, up_1 + right_1, right_1 } },
+            new object[] { new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { up_1, up_2, up_2 + right_1, up_1 + right_1 } },
+            new object[] { new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { up_1 + right_1, up_2 + right_1, up_2 + right_2, up_1 + right_2 } },
+            new object[] { new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { right_1, up_1 + right_1, up_1 + right_2, right_2 } },
+            new object[] { new[] { down_2, left_2, up_2, right_2 }, new[] { down_2, down_1, right_1, right_2 } },
+            new object[] { new[] { down_2, left_2, up_2, right_2 }, new[] { left_2, left_1, down_1, down_2 } },
+            new object[] { new[] { down_2, left_2, up_2, right_2 }, new[] { left_2, up_2, up_1, left_1 } },
+            new object[] { new[] { down_2, left_2, up_2, right_2 }, new[] { up_2, right_2, right_1, up_1 } },
+            // Padded
+            new object[] { new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { right_1 * 0.5f + up_1 * 0.5f, up_2 * 0.75f, up_2 * 0.75f + right_2 * 0.75f, right_2 * 0.75f } },
+            new object[] { new[] { down_2, left_2, up_2, right_2 }, new[] { down_1, left_1, up_1, right_1 } },
+            // Rotated
+            new object[] { new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { up_1 + right_1 * 0.5f, up_2 * 0.75f + right_1, up_1 + right_2 * 0.5f, up_1 * 0.5f + right_1 } },
+            new object[] { new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { up_1, up_2 * 0.75f, up_2 + right_1 * 0.5f, up_2 + right_1 } },
+            new object[] { new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { right_1, up_1 + right_2, up_1 * 0.5f + right_2, right_2 * 0.75f } },
+            new object[] { new[] { down_2, left_2, up_2, right_2 }, new[] { left_1 + up_1, up_1 + right_1, down_1 + right_1, left_1 + down_1 } },
+        };
+
+        [TestCaseSource(nameof(subjectFullyContainedTestCases))]
+        public void TestSubjectFullyContained(Vector2[] clipVertices, Vector2[] subjectVertices)
+        {
+            var clipPolygon = new SimpleConvexPolygon(clipVertices);
+            var subjectPolygon = new SimpleConvexPolygon(subjectVertices);
+
+            assertPolygonEquals(subjectPolygon, new SimpleConvexPolygon(clip(clipPolygon, subjectPolygon).ToArray()), false);
+
+            Array.Reverse(clipVertices);
+            Array.Reverse(subjectVertices);
+
+            assertPolygonEquals(subjectPolygon, new SimpleConvexPolygon(clip(clipPolygon, subjectPolygon).ToArray()), true);
+        }
+
+        [TestCaseSource(nameof(subjectFullyContainedTestCases))]
+        public void TestClipFullyContained(Vector2[] subjectVertices, Vector2[] clipVertices)
+        {
+            var clipPolygon = new SimpleConvexPolygon(clipVertices);
+            var subjectPolygon = new SimpleConvexPolygon(subjectVertices);
+
+            assertPolygonEquals(clipPolygon, new SimpleConvexPolygon(clip(clipPolygon, subjectPolygon).ToArray()), false);
+
+            Array.Reverse(clipVertices);
+            Array.Reverse(subjectVertices);
+
+            assertPolygonEquals(clipPolygon, new SimpleConvexPolygon(clip(clipPolygon, subjectPolygon).ToArray()), true);
+        }
+
+        private static object[] generalClippingTestCases => new object[]
+        {
+            new object[]
+            {
+                new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { left_1 + up_1, up_1 + right_1, down_1 + right_1, left_1 + down_1 }, new[] { origin, up_1, up_1 + right_1, right_1 }
+            },
+            new object[] { new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { left_1, up_1, right_1, down_1 }, new[] { origin, up_1, right_1 } },
+            new object[]
+            {
+                new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { up_1 + right_1, up_3 + right_1, up_3 + right_3, up_1 + right_3 },
+                new[] { up_1 + right_1, up_2 + right_1, up_2 + right_2, up_1 + right_2 }
+            },
+            new object[]
+            {
+                new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { up_2 + right_1, up_3 + right_2, up_2 + right_3, up_1 + right_2 }, new[] { up_2 + right_1, up_2 + right_2, up_1 + right_2 }
+            },
+            new object[] { new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { left_1 + up_1, up_3 + right_1, up_1 + right_1, origin }, new[] { up_2, up_2 + right_1, up_1 + right_1, origin } },
+            new object[]
+            {
+                new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { left_1 + up_1, up_1 + right_3, down_1 + right_3, left_1 + down_1 }, new[] { up_1, up_1 + right_2, right_2, origin }
+            },
+            new object[]
+            {
+                new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { down_1 + left_1, up_3 + left_1, up_3 + right_1, down_1 + right_1 }, new[] { origin, up_2, up_2 + right_1, right_1 }
+            },
+            new object[]
+            {
+                new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { down_1, up_1 + right_1, down_1 + right_2, down_2 + right_1 }, new[] { right_1 * 0.5f, up_1 + right_1, right_2 * 0.75f }
+            },
+            new object[] { new[] { origin, up_2, up_2 + right_2, right_2 }, new[] { origin, up_3 + right_3, right_2 }, new[] { origin, up_2 + right_2, right_2 } },
+            new object[] { new[] { up_2, right_2, down_2, left_2 }, new[] { left_1 + down_2, left_2 + down_2, up_2 + left_2, up_2 + left_1 }, new[] { up_1 + left_1, down_1 + left_1, left_2 } },
+            new object[] { new[] { up_2, right_2, down_2, left_2 }, new[] { origin, down_2 + left_2, up_2 + left_2 }, new[] { origin, down_1 + left_1, left_2, up_1 + left_1 } },
+            new object[] { new[] { up_2, right_2, down_2, left_2 }, new[] { origin, left_3, up_3 }, new[] { origin, left_2, up_2 } },
+            new object[] { new[] { up_2, right_2, down_2, left_2 }, new[] { origin, left_3, up_3, right_3 }, new[] { origin, left_2, up_2, right_2 } },
+            new object[]
+            {
+                new[] { left_1 + up_1, right_1 + up_1, down_1 + right_1, down_1 + left_1 }, new[] { up_2 * 0.75f, right_2 * 0.75f, down_2 * 0.75f, left_2 * 0.75f },
+                new[]
+                {
+                    down_1 + left_1 * 0.5f,
+                    down_1 * 0.5f + left_1,
+                    up_1 * 0.5f + left_1,
+                    up_1 + left_1 * 0.5f,
+                    up_1 + right_1 * 0.5f,
+                    up_1 * 0.5f + right_1,
+                    down_1 * 0.5f + right_1,
+                    down_1 + right_1 * 0.5f
+                }
+            },
+            new object[]
+            {
+                new[] { up_1, right_1, left_1 }, new[] { up_1 + right_1 * 0.5f, down_1 + right_1 * 0.5f, down_1 + left_1 * 0.5f, up_1 + left_1 * 0.5f },
+                new[] { up_1 * 0.5f + left_1 * 0.5f, up_1, up_1 * 0.5f + right_1 * 0.5f, right_1 * 0.5f, left_1 * 0.5f, }
+            },
+            new object[]
+            {
+                // Inverse of the above
+                new[] { up_1 + right_1 * 0.5f, down_1 + right_1 * 0.5f, down_1 + left_1 * 0.5f, up_1 + left_1 * 0.5f }, new[] { up_1, right_1, left_1 },
+                new[] { up_1 * 0.5f + left_1 * 0.5f, up_1, up_1 * 0.5f + right_1 * 0.5f, right_1 * 0.5f, left_1 * 0.5f, }
+            },
+            new object[]
+            {
+                new[] { up_1, right_1, down_1 + right_1, down_1 + left_1, left_1 }, new[] { left_1, up_1, up_1 + right_1, down_1 + right_1, down_1 },
+                new[] { up_1, right_1, right_1 + down_1, down_1, left_1 }
+            }
+        };
+
+        [TestCaseSource(nameof(generalClippingTestCases))]
+        public void TestGeneralClipping(Vector2[] clipVertices, Vector2[] subjectVertices, Vector2[] resultingVertices)
+        {
+            var clipPolygon = new SimpleConvexPolygon(clipVertices);
+            var subjectPolygon = new SimpleConvexPolygon(subjectVertices);
+
+            assertPolygonEquals(new SimpleConvexPolygon(resultingVertices), new SimpleConvexPolygon(clip(clipPolygon, subjectPolygon).ToArray()), false);
+
+            Array.Reverse(clipVertices);
+            Array.Reverse(subjectVertices);
+
+            // The expected polygon is never reversed
+            assertPolygonEquals(new SimpleConvexPolygon(resultingVertices), new SimpleConvexPolygon(clip(clipPolygon, subjectPolygon).ToArray()), false);
+        }
+
+        [Test]
+        public void TestEmptyClip()
+        {
+            var quad = new Quad(0, 0, 1, 1);
+
+            assertPolygonEquals(
+                new SimpleConvexPolygon(Array.Empty<Vector2>()),
+                new SimpleConvexPolygon(clip(new SimpleConvexPolygon(Array.Empty<Vector2>()), quad).ToArray()),
+                false);
+        }
+
+        [Test]
+        public void TestEmptySubject()
+        {
+            var quad = new Quad(0, 0, 1, 1);
+
+            assertPolygonEquals(
+                new SimpleConvexPolygon(Array.Empty<Vector2>()),
+                new SimpleConvexPolygon(clip(quad, new SimpleConvexPolygon(Array.Empty<Vector2>())).ToArray()),
+                false);
+        }
+
+        private Span<Vector2> clip(SimpleConvexPolygon clipPolygon, SimpleConvexPolygon subjectPolygon)
+            => new ConvexPolygonClipper<SimpleConvexPolygon, SimpleConvexPolygon>(ref clipPolygon, ref subjectPolygon).Clip();
+
+        private Span<Vector2> clip<TClip, TSubject>(TClip clipPolygon, TSubject subjectPolygon)
+            where TClip : IConvexPolygon
+            where TSubject : IConvexPolygon
+            => new ConvexPolygonClipper<TClip, TSubject>(ref clipPolygon, ref subjectPolygon).Clip();
+
+        private void assertPolygonEquals(IPolygon expected, IPolygon actual, bool reverse)
+            => Assert.That(Vector2Extensions.GetOrientation(actual.GetVertices()),
+                reverse
+                    ? Is.EqualTo(-Vector2Extensions.GetOrientation(expected.GetVertices()))
+                    : Is.EqualTo(Vector2Extensions.GetOrientation(expected.GetVertices())));
+    }
+}

osu.Framework.Tests/Primitives/Vector2ExtensionsTest.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Primitives;
+using osuTK;
+
+namespace osu.Framework.Tests.Primitives
+{
+    [TestFixture]
+    public class Vector2ExtensionsTest
+    {
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestArrayOrientation(bool clockwise)
+        {
+            var vertices = new[]
+            {
+                new Vector2(0, 1),
+                Vector2.One,
+                new Vector2(1, 0),
+                Vector2.Zero
+            };
+
+            if (!clockwise)
+                Array.Reverse(vertices);
+
+            float orientation = Vector2Extensions.GetOrientation(vertices);
+
+            Assert.That(orientation, Is.EqualTo(clockwise ? 2 : -2).Within(0.001));
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestQuadOrientation(bool normalised)
+        {
+            Quad quad = normalised
+                ? new Quad(Vector2.Zero, new Vector2(1, 0), new Vector2(0, 1), Vector2.One)
+                : new Quad(new Vector2(0, 1), Vector2.One, Vector2.Zero, new Vector2(1, 0));
+
+            float orientation = Vector2Extensions.GetOrientation(quad.GetVertices());
+
+            Assert.That(orientation, Is.EqualTo(normalised ? 2 : -2).Within(0.001));
+        }
+    }
+}

osu.Framework.Tests/Threading/AsyncDisposalQueueTest.cs

···
             objects.ForEach(AsyncDisposalQueue.Enqueue);
 
             int attempts = 1000;
+
             while (!objects.All(o => o.IsDisposed))
             {
                 if (attempts-- == 0)

osu.Framework.Tests/Visual/Audio/TestSceneSamples.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Audio.Track;
+using osu.Framework.Extensions.IEnumerableExtensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Audio;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Framework.Tests.Visual.Audio
+{
+    public class TestSceneSamples : FrameworkTestScene
+    {
+        private readonly AudioContainer samples;
+        private readonly TrackingLine tracking;
+
+        private const int beats = 8;
+        private const int notes = 16;
+
+        public TestSceneSamples()
+        {
+            Children = new Drawable[]
+            {
+                new Container
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Size = new Vector2(0.95f),
+                    FillMode = FillMode.Fit,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Colour = Color4.Blue,
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        new Grid(beats - 1, notes),
+                        samples = new AudioContainer
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            RelativeChildSize = new Vector2(beats - 1, notes),
+                            Children = new Drawable[]
+                            {
+                                new DraggableSample(0, 0),
+                                new DraggableSample(1, 2),
+                                new DraggableSample(2, 4),
+                                new DraggableSample(3, 5),
+                                new DraggableSample(4, 8),
+                                new DraggableSample(5, 11),
+                                new DraggableSample(6, 14),
+                                new DraggableSample(7, 16),
+                                tracking = new TrackingLine()
+                            }
+                        },
+                    }
+                },
+            };
+
+            AddStep("reduce volume", () => samples.VolumeTo(samples.Volume.Value - 0.5f, 1000, Easing.OutQuint));
+            AddStep("increase volume", () => samples.VolumeTo(samples.Volume.Value + 0.5f, 1000, Easing.OutQuint));
+
+            AddStep("reduce frequency", () => samples.FrequencyTo(samples.Frequency.Value - 0.1f, 1000, Easing.OutQuint));
+            AddStep("increase frequency", () => samples.FrequencyTo(samples.Frequency.Value + 0.1f, 1000, Easing.OutQuint));
+
+            AddStep("left balance", () => samples.BalanceTo(samples.Balance.Value - 1, 1000, Easing.OutQuint));
+            AddStep("right balance", () => samples.BalanceTo(samples.Balance.Value + 1, 1000, Easing.OutQuint));
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (tracking.X > beats)
+            {
+                tracking.X = 0;
+                samples.OfType<DraggableSample>().ForEach(s => s.Reset());
+            }
+            else
+            {
+                tracking.X += (float)Clock.ElapsedFrameTime / 500;
+                samples.OfType<DraggableSample>().Where(s => !s.Played && s.X <= tracking.X).ForEach(s => s.Play());
+            }
+        }
+
+        private class TrackingLine : CompositeDrawable
+        {
+            public TrackingLine()
+            {
+                RelativePositionAxes = Axes.Both;
+                RelativeSizeAxes = Axes.Y;
+                Size = new Vector2(4, notes);
+                Colour = Color4.SkyBlue;
+
+                Blending = BlendingMode.Additive;
+
+                InternalChildren = new Drawable[]
+                {
+                    new Box
+                    {
+                        Colour = Color4.White,
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                };
+            }
+        }
+
+        public class Grid : CompositeDrawable
+        {
+            public Grid(int beats, int notes)
+            {
+                RelativeSizeAxes = Axes.Both;
+
+                for (int i = 0; i <= beats; i++)
+                {
+                    AddInternal(new Box
+                    {
+                        RelativePositionAxes = Axes.Both,
+                        RelativeSizeAxes = Axes.Y,
+                        Width = 1,
+                        Colour = Color4.White,
+                        X = (float)i / beats
+                    });
+                }
+
+                for (int i = 0; i <= notes; i++)
+                {
+                    AddInternal(new Box
+                    {
+                        RelativePositionAxes = Axes.Both,
+                        RelativeSizeAxes = Axes.X,
+                        Height = 1,
+                        Colour = Color4.White,
+                        Y = (float)i / notes
+                    });
+                }
+            }
+        }
+
+        private class DraggableSample : CompositeDrawable
+        {
+            public DraggableSample(int beat, int pitch)
+            {
+                RelativePositionAxes = Axes.Both;
+
+                Position = new Vector2(beat, pitch);
+                Size = new Vector2(16);
+
+                Origin = Anchor.Centre;
+
+                InternalChildren = new Drawable[]
+                {
+                    circle = new Circle
+                    {
+                        Colour = Color4.Yellow,
+                        RelativeSizeAxes = Axes.Both,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    },
+                };
+            }
+
+            public bool Played { get; private set; }
+
+            [BackgroundDependencyLoader]
+            private void load(ISampleStore samples)
+            {
+                AddInternal(sample = new DrawableSample(samples.Get("long.mp3")));
+            }
+
+            private DrawableSample sample;
+
+            private readonly Circle circle;
+
+            protected override bool OnDragStart(DragStartEvent e) => true;
+
+            protected override bool OnDrag(DragEvent e)
+            {
+                Y = (int)(e.MousePosition.Y / (Parent.DrawHeight / notes));
+                return true;
+            }
+
+            public void Reset()
+            {
+                Played = false;
+            }
+
+            public void Play()
+            {
+                Played = true;
+                circle.ScaleTo(1.8f).ScaleTo(1, 600, Easing.OutQuint);
+
+                sample.Frequency.Value = 1 + Y / notes;
+                sample.Play();
+            }
+        }
+    }
+}

osu.Framework.Tests/Visual/Audio/TestSceneTrack.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Audio.Track;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Audio;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Framework.Tests.Visual.Audio
+{
+    public class TestSceneTrack : FrameworkTestScene
+    {
+        [BackgroundDependencyLoader]
+        private void load(ITrackStore tracks)
+        {
+            Child = new DraggableAudioContainer
+            {
+                FillMode = FillMode.Fit,
+                Child = new DraggableAudioContainer
+                {
+                    Child = new DraggableAudioContainer
+                    {
+                        Child = new TrackPlayer(tracks.Get("sample-track.mp3"))
+                    }
+                }
+            };
+        }
+
+        private class TrackPlayer : CompositeDrawable
+        {
+            public TrackPlayer(Track track)
+            {
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+
+                DrawableTrack drawableTrack;
+
+                Size = new Vector2(50);
+
+                Masking = true;
+                CornerRadius = 10;
+
+                InternalChildren = new Drawable[]
+                {
+                    new Box
+                    {
+                        Colour = Color4.Yellow,
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                    new SpriteIcon
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Icon = FontAwesome.Solid.VolumeUp,
+                        Colour = Color4.Black,
+                        Size = new Vector2(40)
+                    },
+                    drawableTrack = new DrawableTrack(track)
+                };
+
+                drawableTrack.Looping = true;
+                drawableTrack.Start();
+            }
+        }
+
+        private class DraggableAudioContainer : Container
+        {
+            private readonly Container content;
+
+            private readonly AudioContainer audio;
+
+            private readonly SpriteText textLocal;
+            private readonly SpriteText textAggregate;
+
+            private readonly Box volFill;
+            private readonly Container warpContent;
+            private readonly SpriteIcon spinner;
+
+            protected override Container<Drawable> Content => content;
+
+            public DraggableAudioContainer()
+            {
+                Size = new Vector2(0.8f);
+                RelativeSizeAxes = Axes.Both;
+
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+
+                InternalChildren = new Drawable[]
+                {
+                    warpContent = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Children = new Drawable[]
+                        {
+                            new Box
+                            {
+                                Colour = Color4.DarkGray,
+                                Alpha = 0.5f,
+                                RelativeSizeAxes = Axes.Both,
+                            },
+                            volFill = new Box
+                            {
+                                Anchor = Anchor.BottomLeft,
+                                Origin = Anchor.BottomLeft,
+                                Colour = Color4.DarkViolet,
+                                Alpha = 0.2f,
+                                RelativeSizeAxes = Axes.Both,
+                            },
+                            new Container
+                            {
+                                RelativeSizeAxes = Axes.Both,
+                                Padding = new MarginPadding(10),
+                                Children = new Drawable[]
+                                {
+                                    textLocal = new SpriteText
+                                    {
+                                        Anchor = Anchor.TopLeft,
+                                        Origin = Anchor.TopLeft,
+                                    },
+                                    textAggregate = new SpriteText
+                                    {
+                                        Anchor = Anchor.BottomRight,
+                                        Origin = Anchor.BottomRight,
+                                    },
+                                }
+                            },
+                            spinner = new SpriteIcon
+                            {
+                                Anchor = Anchor.BottomLeft,
+                                Origin = Anchor.Centre,
+                                Icon = FontAwesome.Solid.CircleNotch,
+                                Blending = BlendingMode.Additive,
+                                Colour = Color4.White,
+                                Alpha = 0.2f,
+                                Scale = new Vector2(20),
+                                Position = new Vector2(20, -20)
+                            }
+                        }
+                    },
+
+                    audio = new AudioContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Child = content = new Container
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                    }
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                audio.Volume.BindValueChanged(updateLocal);
+                audio.Balance.BindValueChanged(updateLocal);
+                audio.Frequency.BindValueChanged(updateLocal, true);
+
+                audio.AggregateVolume.BindValueChanged(updateAggregate);
+                audio.AggregateBalance.BindValueChanged(updateAggregate);
+                audio.AggregateFrequency.BindValueChanged(updateAggregate, true);
+            }
+
+            private void updateAggregate(ValueChangedEvent<double> obj)
+            {
+                textAggregate.Text = $"aggregate: vol {audio.AggregateVolume.Value:F1} freq {audio.AggregateFrequency.Value:F1} bal {audio.AggregateBalance.Value:F1}";
+                volFill.Height = (float)audio.AggregateVolume.Value;
+
+                warpContent.Rotation = (float)audio.AggregateBalance.Value * 4;
+            }
+
+            private void updateLocal(ValueChangedEvent<double> obj) =>
+                textLocal.Text = $"local: vol {audio.Volume.Value:F1} freq {audio.Frequency.Value:F1} bal {audio.Balance.Value:F1}";
+
+            protected override bool OnDrag(DragEvent e)
+            {
+                Position += e.Delta;
+
+                audio.Balance.Value = X / 100f;
+                audio.Frequency.Value = 1 - Y / 100f;
+                return true;
+            }
+
+            protected override bool OnScroll(ScrollEvent e)
+            {
+                audio.Volume.Value += e.ScrollDelta.Y / 100f;
+                return true;
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+                spinner.Rotation += (float)(audio.AggregateFrequency.Value * Clock.ElapsedFrameTime);
+            }
+
+            protected override bool OnDragEnd(DragEndEvent e) => true;
+
+            protected override bool OnDragStart(DragStartEvent e) => true;
+        }
+    }
+}

osu.Framework.Tests/Visual/Bindables/TestSceneBindableAutoUnbinding.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Bindables
 {
-    public class TestSceneBindableAutoUnbinding : TestScene
+    public class TestSceneBindableAutoUnbinding : FrameworkTestScene
     {
         [Test]
         public void TestBindableAutoUnbindingAssign()

osu.Framework.Tests/Visual/Bindables/TestSceneBindableNumbers.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 
 namespace osu.Framework.Tests.Visual.Bindables
 {
-    public class TestSceneBindableNumbers : TestScene
+    public class TestSceneBindableNumbers : FrameworkTestScene
     {
         private readonly BindableInt bindableInt = new BindableInt();
         private readonly BindableLong bindableLong = new BindableLong();

osu.Framework.Tests/Visual/Clocks/TestSceneClock.cs

···
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
-using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Clocks
 {
-    public abstract class TestSceneClock : TestScene
+    public abstract class TestSceneClock : FrameworkTestScene
     {
         private readonly FillFlowContainer fill;
 

osu.Framework.Tests/Visual/Containers/TestSceneCircularContainer.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.MathUtils;
-using osu.Framework.Testing;
 using osuTK;
 
 namespace osu.Framework.Tests.Visual.Containers
 {
     [System.ComponentModel.Description(@"Checking for bugged corner radius")]
-    public class TestSceneCircularContainer : TestScene
+    public class TestSceneCircularContainer : FrameworkTestScene
     {
         private SingleUpdateCircularContainer container;
 

osu.Framework.Tests/Visual/Containers/TestSceneCircularContainerSizing.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Testing;
 using osuTK;
 
 namespace osu.Framework.Tests.Visual.Containers
 {
-    public class TestSceneCircularContainerSizing : TestScene
+    public class TestSceneCircularContainerSizing : FrameworkTestScene
     {
         [Test]
         public void TestLateSizing() => Schedule(() =>

osu.Framework.Tests/Visual/Containers/TestSceneCompositeMutability.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Testing;
 
 namespace osu.Framework.Tests.Visual.Containers
 {
-    public class TestSceneCompositeMutability : TestScene
+    public class TestSceneCompositeMutability : FrameworkTestScene
     {
         [TestCase(TestThread.External, false)]
         [TestCase(TestThread.Update, false)]
···
                         case LoadState.Loading when thread != TestThread.Load:
                             container.LoadingEvent.Set();
                             break;
+
                         // Special case for the load thread: possibly active during the ready state, but the ready event is handled in the switch below
                         case LoadState.Ready when thread == TestThread.Load:
                             container.LoadingEvent.Set();
                             stateToWaitFor = LoadState.Loading; // We'll never reach the ready state before the switch below
                             break;
+
                         case LoadState.Ready:
                             container.LoadingEvent.Set();
                             container.ReadyEvent.Set();
                             break;
+
                         case LoadState.Loaded:
                             container.LoadingEvent.Set();
                             container.ReadyEvent.Set();
···
                             AddStep("bind event", () => container.OnLoading += tryThrow);
                             AddStep("set loading", () => container.LoadingEvent.Set());
                             break;
+
                         case LoadState.Ready:
                             AddStep("bind event", () => container.OnReady += tryThrow);
                             AddStep("set loading", () => container.ReadyEvent.Set());

osu.Framework.Tests/Visual/Containers/TestSceneContainerState.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 
 namespace osu.Framework.Tests.Visual.Containers
 {
     [System.ComponentModel.Description("ensure valid container state in various scenarios")]
-    public class TestSceneContainerState : TestScene
+    public class TestSceneContainerState : FrameworkTestScene
     {
         /// <summary>
         /// Tests if a drawable can be added to a container, removed, and then re-added to the same container.
···
         {
             bool unbound = false;
 
-            var drawableA = new Sprite().With(d =>
-            {
-                d.OnUnbindAllBindables += () => unbound = true;
-            });
+            var drawableA = new Sprite().With(d => { d.OnUnbindAllBindables += () => unbound = true; });
 
             var container = new Container { Children = new[] { drawableA } };
 
···
         {
             bool disposed = false;
 
-            var drawableA = new Sprite().With(d =>
-            {
-                d.OnDispose += () => disposed = true;
-            });
+            var drawableA = new Sprite().With(d => { d.OnDispose += () => disposed = true; });
 
             var container = new Container { Children = new[] { drawableA } };
 
···
 
             // Disposal happens asynchronously
             int iterations = 20;
+
             while (iterations-- > 0)
             {
                 if (disposed)

osu.Framework.Tests/Visual/Containers/TestSceneCoordinateSpaces.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Containers
 {
-    public class TestSceneCoordinateSpaces : TestScene
+    public class TestSceneCoordinateSpaces : FrameworkTestScene
     {
         public TestSceneCoordinateSpaces()
         {
···
                     h.CreateMarkerAt(1f);
                     h.CreateMarkerAt(1.1f);
                     break;
+
                 case 1:
                     h.RelativeChildSize = new Vector2(150, 1);
                     h.CreateMarkerAt(0);
···
                     h.CreateMarkerAt(200);
                     h.CreateMarkerAt(250);
                     break;
+
                 case 2:
                     h.RelativeChildOffset = new Vector2(50, 0);
                     h.RelativeChildSize = new Vector2(150, 1);
···
                     h.CreateMarkerAt(200);
                     h.CreateMarkerAt(250);
                     break;
+
                 case 3:
                     h.RelativeChildOffset = new Vector2(150, 0);
                     h.RelativeChildSize = new Vector2(-200, 1);
···
                     h.CreateMarkerAt(200);
                     h.CreateMarkerAt(250);
                     break;
+
                 case 4:
                     h.RelativeChildOffset = new Vector2(0, 0);
                     h.RelativeChildSize = new Vector2(300, 1);
···
                     h.CreateMarkerAt(200);
                     h.CreateMarkerAt(250);
                     break;
+
                 case 5:
                     h.RelativeChildOffset = new Vector2(-250, 0);
                     h.RelativeChildSize = new Vector2(500, 1);

osu.Framework.Tests/Visual/Containers/TestSceneDrawSizePreservingFillContainer.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Containers
 {
-    public class TestSceneDrawSizePreservingFillContainer : TestScene
+    public class TestSceneDrawSizePreservingFillContainer : FrameworkTestScene
     {
         public TestSceneDrawSizePreservingFillContainer()
         {

osu.Framework.Tests/Visual/Containers/TestSceneDynamicDepth.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Containers
 {
     [System.ComponentModel.Description("changing depth of child dynamically")]
-    public class TestSceneDynamicDepth : TestScene
+    public class TestSceneDynamicDepth : FrameworkTestScene
     {
         private void addDepthSteps(DepthBox box, Container container)
         {

osu.Framework.Tests/Visual/Containers/TestSceneFrontToBack.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. 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.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL;
+using osu.Framework.Graphics.OpenGL.Vertices;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.MathUtils;
+using osu.Framework.Testing;
+using osuTK;
+using osuTK.Graphics;
+using osuTK.Graphics.ES30;
+
+namespace osu.Framework.Tests.Visual.Containers
+{
+    public class TestSceneFrontToBack : GridTestScene
+    {
+        private SpriteText labelDrawables;
+        private QueryingCompositeDrawableDrawNode drawNode;
+        private SpriteText labelFrag;
+        private SpriteText labelFrag2;
+        private float currentScale = 1;
+
+        private const int cell_count = 4;
+
+        protected override DrawNode CreateDrawNode() => drawNode = new QueryingCompositeDrawableDrawNode(this);
+
+        public TestSceneFrontToBack()
+            : base(cell_count / 2, cell_count / 2)
+        {
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(FrameworkDebugConfigManager debugConfig)
+        {
+            AddStep("add more drawables", addMoreDrawables);
+            AddToggleStep("disable front to back", val =>
+            {
+                debugConfig.Set(DebugSetting.BypassFrontToBackPass, val);
+                Invalidate(Invalidation.DrawNode); // reset counts
+            });
+
+            Add(new Container
+            {
+                AutoSizeAxes = Axes.Both,
+                Depth = float.NegativeInfinity,
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        Colour = Color4.Black,
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0.8f
+                    },
+                    new FillFlowContainer
+                    {
+                        AutoSizeAxes = Axes.Both,
+                        Padding = new MarginPadding(10),
+                        Direction = FillDirection.Vertical,
+                        Children = new Drawable[]
+                        {
+                            labelDrawables = new SpriteText { Font = new FontUsage("RobotoCondensed", weight: "Regular") },
+                            labelFrag = new SpriteText { Font = new FontUsage("RobotoCondensed", weight: "Regular") },
+                            labelFrag2 = new SpriteText { Font = new FontUsage("RobotoCondensed", weight: "Regular") },
+                        }
+                    },
+                }
+            });
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (drawNode != null)
+            {
+                labelDrawables.Text = $"boxes: {Cell(1).Children.Count * cell_count:N0}";
+                labelFrag.Text = $"samples ({nameof(DrawNode.Draw)}): {drawNode.DrawSamples:N0}";
+                labelFrag2.Text = $"samples ({nameof(DrawNode.DrawOpaqueInteriorSubTree)}): {drawNode.DrawOpaqueInteriorSubTreeSamples:N0}";
+            }
+        }
+
+        private void addMoreDrawables()
+        {
+            for (int i = 0; i < 100; i++)
+            {
+                Cell(i % cell_count).Add(new Box
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Colour = new Color4(RNG.NextSingle(1), RNG.NextSingle(1), RNG.NextSingle(1), 1),
+                    RelativeSizeAxes = Axes.Both,
+                    Scale = new Vector2(currentScale)
+                });
+
+                currentScale -= 0.001f;
+                if (currentScale < 0)
+                    currentScale = 1;
+            }
+        }
+
+        private class QueryingCompositeDrawableDrawNode : CompositeDrawableDrawNode
+        {
+            private int queryObject = -1;
+
+            public int DrawSamples { get; private set; }
+            public int DrawOpaqueInteriorSubTreeSamples { get; private set; }
+
+            public QueryingCompositeDrawableDrawNode(CompositeDrawable source)
+                : base(source)
+            {
+            }
+
+            internal override void DrawOpaqueInteriorSubTree(DepthValue depthValue, Action<TexturedVertex2D> vertexAction)
+            {
+                startQuery();
+                base.DrawOpaqueInteriorSubTree(depthValue, vertexAction);
+                DrawOpaqueInteriorSubTreeSamples = endQuery();
+            }
+
+            public override void ApplyState()
+            {
+                DrawSamples = 0;
+                DrawOpaqueInteriorSubTreeSamples = 0;
+                base.ApplyState();
+            }
+
+            public override void Draw(Action<TexturedVertex2D> vertexAction)
+            {
+                startQuery();
+                base.Draw(vertexAction);
+                DrawSamples = endQuery();
+            }
+
+            private int endQuery()
+            {
+                GL.EndQuery(QueryTarget.SamplesPassed);
+                GL.GetQueryObject(queryObject, GetQueryObjectParam.QueryResult, out int result);
+
+                return result;
+            }
+
+            private void startQuery()
+            {
+                if (queryObject == -1)
+                    queryObject = GL.GenQuery();
+
+                GL.BeginQuery(QueryTarget.SamplesPassed, queryObject);
+            }
+        }
+    }
+}

osu.Framework.Tests/Visual/Containers/TestSceneFrontToBackBox.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Framework.Tests.Visual.Containers
+{
+    public class TestSceneFrontToBackBox : FrameworkTestScene
+    {
+        private TestBox blendedBox;
+
+        [BackgroundDependencyLoader]
+        private void load(FrameworkDebugConfigManager debugConfig)
+        {
+            AddToggleStep("disable front to back", val => debugConfig.Set(DebugSetting.BypassFrontToBackPass, val));
+        }
+
+        [Test]
+        public void TestOpaqueBoxWithMixedBlending()
+        {
+            createBox();
+            AddAssert("renders interior", () => blendedBox.CanDrawOpaqueInterior);
+        }
+
+        [Test]
+        public void TestTransparentBoxWithMixedBlending()
+        {
+            createBox(b => b.Alpha = 0.5f);
+            AddAssert("doesn't render interior", () => !blendedBox.CanDrawOpaqueInterior);
+        }
+
+        [Test]
+        public void TestOpaqueBoxWithAdditiveBlending()
+        {
+            createBox(b => b.Blending = BlendingMode.Additive);
+            AddAssert("doesn't render interior", () => !blendedBox.CanDrawOpaqueInterior);
+        }
+
+        [Test]
+        public void TestTransparentBoxWithAdditiveBlending()
+        {
+            createBox(b =>
+            {
+                b.Blending = BlendingMode.Additive;
+                b.Alpha = 0.5f;
+            });
+
+            AddAssert("doesn't render interior", () => !blendedBox.CanDrawOpaqueInterior);
+        }
+
+        [TestCase(BlendingEquation.Max)]
+        [TestCase(BlendingEquation.Min)]
+        [TestCase(BlendingEquation.Subtract)]
+        [TestCase(BlendingEquation.ReverseSubtract)]
+        public void TestOpaqueBoxWithNonAddRGBEquation(BlendingEquation equationMode)
+        {
+            createBox(b =>
+            {
+                b.Blending = new BlendingParameters
+                {
+                    Mode = BlendingMode.Inherit,
+                    AlphaEquation = BlendingEquation.Inherit,
+                    RGBEquation = equationMode
+                };
+            });
+
+            AddAssert("doesn't render interior", () => !blendedBox.CanDrawOpaqueInterior);
+        }
+
+        [TestCase(BlendingEquation.Max)]
+        [TestCase(BlendingEquation.Min)]
+        [TestCase(BlendingEquation.Subtract)]
+        [TestCase(BlendingEquation.ReverseSubtract)]
+        public void TestOpaqueBoxWithNonAddAlphaEquation(BlendingEquation equationMode)
+        {
+            createBox(b =>
+            {
+                b.Blending = new BlendingParameters
+                {
+                    Mode = BlendingMode.Inherit,
+                    AlphaEquation = equationMode,
+                    RGBEquation = BlendingEquation.Inherit
+                };
+            });
+
+            AddAssert("doesn't render interior", () => !blendedBox.CanDrawOpaqueInterior);
+        }
+
+        private void createBox(Action<Box> setupAction = null) => AddStep("create box", () =>
+        {
+            Clear();
+
+            Add(new Container
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Size = new Vector2(200),
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = new Color4(50, 50, 50, 255)
+                    },
+                    blendedBox = new TestBox
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = new Color4(100, 100, 100, 255),
+                        Size = new Vector2(0.5f),
+                    }
+                }
+            });
+
+            setupAction?.Invoke(blendedBox);
+        });
+
+        private class TestBox : Box
+        {
+            public bool CanDrawOpaqueInterior => currentDrawNode.CanDrawOpaqueInterior;
+
+            private DrawNode currentDrawNode;
+
+            protected override DrawNode CreateDrawNode() => new TestBoxDrawNode(this);
+
+            internal override DrawNode GenerateDrawNodeSubtree(ulong frame, int treeIndex, bool forceNewDrawNode)
+                => currentDrawNode = base.GenerateDrawNodeSubtree(frame, treeIndex, forceNewDrawNode);
+
+            private class TestBoxDrawNode : BoxDrawNode
+            {
+                public TestBoxDrawNode(Box source)
+                    : base(source)
+                {
+                }
+            }
+        }
+    }
+}

osu.Framework.Tests/Visual/Containers/TestSceneLifetimeManagementContainer.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 using osu.Framework.Timing;
 
 namespace osu.Framework.Tests.Visual.Containers
 {
-    public class TestSceneLifetimeManagementContainer : TestScene
+    public class TestSceneLifetimeManagementContainer : FrameworkTestScene
     {
         private ManualClock manualClock;
         private TestContainer container;
···
             AddAssert($"{numAlive} alive children", () =>
             {
                 int num = 0;
+
                 foreach (var child in container.InternalChildren)
                 {
                     num += child.IsAlive ? 1 : 0;
···
             {
                 l = rng.Next(5);
                 r = rng.Next(5);
+
                 if (l > r)
                 {
                     var l1 = l;
···
             });
 
             int count = 1;
+
             for (int i = 0; i < 1000; i++)
             {
                 switch (rng.Next(3))
···
                         }
 
                         break;
+
                     case 1:
                         AddStep("Change lifetime", changeLifetime);
                         break;
+
                     case 2:
                         AddStep("Change time", changeTime);
                         break;

osu.Framework.Tests/Visual/Containers/TestSceneMasking.cs

···
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Containers
 {
-    public class TestSceneMasking : TestScene
+    public class TestSceneMasking : FrameworkTestScene
     {
         protected Container TestContainer;
 

osu.Framework.Tests/Visual/Containers/TestSceneScrollContainer.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
+using osu.Framework.MathUtils;
 using osu.Framework.Testing;
 using osuTK;
 using osuTK.Input;
···
         /// Create a scroll container, attempt to scroll past its <see cref="ScrollContainer.ClampExtension"/>, and check that it does not.
         /// </summary>
         [Test]
-        public void ScrollToTest()
+        public void TestScrollTo()
         {
             AddStep("Create scroll container with specified clamp extension", () => createScrollContainer(clampExtension));
             AddStep("Scroll past extent", () => scrollContainer.ScrollTo(200));
···
         /// Attempt to drag a scrollcontainer past its <see cref="ScrollContainer.ClampExtension"/> and check that it does not.
         /// </summary>
         [Test]
-        public void DraggingScrollTest()
+        public void TestDraggingScroll()
         {
             AddStep("Create scroll container with specified clamp extension", () => createScrollContainer(clampExtension));
             AddStep("Click and drag scrollcontainer", () =>
···
             checkScrollWithinBounds();
         }
 
+        [Test]
+        public void TestContentAnchor()
+        {
+            AddStep("Create scroll container with centre-left content", () =>
+            {
+                createScrollContainer(clampExtension).With(d =>
+                {
+                    d.RelativeSizeAxes = Axes.None;
+                    d.Size = new Vector2(300);
+                    d.ScrollContent.Anchor = Anchor.CentreLeft;
+                    d.ScrollContent.Origin = Anchor.CentreLeft;
+                    d.ScrollContent.Child.Height = 400;
+                });
+            });
+
+            AddStep("Scroll to 0", () => scrollContainer.ScrollTo(0, false));
+            AddAssert("Content position at top", () => Precision.AlmostEquals(scrollContainer.ScreenSpaceDrawQuad.TopLeft, scrollContainer.ScrollContent.ScreenSpaceDrawQuad.TopLeft));
+        }
+
         private void checkScrollWithinBounds()
         {
             AddAssert("Scroll amount is within ClampExtension bounds", () => Math.Abs(scrollContainer.Current) <= scrollContainer.ClampExtension);
         }
 
-        private void createScrollContainer(float clampExtension = 0)
+        private ScrollContainer createScrollContainer(float clampExtension = 0)
         {
             if (scrollContainer != null)
                 InputManager.Remove(scrollContainer);
···
                     }
                 }
             });
+
+            return scrollContainer;
         }
     }
 }

osu.Framework.Tests/Visual/Containers/TestSceneSizing.cs

···
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
 using osu.Framework.MathUtils;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Containers
 {
     [System.ComponentModel.Description("potentially challenging size calculations")]
-    public class TestSceneSizing : TestScene
+    public class TestSceneSizing : FrameworkTestScene
     {
         private Container testContainer;
 
···
 
                     box.OnUpdate += delegate { box.Rotation += 0.05f; };
                     break;
+
                 case 1:
                     testContainer.Add(box = new InfofulBoxAutoSize
                     {
···
                         Colour = Color4.Blue,
                     });
                     break;
+
                 case 2:
                     testContainer.Add(box = new InfofulBoxAutoSize
                     {
···
                         Colour = Color4.SeaGreen,
                     });
                     break;
+
                 case 3:
                     testContainer.Add(box = new InfofulBox
                     {
···
                         Colour = Color4.SeaGreen,
                     });
                     break;
+
                 case 4:
                     testContainer.Add(box = new InfofulBoxAutoSize
                     {
···
                         Anchor = Anchor.CentreLeft
                     });
                     break;
+
                 case 5:
                     testContainer.Add(box = new InfofulBoxAutoSize
                     {
···
                         Anchor = Anchor.CentreLeft
                     });
                     break;
+
                 case 6:
                     testContainer.Add(box = new InfofulBoxAutoSize
                     {
···
                         Colour = Color4.OrangeRed,
                     });
                     break;
+
                 case 7:
                     Container shrinkContainer;
                     Container<Drawable> boxes;
···
             if (Chameleon && (int)Time.Current / 1000 != lastSwitch)
             {
                 lastSwitch = (int)Time.Current / 1000;
+
                 switch (lastSwitch % 6)
                 {
                     case 0:
                         Anchor = (Anchor)((int)Anchor + 1);
                         Origin = (Anchor)((int)Origin + 1);
                         break;
+
                     case 1:
                         this.MoveTo(new Vector2(0, 0), 800, Easing.Out);
                         break;
+
                     case 2:
                         this.MoveTo(new Vector2(200, 0), 800, Easing.Out);
                         break;
+
                     case 3:
                         this.MoveTo(new Vector2(200, 200), 800, Easing.Out);
                         break;
+
                     case 4:
                         this.MoveTo(new Vector2(0, 200), 800, Easing.Out);
                         break;
+
                     case 5:
                         this.MoveTo(new Vector2(0, 0), 800, Easing.Out);
                         break;

osu.Framework.Tests/Visual/Containers/TestSceneTextFlowContainer.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Containers
 {
-    public class TestSceneTextFlowContainer : TestScene
+    public class TestSceneTextFlowContainer : FrameworkTestScene
     {
         private const string default_text = "Default text\n\nnewline";
 

osu.Framework.Tests/Visual/Containers/TestSceneVisibilityContainer.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Framework.Tests.Visual.Containers
+{
+    public class TestSceneVisibilityContainer : FrameworkTestScene
+    {
+        private TestVisibilityContainer testContainer;
+
+        [Test]
+        public void TestShowHide()
+        {
+            AddStep("create container", () => Child = testContainer = new TestVisibilityContainer());
+
+            checkHidden(true);
+
+            AddStep("show", () => testContainer.Show());
+            checkVisible();
+
+            AddStep("hide", () => testContainer.Hide());
+            checkHidden();
+
+            AddAssert("fire count is 2", () => testContainer.FireCount == 2);
+        }
+
+        [TestCase(true)]
+        [TestCase(false)]
+        public void TestStartHidden(bool startHidden)
+        {
+            AddStep("create container", () => Child = testContainer =
+                new TestVisibilityContainer(startHidden) { State = { Value = Visibility.Visible } });
+
+            checkVisible(!startHidden);
+
+            AddStep("hide", () => testContainer.Hide());
+            checkHidden();
+
+            AddAssert("fire count is 2", () => testContainer.FireCount == 2);
+        }
+
+        private void checkHidden(bool instant = false)
+        {
+            AddAssert("is hidden", () => testContainer.State.Value == Visibility.Hidden);
+            if (instant)
+                AddAssert("alpha zero", () => testContainer.Alpha == 0);
+            else
+                AddUntilStep("alpha zero", () => testContainer.Alpha == 0);
+        }
+
+        private void checkVisible(bool instant = false)
+        {
+            AddAssert("is visible", () => testContainer.State.Value == Visibility.Visible);
+            if (instant)
+                AddAssert("alpha one", () => testContainer.Alpha == 1);
+            else
+                AddUntilStep("alpha one", () => testContainer.Alpha == 1);
+        }
+
+        private class TestVisibilityContainer : VisibilityContainer
+        {
+            private readonly bool startHidden;
+
+            protected override bool StartHidden => startHidden;
+
+            public TestVisibilityContainer(bool startHidden = true)
+            {
+                this.startHidden = startHidden;
+
+                Size = new Vector2(0.5f);
+                RelativeSizeAxes = Axes.Both;
+
+                Anchor = Anchor.Centre;
+                Origin = Anchor.Centre;
+
+                Children = new Drawable[]
+                {
+                    new Box
+                    {
+                        Colour = Color4.Cyan,
+                        RelativeSizeAxes = Axes.Both,
+                    },
+                };
+
+                State.ValueChanged += e => FireCount++;
+            }
+
+            public int FireCount { get; private set; }
+
+            protected override void PopIn()
+            {
+                this.FadeIn(1000, Easing.OutQuint);
+                this.ScaleTo(1, 1000, Easing.OutElastic);
+            }
+
+            protected override void PopOut()
+            {
+                this.FadeOut(1000, Easing.OutQuint);
+                this.ScaleTo(0.4f, 1000, Easing.OutQuint);
+            }
+        }
+    }
+}

osu.Framework.Tests/Visual/Drawables/TestSceneBlending.cs

···
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Drawables
 {
-    public class TestSceneBlending : TestScene
+    public class TestSceneBlending : FrameworkTestScene
     {
         private readonly Dropdown<BlendingMode> colourModeDropdown;
         private readonly Dropdown<BlendingEquation> colourEquation;

osu.Framework.Tests/Visual/Drawables/TestSceneConcurrentLoad.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Drawables
 {
-    public class TestSceneConcurrentLoad : TestScene
+    public class TestSceneConcurrentLoad : FrameworkTestScene
     {
         private const int panel_count = 6;
 

osu.Framework.Tests/Visual/Drawables/TestSceneDelayedLoad.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Drawables
 {
-    public class TestSceneDelayedLoad : TestScene
+    public class TestSceneDelayedLoad : FrameworkTestScene
     {
         private const int panel_count = 2048;
 

osu.Framework.Tests/Visual/Drawables/TestSceneDelayedUnload.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Drawables
 {
-    public class TestSceneDelayedUnload : TestScene
+    public class TestSceneDelayedUnload : FrameworkTestScene
     {
         private const int panel_count = 1024;
 

osu.Framework.Tests/Visual/Drawables/TestSceneDrawableLoadCancellation.cs

···
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Logging;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Drawables
 {
-    public class TestSceneDrawableLoadCancellation : TestScene
+    public class TestSceneDrawableLoadCancellation : FrameworkTestScene
     {
         private readonly List<SlowLoader> loaders = new List<SlowLoader>();
 

osu.Framework.Tests/Visual/Drawables/TestSceneEffects.cs

···
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Drawables
 {
     [System.ComponentModel.Description("implementing the IEffect interface")]
-    public class TestSceneEffects : TestScene
+    public class TestSceneEffects : FrameworkTestScene
     {
         private readonly SpriteText changeColourText;
 

osu.Framework.Tests/Visual/Drawables/TestSceneFocus.cs

···
         [Test]
         public void FocusedOverlayTakesFocusOnShow()
         {
-            AddAssert("overlay not visible", () => overlay.State == Visibility.Hidden);
+            AddAssert("overlay not visible", () => overlay.State.Value == Visibility.Hidden);
             checkNotFocused(() => overlay);
 
             AddStep("show overlay", () => overlay.Show());
···
         [Test]
         public void FocusedOverlayLosesFocusOnClickAway()
         {
-            AddAssert("overlay not visible", () => overlay.State == Visibility.Hidden);
+            AddAssert("overlay not visible", () => overlay.State.Value == Visibility.Hidden);
             checkNotFocused(() => overlay);
 
             AddStep("show overlay", () => overlay.Show());
···
             {
                 if (!box.ReceivePositionalInputAt(e.ScreenSpaceMousePosition))
                 {
-                    State = Visibility.Hidden;
+                    Hide();
                     return true;
                 }
 

osu.Framework.Tests/Visual/Drawables/TestSceneIsMaskedAway.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Testing;
 using osuTK;
 
 namespace osu.Framework.Tests.Visual.Drawables
 {
-    public class TestSceneIsMaskedAway : TestScene
+    public class TestSceneIsMaskedAway : FrameworkTestScene
     {
         /// <summary>
         /// Tests that a box which is within the bounds of a parent is never masked away, regardless of whether the parent is masking or not.

osu.Framework.Tests/Visual/Drawables/TestSceneModelBackedDrawable.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Collections.Generic;
 using System.Threading;
 using NUnit.Framework;
 using osu.Framework.Allocation;
···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Drawables
 {
-    public class TestSceneModelBackedDrawable : TestScene
+    public class TestSceneModelBackedDrawable : FrameworkTestScene
     {
         private TestModelBackedDrawable backedDrawable;
 
-        private void createModelBackedDrawable(bool withPlaceholder, bool fadeOutImmediately) =>
+        private void createModelBackedDrawable(bool hasIntermediate, bool showNullModel = false) =>
             Child = backedDrawable = new TestModelBackedDrawable
             {
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
                 Size = new Vector2(200),
-                InternalFadeOutImmediately = fadeOutImmediately,
-                HasPlaceholder = withPlaceholder
+                HasIntermediate = hasIntermediate,
+                ShowNullModel = showNullModel
             };
 
-        [TestCase(false, false)]
-        [TestCase(false, true)]
-        [TestCase(true, false)]
-        [TestCase(true, true)]
-        public void TestDefaultState(bool withPlaceholder, bool fadeOutImmediately)
+        [Test]
+        public void TestEmptyDefaultState()
         {
-            AddStep("setup", () => createModelBackedDrawable(withPlaceholder, fadeOutImmediately));
-
-            if (withPlaceholder)
-                AddAssert("placeholder displayed", () => backedDrawable.DisplayedDrawable is TestPlaceholder);
-            else
-                AddAssert("no drawable displayed", () => backedDrawable.DisplayedDrawable == null);
+            AddStep("setup", () => createModelBackedDrawable(false));
+            AddAssert("nothing shown", () => backedDrawable.DisplayedDrawable == null);
         }
 
-        [TestCase(false, false)]
-        [TestCase(false, true)]
-        [TestCase(true, false)]
-        [TestCase(true, true)]
-        public void TestSingleDelayedLoad(bool withPlaceholder, bool fadeOutImmediately)
+        [Test]
+        public void TestModelDefaultState()
         {
             TestDrawableModel drawableModel = null;
 
-            AddStep("setup", () => createModelBackedDrawable(withPlaceholder, fadeOutImmediately));
-
-            AddStep("set model", () => backedDrawable.Model = new TestModel(drawableModel = new TestDrawableModel(1)));
-
-            if (withPlaceholder)
-                AddAssert("placeholder displayed", () => backedDrawable.DisplayedDrawable is TestPlaceholder);
-            else
-                AddAssert("no drawable displayed", () => backedDrawable.DisplayedDrawable == null);
+            AddStep("setup", () =>
+            {
+                createModelBackedDrawable(false);
+                backedDrawable.Model = new TestModel(drawableModel = new TestDrawableModel(1).With(d => d.AllowLoad.Set()));
+            });
 
-            AddStep("allow load", () => drawableModel.AllowLoad.Set());
-            AddUntilStep("wait for model to be loaded", () => drawableModel.IsLoaded);
-
-            AddAssert("model displayed", () => backedDrawable.DisplayedDrawable == drawableModel);
+            assertDrawableVisibility(1, () => drawableModel);
         }
 
-        [TestCase(false, false)]
-        [TestCase(false, true)]
-        [TestCase(true, false)]
-        [TestCase(true, true)]
-        public void TestMultipleLoadDisplaysSinglePlaceholder(bool withPlaceholder, bool fadeOutImmediately)
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestChangeModel(bool hasIntermediate)
         {
             TestDrawableModel firstModel = null;
             TestDrawableModel secondModel = null;
-            Drawable placeholder = null;
 
-            AddStep("setup", () => createModelBackedDrawable(withPlaceholder, fadeOutImmediately));
-
-            AddStep("set first model", () =>
+            AddStep("setup", () =>
             {
-                backedDrawable.Model = new TestModel(firstModel = new TestDrawableModel(1));
-                placeholder = backedDrawable.DisplayedDrawable;
+                createModelBackedDrawable(hasIntermediate);
+                backedDrawable.Model = new TestModel(firstModel = new TestDrawableModel(1).With(d => d.AllowLoad.Set()));
             });
 
+            assertDrawableVisibility(1, () => firstModel);
+
             AddStep("set second model", () => backedDrawable.Model = new TestModel(secondModel = new TestDrawableModel(2)));
-            AddAssert("first placeholder still displayed", () => backedDrawable.DisplayedDrawable == placeholder);
-
-            AddStep("allow first model to load", () => firstModel.AllowLoad.Set());
-            AddAssert("first placeholder still displayed", () => backedDrawable.DisplayedDrawable == placeholder);
+            assertIntermediateVisibility(hasIntermediate, () => firstModel);
 
             AddStep("allow second model to load", () => secondModel.AllowLoad.Set());
-            AddAssert("placeholder is not displayed", () => backedDrawable.DisplayedDrawable != placeholder);
+            assertDrawableVisibility(2, () => secondModel);
         }
 
-        /// <summary>
-        /// Covers <see cref="ModelBackedDrawable{T}.FadeOutImmediately"/> usage.
-        /// </summary>
-        [TestCase(false, false)]
-        [TestCase(false, true)]
-        [TestCase(true, false)]
-        [TestCase(true, true)]
-        public void TestIntermediaryPlaceholder(bool withPlaceholder, bool fadeOutImmediately)
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestChangeModelDuringLoad(bool hasIntermediate)
         {
             TestDrawableModel firstModel = null;
             TestDrawableModel secondModel = null;
-
-            AddStep("setup", () => createModelBackedDrawable(withPlaceholder, fadeOutImmediately));
-
-            AddStep("set first model", () => backedDrawable.Model = new TestModel(firstModel = new TestDrawableModel(1)));
-
-            if (withPlaceholder)
-                AddAssert("placeholder is displayed", () => backedDrawable.DisplayedDrawable is TestPlaceholder);
-            else
-                AddAssert("nothing displayed", () => backedDrawable.DisplayedDrawable == null);
-
-            AddStep("allow first model to load", () => firstModel.AllowLoad.Set());
-            AddUntilStep("wait for first model to be loaded", () => firstModel.IsLoaded);
-            AddAssert("first model's drawable is displayed", () => backedDrawable.DisplayedDrawable == firstModel);
-
-            AddStep("set second model", () => backedDrawable.Model = new TestModel(secondModel = new TestDrawableModel(2)));
-
-            if (fadeOutImmediately)
-            {
-                if (withPlaceholder)
-                    AddAssert("placeholder is displayed", () => backedDrawable.DisplayedDrawable is TestPlaceholder);
-                else
-                    AddAssert("nothing displayed", () => backedDrawable.DisplayedDrawable == null);
-            }
-            else
-                AddAssert("first model's drawable is displayed", () => backedDrawable.DisplayedDrawable == firstModel);
-
-            AddStep("allow second model to load", () => secondModel.AllowLoad.Set());
-            AddUntilStep("wait for second model to be loaded", () => secondModel.IsLoaded);
-            AddAssert("second model's drawable is displayed", () => backedDrawable.DisplayedDrawable == secondModel);
-        }
-
-        [TestCase(false, false)]
-        [TestCase(false, true)]
-        [TestCase(true, false)]
-        [TestCase(true, true)]
-        public void TestSequentialDelayedLoad(bool withPlaceholder, bool fadeOutImmediately)
-        {
-            const int model_count = 3;
-
-            var drawableModels = new List<TestDrawableModel>(model_count);
+            TestDrawableModel thirdModel = null;
 
             AddStep("setup", () =>
             {
-                drawableModels.Clear();
-                createModelBackedDrawable(withPlaceholder, fadeOutImmediately);
+                createModelBackedDrawable(hasIntermediate);
+                backedDrawable.Model = new TestModel(firstModel = new TestDrawableModel(1).With(d => d.AllowLoad.Set()));
             });
 
-            for (int i = 0; i < model_count; i++)
-            {
-                int localI = i;
-                AddStep($"set model {i + 1}", () =>
-                {
-                    var model = new TestDrawableModel(localI + 1);
-                    drawableModels.Add(model);
+            assertDrawableVisibility(1, () => firstModel);
 
-                    backedDrawable.Model = new TestModel(model);
-                });
-            }
+            AddStep("set second model", () => backedDrawable.Model = new TestModel(secondModel = new TestDrawableModel(2)));
+            assertIntermediateVisibility(hasIntermediate, () => firstModel);
 
-            // Due to potential left-over threading from elsewhere, we may have to wait for all models to get into a loading state
-            AddUntilStep("all loading", () => drawableModels.TrueForAll(d => d.LoadState == LoadState.Loading));
+            AddStep("set third model", () => backedDrawable.Model = new TestModel(thirdModel = new TestDrawableModel(3)));
+            assertIntermediateVisibility(hasIntermediate, () => firstModel);
 
-            for (int i = 0; i < model_count - 1; i++)
-            {
-                int localI = i;
-                AddStep($"allow model {i + 1} to load", () => drawableModels[localI].AllowLoad.Set());
-                if (withPlaceholder)
-                    AddAssert("placeholder displayed", () => backedDrawable.DisplayedDrawable is TestPlaceholder);
-                else
-                    AddAssert("no model displayed", () => backedDrawable.DisplayedDrawable == null);
-                AddWaitStep("wait for potential load", 5);
-                AddAssert($"model {i + 1} not loaded", () => !drawableModels[localI].IsLoaded);
-            }
+            AddStep("allow second model to load", () => secondModel.AllowLoad.Set());
+            assertIntermediateVisibility(hasIntermediate, () => firstModel);
 
-            AddStep($"allow model {model_count} to load", () => drawableModels[model_count - 1].AllowLoad.Set());
-            AddUntilStep($"model {model_count} loaded", () => drawableModels[model_count - 1].IsLoaded);
-            AddAssert($"model {model_count} displayed", () => backedDrawable.DisplayedDrawable == drawableModels[model_count - 1]);
+            AddStep("allow third model to load", () => thirdModel.AllowLoad.Set());
+            assertDrawableVisibility(3, () => thirdModel);
         }
 
-        [TestCase(false, false)]
-        [TestCase(false, true)]
-        [TestCase(true, false)]
-        [TestCase(true, true)]
-        public void TestOutOfOrderDelayedLoad(bool withPlaceholder, bool fadeOutImmediately)
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestOutOfOrderLoad(bool hasIntermediate)
         {
-            const int model_count = 3;
-
-            var drawableModels = new List<TestDrawableModel>(model_count);
+            TestDrawableModel firstModel = null;
+            TestDrawableModel secondModel = null;
 
             AddStep("setup", () =>
             {
-                drawableModels.Clear();
-                createModelBackedDrawable(withPlaceholder, fadeOutImmediately);
+                createModelBackedDrawable(hasIntermediate);
+                backedDrawable.Model = new TestModel(firstModel = new TestDrawableModel(1).With(d => d.AllowLoad.Set()));
             });
 
-            for (int i = 0; i < model_count; i++)
-            {
-                int localI = i;
-                AddStep($"set model {i + 1}", () =>
-                {
-                    var model = new TestDrawableModel(localI + 1);
-                    drawableModels.Add(model);
+            assertDrawableVisibility(1, () => firstModel);
 
-                    backedDrawable.Model = new TestModel(model);
-                });
-            }
+            AddStep("set second model", () => backedDrawable.Model = new TestModel(secondModel = new TestDrawableModel(2)));
+            assertIntermediateVisibility(hasIntermediate, () => firstModel);
 
-            // Due to potential left-over threading from elsewhere, we may have to wait for all models to get into a loading state
-            AddUntilStep("all loading", () => drawableModels.TrueForAll(d => d.LoadState == LoadState.Loading));
+            AddStep("allow second model to load", () => secondModel.AllowLoad.Set());
+            assertDrawableVisibility(2, () => secondModel);
 
-            AddStep($"allow model {model_count} to load", () => drawableModels[model_count - 1].AllowLoad.Set());
-            AddUntilStep($"model {model_count} loaded", () => drawableModels[model_count - 1].IsLoaded);
-            AddAssert($"model {model_count} displayed", () => backedDrawable.DisplayedDrawable == drawableModels[model_count - 1]);
-
-            for (int i = model_count - 2; i >= 0; i--)
-            {
-                int localI = i;
-                AddStep($"allow model {i + 1} to load", () => drawableModels[localI].AllowLoad.Set());
-                AddWaitStep("wait for potential load", 5);
-                AddAssert($"model {model_count} still displayed", () => backedDrawable.DisplayedDrawable == drawableModels[model_count - 1]);
-            }
+            AddStep("allow first model to load", () => firstModel.AllowLoad.Set());
+            assertDrawableVisibility(2, () => secondModel);
         }
 
-        [TestCase(false, false)]
-        [TestCase(false, true)]
-        [TestCase(true, false)]
-        [TestCase(true, true)]
-        public void TestSetNullModel(bool withPlaceholder, bool fadeOutImmediately)
+        [Test]
+        public void TestSetNullModel()
         {
             TestDrawableModel drawableModel = null;
 
-            AddStep("setup", () => createModelBackedDrawable(withPlaceholder, fadeOutImmediately));
-
-            AddStep("set model", () =>
+            AddStep("setup", () =>
             {
-                backedDrawable.Model = new TestModel(drawableModel = new TestDrawableModel(1));
-                drawableModel.AllowLoad.Set();
+                createModelBackedDrawable(false, true);
+                backedDrawable.Model = new TestModel(drawableModel = new TestDrawableModel(1).With(d => d.AllowLoad.Set()));
             });
 
-            AddUntilStep("model is displayed", () => backedDrawable.DisplayedDrawable == drawableModel);
+            assertDrawableVisibility(1, () => drawableModel);
 
             AddStep("set null model", () => backedDrawable.Model = null);
+            AddUntilStep("null model shown", () => backedDrawable.DisplayedDrawable is TestNullDrawableModel);
+        }
 
-            if (withPlaceholder)
-                AddAssert("placeholder displayed", () => backedDrawable.DisplayedDrawable is TestPlaceholder);
+        private void assertIntermediateVisibility(bool hasIntermediate, Func<Drawable> getLastFunc)
+        {
+            if (hasIntermediate)
+                AddAssert("no drawable visible", () => backedDrawable.DisplayedDrawable == null);
             else
-                AddAssert("no drawable displayed", () => backedDrawable.DisplayedDrawable == null);
+                AddUntilStep("last drawable visible", () => backedDrawable.DisplayedDrawable == getLastFunc());
+        }
+
+        private void assertDrawableVisibility(int id, Func<Drawable> getFunc)
+        {
+            AddUntilStep($"model {id} visible", () => backedDrawable.DisplayedDrawable == getFunc());
         }
 
         private class TestModel
···
 
         private class TestDrawableModel : CompositeDrawable
         {
+            private readonly int id;
+
             public readonly ManualResetEventSlim AllowLoad = new ManualResetEventSlim(false);
 
-            public TestDrawableModel(int id)
-                : this($"Model {id}")
+            protected virtual Color4 BackgroundColour
             {
+                get
+                {
+                    switch (id % 5)
+                    {
+                        default:
+                            return Color4.SkyBlue;
+
+                        case 1:
+                            return Color4.Tomato;
+
+                        case 2:
+                            return Color4.DarkGreen;
+
+                        case 3:
+                            return Color4.MediumPurple;
+
+                        case 4:
+                            return Color4.DarkOrchid;
+                    }
+                }
             }
 
-            protected TestDrawableModel(string text)
+            public TestDrawableModel(int id)
             {
+                this.id = id;
+
                 RelativeSizeAxes = Axes.Both;
 
                 InternalChildren = new Drawable[]
···
                     new Box
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Colour = Color4.SkyBlue
+                        Colour = BackgroundColour
                     },
                     new SpriteText
                     {
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
-                        Text = text
+                        Text = id > 0 ? $"model {id}" : "null"
                     }
                 };
             }
···
             }
         }
 
-        private class TestPlaceholder : TestDrawableModel
+        private class TestNullDrawableModel : TestDrawableModel
         {
-            public TestPlaceholder()
-                : base("Placeholder")
+            protected override Color4 BackgroundColour => Color4.SlateGray;
+
+            public TestNullDrawableModel()
+                : base(0)
             {
                 AllowLoad.Set();
             }
···
 
         private class TestModelBackedDrawable : ModelBackedDrawable<TestModel>
         {
+            public bool ShowNullModel;
+
+            public bool HasIntermediate;
+
             protected override Drawable CreateDrawable(TestModel model)
             {
-                if (model == null)
-                    return HasPlaceholder ? new TestPlaceholder() : null;
+                if (model == null && ShowNullModel)
+                    return new TestNullDrawableModel();
 
-                return model.DrawableModel;
+                return model?.DrawableModel;
             }
 
             public new Drawable DisplayedDrawable => base.DisplayedDrawable;
 
             public new TestModel Model
             {
-                get => base.Model;
                 set => base.Model = value;
             }
 
-            public bool InternalFadeOutImmediately;
-
-            public bool HasPlaceholder;
-
-            protected override bool FadeOutImmediately => InternalFadeOutImmediately;
+            protected override bool TransformImmediately => HasIntermediate;
         }
     }
 }

osu.Framework.Tests/Visual/Drawables/TestSceneModelBackedDrawableWithLoading.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Threading;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Framework.Tests.Visual.Drawables
+{
+    public class TestSceneModelBackedDrawableWithLoading : FrameworkTestScene
+    {
+        private TestModelBackedDrawable backedDrawable;
+
+        private void createModelBackedDrawable(bool immediate) =>
+            Child = backedDrawable = new TestModelBackedDrawable(immediate)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Size = new Vector2(200),
+            };
+
+        [Test]
+        public void TestNonImmediateTransform()
+        {
+            AddStep("setup", () => createModelBackedDrawable(false));
+            addUsageSteps();
+        }
+
+        [Test]
+        public void TestTransformImmediately()
+        {
+            AddStep("setup", () => createModelBackedDrawable(true));
+            addUsageSteps();
+        }
+
+        private void addUsageSteps()
+        {
+            TestDrawableModel drawableModel = null;
+
+            AddStep("load first model", () => backedDrawable.Model = new TestModel(drawableModel = new TestDrawableModel()));
+            AddWaitStep("wait a bit", 5);
+            AddStep("finish load", () => drawableModel.AllowLoad.Set());
+            AddWaitStep("wait a bit", 5);
+            AddStep("load second model", () => backedDrawable.Model = new TestModel(drawableModel = new TestDrawableModel()));
+            AddWaitStep("wait a bit", 5);
+            AddStep("finish load", () => drawableModel.AllowLoad.Set());
+        }
+
+        private class TestModelBackedDrawable : ModelBackedDrawable<TestModel>
+        {
+            public new TestModel Model
+            {
+                set => base.Model = value;
+            }
+
+            private readonly bool immediate;
+            private readonly Drawable spinner;
+
+            public TestModelBackedDrawable(bool immediate)
+            {
+                this.immediate = immediate;
+
+                CornerRadius = 5;
+                Masking = true;
+
+                AddRangeInternal(new[]
+                {
+                    new Box
+                    {
+                        Colour = new Color4(0.1f, 0.1f, 0.1f, 1),
+                        RelativeSizeAxes = Axes.Both,
+                        Depth = float.MaxValue
+                    },
+                    spinner = new LoadingSpinner
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Size = new Vector2(20),
+                        Alpha = 0,
+                        Depth = float.MinValue
+                    }
+                });
+            }
+
+            protected override bool TransformImmediately => immediate;
+
+            protected override double TransformDuration => 500;
+
+            protected override Drawable CreateDrawable(TestModel model) => model?.Drawable;
+
+            protected override void OnLoadStarted()
+            {
+                base.OnLoadStarted();
+
+                if (!immediate)
+                    DisplayedDrawable?.FadeTo(0, 300, Easing.OutQuint);
+
+                spinner.FadeIn(300, Easing.OutQuint);
+            }
+
+            protected override void OnLoadFinished()
+            {
+                base.OnLoadFinished();
+
+                spinner.FadeOut(250, Easing.OutQuint);
+            }
+        }
+
+        private class TestModel
+        {
+            public readonly Drawable Drawable;
+
+            public TestModel(TestDrawableModel drawable)
+            {
+                Drawable = drawable;
+            }
+        }
+
+        private class TestDrawableModel : CompositeDrawable
+        {
+            private static int id = 1;
+
+            public readonly ManualResetEventSlim AllowLoad = new ManualResetEventSlim();
+
+            protected Color4 BackgroundColour
+            {
+                get
+                {
+                    switch (id % 5)
+                    {
+                        default:
+                            return Color4.SkyBlue;
+
+                        case 1:
+                            return Color4.Tomato;
+
+                        case 2:
+                            return Color4.DarkGreen;
+
+                        case 3:
+                            return Color4.MediumPurple;
+
+                        case 4:
+                            return Color4.DarkOrchid;
+                    }
+                }
+            }
+
+            public TestDrawableModel()
+            {
+                RelativeSizeAxes = Axes.Both;
+
+                InternalChildren = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Colour = BackgroundColour
+                    },
+                    new SpriteText
+                    {
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Text = $"Model {id++}"
+                    }
+                };
+            }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                AllowLoad.Wait();
+            }
+        }
+
+        private class LoadingSpinner : CompositeDrawable
+        {
+            private readonly SpriteIcon icon;
+
+            public LoadingSpinner()
+            {
+                InternalChild = icon = new SpriteIcon
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Icon = FontAwesome.Solid.Spinner
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                icon.Spin(2000, RotationDirection.Clockwise);
+            }
+        }
+    }
+}

osu.Framework.Tests/Visual/Drawables/TestScenePropertyBoundaries.cs

···
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Testing;
 using osuTK;
 
 namespace osu.Framework.Tests.Visual.Drawables
 {
     [System.ComponentModel.Description("ensure validity of drawables when receiving certain values")]
-    public class TestScenePropertyBoundaries : TestScene
+    public class TestScenePropertyBoundaries : FrameworkTestScene
     {
         [BackgroundDependencyLoader]
         private void load()

osu.Framework.Tests/Visual/Drawables/TestSceneProxyDrawables.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Drawables
 {
-    public class TestSceneProxyDrawables : TestScene
+    public class TestSceneProxyDrawables : FrameworkTestScene
     {
         public TestSceneProxyDrawables()
         {
···
                         generateProxyBelowParentOriginalIndirectlyMaskedAway(1),
                         generateProxyAboveParentOriginalIndirectlyMaskedAway(6),
                         generateProxyBelowParentOriginalIndirectlyMaskedAway(6),
+                        generateOpaqueProxyAboveOpaqueBox(),
                     }
                 }
             };
···
             };
         }
 
+        private Drawable generateOpaqueProxyAboveOpaqueBox()
+        {
+            var box = new Box
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Size = new Vector2(50),
+            };
+
+            var proxy = box.CreateProxy();
+
+            return new Visualiser("proxy above opaque box")
+            {
+                Children = new Drawable[]
+                {
+                    box,
+                    new ProxyVisualiser(proxy, false, 1.0f)
+                }
+            };
+        }
+
         private class NonPresentContainer : Container
         {
             private bool isPresent = true;
···
             private readonly Drawable original;
             private readonly Drawable overlay;
 
-            public ProxyVisualiser(Drawable proxy, bool proxyIsBelow)
+            public ProxyVisualiser(Drawable proxy, bool proxyIsBelow, float boxAlpha = 0.5f)
             {
                 RelativeSizeAxes = Axes.Both;
 
                 original = proxy.Original;
+
                 while (original != (original = original.Original))
                 {
                 }
···
                         new Box
                         {
                             RelativeSizeAxes = Axes.Both,
-                            Alpha = 0.5f,
+                            Alpha = boxAlpha,
                         },
                         new SpriteText
                         {
                             Anchor = Anchor.BottomCentre,
                             Origin = Anchor.BottomCentre,
+                            Colour = Color4.Black,
                             Text = "proxy"
                         }
                     }

osu.Framework.Tests/Visual/Drawables/TestSceneTransformRewinding.cs

···
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Transforms;
 using osu.Framework.MathUtils;
-using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Drawables
 {
-    public class TestSceneTransformRewinding : TestScene
+    public class TestSceneTransformRewinding : FrameworkTestScene
     {
         private const double interval = 250;
         private const int interval_count = 4;
···
                 maxTimeText.Text = wrapping.MaxTime.ToString("n0");
                 maxTimeText.Colour = time > wrapping.MaxTime ? Color4.Gray : wrapping.Time.Elapsed > 0 ? Color4.Blue : Color4.Red;
                 minTimeText.Colour = time < wrapping.MinTime ? Color4.Gray : content.Time.Elapsed > 0 ? Color4.Blue : Color4.Red;
+
                 if (displayedTransforms == null || !ExaminableDrawable.Transforms.SequenceEqual(displayedTransforms))
                 {
                     transforms.Clear();

osu.Framework.Tests/Visual/Drawables/TestSceneUpdateBeforeDraw.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Drawables
 {
     [Description("Tests whether drawable updates occur before drawing.")]
-    public class TestSceneUpdateBeforeDraw : TestScene
+    public class TestSceneUpdateBeforeDraw : FrameworkTestScene
     {
         /// <summary>
         /// Tests whether a <see cref="Drawable"/> is updated before being drawn when it is added to a parent

osu.Framework.Tests/Visual/Drawables/TestSceneWaveform.cs

···
         };
 
         private Button button;
-        private TrackBass track;
+        private Track track;
         private Waveform waveform;
         private Container<Drawable> waveformContainer;
         private readonly Bindable<float> zoom = new BindableFloat(1) { MinValue = 0.1f, MaxValue = 20 };
···
         [BackgroundDependencyLoader]
         private void load(Game game, AudioManager audio)
         {
-            track = new TrackBass(game.Resources.GetStream("Tracks/sample-track.mp3"));
-            audio.Track.AddItem(track);
+            var store = audio.GetTrackStore(game.Resources);
 
-            waveform = new Waveform(game.Resources.GetStream("Tracks/sample-track.mp3"));
+            const string track_name = "Tracks/sample-track.mp3";
+
+            track = store.Get(track_name);
+            waveform = new Waveform(store.GetStream(track_name));
 
             const float track_width = 1366; // required because RelativeSizeAxes.X doesn't seem to work with horizontal scroll
 

osu.Framework.Tests/Visual/Input/TestSceneInputManager.cs

···
 using osu.Framework.Input;
 using osu.Framework.Input.Events;
 using osu.Framework.Input.Handlers.Mouse;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Input
 {
-    public class TestSceneInputManager : TestScene
+    public class TestSceneInputManager : FrameworkTestScene
     {
         public TestSceneInputManager()
         {

osu.Framework.Tests/Visual/Input/TestSceneInputResampler.cs

···
             {
                 NumRaw++;
                 bool foundOne = false;
+
                 foreach (Vector2 relevant in InputResampler.AddPosition(pos))
                 {
                     AddVertex(relevant);

osu.Framework.Tests/Visual/Input/TestSceneJoystick.cs

···
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
 using osu.Framework.Input.Events;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Input
 {
-    public class TestSceneJoystick : TestScene
+    public class TestSceneJoystick : FrameworkTestScene
     {
         public TestSceneJoystick()
         {

osu.Framework.Tests/Visual/Input/TestSceneKeyBindings.cs

···
 
                         Assert.AreEqual(count.OnPressedCount, testButton.OnPressedCount, $"{testButton.Concurrency} {testButton.Action} OnPressedCount");
                         Assert.AreEqual(count.OnReleasedCount, testButton.OnReleasedCount, $"{testButton.Concurrency} {testButton.Action} OnReleasedCount");
+
                         if (testButton is ScrollTestButton scrollTestButton && scrollEntry != null)
                         {
                             Assert.AreEqual(count.OnScrollCount, scrollTestButton.OnScrollCount, $"{testButton.Concurrency} {testButton.Action} OnScrollCount");
···
                 toggleKey(key);
             foreach (var button in pressedMouseButtons.ToArray())
                 toggleMouseButton(button);
+
             foreach (var mode in new[] { none, noneExact, noneModifiers, unique, all })
             {
                 foreach (var action in Enum.GetValues(typeof(TestAction)).Cast<TestAction>())

osu.Framework.Tests/Visual/Input/TestSceneMouseStates.cs

···
                     case MouseMoveEvent mouseMove:
                         LastDelta = mouseMove.ScreenSpaceMousePosition - mouseMove.ScreenSpaceLastMousePosition;
                         break;
+
                     case ScrollEvent scroll:
                         LastScrollDelta = scroll.ScrollDelta;
                         break;
···
                 base.Update();
 
                 var inputManager = GetContainingInputManager();
+
                 if (inputManager != null)
                 {
                     var state = inputManager.CurrentState;

osu.Framework.Tests/Visual/Input/TestSceneNestedHover.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Input
 {
-    public class TestSceneNestedHover : TestScene
+    public class TestSceneNestedHover : FrameworkTestScene
     {
         public TestSceneNestedHover()
         {

osu.Framework.Tests/Visual/Input/TestScenePathInput.cs

···
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input.Events;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Input
 {
-    public class TestScenePathInput : TestScene
+    public class TestScenePathInput : FrameworkTestScene
     {
         private const float path_width = 50;
         private const float path_radius = path_width / 2;

osu.Framework.Tests/Visual/Layout/TestSceneFillFlowContainer.cs

···
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.MathUtils;
-using osu.Framework.Testing;
 using osu.Framework.Threading;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Layout
 {
-    public class TestSceneFillFlowContainer : TestScene
+    public class TestSceneFillFlowContainer : FrameworkTestScene
     {
         private FillDirectionDropdown selectionDropdown;
 
···
                             case 0:
                                 child.Origin = Anchor.TopLeft;
                                 break;
+
                             case 1:
                                 child.Origin = Anchor.TopCentre;
                                 break;
+
                             case 2:
                                 child.Origin = Anchor.TopRight;
                                 break;
+
                             case 3:
                                 child.Origin = Anchor.CentreLeft;
                                 break;
+
                             case 4:
                                 child.Origin = Anchor.Centre;
                                 break;
+
                             case 5:
                                 child.Origin = Anchor.CentreRight;
                                 break;
+
                             case 6:
                                 child.Origin = Anchor.BottomLeft;
                                 break;
+
                             case 7:
                                 child.Origin = Anchor.BottomCentre;
                                 break;
+
                             case 8:
                                 child.Origin = Anchor.BottomRight;
                                 break;

osu.Framework.Tests/Visual/Layout/TestSceneFitInsideFlow.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
-using osu.Framework.Testing;
 using osuTK;
 
 namespace osu.Framework.Tests.Visual.Layout
 {
     [TestFixture]
-    public class TestSceneFitInsideFlow : TestScene
+    public class TestSceneFitInsideFlow : FrameworkTestScene
     {
         private const float container_width = 60;
 

osu.Framework.Tests/Visual/Layout/TestSceneGridContainer.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.MathUtils;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Layout
 {
-    public class TestSceneGridContainer : TestScene
+    public class TestSceneGridContainer : FrameworkTestScene
     {
         private Container gridParent;
         private GridContainer grid;

osu.Framework.Tests/Visual/Layout/TestSceneLayoutDurations.cs

···
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Framework.MathUtils;
-using osu.Framework.Testing;
 using osu.Framework.Timing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Layout
 {
-    public class TestSceneLayoutDurations : TestScene
+    public class TestSceneLayoutDurations : FrameworkTestScene
     {
         private ManualClock manualClock;
         private Container autoSizeContainer;

osu.Framework.Tests/Visual/Layout/TestSceneLayoutTransformRewinding.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.MathUtils;
-using osu.Framework.Testing;
 using osuTK;
 
 namespace osu.Framework.Tests.Visual.Layout
 {
     [System.ComponentModel.Description("Rewinding of transforms that are important to layout.")]
-    public class TestSceneLayoutTransformRewinding : TestScene
+    public class TestSceneLayoutTransformRewinding : FrameworkTestScene
     {
         private readonly ManualUpdateSubTreeContainer manualContainer;
 

osu.Framework.Tests/Visual/Layout/TestSceneScrollableFlow.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.MathUtils;
-using osu.Framework.Testing;
 using osu.Framework.Threading;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Layout
 {
-    public class TestSceneScrollableFlow : TestScene
+    public class TestSceneScrollableFlow : FrameworkTestScene
     {
         private readonly ScheduledDelegate boxCreator;
 

osu.Framework.Tests/Visual/Layout/TestSceneTableContainer.cs

···
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.MathUtils;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Layout
 {
-    public class TestSceneTableContainer : TestScene
+    public class TestSceneTableContainer : FrameworkTestScene
     {
         private TableContainer table;
 

osu.Framework.Tests/Visual/Platform/TestSceneBorderless.cs

···
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Platform;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Platform
 {
-    public class TestSceneBorderless : TestScene
+    public class TestSceneBorderless : FrameworkTestScene
     {
         private readonly SpriteText currentActualSize = new SpriteText();
         private readonly SpriteText currentClientSize = new SpriteText();

osu.Framework.Tests/Visual/Platform/TestSceneFullscreen.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Drawing;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Platform;
-using osu.Framework.Testing;
 
 namespace osu.Framework.Tests.Visual.Platform
 {
-    public class TestSceneFullscreen : TestScene
+    public class TestSceneFullscreen : FrameworkTestScene
     {
         private readonly SpriteText currentActualSize = new SpriteText();
         private readonly SpriteText currentWindowMode = new SpriteText();
         private readonly SpriteText currentDisplay = new SpriteText();
         private readonly SpriteText supportedWindowModes = new SpriteText();
 
-        private GameWindow window;
+        private IWindow window;
         private readonly BindableSize sizeFullscreen = new BindableSize();
         private readonly Bindable<WindowMode> windowMode = new Bindable<WindowMode>();
 

osu.Framework.Tests/Visual/Platform/TestSceneResourceStores.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+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.Framework.Graphics.Textures;
+using osu.Framework.IO.Stores;
+using osu.Framework.Platform;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Framework.Tests.Visual.Platform
+{
+    public class TestSceneResourceStores : FrameworkTestScene
+    {
+        private FillFlowContainer<ResourceDisplay> flow;
+
+        private FontStore fontStore;
+        private TextureStore textureStore;
+        private Storage storage;
+        private AudioManager audioManager;
+
+        [BackgroundDependencyLoader]
+        private void load(FontStore fontStore, Storage storage, TextureStore textureStore, AudioManager audioManager)
+        {
+            Child = new ScrollContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = flow = new FillFlowContainer<ResourceDisplay>
+                {
+                    Margin = new MarginPadding(10),
+                    Spacing = new Vector2(3),
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Direction = FillDirection.Vertical,
+                },
+            };
+
+            this.fontStore = fontStore;
+            this.textureStore = textureStore;
+            this.audioManager = audioManager;
+            this.storage = storage;
+        }
+
+        [Test]
+        public void TestFontStore() => showResources(fontStore.GetAvailableResources(), fontStore.Get);
+
+        [Test]
+        public void TestStorageBackedResourceStore() => showResources(new StorageBackedResourceStore(storage));
+
+        [Test]
+        public void TestGetTextureStore() => showResources(textureStore.GetAvailableResources(), textureStore.Get);
+
+        [Test]
+        public void TestGetTrackManager() => showResources(audioManager.Tracks);
+
+        private void showResources<T>(IResourceStore<T> store) => showResources(store.GetAvailableResources(), store.Get);
+
+        private void showResources<T>(IEnumerable<string> resources, Func<string, T> fetch)
+        {
+            AddStep("list resources", () =>
+            {
+                flow.Clear();
+
+                foreach (var resourceName in resources)
+                    flow.Add(new ResourceDisplay(resourceName, fetch(resourceName)));
+            });
+
+            AddAssert("ensure all loaded", () => flow.Children.All(rd => rd.Resource != null));
+        }
+
+        private class ResourceDisplay : Container
+        {
+            public readonly object Resource;
+
+            public ResourceDisplay(string name, object resource)
+            {
+                Resource = resource;
+
+                AutoSizeAxes = Axes.Y;
+                RelativeSizeAxes = Axes.X;
+
+                Child = new FillFlowContainer
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Direction = FillDirection.Horizontal,
+                    Spacing = new Vector2(10),
+                    Children = new Drawable[]
+                    {
+                        new Container
+                        {
+                            AutoSizeAxes = Axes.X,
+                            RelativeSizeAxes = Axes.Y,
+                            Children = new[]
+                            {
+                                new Box
+                                {
+                                    Colour = Color4.Navy,
+                                    RelativeSizeAxes = Axes.Both,
+                                },
+                                createDisplay(resource),
+                            }
+                        },
+                        new SpriteText { Text = name },
+                    }
+                };
+            }
+
+            private Drawable createDisplay(object resource)
+            {
+                switch (resource)
+                {
+                    case Texture tex:
+                        return new Sprite
+                        {
+                            Size = new Vector2(20),
+                            Texture = tex
+                        };
+
+                    default:
+                        return new SpriteText { Text = resource.ToString() };
+                }
+            }
+        }
+    }
+}

osu.Framework.Tests/Visual/Platform/TestSceneSafeArea.cs

···
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Platform;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
-using GameWindow = osu.Framework.Platform.GameWindow;
 
 namespace osu.Framework.Tests.Visual.Platform
 {
-    public class TestSceneSafeArea : TestScene
+    public class TestSceneSafeArea : FrameworkTestScene
     {
-        private readonly BindableMarginPadding safeAreaPadding = new BindableMarginPadding();
+        private readonly IBindable<MarginPadding> safeAreaPadding = new BindableMarginPadding();
         private readonly Container container;
         private readonly Box box;
         private readonly SpriteText textbox;
 
-        private GameWindow window;
+        private IWindow window;
 
         public TestSceneSafeArea()
         {

osu.Framework.Tests/Visual/Sprites/TestSceneAnimation.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Textures;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Sprites
 {
     [System.ComponentModel.Description("frame-based animations")]
-    public class TestSceneAnimation : TestScene
+    public class TestSceneAnimation : FrameworkTestScene
     {
         public TestSceneAnimation()
         {

osu.Framework.Tests/Visual/Sprites/TestSceneBufferedContainerView.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
+using osu.Framework.Tests.Visual.Containers;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Framework.Tests.Visual.Sprites
+{
+    public class TestSceneBufferedContainerView : FrameworkTestScene
+    {
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestNoEffects(bool originalEffects) => createTest(0, 0, originalEffects);
+
+        [Test]
+        public void TestSubtractOriginalBlur() => createTest(10, 0, false);
+
+        [Test]
+        public void TestCopyOriginalBlur() => createTest(10, 0, true);
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestBlurViewOnly(bool originalEffects) => createTest(0, 10, originalEffects);
+
+        [TestCase(false)]
+        [TestCase(true)]
+        public void TestBlurBoth(bool originalEffects) => createTest(10, 20, originalEffects);
+
+        [Test]
+        public void TestNonSynchronisedQuad() => createTest(10, 0, false, false);
+
+        private void createTest(float originalBlur, float viewBlur, bool originalEffects, bool synchronisedQuad = true)
+        {
+            AddStep("create container", () =>
+            {
+                BufferedContainer container = new BufferedContainer
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Scale = new Vector2(0.75f),
+                    BlurSigma = new Vector2(originalBlur),
+                    Child = new TestSceneCachedBufferedContainer()
+                };
+
+                Children = new Drawable[]
+                {
+                    container,
+                    new BlurView(container, viewBlur, originalEffects, synchronisedQuad)
+                    {
+                        Position = new Vector2(100, 100)
+                    }
+                };
+            });
+        }
+
+        private class BlurView : CompositeDrawable
+        {
+            public BlurView(BufferedContainer buffer, float blur, bool displayEffects, bool synchronisedQuad)
+            {
+                Size = new Vector2(200);
+                Masking = true;
+                CornerRadius = 20;
+                BorderColour = Color4.Magenta;
+                BorderThickness = 2;
+
+                InternalChildren = new Drawable[]
+                {
+                    new GridContainer
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Content = new[]
+                        {
+                            new Drawable[]
+                            {
+                                new Container
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Children = new Drawable[]
+                                    {
+                                        new Box
+                                        {
+                                            RelativeSizeAxes = Axes.Both,
+                                            Colour = Color4.Magenta
+                                        },
+                                        new SpriteText
+                                        {
+                                            Anchor = Anchor.Centre,
+                                            Origin = Anchor.Centre,
+                                            Text = "You can drag this view.",
+                                            Font = new FontUsage(size: 16),
+                                        }
+                                    }
+                                }
+                            },
+                            new Drawable[]
+                            {
+                                new BufferedContainer
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    BackgroundColour = Color4.Black,
+                                    BlurSigma = new Vector2(blur),
+                                    Child = buffer.CreateView().With(d =>
+                                    {
+                                        d.RelativeSizeAxes = Axes.Both;
+                                        d.SynchronisedDrawQuad = synchronisedQuad;
+                                        d.DisplayOriginalEffects = displayEffects;
+                                    })
+                                }
+                            },
+                        },
+                        RowDimensions = new[]
+                        {
+                            new Dimension(GridSizeMode.Absolute, 20),
+                        }
+                    }
+                };
+            }
+
+            protected override bool OnDrag(DragEvent e)
+            {
+                Position += e.Delta;
+                return true;
+            }
+
+            protected override bool OnDragEnd(DragEndEvent e) => true;
+            protected override bool OnDragStart(DragStartEvent e) => true;
+        }
+    }
+}

osu.Framework.Tests/Visual/Sprites/TestSceneScreenshot.cs

···
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Platform;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Sprites
 {
-    public class TestSceneScreenshot : TestScene
+    public class TestSceneScreenshot : FrameworkTestScene
     {
         [Resolved]
         private GameHost host { get; set; }

osu.Framework.Tests/Visual/Sprites/TestSceneSmoothedEdges.cs

···
             }
         }
 
-        private readonly Box[] boxes = new Box[4];
-
-        protected override void Update()
+        protected override void LoadComplete()
         {
-            base.Update();
+            base.LoadComplete();
 
-            foreach (Box box in boxes)
-                box.Rotation += 0.01f;
+            for (int i = 0; i < Rows * Cols; ++i)
+                boxes[i].Spin(10000, RotationDirection.Clockwise);
         }
+
+        private readonly Box[] boxes = new Box[4];
     }
 }

osu.Framework.Tests/Visual/Sprites/TestSceneSpriteIcon.cs

···
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Sprites
 {
     [TestFixture]
-    public class TestSceneSpriteIcon : TestScene
+    public class TestSceneSpriteIcon : FrameworkTestScene
     {
         public TestSceneSpriteIcon()
         {
···
             });
 
             var weights = typeof(FontAwesome).GetNestedTypes();
+
             foreach (var w in weights)
             {
                 flow.Add(new SpriteText

osu.Framework.Tests/Visual/Sprites/TestSceneSpriteText.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 
 namespace osu.Framework.Tests.Visual.Sprites
 {
-    public class TestSceneSpriteText : TestScene
+    public class TestSceneSpriteText : FrameworkTestScene
     {
         public TestSceneSpriteText()
         {

osu.Framework.Tests/Visual/Sprites/TestSceneSpriteTextScenarios.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
···
                         {
                             default:
                                 return LOCALISABLE_STRING_EN;
+
                             case "ja":
                                 return LOCALISABLE_STRING_JA;
                         }
···
             public void Dispose()
             {
             }
+
+            public IEnumerable<string> GetAvailableResources() => Enumerable.Empty<string>();
         }
     }
 }

osu.Framework.Tests/Visual/Sprites/TestSceneSpriteTextTruncate.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Sprites
 {
-    public class TestSceneSpriteTextTruncate : TestScene
+    public class TestSceneSpriteTextTruncate : FrameworkTestScene
     {
         private readonly FillFlowContainer flow;
 

osu.Framework.Tests/Visual/Sprites/TestSceneTextFlow.cs

···
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Sprites
 {
     [System.ComponentModel.Description("word-wrap and paragraphs")]
-    public class TestSceneTextFlow : TestScene
+    public class TestSceneTextFlow : FrameworkTestScene
     {
         public TestSceneTextFlow()
         {

osu.Framework.Tests/Visual/Sprites/TestSceneTextures.cs

···
 using osu.Framework.Graphics.Textures;
 using osu.Framework.IO.Stores;
 using osu.Framework.Platform;
-using osu.Framework.Testing;
 
 namespace osu.Framework.Tests.Visual.Sprites
 {
-    public class TestSceneTextures : TestScene
+    public class TestSceneTextures : FrameworkTestScene
     {
         [Cached]
         private TextureStore normalStore;
···
             AddAssert("textures share gl texture", () => avatar1.Texture.TextureGL == avatar2.Texture.TextureGL);
             AddAssert("textures have different refcount textures", () => avatar1.Texture != avatar2.Texture);
 
-            AddStep("remove delayed from children", Clear);
+            AddStep("dispose children", () =>
+            {
+                Clear();
+                avatar1.Dispose();
+                avatar2.Dispose();
+            });
 
             AddUntilStep("gl textures disposed", () => texture.ReferenceCount == 0);
         }

osu.Framework.Tests/Visual/Sprites/TestSceneTriangles.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
-using osu.Framework.Testing;
 using osu.Framework.Tests.Visual.Containers;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.Sprites
 {
-    public class TestSceneTriangles : TestScene
+    public class TestSceneTriangles : FrameworkTestScene
     {
         private readonly Container testContainer;
 

osu.Framework.Tests/Visual/Sprites/TestSceneVideoSprite.cs

···
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Video;
 using osu.Framework.IO.Network;
-using osu.Framework.Testing;
 using osu.Framework.Timing;
 
 namespace osu.Framework.Tests.Visual.Sprites
 {
-    public class TestSceneVideoSprite : TestScene
+    public class TestSceneVideoSprite : FrameworkTestScene
     {
         private ManualClock clock;
         private VideoSprite videoSprite;
···
             if (videoSprite != null)
             {
                 var newSecond = (int)(videoSprite.PlaybackPosition / 1000.0);
+
                 if (newSecond != currentSecond)
                 {
                     currentSecond = newSecond;

osu.Framework.Tests/Visual/Testing/TestSceneDrawVisualiser.cs

···
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Visualisation;
-using osu.Framework.Testing;
 using osu.Framework.Tests.Visual.Containers;
 using osuTK;
 
 namespace osu.Framework.Tests.Visual.Testing
 {
-    public class TestSceneDrawVisualiser : TestScene
+    public class TestSceneDrawVisualiser : FrameworkTestScene
     {
         [BackgroundDependencyLoader]
         private void load()

osu.Framework.Tests/Visual/Testing/TestSceneTest.cs

···
 
 namespace osu.Framework.Tests.Visual.Testing
 {
-    public class TestSceneTest : TestScene
+    public class TestSceneTest : FrameworkTestScene
     {
         private int setupRun;
         private int setupStepsRun;

osu.Framework.Tests/Visual/UserInterface/TestSceneCheckboxes.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Testing;
 using osuTK;
 
 namespace osu.Framework.Tests.Visual.UserInterface
 {
-    public class TestSceneCheckboxes : TestScene
+    public class TestSceneCheckboxes : FrameworkTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

osu.Framework.Tests/Visual/UserInterface/TestSceneCircularProgress.cs

···
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Testing;
 using osuTK.Graphics;
 using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.PixelFormats;
 
 namespace osu.Framework.Tests.Visual.UserInterface
 {
-    public class TestSceneCircularProgress : TestScene
+    public class TestSceneCircularProgress : FrameworkTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[] { typeof(CircularProgress), typeof(CircularProgressDrawNode) };
 
···
             var image = new Image<Rgba32>(width, 1);
 
             gradientTextureHorizontal = new Texture(width, 1, true);
+
             for (int i = 0; i < width; ++i)
             {
                 float brightness = (float)i / (width - 1);
···
             image = new Image<Rgba32>(width, 1);
 
             gradientTextureVertical = new Texture(1, width, true);
+
             for (int i = 0; i < width; ++i)
             {
                 float brightness = (float)i / (width - 1);
···
             image = new Image<Rgba32>(width, width);
 
             gradientTextureBoth = new Texture(width, width, true);
+
             for (int i = 0; i < width; ++i)
             {
                 for (int j = 0; j < width; ++j)
···
         protected override void Update()
         {
             base.Update();
+
             switch (rotateMode)
             {
                 case 0:
                     clock.Current.Value = Time.Current % (period * 2) / period - 1;
                     break;
+
                 case 1:
                     clock.Current.Value = Time.Current % period / period;
                     break;
+
                 case 2:
                     clock.Current.Value = Time.Current % period / period - 1;
                     break;
+
                 case 3:
                     clock.Current.Value = Time.Current % transition_period / transition_period / 5 - 0.1f;
                     break;
+
                 case 4:
                     clock.Current.Value = (Time.Current % transition_period / transition_period / 5 - 0.1f + 2) % 2 - 1;
                     break;
···
                 case 0:
                     clock.Texture = Texture.WhitePixel;
                     break;
+
                 case 1:
                     clock.Texture = gradientTextureHorizontal;
                     break;
+
                 case 2:
                     clock.Texture = gradientTextureVertical;
                     break;
+
                 case 3:
                     clock.Texture = gradientTextureBoth;
                     break;
···
                 case 0:
                     clock.Colour = new Color4(255, 255, 255, 255);
                     break;
+
                 case 1:
                     clock.Colour = new Color4(255, 128, 128, 255);
                     break;
+
                 case 2:
                     clock.Colour = new ColourInfo
                     {
···
                         BottomRight = new Color4(128, 255, 128, 255),
                     };
                     break;
+
                 case 3:
                     clock.Colour = new ColourInfo
                     {
···
                         BottomRight = new Color4(128, 255, 128, 255),
                     };
                     break;
+
                 case 4:
                     clock.Colour = new ColourInfo
                     {

osu.Framework.Tests/Visual/UserInterface/TestSceneContextMenu.cs

···
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.UserInterface
 {
-    public class TestSceneContextMenu : TestScene
+    public class TestSceneContextMenu : FrameworkTestScene
     {
         private const int start_time = 0;
         private const int duration = 1000;

osu.Framework.Tests/Visual/UserInterface/TestSceneCountingText.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Testing;
 using osuTK;
 
 namespace osu.Framework.Tests.Visual.UserInterface
 {
-    public class TestSceneCountingText : TestScene
+    public class TestSceneCountingText : FrameworkTestScene
     {
         private readonly Bindable<CountType> countType = new Bindable<CountType>();
 
···
                 default:
                 case CountType.AsDouble:
                     return value.ToString(CultureInfo.InvariantCulture);
+
                 case CountType.AsInteger:
                     return ((int)value).ToString();
+
                 case CountType.AsIntegerCeiling:
                     return ((int)Math.Ceiling(value)).ToString();
+
                 case CountType.AsDouble2:
                     return Math.Round(value, 2).ToString(CultureInfo.InvariantCulture);
+
                 case CountType.AsDouble4:
                     return Math.Round(value, 4).ToString(CultureInfo.InvariantCulture);
             }

osu.Framework.Tests/Visual/UserInterface/TestSceneDrawablePath.cs

···
             protected override bool OnDrag(DragEvent e)
             {
                 Vector2 pos = e.MousePosition;
+
                 if ((pos - oldPos).Length > 10)
                 {
                     AddVertex(pos);

osu.Framework.Tests/Visual/UserInterface/TestSceneMarkdown.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Containers.Markdown;
 using osu.Framework.IO.Network;
-using osu.Framework.Testing;
 
 namespace osu.Framework.Tests.Visual.UserInterface
 {
     [Description("markdown reader")]
-    public class TestSceneMarkdown : TestScene
+    public class TestSceneMarkdown : FrameworkTestScene
     {
         public TestSceneMarkdown()
         {

osu.Framework.Tests/Visual/UserInterface/TestSceneNestedMenus.cs

···
             AddAssert("Check closed", () =>
             {
                 int currentSubMenu = 3;
+
                 while (true)
                 {
                     var subMenu = menus.GetSubMenu(currentSubMenu);
···
             AddAssert("Check closed", () =>
             {
                 int currentSubMenu = 3;
+
                 while (true)
                 {
                     var subMenu = menus.GetSubMenu(currentSubMenu);
···
             public Menu GetSubMenu(int index)
             {
                 var currentMenu = menu;
+
                 for (int i = 0; i < index; i++)
                 {
                     if (currentMenu == null)

osu.Framework.Tests/Visual/UserInterface/TestSceneRigidBody.cs

···
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.MathUtils;
 using osu.Framework.Physics;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.UserInterface
 {
-    public class TestSceneRigidBody : TestScene
+    public class TestSceneRigidBody : FrameworkTestScene
     {
         private readonly TestRigidBodySimulation sim;
 
···
             for (int i = 0; i < n; i++)
             {
                 RigidBodyContainer<Drawable> d;
+
                 do
                 {
                     d = generate();

osu.Framework.Tests/Visual/UserInterface/TestSceneScreenStack.cs

···
 using osu.Framework.Input.Events;
 using osu.Framework.MathUtils;
 using osu.Framework.Screens;
-using osu.Framework.Testing;
 using osu.Framework.Testing.Input;
 using osuTK;
 using osuTK.Graphics;
···
 
 namespace osu.Framework.Tests.Visual.UserInterface
 {
-    public class TestSceneScreenStack : TestScene
+    public class TestSceneScreenStack : FrameworkTestScene
     {
         private TestScreen baseScreen;
         private ScreenStack stack;
···
             AddStep("Setup screens", () =>
             {
                 screens = new List<TestScreen>();
+
                 for (int i = 0; i < 5; i++)
                 {
                     var screen = new TestScreen();

osu.Framework.Tests/Visual/UserInterface/TestSceneSearchContainer.cs

···
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Testing;
 using osuTK;
 
 namespace osu.Framework.Tests.Visual.UserInterface
 {
-    public class TestSceneSearchContainer : TestScene
+    public class TestSceneSearchContainer : FrameworkTestScene
     {
         private SearchContainer search;
         private BasicTextBox textBox;

osu.Framework.Tests/Visual/UserInterface/TestSceneTabControl.cs

···
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input;
-using osu.Framework.Testing;
 using osuTK;
 
 namespace osu.Framework.Tests.Visual.UserInterface
 {
-    public class TestSceneTabControl : TestScene
+    public class TestSceneTabControl : FrameworkTestScene
     {
         private readonly IEnumerable<TestEnum> items;
 

osu.Framework.Tests/Visual/UserInterface/TestSceneTextBox.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Testing;
 using osuTK;
 
 namespace osu.Framework.Tests.Visual.UserInterface
 {
-    public class TestSceneTextBox : TestScene
+    public class TestSceneTextBox : FrameworkTestScene
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {

osu.Framework.Tests/Visual/UserInterface/TestSceneTooltip.cs

···
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Framework.Testing;
 using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Tests.Visual.UserInterface
 {
-    public class TestSceneTooltip : TestScene
+    public class TestSceneTooltip : FrameworkTestScene
     {
         private readonly Container testContainer;
 
···
             testContainer.Clear();
 
             CursorContainer cursor = null;
+
             if (!cursorlessTooltip)
             {
                 cursor = new RectangleCursorContainer();

osu.Framework.iOS.props

···
     <Reference Include="mscorlib" />
   </ItemGroup>
   <ItemGroup Label="Package References">
-    <PackageReference Include="Markdig" Version="0.15.7" />
-    <PackageReference Include="FFmpeg.AutoGen" Version="4.1.0.2" />
+    <PackageReference Include="Markdig" Version="0.17.0" />
+    <PackageReference Include="FFmpeg.AutoGen" Version="4.1.0.4" />
     <PackageReference Include="SharpFNT" Version="1.1.0" />
     <PackageReference Include="SixLabors.ImageSharp" Version="1.0.0-beta0006" />
     <PackageReference Include="System.Drawing.Common" Version="4.5.1" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="2.10.0" />
-    <PackageReference Include="ppy.osuTK.NS20" Version="1.0.66" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.0.0" />
+    <PackageReference Include="ppy.osuTK.NS20" Version="1.0.101" />
     <PackageReference Include="System.Runtime.InteropServices" Version="4.3.0" />
     <PackageReference Include="ppy.Microsoft.Diagnostics.Runtime" Version="0.9.180305.1" />
-    <PackageReference Include="NUnit" Version="3.11.0" />
+    <PackageReference Include="NUnit" Version="3.12.0" />
     <PackageReference Include="System.Net.Http" Version="4.3.4" />
     <PackageReference Include="ManagedBass" Version="2.0.4" />
     <PackageReference Include="ManagedBass.Fx" Version="2.0.1" />
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
+    <PackageReference Include="Newtonsoft.Json" Version="12.0.2" />
     <PackageReference Include="System.Reflection.Emit.Lightweight" Version="4.3.0" />
     <PackageReference Include="System.Reflection.Emit.ILGeneration" Version="4.3.0" />
-    <PackageReference Include="JetBrains.Annotations" Version="2018.3.0" />
+    <PackageReference Include="JetBrains.Annotations" Version="2019.1.1" />
   </ItemGroup>
-</Project>
+</Project>

osu.Framework.iOS/IOSGameHost.cs

···
 
 using System;
 using System.Collections.Generic;
+using osu.Framework.Configuration;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Input;
 using osu.Framework.Input.Handlers;
···
             base.SetupForRun();
             IOSGameWindow.GameView = gameView;
             Window = new IOSGameWindow();
+        }
+
+        protected override void SetupConfig(IDictionary<FrameworkSetting, object> gameDefaults)
+        {
+            base.SetupConfig(gameDefaults);
+
+            DebugConfig.Set(DebugSetting.BypassFrontToBackPass, true);
         }
 
         protected override void PerformExit(bool immediately)

osu.Framework.iOS/IOSGameWindow.cs

···
 using osu.Framework.Graphics;
 using System;
 using System.Collections.Generic;
+using osu.Framework.Bindables;
 
 namespace osu.Framework.iOS
 {
     public class IOSGameWindow : GameWindow
     {
         internal static IOSGameView GameView;
+
+        private readonly BindableMarginPadding safeAreaPadding = new BindableMarginPadding();
+
+        public override IBindable<MarginPadding> SafeAreaPadding => safeAreaPadding;
 
         public IOSGameWindow()
             : base(GameView)
···
 
         private void onResize(object sender, EventArgs e)
         {
-            SafeAreaPadding.Value = new MarginPadding
+            safeAreaPadding.Value = new MarginPadding
             {
                 Top = (float)GameView.SafeArea.Top * GameView.Scale,
                 Left = (float)GameView.SafeArea.Left * GameView.Scale,

osu.Framework.iOS/osu.Framework.iOS.csproj

···
     <ProjectReference Include="..\osu.Framework\osu.Framework.csproj" />
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="ppy.osuTK.iOS" Version="1.0.66" />
+    <PackageReference Include="ppy.osuTK.iOS" Version="1.0.101" />
     <PackageReference Include="SixLabors.ImageSharp" Version="1.0.0-beta0006" />
   </ItemGroup>
 </Project>

osu.Framework/Allocation/BackgroundDependencyLoaderAttribute.cs

···
             {
                 case 0:
                     return (_, __) => { };
+
                 case 1:
                     var method = loaderMethods[0];
 
···
                                 case OperationCanceledException _:
                                     // This activator is cancelled - propagate the cancellation as-is (it will be handled silently)
                                     throw exc.InnerException;
+
                                 case DependencyInjectionException die:
                                     // A nested activator has failed (multiple Invoke() calls) - propagate the original error
                                     throw die;
···
                             throw new DependencyInjectionException { DispatchInfo = ExceptionDispatchInfo.Capture(exc.InnerException) };
                         }
                     };
+
                 default:
                     throw new MultipleDependencyLoaderMethodsException(type);
             }

osu.Framework/Allocation/CachedAttribute.cs

···
                         throw new AccessModifierNotAllowedForCachedValueException(AccessModifier.None, pi);
 
                     var setMethod = pi.SetMethod;
+
                     if (setMethod != null)
                     {
                         var modifier = setMethod.GetAccessModifier();

osu.Framework/Allocation/CachedModelDependencyContainer.cs

···
                 case PropertyInfo pi:
                     action(((IBindable)pi.GetValue(targetShadowModel), (IBindable)pi.GetValue(target)));
                     break;
+
                 case FieldInfo fi:
                     action(((IBindable)fi.GetValue(targetShadowModel), (IBindable)fi.GetValue(target)));
                     break;

osu.Framework/Allocation/ObjectHandle.cs

···
             try
             {
                 var value = handle.Target;
+
                 if (value is T)
                 {
                     target = (T)value;

osu.Framework/Allocation/ResolvedAttribute.cs

···
             var activators = new List<Action<object, IReadOnlyDependencyContainer>>();
 
             var properties = type.GetProperties(activator_flags).Where(f => f.GetCustomAttribute<ResolvedAttribute>() != null);
+
             foreach (var property in properties)
             {
                 if (!property.CanWrite)
···
                 var attribute = property.GetCustomAttribute<ResolvedAttribute>();
 
                 var cacheInfo = new CacheInfo(attribute.Name);
+
                 if (attribute.Parent != null)
                 {
                     // When a parent type exists, infer the property name if one is not provided

osu.Framework/Allocation/TripleBuffer.cs

···
 
                     buffers[write].FrameId = Interlocked.Increment(ref currentFrame);
                     return buffers[write];
+
                 case UsageType.Read:
                     if (lastWrite < 0) return null;
 
···
                     lock (buffers)
                         buffers[read].Usage = UsageType.None;
                     break;
+
                 case UsageType.Write:
                     lock (buffers)
                     {

osu.Framework/Audio/AdjustableAudioComponent.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Bindables;
 
 namespace osu.Framework.Audio
 {
-    public class AdjustableAudioComponent : AudioComponent
+    /// <summary>
+    /// An audio component which allows for basic bindable adjustments to be applied.
+    /// </summary>
+    public class AdjustableAudioComponent : AudioComponent, IAggregateAudioAdjustment, IAdjustableAudioComponent
     {
-        private readonly HashSet<BindableDouble> volumeAdjustments = new HashSet<BindableDouble>();
-        private readonly HashSet<BindableDouble> balanceAdjustments = new HashSet<BindableDouble>();
-        private readonly HashSet<BindableDouble> frequencyAdjustments = new HashSet<BindableDouble>();
+        private readonly AudioAdjustments adjustments = new AudioAdjustments();
 
         /// <summary>
-        /// Global volume of this component.
+        /// The volume of this component.
         /// </summary>
-        public readonly BindableDouble Volume = new BindableDouble(1)
-        {
-            MinValue = 0,
-            MaxValue = 1
-        };
-
-        protected readonly BindableDouble VolumeCalculated = new BindableDouble(1)
-        {
-            MinValue = 0,
-            MaxValue = 1
-        };
+        public BindableDouble Volume => adjustments.Volume;
 
         /// <summary>
-        /// Playback balance of this sample (-1 .. 1 where 0 is centered)
+        /// The playback balance of this sample (-1 .. 1 where 0 is centered)
         /// </summary>
-        public readonly BindableDouble Balance = new BindableDouble
-        {
-            MinValue = -1,
-            MaxValue = 1
-        };
-
-        protected readonly BindableDouble BalanceCalculated = new BindableDouble
-        {
-            MinValue = -1,
-            MaxValue = 1
-        };
+        public BindableDouble Balance => adjustments.Balance;
 
         /// <summary>
         /// Rate at which the component is played back (affects pitch). 1 is 100% playback speed, or default frequency.
         /// </summary>
-        public readonly BindableDouble Frequency = new BindableDouble(1);
-
-        protected readonly BindableDouble FrequencyCalculated = new BindableDouble(1);
+        public BindableDouble Frequency => adjustments.Frequency;
 
         protected AdjustableAudioComponent()
         {
-            Volume.ValueChanged += e => InvalidateState(e.NewValue);
-            Balance.ValueChanged += e => InvalidateState(e.NewValue);
-            Frequency.ValueChanged += e => InvalidateState(e.NewValue);
+            AggregateVolume.ValueChanged += InvalidateState;
+            AggregateBalance.ValueChanged += InvalidateState;
+            AggregateFrequency.ValueChanged += InvalidateState;
         }
 
-        internal void InvalidateState(double newValue = 0) => EnqueueAction(OnStateChanged);
+        public void AddAdjustment(AdjustableProperty type, BindableDouble adjustBindable) =>
+            adjustments.AddAdjustment(type, adjustBindable);
 
-        internal virtual void OnStateChanged()
-        {
-            VolumeCalculated.Value = volumeAdjustments.Aggregate(Volume.Value, (current, adj) => current * adj.Value);
-            BalanceCalculated.Value = balanceAdjustments.Aggregate(Balance.Value, (current, adj) => current + adj.Value);
-            FrequencyCalculated.Value = frequencyAdjustments.Aggregate(Frequency.Value, (current, adj) => current * adj.Value);
-        }
+        public void RemoveAdjustment(AdjustableProperty type, BindableDouble adjustBindable) =>
+            adjustments.RemoveAdjustment(type, adjustBindable);
 
-        public void AddAdjustmentDependency(AdjustableAudioComponent component)
-        {
-            AddAdjustment(AdjustableProperty.Balance, component.BalanceCalculated);
-            AddAdjustment(AdjustableProperty.Frequency, component.FrequencyCalculated);
-            AddAdjustment(AdjustableProperty.Volume, component.VolumeCalculated);
-        }
+        internal void InvalidateState(ValueChangedEvent<double> valueChangedEvent = null) => EnqueueAction(OnStateChanged);
 
-        public void RemoveAdjustmentDependency(AdjustableAudioComponent component)
+        internal virtual void OnStateChanged()
         {
-            RemoveAdjustment(AdjustableProperty.Balance, component.BalanceCalculated);
-            RemoveAdjustment(AdjustableProperty.Frequency, component.FrequencyCalculated);
-            RemoveAdjustment(AdjustableProperty.Volume, component.VolumeCalculated);
         }
 
-        public void AddAdjustment(AdjustableProperty type, BindableDouble adjustBindable) => EnqueueAction(() =>
-        {
-            switch (type)
-            {
-                case AdjustableProperty.Balance:
-                    if (balanceAdjustments.Contains(adjustBindable))
-                        throw new ArgumentException("An adjustable binding may only be registered once.");
+        /// <summary>
+        /// Bind all adjustments to another component's aggregated results.
+        /// </summary>
+        /// <param name="component">The other component (generally a direct parent).</param>
+        internal void BindAdjustments(IAggregateAudioAdjustment component) => adjustments.BindAdjustments(component);
 
-                    balanceAdjustments.Add(adjustBindable);
-                    break;
-                case AdjustableProperty.Frequency:
-                    if (frequencyAdjustments.Contains(adjustBindable))
-                        throw new ArgumentException("An adjustable binding may only be registered once.");
+        /// <summary>
+        /// Unbind all adjustments from another component's aggregated results.
+        /// </summary>
+        /// <param name="component">The other component (generally a direct parent).</param>
+        internal void UnbindAdjustments(IAggregateAudioAdjustment component) => adjustments.UnbindAdjustments(component);
 
-                    frequencyAdjustments.Add(adjustBindable);
-                    break;
-                case AdjustableProperty.Volume:
-                    if (volumeAdjustments.Contains(adjustBindable))
-                        throw new ArgumentException("An adjustable binding may only be registered once.");
+        public IBindable<double> AggregateVolume => adjustments.AggregateVolume;
 
-                    volumeAdjustments.Add(adjustBindable);
-                    break;
-            }
+        public IBindable<double> AggregateBalance => adjustments.AggregateBalance;
 
-            InvalidateState();
-        });
-
-        public void RemoveAdjustment(AdjustableProperty type, BindableDouble adjustBindable) => EnqueueAction(() =>
-        {
-            switch (type)
-            {
-                case AdjustableProperty.Balance:
-                    balanceAdjustments.Remove(adjustBindable);
-                    break;
-                case AdjustableProperty.Frequency:
-                    frequencyAdjustments.Remove(adjustBindable);
-                    break;
-                case AdjustableProperty.Volume:
-                    volumeAdjustments.Remove(adjustBindable);
-                    break;
-            }
-
-            InvalidateState();
-        });
+        public IBindable<double> AggregateFrequency => adjustments.AggregateFrequency;
 
         protected override void Dispose(bool disposing)
         {
-            volumeAdjustments.Clear();
-            balanceAdjustments.Clear();
-            frequencyAdjustments.Clear();
-
             base.Dispose(disposing);
+
+            AggregateVolume.UnbindAll();
+            AggregateBalance.UnbindAll();
+            AggregateFrequency.UnbindAll();
         }
     }
 

osu.Framework/Audio/AudioAdjustments.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+
+namespace osu.Framework.Audio
+{
+    /// <summary>
+    /// Provides adjustable and bindable attributes for an audio component.
+    /// Aggregates results as a <see cref="IAggregateAudioAdjustment"/>.
+    /// </summary>
+    public class AudioAdjustments : IAggregateAudioAdjustment, IAdjustableAudioComponent
+    {
+        /// <summary>
+        /// The volume of this component.
+        /// </summary>
+        public BindableDouble Volume { get; } = new BindableDouble(1)
+        {
+            MinValue = 0,
+            MaxValue = 1
+        };
+
+        /// <summary>
+        /// The playback balance of this sample (-1 .. 1 where 0 is centered)
+        /// </summary>
+        public BindableDouble Balance { get; } = new BindableDouble
+        {
+            MinValue = -1,
+            MaxValue = 1
+        };
+
+        /// <summary>
+        /// Rate at which the component is played back (affects pitch). 1 is 100% playback speed, or default frequency.
+        /// </summary>
+        public BindableDouble Frequency { get; } = new BindableDouble(1);
+
+        public IBindable<double> AggregateVolume => volumeAggregate.Result;
+        public IBindable<double> AggregateBalance => balanceAggregate.Result;
+        public IBindable<double> AggregateFrequency => frequencyAggregate.Result;
+
+        private readonly AggregateBindable<double> volumeAggregate;
+        private readonly AggregateBindable<double> balanceAggregate;
+        private readonly AggregateBindable<double> frequencyAggregate;
+
+        public AudioAdjustments()
+        {
+            volumeAggregate = new AggregateBindable<double>((a, b) => a * b, Volume.GetUnboundCopy());
+            volumeAggregate.AddSource(Volume);
+
+            balanceAggregate = new AggregateBindable<double>((a, b) => a + b, Balance.GetUnboundCopy());
+            balanceAggregate.AddSource(Balance);
+
+            frequencyAggregate = new AggregateBindable<double>((a, b) => a * b, Frequency.GetUnboundCopy());
+            frequencyAggregate.AddSource(Frequency);
+        }
+
+        public void AddAdjustment(AdjustableProperty type, BindableDouble adjustBindable)
+        {
+            switch (type)
+            {
+                case AdjustableProperty.Balance:
+                    balanceAggregate.AddSource(adjustBindable);
+                    break;
+
+                case AdjustableProperty.Frequency:
+                    frequencyAggregate.AddSource(adjustBindable);
+                    break;
+
+                case AdjustableProperty.Volume:
+                    volumeAggregate.AddSource(adjustBindable);
+                    break;
+            }
+        }
+
+        public void RemoveAdjustment(AdjustableProperty type, BindableDouble adjustBindable)
+        {
+            switch (type)
+            {
+                case AdjustableProperty.Balance:
+                    balanceAggregate.RemoveSource(adjustBindable);
+                    break;
+
+                case AdjustableProperty.Frequency:
+                    frequencyAggregate.RemoveSource(adjustBindable);
+                    break;
+
+                case AdjustableProperty.Volume:
+                    volumeAggregate.RemoveSource(adjustBindable);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Bind all adjustments from an <see cref="IAggregateAudioAdjustment"/>.
+        /// </summary>
+        /// <param name="component">The adjustment source.</param>
+        internal void BindAdjustments(IAggregateAudioAdjustment component)
+        {
+            volumeAggregate.AddSource(component.AggregateVolume);
+            balanceAggregate.AddSource(component.AggregateBalance);
+            frequencyAggregate.AddSource(component.AggregateFrequency);
+        }
+
+        /// <summary>
+        /// Unbind all adjustments from an <see cref="IAggregateAudioAdjustment"/>.
+        /// </summary>
+        /// <param name="component">The adjustment source.</param>
+        internal void UnbindAdjustments(IAggregateAudioAdjustment component)
+        {
+            volumeAggregate.RemoveSource(component.AggregateVolume);
+            balanceAggregate.RemoveSource(component.AggregateBalance);
+            frequencyAggregate.RemoveSource(component.AggregateFrequency);
+        }
+    }
+}

osu.Framework/Audio/AudioCollectionManager.cs

···
     /// <summary>
     /// A collection of audio components which need central property control.
     /// </summary>
-    public class AudioCollectionManager<T> : AdjustableAudioComponent
+    public class AudioCollectionManager<T> : AdjustableAudioComponent, IBassAudio
         where T : AdjustableAudioComponent
     {
-        protected List<T> Items = new List<T>();
+        internal List<T> Items = new List<T>();
 
         public void AddItem(T item)
         {
-            RegisterItem(item);
-            AddItemToList(item);
-        }
-
-        public void AddItemToList(T item)
-        {
             EnqueueAction(delegate
             {
                 if (Items.Contains(item)) return;
 
+                item.BindAdjustments(this);
                 Items.Add(item);
             });
-        }
-
-        public void RegisterItem(T item)
-        {
-            EnqueueAction(() => item.AddAdjustmentDependency(this));
-        }
-
-        public void UnregisterItem(T item)
-        {
-            EnqueueAction(() => item.RemoveAdjustmentDependency(this));
-        }
-
-        internal override void OnStateChanged()
-        {
-            base.OnStateChanged();
-            foreach (var item in Items)
-                item.OnStateChanged();
         }
 
         public virtual void UpdateDevice(int deviceIndex)

osu.Framework/Audio/AudioComponent.cs

···
 
 namespace osu.Framework.Audio
 {
-    public class AudioComponent : IDisposable, IUpdateable
+    /// <summary>
+    /// A base class for audio components which offers audio thread deferring, disposal and basic update logic.
+    /// </summary>
+    public abstract class AudioComponent : IDisposable, IUpdateable
     {
         /// <summary>
         /// Audio operations will be run on a separate dedicated thread, so we need to schedule any audio API calls using this queue.
         /// </summary>
         protected ConcurrentQueue<Task> PendingActions = new ConcurrentQueue<Task>();
 
+        private bool acceptingActions = true;
+
+        /// <summary>
+        /// Enqueues an action to be performed on the audio thread.
+        /// </summary>
+        /// <param name="action">The action to perform.</param>
+        /// <returns>A task which can be used for continuation logic. May return a <see cref="Task.CompletedTask"/> if called while already on the audio thread.</returns>
         protected Task EnqueueAction(Action action)
         {
             if (ThreadSafety.IsAudioThread)
···
             var task = new Task(action);
             PendingActions.Enqueue(task);
             return task;
-        }
-
-        private bool acceptingActions = true;
-
-        ~AudioComponent()
-        {
-            Dispose(false);
         }
 
         /// <summary>
-        /// Run each loop of the audio thread after queued actions to allow components to update anything they need to.
+        /// Run each loop of the audio thread's execution after queued actions are completed to allow components to perform any additional operations.
         /// </summary>
         protected virtual void UpdateState()
         {
         }
 
+        /// <summary>
+        /// Run each loop of the audio thread's execution, after <see cref="UpdateState"/> as a way to update any child components.
+        /// </summary>
         protected virtual void UpdateChildren()
         {
         }
···
         }
 
         /// <summary>
-        /// This component has completed playback and is now in a stopped state.
+        /// Whether this component has completed playback and is in a stopped state.
         /// </summary>
         public virtual bool HasCompleted => !IsAlive;
 
         /// <summary>
-        /// This component has completed all processing and is ready to be removed from its parent.
+        /// When false, this component has completed all processing and is ready to be removed from its parent.
         /// </summary>
         public virtual bool IsAlive => !IsDisposed;
 
+        /// <summary>
+        /// Whether this component has finished loading its resources.
+        /// </summary>
         public virtual bool IsLoaded => true;
 
         #region IDisposable Support
 
-        protected volatile bool IsDisposed; // To detect redundant calls
+        ~AudioComponent()
+        {
+            Dispose(false);
+        }
+
+        protected volatile bool IsDisposed;
 
         protected virtual void Dispose(bool disposing)
         {

osu.Framework/Audio/AudioManager.cs

···
         /// <summary>
         /// The manager component responsible for audio tracks (e.g. songs).
         /// </summary>
-        public TrackManager Track => GetTrackManager();
+        public ITrackStore Tracks => globalTrackStore.Value;
 
         /// <summary>
         /// The manager component responsible for audio samples (e.g. sound effects).
         /// </summary>
-        public SampleManager Sample => GetSampleManager();
+        public ISampleStore Samples => globalSampleStore.Value;
 
         /// <summary>
         /// The thread audio operations (mainly Bass calls) are ran on.
···
         /// </summary>
         public Scheduler EventScheduler;
 
-        private readonly Lazy<TrackManager> globalTrackManager;
-        private readonly Lazy<SampleManager> globalSampleManager;
+        private readonly Lazy<TrackStore> globalTrackStore;
+        private readonly Lazy<SampleStore> globalSampleStore;
 
         /// <summary>
-        /// Constructs an AudioManager given a track resource store, and a sample resource store.
+        /// Constructs an AudioStore given a track resource store, and a sample resource store.
         /// </summary>
         /// <param name="audioThread">The host's audio thread.</param>
         /// <param name="trackStore">The resource store containing all audio tracks to be used in the future.</param>
···
             sampleStore.AddExtension(@"wav");
             sampleStore.AddExtension(@"mp3");
 
-            globalTrackManager = new Lazy<TrackManager>(() => GetTrackManager(trackStore));
-            globalSampleManager = new Lazy<SampleManager>(() => GetSampleManager(sampleStore));
+            globalTrackStore = new Lazy<TrackStore>(() =>
+            {
+                var store = new TrackStore(trackStore);
+                AddItem(store);
+                store.AddAdjustment(AdjustableProperty.Volume, VolumeTrack);
+                return store;
+            });
+
+            globalSampleStore = new Lazy<SampleStore>(() =>
+            {
+                var store = new SampleStore(sampleStore);
+                AddItem(store);
+                store.AddAdjustment(AdjustableProperty.Volume, VolumeSample);
+                return store;
+            });
 
             scheduler.Add(() =>
             {
···
         private IEnumerable<string> getDeviceNames(List<DeviceInfo> devices) => devices.Skip(1).Select(d => d.Name);
 
         /// <summary>
-        /// Obtains the <see cref="TrackManager"/> corresponding to a given resource store.
-        /// Returns the global <see cref="TrackManager"/> if no resource store is passed.
+        /// Obtains the <see cref="TrackStore"/> corresponding to a given resource store.
+        /// Returns the global <see cref="TrackStore"/> if no resource store is passed.
         /// </summary>
-        /// <param name="store">The <see cref="IResourceStore{T}"/> of which to retrieve the <see cref="TrackManager"/>.</param>
-        public TrackManager GetTrackManager(IResourceStore<byte[]> store = null)
+        /// <param name="store">The <see cref="IResourceStore{T}"/> of which to retrieve the <see cref="TrackStore"/>.</param>
+        public ITrackStore GetTrackStore(IResourceStore<byte[]> store = null)
         {
-            if (store == null) return globalTrackManager.Value;
+            if (store == null) return globalTrackStore.Value;
 
-            TrackManager tm = new TrackManager(store);
-            AddItem(tm);
-            tm.AddAdjustment(AdjustableProperty.Volume, VolumeTrack);
-            VolumeTrack.ValueChanged += e => tm.InvalidateState(e.NewValue);
-
+            TrackStore tm = new TrackStore(store);
+            globalTrackStore.Value.AddItem(tm);
             return tm;
         }
 
         /// <summary>
-        /// Obtains the <see cref="SampleManager"/> corresponding to a given resource store.
-        /// Returns the global <see cref="SampleManager"/> if no resource store is passed.
+        /// Obtains the <see cref="SampleStore"/> corresponding to a given resource store.
+        /// Returns the global <see cref="SampleStore"/> if no resource store is passed.
         /// </summary>
-        /// <param name="store">The <see cref="IResourceStore{T}"/> of which to retrieve the <see cref="SampleManager"/>.</param>
-        public SampleManager GetSampleManager(IResourceStore<byte[]> store = null)
+        /// <param name="store">The <see cref="IResourceStore{T}"/> of which to retrieve the <see cref="SampleStore"/>.</param>
+        public ISampleStore GetSampleStore(IResourceStore<byte[]> store = null)
         {
-            if (store == null) return globalSampleManager.Value;
+            if (store == null) return globalSampleStore.Value;
 
-            SampleManager sm = new SampleManager(store);
-            AddItem(sm);
-            sm.AddAdjustment(AdjustableProperty.Volume, VolumeSample);
-            VolumeSample.ValueChanged += e => sm.InvalidateState(e.NewValue);
-
+            SampleStore sm = new SampleStore(store);
+            globalSampleStore.Value.AddItem(sm);
             return sm;
         }
 
···
                 newDevice = audioDevices.Find(df => df.IsDefault).Name;
 
             bool oldDeviceValid = Bass.CurrentDevice >= 0;
+
             if (oldDeviceValid)
             {
                 DeviceInfo oldDeviceInfo = Bass.GetDeviceInfo(Bass.CurrentDevice);
···
             return true;
         }
 
-        public override void UpdateDevice(int deviceIndex)
-        {
-            Sample.UpdateDevice(deviceIndex);
-            Track.UpdateDevice(deviceIndex);
-        }
-
         private void updateAvailableAudioDevices()
         {
             var currentDeviceList = getAllDevices().Where(d => d.IsEnabled).ToList();
···
                 {
                     // use default device
                     var device = Bass.GetDeviceInfo(Bass.CurrentDevice);
+
                     if (!device.IsDefault && !setAudioDevice())
                     {
                         if (!device.IsEnabled || !setAudioDevice(device.Name))
···
                 {
                     // use whatever is the preferred device
                     var device = Bass.GetDeviceInfo(Bass.CurrentDevice);
+
                     if (device.Name == AudioDevice.Value)
                     {
                         if (!device.IsEnabled && !setAudioDevice())
···
                     else
                     {
                         var preferredDevice = getAllDevices().SingleOrDefault(d => d.Name == AudioDevice.Value);
+
                         if (preferredDevice.Name == AudioDevice.Value && preferredDevice.IsEnabled)
                             setAudioDevice(preferredDevice.Name);
                         else if (!device.IsEnabled && !setAudioDevice())

osu.Framework/Audio/IAdjustableAudioComponent.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+
+namespace osu.Framework.Audio
+{
+    public interface IAdjustableAudioComponent
+    {
+        /// <summary>
+        /// The volume of this component.
+        /// </summary>
+        BindableDouble Volume { get; }
+
+        /// <summary>
+        /// The playback balance of this sample (-1 .. 1 where 0 is centered)
+        /// </summary>
+        BindableDouble Balance { get; }
+
+        /// <summary>
+        /// Rate at which the component is played back (affects pitch). 1 is 100% playback speed, or default frequency.
+        /// </summary>
+        BindableDouble Frequency { get; }
+
+        /// <summary>
+        /// Add a bindable adjustment source.
+        /// </summary>
+        /// <param name="type">The target type for this adjustment.</param>
+        /// <param name="adjustBindable">The bindable adjustment.</param>
+        void AddAdjustment(AdjustableProperty type, BindableDouble adjustBindable);
+
+        /// <summary>
+        /// Remove a bindable adjustment source.
+        /// </summary>
+        /// <param name="type">The target type for this adjustment.</param>
+        /// <param name="adjustBindable">The bindable adjustment.</param>
+        void RemoveAdjustment(AdjustableProperty type, BindableDouble adjustBindable);
+    }
+}

osu.Framework/Audio/IAdjustableResourceStore.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.IO.Stores;
+
+namespace osu.Framework.Audio
+{
+    public interface IAdjustableResourceStore<T> : IResourceStore<T>, IAdjustableAudioComponent
+        where T : AudioComponent
+    {
+    }
+}

osu.Framework/Audio/IAggregateAudioAdjustment.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+
+namespace osu.Framework.Audio
+{
+    /// <summary>
+    /// Provides aggregated adjustments for an audio component.
+    /// </summary>
+    public interface IAggregateAudioAdjustment
+    {
+        /// <summary>
+        /// The aggregate volume of this component (0..1).
+        /// </summary>
+        IBindable<double> AggregateVolume { get; }
+
+        /// <summary>
+        /// The aggregate playback balance of this sample (-1 .. 1 where 0 is centered)
+        /// </summary>
+        IBindable<double> AggregateBalance { get; }
+
+        /// <summary>
+        /// The aggregate rate at which the component is played back (affects pitch). 1 is 100% playback speed, or default frequency.
+        /// </summary>
+        IBindable<double> AggregateFrequency { get; }
+    }
+}

osu.Framework/Audio/Sample/ISampleChannel.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Framework.Audio.Sample
+{
+    /// <summary>
+    /// A channel playing back an audio sample.
+    /// </summary>
+    public interface ISampleChannel
+    {
+        /// <summary>
+        /// Start playback.
+        /// </summary>
+        /// <param name="restart">Whether to restart the sample from the beginning.</param>
+        void Play(bool restart = true);
+
+        /// <summary>
+        /// Stop playback.
+        /// </summary>
+        void Stop();
+
+        /// <summary>
+        /// Whether the sample is playing.
+        /// </summary>
+        bool Playing { get; }
+
+        /// <summary>
+        /// Whether the sample has finished playback.
+        /// </summary>
+        bool Played { get; }
+    }
+}

osu.Framework/Audio/Sample/SampleBass.cs

···
 
 namespace osu.Framework.Audio.Sample
 {
-    internal class SampleBass : Sample, IBassAudio
+    internal sealed class SampleBass : Sample, IBassAudio
     {
         private volatile int sampleId;
 
         public override bool IsLoaded => sampleId != 0;
 
-        public SampleBass(byte[] data, ConcurrentQueue<Task> customPendingActions = null, int concurrency = DEFAULT_CONCURRENCY)
+        internal SampleBass(byte[] data, ConcurrentQueue<Task> customPendingActions = null, int concurrency = DEFAULT_CONCURRENCY)
             : base(concurrency)
         {
             if (customPendingActions != null)

osu.Framework/Audio/Sample/SampleChannel.cs

···
 
 namespace osu.Framework.Audio.Sample
 {
-    public abstract class SampleChannel : AdjustableAudioComponent
+    public abstract class SampleChannel : AdjustableAudioComponent, ISampleChannel
     {
         protected bool WasStarted;
 

osu.Framework/Audio/Sample/SampleChannelBass.cs

···
 
 namespace osu.Framework.Audio.Sample
 {
-    public class SampleChannelBass : SampleChannel, IBassAudio
+    public sealed class SampleChannelBass : SampleChannel, IBassAudio
     {
         private volatile int channel;
         private volatile bool playing;
···
 
             if (channel != 0)
             {
-                Bass.ChannelSetAttribute(channel, ChannelAttribute.Volume, VolumeCalculated.Value);
-                Bass.ChannelSetAttribute(channel, ChannelAttribute.Pan, BalanceCalculated.Value);
-                Bass.ChannelSetAttribute(channel, ChannelAttribute.Frequency, initialFrequency * FrequencyCalculated.Value);
+                Bass.ChannelSetAttribute(channel, ChannelAttribute.Volume, AggregateVolume.Value);
+                Bass.ChannelSetAttribute(channel, ChannelAttribute.Pan, AggregateBalance.Value);
+                Bass.ChannelSetAttribute(channel, ChannelAttribute.Frequency, initialFrequency * AggregateFrequency.Value);
             }
         }
 

osu.Framework/Audio/Sample/SampleManager.cs osu.Framework/Audio/Sample/SampleStore.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.IO;
 using osu.Framework.IO.Stores;
 using osu.Framework.Statistics;
 using System.Linq;
 using System.Threading.Tasks;
+using osu.Framework.Audio.Track;
 
 namespace osu.Framework.Audio.Sample
 {
-    public class SampleManager : AudioCollectionManager<SampleChannel>, IResourceStore<SampleChannel>
+    internal class SampleStore : AudioCollectionManager<AdjustableAudioComponent>, ISampleStore
     {
         private readonly IResourceStore<byte[]> store;
 
···
         /// </summary>
         public int PlaybackConcurrency { get; set; } = Sample.DEFAULT_CONCURRENCY;
 
-        public SampleManager(IResourceStore<byte[]> store)
+        internal SampleStore(IResourceStore<byte[]> store)
         {
             this.store = store;
         }
 
         public SampleChannel Get(string name)
         {
+            if (IsDisposed) throw new ObjectDisposedException($"Cannot retrieve items for an already disposed {nameof(SampleStore)}");
+
             if (string.IsNullOrEmpty(name)) return null;
 
             lock (sampleCache)
             {
                 SampleChannel channel = null;
+
                 if (!sampleCache.TryGetValue(name, out Sample sample))
                 {
                     byte[] data = store.Get(name);
···
 
                 if (sample != null)
                 {
-                    channel = new SampleChannelBass(sample, AddItemToList);
-                    RegisterItem(channel);
+                    channel = new SampleChannelBass(sample, AddItem);
                 }
 
                 return channel;
···
         }
 
         public Stream GetStream(string name) => store.GetStream(name);
+
+        public IEnumerable<string> GetAvailableResources() => store.GetAvailableResources();
     }
 }

osu.Framework/Audio/Track/ISampleStore.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Audio.Sample;
+
+namespace osu.Framework.Audio.Track
+{
+    public interface ISampleStore : IAdjustableResourceStore<SampleChannel>
+    {
+    }
+}

osu.Framework/Audio/Track/ITrack.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Framework.Audio.Track
+{
+    /// <summary>
+    /// An audio track.
+    /// </summary>
+    public interface ITrack
+    {
+        /// <summary>
+        /// States if this track should repeat.
+        /// </summary>
+        bool Looping { get; set; }
+
+        /// <summary>
+        /// Point in time in milliseconds to restart the track to on loop or <see cref="Restart"/>.
+        /// </summary>
+        double RestartPoint { get; set; }
+
+        /// <summary>
+        /// Current position in milliseconds.
+        /// </summary>
+        double CurrentTime { get; }
+
+        /// <summary>
+        /// Length of the track in milliseconds.
+        /// </summary>
+        double Length { get; set; }
+
+        bool IsRunning { get; }
+
+        /// <summary>
+        /// Reset this track to a logical default state.
+        /// </summary>
+        void Reset();
+
+        /// <summary>
+        /// Restarts this track from the <see cref="Track.RestartPoint"/> while retaining adjustments.
+        /// </summary>
+        void Restart();
+
+        void ResetSpeedAdjustments();
+
+        /// <summary>
+        /// Seek to a new position.
+        /// </summary>
+        /// <param name="seek">New position in milliseconds</param>
+        /// <returns>Whether the seek was successful.</returns>
+        bool Seek(double seek);
+
+        /// <summary>
+        /// Start playback.
+        /// </summary>
+        void Start();
+
+        /// <summary>
+        /// Stop playback.
+        /// </summary>
+        void Stop();
+    }
+}

osu.Framework/Audio/Track/ITrackStore.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+
+namespace osu.Framework.Audio.Track
+{
+    public interface ITrackStore : IAdjustableResourceStore<Track>
+    {
+        /// <summary>
+        /// Retrieve a <see cref="TrackVirtual"/> with no audio device backing.
+        /// </summary>
+        /// <param name="length">The length of the virtual track.</param>
+        /// <returns>A new virtual track.</returns>
+        Track GetVirtual(double length = Double.PositiveInfinity);
+    }
+}

osu.Framework/Audio/Track/Track.cs

···
 
 namespace osu.Framework.Audio.Track
 {
-    public abstract class Track : AdjustableAudioComponent, IAdjustableClock, IHasTempoAdjust
+    public abstract class Track : AdjustableAudioComponent, IAdjustableClock, IHasTempoAdjust, ITrack
     {
         public event Action Completed;
         public event Action Failed;
···
 
         protected Track()
         {
-            Tempo.ValueChanged += e => InvalidateState(e.NewValue);
+            Tempo.ValueChanged += InvalidateState;
         }
 
         /// <summary>

osu.Framework/Audio/Track/TrackBass.cs

···
 
 namespace osu.Framework.Audio.Track
 {
-    public class TrackBass : Track, IBassAudio, IHasPitchAdjust
+    public sealed class TrackBass : Track, IBassAudio, IHasPitchAdjust
     {
+        public const int BYTES_PER_SAMPLE = 4;
+
         private AsyncBufferStream dataStream;
 
         /// <summary>
···
         private bool isPlayed;
 
         private long byteLength;
+
+        /// <summary>
+        /// The last position that a seek will succeed for.
+        /// </summary>
+        private double lastSeekablePosition;
 
         private FileCallbacks fileCallbacks;
         private SyncCallback stopCallback;
···
                 if (success)
                 {
                     Length = seconds * 1000;
+
+                    // Bass does not allow seeking to the end of the track, so the last available position is 1 sample before.
+                    lastSeekablePosition = Bass.ChannelBytes2Seconds(activeStream, byteLength - BYTES_PER_SAMPLE) * 1000;
 
                     Bass.ChannelGetAttribute(activeStream, ChannelAttribute.Frequency, out float frequency);
                     initialFrequency = frequency;
···
         {
             // At this point the track may not yet be loaded which is indicated by a 0 length.
             // In that case we still want to return true, hence the conservative length.
-            double conservativeLength = Length == 0 ? double.MaxValue : Length;
+            double conservativeLength = Length == 0 ? double.MaxValue : lastSeekablePosition;
             double conservativeClamped = MathHelper.Clamp(seek, 0, conservativeLength);
 
             await EnqueueAction(() =>
···
         {
             base.OnStateChanged();
 
-            setDirection(FrequencyCalculated.Value < 0);
+            setDirection(AggregateFrequency.Value < 0);
 
-            Bass.ChannelSetAttribute(activeStream, ChannelAttribute.Volume, VolumeCalculated.Value);
-            Bass.ChannelSetAttribute(activeStream, ChannelAttribute.Pan, BalanceCalculated.Value);
+            Bass.ChannelSetAttribute(activeStream, ChannelAttribute.Volume, AggregateVolume.Value);
+            Bass.ChannelSetAttribute(activeStream, ChannelAttribute.Pan, AggregateBalance.Value);
             Bass.ChannelSetAttribute(activeStream, ChannelAttribute.Frequency, bassFreq);
             Bass.ChannelSetAttribute(tempoAdjustStream, ChannelAttribute.Tempo, (Math.Abs(Tempo.Value) - 1) * 100);
         }
 
         private volatile float initialFrequency;
 
-        private int bassFreq => (int)MathHelper.Clamp(Math.Abs(initialFrequency * FrequencyCalculated.Value), 100, 100000);
+        private int bassFreq => (int)MathHelper.Clamp(Math.Abs(initialFrequency * AggregateFrequency.Value), 100, 100000);
 
         private volatile int bitrate;
 

osu.Framework/Audio/Track/TrackManager.cs

···
-// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.IO.Stores;
-
-namespace osu.Framework.Audio.Track
-{
-    public class TrackManager : AudioCollectionManager<Track>
-    {
-        private readonly IResourceStore<byte[]> store;
-
-        public TrackManager(IResourceStore<byte[]> store)
-        {
-            this.store = store;
-        }
-
-        public Track Get(string name)
-        {
-            if (string.IsNullOrEmpty(name)) return null;
-
-            var dataStream = store.GetStream(name);
-
-            if (dataStream == null)
-                return null;
-
-            Track track = new TrackBass(dataStream);
-            AddItem(track);
-            return track;
-        }
-    }
-}

osu.Framework/Audio/Track/TrackStore.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading.Tasks;
+using osu.Framework.IO.Stores;
+
+namespace osu.Framework.Audio.Track
+{
+    internal class TrackStore : AudioCollectionManager<AdjustableAudioComponent>, ITrackStore
+    {
+        private readonly IResourceStore<byte[]> store;
+
+        internal TrackStore(IResourceStore<byte[]> store)
+        {
+            this.store = store;
+        }
+
+        public Track GetVirtual(double length = double.PositiveInfinity)
+        {
+            if (IsDisposed) throw new ObjectDisposedException($"Cannot retrieve items for an already disposed {nameof(TrackStore)}");
+
+            var track = new TrackVirtual(length);
+            AddItem(track);
+            return track;
+        }
+
+        public Track Get(string name)
+        {
+            if (IsDisposed) throw new ObjectDisposedException($"Cannot retrieve items for an already disposed {nameof(TrackStore)}");
+
+            if (string.IsNullOrEmpty(name)) return null;
+
+            var dataStream = store.GetStream(name);
+
+            if (dataStream == null)
+                return null;
+
+            Track track = new TrackBass(dataStream);
+            AddItem(track);
+            return track;
+        }
+
+        public Task<Track> GetAsync(string name) => Task.Run(() => Get(name));
+
+        public Stream GetStream(string name) => store.GetStream(name);
+
+        public IEnumerable<string> GetAvailableResources() => store.GetAvailableResources();
+    }
+}

osu.Framework/Audio/Track/TrackVirtual.cs

···
 
 namespace osu.Framework.Audio.Track
 {
-    public class TrackVirtual : Track
+    public sealed class TrackVirtual : Track
     {
         private readonly StopwatchClock clock = new StopwatchClock();
 
         private double seekOffset;
 
-        public TrackVirtual()
+        public TrackVirtual(double length)
         {
-            Length = double.PositiveInfinity;
+            Length = length;
         }
 
         public override bool Seek(double seek)
···
             base.OnStateChanged();
 
             lock (clock)
-                clock.Rate = Tempo.Value;
+                clock.Rate = Tempo.Value * AggregateFrequency.Value;
         }
     }
 }

osu.Framework/Audio/Track/Waveform.cs

···
     public class Waveform : IDisposable
     {
         /// <summary>
-        /// <see cref="WaveformPoint"/>s are initially generated to a 1ms resolution to cover most use cases.
+        /// <see cref="Point"/>s are initially generated to a 1ms resolution to cover most use cases.
         /// </summary>
         private const float resolution = 0.001f;
 
···
         /// The data stream is iteratively decoded to provide this many points per iteration so as to not exceed BASS's internal buffer size.
         /// </summary>
         private const int points_per_iteration = 100000;
-
-        private const int bytes_per_sample = 4;
 
         /// <summary>
         /// FFT1024 gives ~40hz accuracy.
···
         private const double high_max = 12000;
 
         private int channels;
-        private List<WaveformPoint> points = new List<WaveformPoint>();
+        private List<Point> points = new List<Point>();
 
         private readonly CancellationTokenSource cancelSource = new CancellationTokenSource();
         private readonly Task readTask;
···
                 // Each "point" is generated from a number of samples, each sample contains a number of channels
                 int samplesPerPoint = (int)(info.Frequency * resolution * info.Channels);
 
-                int bytesPerPoint = samplesPerPoint * bytes_per_sample;
+                int bytesPerPoint = samplesPerPoint * TrackBass.BYTES_PER_SAMPLE;
 
                 points.Capacity = (int)(length / bytesPerPoint);
 
                 // Each iteration pulls in several samples
                 int bytesPerIteration = bytesPerPoint * points_per_iteration;
-                var sampleBuffer = new float[bytesPerIteration / bytes_per_sample];
+                var sampleBuffer = new float[bytesPerIteration / TrackBass.BYTES_PER_SAMPLE];
 
                 // Read sample data
                 while (length > 0)
                 {
                     length = Bass.ChannelGetData(decodeStream, sampleBuffer, bytesPerIteration);
-                    int samplesRead = (int)(length / bytes_per_sample);
+                    int samplesRead = (int)(length / TrackBass.BYTES_PER_SAMPLE);
 
                     // Each point is composed of multiple samples
                     for (int i = 0; i < samplesRead; i += samplesPerPoint)
                     {
                         // Channels are interleaved in the sample data (data[0] -> channel0, data[1] -> channel1, data[2] -> channel0, etc)
                         // samplesPerPoint assumes this interleaving behaviour
-                        var point = new WaveformPoint(info.Channels);
+                        var point = new Point(info.Channels);
+
                         for (int j = i; j < i + samplesPerPoint; j += info.Channels)
                         {
                             // Find the maximum amplitude for each channel in the point
···
                 float[] bins = new float[fft_bins];
                 int currentPoint = 0;
                 long currentByte = 0;
+
                 while (length > 0)
                 {
                     length = Bass.ChannelGetData(decodeStream, bins, (int)fft_samples);
···
 
             return await Task.Run(() =>
             {
-                var generatedPoints = new List<WaveformPoint>();
+                var generatedPoints = new List<Point>();
                 float pointsPerGeneratedPoint = (float)points.Count / pointCount;
 
                 // Determines at which width (relative to the resolution) our smoothing filter is truncated.
···
                     int startIndex = (int)i - kernelWidth;
                     int endIndex = (int)i + kernelWidth;
 
-                    var point = new WaveformPoint(channels);
+                    var point = new Point(channels);
                     float totalWeight = 0;
+
                     for (int j = startIndex; j < endIndex; j++)
                     {
                         if (j < 0 || j >= points.Count) continue;
···
         /// <summary>
         /// Gets all the points represented by this <see cref="Waveform"/>.
         /// </summary>
-        public List<WaveformPoint> GetPoints() => GetPointsAsync().Result;
+        public List<Point> GetPoints() => GetPointsAsync().Result;
 
         /// <summary>
         /// Gets all the points represented by this <see cref="Waveform"/>.
         /// </summary>
-        public async Task<List<WaveformPoint>> GetPointsAsync()
+        public async Task<List<Point>> GetPointsAsync()
         {
             if (readTask == null)
                 return points;
···
         }
 
         /// <summary>
-        /// Gets the number of channels represented by each <see cref="WaveformPoint"/>.
+        /// Gets the number of channels represented by each <see cref="Point"/>.
         /// </summary>
         public int GetChannels() => GetChannelsAsync().Result;
 
         /// <summary>
-        /// Gets the number of channels represented by each <see cref="WaveformPoint"/>.
+        /// Gets the number of channels represented by each <see cref="Point"/>.
         /// </summary>
         public async Task<int> GetChannelsAsync()
         {
···
         }
 
         #endregion
-    }
 
-    /// <summary>
-    /// Represents a singular point of data in a <see cref="Waveform"/>.
-    /// </summary>
-    public class WaveformPoint
-    {
         /// <summary>
-        /// An array of amplitudes, one for each channel.
+        /// Represents a singular point of data in a <see cref="Waveform"/>.
         /// </summary>
-        public readonly float[] Amplitude;
+        public class Point
+        {
+            /// <summary>
+            /// An array of amplitudes, one for each channel.
+            /// </summary>
+            public readonly float[] Amplitude;
 
-        /// <summary>
-        /// Unnormalised total intensity of the low-range (bass) frequencies.
-        /// </summary>
-        public double LowIntensity;
+            /// <summary>
+            /// Unnormalised total intensity of the low-range (bass) frequencies.
+            /// </summary>
+            public double LowIntensity;
 
-        /// <summary>
-        /// Unnormalised total intensity of the mid-range frequencies.
-        /// </summary>
-        public double MidIntensity;
+            /// <summary>
+            /// Unnormalised total intensity of the mid-range frequencies.
+            /// </summary>
+            public double MidIntensity;
 
-        /// <summary>
-        /// Unnormalised total intensity of the high-range (treble) frequencies.
-        /// </summary>
-        public double HighIntensity;
+            /// <summary>
+            /// Unnormalised total intensity of the high-range (treble) frequencies.
+            /// </summary>
+            public double HighIntensity;
 
-        /// <summary>
-        /// Cconstructs a <see cref="WaveformPoint"/>.
-        /// </summary>
-        /// <param name="channels">The number of channels that contain data.</param>
-        public WaveformPoint(int channels)
-        {
-            Amplitude = new float[channels];
+            /// <summary>
+            /// Cconstructs a <see cref="Point"/>.
+            /// </summary>
+            /// <param name="channels">The number of channels that contain data.</param>
+            public Point(int channels)
+            {
+                Amplitude = new float[channels];
+            }
         }
     }
 }

osu.Framework/Bindables/AggregateBindable.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace osu.Framework.Bindables
+{
+    /// <summary>
+    /// Combines multiple bindables into one aggregate bindable result.
+    /// </summary>
+    /// <typeparam name="T">The type of values.</typeparam>
+    public class AggregateBindable<T>
+    {
+        private readonly Func<T, T, T> aggregateFunction;
+
+        /// <summary>
+        /// The final result after aggregating all added sources.
+        /// </summary>
+        public IBindable<T> Result => result;
+
+        private readonly Bindable<T> result;
+
+        private readonly T initialValue;
+
+        /// <summary>
+        /// Create a new aggregate bindable.
+        /// </summary>
+        /// <param name="aggregateFunction">The function to be used for aggregation, taking two input <see cref="T"/> values and returning one output.</param>
+        /// <param name="resultBindable">An optional newly constructed bindable to use for <see cref="Result"/>. The initial value of this bindable is used as the initial value for the aggregate.</param>
+        public AggregateBindable(Func<T, T, T> aggregateFunction, Bindable<T> resultBindable = null)
+        {
+            this.aggregateFunction = aggregateFunction;
+            result = resultBindable ?? new Bindable<T>();
+            initialValue = result.Value;
+        }
+
+        private readonly Dictionary<WeakReference, IBindable<T>> sourceMapping = new Dictionary<WeakReference, IBindable<T>>();
+
+        /// <summary>
+        /// Add a new source to be included in aggregation.
+        /// </summary>
+        /// <param name="bindable">The bindable to add.</param>
+        public void AddSource(IBindable<T> bindable)
+        {
+            lock (sourceMapping)
+            {
+                if (findExistingWeak(bindable) != null)
+                    return;
+
+                var boundCopy = bindable.GetBoundCopy();
+                sourceMapping.Add(new WeakReference(bindable), boundCopy);
+                boundCopy.BindValueChanged(recalculateAggregate, true);
+            }
+        }
+
+        /// <summary>
+        /// Remove a source from being included in aggregation.
+        /// </summary>
+        /// <param name="bindable">The bindable to remove.</param>
+        public void RemoveSource(IBindable<T> bindable)
+        {
+            lock (sourceMapping)
+            {
+                var weak = findExistingWeak(bindable);
+
+                if (weak != null)
+                {
+                    sourceMapping[weak].UnbindAll();
+                    sourceMapping.Remove(weak);
+                }
+
+                recalculateAggregate();
+            }
+        }
+
+        private WeakReference findExistingWeak(IBindable<T> bindable) => sourceMapping.Keys.FirstOrDefault(k => k.Target == bindable);
+
+        private void recalculateAggregate(ValueChangedEvent<T> obj = null)
+        {
+            T calculated = initialValue;
+
+            lock (sourceMapping)
+            {
+                foreach (var dead in sourceMapping.Keys.Where(k => !k.IsAlive).ToArray())
+                    sourceMapping.Remove(dead);
+
+                foreach (var s in sourceMapping.Values)
+                    calculated = aggregateFunction(calculated, s.Value);
+            }
+
+            result.Value = calculated;
+        }
+    }
+}

osu.Framework/Bindables/Bindable.cs

···
                 case T t:
                     Value = t;
                     break;
+
                 case string s:
-                    Value = typeof(T).IsEnum
-                        ? (T)Enum.Parse(typeof(T), s)
-                        : (T)Convert.ChangeType(s, typeof(T), CultureInfo.InvariantCulture);
+                    var underlyingType = Nullable.GetUnderlyingType(typeof(T)) ?? typeof(T);
+
+                    if (underlyingType.IsEnum)
+                        Value = (T)Enum.Parse(underlyingType, s);
+                    else
+                        Value = (T)Convert.ChangeType(s, underlyingType, CultureInfo.InvariantCulture);
                     break;
+
                 default:
                     throw new ArgumentException($@"Could not parse provided {input.GetType()} ({input}) to {typeof(T)}.");
             }

osu.Framework/Bindables/BindableList.cs

···
                 case null:
                     Clear();
                     break;
+
                 case IEnumerable<T> enumerable:
                     Clear();
                     AddRange(enumerable);
                     break;
+
                 default:
                     throw new ArgumentException($@"Could not parse provided {input.GetType()} ({input}) to {typeof(T)}.");
             }

osu.Framework/Bindables/BindableMarginPadding.cs

···
                         Right = float.Parse(split[3], CultureInfo.InvariantCulture),
                     };
                     break;
+
                 default:
                     base.Parse(input);
                     break;

osu.Framework/Bindables/BindableNumber.cs

···
                     case TypeCode.UInt64:
                     case TypeCode.Int64:
                         return true;
+
                     default:
                         return false;
                 }
···
 
                     byteBindable.Value = Convert.ToByte(val);
                     break;
+
                 case TypeCode.SByte:
                     var sbyteBindable = this as BindableNumber<sbyte>;
                     if (sbyteBindable == null) throw new ArgumentNullException(nameof(sbyteBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     sbyteBindable.Value = Convert.ToSByte(val);
                     break;
+
                 case TypeCode.UInt16:
                     var ushortBindable = this as BindableNumber<ushort>;
                     if (ushortBindable == null) throw new ArgumentNullException(nameof(ushortBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     ushortBindable.Value = Convert.ToUInt16(val);
                     break;
+
                 case TypeCode.Int16:
                     var shortBindable = this as BindableNumber<short>;
                     if (shortBindable == null) throw new ArgumentNullException(nameof(shortBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     shortBindable.Value = Convert.ToInt16(val);
                     break;
+
                 case TypeCode.UInt32:
                     var uintBindable = this as BindableNumber<uint>;
                     if (uintBindable == null) throw new ArgumentNullException(nameof(uintBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     uintBindable.Value = Convert.ToUInt32(val);
                     break;
+
                 case TypeCode.Int32:
                     var intBindable = this as BindableNumber<int>;
                     if (intBindable == null) throw new ArgumentNullException(nameof(intBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     intBindable.Value = Convert.ToInt32(val);
                     break;
+
                 case TypeCode.UInt64:
                     var ulongBindable = this as BindableNumber<ulong>;
                     if (ulongBindable == null) throw new ArgumentNullException(nameof(ulongBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     ulongBindable.Value = Convert.ToUInt64(val);
                     break;
+
                 case TypeCode.Int64:
                     var longBindable = this as BindableNumber<long>;
                     if (longBindable == null) throw new ArgumentNullException(nameof(longBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     longBindable.Value = Convert.ToInt64(val);
                     break;
+
                 case TypeCode.Single:
                     var floatBindable = this as BindableNumber<float>;
                     if (floatBindable == null) throw new ArgumentNullException(nameof(floatBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     floatBindable.Value = Convert.ToSingle(val);
                     break;
+
                 case TypeCode.Double:
                     var doubleBindable = this as BindableNumber<double>;
                     if (doubleBindable == null) throw new ArgumentNullException(nameof(doubleBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
···
 
                     byteBindable.Value += Convert.ToByte(val);
                     break;
+
                 case TypeCode.SByte:
                     var sbyteBindable = this as BindableNumber<sbyte>;
                     if (sbyteBindable == null) throw new ArgumentNullException(nameof(sbyteBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     sbyteBindable.Value += Convert.ToSByte(val);
                     break;
+
                 case TypeCode.UInt16:
                     var ushortBindable = this as BindableNumber<ushort>;
                     if (ushortBindable == null) throw new ArgumentNullException(nameof(ushortBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     ushortBindable.Value += Convert.ToUInt16(val);
                     break;
+
                 case TypeCode.Int16:
                     var shortBindable = this as BindableNumber<short>;
                     if (shortBindable == null) throw new ArgumentNullException(nameof(shortBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     shortBindable.Value += Convert.ToInt16(val);
                     break;
+
                 case TypeCode.UInt32:
                     var uintBindable = this as BindableNumber<uint>;
                     if (uintBindable == null) throw new ArgumentNullException(nameof(uintBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     uintBindable.Value += Convert.ToUInt32(val);
                     break;
+
                 case TypeCode.Int32:
                     var intBindable = this as BindableNumber<int>;
                     if (intBindable == null) throw new ArgumentNullException(nameof(intBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     intBindable.Value += Convert.ToInt32(val);
                     break;
+
                 case TypeCode.UInt64:
                     var ulongBindable = this as BindableNumber<ulong>;
                     if (ulongBindable == null) throw new ArgumentNullException(nameof(ulongBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     ulongBindable.Value += Convert.ToUInt64(val);
                     break;
+
                 case TypeCode.Int64:
                     var longBindable = this as BindableNumber<long>;
                     if (longBindable == null) throw new ArgumentNullException(nameof(longBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     longBindable.Value += Convert.ToInt64(val);
                     break;
+
                 case TypeCode.Single:
                     var floatBindable = this as BindableNumber<float>;
                     if (floatBindable == null) throw new ArgumentNullException(nameof(floatBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");
 
                     floatBindable.Value += Convert.ToSingle(val);
                     break;
+
                 case TypeCode.Double:
                     var doubleBindable = this as BindableNumber<double>;
                     if (doubleBindable == null) throw new ArgumentNullException(nameof(doubleBindable), $"Generic type {typeof(T)} does not match actual bindable type {GetType()}.");

osu.Framework/Bindables/BindableSize.cs

···
 
                     Value = new Size(int.Parse(split[0]), int.Parse(split[1]));
                     break;
+
                 default:
                     base.Parse(input);
                     break;

osu.Framework/Configuration/FrameworkDebugConfig.cs

···
 
             Set(DebugSetting.ActiveGCMode, GCLatencyMode.SustainedLowLatency);
             Set(DebugSetting.BypassCaching, false).ValueChanged += delegate { StaticCached.BypassCache = Get<bool>(DebugSetting.BypassCaching); };
+            Set(DebugSetting.BypassFrontToBackPass, false);
         }
     }
 
     public enum DebugSetting
     {
         ActiveGCMode,
-        BypassCaching
+        BypassCaching,
+        BypassFrontToBackPass
     }
 }

osu.Framework/Extensions/ExtensionMethods.cs

···
                 return null;
 
             var jagged = new T[rectangular.GetLength(0)][];
+
             for (int r = 0; r < rectangular.GetLength(0); r++)
             {
                 jagged[r] = new T[rectangular.GetLength(1)];
···
             var cols = rows == 0 ? 0 : jagged.Max(c => c?.Length ?? 0);
 
             var rectangular = new T[rows, cols];
+
             for (int r = 0; r < rows; r++)
             for (int c = 0; c < cols; c++)
             {

osu.Framework/Game.cs

···
-// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
···
 using osu.Framework.IO.Stores;
 using osu.Framework.Localisation;
 using osu.Framework.Platform;
-using GameWindow = osu.Framework.Platform.GameWindow;
 
 namespace osu.Framework
 {
     public abstract class Game : Container, IKeyBindingHandler<FrameworkAction>
     {
-        public GameWindow Window => Host?.Window;
+        public IWindow Window => Host?.Window;
 
         public ResourceStore<byte[]> Resources { get; private set; }
 
···
             Textures.AddStore(Host.CreateTextureLoaderStore(new OnlineStore()));
             dependencies.Cache(Textures);
 
-            var tracks = new ResourceStore<byte[]>(Resources);
+            var tracks = new ResourceStore<byte[]>();
             tracks.AddStore(new NamespacedResourceStore<byte[]>(Resources, @"Tracks"));
             tracks.AddStore(new OnlineStore());
 
-            var samples = new ResourceStore<byte[]>(Resources);
+            var samples = new ResourceStore<byte[]>();
             samples.AddStore(new NamespacedResourceStore<byte[]>(Resources, @"Samples"));
             samples.AddStore(new OnlineStore());
 
             Audio = new AudioManager(Host.AudioThread, tracks, samples) { EventScheduler = Scheduler };
             dependencies.Cache(Audio);
+
+            dependencies.CacheAs(Audio.Tracks);
+            dependencies.CacheAs(Audio.Samples);
 
             // attach our bindables to the audio subsystem.
             config.BindWith(FrameworkSetting.AudioDevice, Audio.AudioDevice);

osu.Framework/Graphics/Animations/Animation.cs

···
             if (IsPlaying && frameData.Count > 0)
             {
                 currentFrameTime += Time.Elapsed;
+
                 while (currentFrameTime > frameData[currentFrameIndex].Duration)
                 {
                     currentFrameTime -= frameData[currentFrameIndex].Duration;
                     ++currentFrameIndex;
+
                     if (currentFrameIndex >= frameData.Count)
                     {
                         if (Repeat)

osu.Framework/Graphics/Audio/DrawableAudioWrapper.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using JetBrains.Annotations;
+using osu.Framework.Allocation;
+using osu.Framework.Audio;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Transforms;
+
+namespace osu.Framework.Graphics.Audio
+{
+    /// <summary>
+    /// A wrapper which allows audio components (or adjustments) to exist in the draw hierarchy.
+    /// </summary>
+    [Cached(typeof(IAggregateAudioAdjustment))]
+    public abstract class DrawableAudioWrapper : CompositeDrawable, IAggregateAudioAdjustment
+    {
+        /// <summary>
+        /// The volume of this component.
+        /// </summary>
+        public BindableDouble Volume => adjustments.Volume;
+
+        /// <summary>
+        /// The playback balance of this sample (-1 .. 1 where 0 is centered)
+        /// </summary>
+        public BindableDouble Balance => adjustments.Balance;
+
+        /// <summary>
+        /// Rate at which the component is played back (affects pitch). 1 is 100% playback speed, or default frequency.
+        /// </summary>
+        public BindableDouble Frequency => adjustments.Frequency;
+
+        private readonly AdjustableAudioComponent component;
+
+        private readonly bool disposeUnderlyingComponentOnDispose;
+
+        private readonly AudioAdjustments adjustments = new AudioAdjustments();
+
+        /// <summary>
+        /// Creates a <see cref="DrawableAudioWrapper"/> that will contain a drawable child.
+        /// Generally used to add adjustments to a hierarchy without adding an audio component.
+        /// </summary>
+        /// <param name="content">The <see cref="Drawable"/> to be wrapped.</param>
+        protected DrawableAudioWrapper(Drawable content)
+        {
+            AddInternal(content);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="DrawableAudioWrapper"/> that will wrap an audio component (and contain no drawable content).
+        /// </summary>
+        /// <param name="component">The audio component to wrap.</param>
+        /// <param name="disposeUnderlyingComponentOnDispose">Whether the component should be automatically disposed on drawable disposal/expiry.</param>
+        protected DrawableAudioWrapper([NotNull] AdjustableAudioComponent component, bool disposeUnderlyingComponentOnDispose = true)
+        {
+            this.component = component ?? throw new ArgumentNullException(nameof(component));
+            this.disposeUnderlyingComponentOnDispose = disposeUnderlyingComponentOnDispose;
+
+            component.BindAdjustments(adjustments);
+        }
+
+        [BackgroundDependencyLoader(true)]
+        private void load(IAggregateAudioAdjustment parentAdjustment)
+        {
+            if (parentAdjustment != null)
+                adjustments.BindAdjustments(parentAdjustment);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            component?.UnbindAdjustments(adjustments);
+
+            if (disposeUnderlyingComponentOnDispose)
+                component?.Dispose();
+        }
+
+        public IBindable<double> AggregateVolume => adjustments.AggregateVolume;
+
+        public IBindable<double> AggregateBalance => adjustments.AggregateBalance;
+
+        public IBindable<double> AggregateFrequency => adjustments.AggregateFrequency;
+
+        /// <summary>
+        /// Smoothly adjusts <see cref="Volume"/> over time.
+        /// </summary>
+        /// <returns>A <see cref="TransformSequence{T}"/> to which further transforms can be added.</returns>
+        public TransformSequence<DrawableAudioWrapper> VolumeTo(double newVolume, double duration = 0, Easing easing = Easing.None) =>
+            this.TransformBindableTo(Volume, newVolume, duration, easing);
+
+        /// <summary>
+        /// Smoothly adjusts <see cref="Balance"/> over time.
+        /// </summary>
+        /// <returns>A <see cref="TransformSequence{T}"/> to which further transforms can be added.</returns>
+        public TransformSequence<DrawableAudioWrapper> BalanceTo(double newBalance, double duration = 0, Easing easing = Easing.None) =>
+            this.TransformBindableTo(Balance, newBalance, duration, easing);
+
+        /// <summary>
+        /// Smoothly adjusts <see cref="Frequency"/> over time.
+        /// </summary>
+        /// <returns>A <see cref="TransformSequence{T}"/> to which further transforms can be added.</returns>
+        public TransformSequence<DrawableAudioWrapper> FrequencyTo(double newFrequency, double duration = 0, Easing easing = Easing.None) =>
+            this.TransformBindableTo(Frequency, newFrequency, duration, easing);
+    }
+}

osu.Framework/Graphics/Audio/DrawableSample.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Audio.Sample;
+
+namespace osu.Framework.Graphics.Audio
+{
+    /// <summary>
+    /// A <see cref="SampleChannel"/> wrapper to allow insertion in the draw hierarchy to allow transforms, lifetime management etc.
+    /// </summary>
+    public class DrawableSample : DrawableAudioWrapper, ISampleChannel
+    {
+        private readonly SampleChannel channel;
+
+        /// <summary>
+        /// Construct a new drawable sample instance.
+        /// </summary>
+        /// <param name="channel">The audio sample to wrap.</param>
+        /// <param name="disposeChannelOnDisposal">Whether the sample should be automatically disposed on drawable disposal/expiry.</param>
+        public DrawableSample(SampleChannel channel, bool disposeChannelOnDisposal = true)
+            : base(channel, disposeChannelOnDisposal)
+        {
+            this.channel = channel;
+        }
+
+        public void Play(bool restart = true) => channel.Play(restart);
+
+        public void Stop() => channel.Stop();
+
+        public bool Playing => channel.Playing;
+
+        public bool Played => channel.Played;
+    }
+}

osu.Framework/Graphics/Audio/DrawableTrack.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Audio.Track;
+
+namespace osu.Framework.Graphics.Audio
+{
+    /// <summary>
+    /// A <see cref="Track"/> wrapper to allow insertion in the draw hierarchy to allow transforms, lifetime management etc.
+    /// </summary>
+    public class DrawableTrack : DrawableAudioWrapper, ITrack
+    {
+        private readonly Track track;
+
+        /// <summary>
+        /// Construct a new drawable track instance.
+        /// </summary>
+        /// <param name="track">The audio track to wrap.</param>
+        /// <param name="disposeTrackOnDisposal">Whether the track should be automatically disposed on drawable disposal/expiry.</param>
+        public DrawableTrack(Track track, bool disposeTrackOnDisposal = true)
+            : base(track, disposeTrackOnDisposal)
+        {
+            this.track = track;
+        }
+
+        public bool Looping
+        {
+            get => track.Looping;
+            set => track.Looping = value;
+        }
+
+        public double RestartPoint
+        {
+            get => track.RestartPoint;
+            set => track.RestartPoint = value;
+        }
+
+        public double CurrentTime => track.CurrentTime;
+
+        public double Length
+        {
+            get => track.Length;
+            set => track.Length = value;
+        }
+
+        public bool IsRunning => track.IsRunning;
+
+        public void Reset() => track.Reset();
+
+        public void Restart() => track.Restart();
+
+        public void ResetSpeedAdjustments() => track.ResetSpeedAdjustments();
+
+        public bool Seek(double seek) => track.Seek(seek);
+
+        public void Start() => track.Start();
+
+        public void Stop() => track.Stop();
+    }
+}

osu.Framework/Graphics/Audio/WaveformGraph.cs

···
         private float resolution = 1;
 
         /// <summary>
-        /// Gets or sets the amount of <see cref="WaveformPoint"/>'s displayed relative to <see cref="WaveformGraph.DrawWidth"/>.
+        /// Gets or sets the amount of <see cref="Framework.Audio.Track.Waveform.Point"/>'s displayed relative to <see cref="WaveformGraph.DrawWidth"/>.
         /// </summary>
         public float Resolution
         {
···
             private IShader shader;
             private Texture texture;
 
-            private IReadOnlyList<WaveformPoint> points;
+            private IReadOnlyList<Waveform.Point> points;
 
             private Vector2 drawSize;
             private int channels;
···
                             );
                         }
                             break;
+
                         case 1:
                         {
                             quadToDraw = new Quad(
···
                     }
 
                     quadToDraw *= DrawInfo.Matrix;
-                    texture.DrawQuad(quadToDraw, colour, null, vertexBatch.AddAction, Vector2.Divide(localInflationAmount, quadToDraw.Size));
+                    DrawQuad(texture, quadToDraw, colour, null, vertexBatch.AddAction, Vector2.Divide(localInflationAmount, quadToDraw.Size));
                 }
 
                 shader.Unbind();

osu.Framework/Graphics/Batches/VertexBatch.cs

···
 
             VertexBuffer<T> vertexBuffer = currentVertexBuffer;
 
-            if (!vertexBuffer.Vertices[currentVertex].Equals(v))
+            if (vertexBuffer.SetVertex(currentVertex, v))
             {
                 if (changeBeginIndex == -1)
                     changeBeginIndex = currentVertex;
···
                 changeEndIndex = currentVertex + 1;
             }
 
-            vertexBuffer.Vertices[currentVertex] = v;
             ++currentVertex;
 
-            if (currentVertex >= vertexBuffer.Vertices.Length)
+            if (currentVertex >= vertexBuffer.Size)
             {
                 Draw();
                 FrameStatistics.Increment(StatisticsCounterType.VBufOverflow);

osu.Framework/Graphics/BlendingInfo.cs

···
                     SourceAlpha = BlendingFactorSrc.One;
                     DestinationAlpha = BlendingFactorDest.One;
                     break;
+
                 case BlendingMode.Additive:
                     Source = BlendingFactorSrc.SrcAlpha;
                     Destination = BlendingFactorDest.One;
                     SourceAlpha = BlendingFactorSrc.One;
                     DestinationAlpha = BlendingFactorDest.One;
                     break;
+
                 default:
                     Source = BlendingFactorSrc.One;
                     Destination = BlendingFactorDest.Zero;
···
                 case BlendingEquation.Inherit:
                 case BlendingEquation.Add:
                     return BlendEquationMode.FuncAdd;
+
                 case BlendingEquation.Min:
                     return BlendEquationMode.Min;
+
                 case BlendingEquation.Max:
                     return BlendEquationMode.Max;
+
                 case BlendingEquation.Subtract:
                     return BlendEquationMode.FuncSubtract;
+
                 case BlendingEquation.ReverseSubtract:
                     return BlendEquationMode.FuncReverseSubtract;
             }

osu.Framework/Graphics/BufferedDrawNode.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. 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.Graphics.OpenGL;
+using osu.Framework.Graphics.OpenGL.Buffers;
+using osu.Framework.Graphics.OpenGL.Vertices;
+using osu.Framework.Graphics.Primitives;
+using osuTK;
+using osuTK.Graphics;
+using osuTK.Graphics.ES30;
+
+namespace osu.Framework.Graphics
+{
+    public class BufferedDrawNode : TexturedShaderDrawNode
+    {
+        protected new IBufferedDrawable Source => (IBufferedDrawable)base.Source;
+
+        /// <summary>
+        /// The child <see cref="DrawNode"/> which is used to populate the <see cref="FrameBuffer"/>s with.
+        /// </summary>
+        protected readonly DrawNode Child;
+
+        /// <summary>
+        /// Data shared amongst all <see cref="BufferedDrawNode"/>s, providing storage for <see cref="FrameBuffer"/>s.
+        /// </summary>
+        protected readonly BufferedDrawNodeSharedData SharedData;
+
+        /// <summary>
+        /// Contains the colour and blending information of this <see cref="DrawNode"/>.
+        /// </summary>
+        protected new DrawColourInfo DrawColourInfo { get; private set; }
+
+        protected RectangleF DrawRectangle { get; private set; }
+
+        private Color4 backgroundColour;
+        private RectangleF screenSpaceDrawRectangle;
+        private Vector2 frameBufferSize;
+
+        private readonly All filteringMode;
+        private readonly RenderbufferInternalFormat[] formats;
+
+        public BufferedDrawNode(IBufferedDrawable source, DrawNode child, BufferedDrawNodeSharedData sharedData, RenderbufferInternalFormat[] formats = null, bool pixelSnapping = false)
+            : base(source)
+        {
+            this.formats = formats;
+
+            Child = child;
+            SharedData = sharedData;
+
+            filteringMode = pixelSnapping ? All.Nearest : All.Linear;
+        }
+
+        public override void ApplyState()
+        {
+            base.ApplyState();
+
+            backgroundColour = Source.BackgroundColour;
+            screenSpaceDrawRectangle = Source.ScreenSpaceDrawQuad.AABBFloat;
+            DrawColourInfo = Source.FrameBufferDrawColour ?? new DrawColourInfo(Color4.White, base.DrawColourInfo.Blending);
+
+            frameBufferSize = new Vector2((float)Math.Ceiling(screenSpaceDrawRectangle.Width), (float)Math.Ceiling(screenSpaceDrawRectangle.Height));
+            DrawRectangle = filteringMode == All.Nearest
+                ? new RectangleF(screenSpaceDrawRectangle.X, screenSpaceDrawRectangle.Y, frameBufferSize.X, frameBufferSize.Y)
+                : screenSpaceDrawRectangle;
+
+            Child.ApplyState();
+        }
+
+        /// <summary>
+        /// Whether this <see cref="BufferedDrawNode"/> should be redrawn.
+        /// </summary>
+        protected bool RequiresRedraw => GetDrawVersion() > SharedData.DrawVersion;
+
+        /// <summary>
+        /// Retrieves the version of the state of this <see cref="DrawNode"/>.
+        /// The <see cref="BufferedDrawNode"/> will only re-render if this version is greater than that of the rendered <see cref="FrameBuffer"/>s.
+        /// </summary>
+        /// <remarks>
+        /// By default, the <see cref="BufferedDrawNode"/> is re-rendered with every <see cref="DrawNode"/> invalidation.
+        /// </remarks>
+        /// <returns>A version representing this <see cref="DrawNode"/>'s state.</returns>
+        protected virtual long GetDrawVersion() => InvalidationID;
+
+        public sealed override void Draw(Action<TexturedVertex2D> vertexAction)
+        {
+            if (RequiresRedraw)
+            {
+                SharedData.ResetCurrentEffectBuffer();
+
+                using (establishFrameBufferViewport())
+                {
+                    // Fill the frame buffer with drawn children
+                    using (BindFrameBuffer(SharedData.MainBuffer))
+                    {
+                        // We need to draw children as if they were zero-based to the top-left of the texture.
+                        // We can do this by adding a translation component to our (orthogonal) projection matrix.
+                        GLWrapper.PushOrtho(screenSpaceDrawRectangle);
+                        GLWrapper.Clear(new ClearInfo(backgroundColour));
+
+                        Child.Draw(vertexAction);
+
+                        GLWrapper.PopOrtho();
+                    }
+
+                    PopulateContents();
+                }
+
+                SharedData.DrawVersion = GetDrawVersion();
+            }
+
+            Shader.Bind();
+
+            DrawContents();
+
+            Shader.Unbind();
+        }
+
+        /// <summary>
+        /// Populates the contents of the effect buffers of <see cref="SharedData"/>.
+        /// This is invoked after <see cref="Child"/> has been rendered to the main buffer.
+        /// </summary>
+        protected virtual void PopulateContents()
+        {
+        }
+
+        /// <summary>
+        /// Draws the applicable effect buffers of <see cref="SharedData"/> to the back buffer.
+        /// </summary>
+        protected virtual void DrawContents()
+        {
+            GLWrapper.SetBlend(DrawColourInfo.Blending);
+            DrawFrameBuffer(SharedData.MainBuffer, DrawRectangle, DrawColourInfo.Colour);
+        }
+
+        /// <summary>
+        /// Binds and initialises a <see cref="FrameBuffer"/> if required.
+        /// </summary>
+        /// <param name="frameBuffer">The <see cref="FrameBuffer"/> to bind.</param>
+        /// <returns>A token that must be disposed upon finishing use of <paramref name="frameBuffer"/>.</returns>
+        protected ValueInvokeOnDisposal BindFrameBuffer(FrameBuffer frameBuffer)
+        {
+            if (!frameBuffer.IsInitialized)
+                frameBuffer.Initialize(true, filteringMode);
+
+            if (formats != null)
+            {
+                // These additional render buffers are only required if e.g. depth
+                // or stencil information needs to also be stored somewhere.
+                foreach (var f in formats)
+                    frameBuffer.Attach(f);
+            }
+
+            // This setter will also take care of allocating a texture of appropriate size within the frame buffer.
+            frameBuffer.Size = frameBufferSize;
+
+            frameBuffer.Bind();
+
+            return new ValueInvokeOnDisposal(frameBuffer.Unbind);
+        }
+
+        private ValueInvokeOnDisposal establishFrameBufferViewport()
+        {
+            // Disable masking for generating the frame buffer since masking will be re-applied
+            // when actually drawing later on anyways. This allows more information to be captured
+            // in the frame buffer and helps with cached buffers being re-used.
+            RectangleI screenSpaceMaskingRect = new RectangleI((int)Math.Floor(screenSpaceDrawRectangle.X), (int)Math.Floor(screenSpaceDrawRectangle.Y), (int)frameBufferSize.X + 1, (int)frameBufferSize.Y + 1);
+
+            GLWrapper.PushMaskingInfo(new MaskingInfo
+            {
+                ScreenSpaceAABB = screenSpaceMaskingRect,
+                MaskingRect = screenSpaceDrawRectangle,
+                ToMaskingSpace = Matrix3.Identity,
+                BlendRange = 1,
+                AlphaExponent = 1,
+            }, true);
+
+            // Match viewport to FrameBuffer such that we don't draw unnecessary pixels.
+            GLWrapper.PushViewport(new RectangleI(0, 0, (int)frameBufferSize.X, (int)frameBufferSize.Y));
+
+            return new ValueInvokeOnDisposal(returnViewport);
+        }
+
+        private void returnViewport()
+        {
+            GLWrapper.PopViewport();
+            GLWrapper.PopMaskingInfo();
+        }
+    }
+}

osu.Framework/Graphics/BufferedDrawNodeSharedData.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Graphics.OpenGL.Buffers;
+
+namespace osu.Framework.Graphics
+{
+    /// <summary>
+    /// Contains data which is shared between all <see cref="BufferedDrawNode"/>s of a <see cref="Drawable"/>.
+    /// </summary>
+    /// <remarks>
+    /// This should be constructed _once_ per <see cref="Drawable"/>, and given to the constructor of <see cref="BufferedDrawNode"/>.
+    /// </remarks>
+    public class BufferedDrawNodeSharedData : IDisposable
+    {
+        /// <summary>
+        /// The version of drawn contents currently present in <see cref="MainBuffer"/> and <see cref="effectBuffers"/>.
+        /// This should only be modified by <see cref="BufferedDrawNode"/>.
+        /// </summary>
+        internal long DrawVersion = -1;
+
+        /// <summary>
+        /// The <see cref="FrameBuffer"/> which contains the original version of the rendered <see cref="Drawable"/>.
+        /// </summary>
+        public FrameBuffer MainBuffer { get; }
+
+        /// <summary>
+        /// A set of <see cref="FrameBuffer"/>s which are used in a ping-pong manner to render effects to.
+        /// </summary>
+        private readonly FrameBuffer[] effectBuffers;
+
+        /// <summary>
+        /// Creates a new <see cref="BufferedDrawNodeSharedData"/> with no effect buffers.
+        /// </summary>
+        public BufferedDrawNodeSharedData()
+            : this(0)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="BufferedDrawNodeSharedData"/> with a specific amount of effect buffers.
+        /// </summary>
+        /// <param name="effectBufferCount">The number of effect buffers.</param>
+        /// <exception cref="ArgumentOutOfRangeException">If <paramref name="effectBufferCount"/> is less than 0.</exception>
+        public BufferedDrawNodeSharedData(int effectBufferCount)
+        {
+            if (effectBufferCount < 0)
+                throw new ArgumentOutOfRangeException(nameof(effectBufferCount), "Must be positive.");
+
+            MainBuffer = new FrameBuffer();
+            effectBuffers = new FrameBuffer[effectBufferCount];
+
+            for (int i = 0; i < effectBufferCount; i++)
+                effectBuffers[i] = new FrameBuffer();
+        }
+
+        private int currentEffectBuffer = -1;
+
+        /// <summary>
+        /// The <see cref="FrameBuffer"/> which contains the most up-to-date drawn effect.
+        /// </summary>
+        public FrameBuffer CurrentEffectBuffer => currentEffectBuffer == -1 ? MainBuffer : effectBuffers[currentEffectBuffer];
+
+        /// <summary>
+        /// Retrieves the next <see cref="FrameBuffer"/> which effects can be rendered to.
+        /// </summary>
+        /// <exception cref="InvalidOperationException">If there are no available effect buffers.</exception>
+        public FrameBuffer GetNextEffectBuffer()
+        {
+            if (effectBuffers.Length == 0)
+                throw new InvalidOperationException($"The {nameof(BufferedDrawNode)} requested an effect buffer, but none were available.");
+
+            if (++currentEffectBuffer >= effectBuffers.Length)
+                currentEffectBuffer = 0;
+            return effectBuffers[currentEffectBuffer];
+        }
+
+        /// <summary>
+        /// Resets <see cref="CurrentEffectBuffer"/>.
+        /// This should only be called by <see cref="BufferedDrawNode"/>.
+        /// </summary>
+        internal void ResetCurrentEffectBuffer() => currentEffectBuffer = -1;
+
+        ~BufferedDrawNodeSharedData()
+        {
+            Dispose(false);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool isDisposing)
+        {
+            MainBuffer.Dispose();
+
+            for (int i = 0; i < effectBuffers.Length; i++)
+                effectBuffers[i].Dispose();
+        }
+    }
+}

osu.Framework/Graphics/Containers/AudioContainer.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using osu.Framework.Audio;
+using osu.Framework.Graphics.Audio;
+using osu.Framework.Graphics.Effects;
+using osuTK;
+
+namespace osu.Framework.Graphics.Containers
+{
+    /// <summary>
+    /// A container which exposes audio adjustments via <see cref="IAggregateAudioAdjustment"/>.
+    /// </summary>
+    /// <remarks>
+    /// This is a bare-minimal implementation of a container, so it may be required to be nested inside a <see cref="Container"/> for some use cases.
+    /// </remarks>
+    /// <typeparam name="T">The tyoe of <see cref="Drawable"/>.</typeparam>
+    public class AudioContainer<T> : DrawableAudioWrapper, IContainerEnumerable<T>, IContainerCollection<T>, ICollection<T>, IReadOnlyList<T>
+        where T : Drawable
+    {
+        private readonly Container<T> container;
+
+        public AudioContainer()
+            : this(new Container<T>())
+        {
+        }
+
+        private AudioContainer(Container<T> container)
+            : base(container)
+        {
+            this.container = container;
+        }
+
+        public override Vector2 Size
+        {
+            get => container.Size;
+            set
+            {
+                base.Size = new Vector2(
+                    RelativeSizeAxes.HasFlag(Axes.X) ? 1 : value.X,
+                    RelativeSizeAxes.HasFlag(Axes.Y) ? 1 : value.Y);
+
+                container.Size = value;
+            }
+        }
+
+        public override Axes RelativeSizeAxes
+        {
+            get => container.RelativeSizeAxes;
+            set
+            {
+                base.RelativeSizeAxes = value;
+                container.RelativeSizeAxes = value;
+            }
+        }
+
+        public new Axes AutoSizeAxes
+        {
+            get => container.AutoSizeAxes;
+            set
+            {
+                base.AutoSizeAxes = value;
+                container.AutoSizeAxes = value;
+            }
+        }
+
+        public new EdgeEffectParameters EdgeEffect
+        {
+            get => base.EdgeEffect;
+            set => base.EdgeEffect = value;
+        }
+
+        public new Vector2 RelativeChildSize
+        {
+            get => container.RelativeChildSize;
+            set => container.RelativeChildSize = value;
+        }
+
+        public new Vector2 RelativeChildOffset
+        {
+            get => container.RelativeChildOffset;
+            set => container.RelativeChildOffset = value;
+        }
+
+        public Container<T>.Enumerator GetEnumerator() => container.GetEnumerator();
+
+        IEnumerator<T> IEnumerable<T>.GetEnumerator() => GetEnumerator();
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+        public IReadOnlyList<T> Children
+        {
+            get => container.Children;
+            set => container.Children = value;
+        }
+
+        public int RemoveAll(Predicate<T> match) => container.RemoveAll(match);
+
+        public T Child
+        {
+            get => container.Child;
+            set => container.Child = value;
+        }
+
+        public IEnumerable<T> ChildrenEnumerable
+        {
+            set => container.ChildrenEnumerable = value;
+        }
+
+        public void Add(T drawable)
+        {
+            container.Add(drawable);
+        }
+
+        public void Clear()
+        {
+            container.Clear();
+        }
+
+        public bool Contains(T item) => container.Contains(item);
+
+        public void CopyTo(T[] array, int arrayIndex)
+        {
+            container.CopyTo(array, arrayIndex);
+        }
+
+        public void AddRange(IEnumerable<T> collection)
+        {
+            container.AddRange(collection);
+        }
+
+        public bool Remove(T drawable) => container.Remove(drawable);
+        int ICollection<T>.Count => container.Count;
+
+        public bool IsReadOnly => container.IsReadOnly;
+
+        public void RemoveRange(IEnumerable<T> range)
+        {
+            container.RemoveRange(range);
+        }
+
+        int IReadOnlyCollection<T>.Count => container.Count;
+
+        public T this[int index] => container[index];
+    }
+
+    /// <summary>
+    /// A container which exposes audio adjustments via <see cref="IAggregateAudioAdjustment"/>.
+    /// </summary>
+    /// <remarks>
+    /// This is a bare-minimal implementation of a container, so it may be required to be nested inside a <see cref="Container"/> for some use cases.
+    /// </remarks>
+    public class AudioContainer : AudioContainer<Drawable>
+    {
+    }
+}

osu.Framework/Graphics/Containers/BufferedContainer.cs

···
 using System;
 using System.Collections.Generic;
 using osu.Framework.Caching;
+using osu.Framework.Graphics.Sprites;
 
 namespace osu.Framework.Graphics.Containers
 {
···
     /// appearance of the container at the cost of performance. Such effects include
     /// uniform fading of children, blur, and other post-processing effects.
     /// </summary>
-    public partial class BufferedContainer<T> : Container<T>, IBufferedContainer
+    public partial class BufferedContainer<T> : Container<T>, IBufferedContainer, IBufferedDrawable
         where T : Drawable
     {
         private bool drawOriginal;
···
             get => pixelSnapping;
             set
             {
-                if (sharedData != null)
-                {
-                    for (int i = 0; i < sharedData.FrameBuffers.Length; i++)
-                    {
-                        if (sharedData.FrameBuffers[i].IsInitialized)
-                            throw new InvalidOperationException("May only set PixelSnapping before FrameBuffers are initialized (i.e. before the first draw).");
-                    }
-                }
+                if (sharedData?.MainBuffer.IsInitialized == true)
+                    throw new InvalidOperationException("May only set PixelSnapping before FrameBuffers are initialized (i.e. before the first draw).");
 
                 pixelSnapping = value;
             }
···
 
         protected override bool CanBeFlattened => false;
 
+        public IShader TextureShader { get; private set; }
+
+        public IShader RoundedTextureShader { get; private set; }
+
         private IShader blurShader;
 
         /// <summary>
···
         [BackgroundDependencyLoader]
         private void load(ShaderManager shaders)
         {
+            TextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE);
+            RoundedTextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);
             blurShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.BLUR);
         }
 
         private readonly BufferedContainerDrawNodeSharedData sharedData = new BufferedContainerDrawNodeSharedData();
 
-        protected override DrawNode CreateDrawNode() => new BufferedContainerDrawNode(this, sharedData);
+        protected override DrawNode CreateDrawNode() => new BufferedContainerDrawNode(this, sharedData, attachedFormats.ToArray(), PixelSnapping);
 
         private readonly List<RenderbufferInternalFormat> attachedFormats = new List<RenderbufferInternalFormat>();
 
···
             childrenUpdateVersion = updateVersion;
         }
 
-        private DrawColourInfo baseDrawColourInfo => base.DrawColourInfo;
-
-        public override DrawColourInfo DrawColourInfo
+        /// <summary>
+        /// The blending which <see cref="BufferedContainerDrawNode"/> uses for the effect.
+        /// </summary>
+        public BlendingParameters DrawEffectBlending
         {
             get
             {
-                DrawColourInfo result = base.DrawColourInfo;
+                BlendingParameters blending = EffectBlending;
+                if (blending.Mode == BlendingMode.Inherit)
+                    blending.Mode = Blending.Mode;
 
-                // When drawing our children to the frame buffer we do not
-                // want their colour to be polluted by their parent (us!)
-                // since our own color will be applied on top when we render
-                // from the frame buffer to the back buffer later on.
-                result.Colour = ColourInfo.SingleColour(Color4.White);
-                return result;
+                if (blending.RGBEquation == BlendingEquation.Inherit)
+                    blending.RGBEquation = Blending.RGBEquation;
+
+                if (blending.AlphaEquation == BlendingEquation.Inherit)
+                    blending.AlphaEquation = Blending.AlphaEquation;
+
+                return blending;
             }
         }
+
+        /// <summary>
+        /// Creates a view which can be added to a container to display the content of this <see cref="BufferedContainer{T}"/>.
+        /// </summary>
+        /// <returns>The view.</returns>
+        public BufferedContainerView<T> CreateView() => new BufferedContainerView<T>(this, sharedData);
+
+        public DrawColourInfo? FrameBufferDrawColour => base.DrawColourInfo;
+
+        // Children should not receive the true colour to avoid colour doubling when the frame-buffers are rendered to the back-buffer.
+        public override DrawColourInfo DrawColourInfo => new DrawColourInfo(Color4.White, base.DrawColourInfo.Blending);
 
         protected override void Dispose(bool isDisposing)
         {

osu.Framework/Graphics/Containers/BufferedContainer_DrawNode.cs

···
 using osuTK.Graphics.ES30;
 using osuTK.Graphics;
 using osu.Framework.Graphics.Primitives;
-using osu.Framework.Allocation;
 using osu.Framework.Graphics.Shaders;
 using System;
 using osu.Framework.Graphics.Colour;
-using osu.Framework.Graphics.OpenGL.Vertices;
-using System.Diagnostics;
 using osu.Framework.MathUtils;
 
 namespace osu.Framework.Graphics.Containers
 {
     public partial class BufferedContainer<T>
     {
-        private class BufferedContainerDrawNode : CompositeDrawableDrawNode
+        private class BufferedContainerDrawNode : BufferedDrawNode, ICompositeDrawNode
         {
             protected new BufferedContainer<T> Source => (BufferedContainer<T>)base.Source;
 
+            protected new CompositeDrawableDrawNode Child => (CompositeDrawableDrawNode)base.Child;
+
             private bool drawOriginal;
-            private Color4 backgroundColour;
             private ColourInfo effectColour;
             private BlendingParameters effectBlending;
             private EffectPlacement effectPlacement;
···
 
             private long updateVersion;
 
-            private RectangleF screenSpaceDrawRectangle;
-            private All filteringMode;
-
-            private readonly List<RenderbufferInternalFormat> formats = new List<RenderbufferInternalFormat>();
-
             private IShader blurShader;
 
-            private readonly BufferedContainerDrawNodeSharedData sharedData;
-
-            public BufferedContainerDrawNode(BufferedContainer<T> source, BufferedContainerDrawNodeSharedData sharedData)
-                : base(source)
+            public BufferedContainerDrawNode(BufferedContainer<T> source, BufferedContainerDrawNodeSharedData sharedData, RenderbufferInternalFormat[] formats = null,
+                                             bool pixelSnapping = false)
+                : base(source, new CompositeDrawableDrawNode(source), sharedData, formats, pixelSnapping)
             {
-                this.sharedData = sharedData;
             }
 
             public override void ApplyState()
             {
                 base.ApplyState();
-
-                screenSpaceDrawRectangle = Source.ScreenSpaceDrawQuad.AABBFloat;
-                filteringMode = Source.PixelSnapping ? All.Nearest : All.Linear;
 
                 updateVersion = Source.updateVersion;
-                backgroundColour = Source.BackgroundColour;
-
-                BlendingParameters localEffectBlending = Source.EffectBlending;
-                if (localEffectBlending.Mode == BlendingMode.Inherit)
-                    localEffectBlending.Mode = Source.Blending.Mode;
-
-                if (localEffectBlending.RGBEquation == BlendingEquation.Inherit)
-                    localEffectBlending.RGBEquation = Source.Blending.RGBEquation;
-
-                if (localEffectBlending.AlphaEquation == BlendingEquation.Inherit)
-                    localEffectBlending.AlphaEquation = Source.Blending.AlphaEquation;
 
                 effectColour = Source.EffectColour;
-                effectBlending = localEffectBlending;
+                effectBlending = Source.DrawEffectBlending;
                 effectPlacement = Source.EffectPlacement;
 
                 drawOriginal = Source.DrawOriginal;
                 blurSigma = Source.BlurSigma;
                 blurRadius = new Vector2I(Blur.KernelSize(blurSigma.X), Blur.KernelSize(blurSigma.Y));
                 blurRotation = Source.BlurRotation;
-
-                formats.Clear();
-                formats.AddRange(Source.attachedFormats);
 
                 blurShader = Source.blurShader;
-
-                // BufferedContainer overrides DrawColourInfo for children, but needs to be reset to draw ourselves
-                DrawColourInfo = Source.baseDrawColourInfo;
             }
 
-            public override bool AddChildDrawNodes => RequiresRedraw;
-
-            /// <summary>
-            /// Whether this <see cref="BufferedContainerDrawNode"/> should have its children re-drawn.
-            /// </summary>
-            public bool RequiresRedraw => updateVersion > sharedData.DrawVersion;
+            protected override long GetDrawVersion() => updateVersion;
 
-            private ValueInvokeOnDisposal establishFrameBufferViewport(Vector2 roundedSize)
+            protected override void PopulateContents()
             {
-                // Disable masking for generating the frame buffer since masking will be re-applied
-                // when actually drawing later on anyways. This allows more information to be captured
-                // in the frame buffer and helps with cached buffers being re-used.
-                RectangleI screenSpaceMaskingRect = new RectangleI((int)Math.Floor(screenSpaceDrawRectangle.X), (int)Math.Floor(screenSpaceDrawRectangle.Y), (int)roundedSize.X + 1,
-                    (int)roundedSize.Y + 1);
+                base.PopulateContents();
 
-                GLWrapper.PushMaskingInfo(new MaskingInfo
+                if (blurRadius.X > 0 || blurRadius.Y > 0)
                 {
-                    ScreenSpaceAABB = screenSpaceMaskingRect,
-                    MaskingRect = screenSpaceDrawRectangle,
-                    ToMaskingSpace = Matrix3.Identity,
-                    BlendRange = 1,
-                    AlphaExponent = 1,
-                }, true);
+                    GL.Disable(EnableCap.ScissorTest);
 
-                // Match viewport to FrameBuffer such that we don't draw unnecessary pixels.
-                GLWrapper.PushViewport(new RectangleI(0, 0, (int)roundedSize.X, (int)roundedSize.Y));
+                    if (blurRadius.X > 0) drawBlurredFrameBuffer(blurRadius.X, blurSigma.X, blurRotation);
+                    if (blurRadius.Y > 0) drawBlurredFrameBuffer(blurRadius.Y, blurSigma.Y, blurRotation + 90);
 
-                return new ValueInvokeOnDisposal(returnViewport);
+                    GL.Enable(EnableCap.ScissorTest);
+                }
             }
 
-            private void returnViewport()
+            protected override void DrawContents()
             {
-                GLWrapper.PopViewport();
-                GLWrapper.PopMaskingInfo();
-            }
+                if (drawOriginal && effectPlacement == EffectPlacement.InFront)
+                    base.DrawContents();
 
-            private ValueInvokeOnDisposal bindFrameBuffer(FrameBuffer frameBuffer, Vector2 requestedSize)
-            {
-                if (!frameBuffer.IsInitialized)
-                    frameBuffer.Initialize(true, filteringMode);
+                GLWrapper.SetBlend(new BlendingInfo(effectBlending));
 
-                // These additional render buffers are only required if e.g. depth
-                // or stencil information needs to also be stored somewhere.
-                foreach (var f in formats)
-                    frameBuffer.Attach(f);
+                ColourInfo finalEffectColour = DrawColourInfo.Colour;
+                finalEffectColour.ApplyChild(effectColour);
 
-                // This setter will also take care of allocating a texture of appropriate size within the framebuffer.
-                frameBuffer.Size = requestedSize;
+                DrawFrameBuffer(SharedData.CurrentEffectBuffer, DrawRectangle, finalEffectColour);
 
-                frameBuffer.Bind();
-
-                return new ValueInvokeOnDisposal(frameBuffer.Unbind);
-            }
-
-            private void drawFrameBufferToBackBuffer(FrameBuffer frameBuffer, RectangleF drawRectangle, ColourInfo colourInfo)
-            {
-                // The strange Y coordinate and Height are a result of OpenGL coordinate systems having Y grow upwards and not downwards.
-                RectangleF textureRect = new RectangleF(0, frameBuffer.Texture.Height, frameBuffer.Texture.Width, -frameBuffer.Texture.Height);
-                if (frameBuffer.Texture.Bind())
-                    // Color was already applied by base.Draw(); no need to re-apply. Thus we use White here.
-                    frameBuffer.Texture.DrawQuad(drawRectangle, textureRect, colourInfo);
-            }
-
-            private void drawChildren(Action<TexturedVertex2D> vertexAction, Vector2 frameBufferSize)
-            {
-                // Fill the frame buffer with drawn children
-                using (bindFrameBuffer(currentFrameBuffer, frameBufferSize))
-                {
-                    // We need to draw children as if they were zero-based to the top-left of the texture.
-                    // We can do this by adding a translation component to our (orthogonal) projection matrix.
-                    GLWrapper.PushOrtho(screenSpaceDrawRectangle);
-
-                    GLWrapper.Clear(new ClearInfo(backgroundColour));
-                    base.Draw(vertexAction);
-
-                    GLWrapper.PopOrtho();
-                }
+                if (drawOriginal && effectPlacement == EffectPlacement.Behind)
+                    base.DrawContents();
             }
 
             private void drawBlurredFrameBuffer(int kernelRadius, float sigma, float blurRotation)
             {
-                FrameBuffer source = currentFrameBuffer;
-                FrameBuffer target = advanceFrameBuffer();
+                FrameBuffer current = SharedData.CurrentEffectBuffer;
+                FrameBuffer target = SharedData.GetNextEffectBuffer();
 
                 GLWrapper.SetBlend(new BlendingInfo(BlendingMode.None));
 
-                using (bindFrameBuffer(target, source.Size))
+                using (BindFrameBuffer(target))
                 {
                     blurShader.GetUniform<int>(@"g_Radius").UpdateValue(ref kernelRadius);
                     blurShader.GetUniform<float>(@"g_Sigma").UpdateValue(ref sigma);
 
-                    Vector2 size = source.Size;
+                    Vector2 size = current.Size;
                     blurShader.GetUniform<Vector2>(@"g_TexSize").UpdateValue(ref size);
 
                     float radians = -MathHelper.DegreesToRadians(blurRotation);
···
                     blurShader.GetUniform<Vector2>(@"g_BlurDirection").UpdateValue(ref blur);
 
                     blurShader.Bind();
-                    drawFrameBufferToBackBuffer(source, new RectangleF(0, 0, source.Texture.Width, source.Texture.Height), ColourInfo.SingleColour(Color4.White));
+                    DrawFrameBuffer(current, new RectangleF(0, 0, current.Texture.Width, current.Texture.Height), ColourInfo.SingleColour(Color4.White));
                     blurShader.Unbind();
                 }
             }
 
-            private int currentFrameBufferIndex;
-            private FrameBuffer currentFrameBuffer => sharedData.FrameBuffers[currentFrameBufferIndex];
-            private FrameBuffer advanceFrameBuffer() => sharedData.FrameBuffers[currentFrameBufferIndex = (currentFrameBufferIndex + 1) % 2];
-
-            /// <summary>
-            /// Makes sure the first frame buffer is always the one we want to draw from.
-            /// This saves us the need to sync the draw indices across draw node trees
-            /// since the SharedData.FrameBuffers array is already shared.
-            /// </summary>
-            private void finalizeFrameBuffer()
+            public List<DrawNode> Children
             {
-                if (currentFrameBufferIndex != 0)
-                {
-                    Trace.Assert(currentFrameBufferIndex == 1,
-                        $"Only the first two framebuffers should be the last to be written to at the end of {nameof(Draw)}.");
-
-                    FrameBuffer temp = sharedData.FrameBuffers[0];
-                    sharedData.FrameBuffers[0] = sharedData.FrameBuffers[1];
-                    sharedData.FrameBuffers[1] = temp;
-
-                    currentFrameBufferIndex = 0;
-                }
+                get => Child.Children;
+                set => Child.Children = value;
             }
 
-            // Our effects will be drawn into framebuffers 0 and 1. If we want to preserve the originally
-            // drawn children we need to put them in a separate buffer; in this case buffer 2. Otherwise,
-            // we do not want to allocate a third buffer for nothing and hence we start with 0.
-            private int originalIndex => drawOriginal && (blurRadius.X > 0 || blurRadius.Y > 0) ? 2 : 0;
-
-            public override void Draw(Action<TexturedVertex2D> vertexAction)
-            {
-                currentFrameBufferIndex = originalIndex;
-
-                Vector2 frameBufferSize = new Vector2((float)Math.Ceiling(screenSpaceDrawRectangle.Width), (float)Math.Ceiling(screenSpaceDrawRectangle.Height));
-                if (RequiresRedraw)
-                {
-                    sharedData.DrawVersion = updateVersion;
-
-                    using (establishFrameBufferViewport(frameBufferSize))
-                    {
-                        drawChildren(vertexAction, frameBufferSize);
-
-                        // Blur post-processing in case a blur radius is defined.
-                        if (blurRadius.X > 0 || blurRadius.Y > 0)
-                        {
-                            GL.Disable(EnableCap.ScissorTest);
-
-                            if (blurRadius.X > 0) drawBlurredFrameBuffer(blurRadius.X, blurSigma.X, blurRotation);
-                            if (blurRadius.Y > 0) drawBlurredFrameBuffer(blurRadius.Y, blurSigma.Y, blurRotation + 90);
-
-                            GL.Enable(EnableCap.ScissorTest);
-                        }
-                    }
-
-                    finalizeFrameBuffer();
-                }
-
-                RectangleF drawRectangle = filteringMode == All.Nearest
-                    ? new RectangleF(screenSpaceDrawRectangle.X, screenSpaceDrawRectangle.Y, frameBufferSize.X, frameBufferSize.Y)
-                    : screenSpaceDrawRectangle;
-
-                Shader.Bind();
-
-                if (drawOriginal && effectPlacement == EffectPlacement.InFront)
-                {
-                    GLWrapper.SetBlend(DrawColourInfo.Blending);
-                    drawFrameBufferToBackBuffer(sharedData.FrameBuffers[originalIndex], drawRectangle, DrawColourInfo.Colour);
-                }
-
-                // Blit the final framebuffer to screen.
-                GLWrapper.SetBlend(new BlendingInfo(effectBlending));
-
-                ColourInfo finalEffectColour = DrawColourInfo.Colour;
-                finalEffectColour.ApplyChild(effectColour);
-                drawFrameBufferToBackBuffer(sharedData.FrameBuffers[0], drawRectangle, finalEffectColour);
-
-                if (drawOriginal && effectPlacement == EffectPlacement.Behind)
-                {
-                    GLWrapper.SetBlend(DrawColourInfo.Blending);
-                    drawFrameBufferToBackBuffer(sharedData.FrameBuffers[originalIndex], drawRectangle, DrawColourInfo.Colour);
-                }
-
-                Shader.Unbind();
-            }
+            public bool AddChildDrawNodes => RequiresRedraw;
         }
 
-        private class BufferedContainerDrawNodeSharedData : IDisposable
+        private class BufferedContainerDrawNodeSharedData : BufferedDrawNodeSharedData
         {
-            /// <summary>
-            /// The <see cref="FrameBuffer"/>s to render to.
-            /// These are used in a ping-pong manner to render effects <see cref="BufferedContainerDrawNode"/>.
-            /// </summary>
-            public readonly FrameBuffer[] FrameBuffers = new FrameBuffer[3];
-
-            /// <summary>
-            /// The version of drawn contents currently present in <see cref="FrameBuffers"/>.
-            /// This should only be modified by <see cref="BufferedContainerDrawNode"/>.
-            /// </summary>
-            public long DrawVersion = -1;
-
             public BufferedContainerDrawNodeSharedData()
+                : base(2)
             {
-                for (int i = 0; i < FrameBuffers.Length; i++)
-                    FrameBuffers[i] = new FrameBuffer();
-            }
-
-            ~BufferedContainerDrawNodeSharedData()
-            {
-                dispose();
-            }
-
-            public void Dispose()
-            {
-                dispose();
-                GC.SuppressFinalize(this);
-            }
-
-            private void dispose()
-            {
-                for (int i = 0; i < FrameBuffers.Length; i++)
-                    FrameBuffers[i].Dispose();
             }
         }
     }

osu.Framework/Graphics/Containers/CompositeDrawable.cs

···
 
         private CancellationTokenSource disposalCancellationSource;
 
-        private static readonly ThreadedTaskScheduler threaded_scheduler = new ThreadedTaskScheduler(4);
+        private static readonly ThreadedTaskScheduler threaded_scheduler = new ThreadedTaskScheduler(4, nameof(LoadComponentsAsync));
 
         /// <summary>
         /// Loads a future child or grand-child of this <see cref="CompositeDrawable"/> asynchronously. <see cref="Dependencies"/>
···
                 return false;
 
             internalChildren.RemoveAt(index);
+
             if (drawable.IsAlive)
             {
                 aliveInternalChildren.Remove(drawable);
···
             {
                 case LoadState.NotLoaded:
                     break;
+
                 case LoadState.Loading:
                     if (Thread.CurrentThread != LoadThread)
                         throw new InvalidThreadForChildMutationException(LoadState, "not on the load thread");
 
                     break;
+
                 case LoadState.Ready:
                     // Allow mutating from the load thread since parenting containers may still be in the loading state
                     if (Thread.CurrentThread != LoadThread && !ThreadSafety.IsUpdateThread)
                         throw new InvalidThreadForChildMutationException(LoadState, "not on the load or update threads");
 
                     break;
+
                 case LoadState.Loaded:
                     if (!ThreadSafety.IsUpdateThread)
                         throw new InvalidThreadForChildMutationException(LoadState, "not on the update thread");
···
         private static void addFromComposite(ulong frame, int treeIndex, bool forceNewDrawNode, ref int j, CompositeDrawable parentComposite, List<DrawNode> target)
         {
             SortedList<Drawable> children = parentComposite.aliveInternalChildren;
+
             for (int i = 0; i < children.Count; ++i)
             {
                 Drawable drawable = children[i];
···
                         continue;
 
                     CompositeDrawable composite = drawable as CompositeDrawable;
+
                     if (composite?.CanBeFlattened == true)
                     {
                         if (!composite.IsMaskedAway)
···
             set
             {
                 if ((AutoSizeAxes & Axes.X) != 0)
-                    throw new InvalidOperationException($"The width of a {nameof(CompositeDrawable)} with {nameof(AutoSizeAxes)} should only be manually set if it is relative to its parent.");
+                    throw new InvalidOperationException($"The width of a {nameof(CompositeDrawable)} with {nameof(AutoSizeAxes)} can not be set manually.");
 
                 base.Width = value;
             }
···
             set
             {
                 if ((AutoSizeAxes & Axes.Y) != 0)
-                    throw new InvalidOperationException($"The height of a {nameof(CompositeDrawable)} with {nameof(AutoSizeAxes)} should only be manually set if it is relative to its parent.");
+                    throw new InvalidOperationException($"The height of a {nameof(CompositeDrawable)} with {nameof(AutoSizeAxes)} can not be set manually.");
 
                 base.Height = value;
             }
···
             set
             {
                 if ((AutoSizeAxes & Axes.Both) != 0)
-                    throw new InvalidOperationException($"The Size of a {nameof(CompositeDrawable)} with {nameof(AutoSizeAxes)} should only be manually set if it is relative to its parent.");
+                    throw new InvalidOperationException($"The Size of a {nameof(CompositeDrawable)} with {nameof(AutoSizeAxes)} can not be set manually.");
 
                 base.Size = value;
             }

osu.Framework/Graphics/Containers/CompositeDrawable_DrawNode.cs

···
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Graphics.Colour;
 using System;
+using System.Runtime.CompilerServices;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.OpenGL.Vertices;
+using osuTK.Graphics.ES30;
 
 namespace osu.Framework.Graphics.Containers
 {
···
         /// </summary>
         protected class CompositeDrawableDrawNode : DrawNode, ICompositeDrawNode
         {
+            private static readonly float cos_45 = (float)Math.Cos(Math.PI / 4);
+
             protected new CompositeDrawable Source => (CompositeDrawable)base.Source;
 
             /// <summary>
···
             private bool forceLocalVertexBatch;
 
             /// <summary>
-            /// The vertex batch used for rendering.
+            /// The vertex batch used for child quads during the back-to-front pass.
+            /// </summary>
+            private QuadBatch<TexturedVertex2D> quadBatch;
+
+            /// <summary>
+            /// The vertex batch used for child triangles during the front-to-back pass.
             /// </summary>
-            private QuadBatch<TexturedVertex2D> vertexBatch;
+            private LinearBatch<TexturedVertex2D> triangleBatch;
 
             public CompositeDrawableDrawNode(CompositeDrawable source)
                 : base(source)
···
                     throw new InvalidOperationException("Can not have border effects/edge effects if masking is disabled.");
 
                 Vector3 scale = DrawInfo.MatrixInverse.ExtractScale();
+                float blendRange = Source.MaskingSmoothness * (scale.X + scale.Y) / 2;
+
+                // Calculate a shrunk rectangle which is free from corner radius/smoothing/border effects
+                float shrinkage = Source.CornerRadius - Source.CornerRadius * cos_45 + blendRange + Source.borderThickness;
+                RectangleF shrunkDrawRectangle = Source.DrawRectangle.Shrink(shrinkage);
 
                 maskingInfo = !Source.Masking
                     ? (MaskingInfo?)null
···
                     {
                         ScreenSpaceAABB = Source.ScreenSpaceDrawQuad.AABB,
                         MaskingRect = Source.DrawRectangle,
+                        ConservativeScreenSpaceQuad = Quad.FromRectangle(shrunkDrawRectangle) * DrawInfo.Matrix,
                         ToMaskingSpace = DrawInfo.MatrixInverse,
                         CornerRadius = Source.CornerRadius,
                         BorderThickness = Source.BorderThickness,
···
                         // We are setting the linear blend range to the approximate size of a _pixel_ here.
                         // This results in the optimal trade-off between crispness and smoothness of the
                         // edges of the masked region according to sampling theory.
-                        BlendRange = Source.MaskingSmoothness * (scale.X + scale.Y) / 2,
+                        BlendRange = blendRange,
                         AlphaExponent = 1,
                     };
 
···
 
             private void drawEdgeEffect()
             {
-                if (maskingInfo == null || edgeEffect.Type == EdgeEffectType.None || edgeEffect.Radius <= 0.0f || edgeEffect.Colour.Linear.A <= 0.0f)
+                if (maskingInfo == null || edgeEffect.Type == EdgeEffectType.None || edgeEffect.Radius <= 0.0f || edgeEffect.Colour.Linear.A <= 0)
                     return;
 
                 RectangleF effectRect = maskingInfo.Value.MaskingRect.Inflate(edgeEffect.Radius).Offset(edgeEffect.Offset);
···
                 colour.TopRight.MultiplyAlpha(DrawColourInfo.Colour.TopRight.Linear.A);
                 colour.BottomRight.MultiplyAlpha(DrawColourInfo.Colour.BottomRight.Linear.A);
 
-                Texture.WhitePixel.DrawQuad(
+                DrawQuad(
+                    Texture.WhitePixel,
                     screenSpaceMaskingQuad.Value,
                     colour, null, null, null,
                     // HACK HACK HACK. We re-use the unused vertex blend range to store the original
···
 
             private bool mayHaveOwnVertexBatch(int amountChildren) => forceLocalVertexBatch || amountChildren >= min_amount_children_to_warrant_batch;
 
-            private void updateVertexBatch()
+            private void updateQuadBatch()
+            {
+                if (Children == null)
+                    return;
+
+                // This logic got roughly copied from the old osu! code base. These constants seem to have worked well so far.
+                int clampedAmountChildren = MathHelper.Clamp(Children.Count, 1, 1000);
+                if (mayHaveOwnVertexBatch(clampedAmountChildren) && (quadBatch == null || quadBatch.Size < clampedAmountChildren))
+                    quadBatch = new QuadBatch<TexturedVertex2D>(clampedAmountChildren * 2, 500);
+            }
+
+            private void updateTriangleBatch()
             {
                 if (Children == null)
                     return;
 
                 // This logic got roughly copied from the old osu! code base. These constants seem to have worked well so far.
                 int clampedAmountChildren = MathHelper.Clamp(Children.Count, 1, 1000);
-                if (mayHaveOwnVertexBatch(clampedAmountChildren) && (vertexBatch == null || vertexBatch.Size < clampedAmountChildren))
-                    vertexBatch = new QuadBatch<TexturedVertex2D>(clampedAmountChildren * 2, 500);
+
+                if (mayHaveOwnVertexBatch(clampedAmountChildren) && (triangleBatch == null || triangleBatch.Size < clampedAmountChildren))
+                {
+                    // The same general idea as updateQuadBatch(), except that each child draws up to 3 vertices * 6 triangles after quad-quad intersection
+                    triangleBatch = new LinearBatch<TexturedVertex2D>(clampedAmountChildren * 2 * 3, 500, PrimitiveType.Triangles);
+                }
             }
 
             public override void Draw(Action<TexturedVertex2D> vertexAction)
             {
-                updateVertexBatch();
+                updateQuadBatch();
 
                 // Prefer to use own vertex batch instead of the parent-owned one.
-                if (vertexBatch != null)
-                    vertexAction = vertexBatch.AddAction;
+                if (quadBatch != null)
+                    vertexAction = quadBatch.AddAction;
 
                 base.Draw(vertexAction);
 
                 drawEdgeEffect();
+
                 if (maskingInfo != null)
                 {
                     MaskingInfo info = maskingInfo.Value;
···
                     GLWrapper.PopMaskingInfo();
             }
 
+            internal override void DrawOpaqueInteriorSubTree(DepthValue depthValue, Action<TexturedVertex2D> vertexAction)
+            {
+                DrawChildrenOpaqueInteriors(depthValue, vertexAction);
+                base.DrawOpaqueInteriorSubTree(depthValue, vertexAction);
+            }
+
+            /// <summary>
+            /// Performs <see cref="DrawOpaqueInteriorSubTree"/> on all children of this <see cref="CompositeDrawableDrawNode"/>.
+            /// </summary>
+            /// <param name="depthValue">The previous depth value.</param>
+            /// <param name="vertexAction">The action to be performed on each vertex of the draw node in order to draw it if required. This is primarily used by textured sprites.</param>
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            protected virtual void DrawChildrenOpaqueInteriors(DepthValue depthValue, Action<TexturedVertex2D> vertexAction)
+            {
+                bool canIncrement = depthValue.CanIncrement;
+
+                // Assume that if we can't increment the depth value, no child can, thus nothing will be drawn.
+                if (canIncrement)
+                {
+                    updateTriangleBatch();
+
+                    // Prefer to use own vertex batch instead of the parent-owned one.
+                    if (triangleBatch != null)
+                        vertexAction = triangleBatch.AddAction;
+
+                    if (maskingInfo != null)
+                        GLWrapper.PushMaskingInfo(maskingInfo.Value);
+                }
+
+                // We still need to invoke this method recursively for all children so their depth value is updated
+                if (Children != null)
+                {
+                    for (int i = Children.Count - 1; i >= 0; i--)
+                        Children[i].DrawOpaqueInteriorSubTree(depthValue, vertexAction);
+                }
+
+                // Assume that if we can't increment the depth value, no child can, thus nothing will be drawn.
+                if (canIncrement)
+                {
+                    if (maskingInfo != null)
+                        GLWrapper.PopMaskingInfo();
+                }
+            }
+
             protected override void Dispose(bool isDisposing)
             {
                 base.Dispose(isDisposing);
 
-                vertexBatch?.Dispose();
+                quadBatch?.Dispose();
+                triangleBatch?.Dispose();
             }
         }
     }

osu.Framework/Graphics/Containers/CustomizableTextContainer.cs

···
             var sprites = new List<Drawable>();
             int index = 0;
             string str = line.Text;
+
             while (index < str.Length)
             {
                 Drawable placeholderDrawable = null;
···
                     nextPlaceholderIndex = str.IndexOf(unescaped_left, nextPlaceholderIndex + 2, StringComparison.Ordinal);
 
                 string strPiece = null;
+
                 if (nextPlaceholderIndex != -1)
                 {
                     int placeholderEnd = str.IndexOf(unescaped_right, nextPlaceholderIndex, StringComparison.Ordinal);
···
                         string placeholderName = placeholderStr;
                         string paramStr = "";
                         int parensOpen = placeholderStr.IndexOf('(');
+
                         if (parensOpen != -1)
                         {
                             placeholderName = placeholderStr.Substring(0, parensOpen).Trim();
···
                         else
                         {
                             object[] args;
+
                             if (string.IsNullOrWhiteSpace(paramStr))
                             {
                                 args = Array.Empty<object>();
···
                             {
                                 string[] argStrs = paramStr.Split(',');
                                 args = new object[argStrs.Length];
+
                                 for (int i = 0; i < argStrs.Length; ++i)
                                 {
                                     if (!int.TryParse(argStrs[i], out int argVal))

osu.Framework/Graphics/Containers/DelayedLoadWrapper.cs

···
             AutoSizeAxes = (content as CompositeDrawable)?.AutoSizeAxes ?? AutoSizeAxes;
         }
 
-        public override double LifetimeStart => Content.LifetimeStart;
+        public override double LifetimeStart
+        {
+            get => Content.LifetimeStart;
+            set => Content.LifetimeStart = value;
+        }
 
-        public override double LifetimeEnd => Content.LifetimeEnd;
+        public override double LifetimeEnd
+        {
+            get => Content.LifetimeEnd;
+            set => Content.LifetimeEnd = value;
+        }
 
         public virtual Drawable Content { get; protected set; }
 
···
         {
             if (loadTask != null) throw new InvalidOperationException("Load is already started!");
 
+            DelayedLoadStarted?.Invoke(Content);
             loadTask = LoadComponentAsync(Content, EndDelayedLoad);
         }
 
···
         }
 
         /// <summary>
+        /// Fired when delayed async load has started.
+        /// </summary>
+        public event Action<Drawable> DelayedLoadStarted;
+
+        /// <summary>
         /// Fired when delayed async load completes. Should be used to perform transitions.
         /// </summary>
-        public Action<Drawable> DelayedLoadComplete;
+        public event Action<Drawable> DelayedLoadComplete;
 
         /// <summary>
         /// True if the load task for our content has been started.

osu.Framework/Graphics/Containers/FillFlowContainer.cs

···
         protected override IEnumerable<Vector2> ComputeLayoutPositions()
         {
             var max = MaximumSize;
+
             if (max == Vector2.Zero)
             {
                 var s = ChildSize;
···
 
             // First pass, computing initial flow positions
             Vector2 size = Vector2.Zero;
+
             for (int i = 0; i < children.Length; ++i)
             {
                 Drawable c = children[i];
···
                     {
                         case FillDirection.Full:
                             return Axes.Both;
+
                         case FillDirection.Horizontal:
                             return Axes.X;
+
                         case FillDirection.Vertical:
                             return Axes.Y;
+
                         default:
                             throw new ArgumentException($"{direction.ToString()} is not defined");
                     }
···
                 rowIndices[i] = rowOffsetsToMiddle.Count - 1;
 
                 Vector2 stride = Vector2.Zero;
+
                 if (i < children.Length - 1)
                 {
                     // Compute stride. Note, that the stride depends on the origins of the drawables
···
                                 + $"Consider using multiple instances of {nameof(FillFlowContainer)} if this is intentional.");
 
                         break;
+
                     case FillDirection.Horizontal:
                         if (c.RelativeAnchorPosition.X != ourRelativeAnchor.X)
                             throw new InvalidOperationException(
···
                                 + $"Consider using multiple instances of {nameof(FillFlowContainer)} if this is intentional.");
 
                         break;
+
                     default:
                         if (c.RelativeAnchorPosition != ourRelativeAnchor)
                             throw new InvalidOperationException(

osu.Framework/Graphics/Containers/FlowContainer.cs

···
             var positions = ComputeLayoutPositions().ToArray();
 
             int i = 0;
+
             foreach (var d in FlowingChildren)
             {
                 if (i > positions.Length)

osu.Framework/Graphics/Containers/FocusedOverlayContainer.cs

···
     /// </summary>
     public abstract class FocusedOverlayContainer : OverlayContainer
     {
-        public override bool RequestsFocus => State == Visibility.Visible;
+        public override bool RequestsFocus => State.Value == Visibility.Visible;
 
-        public override bool AcceptsFocus => State == Visibility.Visible;
+        public override bool AcceptsFocus => State.Value == Visibility.Visible;
 
         protected override void PopIn()
         {

osu.Framework/Graphics/Containers/GridContainer.cs

···
 
             // Create the new cell containers and add content
             cells = new CellContainer[requiredRows, requiredColumns];
+
             for (int r = 0; r < cellRows; r++)
             for (int c = 0; c < cellColumns; c++)
             {
···
                 {
                     default:
                         throw new InvalidOperationException($"Unsupported dimension: {dimension.Mode}.");
+
                     case GridSizeMode.Distributed:
                         break;
+
                     case GridSizeMode.Relative:
                         sizes[i] = dimension.Size * spanLength;
                         break;
+
                     case GridSizeMode.Absolute:
                         sizes[i] = dimension.Size;
                         break;
+
                     case GridSizeMode.AutoSize:
                         float size = 0;
 

osu.Framework/Graphics/Containers/LifetimeManagementContainer.cs

···
             }
 
             bool aliveChildrenChanged = false;
+
             if (newState == LifetimeState.Current)
             {
                 MakeChildAlive(child);
···
         private void enqueueEvents(Drawable child, LifetimeState oldState, LifetimeState newState)
         {
             Debug.Assert(oldState != newState);
+
             switch (oldState)
             {
                 case LifetimeState.Future:
···
                     if (newState == LifetimeState.Past)
                         eventQueue.Enqueue(new LifetimeBoundaryCrossedEvent(child, LifetimeBoundaryKind.End, LifetimeBoundaryCrossingDirection.Forward));
                     break;
+
                 case LifetimeState.Current:
                     eventQueue.Enqueue(newState == LifetimeState.Past
                         ? new LifetimeBoundaryCrossedEvent(child, LifetimeBoundaryKind.End, LifetimeBoundaryCrossingDirection.Forward)
                         : new LifetimeBoundaryCrossedEvent(child, LifetimeBoundaryKind.Start, LifetimeBoundaryCrossingDirection.Backward));
                     break;
+
                 case LifetimeState.Past:
                     eventQueue.Enqueue(new LifetimeBoundaryCrossedEvent(child, LifetimeBoundaryKind.End, LifetimeBoundaryCrossingDirection.Backward));
                     if (newState == LifetimeState.Future)
···
             {
                 case LifetimeState.Future:
                     return futureChildren;
+
                 case LifetimeState.Past:
                     return pastChildren;
+
                 default:
                     return null;
             }

osu.Framework/Graphics/Containers/Markdown/MarkdownContainer.cs

···
                 case ThematicBreakBlock thematicBlock:
                     container.Add(CreateSeparator(thematicBlock));
                     break;
+
                 case HeadingBlock headingBlock:
                     container.Add(CreateHeading(headingBlock));
                     break;
+
                 case ParagraphBlock paragraphBlock:
                     container.Add(CreateParagraph(paragraphBlock, level));
                     break;
+
                 case QuoteBlock quoteBlock:
                     container.Add(CreateQuoteBlock(quoteBlock));
                     break;
+
                 case FencedCodeBlock fencedCodeBlock:
                     container.Add(CreateFencedCodeBlock(fencedCodeBlock));
                     break;
+
                 case Table table:
                     container.Add(CreateTable(table));
                     break;
+
                 case ListBlock listBlock:
                     var childContainer = CreateList(listBlock);
                     container.Add(childContainer);
                     foreach (var single in listBlock)
                         AddMarkdownComponent(single, childContainer, level + 1);
                     break;
+
                 case ListItemBlock listItemBlock:
                     foreach (var single in listItemBlock)
                         AddMarkdownComponent(single, container, level);
                     break;
+
                 case HtmlBlock _:
                     // HTML is not supported
                     break;
+
                 case LinkReferenceDefinitionGroup _:
                     // Link reference doesn't need to be displayed.
                     break;
+
                 default:
                     container.Add(CreateNotImplemented(markdownObject));
                     break;

osu.Framework/Graphics/Containers/Markdown/MarkdownHeading.cs

···
             {
                 case 1:
                     return 2.7f;
+
                 case 2:
                     return 2;
+
                 case 3:
                     return 1.5f;
+
                 case 4:
                     return 1.3f;
+
                 default:
                     return 1;
             }

osu.Framework/Graphics/Containers/Markdown/MarkdownTableCell.cs

···
                 case TableColumnAlign.Center:
                     textFlow.TextAnchor = Anchor.Centre;
                     break;
+
                 case TableColumnAlign.Right:
                     textFlow.TextAnchor = Anchor.CentreRight;
                     break;
+
                 default:
                     textFlow.TextAnchor = Anchor.CentreLeft;
                     break;

osu.Framework/Graphics/Containers/Markdown/MarkdownTextFlowContainer.cs

···
                                     addEmphasis(text, emphases);
 
                                     break;
+
                                 case LinkInline linkInline:
                                 {
                                     if (!linkInline.IsImage)
···
                         }
 
                         break;
+
                     case CodeInline codeInline:
                         AddCodeInLine(codeInline);
                         break;
+
                     case LinkInline linkInline when linkInline.IsImage:
                         AddImage(linkInline);
                         break;
+
                     case HtmlInline _:
                     case HtmlEntityInline _:
                         // Handled by the next literal
                         break;
+
                     case LineBreakInline lineBreak:
                         if (lineBreak.IsHard)
                             NewParagraph();
                         else
                             NewLine();
                         break;
+
                     case ContainerInline innerContainer:
                         AddInlineText(innerContainer);
                         break;
+
                     default:
                         AddNotImplementedInlineText(single);
                         break;
···
                     case "_":
                         hasItalic = true;
                         break;
+
                     case "**":
                     case "__":
                         hasBold = true;

osu.Framework/Graphics/Containers/ModelBackedDrawable.cs

···
 
 using System;
 using System.Collections.Generic;
+using JetBrains.Annotations;
 using osu.Framework.Graphics.Transforms;
 using osu.Framework.Lists;
 
···
         /// <summary>
         /// The currently displayed <see cref="Drawable"/>. Null if no drawable is displayed.
         /// </summary>
-        protected Drawable DisplayedDrawable { get; private set; }
+        protected Drawable DisplayedDrawable => displayedWrapper?.Content;
 
         /// <summary>
         /// The <see cref="IEqualityComparer{T}"/> used to compare models to ensure that <see cref="Drawable"/>s are not updated unnecessarily.
···
         }
 
         /// <summary>
+        /// The wrapper which has the current displayed content.
+        /// </summary>
+        private DelayedLoadWrapper displayedWrapper;
+
+        /// <summary>
+        /// The wrapper which is currently loading, or has finished loading (i.e <see cref="displayedWrapper"/>).
+        /// </summary>
+        private DelayedLoadWrapper currentWrapper;
+
+        /// <summary>
         /// Constructs a new <see cref="ModelBackedDrawable{T}"/> with the default <typeparamref name="T"/> equality comparer.
         /// </summary>
         protected ModelBackedDrawable()
···
             updateDrawable();
         }
 
-        private DelayedLoadWrapper currentWrapper;
-        private bool placeholderDisplayed;
-
         private void updateDrawable()
         {
-            if (model == null)
-                loadPlaceholder();
+            if (TransformImmediately)
+            {
+                // If loading to a new model and we've requested to transform immediately, load a null model to allow such transforms to occur
+                loadDrawable(null);
+            }
+
+            loadDrawable(() => CreateDrawable(model));
+        }
+
+        private void loadDrawable(Func<Drawable> createDrawableFunc)
+        {
+            // Remove the previous wrapper if the inner drawable hasn't finished loading.
+            if (currentWrapper?.DelayedLoadCompleted == false)
+            {
+                RemoveInternal(currentWrapper);
+                DisposeChildAsync(currentWrapper);
+            }
+
+            currentWrapper = createWrapper(createDrawableFunc, LoadDelay);
+
+            if (currentWrapper == null)
+            {
+                OnLoadStarted();
+                finishLoad(currentWrapper);
+                OnLoadFinished();
+            }
             else
             {
-                if (FadeOutImmediately) loadPlaceholder();
-                loadDrawable(CreateDrawable(model), false);
+                AddInternal(currentWrapper);
+                currentWrapper.DelayedLoadStarted += _ => OnLoadStarted();
+                currentWrapper.DelayedLoadComplete += _ =>
+                {
+                    finishLoad(currentWrapper);
+                    OnLoadFinished();
+                };
             }
         }
 
-        private void loadPlaceholder()
+        /// <summary>
+        /// Invoked when a <see cref="DelayedLoadWrapper"/> has finished loading its contents.
+        /// May be invoked multiple times for each <see cref="DelayedLoadWrapper"/>.
+        /// </summary>
+        /// <param name="wrapper">The <see cref="DelayedLoadWrapper"/>.</param>
+        private void finishLoad(DelayedLoadWrapper wrapper)
         {
-            if (placeholderDisplayed)
+            var lastWrapper = displayedWrapper;
+
+            // If the wrapper hasn't changed then this invocation must be a result of a reload (e.g. DelayedLoadUnloadWrapper)
+            // In this case, we do not want to transform/expire the wrapper
+            if (lastWrapper == wrapper)
                 return;
 
-            var placeholder = CreateDrawable(null);
+            // Make the new wrapper initially hidden
+            ApplyHideTransforms(wrapper);
+            wrapper?.FinishTransforms();
+
+            var showTransforms = ApplyShowTransforms(wrapper);
+
+            // If we have a non-null new wrapper, we need to wait for the show transformation to complete before hiding the old wrapper,
+            // otherwise, we can hide the old wrapper instantaneously and leave a blank display
+            var hideTransforms = wrapper == null
+                ? ApplyHideTransforms(lastWrapper)
+                : ((Drawable)lastWrapper)?.Delay(TransformDuration)?.Append(ApplyHideTransforms);
 
-            loadDrawable(placeholder, true);
+            // Expire the last wrapper after the front-most transform has completed (the last wrapper is assumed to be invisible by that point)
+            (showTransforms ?? hideTransforms)?.OnComplete(_ => lastWrapper?.Expire());
 
-            // in the case a placeholder has not been specified, this should not be set as to allow for a potential runtime change
-            // of placeholder logic on a future load operation.
-            placeholderDisplayed = placeholder != null;
+            displayedWrapper = wrapper;
         }
 
-        private void loadDrawable(Drawable newDrawable, bool isPlaceholder)
+        /// <summary>
+        /// Creates a <see cref="DelayedLoadWrapper"/> which supports reloading.
+        /// </summary>
+        /// <param name="createContentFunc">A function that creates the wrapped <see cref="Drawable"/>.</param>
+        /// <param name="timeBeforeLoad">The time before loading should begin.</param>
+        /// <returns>A <see cref="DelayedLoadWrapper"/> or null if <see cref="createContentFunc"/> returns null.</returns>
+        private DelayedLoadWrapper createWrapper(Func<Drawable> createContentFunc, double timeBeforeLoad)
         {
-            // Remove the previous wrapper if the inner drawable hasn't finished loading.
-            // We check IsLoaded on the content rather than DelayedLoadCompleted so that we can ensure that finishLoad() has not been called and DisplayedDrawable hasn't been updated
-            if (currentWrapper?.Content.IsLoaded == false)
-            {
-                // Using .Expire() will be one frame too late, since children's lifetime has already been updated this frame
-                RemoveInternal(currentWrapper);
-                DisposeChildAsync(currentWrapper);
-            }
+            var content = createContentFunc?.Invoke();
 
-            currentWrapper = null;
+            if (content == null)
+                return null;
 
-            if (newDrawable != null)
+            return CreateDelayedLoadWrapper(() =>
             {
-                AddInternal(isPlaceholder ? newDrawable : currentWrapper = CreateDelayedLoadWrapper(newDrawable, LoadDelay));
-
-                if (isPlaceholder)
+                try
                 {
-                    // Although the drawable is technically not loaded, it does have a clock and we need DisplayedDrawable to be updated instantly
-                    finishLoad();
+                    // optimisation to use already constructed object (used above for null check).
+                    return content ?? createContentFunc();
+                }
+                finally
+                {
+                    // consume initial object if not already.
+                    content = null;
                 }
-                else
-                    newDrawable.OnLoadComplete += _ => finishLoad();
-            }
-            else
-                finishLoad();
+            }, timeBeforeLoad);
+        }
 
-            void finishLoad()
-            {
-                var currentDrawable = DisplayedDrawable;
+        /// <summary>
+        /// Invoked when the <see cref="Drawable"/> representation of a model begins loading.
+        /// </summary>
+        protected virtual void OnLoadStarted()
+        {
+        }
 
-                var transform = ReplaceDrawable(currentDrawable, newDrawable) ?? (currentDrawable ?? newDrawable)?.DelayUntilTransformsFinished();
-                transform?.OnComplete(_ => currentDrawable?.Expire());
-
-                DisplayedDrawable = newDrawable;
-                placeholderDisplayed = isPlaceholder;
-            }
+        /// <summary>
+        /// Invoked when the <see cref="Drawable"/> representation of a model has finished loading.
+        /// </summary>
+        protected virtual void OnLoadFinished()
+        {
         }
 
         /// <summary>
-        /// Determines whether the current <see cref="Drawable"/> should fade out straight away when switching to a new model,
-        /// or whether it should wait until the new <see cref="Drawable"/> has finished loading.
+        /// Determines whether <see cref="ApplyHideTransforms"/> should be invoked immediately on the currently-displayed drawable when switching to a new model.
         /// </summary>
-        protected virtual bool FadeOutImmediately => false;
+        protected virtual bool TransformImmediately => false;
 
         /// <summary>
-        /// The time in milliseconds that <see cref="Drawable"/>s will fade in and out.
+        /// The default time in milliseconds for transforms applied through <see cref="ApplyHideTransforms"/> and <see cref="ApplyShowTransforms"/>.
         /// </summary>
-        protected virtual double FadeDuration => 1000;
+        protected virtual double TransformDuration => 1000;
 
         /// <summary>
         /// The delay in milliseconds before <see cref="Drawable"/>s will begin loading.
···
         /// <summary>
         /// Allows subclasses to customise the <see cref="DelayedLoadWrapper"/>.
         /// </summary>
-        protected virtual DelayedLoadWrapper CreateDelayedLoadWrapper(Drawable content, double timeBeforeLoad) =>
-            new DelayedLoadWrapper(content, timeBeforeLoad);
+        [NotNull]
+        protected virtual DelayedLoadWrapper CreateDelayedLoadWrapper([NotNull] Func<Drawable> createContentFunc, double timeBeforeLoad) =>
+            new DelayedLoadWrapper(createContentFunc(), timeBeforeLoad);
 
         /// <summary>
-        /// Override to instantiate a custom <see cref="Drawable"/> based on the passed model.
-        /// May be null to indicate that the model has no visual representation,
-        /// in which case the placeholder will be used if it exists.
+        /// Creates a custom <see cref="Drawable"/> to display a model.
         /// </summary>
         /// <param name="model">The model that the <see cref="Drawable"/> should represent.</param>
-        protected abstract Drawable CreateDrawable(T model);
+        /// <returns>A <see cref="Drawable"/> that represents <paramref name="model"/>, or null if no <see cref="Drawable"/> should be displayed.</returns>
+        [CanBeNull]
+        protected abstract Drawable CreateDrawable([CanBeNull] T model);
 
         /// <summary>
-        /// Returns a <see cref="TransformSequence{Drawable}"/> that replaces the given <see cref="Drawable"/>s.
-        /// Default functionality is to fade in the target from zero, or if it is null, to fade out the source.
+        /// Hides a drawable.
+        /// </summary>
+        /// <param name="drawable">The drawable that is to be hidden.</param>
+        /// <returns>The transform sequence.</returns>
+        protected virtual TransformSequence<Drawable> ApplyHideTransforms([CanBeNull] Drawable drawable)
+            => drawable?.FadeOut(TransformDuration, Easing.OutQuint);
+
+        /// <summary>
+        /// Shows a drawable.
         /// </summary>
-        /// <returns>The drawable.</returns>
-        /// <param name="source">The <see cref="Drawable"/> to be replaced.</param>
-        /// <param name="target">The <see cref="Drawable"/> we are replacing with.</param>
-        protected virtual TransformSequence<Drawable> ReplaceDrawable(Drawable source, Drawable target) =>
-            target?.FadeInFromZero(FadeDuration, Easing.OutQuint) ?? source?.FadeOut(FadeDuration, Easing.OutQuint);
+        /// <param name="drawable">The drawable that is to be shown.</param>
+        /// <returns>The transform sequence.</returns>
+        protected virtual TransformSequence<Drawable> ApplyShowTransforms([CanBeNull] Drawable drawable)
+            => drawable?.FadeIn(TransformDuration, Easing.OutQuint);
     }
 }

osu.Framework/Graphics/Containers/ScrollContainer.cs

···
                     case Key.PageUp:
                         ScrollTo(target - displayableContent);
                         return true;
+
                     case Key.PageDown:
                         ScrollTo(target + displayableContent);
                         return true;
···
             if (ScrollDirection == Direction.Horizontal)
             {
                 Scrollbar.X = Current * Scrollbar.Size.X;
-                content.X = -Current;
+                content.X = -Current + scrollableExtent * content.RelativeAnchorPosition.X;
             }
             else
             {
                 Scrollbar.Y = Current * Scrollbar.Size.Y;
-                content.Y = -Current;
+                content.Y = -Current + scrollableExtent * content.RelativeAnchorPosition.Y;
             }
         }
 
···
                 case PlatformActionType.LineStart:
                     ScrollToStart();
                     return true;
+
                 case PlatformActionType.LineEnd:
                     ScrollToEnd();
                     return true;
+
                 default:
                     return false;
             }

osu.Framework/Graphics/Containers/TabbableContainer.cs

···
             stack.Push(target);
 
             bool started = false;
+
             while (stack.Count > 0)
             {
                 var drawable = stack.Pop();
···
                 {
                     var newChildren = composite.InternalChildren.ToList();
                     int bound = reverse ? newChildren.Count : 0;
+
                     if (!started)
                     {
                         // Find self, to know starting point

osu.Framework/Graphics/Containers/TextFlowContainer.cs

···
         {
             bool first = true;
             var sprites = new List<Drawable>();
+
             foreach (string l in line.Text.Split('\n'))
             {
                 if (!first)
                 {
                     Drawable lastChild = Children.LastOrDefault();
+
                     if (lastChild != null)
                     {
                         var newLine = new NewLineContainer(newLineIsParagraph);
···
         {
             var childrenByLine = new List<List<Drawable>>();
             var curLine = new List<Drawable>();
+
             foreach (var c in Children)
             {
                 c.Anchor = TextAnchor;
···
 
             bool isFirstLine = true;
             float lastLineHeight = 0f;
+
             foreach (var line in childrenByLine)
             {
                 bool isFirstChild = true;

osu.Framework/Graphics/Containers/VisibilityContainer.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System;
+using osu.Framework.Bindables;
 
 namespace osu.Framework.Graphics.Containers
 {
     /// <summary>
     /// A container which adds a basic visibility state.
     /// </summary>
-    public abstract class VisibilityContainer : Container, IStateful<Visibility>
+    public abstract class VisibilityContainer : Container
     {
+        /// <summary>
+        /// The current visibility state.
+        /// </summary>
+        public readonly Bindable<Visibility> State = new Bindable<Visibility>();
+
         /// <summary>
         /// Whether we should be in a hidden state when first displayed.
         /// Override this and set to true to *always* perform a <see cref="PopIn"/> animation even when the state is non-hidden at
         /// first display.
         /// </summary>
-        protected virtual bool StartHidden => state == Visibility.Hidden;
+        protected virtual bool StartHidden => State.Value == Visibility.Hidden;
 
         protected override void LoadComplete()
         {
···
                 FinishTransforms(true);
             }
 
-            if (state != Visibility.Hidden)
-                updateState();
+            State.BindValueChanged(updateState, State.Value != Visibility.Hidden);
 
             base.LoadComplete();
         }
 
-        private Visibility state;
+        /// <summary>
+        /// Hide this container by setting its visibility to <see cref="Visibility.Visible"/>.
+        /// </summary>
+        public override void Show() => State.Value = Visibility.Visible;
 
-        public Visibility State
-        {
-            get => state;
-            set
-            {
-                if (value == state) return;
+        /// <summary>
+        /// Hide this container by setting its visibility to <see cref="Visibility.Hidden"/>.
+        /// </summary>
+        public override void Hide() => State.Value = Visibility.Hidden;
 
-                state = value;
+        /// <summary>
+        /// Toggle this container's visibility.
+        /// </summary>
+        public void ToggleVisibility() => State.Value = State.Value == Visibility.Visible ? Visibility.Hidden : Visibility.Visible;
 
-                if (!IsLoaded) return;
+        public override bool PropagateNonPositionalInputSubTree => base.PropagateNonPositionalInputSubTree && State.Value == Visibility.Visible;
+        public override bool PropagatePositionalInputSubTree => base.PropagatePositionalInputSubTree && State.Value == Visibility.Visible;
 
-                updateState();
-            }
-        }
+        /// <summary>
+        /// Implement any transition to be played when <see cref="State"/> becomes <see cref="Visibility.Visible"/>.
+        /// </summary>
+        protected abstract void PopIn();
 
-        private void updateState()
+        /// <summary>
+        /// Implement any transition to be played when <see cref="State"/> becomes <see cref="Visibility.Hidden"/>.
+        /// Will be invoked once on <see cref="LoadComplete"/> if <see cref="StartHidden"/> is set.
+        /// </summary>
+        protected abstract void PopOut();
+
+        private void updateState(ValueChangedEvent<Visibility> e)
         {
-            switch (state)
+            switch (e.NewValue)
             {
                 case Visibility.Hidden:
                     PopOut();
                     break;
+
                 case Visibility.Visible:
                     PopIn();
                     break;
             }
-
-            StateChanged?.Invoke(state);
         }
-
-        public override void Hide() => State = Visibility.Hidden;
-
-        public override void Show() => State = Visibility.Visible;
-
-        public override bool PropagateNonPositionalInputSubTree => base.PropagateNonPositionalInputSubTree && State == Visibility.Visible;
-        public override bool PropagatePositionalInputSubTree => base.PropagatePositionalInputSubTree && State == Visibility.Visible;
-
-        public event Action<Visibility> StateChanged;
-
-        protected abstract void PopIn();
-
-        protected abstract void PopOut();
-
-        public void ToggleVisibility() => State = State == Visibility.Visible ? Visibility.Hidden : Visibility.Visible;
     }
 
     public enum Visibility

osu.Framework/Graphics/Cursor/ContextMenuContainer.cs

···
                     relativeCursorPosition = ToSpaceOfOtherDrawable(menu.Position, menuTarget);
                     menu.Open();
                     return true;
+
                 default:
                     menu.Close();
                     return false;

osu.Framework/Graphics/Cursor/CursorContainer.cs

···
             Depth = float.MinValue;
             RelativeSizeAxes = Axes.Both;
 
-            State = Visibility.Visible;
+            State.Value = Visibility.Visible;
         }
 
         [BackgroundDependencyLoader]

osu.Framework/Graphics/Cursor/CursorEffectContainer.cs

···
                 // We keep track of all drawables we found while traversing the parent chain upwards.
                 newChildDrawables.Clear();
                 newChildDrawables.Add(candidate);
+
                 // When we encounter a drawable we already encountered before, then there is no need
                 // to keep going upward, since we already recorded it previously. At that point we know
                 // the drawables we found are in fact children of ours.

osu.Framework/Graphics/Cursor/TooltipContainer.cs

···
             base.Update();
 
             IHasTooltip target = findTooltipTarget();
+
             if (target != null && target != currentlyDisplayed)
             {
                 currentlyDisplayed = target;
···
                 return hasValidTooltip(draggedTarget) ? draggedTarget : null;
 
             IHasTooltip targetCandidate = FindTargets().Find(t => t.TooltipText != null);
+
             // check this first - if we find no target candidate we still want to clear the recorded positions and update the lastCandidate.
             if (targetCandidate != lastCandidate)
             {
···
             double appearDelay = (targetCandidate as IHasAppearDelay)?.AppearDelay ?? AppearDelay;
             // Always keep 10 positions at equally-sized time intervals that add up to AppearDelay.
             double positionRecordInterval = appearDelay / 10;
+
             if (Time.Current - lastRecordedPositionTime >= positionRecordInterval)
             {
                 lastRecordedPositionTime = Time.Current;

osu.Framework/Graphics/DrawNode.cs

···
 
 using osu.Framework.Graphics.OpenGL;
 using System;
+using System.Runtime.CompilerServices;
+using osu.Framework.Graphics.Batches;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.OpenGL.Buffers;
+using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.OpenGL.Vertices;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.MathUtils.Clipping;
 using osu.Framework.Threading;
+using osuTK;
 
 namespace osu.Framework.Graphics
 {
···
         /// <summary>
         /// Contains the colour and blending information of this <see cref="DrawNode"/>.
         /// </summary>
-        protected internal DrawColourInfo DrawColourInfo { get; internal set; }
+        protected DrawColourInfo DrawColourInfo { get; private set; }
 
         /// <summary>
         /// Identifies the state of this draw node with an invalidation state of its corresponding
···
         private readonly AtomicCounter referenceCount = new AtomicCounter();
 
         /// <summary>
+        /// The depth at which drawing should take place.
+        /// This is written to from the front-to-back pass and used in both passes.
+        /// </summary>
+        private float drawDepth;
+
+        /// <summary>
         /// Creates a new <see cref="DrawNode"/>.
         /// </summary>
         /// <param name="source">The <see cref="Drawable"/> to draw with this <see cref="DrawNode"/>.</param>
···
         }
 
         /// <summary>
-        /// Draws this draw node to the screen.
+        /// Draws this <see cref="DrawNode"/> to the screen.
         /// </summary>
-        /// <param name="vertexAction">The action to be performed on each vertex of
-        /// the draw node in order to draw it if required. This is primarily used by
-        /// textured sprites.</param>
+        /// <remarks>
+        /// This is the back-to-front (BTF) pass. The back-buffer depth test function used is GL_LESS.<br />
+        /// The depth test will fail for samples that overlap the opaque interior of this <see cref="DrawNode"/> and any <see cref="DrawNode"/>s above this one.<br />
+        /// </remarks>
+        /// <param name="vertexAction">The action to be performed on each vertex of the draw node in order to draw it if required. This is primarily used by textured sprites.</param>
         public virtual void Draw(Action<TexturedVertex2D> vertexAction)
         {
             GLWrapper.SetBlend(DrawColourInfo.Blending);
+            GLWrapper.SetDrawDepth(drawDepth);
+        }
+
+        /// <summary>
+        /// Draws the opaque interior of this <see cref="DrawNode"/> and all <see cref="DrawNode"/>s further down the scene graph, invoking <see cref="DrawOpaqueInterior"/> if <see cref="CanDrawOpaqueInterior"/>
+        /// indicates that an opaque interior can be drawn for each relevant <see cref="DrawNode"/>.
+        /// </summary>
+        /// <remarks>
+        /// This is the front-to-back pass. The back-buffer depth test function used is GL_LESS.<br />
+        /// If an opaque interior is not drawn: the current value of <paramref name="depthValue"/> is stored.<br />
+        /// If an opaque interior is drawn: <paramref name="depthValue"/> is incremented, stored, and the opaque interior vertices are drawn at the post-incremented depth value.
+        /// Incrementing <paramref name="depthValue"/> at this point allows for early-z testing to also occur within the front-to-back pass.<br />
+        /// </remarks>
+        /// <param name="depthValue">The previous depth value.</param>
+        /// <param name="vertexAction">The action to be performed on each vertex of the draw node in order to draw it if required. This is primarily used by textured sprites.</param>
+        internal virtual void DrawOpaqueInteriorSubTree(DepthValue depthValue, Action<TexturedVertex2D> vertexAction)
+        {
+            if (!depthValue.CanIncrement || !CanDrawOpaqueInterior)
+            {
+                // The back-to-front pass requires the depth value
+                drawDepth = depthValue;
+                return;
+            }
+
+            // It is crucial to draw with an incremented depth value, consider the case of a box:
+            // In the front-to-back pass, the inner conservative area is drawn at depth X
+            // In the back-to-front pass, the full area is drawn at depth X, and the depth test function is set to GL_LESS, so the inner conservative area is not redrawn
+            // Furthermore, a back-to-front-drawn object above the box will be visible since it will be drawn with a depth of (X - increment), satisfying the depth test
+            drawDepth = depthValue.Increment();
+
+            DrawOpaqueInterior(vertexAction);
+        }
+
+        /// <summary>
+        /// Draws the opaque interior of this <see cref="DrawNode"/> to the screen.
+        /// The opaque interior must be a fully-opaque, non-blended area of this <see cref="DrawNode"/>, clipped to the current masking area via <code>DrawClipped()</code>.
+        /// See <see cref="Shapes.Box.BoxDrawNode"/> for an example implementation.
+        /// </summary>
+        /// <param name="vertexAction">The action to be performed on each vertex of the draw node in order to draw it if required. This is primarily used by textured sprites.</param>
+        protected virtual void DrawOpaqueInterior(Action<TexturedVertex2D> vertexAction)
+        {
+            GLWrapper.SetBlend(DrawColourInfo.Blending);
+            GLWrapper.SetDrawDepth(drawDepth);
+        }
+
+        /// <summary>
+        /// Whether this <see cref="DrawNode"/> can draw a opaque interior. <see cref="DrawOpaqueInterior"/> will only be invoked if this value is <code>true</code>.
+        /// Should not return <code>true</code> if <see cref="DrawOpaqueInterior"/> will result in a no-op.
+        /// </summary>
+        protected internal virtual bool CanDrawOpaqueInterior => false;
+
+        /// <summary>
+        /// Draws a triangle to the screen.
+        /// </summary>
+        /// <param name="texture">The texture to fill the triangle with.</param>
+        /// <param name="vertexTriangle">The triangle to draw.</param>
+        /// <param name="textureRect">The texture rectangle.</param>
+        /// <param name="drawColour">The vertex colour.</param>
+        /// <param name="vertexAction">An action that adds vertices to a <see cref="VertexBatch{T}"/>.</param>
+        /// <param name="inflationPercentage">The percentage amount that <see cref="textureRect"/> should be inflated.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected void DrawTriangle(Texture texture, Triangle vertexTriangle, ColourInfo drawColour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null,
+                                    Vector2? inflationPercentage = null)
+            => texture.DrawTriangle(vertexTriangle, drawColour, textureRect, vertexAction, inflationPercentage);
+
+        /// <summary>
+        /// Draws a triangle to the screen.
+        /// </summary>
+        /// <param name="texture">The texture to fill the triangle with.</param>
+        /// <param name="vertexTriangle">The triangle to draw.</param>
+        /// <param name="drawColour">The vertex colour.</param>
+        /// <param name="textureRect">The texture rectangle.</param>
+        /// <param name="vertexAction">An action that adds vertices to a <see cref="VertexBatch{T}"/>.</param>
+        /// <param name="inflationPercentage">The percentage amount that <see cref="textureRect"/> should be inflated.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected void DrawTriangle(TextureGL texture, Triangle vertexTriangle, ColourInfo drawColour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null,
+                                    Vector2? inflationPercentage = null)
+            => texture.DrawTriangle(vertexTriangle, drawColour, textureRect, vertexAction, inflationPercentage);
+
+        /// <summary>
+        /// Draws a quad to the screen.
+        /// </summary>
+        /// <param name="texture">The texture to fill the triangle with.</param>
+        /// <param name="vertexQuad">The quad to draw.</param>
+        /// <param name="textureRect">The texture rectangle.</param>
+        /// <param name="drawColour">The vertex colour.</param>
+        /// <param name="vertexAction">An action that adds vertices to a <see cref="VertexBatch{T}"/>.</param>
+        /// <param name="inflationPercentage">The percentage amount that <see cref="textureRect"/> should be inflated.</param>
+        /// <param name="blendRangeOverride">The range over which the edges of the <see cref="textureRect"/> should be blended.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected void DrawQuad(Texture texture, Quad vertexQuad, ColourInfo drawColour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null,
+                                Vector2? inflationPercentage = null, Vector2? blendRangeOverride = null)
+            => texture.DrawQuad(vertexQuad, drawColour, textureRect, vertexAction, inflationPercentage: inflationPercentage, blendRangeOverride: blendRangeOverride);
+
+        /// <summary>
+        /// Draws a quad to the screen.
+        /// </summary>
+        /// <param name="texture">The texture to fill the triangle with.</param>
+        /// <param name="vertexQuad">The quad to draw.</param>
+        /// <param name="drawColour">The vertex colour.</param>
+        /// <param name="textureRect">The texture rectangle.</param>
+        /// <param name="vertexAction">An action that adds vertices to a <see cref="VertexBatch{T}"/>.</param>
+        /// <param name="inflationPercentage">The percentage amount that <see cref="textureRect"/> should be inflated.</param>
+        /// <param name="blendRangeOverride">The range over which the edges of the <see cref="textureRect"/> should be blended.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected void DrawQuad(TextureGL texture, Quad vertexQuad, ColourInfo drawColour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null,
+                                Vector2? inflationPercentage = null, Vector2? blendRangeOverride = null)
+            => texture.DrawQuad(vertexQuad, drawColour, textureRect, vertexAction, inflationPercentage: inflationPercentage, blendRangeOverride: blendRangeOverride);
+
+        /// <summary>
+        /// Clips a <see cref="IConvexPolygon"/> to the current masking area and draws the resulting triangles to the screen using the specified texture.
+        /// </summary>
+        /// <param name="polygon">The polygon to draw.</param>
+        /// <param name="texture">The texture to fill the triangle with.</param>
+        /// <param name="textureRect">The texture rectangle.</param>
+        /// <param name="drawColour">The vertex colour.</param>
+        /// <param name="vertexAction">An action that adds vertices to a <see cref="VertexBatch{T}"/>.</param>
+        /// <param name="inflationPercentage">The percentage amount that <see cref="textureRect"/> should be inflated.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected void DrawClipped<T>(ref T polygon, Texture texture, ColourInfo drawColour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null,
+                                      Vector2? inflationPercentage = null)
+            where T : IConvexPolygon
+        {
+            var maskingQuad = GLWrapper.CurrentMaskingInfo.ConservativeScreenSpaceQuad;
+
+            var clipper = new ConvexPolygonClipper<Quad, T>(ref maskingQuad, ref polygon);
+            Span<Vector2> buffer = stackalloc Vector2[clipper.GetClipBufferSize()];
+            Span<Vector2> clippedRegion = clipper.Clip(buffer);
+
+            for (int i = 2; i < clippedRegion.Length; i++)
+                DrawTriangle(texture, new Triangle(clippedRegion[0], clippedRegion[i - 1], clippedRegion[i]), drawColour, textureRect, vertexAction, inflationPercentage);
+        }
+
+        /// <summary>
+        /// Clips a <see cref="IConvexPolygon"/> to the current masking area and draws the resulting triangles to the screen using the specified texture.
+        /// </summary>
+        /// <param name="polygon">The polygon to draw.</param>
+        /// <param name="texture">The texture to fill the triangle with.</param>
+        /// <param name="textureRect">The texture rectangle.</param>
+        /// <param name="drawColour">The vertex colour.</param>
+        /// <param name="vertexAction">An action that adds vertices to a <see cref="VertexBatch{T}"/>.</param>
+        /// <param name="inflationPercentage">The percentage amount that <see cref="textureRect"/> should be inflated.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected void DrawClipped<T>(ref T polygon, TextureGL texture, ColourInfo drawColour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null,
+                                      Vector2? inflationPercentage = null)
+            where T : IConvexPolygon
+        {
+            var maskingQuad = GLWrapper.CurrentMaskingInfo.ConservativeScreenSpaceQuad;
+
+            var clipper = new ConvexPolygonClipper<Quad, T>(ref maskingQuad, ref polygon);
+            Span<Vector2> buffer = stackalloc Vector2[clipper.GetClipBufferSize()];
+            Span<Vector2> clippedRegion = clipper.Clip(buffer);
+
+            for (int i = 2; i < clippedRegion.Length; i++)
+                DrawTriangle(texture, new Triangle(clippedRegion[0], clippedRegion[i - 1], clippedRegion[i]), drawColour, textureRect, vertexAction, inflationPercentage);
+        }
+
+        /// <summary>
+        /// Draws a <see cref="FrameBuffer"/> to the screen.
+        /// </summary>
+        /// <param name="frameBuffer">The <see cref="FrameBuffer"/> to draw.</param>
+        /// <param name="vertexQuad">The destination vertices.</param>
+        /// <param name="drawColour">The colour to draw the <paramref name="frameBuffer"/> with.</param>
+        /// <param name="vertexAction">An action that adds vertices to a <see cref="VertexBatch{T}"/>.</param>
+        /// <param name="inflationPercentage">The percentage amount that the frame buffer area  should be inflated.</param>
+        /// <param name="blendRangeOverride">The range over which the edges of the frame buffer should be blended.</param>
+        protected void DrawFrameBuffer(FrameBuffer frameBuffer, Quad vertexQuad, ColourInfo drawColour, Action<TexturedVertex2D> vertexAction = null,
+                                       Vector2? inflationPercentage = null, Vector2? blendRangeOverride = null)
+        {
+            // The strange Y coordinate and Height are a result of OpenGL coordinate systems having Y grow upwards and not downwards.
+            RectangleF textureRect = new RectangleF(0, frameBuffer.Texture.Height, frameBuffer.Texture.Width, -frameBuffer.Texture.Height);
+
+            if (frameBuffer.Texture.Bind())
+                DrawQuad(frameBuffer.Texture, vertexQuad, drawColour, textureRect, vertexAction, inflationPercentage, blendRangeOverride);
         }
 
         /// <summary>

osu.Framework/Graphics/Drawable.cs

···
             get
             {
                 Vector2 offset = Vector2.Zero;
+
                 if (Parent != null && RelativePositionAxes != Axes.None)
                 {
                     offset = Parent.RelativeChildOffset;
···
         private void updateBypassAutoSizeAxes()
         {
             var value = RelativePositionAxes | RelativeSizeAxes | bypassAutoSizeAdditionalAxes;
+
             if (bypassAutoSizeAxes != value)
             {
                 var changedAxes = bypassAutoSizeAxes ^ value;
···
         protected InputManager GetContainingInputManager()
         {
             Drawable search = Parent;
+
             while (search != null)
             {
                 if (search is InputManager test) return test;
···
         internal virtual DrawNode GenerateDrawNodeSubtree(ulong frame, int treeIndex, bool forceNewDrawNode)
         {
             DrawNode node = drawNodes[treeIndex];
+
             if (node == null || forceNewDrawNode)
             {
                 drawNodes[treeIndex] = node = CreateDrawNode();
···
             {
                 case MouseMoveEvent mouseMove:
                     return OnMouseMove(mouseMove);
+
                 case HoverEvent hover:
                     return OnHover(hover);
+
                 case HoverLostEvent hoverLost:
                     OnHoverLost(hoverLost);
                     return false;
+
                 case MouseDownEvent mouseDown:
                     return OnMouseDown(mouseDown);
+
                 case MouseUpEvent mouseUp:
                     return OnMouseUp(mouseUp);
+
                 case ClickEvent click:
                     return OnClick(click);
+
                 case DoubleClickEvent doubleClick:
                     return OnDoubleClick(doubleClick);
+
                 case DragStartEvent dragStart:
                     return OnDragStart(dragStart);
+
                 case DragEvent drag:
                     return OnDrag(drag);
+
                 case DragEndEvent dragEnd:
                     return OnDragEnd(dragEnd);
+
                 case ScrollEvent scroll:
                     return OnScroll(scroll);
+
                 case FocusEvent focus:
                     OnFocus(focus);
                     return false;
+
                 case FocusLostEvent focusLost:
                     OnFocusLost(focusLost);
                     return false;
+
                 case KeyDownEvent keyDown:
                     return OnKeyDown(keyDown);
+
                 case KeyUpEvent keyUp:
                     return OnKeyUp(keyUp);
+
                 case JoystickPressEvent joystickPress:
                     return OnJoystickPress(joystickPress);
+
                 case JoystickReleaseEvent joystickRelease:
                     return OnJoystickRelease(joystickRelease);
+
                 default:
                     return false;
             }
···
             private static bool get(Drawable drawable, ConcurrentDictionary<Type, bool> cache, bool positional)
             {
                 var type = drawable.GetType();
+
                 if (!cache.TryGetValue(type, out var value))
                 {
                     value = compute(type, positional);
···
             private static bool compute(Type type, bool positional)
             {
                 var inputMethods = positional ? positional_input_methods : non_positional_input_methods;
+
                 foreach (var inputMethod in inputMethods)
                 {
                     // check for any input method overrides which are at a higher level than drawable.
···
                 }
 
                 var inputInterfaces = positional ? positional_input_interfaces : non_positional_input_interfaces;
+
                 foreach (var inputInterface in inputInterfaces)
                 {
                     // check if this type implements any interface which requires a drawable to handle input.

osu.Framework/Graphics/Drawable_ProxyDrawable.cs

···
                 {
                 }
 
+                internal override void DrawOpaqueInteriorSubTree(DepthValue depthValue, Action<TexturedVertex2D> vertexAction)
+                    => getCurrentFrameSource()?.DrawOpaqueInteriorSubTree(depthValue, vertexAction);
+
                 public override void Draw(Action<TexturedVertex2D> vertexAction)
+                    => getCurrentFrameSource()?.Draw(vertexAction);
+
+                protected internal override bool CanDrawOpaqueInterior => getCurrentFrameSource()?.CanDrawOpaqueInterior ?? false;
+
+                private DrawNode getCurrentFrameSource()
                 {
                     var target = Source.originalDrawNodes[DrawNodeIndex];
+
                     if (target == null)
-                        return;
+                        return null;
 
                     if (Source.drawNodeValidationIds[DrawNodeIndex] != FrameCount)
-                        return;
+                        return null;
 
-                    target.Draw(vertexAction);
+                    return target;
                 }
             }
         }

osu.Framework/Graphics/IBufferedDrawable.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Graphics.OpenGL.Buffers;
+using osuTK.Graphics;
+
+namespace osu.Framework.Graphics
+{
+    /// <summary>
+    /// Interface for <see cref="Drawable"/>s which can be drawn by a <see cref="BufferedDrawNode"/>.
+    /// </summary>
+    public interface IBufferedDrawable : ITexturedShaderDrawable
+    {
+        /// <summary>
+        /// The background colour of the <see cref="FrameBuffer"/>s.
+        /// Visually changes the colour which rendered alpha is blended against.
+        /// </summary>
+        /// <remarks>
+        /// This should generally be transparent-black or transparent-white, but can also be used to
+        /// colourise the background colour of the <see cref="FrameBuffer"/> with non-transparent colours.
+        /// </remarks>
+        Color4 BackgroundColour { get; }
+
+        /// <summary>
+        /// The colour with which the <see cref="FrameBuffer"/>s are rendered to the screen.
+        /// A null value implies the <see cref="FrameBuffer"/>s should be drawn as they are.
+        /// </summary>
+        DrawColourInfo? FrameBufferDrawColour { get; }
+    }
+}

osu.Framework/Graphics/Lines/Path.cs

···
 using osu.Framework.Allocation;
 using System.Collections.Generic;
 using osu.Framework.Caching;
+using osuTK.Graphics;
+using osuTK.Graphics.ES30;
 
 namespace osu.Framework.Graphics.Lines
 {
-    public partial class Path : Drawable, ITexturedShaderDrawable
+    public partial class Path : Drawable, IBufferedDrawable
     {
         public IShader RoundedTextureShader { get; private set; }
         public IShader TextureShader { get; private set; }
+        private IShader pathShader;
 
         [BackgroundDependencyLoader]
         private void load(ShaderManager shaders)
         {
-            RoundedTextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_3, FragmentShaderDescriptor.TEXTURE_ROUNDED);
-            TextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_3, FragmentShaderDescriptor.TEXTURE);
+            RoundedTextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);
+            TextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE);
+            pathShader = shaders.Load(VertexShaderDescriptor.TEXTURE_3, FragmentShaderDescriptor.TEXTURE);
         }
 
         private readonly List<Vector2> vertices = new List<Vector2>();
···
             }
         }
 
-        protected override DrawNode CreateDrawNode() => new PathDrawNode(this);
+        public DrawColourInfo? FrameBufferDrawColour => base.DrawColourInfo;
+
+        // The path should not receive the true colour to avoid colour doubling when the frame-buffer is rendered to the back-buffer.
+        // Removal of blending allows for correct blending between the wedges of the path.
+        public override DrawColourInfo DrawColourInfo => new DrawColourInfo(Color4.White, new BlendingInfo(BlendingMode.None));
+
+        public Color4 BackgroundColour => new Color4(0, 0, 0, 0);
+
+        private readonly BufferedDrawNodeSharedData sharedData = new BufferedDrawNodeSharedData();
+
+        protected override DrawNode CreateDrawNode() => new BufferedDrawNode(this, new PathDrawNode(this), sharedData, new[] { RenderbufferInternalFormat.DepthComponent16 });
     }
 }

osu.Framework/Graphics/Lines/Path_DrawNode.cs

···
 using osu.Framework.Graphics.OpenGL.Vertices;
 using osuTK.Graphics;
 using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Shaders;
 
 namespace osu.Framework.Graphics.Lines
 {
     public partial class Path
     {
-        private class PathDrawNode : TexturedShaderDrawNode
+        private class PathDrawNode : DrawNode
         {
             public const int MAX_RES = 24;
 
···
             private Texture texture;
             private Vector2 drawSize;
             private float radius;
+            private IShader pathShader;
 
             // We multiply the size param by 3 such that the amount of vertices is a multiple of the amount of vertices
             // per primitive (triangles in this case). Otherwise overflowing the batch will result in wrong
···
                 texture = Source.Texture;
                 drawSize = Source.DrawSize;
                 radius = Source.PathRadius;
+                pathShader = Source.pathShader;
             }
 
             private Vector2 pointOnCircle(float angle) => new Vector2((float)Math.Sin(angle), -(float)Math.Cos(angle));
···
 
                 GLWrapper.PushDepthInfo(DepthInfo.Default);
 
-                Shader.Bind();
+                pathShader.Bind();
 
                 texture.TextureGL.WrapMode = TextureWrapMode.ClampToEdge;
                 texture.TextureGL.Bind();
 
                 updateVertexBuffer();
 
-                Shader.Unbind();
+                pathShader.Unbind();
 
                 GLWrapper.PopDepthInfo();
             }

osu.Framework/Graphics/OpenGL/Buffers/FrameBuffer.cs

···
         public void Bind()
         {
             GLWrapper.BindFrameBuffer(frameBuffer);
+
             foreach (var r in attachedRenderBuffers)
             {
                 r.Size = Size;

osu.Framework/Graphics/OpenGL/Buffers/LinearVertexBuffer.cs

···
     {
         private readonly int amountVertices;
 
-        public LinearVertexBuffer(int amountVertices, PrimitiveType type, BufferUsageHint usage)
+        internal LinearVertexBuffer(int amountVertices, PrimitiveType type, BufferUsageHint usage)
             : base(amountVertices, usage)
         {
             this.amountVertices = amountVertices;

osu.Framework/Graphics/OpenGL/Buffers/QuadVertexBuffer.cs

···
     {
         private readonly int amountQuads;
 
-        public QuadVertexBuffer(int amountQuads, BufferUsageHint usage)
+        internal QuadVertexBuffer(int amountQuads, BufferUsageHint usage)
             : base(amountQuads * 4, usage)
         {
             this.amountQuads = amountQuads;
···
             base.Initialise();
 
             int amountIndices = amountQuads * 6;
+
             if (amountIndices > QuadIndexData.MaxAmountIndices)
             {
                 ushort[] indices = new ushort[amountIndices];

osu.Framework/Graphics/OpenGL/Buffers/RenderBuffer.cs

···
                     case RenderbufferInternalFormat.DepthComponent16:
                         GL.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, FramebufferAttachment.DepthAttachment, RenderbufferTarget.Renderbuffer, info.RenderBufferID);
                         break;
+
                     case RenderbufferInternalFormat.Rgb565:
                     case RenderbufferInternalFormat.Rgb5A1:
                     case RenderbufferInternalFormat.Rgba4:
                         GL.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, RenderbufferTarget.Renderbuffer, info.RenderBufferID);
                         break;
+
                     case RenderbufferInternalFormat.StencilIndex8:
                         GL.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, FramebufferAttachment.DepthAttachment, RenderbufferTarget.Renderbuffer, info.RenderBufferID);
                         break;

osu.Framework/Graphics/OpenGL/Buffers/VertexBuffer.cs

···
     public abstract class VertexBuffer<T> : IDisposable
         where T : struct, IEquatable<T>, IVertex
     {
-        protected static readonly int STRIDE = VertexUtils<T>.STRIDE;
+        protected static readonly int STRIDE = VertexUtils<DepthWrappingVertex<T>>.STRIDE;
 
-        public readonly T[] Vertices;
+        private readonly DepthWrappingVertex<T>[] vertices;
 
         private readonly BufferUsageHint usage;
 
···
         {
             this.usage = usage;
 
-            Vertices = new T[amountVertices];
+            vertices = new DepthWrappingVertex<T>[amountVertices];
+        }
+
+        /// <summary>
+        /// Sets the vertex at a specific index of this <see cref="VertexBuffer{T}"/>.
+        /// </summary>
+        /// <param name="vertexIndex">The index of the vertex.</param>
+        /// <param name="vertex">The vertex.</param>
+        /// <returns>Whether the vertex changed.</returns>
+        public bool SetVertex(int vertexIndex, T vertex)
+        {
+            bool isNewVertex = !vertices[vertexIndex].Equals(vertex) || vertices[vertexIndex].BackbufferDrawDepth != GLWrapper.BackbufferDrawDepth;
+
+            vertices[vertexIndex].Vertex = vertex;
+            vertices[vertexIndex].BackbufferDrawDepth = GLWrapper.BackbufferDrawDepth;
+
+            return isNewVertex;
         }
+
+        /// <summary>
+        /// Gets the number of vertices in this <see cref="VertexBuffer{T}"/>.
+        /// </summary>
+        public int Size => vertices.Length;
 
         /// <summary>
         /// Initialises this <see cref="VertexBuffer{T}"/>. Guaranteed to be run on the draw thread.
···
             GL.GenBuffers(1, out vboId);
 
             if (GLWrapper.BindBuffer(BufferTarget.ArrayBuffer, vboId))
-                VertexUtils<T>.Bind();
+                VertexUtils<DepthWrappingVertex<T>>.Bind();
 
-            GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(Vertices.Length * STRIDE), IntPtr.Zero, usage);
+            GL.BufferData(BufferTarget.ArrayBuffer, (IntPtr)(vertices.Length * STRIDE), IntPtr.Zero, usage);
         }
 
         ~VertexBuffer()
···
             }
 
             if (GLWrapper.BindBuffer(BufferTarget.ArrayBuffer, vboId))
-                VertexUtils<T>.Bind();
+                VertexUtils<DepthWrappingVertex<T>>.Bind();
         }
 
         public virtual void Unbind()
···
 
         public void Draw()
         {
-            DrawRange(0, Vertices.Length);
+            DrawRange(0, vertices.Length);
         }
 
         public void DrawRange(int startIndex, int endIndex)
···
 
         public void Update()
         {
-            UpdateRange(0, Vertices.Length);
+            UpdateRange(0, vertices.Length);
         }
 
         public void UpdateRange(int startIndex, int endIndex)
···
             Bind(false);
 
             int amountVertices = endIndex - startIndex;
-            GL.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr)(startIndex * STRIDE), (IntPtr)(amountVertices * STRIDE), ref Vertices[startIndex]);
+            GL.BufferSubData(BufferTarget.ArrayBuffer, (IntPtr)(startIndex * STRIDE), (IntPtr)(amountVertices * STRIDE), ref vertices[startIndex]);
 
             Unbind();
 

osu.Framework/Graphics/OpenGL/DepthValue.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Runtime.CompilerServices;
+
+namespace osu.Framework.Graphics.OpenGL
+{
+    /// <summary>
+    /// The depth value used to draw 2D objects to the screen.
+    /// Starts at -1f and increments to 1f for each <see cref="Drawable"/> which draws a opaque interior through <see cref="DrawNode.DrawOpaqueInterior"/>.
+    /// </summary>
+    public class DepthValue
+    {
+        /// <summary>
+        /// A safe value, such that rounding issues don't occur within 16-bit float precision.
+        /// </summary>
+        private const float increment = 0.001f;
+
+        /// <summary>
+        /// Calculated as (1 - (-1)) / increment - 1.
+        /// -1 is subtracted since a depth of 1.0f conflicts with the default backbuffer clear value.
+        /// </summary>
+        private const int max_count = 1999;
+
+        private float depth = -1;
+        private int count;
+
+        /// <summary>
+        /// Increments the depth value.
+        /// </summary>
+        /// <returns>The post-incremented depth value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal float Increment()
+        {
+            if (count == max_count)
+                return depth;
+
+            depth += increment;
+            count++;
+
+            return depth;
+        }
+
+        /// <summary>
+        /// Whether the depth value can be incremented.
+        /// </summary>
+        internal bool CanIncrement
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => count < max_count;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator float(DepthValue d) => d.depth;
+    }
+}

osu.Framework/Graphics/OpenGL/GLWrapper.cs

···
 using osu.Framework.MathUtils;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.OpenGL.Buffers;
 using osu.Framework.Platform;
+using GameWindow = osu.Framework.Platform.GameWindow;
 
 namespace osu.Framework.Graphics.OpenGL
 {
···
         public static RectangleF Ortho { get; private set; }
         public static Matrix4 ProjectionMatrix { get; private set; }
         public static DepthInfo CurrentDepthInfo { get; private set; }
+
+        public static float BackbufferDrawDepth { get; private set; }
 
         public static bool UsingBackbuffer => frame_buffer_stack.Peek() == DefaultFrameBuffer;
 
···
         {
             if (IsInitialized) return;
 
-            isEmbedded = host.Window.IsEmbedded;
+            if (host.Window is GameWindow win)
+                isEmbedded = win.IsEmbedded;
 
             GLWrapper.host = new WeakReference<GameHost>(host);
             reset_scheduler.SetCurrentThread();
···
                 AlphaExponent = 1,
             }, true);
 
-            PushDepthInfo(new DepthInfo(false));
+            PushDepthInfo(DepthInfo.Default);
             Clear(ClearInfo.Default);
         }
 
···
 
         public static void Clear(ClearInfo clearInfo)
         {
+            PushDepthInfo(new DepthInfo(writeDepth: true));
+
             if (clearInfo.Colour != currentClearInfo.Colour)
                 GL.ClearColor(clearInfo.Colour);
 
···
             GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit | ClearBufferMask.StencilBufferBit);
 
             currentClearInfo = clearInfo;
+
+            PopDepthInfo();
         }
 
         /// <summary>
···
             GlobalPropertyManager.Set(GlobalProperty.CornerRadius, maskingInfo.CornerRadius);
 
             GlobalPropertyManager.Set(GlobalProperty.BorderThickness, maskingInfo.BorderThickness / maskingInfo.BlendRange);
+
             if (maskingInfo.BorderThickness > 0)
             {
                 GlobalPropertyManager.Set(GlobalProperty.BorderColour, new Vector4(
···
         }
 
         /// <summary>
+        /// Sets the current draw depth.
+        /// The draw depth is written to every vertex added to <see cref="VertexBuffer{T}"/>s.
+        /// </summary>
+        /// <param name="drawDepth">The draw depth.</param>
+        internal static void SetDrawDepth(float drawDepth) => BackbufferDrawDepth = drawDepth;
+
+        /// <summary>
         /// Binds a framebuffer.
         /// </summary>
         /// <param name="frameBuffer">The framebuffer to bind.</param>
···
             {
                 FlushCurrentBatch();
                 GL.BindFramebuffer(FramebufferTarget.Framebuffer, frameBuffer);
+                GlobalPropertyManager.Set(GlobalProperty.BackbufferDraw, UsingBackbuffer);
             }
 
             GlobalPropertyManager.Set(GlobalProperty.GammaCorrection, UsingBackbuffer);
···
             FlushCurrentBatch();
             GL.BindFramebuffer(FramebufferTarget.Framebuffer, frame_buffer_stack.Peek());
 
+            GlobalPropertyManager.Set(GlobalProperty.BackbufferDraw, UsingBackbuffer);
             GlobalPropertyManager.Set(GlobalProperty.GammaCorrection, UsingBackbuffer);
         }
 
···
                 case IUniformWithValue<bool> b:
                     GL.Uniform1(uniform.Location, b.GetValue() ? 1 : 0);
                     break;
+
                 case IUniformWithValue<int> i:
                     GL.Uniform1(uniform.Location, i.GetValue());
                     break;
+
                 case IUniformWithValue<float> f:
                     GL.Uniform1(uniform.Location, f.GetValue());
                     break;
+
                 case IUniformWithValue<Vector2> v2:
                     GL.Uniform2(uniform.Location, ref v2.GetValueByRef());
                     break;
+
                 case IUniformWithValue<Vector3> v3:
                     GL.Uniform3(uniform.Location, ref v3.GetValueByRef());
                     break;
+
                 case IUniformWithValue<Vector4> v4:
                     GL.Uniform4(uniform.Location, ref v4.GetValueByRef());
                     break;
+
                 case IUniformWithValue<Matrix2> m2:
                     GL.UniformMatrix2(uniform.Location, false, ref m2.GetValueByRef());
                     break;
+
                 case IUniformWithValue<Matrix3> m3:
                     GL.UniformMatrix3(uniform.Location, false, ref m3.GetValueByRef());
                     break;
+
                 case IUniformWithValue<Matrix4> m4:
                     GL.UniformMatrix4(uniform.Location, false, ref m4.GetValueByRef());
                     break;
···
     {
         public RectangleI ScreenSpaceAABB;
         public RectangleF MaskingRect;
+
+        public Quad ConservativeScreenSpaceQuad;
 
         /// <summary>
         /// This matrix transforms screen space coordinates to masking space (likely the parent

osu.Framework/Graphics/OpenGL/Textures/TextureGL.cs

···
 
 using System;
 using System.Threading;
+using osu.Framework.Graphics.Batches;
 using osu.Framework.Graphics.Primitives;
 using osuTK.Graphics.ES30;
 using osuTK;
···
         public abstract RectangleF GetTextureRect(RectangleF? textureRect);
 
         /// <summary>
-        /// Blit a triangle to OpenGL display with specified parameters.
+        /// Draws a triangle to the screen.
         /// </summary>
-        public abstract void DrawTriangle(Triangle vertexTriangle, RectangleF? textureRect, ColourInfo drawColour, Action<TexturedVertex2D> vertexAction = null, Vector2? inflationPercentage = null);
+        /// <param name="vertexTriangle">The triangle to draw.</param>
+        /// <param name="drawColour">The vertex colour.</param>
+        /// <param name="textureRect">The texture rectangle.</param>
+        /// <param name="vertexAction">An action that adds vertices to a <see cref="VertexBatch{T}"/>.</param>
+        /// <param name="inflationPercentage">The percentage amount that <see cref="textureRect"/> should be inflated.</param>
+        internal abstract void DrawTriangle(Triangle vertexTriangle, ColourInfo drawColour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null,
+                                            Vector2? inflationPercentage = null);
 
         /// <summary>
-        /// Blit a quad to OpenGL display with specified parameters.
+        /// Draws a quad to the screen.
         /// </summary>
-        public abstract void DrawQuad(Quad vertexQuad, RectangleF? textureRect, ColourInfo drawColour, Action<TexturedVertex2D> vertexAction = null, Vector2? inflationPercentage = null, Vector2? blendRangeOverride = null);
+        /// <param name="vertexQuad">The quad to draw.</param>
+        /// <param name="drawColour">The vertex colour.</param>
+        /// <param name="textureRect">The texture rectangle.</param>
+        /// <param name="vertexAction">An action that adds vertices to a <see cref="VertexBatch{T}"/>.</param>
+        /// <param name="inflationPercentage">The percentage amount that <see cref="textureRect"/> should be inflated.</param>
+        /// <param name="blendRangeOverride">The range over which the edges of the <see cref="textureRect"/> should be blended.</param>
+        internal abstract void DrawQuad(Quad vertexQuad, ColourInfo drawColour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null, Vector2? inflationPercentage = null,
+                                        Vector2? blendRangeOverride = null);
 
         /// <summary>
         /// Bind as active texture.

osu.Framework/Graphics/OpenGL/Textures/TextureGLSingle.cs

···
             return texRect;
         }
 
-        public override void DrawTriangle(Triangle vertexTriangle, RectangleF? textureRect, ColourInfo drawColour, Action<TexturedVertex2D> vertexAction = null, Vector2? inflationPercentage = null)
+        internal override void DrawTriangle(Triangle vertexTriangle, ColourInfo drawColour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null,
+                                            Vector2? inflationPercentage = null)
         {
             if (!Available)
                 throw new ObjectDisposedException(ToString(), "Can not draw a triangle with a disposed texture.");
···
             FrameStatistics.Add(StatisticsCounterType.Pixels, (long)vertexTriangle.ConservativeArea);
         }
 
-        public override void DrawQuad(Quad vertexQuad, RectangleF? textureRect, ColourInfo drawColour, Action<TexturedVertex2D> vertexAction = null, Vector2? inflationPercentage = null,
-                                      Vector2? blendRangeOverride = null)
+        internal override void DrawQuad(Quad vertexQuad, ColourInfo drawColour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null, Vector2? inflationPercentage = null,
+                                        Vector2? blendRangeOverride = null)
         {
             if (!Available)
                 throw new ObjectDisposedException(ToString(), "Can not draw a quad with a disposed texture.");

osu.Framework/Graphics/OpenGL/Textures/TextureGLSub.cs

···
 
         public override RectangleF GetTextureRect(RectangleF? textureRect) => parent.GetTextureRect(boundsInParent(textureRect));
 
-        public override void DrawTriangle(Triangle vertexTriangle, RectangleF? textureRect, ColourInfo drawColour, Action<TexturedVertex2D> vertexAction = null, Vector2? inflationPercentage = null)
+        internal override void DrawTriangle(Triangle vertexTriangle, ColourInfo drawColour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null,
+                                            Vector2? inflationPercentage = null)
         {
-            parent.DrawTriangle(vertexTriangle, boundsInParent(textureRect), drawColour, vertexAction, inflationPercentage);
+            parent.DrawTriangle(vertexTriangle, drawColour, boundsInParent(textureRect), vertexAction, inflationPercentage);
         }
 
-        public override void DrawQuad(Quad vertexQuad, RectangleF? textureRect, ColourInfo drawColour, Action<TexturedVertex2D> vertexAction = null, Vector2? inflationPercentage = null, Vector2? blendRangeOverride = null)
+        internal override void DrawQuad(Quad vertexQuad, ColourInfo drawColour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null, Vector2? inflationPercentage = null,
+                                        Vector2? blendRangeOverride = null)
         {
-            parent.DrawQuad(vertexQuad, boundsInParent(textureRect), drawColour, vertexAction, inflationPercentage, blendRangeOverride);
+            parent.DrawQuad(vertexQuad, drawColour, boundsInParent(textureRect), vertexAction, inflationPercentage: inflationPercentage, blendRangeOverride: blendRangeOverride);
         }
 
         internal override bool Upload() => false;

osu.Framework/Graphics/OpenGL/Vertices/DepthWrappingVertex.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Runtime.InteropServices;
+using osuTK.Graphics.ES30;
+
+namespace osu.Framework.Graphics.OpenGL.Vertices
+{
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct DepthWrappingVertex<TVertex> : IVertex, IEquatable<DepthWrappingVertex<TVertex>>, IEquatable<TVertex>
+        where TVertex : IVertex, IEquatable<TVertex>
+    {
+        public TVertex Vertex;
+
+        [VertexMember(1, VertexAttribPointerType.Float)]
+        public float BackbufferDrawDepth;
+
+        public bool Equals(DepthWrappingVertex<TVertex> other)
+            => Vertex.Equals(other.Vertex)
+               && BackbufferDrawDepth.Equals(other.BackbufferDrawDepth);
+
+        public bool Equals(TVertex other)
+            => Vertex.Equals(other);
+    }
+}

osu.Framework/Graphics/OpenGL/Vertices/VertexUtils.cs

···
 
 // ReSharper disable StaticMemberInGenericType
 
+using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
-using osuTK;
 using osuTK.Graphics.ES30;
 
 namespace osu.Framework.Graphics.OpenGL.Vertices
···
         /// <summary>
         /// The stride of the vertex of type <see cref="T"/>.
         /// </summary>
-        public static readonly int STRIDE = BlittableValueType.StrideOf(default(T));
+        public static readonly int STRIDE = Marshal.SizeOf(default(T));
 
         private static readonly List<VertexMemberAttribute> attributes = new List<VertexMemberAttribute>();
         private static int amountEnabledAttributes;
 
         static VertexUtils()
         {
-            // Use reflection to retrieve the members attached with a VertexMemberAttribute
-            foreach (FieldInfo field in typeof(T).GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Where(t => t.IsDefined(typeof(VertexMemberAttribute), true)))
+            addAttributesRecursive(typeof(T), 0);
+        }
+
+        private static void addAttributesRecursive(Type type, int currentOffset)
+        {
+            foreach (FieldInfo field in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
             {
-                var attrib = (VertexMemberAttribute)field.GetCustomAttribute(typeof(VertexMemberAttribute));
+                int fieldOffset = currentOffset + Marshal.OffsetOf(type, field.Name).ToInt32();
 
-                // Because this is an un-seen vertex, the attribute locations are unknown, but they're needed for marshalling
-                attrib.Offset = Marshal.OffsetOf(typeof(T), field.Name);
+                if (typeof(IVertex).IsAssignableFrom(field.FieldType))
+                {
+                    // Vertices may contain others, but the attributes of contained vertices belong to the parent when marshalled, so they are recursively added for their parent
+                    // Their field offsets must be adjusted to reflect the position of the child attribute in the parent vertex
+                    addAttributesRecursive(field.FieldType, fieldOffset);
+                }
+                else if (field.IsDefined(typeof(VertexMemberAttribute), true))
+                {
+                    var attrib = (VertexMemberAttribute)field.GetCustomAttribute(typeof(VertexMemberAttribute));
 
-                attributes.Add(attrib);
+                    // Because this is an un-seen vertex, the attribute locations are unknown, but they're needed for marshalling
+                    attrib.Offset = new IntPtr(fieldOffset);
+
+                    attributes.Add(attrib);
+                }
             }
         }
 

osu.Framework/Graphics/Performance/FrameStatisticsDisplay.cs

···
                         labelText.Origin = Anchor.CentreRight;
                         labelText.Rotation = 0;
                         break;
+
                     case FrameStatisticsMode.Full:
                         mainContainer.AutoSizeAxes = Axes.None;
                         mainContainer.Size = new Vector2(WIDTH, HEIGHT);
···
             }
         }
 
-        public FrameStatisticsDisplay(GameThread thread, TextureAtlas atlas)
+        public FrameStatisticsDisplay(GameThread thread)
         {
             Name = thread.Name;
             monitor = thread.Monitor;
···
                                     {
                                         counterBarBackground = new Sprite
                                         {
-                                            Texture = new Texture(atlas.Add(1, HEIGHT)),
+                                            Texture = new Texture(1, HEIGHT),
                                             RelativeSizeAxes = Axes.Both,
                                             Size = new Vector2(1, 1),
                                         },
···
                                 RelativeSizeAxes = Axes.Both,
                                 Children = timeBars = new[]
                                 {
-                                    new TimeBar(atlas),
-                                    new TimeBar(atlas),
+                                    new TimeBar(),
+                                    new TimeBar(),
                                 },
                             },
                             frameTimeDisplay = new FrameTimeDisplay(monitor.Clock)
···
                 case Key.ControlLeft:
                     Expanded = true;
                     break;
+
                 case Key.ShiftLeft:
                     Running = false;
                     break;
···
                 case Key.ControlLeft:
                     Expanded = false;
                     break;
+
                 case Key.ShiftLeft:
                     Running = true;
                     break;
···
             {
                 default:
                     return Color4.YellowGreen;
+
                 case PerformanceCollectionType.SwapBuffer:
                     return Color4.Red;
 #if DEBUG
···
 #endif
                 case PerformanceCollectionType.Sleep:
                     return Color4.DarkBlue;
+
                 case PerformanceCollectionType.Scheduler:
                     return Color4.HotPink;
+
                 case PerformanceCollectionType.WndProc:
                     return Color4.GhostWhite;
+
                 case PerformanceCollectionType.GLReset:
                     return Color4.Cyan;
             }
···
             {
                 default:
                     return Color4.BlueViolet;
+
                 case 1:
                     return Color4.YellowGreen;
+
                 case 2:
                     return Color4.HotPink;
+
                 case 3:
                     return Color4.Red;
+
                 case 4:
                     return Color4.Cyan;
+
                 case 5:
                     return Color4.Yellow;
+
                 case 6:
                     return Color4.SkyBlue;
             }
···
                 bool acceptableRange = (float)currentHeight / HEIGHT > 1 - monitor.FrameAimTime / visible_ms_range;
 
                 float brightnessAdjust = 1;
+
                 if (!frameTimeType.HasValue)
                 {
                     int step = amountSteps / HEIGHT;
···
         {
             public readonly Sprite Sprite;
 
-            public TimeBar(TextureAtlas atlas)
+            public TimeBar()
             {
                 Size = new Vector2(WIDTH, HEIGHT);
                 Child = Sprite = new Sprite();
 
-                Sprite.Texture = new Texture(atlas.Add(WIDTH, HEIGHT));
+                Sprite.Texture = new Texture(WIDTH, HEIGHT);
             }
         }
 

osu.Framework/Graphics/Performance/PerformanceOverlay.cs

···
 
 using System;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Graphics.OpenGL;
-using osu.Framework.Graphics.Textures;
-using osuTK.Graphics.ES30;
 using osu.Framework.Threading;
 using System.Collections.Generic;
 
···
 {
     internal class PerformanceOverlay : FillFlowContainer<FrameStatisticsDisplay>, IStateful<FrameStatisticsMode>
     {
+        private readonly IEnumerable<GameThread> threads;
         private FrameStatisticsMode state;
 
         public event Action<FrameStatisticsMode> StateChanged;
 
+        private bool initialised;
+
         public FrameStatisticsMode State
         {
             get => state;
···
                     case FrameStatisticsMode.None:
                         this.FadeOut(100);
                         break;
+
                     case FrameStatisticsMode.Minimal:
                     case FrameStatisticsMode.Full:
+                        if (!initialised)
+                        {
+                            initialised = true;
+                            foreach (GameThread t in threads)
+                                Add(new FrameStatisticsDisplay(t) { State = state });
+                        }
+
                         this.FadeIn(100);
                         break;
                 }
···
 
         public PerformanceOverlay(IEnumerable<GameThread> threads)
         {
+            this.threads = threads;
             Direction = FillDirection.Vertical;
-            TextureAtlas atlas = new TextureAtlas(GLWrapper.MaxTextureSize, GLWrapper.MaxTextureSize, true, All.Nearest);
-
-            foreach (GameThread t in threads)
-                Add(new FrameStatisticsDisplay(t, atlas) { State = state });
         }
     }
 

osu.Framework/Graphics/Primitives/IPolygon.cs

···
     public interface IPolygon
     {
         /// <summary>
-        /// The vertices that define the axes spanned by this polygon.
+        /// The vertices that define the axes spanned by this polygon in screen-space counter-clockwise orientation.
         /// </summary>
         /// <remarks>
-        /// Must be returned in a clockwise orientation. For best performance, vertices that form colinear edges should not be included.
+        /// Counter-clockwise orientation in screen-space coordinates is equivalent to a clockwise orientation in standard coordinates.
+        /// <para>
+        /// E.g. For the set of vertices { (0, 0), (1, 0), (0, 1), (1, 1) }, a counter-clockwise orientation is { (0, 0), (0, 1), (1, 1), (1, 0) }.
+        /// </para>
         /// </remarks>
-        /// <returns>
-        /// The vertices that define the axes spanned by this polygon.
-        /// </returns>
+        /// <returns>The vertices that define the axes spanned by this polygon.</returns>
         ReadOnlySpan<Vector2> GetAxisVertices();
 
         /// <summary>
-        /// Retrieves the vertices of this polygon.
+        /// Retrieves the vertices of this polygon in screen-space counter-clockwise orientation.
         /// </summary>
         /// <remarks>
-        /// Must be returned in a clockwise orientation.
+        /// Counter-clockwise orientation in screen-space coordinates is equivalent to a clockwise orientation in standard coordinates.
+        /// <para>
+        /// E.g. For the set of vertices { (0, 0), (1, 0), (0, 1), (1, 1) }, a counter-clockwise orientation is { (0, 0), (0, 1), (1, 1), (1, 0) }.
+        /// </para>
         /// </remarks>
         /// <returns>The vertices of this polygon.</returns>
         ReadOnlySpan<Vector2> GetVertices();

osu.Framework/Graphics/Primitives/Line.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Runtime.CompilerServices;
 using osu.Framework.MathUtils;
 using osuTK;
 
···
     /// <summary>
     /// Represents a single line segment.
     /// </summary>
-    public struct Line
+    public readonly struct Line
     {
         /// <summary>
         /// Begin point of the line.
         /// </summary>
-        public Vector2 StartPoint;
+        public readonly Vector2 StartPoint;
 
         /// <summary>
         /// End point of the line.
         /// </summary>
-        public Vector2 EndPoint;
+        public readonly Vector2 EndPoint;
 
         /// <summary>
         /// The length of the line.
···
         /// </summary>
         /// <param name="t">A parameter representing the position along the line to compute. 0 yields the start point and 1 yields the end point.</param>
         /// <returns>The position along the line.</returns>
-        public Vector2 At(float t) => StartPoint + Direction * t;
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector2 At(float t) => new Vector2(StartPoint.X + (EndPoint.X - StartPoint.X) * t, StartPoint.Y + (EndPoint.Y - StartPoint.Y) * t);
 
         /// <summary>
         /// Intersects this line with another.
···
         /// <returns>Whether the two lines intersect and, if so, the distance along this line at which the intersection occurs.
         /// An intersection may occur even if the two lines don't touch, at which point the parameter will be outside the [0, 1] range.
         /// To compute the point of intersection, <see cref="At"/>.</returns>
-        public (bool success, float distance) IntersectWith(Line other)
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public (bool success, float distance) IntersectWith(in Line other)
         {
-            Vector2 diff1 = Direction;
-            Vector2 diff2 = other.Direction;
+            bool success = TryIntersectWith(other, out var distance);
+            return (success, distance);
+        }
+
+        /// <summary>
+        /// Intersects this line with another.
+        /// </summary>
+        /// <param name="other">The line to intersect with.</param>
+        /// <param name="distance">The distance along this line at which the intersection occurs. To compute the point of intersection, <see cref="At"/>.</param>
+        /// <returns>Whether the two lines intersect. An intersection may occur even if the two lines don't touch, at which point the parameter will be outside the [0, 1] range.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool TryIntersectWith(in Line other, out float distance)
+        {
+            var startPoint = other.StartPoint;
+            var endPoint = other.EndPoint;
+
+            return TryIntersectWith(ref startPoint, ref endPoint, out distance);
+        }
 
-            float denom = diff1.X * diff2.Y - diff1.Y * diff2.X;
+        /// <summary>
+        /// Intersects this line with another.
+        /// </summary>
+        /// <param name="otherStart">The start point of the other line to intsersect with.</param>
+        /// <param name="otherEnd">The end point of the other line to intersect with.</param>
+        /// <param name="distance">The distance along this line at which the intersection occurs. To compute the point of intersection, <see cref="At"/>.</param>
+        /// <returns>Whether the two lines intersect. An intersection may occur even if the two lines don't touch, at which point the parameter will be outside the [0, 1] range.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public bool TryIntersectWith(ref Vector2 otherStart, ref Vector2 otherEnd, out float distance)
+        {
+            float otherYDist = otherEnd.Y - otherStart.Y;
+            float otherXDist = otherEnd.X - otherStart.X;
 
-            if (Precision.AlmostEquals(0, denom))
-                return (false, 0); // Co-linear
+            float denom = (EndPoint.X - StartPoint.X) * otherYDist - (EndPoint.Y - StartPoint.Y) * otherXDist;
 
-            Vector2 d = other.StartPoint - StartPoint;
-            float t = (d.X * diff2.Y - d.Y * diff2.X) / denom;
+            if (Precision.AlmostEquals(denom, 0))
+            {
+                distance = 0;
+                return false;
+            }
 
-            return (true, t);
+            distance = ((otherStart.X - StartPoint.X) * otherYDist - (otherStart.Y - StartPoint.Y) * otherXDist) / denom;
+            return true;
         }
 
         /// <summary>

osu.Framework/Graphics/Primitives/Quad.cs

···
     [StructLayout(LayoutKind.Sequential)]
     public struct Quad : IConvexPolygon, IEquatable<Quad>
     {
-        // Note: Do not change the order of vertices.
+        // Note: Do not change the order of vertices. They are ordered in screen-space counter-clockwise fashion.
+        // See: IPolygon.GetVertices()
         public Vector2 TopLeft;
-        public Vector2 TopRight;
+        public Vector2 BottomLeft;
         public Vector2 BottomRight;
-        public Vector2 BottomLeft;
+        public Vector2 TopRight;
 
         public Quad(Vector2 topLeft, Vector2 topRight, Vector2 bottomLeft, Vector2 bottomRight)
         {

osu.Framework/Graphics/Primitives/SimpleConvexPolygon.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osuTK;
+
+namespace osu.Framework.Graphics.Primitives
+{
+    public class SimpleConvexPolygon : IConvexPolygon
+    {
+        private readonly Vector2[] vertices;
+
+        public SimpleConvexPolygon(Vector2[] vertices)
+        {
+            this.vertices = vertices;
+        }
+
+        public ReadOnlySpan<Vector2> GetAxisVertices() => vertices;
+
+        public ReadOnlySpan<Vector2> GetVertices() => vertices;
+
+        public int MaxClipVertices => vertices.Length * 2;
+    }
+}

osu.Framework/Graphics/Shaders/GlobalProperty.cs

···
         DiscardInner,
         InnerCornerRadius,
         GammaCorrection,
+        BackbufferDraw,
     }
 }

osu.Framework/Graphics/Shaders/GlobalPropertyManager.cs

···
             global_properties[(int)GlobalProperty.DiscardInner] = new UniformMapping<bool>("g_DiscardInner");
             global_properties[(int)GlobalProperty.InnerCornerRadius] = new UniformMapping<float>("g_InnerCornerRadius");
             global_properties[(int)GlobalProperty.GammaCorrection] = new UniformMapping<bool>("g_GammaCorrection");
+
+            // Backbuffer internals
+            global_properties[(int)GlobalProperty.BackbufferDraw] = new UniformMapping<bool>("g_BackbufferDraw");
         }
 
         /// <summary>
···
         public static void Set<T>(GlobalProperty property, T value)
             where T : struct
         {
-            lock (global_properties)
-                ((UniformMapping<T>)global_properties[(int)property]).UpdateValue(ref value);
+            ((UniformMapping<T>)global_properties[(int)property]).UpdateValue(ref value);
         }
 
         public static void Register(Shader shader)
         {
-            lock (global_properties)
+            // transfer all existing global properties across.
+            foreach (var global in global_properties)
             {
-                // transfer all existing global properties across.
-                foreach (var global in global_properties)
-                {
-                    if (!shader.Uniforms.TryGetValue(global.Name, out IUniform uniform))
-                        continue;
+                if (!shader.Uniforms.TryGetValue(global.Name, out IUniform uniform))
+                    continue;
 
-                    global.LinkShaderUniform(uniform);
-                }
+                global.LinkShaderUniform(uniform);
+            }
 
-                all_shaders.Add(shader);
-            }
+            all_shaders.Add(shader);
         }
 
         public static void Unregister(Shader shader)
         {
-            lock (global_properties)
+            if (!all_shaders.Remove(shader)) return;
+
+            foreach (var global in global_properties)
             {
-                if (!all_shaders.Remove(shader)) return;
+                if (!shader.Uniforms.TryGetValue(global.Name, out IUniform uniform))
+                    continue;
 
-                foreach (var global in global_properties)
-                {
-                    if (!shader.Uniforms.TryGetValue(global.Name, out IUniform uniform))
-                        continue;
-
-                    global.UnlinkShaderUniform(uniform);
-                }
+                global.UnlinkShaderUniform(uniform);
             }
         }
 
···
         /// </summary>
         /// <param name="name">The name to check</param>
         /// <returns>Whether a global exists.</returns>
-        public static bool CheckGlobalExists(string name)
-        {
-            lock (global_properties)
-            {
-                return global_properties.Any(m => m.Name == name);
-            }
-        }
+        public static bool CheckGlobalExists(string name) => global_properties.Any(m => m.Name == name);
     }
 }

osu.Framework/Graphics/Shaders/Shader.cs

···
                 return;
 
             programID = GL.CreateProgram();
+
             foreach (ShaderPart p in parts)
             {
                 if (!p.Compiled) p.Compile();
···
 
             Log.AppendLine(string.Format(ShaderPart.BOUNDARY, name));
             Log.AppendLine($"Linked: {linkResult == 1}");
+
             if (linkResult == 0)
             {
                 Log.AppendLine("Log:");
···
                     }
 
                     IUniform uniform;
+
                     switch (type)
                     {
                         case ActiveUniformType.Bool:
                             uniform = createUniform<bool>(uniformName);
                             break;
+
                         case ActiveUniformType.Float:
                             uniform = createUniform<float>(uniformName);
                             break;
+
                         case ActiveUniformType.Int:
                             uniform = createUniform<int>(uniformName);
                             break;
+
                         case ActiveUniformType.FloatMat3:
                             uniform = createUniform<Matrix3>(uniformName);
                             break;
+
                         case ActiveUniformType.FloatMat4:
                             uniform = createUniform<Matrix4>(uniformName);
                             break;
+
                         case ActiveUniformType.FloatVec2:
                             uniform = createUniform<Vector2>(uniformName);
                             break;
+
                         case ActiveUniformType.FloatVec3:
                             uniform = createUniform<Vector3>(uniformName);
                             break;
+
                         case ActiveUniformType.FloatVec4:
                             uniform = createUniform<Vector4>(uniformName);
                             break;
+
                         default:
                             continue;
                     }

osu.Framework/Graphics/Shaders/ShaderManager.cs

···
             {
                 case ShaderType.FragmentShader:
                     return @".fs";
+
                 case ShaderType.VertexShader:
                     return @".vs";
             }

osu.Framework/Graphics/Shaders/ShaderPart.cs

···
 
         internal ShaderType Type;
 
+        private bool isVertexShader => Type == ShaderType.VertexShader || Type == ShaderType.VertexShaderArb;
+
         private int partID = -1;
 
         private int lastShaderInputIndex;
···
 
             this.manager = manager;
 
-            shaderCodes.Add(loadFile(data));
+            shaderCodes.Add(loadFile(data, true));
             shaderCodes.RemoveAll(string.IsNullOrEmpty);
 
             if (shaderCodes.Count == 0)
···
             HasCode = true;
         }
 
-        private string loadFile(byte[] bytes)
+        private string loadFile(byte[] bytes, bool mainFile)
         {
             if (bytes == null)
                 return null;
···
                     }
 
                     Match includeMatch = includeRegex.Match(line);
+
                     if (includeMatch.Success)
                     {
                         string includeName = includeMatch.Groups[1].Value.Trim();
···
                         //                        if (File.Exists(includeName))
                         //                            rawData = File.ReadAllBytes(includeName);
                         //#endif
-                        code += loadFile(manager.LoadRaw(includeName)) + '\n';
+                        code += loadFile(manager.LoadRaw(includeName), false) + '\n';
                     }
                     else
                         code += line + '\n';
···
                     if (Type == ShaderType.VertexShader || Type == ShaderType.VertexShaderArb)
                     {
                         Match inputMatch = shaderInputRegex.Match(line);
+
                         if (inputMatch.Success)
                         {
                             ShaderInputs.Add(new ShaderInputInfo
···
                     }
                 }
 
+                if (mainFile && isVertexShader)
+                {
+                    string realMainName = "real_main_" + Guid.NewGuid().ToString("N");
+
+                    string backbufferCode = loadFile(manager.LoadRaw("sh_Backbuffer_Internal.h"), false);
+
+                    backbufferCode = backbufferCode.Replace("{{ real_main }}", realMainName);
+                    code = Regex.Replace(code, @"void main\((.*)\)", $"void {realMainName}()") + backbufferCode + '\n';
+                }
+
                 return code;
             }
         }
···
             string compileLog = GL.GetShaderInfoLog(this);
             Log.AppendLine(string.Format('\t' + BOUNDARY, Name));
             Log.AppendLine($"\tCompiled: {Compiled}");
+
             if (!Compiled)
             {
                 Log.AppendLine("\tLog:");

osu.Framework/Graphics/Shapes/Box.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using osu.Framework.Graphics.OpenGL;
+using osu.Framework.Graphics.OpenGL.Vertices;
+using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.Textures;
+using osuTK;
+using osuTK.Graphics.ES30;
 
 namespace osu.Framework.Graphics.Shapes
 {
···
     /// </summary>
     public class Box : Sprite
     {
+        /// <summary>
+        /// The screen space draw quad of this <see cref="Box"/> free from inflation due to edge smoothing.
+        /// </summary>
+        private Quad conservativeScreenSpaceDrawQuad;
+
         public Box()
         {
-            Texture = Texture.WhitePixel;
+            base.Texture = Texture.WhitePixel;
+        }
+
+        public override Texture Texture
+        {
+            get => base.Texture;
+            set => throw new InvalidOperationException($"The texture of a {nameof(Box)} cannot be set.");
+        }
+
+        protected override DrawNode CreateDrawNode() => new BoxDrawNode(this);
+
+        protected override Quad ComputeScreenSpaceDrawQuad()
+        {
+            conservativeScreenSpaceDrawQuad = ToScreenSpace(DrawRectangle);
+            return base.ComputeScreenSpaceDrawQuad();
+        }
+
+        protected class BoxDrawNode : SpriteDrawNode
+        {
+            protected new Box Source => (Box)base.Source;
+
+            private Quad conservativeScreenSpaceDrawQuad;
+            private bool hasOpaqueInterior;
+
+            public BoxDrawNode(Box source)
+                : base(source)
+            {
+            }
+
+            public override void ApplyState()
+            {
+                base.ApplyState();
+
+                conservativeScreenSpaceDrawQuad = Source.conservativeScreenSpaceDrawQuad;
+
+                hasOpaqueInterior = DrawColourInfo.Colour.MinAlpha == 1
+                                    && DrawColourInfo.Blending.Equals(new BlendingInfo(BlendingMode.Mixture))
+                                    && DrawColourInfo.Colour.HasSingleColour;
+            }
+
+            protected override void DrawOpaqueInterior(Action<TexturedVertex2D> vertexAction)
+            {
+                base.DrawOpaqueInterior(vertexAction);
+
+                TextureShader.Bind();
+                Texture.TextureGL.WrapMode = WrapTexture ? TextureWrapMode.Repeat : TextureWrapMode.ClampToEdge;
+
+                if (GLWrapper.IsMaskingActive)
+                    DrawClipped(ref conservativeScreenSpaceDrawQuad, Texture, DrawColourInfo.Colour, vertexAction: vertexAction);
+                else
+                {
+                    ReadOnlySpan<Vector2> vertices = conservativeScreenSpaceDrawQuad.GetVertices();
+
+                    for (int i = 2; i < vertices.Length; i++)
+                        DrawTriangle(Texture, new Primitives.Triangle(vertices[0], vertices[i - 1], vertices[i]), DrawColourInfo.Colour, vertexAction: vertexAction);
+                }
+
+                TextureShader.Unbind();
+            }
+
+            protected internal override bool CanDrawOpaqueInterior => Texture?.Available == true && hasOpaqueInterior;
         }
     }
 }

osu.Framework/Graphics/Shapes/Triangle.cs

···
 
         private class TriangleDrawNode : SpriteDrawNode
         {
-            protected new Triangle Source => (Triangle)base.Source;
-
             public TriangleDrawNode(Triangle source)
                 : base(source)
             {
···
 
             protected override void Blit(Action<TexturedVertex2D> vertexAction)
             {
-                Texture.DrawTriangle(toTriangle(ScreenSpaceDrawQuad), DrawColourInfo.Colour, null, null,
+                DrawTriangle(Texture, toTriangle(ScreenSpaceDrawQuad), DrawColourInfo.Colour, null, null,
                     new Vector2(InflationAmount.X / DrawRectangle.Width, InflationAmount.Y / DrawRectangle.Height));
             }
         }

osu.Framework/Graphics/Sprites/BufferedContainerView.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. 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.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL;
+using osu.Framework.Graphics.OpenGL.Vertices;
+using osu.Framework.Graphics.Primitives;
+using osu.Framework.Graphics.Shaders;
+
+namespace osu.Framework.Graphics.Sprites
+{
+    /// <summary>
+    /// A view that displays the contents of a <see cref="BufferedContainer{T}"/>.
+    /// </summary>
+    public class BufferedContainerView<T> : Drawable, ITexturedShaderDrawable
+        where T : Drawable
+    {
+        public IShader TextureShader { get; private set; }
+        public IShader RoundedTextureShader { get; private set; }
+
+        private BufferedContainer<T> container;
+        private BufferedDrawNodeSharedData sharedData;
+
+        internal BufferedContainerView(BufferedContainer<T> container, BufferedDrawNodeSharedData sharedData)
+        {
+            this.container = container;
+            this.sharedData = sharedData;
+
+            container.OnDispose += removeContainer;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(ShaderManager shaders)
+        {
+            TextureShader = shaders?.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE);
+            RoundedTextureShader = shaders?.Load(VertexShaderDescriptor.TEXTURE_2, FragmentShaderDescriptor.TEXTURE_ROUNDED);
+        }
+
+        protected override DrawNode CreateDrawNode() => new BufferSpriteDrawNode(this);
+
+        private bool synchronisedDrawQuad;
+
+        /// <summary>
+        /// Whether this <see cref="BufferedContainerView{T}"/> should be drawn using the original <see cref="BufferedContainer{T}"/>'s draw quad.
+        /// </summary>
+        /// <remarks>
+        /// This can be useful to display the <see cref="BufferedContainer{T}"/> as an overlay on top of itself.
+        /// </remarks>
+        public bool SynchronisedDrawQuad
+        {
+            get => synchronisedDrawQuad;
+            set
+            {
+                if (value == synchronisedDrawQuad)
+                    return;
+
+                synchronisedDrawQuad = value;
+
+                Invalidate(Invalidation.DrawNode);
+            }
+        }
+
+        private bool displayOriginalEffects;
+
+        /// <summary>
+        /// Whether the effects drawn by the <see cref="BufferedContainer{T}"/> should also be drawn for this view.
+        /// </summary>
+        public bool DisplayOriginalEffects
+        {
+            get => displayOriginalEffects;
+            set
+            {
+                if (displayOriginalEffects == value)
+                    return;
+
+                displayOriginalEffects = value;
+
+                Invalidate(Invalidation.DrawNode);
+            }
+        }
+
+        private void removeContainer()
+        {
+            if (container == null)
+                return;
+
+            container.OnDispose -= removeContainer;
+
+            container = null;
+            sharedData = null;
+
+            Invalidate(Invalidation.DrawNode);
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+
+            removeContainer();
+        }
+
+        private class BufferSpriteDrawNode : TexturedShaderDrawNode
+        {
+            protected new BufferedContainerView<T> Source => (BufferedContainerView<T>)base.Source;
+
+            private Quad screenSpaceDrawQuad;
+            private BufferedDrawNodeSharedData shared;
+            private bool displayOriginalEffects;
+
+            private bool sourceDrawsOriginal;
+            private ColourInfo sourceEffectColour;
+            private BlendingParameters sourceEffectBlending;
+            private EffectPlacement sourceEffectPlacement;
+
+            public BufferSpriteDrawNode(BufferedContainerView<T> source)
+                : base(source)
+            {
+            }
+
+            public override void ApplyState()
+            {
+                base.ApplyState();
+
+                screenSpaceDrawQuad = Source.synchronisedDrawQuad ? Source.container.ScreenSpaceDrawQuad : Source.ScreenSpaceDrawQuad;
+                shared = Source.sharedData;
+
+                displayOriginalEffects = Source.displayOriginalEffects;
+                sourceDrawsOriginal = Source.container.DrawOriginal;
+                sourceEffectColour = Source.container.EffectColour;
+                sourceEffectBlending = Source.container.DrawEffectBlending;
+                sourceEffectPlacement = Source.container.EffectPlacement;
+            }
+
+            public override void Draw(Action<TexturedVertex2D> vertexAction)
+            {
+                base.Draw(vertexAction);
+
+                if (shared?.MainBuffer?.Texture?.Available != true || shared.DrawVersion == -1)
+                    return;
+
+                Shader.Bind();
+
+                if (sourceEffectPlacement == EffectPlacement.InFront)
+                    drawMainBuffer(vertexAction);
+
+                drawEffectBuffer(vertexAction);
+
+                if (sourceEffectPlacement == EffectPlacement.Behind)
+                    drawMainBuffer(vertexAction);
+
+                Shader.Unbind();
+            }
+
+            private void drawMainBuffer(Action<TexturedVertex2D> vertexAction)
+            {
+                // If the original was drawn, draw it.
+                // Otherwise, if an effect will also not be drawn then we still need to display something - the original.
+                // Keep in mind that the effect MAY be the original itself, but is drawn through drawEffectBuffer().
+                if (!sourceDrawsOriginal && shouldDrawEffectBuffer)
+                    return;
+
+                GLWrapper.SetBlend(DrawColourInfo.Blending);
+                DrawFrameBuffer(shared.MainBuffer, screenSpaceDrawQuad, DrawColourInfo.Colour, vertexAction);
+            }
+
+            private void drawEffectBuffer(Action<TexturedVertex2D> vertexAction)
+            {
+                if (!shouldDrawEffectBuffer)
+                    return;
+
+                GLWrapper.SetBlend(new BlendingInfo(sourceEffectBlending));
+                ColourInfo finalEffectColour = DrawColourInfo.Colour;
+                finalEffectColour.ApplyChild(sourceEffectColour);
+
+                DrawFrameBuffer(shared.CurrentEffectBuffer, screenSpaceDrawQuad, DrawColourInfo.Colour, vertexAction);
+            }
+
+            /// <summary>
+            /// Whether the source's current effect buffer should be drawn.
+            /// This is true if we explicitly want to draw it or if no effects were drawn by the source. In the case that no effects were drawn by the source,
+            /// the current effect buffer will be the main buffer, and what will be drawn is the main buffer with the effect blending applied.
+            /// </summary>
+            private bool shouldDrawEffectBuffer => displayOriginalEffects || shared.CurrentEffectBuffer == shared.MainBuffer;
+        }
+    }
+}

osu.Framework/Graphics/Sprites/Sprite.cs

···
         /// of this sprite will be set to the size of the texture.
         /// <see cref="Drawable.FillAspectRatio"/> is automatically set to the aspect ratio of the given texture or 1 if the texture is null.
         /// </summary>
-        public Texture Texture
+        public virtual Texture Texture
         {
             get => texture;
             set

osu.Framework/Graphics/Sprites/SpriteDrawNode.cs

···
 
         protected virtual void Blit(Action<TexturedVertex2D> vertexAction)
         {
-            Texture.DrawQuad(ScreenSpaceDrawQuad, DrawColourInfo.Colour, null, vertexAction,
+            DrawQuad(Texture, ScreenSpaceDrawQuad, DrawColourInfo.Colour, null, vertexAction,
                 new Vector2(InflationAmount.X / DrawRectangle.Width, InflationAmount.Y / DrawRectangle.Height));
         }
 

osu.Framework/Graphics/Sprites/SpriteText.cs

···
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Caching;
+using osu.Framework.Development;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Shaders;
···
         /// </summary>
         private void computeCharacters()
         {
+            if (LoadState >= LoadState.Loaded)
+                ThreadSafety.EnsureUpdateThread();
+
             if (store == null)
                 return;
 

osu.Framework/Graphics/Sprites/SpriteText_DrawNode.cs

···
                         shadowQuad.BottomLeft += shadowOffset;
                         shadowQuad.BottomRight += shadowOffset;
 
-                        parts[i].Texture.DrawQuad(shadowQuad, finalShadowColour, vertexAction: vertexAction);
+                        DrawQuad(parts[i].Texture, shadowQuad, finalShadowColour, vertexAction: vertexAction);
                     }
 
-                    parts[i].Texture.DrawQuad(parts[i].DrawQuad, DrawColourInfo.Colour, vertexAction: vertexAction);
+                    DrawQuad(parts[i].Texture, parts[i].DrawQuad, DrawColourInfo.Colour, vertexAction: vertexAction);
                 }
 
                 Shader.Unbind();

osu.Framework/Graphics/TexturedShaderDrawNode.cs

···
 {
     public abstract class TexturedShaderDrawNode : DrawNode
     {
-        protected IShader Shader => RequiresRoundedShader ? roundedTextureShader : textureShader;
+        protected IShader Shader => RequiresRoundedShader ? RoundedTextureShader : TextureShader;
 
-        private IShader textureShader;
-        private IShader roundedTextureShader;
+        protected IShader TextureShader { get; private set; }
+        protected IShader RoundedTextureShader { get; private set; }
 
         protected new ITexturedShaderDrawable Source => (ITexturedShaderDrawable)base.Source;
 
···
         {
             base.ApplyState();
 
-            textureShader = Source.TextureShader;
-            roundedTextureShader = Source.RoundedTextureShader;
+            TextureShader = Source.TextureShader;
+            RoundedTextureShader = Source.RoundedTextureShader;
         }
 
         protected virtual bool RequiresRoundedShader => GLWrapper.IsMaskingActive;

osu.Framework/Graphics/Textures/PrefixTextureStore.cs

···
-// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using osu.Framework.IO.Stores;
-
-namespace osu.Framework.Graphics.Textures
-{
-    public class PrefixTextureStore : TextureStore
-    {
-        private readonly string prefix;
-
-        public PrefixTextureStore(string prefix, IResourceStore<TextureUpload> stores)
-            : base(stores)
-        {
-            this.prefix = prefix;
-        }
-
-        public override Texture Get(string name) => base.Get($@"{prefix}-{name}");
-    }
-}

osu.Framework/Graphics/Textures/Texture.cs

···
 
 using System;
 using System.IO;
+using osu.Framework.Graphics.Batches;
 using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Primitives;
 using osuTK;
···
 
         public RectangleF GetTextureRect(RectangleF? textureRect = null) => TextureGL.GetTextureRect(TextureBounds(textureRect));
 
-        public void DrawTriangle(Triangle vertexTriangle, ColourInfo colour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null, Vector2? inflationPercentage = null)
+        /// <summary>
+        /// Draws a triangle to the screen.
+        /// </summary>
+        /// <param name="vertexTriangle">The triangle to draw.</param>
+        /// <param name="drawColour">The vertex colour.</param>
+        /// <param name="textureRect">The texture rectangle.</param>
+        /// <param name="vertexAction">An action that adds vertices to a <see cref="VertexBatch{T}"/>.</param>
+        /// <param name="inflationPercentage">The percentage amount that <see cref="textureRect"/> should be inflated.</param>
+        internal void DrawTriangle(Triangle vertexTriangle, ColourInfo drawColour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null,
+                                   Vector2? inflationPercentage = null)
         {
             if (TextureGL == null || !TextureGL.Bind()) return;
 
-            TextureGL.DrawTriangle(vertexTriangle, TextureBounds(textureRect), colour, vertexAction, inflationPercentage);
+            TextureGL.DrawTriangle(vertexTriangle, drawColour, TextureBounds(textureRect), vertexAction, inflationPercentage);
         }
 
-        public void DrawQuad(Quad vertexQuad, ColourInfo colour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null, Vector2? inflationPercentage = null, Vector2? blendRangeOverride = null)
+        /// <summary>
+        /// Draws a quad to the screen.
+        /// </summary>
+        /// <param name="vertexQuad">The quad to draw.</param>
+        /// <param name="drawColour">The vertex colour.</param>
+        /// <param name="textureRect">The texture rectangle.</param>
+        /// <param name="vertexAction">An action that adds vertices to a <see cref="VertexBatch{T}"/>.</param>
+        /// <param name="inflationPercentage">The percentage amount that <see cref="textureRect"/> should be inflated.</param>
+        /// <param name="blendRangeOverride">The range over which the edges of the <see cref="textureRect"/> should be blended.</param>
+        internal void DrawQuad(Quad vertexQuad, ColourInfo drawColour, RectangleF? textureRect = null, Action<TexturedVertex2D> vertexAction = null, Vector2? inflationPercentage = null,
+                               Vector2? blendRangeOverride = null)
         {
             if (TextureGL == null || !TextureGL.Bind()) return;
 
-            TextureGL.DrawQuad(vertexQuad, TextureBounds(textureRect), colour, vertexAction, inflationPercentage, blendRangeOverride);
+            TextureGL.DrawQuad(vertexQuad, drawColour, TextureBounds(textureRect), vertexAction, inflationPercentage, blendRangeOverride);
         }
 
         public override string ToString() => $@"{AssetName} ({Width}, {Height})";

osu.Framework/Graphics/Textures/TextureAtlas.cs

···
             Vector2I res = new Vector2I(0, currentY);
 
             int maxY = currentY;
+
             foreach (RectangleI bounds in subTextureBounds)
             {
                 // +1 is required to prevent aliasing issues with sub-pixel positions while drawing. Bordering edged of other textures can show without it.

osu.Framework/Graphics/Textures/TextureLoaderStore.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Threading.Tasks;
 using osu.Framework.IO.Stores;
···
 
 namespace osu.Framework.Graphics.Textures
 {
-    public class TextureLoaderStore : ResourceStore<TextureUpload>
+    public class TextureLoaderStore : IResourceStore<TextureUpload>
     {
         private IResourceStore<byte[]> store { get; }
 
···
             (store as ResourceStore<byte[]>)?.AddExtension(@"jpg");
         }
 
-        public override Task<TextureUpload> GetAsync(string name) => Task.Run(() => Get(name));
+        public Task<TextureUpload> GetAsync(string name) => Task.Run(() => Get(name));
 
-        public override TextureUpload Get(string name)
+        public TextureUpload Get(string name)
         {
             try
             {
···
 
             return null;
         }
+
+        public Stream GetStream(string name) => store.GetStream(name);
 
         protected virtual Image<TPixel> ImageFromStream<TPixel>(Stream stream) where TPixel : struct, IPixel<TPixel>
             => Image.Load<TPixel>(stream);
+
+        public IEnumerable<string> GetAvailableResources() => store.GetAvailableResources();
+
+        #region IDisposable Support
+
+        private bool isDisposed;
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!isDisposed)
+            {
+                isDisposed = true;
+                store.Dispose();
+            }
+        }
+
+        ~TextureLoaderStore()
+        {
+            Dispose(false);
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        #endregion
     }
 }

osu.Framework/Graphics/Textures/TextureStore.cs

···
             }
         }
     }
-}
+}

osu.Framework/Graphics/TransformableExtensions.cs

···
             {
                 case Direction.Horizontal:
                     return drawable.MoveToX(destination, duration, easing);
+
                 case Direction.Vertical:
                     return drawable.MoveToY(destination, duration, easing);
             }

osu.Framework/Graphics/Transforms/TransformCustom.cs

···
         private static Accessor findAccessor(Type type, string propertyOrFieldName)
         {
             PropertyInfo property = type.GetProperty(propertyOrFieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+
             if (property != null)
             {
                 if (property.PropertyType != typeof(TValue))
···
             }
 
             FieldInfo field = type.GetField(propertyOrFieldName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
+
             if (field != null)
             {
                 if (field.FieldType != typeof(TValue))

osu.Framework/Graphics/Transforms/TransformSequence.cs

···
                 throw new InvalidOperationException($"Can not perform {nameof(Loop)} on an endless {nameof(TransformSequence<T>)}.");
 
             var iterDuration = endTime - startTime + pause;
+
             foreach (var t in transforms)
             {
                 Action tmpOnAbort = t.OnAbort;
···
                 // inserted in the correct order such that none of them trigger abortions on
                 // each other due to instant re-sorting upon adding.
                 double currentTransformTime = t.TargetTransformable.Time.Current;
+
                 while (t.EndTime <= currentTransformTime)
                 {
                     t.StartTime += iterDuration;

osu.Framework/Graphics/Transforms/Transformable.cs

···
                 return;
 
             Transform[] toAbort;
+
             if (targetMember == null)
             {
                 toAbort = transformsLazy.Value.Where(t => t.StartTime >= time).ToArray();
···
             for (int i = insertionIndex + 1; i < transforms.Count; ++i)
             {
                 var t = transforms[i];
+
                 if (t.TargetMember == transform.TargetMember)
                 {
                     transforms.RemoveAt(i--);

osu.Framework/Graphics/UserInterface/Button.cs

···
                     Background = new Box
                     {
                         RelativeSizeAxes = Axes.Both,
+                        Colour = Color4.DarkSlateGray,
                         Anchor = Anchor.Centre,
                         Origin = Anchor.Centre,
                     },

osu.Framework/Graphics/UserInterface/CircularProgressDrawNode.cs

···
                 // dir is used so negative angles result in negative angularOffset.
                 float angularOffset = dir * Math.Min(i * step, dir * angle);
                 float normalisedOffset = angularOffset / MathHelper.TwoPi;
+
                 if (dir < 0)
                 {
                     normalisedOffset += 1.0f;

osu.Framework/Graphics/UserInterface/Dropdown.cs

···
             {
                 case MenuItem i:
                     return i.Text.Value;
+
                 case IHasText t:
                     return t.Text;
+
                 case Enum e:
                     return e.GetDescription();
+
                 default:
                     return item?.ToString() ?? "null";
             }

osu.Framework/Graphics/UserInterface/Menu.cs

···
                 case Direction.Horizontal:
                     ItemsContainer.AutoSizeAxes = Axes.X;
                     break;
+
                 case Direction.Vertical:
                     ItemsContainer.AutoSizeAxes = Axes.Y;
                     break;
···
                 case MenuState.Closed:
                     AnimateClose();
                     break;
+
                 case MenuState.Open:
                     AnimateOpen();
                     if (!TopLevelMenu)
···
                 case MenuState.Closed:
                     selectedItem.State = MenuItemState.NotSelected;
                     break;
+
                 case MenuState.Open:
                     selectedItem.State = MenuItemState.Selected;
                     break;

osu.Framework/Graphics/UserInterface/SliderBar.cs

···
                     currentNumberInstantaneous.Add(step);
                     onUserChange(currentNumberInstantaneous.Value);
                     return true;
+
                 case Key.Left:
                     currentNumberInstantaneous.Add(-step);
                     onUserChange(currentNumberInstantaneous.Value);
                     return true;
+
                 default:
                     return false;
             }

osu.Framework/Graphics/UserInterface/TextBox.cs

···
             pos = Parent.ToSpaceOfOtherDrawable(pos, TextFlow);
 
             int i = 0;
+
             foreach (Drawable d in TextFlow.Children)
             {
                 if (d.DrawPosition.X + d.DrawSize.X / 2 > pos.X)
···
 
             if (oldStart != selectionStart || oldEnd != selectionEnd)
             {
-                audio.Sample.Get(@"Keyboard/key-movement")?.Play();
+                audio.Samples.Get(@"Keyboard/key-movement")?.Play();
                 cursorAndLayout.Invalidate();
             }
         }
···
             if (count == 0) return false;
 
             if (sound)
-                audio.Sample.Get(@"Keyboard/key-delete")?.Play();
+                audio.Samples.Get(@"Keyboard/key-delete")?.Play();
 
             foreach (var d in TextFlow.Children.Skip(start).Take(count).ToArray()) //ToArray since we are removing items from the children in this block.
             {
···
             foreach (char c in addText)
             {
                 var ch = addCharacter(c);
+
                 if (ch == null)
                 {
                     notifyInputError();
···
             if (!string.IsNullOrEmpty(pendingText) && !ReadOnly)
             {
                 if (pendingText.Any(char.IsUpper))
-                    audio.Sample.Get(@"Keyboard/key-caps")?.Play();
+                    audio.Samples.Get(@"Keyboard/key-caps")?.Play();
                 else
-                    audio.Sample.Get($@"Keyboard/key-press-{RNG.Next(1, 5)}")?.Play();
+                    audio.Samples.Get($@"Keyboard/key-press-{RNG.Next(1, 5)}")?.Play();
 
                 insertString(pendingText);
             }
···
                 case Key.Escape:
                     KillFocus();
                     return true;
+
                 case Key.KeypadEnter:
                 case Key.Enter:
                     Commit();
···
             Background.ClearTransforms();
             Background.FlashColour(BackgroundCommit, 400);
 
-            audio.Sample.Get(@"Keyboard/key-confirm")?.Play();
+            audio.Samples.Get(@"Keyboard/key-confirm")?.Play();
             OnCommit?.Invoke(this, true);
         }
 
···
             {
                 //in the case of backspacing (or a NOP), we can exit early here.
                 if (didDelete)
-                    audio.Sample.Get(@"Keyboard/key-delete")?.Play();
+                    audio.Samples.Get(@"Keyboard/key-delete")?.Play();
                 return;
             }
 
···
             for (int i = matchCount; i < s.Length; i++)
             {
                 Drawable dr = addCharacter(s[i]);
+
                 if (dr != null)
                 {
                     dr.Colour = Color4.Aqua;
···
                 }
             }
 
-            audio.Sample.Get($@"Keyboard/key-press-{RNG.Next(1, 5)}")?.Play();
+            audio.Samples.Get($@"Keyboard/key-press-{RNG.Next(1, 5)}")?.Play();
         }
 
         #endregion

osu.Framework/Graphics/Vector2Extensions.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Runtime.CompilerServices;
+using osu.Framework.Graphics.Primitives;
 using osuTK;
 
 namespace osu.Framework.Graphics
···
         {
             result = (vec2.X - vec1.X) * (vec2.X - vec1.X) + (vec2.Y - vec1.Y) * (vec2.Y - vec1.Y);
         }
+
+        /// <summary>
+        /// Retrieves the orientation of a set of vertices.
+        /// </summary>
+        /// <param name="vertices">The vertices.</param>
+        /// <returns>Twice the area enclosed by the vertices.
+        /// The vertices are clockwise-oriented if the value is positive.
+        /// The vertices are counter-clockwise-oriented if the value is negative.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float GetOrientation(in ReadOnlySpan<Vector2> vertices)
+        {
+            if (vertices.Length == 0)
+                return 0;
+
+            float rotation = 0;
+            for (int i = 0; i < vertices.Length - 1; ++i)
+                rotation += (vertices[i + 1].X - vertices[i].X) * (vertices[i + 1].Y + vertices[i].Y);
+
+            rotation += (vertices[0].X - vertices[vertices.Length - 1].X) * (vertices[0].Y + vertices[vertices.Length - 1].Y);
+
+            return rotation;
+        }
+
+        /// <summary>
+        /// Determines whether a point is within the right half-plane of a line.
+        /// </summary>
+        /// <param name="line">The line.</param>
+        /// <param name="point">The point.</param>
+        /// <returns>Whether <paramref name="point"/> is in the right half-plane of <paramref name="line"/>.
+        /// If the point is colinear to the line, it is said to be in the right half-plane of the line.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool InRightHalfPlaneOf(this Vector2 point, in Line line)
+            => (line.EndPoint.X - line.StartPoint.X) * (point.Y - line.StartPoint.Y)
+               - (line.EndPoint.Y - line.StartPoint.Y) * (point.X - line.StartPoint.X) <= 0;
     }
 }

osu.Framework/Graphics/Video/VideoDecoder.cs

···
                 case StdIo.SEEK_CUR:
                     videoStream.Seek(offset, SeekOrigin.Current);
                     break;
+
                 case StdIo.SEEK_END:
                     videoStream.Seek(offset, SeekOrigin.End);
                     break;
+
                 case StdIo.SEEK_SET:
                     videoStream.Seek(offset, SeekOrigin.Begin);
                     break;
+
                 case ffmpeg.AVSEEK_SIZE:
                     return videoStream.Length;
+
                 default:
                     return -1;
             }
···
                 throw new Exception("Could not find stream info.");
 
             var nStreams = formatContext->nb_streams;
+
             for (var i = 0; i < nStreams; ++i)
             {
                 stream = formatContext->streams[i];
 
                 codecParams = *stream->codecpar;
+
                 if (codecParams.codec_type == AVMediaType.AVMEDIA_TYPE_VIDEO)
                 {
                     timeBaseInSeconds = stream->time_base.GetValue();
···
                         if (readFrameResult >= 0)
                         {
                             state = DecoderState.Running;
+
                             if (packet->stream_index == stream->index)
                             {
                                 if (ffmpeg.avcodec_send_packet(stream->codec, packet) < 0)
                                     throw new Exception("Error sending packet.");
 
                                 var result = ffmpeg.avcodec_receive_frame(stream->codec, frame);
+
                                 if (result == 0)
                                 {
                                     var frameTime = (frame->best_effort_timestamp - stream->start_time) * timeBaseInSeconds * 1000;
+
                                     if (!skipOutputUntilTime.HasValue || skipOutputUntilTime.Value < frameTime)
                                     {
                                         skipOutputUntilTime = null;
 
                                         SwsContext* swsCtx = null;
+
                                         try
                                         {
                                             swsCtx = ffmpeg.sws_getContext(codecParams.width, codecParams.height, (AVPixelFormat)frame->format, codecParams.width, codecParams.height, AVPixelFormat.AV_PIX_FMT_RGBA, 0, null, null, null);

osu.Framework/Graphics/Video/VideoSprite.cs

···
                 startTime = Clock.CurrentTime;
 
             var nextFrame = availableFrames.Count > 0 ? availableFrames.Peek() : null;
+
             if (nextFrame != null)
             {
                 bool tooFarBehind = Math.Abs(PlaybackPosition - nextFrame.Time) > lenience_before_seek &&

osu.Framework/Graphics/Visualisation/DrawVisualiser.cs

···
                         Drawable lastHighlight = highlightedTarget?.Target;
 
                         var parent = Target?.Parent;
+
                         if (parent != null)
                         {
                             var lastVisualiser = targetVisualiser;
···
                         if (lastHighlight != null)
                         {
                             VisualisedDrawable visualised = targetVisualiser.FindVisualisedDrawable(lastHighlight);
+
                             if (visualised != null)
                             {
-                                propertyDisplay.State = Visibility.Visible;
+                                propertyDisplay.Show();
                                 setHighlight(visualised);
                             }
                         }
···
 
                         propertyDisplay.ToggleVisibility();
 
-                        if (propertyDisplay.State == Visibility.Visible)
+                        if (propertyDisplay.State.Value == Visibility.Visible)
                             setHighlight(targetVisualiser);
                     },
                 },
···
 
             propertyDisplay = treeContainer.PropertyDisplay;
 
-            propertyDisplay.StateChanged += visibility =>
+            propertyDisplay.State.ValueChanged += v =>
             {
-                switch (visibility)
+                switch (v.NewValue)
                 {
                     case Visibility.Hidden:
                         // Dehighlight everything automatically if property display is closed
···
 
             visualiser.HighlightTarget = d =>
             {
-                propertyDisplay.State = Visibility.Visible;
+                propertyDisplay.Show();
 
                 // Either highlight or dehighlight the target, depending on whether
                 // it is currently highlighted
···
             treeContainer.Remove(visualiser);
 
             if (Target == null)
-                propertyDisplay.State = Visibility.Hidden;
+                propertyDisplay.Hide();
         }
 
         private VisualisedDrawable targetVisualiser;
···
             }
 
             // Only update when property display is visible
-            if (propertyDisplay.State == Visibility.Visible)
+            if (propertyDisplay.State.Value == Visibility.Visible)
             {
                 highlightedTarget = newHighlight;
                 newHighlight.IsHighlighted = true;

osu.Framework/Graphics/Visualisation/LogOverlay.cs

···
         private void load(FrameworkConfigManager config)
         {
             enabled = config.GetBindable<bool>(FrameworkSetting.ShowLogOverlay);
-            enabled.ValueChanged += e => State = e.NewValue ? Visibility.Visible : Visibility.Hidden;
+            enabled.ValueChanged += e => State.Value = e.NewValue ? Visibility.Visible : Visibility.Hidden;
             enabled.TriggerChange();
         }
 
···
             {
                 case LoggingTarget.Runtime:
                     return Color4.YellowGreen;
+
                 case LoggingTarget.Network:
                     return Color4.BlueViolet;
+
                 case LoggingTarget.Performance:
                     return Color4.HotPink;
+
                 case LoggingTarget.Information:
                     return Color4.CadetBlue;
+
                 default:
                     return Color4.Cyan;
             }

osu.Framework/Graphics/Visualisation/PropertyDisplay.cs

···
             public PropertyItem(MemberInfo info, IDrawable d)
             {
                 Type type;
+
                 switch (info.MemberType)
                 {
                     case MemberTypes.Property:
···
             private void updateValue()
             {
                 object value;
+
                 try
                 {
                     value = getValue() ?? "<null>";

osu.Framework/Graphics/Visualisation/TreeContainer.cs

···
                     case TreeContainerStatus.Offscreen:
                         this.Delay(500).FadeTo(0.7f, 300);
                         break;
+
                     case TreeContainerStatus.Onscreen:
                         this.FadeIn(300, Easing.OutQuint);
                         break;
···
                 }
             });
 
-            PropertyDisplay.StateChanged += v => propertyButton.BackgroundColour = v == Visibility.Visible ? buttonBackgroundHighlighted : buttonBackground;
+            PropertyDisplay.State.ValueChanged += v => propertyButton.BackgroundColour = v.NewValue == Visibility.Visible ? buttonBackgroundHighlighted : buttonBackground;
         }
 
         protected override void Update()

osu.Framework/Graphics/Visualisation/VisualisedDrawable.cs

···
         private void updateSpecifics()
         {
             Vector2 posInTree = ToSpaceOfOtherDrawable(Vector2.Zero, tree);
+
             if (posInTree.Y < -previewBox.DrawHeight || posInTree.Y > tree.Height)
             {
                 text.Text = string.Empty;

osu.Framework/Host.cs

···
             {
                 case RuntimeInfo.Platform.MacOsx:
                     return new MacOSGameHost(gameName, bindIPC, toolkitOptions, portableInstallation);
+
                 case RuntimeInfo.Platform.Linux:
                     return new LinuxGameHost(gameName, bindIPC, toolkitOptions, portableInstallation);
+
                 case RuntimeInfo.Platform.Windows:
                     return new WindowsGameHost(gameName, bindIPC, toolkitOptions, portableInstallation);
+
                 default:
                     throw new InvalidOperationException($"Could not find a suitable host for the selected operating system ({Enum.GetName(typeof(RuntimeInfo.Platform), RuntimeInfo.OS)}).");
             }

osu.Framework/IO/AsyncBufferStream.cs

···
                 return;
 
             int last = -1;
+
             while (!isLoaded && !isClosed)
             {
                 cancellationToken.Token.ThrowIfCancellationRequested();
 
                 int curr = nextBlockToLoad;
+
                 if (curr < 0)
                 {
                     Thread.Sleep(1);
···
                 case SeekOrigin.Begin:
                     Position = offset;
                     break;
+
                 case SeekOrigin.Current:
                     Position += offset;
                     break;
+
                 case SeekOrigin.End:
                     Position = data.Length + offset;
                     break;

osu.Framework/IO/File/FileSafety.cs

···
             }
 
             string deathLocation = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+
             try
             {
                 System.IO.File.Move(filename, deathLocation);
···
             }
 
             bool didExist = Directory.Exists(newDirectory);
+
             if (!didExist)
             {
                 DirectoryInfo newDirectoryInfo = Directory.CreateDirectory(newDirectory);
+
                 try
                 {
                     if (new DirectoryInfo(oldDirectory).Attributes.HasFlag(FileAttributes.Hidden))
···
                 string newFile = Path.Combine(newDirectory, Path.GetFileName(file));
 
                 bool didMove = FileMove(file, newFile, didExist);
+
                 if (!didMove)
                 {
                     try
···
                 return string.Empty;
 
             char[] converted = new char[(encoded.Length + 1) / 2];
+
             fixed (byte* bytePtr = encoded)
             fixed (char* stringPtr = converted)
             {
                 byte* stringBytes = (byte*)stringPtr;
                 byte* stringEnd = (byte*)stringPtr + converted.Length * 2;
                 byte* bytePtr2 = bytePtr;
+
                 do
                 {
                     *stringBytes = *bytePtr2++;
···
         public static void CreateBackup(string filename)
         {
             string backupFilename = filename + @"." + DateTime.Now.Ticks + @".bak";
+
             if (System.IO.File.Exists(filename) && !System.IO.File.Exists(backupFilename))
             {
                 Debug.Print(@"Backup created: " + backupFilename);

osu.Framework/IO/Network/UrlEncoding.cs

···
         {
             int num = 0;
             int num2 = 0;
+
             for (int i = 0; i < count; i++)
             {
                 char ch = (char)bytes[offset + i];
+
                 if (paramEncode && ch == ' ')
                 {
                     num++;
···
 
             byte[] buffer = new byte[count + num2 * 2];
             int num4 = 0;
+
             for (int j = 0; j < count; j++)
             {
                 byte num6 = bytes[offset + j];
                 char ch2 = (char)num6;
+
                 if (IsSafe(ch2))
                 {
                     buffer[num4++] = num6;

osu.Framework/IO/Network/WebRequest.cs

···
         private async Task internalPerform()
         {
             var url = Url;
+
             if (!AllowInsecureRequests && !url.StartsWith(@"https://"))
             {
                 logger.Add($"Insecure request was automatically converted to https ({Url})");
···
                 {
                     // in the case we fail a request, spitting out the response in the log is quite helpful.
                     ResponseStream.Seek(0, SeekOrigin.Begin);
+
                     using (StreamReader r = new StreamReader(ResponseStream, new UTF8Encoding(false, true), true, 1024, true))
                     {
                         try

osu.Framework/IO/Stores/CachedResourceStore.cs

···
-// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace osu.Framework.IO.Stores
-{
-    public class CachedResourceStore<T> : ResourceStore<T>
-    {
-        private readonly Dictionary<string, T> cache = new Dictionary<string, T>();
-
-        /// <summary>
-        /// Initializes a resource store with no stores.
-        /// </summary>
-        public CachedResourceStore()
-        {
-        }
-
-        /// <summary>
-        /// Initializes a resource store with a single store.
-        /// </summary>
-        /// <param name="stores">A collection of stores to add.</param>
-        public CachedResourceStore(IResourceStore<T>[] stores)
-            : base(stores)
-        {
-        }
-
-        /// <summary>
-        /// Initializes a resource store with a collection of stores.
-        /// </summary>
-        /// <param name="store">The store.</param>
-        public CachedResourceStore(IResourceStore<T> store)
-            : base(store)
-        {
-        }
-
-        /// <summary>
-        /// Notifies a bound delegate that the resource has changed.
-        /// </summary>
-        /// <param name="name">The resource that has changed.</param>
-        protected override void NotifyChanged(string name)
-        {
-            cache.Remove(name);
-            base.NotifyChanged(name);
-        }
-
-        /// <summary>
-        /// Adds a resource store to this store.
-        /// </summary>
-        /// <param name="store">The store to add.</param>
-        public override void AddStore(IResourceStore<T> store)
-        {
-            base.AddStore(store);
-
-            if (store is ChangeableResourceStore<T> crm)
-                crm.OnChanged += NotifyChanged;
-        }
-
-        /// <summary>
-        /// Removes a store from this store.
-        /// </summary>
-        /// <param name="store">The store to remove.</param>
-        public override void RemoveStore(IResourceStore<T> store)
-        {
-            base.RemoveStore(store);
-
-            if (store is ChangeableResourceStore<T> crm)
-                crm.OnChanged -= NotifyChanged;
-        }
-
-        /// <summary>
-        /// Retrieves an object from the store.
-        /// </summary>
-        /// <param name="name">The name of the object.</param>
-        /// <returns>The object.</returns>
-        public override async Task<T> GetAsync(string name)
-        {
-            if (cache.TryGetValue(name, out T result))
-                return result;
-
-            result = await base.GetAsync(name);
-
-            if (result != null)
-                cache[name] = result;
-
-            return result;
-        }
-
-        /// <summary>
-        /// Releases a resource from the cache.
-        /// </summary>
-        /// <param name="name">The resource to release.</param>
-        public void Release(string name)
-        {
-            cache.Remove(name);
-        }
-
-        /// <summary>
-        /// Releases all resources stored in the cache.
-        /// </summary>
-        public void ResetCache()
-        {
-            cache.Clear();
-        }
-
-        protected override void Dispose(bool disposing)
-        {
-            base.Dispose(disposing);
-            ResetCache();
-        }
-    }
-}

osu.Framework/IO/Stores/ChangeableResourceStore.cs

···
-// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System;
-
-namespace osu.Framework.IO.Stores
-{
-    public class ChangeableResourceStore<T> : ResourceStore<T>
-    {
-        public event Action<string> OnChanged;
-
-        protected void TriggerOnChanged(string name)
-        {
-            OnChanged?.Invoke(name);
-        }
-    }
-}

osu.Framework/IO/Stores/DllResourceStore.cs

···
         /// <summary>
         /// Retrieve a list of available resources provided by this store.
         /// </summary>
-        public IEnumerable<string> AvailableResources =>
+        public IEnumerable<string> GetAvailableResources() =>
             assembly.GetManifestResourceNames().Select(n =>
             {
-                var chars = n.ToCharArray();
+                n = n.Substring(n.StartsWith(prefix) ? prefix.Length + 1 : 0);
 
-                int startIndex = n.StartsWith(prefix) ? prefix.Length + 1 : 0;
                 int lastDot = n.LastIndexOf('.');
 
-                for (int i = startIndex; i < lastDot; i++)
+                var chars = n.ToCharArray();
+
+                for (int i = 0; i < lastDot; i++)
                     if (chars[i] == '.')
                         chars[i] = '/';
 

osu.Framework/IO/Stores/FileSystemResourceStore.cs

···
-// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
-// See the LICENCE file in the repository root for full licence text.
-
-using System.IO;
-using System.Threading.Tasks;
-
-namespace osu.Framework.IO.Stores
-{
-    public class FileSystemResourceStore : ChangeableResourceStore<byte[]>
-    {
-        private readonly FileSystemWatcher watcher;
-        private readonly string directory;
-
-        private bool isDisposed;
-
-        public FileSystemResourceStore(string directory)
-        {
-            this.directory = directory;
-
-            watcher = new FileSystemWatcher(directory)
-            {
-                EnableRaisingEvents = true
-            };
-            watcher.Renamed += watcherChanged;
-            watcher.Changed += watcherChanged;
-            watcher.Created += watcherChanged;
-        }
-
-        #region Disposal
-
-        ~FileSystemResourceStore()
-        {
-            Dispose(false);
-        }
-
-        protected override void Dispose(bool disposing)
-        {
-            if (isDisposed)
-                return;
-
-            isDisposed = true;
-
-            watcher.Dispose();
-        }
-
-        #endregion
-
-        private void watcherChanged(object sender, FileSystemEventArgs e)
-        {
-            TriggerOnChanged(e.FullPath.Replace(directory, string.Empty));
-        }
-
-        public override async Task<byte[]> GetAsync(string name)
-        {
-            byte[] result;
-
-            using (FileStream stream = System.IO.File.OpenRead(Path.Combine(directory, name)))
-            {
-                result = new byte[stream.Length];
-                await stream.ReadAsync(result, 0, (int)stream.Length);
-            }
-
-            return result;
-        }
-    }
-}

osu.Framework/IO/Stores/FontStore.cs

···
                 case FontStore fs:
                     nestedFontStores.Add(fs);
                     return;
+
                 case GlyphStore gs:
                     glyphStores.Add(gs);
                     queueLoad(gs);
···
                 case FontStore fs:
                     nestedFontStores.Remove(fs);
                     return;
+
                 case GlyphStore gs:
                     glyphStores.Remove(gs);
                     break;

osu.Framework/IO/Stores/GlyphStore.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
···
         }
 
         public Stream GetStream(string name) => throw new NotSupportedException();
+
+        public IEnumerable<string> GetAvailableResources() => Font.Characters.Keys.Select(k => $"{FontName}/{(char)k}");
 
         private int loadedPageCount;
         private int loadedGlyphCount;

osu.Framework/IO/Stores/IResourceStore.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Threading.Tasks;
 
···
         Task<T> GetAsync(string name);
 
         Stream GetStream(string name);
+
+        /// <summary>
+        /// Gets a collection of string representations of the resources available in this store.
+        /// </summary>
+        /// <returns>String representations of the resources available.</returns>
+        IEnumerable<string> GetAvailableResources();
     }
 }

osu.Framework/IO/Stores/NamespacedResourceStore.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Generic;
+using System.Linq;
 
 namespace osu.Framework.IO.Stores
 {
···
         }
 
         protected override IEnumerable<string> GetFilenames(string name) => base.GetFilenames($@"{Namespace}/{name}");
+
+        public override IEnumerable<string> GetAvailableResources() => base.GetAvailableResources()
+                                                                           .Where(x => x.StartsWith($"{Namespace}/"))
+                                                                           .Select(x => x.Remove(0, $"{Namespace}/".Length));
     }
 }

osu.Framework/IO/Stores/OnlineStore.cs

···
-// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
 using WebRequest = osu.Framework.IO.Network.WebRequest;
 
···
 
             return new MemoryStream(ret);
         }
+
+        public IEnumerable<string> GetAvailableResources() => Enumerable.Empty<string>();
 
         #region IDisposable Support
 

osu.Framework/IO/Stores/ResourceStore.cs

···
                 searchExtensions.Add(extension);
         }
 
+        public virtual IEnumerable<string> GetAvailableResources()
+        {
+            lock (stores) return stores.SelectMany(s => s.GetAvailableResources());
+        }
+
         #region IDisposable Support
 
         private bool isDisposed;

osu.Framework/IO/Stores/StorageBackedResourceStore.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
 using osu.Framework.Platform;
 
···
         }
 
         public Stream GetStream(string name) => storage.GetStream(name);
+
+        public IEnumerable<string> GetAvailableResources() =>
+            storage.GetDirectories(string.Empty).SelectMany(storage.GetFiles);
 
         #region IDisposable Support
 

osu.Framework/Input/Bindings/KeyBindingContainer.cs

···
         protected override bool Handle(UIEvent e)
         {
             var state = e.CurrentState;
+
             switch (e)
             {
                 case MouseDownEvent mouseDown:

osu.Framework/Input/Bindings/KeyCombination.cs

···
             {
                 case InputKey.None:
                     return string.Empty;
+
                 case InputKey.Shift:
                     return "Shift";
+
                 case InputKey.Control:
                     return "Ctrl";
+
                 case InputKey.Alt:
                     return "Alt";
+
                 case InputKey.Super:
                     return "Win";
+
                 case InputKey.Escape:
                     return "Esc";
+
                 case InputKey.BackSpace:
                     return "Backsp";
+
                 case InputKey.Insert:
                     return "Ins";
+
                 case InputKey.Delete:
                     return "Del";
+
                 case InputKey.PageUp:
                     return "Pgup";
+
                 case InputKey.PageDown:
                     return "Pgdn";
+
                 case InputKey.CapsLock:
                     return "Caps";
+
                 case InputKey.Number0:
                 case InputKey.Keypad0:
                     return "0";
+
                 case InputKey.Number1:
                 case InputKey.Keypad1:
                     return "1";
+
                 case InputKey.Number2:
                 case InputKey.Keypad2:
                     return "2";
+
                 case InputKey.Number3:
                 case InputKey.Keypad3:
                     return "3";
+
                 case InputKey.Number4:
                 case InputKey.Keypad4:
                     return "4";
+
                 case InputKey.Number5:
                 case InputKey.Keypad5:
                     return "5";
+
                 case InputKey.Number6:
                 case InputKey.Keypad6:
                     return "6";
+
                 case InputKey.Number7:
                 case InputKey.Keypad7:
                     return "7";
+
                 case InputKey.Number8:
                 case InputKey.Keypad8:
                     return "8";
+
                 case InputKey.Number9:
                 case InputKey.Keypad9:
                     return "9";
+
                 case InputKey.Tilde:
                     return "~";
+
                 case InputKey.Minus:
                     return "-";
+
                 case InputKey.Plus:
                     return "+";
+
                 case InputKey.BracketLeft:
                     return "(";
+
                 case InputKey.BracketRight:
                     return ")";
+
                 case InputKey.Semicolon:
                     return ";";
+
                 case InputKey.Quote:
                     return "\"";
+
                 case InputKey.Comma:
                     return ",";
+
                 case InputKey.Period:
                     return ".";
+
                 case InputKey.Slash:
                     return "/";
+
                 case InputKey.BackSlash:
                 case InputKey.NonUSBackSlash:
                     return "\\";
+
                 case InputKey.MouseLeft:
                     return "M1";
+
                 case InputKey.MouseMiddle:
                     return "M3";
+
                 case InputKey.MouseRight:
                     return "M2";
+
                 case InputKey.MouseButton1:
                     return "M4";
+
                 case InputKey.MouseButton2:
                     return "M5";
+
                 case InputKey.MouseButton3:
                     return "M6";
+
                 case InputKey.MouseButton4:
                     return "M7";
+
                 case InputKey.MouseButton5:
                     return "M8";
+
                 case InputKey.MouseButton6:
                     return "M9";
+
                 case InputKey.MouseButton7:
                     return "M10";
+
                 case InputKey.MouseButton8:
                     return "M11";
+
                 case InputKey.MouseButton9:
                     return "M12";
+
                 case InputKey.MouseWheelDown:
                     return "Wheel Down";
+
                 case InputKey.MouseWheelUp:
                     return "Wheel Up";
+
                 default:
                     return key.ToString();
             }
···
             {
                 case Key.RShift:
                     return InputKey.Shift;
+
                 case Key.RAlt:
                     return InputKey.Alt;
+
                 case Key.RControl:
                     return InputKey.Control;
+
                 case Key.RWin:
                     return InputKey.Super;
             }
···
                             if (!keys.Contains(iKey))
                                 keys.Add(iKey);
                             break;
+
                         default:
                             keys.Add(iKey);
                             break;

osu.Framework/Input/CustomInputManager.cs

···
             if (!handler.Initialize(Host)) return;
 
             int index = inputHandlers.BinarySearch(handler, new InputHandlerComparer());
+
             if (index < 0)
             {
                 index = ~index;

osu.Framework/Input/GameWindowTextInput.cs

···
 {
     public class GameWindowTextInput : ITextInputSource
     {
-        private readonly GameWindow window;
+        private readonly IWindow window;
 
         private string pending = string.Empty;
 
-        public GameWindowTextInput(GameWindow window)
+        public GameWindowTextInput(IWindow window)
         {
             this.window = window;
         }

osu.Framework/Input/Handlers/Joystick/OsuTKJoystickHandler.cs

···
             for (int index = 0; index < rawStates.Count; index++)
             {
                 var rawState = rawStates[index];
+
                 if (index < devices.Count)
                 {
                     devices[index].UpdateRawState(rawState);

osu.Framework/Input/Handlers/Mouse/OsuTKMouseHandlerBase.cs

···
             else
             {
                 var delta = state.Position - lastState.Position;
+
                 if (delta != Vector2.Zero)
                 {
                     PendingInputs.Enqueue(new MousePositionRelativeInput { Delta = delta });
···
             if (lastState != null && state.WasActive)
             {
                 var scrollDelta = state.Scroll - lastState.Scroll;
+
                 if (scrollDelta != Vector2.Zero)
                 {
                     PendingInputs.Enqueue(new MouseScrollRelativeInput { Delta = scrollDelta, IsPrecise = state.HasPreciseScroll });

osu.Framework/Input/InputManager.cs

···
             {
                 case MouseButton.Left:
                     return new MouseLeftButtonEventManager(button);
+
                 default:
                     return new MouseMinorButtonEventManager(button);
             }
···
             if (!(keyboardRepeatKey is Key key)) return;
 
             keyboardRepeatTime -= Time.Elapsed;
+
             while (keyboardRepeatTime < 0)
             {
                 handleKeyDown(state, key, true);
···
                     }
 
                     d.IsHovered = true;
+
                     if (d.TriggerEvent(new HoverEvent(state)))
                     {
                         hoverHandledDrawable = d;
···
                 case MousePositionChangeEvent mousePositionChange:
                     HandleMousePositionChange(mousePositionChange);
                     return;
+
                 case MouseScrollChangeEvent mouseScrollChange:
                     HandleMouseScrollChange(mouseScrollChange);
                     return;
+
                 case ButtonStateChangeEvent<MouseButton> mouseButtonStateChange:
                     HandleMouseButtonStateChange(mouseButtonStateChange);
                     return;
+
                 case ButtonStateChangeEvent<Key> keyboardKeyStateChange:
                     HandleKeyboardKeyStateChange(keyboardKeyStateChange);
                     return;
+
                 case ButtonStateChangeEvent<JoystickButton> joystickButtonStateChange:
                     HandleJoystickButtonStateChange(joystickButtonStateChange);
                     return;
···
             {
                 //ensure we are visible
                 CompositeDrawable d = FocusedDrawable.Parent;
+
                 while (d != null)
                 {
                     if (!d.IsPresent || !d.IsAlive)

osu.Framework/Input/MouseButtonEventManager.cs

···
 
             // only drawables up to the one that handled mouse down should handle mouse up
             MouseDownInputQueue = positionalInputQueue;
+
             if (handledBy != null)
             {
                 var count = MouseDownInputQueue.IndexOf(handledBy) + 1;

osu.Framework/Input/StateChanges/ButtonInput.cs

···
         public void Apply(InputState state, IInputStateChangeHandler handler)
         {
             var buttonStates = GetButtonStates(state);
+
             foreach (var entry in Entries)
             {
                 if (buttonStates.SetPressed(entry.Button, entry.IsPressed))

osu.Framework/Input/StateChanges/MousePositionAbsoluteInput.cs

···
         public void Apply(InputState state, IInputStateChangeHandler handler)
         {
             var mouse = state.Mouse;
+
             if (!mouse.IsPositionValid || mouse.Position != Position)
             {
                 var lastPosition = mouse.IsPositionValid ? mouse.Position : Position;

osu.Framework/Input/StateChanges/MousePositionRelativeInput.cs

···
         public void Apply(InputState state, IInputStateChangeHandler handler)
         {
             var mouse = state.Mouse;
+
             if (mouse.IsPositionValid && Delta != Vector2.Zero)
             {
                 var lastPosition = mouse.Position;

osu.Framework/Input/StateChanges/MouseScrollRelativeInput.cs

···
         public void Apply(InputState state, IInputStateChangeHandler handler)
         {
             var mouse = state.Mouse;
+
             if (Delta != Vector2.Zero)
             {
                 var lastScroll = mouse.Scroll;

osu.Framework/Logging/Logger.cs

···
             lock (static_sync_lock)
             {
                 var nameLower = name.ToLower();
+
                 if (!static_loggers.TryGetValue(nameLower, out Logger l))
                 {
                     static_loggers[nameLower] = l = Enum.TryParse(name, true, out LoggingTarget target) ? new Logger(target) : new Logger(name);

osu.Framework/MathUtils/Clipping/ConvexPolygonClipper.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Runtime.CompilerServices;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Primitives;
+using osuTK;
+
+namespace osu.Framework.MathUtils.Clipping
+{
+    public readonly ref struct ConvexPolygonClipper<TClip, TSubject>
+        where TClip : IConvexPolygon
+        where TSubject : IConvexPolygon
+    {
+        private readonly TClip clipPolygon;
+        private readonly TSubject subjectPolygon;
+
+        public ConvexPolygonClipper(ref TClip clipPolygon, ref TSubject subjectPolygon)
+        {
+            this.clipPolygon = clipPolygon;
+            this.subjectPolygon = subjectPolygon;
+        }
+
+        /// <summary>
+        /// Determines the minimum buffer size required to clip the two polygons.
+        /// </summary>
+        /// <returns>The minimum buffer size required for <see cref="clipPolygon"/> to clip <see cref="subjectPolygon"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int GetClipBufferSize()
+        {
+            // There can only be at most two intersections for each of the subject's vertices
+            return subjectPolygon.GetVertices().Length * 2;
+        }
+
+        /// <summary>
+        /// Clips <see cref="subjectPolygon"/> by <see cref="clipPolygon"/>.
+        /// </summary>
+        /// <returns>A clockwise-ordered set of vertices representing the result of clipping <see cref="subjectPolygon"/> by <see cref="clipPolygon"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Span<Vector2> Clip() => Clip(new Vector2[GetClipBufferSize()]);
+
+        /// <summary>
+        /// Clips <see cref="subjectPolygon"/> by <see cref="clipPolygon"/> using an intermediate buffer.
+        /// </summary>
+        /// <param name="buffer">The buffer to contain the clipped vertices. Must have a length of <see cref="GetClipBufferSize"/>.</param>
+        /// <returns>A clockwise-ordered set of vertices representing the result of clipping <see cref="subjectPolygon"/> by <see cref="clipPolygon"/>.</returns>
+        public Span<Vector2> Clip(in Span<Vector2> buffer)
+        {
+            if (buffer.Length < GetClipBufferSize())
+            {
+                throw new ArgumentException($"Clip buffer must have a length of {GetClipBufferSize()}, but was {buffer.Length}."
+                                            + "Use GetClipBufferSize() to calculate the size of the buffer.", nameof(buffer));
+            }
+
+            ReadOnlySpan<Vector2> origSubjectVertices = subjectPolygon.GetVertices();
+            if (origSubjectVertices.Length == 0)
+                return Span<Vector2>.Empty;
+
+            ReadOnlySpan<Vector2> origClipVertices = clipPolygon.GetVertices();
+            if (origClipVertices.Length == 0)
+                return Span<Vector2>.Empty;
+
+            // Add the subject vertices to the buffer and immediately normalise them
+            Span<Vector2> subjectVertices = getNormalised(origSubjectVertices, buffer.Slice(0, origSubjectVertices.Length), true);
+
+            // Since the clip vertices aren't modified, we can use them as they are if they are normalised
+            // However if they are not normalised, then we must add them to the buffer and normalise them there
+            bool clipNormalised = Vector2Extensions.GetOrientation(origClipVertices) >= 0;
+            Span<Vector2> clipBuffer = clipNormalised ? null : stackalloc Vector2[origClipVertices.Length];
+            ReadOnlySpan<Vector2> clipVertices = clipNormalised
+                ? origClipVertices
+                : getNormalised(origClipVertices, clipBuffer, false);
+
+            // Number of vertices in the buffer that need to be tested against
+            // This becomes the number of vertices in the resulting polygon after each clipping iteration
+            int inputCount = subjectVertices.Length;
+
+            // Process the clip edge connecting the last vertex to the first vertex
+            inputCount = processClipEdge(new Line(clipVertices[clipVertices.Length - 1], clipVertices[0]), buffer, inputCount);
+
+            // Process all other edges
+            for (int c = 1; c < clipVertices.Length; c++)
+            {
+                if (inputCount == 0)
+                    break;
+
+                inputCount = processClipEdge(new Line(clipVertices[c - 1], clipVertices[c]), buffer, inputCount);
+            }
+
+            return buffer.Slice(0, inputCount);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private int processClipEdge(in Line clipEdge, in Span<Vector2> buffer, in int inputCount)
+        {
+            // Temporary storage for the vertices from the buffer as the buffer gets altered
+            Span<Vector2> inputVertices = stackalloc Vector2[buffer.Length];
+
+            // Store the original vertices (buffer will get altered)
+            buffer.CopyTo(inputVertices);
+
+            int outputCount = 0;
+
+            // Process the edge connecting the last vertex with the first vertex
+            outputVertices(ref inputVertices[inputCount - 1], ref inputVertices[0], clipEdge, buffer, ref outputCount);
+
+            // Process all other vertices
+            for (int i = 1; i < inputCount; i++)
+                outputVertices(ref inputVertices[i - 1], ref inputVertices[i], clipEdge, buffer, ref outputCount);
+
+            return outputCount;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void outputVertices(ref Vector2 startVertex, ref Vector2 endVertex, in Line clipEdge, in Span<Vector2> buffer, ref int bufferIndex)
+        {
+            if (endVertex.InRightHalfPlaneOf(clipEdge))
+            {
+                if (!startVertex.InRightHalfPlaneOf(clipEdge))
+                {
+                    clipEdge.TryIntersectWith(ref startVertex, ref endVertex, out var t);
+                    buffer[bufferIndex++] = clipEdge.At(t);
+                }
+
+                buffer[bufferIndex++] = endVertex;
+            }
+            else if (startVertex.InRightHalfPlaneOf(clipEdge))
+            {
+                clipEdge.TryIntersectWith(ref startVertex, ref endVertex, out var t);
+                buffer[bufferIndex++] = clipEdge.At(t);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private Span<Vector2> getNormalised(in ReadOnlySpan<Vector2> original, in Span<Vector2> bufferSlice, bool verify)
+        {
+            original.CopyTo(bufferSlice);
+
+            if (!verify || Vector2Extensions.GetOrientation(original) < 0)
+                bufferSlice.Reverse();
+
+            return bufferSlice;
+        }
+    }
+}

osu.Framework/MathUtils/Interpolation.cs

···
         {
             int n = points.Length;
             double[] w = new double[n];
+
             for (int i = 0; i < n; i++)
             {
                 w[i] = 1;
···
                 case Easing.In:
                 case Easing.InQuad:
                     return time * time;
+
                 case Easing.Out:
                 case Easing.OutQuad:
                     return time * (2 - time);
+
                 case Easing.InOutQuad:
                     if (time < .5) return time * time * 2;
 
···
 
                 case Easing.InCubic:
                     return time * time * time;
+
                 case Easing.OutCubic:
                     return --time * time * time + 1;
+
                 case Easing.InOutCubic:
                     if (time < .5) return time * time * time * 4;
 
···
 
                 case Easing.InQuart:
                     return time * time * time * time;
+
                 case Easing.OutQuart:
                     return 1 - --time * time * time * time;
+
                 case Easing.InOutQuart:
                     if (time < .5) return time * time * time * time * 8;
 
···
 
                 case Easing.InQuint:
                     return time * time * time * time * time;
+
                 case Easing.OutQuint:
                     return --time * time * time * time * time + 1;
+
                 case Easing.InOutQuint:
                     if (time < .5) return time * time * time * time * time * 16;
 
···
 
                 case Easing.InSine:
                     return 1 - Math.Cos(time * Math.PI * .5);
+
                 case Easing.OutSine:
                     return Math.Sin(time * Math.PI * .5);
+
                 case Easing.InOutSine:
                     return .5 - .5 * Math.Cos(Math.PI * time);
 
                 case Easing.InExpo:
                     return Math.Pow(2, 10 * (time - 1));
+
                 case Easing.OutExpo:
                     return -Math.Pow(2, -10 * time) + 1;
+
                 case Easing.InOutExpo:
                     if (time < .5) return .5 * Math.Pow(2, 20 * time - 10);
 
···
 
                 case Easing.InCirc:
                     return 1 - Math.Sqrt(1 - time * time);
+
                 case Easing.OutCirc:
                     return Math.Sqrt(1 - --time * time);
+
                 case Easing.InOutCirc:
                     if ((time *= 2) < 1) return .5 - .5 * Math.Sqrt(1 - time * time);
 
···
 
                 case Easing.InElastic:
                     return -Math.Pow(2, -10 + 10 * time) * Math.Sin((1 - elastic_const2 - time) * elastic_const);
+
                 case Easing.OutElastic:
                     return Math.Pow(2, -10 * time) * Math.Sin((time - elastic_const2) * elastic_const) + 1;
+
                 case Easing.OutElasticHalf:
                     return Math.Pow(2, -10 * time) * Math.Sin((.5 * time - elastic_const2) * elastic_const) + 1;
+
                 case Easing.OutElasticQuarter:
                     return Math.Pow(2, -10 * time) * Math.Sin((.25 * time - elastic_const2) * elastic_const) + 1;
+
                 case Easing.InOutElastic:
                     if ((time *= 2) < 1)
                         return -.5 * Math.Pow(2, -10 + 10 * time) * Math.Sin((1 - elastic_const2 * 1.5 - time) * elastic_const / 1.5);
···
 
                 case Easing.InBack:
                     return time * time * ((back_const + 1) * time - back_const);
+
                 case Easing.OutBack:
                     return --time * time * ((back_const + 1) * time + back_const) + 1;
+
                 case Easing.InOutBack:
                     if ((time *= 2) < 1) return .5 * time * time * ((back_const2 + 1) * time - back_const2);
 
···
                         return 1 - (7.5625 * (time -= 2.25 * bounce_const) * time + .9375);
 
                     return 1 - (7.5625 * (time -= 2.625 * bounce_const) * time + .984375);
+
                 case Easing.OutBounce:
                     if (time < bounce_const)
                         return 7.5625 * time * time;
···
                         return 7.5625 * (time -= 2.25 * bounce_const) * time + .9375;
 
                     return 7.5625 * (time -= 2.625 * bounce_const) * time + .984375;
+
                 case Easing.InOutBounce:
                     if (time < .5) return .5 - .5 * ApplyEasing(Easing.OutBounce, 1 - time * 2);
 

osu.Framework/MathUtils/PathApproximator.cs

···
             while (toFlatten.Count > 0)
             {
                 Vector2[] parent = toFlatten.Pop();
+
                 if (bezierIsFlatEnough(parent))
                 {
                     // If the control points we currently operate on are sufficiently "flat", we use
···
             // AC B lies.
             Vector2 orthoAtoC = c - a;
             orthoAtoC = new Vector2(orthoAtoC.Y, -orthoAtoC.X);
+
             if (Vector2.Dot(orthoAtoC, b - a) < 0)
             {
                 dir = -dir;
···
 
             float minX = controlPoints[0].X;
             float maxX = controlPoints[0].X;
+
             for (int i = 1; i < controlPoints.Length; i++)
             {
                 minX = Math.Min(minX, controlPoints[i].X);
···
                 l[count + i] = r[i + 1];
 
             output.Add(controlPoints[0]);
+
             for (int i = 1; i < count - 1; ++i)
             {
                 int index = 2 * i;

osu.Framework/Physics/RigidBodyContainer.cs

···
                 float usableLength = Math.Max(length - 2 * cornerRadius, 0);
 
                 Vector2 normal = (b - a).PerpendicularRight.Normalized();
+
                 for (int j = 0; j < amount_side_steps; ++j)
                 {
                     Vertices.Add(a + dir * (cornerRadius + j * usableLength / (amount_side_steps - 1)));
···
             }
 
             const int amount_corner_steps = 10;
+
             if (cornerRadius > 0)
             {
                 // Rounded corners
···
                 return false;
 
             bool didCollide = false;
+
             for (int i = 0; i < Vertices.Count; ++i)
             {
                 if (other.BodyContains(Vector2Extensions.Transform(Vertices[i], SimulationToScreenSpace)))

osu.Framework/Platform/DesktopGameWindow.cs

···
                 case Input.ConfineMouseMode.Fullscreen:
                     confine = WindowMode.Value != Configuration.WindowMode.Windowed;
                     break;
+
                 case Input.ConfineMouseMode.Always:
                     confine = true;
                     break;
···
             try
             {
                 inWindowModeTransition = true;
+
                 switch (newMode)
                 {
                     case Configuration.WindowMode.Fullscreen:
···
 
                         WindowState = WindowState.Fullscreen;
                         break;
+
                     case Configuration.WindowMode.Borderless:
                         if (lastFullscreenDisplay != null)
                             RestoreResolution(lastFullscreenDisplay);
···
                         ClientSize = new Size(currentDisplay.Bounds.Width + 1, currentDisplay.Bounds.Height + 1);
                         Location = currentDisplay.Bounds.Location;
                         break;
+
                     case Configuration.WindowMode.Windowed:
                         if (lastFullscreenDisplay != null)
                             RestoreResolution(lastFullscreenDisplay);

osu.Framework/Platform/GameHost.cs

···
 {
     public abstract class GameHost : IIpcHost, IDisposable
     {
-        public GameWindow Window { get; protected set; }
+        public IWindow Window { get; protected set; }
 
-        private FrameworkDebugConfigManager debugConfig;
+        protected FrameworkDebugConfigManager DebugConfig { get; private set; }
 
-        private FrameworkConfigManager config;
+        protected FrameworkConfigManager Config { get; private set; }
 
         /// <summary>
-        /// Whether the <see cref="GameWindow"/> is active (in the foreground).
+        /// Whether the <see cref="IWindow"/> is active (in the foreground).
         /// </summary>
         public readonly IBindable<bool> IsActive = new Bindable<bool>(true);
 
···
 
             if (Window == null)
             {
-                var windowedSize = config.Get<Size>(FrameworkSetting.WindowedSize);
+                var windowedSize = Config.Get<Size>(FrameworkSetting.WindowedSize);
                 Root.Size = new Vector2(windowedSize.Width, windowedSize.Height);
             }
             else if (Window.WindowState != WindowState.Minimized)
···
                     using (drawMonitor.BeginCollecting(PerformanceCollectionType.GLReset))
                         GLWrapper.Reset(new Vector2(Window.ClientSize.Width, Window.ClientSize.Height));
 
+                    if (!bypassFrontToBackPass.Value)
+                    {
+                        var depthValue = new DepthValue();
+
+                        GLWrapper.PushDepthInfo(DepthInfo.Default);
+
+                        // Front pass
+                        buffer.Object.DrawOpaqueInteriorSubTree(depthValue, null);
+
+                        GLWrapper.PopDepthInfo();
+
+                        // The back pass doesn't write depth, but needs to depth test properly
+                        GLWrapper.PushDepthInfo(new DepthInfo(true, false));
+                    }
+                    else
+                    {
+                        // Disable depth testing
+                        GLWrapper.PushDepthInfo(new DepthInfo());
+                    }
+
+                    // Back pass
                     buffer.Object.Draw(null);
+
+                    GLWrapper.PopDepthInfo();
+
                     lastDrawFrameId = buffer.FrameId;
                     break;
                 }
···
 
                 ExecutionState = ExecutionState.Running;
 
-                setupConfig(game.GetFrameworkConfigDefaults());
+                SetupConfig(game.GetFrameworkConfigDefaults());
 
                 if (Window != null)
                 {
-                    Window.SetupWindow(config);
+                    Window.SetupWindow(Config);
                     Window.Title = $@"osu!framework (running ""{Name}"")";
 
                     IsActive.BindTo(Window.IsActive);
···
                     h.Dispose();
 
             AvailableInputHandlers = CreateAvailableInputHandlers();
+
             foreach (var handler in AvailableInputHandlers)
             {
                 if (!handler.Initialize(this))
···
 
         private InvokeOnDisposal inputPerformanceCollectionPeriod;
 
+        private Bindable<bool> bypassFrontToBackPass;
+
         private Bindable<GCLatencyMode> activeGCMode;
 
         private Bindable<FrameSync> frameSyncMode;
···
 
         private Bindable<WindowMode> windowMode;
 
-        private void setupConfig(IDictionary<FrameworkSetting, object> gameDefaults)
+        protected virtual void SetupConfig(IDictionary<FrameworkSetting, object> gameDefaults)
         {
             var hostDefaults = new Dictionary<FrameworkSetting, object>
             {
···
                     hostDefaults[d.Key] = d.Value;
             }
 
-            Dependencies.Cache(debugConfig = new FrameworkDebugConfigManager());
-            Dependencies.Cache(config = new FrameworkConfigManager(Storage, hostDefaults));
+            Dependencies.Cache(DebugConfig = new FrameworkDebugConfigManager());
+            Dependencies.Cache(Config = new FrameworkConfigManager(Storage, hostDefaults));
 
-            windowMode = config.GetBindable<WindowMode>(FrameworkSetting.WindowMode);
+            windowMode = Config.GetBindable<WindowMode>(FrameworkSetting.WindowMode);
 
             windowMode.BindValueChanged(mode =>
             {
···
                     windowMode.Value = Window.DefaultWindowMode;
             }, true);
 
-            activeGCMode = debugConfig.GetBindable<GCLatencyMode>(DebugSetting.ActiveGCMode);
+            activeGCMode = DebugConfig.GetBindable<GCLatencyMode>(DebugSetting.ActiveGCMode);
             activeGCMode.ValueChanged += e => { GCSettings.LatencyMode = IsActive.Value ? e.NewValue : GCLatencyMode.Interactive; };
 
-            frameSyncMode = config.GetBindable<FrameSync>(FrameworkSetting.FrameSync);
+            frameSyncMode = Config.GetBindable<FrameSync>(FrameworkSetting.FrameSync);
             frameSyncMode.ValueChanged += e =>
             {
                 float refreshRate = DisplayDevice.Default?.RefreshRate ?? 0;
···
                         drawLimiter = int.MaxValue;
                         updateLimiter *= 2;
                         break;
+
                     case FrameSync.Limit2x:
                         drawLimiter *= 2;
                         updateLimiter *= 2;
                         break;
+
                     case FrameSync.Limit4x:
                         drawLimiter *= 4;
                         updateLimiter *= 4;
                         break;
+
                     case FrameSync.Limit8x:
                         drawLimiter *= 8;
                         updateLimiter *= 8;
                         break;
+
                     case FrameSync.Unlimited:
                         drawLimiter = updateLimiter = int.MaxValue;
                         break;
···
                 if (UpdateThread != null) UpdateThread.ActiveHz = updateLimiter;
             };
 
-            ignoredInputHandlers = config.GetBindable<string>(FrameworkSetting.IgnoredInputHandlers);
+            ignoredInputHandlers = Config.GetBindable<string>(FrameworkSetting.IgnoredInputHandlers);
             ignoredInputHandlers.ValueChanged += e =>
             {
                 var configIgnores = e.NewValue.Split(' ').Where(s => !string.IsNullOrWhiteSpace(s));
···
                 }
             };
 
-            cursorSensitivity = config.GetBindable<double>(FrameworkSetting.CursorSensitivity);
+            cursorSensitivity = Config.GetBindable<double>(FrameworkSetting.CursorSensitivity);
 
-            config.BindWith(FrameworkSetting.PerformanceLogging, performanceLogging);
+            Config.BindWith(FrameworkSetting.PerformanceLogging, performanceLogging);
             performanceLogging.BindValueChanged(logging => threads.ForEach(t => t.Monitor.EnablePerformanceProfiling = logging.NewValue), true);
+
+            bypassFrontToBackPass = DebugConfig.GetBindable<bool>(DebugSetting.BypassFrontToBackPass);
         }
 
         private void setVSyncMode()
···
             Root?.Dispose();
             Root = null;
 
-            config?.Dispose();
-            debugConfig?.Dispose();
+            Config?.Dispose();
+            DebugConfig?.Dispose();
 
             Window?.Dispose();
 

osu.Framework/Platform/GameWindow.cs

···
 using System.Drawing;
 using JetBrains.Annotations;
 using osu.Framework.Bindables;
+using osu.Framework.Graphics;
 using Icon = osuTK.Icon;
 
 namespace osu.Framework.Platform
 {
-    public abstract class GameWindow : IGameWindow
+    public abstract class GameWindow : IWindow
     {
         /// <summary>
         /// The <see cref="IGraphicsContext"/> associated with this <see cref="GameWindow"/>.
···
 
             FocusedChanged += (o, e) => isActive.Value = Focused;
 
-            SupportedWindowModes.AddRange(DefaultSupportedWindowModes);
+            supportedWindowModes.AddRange(DefaultSupportedWindowModes);
 
             bool firstUpdate = true;
             UpdateFrame += (o, e) =>
···
         /// devices.  This usually corresponds to areas of the screen hidden under notches and rounded corners.
         /// The safe area insets are provided by the operating system and dynamically change as the user rotates the device.
         /// </summary>
-        public readonly BindableMarginPadding SafeAreaPadding = new BindableMarginPadding();
+        public virtual IBindable<MarginPadding> SafeAreaPadding { get; } = new BindableMarginPadding();
 
-        public readonly BindableList<WindowMode> SupportedWindowModes = new BindableList<WindowMode>();
+        private readonly BindableList<WindowMode> supportedWindowModes = new BindableList<WindowMode>();
+
+        public IBindableList<WindowMode> SupportedWindowModes => supportedWindowModes;
 
         public virtual WindowMode DefaultWindowMode => SupportedWindowModes.First();
 
···
                     case Configuration.WindowMode.Windowed:
                         currentValue = Configuration.WindowMode.Borderless;
                         break;
+
                     case Configuration.WindowMode.Borderless:
                         currentValue = Configuration.WindowMode.Fullscreen;
                         break;
+
                     case Configuration.WindowMode.Fullscreen:
                         currentValue = Configuration.WindowMode.Windowed;
                         break;

osu.Framework/Platform/IWindow.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Collections.Generic;
+using JetBrains.Annotations;
+using osu.Framework.Bindables;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osuTK;
+using osuTK.Platform;
+
+namespace osu.Framework.Platform
+{
+    /// <summary>
+    /// Interface representation of the game window, intended to hide any implementation-specific code.
+    /// Currently inherits from osuTK; this will be removed as part of the <see cref="GameWindow"/> refactor.
+    /// </summary>
+    public interface IWindow : IGameWindow
+    {
+        /// <summary>
+        /// Cycles through the available <see cref="WindowMode"/>s as determined by <see cref="SupportedWindowModes"/>.
+        /// </summary>
+        void CycleMode();
+
+        /// <summary>
+        /// Configures the <see cref="IWindow"/> based on the provided <see cref="FrameworkConfigManager"/>.
+        /// </summary>
+        /// <param name="config">The configuration manager to use.</param>
+        void SetupWindow(FrameworkConfigManager config);
+
+        /// <summary>
+        /// Return value decides whether we should intercept and cancel this exit (if possible).
+        /// </summary>
+        [CanBeNull]
+        event Func<bool> ExitRequested;
+
+        /// <summary>
+        /// Invoked when the <see cref="IWindow"/> has closed.
+        /// </summary>
+        [CanBeNull]
+        event Action Exited;
+
+        /// <summary>
+        /// Whether the OS cursor is currently contained within the game window.
+        /// </summary>
+        bool CursorInWindow { get; }
+
+        /// <summary>
+        /// Controls the state of the OS cursor.
+        /// </summary>
+        CursorState CursorState { get; set; }
+
+        /// <summary>
+        /// Controls the vertical sync mode of the screen.
+        /// </summary>
+        VSyncMode VSync { get; set; }
+
+        /// <summary>
+        /// Returns the default <see cref="WindowMode"/> for the implementation.
+        /// </summary>
+        WindowMode DefaultWindowMode { get; }
+
+        /// <summary>
+        /// Gets the <see cref="DisplayDevice"/> that this window is currently on.
+        /// </summary>
+        DisplayDevice CurrentDisplay { get; }
+
+        /// <summary>
+        /// Whether this <see cref="IWindow"/> is active (in the foreground).
+        /// </summary>
+        IBindable<bool> IsActive { get; }
+
+        /// <summary>
+        /// Provides a <see cref="IBindable{MarginPadding}"/> that can be used to keep track of the "safe area" insets on mobile
+        /// devices. This usually corresponds to areas of the screen hidden under notches and rounded corners.
+        /// The safe area insets are provided by the operating system and dynamically change as the user rotates the device.
+        /// </summary>
+        IBindable<MarginPadding> SafeAreaPadding { get; }
+
+        /// <summary>
+        /// The <see cref="WindowMode"/>s supported by this <see cref="IWindow"/> implementation.
+        /// </summary>
+        IBindableList<WindowMode> SupportedWindowModes { get; }
+
+        /// <summary>
+        /// Available resolutions for full-screen display.
+        /// </summary>
+        IEnumerable<DisplayResolution> AvailableResolutions { get; }
+    }
+}

osu.Framework/Platform/Linux/Native/Library.cs

···
         public static void Load(string library, LoadFlags flags)
         {
             var paths = (string)AppContext.GetData("NATIVE_DLL_SEARCH_DIRECTORIES");
+
             foreach (var path in paths.Split(':'))
             {
                 if (dlopen(Path.Combine(path, library), flags) != IntPtr.Zero)

osu.Framework/Platform/MacOS/MacOSGameWindow.cs

···
         {
             // update the window mode if we have an update queued
             WindowMode? mode = pendingWindowMode;
+
             if (mode.HasValue)
             {
                 pendingWindowMode = null;

osu.Framework/Platform/MacOS/MacOSTextInput.cs

···
 
         private static bool isCapsLockOn => (Cocoa.CGEventSourceFlagsState(event_source_state_hid_system_state) & event_flag_mask_alpha_shift) != 0;
 
-        public MacOSTextInput(GameWindow window)
+        public MacOSTextInput(IWindow window)
             : base(window)
         {
         }

osu.Framework/Platform/NativeStorage.cs

···
                     if (!File.Exists(path)) return null;
 
                     return File.Open(path, FileMode.Open, access, FileShare.Read);
+
                 default:
                     return File.Open(path, mode, access);
             }

osu.Framework/Platform/TcpIpcProvider.cs

···
         public bool Bind()
         {
             listener = new TcpListener(IPAddress.Loopback, ipc_port);
+
             try
             {
                 listener.Start();
···
         public async Task StartAsync()
         {
             var token = cancelListener.Token;
+
             try
             {
                 while (!token.IsCancellationRequested)
···
             using (var client = new TcpClient())
             {
                 await client.ConnectAsync(IPAddress.Loopback, ipc_port);
+
                 using (var stream = client.GetStream())
                 {
                     var str = JsonConvert.SerializeObject(message, Formatting.None);

osu.Framework/Platform/Windows/Native/IconGroup.cs

···
         {
             int requested = Math.Min(width, height);
             int closest = -1;
+
             for (int i = 0; i < iconDir.Count; i++)
             {
                 var entry = iconDir.Entries[i];

osu.Framework/Resources/Shaders/sh_Backbuffer_Internal.h

···
+// Automatically included for every vertex shader.
+
+attribute float m_BackbufferDrawDepth;
+
+// Whether the backbuffer is currently being drawn to
+uniform bool g_BackbufferDraw;
+
+void main()
+{
+    {{ real_main }}(); // Invoke real main func
+
+    if (g_BackbufferDraw)
+        gl_Position.z = m_BackbufferDrawDepth;
+}

osu.Framework/Resources/Shaders/sh_Texture2D.vs

···
-#include "sh_Utils.h"
-
-attribute vec2 m_Position;
-attribute vec4 m_Colour;
-attribute vec2 m_TexCoord;
-attribute vec4 m_TexRect;
-attribute vec2 m_BlendRange;
-
-varying vec2 v_MaskingPosition;
-varying vec4 v_Colour;
-varying vec2 v_TexCoord;
-varying vec4 v_TexRect;
-varying vec2 v_BlendRange;
-
-uniform mat4 g_ProjMatrix;
-uniform mat3 g_ToMaskingSpace;
-
-void main(void)
-{
-	// Transform to position to masking space.
-	vec3 maskingPos = g_ToMaskingSpace * vec3(m_Position, 1.0);
-	v_MaskingPosition = maskingPos.xy / maskingPos.z;
-
-	v_Colour = m_Colour;
-	v_TexCoord = m_TexCoord;
-	v_TexRect = m_TexRect;
-	v_BlendRange = m_BlendRange;
-	gl_Position = g_ProjMatrix * vec4(m_Position, 1.0, 1.0);
+#include "sh_Utils.h"
+
+attribute vec2 m_Position;
+attribute vec4 m_Colour;
+attribute vec2 m_TexCoord;
+attribute vec4 m_TexRect;
+attribute vec2 m_BlendRange;
+
+varying vec2 v_MaskingPosition;
+varying vec4 v_Colour;
+varying vec2 v_TexCoord;
+varying vec4 v_TexRect;
+varying vec2 v_BlendRange;
+
+uniform mat4 g_ProjMatrix;
+uniform mat3 g_ToMaskingSpace;
+
+void main(void)
+{
+	// Transform from screen space to masking space.
+	vec3 maskingPos = g_ToMaskingSpace * vec3(m_Position, 1.0);
+	v_MaskingPosition = maskingPos.xy / maskingPos.z;
+
+	v_Colour = m_Colour;
+	v_TexCoord = m_TexCoord;
+	v_TexRect = m_TexRect;
+	v_BlendRange = m_BlendRange;
+
+	gl_Position = g_ProjMatrix * vec4(m_Position, 1.0, 1.0);
 }

osu.Framework/RuntimeInfo.cs

···
             if (OS == Platform.Windows)
             {
                 IntPtr hModule = GetModuleHandle(@"ntdll.dll");
+
                 if (hModule == IntPtr.Zero)
                     IsWine = false;
                 else

osu.Framework/Screens/IScreen.cs

···
                 case null:
                     onFail?.Invoke();
                     return;
+
                 case ScreenStack stack:
                     onRoot(stack);
                     break;
+
                 default:
                     runOnRoot(current.Parent, onRoot, onFail);
                     break;
···
                         return onFail.Invoke();
 
                     return default;
+
                 case ScreenStack stack:
                     return onRoot(stack);
+
                 default:
                     return runOnRoot(current.Parent, onRoot, onFail);
             }

osu.Framework/Statistics/PerformanceMonitor.cs

···
                 for (int i = 0; i < lastAmountGarbageCollects.Length; ++i)
                 {
                     int amountCollections = GC.CollectionCount(i);
+
                     if (lastAmountGarbageCollects[i] != amountCollections)
                     {
                         lastAmountGarbageCollects[i] = amountCollections;

osu.Framework/Testing/DrawFrameRecordingContainer.cs

···
                     currentFrame.Value = currentFrame.MaxValue = 0;
 
                     return base.GenerateDrawNodeSubtree(frame, treeIndex, forceNewDrawNode);
+
                 case RecordState.Recording:
                     var node = base.GenerateDrawNodeSubtree(frame, treeIndex, true);
 
···
                     currentFrame.Value = currentFrame.MaxValue = recordedFrames.Count - 1;
 
                     return node;
+
                 case RecordState.Stopped:
                     return recordedFrames[currentFrame.Value];
             }

osu.Framework/Testing/Drawables/Sections/ToolbarRecordSection.cs

···
                     recordButton.Text = "record";
                     playbackControls.Hide();
                     break;
+
                 case RecordState.Recording:
                     recordButton.Text = "stop";
                     playbackControls.Hide();
                     break;
+
                 case RecordState.Stopped:
                     recordButton.Text = "reset";
                     playbackControls.Show();

osu.Framework/Testing/Drawables/TestSceneButton.cs

···
             text.AddText(TestScene.RemovePrefix(test.Name));
 
             var description = test.GetCustomAttribute<DescriptionAttribute>()?.Description;
+
             if (description != null)
             {
                 text.NewLine();

osu.Framework/Testing/Input/ManualInputManager.cs

···
                         case MouseButton.Left:
                             left.FadeIn();
                             break;
+
                         case MouseButton.Right:
                             right.FadeIn();
                             break;
···
                         case MouseButton.Left:
                             left.FadeOut(500);
                             break;
+
                         case MouseButton.Right:
                             right.FadeOut(500);
                             break;

osu.Framework/Testing/ManualInputManagerTestScene.cs

···
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Testing.Input;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Framework.Testing
 {
···
         /// </summary>
         protected ManualInputManager InputManager { get; }
 
+        private readonly Button buttonTest;
+        private readonly Button buttonLocal;
+
+        [SetUp]
+        public virtual void SetUp() => ResetInput();
+
         protected ManualInputManagerTestScene()
         {
-            base.Content.Add(InputManager = new ManualInputManager());
-            AddStep("return user input", () => InputManager.UseParentInput = true);
+            base.Content.AddRange(new Drawable[]
+            {
+                InputManager = new ManualInputManager
+                {
+                    UseParentInput = true,
+                },
+                new Container
+                {
+                    Depth = float.MinValue,
+                    AutoSizeAxes = Axes.Both,
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopRight,
+                    Margin = new MarginPadding(5),
+                    CornerRadius = 5,
+                    Masking = true,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            Colour = Color4.Black,
+                            RelativeSizeAxes = Axes.Both,
+                            Alpha = 0.5f,
+                        },
+                        new FillFlowContainer
+                        {
+                            AutoSizeAxes = Axes.Both,
+                            Direction = FillDirection.Vertical,
+                            Margin = new MarginPadding(5),
+                            Spacing = new Vector2(5),
+                            Children = new Drawable[]
+                            {
+                                new SpriteText
+                                {
+                                    Anchor = Anchor.TopCentre,
+                                    Origin = Anchor.TopCentre,
+                                    Text = "Input Priority"
+                                },
+                                new FillFlowContainer
+                                {
+                                    AutoSizeAxes = Axes.Both,
+                                    Anchor = Anchor.TopCentre,
+                                    Origin = Anchor.TopCentre,
+                                    Margin = new MarginPadding(5),
+                                    Spacing = new Vector2(5),
+                                    Direction = FillDirection.Horizontal,
+
+                                    Children = new Drawable[]
+                                    {
+                                        buttonLocal = new Button
+                                        {
+                                            Text = "local",
+                                            Size = new Vector2(50, 30),
+                                            Action = returnUserInput
+                                        },
+                                        buttonTest = new Button
+                                        {
+                                            Text = "test",
+                                            Size = new Vector2(50, 30),
+                                            Action = returnTestInput
+                                        },
+                                    }
+                                },
+                            }
+                        },
+                    }
+                },
+            });
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            buttonTest.Enabled.Value = InputManager.UseParentInput;
+            buttonLocal.Enabled.Value = !InputManager.UseParentInput;
         }
 
         /// <summary>
···
         /// </summary>
         protected void ResetInput()
         {
-            InputManager.UseParentInput = false;
+            InputManager.UseParentInput = true;
             var currentState = InputManager.CurrentState;
 
             var mouse = currentState.Mouse;
···
             joystick.Buttons.ForEach(InputManager.ReleaseJoystickButton);
         }
 
-        [SetUp]
-        public virtual void SetUp()
-        {
-            ResetInput();
-        }
+        private void returnUserInput() =>
+            InputManager.UseParentInput = true;
+
+        private void returnTestInput() =>
+            InputManager.UseParentInput = false;
     }
 }

osu.Framework/Testing/TestBrowser.cs

···
                 backgroundCompiler.CompilationStarted += compileStarted;
                 backgroundCompiler.CompilationFinished += compileFinished;
                 backgroundCompiler.CompilationFailed += compileFailed;
+
                 try
                 {
                     backgroundCompiler.Start();
···
                     if (leftContainer.Width == 0) toggleTestList();
                     GetContainingInputManager().ChangeFocus(searchTextBox);
                     return true;
+
                 case TestBrowserAction.Reload:
                     LoadTest(CurrentTest.GetType());
                     return true;
+
                 case TestBrowserAction.ToggleTestList:
                     toggleTestList();
                     return true;

osu.Framework/Testing/TestScene.cs

···
                 throw new InvalidCastException($"The test runner must be a {nameof(Game)}.");
 
             runTask = Task.Factory.StartNew(() => host.Run(game), TaskCreationOptions.LongRunning);
+
             while (!game.IsLoaded)
             {
                 checkForErrors();

osu.Framework/Threading/ThreadedTaskScheduler.cs

···
         /// Initializes a new instance of the StaTaskScheduler class with the specified concurrency level.
         /// </summary>
         /// <param name="numberOfThreads">The number of threads that should be created and used by this scheduler.</param>
-        public ThreadedTaskScheduler(int numberOfThreads)
+        /// <param name="name">The thread name to give threads in this pool.</param>
+        public ThreadedTaskScheduler(int numberOfThreads, string name)
         {
             if (numberOfThreads < 1)
                 throw new ArgumentOutOfRangeException(nameof(numberOfThreads));
···
             {
                 var thread = new Thread(processTasks)
                 {
-                    Name = "LoadComponentThreadPool",
+                    Name = $"ThreadedTaskScheduler ({name})",
                     IsBackground = true
                 };
 

osu.Framework/osu.Framework.csproj

···
     <PackageReference Include="SixLabors.ImageSharp" Version="1.0.0-beta0006" />
     <PackageReference Include="System.Drawing.Common" Version="4.5.1" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.0.0" />
-    <PackageReference Include="ppy.osuTK.NS20" Version="1.0.66" />
     <PackageReference Include="System.Runtime.InteropServices" Version="4.3.0" />
     <PackageReference Include="ppy.Microsoft.Diagnostics.Runtime" Version="0.9.180305.1" />
     <PackageReference Include="NUnit" Version="3.12.0" />
···
     <PackageReference Include="System.Reflection.Emit.Lightweight" Version="4.3.0" />
     <PackageReference Include="System.Reflection.Emit.ILGeneration" Version="4.3.0" />
     <PackageReference Include="JetBrains.Annotations" Version="2019.1.1" />
+    <PackageReference Include="ppy.osuTK.NS20" Version="1.0.101" />
   </ItemGroup>
   <ItemGroup>
     <Folder Include="Resources\Fonts\FontAwesome" />