Merge branch 'master' into masking-negative-size

.config/dotnet-tools.json

···
         "jb"
       ]
     },
-    "nvika": {
-      "version": "2.0.0",
+    "smoogipoo.nvika": {
+      "version": "1.0.1",
       "commands": [
         "nvika"
       ]

.github/workflows/ci.yml

···
       - name: InspectCode
         run: dotnet jb inspectcode $(pwd)/osu-framework.Desktop.slnf --output=$(pwd)/inspectcodereport.xml --cachesDir=$(pwd)/inspectcode --verbosity=WARN
 
-      - name: ReSharper
-        uses: glassechidna/resharper-action@master
-        with:
-          report: ${{github.workspace}}/inspectcodereport.xml
+      - name: NVika
+        run: dotnet nvika parsereport "${{github.workspace}}/inspectcodereport.xml" --treatwarningsaserrors

.github/workflows/report-nunit.yml

···
 # See:
 #   * https://github.com/dorny/test-reporter#recommended-setup-for-public-repositories
 #   * https://docs.github.com/en/actions/reference/authentication-in-a-workflow#permissions-for-the-github_token
-name: "Test Report"
+name: Annotate CI run with test results
 on:
   workflow_run:
     workflows: ["Continuous Integration"]
     types:
       - completed
 jobs:
-  report:
+  annotate:
+    name: Annotate CI run with test results
     runs-on: ubuntu-latest
     if: ${{ github.event.workflow_run.conclusion != 'cancelled' }}
     strategy:
···
             - { prettyname: Linux }
           threadingMode: ['SingleThread', 'MultiThreaded']
     steps:
-      - name: Continuous Integration Test Report
+      - name: Annotate CI run with test results
         uses: dorny/test-reporter@v1.4.2
         with:
           artifact: osu-framework-test-results-${{matrix.os.prettyname}}-${{matrix.threadingMode}}

CodeAnalysis/BannedSymbols.txt

···
 M:System.ValueType.Equals(System.Object)~System.Boolean;Don't use object.Equals(Fallbacks to ValueType). Use IEquatable<T> or EqualityComparer<T>.Default instead.
 T:System.IComparable;Don't use non-generic IComparable. Use generic version instead.
 M:System.Enum.HasFlag(System.Enum);Use osu.Framework.Extensions.EnumExtensions.HasFlagFast<T>() instead.
-F:System.UriKind.RelativeOrAbsolute;Incompatible results when run on mono, see https://www.mono-project.com/docs/faq/known-issues/urikind-relativeorabsolute/
+F:System.UriKind.RelativeOrAbsolute;Incompatible results when run on mono (see https://www.mono-project.com/docs/faq/known-issues/urikind-relativeorabsolute/). Use Validation.TryParseUri(string, out Uri?) instead.

InspectCode.ps1

···
+dotnet tool restore
+
+# Temporarily disabled until the tool is upgraded to 5.0.
+  # The version specified in .config/dotnet-tools.json (3.1.37601) won't run on .NET hosts >=5.0.7.
+  # - cmd: dotnet format --dry-run --check
+
+dotnet CodeFileSanity
+dotnet jb inspectcode "osu-framework.Desktop.slnf" --output="inspectcodereport.xml" --caches-home="inspectcode" --verbosity=WARN
+dotnet nvika parsereport "inspectcodereport.xml" --treatwarningsaserrors
+
+exit $LASTEXITCODE

InspectCode.sh

···
+#!/bin/bash
+
+dotnet tool restore
+dotnet CodeFileSanity
+dotnet jb inspectcode "osu-framework.Desktop.slnf" --output="inspectcodereport.xml" --caches-home="inspectcode" --verbosity=WARN
+dotnet nvika parsereport "inspectcodereport.xml" --treatwarningsaserrors

README.md

···
 
 ### Code analysis
 
-Code analysis can be run with `powershell ./build.ps1` or `build.sh`. This is currently only supported under windows due to [resharper cli shortcomings](https://youtrack.jetbrains.com/issue/RSRP-410004). Alternatively, you can install resharper or use rider to get inline support in your IDE of choice.
+Code analysis can be run with `powershell ./InspectCode.ps1` or `InspectCode.sh`.
 
 ## Contributing
 

build/build.cake

···
         });
     });
 
