Merge pull request #10294 from peppy/osu-selection-scaling

Add selection scale and rotate support

osu.Game/Screens/Edit/Compose/Components/ComposeSelectionBox.cs

@@ -0,0 +1,312 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using osu.Framework.Allocation;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Screens.Edit.Compose.Components
+{
+    public class ComposeSelectionBox : CompositeDrawable
+    {
+        public Action<DragEvent> OnRotation;
+        public Action<DragEvent, Anchor> OnScale;
+
+        public Action OperationStarted;
+        public Action OperationEnded;
+
+        private bool canRotate;
+
+        /// <summary>
+        /// Whether rotation support should be enabled.
+        /// </summary>
+        public bool CanRotate
+        {
+            get => canRotate;
+            set
+            {
+                canRotate = value;
+                recreate();
+            }
+        }
+
+        private bool canScaleX;
+
+        /// <summary>
+        /// Whether vertical scale support should be enabled.
+        /// </summary>
+        public bool CanScaleX
+        {
+            get => canScaleX;
+            set
+            {
+                canScaleX = value;
+                recreate();
+            }
+        }
+
+        private bool canScaleY;
+
+        /// <summary>
+        /// Whether horizontal scale support should be enabled.
+        /// </summary>
+        public bool CanScaleY
+        {
+            get => canScaleY;
+            set
+            {
+                canScaleY = value;
+                recreate();
+            }
+        }
+
+        public const float BORDER_RADIUS = 3;
+
+        [Resolved]
+        private OsuColour colours { get; set; }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            RelativeSizeAxes = Axes.Both;
+
+            recreate();
+        }
+
+        private void recreate()
+        {
+            if (LoadState < LoadState.Loading)
+                return;
+
+            InternalChildren = new Drawable[]
+            {
+                new Container
+                {
+                    Masking = true,
+                    BorderThickness = BORDER_RADIUS,
+                    BorderColour = colours.YellowDark,
+                    RelativeSizeAxes = Axes.Both,
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+
+                            AlwaysPresent = true,
+                            Alpha = 0
+                        },
+                    }
+                },
+            };
+
+            if (CanRotate)
+            {
+                const float separation = 40;
+
+                AddRangeInternal(new Drawable[]
+                {
+                    new Box
+                    {
+                        Colour = colours.YellowLight,
+                        Blending = BlendingParameters.Additive,
+                        Alpha = 0.3f,
+                        Size = new Vector2(BORDER_RADIUS, separation),
+                        Anchor = Anchor.TopCentre,
+                        Origin = Anchor.BottomCentre,
+                    },
+                    new RotationDragHandle
+                    {
+                        Anchor = Anchor.TopCentre,
+                        Y = -separation,
+                        HandleDrag = e => OnRotation?.Invoke(e),
+                        OperationStarted = operationStarted,
+                        OperationEnded = operationEnded
+                    }
+                });
+            }
+
+            if (CanScaleY)
+            {
+                AddRangeInternal(new[]
+                {
+                    createDragHandle(Anchor.TopCentre),
+                    createDragHandle(Anchor.BottomCentre),
+                });
+            }
+
+            if (CanScaleX)
+            {
+                AddRangeInternal(new[]
+                {
+                    createDragHandle(Anchor.CentreLeft),
+                    createDragHandle(Anchor.CentreRight),
+                });
+            }
+
+            if (CanScaleX && CanScaleY)
+            {
+                AddRangeInternal(new[]
+                {
+                    createDragHandle(Anchor.TopLeft),
+                    createDragHandle(Anchor.TopRight),
+                    createDragHandle(Anchor.BottomLeft),
+                    createDragHandle(Anchor.BottomRight),
+                });
+            }
+
+            ScaleDragHandle createDragHandle(Anchor anchor) =>
+                new ScaleDragHandle(anchor)
+                {
+                    HandleDrag = e => OnScale?.Invoke(e, anchor),
+                    OperationStarted = operationStarted,
+                    OperationEnded = operationEnded
+                };
+        }
+
+        private int activeOperations;
+
+        private void operationEnded()
+        {
+            if (--activeOperations == 0)
+                OperationEnded?.Invoke();
+        }
+
+        private void operationStarted()
+        {
+            if (activeOperations++ == 0)
+                OperationStarted?.Invoke();
+        }
+
+        private class ScaleDragHandle : DragHandle
+        {
+            public ScaleDragHandle(Anchor anchor)
+            {
+                Anchor = anchor;
+            }
+        }
+
+        private class RotationDragHandle : DragHandle
+        {
+            private SpriteIcon icon;
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Size *= 2;
+
+                AddInternal(icon = new SpriteIcon
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Size = new Vector2(0.5f),
+                    Icon = FontAwesome.Solid.Redo,
+                    Anchor = Anchor.Centre,
+                    Origin = Anchor.Centre,
+                });
+            }
+
+            protected override void UpdateHoverState()
+            {
+                base.UpdateHoverState();
+                icon.Colour = !HandlingMouse && IsHovered ? Color4.White : Color4.Black;
+            }
+        }
+
+        private class DragHandle : Container
+        {
+            public Action OperationStarted;
+            public Action OperationEnded;
+
+            public Action<DragEvent> HandleDrag { get; set; }
+
+            private Circle circle;
+
+            [Resolved]
+            private OsuColour colours { get; set; }
+
+            [BackgroundDependencyLoader]
+            private void load()
+            {
+                Size = new Vector2(10);
+                Origin = Anchor.Centre;
+
+                InternalChildren = new Drawable[]
+                {
+                    circle = new Circle
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Anchor = Anchor.Centre,
+                        Origin = Anchor.Centre,
+                    },
+                };
+            }
+
+            protected override void LoadComplete()
+            {
+                base.LoadComplete();
+                UpdateHoverState();
+            }
+
+            protected override bool OnHover(HoverEvent e)
+            {
+                UpdateHoverState();
+                return base.OnHover(e);
+            }
+
+            protected override void OnHoverLost(HoverLostEvent e)
+            {
+                base.OnHoverLost(e);
+                UpdateHoverState();
+            }
+
+            protected bool HandlingMouse;
+
+            protected override bool OnMouseDown(MouseDownEvent e)
+            {
+                HandlingMouse = true;
+                UpdateHoverState();
+                return true;
+            }
+
+            protected override bool OnDragStart(DragStartEvent e)
+            {
+                OperationStarted?.Invoke();
+                return true;
+            }
+
+            protected override void OnDrag(DragEvent e)
+            {
+                HandleDrag?.Invoke(e);
+                base.OnDrag(e);
+            }
+
+            protected override void OnDragEnd(DragEndEvent e)
+            {
+                HandlingMouse = false;
+                OperationEnded?.Invoke();
+
+                UpdateHoverState();
+                base.OnDragEnd(e);
+            }
+
+            protected override void OnMouseUp(MouseUpEvent e)
+            {
+                HandlingMouse = false;
+                UpdateHoverState();
+                base.OnMouseUp(e);
+            }
+
+            protected virtual void UpdateHoverState()
+            {
+                circle.Colour = HandlingMouse ? colours.GrayF : (IsHovered ? colours.Red : colours.YellowDark);
+                this.ScaleTo(HandlingMouse || IsHovered ? 1.5f : 1, 100, Easing.OutQuint);
+            }
+        }
+    }
+}

