Merge branch 'master' into sdl2

# Conflicts:
# osu.Framework/Platform/Linux/LinuxGameHost.cs
# osu.Framework/osu.Framework.csproj

SampleGame.Android/Properties/AndroidManifest.xml

···
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="SampleGame.Android" android:installLocation="auto">
-	<uses-sdk android:minSdkVersion="21" android:targetSdkVersion="27" />
+	<uses-sdk android:minSdkVersion="21" android:targetSdkVersion="29" />
 	<application />
 </manifest>

SampleGame.Android/SampleGame.Android.csproj

···
     <ProjectTypeGuids>{EFBA0AD7-5A72-4C68-AF49-83D382785DCF};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
     <RootNamespace>SampleGame.Android</RootNamespace>
     <AssemblyName>SampleGame.Android</AssemblyName>
-    <TargetFrameworkVersion>v8.0</TargetFrameworkVersion>
     <AndroidApplication>True</AndroidApplication>
     <AndroidManifest>Properties\AndroidManifest.xml</AndroidManifest>
     <AndroidSupportedAbis>armeabi-v7a;x86;arm64-v8a</AndroidSupportedAbis>
+    <TargetFrameworkVersion>v10.0</TargetFrameworkVersion>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="SampleGameActivity.cs" />

SampleGame/SampleGame.csproj

···
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
+    <TargetFramework>netstandard2.1</TargetFramework>
   </PropertyGroup>
   <ItemGroup Label="Project References">
     <ProjectReference Include="..\osu.Framework\osu.Framework.csproj" />

global.json

···
 {
   "msbuild-sdks": {
     "MSBuild.Sdk.Extras": "2.0.54",
-    "Microsoft.Build.Traversal": "2.0.19"
+    "Microsoft.Build.Traversal": "2.0.24"
   }
 }

osu-framework.iOS.slnf

···
       "SampleGame\\SampleGame.csproj",
       "osu.Framework.iOS\\osu.Framework.iOS.csproj",
       "osu.Framework.NativeLibs\\osu.Framework.NativeLibs.csproj",
-      "osu.Framework.Tests.Android\\osu.Framework.Tests.Android.csproj",
+      "osu.Framework.Tests.iOS\\osu.Framework.Tests.iOS.csproj",
       "osu.Framework\\osu.Framework.csproj"
     ]
   }

osu.Framework.Android.props

···
     <GenerateSerializationAssemblies>Off</GenerateSerializationAssemblies>
     <AndroidApplication>True</AndroidApplication>
     <AndroidHttpClientHandlerType>Xamarin.Android.Net.AndroidClientHandler</AndroidHttpClientHandlerType>
-    <TargetFrameworkVersion>v8.1</TargetFrameworkVersion>
+    <!-- This does not take effect, unlike osu game repo.  -->
+    <!--<TargetFrameworkVersion>v10.0</TargetFrameworkVersion>-->
     <AndroidUseLatestPlatformSdk>false</AndroidUseLatestPlatformSdk>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <AndroidSupportedAbis>armeabi-v7a;x86;arm64-v8a</AndroidSupportedAbis>
···
   <ItemGroup Label="Package References">
     <PackageReference Include="ManagedBass" Version="2.0.4" />
     <PackageReference Include="ManagedBass.Fx" Version="2.0.1" />
-    <PackageReference Include="System.ValueTuple" Version="4.5.0" />
   </ItemGroup>
 </Project>

osu.Framework.Android/AndroidGameView.cs

···
         public void RenderGame()
         {
             Host = new AndroidGameHost(this);
+            Host.ExceptionThrown += handleException;
             Host.Run(game);
+        }
+
+        private bool handleException(Exception ex)
+        {
+            // suppress exceptions related to MobileAuthenticatedStream disposal
+            // (see: https://github.com/ppy/osu/issues/6264 and linked related mono/xamarin issues)
+            // to be removed when upstream fixes come in
+            return ex is AggregateException ae
+                && ae.InnerException is ObjectDisposedException ode
+                && ode.ObjectName == "MobileAuthenticatedStream";
         }
 
         public override bool OnCheckIsTextEditor() => true;

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

···
 <Project Sdk="MSBuild.Sdk.Extras">
   <PropertyGroup Label="Project">
-    <TargetFramework>monoandroid80</TargetFramework>
+    <TargetFramework>monoandroid10.0</TargetFramework>
     <OutputType>Library</OutputType>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <AssemblyTitle>osu!framework Android</AssemblyTitle>

osu.Framework.Tests.Android/Properties/AndroidManifest.xml

···
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="osu.Framework.Tests.Android" android:installLocation="auto">
-	<uses-sdk android:minSdkVersion="21" android:targetSdkVersion="27" />
+	<uses-sdk android:minSdkVersion="21" android:targetSdkVersion="29" />
 	<application android:label="osu!framework test" />
 </manifest>

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

···
     <AssemblyName>osu.Framework.Tests.Android</AssemblyName>
     <AndroidManifest>Properties\AndroidManifest.xml</AndroidManifest>
     <AndroidSupportedAbis>armeabi-v7a;x86;arm64-v8a</AndroidSupportedAbis>
+    <TargetFrameworkVersion>v10.0</TargetFrameworkVersion>
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="TestGameActivity.cs" />

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.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
···
         public void SetUp()
         {
             thread = new AudioThread();
-            store = new NamespacedResourceStore<byte[]>(new DllResourceStore(@"osu.Framework.dll"), @"Resources");
+            store = new NamespacedResourceStore<byte[]>(new DllResourceStore(new AssemblyName("osu.Framework")), @"Resources");
 
             manager = new AudioManager(thread, store, store);
 

osu.Framework.Tests/Audio/AudioManagerWithDeviceLoss.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.Linq;
+using ManagedBass;
+using osu.Framework.Audio;
+using osu.Framework.IO.Stores;
+using osu.Framework.Threading;
+
+namespace osu.Framework.Tests.Audio
+{
+    /// <summary>
+    /// <see cref="AudioManager"/> that can simulate the loss of a device.
+    /// This will NOT work without a physical audio device!
+    /// </summary>
+    internal class AudioManagerWithDeviceLoss : AudioManager
+    {
+        public AudioManagerWithDeviceLoss(AudioThread audioThread, ResourceStore<byte[]> trackStore, ResourceStore<byte[]> sampleStore)
+            : base(audioThread, trackStore, sampleStore)
+        {
+        }
+
+        public volatile int CurrentDevice = Bass.DefaultDevice;
+
+        private volatile bool simulateLoss;
+
+        protected override bool InitBass(int device)
+        {
+            if (simulateLoss)
+            {
+                if (device != Bass.NoSoundDevice || !base.InitBass(device))
+                    return false;
+
+                CurrentDevice = device;
+                return true;
+            }
+
+            if (!base.InitBass(device))
+                return false;
+
+            CurrentDevice = device;
+            return true;
+        }
+
+        protected override IEnumerable<DeviceInfo> EnumerateAllDevices()
+        {
+            var devices = base.EnumerateAllDevices();
+
+            if (simulateLoss)
+                devices = devices.Take(1);
+
+            return devices;
+        }
+
+        protected override bool IsCurrentDeviceValid()
+        {
+            if (simulateLoss)
+                return CurrentDevice == Bass.NoSoundDevice && base.IsCurrentDeviceValid();
+
+            return CurrentDevice != Bass.NoSoundDevice && base.IsCurrentDeviceValid();
+        }
+
+        public void SimulateDeviceLoss()
+        {
+            var current = CurrentDevice;
+
+            simulateLoss = true;
+
+            if (current != Bass.NoSoundDevice)
+                WaitForDeviceChange(current);
+        }
+
+        public void SimulateDeviceRestore()
+        {
+            var current = CurrentDevice;
+
+            simulateLoss = false;
+
+            if (current == Bass.NoSoundDevice)
+                WaitForDeviceChange(current);
+        }
+
+        public void WaitForDeviceChange(int? current = null, int timeoutMs = 5000)
+        {
+            current ??= CurrentDevice;
+
+            AudioThreadTest.WaitForOrAssert(() => CurrentDevice != current, $"Timed out while waiting for the device to change from {current}.", timeoutMs);
+        }
+    }
+}

osu.Framework.Tests/Audio/AudioThreadTest.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.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using osu.Framework.Audio.Track;
+using osu.Framework.IO.Stores;
+using osu.Framework.Threading;
+
+namespace osu.Framework.Tests.Audio
+{
+    [TestFixture]
+    public abstract class AudioThreadTest
+    {
+        private AudioThread thread;
+        internal AudioManagerWithDeviceLoss Manager;
+
+        [SetUp]
+        public virtual void SetUp()
+        {
+            thread = new AudioThread();
+
+            var store = new NamespacedResourceStore<byte[]>(new DllResourceStore(@"osu.Framework.Tests.dll"), @"Resources");
+
+            Manager = new AudioManagerWithDeviceLoss(thread, store, store);
+
+            thread.Start();
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            Assert.IsFalse(thread.Exited);
+
+            thread.Exit();
+
+            WaitForOrAssert(() => thread.Exited, "Audio thread did not exit in time");
+        }
+
+        public void CheckTrackIsProgressing(Track track)
+        {
+            // playback should be continuing after device change
+            for (int i = 0; i < 2; i++)
+            {
+                var checkAfter = track.CurrentTime;
+                WaitForOrAssert(() => track.CurrentTime > checkAfter, "Track time did not increase", 1000);
+                Assert.IsTrue(track.IsRunning);
+            }
+        }
+
+        /// <summary>
+        /// Waits for a specified condition to become true, or timeout reached.
+        /// </summary>
+        /// <param name="condition">The condition which should become true.</param>
+        /// <param name="message">A message to display on timeout.</param>
+        /// <param name="timeout">Timeout in milliseconds.</param>
+        public static void WaitForOrAssert(Func<bool> condition, string message, int timeout = 60000) =>
+            Assert.IsTrue(Task.Run(() =>
+            {
+                while (!condition()) Thread.Sleep(50);
+            }).Wait(timeout), message);
+    }
+}

osu.Framework.Tests/Audio/DeviceLosingAudioTest.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;
+
+namespace osu.Framework.Tests.Audio
+{
+    /// <remarks>
+    /// This unit will ALWAYS SKIP if the system does not have a physical audio device!!!
+    /// A physical audio device is required to simulate the "loss" of it during playback.
+    /// </remarks>
+    [TestFixture]
+    public class DeviceLosingAudioTest : AudioThreadTest
+    {
+        public override void SetUp()
+        {
+            base.SetUp();
+
+            // wait for any device to be initialized
+            Manager.WaitForDeviceChange(-1);
+
+            // if the initialized device is "No sound", it indicates that no other physical devices are available, so this unit should be ignored
+            if (Manager.CurrentDevice == 0)
+                Assert.Ignore("Physical audio devices are required for this unit.");
+
+            // we don't want music playing in unit tests :)
+            Manager.Volume.Value = 0;
+        }
+
+        [Test]
+        public void TestPlaybackWithDeviceLoss() => testPlayback(Manager.SimulateDeviceRestore, Manager.SimulateDeviceLoss);
+
+        [Test]
+        public void TestPlaybackWithDeviceRestore() => testPlayback(Manager.SimulateDeviceLoss, Manager.SimulateDeviceRestore);
+
+        private void testPlayback(Action preparation, Action simulate)
+        {
+            preparation();
+
+            var track = Manager.Tracks.Get("Tracks.sample-track.mp3");
+
+            // start track
+            track.Restart();
+
+            WaitForOrAssert(() => track.IsRunning, "Track did not start running");
+
+            WaitForOrAssert(() => track.CurrentTime > 0, "Track did not start running");
+
+            // simulate change (loss/restore)
+            simulate();
+
+            CheckTrackIsProgressing(track);
+
+            // stop track
+            track.Stop();
+
+            WaitForOrAssert(() => !track.IsRunning, "Track did not stop", 1000);
+
+            // seek track
+            track.Seek(0);
+
+            Assert.IsFalse(track.IsRunning);
+            WaitForOrAssert(() => track.CurrentTime == 0, "Track did not seek correctly", 1000);
+        }
+    }
+}

osu.Framework.Tests/Audio/DevicelessAudioTest.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;
+
+namespace osu.Framework.Tests.Audio
+{
+    [TestFixture]
+    public class DevicelessAudioTest : AudioThreadTest
+    {
+        public override void SetUp()
+        {
+            base.SetUp();
+
+            // lose all devices
+            Manager.SimulateDeviceLoss();
+        }
+
+        [Test]
+        public void TestPlayTrackWithoutDevices()
+        {
+            var track = Manager.Tracks.Get("Tracks.sample-track.mp3");
+
+            // start track
+            track.Restart();
+            Assert.IsTrue(track.IsRunning);
+
+            CheckTrackIsProgressing(track);
+
+            // stop track
+            track.Stop();
+
+            WaitForOrAssert(() => !track.IsRunning, "Track did not stop", 1000);
+
+            Assert.IsFalse(track.IsRunning);
+
+            // seek track
+            track.Seek(0);
+
+            Assert.IsFalse(track.IsRunning);
+            WaitForOrAssert(() => track.CurrentTime == 0, "Track did not seek correctly", 1000);
+        }
+    }
+}

osu.Framework.Tests/Audio/TrackBassTest.cs

···
             // Initialize bass with no audio to make sure the test remains consistent even if there is no audio device.
             Bass.Init(0);
 
-            resources = new DllResourceStore("osu.Framework.Tests.dll");
+            resources = new DllResourceStore(typeof(TrackBassTest).Assembly);
 
             track = new TrackBass(resources.GetStream("Resources.Tracks.sample-track.mp3"));
             updateTrack();

osu.Framework.Tests/IO/FontStoreTest.cs

···
         [OneTimeSetUp]
         public void OneTimeSetUp()
         {
-            storage = new TemporaryNativeStorage("fontstore-test");
-            fontResourceStore = new NamespacedResourceStore<byte[]>(new DllResourceStore(typeof(Drawable).Assembly.Location), "Resources.Fonts.OpenSans");
-
-            storage.GetFullPath("./", true);
+            storage = new TemporaryNativeStorage("fontstore-test", createIfEmpty: true);
+            fontResourceStore = new NamespacedResourceStore<byte[]>(new DllResourceStore(typeof(Drawable).Assembly), "Resources.Fonts.OpenSans");
         }
 
         [Test]
         public void TestNestedScaleAdjust()
         {
-            var fontStore = new FontStore(new GlyphStore(fontResourceStore, "OpenSans") { CacheStorage = storage }, scaleAdjust: 100);
-            var nestedFontStore = new FontStore(new GlyphStore(fontResourceStore, "OpenSans-Bold") { CacheStorage = storage }, 10);
+            var fontStore = new FontStore(new RawCachingGlyphStore(fontResourceStore, "OpenSans") { CacheStorage = storage }, scaleAdjust: 100);
+            var nestedFontStore = new FontStore(new RawCachingGlyphStore(fontResourceStore, "OpenSans-Bold") { CacheStorage = storage }, 10);
 
             fontStore.AddStore(nestedFontStore);
 

osu.Framework.Tests/IO/TestWebRequest.cs

···
             Assert.IsTrue(request.Completed);
             Assert.IsTrue(request.Aborted);
 
-            Assert.IsTrue(request.ResponseString == null);
+            Assert.IsTrue(request.GetResponseString() == null);
             Assert.IsNotNull(finishedException);
         }
 
···
             Assert.IsTrue(request.Completed);
             Assert.IsTrue(request.Aborted);
 
-            Assert.IsEmpty(request.ResponseString);
+            Assert.IsEmpty(request.GetResponseString());
 
             Assert.IsTrue(hasThrown);
         }