-Task("DotnetFormat")
-    .Does(() => DotNetCoreTool(sln.FullPath, "format", "--dry-run --check"));
+// Temporarily disabled until the tool is upgraded to 5.0.
+// The version specified in .config/dotnet-tools.json (3.1.37601) won't run on .NET hosts >=5.0.7.
+// Task("DotnetFormat")
+//    .Does(() => DotNetCoreTool(sln.FullPath, "format", "--dry-run --check"));
 
 Task("PackFramework")
     .Does(() => {
···
     .IsDependentOn("Clean")
     .IsDependentOn("DetermineAppveyorBuildProperties")
     .IsDependentOn("CodeFileSanity")
-    .IsDependentOn("DotnetFormat")
+    //.IsDependentOn("DotnetFormat") <- To be uncommented after fixing the task.
     .IsDependentOn("InspectCode")
     .IsDependentOn("Test")
     .IsDependentOn("DetermineAppveyorDeployProperties")

osu.Framework.Tests/Audio/TestAudioAdjustments.cs

···
         public void TestAdjustBoundComponentBeforeBind()
         {
             var adjustments = new AudioAdjustments();
-            var adjustments2 = new AudioAdjustments();
 
-            adjustments2.Volume.Value = 0.5f;
+            var adjustments2 = new AudioAdjustments
+            {
+                Volume =
+                {
+                    Value = 0.5f
+                }
+            };
 
             adjustments.BindAdjustments(adjustments2);
 

osu.Framework.Tests/Bindables/BindableSerializationTest.cs

···
         }
 
         [Test]
+        public void TestClassWithInitialisationFromCtorArgs()
+        {
+            var toSerialize = new CustomObjWithCtorInit
+            {
+                Bindable1 = { Value = 5 }
+            };
+
+            var deserialized = JsonConvert.DeserializeObject<CustomObjWithCtorInit>(JsonConvert.SerializeObject(toSerialize));
+
+            Assert.AreEqual(toSerialize.Bindable1.Value, deserialized?.Bindable1.Value);
+        }
+
+        [Test]
         public void TestIntWithBounds()
         {
             var toSerialize = new CustomObj2
···
             JsonConvert.PopulateObject(serialized, obj);
 
             Assert.IsTrue(valueChanged);
+        }
+
+        private class CustomObjWithCtorInit
+        {
+            public readonly Bindable<int> Bindable1 = new Bindable<int>();
+
+            public CustomObjWithCtorInit(int bindable1 = 0)
+            {
+                Bindable1.Value = bindable1;
+            }
         }
 
         private class CustomObj

osu.Framework.Tests/Graphics/ColourTest.cs

···
 
         private static readonly object[][] valid_hex_colours =
         {
-            new object[] { Colour4.White, Colour4.FromHex("#fff") },
-            new object[] { Colour4.Red, Colour4.FromHex("#ff0000") },
-            new object[] { Colour4.Yellow.Opacity(half_alpha), Colour4.FromHex("ffff0080") },
-            new object[] { Colour4.Lime.Opacity(half_alpha), Colour4.FromHex("00ff0080") },
-            new object[] { new Colour4(17, 34, 51, 255), Colour4.FromHex("123") },
-            new object[] { new Colour4(17, 34, 51, 255), Colour4.FromHex("#123") },
-            new object[] { new Colour4(17, 34, 51, 68), Colour4.FromHex("1234") },
-            new object[] { new Colour4(17, 34, 51, 68), Colour4.FromHex("#1234") },
-            new object[] { new Colour4(18, 52, 86, 255), Colour4.FromHex("123456") },
-            new object[] { new Colour4(18, 52, 86, 255), Colour4.FromHex("#123456") },
-            new object[] { new Colour4(18, 52, 86, 120), Colour4.FromHex("12345678") },
-            new object[] { new Colour4(18, 52, 86, 120), Colour4.FromHex("#12345678") }
+            new object[] { Colour4.White, "#fff" },
+            new object[] { Colour4.Red, "#ff0000" },
+            new object[] { Colour4.Yellow.Opacity(half_alpha), "ffff0080" },
+            new object[] { Colour4.Lime.Opacity(half_alpha), "00ff0080" },
+            new object[] { new Colour4(17, 34, 51, 255), "123" },
+            new object[] { new Colour4(17, 34, 51, 255), "#123" },
+            new object[] { new Colour4(17, 34, 51, 68), "1234" },
+            new object[] { new Colour4(17, 34, 51, 68), "#1234" },
+            new object[] { new Colour4(18, 52, 86, 255), "123456" },
+            new object[] { new Colour4(18, 52, 86, 255), "#123456" },
+            new object[] { new Colour4(18, 52, 86, 120), "12345678" },
+            new object[] { new Colour4(18, 52, 86, 120), "#12345678" }
         };
 
         [TestCaseSource(nameof(valid_hex_colours))]
-        public void TestFromHex(Colour4 expected, Colour4 actual) => Assert.AreEqual(expected, actual);
+        public void TestFromHex(Colour4 expectedColour, string hexCode)
+        {
+            Assert.AreEqual(expectedColour, Colour4.FromHex(hexCode));
+
+            Assert.True(Colour4.TryParseHex(hexCode, out var actualColour));
+            Assert.AreEqual(expectedColour, actualColour);
+        }
 
         [TestCase("1")]
         [TestCase("#1")]
···
         {
             // Assert.Catch allows any exception type, contrary to .Throws<T>() (which expects exactly T)
             Assert.Catch(() => Colour4.FromHex(invalidColour));
+
+            Assert.False(Colour4.TryParseHex(invalidColour, out _));
         }
 
         [Test]

osu.Framework.Tests/IO/FontStoreTest.cs

···
         public void OneTimeSetUp()
         {
             storage = new TemporaryNativeStorage("fontstore-test");
-            fontResourceStore = new NamespacedResourceStore<byte[]>(new DllResourceStore(typeof(Drawable).Assembly), "Resources.Fonts.OpenSans");
+            fontResourceStore = new NamespacedResourceStore<byte[]>(new DllResourceStore(typeof(Drawable).Assembly), "Resources.Fonts.Roboto");
         }
 
         [Test]
         public void TestNestedScaleAdjust()
         {
-            using (var fontStore = new FontStore(new RawCachingGlyphStore(fontResourceStore, "OpenSans-Regular") { CacheStorage = storage }, scaleAdjust: 100))
-            using (var nestedFontStore = new FontStore(new RawCachingGlyphStore(fontResourceStore, "OpenSans-Bold") { CacheStorage = storage }, 10))
+            using (var fontStore = new FontStore(new RawCachingGlyphStore(fontResourceStore, "Roboto-Regular") { CacheStorage = storage }, scaleAdjust: 100))
+            using (var nestedFontStore = new FontStore(new RawCachingGlyphStore(fontResourceStore, "Roboto-Bold") { CacheStorage = storage }, 10))
             {
                 fontStore.AddStore(nestedFontStore);
 
-                var normalGlyph = (TexturedCharacterGlyph)fontStore.Get("OpenSans-Regular", 'a');
+                var normalGlyph = (TexturedCharacterGlyph)fontStore.Get("Roboto-Regular", 'a');
                 Assert.That(normalGlyph, Is.Not.Null);
 
-                var boldGlyph = (TexturedCharacterGlyph)fontStore.Get("OpenSans-Bold", 'a');
+                var boldGlyph = (TexturedCharacterGlyph)fontStore.Get("Roboto-Bold", 'a');
                 Assert.That(boldGlyph, Is.Not.Null);
 
                 Assert.That(normalGlyph.Scale, Is.EqualTo(1f / 100));

osu.Framework.Tests/Localisation/LocalisableEnumAttributeTest.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.Extensions;
+using osu.Framework.Localisation;
+
+namespace osu.Framework.Tests.Localisation
+{
+    [TestFixture]
+    public class LocalisableEnumAttributeTest
+    {
+        [TestCase(EnumA.Item1, "Item1")]
+        [TestCase(EnumA.Item2, "B")]
+        public void TestNonLocalisableEnumReturnsDescriptionOrToString(EnumA value, string expected)
+        {
+            Assert.That(value.GetLocalisableDescription().ToString(), Is.EqualTo(expected));
+        }
+
+        [TestCase(EnumB.Item1, "A")]
+        [TestCase(EnumB.Item2, "B")]
+        public void TestLocalisableEnumReturnsMappedValue(EnumB value, string expected)
+        {
+            Assert.That(value.GetLocalisableDescription().ToString(), Is.EqualTo(expected));
+        }
+
+        [Test]
+        public void TestLocalisableEnumWithInvalidBaseTypeThrows()
+        {
+            // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+            Assert.Throws<ArgumentException>(() => EnumC.Item1.GetLocalisableDescription().ToString());
+        }
+
+        [Test]
+        public void TestLocalisableEnumWithInvalidGenericTypeThrows()
+        {
+            // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+            Assert.Throws<InvalidOperationException>(() => EnumD.Item1.GetLocalisableDescription().ToString());
+        }
+
+        public enum EnumA
+        {
+            Item1,
+
+            [System.ComponentModel.Description("B")]
+            Item2
+        }
+
+        [LocalisableEnum(typeof(EnumBEnumLocalisationMapper))]
+        public enum EnumB
+        {
+            Item1,
+            Item2
+        }
+
+        private class EnumBEnumLocalisationMapper : EnumLocalisationMapper<EnumB>
+        {
+            public override LocalisableString Map(EnumB value)
+            {
+                switch (value)
+                {
+                    case EnumB.Item1:
+                        return "A";
+
+                    case EnumB.Item2:
+                        return "B";
+
+                    default:
+                        throw new ArgumentOutOfRangeException(nameof(value), value, null);
+                }
+            }
+        }
+
+        [LocalisableEnum(typeof(EnumCEnumLocalisationMapper))]
+        public enum EnumC
+        {
+            Item1,
+        }
+
+        private class EnumCEnumLocalisationMapper
+        {
+        }
+
+        [LocalisableEnum(typeof(EnumDEnumLocalisationMapper))]
+        public enum EnumD
+        {
+            Item1,
+        }
+
+        private class EnumDEnumLocalisationMapper : EnumLocalisationMapper<EnumA>
+        {
+            public override LocalisableString Map(EnumA value) => "A";
+        }
+    }
+}

osu.Framework.Tests/Localisation/LocalisationTest.cs

···
         }
 
         [Test]
+        public void TestConfigSettingRetainedWhenAddingNewLanguage()
+        {
+            config.SetValue(FrameworkSetting.Locale, "ja-JP");
+
+            // ensure that adding a new language which doesn't match the user's choice doesn't cause the configuration value to get reset.
+            manager.AddLanguage("po", new FakeStorage("po-OP"));
+            Assert.AreEqual("ja-JP", config.Get<string>(FrameworkSetting.Locale));
+
+            var localisedText = manager.GetLocalisedString(new TranslatableString(FakeStorage.LOCALISABLE_STRING_EN, FakeStorage.LOCALISABLE_STRING_EN));
+            Assert.AreEqual(FakeStorage.LOCALISABLE_STRING_EN, localisedText.Value);
+
+            // ensure that if the user's selection is added in a further AddLanguage call, the manager correctly translates strings.
+            manager.AddLanguage("ja-JP", new FakeStorage("ja-JP"));
+            Assert.AreEqual(FakeStorage.LOCALISABLE_STRING_JA_JP, localisedText.Value);
+        }
+
+        [Test]
         public void TestNotLocalised()
         {
             manager.AddLanguage("ja-JP", new FakeStorage("ja-JP"));

osu.Framework.Tests/Platform/GameHostSuspendTest.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
+using osu.Framework.Bindables;
+using osu.Framework.Configuration;
+using osu.Framework.Development;
 using osu.Framework.Platform;
+using osu.Framework.Threading;
 
 namespace osu.Framework.Tests.Platform
 {
···
 
         private const int timeout = 10000;
 
-        [Test]
-        public void TestPauseResume()
+        [TestCase(ExecutionMode.SingleThread)]
+        [TestCase(ExecutionMode.MultiThreaded)]
+        public void TestPauseResume(ExecutionMode threadMode)
         {
             var gameCreated = new ManualResetEventSlim();
+
+            IBindable<GameThreadState> updateThreadState = null;
 
             var task = Task.Run(() =>
             {
-                using (host = new HeadlessGameHost(@"host", false))
+                using (host = new ExecutionModeGameHost(@"host", threadMode))
                 {
                     game = new TestTestGame();
                     gameCreated.Set();
···
 
             // check scheduling is working before suspend
             var completed = new ManualResetEventSlim();
-            game.Schedule(() => completed.Set());
+            game.Schedule(() =>
+            {
+                updateThreadState = host.UpdateThread.State.GetBoundCopy();
+                updateThreadState.BindValueChanged(state =>
+                {
+                    if (state.NewValue != GameThreadState.Starting)
+                        Assert.IsTrue(ThreadSafety.IsUpdateThread);
+                });
+                completed.Set();
+            });
+
             Assert.IsTrue(completed.Wait(timeout / 10));
+            Assert.AreEqual(GameThreadState.Running, updateThreadState.Value);
 
             host.Suspend();
 
···
             int gameUpdates = 0;
             game.Scheduler.AddDelayed(() => ++gameUpdates, 0, true);
             Assert.That(() => gameUpdates, Is.LessThan(2).After(timeout / 10));
+            Assert.AreEqual(GameThreadState.Paused, updateThreadState.Value);
 
             // check that scheduler doesn't process while suspended..
             completed.Reset();
···
             // ..and does after resume.
             host.Resume();
             Assert.IsTrue(completed.Wait(timeout / 10));
+            Assert.AreEqual(GameThreadState.Running, updateThreadState.Value);
 
             game.Exit();
             Assert.IsTrue(task.Wait(timeout));
+            Assert.AreEqual(GameThreadState.Exited, updateThreadState.Value);
+        }
+
+        private class ExecutionModeGameHost : HeadlessGameHost
+        {
+            private readonly ExecutionMode threadMode;
+
+            public ExecutionModeGameHost(string name, ExecutionMode threadMode)
+                : base(name)
+            {
+                this.threadMode = threadMode;
+            }
+
+            protected override void SetupConfig(IDictionary<FrameworkSetting, object> defaultOverrides)
+            {
+                base.SetupConfig(defaultOverrides);
+                Config.SetValue(FrameworkSetting.ExecutionMode, threadMode);
+            }
         }
 
         private class TestTestGame : TestGame

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

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Configuration;
+using osu.Framework.Platform;
+
+namespace osu.Framework.Tests.Visual.Platform
+{
+    [Ignore("This test does not cover correct GL context acquire/release when run headless.")]
+    public class TestSceneExecutionModes : FrameworkTestScene
+    {
+        private Bindable<ExecutionMode> executionMode;
+
+        [BackgroundDependencyLoader]
+        private void load(FrameworkConfigManager configManager)
+        {
+            executionMode = configManager.GetBindable<ExecutionMode>(FrameworkSetting.ExecutionMode);
+        }
+
+        [Test]
+        public void ToggleModeSmokeTest()
+        {
+            AddRepeatStep("toggle execution mode", () => executionMode.Value = executionMode.Value == ExecutionMode.MultiThreaded
+                ? ExecutionMode.SingleThread
+                : ExecutionMode.MultiThreaded, 2);
+        }
+    }
+}

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

···
         private readonly SpriteText currentActualSize = new SpriteText();
         private readonly SpriteText currentDisplayMode = new SpriteText();
         private readonly SpriteText currentWindowMode = new SpriteText();
+        private readonly SpriteText currentWindowState = new SpriteText();
         private readonly SpriteText supportedWindowModes = new SpriteText();
         private readonly Dropdown<Display> displaysDropdown;
 
···
                     currentActualSize,
                     currentDisplayMode,
                     currentWindowMode,
+                    currentWindowState,
                     supportedWindowModes,
                     displaysDropdown = new BasicDropdown<Display> { Width = 600 }
                 },
···
 
             currentActualSize.Text = $"Window size: {window?.ClientSize}";
             currentDisplayMode.Text = $"Display mode: {window?.CurrentDisplayMode}";
+            currentWindowState.Text = $"Window State: {window?.WindowState}";
         }
 
         private void testResolution(int w, int h)

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

···
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 using osuTK;
 using osuTK.Graphics;
 
···
 
         private class Icon : Container, IHasTooltip
         {
-            public string TooltipText { get; }
+            public LocalisableString TooltipText { get; }
 
             public SpriteIcon SpriteIcon { get; }
 

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

···
                 SpriteText text = new SpriteText
                 {
                     Text = $@"Font testy at size {i}",
-                    Font = new FontUsage("OpenSans", i, i % 4 > 1 ? "Bold" : "Regular", i % 2 == 1),
+                    Font = new FontUsage("Roboto", i, i % 4 > 1 ? "Bold" : "Regular", i % 2 == 1),
                     AllowMultiline = true,
                     RelativeSizeAxes = Axes.X,
                 };

osu.Framework.Tests/Visual/UserInterface/TestSceneColourPicker.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;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Testing;
+
+namespace osu.Framework.Tests.Visual.UserInterface
+{
+    public class TestSceneColourPicker : FrameworkTestScene
+    {
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            ColourPicker colourPicker = null;
+
+            AddStep("create picker", () => Child = colourPicker = new BasicColourPicker());
+            AddStep("set colour externally", () => colourPicker.Current.Value = Colour4.CornflowerBlue);
+        }
+    }
+}

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

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osuTK;
+using osuTK.Graphics;
+using osuTK.Input;
+
+namespace osu.Framework.Tests.Visual.UserInterface
+{
+    public class TestSceneHSVColourPicker : ManualInputManagerTestScene
+    {
+        private TestHSVColourPicker colourPicker;
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("create picker", () => Child = colourPicker = new TestHSVColourPicker());
+        }
+
+        [Test]
+        public void HueSelectorInput()
+        {
+            assertHue(0);
+
+            AddStep("click selector centre", () =>
+            {
+                InputManager.MoveMouseTo(colourPicker.HueControl.ScreenSpaceDrawQuad.Centre);
+                InputManager.Click(MouseButton.Left);
+            });
+            assertHue(0.5f);
+
+            AddStep("click right edge of selector", () =>
+            {
+                InputManager.MoveMouseTo(new Vector2(colourPicker.HueControl.ScreenSpaceDrawQuad.TopRight.X - 1, colourPicker.HueControl.ScreenSpaceDrawQuad.Centre.Y));
+                InputManager.Click(MouseButton.Left);
+            });
+            assertHue(1);
+
+            AddStep("drag back to start", () =>
+            {
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.MoveMouseTo(new Vector2(colourPicker.HueControl.ScreenSpaceDrawQuad.TopLeft.X + 1, colourPicker.HueControl.ScreenSpaceDrawQuad.Centre.Y));
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+            assertHue(0);
+        }
+
+        [Test]
+        public void SaturationValueSelectorInput()
+        {
+            AddStep("set initial colour", () => colourPicker.Current.Value = Color4.Red);
+            assertSaturationAndValue(1, 1, 0);
+
+            AddStep("click top left corner", () =>
+            {
+                InputManager.MoveMouseTo(colourPicker.SaturationValueControl.ScreenSpaceDrawQuad.TopLeft + new Vector2(1));
+                InputManager.Click(MouseButton.Left);
+            });
+            assertSaturationAndValue(0, 1);
+
+            AddStep("drag to center", () =>
+            {
+                InputManager.PressButton(MouseButton.Left);
+                InputManager.MoveMouseTo(colourPicker.SaturationValueControl.ScreenSpaceDrawQuad.Centre);
+                InputManager.ReleaseButton(MouseButton.Left);
+            });
+            assertSaturationAndValue(0.5f, 0.5f);
+
+            AddStep("click bottom left corner", () =>
+            {
+                InputManager.MoveMouseTo(colourPicker.SaturationValueControl.ScreenSpaceDrawQuad.BottomLeft + new Vector2(1, -1));
+                InputManager.Click(MouseButton.Left);
+            });
+            assertSaturationAndValue(0, 0);
+
+            AddStep("click bottom right corner", () =>
+            {
+                InputManager.MoveMouseTo(colourPicker.SaturationValueControl.ScreenSpaceDrawQuad.BottomRight - new Vector2(1));
+                InputManager.Click(MouseButton.Left);
+            });
+            assertSaturationAndValue(1, 0);
+
+            AddStep("change hue", () =>
+            {
+                InputManager.MoveMouseTo(colourPicker.HueControl.ScreenSpaceDrawQuad.Centre);
+                InputManager.Click(MouseButton.Left);
+            });
+            assertHue(0.5f);
+        }
+
+        [Test]
+        public void TestExternalChange()
+        {
+            const float hue = 0.34f;
+            const float saturation = 0.46f;
+            const float value = 0.84f;
+            Colour4 colour = Colour4.FromHSV(hue, saturation, value);
+
+            AddStep("set colour", () => colourPicker.Current.Value = colour);
+
+            assertHue(hue);
+            assertSaturationAndValue(saturation, value);
+        }
+
+        [Test]
+        public void TestHueUnchangedIfSaturationAlmostZero()
+        {
+            AddStep("change colour", () => colourPicker.Current.Value = Colour4.FromHSV(0.5f, 0.5f, 0.5f));
+            AddStep("set saturation to 0", () => colourPicker.SaturationValueControl.Saturation.Value = 0);
+            AddAssert("hue is unchanged", () => colourPicker.HueControl.Hue.Value == 0.5f);
+        }
+
+        [Test]
+        public void TestHueDoesNotWrapAround()
+        {
+            // the hue of 1 is special, because it's equivalent to hue of 0.
+            // we want to make sure there is never a jump from 1 to 0, since it doesn't actually do anything.
+            AddStep("set hue to 1", () => colourPicker.HueControl.Hue.Value = 1);
+            AddStep("click saturation value control", () =>
+            {
+                InputManager.MoveMouseTo(colourPicker.SaturationValueControl.ScreenSpaceDrawQuad.Centre);
+                InputManager.Click(MouseButton.Left);
+            });
+            assertHue(1, 0);
+
+            AddStep("set hue to 1", () => colourPicker.HueControl.Hue.Value = 1);
+            AddStep("set colour externally", () => colourPicker.Current.Value = Colour4.Red);
+            assertHue(1, 0);
+        }
+
+        private void assertHue(float hue, float tolerance = 0.005f)
+        {
+            AddAssert($"hue selector has {hue}", () => Precision.AlmostEquals(colourPicker.HueControl.Hue.Value, hue, tolerance));
+            AddAssert($"saturation/value selector has {hue}", () => Precision.AlmostEquals(colourPicker.SaturationValueControl.Hue.Value, hue, tolerance));
+        }
+
+        private void assertSaturationAndValue(float saturation, float value, float tolerance = 0.005f)
+        {
+            AddAssert($"saturation is {saturation}", () => Precision.AlmostEquals(colourPicker.SaturationValueControl.Saturation.Value, saturation, tolerance));
+            AddAssert($"value is {value}", () => Precision.AlmostEquals(colourPicker.SaturationValueControl.Value.Value, value, tolerance));
+        }
+
+        private class TestHSVColourPicker : BasicHSVColourPicker
+        {
+            public HueSelector HueControl => this.ChildrenOfType<HueSelector>().Single();
+            public SaturationValueSelector SaturationValueControl => this.ChildrenOfType<SaturationValueSelector>().Single();
+        }
+    }
+}

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

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System.Linq;
+using NUnit.Framework;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Testing;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Framework.Tests.Visual.UserInterface
+{
+    public class TestSceneHexColourPicker : ManualInputManagerTestScene
+    {
+        private TestHexColourPicker hexColourPicker;
+        private SpriteText currentText;
+        private Box currentPreview;
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("create content", () =>
+            {
+                Child = new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Direction = FillDirection.Vertical,
+                    Spacing = new Vector2(0, 10),
+                    Children = new Drawable[]
+                    {
+                        hexColourPicker = new TestHexColourPicker(),
+                        new FillFlowContainer
+                        {
+                            RelativeSizeAxes = Axes.X,
+                            AutoSizeAxes = Axes.Y,
+                            Direction = FillDirection.Horizontal,
+                            Spacing = new Vector2(10, 0),
+                            Children = new Drawable[]
+                            {
+                                currentText = new SpriteText(),
+                                new Container
+                                {
+                                    Width = 50,
+                                    RelativeSizeAxes = Axes.Y,
+                                    Child = currentPreview = new Box
+                                    {
+                                        RelativeSizeAxes = Axes.Both
+                                    }
+                                }
+                            }
+                        }
+                    }
+                };
+
+                hexColourPicker.Current.BindValueChanged(colour =>
+                {
+                    currentText.Text = $"Current.Value = {colour.NewValue.ToHex()}";
+                    currentPreview.Colour = colour.NewValue;
+                }, true);
+            });
+        }
+
+        [Test]
+        public void TestExternalChange()
+        {
+            Colour4 colour = Colour4.Yellow;
+
+            AddStep("set current colour", () => hexColourPicker.Current.Value = colour);
+
+            AddAssert("hex code updated", () => hexColourPicker.HexCodeTextBox.Text == colour.ToHex());
+            assertPreviewUpdated(colour);
+        }
+
+        [Test]
+        public void TestTextBoxBehaviour()
+        {
+            clickTextBox();
+            AddStep("insert valid colour", () => hexColourPicker.HexCodeTextBox.Text = "#ff00ff");
+            assertPreviewUpdated(Colour4.Magenta);
+            AddAssert("current not changed yet", () => hexColourPicker.Current.Value == Colour4.White);
+
+            AddStep("commit text", () => InputManager.Key(Key.Enter));
+            AddAssert("current updated", () => hexColourPicker.Current.Value == Colour4.Magenta);
+
+            clickTextBox();
+            AddStep("insert invalid colour", () => hexColourPicker.HexCodeTextBox.Text = "c0d0");
+            AddStep("commit text", () => InputManager.Key(Key.Enter));
+            AddAssert("current not changed", () => hexColourPicker.Current.Value == Colour4.Magenta);
+            AddAssert("old hex code restored", () => hexColourPicker.HexCodeTextBox.Text == "#FF00FF");
+        }
+
+        private void clickTextBox()
+            => AddStep("click text box", () =>
+            {
+                InputManager.MoveMouseTo(hexColourPicker.HexCodeTextBox);
+                InputManager.Click(MouseButton.Left);
+            });
+
+        private void assertPreviewUpdated(Colour4 expected)
+            => AddAssert("preview colour updated", () => hexColourPicker.Preview.Current.Value == expected);
+
+        private class TestHexColourPicker : BasicHexColourPicker
+        {
+            public TextBox HexCodeTextBox => this.ChildrenOfType<TextBox>().Single();
+            public ColourPreview Preview => this.ChildrenOfType<ColourPreview>().Single();
+        }
+    }
+}

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

···
             AddAssert("has correct link", () => markdownContainer.Links[0].Url == "https://some.test.url/file");
         }
 
+        [Test]
+        public void TestAbsoluteLinkWithDifferentScheme()
+        {
+            AddStep("set content", () =>
+            {
+                markdownContainer.DocumentUrl = "https://some.test.url/some/path/2";
+                markdownContainer.RootUrl = "https://some.test.url/some/";
+                markdownContainer.Text = "[link](mailto:[e-mail])";
+            });
+
+            AddAssert("has correct link", () => markdownContainer.Links[0].Url == "mailto:[e-mail]");
+        }
+
         private class TestMarkdownContainer : MarkdownContainer
         {
             public new string DocumentUrl
···
                 UrlAdded = url => Links.Add(url)
             };
 
-            public override SpriteText CreateSpriteText() => base.CreateSpriteText().With(t => t.Font = t.Font.With("OpenSans", weight: "Regular"));
+            public override SpriteText CreateSpriteText() => base.CreateSpriteText().With(t => t.Font = t.Font.With("Roboto", weight: "Regular"));
 
             private class TestMarkdownTextFlowContainer : MarkdownTextFlowContainer
             {

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

···
             TestScreen screen1 = null;
 
             AddStep("push once", () => stack.Push(screen1 = new TestScreen()));
+            AddUntilStep("wait for screen to be loaded", () => screen1.IsLoaded);
             AddStep("exit", () => screen1.Exit());
             AddStep("push again fails", () => Assert.Throws<InvalidOperationException>(() => stack.Push(screen1)));
             AddAssert("stack in valid state", () => stack.CurrentScreen == baseScreen);

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

···
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
+using osu.Framework.Localisation;
 using osuTK;
 using osuTK.Graphics;
 
···
 
             private class CustomContent
             {
-                public readonly string Text;
+                public readonly LocalisableString Text;
 
                 public CustomContent(string text)
                 {
···
 
         private class TooltipSpriteText : Container, IHasTooltip
         {
-            public string TooltipText { get; }
+            public LocalisableString TooltipText { get; }
 
             public TooltipSpriteText(string displayedContent)
                 : this(displayedContent, displayedContent)
···
 
         private class TooltipTooltipContainer : TooltipContainer, IHasTooltip
         {
-            public string TooltipText { get; set; }
+            public LocalisableString TooltipText { get; set; }
 
             public TooltipTooltipContainer(string tooltipText)
             {
···
 
         private class TooltipTextbox : BasicTextBox, IHasTooltip
         {
-            public string TooltipText => Text;
+            public LocalisableString TooltipText => Text;
         }
 
         private class TooltipBox : Box, IHasTooltip
         {
-            public string TooltipText { get; set; }
+            public LocalisableString TooltipText { get; set; }
         }
 
         private class RectangleCursorContainer : CursorContainer

osu.Framework/Audio/Track/Waveform.cs

···
 namespace osu.Framework.Audio.Track
 {
     /// <summary>
-    /// Procsses audio sample data such that it can then be consumed to generate waveform plots of the audio.
+    /// Processes audio sample data such that it can then be consumed to generate waveform plots of the audio.
     /// </summary>
     public class Waveform : IDisposable
     {

osu.Framework/Bindables/NonNullableBindable.cs

···
             set
             {
                 if (value == null)
-                    throw new ArgumentNullException(nameof(Value), $"Cannot set {nameof(Value)} of a {nameof(NonNullableBindable<T>)} to null.");
+                    throw new ArgumentNullException(nameof(value), $"Cannot set {nameof(Value)} of a {nameof(NonNullableBindable<T>)} to null.");
 
                 base.Value = value;
             }

osu.Framework/Extensions/ExtensionMethods.cs

···
 using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Diagnostics;
 using System.Drawing;
 using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Security.Cryptography;
 using System.Text;
+using osu.Framework.Extensions.TypeExtensions;
+using osu.Framework.Localisation;
 using osu.Framework.Platform;
 using osuTK;
 
···
             }
         }
 
+        /// <summary>
+        /// Returns the description of a given enum value, via (in order):
+        /// <list type="number">
+        ///   <item>
+        ///     <description>Any <see cref="LocalisableEnumAttribute"/> attached to the enum type.</description>
+        ///   </item>
+        ///   <item>
+        ///     <description><see cref="GetDescription"/></description>
+        ///   </item>
+        /// </list>
+        /// </summary>
+        /// <exception cref="InvalidOperationException">When the enum type has an attached <see cref="LocalisableEnumAttribute"/>
+        /// and the <see cref="EnumLocalisationMapper{T}"/> could not be instantiated.</exception>
+        /// <exception cref="InvalidOperationException">When the enum type has an attached <see cref="LocalisableEnumAttribute"/>
+        /// and the type handled by the <see cref="EnumLocalisationMapper{T}"/> is not <typeparamref name="T"/>.</exception>
+        public static LocalisableString GetLocalisableDescription<T>(this T value)
+            where T : Enum
+        {
+            var enumType = value.GetType();
+
+            var mapperType = enumType.GetCustomAttribute<LocalisableEnumAttribute>()?.MapperType;
+            if (mapperType == null)
+                return GetDescription(value);
+
+            var mapperInstance = Activator.CreateInstance(mapperType);
+            if (mapperInstance == null)
+                throw new InvalidOperationException($"Could not create the {nameof(EnumLocalisationMapper<T>)} for enum type {enumType.ReadableName()}");
+
+            var mapMethod = mapperType.GetMethod(nameof(EnumLocalisationMapper<T>.Map), BindingFlags.Instance | BindingFlags.Public);
+            Debug.Assert(mapMethod != null);
+
+            var expectedMappingType = mapMethod.GetParameters()[0].ParameterType;
+            if (expectedMappingType != enumType)
+                throw new InvalidOperationException($"Cannot use {mapperType.ReadableName()} (maps {expectedMappingType.ReadableName()} enum values) to map {enumType.ReadableName()} enum values.");
+
+            var mappedValue = mapMethod.Invoke(mapperInstance, new object[] { value });
+            Debug.Assert(mappedValue != null);
+
+            return (LocalisableString)mappedValue;
+        }
+
+        /// <summary>
+        /// Returns the description of a given object, via (in order):
+        /// <list type="number">
+        ///   <item>
+        ///     <description>Any attached <see cref="DescriptionAttribute"/>.</description>
+        ///   </item>
+        ///   <item>
+        ///     <description>The object's <see cref="object.ToString()"/>.</description>
+        ///   </item>
+        /// </list>
+        /// </summary>
         public static string GetDescription(this object value)
             => value.GetType()
                     .GetField(value.ToString())?

osu.Framework/Game.cs

···
             // note that currently this means there could be two async font load operations.
             Fonts.AddStore(localFonts = new FontStore(useAtlas: false));
 
-            addFont(localFonts, Resources, @"Fonts/OpenSans/OpenSans-Regular");
-            addFont(localFonts, Resources, @"Fonts/OpenSans/OpenSans-Bold");
-            addFont(localFonts, Resources, @"Fonts/OpenSans/OpenSans-RegularItalic");
-            addFont(localFonts, Resources, @"Fonts/OpenSans/OpenSans-BoldItalic");
+            // Roboto (FrameworkFont.Regular)
+            addFont(localFonts, Resources, @"Fonts/Roboto/Roboto-Regular");
+            addFont(localFonts, Resources, @"Fonts/Roboto/Roboto-RegularItalic");
+            addFont(localFonts, Resources, @"Fonts/Roboto/Roboto-Bold");
+            addFont(localFonts, Resources, @"Fonts/Roboto/Roboto-BoldItalic");
+
+            // RobotoCondensed (FrameworkFont.Condensed)
+            addFont(localFonts, Resources, @"Fonts/RobotoCondensed/RobotoCondensed-Regular");
+            addFont(localFonts, Resources, @"Fonts/RobotoCondensed/RobotoCondensed-Bold");
 
             addFont(Fonts, Resources, @"Fonts/FontAwesome5/FontAwesome-Solid");
             addFont(Fonts, Resources, @"Fonts/FontAwesome5/FontAwesome-Regular");

osu.Framework/Graphics/Colour4.cs

···
         /// <exception cref="ArgumentException">If <paramref name="hex"/> is not a supported colour code.</exception>
         public static Colour4 FromHex(string hex)
         {
+            if (!TryParseHex(hex, out var colour))
+                throw new ArgumentException($"{hex} is not a valid colour hex string.", nameof(hex));
+
+            return colour;
+        }
+
+        /// <summary>
+        /// Attempts to convert an RGB or RGBA-formatted hex colour code into a <see cref="Colour4"/>.
+        /// Supported colour code formats:
+        /// <list type="bullet">
+        /// <item><description>RGB</description></item>
+        /// <item><description>#RGB</description></item>
+        /// <item><description>RGBA</description></item>
+        /// <item><description>#RGBA</description></item>
+        /// <item><description>RRGGBB</description></item>
+        /// <item><description>#RRGGBB</description></item>
+        /// <item><description>RRGGBBAA</description></item>
+        /// <item><description>#RRGGBBAA</description></item>
+        /// </list>
+        /// </summary>
+        /// <param name="hex">The hex code.</param>
+        /// <param name="colour">The <see cref="Colour4"/> representing the colour, if parsing succeeded.</param>
+        /// <returns>Whether the input could be parsed as a hex code.</returns>
+        public static bool TryParseHex(string hex, out Colour4 colour)
+        {
             var hexSpan = hex.StartsWith('#') ? hex.AsSpan(1) : hex.AsSpan();
 
+            bool parsed = true;
+            byte r = 255, g = 255, b = 255, a = 255;
+
             switch (hexSpan.Length)
             {
                 default:
-                    throw new ArgumentException($"Invalid hex string length {hex.Length}, expected 3, 4, 6, or 8.", nameof(hex));
+                    parsed = false;
+                    break;
 
                 case 3:
-                    return new Colour4(
-                        (byte)(byte.Parse(hexSpan.Slice(0, 1), NumberStyles.HexNumber) * 17),
-                        (byte)(byte.Parse(hexSpan.Slice(1, 1), NumberStyles.HexNumber) * 17),
-                        (byte)(byte.Parse(hexSpan.Slice(2, 1), NumberStyles.HexNumber) * 17),
-                        255);
+                    parsed &= byte.TryParse(hexSpan.Slice(0, 1), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out r);
+                    parsed &= byte.TryParse(hexSpan.Slice(1, 1), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out g);
+                    parsed &= byte.TryParse(hexSpan.Slice(2, 1), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out b);
+
+                    r *= 17;
+                    g *= 17;
+                    b *= 17;
+                    break;
 
                 case 6:
-                    return new Colour4(
-                        byte.Parse(hexSpan.Slice(0, 2), NumberStyles.HexNumber),
-                        byte.Parse(hexSpan.Slice(2, 2), NumberStyles.HexNumber),
-                        byte.Parse(hexSpan.Slice(4, 2), NumberStyles.HexNumber),
-                        255);
+                    parsed &= byte.TryParse(hexSpan.Slice(0, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out r);
+                    parsed &= byte.TryParse(hexSpan.Slice(2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out g);
+                    parsed &= byte.TryParse(hexSpan.Slice(4, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out b);
+                    break;
 
                 case 4:
-                    return new Colour4(
-                        (byte)(byte.Parse(hexSpan.Slice(0, 1), NumberStyles.HexNumber) * 17),
-                        (byte)(byte.Parse(hexSpan.Slice(1, 1), NumberStyles.HexNumber) * 17),
-                        (byte)(byte.Parse(hexSpan.Slice(2, 1), NumberStyles.HexNumber) * 17),
-                        (byte)(byte.Parse(hexSpan.Slice(3, 1), NumberStyles.HexNumber) * 17));
+                    parsed &= byte.TryParse(hexSpan.Slice(0, 1), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out r);
+                    parsed &= byte.TryParse(hexSpan.Slice(1, 1), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out g);
+                    parsed &= byte.TryParse(hexSpan.Slice(2, 1), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out b);
+                    parsed &= byte.TryParse(hexSpan.Slice(3, 1), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out a);
+
+                    r *= 17;
+                    g *= 17;
+                    b *= 17;
+                    a *= 17;
+                    break;
 
                 case 8:
-                    return new Colour4(
-                        byte.Parse(hexSpan.Slice(0, 2), NumberStyles.HexNumber),
-                        byte.Parse(hexSpan.Slice(2, 2), NumberStyles.HexNumber),
-                        byte.Parse(hexSpan.Slice(4, 2), NumberStyles.HexNumber),
-                        byte.Parse(hexSpan.Slice(6, 2), NumberStyles.HexNumber));
+                    parsed &= byte.TryParse(hexSpan.Slice(0, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out r);
+                    parsed &= byte.TryParse(hexSpan.Slice(2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out g);
+                    parsed &= byte.TryParse(hexSpan.Slice(4, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out b);
+                    parsed &= byte.TryParse(hexSpan.Slice(6, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out a);
+                    break;
             }
+
+            colour = new Colour4(r, g, b, a);
+            return parsed;
         }
 
         /// <summary>

osu.Framework/Graphics/Containers/GridContainer.cs

···
             set
             {
                 if (value == null)
-                    throw new ArgumentNullException(nameof(RowDimensions));
+                    throw new ArgumentNullException(nameof(value));
 
                 if (rowDimensions == value)
                     return;
···
             set
             {
                 if (value == null)
-                    throw new ArgumentNullException(nameof(ColumnDimensions));
+                    throw new ArgumentNullException(nameof(value));
 
                 if (columnDimensions == value)
                     return;

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

···
 using osu.Framework.Caching;
 using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Utils;
 using osuTK;
 
 namespace osu.Framework.Graphics.Containers.Markdown
···
                     if (string.IsNullOrEmpty(url))
                         continue;
 
-                    // Can't use Uri.TryCreate with RelativeOrAbsolute, see https://www.mono-project.com/docs/faq/known-issues/urikind-relativeorabsolute/.
-                    bool isAbsolute = url.Contains("://");
+                    if (!Validation.TryParseUri(url, out Uri linkUri))
+                        continue;
 
-                    if (isAbsolute)
+                    if (linkUri.IsAbsoluteUri)
                         continue;
 
                     if (documentUri != null)

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

···
 
 using Markdig.Syntax;
 using osu.Framework.Allocation;
-using osuTK;
+using osu.Framework.Graphics.Sprites;
 
 namespace osu.Framework.Graphics.Containers.Markdown
 {
···
             MarkdownTextFlowContainer textFlow;
             InternalChild = textFlow = CreateTextFlow();
 
-            textFlow.Scale = new Vector2(GetFontSizeByLevel(headingBlock.Level));
             textFlow.AddInlineText(headingBlock.Inline);
         }
 
-        public virtual MarkdownTextFlowContainer CreateTextFlow() => parentFlowComponent.CreateTextFlow();
+        public virtual MarkdownTextFlowContainer CreateTextFlow() => new MarkdownHeadingTextFlowContainer
+        {
+            FontSize = GetFontSizeByLevel(headingBlock.Level),
+        };
 
         protected virtual float GetFontSizeByLevel(int level)
         {
             switch (level)
             {
                 case 1:
-                    return 2.7f;
+                    return 54;
 
                 case 2:
-                    return 2;
+                    return 40;
 
                 case 3:
-                    return 1.5f;
+                    return 30;
 
                 case 4:
-                    return 1.3f;
+                    return 26;
 
                 default:
-                    return 1;
+                    return 20;
             }
+        }
+
+        private class MarkdownHeadingTextFlowContainer : MarkdownTextFlowContainer
+        {
+            public float FontSize;
+
+            protected override SpriteText CreateSpriteText()
+                => base.CreateSpriteText().With(t => t.Font = t.Font.With(size: FontSize));
         }
     }
 }

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

···
 using osu.Framework.Allocation;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 using osu.Framework.Platform;
 using osuTK.Graphics;
 
···
     /// </code>
     public class MarkdownLinkText : CompositeDrawable, IHasTooltip, IMarkdownTextComponent
     {
-        public string TooltipText => Url;
+        public LocalisableString TooltipText => Url;
 
         [Resolved]
         private IMarkdownTextComponent parentTextComponent { get; set; }

osu.Framework/Graphics/Cursor/IHasTooltip.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.Localisation;
+
 namespace osu.Framework.Graphics.Cursor
 {
     /// <summary>
···
         /// <summary>
         /// Tooltip text that shows when hovering the drawable.
         /// </summary>
-        string TooltipText { get; }
+        LocalisableString TooltipText { get; }
     }
 }

osu.Framework/Graphics/Cursor/TooltipContainer.cs

···
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Input;
+using osu.Framework.Localisation;
 using osuTK;
 using osuTK.Graphics;
 
···
         {
             var targetContent = getTargetContent(target);
 
-            if (targetContent is string strContent)
-                return !string.IsNullOrEmpty(strContent);
+            if (targetContent is LocalisableString localisableString)
+                return !string.IsNullOrEmpty(localisableString.Data?.ToString());
 
             return targetContent != null;
         }
···
 
             public virtual bool SetContent(object content)
             {
-                if (!(content is string contentString))
+                if (!(content is LocalisableString contentString))
                     return false;
 
                 text.Text = contentString;
···
                     },
                     text = new SpriteText
                     {
-                        Font = new FontUsage(size: text_size),
+                        Font = FrameworkFont.Regular.With(size: text_size),
                         Padding = new MarginPadding(5),
                     }
                 };

osu.Framework/Graphics/Performance/FrameStatisticsDisplay.cs

···
                                 Origin = Anchor.BottomCentre,
                                 Anchor = Anchor.CentreLeft,
                                 Rotation = -90,
+                                Font = FrameworkFont.Regular,
                             },
                             !hasCounters
                                 ? new Container { Width = 2 }
···
                                             {
                                                 Colour = getColour(t),
                                                 Text = t.ToString(),
-                                                Alpha = 0
+                                                Alpha = 0,
+                                                Font = FrameworkFont.Regular,
                                             },
                                     },
                                     new SpriteText
                                     {
                                         Padding = new MarginPadding { Left = 4 },
-                                        Text = $@"{visible_ms_range}ms"
+                                        Text = $@"{visible_ms_range}ms",
+                                        Font = FrameworkFont.Regular,
                                     },
                                     new SpriteText
                                     {
                                         Padding = new MarginPadding { Left = 4 },
                                         Text = @"0ms",
                                         Anchor = Anchor.BottomLeft,
-                                        Origin = Anchor.BottomLeft
+                                        Origin = Anchor.BottomLeft,
+                                        Font = FrameworkFont.Regular,
                                     }
                                 }
                             }
···
                         Anchor = Anchor.BottomRight,
                         Rotation = -90,
                         Position = new Vector2(-bar_width - 1, 0),
-                        Font = new FontUsage(size: 16),
+                        Font = FrameworkFont.Regular.With(size: 16),
                     },
                     box = new Box
                     {

osu.Framework/Graphics/Performance/FrameTimeDisplay.cs

···
         {
             public CounterText()
             {
-                Font = new FontUsage(fixedWidth: true);
+                Font = FrameworkFont.Regular.With(fixedWidth: true);
             }
 
             protected override char[] FixedWidthExcludeCharacters { get; } = { ',', '.', ' ' };

osu.Framework/Graphics/Shaders/ShaderManager.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.
 
+#nullable enable
+
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
···
 
 namespace osu.Framework.Graphics.Shaders
 {
-    public class ShaderManager
+    public class ShaderManager : IDisposable
     {
         private const string shader_prefix = @"sh_";
 
         private readonly ConcurrentDictionary<string, ShaderPart> partCache = new ConcurrentDictionary<string, ShaderPart>();
         private readonly ConcurrentDictionary<(string, string), Shader> shaderCache = new ConcurrentDictionary<(string, string), Shader>();
 
-        private readonly ResourceStore<byte[]> store;
+        private readonly IResourceStore<byte[]> store;
 
-        public ShaderManager(ResourceStore<byte[]> store)
+        /// <summary>
+        /// Constructs a new <see cref="ShaderManager"/>.
+        /// </summary>
+        public ShaderManager(IResourceStore<byte[]> store)
         {
             this.store = store;
         }
 
-        private string getFileEnding(ShaderType type)
+        /// <summary>
+        /// Retrieves raw shader data from the store.
+        /// Use <see cref="Load"/> to retrieve a usable <see cref="IShader"/> instead.
+        /// </summary>
+        /// <param name="name">The shader name.</param>
+        public virtual byte[]? LoadRaw(string name) => store.Get(name);
+
+        /// <summary>
+        /// Retrieves a usable <see cref="IShader"/> given the vertex and fragment shaders.
+        /// </summary>
+        /// <param name="vertex">The vertex shader name.</param>
+        /// <param name="fragment">The fragment shader name.</param>
+        /// <param name="continuousCompilation"></param>
+        public IShader Load(string vertex, string fragment, bool continuousCompilation = false)
         {
-            switch (type)
+            var tuple = (vertex, fragment);
+
+            if (shaderCache.TryGetValue(tuple, out Shader? shader))
+                return shader;
+
+            List<ShaderPart> parts = new List<ShaderPart>
             {
-                case ShaderType.FragmentShader:
-                    return @".fs";
+                createShaderPart(vertex, ShaderType.VertexShader),
+                createShaderPart(fragment, ShaderType.FragmentShader)
+            };
 
-                case ShaderType.VertexShader:
-                    return @".vs";
-            }
+            return shaderCache[tuple] = new Shader($"{vertex}/{fragment}", parts);
+        }
+
+        private ShaderPart createShaderPart(string name, ShaderType type, bool bypassCache = false)
+        {
+            name = ensureValidName(name, type);
+
+            if (!bypassCache && partCache.TryGetValue(name, out ShaderPart? part))
+                return part;
 
-            return string.Empty;
+            byte[]? rawData = LoadRaw(name);
+
+            part = new ShaderPart(name, rawData, type, this);
+
+            //cache even on failure so we don't try and fail every time.
+            partCache[name] = part;
+            return part;
         }
 
         private string ensureValidName(string name, ShaderType type)
         {
             string ending = getFileEnding(type);
+
             if (!name.StartsWith(shader_prefix, StringComparison.Ordinal))
                 name = shader_prefix + name;
             if (name.EndsWith(ending, StringComparison.Ordinal))
···
             return name + ending;
         }
 
-        internal byte[] LoadRaw(string name) => store.Get(name);
+        private string getFileEnding(ShaderType type)
+        {
+            switch (type)
+            {
+                case ShaderType.FragmentShader:
+                    return @".fs";
 
-        private ShaderPart createShaderPart(string name, ShaderType type, bool bypassCache = false)
-        {
-            name = ensureValidName(name, type);
+                case ShaderType.VertexShader:
+                    return @".vs";
+            }
 
-            if (!bypassCache && partCache.TryGetValue(name, out ShaderPart part))
-                return part;
+            return string.Empty;
+        }
 
-            byte[] rawData = LoadRaw(name);
+        #region IDisposable Support
 
-            part = new ShaderPart(name, rawData, type, this);
+        private bool isDisposed;
 
-            //cache even on failure so we don't try and fail every time.
-            partCache[name] = part;
-            return part;
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
         }
 
-        public IShader Load(string vertex, string fragment, bool continuousCompilation = false)
+        protected virtual void Dispose(bool disposing)
         {
-            var tuple = (vertex, fragment);
-
-            if (shaderCache.TryGetValue(tuple, out Shader shader))
-                return shader;
-
-            List<ShaderPart> parts = new List<ShaderPart>
+            if (!isDisposed)
             {
-                createShaderPart(vertex, ShaderType.VertexShader),
-                createShaderPart(fragment, ShaderType.FragmentShader)
-            };
+                isDisposed = true;
+                store.Dispose();
+            }
+        }
 
-            return shaderCache[tuple] = new Shader($"{vertex}/{fragment}", parts);
-        }
+        #endregion
     }
 
     public static class VertexShaderDescriptor

osu.Framework/Graphics/UserInterface/BasicColourPicker.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+namespace osu.Framework.Graphics.UserInterface
+{
+    public class BasicColourPicker : ColourPicker
+    {
+        protected override HSVColourPicker CreateHSVColourPicker() => new BasicHSVColourPicker();
+        protected override HexColourPicker CreateHexColourPicker() => new BasicHexColourPicker();
+    }
+}

osu.Framework/Graphics/UserInterface/BasicHSVColourPicker.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.Containers;
+using osu.Framework.Graphics.Shapes;
+using osuTK;
+
+namespace osu.Framework.Graphics.UserInterface
+{
+    public class BasicHSVColourPicker : HSVColourPicker
+    {
+        public BasicHSVColourPicker()
+        {
+            Background.Colour = FrameworkColour.GreenDark;
+
+            Content.Padding = new MarginPadding(20);
+            Content.Spacing = new Vector2(0, 10);
+        }
+
+        protected override HueSelector CreateHueSelector() => new BasicHueSelector();
+        protected override SaturationValueSelector CreateSaturationValueSelector() => new BasicSaturationValueSelector();
+
+        public class BasicHueSelector : HueSelector
+        {
+            protected override Drawable CreateSliderNub() => new BasicHueSelectorNub();
+        }
+
+        public class BasicHueSelectorNub : CompositeDrawable
+        {
+            public BasicHueSelectorNub()
+            {
+                InternalChild = new Container
+                {
+                    RelativeSizeAxes = Axes.Y,
+                    Width = 8,
+                    Height = 1.2f,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Child = new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0,
+                        AlwaysPresent = true
+                    },
+                    Masking = true,
+                    BorderColour = FrameworkColour.YellowGreen,
+                    BorderThickness = 4
+                };
+            }
+        }
+
+        public class BasicSaturationValueSelector : SaturationValueSelector
+        {
+            protected override Marker CreateMarker() => new BasicMarker();
+
+            private class BasicMarker : Marker
+            {
+                private readonly Box colourPreview;
+
+                public BasicMarker()
+                {
+                    InternalChild = new Container
+                    {
+                        Size = new Vector2(15),
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                        Masking = true,
+                        BorderColour = FrameworkColour.YellowGreen,
+                        BorderThickness = 4,
+                        Child = colourPreview = new Box
+                        {
+                            RelativeSizeAxes = Axes.Both
+                        }
+                    };
+                }
+
+                protected override void LoadComplete()
+                {
+                    base.LoadComplete();
+
+                    Current.BindValueChanged(_ => updatePreview(), true);
+                }
+
+                private void updatePreview() => colourPreview.Colour = Current.Value;
+            }
+        }
+    }
+}

osu.Framework/Graphics/UserInterface/BasicHexColourPicker.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.Shapes;
+
+namespace osu.Framework.Graphics.UserInterface
+{
+    public class BasicHexColourPicker : HexColourPicker
+    {
+        public BasicHexColourPicker()
+        {
+            Background.Colour = FrameworkColour.GreenDarker;
+
+            Padding = new MarginPadding(20);
+            Spacing = 10;
+        }
+
+        protected override TextBox CreateHexCodeTextBox() => new BasicTextBox
+        {
+            Height = 40
+        };
+
+        protected override ColourPreview CreateColourPreview() => new BasicColourPreview();
+
+        private class BasicColourPreview : ColourPreview
+        {
+            private readonly Box previewBox;
+
+            public BasicColourPreview()
+            {
+                InternalChild = previewBox = new Box
+                {
+                    RelativeSizeAxes = Axes.Both
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                Current.BindValueChanged(_ => updatePreview(), true);
+            }
+
+            private void updatePreview()
+            {
+                previewBox.Colour = Current.Value;
+            }
+        }
+    }
+}

osu.Framework/Graphics/UserInterface/BasicTabControl.cs

···
                 {
                     Margin = new MarginPadding(2),
                     Text = value.ToString(),
-                    Font = new FontUsage(size: 18),
+                    Font = FrameworkFont.Regular.With(size: 18),
                 });
             }
 
···
                     Foreground.RelativeSizeAxes = Axes.None;
                     Foreground.AutoSizeAxes = Axes.Both;
 
-                    Foreground.Child = new SpriteText { Text = "…" };
+                    Foreground.Child = new SpriteText
+                    {
+                        Text = "…",
+                        Font = FrameworkFont.Regular
+                    };
                 }
             }
         }

osu.Framework/Graphics/UserInterface/ColourPicker.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Containers;
+
+namespace osu.Framework.Graphics.UserInterface
+{
+    /// <summary>
+    /// A group of controls to be used for selecting a colour.
+    /// Allows both for mouse-interactive input (via <see cref="HSVColourPicker"/>) and textual input (via <see cref="HexColourPicker"/>).
+    /// </summary>
+    public abstract class ColourPicker : CompositeDrawable, IHasCurrentValue<Colour4>
+    {
+        private readonly BindableWithCurrent<Colour4> current = new BindableWithCurrent<Colour4>();
+
+        public Bindable<Colour4> Current
+        {
+            get => current.Current;
+            set => current.Current = value;
+        }
+
+        private readonly HSVColourPicker hsvColourPicker;
+        private readonly HexColourPicker hexColourPicker;
+
+        protected ColourPicker()
+        {
+            Current.Value = Colour4.White;
+            AutoSizeAxes = Axes.Y;
+            Width = 300;
+
+            InternalChildren = new Drawable[]
+            {
+                new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Direction = FillDirection.Vertical,
+                    Children = new Drawable[]
+                    {
+                        hsvColourPicker = CreateHSVColourPicker().With(d =>
+                        {
+                            d.RelativeSizeAxes = Axes.X;
+                            d.Width = 1;
+                        }),
+                        hexColourPicker = CreateHexColourPicker().With(d =>
+                        {
+                            d.RelativeSizeAxes = Axes.X;
+                            d.Width = 1;
+                        })
+                    }
+                }
+            };
+        }
+
+        /// <summary>
+        /// Creates the control that allows for interactively specifying the target colour, using the hue-saturation-value colour model.
+        /// </summary>
+        protected abstract HSVColourPicker CreateHSVColourPicker();
+
+        /// <summary>
+        /// Creates the control that allows for specifying the target colour using a hex code.
+        /// </summary>
+        protected abstract HexColourPicker CreateHexColourPicker();
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            hsvColourPicker.Current = Current;
+            hexColourPicker.Current = Current;
+        }
+    }
+}

osu.Framework/Graphics/UserInterface/Dropdown.cs

···
                     return t.Text;
 
                 case Enum e:
-                    return e.GetDescription();
+                    return e.GetLocalisableDescription();
 
                 default:
                     return item?.ToString() ?? "null";

osu.Framework/Graphics/UserInterface/HSVColourPicker.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+
+namespace osu.Framework.Graphics.UserInterface
+{
+    /// <summary>
+    /// Control that allows for specifying a colour using the hue-saturation-value (HSV) colour model.
+    /// </summary>
+    public abstract partial class HSVColourPicker : CompositeDrawable, IHasCurrentValue<Colour4>
+    {
+        private readonly BindableWithCurrent<Colour4> current = new BindableWithCurrent<Colour4>();
+
+        public Bindable<Colour4> Current
+        {
+            get => current.Current;
+            set => current.Current = value;
+        }
+
+        /// <summary>
+        /// The background of the control.
+        /// </summary>
+        protected Box Background { get; }
+
+        /// <summary>
+        /// Contains the elements of the colour picker.
+        /// </summary>
+        protected FillFlowContainer Content { get; }
+
+        private readonly SaturationValueSelector saturationValueSelector;
+        private readonly HueSelector hueSelector;
+
+        protected HSVColourPicker()
+        {
+            Width = 300;
+            AutoSizeAxes = Axes.Y;
+            Current.Value = Colour4.White;
+
+            InternalChildren = new Drawable[]
+            {
+                Background = new Box
+                {
+                    RelativeSizeAxes = Axes.Both
+                },
+                Content = new FillFlowContainer
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Direction = FillDirection.Vertical,
+                    Children = new Drawable[]
+                    {
+                        saturationValueSelector = CreateSaturationValueSelector(),
+                        hueSelector = CreateHueSelector()
+                    }
+                }
+            };
+        }
+
+        /// <summary>
+        /// Creates the control to be used for interactively selecting the hue of the target colour.
+        /// </summary>
+        protected abstract HueSelector CreateHueSelector();
+
+        /// <summary>
+        /// Creates the control to be used for interactively selecting the saturation and value of the target colour.
+        /// </summary>
+        protected abstract SaturationValueSelector CreateSaturationValueSelector();
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            saturationValueSelector.Current.BindTo(current);
+            hueSelector.Hue.BindTo(saturationValueSelector.Hue);
+        }
+    }
+}

osu.Framework/Graphics/UserInterface/HSVColourPicker_HueSelector.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shaders;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+using osuTK;
+
+namespace osu.Framework.Graphics.UserInterface
+{
+    public abstract partial class HSVColourPicker
+    {
+        public abstract class HueSelector : CompositeDrawable
+        {
+            public Bindable<float> Hue { get; } = new BindableFloat
+            {
+                MinValue = 0,
+                MaxValue = 1
+            };
+
+            /// <summary>
+            /// The body of the hue slider.
+            /// </summary>
+            protected readonly Container SliderBar;
+
+            private readonly Drawable nub;
+
+            protected HueSelector()
+            {
+                AutoSizeAxes = Axes.Y;
+                RelativeSizeAxes = Axes.X;
+
+                InternalChildren = new[]
+                {
+                    SliderBar = new Container
+                    {
+                        Height = 30,
+                        RelativeSizeAxes = Axes.X,
+                        Child = new HueSelectorBackground
+                        {
+                            RelativeSizeAxes = Axes.Both
+                        }
+                    },
+                    nub = CreateSliderNub().With(d =>
+                    {
+                        d.RelativeSizeAxes = Axes.Y;
+                        d.RelativePositionAxes = Axes.X;
+                    })
+                };
+            }
+
+            /// <summary>
+            /// Creates the nub which will be used for the hue slider.
+            /// </summary>
+            protected abstract Drawable CreateSliderNub();
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                Hue.BindValueChanged(_ => Scheduler.AddOnce(updateNubPosition), true);
+            }
+
+            private void updateNubPosition()
+            {
+                nub.Position = new Vector2(Hue.Value, 0);
+            }
+
+            protected override bool OnMouseDown(MouseDownEvent e)
+            {
+                handleMouseInput(e.ScreenSpaceMousePosition);
+                return true;
+            }
+
+            protected override bool OnDragStart(DragStartEvent e)
+            {
+                handleMouseInput(e.ScreenSpaceMousePosition);
+                return true;
+            }
+
+            protected override void OnDrag(DragEvent e)
+            {
+                handleMouseInput(e.ScreenSpaceMousePosition);
+            }
+
+            private void handleMouseInput(Vector2 mousePosition)
+            {
+                var localSpacePosition = ToLocalSpace(mousePosition);
+                Hue.Value = localSpacePosition.X / DrawWidth;
+            }
+
+            private class HueSelectorBackground : Box, ITexturedShaderDrawable
+            {
+                public new IShader TextureShader { get; private set; }
+                public new IShader RoundedTextureShader { get; private set; }
+
+                [BackgroundDependencyLoader]
+                private void load(ShaderManager shaders)
+                {
+                    TextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, "HueSelectorBackground");
+                    RoundedTextureShader = shaders.Load(VertexShaderDescriptor.TEXTURE_2, "HueSelectorBackgroundRounded");
+                }
+            }
+        }
+    }
+}

