Mode -> Ruleset.

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

@@ -0,0 +1,21 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Graphics.Containers;
+using osu.Game.Rulesets.Objects;
+using System.Collections.Generic;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
+{
+    /// <summary>
+    /// Connects hit objects visually, for example with follow points.
+    /// </summary>
+    public abstract class ConnectionRenderer<T> : Container
+        where T : HitObject
+    {
+        /// <summary>
+        /// Hit objects to create connections for
+        /// </summary>
+        public abstract IEnumerable<T> HitObjects { get; set; }
+    }
+}

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

@@ -0,0 +1,66 @@
+// Copyright (c) 2007-2017 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 osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
+{
+    public class FollowPoint : Container
+    {
+        public double StartTime;
+        public double EndTime;
+        public Vector2 EndPosition;
+
+        private const float width = 8;
+
+        public FollowPoint()
+        {
+            Origin = Anchor.Centre;
+            Alpha = 0;
+
+            Masking = true;
+            AutoSizeAxes = Axes.Both;
+            CornerRadius = width / 2;
+            EdgeEffect = new EdgeEffect
+            {
+                Type = EdgeEffectType.Glow,
+                Colour = Color4.White.Opacity(0.2f),
+                Radius = 4,
+            };
+
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    Size = new Vector2(width),
+                    BlendingMode = BlendingMode.Additive,
+                    Origin = Anchor.Centre,
+                    Anchor = Anchor.Centre,
+                    Alpha = 0.5f,
+                },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            Delay(StartTime);
+            FadeIn(DrawableOsuHitObject.TIME_FADEIN);
+            ScaleTo(1.5f);
+            ScaleTo(1, DrawableOsuHitObject.TIME_FADEIN, EasingTypes.Out);
+            MoveTo(EndPosition, DrawableOsuHitObject.TIME_FADEIN, EasingTypes.Out);
+
+            Delay(EndTime - StartTime);
+            FadeOut(DrawableOsuHitObject.TIME_FADEIN);
+
+            Delay(DrawableOsuHitObject.TIME_FADEIN);
+            Expire(true);
+        }
+    }
+}

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