osu.Framework.Tests/MathUtils/TestInterpolation.cs

···
 // 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.Graphics;
 using osu.Framework.MathUtils;
···
     [TestFixture]
     public class TestInterpolation
     {
+        [TestCaseSource(nameof(getEasings))]
+        public void TestEasingStartsAtZero(Easing easing) => Assert.That(Interpolation.ApplyEasing(easing, 0), Is.EqualTo(0).Within(Precision.DOUBLE_EPSILON));
+
+        [TestCaseSource(nameof(getEasings))]
+        public void TestEasingEndsAtOne(Easing easing) => Assert.That(Interpolation.ApplyEasing(easing, 1), Is.EqualTo(1).Within(Precision.DOUBLE_EPSILON));
+
+        private static IEnumerable<Easing> getEasings() => Enum.GetValues(typeof(Easing)).OfType<Easing>();
+
         [Test]
         public void TestLerp()
         {

osu.Framework.Tests/TemporaryNativeStorage.cs

···
 {
     public class TemporaryNativeStorage : NativeStorage, IDisposable
     {
-        public TemporaryNativeStorage(string name, GameHost host = null)
+        public TemporaryNativeStorage(string name, GameHost host = null, bool createIfEmpty = false)
             : base(name, host)
         {
+            if (createIfEmpty)
+            {
+                // create directory
+                GetFullPath("./", true);
+            }
         }
 
         public void Dispose()

osu.Framework.Tests/TestGame.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.Reflection;
 using osu.Framework.Allocation;
 using osu.Framework.IO.Stores;
 
···
         [BackgroundDependencyLoader]
         private void load()
         {
-            Resources.AddStore(new NamespacedResourceStore<byte[]>(new DllResourceStore(Assembly.GetExecutingAssembly().Location), "Resources"));
+            Resources.AddStore(new NamespacedResourceStore<byte[]>(new DllResourceStore(typeof(TestGame).Assembly), "Resources"));
         }
     }
 }

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

···
 {
     public class TestSceneBufferedContainer : TestSceneMasking
     {
-        private readonly BufferedContainer buffer;
-
         public TestSceneBufferedContainer()
         {
             Remove(TestContainer);
 
+            BufferedContainer buffer;
             Add(buffer = new BufferedContainer
             {
                 RelativeSizeAxes = Axes.Both,
                 Children = new[] { TestContainer }
             });
-        }
+
+            AddSliderStep("blur", 0f, 20f, 0f, blur =>
+            {
+                buffer.BlurTo(new Vector2(blur));
+            });
 
-        protected override void LoadComplete()
-        {
-            base.LoadComplete();
+            AddSliderStep("fbo scale (x)", 0.01f, 4f, 1f, scale =>
+            {
+                buffer.FrameBufferScale = new Vector2(scale, buffer.FrameBufferScale.Y);
+            });
 
-            buffer.BlurTo(new Vector2(20), 1000).Then().BlurTo(Vector2.Zero, 1000).Loop();
+            AddSliderStep("fbo scale (y)", 0.01f, 4f, 1f, scale =>
+            {
+                buffer.FrameBufferScale = new Vector2(buffer.FrameBufferScale.X, scale);
+            });
         }
     }
 }

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

···
                     box.OnUpdate += delegate
                     {
                         box.Rotation += 0.05f;
-                        box.CornerRadius = 100 + 100 * (float)Math.Sin(box.Rotation * 0.01);
+                        box.CornerRadius = 100 + 100 * MathF.Sin(box.Rotation * 0.01f);
                     };
                     break;
                 }

osu.Framework.Tests/Visual/Drawables/TestSceneEasingCurves.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.Linq;
+using osu.Framework.Bindables;
+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.Testing;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Framework.Tests.Visual.Drawables
+{
+    public class TestSceneEasingCurves : TestScene
+    {
+        private const float default_size = 300;
+
+        public TestSceneEasingCurves()
+        {
+            FillFlowContainer easingsContainer = null;
+
+            var easingTypes = Enum.GetValues(typeof(Easing))
+                                  .OfType<Easing>()
+                                  .ToList();
+
+            AddStep("set up easings", () => Child = new BasicScrollContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                Child = easingsContainer = new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Children = easingTypes.Select(type => new Visualiser(type))
+                                          .ToArray()
+                }
+            });
+
+            AddSliderStep("resize easings", default_size, 3 * default_size, default_size, size =>
+            {
+                easingsContainer?.Children?.OfType<Visualiser>().ForEach(easing => easing.ResizeTo(new Vector2(size)));
+            });
+
+            foreach (var type in easingTypes)
+            {
+                AddToggleStep($"toggle {type}", enabled =>
+                {
+                    var easingContainer = easingsContainer.Children.OfType<Visualiser>().Single(easing => easing.Easing == type);
+                    easingContainer.Visible.Value = enabled;
+                });
+            }
+        }
+
+        private class Visualiser : Container
+        {
+            private const float movement_duration = 1000f;
+            private const float pause_duration = 500f;
+
+            public readonly Easing Easing;
+
+            public Bindable<bool> Visible { get; } = new BindableBool();
+
+            private readonly CircularContainer dot;
+
+            public Visualiser(Easing easing)
+            {
+                Easing = easing;
+
+                Size = new Vector2(default_size);
+                Padding = new MarginPadding(25);
+
+                InternalChildren = new Drawable[]
+                {
+                    new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Anchor = Anchor.BottomCentre,
+                        Origin = Anchor.BottomCentre,
+                        Children = new Drawable[]
+                        {
+                            new Box
+                            {
+                                Colour = Color4.DimGray,
+                                RelativeSizeAxes = Axes.Both
+                            },
+                            dot = new CircularContainer
+                            {
+                                Origin = Anchor.Centre,
+                                RelativePositionAxes = Axes.Both,
+                                Size = new Vector2(10),
+                                Masking = true,
+                                Child = new Box
+                                {
+                                    RelativeSizeAxes = Axes.Both,
+                                    Colour = Color4.White
+                                }
+                            }
+                        }
+                    },
+                    new SpriteText
+                    {
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.TopCentre,
+                        Y = 10,
+                        Text = easing.ToString()
+                    },
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                Visible.BindValueChanged(e => Alpha = e.NewValue ? 1 : 0, true);
+
+                dot.MoveToX(1.0f, movement_duration, Easing)
+                   .Then(pause_duration)
+                   .MoveToX(0.0f, movement_duration, Easing)
+                   .Loop(pause_duration);
+                dot.MoveToY(1.0f, movement_duration)
+                   .Then(pause_duration)
+                   .MoveToY(0.0f, movement_duration)
+                   .Loop(pause_duration);
+            }
+        }
+    }
+}

osu.Framework.Tests/Visual/FrameworkTestScene.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.Reflection;
 using osu.Framework.Allocation;
 using osu.Framework.IO.Stores;
 using osu.Framework.Testing;
···
             [BackgroundDependencyLoader]
             private void load()
             {
-                Resources.AddStore(new NamespacedResourceStore<byte[]>(new DllResourceStore(Path.GetFileName(Assembly.GetExecutingAssembly().Location)), "Resources"));
+                Resources.AddStore(new NamespacedResourceStore<byte[]>(new DllResourceStore(typeof(FrameworkTestScene).Assembly), "Resources"));
             }
         }
     }

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

···
                 Texture = texture;
                 Colour = colour;
 
-                const int target_raw = 1024;
+                const float target_raw = 1024;
 
-                for (int i = 0; i < target_raw; i++)
+                for (float i = 0; i < target_raw; i++)
                 {
-                    float x = (float)(Math.Sin(i / (double)target_raw * (Math.PI * 0.5)) * 200) + 50.5f;
-                    float y = (float)(Math.Cos(i / (double)target_raw * (Math.PI * 0.5)) * 200) + 50.5f;
+                    float x = (MathF.Sin(i / target_raw * (MathF.PI * 0.5f)) * 200) + 50.5f;
+                    float y = (MathF.Cos(i / target_raw * (MathF.PI * 0.5f)) * 200) + 50.5f;
                     Vector2 v = keepFraction ? new Vector2(x, y) : new Vector2((int)x, (int)y);
                     if (raw)
                         AddRawVertex(v);

osu.Framework.Tests/Visual/Sprites/TestSceneTextures.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.Graphics.Containers;
···
                 avatar2.Dispose();
             });
 
-            AddUntilStep("gl textures disposed", () => texture.ReferenceCount == 0);
+            assertAvailability(() => texture, false);
         }
 
         /// <summary>
···
             AddStep("get texture", () => texture = largeStore.Get("https://a.ppy.sh/3"));
             AddStep("dispose texture", () => texture.Dispose());
 
-            AddAssert("texture is not available", () => !texture.Available);
+            assertAvailability(() => texture, false);
         }
 
         /// <summary>
···
 
             AddAssert("texture is still available", () => texture.Available);
         }
+
+        private void assertAvailability(Func<Texture> textureFunc, bool available)
+            => AddAssert($"texture available = {available}", () => ((TextureWithRefCount)textureFunc()).IsDisposed == !available);
 
         private Avatar addSprite(string url)
         {

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

···
             assertMenuInCentre(() => box2);
         }
 
-        [Ignore("needs to be fixed")]
         [Test]
         public void TestMenuHiddenWhenTargetHidden()
         {

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

···
             AddStep("MarkdownFromInternet", () =>
             {
                 req = new WebRequest("https://raw.githubusercontent.com/ppy/osu-wiki/master/wiki/Skinning/skin.ini/en.md");
-                req.Finished += () => Schedule(() => markdownContainer.Text = req.ResponseString);
+                req.Finished += () => Schedule(() => markdownContainer.Text = req.GetResponseString());
 
                 Task.Run(() => req.PerformAsync());
             });

osu.Framework/Audio/AudioManager.cs

···
         /// <summary>
         /// The names of all available audio devices.
         /// </summary>
+        /// <remarks>
+        /// This property does not contain the names of disabled audio devices.
+        /// </remarks>
         public IEnumerable<string> AudioDeviceNames => audioDeviceNames;
 
         /// <summary>
···
         /// <see cref="string.Empty"/> denotes the OS default.
         /// </summary>
         public readonly Bindable<string> AudioDevice = new Bindable<string>();
-
-        private string currentAudioDevice;
 
         /// <summary>
         /// Volume of all samples played game-wide.
···
                 return store;
             });
 
-            scheduler.Add(() =>
+            // check for device validity every 100ms
+            scheduler.AddDelayed(() =>
             {
                 try
                 {
-                    setAudioDevice();
+                    if (!IsCurrentDeviceValid())
+                        setAudioDevice();
                 }
                 catch
                 {
                 }
-            });
+            }, 100, true);
 
-            scheduler.AddDelayed(delegate
+            // enumerate new list of devices every second
+            scheduler.AddDelayed(() =>
             {
-                updateAvailableAudioDevices();
-                checkAudioDeviceChanged();
+                try
+                {
+                    setAudioDevice(AudioDevice.Value);
+                }
+                catch
+                {
+                }
             }, 1000, true);
         }
 
···
 
         private void onDeviceChanged(ValueChangedEvent<string> args)
         {
-            scheduler.Add(() => setAudioDevice(string.IsNullOrEmpty(args.NewValue) ? null : args.NewValue));
+            scheduler.Add(() => setAudioDevice(args.NewValue));
         }
 
         /// <summary>
-        /// Returns a list of the names of recognized audio devices.
-        /// </summary>
-        /// <remarks>
-        /// The No Sound device that is in the list of Audio Devices that are stored internally is not returned.
-        /// Regarding the .Skip(1) as implementation for removing "No Sound", see http://bass.radio42.com/help/html/e5a666b4-1bdd-d1cb-555e-ce041997d52f.htm.
-        /// </remarks>
-        /// <returns>A list of the names of recognized audio devices.</returns>
-        private IEnumerable<string> getDeviceNames(IEnumerable<DeviceInfo> devices) => devices.Skip(1).Select(d => d.Name);
-
-        /// <summary>
         /// Obtains the <see cref="TrackStore"/> corresponding to a given resource store.
         /// Returns the global <see cref="TrackStore"/> if no resource store is passed.
         /// </summary>