osu.Framework/Graphics/UserInterface/HSVColourPicker_SaturationValueSelector.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+using osu.Framework.Utils;
+using osuTK;
+
+namespace osu.Framework.Graphics.UserInterface
+{
+    public abstract partial class HSVColourPicker
+    {
+        public abstract class SaturationValueSelector : CompositeDrawable
+        {
+            public readonly Bindable<Colour4> Current = new Bindable<Colour4>();
+
+            public Bindable<float> Hue { get; } = new BindableFloat
+            {
+                MinValue = 0,
+                MaxValue = 1
+            };
+
+            public Bindable<float> Saturation { get; } = new BindableFloat
+            {
+                MinValue = 0,
+                MaxValue = 1
+            };
+
+            public Bindable<float> Value { get; } = new BindableFloat
+            {
+                MinValue = 0,
+                MaxValue = 1
+            };
+
+            /// <summary>
+            /// The gradiented box serving as the selection area.
+            /// </summary>
+            protected Container SelectionArea { get; }
+
+            private readonly Box hueBox;
+            private readonly Drawable marker;
+
+            protected SaturationValueSelector()
+            {
+                RelativeSizeAxes = Axes.X;
+
+                InternalChildren = new[]
+                {
+                    SelectionArea = new Container
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Children = new[]
+                        {
+                            hueBox = new Box
+                            {
+                                Name = "Hue",
+                                RelativeSizeAxes = Axes.Both
+                            },
+                            new Box
+                            {
+                                Name = "Saturation",
+                                RelativeSizeAxes = Axes.Both,
+                                Colour = ColourInfo.GradientHorizontal(Colour4.White, Colour4.White.Opacity(0))
+                            },
+                            new Box
+                            {
+                                Name = "Value",
+                                RelativeSizeAxes = Axes.Both,
+                                Colour = ColourInfo.GradientVertical(Colour4.Black.Opacity(0), Colour4.Black)
+                            },
+                        }
+                    },
+                    marker = CreateMarker().With(d =>
+                    {
+                        d.Current.BindTo(Current);
+
+                        d.Origin = Anchor.Centre;
+                        d.RelativePositionAxes = Axes.Both;
+                    })
+                };
+            }
+
+            /// <summary>
+            /// Creates the marker which will be used for selecting the final colour from the gamut.
+            /// </summary>
+            protected abstract Marker CreateMarker();
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+
+                Current.BindValueChanged(_ => currentChanged(), true);
+
+                Hue.BindValueChanged(_ => Scheduler.AddOnce(hueChanged), true);
+                Saturation.BindValueChanged(_ => Scheduler.AddOnce(saturationChanged), true);
+                Value.BindValueChanged(_ => Scheduler.AddOnce(valueChanged), true);
+            }
+
+            // As Current and {Hue,Saturation,Value} are mutually bound together,
+            // using unprotected value change callbacks can end up causing partial colour updates (e.g. only the hue changing when Current is set),
+            // or circular updates (e.g. Hue.Changed -> Current.Changed -> Hue.Changed).
+            // To prevent this, this flag is set on every original change on each of the four bindables,
+            // and any subsequent value change callbacks are supposed to not mutate any of those bindables further if the flag is set.
+            private bool changeInProgress;
+
+            private void currentChanged()
+            {
+                if (changeInProgress)
+                    return;
+
+                var asHSV = Current.Value.ToHSV();
+
+                changeInProgress = true;
+
+                Saturation.Value = asHSV.Y;
+                Value.Value = asHSV.Z;
+
+                if (shouldUpdateHue(asHSV.X))
+                    Hue.Value = asHSV.X;
+
+                changeInProgress = false;
+            }
+
+            private bool shouldUpdateHue(float newHue)
+            {
+                // there are two situations in which a hue value change is possibly unwanted.
+                // * if saturation is near-zero, it may not be really possible to accurately measure the hue of the colour,
+                //   as hsv(x, 0, y) == hsv(z, 0, y) for any x,y,z.
+                // * similarly, the hues of 0 and 1 are functionally equivalent,
+                //   as hsv(0, x, y) == hsv(1, x, y) for any x,y.
+                // in those cases, just keep the hue as it was, as the colour will still be roughly the same to the point of being imperceptible,
+                // and doing this will prevent UX idiosyncrasies (such as the hue slider jumping to 0 for no apparent reason).
+                return Precision.DefinitelyBigger(Saturation.Value, 0)
+                       && !Precision.AlmostEquals(Hue.Value - newHue, 1);
+            }
+
+            private void hueChanged()
+            {
+                hueBox.Colour = Colour4.FromHSV(Hue.Value, 1, 1);
+                updateCurrent();
+            }
+
+            private void saturationChanged()
+            {
+                marker.X = Saturation.Value;
+                updateCurrent();
+            }
+
+            private void valueChanged()
+            {
+                marker.Y = 1 - Value.Value;
+                updateCurrent();
+            }
+
+            private void updateCurrent()
+            {
+                if (changeInProgress)
+                    return;
+
+                changeInProgress = true;
+                Current.Value = Colour4.FromHSV(Hue.Value, Saturation.Value, Value.Value);
+                changeInProgress = false;
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                // manually preserve aspect ratio.
+                // Fill{Mode,AspectRatio} do not work here, because they require RelativeSizeAxes = Both,
+                // which in turn causes BypassAutoSizeAxes to be set to Both, and so the parent ignores the child height and assumes 0.
+                Height = DrawWidth;
+            }
+
+            protected override bool OnMouseDown(MouseDownEvent e)
+            {
+                handleMouseInput(e.ScreenSpaceMousePosition);
+                return true;
+            }
+
+            protected override bool OnDragStart(DragStartEvent e) => true;
+
+            protected override void OnDrag(DragEvent e)
+            {
+                handleMouseInput(e.ScreenSpaceMousePosition);
+            }
+
+            private void handleMouseInput(Vector2 mousePosition)
+            {
+                var localSpacePosition = ToLocalSpace(mousePosition);
+                Saturation.Value = localSpacePosition.X / DrawWidth;
+                Value.Value = 1 - localSpacePosition.Y / DrawHeight;
+            }
+
+            protected abstract class Marker : CompositeDrawable
+            {
+                public IBindable<Colour4> Current { get; } = new Bindable<Colour4>();
+            }
+        }
+    }
+}