@@ -0,0 +1,97 @@
+// 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;
+using System.Collections.Generic;
+using OpenTK;
+using osu.Game.Rulesets.Objects.Types;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Connections
+{
+    public class FollowPointRenderer : ConnectionRenderer<OsuHitObject>
+    {
+        private int pointDistance = 32;
+        /// <summary>
+        /// Determines how much space there is between points.
+        /// </summary>
+        public int PointDistance
+        {
+            get { return pointDistance; }
+            set
+            {
+                if (pointDistance == value) return;
+                pointDistance = value;
+                update();
+            }
+        }
+
+        private int preEmpt = 800;
+        /// <summary>
+        /// Follow points to the next hitobject start appearing for this many milliseconds before an hitobject's end time.
+        /// </summary>
+        public int PreEmpt
+        {
+            get { return preEmpt; }
+            set
+            {
+                if (preEmpt == value) return;
+                preEmpt = value;
+                update();
+            }
+        }
+
+        private IEnumerable<OsuHitObject> hitObjects;
+        public override IEnumerable<OsuHitObject> HitObjects
+        {
+            get { return hitObjects; }
+            set
+            {
+                hitObjects = value;
+                update();
+            }
+        }
+
+        private void update()
+        {
+            Clear();
+            if (hitObjects == null)
+                return;
+
+            OsuHitObject prevHitObject = null;
+            foreach (var currHitObject in hitObjects)
+            {
+                if (prevHitObject != null && !currHitObject.NewCombo && !(prevHitObject is Spinner) && !(currHitObject is Spinner))
+                {
+                    Vector2 startPosition = prevHitObject.EndPosition;
+                    Vector2 endPosition = currHitObject.Position;
+                    double startTime = (prevHitObject as IHasEndTime)?.EndTime ?? prevHitObject.StartTime;
+                    double endTime = currHitObject.StartTime;
+
+                    Vector2 distanceVector = endPosition - startPosition;
+                    int distance = (int)distanceVector.Length;
+                    float rotation = (float)Math.Atan2(distanceVector.Y, distanceVector.X);
+                    double duration = endTime - startTime;
+
+                    for (int d = (int)(PointDistance * 1.5); d < distance - PointDistance; d += PointDistance)
+                    {
+                        float fraction = (float)d / distance;
+                        Vector2 pointStartPosition = startPosition + (fraction - 0.1f) * distanceVector;
+                        Vector2 pointEndPosition = startPosition + fraction * distanceVector;
+                        double fadeOutTime = startTime + fraction * duration;
+                        double fadeInTime = fadeOutTime - PreEmpt;
+
+                        Add(new FollowPoint
+                        {
+                            StartTime = fadeInTime,
+                            EndTime = fadeOutTime,
+                            Position = pointStartPosition,
+                            EndPosition = pointEndPosition,
+                            Rotation = rotation,
+                        });
+                    }
+                }
+                prevHitObject = currHitObject;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableHitCircle.cs

@@ -0,0 +1,155 @@
+// 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;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using OpenTK;
+using osu.Game.Rulesets.Objects.Types;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables
+{
+    public class DrawableHitCircle : DrawableOsuHitObject, IDrawableHitObjectWithProxiedApproach
+    {
+        public ApproachCircle ApproachCircle;
+        private readonly CirclePiece circle;
+        private readonly RingPiece ring;
+        private readonly FlashPiece flash;
+        private readonly ExplodePiece explode;
+        private readonly NumberPiece number;
+        private readonly GlowPiece glow;
+
+        public DrawableHitCircle(OsuHitObject h) : base(h)
+        {
+            Origin = Anchor.Centre;
+
+            Position = HitObject.StackedPosition;
+            Scale = new Vector2(HitObject.Scale);
+
+            Children = new Drawable[]
+            {
+                glow = new GlowPiece
+                {
+                    Colour = AccentColour
+                },
+                circle = new CirclePiece
+                {
+                    Colour = AccentColour,
+                    Hit = () =>
+                    {
+                        if (Judgement.Result != HitResult.None) return false;
+
+                        Judgement.PositionOffset = Vector2.Zero; //todo: set to correct value
+                        UpdateJudgement(true);
+                        return true;
+                    },
+                },
+                number = new NumberPiece
+                {
+                    Text = h is Spinner ? "S" : (HitObject.ComboIndex + 1).ToString(),
+                },
+                ring = new RingPiece(),
+                flash = new FlashPiece(),
+                explode = new ExplodePiece
+                {
+                    Colour = AccentColour,
+                },
+                ApproachCircle = new ApproachCircle
+                {
+                    Colour = AccentColour,
+                }
+            };
+
+            //may not be so correct
+            Size = circle.DrawSize;
+        }
+
+        protected override void CheckJudgement(bool userTriggered)
+        {
+            if (!userTriggered)
+            {
+                if (Judgement.TimeOffset > HitObject.HitWindowFor(OsuScoreResult.Hit50))
+                    Judgement.Result = HitResult.Miss;
+                return;
+            }
+
+            double hitOffset = Math.Abs(Judgement.TimeOffset);
+
+            if (hitOffset < HitObject.HitWindowFor(OsuScoreResult.Hit50))
+            {
+                Judgement.Result = HitResult.Hit;
+                Judgement.Score = HitObject.ScoreResultForOffset(hitOffset);
+            }
+            else
+                Judgement.Result = HitResult.Miss;
+        }
+
+        protected override void UpdateInitialState()
+        {
+            base.UpdateInitialState();
+
+            //sane defaults
+            ring.Alpha = circle.Alpha = number.Alpha = glow.Alpha = 1;
+            ApproachCircle.Alpha = 0;
+            ApproachCircle.Scale = new Vector2(4);
+            explode.Alpha = 0;
+        }
+
+        protected override void UpdatePreemptState()
+        {
+            base.UpdatePreemptState();
+
+            ApproachCircle.FadeIn(Math.Min(TIME_FADEIN * 2, TIME_PREEMPT));
+            ApproachCircle.ScaleTo(1.1f, TIME_PREEMPT);
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+            base.UpdateState(state);
+
+            ApproachCircle.FadeOut();
+
+            double endTime = (HitObject as IHasEndTime)?.EndTime ?? HitObject.StartTime;
+            double duration = endTime - HitObject.StartTime;
+
+            glow.Delay(duration);
+            glow.FadeOut(400);
+
+            switch (state)
+            {
+                case ArmedState.Idle:
+                    Delay(duration + TIME_PREEMPT);
+                    FadeOut(TIME_FADEOUT);
+                    Expire(true);
+                    break;
+                case ArmedState.Miss:
+                    FadeOut(TIME_FADEOUT / 5);
+                    Expire();
+                    break;
+                case ArmedState.Hit:
+                    const double flash_in = 40;
+
+                    flash.FadeTo(0.8f, flash_in);
+                    flash.Delay(flash_in);
+                    flash.FadeOut(100);
+
+                    explode.FadeIn(flash_in);
+
+                    Delay(flash_in, true);
+
+                    //after the flash, we can hide some elements that were behind it
+                    ring.FadeOut();
+                    circle.FadeOut();
+                    number.FadeOut();
+
+                    FadeOut(800);
+                    ScaleTo(Scale * 1.5f, 400, EasingTypes.OutQuad);
+                    Expire();
+                    break;
+            }
+        }
+
+        public Drawable ProxiedLayer => ApproachCircle;
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuHitObject.cs

@@ -0,0 +1,71 @@
+// 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.ComponentModel;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Judgements;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables
+{
+    public class DrawableOsuHitObject : DrawableHitObject<OsuHitObject, OsuJudgement>
+    {
+        public const float TIME_PREEMPT = 600;
+        public const float TIME_FADEIN = 400;
+        public const float TIME_FADEOUT = 500;
+
+        protected DrawableOsuHitObject(OsuHitObject hitObject)
+            : base(hitObject)
+        {
+            AccentColour = HitObject.ComboColour;
+        }
+
+        protected override OsuJudgement CreateJudgement() => new OsuJudgement { MaxScore = OsuScoreResult.Hit300 };
+
+        protected override void UpdateState(ArmedState state)
+        {
+            Flush();
+
+            UpdateInitialState();
+
+            Delay(HitObject.StartTime - Time.Current - TIME_PREEMPT + Judgement.TimeOffset, true);
+
+            UpdatePreemptState();
+
+            Delay(TIME_PREEMPT, true);
+        }
+
+        protected virtual void UpdatePreemptState()
+        {
+            FadeIn(TIME_FADEIN);
+        }
+
+        protected virtual void UpdateInitialState()
+        {
+            Alpha = 0;
+        }
+    }
+
+    public enum ComboResult
+    {
+        [Description(@"")]
+        None,
+        [Description(@"Good")]
+        Good,
+        [Description(@"Amazing")]
+        Perfect
+    }
+
+    public enum OsuScoreResult
+    {
+        [Description(@"Miss")]
+        Miss,
+        [Description(@"50")]
+        Hit50,
+        [Description(@"100")]
+        Hit100,
+        [Description(@"300")]
+        Hit300,
+        [Description(@"10")]
+        SliderTick
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableOsuJudgement.cs

@@ -0,0 +1,26 @@
+// Copyright (c) 2007-2017 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.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Judgements;
+using OpenTK;
+using osu.Game.Rulesets.Judgements;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables
+{
+    public class DrawableOsuJudgement : DrawableJudgement<OsuJudgement>
+    {
+        public DrawableOsuJudgement(OsuJudgement judgement) : base(judgement)
+        {
+        }
+
+        protected override void LoadComplete()
+        {
+            if (Judgement.Result != HitResult.Miss)
+                JudgementText.TransformSpacingTo(new Vector2(14, 0), 1800, EasingTypes.OutQuint);
+
+            base.LoadComplete();
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSlider.cs

@@ -0,0 +1,184 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using OpenTK;
+using osu.Framework.Graphics;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using System.Collections.Generic;
+using System.Linq;
+using osu.Framework.Graphics.Containers;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables
+{
+    public class DrawableSlider : DrawableOsuHitObject, IDrawableHitObjectWithProxiedApproach
+    {
+        private readonly Slider slider;
+
+        private readonly DrawableHitCircle initialCircle;
+
+        private readonly List<ISliderProgress> components = new List<ISliderProgress>();
+
+        private readonly Container<DrawableSliderTick> ticks;
+
+        private readonly SliderBody body;
+        private readonly SliderBall ball;
+
+        private readonly SliderBouncer bouncer2;
+
+        public DrawableSlider(Slider s) : base(s)
+        {
+            // Since the DrawableSlider itself is just a container without a size we need to
+            // pass all input through.
+            AlwaysReceiveInput = true;
+
+            SliderBouncer bouncer1;
+            slider = s;
+
+            Children = new Drawable[]
+            {
+                body = new SliderBody(s)
+                {
+                    AccentColour = AccentColour,
+                    Position = s.StackedPosition,
+                    PathWidth = s.Scale * 64,
+                },
+                ticks = new Container<DrawableSliderTick>(),
+                bouncer1 = new SliderBouncer(s, false)
+                {
+                    Position = s.Curve.PositionAt(1),
+                    Scale = new Vector2(s.Scale),
+                },
+                bouncer2 = new SliderBouncer(s, true)
+                {
+                    Position = s.StackedPosition,
+                    Scale = new Vector2(s.Scale),
+                },
+                ball = new SliderBall(s)
+                {
+                    Scale = new Vector2(s.Scale),
+                    AccentColour = AccentColour
+                },
+                initialCircle = new DrawableHitCircle(new HitCircle
+                {
+                    //todo: avoid creating this temporary HitCircle.
+                    StartTime = s.StartTime,
+                    Position = s.StackedPosition,
+                    ComboIndex = s.ComboIndex,
+                    Scale = s.Scale,
+                    ComboColour = s.ComboColour,
+                    Samples = s.Samples,
+                }),
+            };
+
+            components.Add(body);
+            components.Add(ball);
+            components.Add(bouncer1);
+            components.Add(bouncer2);
+
+            AddNested(initialCircle);
+
+            var repeatDuration = s.Curve.Distance / s.Velocity;
+            foreach (var tick in s.Ticks)
+            {
+                var repeatStartTime = s.StartTime + tick.RepeatIndex * repeatDuration;
+                var fadeInTime = repeatStartTime + (tick.StartTime - repeatStartTime) / 2 - (tick.RepeatIndex == 0 ? TIME_FADEIN : TIME_FADEIN / 2);
+                var fadeOutTime = repeatStartTime + repeatDuration;
+
+                var drawableTick = new DrawableSliderTick(tick)
+                {
+                    FadeInTime = fadeInTime,
+                    FadeOutTime = fadeOutTime,
+                    Position = tick.Position,
+                };
+
+                ticks.Add(drawableTick);
+                AddNested(drawableTick);
+            }
+        }
+
+        private int currentRepeat;
+
+        protected override void Update()
+        {
+            base.Update();
+
+            double progress = MathHelper.Clamp((Time.Current - slider.StartTime) / slider.Duration, 0, 1);
+
+            int repeat = slider.RepeatAt(progress);
+            progress = slider.ProgressAt(progress);
+
+            if (repeat > currentRepeat)
+            {
+                if (repeat < slider.RepeatCount && ball.Tracking)
+                    PlaySamples();
+                currentRepeat = repeat;
+            }
+
+            bouncer2.Position = slider.Curve.PositionAt(body.SnakedEnd ?? 0);
+
+            //todo: we probably want to reconsider this before adding scoring, but it looks and feels nice.
+            if (initialCircle.Judgement?.Result != HitResult.Hit)
+                initialCircle.Position = slider.Curve.PositionAt(progress);
+
+            foreach (var c in components) c.UpdateProgress(progress, repeat);
+            foreach (var t in ticks.Children) t.Tracking = ball.Tracking;
+        }
+
+        protected override void CheckJudgement(bool userTriggered)
+        {
+            if (!userTriggered && Time.Current >= slider.EndTime)
+            {
+                var ticksCount = ticks.Children.Count() + 1;
+                var ticksHit = ticks.Children.Count(t => t.Judgement.Result == HitResult.Hit);
+                if (initialCircle.Judgement.Result == HitResult.Hit)
+                    ticksHit++;
+
+                var hitFraction = (double)ticksHit / ticksCount;
+                if (hitFraction == 1 && initialCircle.Judgement.Score == OsuScoreResult.Hit300)
+                    Judgement.Score = OsuScoreResult.Hit300;
+                else if (hitFraction >= 0.5 && initialCircle.Judgement.Score >= OsuScoreResult.Hit100)
+                    Judgement.Score = OsuScoreResult.Hit100;
+                else if (hitFraction > 0)
+                    Judgement.Score = OsuScoreResult.Hit50;
+                else
+                    Judgement.Score = OsuScoreResult.Miss;
+
+                Judgement.Result = Judgement.Score != OsuScoreResult.Miss ? HitResult.Hit : HitResult.Miss;
+            }
+        }
+
+        protected override void UpdateInitialState()
+        {
+            base.UpdateInitialState();
+            body.Alpha = 1;
+
+            //we need to be present to handle input events. note that we still don't get enough events (we don't get a position if the mouse hasn't moved since the slider appeared).
+            ball.AlwaysPresent = true;
+            ball.Alpha = 0;
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+            base.UpdateState(state);
+
+            ball.FadeIn();
+
+            Delay(slider.Duration, true);
+
+            body.FadeOut(160);
+            ball.FadeOut(160);
+
+            FadeOut(800);
+
+            Expire();
+        }
+
+        public Drawable ProxiedLayer => initialCircle.ApproachCircle;
+    }
+
+    internal interface ISliderProgress
+    {
+        void UpdateProgress(double progress, int repeat);
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSliderTick.cs

@@ -0,0 +1,96 @@
+// 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;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Judgements;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables
+{
+    public class DrawableSliderTick : DrawableOsuHitObject
+    {
+        private readonly SliderTick sliderTick;
+
+        public double FadeInTime;
+        public double FadeOutTime;
+
+        public bool Tracking;
+
+        public override bool RemoveWhenNotAlive => false;
+
+        protected override OsuJudgement CreateJudgement() => new OsuJudgement { MaxScore = OsuScoreResult.SliderTick };
+
+        public DrawableSliderTick(SliderTick sliderTick) : base(sliderTick)
+        {
+            this.sliderTick = sliderTick;
+
+            Size = new Vector2(16) * sliderTick.Scale;
+
+            Masking = true;
+            CornerRadius = Size.X / 2;
+
+            Origin = Anchor.Centre;
+
+            BorderThickness = 2;
+            BorderColour = Color4.White;
+
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = AccentColour,
+                    Alpha = 0.3f,
+                }
+            };
+        }
+
+        protected override void CheckJudgement(bool userTriggered)
+        {
+            if (Judgement.TimeOffset >= 0)
+            {
+                Judgement.Result = Tracking ? HitResult.Hit : HitResult.Miss;
+                Judgement.Score = Tracking ? OsuScoreResult.SliderTick : OsuScoreResult.Miss;
+            }
+        }
+
+        protected override void UpdatePreemptState()
+        {
+            var animIn = Math.Min(150, sliderTick.StartTime - FadeInTime);
+
+            ScaleTo(0.5f);
+            ScaleTo(1.2f, animIn);
+            FadeIn(animIn);
+
+            Delay(animIn);
+            ScaleTo(1, 150, EasingTypes.Out);
+
+            Delay(-animIn);
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+            base.UpdateState(state);
+
+            switch (state)
+            {
+                case ArmedState.Idle:
+                    Delay(FadeOutTime - sliderTick.StartTime);
+                    FadeOut();
+                    break;
+                case ArmedState.Miss:
+                    FadeOut(160);
+                    FadeColour(Color4.Red, 80);
+                    break;
+                case ArmedState.Hit:
+                    FadeOut(120, EasingTypes.OutQuint);
+                    ScaleTo(Scale * 1.5f, 120, EasingTypes.OutQuint);
+                    break;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/DrawableSpinner.cs

@@ -0,0 +1,156 @@
+// 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;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.MathUtils;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.Osu.Objects.Drawables.Pieces;
+using OpenTK;
+using OpenTK.Graphics;
+using osu.Game.Rulesets.Osu.UI;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables
+{
+    public class DrawableSpinner : DrawableOsuHitObject
+    {
+        private readonly Spinner spinner;
+
+        private readonly SpinnerDisc disc;
+        private readonly SpinnerBackground background;
+        private readonly Container circleContainer;
+        private readonly DrawableHitCircle circle;
+
+        public DrawableSpinner(Spinner s) : base(s)
+        {
+            AlwaysReceiveInput = true;
+
+            Origin = Anchor.Centre;
+            Position = s.Position;
+
+            //take up full playfield.
+            Size = OsuPlayfield.BASE_SIZE;
+
+            spinner = s;
+
+            Children = new Drawable[]
+            {
+                background = new SpinnerBackground
+                {
+                    Alpha = 0,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    DiscColour = Color4.Black
+                },
+                disc = new SpinnerDisc
+                {
+                    Alpha = 0,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    DiscColour = AccentColour
+                },
+                circleContainer = new Container
+                {
+                    AutoSizeAxes = Axes.Both,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    Children = new []
+                    {
+                        circle = new DrawableHitCircle(s)
+                        {
+                            Interactive = false,
+                            Position = Vector2.Zero,
+                            Anchor = Anchor.Centre,
+                        }
+                    }
+                }
+            };
+
+            background.Scale = scaleToCircle;
+            disc.Scale = scaleToCircle;
+        }
+
+        protected override void CheckJudgement(bool userTriggered)
+        {
+            if (Time.Current < HitObject.StartTime) return;
+
+            disc.ScaleTo(Interpolation.ValueAt(Math.Sqrt(Progress), scaleToCircle, Vector2.One, 0, 1), 100);
+
+            if (Progress >= 1)
+                disc.Complete = true;
+
+            if (!userTriggered && Time.Current >= spinner.EndTime)
+            {
+                if (Progress >= 1)
+                {
+                    Judgement.Score = OsuScoreResult.Hit300;
+                    Judgement.Result = HitResult.Hit;
+                }
+                else if (Progress > .9)
+                {
+                    Judgement.Score = OsuScoreResult.Hit100;
+                    Judgement.Result = HitResult.Hit;
+                }
+                else if (Progress > .75)
+                {
+                    Judgement.Score = OsuScoreResult.Hit50;
+                    Judgement.Result = HitResult.Hit;
+                }
+                else
+                {
+                    Judgement.Score = OsuScoreResult.Miss;
+                    if (Time.Current >= spinner.EndTime)
+                        Judgement.Result = HitResult.Miss;
+                }
+            }
+        }
+
+        private Vector2 scaleToCircle => circle.Scale * circle.DrawWidth / DrawWidth * 0.95f;
+
+        private const float spins_per_minute_needed = 100 + 5 * 15; //TODO: read per-map OD and place it on the 5
+
+        private float rotationsNeeded => (float)(spins_per_minute_needed * (spinner.EndTime - spinner.StartTime) / 60000f);
+
+        public float Progress => MathHelper.Clamp(disc.RotationAbsolute / 360 / rotationsNeeded, 0, 1);
+
+        protected override void UpdatePreemptState()
+        {
+            base.UpdatePreemptState();
+
+            circleContainer.ScaleTo(1, 400, EasingTypes.OutElastic);
+
+            background.Delay(TIME_PREEMPT - 500);
+
+            background.ScaleTo(scaleToCircle * 1.2f, 400, EasingTypes.OutQuint);
+            background.FadeIn(200);
+
+            background.Delay(400);
+            background.ScaleTo(1, 250, EasingTypes.OutQuint);
+
+            disc.Delay(TIME_PREEMPT - 50);
+            disc.FadeIn(200);
+        }
+
+        protected override void UpdateState(ArmedState state)
+        {
+            base.UpdateState(state);
+
+            Delay(spinner.Duration, true);
+
+            FadeOut(160);
+
+            switch (state)
+            {
+                case ArmedState.Hit:
+                    ScaleTo(Scale * 1.2f, 320, EasingTypes.Out);
+                    Expire();
+                    break;
+                case ArmedState.Miss:
+                    ScaleTo(Scale * 0.8f, 320, EasingTypes.In);
+                    Expire();
+                    break;
+            }
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/ApproachCircle.cs

@@ -0,0 +1,35 @@
+// Copyright (c) 2007-2017 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.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class ApproachCircle : Container
+    {
+        private readonly Sprite approachCircle;
+
+        public ApproachCircle()
+        {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            AutoSizeAxes = Axes.Both;
+
+            Children = new Drawable[]
+            {
+                approachCircle = new Sprite()
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(TextureStore textures)
+        {
+            approachCircle.Texture = textures.Get(@"Play/osu/approachcircle");
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/CirclePiece.cs

@@ -0,0 +1,58 @@
+// 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;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Input;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class CirclePiece : Container
+    {
+        private readonly Sprite disc;
+
+
+        public Func<bool> Hit;
+
+        public CirclePiece()
+        {
+            Size = new Vector2((float)OsuHitObject.OBJECT_RADIUS * 2);
+            Masking = true;
+            CornerRadius = Size.X / 2;
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            Children = new Drawable[]
+            {
+                disc = new Sprite
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre
+                },
+                new TrianglesPiece
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    BlendingMode = BlendingMode.Additive,
+                    Alpha = 0.5f,
+                }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(TextureStore textures)
+        {
+            disc.Texture = textures.Get(@"Play/osu/disc");
+        }
+
+        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        {
+            return Hit?.Invoke() ?? false;
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/ExplodePiece.cs

@@ -0,0 +1,33 @@
+// Copyright (c) 2007-2017 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 OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class ExplodePiece : Container
+    {
+        public ExplodePiece()
+        {
+            Size = new Vector2(128);
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            BlendingMode = BlendingMode.Additive;
+            Alpha = 0;
+
+            Children = new Drawable[]
+            {
+                new TrianglesPiece
+                {
+                    BlendingMode = BlendingMode.Additive,
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0.2f,
+                }
+            };
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/FlashPiece.cs

@@ -0,0 +1,35 @@
+// Copyright (c) 2007-2017 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.Framework.Graphics.Sprites;
+using OpenTK;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class FlashPiece : Container
+    {
+        public FlashPiece()
+        {
+            Size = new Vector2(128);
+
+            Masking = true;
+            CornerRadius = Size.X / 2;
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            BlendingMode = BlendingMode.Additive;
+            Alpha = 0;
+
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    RelativeSizeAxes = Axes.Both
+                }
+            };
+        }
+    }
+}

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

@@ -0,0 +1,39 @@
+// Copyright (c) 2007-2017 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.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class GlowPiece : Container
+    {
+        private readonly Sprite layer;
+
+        public GlowPiece()
+        {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            Children = new[]
+            {
+                layer = new Sprite
+                {
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    BlendingMode = BlendingMode.Additive,
+                    Alpha = 0.5f
+                }
+            };
+        }
+
+        [BackgroundDependencyLoader]
+        private void load(TextureStore textures)
+        {
+            layer.Texture = textures.Get(@"Play/osu/ring-glow");
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/NumberPiece.cs

@@ -0,0 +1,58 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Game.Graphics.Sprites;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class NumberPiece : Container
+    {
+        private readonly SpriteText number;
+
+        public string Text
+        {
+            get { return number.Text; }
+            set { number.Text = value; }
+        }
+
+        public NumberPiece()
+        {
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            Children = new Drawable[]
+            {
+                new CircularContainer
+                {
+                    Masking = true,
+                    Origin = Anchor.Centre,
+                    EdgeEffect = new EdgeEffect
+                    {
+                        Type = EdgeEffectType.Glow,
+                        Radius = 60,
+                        Colour = Color4.White.Opacity(0.5f),
+                    },
+                    Children = new[]
+                    {
+                        new Box()
+                    }
+                },
+                number = new OsuSpriteText
+                {
+                    Text = @"1",
+                    Font = @"Venera",
+                    UseFullGlyphHeight = false,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    TextSize = 40,
+                    Alpha = 1
+                }
+            };
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/RingPiece.cs

@@ -0,0 +1,38 @@
+// Copyright (c) 2007-2017 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.Framework.Graphics.Sprites;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class RingPiece : Container
+    {
+        public RingPiece()
+        {
+            Size = new Vector2(128);
+
+            Masking = true;
+            CornerRadius = Size.X / 2;
+
+            Anchor = Anchor.Centre;
+            Origin = Anchor.Centre;
+
+            BorderThickness = 10;
+            BorderColour = Color4.White;
+
+            Children = new Drawable[]
+            {
+                new Box
+                {
+                    AlwaysPresent = true,
+                    Alpha = 0,
+                    RelativeSizeAxes = Axes.Both
+                }
+            };
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SliderBall.cs

@@ -0,0 +1,129 @@
+// Copyright (c) 2007-2017 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.Framework.Graphics.Sprites;
+using osu.Framework.Input;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class SliderBall : CircularContainer, ISliderProgress
+    {
+        private const float width = 128;
+
+        private Color4 accentColour = Color4.Black;
+        /// <summary>
+        /// The colour that is used for the slider ball.
+        /// </summary>
+        public Color4 AccentColour
+        {
+            get { return accentColour; }
+            set
+            {
+                accentColour = value;
+                if (ball != null)
+                    ball.Colour = value;
+            }
+        }
+
+        private readonly Slider slider;
+        private readonly Box follow;
+        private readonly Box ball;
+
+        public SliderBall(Slider slider)
+        {
+            this.slider = slider;
+            Masking = true;
+            AutoSizeAxes = Axes.Both;
+            BlendingMode = BlendingMode.Additive;
+            Origin = Anchor.Centre;
+            BorderThickness = 10;
+            BorderColour = Color4.Orange;
+
+            Children = new Drawable[]
+            {
+                follow = new Box
+                {
+                    Origin = Anchor.Centre,
+                    Anchor = Anchor.Centre,
+                    Colour = Color4.Orange,
+                    Width = width,
+                    Height = width,
+                    Alpha = 0,
+                },
+                new CircularContainer
+                {
+                    Masking = true,
+                    AutoSizeAxes = Axes.Both,
+                    Origin = Anchor.Centre,
+                    Anchor = Anchor.Centre,
+                    BorderThickness = 10,
+                    BorderColour = Color4.White,
+                    Alpha = 1,
+                    Children = new[]
+                    {
+                        ball = new Box
+                        {
+                            Colour = AccentColour,
+                            Alpha = 0.4f,
+                            Width = width,
+                            Height = width,
+                        },
+                    }
+                }
+            };
+        }
+
+        private InputState lastState;
+
+        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        {
+            lastState = state;
+            return base.OnMouseDown(state, args);
+        }
+
+        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        {
+            lastState = state;
+            return base.OnMouseUp(state, args);
+        }
+
+        protected override bool OnMouseMove(InputState state)
+        {
+            lastState = state;
+            return base.OnMouseMove(state);
+        }
+
+        private bool tracking;
+        public bool Tracking
+        {
+            get { return tracking; }
+            set
+            {
+                if (value == tracking) return;
+
+                tracking = value;
+
+                follow.ScaleTo(tracking ? 2.8f : 1, 300, EasingTypes.OutQuint);
+                follow.FadeTo(tracking ? 0.2f : 0, 300, EasingTypes.OutQuint);
+            }
+        }
+
+        private bool canCurrentlyTrack => Time.Current >= slider.StartTime && Time.Current < slider.EndTime;
+
+        protected override void Update()
+        {
+            base.Update();
+
+            if (Time.Current < slider.EndTime)
+                Tracking = canCurrentlyTrack && lastState != null && Contains(lastState.Mouse.NativeState.Position) && lastState.Mouse.HasMainButtonPressed;
+        }
+
+        public void UpdateProgress(double progress, int repeat)
+        {
+            Position = slider.Curve.PositionAt(progress);
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SliderBody.cs

@@ -0,0 +1,185 @@
+// 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;
+using System.Collections.Generic;
+using osu.Framework.Allocation;
+using osu.Framework.Configuration;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.OpenGL.Textures;
+using osu.Framework.Graphics.Lines;
+using osu.Framework.Graphics.Textures;
+using osu.Game.Configuration;
+using OpenTK;
+using OpenTK.Graphics.ES30;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class SliderBody : Container, ISliderProgress
+    {
+        private readonly Path path;
+        private readonly BufferedContainer container;
+
+        public float PathWidth
+        {
+            get { return path.PathWidth; }
+            set { path.PathWidth = value; }
+        }
+
+        public double? SnakedStart { get; private set; }
+        public double? SnakedEnd { get; private set; }
+
+        private Color4 accentColour;
+        /// <summary>
+        /// Used to colour the path.
+        /// </summary>
+        public Color4 AccentColour
+        {
+            get { return accentColour; }
+            set
+            {
+                if (accentColour == value)
+                    return;
+                accentColour = value;
+
+                if (LoadState == LoadState.Loaded)
+                    Schedule(reloadTexture);
+            }
+        }
+
+        private int textureWidth => (int)PathWidth * 2;
+
+        private readonly Slider slider;
+        public SliderBody(Slider s)
+        {
+            slider = s;
+
+            Children = new Drawable[]
+            {
+                container = new BufferedContainer
+                {
+                    CacheDrawnFrameBuffer = true,
+                    Children = new Drawable[]
+                    {
+                        path = new Path
+                        {
+                            BlendingMode = BlendingMode.None,
+                        },
+                    }
+                },
+            };
+
+            container.Attach(RenderbufferInternalFormat.DepthComponent16);
+        }
+
+        public void SetRange(double p0, double p1)
+        {
+            if (p0 > p1)
+                MathHelper.Swap(ref p0, ref p1);
+
+            if (updateSnaking(p0, p1))
+            {
+                // Autosizing does not give us the desired behaviour here.
+                // We want the container to have the same size as the slider,
+                // and to be positioned such that the slider head is at (0,0).
+                container.Size = path.Size;
+                container.Position = -path.PositionInBoundingBox(slider.Curve.PositionAt(0) - currentCurve[0]);
+
+                container.ForceRedraw();
+            }
+        }
+
+        private Bindable<bool> snakingIn;
+        private Bindable<bool> snakingOut;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuConfigManager config)
+        {
+            snakingIn = config.GetBindable<bool>(OsuConfig.SnakingInSliders);
+            snakingOut = config.GetBindable<bool>(OsuConfig.SnakingOutSliders);
+
+            reloadTexture();
+        }
+
+        private void reloadTexture()
+        {
+            var texture = new Texture(textureWidth, 1);
+
+            //initialise background
+            var upload = new TextureUpload(textureWidth * 4);
+            var bytes = upload.Data;
+
+            const float aa_portion = 0.02f;
+            const float border_portion = 0.128f;
+            const float gradient_portion = 1 - border_portion;
+
+            const float opacity_at_centre = 0.3f;
+            const float opacity_at_edge = 0.8f;
+
+            for (int i = 0; i < textureWidth; i++)
+            {
+                float progress = (float)i / (textureWidth - 1);
+
+                if (progress <= border_portion)
+                {
+                    bytes[i * 4] = 255;
+                    bytes[i * 4 + 1] = 255;
+                    bytes[i * 4 + 2] = 255;
+                    bytes[i * 4 + 3] = (byte)(Math.Min(progress / aa_portion, 1) * 255);
+                }
+                else
+                {
+                    progress -= border_portion;
+
+                    bytes[i * 4] = (byte)(AccentColour.R * 255);
+                    bytes[i * 4 + 1] = (byte)(AccentColour.G * 255);
+                    bytes[i * 4 + 2] = (byte)(AccentColour.B * 255);
+                    bytes[i * 4 + 3] = (byte)((opacity_at_edge - (opacity_at_edge - opacity_at_centre) * progress / gradient_portion) * (AccentColour.A * 255));
+                }
+            }
+
+            texture.SetData(upload);
+            path.Texture = texture;
+        }
+
+        private readonly List<Vector2> currentCurve = new List<Vector2>();
+        private bool updateSnaking(double p0, double p1)
+        {
+            if (SnakedStart == p0 && SnakedEnd == p1) return false;
+
+            SnakedStart = p0;
+            SnakedEnd = p1;
+
+            slider.Curve.GetPathToProgress(currentCurve, p0, p1);
+
+            path.ClearVertices();
+            foreach (Vector2 p in currentCurve)
+                path.AddVertex(p - currentCurve[0]);
+
+            return true;
+        }
+
+        public void UpdateProgress(double progress, int repeat)
+        {
+            double start = 0;
+            double end = snakingIn ? MathHelper.Clamp((Time.Current - (slider.StartTime - DrawableOsuHitObject.TIME_PREEMPT)) / DrawableOsuHitObject.TIME_FADEIN, 0, 1) : 1;
+
+            if (repeat >= slider.RepeatCount - 1)
+            {
+                if (Math.Min(repeat, slider.RepeatCount - 1) % 2 == 1)
+                {
+                    start = 0;
+                    end = snakingOut ? progress : 1;
+                }
+                else
+                {
+                    start = snakingOut ? progress : 0;
+                }
+            }
+
+            SetRange(start, end);
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SliderBouncer.cs

@@ -0,0 +1,52 @@
+// Copyright (c) 2007-2017 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.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class SliderBouncer : Container, ISliderProgress
+    {
+        private readonly Slider slider;
+        private readonly bool isEnd;
+        private readonly TextAwesome icon;
+
+        public SliderBouncer(Slider slider, bool isEnd)
+        {
+            this.slider = slider;
+            this.isEnd = isEnd;
+
+            AutoSizeAxes = Axes.Both;
+            BlendingMode = BlendingMode.Additive;
+            Origin = Anchor.Centre;
+
+            Children = new Drawable[]
+            {
+                icon = new TextAwesome
+                {
+                    Icon = FontAwesome.fa_eercast,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                    TextSize = 48,
+                }
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+            icon.RotateTo(360, 1000);
+            icon.Loop();
+        }
+
+        public void UpdateProgress(double progress, int repeat)
+        {
+            if (Time.Current < slider.StartTime)
+                Alpha = 0;
+
+            Alpha = repeat + 1 < slider.RepeatCount && repeat % 2 == (isEnd ? 0 : 1) ? 1 : 0;
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerBackground.cs

@@ -0,0 +1,10 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class SpinnerBackground : SpinnerDisc
+    {
+        public override bool HandleInput => false;
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/SpinnerDisc.cs

@@ -0,0 +1,208 @@
+// 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;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Colour;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Transforms;
+using osu.Framework.Input;
+using osu.Game.Graphics;
+using OpenTK;
+using OpenTK.Graphics;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class SpinnerDisc : CircularContainer
+    {
+        protected Sprite Disc;
+
+        public SRGBColour DiscColour
+        {
+            get { return Disc.Colour; }
+            set { Disc.Colour = value; }
+        }
+
+        private Color4 completeColour;
+
+        [BackgroundDependencyLoader]
+        private void load(OsuColour colours)
+        {
+            completeColour = colours.YellowLight.Opacity(0.8f);
+            Masking = true;
+        }
+
+        private class SpinnerBorder : Container
+        {
+            public SpinnerBorder()
+            {
+                Origin = Anchor.Centre;
+                Anchor = Anchor.Centre;
+                RelativeSizeAxes = Axes.Both;
+
+                layout();
+            }
+
+            private int lastLayoutDotCount;
+            private void layout()
+            {
+                int count = (int)(MathHelper.Pi * ScreenSpaceDrawQuad.Width / 9);
+
+                if (count == lastLayoutDotCount) return;
+
+                lastLayoutDotCount = count;
+
+                while (Children.Count() < count)
+                {
+                    Add(new CircularContainer
+                    {
+                        Colour = Color4.White,
+                        RelativePositionAxes = Axes.Both,
+                        Masking = true,
+                        Origin = Anchor.Centre,
+                        Size = new Vector2(1 / ScreenSpaceDrawQuad.Width * 2000),
+                        Children = new[]
+                        {
+                            new Box
+                            {
+                                Origin = Anchor.Centre,
+                                Anchor = Anchor.Centre,
+                                RelativeSizeAxes = Axes.Both,
+                            }
+                        }
+                    });
+                }
+
+                var size = new Vector2(1 / ScreenSpaceDrawQuad.Width * 2000);
+
+                int i = 0;
+                foreach (var d in Children)
+                {
+                    d.Size = size;
+                    d.Position = new Vector2(
+                        0.5f + (float)Math.Sin((float)i / count * 2 * MathHelper.Pi) / 2,
+                        0.5f + (float)Math.Cos((float)i / count * 2 * MathHelper.Pi) / 2
+                    );
+
+                    i++;
+                }
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+                layout();
+            }
+        }
+
+        public SpinnerDisc()
+        {
+            AlwaysReceiveInput = true;
+
+            RelativeSizeAxes = Axes.Both;
+
+            Children = new Drawable[]
+            {
+                Disc = new Box
+                {
+                    Origin = Anchor.Centre,
+                    Anchor = Anchor.Centre,
+                    RelativeSizeAxes = Axes.Both,
+                    Alpha = 0.2f,
+                },
+                new SpinnerBorder()
+            };
+        }
+
+        private bool tracking;
+        public bool Tracking
+        {
+            get { return tracking; }
+            set
+            {
+                if (value == tracking) return;
+
+                tracking = value;
+
+                Disc.FadeTo(tracking ? 0.5f : 0.2f, 100);
+            }
+        }
+
+        private bool complete;
+        public bool Complete
+        {
+            get { return complete; }
+            set
+            {
+                if (value == complete) return;
+
+                complete = value;
+
+                Disc.FadeColour(completeColour, 200);
+
+                updateCompleteTick();
+            }
+        }
+
+        protected override bool OnMouseDown(InputState state, MouseDownEventArgs args)
+        {
+            Tracking = true;
+            return base.OnMouseDown(state, args);
+        }
+
+        protected override bool OnMouseUp(InputState state, MouseUpEventArgs args)
+        {
+            Tracking = false;
+            return base.OnMouseUp(state, args);
+        }
+
+        protected override bool OnMouseMove(InputState state)
+        {
+            Tracking |= state.Mouse.HasMainButtonPressed;
+            mousePosition = state.Mouse.Position;
+            return base.OnMouseMove(state);
+        }
+
+        private Vector2 mousePosition;
+
+        private float lastAngle;
+        private float currentRotation;
+        public float RotationAbsolute;
+
+        private int completeTick;
+
+        private bool updateCompleteTick() => completeTick != (completeTick = (int)(RotationAbsolute / 360));
+
+        protected override void Update()
+        {
+            base.Update();
+
+            var thisAngle = -(float)MathHelper.RadiansToDegrees(Math.Atan2(mousePosition.X - DrawSize.X / 2, mousePosition.Y - DrawSize.Y / 2));
+            if (tracking)
+            {
+                if (thisAngle - lastAngle > 180)
+                    lastAngle += 360;
+                else if (lastAngle - thisAngle > 180)
+                    lastAngle -= 360;
+
+                currentRotation += thisAngle - lastAngle;
+                RotationAbsolute += Math.Abs(thisAngle - lastAngle);
+            }
+            lastAngle = thisAngle;
+
+            if (Complete && updateCompleteTick())
+            {
+                Disc.Flush(flushType: typeof(TransformAlpha));
+                Disc.FadeTo(0.75f, 30, EasingTypes.OutExpo);
+                Disc.Delay(30);
+                Disc.FadeTo(0.5f, 250, EasingTypes.OutQuint);
+            }
+
+            RotateTo(currentRotation, 100, EasingTypes.OutExpo);
+        }
+    }
+}

osu.Game.Rulesets.Osu/Objects/Drawables/Pieces/TrianglesPiece.cs

@@ -0,0 +1,26 @@
+// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
+// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE
+
+using osu.Game.Graphics.Backgrounds;
+
+namespace osu.Game.Rulesets.Osu.Objects.Drawables.Pieces
+{
+    public class TrianglesPiece : Triangles
+    {
+        protected override bool ExpireOffScreenTriangles => false;
+        protected override bool CreateNewTriangles => false;
+        protected override float SpawnRatio => 0.5f;
+
+        public TrianglesPiece()
+        {
+            TriangleScale = 1.2f;
+            HideAlphaDiscrepancies = false;
+        }
+
+        protected override void Update()
+        {
+            if (IsPresent)
+                base.Update();
+        }
+    }
+}