···
             return sm;
         }
 
-        private IEnumerable<DeviceInfo> enumerateAllDevices()
-        {
-            int deviceCount = Bass.DeviceCount;
-            for (int i = 0; i < deviceCount; i++)
-                yield return Bass.GetDeviceInfo(i);
-        }
+        private DeviceInfo currentAudioDevice;
 
-        private bool setAudioDevice(string preferredDevice = null)
+        /// <summary>
+        /// Sets the output audio device by its name.
+        /// This will automatically fall back to the system default device on failure.
+        /// </summary>
+        /// <param name="deviceName">Name of the audio device, or null to use the configured device preference <see cref="AudioDevice"/>.</param>
+        private bool setAudioDevice(string deviceName = null)
         {
             updateAvailableAudioDevices();
 
-            string oldDevice = currentAudioDevice;
-            string newDevice = preferredDevice;
+            deviceName ??= AudioDevice.Value;
 
-            if (string.IsNullOrEmpty(newDevice))
-                newDevice = audioDevices.Find(df => df.IsDefault).Name;
+            // try using the specified device
+            if (setAudioDevice(audioDevices.FindIndex(d => d.Name == deviceName)))
+                return true;
 
-            bool oldDeviceValid = Bass.CurrentDevice >= 0;
+            // try using the system default device
+            if (setAudioDevice(audioDevices.FindIndex(d => d.Name != deviceName && d.IsDefault)))
+                return true;
 
-            if (oldDeviceValid)
-            {
-                DeviceInfo oldDeviceInfo = Bass.GetDeviceInfo(Bass.CurrentDevice);
-                oldDeviceValid &= oldDeviceInfo.IsEnabled && oldDeviceInfo.IsInitialized;
-            }
-
-            if (newDevice == oldDevice && oldDeviceValid)
+            // no audio devices can be used, so try using Bass-provided "No sound" device as last resort
+            if (setAudioDevice(Bass.NoSoundDevice))
                 return true;
 
-            if (string.IsNullOrEmpty(newDevice))
-            {
-                Logger.Log(@"BASS Initialization failed (no audio device present)");
-                return false;
-            }
+            //we're fucked. even "No sound" device won't initialise.
+            currentAudioDevice = default;
+            return false;
+        }
 
-            int newDeviceIndex = audioDevices.FindIndex(df => df.Name == newDevice);
+        private bool setAudioDevice(int deviceIndex)
+        {
+            var device = audioDevices.ElementAtOrDefault(deviceIndex);
 
-            DeviceInfo newDeviceInfo = new DeviceInfo();
-
-            try
-            {
-                if (newDeviceIndex >= 0)
-                    newDeviceInfo = Bass.GetDeviceInfo(newDeviceIndex);
-                //we may have previously initialised this device.
-            }
-            catch
-            {
-            }
+            // device is invalid
+            if (!device.IsEnabled)
+                return false;
 
-            if (oldDeviceValid && (newDeviceInfo.Driver == null || !newDeviceInfo.IsEnabled))
-            {
-                //handles the case we are trying to load a user setting which is currently unavailable,
-                //and we have already fallen back to a sane default.
+            // same device
+            if (device.IsInitialized && device.Name == currentAudioDevice.Name)
                 return true;
-            }
 
-            if (!Bass.Init(newDeviceIndex) && Bass.LastError != Errors.Already)
-            {
-                //the new device didn't go as planned. we need another option.
-
-                if (preferredDevice == null)
-                {
-                    //we're fucked. the default device won't initialise.
-                    currentAudioDevice = null;
-                    return false;
-                }
-
-                //let's try again using the default device.
-                return setAudioDevice();
-            }
+            // initialize new device
+            if (!InitBass(deviceIndex) && Bass.LastError != Errors.Already)
+                return false;
 
             if (Bass.LastError == Errors.Already)
             {
                 // We check if the initialization error is that we already initialized the device
                 // If it is, it means we can just tell Bass to use the already initialized device without much
                 // other fuzz.
-                Bass.CurrentDevice = newDeviceIndex;
+                Bass.CurrentDevice = deviceIndex;
                 Bass.Free();
-                Bass.Init(newDeviceIndex);
+                InitBass(deviceIndex);
             }
 
             Trace.Assert(Bass.LastError == Errors.OK);
···
             Logger.Log($@"BASS Initialized
                           BASS Version:               {Bass.Version}
                           BASS FX Version:            {ManagedBass.Fx.BassFx.Version}
-                          Device:                     {newDeviceInfo.Name}
-                          Drive:                      {newDeviceInfo.Driver}");
+                          Device:                     {device.Name}
+                          Drive:                      {device.Driver}");
 
             //we have successfully initialised a new device.
-            currentAudioDevice = newDevice;
+            currentAudioDevice = device;
 
-            UpdateDevice(newDeviceIndex);
+            UpdateDevice(deviceIndex);
 
             Bass.PlaybackBufferLength = 100;
             Bass.UpdatePeriod = 5;
···
             return true;
         }
 
+        /// <summary>
+        /// This method calls <see cref="Bass.Init(int, int, DeviceInitFlags, IntPtr, IntPtr)"/>.
+        /// It can be overridden for unit testing.
+        /// </summary>
+        protected virtual bool InitBass(int device) => Bass.Init(device);
+
         private void updateAvailableAudioDevices()
         {
-            var currentDeviceList = enumerateAllDevices().Where(d => d.IsEnabled).ToList();
-            var currentDeviceNames = getDeviceNames(currentDeviceList).ToList();
+            audioDevices = EnumerateAllDevices().ToList();
 
-            var newDevices = currentDeviceNames.Except(audioDeviceNames).ToList();
-            var lostDevices = audioDeviceNames.Except(currentDeviceNames).ToList();
+            // Bass should always be providing "No sound" device
+            Trace.Assert(audioDevices.Count > 0, "Bass did not provide any audio devices.");
+
+            var oldDeviceNames = audioDeviceNames;
+            var newDeviceNames = audioDeviceNames = audioDevices.Skip(1).Where(d => d.IsEnabled).Select(d => d.Name).ToList();
+
+            var newDevices = newDeviceNames.Except(oldDeviceNames).ToList();
+            var lostDevices = oldDeviceNames.Except(newDeviceNames).ToList();
 
             if (newDevices.Count > 0 || lostDevices.Count > 0)
             {
···
                         OnLostDevice?.Invoke(d);
                 });
             }
+        }
 
-            audioDevices = currentDeviceList;
-            audioDeviceNames = currentDeviceNames;
+        protected virtual IEnumerable<DeviceInfo> EnumerateAllDevices()
+        {
+            int deviceCount = Bass.DeviceCount;
+            for (int i = 0; i < deviceCount; i++)
+                yield return Bass.GetDeviceInfo(i);
         }
 
-        private void checkAudioDeviceChanged()
+        protected virtual bool IsCurrentDeviceValid()
         {
-            try
-            {
-                if (AudioDevice.Value == string.Empty)
-                {
-                    // use default device
-                    var device = Bass.GetDeviceInfo(Bass.CurrentDevice);
+            var deviceIndex = Bass.CurrentDevice;
+            var device = deviceIndex == Bass.DefaultDevice ? default : Bass.GetDeviceInfo(deviceIndex);
 
-                    if (!device.IsDefault && !setAudioDevice())
-                    {
-                        if (!device.IsEnabled || !setAudioDevice(device.Name))
-                        {
-                            foreach (var d in enumerateAllDevices())
-                            {
-                                if (d.Name == device.Name || !d.IsEnabled)
-                                    continue;
-
-                                if (setAudioDevice(d.Name))
-                                    break;
-                            }
-                        }
-                    }
-                }
-                else
-                {
-                    // use whatever is the preferred device
-                    var device = Bass.GetDeviceInfo(Bass.CurrentDevice);
-
-                    if (device.Name == AudioDevice.Value)
-                    {
-                        if (!device.IsEnabled && !setAudioDevice())
-                        {
-                            foreach (var d in enumerateAllDevices())
-                            {
-                                if (d.Name == device.Name || !d.IsEnabled)
-                                    continue;
-
-                                if (setAudioDevice(d.Name))
-                                    break;
-                            }
-                        }
-                    }
-                    else
-                    {
-                        var preferredDevice = enumerateAllDevices().SingleOrDefault(d => d.Name == AudioDevice.Value);
-
-                        if (preferredDevice.Name == AudioDevice.Value && preferredDevice.IsEnabled)
-                            setAudioDevice(preferredDevice.Name);
-                        else if (!device.IsEnabled && !setAudioDevice())
-                        {
-                            foreach (var d in enumerateAllDevices())
-                            {
-                                if (d.Name == device.Name || !d.IsEnabled)
-                                    continue;
-
-                                if (setAudioDevice(d.Name))
-                                    break;
-                            }
-                        }
-                    }
-                }
-            }
-            catch
-            {
-            }
+            return device.IsEnabled && device.IsInitialized;
         }
 
         public override string ToString() => $@"{GetType().ReadableName()} ({currentAudioDevice})";

osu.Framework/Audio/Track/TrackBass.cs

···
             InvalidateState();
         }
 
+        /// <summary>
+        /// Returns whether the playback state is considered to be running or not.
+        /// This will only return true for <see cref="PlaybackState.Playing"/> and <see cref="PlaybackState.Stalled"/>.
+        /// </summary>
+        private static bool isRunningState(PlaybackState state) => state == PlaybackState.Playing || state == PlaybackState.Stalled;
+
         void IBassAudio.UpdateDevice(int deviceIndex)
         {
             Bass.ChannelSetDevice(activeStream, deviceIndex);
             Trace.Assert(Bass.LastError == Errors.OK);
+
+            // Bass may leave us in an invalid state after the output device changes (this is true for "No sound" device)
+            // if the observed state was playing before change, we should force things into a good state.
+            if (isPlayed)
+            {
+                // While on windows, changing to "No sound" changes the playback state correctly,
+                // on macOS it is left in a playing-but-stalled state. Forcefully stopping first fixes this.
+                stopInternal();
+                startInternal();
+            }
         }
 
         protected override void UpdateState()
         {
-            isRunning = Bass.ChannelIsActive(activeStream) == PlaybackState.Playing;
+            var running = isRunningState(Bass.ChannelIsActive(activeStream));
+            var bytePosition = Bass.ChannelGetPosition(activeStream);
+
+            // because device validity check isn't done frequently, when switching to "No sound" device,
+            // there will be a brief time where this track will be stopped, before we resume it manually (see comments in UpdateDevice(int).)
+            // this makes us appear to be playing, even if we may not be.
+            isRunning = running || (isPlayed && bytePosition != byteLength);
 
-            Interlocked.Exchange(ref currentTime, Bass.ChannelBytes2Seconds(activeStream, Bass.ChannelGetPosition(activeStream)) * 1000);
+            Interlocked.Exchange(ref currentTime, Bass.ChannelBytes2Seconds(activeStream, bytePosition) * 1000);
 
             var leftChannel = isPlayed ? Bass.ChannelGetLevelLeft(activeStream) / 32768f : -1;
             var rightChannel = isPlayed ? Bass.ChannelGetLevelRight(activeStream) / 32768f : -1;
···
 
         public Task StopAsync() => EnqueueAction(() =>
         {
-            if (Bass.ChannelIsActive(activeStream) == PlaybackState.Playing)
-                Bass.ChannelPause(activeStream);
-
+            stopInternal();
             isPlayed = false;
         });
+
+        private bool stopInternal() => isRunningState(Bass.ChannelIsActive(activeStream)) && Bass.ChannelPause(activeStream);
 
         private int direction;
 
···
 
         public Task StartAsync() => EnqueueAction(() =>
         {
+            if (startInternal())
+                isPlayed = true;
+        });
+
+        private bool startInternal()
+        {
             // Bass will restart the track if it has reached its end. This behavior isn't desirable so block locally.
             if (Bass.ChannelGetPosition(activeStream) == byteLength)
-                return;
+                return false;
 
-            if (Bass.ChannelPlay(activeStream))
-                isPlayed = true;
-            else
-                isRunning = false;
-        });
+            return Bass.ChannelPlay(activeStream);
+        }
 
         public override bool Seek(double seek) => SeekAsync(seek).Result;
 

osu.Framework/Configuration/FrameworkConfigManager.cs

···
             Set(FrameworkSetting.IgnoredInputHandlers, string.Empty);
             Set(FrameworkSetting.CursorSensitivity, 1.0, 0.1, 6, 0.01);
             Set(FrameworkSetting.Locale, string.Empty);
-            Set(FrameworkSetting.PerformanceLogging, false);
         }
 
         public FrameworkConfigManager(Storage storage, IDictionary<FrameworkSetting, object> defaultOverrides = null)
···
         IgnoredInputHandlers,
         CursorSensitivity,
         MapAbsoluteInputToWindow,
-
-        PerformanceLogging
     }
 }

osu.Framework/Configuration/FrameworkDebugConfig.cs

···
             base.InitialiseDefaults();
 
             Set(DebugSetting.BypassFrontToBackPass, false);
+            Set(DebugSetting.PerformanceLogging, false);
         }
     }
 
     public enum DebugSetting
     {
-        BypassFrontToBackPass
+        BypassFrontToBackPass,
+        PerformanceLogging
     }
 }

osu.Framework/Development/DebugUtils.cs

···
         );
 
         /// <summary>