osu.Framework/Graphics/UserInterface/HexColourPicker.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using osu.Framework.Bindables;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+
+namespace osu.Framework.Graphics.UserInterface
+{
+    public abstract class HexColourPicker : CompositeDrawable, IHasCurrentValue<Colour4>
+    {
+        private readonly BindableWithCurrent<Colour4> current = new BindableWithCurrent<Colour4>();
+
+        public Bindable<Colour4> Current
+        {
+            get => current.Current;
+            set => current.Current = value;
+        }
+
+        public new MarginPadding Padding
+        {
+            get => content.Padding;
+            set => content.Padding = value;
+        }
+
+        /// <summary>
+        /// Sets the spacing between the hex input text box and the colour preview.
+        /// </summary>
+        public float Spacing
+        {
+            get => spacer.Width;
+            set => spacer.Width = value;
+        }
+
+        /// <summary>
+        /// The background of the control.
+        /// </summary>
+        protected readonly Box Background;
+
+        private readonly Container content;
+
+        private readonly TextBox hexCodeTextBox;
+        private readonly Drawable spacer;
+        private readonly ColourPreview colourPreview;
+
+        protected HexColourPicker()
+        {
+            Current.Value = Colour4.White;
+
+            Width = 300;
+            AutoSizeAxes = Axes.Y;
+
+            InternalChildren = new Drawable[]
+            {
+                Background = new Box
+                {
+                    RelativeSizeAxes = Axes.Both
+                },
+                content = new Container
+                {
+                    RelativeSizeAxes = Axes.X,
+                    AutoSizeAxes = Axes.Y,
+                    Child = new GridContainer
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        AutoSizeAxes = Axes.Y,
+                        ColumnDimensions = new[]
+                        {
+                            new Dimension(),
+                            new Dimension(GridSizeMode.AutoSize),
+                            new Dimension()
+                        },
+                        RowDimensions = new[]
+                        {
+                            new Dimension(GridSizeMode.AutoSize)
+                        },
+                        Content = new[]
+                        {
+                            new[]
+                            {
+                                hexCodeTextBox = CreateHexCodeTextBox().With(d =>
+                                {
+                                    d.RelativeSizeAxes = Axes.X;
+                                    d.CommitOnFocusLost = true;
+                                }),
+                                spacer = Empty(),
+                                colourPreview = CreateColourPreview().With(d => d.RelativeSizeAxes = Axes.Both)
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        /// <summary>
+        /// Creates the text box to be used for specifying the hex code of the target colour.
+        /// </summary>
+        protected abstract TextBox CreateHexCodeTextBox();
+
+        /// <summary>
+        /// Creates the control that will be used for displaying the preview of the target colour.
+        /// </summary>
+        protected abstract ColourPreview CreateColourPreview();
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Current.BindValueChanged(_ => updateState(), true);
+
+            hexCodeTextBox.Current.BindValueChanged(_ => tryPreviewColour());
+            hexCodeTextBox.OnCommit += commitColour;
+        }
+
+        private void updateState()
+        {
+            hexCodeTextBox.Text = Current.Value.ToHex();
+            colourPreview.Current.Value = Current.Value;
+        }
+
+        private void tryPreviewColour()
+        {
+            if (!Colour4.TryParseHex(hexCodeTextBox.Text, out var colour) || colour.A < 1)
+                return;
+
+            colourPreview.Current.Value = colour;
+        }
+
+        private void commitColour(TextBox sender, bool newText)
+        {
+            if (!Colour4.TryParseHex(sender.Text, out var colour) || colour.A < 1)
+            {
+                Current.TriggerChange(); // restore previous value.
+                return;
+            }
+
+            Current.Value = colour;
+        }
+
+        public abstract class ColourPreview : CompositeDrawable
+        {
+            public Bindable<Colour4> Current = new Bindable<Colour4>();
+        }
+    }
+}

osu.Framework/Graphics/Visualisation/DrawableTransform.cs

···
             {
                 applied = new Box { Size = new Vector2(height) },
                 appliedToEnd = new Box { X = height + 2, Size = new Vector2(height) },
-                text = new SpriteText { X = (height + 2) * 2, Font = new FontUsage(size: height) },
+                text = new SpriteText { X = (height + 2) * 2, Font = FrameworkFont.Regular.With(size: height) },
             };
         }
 

osu.Framework/Graphics/Visualisation/LogOverlay.cs

···
                             Shadow = true,
                             ShadowColour = Color4.Black,
                             Margin = new MarginPadding { Left = 5, Right = 5 },
-                            Font = new FontUsage(size: font_size),
+                            Font = FrameworkFont.Regular.With(size: font_size),
                             Text = entry.Target?.ToString() ?? entry.LoggerName,
                         }
                     }
···
                     Child = new SpriteText
                     {
                         RelativeSizeAxes = Axes.X,
-                        Font = new FontUsage(size: font_size),
+                        Font = FrameworkFont.Regular.With(size: font_size),
                         Text = entry.Message
                     }
                 }

