Rename *ScrollingDrawableTimingSection -> *ScrollingContainer, move LinearScrollingContainer to osu.Game, make SpeedAdjustmentContainer non-abstract.

osu.Game/Rulesets/Timing/ScrollingContainer.cs

@@ -0,0 +1,146 @@
+// Copyright (c) 2007-2017 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.Caching;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Objects.Drawables;
+using OpenTK;
+using osu.Game.Rulesets.Objects.Types;
+
+namespace osu.Game.Rulesets.Timing
+{
+    /// <summary>
+    /// A collection of hit objects which scrolls within a <see cref="SpeedAdjustmentContainer"/>.
+    ///
+    /// <para>
+    /// This container handles the conversion between time and position through <see cref="Container{T}.RelativeChildSize"/> and
+    /// <see cref="Container{T}.RelativeChildOffset"/> such that hit objects added to this container should have time values set as their
+    /// positions/sizes to make proper use of this container.
+    /// </para>
+    ///
+    /// <para>
+    /// This container will auto-size to the total duration of the contained hit objects along the desired auto-sizing axes such that the resulting size
+    /// of this container will be a value representing the total duration of all contained hit objects.
+    /// </para>
+    ///
+    /// <para>
+    /// This container is and must always be relatively-sized and positioned to its such that the parent can utilise <see cref="Container{T}.RelativeChildSize"/>
+    /// and <see cref="Container{T}.RelativeChildOffset"/> to apply further time offsets to this collection of hit objects.
+    /// </para>
+    /// </summary>
+    public abstract class ScrollingContainer : Container<DrawableHitObject>
+    {
+        private readonly BindableDouble visibleTimeRange = new BindableDouble();
+        /// <summary>
+        /// Gets or sets the range of time that is visible by the length of this container.
+        /// </summary>
+        public BindableDouble VisibleTimeRange
+        {
+            get { return visibleTimeRange; }
+            set { visibleTimeRange.BindTo(value); }
+        }
+
+        /// <summary>
+        /// Axes through which this timing section scrolls. This is set by the <see cref="SpeedAdjustmentContainer"/>.
+        /// </summary>
+        internal Axes ScrollingAxes;
+
+        /// <summary>
+        /// The control point that provides the speed adjustments for this container. This is set by the <see cref="SpeedAdjustmentContainer"/>.
+        /// </summary>
+        internal MultiplierControlPoint ControlPoint;
+
+        protected override int Compare(Drawable x, Drawable y)
+        {
+            var xHitObject = x as DrawableHitObject;
+            var yHitObject = y as DrawableHitObject;
+
+            // If either of the two drawables are not hit objects, fall back to the base comparer
+            if (xHitObject?.HitObject == null || yHitObject?.HitObject == null)
+                return base.Compare(x, y);
+
+            // Compare by start time
+            int i = yHitObject.HitObject.StartTime.CompareTo(xHitObject.HitObject.StartTime);
+            if (i != 0)
+                return i;
+
+            return base.Compare(x, y);
+        }
+
+        /// <summary>
+        /// Creates a new <see cref="ScrollingContainer"/>.
+        /// </summary>
+        protected ScrollingContainer()
+        {
+            RelativeSizeAxes = Axes.Both;
+            RelativePositionAxes = Axes.Both;
+        }
+
+        public override void InvalidateFromChild(Invalidation invalidation)
+        {
+            // We only want to re-compute our size when a child's size or position has changed
+            if ((invalidation & Invalidation.RequiredParentSizeToFit) == 0)
+            {
+                base.InvalidateFromChild(invalidation);
+                return;
+            }
+
+            durationBacking.Invalidate();
+
+            base.InvalidateFromChild(invalidation);
+        }
+
+        private Cached<double> durationBacking;
+
+        private double computeDuration()
+        {
+            if (!Children.Any())
+                return 0;
+
+            double baseDuration = Children.Max(c => (c.HitObject as IHasEndTime)?.EndTime ?? c.HitObject.StartTime) - ControlPoint.StartTime;
+
+            // If we have a singular hit object at the timing section's start time, let's set a sane default duration
+            if (baseDuration == 0)
+                baseDuration = 1;
+
+            // Scrolling ruleset hit objects typically have anchors+origins set to the hit object's start time, but if the hit object doesn't implement IHasEndTime and lies on the control point
+            // then the baseDuration above will be 0. This will cause problems with masking when it is further set as the value for Size in Update(). We _want_ the timing section bounds to
+            // completely enclose the hit object to avoid the masking optimisations.
+            //
+            // To do this we need to find a duration that corresponds to the absolute size of the element that extrudes beyond the timing section's bounds and add that to baseDuration.
+            // We can utilize the fact that the Size and RelativeChildSpace are 1:1, meaning that an change in duration for the timing section has no change to the hit object's positioning
+            // and simply find the largest absolutely-sized element in this timing section. This introduces a little bit of error, but will never under-estimate the duration.
+
+            // Find the largest element that is absolutely-sized along ScrollingAxes
+            float maxAbsoluteSize = Children.Where(c => (c.RelativeSizeAxes & ScrollingAxes) == 0)
+                                            .Select(c => (ScrollingAxes & Axes.X) > 0 ? c.Width : c.Height)
+                                            .DefaultIfEmpty().Max();
+
+            float ourAbsoluteSize = (ScrollingAxes & Axes.X) > 0 ? DrawWidth : DrawHeight;
+
+            // Add the extra duration to account for the absolute size
+            baseDuration *= 1 + maxAbsoluteSize / ourAbsoluteSize;
+
+            return baseDuration;
+        }
+
+        /// <summary>
+        /// The maximum duration of any one hit object inside this <see cref="ScrollingContainer"/>. This is calculated as the maximum
+        /// end time between all hit objects relative to this <see cref="ScrollingContainer"/>'s <see cref="MultiplierControlPoint.StartTime"/>.
+        /// </summary>
+        public double Duration => durationBacking.IsValid ? durationBacking : (durationBacking.Value = computeDuration());
+
+        protected override void Update()
+        {
+            base.Update();
+
+            // We want our size and position-space along ScrollingAxes to span our duration to completely enclose all the hit objects
+            Size = new Vector2((ScrollingAxes & Axes.X) > 0 ? (float)Duration : Size.X, (ScrollingAxes & Axes.Y) > 0 ? (float)Duration : Size.Y);
+            // And we need to make sure the hit object's position-space doesn't change due to our resizing
+            RelativeChildSize = Size;
+        }
+    }
+}