-        /// Whether the framework is currently logging performance issues via <see cref="FrameworkSetting.PerformanceLogging"/>.
+        /// Whether the framework is currently logging performance issues via <see cref="DebugSetting.PerformanceLogging"/>.
         /// This should be used only when a configuration is not available via DI or otherwise (ie. in a static context).
         /// </summary>
         public static bool LogPerformanceIssues { get; internal set; }

osu.Framework/Extensions/MatrixExtensions/MatrixExtensions.cs

···
 
         public static void RotateFromLeft(ref Matrix3 m, float radians)
         {
-            float cos = (float)Math.Cos(radians);
-            float sin = (float)Math.Sin(radians);
+            float cos = MathF.Cos(radians);
+            float sin = MathF.Sin(radians);
 
             Vector3 row0 = m.Row0 * cos + m.Row1 * sin;
             m.Row1 = m.Row1 * cos - m.Row0 * sin;
···
 
         public static void RotateFromRight(ref Matrix3 m, float radians)
         {
-            float cos = (float)Math.Cos(radians);
-            float sin = (float)Math.Sin(radians);
+            float cos = MathF.Cos(radians);
+            float sin = MathF.Sin(radians);
 
             //Vector3 column0 = m.Column0 * cos + m.Column1 * sin;
             float m11 = m.M11 * cos - m.M12 * sin;

osu.Framework/Game.cs

···
 
         public ShaderManager Shaders { get; private set; }
 
+        /// <summary>
+        /// A store containing fonts accessible game-wide.
+        /// </summary>
+        /// <remarks>
+        /// It is recommended to use <see cref="AddFont"/> when adding new fonts.
+        /// </remarks>
         public FontStore Fonts { get; private set; }
 
         private FontStore localFonts;
···
         private void load(FrameworkConfigManager config)
         {
             Resources = new ResourceStore<byte[]>();
-            Resources.AddStore(new NamespacedResourceStore<byte[]>(new DllResourceStore(@"osu.Framework.dll"), @"Resources"));
+            Resources.AddStore(new NamespacedResourceStore<byte[]>(new DllResourceStore(typeof(Game).Assembly), @"Resources"));
 
             Textures = new TextureStore(Host.CreateTextureLoaderStore(new NamespacedResourceStore<byte[]>(Resources, @"Textures")));
             Textures.AddStore(Host.CreateTextureLoaderStore(new OnlineStore()));
···
             // note that currently this means there could be two async font load operations.
             Fonts.AddStore(localFonts = new FontStore(useAtlas: false));
 
-            localFonts.AddStore(new GlyphStore(Resources, @"Fonts/OpenSans/OpenSans"));
-            localFonts.AddStore(new GlyphStore(Resources, @"Fonts/OpenSans/OpenSans-Bold"));
-            localFonts.AddStore(new GlyphStore(Resources, @"Fonts/OpenSans/OpenSans-Italic"));
-            localFonts.AddStore(new GlyphStore(Resources, @"Fonts/OpenSans/OpenSans-BoldItalic"));
+            addFont(localFonts, Resources, @"Fonts/OpenSans/OpenSans");
+            addFont(localFonts, Resources, @"Fonts/OpenSans/OpenSans-Bold");
+            addFont(localFonts, Resources, @"Fonts/OpenSans/OpenSans-Italic");
+            addFont(localFonts, Resources, @"Fonts/OpenSans/OpenSans-BoldItalic");
 
-            Fonts.AddStore(new GlyphStore(Resources, @"Fonts/FontAwesome5/FontAwesome-Solid"));
-            Fonts.AddStore(new GlyphStore(Resources, @"Fonts/FontAwesome5/FontAwesome-Regular"));
-            Fonts.AddStore(new GlyphStore(Resources, @"Fonts/FontAwesome5/FontAwesome-Brands"));
+            addFont(Fonts, Resources, @"Fonts/FontAwesome5/FontAwesome-Solid");
+            addFont(Fonts, Resources, @"Fonts/FontAwesome5/FontAwesome-Regular");
+            addFont(Fonts, Resources, @"Fonts/FontAwesome5/FontAwesome-Brands");
 
             dependencies.Cache(Fonts);
 
             Localisation = new LocalisationManager(config);
             dependencies.Cache(Localisation);
         }
+
+        /// <summary>
+        /// Add a font to be globally accessible to the game.
+        /// </summary>
+        /// <param name="store">The backing store with font resources.</param>
+        /// <param name="assetName">The base name of the font.</param>
+        public void AddFont(ResourceStore<byte[]> store, string assetName = null)
+            => addFont(Fonts, store, assetName);
+
+        private void addFont(FontStore target, ResourceStore<byte[]> store, string assetName = null)
+            => target.AddStore(new RawCachingGlyphStore(store, assetName, Host.CreateTextureLoaderStore(store)));
 
         protected override void LoadComplete()
         {

osu.Framework/Graphics/BufferedDrawNode.cs

···
 
         private Color4 backgroundColour;
         private RectangleF screenSpaceDrawRectangle;
+        private Vector2 frameBufferScale;
         private Vector2 frameBufferSize;
 
         public BufferedDrawNode(IBufferedDrawable source, DrawNode child, BufferedDrawNodeSharedData sharedData)
···
             backgroundColour = Source.BackgroundColour;
             screenSpaceDrawRectangle = Source.ScreenSpaceDrawQuad.AABBFloat;
             DrawColourInfo = Source.FrameBufferDrawColour ?? new DrawColourInfo(Color4.White, base.DrawColourInfo.Blending);
+            frameBufferScale = Source.FrameBufferScale;
 
-            frameBufferSize = new Vector2((float)Math.Ceiling(screenSpaceDrawRectangle.Width), (float)Math.Ceiling(screenSpaceDrawRectangle.Height));
+            frameBufferSize = new Vector2(MathF.Ceiling(screenSpaceDrawRectangle.Width * frameBufferScale.X), MathF.Ceiling(screenSpaceDrawRectangle.Height * frameBufferScale.Y));
             DrawRectangle = SharedData.PixelSnapping
                 ? new RectangleF(screenSpaceDrawRectangle.X, screenSpaceDrawRectangle.Y, frameBufferSize.X, frameBufferSize.Y)
                 : screenSpaceDrawRectangle;
···
 
             // Match viewport to FrameBuffer such that we don't draw unnecessary pixels.
             GLWrapper.PushViewport(new RectangleI(0, 0, (int)frameBufferSize.X, (int)frameBufferSize.Y));
+            GLWrapper.PushScissor(new RectangleI(0, 0, (int)frameBufferSize.X, (int)frameBufferSize.Y));
+            GLWrapper.PushScissorOffset(screenSpaceMaskingRect.Location);
 
             return new ValueInvokeOnDisposal(returnViewport);
         }
 
         private void returnViewport()
         {
+            GLWrapper.PopScissorOffset();
             GLWrapper.PopViewport();
+            GLWrapper.PopScissor();
             GLWrapper.PopMaskingInfo();
         }
 

osu.Framework/Graphics/Containers/BufferedContainer.cs

···
             }
         }
 
+        private Vector2 frameBufferScale = Vector2.One;
+
+        public Vector2 FrameBufferScale
+        {
+            get => frameBufferScale;
+            set
+            {
+                if (frameBufferScale == value)
+                    return;
+
+                frameBufferScale = value;
+                ForceRedraw();
+            }
+        }
+
         /// <summary>
         /// Whether the rendered framebuffer shall be cached until <see cref="ForceRedraw"/> is called
         /// or the size of the container (i.e. framebuffer) changes.

osu.Framework/Graphics/Containers/BufferedContainer_DrawNode.cs

···
                     blurShader.GetUniform<Vector2>(@"g_TexSize").UpdateValue(ref size);
 
                     float radians = -MathHelper.DegreesToRadians(blurRotation);
-                    Vector2 blur = new Vector2((float)Math.Cos(radians), (float)Math.Sin(radians));
+                    Vector2 blur = new Vector2(MathF.Cos(radians), MathF.Sin(radians));
                     blurShader.GetUniform<Vector2>(@"g_BlurDirection").UpdateValue(ref blur);
 
                     blurShader.Bind();

osu.Framework/Graphics/Containers/CompositeDrawable.cs

···
                 Vector2 u = ToParentSpace(new Vector2(cRadius, 0)) - offset;
                 Vector2 v = ToParentSpace(new Vector2(0, cRadius)) - offset;
                 Vector2 inflation = new Vector2(
-                    (float)Math.Sqrt(u.X * u.X + v.X * v.X),
-                    (float)Math.Sqrt(u.Y * u.Y + v.Y * v.Y)
+                    MathF.Sqrt(u.X * u.X + v.X * v.X),
+                    MathF.Sqrt(u.Y * u.Y + v.Y * v.Y)
                 );
 
                 RectangleF result = ToParentSpace(drawRect).AABBFloat.Inflate(inflation);

osu.Framework/Graphics/Containers/CompositeDrawable_DrawNode.cs

···
         /// </summary>
         protected class CompositeDrawableDrawNode : DrawNode, ICompositeDrawNode
         {
-            private static readonly float cos_45 = (float)Math.Cos(Math.PI / 4);
+            private static readonly float cos_45 = MathF.Cos(MathF.PI / 4);
 
             protected new CompositeDrawable Source => (CompositeDrawable)base.Source;
 

osu.Framework/Graphics/Cursor/ContextMenuContainer.cs

···
 
             if (menu.State != MenuState.Open || menuTarget == null) return;
 
-            if ((menuTarget as Drawable)?.FindClosestParent<ContextMenuContainer>() != this)
+            if ((menuTarget as Drawable)?.FindClosestParent<ContextMenuContainer>() != this || (!menuTarget?.IsPresent ?? false))
             {
                 cancelDisplay();
                 return;

osu.Framework/Graphics/Cursor/TooltipContainer.cs

···
             // Clamp position to tooltip container
             tooltipPos.X = Math.Min(tooltipPos.X, DrawWidth - CurrentTooltip.DrawSize.X - 5);
             float dX = Math.Max(0, tooltipPos.X - cursorCentre.X);
-            float dY = (float)Math.Sqrt(boundingRadius * boundingRadius - dX * dX);
+            float dY = MathF.Sqrt(boundingRadius * boundingRadius - dX * dX);
 
             if (tooltipPos.Y > DrawHeight - CurrentTooltip.DrawSize.Y - 5)
                 tooltipPos.Y = cursorCentre.Y - dY - CurrentTooltip.DrawSize.Y;

osu.Framework/Graphics/IBufferedDrawable.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using osu.Framework.Graphics.OpenGL.Buffers;
+using osuTK;
 using osuTK.Graphics;
 
 namespace osu.Framework.Graphics
···
         /// A null value implies the <see cref="FrameBuffer"/>s should be drawn as they are.
         /// </summary>
         DrawColourInfo? FrameBufferDrawColour { get; }
+
+        /// <summary>
+        /// The scale of the <see cref="FrameBuffer"/>s drawn relative to the size of this <see cref="IBufferedDrawable"/>.
+        /// </summary>
+        /// <remarks>
+        /// The contents of the <see cref="FrameBuffer"/>s are populated at this scale, however the scale of <see cref="Drawable"/>s remains unaffected.
+        /// </remarks>
+        Vector2 FrameBufferScale { get; }
     }
 }

osu.Framework/Graphics/Lines/Path.cs

···
 
         public DrawColourInfo? FrameBufferDrawColour => base.DrawColourInfo;
 
+        public Vector2 FrameBufferScale { get; } = Vector2.One;
+
         // The path should not receive the true colour to avoid colour doubling when the frame-buffer is rendered to the back-buffer.
         public override DrawColourInfo DrawColourInfo => new DrawColourInfo(Color4.White, base.DrawColourInfo.Blending);
 

osu.Framework/Graphics/Lines/Path_DrawNode.cs

···
                 pathShader = Source.pathShader;
             }
 
-            private Vector2 pointOnCircle(float angle) => new Vector2((float)Math.Sin(angle), -(float)Math.Cos(angle));
+            private Vector2 pointOnCircle(float angle) => new Vector2(MathF.Sin(angle), -MathF.Cos(angle));
 
             private Vector2 relativePosition(Vector2 localPos) => Vector2.Divide(localPos, drawSize);
 
···
 
             private void addLineCap(Vector2 origin, float theta, float thetaDiff, RectangleF texRect)
             {
-                const float step = MathHelper.Pi / MAX_RES;
+                const float step = MathF.PI / MAX_RES;
 
                 float dir = Math.Sign(thetaDiff);
                 thetaDiff = dir * thetaDiff;
···
                 int amountPoints = (int)Math.Ceiling(thetaDiff / step);
 
                 if (dir < 0)
-                    theta += MathHelper.Pi;
+                    theta += MathF.PI;
 
                 Vector2 current = origin + pointOnCircle(theta) * radius;
                 Color4 currentColour = colourAt(current);
···
 
                 // Offset by 0.5 pixels inwards to ensure we never sample texels outside the bounds
                 RectangleF texRect = texture.GetTextureRect(new RectangleF(0.5f, 0.5f, texture.Width - 1, texture.Height - 1));
-                addLineCap(line.StartPoint, theta + MathHelper.Pi, MathHelper.Pi, texRect);
+                addLineCap(line.StartPoint, theta + MathF.PI, MathF.PI, texRect);
 
                 for (int i = 1; i < segments.Count; ++i)
                 {
···
                     theta = nextTheta;
                 }
 
-                addLineCap(line.EndPoint, theta, MathHelper.Pi, texRect);
+                addLineCap(line.EndPoint, theta, MathF.PI, texRect);
 
                 foreach (Line segment in segments)
                     addLineQuads(segment, texRect);

osu.Framework/Graphics/Lines/SmoothPath.cs

···
                 raw[i, 0] = new Rgba32(colour.R, colour.G, colour.B, colour.A * Math.Min(progress / aa_portion, 1));
             }
 