osu.Framework/Graphics/Visualisation/PropertyDisplay.cs

···
                                 {
                                     Text = info.Name,
                                     Colour = FrameworkColour.Yellow,
+                                    Font = FrameworkFont.Regular
                                 },
                                 new SpriteText
                                 {
                                     Text = $@"[{type.Name}]:",
                                     Colour = FrameworkColour.YellowGreen,
+                                    Font = FrameworkFont.Regular
                                 },
                                 valueText = new SpriteText
                                 {
                                     Colour = Color4.White,
+                                    Font = FrameworkFont.Regular
                                 },
                             }
                         }

osu.Framework/Graphics/Visualisation/TextureVisualiser.cs

···
 using osu.Framework.Graphics.OpenGL.Vertices;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
+using osu.Framework.Localisation;
 using osu.Framework.Utils;
 using osuTK;
 using osuTK.Graphics;
···
                         {
                             Anchor = Anchor.TopCentre,
                             Origin = Anchor.TopCentre,
-                            Font = FontUsage.Default.With(size: 16)
+                            Font = FrameworkFont.Regular.With(size: 16)
                         },
                         new Container
                         {
···
                         {
                             Anchor = Anchor.TopCentre,
                             Origin = Anchor.TopCentre,
-                            Font = FontUsage.Default.With(size: 16),
+                            Font = FrameworkFont.Regular.With(size: 16),
                         },
                     }
                 };
