Make the dragger attach to objects it surrounds

Plus a lot more implementation.

osu.Game/Rulesets/Edit/HitObjectComposer.cs

@@ -77,7 +77,7 @@ namespace osu.Game.Rulesets.Edit
                                     Alpha = 0,
                                     AlwaysPresent = true,
                                 },
-                                CreateUnderlay(rulesetContainer.Playfield),
+                                CreateUnderlay(),
                                 rulesetContainer,
                                 CreateOverlay(rulesetContainer.Playfield)
                             }
@@ -106,9 +106,9 @@ namespace osu.Game.Rulesets.Edit
 
         protected virtual RulesetContainer CreateRulesetContainer(Ruleset ruleset, WorkingBeatmap beatmap) => ruleset.CreateRulesetContainerWith(beatmap, true);
 
-        protected virtual PlayfieldUnderlay CreateUnderlay(Playfield playfield) => new PlayfieldUnderlay();
+        protected virtual PlayfieldUnderlay CreateUnderlay() => new PlayfieldUnderlay();
 
-        protected virtual PlayfieldOverlay CreateOverlay(Playfield playfield) => new PlayfieldOverlay();
+        protected virtual PlayfieldOverlay CreateOverlay(Playfield playfield) => new PlayfieldOverlay(playfield);
 
         protected abstract IReadOnlyList<ICompositionTool> CompositionTools { get; }
     }

osu.Game/Rulesets/Edit/PlayfieldOverlay.cs

@@ -9,15 +9,27 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input;
 using OpenTK;
 using OpenTK.Graphics;
+using System.Collections.Generic;
+using osu.Game.Rulesets.Objects.Drawables;
+using osu.Game.Rulesets.UI;
+using System.Linq;
+using osu.Game.Graphics;
 
 namespace osu.Game.Rulesets.Edit
 {
     public class PlayfieldOverlay : CompositeDrawable
     {
-        private readonly Drawable dragBox;
+        private readonly static Color4 selection_normal_colour = Color4.White;
+        private readonly static Color4 selection_attached_colour = OsuColour.FromHex("eeaa00");
 
-        public PlayfieldOverlay()
+        private readonly Container dragBox;
+
+        private readonly Playfield playfield;
+
+        public PlayfieldOverlay(Playfield playfield)
         {
+            this.playfield = playfield;
+
             RelativeSizeAxes = Axes.Both;
 
             InternalChildren = new[]
@@ -31,25 +43,31 @@ namespace osu.Game.Rulesets.Edit
                     Child = new Box
                     {
                         RelativeSizeAxes = Axes.Both,
-                        Alpha = 0,
-                        AlwaysPresent = true
+                        Alpha = 0.1f
                     }
                 }
             };
         }
 
         private Vector2 dragStartPos;