-            var texture = new TextureWithRefCount(textureWidth, 1, true);
+            var texture = new DisposableTexture(textureWidth, 1, true);
             texture.SetData(new TextureUpload(raw));
             Texture = texture;
 

osu.Framework/Graphics/OpenGL/GLWrapper.cs

···
 using osuTK.Graphics;
 using osuTK.Graphics.ES30;
 using osu.Framework.Statistics;
-using osu.Framework.MathUtils;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Colour;
 using osu.Framework.Graphics.OpenGL.Buffers;
···
         public static MaskingInfo CurrentMaskingInfo { get; private set; }
         public static RectangleI Viewport { get; private set; }
         public static RectangleF Ortho { get; private set; }
-        public static Matrix4 ProjectionMatrix { get; private set; }
+        public static RectangleI Scissor { get; private set; }
+        public static Vector2I ScissorOffset { get; private set; }
+        public static Matrix4 ProjectionMatrix { get; set; }
         public static DepthInfo CurrentDepthInfo { get; private set; }
 
         public static float BackbufferDrawDepth { get; private set; }
···
             frame_buffer_stack.Clear();
             depth_stack.Clear();
             scissor_state_stack.Clear();
+            scissor_offset_stack.Clear();
 
             BindFrameBuffer(DefaultFrameBuffer);
 
-            scissor_rect_stack.Push(new RectangleI(0, 0, (int)size.X, (int)size.Y));
-
+            Scissor = RectangleI.Empty;
+            ScissorOffset = Vector2I.Zero;
             Viewport = RectangleI.Empty;
             Ortho = RectangleF.Empty;
 
             PushScissorState(true);
             PushViewport(new RectangleI(0, 0, (int)size.X, (int)size.Y));
+            PushScissor(new RectangleI(0, 0, (int)size.X, (int)size.Y));
+            PushScissorOffset(Vector2I.Zero);
             PushMaskingInfo(new MaskingInfo
             {
                 ScreenSpaceAABB = new RectangleI(0, 0, (int)size.X, (int)size.Y),
···
             Viewport = actualRect;
 
             GL.Viewport(Viewport.Left, Viewport.Top, Viewport.Width, Viewport.Height);
-
-            UpdateScissorToCurrentViewportAndOrtho();
         }
 
         /// <summary>
···
             Viewport = actualRect;
 
             GL.Viewport(Viewport.Left, Viewport.Top, Viewport.Width, Viewport.Height);
+        }
 
-            UpdateScissorToCurrentViewportAndOrtho();
+        /// <summary>
+        /// Applies a new scissor rectangle.
+        /// </summary>
+        /// <param name="scissor">The scissor rectangle.</param>
+        public static void PushScissor(RectangleI scissor)
+        {
+            FlushCurrentBatch();
+
+            scissor_rect_stack.Push(scissor);
+            if (Scissor == scissor)
+                return;
+
+            Scissor = scissor;
+            setScissor(scissor);
+        }
+
+        /// <summary>
+        /// Applies the last scissor rectangle.
+        /// </summary>
+        public static void PopScissor()
+        {
+            Trace.Assert(scissor_rect_stack.Count > 1);
+
+            FlushCurrentBatch();
+
+            scissor_rect_stack.Pop();
+            RectangleI scissor = scissor_rect_stack.Peek();
+
+            if (Scissor == scissor)
+                return;
+
+            Scissor = scissor;
+            setScissor(scissor);
+        }
+
+        private static void setScissor(RectangleI scissor)
+        {
+            if (scissor.Width < 0)
+            {
+                scissor.X += scissor.Width;
+                scissor.Width = -scissor.Width;
+            }
+
+            if (scissor.Height < 0)
+            {
+                scissor.Y += scissor.Height;
+                scissor.Height = -scissor.Height;
+            }
+
+            GL.Scissor(scissor.X, Viewport.Height - scissor.Bottom, scissor.Width, scissor.Height);
+        }
+
+        private static readonly Stack<Vector2I> scissor_offset_stack = new Stack<Vector2I>();
+
+        /// <summary>
+        /// Applies an offset to the scissor rectangle.
+        /// </summary>
+        /// <param name="offset">The offset.</param>
+        public static void PushScissorOffset(Vector2I offset)
+        {
+            FlushCurrentBatch();
+
+            scissor_offset_stack.Push(offset);
+            if (ScissorOffset == offset)
+                return;
+
+            ScissorOffset = offset;
+        }
+
+        /// <summary>
+        /// Applies the last scissor rectangle offset.
+        /// </summary>
+        public static void PopScissorOffset()
+        {
+            Trace.Assert(scissor_offset_stack.Count > 1);
+
+            FlushCurrentBatch();
+
+            scissor_offset_stack.Pop();
+            Vector2I offset = scissor_offset_stack.Peek();
+
+            if (ScissorOffset == offset)
+                return;
+
+            ScissorOffset = offset;
         }
 
         private static readonly Stack<RectangleF> ortho_stack = new Stack<RectangleF>();
···
 
             ProjectionMatrix = Matrix4.CreateOrthographicOffCenter(Ortho.Left, Ortho.Right, Ortho.Bottom, Ortho.Top, -1, 1);
             GlobalPropertyManager.Set(GlobalProperty.ProjMatrix, ProjectionMatrix);
-
-            UpdateScissorToCurrentViewportAndOrtho();
         }
 
         /// <summary>
···
 
             ProjectionMatrix = Matrix4.CreateOrthographicOffCenter(Ortho.Left, Ortho.Right, Ortho.Bottom, Ortho.Top, -1, 1);
             GlobalPropertyManager.Set(GlobalProperty.ProjMatrix, ProjectionMatrix);
-
-            UpdateScissorToCurrentViewportAndOrtho();
         }
 
         private static readonly Stack<MaskingInfo> masking_stack = new Stack<MaskingInfo>();
···
         private static readonly Stack<int> frame_buffer_stack = new Stack<int>();
         private static readonly Stack<DepthInfo> depth_stack = new Stack<DepthInfo>();
 
-        public static void UpdateScissorToCurrentViewportAndOrtho()
-        {
-            RectangleF viewportRect = Viewport;
-            Vector2 offset = viewportRect.TopLeft - Ortho.TopLeft;
-
-            RectangleI currentScissorRect = scissor_rect_stack.Peek();
-
-            RectangleI scissorRect = new RectangleI(
-                currentScissorRect.X + (int)Math.Floor(offset.X),
-                Viewport.Height - currentScissorRect.Bottom - (int)Math.Ceiling(offset.Y),
-                currentScissorRect.Width,
-                currentScissorRect.Height);
-
-            if (!Precision.AlmostEquals(offset, Vector2.Zero))
-            {
-                ++scissorRect.Width;
-                ++scissorRect.Height;
-            }
-
-            GL.Scissor(scissorRect.X, scissorRect.Y, scissorRect.Width, scissorRect.Height);
-        }
-
         private static void setMaskingInfo(MaskingInfo maskingInfo, bool isPushing, bool overwritePreviousScissor)
         {
             FlushCurrentBatch();
···
             if (maskingInfo.Hollow)
                 GlobalPropertyManager.Set(GlobalProperty.InnerCornerRadius, maskingInfo.HollowCornerRadius);
 
-            RectangleI actualRect = maskingInfo.ScreenSpaceAABB;
-            actualRect.X += Viewport.X;
-            actualRect.Y += Viewport.Y;
-
-            // Ensure the rectangle only has positive width and height. (Required by OGL)
-            if (actualRect.Width < 0)
+            if (isPushing)
             {
-                actualRect.X += actualRect.Width;
-                actualRect.Width = -actualRect.Width;
-            }
+                // When drawing to a viewport that doesn't match the projection size (e.g. via framebuffers), the resultant image will be scaled
+                Vector2 viewportScale = Vector2.Divide(Viewport.Size, Ortho.Size);
 
-            if (actualRect.Height < 0)
-            {
-                actualRect.Y += actualRect.Height;
-                actualRect.Height = -actualRect.Height;
-            }
+                Vector2 location = (maskingInfo.ScreenSpaceAABB.Location - ScissorOffset) * viewportScale;
+                Vector2 size = maskingInfo.ScreenSpaceAABB.Size * viewportScale;
 
-            if (isPushing)
-            {
-                scissor_rect_stack.Push(overwritePreviousScissor ? actualRect : RectangleI.Intersect(scissor_rect_stack.Peek(), actualRect));
+                RectangleI actualRect = new RectangleI(
+                    (int)Math.Floor(location.X),
+                    (int)Math.Floor(location.Y),
+                    (int)Math.Ceiling(size.X),
+                    (int)Math.Ceiling(size.Y));
+
+                PushScissor(overwritePreviousScissor ? actualRect : RectangleI.Intersect(scissor_rect_stack.Peek(), actualRect));
             }
             else
-            {
-                Trace.Assert(scissor_rect_stack.Count > 1);
-                scissor_rect_stack.Pop();
-            }
-
-            UpdateScissorToCurrentViewportAndOrtho();
+                PopScissor();
         }
 
         internal static void FlushCurrentBatch()

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

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Threading;
 using osu.Framework.Graphics.Batches;
 using osu.Framework.Graphics.Primitives;
 using osuTK.Graphics.ES30;
···
         ~TextureGL()
         {
             Dispose(false);
-        }
-
-        internal int ReferenceCount;
-
-        public void Reference() => Interlocked.Increment(ref ReferenceCount);
-
-        public void Dereference()
-        {
-            if (Interlocked.Decrement(ref ReferenceCount) == 0)
-                Dispose();
         }
 
         /// <summary>

osu.Framework/Graphics/Primitives/Line.cs

···
         /// <summary>
         /// The direction of the second point from the first.
         /// </summary>
-        public float Theta => (float)Math.Atan2(EndPoint.Y - StartPoint.Y, EndPoint.X - StartPoint.X);
+        public float Theta => MathF.Atan2(EndPoint.Y - StartPoint.Y, EndPoint.X - StartPoint.X);
 
         /// <summary>
         /// The direction of this <see cref="Line"/>.

osu.Framework/Graphics/Primitives/RectangleF.cs

···
             float distX = Math.Max(0.0f, Math.Max(localSpacePos.X - Right, Left - localSpacePos.X));
             float distY = Math.Max(0.0f, Math.Max(localSpacePos.Y - Bottom, Top - localSpacePos.Y));
 
-            return (float)Math.Pow(distX, exponent) + (float)Math.Pow(distY, exponent);
+            return MathF.Pow(distX, exponent) + MathF.Pow(distY, exponent);
         }
 
         // This could be optimized further in the future, but made for a simple implementation right now.

osu.Framework/Graphics/Sprites/SpriteIcon.cs

···
                 //squared result for quadratic fall-off seems to give the best result.
                 var avgColour = (Color4)DrawColourInfo.Colour.AverageColour;
 
-                spriteShadow.Alpha = (float)Math.Pow(Math.Max(Math.Max(avgColour.R, avgColour.G), avgColour.B), 2);
+                spriteShadow.Alpha = MathF.Pow(Math.Max(Math.Max(avgColour.R, avgColour.G), avgColour.B), 2);
 
                 layout.Validate();
             }

osu.Framework/Graphics/Sprites/SpriteText_DrawNode.cs

···
                 Shader.Bind();
 
                 var avgColour = (Color4)DrawColourInfo.Colour.AverageColour;
-                float shadowAlpha = (float)Math.Pow(Math.Max(Math.Max(avgColour.R, avgColour.G), avgColour.B), 2);
+                float shadowAlpha = MathF.Pow(Math.Max(Math.Max(avgColour.R, avgColour.G), avgColour.B), 2);
 
                 //adjust shadow alpha based on highest component intensity to avoid muddy display of darker text.
                 //squared result for quadratic fall-off seems to give the best result.

osu.Framework/Graphics/Textures/DisposableTexture.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.Textures;
+using osuTK.Graphics.ES30;
+
+namespace osu.Framework.Graphics.Textures
+{
+    /// <summary>
+    /// A texture which can cleans up any resources held by the underlying <see cref="TextureGL"/> on <see cref="Dispose"/>.
+    /// </summary>
+    public class DisposableTexture : Texture
+    {
+        public DisposableTexture(TextureGL textureGl)
+            : base(textureGl)
+        {
+        }
+
+        public DisposableTexture(int width, int height, bool manualMipmaps = false, All filteringMode = All.Linear)
+            : base(width, height, manualMipmaps, filteringMode)
+        {
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            base.Dispose(isDisposing);
+            TextureGL.Dispose();
+        }
+    }
+}

osu.Framework/Graphics/Textures/LargeTextureStore.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.Diagnostics;
+using System.Threading;
 using osu.Framework.IO.Stores;
 using osuTK.Graphics.ES30;
 
···
     /// </summary>
     public class LargeTextureStore : TextureStore
     {
+        private readonly object referenceCountLock = new object();
+        private readonly Dictionary<string, TextureWithRefCount.ReferenceCount> referenceCounts = new Dictionary<string, TextureWithRefCount.ReferenceCount>();
+
         public LargeTextureStore(IResourceStore<TextureUpload> store = null)
             : base(store, false, All.Linear, true)
         {
···
         /// <returns>The texture.</returns>
         public override Texture Get(string name)
         {
-            var baseTex = base.Get(name);
+            lock (referenceCountLock)
+            {
+                var tex = base.Get(name);
 
-            if (baseTex?.TextureGL == null) return null;
+                if (tex?.TextureGL == null)
+                    return null;
 
-            // encapsulate texture for ref counting
-            return new TextureWithRefCount(baseTex.TextureGL) { ScaleAdjust = ScaleAdjust };
+                if (!referenceCounts.TryGetValue(name, out TextureWithRefCount.ReferenceCount count))
+                    referenceCounts[name] = count = new TextureWithRefCount.ReferenceCount(referenceCountLock, () => onAllReferencesLost(name));
+
+                return new TextureWithRefCount(tex.TextureGL, count);
+            }
+        }
+
+        private void onAllReferencesLost(string name)
+        {
+            Debug.Assert(Monitor.IsEntered(referenceCountLock));
+
+            referenceCounts.Remove(name);
+            Purge(name);
         }
     }
 }