···
                 protected internal override bool CanDrawOpaqueInterior => false;
             }
 
-            public string TooltipText
+            public LocalisableString TooltipText
             {
                 get
                 {

osu.Framework/Graphics/Visualisation/TreeContainer.cs

···
             AddInternal(waitingText = new SpriteText
             {
                 Text = @"Waiting for target selection...",
+                Font = FrameworkFont.Regular,
                 Anchor = Anchor.Centre,
                 Origin = Anchor.Centre,
             });

osu.Framework/Graphics/Visualisation/VisualisedDrawable.cs

···
                             Position = new Vector2(24, 0),
                             Children = new Drawable[]
                             {
-                                text = new SpriteText(),
-                                text2 = new SpriteText()
+                                text = new SpriteText { Font = FrameworkFont.Regular },
+                                text2 = new SpriteText { Font = FrameworkFont.Regular },
                             }
                         },
                     }

osu.Framework/Input/PassThroughInputManager.cs

···
         /// <summary>
         /// If there's an InputManager above us, decide whether we should use their available state.
         /// </summary>
-        public bool UseParentInput
+        public virtual bool UseParentInput
         {
             get => useParentInput;
             set

osu.Framework/Localisation/EnumLocalisationMapper.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+
+namespace osu.Framework.Localisation
+{
+    /// <summary>
+    /// Describes the values of an <see cref="Enum"/> type by <see cref="LocalisableString"/>s.
+    /// </summary>
+    /// <typeparam name="T">The <see cref="Enum"/> type.</typeparam>
+    public abstract class EnumLocalisationMapper<T> : IEnumLocalisationMapper
+        where T : Enum
+    {
+        /// <summary>
+        /// Describes a <typeparamref name="T"/> value by a <see cref="LocalisableString"/>.
+        /// </summary>
+        /// <param name="value">The value to map.</param>
+        /// <returns>The <see cref="LocalisableString"/> describing <paramref name="value"/>.</returns>
+        public abstract LocalisableString Map(T value);
+    }
+
+    /// <summary>
+    /// Marker class for <see cref="EnumLocalisationMapper{T}"/>. Do not use.
+    /// </summary>
+    internal interface IEnumLocalisationMapper
+    {
+    }
+}

osu.Framework/Localisation/LocalisableEnumAttribute.cs

···
+// Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Extensions;
+using osu.Framework.Extensions.TypeExtensions;
+
+namespace osu.Framework.Localisation
+{
+    /// <summary>
+    /// Indicates that the values of an enum have <see cref="LocalisableString"/> descriptions.
+    /// The descriptions can be retrieved through <see cref="ExtensionMethods.GetLocalisableDescription{T}"/>.
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Enum)]
+    public sealed class LocalisableEnumAttribute : Attribute
+    {
+        /// <summary>
+        /// The <see cref="EnumLocalisationMapper{T}"/> type that maps enum values to <see cref="LocalisableString"/>s.
+        /// </summary>
+        public readonly Type MapperType;
+
+        /// <summary>
+        /// Creates a new <see cref="LocalisableEnumAttribute"/>.
+        /// </summary>
+        /// <param name="mapperType">The <see cref="EnumLocalisationMapper{T}"/> type that maps enum values to <see cref="LocalisableString"/>s.</param>
+        public LocalisableEnumAttribute(Type mapperType)
+        {
+            MapperType = mapperType;
+
+            if (!typeof(IEnumLocalisationMapper).IsAssignableFrom(mapperType))
+                throw new ArgumentException($"Type \"{mapperType.ReadableName()}\" must inherit from {nameof(EnumLocalisationMapper<Enum>)}.", nameof(mapperType));
+        }
+    }
+}

osu.Framework/Localisation/LocalisationManager.cs

···
 
 using System.Collections.Generic;
 using System.Globalization;
-using JetBrains.Annotations;
 using osu.Framework.Bindables;
 using osu.Framework.Configuration;
 
···
         /// Creates an <see cref="ILocalisedBindableString"/> which automatically updates its text according to information provided in <see cref="ILocalisedBindableString.Text"/>.
         /// </summary>
         /// <returns>The <see cref="ILocalisedBindableString"/>.</returns>
-        [NotNull]
         public ILocalisedBindableString GetLocalisedString(LocalisableString original) => new LocalisedBindableString(original, currentStorage, preferUnicode);
 
-        private void updateLocale(ValueChangedEvent<string> args)
+        private void updateLocale(ValueChangedEvent<string> locale)
         {
             if (locales.Count == 0)
                 return;
 
-            var validLocale = locales.Find(l => l.Name == args.NewValue);
+            var validLocale = locales.Find(l => l.Name == locale.NewValue);
 
             if (validLocale == null)
             {
-                var culture = string.IsNullOrEmpty(args.NewValue) ? CultureInfo.CurrentCulture : new CultureInfo(args.NewValue);
+                var culture = string.IsNullOrEmpty(locale.NewValue) ? CultureInfo.CurrentCulture : new CultureInfo(locale.NewValue);
 
                 for (var c = culture; !EqualityComparer<CultureInfo>.Default.Equals(c, CultureInfo.InvariantCulture); c = c.Parent)
                 {
···
                 validLocale ??= locales[0];
             }
 
-            if (validLocale.Name != args.NewValue)
-                configLocale.Value = validLocale.Name;
-            else
-                currentStorage.Value = validLocale.Storage;
+            currentStorage.Value = validLocale.Storage;
         }
 
         private class LocaleMapping

osu.Framework/Platform/GameHost.cs

···
             thread.UnhandledException = null;
         }
 
-        public DrawThread DrawThread;
-        public GameThread UpdateThread;
-        public InputThread InputThread;
-        public AudioThread AudioThread;
+        public DrawThread DrawThread { get; private set; }
+        public GameThread UpdateThread { get; private set; }
+        public InputThread InputThread { get; private set; }
+        public AudioThread AudioThread { get; private set; }
 
         private double maximumUpdateHz;
 
···
 
                 Window = CreateWindow();
 
-                ExecutionState = ExecutionState.Running;
-
                 populateInputHandlers();
 
                 SetupConfig(game.GetFrameworkConfigDefaults() ?? new Dictionary<FrameworkSetting, object>());
+
+                ExecutionState = ExecutionState.Running;
 
                 initialiseInputHandlers();
 
···
         /// </summary>
         public void Suspend()
         {
-            threadRunner.Suspend();
             suspended = true;
+            threadRunner.Suspend();
         }
 
         /// <summary>

osu.Framework/Platform/SDL2/SDL2Extensions.cs

···
 
         public static WindowState ToWindowState(this SDL.SDL_WindowFlags windowFlags)
         {
-            // NOTE: on macOS, SDL2 does not differentiate between "maximised" and "fullscreen desktop"
             if (windowFlags.HasFlagFast(SDL.SDL_WindowFlags.SDL_WINDOW_FULLSCREEN_DESKTOP) ||
-                windowFlags.HasFlagFast(SDL.SDL_WindowFlags.SDL_WINDOW_BORDERLESS) ||
-                windowFlags.HasFlagFast(SDL.SDL_WindowFlags.SDL_WINDOW_MAXIMIZED) && RuntimeInfo.OS == RuntimeInfo.Platform.macOS)
+                windowFlags.HasFlagFast(SDL.SDL_WindowFlags.SDL_WINDOW_BORDERLESS))
                 return WindowState.FullscreenBorderless;
 
             if (windowFlags.HasFlagFast(SDL.SDL_WindowFlags.SDL_WINDOW_MINIMIZED))
···
                     return SDL.SDL_WindowFlags.SDL_WINDOW_FULLSCREEN;
 
                 case WindowState.Maximised:
-                    return RuntimeInfo.OS == RuntimeInfo.Platform.macOS
-                        ? SDL.SDL_WindowFlags.SDL_WINDOW_FULLSCREEN_DESKTOP
-                        : SDL.SDL_WindowFlags.SDL_WINDOW_MAXIMIZED;
+                    return SDL.SDL_WindowFlags.SDL_WINDOW_MAXIMIZED;
 
                 case WindowState.Minimised:
                     return SDL.SDL_WindowFlags.SDL_WINDOW_MINIMIZED;

osu.Framework/Platform/SDL2/SDL2GraphicsBackend.cs

···
             return context;
         }
 
-        protected override void MakeCurrent(IntPtr context) => SDL.SDL_GL_MakeCurrent(sdlWindowHandle, context);
+        protected override void MakeCurrent(IntPtr context)
+        {
+            int result = SDL.SDL_GL_MakeCurrent(sdlWindowHandle, context);
+            if (result < 0)
+                throw new InvalidOperationException($"Failed to acquire GL context ({SDL.SDL_GetError()})");
+        }
 
         public override void SwapBuffers() => SDL.SDL_GL_SwapWindow(sdlWindowHandle);
 

osu.Framework/Platform/SDL2DesktopWindow.cs

···
 
                 if (e.type == SDL.SDL_EventType.SDL_WINDOWEVENT && e.window.windowEvent == SDL.SDL_WindowEventID.SDL_WINDOWEVENT_RESIZED)
                 {
-                    // This function will be invoked before the SDL internal states are all changed. (as documented here: https://wiki.libsdl.org/SDL_SetEventFilter)
-                    // Therefore we should only update the client size without saving to config, as we don't know what state the window would end up in.
                     updateWindowSize();
-                    return 0;
                 }
 
                 return 1;