osu.Game/Screens/Edit/Compose/Components/DragBox.cs

@@ -45,7 +45,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
         {
             Masking = true,
             BorderColour = Color4.White,
-            BorderThickness = SelectionHandler.BORDER_RADIUS,
+            BorderThickness = ComposeSelectionBox.BORDER_RADIUS,
             Child = new Box
             {
                 RelativeSizeAxes = Axes.Both,

osu.Game/Screens/Edit/Compose/Components/SelectionHandler.cs

@@ -32,8 +32,6 @@ namespace osu.Game.Screens.Edit.Compose.Components
     /// </summary>
     public class SelectionHandler : CompositeDrawable, IKeyBindingHandler<PlatformAction>, IHasContextMenu
     {
-        public const float BORDER_RADIUS = 2;
-
         public IEnumerable<SelectionBlueprint> SelectedBlueprints => selectedBlueprints;
         private readonly List<SelectionBlueprint> selectedBlueprints;
 
@@ -45,6 +43,8 @@ namespace osu.Game.Screens.Edit.Compose.Components
 
         private OsuSpriteText selectionDetailsText;
 
+        protected ComposeSelectionBox SelectionBox { get; private set; }
+
         [Resolved(CanBeNull = true)]
         protected EditorBeatmap EditorBeatmap { get; private set; }
 
@@ -69,19 +69,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             {
                 Children = new Drawable[]
                 {
-                    new Container
-                    {
-                        RelativeSizeAxes = Axes.Both,
-                        Masking = true,
-                        BorderThickness = BORDER_RADIUS,
-                        BorderColour = colours.YellowDark,
-                        Child = new Box
-                        {
-                            RelativeSizeAxes = Axes.Both,
-                            AlwaysPresent = true,
-                            Alpha = 0
-                        }
-                    },
+                    // todo: should maybe be inside the SelectionBox?
                     new Container
                     {
                         Name = "info text",
@@ -100,11 +88,38 @@ namespace osu.Game.Screens.Edit.Compose.Components
                                 Font = OsuFont.Default.With(size: 11)
                             }
                         }
-                    }
+                    },
+                    SelectionBox = CreateSelectionBox(),
                 }
             };
         }
 