osu.Framework/Graphics/Textures/TextureLoaderStore.cs

···
 
         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);
+        protected virtual Image<TPixel> ImageFromStream<TPixel>(Stream stream) where TPixel : unmanaged, IPixel<TPixel>
+            => TextureUpload.LoadFromStream<TPixel>(stream);
 
         public IEnumerable<string> GetAvailableResources() => store.GetAvailableResources();
 

osu.Framework/Graphics/Textures/TextureStore.cs

···
                 glTexture = new TextureGLSingle(upload.Width, upload.Height, manualMipmaps, filteringMode);
 
             Texture tex = new Texture(glTexture) { ScaleAdjust = ScaleAdjust };
-
             tex.SetData(upload);
 
             return tex;
···
             lock (textureCache)
             {
                 // refresh the texture if no longer available (may have been previously disposed).
-                if (!textureCache.TryGetValue(name, out var tex) || tex?.Available == false)
+                if (!textureCache.TryGetValue(name, out var tex))
                 {
                     try
                     {
···
                 }
 
                 return tex;
+            }
+        }
+
+        /// <summary>
+        /// Disposes and removes a texture with the specified name from the texture cache.
+        /// </summary>
+        /// <param name="name">The name of the texture to purge from the cache.</param>
+        protected void Purge(string name)
+        {
+            lock (textureCache)
+            {
+                if (textureCache.TryGetValue(name, out var tex))
+                    tex.Dispose();
+                textureCache.Remove(name);
             }
         }
     }

osu.Framework/Graphics/Textures/TextureUpload.cs

···
 
 using System;
 using System.IO;
+using System.Runtime.InteropServices;
 using osu.Framework.Graphics.OpenGL;
 using osu.Framework.Graphics.OpenGL.Buffers;
 using osu.Framework.Graphics.Primitives;
+using osu.Framework.Logging;
 using osuTK.Graphics.ES30;
 using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.PixelFormats;