+        private RectangleF dragRectangle;
+        private List<DrawableHitObject> capturedHitObjects = new List<DrawableHitObject>();
 
         protected override bool OnDragStart(InputState state)
         {
             dragStartPos = ToLocalSpace(state.Mouse.NativeState.Position);
+            dragBox.Position = dragStartPos;
+            dragBox.Size = Vector2.Zero;
+            dragBox.FadeTo(1);
+            dragBox.FadeColour(selection_normal_colour);
+            dragBox.BorderThickness = 2;
             return true;
         }
 
         protected override bool OnDrag(InputState state)
         {
             var dragPos = ToLocalSpace(state.Mouse.NativeState.Position);
-            var dragRectangle = RectangleF.FromLTRB(
+            dragRectangle = RectangleF.FromLTRB(
                 Math.Min(dragStartPos.X, dragPos.X),
                 Math.Min(dragStartPos.Y, dragPos.Y),
                 Math.Max(dragStartPos.X, dragPos.X),
@@ -58,11 +76,51 @@ namespace osu.Game.Rulesets.Edit
             dragBox.Position = dragRectangle.Location;
             dragBox.Size = dragRectangle.Size;
 
+            updateCapturedHitObjects();
+
             return true;
         }
 
+        private void updateCapturedHitObjects()
+        {
+            capturedHitObjects.Clear();
+
+            foreach (var obj in playfield.HitObjects.Objects)
+            {
+                if (!obj.IsAlive || !obj.IsPresent)
+                    continue;
+
+                var objectPosition = obj.Parent.ToScreenSpace(obj.SelectionPoint);
+                if (dragRectangle.Contains(ToLocalSpace(objectPosition)))
+                    capturedHitObjects.Add(obj);
+            }
+        }
+
         protected override bool OnDragEnd(InputState state)
         {
+            if (capturedHitObjects.Count == 0)
+                dragBox.FadeOut(400, Easing.OutQuint);
+            else
+            {
+                // Move the rectangle to cover the hitobjects
+                var topLeft = new Vector2(float.MaxValue, float.MaxValue);
+                var bottomRight = new Vector2(float.MinValue, float.MinValue);
+
+                foreach (var obj in capturedHitObjects)
+                {
+                    topLeft = Vector2.ComponentMin(topLeft, ToLocalSpace(obj.SelectionQuad.TopLeft));
+                    bottomRight = Vector2.ComponentMax(bottomRight, ToLocalSpace(obj.SelectionQuad.BottomRight));
+                }
+
+                topLeft -= new Vector2(5);
+                bottomRight += new Vector2(5);
+
+                dragBox.MoveTo(topLeft, 200, Easing.OutQuint)
+                       .ResizeTo(bottomRight - topLeft, 200, Easing.OutQuint)
+                       .FadeColour(selection_attached_colour, 200, Easing.OutQuint);
+                dragBox.BorderThickness = 3;
+            }
+
             return true;
         }
     }

osu.Game/Rulesets/Edit/SelectionDragger.cs

@@ -0,0 +1,12 @@
+// 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;
+
+namespace osu.Game.Rulesets.Edit
+{
+    public class SelectionDragger : CompositeDrawable
+    {
+
+    }
+}

osu.Game/Rulesets/Objects/Drawables/DrawableHitObject.cs

@@ -14,6 +14,8 @@ using osu.Game.Audio;
 using System.Linq;
 using osu.Game.Graphics;
 using osu.Framework.Configuration;
+using OpenTK;
+using osu.Framework.Graphics.Primitives;
 
 namespace osu.Game.Rulesets.Objects.Drawables
 {
@@ -38,6 +40,16 @@ namespace osu.Game.Rulesets.Objects.Drawables
         {
             HitObject = hitObject;
         }
+
+        /// <summary>
+        /// The local point that causes this <see cref="DrawableHitObject"/> to be selected in the Editor.
+        /// </summary>
+        public virtual Vector2 SelectionPoint => DrawPosition;
+
+        /// <summary>
+        /// The local rectangle that outlines this <see cref="DrawableHitObject"/> for selections in the Editor.
+        /// </summary>
+        public virtual Quad SelectionQuad => ScreenSpaceDrawQuad;
     }
 
     public abstract class DrawableHitObject<TObject> : DrawableHitObject

osu.Game/Rulesets/UI/RulesetContainer.cs

@@ -55,10 +55,11 @@ namespace osu.Game.Rulesets.UI
 
         public abstract IEnumerable<HitObject> Objects { get; }
 
+        private Playfield playfield;
         /// <summary>
         /// The playfield.
         /// </summary>
-        public Playfield Playfield { get; protected set; }
+        public Playfield Playfield => playfield ?? (playfield = CreatePlayfield());
 
         protected readonly Ruleset Ruleset;
 
@@ -95,6 +96,12 @@ namespace osu.Game.Rulesets.UI
             Replay = replay;
             ReplayInputManager.ReplayInputHandler = replay != null ? CreateReplayInputHandler(replay) : null;
         }
+
+        /// <summary>
+        /// Creates a Playfield.
+        /// </summary>
+        /// <returns>The Playfield.</returns>
+        protected abstract Playfield CreatePlayfield();
     }
 
     /// <summary>
@@ -198,7 +205,7 @@ namespace osu.Game.Rulesets.UI
             });
 
             AddInternal(KeyBindingInputManager);
-            KeyBindingInputManager.Add(Playfield = CreatePlayfield());
+            KeyBindingInputManager.Add(Playfield);
 
             loadObjects();
         }
@@ -286,12 +293,6 @@ namespace osu.Game.Rulesets.UI
         /// <param name="h">The HitObject to make drawable.</param>
         /// <returns>The DrawableHitObject.</returns>
         protected abstract DrawableHitObject<TObject> GetVisualRepresentation(TObject h);
-
-        /// <summary>
-        /// Creates a Playfield.
-        /// </summary>
-        /// <returns>The Playfield.</returns>
-        protected abstract Playfield CreatePlayfield();
     }
 
     /// <summary>