···
         private void updateWindowSize()
         {
             SDL.SDL_GL_GetDrawableSize(SDLWindowHandle, out var w, out var h);
-
             SDL.SDL_GetWindowSize(SDLWindowHandle, out var actualW, out var _);
+
             Scale = (float)w / actualW;
+            Size = new Size(w, h);
 
-            Size = new Size(w, h);
+            // This function may be invoked before the SDL internal states are all changed. (as documented here: https://wiki.libsdl.org/SDL_SetEventFilter)
+            // Scheduling the store to config until after the event poll has run will ensure the window is in the correct state.
+            eventScheduler.Add(storeWindowSizeToConfig, true);
         }
 
         /// <summary>
···
 
                 case SDL.SDL_WindowEventID.SDL_WINDOWEVENT_SIZE_CHANGED:
                     updateWindowSize();
-                    if (WindowState == WindowState.Normal)
-                        storeWindowSizeToConfig();
-
                     break;
 
                 case SDL.SDL_WindowEventID.SDL_WINDOWEVENT_ENTER:
···
                     break;
 
                 case WindowState.Maximised:
+                    SDL.SDL_RestoreWindow(SDLWindowHandle);
                     SDL.SDL_MaximizeWindow(SDLWindowHandle);
 
                     SDL.SDL_GL_GetDrawableSize(SDLWindowHandle, out int w, out int h);
···
 
         private void storeWindowSizeToConfig()
         {
+            if (WindowState != WindowState.Normal)
+                return;
+
             storingSizeToConfig = true;
             sizeWindowed.Value = (Size / Scale).ToSize();
             storingSizeToConfig = false;

osu.Framework/Platform/ThreadRunner.cs

···
             }
         }
 
+        private readonly object startStopLock = new object();
+
         /// <summary>
         /// Construct a new ThreadRunner instance.
         /// </summary>
···
                     lock (threads)
                     {
                         foreach (var t in threads)
-                            t.ProcessFrame();
+                            t.RunSingleFrame();
                     }
 
                     break;
···
 
                 case ExecutionMode.MultiThreaded:
                     // still need to run the main/input thread on the window loop
-                    mainThread.ProcessFrame();
+                    mainThread.RunSingleFrame();
                     break;
             }
         }
···
 
         public void Suspend()
         {
-            pauseAllThreads();
-
-            // set the active execution mode back to null to set the state checking back to when it can be resumed.
-            activeExecutionMode = null;
+            lock (startStopLock)
+            {
+                pauseAllThreads();
+                activeExecutionMode = null;
+            }
         }
 
         public void Stop()
···
             });
 
             // as the input thread isn't actually handled by a thread, the above join does not necessarily mean it has been completed to an exiting state.
-            while (!mainThread.Exited)
-                mainThread.ProcessFrame();
+            mainThread.WaitForState(GameThreadState.Exited);
 
             ThreadSafety.ResetAllForCurrentThread();
         }
 
         private void ensureCorrectExecutionMode()
         {
-            if (ExecutionMode == activeExecutionMode)
-                return;
+            // locking is required as this method may be called from two different threads.
+            lock (startStopLock)
+            {
+                if (ExecutionMode == activeExecutionMode)
+                    return;
 
-            // if null, we have not yet got an execution mode, so set this early to allow usage in GameThread.Initialize overrides.
-            activeExecutionMode ??= ThreadSafety.ExecutionMode = ExecutionMode;
-            Logger.Log($"Execution mode changed to {activeExecutionMode}");
+                activeExecutionMode = ThreadSafety.ExecutionMode = ExecutionMode;
+                Logger.Log($"Execution mode changed to {activeExecutionMode}");
+            }
 
             pauseAllThreads();
 
···
                 {
                     // switch to multi-threaded
                     foreach (var t in Threads)
-                    {
                         t.Start();
-                        t.Clock.Throttling = true;
-                    }
 
                     break;
                 }
···
                     break;
                 }
             }
-
-            activeExecutionMode = ThreadSafety.ExecutionMode = ExecutionMode;
 
             updateMainThreadRates();
         }

osu.Framework/Resources/Fonts/OpenSans/LICENSE.txt

···
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

osu.Framework/Resources/Shaders/sh_HueSelectorBackground.fs

···
+#include "sh_Utils.h"
+
+varying mediump vec2 v_TexCoord;
+varying mediump vec4 v_TexRect;
+
+void main(void)
+{
+    float hueValue = v_TexCoord.x / (v_TexRect[2] - v_TexRect[0]);
+    gl_FragColor = hsv2rgb(vec4(hueValue, 1, 1, 1));
+}

osu.Framework/Resources/Shaders/sh_HueSelectorBackgroundRounded.fs

···
+#include "sh_Utils.h"
+#include "sh_Masking.h"
+
+varying mediump vec2 v_TexCoord;
+
+void main(void)
+{
+    float hueValue = v_TexCoord.x / (v_TexRect[2] - v_TexRect[0]);
+    gl_FragColor = getRoundedColor(hsv2rgb(vec4(hueValue, 1, 1, 1)), v_TexCoord);
+}

osu.Framework/Resources/Shaders/sh_Utils.h

···
         finalAlpha
     );
 }
+
+// http://lolengine.net/blog/2013/07/27/rgb-to-hsv-in-glsl
+// slightly amended to also handle alpha
+vec4 hsv2rgb(vec4 c)
+{
+    vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+    return vec4(c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y), c.w);
+}

osu.Framework/Testing/DynamicClassCompiler.cs

···
 
         public void Start()
         {
-            var di = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory);
-
             if (Debugger.IsAttached)
             {
                 referenceBuilder = new EmptyTypeReferenceBuilder();
···
                 return;
             }
 
+            var di = new DirectoryInfo(AppDomain.CurrentDomain.BaseDirectory);
+            var basePath = getSolutionPath(di);
+
+            if (!Directory.Exists(basePath))
+            {
+                referenceBuilder = new EmptyTypeReferenceBuilder();
+
+                Logger.Log("Dynamic compilation disabled (no solution file found).");
+                return;
+            }
+
 #if NET5_0
             referenceBuilder = new RoslynTypeReferenceBuilder();
 #else