+using StbiSharp;
 
 namespace osu.Framework.Graphics.Textures
 {
···
 
         /// <summary>
         /// Create an upload from an arbitrary image stream.
+        /// Note that this bypasses per-platform image loading optimisations.
+        /// Use <see cref="TextureLoaderStore"/> as provided from GameHost where possible.
         /// </summary>
         /// <param name="stream">The image content.</param>
         public TextureUpload(Stream stream)
-            : this(Image.Load<Rgba32>(stream))
+            : this(LoadFromStream<Rgba32>(stream))
+        {
+        }
+
+        internal static Image<TPixel> LoadFromStream<TPixel>(Stream stream) where TPixel : unmanaged, IPixel<TPixel>
         {
+            long initialPos = stream.Position;
+
+            try
+            {
+                using (var m = new MemoryStream())
+                {
+                    stream.CopyTo(m);
+                    using (var stbiImage = Stbi.LoadFromMemory(m, 4))
+                        return Image.LoadPixelData(MemoryMarshal.Cast<byte, TPixel>(stbiImage.Data), stbiImage.Width, stbiImage.Height);
+                }
+            }
+            catch (Exception e)
+            {
+                Logger.Error(e, "Texture could not be loaded via STB; falling back to ImageSharp.");
+                stream.Position = initialPos;
+                return Image.Load<TPixel>(stream);
+            }
         }
 
         /// <summary>

osu.Framework/Graphics/Textures/TextureWithRefCount.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using osu.Framework.Graphics.OpenGL;
+using System.Threading;
 using osu.Framework.Graphics.OpenGL.Textures;
-using osuTK.Graphics.ES30;
 
 namespace osu.Framework.Graphics.Textures
 {
     /// <summary>
-    /// A texture which updates the reference count of the underlying <see cref="TextureGL"/> on ctor and disposal.
+    /// A texture which shares a common reference count with all other textures using the same <see cref="TextureGL"/>.
     /// </summary>
-    public class TextureWithRefCount : Texture
+    internal class TextureWithRefCount : Texture
     {
-        public TextureWithRefCount(TextureGL textureGl)
+        private readonly ReferenceCount count;
+
+        public TextureWithRefCount(TextureGL textureGl, ReferenceCount count)
             : base(textureGl)
         {
-            textureGl.Reference();
-        }
+            this.count = count;
 
-        public TextureWithRefCount(int width, int height, bool manualMipmaps = false, All filteringMode = All.Linear)
-            : this(new TextureGLSingle(width, height, manualMipmaps, filteringMode))
-        {
+            count.Increment();
         }
-
-        internal int ReferenceCount => base.TextureGL.ReferenceCount;
 
         public sealed override TextureGL TextureGL
         {
             get
             {
-                var tex = base.TextureGL;
-                if (tex.ReferenceCount <= 0)
+                if (!Available)
                     throw new InvalidOperationException($"Attempting to access a {nameof(TextureWithRefCount)}'s underlying texture after all references are lost.");
 
-                return tex;
+                return base.TextureGL;
             }
         }
 
-        // The base property references TextureGL, but doing so may throw an exception (above)
+        // The base property invokes the overridden TextureGL property, which will throw an exception if not available
+        // So this property is redirected to reference the intended member
         public sealed override bool Available => base.TextureGL.Available;
-
-        #region Disposal
 
         ~TextureWithRefCount()
         {
···
             Dispose(false);
         }
 
-        private bool isDisposed;
+        public bool IsDisposed { get; private set; }
 
         protected override void Dispose(bool isDisposing)
         {
             base.Dispose(isDisposing);
 
-            if (isDisposed)
+            if (IsDisposed)
                 return;
 
-            isDisposed = true;
+            IsDisposed = true;
 
-            GLWrapper.ScheduleDisposal(() => base.TextureGL.Dereference());
+            count.Decrement();
         }
 
-        #endregion
+        public class ReferenceCount
+        {
+            private readonly object lockObject;
+            private readonly Action onAllReferencesLost;
+
+            private int referenceCount;
+
+            /// <summary>
+            /// Creates a new <see cref="ReferenceCount"/>.
+            /// </summary>
+            /// <param name="lockObject">The <see cref="object"/> which locks will be taken out on.</param>
+            /// <param name="onAllReferencesLost">A delegate to invoke after all references have been lost.</param>
+            public ReferenceCount(object lockObject, Action onAllReferencesLost)
+            {
+                this.lockObject = lockObject;
+                this.onAllReferencesLost = onAllReferencesLost;
+            }
+
+            /// <summary>
+            /// Increments the reference count.
+            /// </summary>
+            public void Increment()
+            {
+                lock (lockObject)
+                    Interlocked.Increment(ref referenceCount);
+            }
+
+            /// <summary>
+            /// Decrements the reference count, invoking <see cref="onAllReferencesLost"/> if there are no remaining references.
+            /// The delegate is invoked while a lock on the provided <see cref="lockObject"/> is held.
+            /// </summary>
+            public void Decrement()
+            {
+                lock (lockObject)
+                {
+                    if (Interlocked.Decrement(ref referenceCount) == 0)
+                        onAllReferencesLost?.Invoke();
+                }
+            }
+        }
     }
 }

osu.Framework/Graphics/UserInterface/CircularProgressDrawNode.cs

···
     {
         private const float arc_tolerance = 0.1f;
 
+        private const float two_pi = MathF.PI * 2;
+
         protected new CircularProgress Source => (CircularProgress)base.Source;
 
         private LinearBatch<TexturedVertex2D> halfCircleBatch;
···
 
             texture = Source.Texture;
             drawSize = Source.DrawSize;
-            angle = (float)Source.Current.Value * MathHelper.TwoPi;
+            angle = (float)Source.Current.Value * two_pi;
             innerRadius = Source.InnerRadius;
         }
 
-        private Vector2 pointOnCircle(float angle) => new Vector2((float)Math.Sin(angle), -(float)Math.Cos(angle));
-        private float angleToUnitInterval(float angle) => angle / MathHelper.TwoPi + (angle >= 0 ? 0 : 1);
+        private Vector2 pointOnCircle(float angle) => new Vector2(MathF.Sin(angle), -MathF.Cos(angle));
+        private float angleToUnitInterval(float angle) => angle / two_pi + (angle >= 0 ? 0 : 1);
 
         // Gets colour at the localPos position in the unit square of our Colour gradient box.
         private Color4 colourAt(Vector2 localPos) => DrawColourInfo.Colour.HasSingleColour
···
 
                 // Clamps the angle so we don't overshoot.
                 // dir is used so negative angles result in negative angularOffset.
-                float angularOffset = Math.Min(fract * MathHelper.TwoPi, dir * angle);
-                float normalisedOffset = angularOffset / MathHelper.TwoPi;
+                float angularOffset = Math.Min(fract * two_pi, dir * angle);
+                float normalisedOffset = angularOffset / two_pi;
 
                 if (dir < 0)
                     normalisedOffset += 1.0f;

osu.Framework/Graphics/UserInterface/SliderBar.cs

···
                 return false;
 
             var step = KeyboardStep != 0 ? KeyboardStep : (Convert.ToSingle(currentNumberInstantaneous.MaxValue) - Convert.ToSingle(currentNumberInstantaneous.MinValue)) / 20;
-            if (currentNumberInstantaneous.IsInteger) step = (float)Math.Ceiling(step);
+            if (currentNumberInstantaneous.IsInteger) step = MathF.Ceiling(step);
 
             switch (e.Key)
             {

osu.Framework/Graphics/Vector2Extensions.cs

···
         /// <param name="result">The distance</param>
         public static void Distance(ref Vector2 vec1, ref Vector2 vec2, out float result)
         {
-            result = (float)Math.Sqrt((vec2.X - vec1.X) * (vec2.X - vec1.X) + (vec2.Y - vec1.Y) * (vec2.Y - vec1.Y));
+            result = MathF.Sqrt((vec2.X - vec1.X) * (vec2.X - vec1.X) + (vec2.Y - vec1.Y) * (vec2.Y - vec1.Y));
         }
 
         /// <summary>

osu.Framework/IO/Network/JsonWebRequest.cs

···
         {
         }
 
-        protected override void ProcessResponse() => ResponseObject = JsonConvert.DeserializeObject<T>(ResponseString);
+        protected override void ProcessResponse() => ResponseObject = JsonConvert.DeserializeObject<T>(GetResponseString());
 
         public T ResponseObject { get; private set; }
     }

osu.Framework/IO/Network/WebRequest.cs

···
 
         public Stream ResponseStream;
 
-        public string ResponseString
+        [Obsolete("Use GetResponseString method instead")] // can be removed 20200521
+        public string ResponseString => GetResponseString();
+
+        /// <summary>
+        /// Retrieve the full response body as a UTF8 encoded string.
+        /// </summary>
+        /// <returns>The response body.</returns>
+        public string GetResponseString()
         {
-            get
+            try
+            {
+                ResponseStream.Seek(0, SeekOrigin.Begin);
+                StreamReader r = new StreamReader(ResponseStream, Encoding.UTF8);
+                return r.ReadToEnd();
+            }
+            catch
             {
-                try
-                {
-                    ResponseStream.Seek(0, SeekOrigin.Begin);
-                    StreamReader r = new StreamReader(ResponseStream, Encoding.UTF8);
-                    return r.ReadToEnd();
-                }
-                catch
-                {
-                    return null;
-                }
+                return null;
             }
         }
 
-        public byte[] ResponseData
+        [Obsolete("Use GetResponseData method instead")] // can be removed 20200521
+        public byte[] ResponseData => GetResponseData();
+
+        /// <summary>
+        /// Retrieve the full response body as an array of bytes.
+        /// </summary>
+        /// <returns>The response body.</returns>
+        public byte[] GetResponseData()
         {
-            get
+            try
+            {
+                byte[] data = new byte[ResponseStream.Length];
+                ResponseStream.Seek(0, SeekOrigin.Begin);
+                ResponseStream.Read(data, 0, data.Length);
+                return data;
+            }
+            catch
             {
-                try
-                {
-                    byte[] data = new byte[ResponseStream.Length];
-                    ResponseStream.Seek(0, SeekOrigin.Begin);
-                    ResponseStream.Read(data, 0, data.Length);
-                    return data;
-                }
-                catch
-                {
-                    return null;
-                }
+                return null;
             }
         }
 

osu.Framework/IO/Stores/DllResourceStore.cs

···
         {
             string filePath = Path.Combine(Path.GetDirectoryName(Assembly.GetCallingAssembly().Location), dllName);
 
-            // prefer the local file if it exists, else load from assembly cache.
-            assembly = System.IO.File.Exists(filePath) ? Assembly.LoadFrom(filePath) : Assembly.Load(Path.GetFileNameWithoutExtension(dllName));
+            // prefer the local file if it exists, else load from standard dependency resolver.
+            assembly = System.IO.File.Exists(filePath) ? Assembly.LoadFile(filePath) : Assembly.Load(Path.GetFileNameWithoutExtension(dllName));
+
+            prefix = assembly.GetName().Name;
+        }
+
+        public DllResourceStore(AssemblyName name)
+            : this(Assembly.Load(name))
+        {
+        }
 
-            prefix = Path.GetFileNameWithoutExtension(dllName);
+        public DllResourceStore(Assembly assembly)
+        {
+            this.assembly = assembly;
+            prefix = assembly.GetName().Name;
         }
 
         public byte[] Get(string name)

osu.Framework/IO/Stores/FontStore.cs

···
 
                 case GlyphStore gs:
 
-                    if (gs.CacheStorage == null)
-                        gs.CacheStorage = cacheStorage;
+                    if (gs is RawCachingGlyphStore raw && raw.CacheStorage == null)
+                        raw.CacheStorage = cacheStorage;
 
                     glyphStores.Add(gs);
                     queueLoad(gs);

osu.Framework/IO/Stores/GlyphStore.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.IO;
 using System.Linq;
 using System.Threading.Tasks;
-using osu.Framework.Extensions;
 using osu.Framework.Graphics.Textures;
 using osu.Framework.Logging;
-using osu.Framework.Platform;
 using osu.Framework.Text;
 using SharpFNT;
 using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.Advanced;
 using SixLabors.ImageSharp.PixelFormats;
-using SixLabors.Primitives;
 
 namespace osu.Framework.IO.Stores
 {
+    /// <summary>
+    /// A basic glyph store that will load font sprite sheets every character retrieval.
+    /// </summary>
     public class GlyphStore : IResourceStore<TextureUpload>, IGlyphStore
     {
-        private readonly string assetName;
+        protected readonly string AssetName;
+
+        protected readonly IResourceStore<TextureUpload> TextureLoader;
 
         public readonly string FontName;
 
-        private const float default_size = 96;
-
-        private readonly ResourceStore<byte[]> store;
+        protected readonly ResourceStore<byte[]> Store;
 
         protected BitmapFont Font => completionSource.Task.Result;
 
         private readonly TaskCompletionSource<BitmapFont> completionSource = new TaskCompletionSource<BitmapFont>();
 
-        internal Storage CacheStorage;
-
-        private Task fontLoadTask;
-
-        public GlyphStore(ResourceStore<byte[]> store, string assetName = null)
+        /// <summary>
+        /// Create a new glyph store.
+        /// </summary>
+        /// <param name="store">The store to provide font resources.</param>
+        /// <param name="assetName">The base name of thße font.</param>
+        /// <param name="textureLoader">An optional platform-specific store for loading textures. Should load for the store provided in <param ref="param"/>.</param>
+        public GlyphStore(ResourceStore<byte[]> store, string assetName = null, IResourceStore<TextureUpload> textureLoader = null)
         {
-            this.store = new ResourceStore<byte[]>(store);
+            Store = new ResourceStore<byte[]>(store);
 
-            this.store.AddExtension("fnt");
-            this.store.AddExtension("bin");
+            Store.AddExtension("fnt");
+            Store.AddExtension("bin");
 
-            this.assetName = assetName;
+            AssetName = assetName;
+            TextureLoader = textureLoader;
 
             FontName = assetName?.Split('/').Last();
         }
 
+        private Task fontLoadTask;
+
         public Task LoadFontAsync() => fontLoadTask ??= Task.Factory.StartNew(() =>
         {
             try
             {
                 BitmapFont font;
-                using (var s = store.GetStream($@"{assetName}"))
+                using (var s = Store.GetStream($@"{AssetName}"))
                     font = BitmapFont.FromStream(s, FormatHint.Binary, false);
 
                 completionSource.SetResult(font);
             }
             catch (Exception ex)
             {
-                Logger.Error(ex, $"Couldn't load font asset from {assetName}.");
+                Logger.Error(ex, $"Couldn't load font asset from {AssetName}.");
                 completionSource.SetResult(null);
                 throw;
             }
···
             return Font.Common.Base;
         }
 
-        public TextureUpload Get(string name)
-        {
-            if (name.Length > 1 && !name.StartsWith($@"{FontName}/", StringComparison.Ordinal))
-                return null;
-
-            if (!Font.Characters.TryGetValue(name.Last(), out Character c))
-                return null;
-
-            return loadCharacter(c);
-        }
-
-        public virtual async Task<TextureUpload> GetAsync(string name)
+        protected virtual TextureUpload GetPageImage(int page)
         {
-            if (name.Length > 1 && !name.StartsWith($@"{FontName}/", StringComparison.Ordinal))
-                return null;
+            if (TextureLoader != null)
+                return TextureLoader.Get(GetFilenameForPage(page));
 
-            if (!(await completionSource.Task).Characters.TryGetValue(name.Last(), out Character c))
-                return null;
-
-            return loadCharacter(c);
+            using (var stream = Store.GetStream(GetFilenameForPage(page)))
+                return new TextureUpload(stream);
         }
 
-        Task<CharacterGlyph> IResourceStore<CharacterGlyph>.GetAsync(string name) => Task.Run(() => ((IGlyphStore)this).Get(name[0]));
-
-        CharacterGlyph IResourceStore<CharacterGlyph>.Get(string name) => Get(name[0]);
+        protected string GetFilenameForPage(int page)
+            => $@"{AssetName}_{page.ToString().PadLeft((Font.Pages.Count - 1).ToString().Length, '0')}.png";
 
         public CharacterGlyph Get(char character)
         {
···
 
         public int GetKerning(char left, char right) => Font.GetKerningAmount(left, right);
 
-        private readonly Dictionary<int, PageInfo> pageLookup = new Dictionary<int, PageInfo>();
+        Task<CharacterGlyph> IResourceStore<CharacterGlyph>.GetAsync(string name) => Task.Run(() => ((IGlyphStore)this).Get(name[0]));
 
-        private class PageInfo
-        {
-            public string Filename;
-            public Size Size;
-        }
+        CharacterGlyph IResourceStore<CharacterGlyph>.Get(string name) => Get(name[0]);
 
-        private TextureUpload loadCharacter(Character c)
+        public TextureUpload Get(string name)
         {
-            if (!pageLookup.TryGetValue(c.Page, out var pageInfo))
-            {
-                string filename = $@"{assetName}_{c.Page.ToString().PadLeft((Font.Pages.Count - 1).ToString().Length, '0')}.png";
+            if (name.Length > 1 && !name.StartsWith($@"{FontName}/", StringComparison.Ordinal))
+                return null;
 
-                using (var stream = store.GetStream(filename))
-                using (var convert = Image.Load<Rgba32>(stream))
-                {
-                    string streamMd5 = stream.ComputeMD5Hash();
-                    string filenameMd5 = filename.ComputeMD5Hash();
+            if (!Font.Characters.TryGetValue(name.Last(), out Character c))
+                return null;
 
-                    string accessFilename = $"{filenameMd5}#{streamMd5}";
+            return LoadCharacter(c);
+        }
 
-                    var existing = CacheStorage.GetFiles(string.Empty, $"{accessFilename}*").FirstOrDefault();
+        public virtual async Task<TextureUpload> GetAsync(string name)
+        {
+            if (name.Length > 1 && !name.StartsWith($@"{FontName}/", StringComparison.Ordinal))
+                return null;
 
-                    if (existing != null)
-                    {
-                        var split = existing.Split('#');
-                        pageLookup[c.Page] = pageInfo = new PageInfo
-                        {
-                            Size = new Size(int.Parse(split[2]), int.Parse(split[3])),
-                            Filename = existing
-                        };
-                    }
-                    else
-                    {
-                        // todo: use i# memoryallocator once netstandard supports stream operations
-                        byte[] output = new byte[convert.Width * convert.Height];
+            if (!(await completionSource.Task).Characters.TryGetValue(name.Last(), out Character c))
+                return null;
 
-                        var pxl = convert.GetPixelSpan();
+            return LoadCharacter(c);
+        }
 
-                        for (int i = 0; i < convert.Width * convert.Height; i++)
-                            output[i] = pxl[i].A;
+        protected int LoadedGlyphCount;
 
-                        // ensure any stale cached versions are deleted.
-                        foreach (var f in CacheStorage.GetFiles(string.Empty, $"{filenameMd5}*"))
-                            CacheStorage.Delete(f);
+        protected virtual TextureUpload LoadCharacter(Character character)
+        {
+            var page = GetPageImage(character.Page);
+            LoadedGlyphCount++;
 
-                        accessFilename += $"#{convert.Width}#{convert.Height}";
+            var image = new Image<Rgba32>(SixLabors.ImageSharp.Configuration.Default, character.Width, character.Height, new Rgba32(255, 255, 255, 0));
 
-                        using (var outStream = CacheStorage.GetStream(accessFilename, FileAccess.Write, FileMode.Create))
-                            outStream.Write(output, 0, output.Length);
+            var dest = image.GetPixelSpan();
+            var source = page.Data;
 
-                        pageLookup[c.Page] = pageInfo = new PageInfo
-                        {
-                            Size = new Size(convert.Width, convert.Height),
-                            Filename = accessFilename
-                        };
-                    }
-                }
-            }
-
-            int pageWidth = pageInfo.Size.Width;
-
-            int charWidth = c.Width;
-            int charHeight = c.Height;
+            // the spritesheet may have unused pixels trimmed
+            int readableHeight = Math.Min(character.Height, page.Height - character.Y);
+            int readableWidth = Math.Min(character.Width, page.Width - character.X);
 
-            if (readBuffer == null || readBuffer.Length < pageWidth)
-                readBuffer = new byte[pageWidth];
-
-            var image = new Image<Rgba32>(SixLabors.ImageSharp.Configuration.Default, charWidth, charHeight, new Rgba32(255, 255, 255, 0));
-
-            using (var stream = CacheStorage.GetStream(pageInfo.Filename))
+            for (int y = 0; y < readableHeight; y++)
             {
-                var pixels = image.GetPixelSpan();
-                stream.Seek(pageWidth * c.Y, SeekOrigin.Current);
-
-                // the spritesheet may have unused pixels trimmed
-                int readableHeight = Math.Min(c.Height, pageInfo.Size.Height - c.Y);
-                int readableWidth = Math.Min(c.Width, pageWidth - c.X);
-
-                for (int y = 0; y < readableHeight; y++)
-                {
-                    stream.Read(readBuffer, 0, pageWidth);
-
-                    int writeOffset = y * charWidth;
+                int readOffset = (character.Y + y) * page.Width + character.X;
+                int writeOffset = y * character.Width;
 
-                    for (int x = 0; x < readableWidth; x++)
-                        pixels[writeOffset + x] = new Rgba32(255, 255, 255, readBuffer[c.X + x]);
-                }
+                for (int x = 0; x < readableWidth; x++)
+                    dest[writeOffset + x] = source[readOffset + x];
             }
 
             return new TextureUpload(image);
         }
-
-        private byte[] readBuffer;
 
         public Stream GetStream(string name) => throw new NotSupportedException();
 

osu.Framework/IO/Stores/OnlineStore.cs

···
                 using (WebRequest req = new WebRequest($@"{url}"))
                 {
                     await req.PerformAsync();
-                    return req.ResponseData;
+                    return req.GetResponseData();
                 }
             }
             catch
···
                 using (WebRequest req = new WebRequest($@"{url}"))
                 {
                     req.Perform();
-                    return req.ResponseData;
+                    return req.GetResponseData();
                 }
             }
             catch

osu.Framework/IO/Stores/RawCachingGlyphStore.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.Linq;
+using osu.Framework.Extensions;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Platform;
+using SharpFNT;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Advanced;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.Primitives;
+
+namespace osu.Framework.IO.Stores
+{
+    /// <summary>
+    /// A glyph store which caches font sprite sheets as raw pixels to disk on first use.
+    /// </summary>
+    /// <remarks>
+    /// This results in memory efficient lookups with good performance on solid state backed devices.
+    /// </remarks>
+    public class RawCachingGlyphStore : GlyphStore
+    {
+        public Storage CacheStorage;
+
+        public RawCachingGlyphStore(ResourceStore<byte[]> store, string assetName = null, IResourceStore<TextureUpload> textureLoader = null)
+            : base(store, assetName, textureLoader)
+        {
+        }
+
+        private readonly Dictionary<int, PageInfo> pageLookup = new Dictionary<int, PageInfo>();
+
+        protected override TextureUpload LoadCharacter(Character character)
+        {
+            if (!pageLookup.TryGetValue(character.Page, out var pageInfo))
+                pageInfo = createCachedPageInfo(character.Page);
+
+            return createTextureUpload(character, pageInfo);
+        }
+
+        private PageInfo createCachedPageInfo(int page)
+        {
+            string filename = GetFilenameForPage(page);
+
+            using (var stream = Store.GetStream(filename))
+            {
+                string streamMd5 = stream.ComputeMD5Hash();
+                string filenameMd5 = filename.ComputeMD5Hash();
+
+                string accessFilename = $"{filenameMd5}#{streamMd5}";
+
+                var existing = CacheStorage.GetFiles(string.Empty, $"{accessFilename}*").FirstOrDefault();
+
+                if (existing != null)
+                {
+                    var split = existing.Split('#');
+                    return pageLookup[page] = new PageInfo
+                    {
+                        Size = new Size(int.Parse(split[2]), int.Parse(split[3])),
+                        Filename = existing
+                    };
+                }
+
+                using (var convert = GetPageImage(page))
+                {
+                    // todo: use i# memoryallocator once netstandard supports stream operations
+                    byte[] output = new byte[convert.Width * convert.Height];
+
+                    var pxl = convert.Data;
+
+                    for (int i = 0; i < convert.Width * convert.Height; i++)
+                        output[i] = pxl[i].A;
+
+                    // ensure any stale cached versions are deleted.
+                    foreach (var f in CacheStorage.GetFiles(string.Empty, $"{filenameMd5}*"))
+                        CacheStorage.Delete(f);
+
+                    accessFilename += $"#{convert.Width}#{convert.Height}";
+
+                    using (var outStream = CacheStorage.GetStream(accessFilename, FileAccess.Write, FileMode.Create))
+                        outStream.Write(output, 0, output.Length);
+
+                    return pageLookup[page] = new PageInfo
+                    {
+                        Size = new Size(convert.Width, convert.Height),
+                        Filename = accessFilename
+                    };
+                }
+            }
+        }
+
+        private TextureUpload createTextureUpload(Character character, PageInfo page)
+        {
+            int pageWidth = page.Size.Width;
+
+            if (readBuffer == null || readBuffer.Length < pageWidth)
+                readBuffer = new byte[pageWidth];
+
+            var image = new Image<Rgba32>(SixLabors.ImageSharp.Configuration.Default, character.Width, character.Height, new Rgba32(255, 255, 255, 0));
+
+            using (var source = CacheStorage.GetStream(page.Filename))
+            {
+                var dest = image.GetPixelSpan();
+                source.Seek(pageWidth * character.Y, SeekOrigin.Current);
+
+                // the spritesheet may have unused pixels trimmed
+                int readableHeight = Math.Min(character.Height, page.Size.Height - character.Y);
+                int readableWidth = Math.Min(character.Width, pageWidth - character.X);
+
+                for (int y = 0; y < readableHeight; y++)
+                {
+                    source.Read(readBuffer, 0, pageWidth);
+
+                    int writeOffset = y * character.Width;
+
+                    for (int x = 0; x < readableWidth; x++)
+                        dest[writeOffset + x] = new Rgba32(255, 255, 255, readBuffer[character.X + x]);
+                }
+            }
+
+            return new TextureUpload(image);
+        }
+
+        private byte[] readBuffer;
+
+        private class PageInfo
+        {
+            public string Filename;
+            public Size Size;
+        }
+    }
+}

osu.Framework/Input/InputResampler.cs

···
                 }
 
                 // HD if it has fractions
-                if (position.X - (float)Math.Truncate(position.X) != 0)
+                if (position.X - MathF.Truncate(position.X) != 0)
                     isRawInput = true;
             }
 

osu.Framework/MathUtils/Interpolation.cs

···
                 val1.Height + t * (val2.X - val1.Height));
         }
 
