diff --git a/osu.Game.Rulesets.Catch/UI/CatchPlayfield.cs b/osu.Game.Rulesets.Catch/UI/CatchPlayfield.cs
index 925e7aaac9..08b7684677 100644
--- a/osu.Game.Rulesets.Catch/UI/CatchPlayfield.cs
+++ b/osu.Game.Rulesets.Catch/UI/CatchPlayfield.cs
@@ -23,7 +23,7 @@ namespace osu.Game.Rulesets.Catch.UI
 
         protected override bool UserScrollSpeedAdjustment => false;
 
-        protected override SpeedChangeVisualisationMethod VisualisationMethod => SpeedChangeVisualisationMethod.Constant;
+        protected override ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Constant;
 
         public CatchPlayfield(BeatmapDifficulty difficulty, Func<CatchHitObject, DrawableHitObject<CatchHitObject>> getVisualRepresentation)
         {
diff --git a/osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs b/osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs
index 40ed659bd6..824c1f817a 100644
--- a/osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs
+++ b/osu.Game.Rulesets.Taiko/UI/TaikoPlayfield.cs
@@ -41,7 +41,7 @@ namespace osu.Game.Rulesets.Taiko.UI
 
         protected override bool UserScrollSpeedAdjustment => false;
 
-        protected override SpeedChangeVisualisationMethod VisualisationMethod => SpeedChangeVisualisationMethod.Overlapping;
+        protected override ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Overlapping;
 
         private readonly Container<HitExplosion> hitExplosionContainer;
         private readonly Container<KiaiHitExplosion> kiaiExplosionContainer;
diff --git a/osu.Game.Tests/ScrollAlgorithms/ConstantScrollTest.cs b/osu.Game.Tests/ScrollAlgorithms/ConstantScrollTest.cs
new file mode 100644
index 0000000000..5e01213a48
--- /dev/null
+++ b/osu.Game.Tests/ScrollAlgorithms/ConstantScrollTest.cs
@@ -0,0 +1,54 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using NUnit.Framework;
+using osu.Game.Rulesets.UI.Scrolling.Algorithms;
+
+namespace osu.Game.Tests.ScrollAlgorithms
+{
+    [TestFixture]
+    public class ConstantScrollTest
+    {
+        private IScrollAlgorithm algorithm;
+
+        [SetUp]
+        public void Setup()
+        {
+            algorithm = new ConstantScrollAlgorithm();
+        }
+
+        [Test]
+        public void TestDisplayStartTime()
+        {
+            Assert.AreEqual(-8000, algorithm.GetDisplayStartTime(2000, 10000));
+            Assert.AreEqual(-3000, algorithm.GetDisplayStartTime(2000, 5000));
+            Assert.AreEqual(2000, algorithm.GetDisplayStartTime(7000, 5000));
+            Assert.AreEqual(7000, algorithm.GetDisplayStartTime(17000, 10000));
+        }
+
+        [Test]
+        public void TestLength()
+        {
+            Assert.AreEqual(1f / 5, algorithm.GetLength(0, 1000, 5000, 1));
+            Assert.AreEqual(1f / 5, algorithm.GetLength(6000, 7000, 5000, 1));
+        }
+
+        [Test]
+        public void TestPosition()
+        {
+            Assert.AreEqual(1f / 5, algorithm.PositionAt(1000, 0, 5000, 1));
+            Assert.AreEqual(1f / 5, algorithm.PositionAt(6000, 5000, 5000, 1));
+        }
+
+        [TestCase(1000)]
+        [TestCase(10000)]
+        [TestCase(15000)]
+        [TestCase(20000)]
+        [TestCase(25000)]
+        public void TestTime(double time)
+        {
+            Assert.AreEqual(time, algorithm.TimeAt(algorithm.PositionAt(time, 0, 5000, 1), 0, 5000, 1), 0.001);
+            Assert.AreEqual(time, algorithm.TimeAt(algorithm.PositionAt(time, 5000, 5000, 1), 5000, 5000, 1), 0.001);
+        }
+    }
+}
diff --git a/osu.Game.Tests/ScrollAlgorithms/OverlappingScrollTest.cs b/osu.Game.Tests/ScrollAlgorithms/OverlappingScrollTest.cs
new file mode 100644
index 0000000000..c1a5a0f3c9
--- /dev/null
+++ b/osu.Game.Tests/ScrollAlgorithms/OverlappingScrollTest.cs
@@ -0,0 +1,67 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using NUnit.Framework;
+using osu.Framework.Lists;
+using osu.Game.Rulesets.Timing;
+using osu.Game.Rulesets.UI.Scrolling.Algorithms;
+
+namespace osu.Game.Tests.ScrollAlgorithms
+{
+    [TestFixture]
+    public class OverlappingScrollTest
+    {
+        private IScrollAlgorithm algorithm;
+
+        [SetUp]
+        public void Setup()
+        {
+            var controlPoints = new SortedList<MultiplierControlPoint>
+            {
+                new MultiplierControlPoint(0) { Velocity = 1 },
+                new MultiplierControlPoint(10000) { Velocity = 2f },
+                new MultiplierControlPoint(20000) { Velocity = 0.5f }
+            };
+
+            algorithm = new OverlappingScrollAlgorithm(controlPoints);
+        }
+
+        [Test]
+        public void TestDisplayStartTime()
+        {
+            Assert.AreEqual(1000, algorithm.GetDisplayStartTime(2000, 1000)); // Like constant
+            Assert.AreEqual(10000, algorithm.GetDisplayStartTime(10500, 1000)); // 10500 - (1000 * 0.5)
+            Assert.AreEqual(20000, algorithm.GetDisplayStartTime(22000, 1000)); // 23000 - (1000 / 0.5)
+        }
+
+        [Test]
+        public void TestLength()
+        {
+            Assert.AreEqual(1f / 5, algorithm.GetLength(0, 1000, 5000, 1)); // Like constant
+            Assert.AreEqual(1f / 5, algorithm.GetLength(10000, 10500, 5000, 1)); // (10500 - 10000) / 0.5 / 5000
+            Assert.AreEqual(1f / 5, algorithm.GetLength(20000, 22000, 5000, 1)); // (22000 - 20000) * 0.5 / 5000
+        }
+
+        [Test]
+        public void TestPosition()
+        {
+            // Basically same calculations as TestLength()
+            Assert.AreEqual(1f / 5, algorithm.PositionAt(1000, 0, 5000, 1));
+            Assert.AreEqual(1f / 5, algorithm.PositionAt(10500, 10000, 5000, 1));
+            Assert.AreEqual(1f / 5, algorithm.PositionAt(22000, 20000, 5000, 1));
+        }
+
+        [TestCase(1000)]
+        [TestCase(10000)]
+        [TestCase(15000)]
+        [TestCase(20000)]
+        [TestCase(25000)]
+        [Ignore("Disabled for now because overlapping control points have multiple time values under the same position."
+                + "Ideally, scrolling should be changed to constant or sequential during editing of hitobjects.")]
+        public void TestTime(double time)
+        {
+            Assert.AreEqual(time, algorithm.TimeAt(algorithm.PositionAt(time, 0, 5000, 1), 0, 5000, 1), 0.001);
+            Assert.AreEqual(time, algorithm.TimeAt(algorithm.PositionAt(time, 5000, 5000, 1), 5000, 5000, 1), 0.001);
+        }
+    }
+}
diff --git a/osu.Game.Tests/ScrollAlgorithms/SequentialScrollTest.cs b/osu.Game.Tests/ScrollAlgorithms/SequentialScrollTest.cs
new file mode 100644
index 0000000000..990fb92e6c
--- /dev/null
+++ b/osu.Game.Tests/ScrollAlgorithms/SequentialScrollTest.cs
@@ -0,0 +1,64 @@
+// Copyright (c) 2007-2018 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using NUnit.Framework;
+using osu.Framework.Lists;
+using osu.Game.Rulesets.Timing;
+using osu.Game.Rulesets.UI.Scrolling.Algorithms;
+
+namespace osu.Game.Tests.ScrollAlgorithms
+{
+    [TestFixture]
+    public class SequentialScrollTest
+    {
+        private IScrollAlgorithm algorithm;
+
+        [SetUp]
+        public void Setup()
+        {
+            var controlPoints = new SortedList<MultiplierControlPoint>
+            {
+                new MultiplierControlPoint(0) { Velocity = 1 },
+                new MultiplierControlPoint(10000) { Velocity = 2f },
+                new MultiplierControlPoint(20000) { Velocity = 0.5f }
+            };
+
+            algorithm = new SequentialScrollAlgorithm(controlPoints);
+        }
+
+        [Test]
+        public void TestDisplayStartTime()
+        {
+            // Sequential scroll algorithm approximates the start time
+            // This should be fixed in the future
+        }
+
+        [Test]
+        public void TestLength()
+        {
+            Assert.AreEqual(1f / 5, algorithm.GetLength(0, 1000, 5000, 1)); // Like constant
+            Assert.AreEqual(1f / 5, algorithm.GetLength(10000, 10500, 5000, 1)); // (10500 - 10000) / 0.5 / 5000
+            Assert.AreEqual(1f / 5, algorithm.GetLength(20000, 22000, 5000, 1)); // (22000 - 20000) * 0.5 / 5000
+        }
+
+        [Test]
+        public void TestPosition()
+        {
+            // Basically same calculations as TestLength()
+            Assert.AreEqual(1f / 5, algorithm.PositionAt(1000, 0, 5000, 1));
+            Assert.AreEqual(1f / 5, algorithm.PositionAt(10500, 10000, 5000, 1));
+            Assert.AreEqual(1f / 5, algorithm.PositionAt(22000, 20000, 5000, 1));
+        }
+
+        [TestCase(1000)]
+        [TestCase(10000)]
+        [TestCase(15000)]
+        [TestCase(20000)]
+        [TestCase(25000)]
+        public void TestTime(double time)
+        {
+            Assert.AreEqual(time, algorithm.TimeAt(algorithm.PositionAt(time, 0, 5000, 1), 0, 5000, 1), 0.001);
+            Assert.AreEqual(time, algorithm.TimeAt(algorithm.PositionAt(time, 5000, 5000, 1), 5000, 5000, 1), 0.001);
+        }
+    }
+}
diff --git a/osu.Game.Tests/Visual/TestCaseScrollingHitObjects.cs b/osu.Game.Tests/Visual/TestCaseScrollingHitObjects.cs
index b254325472..eb322df185 100644
--- a/osu.Game.Tests/Visual/TestCaseScrollingHitObjects.cs
+++ b/osu.Game.Tests/Visual/TestCaseScrollingHitObjects.cs
@@ -114,11 +114,11 @@ namespace osu.Game.Tests.Visual
 
         private class TestPlayfield : ScrollingPlayfield
         {
-            public new readonly ScrollingDirection Direction;
+            public new ScrollingDirection Direction => base.Direction;
 
             public TestPlayfield(ScrollingDirection direction)
             {
-                Direction = direction;
+                base.Direction.Value = direction;
 
                 Padding = new MarginPadding(2);
 
diff --git a/osu.Game/Configuration/SpeedChangeVisualisationMethod.cs b/osu.Game/Configuration/ScrollVisualisationMethod.cs
similarity index 89%
rename from osu.Game/Configuration/SpeedChangeVisualisationMethod.cs
rename to osu.Game/Configuration/ScrollVisualisationMethod.cs
index 39c6e5649c..cc7dcdbc0e 100644
--- a/osu.Game/Configuration/SpeedChangeVisualisationMethod.cs
+++ b/osu.Game/Configuration/ScrollVisualisationMethod.cs
@@ -5,7 +5,7 @@ using System.ComponentModel;
 
 namespace osu.Game.Configuration
 {
-    public enum SpeedChangeVisualisationMethod
+    public enum ScrollVisualisationMethod
     {
         [Description("Sequential")]
         Sequential,
diff --git a/osu.Game/Overlays/MusicController.cs b/osu.Game/Overlays/MusicController.cs
index b32fd265cb..f282b757cd 100644
--- a/osu.Game/Overlays/MusicController.cs
+++ b/osu.Game/Overlays/MusicController.cs
@@ -245,10 +245,10 @@ namespace osu.Game.Overlays
         {
             base.Update();
 
-            if (current?.TrackLoaded ?? false)
-            {
-                var track = current.Track;
+            var track = current?.TrackLoaded ?? false ? current.Track : null;
 
+            if (track?.IsDummyDevice == false)
+            {
                 progressBar.EndTime = track.Length;
                 progressBar.CurrentTime = track.CurrentTime;
 
@@ -258,7 +258,11 @@ namespace osu.Game.Overlays
                     next();
             }
             else
+            {
+                progressBar.CurrentTime = 0;
+                progressBar.EndTime = 1;
                 playButton.Icon = FontAwesome.fa_play_circle_o;
+            }
         }
 
         private void play()
diff --git a/osu.Game/Rulesets/UI/Scrolling/Algorithms/ConstantScrollAlgorithm.cs b/osu.Game/Rulesets/UI/Scrolling/Algorithms/ConstantScrollAlgorithm.cs
new file mode 100644
index 0000000000..5628fb51f3
--- /dev/null
+++ b/osu.Game/Rulesets/UI/Scrolling/Algorithms/ConstantScrollAlgorithm.cs
@@ -0,0 +1,27 @@
+// 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.UI.Scrolling.Algorithms
+{
+    public class ConstantScrollAlgorithm : IScrollAlgorithm
+    {
+        public double GetDisplayStartTime(double time, double timeRange) => time - timeRange;
+
+        public float GetLength(double startTime, double endTime, double timeRange, float scrollLength)
+        {
+            // At the hitobject's end time, the hitobject will be positioned such that its end rests at the origin.
+            // This results in a negative-position value, and the absolute of it indicates the length of the hitobject.
+            return -PositionAt(startTime, endTime, timeRange, scrollLength);
+        }
+
+        public float PositionAt(double time, double currentTime, double timeRange, float scrollLength)
+            => (float)((time - currentTime) / timeRange * scrollLength);
+
+        public double TimeAt(float position, double currentTime, double timeRange, float scrollLength)
+            => position * timeRange / scrollLength + currentTime;
+
+        public void Reset()
+        {
+        }
+    }
+}
diff --git a/osu.Game/Rulesets/UI/Scrolling/Algorithms/IScrollAlgorithm.cs b/osu.Game/Rulesets/UI/Scrolling/Algorithms/IScrollAlgorithm.cs
new file mode 100644
index 0000000000..2ece9bef9b
--- /dev/null
+++ b/osu.Game/Rulesets/UI/Scrolling/Algorithms/IScrollAlgorithm.cs
@@ -0,0 +1,54 @@
+// 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.UI.Scrolling.Algorithms
+{
+    public interface IScrollAlgorithm
+    {
+        /// <summary>
+        /// Given a point in time, computes the time at which it enters the time range.
+        /// </summary>
+        /// <remarks>
+        /// E.g. For a constant time range of 5000ms, the time at which t=7000ms enters the time range is 2000ms.
+        /// </remarks>
+        /// <param name="time">The point in time.</param>
+        /// <param name="timeRange">The amount of visible time.</param>
+        /// <returns>The time at which <paramref name="time"/> enters <see cref="timeRange"/>.</returns>
+        double GetDisplayStartTime(double time, double timeRange);
+
+        /// <summary>
+        /// Computes the spatial length within a start and end time.
+        /// </summary>
+        /// <param name="startTime">The start time.</param>
+        /// <param name="endTime">The end time.</param>
+        /// <param name="timeRange">The amount of visible time.</param>
+        /// <param name="scrollLength">The absolute spatial length through <see cref="timeRange"/>.</param>
+        /// <returns>The absolute spatial length.</returns>
+        float GetLength(double startTime, double endTime, double timeRange, float scrollLength);
+
+        /// <summary>
+        /// Given the current time, computes the spatial position of a point in time.
+        /// </summary>
+        /// <param name="time">The time to compute the spatial position of.</param>
+        /// <param name="currentTime">The current time.</param>
+        /// <param name="timeRange">The amount of visible time.</param>
+        /// <param name="scrollLength">The absolute spatial length through <see cref="timeRange"/>.</param>
+        /// <returns>The absolute spatial position.</returns>
+        float PositionAt(double time, double currentTime, double timeRange, float scrollLength);
+
+        /// <summary>
+        /// Computes the time which brings a point to a provided spatial position given the current time.
+        /// </summary>
+        /// <param name="position">The absolute spatial position.</param>
+        /// <param name="currentTime">The current time.</param>
+        /// <param name="timeRange">The amount of visible time.</param>
+        /// <param name="scrollLength">The absolute spatial length through <see cref="timeRange"/>.</param>
+        /// <returns>The time at which <see cref="PositionAt(t)"/> == <paramref name="position"/>.</returns>
+        double TimeAt(float position, double currentTime, double timeRange, float scrollLength);
+
+        /// <summary>
+        /// Resets this <see cref="IScrollAlgorithm"/> to a default state.
+        /// </summary>
+        void Reset();
+    }
+}
diff --git a/osu.Game/Rulesets/UI/Scrolling/Algorithms/OverlappingScrollAlgorithm.cs b/osu.Game/Rulesets/UI/Scrolling/Algorithms/OverlappingScrollAlgorithm.cs
new file mode 100644
index 0000000000..4d9659c820
--- /dev/null
+++ b/osu.Game/Rulesets/UI/Scrolling/Algorithms/OverlappingScrollAlgorithm.cs
@@ -0,0 +1,93 @@
+// 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.Lists;
+using osu.Game.Rulesets.Timing;
+using OpenTK;
+
+namespace osu.Game.Rulesets.UI.Scrolling.Algorithms
+{
+    public class OverlappingScrollAlgorithm : IScrollAlgorithm
+    {
+        private readonly MultiplierControlPoint searchPoint;
+
+        private readonly SortedList<MultiplierControlPoint> controlPoints;
+
+        public OverlappingScrollAlgorithm(SortedList<MultiplierControlPoint> controlPoints)
+        {
+            this.controlPoints = controlPoints;
+
+            searchPoint = new MultiplierControlPoint();
+        }
+
+        public double GetDisplayStartTime(double time, double timeRange)
+        {
+            // The total amount of time that the hitobject will remain visible within the timeRange, which decreases as the speed multiplier increases
+            double visibleDuration = timeRange / controlPointAt(time).Multiplier;
+            return time - visibleDuration;
+        }
+
+        public float GetLength(double startTime, double endTime, double timeRange, float scrollLength)
+        {
+            // At the hitobject's end time, the hitobject will be positioned such that its end rests at the origin.
+            // This results in a negative-position value, and the absolute of it indicates the length of the hitobject.
+            return -PositionAt(startTime, endTime, timeRange, scrollLength);
+        }
+
+        public float PositionAt(double time, double currentTime, double timeRange, float scrollLength)
+            => (float)((time - currentTime) / timeRange * controlPointAt(time).Multiplier * scrollLength);
+
+        public double TimeAt(float position, double currentTime, double timeRange, float scrollLength)
+        {
+            // Find the control point relating to the position.
+            // Note: Due to velocity adjustments, overlapping control points will provide multiple valid time values for a single position
+            // As such, this operation provides unexpected results by using the latter of the control points.
+
+            int i = 0;
+            float pos = 0;
+
+            for (; i < controlPoints.Count; i++)
+            {
+                float lastPos = pos;
+                pos = PositionAt(controlPoints[i].StartTime, currentTime, timeRange, scrollLength);
+
+                if (pos > position)
+                {
+                    i--;
+                    pos = lastPos;
+                    break;
+                }
+            }
+
+            i = MathHelper.Clamp(i, 0, controlPoints.Count - 1);
+
+            return controlPoints[i].StartTime + (position - pos) * timeRange / controlPoints[i].Multiplier / scrollLength;
+        }
+
+        public void Reset()
+        {
+        }
+
+        /// <summary>
+        /// Finds the <see cref="MultiplierControlPoint"/> which affects the speed of hitobjects at a specific time.
+        /// </summary>
+        /// <param name="time">The time which the <see cref="MultiplierControlPoint"/> should affect.</param>
+        /// <returns>The <see cref="MultiplierControlPoint"/>.</returns>
+        private MultiplierControlPoint controlPointAt(double time)
+        {
+            if (controlPoints.Count == 0)
+                return new MultiplierControlPoint(double.NegativeInfinity);
+
+            if (time < controlPoints[0].StartTime)
+                return controlPoints[0];
+
+            searchPoint.StartTime = time;
+            int index = controlPoints.BinarySearch(searchPoint);
+
+            if (index < 0)
+                index = ~index - 1;
+
+            return controlPoints[index];
+        }
+    }
+}
diff --git a/osu.Game/Rulesets/UI/Scrolling/Algorithms/SequentialScrollAlgorithm.cs b/osu.Game/Rulesets/UI/Scrolling/Algorithms/SequentialScrollAlgorithm.cs
new file mode 100644
index 0000000000..8f8f546992
--- /dev/null
+++ b/osu.Game/Rulesets/UI/Scrolling/Algorithms/SequentialScrollAlgorithm.cs
@@ -0,0 +1,117 @@
+// 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 osu.Game.Rulesets.Timing;
+
+namespace osu.Game.Rulesets.UI.Scrolling.Algorithms
+{
+    public class SequentialScrollAlgorithm : IScrollAlgorithm
+    {
+        private readonly Dictionary<double, double> positionCache;
+
+        private readonly IReadOnlyList<MultiplierControlPoint> controlPoints;
+
+        public SequentialScrollAlgorithm(IReadOnlyList<MultiplierControlPoint> controlPoints)
+        {
+            this.controlPoints = controlPoints;
+
+            positionCache = new Dictionary<double, double>();
+        }
+
+        public double GetDisplayStartTime(double time, double timeRange) => time - timeRange - 1000;
+
+        public float GetLength(double startTime, double endTime, double timeRange, float scrollLength)
+        {
+            var objectLength = relativePositionAtCached(endTime, timeRange) - relativePositionAtCached(startTime, timeRange);
+            return (float)(objectLength * scrollLength);
+        }
+
+        public float PositionAt(double time, double currentTime, double timeRange, float scrollLength)
+        {
+            // Caching is not used here as currentTime is unlikely to have been previously cached
+            double timelinePosition = relativePositionAt(currentTime, timeRange);
+            return (float)((relativePositionAtCached(time, timeRange) - timelinePosition) * scrollLength);
+        }
+
+        public double TimeAt(float position, double currentTime, double timeRange, float scrollLength)
+        {
+            // Convert the position to a length relative to time = 0
+            double length = position / scrollLength + relativePositionAt(currentTime, timeRange);
+
+            // We need to consider all timing points until the specified time and not just the currently-active one,
+            // since each timing point individually affects the positions of _all_ hitobjects after its start time
+            for (int i = 0; i < controlPoints.Count; i++)
+            {
+                var current = controlPoints[i];
+                var next = i < controlPoints.Count - 1 ? controlPoints[i + 1] : null;
+
+                // Duration of the current control point
+                var currentDuration = (next?.StartTime ?? double.PositiveInfinity) - current.StartTime;
+
+                // Figure out the length of control point
+                var currentLength = currentDuration / timeRange * current.Multiplier;
+
+                if (currentLength > length)
+                {
+                    // The point is within this control point
+                    return current.StartTime + length * timeRange / current.Multiplier;
+                }
+
+                length -= currentLength;
+            }
+
+            return 0; // Should never occur
+        }
+
+        private double relativePositionAtCached(double time, double timeRange)
+        {
+            if (!positionCache.TryGetValue(time, out double existing))
+                positionCache[time] = existing = relativePositionAt(time, timeRange);
+            return existing;
+        }
+
+        public void Reset() => positionCache.Clear();
+
+        /// <summary>
+        /// Finds the position which corresponds to a point in time.
+        /// This is a non-linear operation that depends on all the control points up to and including the one active at the time value.
+        /// </summary>
+        /// <param name="time">The time to find the position at.</param>
+        /// <param name="timeRange">The amount of time visualised by the scrolling area.</param>
+        /// <returns>A positive value indicating the position at <paramref name="time"/>.</returns>
+        private double relativePositionAt(double time, double timeRange)
+        {
+            if (controlPoints.Count == 0)
+                return time / timeRange;
+
+            double length = 0;
+
+            // We need to consider all timing points until the specified time and not just the currently-active one,
+            // since each timing point individually affects the positions of _all_ hitobjects after its start time
+            for (int i = 0; i < controlPoints.Count; i++)
+            {
+                var current = controlPoints[i];
+                var next = i < controlPoints.Count - 1 ? controlPoints[i + 1] : null;
+
+                // We don't need to consider any control points beyond the current time, since it will not yet
+                // affect any hitobjects
+                if (i > 0 && current.StartTime > time)
+                    continue;
+
+                // Duration of the current control point
+                var currentDuration = (next?.StartTime ?? double.PositiveInfinity) - current.StartTime;
+
+                // We want to consider the minimal amount of time that this control point has affected,
+                // which may be either its duration, or the amount of time that has passed within it
+                var durationInCurrent = Math.Min(currentDuration, time - current.StartTime);
+
+                // Figure out how much of the time range the duration represents, and adjust it by the speed multiplier
+                length += durationInCurrent / timeRange * current.Multiplier;
+            }
+
+            return length;
+        }
+    }
+}
diff --git a/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs b/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs
index 7307fc0ead..489604afc9 100644
--- a/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs
+++ b/osu.Game/Rulesets/UI/Scrolling/ScrollingHitObjectContainer.cs
@@ -7,8 +7,9 @@ using osu.Framework.Graphics;
 using osu.Framework.Lists;
 using osu.Game.Configuration;
 using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Objects.Types;
 using osu.Game.Rulesets.Timing;
-using osu.Game.Rulesets.UI.Scrolling.Visualisers;
+using osu.Game.Rulesets.UI.Scrolling.Algorithms;
 
 namespace osu.Game.Rulesets.UI.Scrolling
 {
@@ -30,11 +31,11 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
         public readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
 
+        private readonly IScrollAlgorithm algorithm;
+
         private Cached initialStateCache = new Cached();
 
-        private readonly ISpeedChangeVisualiser speedChangeVisualiser;
-
-        public ScrollingHitObjectContainer(SpeedChangeVisualisationMethod visualisationMethod)
+        public ScrollingHitObjectContainer(ScrollVisualisationMethod visualisationMethod)
         {
             RelativeSizeAxes = Axes.Both;
 
@@ -43,14 +44,14 @@ namespace osu.Game.Rulesets.UI.Scrolling
 
             switch (visualisationMethod)
             {
-                case SpeedChangeVisualisationMethod.Sequential:
-                    speedChangeVisualiser = new SequentialSpeedChangeVisualiser(ControlPoints);
+                case ScrollVisualisationMethod.Sequential:
+                    algorithm = new SequentialScrollAlgorithm(ControlPoints);
                     break;
-                case SpeedChangeVisualisationMethod.Overlapping:
-                    speedChangeVisualiser = new OverlappingSpeedChangeVisualiser(ControlPoints);
+                case ScrollVisualisationMethod.Overlapping:
+                    algorithm = new OverlappingScrollAlgorithm(ControlPoints);
                     break;
-                case SpeedChangeVisualisationMethod.Constant:
-                    speedChangeVisualiser = new ConstantSpeedChangeVisualiser();
+                case ScrollVisualisationMethod.Constant:
+                    algorithm = new ConstantScrollAlgorithm();
                     break;
             }
         }
@@ -91,23 +92,87 @@ namespace osu.Game.Rulesets.UI.Scrolling
             return base.Invalidate(invalidation, source, shallPropagate);
         }
 
+        private float scrollLength;
+
         protected override void Update()
         {
             base.Update();
 
             if (!initialStateCache.IsValid)
             {
-                speedChangeVisualiser.ComputeInitialStates(Objects, Direction, TimeRange, DrawSize);
+                switch (Direction.Value)
+                {
+                    case ScrollingDirection.Up:
+                    case ScrollingDirection.Down:
+                        scrollLength = DrawSize.Y;
+                        break;
+                    default:
+                        scrollLength = DrawSize.X;
+                        break;
+                }
+
+                algorithm.Reset();
+
+                foreach (var obj in Objects)
+                    computeInitialStateRecursive(obj);
                 initialStateCache.Validate();
             }
         }
 
+        private void computeInitialStateRecursive(DrawableHitObject hitObject)
+        {
+            hitObject.LifetimeStart = algorithm.GetDisplayStartTime(hitObject.HitObject.StartTime, TimeRange);
+
+            if (hitObject.HitObject is IHasEndTime endTime)
+            {
+                switch (Direction.Value)
+                {
+                    case ScrollingDirection.Up:
+                    case ScrollingDirection.Down:
+                        hitObject.Height = algorithm.GetLength(hitObject.HitObject.StartTime, endTime.EndTime, TimeRange, scrollLength);
+                        break;
+                    case ScrollingDirection.Left:
+                    case ScrollingDirection.Right:
+                        hitObject.Width = algorithm.GetLength(hitObject.HitObject.StartTime, endTime.EndTime, TimeRange, scrollLength);
+                        break;
+                }
+            }
+
+            foreach (var obj in hitObject.NestedHitObjects)
+            {
+                computeInitialStateRecursive(obj);
+
+                // Nested hitobjects don't need to scroll, but they do need accurate positions
+                updatePosition(obj, hitObject.HitObject.StartTime);
+            }
+        }
+
         protected override void UpdateAfterChildrenLife()
         {
             base.UpdateAfterChildrenLife();
 
-            // We need to calculate this as soon as possible after lifetimes so that hitobjects get the final say in their positions
-            speedChangeVisualiser.UpdatePositions(AliveObjects, Direction, Time.Current, TimeRange, DrawSize);
+            // We need to calculate hitobject positions as soon as possible after lifetimes so that hitobjects get the final say in their positions
+            foreach (var obj in AliveObjects)
+                updatePosition(obj, Time.Current);
+        }
+
+        private void updatePosition(DrawableHitObject hitObject, double currentTime)
+        {
+            switch (Direction.Value)
+            {
+                case ScrollingDirection.Up:
+                    hitObject.Y = algorithm.PositionAt(hitObject.HitObject.StartTime, currentTime, TimeRange, scrollLength);
+                    break;
+                case ScrollingDirection.Down:
+                    hitObject.Y = -algorithm.PositionAt(hitObject.HitObject.StartTime, currentTime, TimeRange, scrollLength);
+                    break;
+                case ScrollingDirection.Left:
+                    hitObject.X = algorithm.PositionAt(hitObject.HitObject.StartTime, currentTime, TimeRange, scrollLength);
+                    break;
+                case ScrollingDirection.Right:
+                    hitObject.X = -algorithm.PositionAt(hitObject.HitObject.StartTime, currentTime, TimeRange, scrollLength);
+                    break;
+            }
         }
     }
 }
diff --git a/osu.Game/Rulesets/UI/Scrolling/ScrollingPlayfield.cs b/osu.Game/Rulesets/UI/Scrolling/ScrollingPlayfield.cs
index a1fc13ce4d..5e2704c9ee 100644
--- a/osu.Game/Rulesets/UI/Scrolling/ScrollingPlayfield.cs
+++ b/osu.Game/Rulesets/UI/Scrolling/ScrollingPlayfield.cs
@@ -63,7 +63,7 @@ namespace osu.Game.Rulesets.UI.Scrolling
         /// </summary>
         protected readonly Bindable<ScrollingDirection> Direction = new Bindable<ScrollingDirection>();
 
-        protected virtual SpeedChangeVisualisationMethod VisualisationMethod => SpeedChangeVisualisationMethod.Sequential;
+        protected virtual ScrollVisualisationMethod VisualisationMethod => ScrollVisualisationMethod.Sequential;
 
         [BackgroundDependencyLoader]
         private void load()
diff --git a/osu.Game/Rulesets/UI/Scrolling/Visualisers/ConstantSpeedChangeVisualiser.cs b/osu.Game/Rulesets/UI/Scrolling/Visualisers/ConstantSpeedChangeVisualiser.cs
deleted file mode 100644
index 9e910d6b11..0000000000
--- a/osu.Game/Rulesets/UI/Scrolling/Visualisers/ConstantSpeedChangeVisualiser.cs
+++ /dev/null
@@ -1,67 +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 System.Collections.Generic;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Objects.Types;
-using OpenTK;
-
-namespace osu.Game.Rulesets.UI.Scrolling.Visualisers
-{
-    public class ConstantSpeedChangeVisualiser : ISpeedChangeVisualiser
-    {
-        public void ComputeInitialStates(IEnumerable<DrawableHitObject> hitObjects, ScrollingDirection direction, double timeRange, Vector2 length)
-        {
-            foreach (var obj in hitObjects)
-            {
-                obj.LifetimeStart = obj.HitObject.StartTime - timeRange;
-
-                if (obj.HitObject is IHasEndTime endTime)
-                {
-                    var hitObjectLength = (endTime.EndTime - obj.HitObject.StartTime) / timeRange;
-
-                    switch (direction)
-                    {
-                        case ScrollingDirection.Up:
-                        case ScrollingDirection.Down:
-                            obj.Height = (float)(hitObjectLength * length.Y);
-                            break;
-                        case ScrollingDirection.Left:
-                        case ScrollingDirection.Right:
-                            obj.Width = (float)(hitObjectLength * length.X);
-                            break;
-                    }
-                }
-
-                ComputeInitialStates(obj.NestedHitObjects, direction, timeRange, length);
-
-                // Nested hitobjects don't need to scroll, but they do need accurate positions
-                UpdatePositions(obj.NestedHitObjects, direction, obj.HitObject.StartTime, timeRange, length);
-            }
-        }
-
-        public void UpdatePositions(IEnumerable<DrawableHitObject> hitObjects, ScrollingDirection direction, double currentTime, double timeRange, Vector2 length)
-        {
-            foreach (var obj in hitObjects)
-            {
-                var position = (obj.HitObject.StartTime - currentTime) / timeRange;
-
-                switch (direction)
-                {
-                    case ScrollingDirection.Up:
-                        obj.Y = (float)(position * length.Y);
-                        break;
-                    case ScrollingDirection.Down:
-                        obj.Y = (float)(-position * length.Y);
-                        break;
-                    case ScrollingDirection.Left:
-                        obj.X = (float)(position * length.X);
-                        break;
-                    case ScrollingDirection.Right:
-                        obj.X = (float)(-position * length.X);
-                        break;
-                }
-            }
-        }
-    }
-}
diff --git a/osu.Game/Rulesets/UI/Scrolling/Visualisers/ISpeedChangeVisualiser.cs b/osu.Game/Rulesets/UI/Scrolling/Visualisers/ISpeedChangeVisualiser.cs
deleted file mode 100644
index 097e28b2dc..0000000000
--- a/osu.Game/Rulesets/UI/Scrolling/Visualisers/ISpeedChangeVisualiser.cs
+++ /dev/null
@@ -1,32 +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 System.Collections.Generic;
-using osu.Game.Rulesets.Objects.Drawables;
-using OpenTK;
-
-namespace osu.Game.Rulesets.UI.Scrolling.Visualisers
-{
-    public interface ISpeedChangeVisualiser
-    {
-        /// <summary>
-        /// Computes the states of <see cref="DrawableHitObject"/>s that remain constant while scrolling, such as lifetime and spatial length.
-        /// This is invoked once whenever <paramref name="timeRange"/> or <paramref name="length"/> changes.
-        /// </summary>
-        /// <param name="hitObjects">The <see cref="DrawableHitObject"/>s whose states should be computed.</param>
-        /// <param name="direction">The scrolling direction.</param>
-        /// <param name="timeRange">The duration required to scroll through one length of the screen before any speed adjustments.</param>
-        /// <param name="length">The length of the screen that is scrolled through.</param>
-        void ComputeInitialStates(IEnumerable<DrawableHitObject> hitObjects, ScrollingDirection direction, double timeRange, Vector2 length);
-
-        /// <summary>
-        /// Updates the positions of <see cref="DrawableHitObject"/>s, depending on the current time. This is invoked once per frame.
-        /// </summary>
-        /// <param name="hitObjects">The <see cref="DrawableHitObject"/>s whose positions should be computed.</param>
-        /// <param name="direction">The scrolling direction.</param>
-        /// <param name="currentTime">The current time.</param>
-        /// <param name="timeRange">The duration required to scroll through one length of the screen before any speed adjustments.</param>
-        /// <param name="length">The length of the screen that is scrolled through.</param>
-        void UpdatePositions(IEnumerable<DrawableHitObject> hitObjects, ScrollingDirection direction, double currentTime, double timeRange, Vector2 length);
-    }
-}
diff --git a/osu.Game/Rulesets/UI/Scrolling/Visualisers/OverlappingSpeedChangeVisualiser.cs b/osu.Game/Rulesets/UI/Scrolling/Visualisers/OverlappingSpeedChangeVisualiser.cs
deleted file mode 100644
index d2b79e2fa7..0000000000
--- a/osu.Game/Rulesets/UI/Scrolling/Visualisers/OverlappingSpeedChangeVisualiser.cs
+++ /dev/null
@@ -1,120 +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 System.Collections.Generic;
-using osu.Framework.Lists;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Rulesets.Timing;
-using OpenTK;
-
-namespace osu.Game.Rulesets.UI.Scrolling.Visualisers
-{
-    public class OverlappingSpeedChangeVisualiser : ISpeedChangeVisualiser
-    {
-        private readonly SortedList<MultiplierControlPoint> controlPoints;
-
-        public OverlappingSpeedChangeVisualiser(SortedList<MultiplierControlPoint> controlPoints)
-        {
-            this.controlPoints = controlPoints;
-        }
-
-        public void ComputeInitialStates(IEnumerable<DrawableHitObject> hitObjects, ScrollingDirection direction, double timeRange, Vector2 length)
-        {
-            foreach (var obj in hitObjects)
-            {
-                // The total amount of time that the hitobject will remain visible within the timeRange, which decreases as the speed multiplier increases
-                double visibleDuration = timeRange / controlPointAt(obj.HitObject.StartTime).Multiplier;
-
-                obj.LifetimeStart = obj.HitObject.StartTime - visibleDuration;
-
-                if (obj.HitObject is IHasEndTime endTime)
-                {
-                    // At the hitobject's end time, the hitobject will be positioned such that its end rests at the origin.
-                    // This results in a negative-position value, and the absolute of it indicates the length of the hitobject.
-                    var hitObjectLength = -hitObjectPositionAt(obj, endTime.EndTime, timeRange);
-
-                    switch (direction)
-                    {
-                        case ScrollingDirection.Up:
-                        case ScrollingDirection.Down:
-                            obj.Height = (float)(hitObjectLength * length.Y);
-                            break;
-                        case ScrollingDirection.Left:
-                        case ScrollingDirection.Right:
-                            obj.Width = (float)(hitObjectLength * length.X);
-                            break;
-                    }
-                }
-
-                ComputeInitialStates(obj.NestedHitObjects, direction, timeRange, length);
-
-                // Nested hitobjects don't need to scroll, but they do need accurate positions
-                UpdatePositions(obj.NestedHitObjects, direction, obj.HitObject.StartTime, timeRange, length);
-            }
-        }
-
-        public void UpdatePositions(IEnumerable<DrawableHitObject> hitObjects, ScrollingDirection direction, double currentTime, double timeRange, Vector2 length)
-        {
-            foreach (var obj in hitObjects)
-            {
-                var position = hitObjectPositionAt(obj, currentTime, timeRange);
-
-                switch (direction)
-                {
-                    case ScrollingDirection.Up:
-                        obj.Y = (float)(position * length.Y);
-                        break;
-                    case ScrollingDirection.Down:
-                        obj.Y = (float)(-position * length.Y);
-                        break;
-                    case ScrollingDirection.Left:
-                        obj.X = (float)(position * length.X);
-                        break;
-                    case ScrollingDirection.Right:
-                        obj.X = (float)(-position * length.X);
-                        break;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Computes the position of a <see cref="DrawableHitObject"/> at a point in time.
-        /// <para>
-        /// At t &lt; startTime, position &gt; 0. <br />
-        /// At t = startTime, position = 0. <br />
-        /// At t &gt; startTime, position &lt; 0.
-        /// </para>
-        /// </summary>
-        /// <param name="obj">The <see cref="DrawableHitObject"/>.</param>
-        /// <param name="time">The time to find the position of <paramref name="obj"/> at.</param>
-        /// <param name="timeRange">The amount of time visualised by the scrolling area.</param>
-        /// <returns>The position of <paramref name="obj"/> in the scrolling area at time = <paramref name="time"/>.</returns>
-        private double hitObjectPositionAt(DrawableHitObject obj, double time, double timeRange)
-            => (obj.HitObject.StartTime - time) / timeRange * controlPointAt(obj.HitObject.StartTime).Multiplier;
-
-        private readonly MultiplierControlPoint searchPoint = new MultiplierControlPoint();
-
-        /// <summary>
-        /// Finds the <see cref="MultiplierControlPoint"/> which affects the speed of hitobjects at a specific time.
-        /// </summary>
-        /// <param name="time">The time which the <see cref="MultiplierControlPoint"/> should affect.</param>
-        /// <returns>The <see cref="MultiplierControlPoint"/>.</returns>
-        private MultiplierControlPoint controlPointAt(double time)
-        {
-            if (controlPoints.Count == 0)
-                return new MultiplierControlPoint(double.NegativeInfinity);
-
-            if (time < controlPoints[0].StartTime)
-                return controlPoints[0];
-
-            searchPoint.StartTime = time;
-            int index = controlPoints.BinarySearch(searchPoint);
-
-            if (index < 0)
-                index = ~index - 1;
-
-            return controlPoints[index];
-        }
-    }
-}
diff --git a/osu.Game/Rulesets/UI/Scrolling/Visualisers/SequentialSpeedChangeVisualiser.cs b/osu.Game/Rulesets/UI/Scrolling/Visualisers/SequentialSpeedChangeVisualiser.cs
deleted file mode 100644
index 25dea8dfbf..0000000000
--- a/osu.Game/Rulesets/UI/Scrolling/Visualisers/SequentialSpeedChangeVisualiser.cs
+++ /dev/null
@@ -1,124 +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 System;
-using System.Collections.Generic;
-using osu.Game.Rulesets.Objects.Drawables;
-using osu.Game.Rulesets.Objects.Types;
-using osu.Game.Rulesets.Timing;
-using OpenTK;
-
-namespace osu.Game.Rulesets.UI.Scrolling.Visualisers
-{
-    public class SequentialSpeedChangeVisualiser : ISpeedChangeVisualiser
-    {
-        private readonly Dictionary<DrawableHitObject, double> hitObjectPositions = new Dictionary<DrawableHitObject, double>();
-
-        private readonly IReadOnlyList<MultiplierControlPoint> controlPoints;
-
-        public SequentialSpeedChangeVisualiser(IReadOnlyList<MultiplierControlPoint> controlPoints)
-        {
-            this.controlPoints = controlPoints;
-        }
-
-        public void ComputeInitialStates(IEnumerable<DrawableHitObject> hitObjects, ScrollingDirection direction, double timeRange, Vector2 length)
-        {
-            foreach (var obj in hitObjects)
-            {
-                // To reduce iterations when updating hitobject positions later on, their initial positions are cached
-                var startPosition = hitObjectPositions[obj] = positionAt(obj.HitObject.StartTime, timeRange);
-
-                // Todo: This is approximate and will be incorrect in the case of extreme speed changes
-                obj.LifetimeStart = obj.HitObject.StartTime - timeRange - 1000;
-
-                if (obj.HitObject is IHasEndTime endTime)
-                {
-                    var hitObjectLength = positionAt(endTime.EndTime, timeRange) - startPosition;
-
-                    switch (direction)
-                    {
-                        case ScrollingDirection.Up:
-                        case ScrollingDirection.Down:
-                            obj.Height = (float)(hitObjectLength * length.Y);
-                            break;
-                        case ScrollingDirection.Left:
-                        case ScrollingDirection.Right:
-                            obj.Width = (float)(hitObjectLength * length.X);
-                            break;
-                    }
-                }
-
-                ComputeInitialStates(obj.NestedHitObjects, direction, timeRange, length);
-
-                // Nested hitobjects don't need to scroll, but they do need accurate positions
-                UpdatePositions(obj.NestedHitObjects, direction, obj.HitObject.StartTime, timeRange, length);
-            }
-        }
-
-        public void UpdatePositions(IEnumerable<DrawableHitObject> hitObjects, ScrollingDirection direction, double currentTime, double timeRange, Vector2 length)
-        {
-            var timelinePosition = positionAt(currentTime, timeRange);
-
-            foreach (var obj in hitObjects)
-            {
-                var finalPosition = hitObjectPositions[obj] - timelinePosition;
-
-                switch (direction)
-                {
-                    case ScrollingDirection.Up:
-                        obj.Y = (float)(finalPosition * length.Y);
-                        break;
-                    case ScrollingDirection.Down:
-                        obj.Y = (float)(-finalPosition * length.Y);
-                        break;
-                    case ScrollingDirection.Left:
-                        obj.X = (float)(finalPosition * length.X);
-                        break;
-                    case ScrollingDirection.Right:
-                        obj.X = (float)(-finalPosition * length.X);
-                        break;
-                }
-            }
-        }
-
-        /// <summary>
-        /// Finds the position which corresponds to a point in time.
-        /// This is a non-linear operation that depends on all the control points up to and including the one active at the time value.
-        /// </summary>
-        /// <param name="time">The time to find the position at.</param>
-        /// <param name="timeRange">The amount of time visualised by the scrolling area.</param>
-        /// <returns>A positive value indicating the position at <paramref name="time"/>.</returns>
-        private double positionAt(double time, double timeRange)
-        {
-            if (controlPoints.Count == 0)
-                return time / timeRange;
-
-            double length = 0;
-
-            // We need to consider all timing points until the specified time and not just the currently-active one,
-            // since each timing point individually affects the positions of _all_ hitobjects after its start time
-            for (int i = 0; i < controlPoints.Count; i++)
-            {
-                var current = controlPoints[i];
-                var next = i < controlPoints.Count - 1 ? controlPoints[i + 1] : null;
-
-                // We don't need to consider any control points beyond the current time, since it will not yet
-                // affect any hitobjects
-                if (i > 0 && current.StartTime > time)
-                    continue;
-
-                // Duration of the current control point
-                var currentDuration = (next?.StartTime ?? double.PositiveInfinity) - current.StartTime;
-
-                // We want to consider the minimal amount of time that this control point has affected,
-                // which may be either its duration, or the amount of time that has passed within it
-                var durationInCurrent = Math.Min(currentDuration, time - current.StartTime);
-
-                // Figure out how much of the time range the duration represents, and adjust it by the speed multiplier
-                length += durationInCurrent / timeRange * current.Multiplier;
-            }
-
-            return length;
-        }
-    }
-}