Merge pull request #3761 from peppy/fix-channelmanager-cache

Fix order of ChannelManager dependency caching

.gitignore

@@ -252,7 +252,11 @@ paket-files/
 .fake/
 
 # JetBrains Rider
-.idea/
+.idea/.idea.osu/.idea/*.xml
+.idea/.idea.osu/.idea/codeStyles/*.xml
+.idea/.idea.osu/.idea/dataSources/*.xml
+.idea/.idea.osu/.idea/dictionaries/*.xml
+.idea/.idea.osu/*.iml
 *.sln.iml
 
 # CodeRush

osu.Desktop/OsuGameDesktop.cs

@@ -10,7 +10,7 @@ using osu.Desktop.Overlays;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Platform;
 using osu.Game;
-using OpenTK.Input;
+using osuTK.Input;
 using Microsoft.Win32;
 using osu.Desktop.Updater;
 using osu.Framework;

osu.Desktop/Overlays/VersionManager.cs

@@ -15,8 +15,8 @@ using osu.Game.Graphics.Sprites;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
 using osu.Game.Utils;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Desktop.Overlays
 {

osu.Desktop/Updater/SquirrelUpdateManager.cs

@@ -2,6 +2,8 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using System.IO;
+using System.Reflection;
 using System.Threading.Tasks;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
@@ -12,9 +14,10 @@ using osu.Game;
 using osu.Game.Graphics;
 using osu.Game.Overlays;
 using osu.Game.Overlays.Notifications;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 using Squirrel;
+using LogLevel = Splat.LogLevel;
 
 namespace osu.Desktop.Updater
 {
@@ -35,7 +38,10 @@ namespace osu.Desktop.Updater
             notificationOverlay = notification;
 
             if (game.IsDeployedBuild)
+            {
+                Splat.Locator.CurrentMutable.Register(() => new SquirrelLogger(), typeof(Splat.ILogger));
                 Schedule(() => Task.Run(() => checkForUpdateAsync()));
+            }
         }
 
         private async void checkForUpdateAsync(bool useDeltaPatching = true, UpdateProgressNotification notification = null)
@@ -159,5 +165,31 @@ namespace osu.Desktop.Updater
                 });
             }
         }
+
+        private class SquirrelLogger : Splat.ILogger, IDisposable
+        {
+            private readonly string path;
+            private readonly object locker = new object();
+            public LogLevel Level { get; set; } = LogLevel.Info;
+
+            public SquirrelLogger()
+            {
+                var file = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "SquirrelSetupUpdater.log");
+                if (File.Exists(file)) File.Delete(file);
+                path = file;
+            }
+
+            public void Write(string message, LogLevel logLevel)
+            {
+                if (logLevel < Level)
+                    return;
+
+                lock (locker) File.AppendAllText(path, message + "\r\n");
+            }
+
+            public void Dispose()
+            {
+            }
+        }
     }
 }

osu.Desktop/osu.Desktop.csproj

@@ -27,7 +27,7 @@
   </ItemGroup>
   <ItemGroup Label="Package References">
     <PackageReference Include="System.IO.Packaging" Version="4.5.0" />
-    <PackageReference Include="ppy.squirrel.windows" Version="1.9.0.2" />
+    <PackageReference Include="ppy.squirrel.windows" Version="1.9.0.3" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.1.4" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="2.1.4" />
   </ItemGroup>

osu.Game.Rulesets.Catch.Tests/TestCaseAutoJuiceStream.cs

@@ -5,10 +5,11 @@ using System.Linq;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Screens.Play;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {
@@ -37,13 +38,11 @@ namespace osu.Game.Rulesets.Catch.Tests
                 beatmap.HitObjects.Add(new JuiceStream
                 {
                     X = 0.5f - width / 2,
-                    ControlPoints = new[]
+                    Path = new SliderPath(PathType.Linear, new[]
                     {
                         Vector2.Zero,
                         new Vector2(width * CatchPlayfield.BASE_WIDTH, 0)
-                    },
-                    PathType = PathType.Linear,
-                    Distance = width * CatchPlayfield.BASE_WIDTH,
+                    }),
                     StartTime = i * 2000,
                     NewCombo = i % 8 == 0
                 });

osu.Game.Rulesets.Catch.Tests/TestCaseFruitObjects.cs

@@ -10,7 +10,7 @@ using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Tests
 {

osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapConverter.cs

@@ -34,9 +34,7 @@ namespace osu.Game.Rulesets.Catch.Beatmaps
                 {
                     StartTime = obj.StartTime,
                     Samples = obj.Samples,
-                    ControlPoints = curveData.ControlPoints,
-                    PathType = curveData.PathType,
-                    Distance = curveData.Distance,
+                    Path = curveData.Path,
                     NodeSamples = curveData.NodeSamples,
                     RepeatCount = curveData.RepeatCount,
                     X = (positionData?.X ?? 0) / CatchPlayfield.BASE_WIDTH,

osu.Game.Rulesets.Catch/Beatmaps/CatchBeatmapProcessor.cs

@@ -8,7 +8,7 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects.Types;
-using OpenTK;
+using osuTK;
 using osu.Game.Rulesets.Catch.MathUtils;
 
 namespace osu.Game.Rulesets.Catch.Beatmaps

osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyHitObject.cs

@@ -4,7 +4,7 @@
 using System;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.UI;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Difficulty
 {

osu.Game.Rulesets.Catch/Mods/CatchModFlashlight.cs

@@ -1,12 +1,66 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Catch.Objects;
+using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.UI;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Mods
 {
-    public class CatchModFlashlight : ModFlashlight
+    public class CatchModFlashlight : ModFlashlight<CatchHitObject>
     {
         public override double ScoreMultiplier => 1.12;
+
+        private const float default_flashlight_size = 350;
+
+        public override Flashlight CreateFlashlight() => new CatchFlashlight(playfield);
+
+        private CatchPlayfield playfield;
+
+        public override void ApplyToRulesetContainer(RulesetContainer<CatchHitObject> rulesetContainer)
+        {
+            playfield = (CatchPlayfield)rulesetContainer.Playfield;
+            base.ApplyToRulesetContainer(rulesetContainer);
+        }
+
+        private class CatchFlashlight : Flashlight
+        {
+            private readonly CatchPlayfield playfield;
+
+            public CatchFlashlight(CatchPlayfield playfield)
+            {
+                this.playfield = playfield;
+                FlashlightSize = new Vector2(0, getSizeFor(0));
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                var catcherArea = playfield.CatcherArea;
+
+                FlashlightPosition = catcherArea.ToSpaceOfOtherDrawable(catcherArea.MovableCatcher.DrawPosition, this);
+            }
+
+            private float getSizeFor(int combo)
+            {
+                if (combo > 200)
+                    return default_flashlight_size * 0.8f;
+                else if (combo > 100)
+                    return default_flashlight_size * 0.9f;
+                else
+                    return default_flashlight_size;
+            }
+
+            protected override void OnComboChange(int newCombo)
+            {
+                this.TransformTo(nameof(FlashlightSize), new Vector2(0, getSizeFor(newCombo)), FLASHLIGHT_FADE_DURATION);
+            }
+
+            protected override string FragmentShader => "CircularFlashlight";
+        }
     }
 }

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableCatchHitObject.cs

@@ -2,8 +2,8 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableDroplet.cs

@@ -4,8 +4,8 @@
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableFruit.cs

@@ -9,8 +9,8 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Catch.Objects.Drawable.Pieces;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {

osu.Game.Rulesets.Catch/Objects/Drawable/DrawableTinyDroplet.cs

@@ -1,7 +1,7 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable
 {

osu.Game.Rulesets.Catch/Objects/Drawable/Pieces/Pulp.cs

@@ -6,7 +6,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.Objects.Drawable.Pieces
 {

osu.Game.Rulesets.Catch/Objects/JuiceStream.cs

@@ -10,7 +10,6 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Catch.UI;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
-using OpenTK;
 
 namespace osu.Game.Rulesets.Catch.Objects
 {
@@ -138,28 +137,18 @@ namespace osu.Game.Rulesets.Catch.Objects
 
         public double Duration => EndTime - StartTime;
 
-        public double Distance
+        private SliderPath path;
+
+        public SliderPath Path
         {
-            get { return Path.Distance; }
-            set { Path.Distance = value; }
+            get => path;
+            set => path = value;
         }
 
-        public SliderPath Path { get; } = new SliderPath();
-
-        public Vector2[] ControlPoints
-        {
-            get { return Path.ControlPoints; }
-            set { Path.ControlPoints = value; }
-        }
+        public double Distance => Path.Distance;
 
         public List<List<SampleInfo>> NodeSamples { get; set; } = new List<List<SampleInfo>>();
 
-        public PathType PathType
-        {
-            get { return Path.PathType; }
-            set { Path.PathType = value; }
-        }
-
         public double? LegacyLastTickOffset { get; set; }
     }
 }

osu.Game.Rulesets.Catch/UI/CatchPlayfield.cs

@@ -5,13 +5,12 @@ using System;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
-using osu.Game.Configuration;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
@@ -19,16 +18,10 @@ namespace osu.Game.Rulesets.Catch.UI
     {
         public const float BASE_WIDTH = 512;
 
-        private readonly CatcherArea catcherArea;
-
-        protected override bool UserScrollSpeedAdjustment => false;
-
-        protected override SpeedChangeVisualisationMethod VisualisationMethod => SpeedChangeVisualisationMethod.Constant;
+        internal readonly CatcherArea CatcherArea;
 
         public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> getVisualRepresentation)
         {
-            Direction.Value = ScrollingDirection.Down;
-
             Container explodingFruitContainer;
 
             Anchor = Anchor.TopCentre;
@@ -45,7 +38,7 @@ namespace osu.Game.Rulesets.Catch.UI
                     {
                         RelativeSizeAxes = Axes.Both,
                     },
-                    catcherArea = new CatcherArea(difficulty)
+                    CatcherArea = new CatcherArea(difficulty)
                     {
                         GetVisualRepresentation = getVisualRepresentation,
                         ExplodingFruitTarget = explodingFruitContainer,
@@ -55,11 +48,9 @@ namespace osu.Game.Rulesets.Catch.UI
                     HitObjectContainer
                 }
             };
-
-            VisibleTimeRange.Value = BeatmapDifficulty.DifficultyRange(difficulty.ApproachRate, 1800, 1200, 450);
         }
 
-        public bool CheckIfWeCanCatch(CatchHitObject obj) => catcherArea.AttemptCatch(obj);
+        public bool CheckIfWeCanCatch(CatchHitObject obj) => CatcherArea.AttemptCatch(obj);
 
         public override void Add(DrawableHitObject h)
         {
@@ -72,6 +63,6 @@ namespace osu.Game.Rulesets.Catch.UI
         }
 
         private void onNewResult(DrawableHitObject judgedObject, JudgementResult result)
-            => catcherArea.OnResult((DrawableCatchHitObject)judgedObject, result);
+            => CatcherArea.OnResult((DrawableCatchHitObject)judgedObject, result);
     }
 }

osu.Game.Rulesets.Catch/UI/CatchRulesetContainer.cs

@@ -3,6 +3,7 @@
 
 using osu.Framework.Input;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Input.Handlers;
 using osu.Game.Rulesets.Catch.Objects;
 using osu.Game.Rulesets.Catch.Objects.Drawable;
@@ -18,9 +19,15 @@ namespace osu.Game.Rulesets.Catch.UI
 {
     public class CatchRulesetContainer : ScrollingRulesetContainer<CatchPlayfield, CatchHitObject>
     {
+        protected override ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Constant;
+
+        protected override bool UserScrollSpeedAdjustment => false;
+
         public CatchRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
+            Direction.Value = ScrollingDirection.Down;
+            TimeRange.Value = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450);
         }
 
         public override ScoreProcessor CreateScoreProcessor() => new CatchScoreProcessor(this);

osu.Game.Rulesets.Catch/UI/CatcherArea.cs

@@ -18,8 +18,8 @@ using osu.Game.Rulesets.Catch.Replays;
 using osu.Game.Rulesets.Judgements;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Catch.UI
 {
@@ -27,7 +27,7 @@ namespace osu.Game.Rulesets.Catch.UI
     {
         public const float CATCHER_SIZE = 100;
 
-        protected readonly Catcher MovableCatcher;
+        protected internal readonly Catcher MovableCatcher;
 
         public Func<CatchHitObject, DrawableHitObject<CatchHitObject>> GetVisualRepresentation;
 

osu.Game.Rulesets.Catch/UI/PlayfieldAdjustmentContainer.cs

@@ -3,7 +3,7 @@
 
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Catch.UI
 {

osu.Game.Rulesets.Mania.Tests/ScrollingTestContainer.cs

@@ -1,33 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Allocation;
-using osu.Framework.Configuration;
-using osu.Framework.Graphics.Containers;
-using osu.Game.Rulesets.Mania.UI;
-using osu.Game.Rulesets.UI.Scrolling;
-
-namespace osu.Game.Rulesets.Mania.Tests
-{
-    /// <summary>
-    /// A container which provides a <see cref="IScrollingInfo"/> to children.
-    /// </summary>
-    public class ScrollingTestContainer : Container
-    {
-        [Cached(Type = typeof(IScrollingInfo))]
-        private readonly TestScrollingInfo scrollingInfo = new TestScrollingInfo();
-
-        public ScrollingTestContainer(ScrollingDirection direction)
-        {
-            scrollingInfo.Direction.Value = direction;
-        }
-
-        public void Flip() => scrollingInfo.Direction.Value = scrollingInfo.Direction.Value == ScrollingDirection.Up ? ScrollingDirection.Down : ScrollingDirection.Up;
-    }
-
-    public class TestScrollingInfo : IScrollingInfo
-    {
-        public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
-        IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
-    }
-}

osu.Game.Rulesets.Mania.Tests/TestCaseColumn.cs

@@ -14,8 +14,9 @@ using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Mania.UI.Components;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
-using OpenTK.Graphics;
+using osu.Game.Tests.Visual;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
@@ -93,7 +94,6 @@ namespace osu.Game.Rulesets.Mania.Tests
                 Height = 0.85f,
                 AccentColour = Color4.OrangeRed,
                 Action = { Value = action },
-                VisibleTimeRange = { Value = 2000 }
             };
 
             columns.Add(column);
@@ -104,6 +104,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 Origin = Anchor.Centre,
                 AutoSizeAxes = Axes.X,
                 RelativeSizeAxes = Axes.Y,
+                TimeRange = 2000,
                 Child = column
             };
         }

osu.Game.Rulesets.Mania.Tests/TestCaseHoldNoteSelectionBlueprint.cs

@@ -0,0 +1,57 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Edit.Blueprints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public class TestCaseHoldNoteSelectionBlueprint : SelectionBlueprintTestCase
+    {
+        private readonly DrawableHoldNote drawableObject;
+
+        protected override Container<Drawable> Content => content ?? base.Content;
+        private readonly Container content;
+
+        public TestCaseHoldNoteSelectionBlueprint()
+        {
+            var holdNote = new HoldNote { Column = 0, Duration = 1000 };
+            holdNote.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            base.Content.Child = content = new ScrollingTestContainer(ScrollingDirection.Down)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                AutoSizeAxes = Axes.Y,
+                Width = 50,
+                Child = drawableObject = new DrawableHoldNote(holdNote)
+                {
+                    Height = 300,
+                    AccentColour = OsuColour.Gray(0.3f)
+                }
+            };
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            foreach (var nested in drawableObject.NestedHitObjects)
+            {
+                double finalPosition = (nested.HitObject.StartTime - drawableObject.HitObject.StartTime) / drawableObject.HitObject.Duration;
+                nested.Y = (float)(-finalPosition * content.DrawHeight);
+            }
+        }
+
+        protected override SelectionBlueprint CreateBlueprint() => new HoldNoteSelectionBlueprint(drawableObject);
+    }
+}

osu.Game.Rulesets.Mania.Tests/TestCaseNoteSelectionBlueprint.cs

@@ -0,0 +1,41 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Beatmaps;
+using osu.Game.Beatmaps.ControlPoints;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Mania.Edit.Blueprints;
+using osu.Game.Rulesets.Mania.Objects;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+using osu.Game.Rulesets.UI.Scrolling;
+using osu.Game.Tests.Visual;
+using osuTK;
+
+namespace osu.Game.Rulesets.Mania.Tests
+{
+    public class TestCaseNoteSelectionBlueprint : SelectionBlueprintTestCase
+    {
+        private readonly DrawableNote drawableObject;
+
+        protected override Container<Drawable> Content => content ?? base.Content;
+        private readonly Container content;
+
+        public TestCaseNoteSelectionBlueprint()
+        {
+            var note = new Note { Column = 0 };
+            note.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty());
+
+            base.Content.Child = content = new ScrollingTestContainer(ScrollingDirection.Down)
+            {
+                Anchor = Anchor.Centre,
+                Origin = Anchor.Centre,
+                Size = new Vector2(50, 20),
+                Child = drawableObject = new DrawableNote(note)
+            };
+        }
+
+        protected override SelectionBlueprint CreateBlueprint() => new NoteSelectionBlueprint(drawableObject);
+    }
+}

osu.Game.Rulesets.Mania.Tests/TestCaseNotes.cs

@@ -20,8 +20,8 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.UI.Scrolling;
 using osu.Game.Tests.Visual;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {

osu.Game.Rulesets.Mania.Tests/TestCaseStage.cs

@@ -14,7 +14,8 @@ using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
+using osu.Game.Tests.Visual;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Tests
 {
@@ -122,7 +123,7 @@ namespace osu.Game.Rulesets.Mania.Tests
         {
             var specialAction = ManiaAction.Special1;
 
-            var stage = new ManiaStage(0, new StageDefinition { Columns = 2 }, ref action, ref specialAction) { VisibleTimeRange = { Value = 2000 } };
+            var stage = new ManiaStage(0, new StageDefinition { Columns = 2 }, ref action, ref specialAction);
             stages.Add(stage);
 
             return new ScrollingTestContainer(direction)
@@ -131,6 +132,7 @@ namespace osu.Game.Rulesets.Mania.Tests
                 Origin = Anchor.Centre,
                 RelativeSizeAxes = Axes.Y,
                 AutoSizeAxes = Axes.X,
+                TimeRange = 2000,
                 Child = stage
             };
         }

osu.Game.Rulesets.Mania/Beatmaps/ManiaBeatmapConverter.cs

@@ -12,7 +12,7 @@ using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Mania.Beatmaps.Patterns;
 using osu.Game.Rulesets.Mania.MathUtils;
 using osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy;
-using OpenTK;
+using osuTK;
 using osu.Game.Audio;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/HitObjectPatternGenerator.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using OpenTK;
+using osuTK;
 using osu.Game.Audio;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;

osu.Game.Rulesets.Mania/Beatmaps/Patterns/Legacy/PatternGenerator.cs

@@ -7,7 +7,7 @@ using JetBrains.Annotations;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.MathUtils;
 using osu.Game.Rulesets.Objects;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Beatmaps.Patterns.Legacy
 {

osu.Game.Rulesets.Mania/Edit/Blueprints/Components/EditNotePiece.cs

@@ -0,0 +1,29 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Graphics;
+using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
+
+namespace osu.Game.Rulesets.Mania.Edit.Blueprints.Components
+{
+    public class EditNotePiece : CompositeDrawable
+    {
+        public EditNotePiece()
+        {
+            Height = NotePiece.NOTE_HEIGHT;
+
+            CornerRadius = 5;
+            Masking = true;
+
+            InternalChild = new NotePiece();
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            Colour = colours.Yellow;
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/Blueprints/HoldNoteSelectionBlueprint.cs

@@ -4,18 +4,17 @@
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
+using osu.Framework.Graphics.Primitives;
 using osu.Game.Graphics;
-using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Mania.Edit.Masks
+namespace osu.Game.Rulesets.Mania.Edit.Blueprints
 {
-    public class HoldNoteSelectionMask : SelectionMask
+    public class HoldNoteSelectionBlueprint : ManiaSelectionBlueprint
     {
         public new DrawableHoldNote HitObject => (DrawableHoldNote)base.HitObject;
 
@@ -23,13 +22,13 @@ namespace osu.Game.Rulesets.Mania.Edit.Masks
 
         private readonly BodyPiece body;
 
-        public HoldNoteSelectionMask(DrawableHoldNote hold)
+        public HoldNoteSelectionBlueprint(DrawableHoldNote hold)
             : base(hold)
         {
             InternalChildren = new Drawable[]
             {
-                new HoldNoteNoteSelectionMask(hold.Head),
-                new HoldNoteNoteSelectionMask(hold.Tail),
+                new HoldNoteNoteSelectionBlueprint(hold.Head),
+                new HoldNoteNoteSelectionBlueprint(hold.Tail),
                 body = new BodyPiece
                 {
                     AccentColour = Color4.Transparent
@@ -59,9 +58,11 @@ namespace osu.Game.Rulesets.Mania.Edit.Masks
                 Y -= HitObject.Tail.DrawHeight;
         }
 
-        private class HoldNoteNoteSelectionMask : NoteSelectionMask
+        public override Quad SelectionQuad => ScreenSpaceDrawQuad;
+
+        private class HoldNoteNoteSelectionBlueprint : NoteSelectionBlueprint
         {
-            public HoldNoteNoteSelectionMask(DrawableNote note)
+            public HoldNoteNoteSelectionBlueprint(DrawableNote note)
                 : base(note)
             {
                 Select();

osu.Game.Rulesets.Mania/Edit/Blueprints/ManiaSelectionBlueprint.cs

@@ -0,0 +1,23 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Edit.Blueprints
+{
+    public class ManiaSelectionBlueprint : SelectionBlueprint
+    {
+        public ManiaSelectionBlueprint(DrawableHitObject hitObject)
+            : base(hitObject)
+        {
+            RelativeSizeAxes = Axes.None;
+        }
+
+        public override void AdjustPosition(DragEvent dragEvent)
+        {
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/Blueprints/NoteSelectionBlueprint.cs

@@ -0,0 +1,26 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mania.Edit.Blueprints.Components;
+using osu.Game.Rulesets.Mania.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Edit.Blueprints
+{
+    public class NoteSelectionBlueprint : ManiaSelectionBlueprint
+    {
+        public NoteSelectionBlueprint(DrawableNote note)
+            : base(note)
+        {
+            AddInternal(new EditNotePiece { RelativeSizeAxes = Axes.X });
+        }
+
+        protected override void Update()
+        {
+            base.Update();
+
+            Size = HitObject.DrawSize;
+            Position = Parent.ToLocalSpace(HitObject.ScreenSpaceDrawQuad.TopLeft);
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/ManiaEditRulesetContainer.cs

@@ -2,15 +2,18 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Graphics;
-using OpenTK;
+using osuTK;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI;
+using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
     public class ManiaEditRulesetContainer : ManiaRulesetContainer
     {
+        public new IScrollingInfo ScrollingInfo => base.ScrollingInfo;
+
         public ManiaEditRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {

osu.Game.Rulesets.Mania/Edit/ManiaHitObjectComposer.cs

@@ -10,45 +10,46 @@ using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Drawables;
 using System.Collections.Generic;
 using osu.Framework.Allocation;
-using osu.Game.Rulesets.Mania.Configuration;
-using osu.Game.Rulesets.Mania.Edit.Masks;
-using osu.Game.Rulesets.Mania.UI;
+using osu.Game.Rulesets.Mania.Edit.Blueprints;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Rulesets.Mania.Edit
 {
     public class ManiaHitObjectComposer : HitObjectComposer<ManiaHitObject>
     {
-        protected new ManiaConfigManager Config => (ManiaConfigManager)base.Config;
-
         public ManiaHitObjectComposer(Ruleset ruleset)
             : base(ruleset)
         {
         }
 
+        private DependencyContainer dependencies;
+
         protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
-        {
-            var dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-            dependencies.CacheAs<IScrollingInfo>(new ManiaScrollingInfo(Config));
-            return dependencies;
-        }
+            => dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
 
         protected override RulesetContainer<ManiaHitObject> CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
-            => new ManiaEditRulesetContainer(ruleset, beatmap);
+        {
+            var rulesetContainer = new ManiaEditRulesetContainer(ruleset, beatmap);
+
+            // This is the earliest we can cache the scrolling info to ourselves, before masks are added to the hierarchy and inject it
+            dependencies.CacheAs(rulesetContainer.ScrollingInfo);
+
+            return rulesetContainer;
+        }
 
         protected override IReadOnlyList<HitObjectCompositionTool> CompositionTools => Array.Empty<HitObjectCompositionTool>();
 
-        public override SelectionMask CreateMaskFor(DrawableHitObject hitObject)
+        public override SelectionBlueprint CreateBlueprintFor(DrawableHitObject hitObject)
         {
             switch (hitObject)
             {
                 case DrawableNote note:
-                    return new NoteSelectionMask(note);
+                    return new NoteSelectionBlueprint(note);
                 case DrawableHoldNote holdNote:
-                    return new HoldNoteSelectionMask(holdNote);
+                    return new HoldNoteSelectionBlueprint(holdNote);
             }
 
-            return base.CreateMaskFor(hitObject);
+            return base.CreateBlueprintFor(hitObject);
         }
     }
 }

osu.Game.Rulesets.Mania/Edit/Masks/ManiaSelectionBlueprint.cs

@@ -0,0 +1,18 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects.Drawables;
+
+namespace osu.Game.Rulesets.Mania.Edit.Masks
+{
+    public abstract class ManiaSelectionBlueprint : SelectionBlueprint
+    {
+        protected ManiaSelectionBlueprint(DrawableHitObject hitObject)
+            : base(hitObject)
+        {
+            RelativeSizeAxes = Axes.None;
+        }
+    }
+}

osu.Game.Rulesets.Mania/Edit/Masks/NoteSelectionMask.cs

@@ -1,39 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Allocation;
-using osu.Game.Graphics;
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Mania.Objects.Drawables;
-using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
-
-namespace osu.Game.Rulesets.Mania.Edit.Masks
-{
-    public class NoteSelectionMask : SelectionMask
-    {
-        public NoteSelectionMask(DrawableNote note)
-            : base(note)
-        {
-            Scale = note.Scale;
-
-            CornerRadius = 5;
-            Masking = true;
-
-            AddInternal(new NotePiece());
-        }
-
-        [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
-        {
-            Colour = colours.Yellow;
-        }
-
-        protected override void Update()
-        {
-            base.Update();
-
-            Size = HitObject.DrawSize;
-            Position = Parent.ToLocalSpace(HitObject.ScreenSpaceDrawQuad.TopLeft);
-        }
-    }
-}

osu.Game.Rulesets.Mania/Mods/ManiaModFadeIn.cs

@@ -3,6 +3,7 @@
 
 using System;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -16,6 +17,6 @@ namespace osu.Game.Rulesets.Mania.Mods
         public override string Description => @"Keys appear out of nowhere!";
         public override double ScoreMultiplier => 1;
         public override bool Ranked => true;
-        public override Type[] IncompatibleMods => new[] { typeof(ModFlashlight) };
+        public override Type[] IncompatibleMods => new[] { typeof(ModFlashlight<ManiaHitObject>) };
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModFlashlight.cs

@@ -2,13 +2,60 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using osu.Framework.Caching;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.Mods
 {
-    public class ManiaModFlashlight : ModFlashlight
+    public class ManiaModFlashlight : ModFlashlight<ManiaHitObject>
     {
         public override double ScoreMultiplier => 1;
         public override Type[] IncompatibleMods => new[] { typeof(ModHidden) };
+
+        private const float default_flashlight_size = 180;
+
+        public override Flashlight CreateFlashlight() => new ManiaFlashlight();
+
+        private class ManiaFlashlight : Flashlight
+        {
+            private readonly Cached flashlightProperties = new Cached();
+
+            public ManiaFlashlight()
+            {
+                FlashlightSize = new Vector2(0, default_flashlight_size);
+            }
+
+            public override bool Invalidate(Invalidation invalidation = Invalidation.All, Drawable source = null, bool shallPropagate = true)
+            {
+                if ((invalidation & Invalidation.DrawSize) > 0)
+                {
+                    flashlightProperties.Invalidate();
+                }
+
+                return base.Invalidate(invalidation, source, shallPropagate);
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (!flashlightProperties.IsValid)
+                {
+                    FlashlightSize = new Vector2(DrawWidth, FlashlightSize.Y);
+
+                    FlashlightPosition = DrawPosition + DrawSize / 2;
+                    flashlightProperties.Validate();
+                }
+            }
+
+            protected override void OnComboChange(int newCombo)
+            {
+            }
+
+            protected override string FragmentShader => "RectangularFlashlight";
+        }
     }
 }

osu.Game.Rulesets.Mania/Mods/ManiaModHidden.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
+using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Mods;
 
 namespace osu.Game.Rulesets.Mania.Mods
@@ -10,6 +11,6 @@ namespace osu.Game.Rulesets.Mania.Mods
     {
         public override string Description => @"Keys fade out before you hit them!";
         public override double ScoreMultiplier => 1;
-        public override Type[] IncompatibleMods => new[] { typeof(ModFlashlight) };
+        public override Type[] IncompatibleMods => new[] { typeof(ModFlashlight<ManiaHitObject>) };
     }
 }

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableBarLine.cs

@@ -1,11 +1,11 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
+using osuTK;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Rulesets.Objects.Drawables;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables
 {

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNote.cs

@@ -5,7 +5,7 @@ using System.Linq;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
 using osu.Game.Rulesets.Scoring;

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableHoldNoteTick.cs

@@ -2,8 +2,8 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using System;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableManiaHitObject.cs

@@ -5,7 +5,6 @@ using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Graphics;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI.Scrolling;
 

osu.Game.Rulesets.Mania/Objects/Drawables/DrawableNote.cs

@@ -2,7 +2,7 @@
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
 using osu.Framework.Extensions.Color4Extensions;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/BodyPiece.cs

@@ -3,7 +3,7 @@
 
 using System;
 using osu.Framework.Caching;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/GlowPiece.cs

@@ -6,7 +6,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces
 {

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/LaneGlowPiece.cs

@@ -1,7 +1,7 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Colour;

osu.Game.Rulesets.Mania/Objects/Drawables/Pieces/NotePiece.cs

@@ -3,13 +3,12 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
-using osu.Game.Rulesets.Mania.UI;
 using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.Objects.Drawables.Pieces

osu.Game.Rulesets.Mania/UI/Column.cs

@@ -1,12 +1,12 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK.Graphics;
+using System.Linq;
+using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Objects.Drawables;
-using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Configuration;
 using osu.Framework.Input.Bindings;
@@ -16,7 +16,7 @@ using osu.Game.Rulesets.UI.Scrolling;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class Column : ManiaScrollingPlayfield, IKeyBindingHandler<ManiaAction>, IHasAccentColour
+    public class Column : ScrollingPlayfield, IKeyBindingHandler<ManiaAction>, IHasAccentColour
     {
         private const float column_width = 45;
         private const float special_column_width = 70;
@@ -134,7 +134,7 @@ namespace osu.Game.Rulesets.Mania.UI
             hitObject.AccentColour = AccentColour;
             hitObject.OnNewResult += OnNewResult;
 
-            HitObjects.Add(hitObject);
+            HitObjectContainer.Add(hitObject);
         }
 
         internal void OnNewResult(DrawableHitObject judgedObject, JudgementResult result)
@@ -144,7 +144,7 @@ namespace osu.Game.Rulesets.Mania.UI
 
             explosionContainer.Add(new HitExplosion(judgedObject)
             {
-                Anchor = Direction == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre
+                Anchor = Direction.Value == ScrollingDirection.Up ? Anchor.TopCentre : Anchor.BottomCentre
             });
         }
 
@@ -154,10 +154,10 @@ namespace osu.Game.Rulesets.Mania.UI
                 return false;
 
             var nextObject =
-                HitObjects.AliveObjects.FirstOrDefault(h => h.HitObject.StartTime > Time.Current) ??
+                HitObjectContainer.AliveObjects.FirstOrDefault(h => h.HitObject.StartTime > Time.Current) ??
                 // fallback to non-alive objects to find next off-screen object
-                HitObjects.Objects.FirstOrDefault(h => h.HitObject.StartTime > Time.Current) ??
-                HitObjects.Objects.LastOrDefault();
+                HitObjectContainer.Objects.FirstOrDefault(h => h.HitObject.StartTime > Time.Current) ??
+                HitObjectContainer.Objects.LastOrDefault();
 
             nextObject?.PlaySamples();
 

osu.Game.Rulesets.Mania/UI/Components/ColumnBackground.cs

@@ -11,7 +11,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Bindings;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.UI.Components
 {

osu.Game.Rulesets.Mania/UI/Components/ColumnHitObjectArea.cs

@@ -10,7 +10,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK.Graphics;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.UI.Components
 {

osu.Game.Rulesets.Mania/UI/Components/ColumnKeyArea.cs

@@ -11,8 +11,8 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Bindings;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.UI.Components
 {

osu.Game.Rulesets.Mania/UI/HitExplosion.cs

@@ -1,7 +1,7 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK.Graphics;
+using osuTK.Graphics;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
@@ -9,7 +9,7 @@ using osu.Framework.MathUtils;
 using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Mania.Objects.Drawables.Pieces;
 using osu.Game.Rulesets.Objects.Drawables;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.UI
 {

osu.Game.Rulesets.Mania/UI/ManiaPlayfield.cs

@@ -1,20 +1,19 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using System;
 using System.Collections.Generic;
 using osu.Game.Rulesets.Mania.Beatmaps;
-using osu.Game.Rulesets.Mania.Configuration;
 using osu.Game.Rulesets.Mania.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
-using OpenTK;
+using osu.Game.Rulesets.UI.Scrolling;
+using osuTK;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
-    public class ManiaPlayfield : ManiaScrollingPlayfield
+    public class ManiaPlayfield : ScrollingPlayfield
     {
         private readonly List<ManiaStage> stages = new List<ManiaStage>();
 
@@ -41,7 +40,6 @@ namespace osu.Game.Rulesets.Mania.UI
             for (int i = 0; i < stageDefinitions.Count; i++)
             {
                 var newStage = new ManiaStage(firstColumnIndex, stageDefinitions[i], ref normalColumnAction, ref specialColumnAction);
-                newStage.VisibleTimeRange.BindTo(VisibleTimeRange);
 
                 playfieldGrid.Content[0][i] = newStage;
 
@@ -68,11 +66,5 @@ namespace osu.Game.Rulesets.Mania.UI
 
             return null;
         }
-
-        [BackgroundDependencyLoader]
-        private void load(ManiaConfigManager maniaConfig)
-        {
-            maniaConfig.BindWith(ManiaSetting.ScrollTime, VisibleTimeRange);
-        }
     }
 }

osu.Game.Rulesets.Mania/UI/ManiaRulesetContainer.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
+using osu.Framework.Configuration;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Input;
@@ -35,6 +36,8 @@ namespace osu.Game.Rulesets.Mania.UI
 
         protected new ManiaConfigManager Config => (ManiaConfigManager)base.Config;
 
+        private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
+
         public ManiaRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap)
             : base(ruleset, beatmap)
         {
@@ -70,18 +73,11 @@ namespace osu.Game.Rulesets.Mania.UI
         private void load()
         {
             BarLines.ForEach(Playfield.Add);
-        }
 
-        private DependencyContainer dependencies;
+            Config.BindWith(ManiaSetting.ScrollDirection, configDirection);
+            configDirection.BindValueChanged(v => Direction.Value = (ScrollingDirection)v, true);
 
-        protected override IReadOnlyDependencyContainer CreateChildDependencies(IReadOnlyDependencyContainer parent)
-        {
-            dependencies = new DependencyContainer(base.CreateChildDependencies(parent));
-
-            if (dependencies.Get<ManiaScrollingInfo>() == null)
-                dependencies.CacheAs<IScrollingInfo>(new ManiaScrollingInfo(Config));
-
-            return dependencies;
+            Config.BindWith(ManiaSetting.ScrollTime, TimeRange);
         }
 
         protected override Playfield CreatePlayfield() => new ManiaPlayfield(Beatmap.Stages)

osu.Game.Rulesets.Mania/UI/ManiaScrollingInfo.cs

@@ -1,23 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Configuration;
-using osu.Game.Rulesets.Mania.Configuration;
-using osu.Game.Rulesets.UI.Scrolling;
-
-namespace osu.Game.Rulesets.Mania.UI
-{
-    public class ManiaScrollingInfo : IScrollingInfo
-    {
-        private readonly Bindable<ManiaScrollingDirection> configDirection = new Bindable<ManiaScrollingDirection>();
-
-        public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
-        IBindable<ScrollingDirection> IScrollingInfo.Direction => Direction;
-
-        public ManiaScrollingInfo(ManiaConfigManager config)
-        {
-            config.BindWith(ManiaSetting.ScrollDirection, configDirection);
-            configDirection.BindValueChanged(v => Direction.Value = (ScrollingDirection)v, true);
-        }
-    }
-}

osu.Game.Rulesets.Mania/UI/ManiaScrollingPlayfield.cs

@@ -1,21 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Allocation;
-using osu.Framework.Configuration;
-using osu.Game.Rulesets.UI.Scrolling;
-
-namespace osu.Game.Rulesets.Mania.UI
-{
-    public abstract class ManiaScrollingPlayfield : ScrollingPlayfield
-    {
-        private readonly IBindable<ScrollingDirection> direction = new Bindable<ScrollingDirection>();
-
-        [BackgroundDependencyLoader]
-        private void load(IScrollingInfo scrollingInfo)
-        {
-            direction.BindTo(scrollingInfo.Direction);
-            direction.BindValueChanged(direction => Direction.Value = direction, true);
-        }
-    }
-}

osu.Game.Rulesets.Mania/UI/ManiaStage.cs

@@ -15,15 +15,15 @@ using osu.Game.Rulesets.Mania.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.UI;
 using osu.Game.Rulesets.UI.Scrolling;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Rulesets.Mania.UI
 {
     /// <summary>
     /// A collection of <see cref="Column"/>s.
     /// </summary>
-    public class ManiaStage : ManiaScrollingPlayfield
+    public class ManiaStage : ScrollingPlayfield
     {
         public const float HIT_TARGET_POSITION = 50;
 
@@ -144,8 +144,6 @@ namespace osu.Game.Rulesets.Mania.UI
 
         public void AddColumn(Column c)
         {
-            c.VisibleTimeRange.BindTo(VisibleTimeRange);
-
             topLevelContainer.Add(c.TopLevelContainer.CreateProxy());
             columnFlow.Add(c);
             AddNested(c);

osu.Game.Rulesets.Osu.Tests/TestCaseHitCircle.cs

@@ -8,7 +8,7 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
 using System.Collections.Generic;
 using System;
 using osu.Game.Rulesets.Mods;

osu.Game.Rulesets.Osu.Tests/TestCaseHitCirclePlacementBlueprint.cs

@@ -4,16 +4,16 @@
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public class TestCaseHitCirclePlacementMask : HitObjectPlacementMaskTestCase
+    public class TestCaseHitCirclePlacementBlueprint : PlacementBlueprintTestCase
     {
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableHitCircle((HitCircle)hitObject);
-        protected override PlacementMask CreateMask() => new HitCirclePlacementMask();
+        protected override PlacementBlueprint CreateBlueprint() => new HitCirclePlacementBlueprint();
     }
 }

osu.Game.Rulesets.Osu.Tests/TestCaseHitCircleSelectionBlueprint.cs

@@ -4,19 +4,19 @@
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public class TestCaseHitCircleSelectionMask : HitObjectSelectionMaskTestCase
+    public class TestCaseHitCircleSelectionBlueprint : SelectionBlueprintTestCase
     {
         private readonly DrawableHitCircle drawableObject;
 
-        public TestCaseHitCircleSelectionMask()
+        public TestCaseHitCircleSelectionBlueprint()
         {
             var hitCircle = new HitCircle { Position = new Vector2(256, 192) };
             hitCircle.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { CircleSize = 2 });
@@ -24,6 +24,6 @@ namespace osu.Game.Rulesets.Osu.Tests
             Add(drawableObject = new DrawableHitCircle(hitCircle));
         }
 
-        protected override SelectionMask CreateMask() => new HitCircleSelectionMask(drawableObject);
+        protected override SelectionBlueprint CreateBlueprint() => new HitCircleSelectionBlueprint(drawableObject);
     }
 }

osu.Game.Rulesets.Osu.Tests/TestCaseSlider.cs

@@ -11,13 +11,14 @@ using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 using osu.Game.Rulesets.Mods;
 using System.Linq;
 using NUnit.Framework;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Rulesets.Judgements;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
@@ -108,13 +109,12 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(239, 176),
-                ControlPoints = new[]
+                Path = new SliderPath(PathType.PerfectCurve, new[]
                 {
                     Vector2.Zero,
                     new Vector2(154, 28),
                     new Vector2(52, -34)
-                },
-                Distance = 700,
+                }, 700),
                 RepeatCount = repeats,
                 NodeSamples = createEmptySamples(repeats),
                 StackHeight = 10
@@ -141,12 +141,11 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(-(distance / 2), 0),
-                ControlPoints = new[]
+                Path = new SliderPath(PathType.PerfectCurve, new[]
                 {
                     Vector2.Zero,
                     new Vector2(distance, 0),
-                },
-                Distance = distance,
+                }, distance),
                 RepeatCount = repeats,
                 NodeSamples = createEmptySamples(repeats),
                 StackHeight = stackHeight
@@ -161,13 +160,12 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(-200, 0),
-                ControlPoints = new[]
+                Path = new SliderPath(PathType.PerfectCurve, new[]
                 {
                     Vector2.Zero,
                     new Vector2(200, 200),
                     new Vector2(400, 0)
-                },
-                Distance = 600,
+                }, 600),
                 RepeatCount = repeats,
                 NodeSamples = createEmptySamples(repeats)
             };
@@ -181,10 +179,9 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var slider = new Slider
             {
-                PathType = PathType.Linear,
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(-200, 0),
-                ControlPoints = new[]
+                Path = new SliderPath(PathType.Linear, new[]
                 {
                     Vector2.Zero,
                     new Vector2(150, 75),
@@ -192,8 +189,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                     new Vector2(300, -200),
                     new Vector2(400, 0),
                     new Vector2(430, 0)
-                },
-                Distance = 793.4417,
+                }),
                 RepeatCount = repeats,
                 NodeSamples = createEmptySamples(repeats)
             };
@@ -207,18 +203,16 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var slider = new Slider
             {
-                PathType = PathType.Bezier,
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(-200, 0),
-                ControlPoints = new[]
+                Path = new SliderPath(PathType.Bezier, new[]
                 {
                     Vector2.Zero,
                     new Vector2(150, 75),
                     new Vector2(200, 100),
                     new Vector2(300, -200),
                     new Vector2(430, 0)
-                },
-                Distance = 480,
+                }),
                 RepeatCount = repeats,
                 NodeSamples = createEmptySamples(repeats)
             };
@@ -232,10 +226,9 @@ namespace osu.Game.Rulesets.Osu.Tests
         {
             var slider = new Slider
             {
-                PathType = PathType.Linear,
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(0, 0),
-                ControlPoints = new[]
+                Path = new SliderPath(PathType.Linear, new[]
                 {
                     Vector2.Zero,
                     new Vector2(-200, 0),
@@ -243,8 +236,7 @@ namespace osu.Game.Rulesets.Osu.Tests
                     new Vector2(0, -200),
                     new Vector2(-200, -200),
                     new Vector2(0, -200)
-                },
-                Distance = 1000,
+                }),
                 RepeatCount = repeats,
                 NodeSamples = createEmptySamples(repeats)
             };
@@ -264,15 +256,13 @@ namespace osu.Game.Rulesets.Osu.Tests
             {
                 StartTime = Time.Current + 1000,
                 Position = new Vector2(-100, 0),
-                PathType = PathType.Catmull,
-                ControlPoints = new[]
+                Path = new SliderPath(PathType.Catmull, new[]
                 {
                     Vector2.Zero,
                     new Vector2(50, -50),
                     new Vector2(150, 50),
                     new Vector2(200, 0)
-                },
-                Distance = 300,
+                }),
                 RepeatCount = repeats,
                 NodeSamples = repeatSamples
             };

osu.Game.Rulesets.Osu.Tests/TestCaseSliderPlacementBlueprint.cs

@@ -4,16 +4,16 @@
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public class TestCaseSliderPlacementMask : HitObjectPlacementMaskTestCase
+    public class TestCaseSliderPlacementBlueprint : PlacementBlueprintTestCase
     {
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableSlider((Slider)hitObject);
-        protected override PlacementMask CreateMask() => new SliderPlacementMask();
+        protected override PlacementBlueprint CreateBlueprint() => new SliderPlacementBlueprint();
     }
 }

osu.Game.Rulesets.Osu.Tests/TestCaseSliderSelectionBlueprint.cs

@@ -6,22 +6,23 @@ using System.Collections.Generic;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks;
-using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public class TestCaseSliderSelectionMask : HitObjectSelectionMaskTestCase
+    public class TestCaseSliderSelectionBlueprint : SelectionBlueprintTestCase
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
-            typeof(SliderSelectionMask),
-            typeof(SliderCircleSelectionMask),
+            typeof(SliderSelectionBlueprint),
+            typeof(SliderCircleSelectionBlueprint),
             typeof(SliderBodyPiece),
             typeof(SliderCircle),
             typeof(PathControlPointVisualiser),
@@ -30,19 +31,17 @@ namespace osu.Game.Rulesets.Osu.Tests
 
         private readonly DrawableSlider drawableObject;
 
-        public TestCaseSliderSelectionMask()
+        public TestCaseSliderSelectionBlueprint()
         {
             var slider = new Slider
             {
                 Position = new Vector2(256, 192),
-                ControlPoints = new[]
+                Path = new SliderPath(PathType.Bezier, new[]
                 {
                     Vector2.Zero,
                     new Vector2(150, 150),
                     new Vector2(300, 0)
-                },
-                PathType = PathType.Bezier,
-                Distance = 350
+                })
             };
 
             slider.ApplyDefaults(new ControlPointInfo(), new BeatmapDifficulty { CircleSize = 2 });
@@ -50,6 +49,6 @@ namespace osu.Game.Rulesets.Osu.Tests
             Add(drawableObject = new DrawableSlider(slider));
         }
 
-        protected override SelectionMask CreateMask() => new SliderSelectionMask(drawableObject);
+        protected override SelectionBlueprint CreateBlueprint() => new SliderSelectionBlueprint(drawableObject);
     }
 }

osu.Game.Rulesets.Osu.Tests/TestCaseSpinnerPlacementBlueprint.cs

@@ -4,17 +4,17 @@
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public class TestCaseSpinnerPlacementMask : HitObjectPlacementMaskTestCase
+    public class TestCaseSpinnerPlacementBlueprint : PlacementBlueprintTestCase
     {
         protected override DrawableHitObject CreateHitObject(HitObject hitObject) => new DrawableSpinner((Spinner)hitObject);
 
-        protected override PlacementMask CreateMask() => new SpinnerPlacementMask();
+        protected override PlacementBlueprint CreateBlueprint() => new SpinnerPlacementBlueprint();
     }
 }

osu.Game.Rulesets.Osu.Tests/TestCaseSpinnerSelectionBlueprint.cs

@@ -8,26 +8,26 @@ using osu.Framework.Graphics.Containers;
 using osu.Game.Beatmaps;
 using osu.Game.Beatmaps.ControlPoints;
 using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks;
-using osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks.Components;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Tests.Visual;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Tests
 {
-    public class TestCaseSpinnerSelectionMask : HitObjectSelectionMaskTestCase
+    public class TestCaseSpinnerSelectionBlueprint : SelectionBlueprintTestCase
     {
         public override IReadOnlyList<Type> RequiredTypes => new[]
         {
-            typeof(SpinnerSelectionMask),
+            typeof(SpinnerSelectionBlueprint),
             typeof(SpinnerPiece)
         };
 
         private readonly DrawableSpinner drawableSpinner;
 
-        public TestCaseSpinnerSelectionMask()
+        public TestCaseSpinnerSelectionBlueprint()
         {
             var spinner = new Spinner
             {
@@ -45,6 +45,6 @@ namespace osu.Game.Rulesets.Osu.Tests
             });
         }
 
-        protected override SelectionMask CreateMask() => new SpinnerSelectionMask(drawableSpinner) { Size = new Vector2(0.5f) };
+        protected override SelectionBlueprint CreateBlueprint() => new SpinnerSelectionBlueprint(drawableSpinner) { Size = new Vector2(0.5f) };
     }
 }

osu.Game.Rulesets.Osu/Beatmaps/OsuBeatmapConverter.cs

@@ -1,7 +1,7 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
+using osuTK;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
@@ -35,9 +35,7 @@ namespace osu.Game.Rulesets.Osu.Beatmaps
                 {
                     StartTime = original.StartTime,
                     Samples = original.Samples,
-                    ControlPoints = curveData.ControlPoints,
-                    PathType = curveData.PathType,
-                    Distance = curveData.Distance,
+                    Path = curveData.Path,
                     NodeSamples = curveData.NodeSamples,
                     RepeatCount = curveData.RepeatCount,
                     Position = positionData?.Position ?? Vector2.Zero,

osu.Game.Rulesets.Osu/Difficulty/Preprocessing/OsuDifficultyHitObject.cs

@@ -4,7 +4,7 @@
 using System;
 using System.Linq;
 using osu.Game.Rulesets.Osu.Objects;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Difficulty.Preprocessing
 {

osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/Components/HitCirclePiece.cs

@@ -3,19 +3,19 @@
 
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using OpenTK;
+using osuTK;
 
-namespace osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks.Components
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components
 {
-    public class HitCirclePiece : CompositeDrawable
+    public class HitCirclePiece : HitObjectPiece
     {
         private readonly HitCircle hitCircle;
 
         public HitCirclePiece(HitCircle hitCircle)
+            : base(hitCircle)
         {
             this.hitCircle = hitCircle;
             Origin = Anchor.Centre;
@@ -25,10 +25,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks.Components
             CornerRadius = Size.X / 2;
 
             InternalChild = new RingPiece();
-
-            hitCircle.PositionChanged += _ => UpdatePosition();
-            hitCircle.StackHeightChanged += _ => UpdatePosition();
-            hitCircle.ScaleChanged += _ => Scale = new Vector2(hitCircle.Scale);
         }
 
         [BackgroundDependencyLoader]
@@ -36,7 +32,9 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks.Components
         {
             Colour = colours.Yellow;
 
-            UpdatePosition();
+            PositionBindable.BindValueChanged(_ => UpdatePosition(), true);
+            StackHeightBindable.BindValueChanged(_ => UpdatePosition());
+            ScaleBindable.BindValueChanged(v => Scale = new Vector2(v), true);
         }
 
         protected virtual void UpdatePosition() => Position = hitCircle.StackedPosition;

osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCirclePlacementBlueprint.cs

@@ -3,16 +3,16 @@
 
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks.Components;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Objects;
 
-namespace osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
 {
-    public class HitCirclePlacementMask : PlacementMask
+    public class HitCirclePlacementBlueprint : PlacementBlueprint
     {
         public new HitCircle HitObject => (HitCircle)base.HitObject;
 
-        public HitCirclePlacementMask()
+        public HitCirclePlacementBlueprint()
             : base(new HitCircle())
         {
             InternalChild = new HitCirclePiece(HitObject);

osu.Game.Rulesets.Osu/Edit/Blueprints/HitCircles/HitCircleSelectionBlueprint.cs

@@ -1,16 +1,15 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks.Components;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 
-namespace osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles
 {
-    public class HitCircleSelectionMask : SelectionMask
+    public class HitCircleSelectionBlueprint : OsuSelectionBlueprint
     {
-        public HitCircleSelectionMask(DrawableHitCircle hitCircle)
+        public HitCircleSelectionBlueprint(DrawableHitCircle hitCircle)
             : base(hitCircle)
         {
             InternalChild = new HitCirclePiece((HitCircle)hitCircle.HitObject);

osu.Game.Rulesets.Osu/Edit/Blueprints/HitObjectPiece.cs

@@ -0,0 +1,36 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints
+{
+    /// <summary>
+    /// A piece of a blueprint which responds to changes in the state of a <see cref="OsuHitObject"/>.
+    /// </summary>
+    public abstract class HitObjectPiece : CompositeDrawable
+    {
+        protected readonly IBindable<Vector2> PositionBindable = new Bindable<Vector2>();
+        protected readonly IBindable<int> StackHeightBindable = new Bindable<int>();
+        protected readonly IBindable<float> ScaleBindable = new Bindable<float>();
+
+        private readonly OsuHitObject hitObject;
+
+        protected HitObjectPiece(OsuHitObject hitObject)
+        {
+            this.hitObject = hitObject;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            PositionBindable.BindTo(hitObject.PositionBindable);
+            StackHeightBindable.BindTo(hitObject.StackHeightBindable);
+            ScaleBindable.BindTo(hitObject.ScaleBindable);
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Blueprints/OsuSelectionBlueprint.cs

@@ -0,0 +1,22 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints
+{
+    public class OsuSelectionBlueprint : SelectionBlueprint
+    {
+        protected OsuHitObject OsuObject => (OsuHitObject)HitObject.HitObject;
+
+        public OsuSelectionBlueprint(DrawableHitObject hitObject)
+            : base(hitObject)
+        {
+        }
+
+        public override void AdjustPosition(DragEvent dragEvent) => OsuObject.Position += dragEvent.Delta;
+    }
+}

osu.Game.Rulesets.Osu/Edit/Blueprints/SliderPiece.cs

@@ -0,0 +1,32 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Objects;
+
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints
+{
+    /// <summary>
+    /// A piece of a blueprint which responds to changes in the state of a <see cref="Slider"/>.
+    /// </summary>
+    public abstract class SliderPiece : HitObjectPiece
+    {
+        protected readonly IBindable<SliderPath> PathBindable = new Bindable<SliderPath>();
+
+        private readonly Slider slider;
+
+        protected SliderPiece(Slider slider)
+            : base(slider)
+        {
+            this.slider = slider;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            PathBindable.BindTo(slider.PathBindable);
+        }
+    }
+}

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointPiece.cs

@@ -1,7 +1,6 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
@@ -9,10 +8,11 @@ using osu.Framework.Graphics.Lines;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Game.Graphics;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
-using OpenTK;
+using osuTK;
 
-namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {
     public class PathControlPointPiece : CompositeDrawable
     {
@@ -55,16 +55,16 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
         {
             base.Update();
 
-            Position = slider.StackedPosition + slider.ControlPoints[index];
+            Position = slider.StackedPosition + slider.Path.ControlPoints[index];
 
             marker.Colour = isSegmentSeparator ? colours.Red : colours.Yellow;
 
             path.ClearVertices();
 
-            if (index != slider.ControlPoints.Length - 1)
+            if (index != slider.Path.ControlPoints.Length - 1)
             {
                 path.AddVertex(Vector2.Zero);
-                path.AddVertex(slider.ControlPoints[index + 1] - slider.ControlPoints[index]);
+                path.AddVertex(slider.Path.ControlPoints[index + 1] - slider.Path.ControlPoints[index]);
             }
 
             path.OriginPosition = path.PositionInBoundingBox(Vector2.Zero);
@@ -76,7 +76,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
 
         protected override bool OnDrag(DragEvent e)
         {
-            var newControlPoints = slider.ControlPoints.ToArray();
+            var newControlPoints = slider.Path.ControlPoints.ToArray();
 
             if (index == 0)
             {
@@ -96,8 +96,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
             if (isSegmentSeparatorWithPrevious)
                 newControlPoints[index - 1] = newControlPoints[index];
 
-            slider.ControlPoints = newControlPoints;
-            slider.Path.Calculate(true);
+            slider.Path = new SliderPath(slider.Path.Type, newControlPoints);
 
             return true;
         }
@@ -106,8 +105,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
 
         private bool isSegmentSeparator => isSegmentSeparatorWithNext || isSegmentSeparatorWithPrevious;
 
-        private bool isSegmentSeparatorWithNext => index < slider.ControlPoints.Length - 1 && slider.ControlPoints[index + 1] == slider.ControlPoints[index];
+        private bool isSegmentSeparatorWithNext => index < slider.Path.ControlPoints.Length - 1 && slider.Path.ControlPoints[index + 1] == slider.Path.ControlPoints[index];
 
-        private bool isSegmentSeparatorWithPrevious => index > 0 && slider.ControlPoints[index - 1] == slider.ControlPoints[index];
+        private bool isSegmentSeparatorWithPrevious => index > 0 && slider.Path.ControlPoints[index - 1] == slider.Path.ControlPoints[index];
     }
 }

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs

@@ -1,33 +1,38 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Allocation;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Game.Rulesets.Osu.Objects;
 
-namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {
-    public class PathControlPointVisualiser : CompositeDrawable
+    public class PathControlPointVisualiser : SliderPiece
     {
         private readonly Slider slider;
 
         private readonly Container<PathControlPointPiece> pieces;
 
         public PathControlPointVisualiser(Slider slider)
+            : base(slider)
         {
             this.slider = slider;
 
             InternalChild = pieces = new Container<PathControlPointPiece> { RelativeSizeAxes = Axes.Both };
+        }
 
-            slider.ControlPointsChanged += _ => updatePathControlPoints();
-            updatePathControlPoints();
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            PathBindable.BindValueChanged(_ => updatePathControlPoints(), true);
         }
 
         private void updatePathControlPoints()
         {
-            while (slider.ControlPoints.Length > pieces.Count)
+            while (slider.Path.ControlPoints.Length > pieces.Count)
                 pieces.Add(new PathControlPointPiece(slider, pieces.Count));
-            while (slider.ControlPoints.Length < pieces.Count)
+            while (slider.Path.ControlPoints.Length < pieces.Count)
                 pieces.Remove(pieces[pieces.Count - 1]);
         }
     }

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/SliderBodyPiece.cs

@@ -3,21 +3,21 @@
 
 using System.Collections.Generic;
 using osu.Framework.Allocation;
-using osu.Framework.Graphics.Containers;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 
-namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {
-    public class SliderBodyPiece : CompositeDrawable
+    public class SliderBodyPiece : SliderPiece
     {
         private readonly Slider slider;
         private readonly ManualSliderBody body;
 
         public SliderBodyPiece(Slider slider)
+            : base(slider)
         {
             this.slider = slider;
 
@@ -26,9 +26,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
                 AccentColour = Color4.Transparent,
                 PathWidth = slider.Scale * 64
             };
-
-            slider.PositionChanged += _ => updatePosition();
-            slider.ScaleChanged += _ => body.PathWidth = slider.Scale * 64;
         }
 
         [BackgroundDependencyLoader]
@@ -36,7 +33,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
         {
             body.BorderColour = colours.Yellow;
 
-            updatePosition();
+            PositionBindable.BindValueChanged(_ => updatePosition(), true);
+            ScaleBindable.BindValueChanged(v => body.PathWidth = v * 64, true);
         }
 
         private void updatePosition() => Position = slider.StackedPosition;
@@ -45,8 +43,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
         {
             base.Update();
 
-            slider.Path.Calculate();
-
             var vertices = new List<Vector2>();
             slider.Path.GetPathToProgress(vertices, 0, 1);
 

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/SliderCirclePiece.cs

@@ -1,13 +1,18 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks.Components;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Game.Rulesets.Objects;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
 using osu.Game.Rulesets.Osu.Objects;
 
-namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
 {
     public class SliderCirclePiece : HitCirclePiece
     {
+        private readonly IBindable<SliderPath> pathBindable = new Bindable<SliderPath>();
+
         private readonly Slider slider;
         private readonly SliderPosition position;
 
@@ -16,8 +21,13 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components
         {
             this.slider = slider;
             this.position = position;
+        }
 
-            slider.ControlPointsChanged += _ => UpdatePosition();
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            pathBindable.BindTo(slider.PathBindable);
+            pathBindable.BindValueChanged(_ => UpdatePosition(), true);
         }
 
         protected override void UpdatePosition()

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderCircleSelectionBlueprint.cs

@@ -1,18 +1,22 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 
-namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 {
-    public class SliderCircleSelectionMask : SelectionMask
+    public class SliderCircleSelectionBlueprint : OsuSelectionBlueprint
     {
-        public SliderCircleSelectionMask(DrawableOsuHitObject hitObject, Slider slider, SliderPosition position)
+        private readonly Slider slider;
+
+        public SliderCircleSelectionBlueprint(DrawableOsuHitObject hitObject, Slider slider, SliderPosition position)
             : base(hitObject)
         {
+            this.slider = slider;
+
             InternalChild = new SliderCirclePiece(slider, position);
 
             Select();
@@ -20,5 +24,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks
 
         // Todo: This is temporary, since the slider circle masks don't do anything special yet. In the future they will handle input.
         public override bool HandlePositionalInput => false;
+
+        public override void AdjustPosition(DragEvent dragEvent) => slider.Position += dragEvent.Delta;
     }
 }

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPlacementBlueprint.cs

@@ -1,24 +1,23 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
-using osu.Framework.MathUtils;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Edit;
+using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components;
-using OpenTK;
-using OpenTK.Input;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
+using osuTK;
+using osuTK.Input;
 
-namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 {
-    public class SliderPlacementMask : PlacementMask
+    public class SliderPlacementBlueprint : PlacementBlueprint
     {
         public new Objects.Slider HitObject => (Objects.Slider)base.HitObject;
 
@@ -27,7 +26,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks
 
         private PlacementState state;
 
-        public SliderPlacementMask()
+        public SliderPlacementBlueprint()
             : base(new Objects.Slider())
         {
             RelativeSizeAxes = Axes.Both;
@@ -119,12 +118,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks
 
         private void updateSlider()
         {
-            for (int i = 0; i < segments.Count; i++)
-                segments[i].Calculate(i == segments.Count - 1 ? (Vector2?)cursor : null);
-
-            HitObject.ControlPoints = segments.SelectMany(s => s.ControlPoints).Concat(cursor.Yield()).ToArray();
-            HitObject.PathType = HitObject.ControlPoints.Length > 2 ? PathType.Bezier : PathType.Linear;
-            HitObject.Distance = segments.Sum(s => s.Distance);
+            var newControlPoints = segments.SelectMany(s => s.ControlPoints).Concat(cursor.Yield()).ToArray();
+            HitObject.Path = new SliderPath(newControlPoints.Length > 2 ? PathType.Bezier : PathType.Linear, newControlPoints);
         }
 
         private void setState(PlacementState newState)
@@ -140,41 +135,12 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks
 
         private class Segment
         {
-            public float Distance { get; private set; }
-
             public readonly List<Vector2> ControlPoints = new List<Vector2>();
 
             public Segment(Vector2 offset)
             {
                 ControlPoints.Add(offset);
             }
-
-            public void Calculate(Vector2? cursor = null)
-            {
-                Span<Vector2> allControlPoints = stackalloc Vector2[ControlPoints.Count + (cursor.HasValue ? 1 : 0)];
-
-                for (int i = 0; i < ControlPoints.Count; i++)
-                    allControlPoints[i] = ControlPoints[i];
-                if (cursor.HasValue)
-                    allControlPoints[allControlPoints.Length - 1] = cursor.Value;
-
-                List<Vector2> result;
-
-                switch (allControlPoints.Length)
-                {
-                    case 1:
-                    case 2:
-                        result = PathApproximator.ApproximateLinear(allControlPoints);
-                        break;
-                    default:
-                        result = PathApproximator.ApproximateBezier(allControlPoints);
-                        break;
-                }
-
-                Distance = 0;
-                for (int i = 0; i < result.Count - 1; i++)
-                    Distance += Vector2.Distance(result[i], result[i + 1]);
-            }
         }
     }
 }

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderPosition.cs

@@ -1,7 +1,7 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
 {
     public enum SliderPosition
     {

osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/SliderSelectionBlueprint.cs

@@ -0,0 +1,32 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
+using osu.Game.Rulesets.Osu.Objects;
+using osu.Game.Rulesets.Osu.Objects.Drawables;
+using osuTK;
+
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
+{
+    public class SliderSelectionBlueprint : OsuSelectionBlueprint
+    {
+        private readonly SliderCircleSelectionBlueprint headBlueprint;
+
+        public SliderSelectionBlueprint(DrawableSlider slider)
+            : base(slider)
+        {
+            var sliderObject = (Slider)slider.HitObject;
+
+            InternalChildren = new Drawable[]
+            {
+                new SliderBodyPiece(sliderObject),
+                headBlueprint = new SliderCircleSelectionBlueprint(slider.HeadCircle, sliderObject, SliderPosition.Start),
+                new SliderCircleSelectionBlueprint(slider.TailCircle, sliderObject, SliderPosition.End),
+                new PathControlPointVisualiser(sliderObject),
+            };
+        }
+
+        public override Vector2 SelectionPoint => headBlueprint.SelectionPoint;
+    }
+}

osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/Components/SpinnerPiece.cs

@@ -8,16 +8,18 @@ using osu.Framework.Graphics.Shapes;
 using osu.Game.Graphics;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
-using OpenTK;
+using osuTK;
 
-namespace osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks.Components
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components
 {
-    public class SpinnerPiece : CompositeDrawable
+    public class SpinnerPiece : HitObjectPiece
     {
         private readonly Spinner spinner;
         private readonly CircularContainer circle;
+        private readonly RingPiece ring;
 
         public SpinnerPiece(Spinner spinner)
+            : base(spinner)
         {
             this.spinner = spinner;
 
@@ -27,7 +29,6 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks.Components
             FillMode = FillMode.Fit;
             Size = new Vector2(1.3f);
 
-            RingPiece ring;
             InternalChildren = new Drawable[]
             {
                 circle = new CircularContainer
@@ -45,18 +46,16 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks.Components
             };
 
             ring.Scale = new Vector2(spinner.Scale);
-
-            spinner.PositionChanged += _ => updatePosition();
-            spinner.StackHeightChanged += _ => updatePosition();
-            spinner.ScaleChanged += _ => ring.Scale = new Vector2(spinner.Scale);
-
-            updatePosition();
         }
 
         [BackgroundDependencyLoader]
         private void load(OsuColour colours)
         {
             Colour = colours.Yellow;
+
+            PositionBindable.BindValueChanged(_ => updatePosition(), true);
+            StackHeightBindable.BindValueChanged(_ => updatePosition());
+            ScaleBindable.BindValueChanged(v => ring.Scale = new Vector2(v), true);
         }
 
         private void updatePosition() => Position = spinner.Position;

osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerPlacementBlueprint.cs

@@ -4,13 +4,13 @@
 using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks.Components;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.UI;
 
-namespace osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
 {
-    public class SpinnerPlacementMask : PlacementMask
+    public class SpinnerPlacementBlueprint : PlacementBlueprint
     {
         public new Spinner HitObject => (Spinner)base.HitObject;
 
@@ -18,7 +18,7 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks
 
         private bool isPlacingEnd;
 
-        public SpinnerPlacementMask()
+        public SpinnerPlacementBlueprint()
             : base(new Spinner { Position = OsuPlayfield.BASE_SIZE / 2 })
         {
             InternalChild = piece = new SpinnerPiece(HitObject) { Alpha = 0.5f };
@@ -37,6 +37,8 @@ namespace osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks
 
                 isPlacingEnd = true;
                 piece.FadeTo(1f, 150, Easing.OutQuint);
+
+                BeginPlacement();
             }
 
             return true;

osu.Game.Rulesets.Osu/Edit/Blueprints/Spinners/SpinnerSelectionBlueprint.cs

@@ -1,24 +1,29 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks.Components;
+using osu.Framework.Input.Events;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners.Components;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
-using OpenTK;
+using osuTK;
 
-namespace osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks
+namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners
 {
-    public class SpinnerSelectionMask : SelectionMask
+    public class SpinnerSelectionBlueprint : OsuSelectionBlueprint
     {
         private readonly SpinnerPiece piece;
 
-        public SpinnerSelectionMask(DrawableSpinner spinner)
+        public SpinnerSelectionBlueprint(DrawableSpinner spinner)
             : base(spinner)
         {
             InternalChild = piece = new SpinnerPiece((Spinner)spinner.HitObject);
         }
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => piece.ReceivePositionalInputAt(screenSpacePos);
+
+        public override void AdjustPosition(DragEvent dragEvent)
+        {
+            // Spinners don't support position adjustments
+        }
     }
 }

osu.Game.Rulesets.Osu/Edit/HitCircleCompositionTool.cs

@@ -3,7 +3,7 @@
 
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
-using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Edit
@@ -15,6 +15,6 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
         }
 
-        public override PlacementMask CreatePlacementMask() => new HitCirclePlacementMask();
+        public override PlacementBlueprint CreatePlacementBlueprint() => new HitCirclePlacementBlueprint();
     }
 }

osu.Game.Rulesets.Osu/Edit/Masks/SliderMasks/SliderSelectionMask.cs

@@ -1,33 +0,0 @@
-// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
-// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
-
-using osu.Framework.Graphics;
-using osu.Game.Rulesets.Edit;
-using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks.Components;
-using osu.Game.Rulesets.Osu.Objects;
-using osu.Game.Rulesets.Osu.Objects.Drawables;
-using OpenTK;
-
-namespace osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks
-{
-    public class SliderSelectionMask : SelectionMask
-    {
-        private readonly SliderCircleSelectionMask headMask;
-
-        public SliderSelectionMask(DrawableSlider slider)
-            : base(slider)
-        {
-            var sliderObject = (Slider)slider.HitObject;
-
-            InternalChildren = new Drawable[]
-            {
-                new SliderBodyPiece(sliderObject),
-                headMask = new SliderCircleSelectionMask(slider.HeadCircle, sliderObject, SliderPosition.Start),
-                new SliderCircleSelectionMask(slider.TailCircle, sliderObject, SliderPosition.End),
-                new PathControlPointVisualiser(sliderObject),
-            };
-        }
-
-        public override Vector2 SelectionPoint => headMask.SelectionPoint;
-    }
-}

osu.Game.Rulesets.Osu/Edit/OsuEditRulesetContainer.cs

@@ -5,7 +5,7 @@ using osu.Framework.Graphics.Cursor;
 using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Osu.UI;
 using osu.Game.Rulesets.UI;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Edit
 {

osu.Game.Rulesets.Osu/Edit/OsuHitObjectComposer.cs

@@ -8,9 +8,9 @@ using osu.Game.Beatmaps;
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
 using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Osu.Edit.Masks.HitCircleMasks;
-using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks;
-using osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.Objects.Drawables;
 using osu.Game.Rulesets.Osu.UI;
@@ -37,19 +37,19 @@ namespace osu.Game.Rulesets.Osu.Edit
 
         protected override Container CreateLayerContainer() => new PlayfieldAdjustmentContainer { RelativeSizeAxes = Axes.Both };
 
-        public override SelectionMask CreateMaskFor(DrawableHitObject hitObject)
+        public override SelectionBlueprint CreateBlueprintFor(DrawableHitObject hitObject)
         {
             switch (hitObject)
             {
                 case DrawableHitCircle circle:
-                    return new HitCircleSelectionMask(circle);
+                    return new HitCircleSelectionBlueprint(circle);
                 case DrawableSlider slider:
-                    return new SliderSelectionMask(slider);
+                    return new SliderSelectionBlueprint(slider);
                 case DrawableSpinner spinner:
-                    return new SpinnerSelectionMask(spinner);
+                    return new SpinnerSelectionBlueprint(spinner);
             }
 
-            return base.CreateMaskFor(hitObject);
+            return base.CreateBlueprintFor(hitObject);
         }
     }
 }

osu.Game.Rulesets.Osu/Edit/SliderCompositionTool.cs

@@ -3,7 +3,7 @@
 
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
-using osu.Game.Rulesets.Osu.Edit.Masks.SliderMasks;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Edit
@@ -15,6 +15,6 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
         }
 
-        public override PlacementMask CreatePlacementMask() => new SliderPlacementMask();
+        public override PlacementBlueprint CreatePlacementBlueprint() => new SliderPlacementBlueprint();
     }
 }

osu.Game.Rulesets.Osu/Edit/SpinnerCompositionTool.cs

@@ -3,7 +3,7 @@
 
 using osu.Game.Rulesets.Edit;
 using osu.Game.Rulesets.Edit.Tools;
-using osu.Game.Rulesets.Osu.Edit.Masks.SpinnerMasks;
+using osu.Game.Rulesets.Osu.Edit.Blueprints.Spinners;
 using osu.Game.Rulesets.Osu.Objects;
 
 namespace osu.Game.Rulesets.Osu.Edit
@@ -15,6 +15,6 @@ namespace osu.Game.Rulesets.Osu.Edit
         {
         }
 
-        public override PlacementMask CreatePlacementMask() => new SpinnerPlacementMask();
+        public override PlacementBlueprint CreatePlacementBlueprint() => new SpinnerPlacementBlueprint();
     }
 }

osu.Game.Rulesets.Osu/Mods/OsuModFlashlight.cs

@@ -1,12 +1,52 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
+using osu.Framework.Graphics;
+using osu.Framework.Input;
+using osu.Framework.Input.Events;
 using osu.Game.Rulesets.Mods;
+using osu.Game.Rulesets.Osu.Objects;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
-    public class OsuModFlashlight : ModFlashlight
+    public class OsuModFlashlight : ModFlashlight<OsuHitObject>
     {
         public override double ScoreMultiplier => 1.12;
+
+        private const float default_flashlight_size = 180;
+
+        public override Flashlight CreateFlashlight() => new OsuFlashlight();
+
+        private class OsuFlashlight : Flashlight, IRequireHighFrequencyMousePosition
+        {
+            public OsuFlashlight()
+            {
+                FlashlightSize = new Vector2(0, getSizeFor(0));
+            }
+
+            protected override bool OnMouseMove(MouseMoveEvent e)
+            {
+                FlashlightPosition = e.MousePosition;
+                return base.OnMouseMove(e);
+            }
+
+            private float getSizeFor(int combo)
+            {
+                if (combo > 200)
+                    return default_flashlight_size * 0.8f;
+                else if (combo > 100)
+                    return default_flashlight_size * 0.9f;
+                else
+                    return default_flashlight_size;
+            }
+
+            protected override void OnComboChange(int newCombo)
+            {
+                this.TransformTo(nameof(FlashlightSize), new Vector2(0, getSizeFor(newCombo)), FLASHLIGHT_FADE_DURATION);
+            }
+
+            protected override string FragmentShader => "CircularFlashlight";
+        }
     }
 }

osu.Game.Rulesets.Osu/Mods/OsuModHardRock.cs

@@ -7,7 +7,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects;
 using osu.Game.Rulesets.Osu.Objects;
 using osu.Game.Rulesets.Osu.UI;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {
@@ -32,12 +32,11 @@ namespace osu.Game.Rulesets.Osu.Mods
             slider.NestedHitObjects.OfType<SliderTick>().ForEach(h => h.Position = new Vector2(h.Position.X, OsuPlayfield.BASE_SIZE.Y - h.Position.Y));
             slider.NestedHitObjects.OfType<RepeatPoint>().ForEach(h => h.Position = new Vector2(h.Position.X, OsuPlayfield.BASE_SIZE.Y - h.Position.Y));
 
-            var newControlPoints = new Vector2[slider.ControlPoints.Length];
-            for (int i = 0; i < slider.ControlPoints.Length; i++)
-                newControlPoints[i] = new Vector2(slider.ControlPoints[i].X, -slider.ControlPoints[i].Y);
+            var newControlPoints = new Vector2[slider.Path.ControlPoints.Length];
+            for (int i = 0; i < slider.Path.ControlPoints.Length; i++)
+                newControlPoints[i] = new Vector2(slider.Path.ControlPoints[i].X, -slider.Path.ControlPoints[i].Y);
 
-            slider.ControlPoints = newControlPoints;
-            slider.Path?.Calculate(); // Recalculate the slider curve
+            slider.Path = new SliderPath(slider.Path.Type, newControlPoints, slider.Path.ExpectedDistance);
         }
     }
 }

osu.Game.Rulesets.Osu/Mods/OsuModTransform.cs

@@ -8,7 +8,7 @@ using osu.Game.Graphics;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Osu.Objects;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {

osu.Game.Rulesets.Osu/Mods/OsuModWiggle.cs

@@ -9,7 +9,7 @@ using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Osu.Objects;
-using OpenTK;
+using osuTK;
 
 namespace osu.Game.Rulesets.Osu.Mods
 {

osu.Game.Rulesets.Osu/Objects/Drawables/Connections/FollowPoint.cs

@@ -1,8 +1,8 @@
 // Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
 // Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
 
-using OpenTK;
-using OpenTK.Graphics;
+using osuTK;
+using osuTK.Graphics;
 using osu.Framework.Extensions.Color4Extensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;