-        public static double ApplyEasing(Easing easing, double time)
-        {
-            const double elastic_const = 2 * Math.PI / .3;
-            const double elastic_const2 = .3 / 4;
+        #region Easing constants
+
+        private const double elastic_const = 2 * Math.PI / .3;
+        private const double elastic_const2 = .3 / 4;
+
+        private const double back_const = 1.70158;
+        private const double back_const2 = back_const * 1.525;
+
+        private const double bounce_const = 1 / 2.75;
 
-            const double back_const = 1.70158;
-            const double back_const2 = back_const * 1.525;
+        // constants used to fix expo and elastic curves to start/end at 0/1
+        private static readonly double expo_offset = Math.Pow(2, -10);
+        private static readonly double elastic_offset_full = Math.Pow(2, -11);
+        private static readonly double elastic_offset_half = Math.Pow(2, -10) * Math.Sin((.5 - elastic_const2) * elastic_const);
+        private static readonly double elastic_offset_quarter = Math.Pow(2, -10) * Math.Sin((.25 - elastic_const2) * elastic_const);
+        private static readonly double in_out_elastic_offset = Math.Pow(2, -10) * Math.Sin((1 - elastic_const2 * 1.5) * elastic_const / 1.5);
 
-            const double bounce_const = 1 / 2.75;
+        #endregion
 
+        public static double ApplyEasing(Easing easing, double time)
+        {
             switch (easing)
             {
                 default:
···
                     return .5 - .5 * Math.Cos(Math.PI * time);
 
                 case Easing.InExpo:
-                    return Math.Pow(2, 10 * (time - 1));
+                    return Math.Pow(2, 10 * (time - 1)) + expo_offset * (time - 1);
 
                 case Easing.OutExpo:
-                    return -Math.Pow(2, -10 * time) + 1;
+                    return -Math.Pow(2, -10 * time) + 1 + expo_offset * time;
 
                 case Easing.InOutExpo:
-                    if (time < .5) return .5 * Math.Pow(2, 20 * time - 10);
+                    if (time < .5) return .5 * (Math.Pow(2, 20 * time - 10) + expo_offset * (2 * time - 1));
 
-                    return 1 - .5 * Math.Pow(2, -20 * time + 10);
+                    return 1 - .5 * (Math.Pow(2, -20 * time + 10) + expo_offset * (-2 * time + 1));
 
                 case Easing.InCirc:
                     return 1 - Math.Sqrt(1 - time * time);
···
                     return .5 * Math.Sqrt(1 - (time -= 2) * time) + .5;
 
                 case Easing.InElastic:
-                    return -Math.Pow(2, -10 + 10 * time) * Math.Sin((1 - elastic_const2 - time) * elastic_const);
+                    return -Math.Pow(2, -10 + 10 * time) * Math.Sin((1 - elastic_const2 - time) * elastic_const) + elastic_offset_full * (1 - time);
 
                 case Easing.OutElastic:
-                    return Math.Pow(2, -10 * time) * Math.Sin((time - elastic_const2) * elastic_const) + 1;
+                    return Math.Pow(2, -10 * time) * Math.Sin((time - elastic_const2) * elastic_const) + 1 - elastic_offset_full * time;
 
                 case Easing.OutElasticHalf:
-                    return Math.Pow(2, -10 * time) * Math.Sin((.5 * time - elastic_const2) * elastic_const) + 1;
+                    return Math.Pow(2, -10 * time) * Math.Sin((.5 * time - elastic_const2) * elastic_const) + 1 - elastic_offset_half * time;
 
                 case Easing.OutElasticQuarter:
-                    return Math.Pow(2, -10 * time) * Math.Sin((.25 * time - elastic_const2) * elastic_const) + 1;
+                    return Math.Pow(2, -10 * time) * Math.Sin((.25 * time - elastic_const2) * elastic_const) + 1 - elastic_offset_quarter * time;
 
                 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);
+                    {
+                        return -.5 * (Math.Pow(2, -10 + 10 * time) * Math.Sin((1 - elastic_const2 * 1.5 - time) * elastic_const / 1.5)
+                                      - in_out_elastic_offset * (1 - time));
+                    }
 
-                    return .5 * Math.Pow(2, -10 * --time) * Math.Sin((time - elastic_const2 * 1.5) * elastic_const / 1.5) + 1;
+                    return .5 * (Math.Pow(2, -10 * --time) * Math.Sin((time - elastic_const2 * 1.5) * elastic_const / 1.5)
+                                 - in_out_elastic_offset * time) + 1;
 
                 case Easing.InBack:
                     return time * time * ((back_const + 1) * time - back_const);

osu.Framework/Physics/RigidBodyContainer.cs

···
                 {
                     Vector2 a = corners[i];
 
-                    float startTheta = (i - 1) * (float)Math.PI / 2;
+                    float startTheta = (i - 1) * MathF.PI / 2;
 
                     for (int j = 0; j < amount_corner_steps; ++j)
                     {
-                        float theta = startTheta + j * (float)Math.PI / (2 * (amount_corner_steps - 1));
+                        float theta = startTheta + j * MathF.PI / (2 * (amount_corner_steps - 1));
 
-                        Vector2 normal = new Vector2((float)Math.Sin(theta), (float)Math.Cos(theta));
+                        Vector2 normal = new Vector2(MathF.Sin(theta), MathF.Cos(theta));
                         Vertices.Add(a + offsets[i] + normal * cornerRadius);
                         Normals.Add(normal);
                     }

osu.Framework/Platform/GameHost.cs

···
 
             cursorSensitivity = Config.GetBindable<double>(FrameworkSetting.CursorSensitivity);
 
-            Config.BindWith(FrameworkSetting.PerformanceLogging, performanceLogging);
+            DebugConfig.BindWith(DebugSetting.PerformanceLogging, performanceLogging);
             performanceLogging.BindValueChanged(logging =>
             {
                 threads.ForEach(t => t.Monitor.EnablePerformanceProfiling = logging.NewValue);

osu.Framework/Platform/Linux/LinuxGameHost.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.Platform.Linux.Native;
 using osu.Framework.Platform.Linux.Sdl;
 using osuTK;
 
···
         internal LinuxGameHost(string gameName, bool bindIPC = false, ToolkitOptions toolkitOptions = default, bool portableInstallation = false, bool useSdl = false)
             : base(gameName, bindIPC, toolkitOptions, portableInstallation, useSdl)
         {
-        }
-
-        protected override void SetupForRun()
-        {
-            base.SetupForRun();
-
-            // required for the time being to address libbass_fx.so load failures (see https://github.com/ppy/osu/issues/2852)
-            Library.Load("libbass.so", Library.LoadFlags.RTLD_LAZY | Library.LoadFlags.RTLD_GLOBAL);
         }
 
         protected override IWindow CreateWindow() =>

osu.Framework/Platform/Linux/Native/Library.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.IO;
-using System.Runtime.InteropServices;
-
-namespace osu.Framework.Platform.Linux.Native
-{
-    public static class Library
-    {
-        [DllImport("libdl.so.2", EntryPoint = "dlopen")]
-        private static extern IntPtr dlopen(string library, LoadFlags flags);
-
-        /// <summary>
-        /// Loads a library with flags to use with dlopen. Uses <see cref="LoadFlags"/> for the flags
-        ///
-        /// Uses NATIVE_DLL_SEARCH_DIRECTORIES and then ld.so for library paths
-        /// </summary>
-        /// <param name="library">Full name of the library</param>
-        /// <param name="flags">See 'man dlopen' for more information.</param>
-        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)
-                    break;
-            }
-        }
-
-        [Flags]
-        public enum LoadFlags
-        {
-            RTLD_LAZY = 0x00001,
-            RTLD_NOW = 0x00002,
-            RTLD_BINDING_MASK = 0x00003,
-            RTLD_NOLOAD = 0x00004,
-            RTLD_DEEPBIND = 0x00008,
-            RTLD_GLOBAL = 0x00100,
-            RTLD_LOCAL = 0x00000,
-            RTLD_NODELETE = 0x01000
-        }
-    }
-}

osu.Framework/Platform/Windows/WindowsStorage.cs

···
 
 using System;
 using System.Diagnostics;
-using System.Text.RegularExpressions;
 
 namespace osu.Framework.Platform.Windows
 {
···
         public WindowsStorage(string baseName, DesktopGameHost host)
             : base(baseName, host)
         {
-            // allows traversal of long directory/filenames beyond the standard limitations (see https://stackoverflow.com/a/5188559)
-            BasePath = Regex.Replace(BasePath, @"^([a-zA-Z]):\\", @"\\?\$1:\");
         }
 
         public override void OpenInNativeExplorer() => Process.Start("explorer.exe", GetFullPath(string.Empty));

osu.Framework/Testing/TestBrowser.cs

···
             var resources = game.Resources;
 
             //Roboto
-            fonts.AddStore(new GlyphStore(resources, @"Fonts/Roboto/Roboto-Regular"));
-            fonts.AddStore(new GlyphStore(resources, @"Fonts/Roboto/Roboto-Bold"));
+            game.AddFont(resources, @"Fonts/Roboto/Roboto-Regular");
+            game.AddFont(resources, @"Fonts/Roboto/Roboto-Bold");
 
             //RobotoCondensed
-            fonts.AddStore(new GlyphStore(resources, @"Fonts/RobotoCondensed/RobotoCondensed-Regular"));
-            fonts.AddStore(new GlyphStore(resources, @"Fonts/RobotoCondensed/RobotoCondensed-Bold"));
+            game.AddFont(resources, @"Fonts/RobotoCondensed/RobotoCondensed-Regular");
+            game.AddFont(resources, @"Fonts/RobotoCondensed/RobotoCondensed-Bold");
 
             showLogOverlay = frameworkConfig.GetBindable<bool>(FrameworkSetting.ShowLogOverlay);
 

osu.Framework/osu.Framework.csproj

···
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup Label="Project">
-    <TargetFrameworks>netcoreapp3.0;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>netcoreapp3.0;netstandard2.1</TargetFrameworks>
     <OutputType>Library</OutputType>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <AssemblyTitle>osu!framework</AssemblyTitle>
···
   <ItemGroup Label="Package References">
     <PackageReference Include="Markdig" Version="0.18.0" />
     <PackageReference Include="FFmpeg.AutoGen" Version="4.2.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="2.9.7" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="2.9.8" PrivateAssets="All" />
     <PackageReference Include="Microsoft.Extensions.ObjectPool" Version="3.0.1" />
-    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0-beta2-19554-01" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
     <PackageReference Include="SharpFNT" Version="1.1.0" />
     <PackageReference Include="SixLabors.ImageSharp" Version="1.0.0-beta0007" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.3.1" />
-    <PackageReference Include="System.Runtime.InteropServices" Version="4.3.0" />
-    <PackageReference Include="Microsoft.Diagnostics.Runtime" Version="1.1.46104" />
+    <PackageReference Include="Microsoft.Diagnostics.Runtime" Version="1.1.57604" />
     <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.3" />
-    <PackageReference Include="System.Reflection.Emit.Lightweight" Version="4.6.0" />
-    <PackageReference Include="System.Reflection.Emit.ILGeneration" Version="4.6.0" />
     <PackageReference Include="JetBrains.Annotations" Version="2019.1.3" />
     <PackageReference Include="ppy.osuTK.NS20" Version="1.0.115" />
     <PackageReference Include="Veldrid" Version="4.7.0" />
     <PackageReference Include="Veldrid.StartupUtilities" Version="4.7.0" />
+    <PackageReference Include="StbiSharp" Version="1.0.8" />
   </ItemGroup>
   <ItemGroup Condition="$(TargetFrameworkIdentifier) == '.NETCoreApp'">
     <!-- DO NOT use ProjectReference for native packaging project.