···
             {
                 Logger.Log("Initialising dynamic compilation...");
 
-                var basePath = getSolutionPath(di);
-
-                if (!Directory.Exists(basePath))
-                    return;
-
-                await referenceBuilder.Initialise(Directory.GetFiles(getSolutionPath(di), "*.sln").First()).ConfigureAwait(false);
+                await referenceBuilder.Initialise(Directory.GetFiles(basePath, "*.sln").First()).ConfigureAwait(false);
 
                 foreach (var dir in Directory.GetDirectories(basePath))
                 {

osu.Framework/Testing/Input/ManualInputManager.cs

···
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input;
+using osu.Framework.Input.Events;
 using osu.Framework.Input.Handlers;
 using osu.Framework.Input.StateChanges;
 using osu.Framework.Platform;
···
 
         private readonly TestCursorContainer testCursor;
 
+        private readonly LocalPlatformActionContainer platformActionContainer;
+
+        public override bool UseParentInput
+        {
+            get => base.UseParentInput;
+            set
+            {
+                base.UseParentInput = value;
+                platformActionContainer.ShouldHandle = !value;
+            }
+        }
+
         public ManualInputManager()
         {
-            UseParentInput = true;
             AddHandler(handler = new ManualInputHandler());
 
             InternalChildren = new Drawable[]
             {
-                content = new Container { RelativeSizeAxes = Axes.Both },
+                platformActionContainer = new LocalPlatformActionContainer().WithChild(content = new Container { RelativeSizeAxes = Axes.Both }),
                 testCursor = new TestCursorContainer(),
             };
+
+            UseParentInput = true;
         }
 
         public void Input(IInput input)
···
 
         public void PressTabletAuxiliaryButton(TabletAuxiliaryButton auxiliaryButton) => Input(new TabletAuxiliaryButtonInput(auxiliaryButton, true));
         public void ReleaseTabletAuxiliaryButton(TabletAuxiliaryButton auxiliaryButton) => Input(new TabletAuxiliaryButtonInput(auxiliaryButton, false));
+
+        private class LocalPlatformActionContainer : PlatformActionContainer
+        {
+            public bool ShouldHandle;
+
+            protected override bool Handle(UIEvent e)
+            {
+                if (!ShouldHandle)
+                    return false;
+
+                return base.Handle(e);
+            }
+        }
 
         private class ManualInputHandler : InputHandler
         {

osu.Framework/Testing/ManualInputManagerTestScene.cs

···
                 InputManager = new ManualInputManager
                 {
                     UseParentInput = true,
-                    Child = new PlatformActionContainer().WithChild(Content)
+                    Child = Content,
                 },
                 new Container
                 {

osu.Framework/Testing/TestBrowser.cs

···
         private readonly BindableDouble audioRateAdjust = new BindableDouble(1);
 
         [BackgroundDependencyLoader]
-        private void load(Storage storage, GameHost host, FrameworkConfigManager frameworkConfig, FontStore fonts, Game game, AudioManager audio)
+        private void load(Storage storage, GameHost host, FrameworkConfigManager frameworkConfig, FontStore fonts, AudioManager audio)
         {
             interactive = host.Window != null;
             config = new TestBrowserConfig(storage);
···
             exit = host.Exit;
 
             audio.AddAdjustment(AdjustableProperty.Frequency, audioRateAdjust);
-
-            var resources = game.Resources;
-
-            //Roboto
-            game.AddFont(resources, @"Fonts/Roboto/Roboto-Regular");
-            game.AddFont(resources, @"Fonts/Roboto/Roboto-Bold");
-
-            //RobotoCondensed
-            game.AddFont(resources, @"Fonts/RobotoCondensed/RobotoCondensed-Regular");
-            game.AddFont(resources, @"Fonts/RobotoCondensed/RobotoCondensed-Bold");
 
             showLogOverlay = frameworkConfig.GetBindable<bool>(FrameworkSetting.ShowLogOverlay);
 

osu.Framework/Threading/AudioThread.cs

···
         public AudioThread()
             : base(name: "Audio")
         {
-            OnNewFrame = onNewFrame;
+            OnNewFrame += onNewFrame;
 
             if (RuntimeInfo.OS == RuntimeInfo.Platform.Linux)
             {
···
             initialised_devices.Add(deviceId);
         }
 
-        protected override void PerformExit()
+        protected override void OnExit()
         {
-            base.PerformExit();
+            base.OnExit();
 
             lock (managers)
             {

osu.Framework/Threading/DrawThread.cs

···
             host.Window?.MakeCurrent();
         }
 
-        protected sealed override void Cleanup()
+        protected sealed override void OnSuspended()
         {
-            base.Cleanup();
-
+            base.OnSuspended();
             host.Window?.ClearCurrent();
         }
 

osu.Framework/Threading/GameThread.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
-using System.Threading;
-using osu.Framework.Statistics;
-using osu.Framework.Timing;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
+using System.Threading;
 using JetBrains.Annotations;
 using osu.Framework.Bindables;
 using osu.Framework.Development;
+using osu.Framework.Platform;
+using osu.Framework.Statistics;
+using osu.Framework.Timing;
 
 namespace osu.Framework.Threading
 {
+    /// <summary>
+    /// A conceptual thread used for running game work. May or may not be backed by a native thread.
+    /// </summary>
     public class GameThread
     {
         internal const double DEFAULT_ACTIVE_HZ = 1000;
         internal const double DEFAULT_INACTIVE_HZ = 60;
 
-        internal PerformanceMonitor Monitor { get; }
+        /// <summary>
+        /// The name of this thread.
+        /// </summary>
+        public readonly string Name;
+
+        /// <summary>
+        /// Whether the game is active (in the foreground).
+        /// </summary>
+        public readonly IBindable<bool> IsActive = new Bindable<bool>(true);
+
+        /// <summary>
+        /// The current state of this thread.
+        /// </summary>
+        public IBindable<GameThreadState> State => state;
+
+        private readonly Bindable<GameThreadState> state = new Bindable<GameThreadState>();
+
+        /// <summary>
+        /// Whether this thread is currently running.
+        /// </summary>
+        public bool Running => state.Value == GameThreadState.Running;
+
+        /// <summary>
+        /// Whether this thread is exited.
+        /// </summary>
+        public bool Exited => state.Value == GameThreadState.Exited;
+
+        /// <summary>
+        /// Whether currently executing on this thread (from the point of invocation).
+        /// </summary>
+        public virtual bool IsCurrent => true;
+
+        /// <summary>
+        /// The thread's clock. Responsible for timekeeping and throttling.
+        /// </summary>
         public ThrottledFrameClock Clock { get; }
 
+        /// <summary>
+        /// The current dedicated OS thread for this <see cref="GameThread"/>.
+        /// A value of <see langword="null"/> does not necessarily mean that this thread is not running;
+        /// in <see cref="ExecutionMode.SingleThread"/> execution mode <see cref="ThreadRunner"/> drives its <see cref="GameThread"/>s
+        /// manually and sequentially on the main OS thread of the game process.
+        /// </summary>
         [CanBeNull]
         public Thread Thread { get; private set; }
 
+        /// <summary>
+        /// The thread's scheduler.
+        /// </summary>
         public Scheduler Scheduler { get; }
 
         /// <summary>
···
         /// </summary>
         public EventHandler<UnhandledExceptionEventArgs> UnhandledException;
 
-        protected Action OnNewFrame;
-
         /// <summary>
-        /// Whether the game is active (in the foreground).
+        /// The culture of this thread.
         /// </summary>
-        public readonly IBindable<bool> IsActive = new Bindable<bool>(true);
+        public CultureInfo CurrentCulture
+        {
+            get => culture;
+            set
+            {
+                culture = value;
 
-        private double activeHz = DEFAULT_ACTIVE_HZ;
+                updateCulture();
+            }
+        }
 
+        private CultureInfo culture;
+
+        /// <summary>
+        /// The refresh rate this thread should run at when active. Only applies when the underlying clock is throttling.
+        /// </summary>
         public double ActiveHz
         {
             get => activeHz;
···
             }
         }
 
-        private double inactiveHz = DEFAULT_INACTIVE_HZ;
+        private double activeHz = DEFAULT_ACTIVE_HZ;
 
+        /// <summary>
+        /// The refresh rate this thread should run at when inactive. Only applies when the underlying clock is throttling.
+        /// </summary>
         public double InactiveHz
         {
             get => inactiveHz;
···
             }
         }
 
-        public static string PrefixedThreadNameFor(string name) => $"{nameof(GameThread)}.{name}";
-
-        public bool Running => Thread?.IsAlive == true;
-
-        public virtual bool IsCurrent => true;
-
-        private readonly ManualResetEvent initializedEvent = new ManualResetEvent(false);
-
-        internal void Initialize(bool withThrottling)
-        {
-            MakeCurrent();
+        private double inactiveHz = DEFAULT_INACTIVE_HZ;
 
-            OnInitialize();
+        internal PerformanceMonitor Monitor { get; }
 
-            Clock.Throttling = withThrottling;
-
-            Monitor.MakeCurrent();
+        internal virtual IEnumerable<StatisticsCounterType> StatisticsCounters => Array.Empty<StatisticsCounterType>();
 
-            updateCulture();
+        /// <summary>
+        /// The main work which is fired on each frame.
+        /// </summary>
+        protected event Action OnNewFrame;
 
-            initializedEvent.Set();
-        }
+        private readonly ManualResetEvent initializedEvent = new ManualResetEvent(false);
 
-        protected virtual void OnInitialize() { }
+        private readonly object startStopLock = new object();
 
-        internal virtual IEnumerable<StatisticsCounterType> StatisticsCounters => Array.Empty<StatisticsCounterType>();
+        /// <summary>
+        /// Whether a pause has been requested.
+        /// </summary>
+        private volatile bool pauseRequested;
 
-        public readonly string Name;
+        /// <summary>
+        /// Whether an exit has been requested.
+        /// </summary>
+        private volatile bool exitRequested;
 
         internal GameThread(Action onNewFrame = null, string name = "unknown", bool monitorPerformance = true)
         {
···
             IsActive.BindValueChanged(_ => updateMaximumHz(), true);
         }
 
-        private void createThread()
-        {
-            Debug.Assert(Thread == null);
-
-            Thread = new Thread(runWork)
-            {
-                Name = PrefixedThreadNameFor(Name),
-                IsBackground = true,
-            };
-
-            updateCulture();
-        }
-
+        /// <summary>
+        /// Block until this thread has entered an initialised state.
+        /// </summary>
         public void WaitUntilInitialized()
         {
             initializedEvent.WaitOne();
         }
 
-        private void updateMaximumHz() => Scheduler.Add(() => Clock.MaximumUpdateHz = IsActive.Value ? activeHz : inactiveHz);
+        /// <summary>
+        /// Returns a string representation that is prefixed with this thread's identifier.
+        /// </summary>
+        /// <param name="name">The content to prefix.</param>
+        /// <returns>A prefixed string.</returns>
+        public static string PrefixedThreadNameFor(string name) => $"{nameof(GameThread)}.{name}";
 
-        private void runWork()
+        /// <summary>
+        /// Start this thread.
+        /// </summary>
+        /// <remarks>
+        /// This method blocks until in a running state.
+        /// </remarks>
+        public void Start()
         {
-            try
+            lock (startStopLock)
             {
-                Initialize(true);
+                switch (state.Value)
+                {
+                    case GameThreadState.Paused:
+                    case GameThreadState.NotStarted:
+                        break;
 
-                while (!exitCompleted && !paused)
+                    default:
+                        throw new InvalidOperationException($"Cannot start when thread is {state.Value}.");
+                }
+
+                state.Value = GameThreadState.Starting;
+                PrepareForWork();
+            }
+
+            WaitForState(GameThreadState.Running);
+            Debug.Assert(state.Value == GameThreadState.Running);
+        }
+
+        /// <summary>
+        /// Request that this thread is exited.
+        /// </summary>
+        /// <remarks>
+        /// This does not block and will only queue an exit request, which is processed in the main frame loop.
+        /// </remarks>
+        /// <exception cref="InvalidOperationException">Thrown when attempting to exit from an invalid state.</exception>
+        public void Exit()
+        {
+            lock (startStopLock)
+            {
+                switch (state.Value)
                 {
-                    ProcessFrame();
+                    // technically we could support this, but we don't use this yet and it will add more complexity.
+                    case GameThreadState.Paused:
+                    case GameThreadState.NotStarted:
+                    case GameThreadState.Starting:
+                        throw new InvalidOperationException($"Cannot exit when thread is {state.Value}.");
+
+                    case GameThreadState.Exited:
+                        return;
+
+                    default:
+                        // actual exit will be done in ProcessFrame.
+                        exitRequested = true;
+                        break;
                 }
             }
-            finally
+        }
+
+        /// <summary>
+        /// Prepare this thread for performing work. Must be called when entering a running state.
+        /// </summary>
+        /// <param name="withThrottling">Whether this thread's clock should be throttling via thread sleeps.</param>
+        internal void Initialize(bool withThrottling)
+        {
+            lock (startStopLock)
             {
-                Cleanup();
+                Debug.Assert(state.Value != GameThreadState.Running);
+                Debug.Assert(state.Value != GameThreadState.Exited);
+
+                MakeCurrent();
+
+                OnInitialize();
+
+                Clock.Throttling = withThrottling;
+
+                Monitor.MakeCurrent();
+
+                updateCulture();
+
+                initializedEvent.Set();
+                state.Value = GameThreadState.Running;
             }
         }
 
         /// <summary>
-        /// Run when thread transitions into an active/processing state.
+        /// Run when thread transitions into an active/processing state, at the beginning of each frame.
         /// </summary>
         internal virtual void MakeCurrent()
         {
             ThreadSafety.ResetAllForCurrentThread();
         }
 
-        internal void ProcessFrame()
+        /// <summary>
+        /// Runs a single frame, updating the execution state if required.
+        /// </summary>
+        internal void RunSingleFrame()
         {
-            try
+            var newState = processFrame();
+
+            if (newState.HasValue)
+                setExitState(newState.Value);
+        }
+
+        /// <summary>
+        /// Pause this thread. Must be run from <see cref="ThreadRunner"/> in a safe manner.
+        /// </summary>
+        /// <remarks>
+        /// This method blocks until in a paused state.
+        /// </remarks>
+        internal void Pause()
+        {
+            lock (startStopLock)
             {
-                if (exitCompleted)
+                if (state.Value != GameThreadState.Running)
                     return;
 
-                MakeCurrent();
+                // actual pause will be done in ProcessFrame.
+                pauseRequested = true;
+            }
 
-                if (exitRequested)
-                {
-                    PerformExit();
-                    exitCompleted = true;
-                    return;
-                }
+            WaitForState(GameThreadState.Paused);
+        }
 
+        /// <summary>
+        /// Spin indefinitely until this thread enters a required state.
+        /// For cases where no native thread is present, this will run <see cref="processFrame"/> until the required state is reached.
+        /// </summary>
+        /// <param name="targetState">The state to wait for.</param>
+        internal void WaitForState(GameThreadState targetState)
+        {
+            if (state.Value == targetState)
+                return;
+
+            if (Thread == null)
+            {
+                GameThreadState? newState = null;
+
+                // if the thread is null at this point, we need to assume that this WaitForState call is running on the same native thread as this GameThread has/will be running.
+                // run frames until the required state is reached.
+                while (newState != targetState)
+                    newState = processFrame();
+
+                // note that the only state transition here can be an exiting one. entering a running state can only occur in Initialize().
+                setExitState(newState.Value);
+            }
+            else
+            {
+                while (state.Value != targetState)
+                    Thread.Sleep(1);
+            }
+        }
+
+        /// <summary>
+        /// Prepares this game thread for work. Should block until <see cref="Initialize"/> has been run.
+        /// </summary>
+        protected virtual void PrepareForWork()
+        {
+            Debug.Assert(Thread == null);
+            createThread();
+            Debug.Assert(Thread != null);
+
+            Thread.Start();
+        }
+
+        /// <summary>
+        /// Called whenever the thread is initialised. Should prepare the thread for performing work.
+        /// </summary>
+        protected virtual void OnInitialize()
+        {
+        }
+
+        /// <summary>
+        /// Called when a <see cref="Pause"/> or <see cref="Exit"/> is requested on this <see cref="GameThread"/>.
+        /// Use this method to release exclusive resources that the thread could have been holding in its current execution mode,
+        /// like GL contexts or similar.
+        /// </summary>
+        protected virtual void OnSuspended()
+        {
+        }
+
+        /// <summary>
+        /// Called when the thread is exited. Should clean up any thread-specific resources.
+        /// </summary>
+        protected virtual void OnExit()
+        {
+        }
+
+        private void updateMaximumHz()
+        {
+            Scheduler.Add(() => Clock.MaximumUpdateHz = IsActive.Value ? activeHz : inactiveHz);
+        }
+
+        /// <summary>
+        /// Create the native backing thread to run work.
+        /// </summary>
+        /// <remarks>
+        /// This does not start the thread, but guarantees <see cref="Thread"/> is non-null.
+        /// </remarks>
+        private void createThread()
+        {
+            Debug.Assert(Thread == null);
+            Debug.Assert(!Running);
+
+            Thread = new Thread(runWork)
+            {
+                Name = PrefixedThreadNameFor(Name),
+                IsBackground = true,
+            };
+
+            void runWork()
+            {
+                Initialize(true);
+
+                while (Running)
+                    RunSingleFrame();
+            }
+        }
+
+        /// <summary>
+        /// Process a single frame of this thread's work.
+        /// </summary>
+        /// <returns>A potential execution state change.</returns>
+        private GameThreadState? processFrame()
+        {
+            if (state.Value != GameThreadState.Running)
+                // host could be in a suspended state. the input thread will still make calls to ProcessFrame so we can't throw.
+                return null;
+
+            MakeCurrent();
+
+            if (exitRequested)
+            {
+                exitRequested = false;
+                return GameThreadState.Exited;
+            }
+
+            if (pauseRequested)
+            {
+                pauseRequested = false;
+                return GameThreadState.Paused;
+            }
+
+            try
+            {
                 Monitor?.NewFrame();
 
                 using (Monitor?.BeginCollecting(PerformanceCollectionType.Scheduler))
···
                 else
                     throw;
             }
-        }
 
-        private volatile bool exitRequested;
-        private volatile bool exitCompleted;
-
-        public bool Exited => exitCompleted;
-
-        private CultureInfo culture;
-
-        public CultureInfo CurrentCulture
-        {
-            get => culture;
-            set
-            {
-                culture = value;
-
-                updateCulture();
-            }
+            return null;
         }
 
         private void updateCulture()
···
             Thread.CurrentUICulture = culture;
         }
 
-        private bool paused;
-
-        public void Pause()
+        private void setExitState(GameThreadState exitState)
         {
-            if (Thread != null)
-            {
-                paused = true;
-                while (Running)
-                    Thread.Sleep(1);
-            }
-            else
+            lock (startStopLock)
             {
-                Cleanup();
-            }
-        }
+                Debug.Assert(state.Value == GameThreadState.Running);
+                Debug.Assert(exitState == GameThreadState.Exited || exitState == GameThreadState.Paused);
 
-        protected virtual void Cleanup()
-        {
-            Thread = null;
-        }
+                Thread = null;
+                OnSuspended();
 
-        public void Exit() => exitRequested = true;
+                switch (exitState)
+                {
+                    case GameThreadState.Exited:
+                        Monitor?.Dispose();
+                        initializedEvent?.Dispose();
 
-        public virtual void Start()
-        {
-            paused = false;
+                        OnExit();
+                        break;
+                }
 
-            if (Thread == null)
-            {
-                createThread();
-                Debug.Assert(Thread != null);
+                state.Value = exitState;
             }
-
-            Thread.Start();
         }
 
-        protected virtual void PerformExit()
-        {
-            Monitor?.Dispose();
-            initializedEvent?.Dispose();
-        }
-
-        public class GameThreadScheduler : Scheduler
+        private class GameThreadScheduler : Scheduler
         {
             public GameThreadScheduler(GameThread thread)
                 : base(() => thread.IsCurrent, thread.Clock)

osu.Framework/Threading/GameThreadState.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;
+
+namespace osu.Framework.Threading
+{
+    public enum GameThreadState
+    {
+        /// <summary>
+        /// This thread has not yet been started.
+        /// </summary>
+        NotStarted,
+
+        /// <summary>
+        /// This thread is preparing to run.
+        /// </summary>
+        Starting,
+
+        /// <summary>
+        /// This thread is running.
+        /// </summary>
+        Running,
+
+        /// <summary>
+        /// This thread is paused to be moved to a different native thread. This occurs when <see cref="ExecutionMode"/> changes.
+        /// </summary>
+        Paused,
+
+        /// <summary>
+        /// This thread has permanently exited.
+        /// </summary>
+        Exited
+    }
+}

osu.Framework/Threading/InputThread.cs

···
             StatisticsCounterType.TabletEvents,
         };
 
+        protected override void PrepareForWork()
+        {
+            // Intentionally inhibiting the base implementation which spawns a native thread.
+            // Therefore, we need to run Initialize inline.
+            Initialize(true);
+        }
+
         public override bool IsCurrent => ThreadSafety.IsInputThread;
 
         internal sealed override void MakeCurrent()
···
             base.MakeCurrent();
 
             ThreadSafety.IsInputThread = true;
-        }
-
-        public override void Start()
-        {
-            // InputThread does not get started. it is run manually by GameHost.
         }
     }
 }

osu.Framework/Utils/Validation.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.Diagnostics.CodeAnalysis;
 using osuTK;
 using osu.Framework.Graphics;
+
+#nullable enable
 
 namespace osu.Framework.Utils
 {
···
         /// <param name="toCheck">The <see cref="MarginPadding"/> to check.</param>
         /// <returns>False if either component of <paramref name="toCheck"/> are Infinity or NaN, true otherwise. </returns>
         public static bool IsFinite(MarginPadding toCheck) => float.IsFinite(toCheck.Top) && float.IsFinite(toCheck.Bottom) && float.IsFinite(toCheck.Left) && float.IsFinite(toCheck.Right);
+
+        /// <summary>
+        /// Attempts to parse <paramref name="uriString"/> as an absolute or relative <see cref="Uri"/> in a platform-agnostic manner.
+        /// </summary>
+        /// <remarks>
+        /// This method is a workaround for inconsistencies across .NET and mono runtimes;
+        /// on mono runtimes paths starting with <c>/</c> are considered absolute as per POSIX,
+        /// and on .NET such paths are considered to be relative.
+        /// This method uses the .NET behaviour.
+        /// For more info, see <a href="https://www.mono-project.com/docs/faq/known-issues/urikind-relativeorabsolute/">Mono documentation</a>.
+        /// </remarks>
+        /// <param name="uriString">The string representation of the URI to parse.</param>
+        /// <param name="result">The resultant parsed URI, if parsing succeeded.</param>
+        /// <returns><see langword="true"/> if parsing succeeded; <see langword="false"/> otherwise.</returns>
+        public static bool TryParseUri(string uriString, [NotNullWhen(true)] out Uri? result)
+        {
+#pragma warning disable RS0030 // Bypassing banned API check, as it'll actually be used properly here
+            UriKind kind = uriString.StartsWith('/') ? UriKind.Relative : UriKind.RelativeOrAbsolute;
+#pragma warning restore RS0030
+            return Uri.TryCreate(uriString, kind, out result);
+        }
     }
 }