+        public ComposeSelectionBox CreateSelectionBox()
+            => new ComposeSelectionBox
+            {
+                OperationStarted = OnDragOperationBegan,
+                OperationEnded = OnDragOperationEnded,
+
+                OnRotation = e => HandleRotation(e.Delta.X),
+                OnScale = (e, anchor) => HandleScale(e.Delta, anchor),
+            };
+
+        /// <summary>
+        /// Fired when a drag operation ends from the selection box.
+        /// </summary>
+        protected virtual void OnDragOperationBegan()
+        {
+            ChangeHandler.BeginChange();
+        }
+
+        /// <summary>
+        /// Fired when a drag operation begins from the selection box.
+        /// </summary>
+        protected virtual void OnDragOperationEnded()
+        {
+            ChangeHandler.EndChange();
+        }
+
         #region User Input Handling
 
         /// <summary>
@@ -119,7 +134,22 @@ namespace osu.Game.Screens.Edit.Compose.Components
         /// Whether any <see cref="DrawableHitObject"/>s could be moved.
         /// Returning true will also propagate StartTime changes provided by the closest <see cref="IPositionSnapProvider.SnapScreenSpacePositionToValidTime"/>.
         /// </returns>
-        public virtual bool HandleMovement(MoveSelectionEvent moveEvent) => true;
+        public virtual bool HandleMovement(MoveSelectionEvent moveEvent) => false;
+
+        /// <summary>
+        /// Handles the selected <see cref="DrawableHitObject"/>s being rotated.
+        /// </summary>
+        /// <param name="angle">The delta angle to apply to the selection.</param>
+        /// <returns>Whether any <see cref="DrawableHitObject"/>s could be moved.</returns>
+        public virtual bool HandleRotation(float angle) => false;
+
+        /// <summary>
+        /// Handles the selected <see cref="DrawableHitObject"/>s being scaled.
+        /// </summary>
+        /// <param name="scale">The delta scale to apply, in playfield local coordinates.</param>
+        /// <param name="anchor">The point of reference where the scale is originating from.</param>
+        /// <returns>Whether any <see cref="DrawableHitObject"/>s could be moved.</returns>
+        public virtual bool HandleScale(Vector2 scale, Anchor anchor) => false;
 
         public bool OnPressed(PlatformAction action)
         {
@@ -222,11 +252,22 @@ namespace osu.Game.Screens.Edit.Compose.Components
             selectionDetailsText.Text = count > 0 ? count.ToString() : string.Empty;
 
             if (count > 0)
+            {
                 Show();
+                OnSelectionChanged();
+            }
             else
                 Hide();
         }
 
+        /// <summary>
+        /// Triggered whenever more than one object is selected, on each change.
+        /// Should update the selection box's state to match supported operations.
+        /// </summary>
+        protected virtual void OnSelectionChanged()
+        {
+        }
+
         protected override void Update()
         {
             base.Update();