2019-01-24 08:43:03 +00:00
|
|
|
// 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.
|
2018-11-16 08:12:24 +00:00
|
|
|
|
2020-09-29 10:50:03 +00:00
|
|
|
using System;
|
2020-09-30 05:41:32 +00:00
|
|
|
using System.Collections.Generic;
|
2018-11-16 08:12:24 +00:00
|
|
|
using System.Linq;
|
2020-09-29 10:43:50 +00:00
|
|
|
using osu.Framework.Graphics;
|
2020-09-29 10:50:03 +00:00
|
|
|
using osu.Framework.Graphics.Primitives;
|
2020-09-30 04:02:05 +00:00
|
|
|
using osu.Framework.Utils;
|
2020-09-29 11:00:19 +00:00
|
|
|
using osu.Game.Rulesets.Objects.Types;
|
2018-11-16 08:12:24 +00:00
|
|
|
using osu.Game.Rulesets.Osu.Objects;
|
|
|
|
using osu.Game.Screens.Edit.Compose.Components;
|
2019-11-06 08:27:41 +00:00
|
|
|
using osuTK;
|
2018-11-16 08:12:24 +00:00
|
|
|
|
|
|
|
namespace osu.Game.Rulesets.Osu.Edit
|
|
|
|
{
|
2018-11-19 07:58:11 +00:00
|
|
|
public class OsuSelectionHandler : SelectionHandler
|
2018-11-16 08:12:24 +00:00
|
|
|
{
|
2020-09-30 04:52:57 +00:00
|
|
|
protected override void OnSelectionChanged()
|
|
|
|
{
|
|
|
|
base.OnSelectionChanged();
|
2020-09-29 10:43:50 +00:00
|
|
|
|
2020-09-30 04:52:57 +00:00
|
|
|
bool canOperate = SelectedHitObjects.Count() > 1 || SelectedHitObjects.Any(s => s is Slider);
|
|
|
|
|
|
|
|
SelectionBox.CanRotate = canOperate;
|
|
|
|
SelectionBox.CanScaleX = canOperate;
|
|
|
|
SelectionBox.CanScaleY = canOperate;
|
|
|
|
}
|
2020-09-29 11:08:28 +00:00
|
|
|
|
2020-10-01 07:24:04 +00:00
|
|
|
protected override void OnOperationEnded()
|
2020-09-30 04:52:57 +00:00
|
|
|
{
|
2020-10-01 07:24:04 +00:00
|
|
|
base.OnOperationEnded();
|
2020-09-30 04:52:57 +00:00
|
|
|
referenceOrigin = null;
|
|
|
|
}
|
2020-09-29 10:43:50 +00:00
|
|
|
|
2020-09-30 04:02:05 +00:00
|
|
|
public override bool HandleMovement(MoveSelectionEvent moveEvent) =>
|
|
|
|
moveSelection(moveEvent.InstantDelta);
|
2020-09-29 11:08:28 +00:00
|
|
|
|
2020-09-30 04:02:05 +00:00
|
|
|
/// <summary>
|
|
|
|
/// During a transform, the initial origin is stored so it can be used throughout the operation.
|
|
|
|
/// </summary>
|
|
|
|
private Vector2? referenceOrigin;
|
2020-09-29 11:08:28 +00:00
|
|
|
|
2020-10-01 07:24:50 +00:00
|
|
|
public override bool HandleFlip(Direction direction)
|
|
|
|
{
|
|
|
|
var hitObjects = selectedMovableObjects;
|
|
|
|
|
|
|
|
var selectedObjectsQuad = getSurroundingQuad(hitObjects);
|
|
|
|
var centre = selectedObjectsQuad.Centre;
|
|
|
|
|
|
|
|
foreach (var h in hitObjects)
|
|
|
|
{
|
|
|
|
var pos = h.Position;
|
|
|
|
|
|
|
|
switch (direction)
|
|
|
|
{
|
|
|
|
case Direction.Horizontal:
|
|
|
|
pos.X = centre.X - (pos.X - centre.X);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case Direction.Vertical:
|
|
|
|
pos.Y = centre.Y - (pos.Y - centre.Y);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
h.Position = pos;
|
|
|
|
|
|
|
|
if (h is Slider slider)
|
|
|
|
{
|
|
|
|
foreach (var point in slider.Path.ControlPoints)
|
|
|
|
{
|
|
|
|
point.Position.Value = new Vector2(
|
|
|
|
(direction == Direction.Horizontal ? -1 : 1) * point.Position.Value.X,
|
|
|
|
(direction == Direction.Vertical ? -1 : 1) * point.Position.Value.Y
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-09-30 06:08:56 +00:00
|
|
|
public override bool HandleScale(Vector2 scale, Anchor reference)
|
2020-09-29 11:00:19 +00:00
|
|
|
{
|
2020-09-30 06:17:27 +00:00
|
|
|
adjustScaleFromAnchor(ref scale, reference);
|
2020-09-29 11:00:19 +00:00
|
|
|
|
2020-09-30 05:41:32 +00:00
|
|
|
var hitObjects = selectedMovableObjects;
|
2020-09-29 10:43:50 +00:00
|
|
|
|
2020-09-30 05:41:32 +00:00
|
|
|
// for the time being, allow resizing of slider paths only if the slider is
|
|
|
|
// the only hit object selected. with a group selection, it's likely the user
|
|
|
|
// is not looking to change the duration of the slider but expand the whole pattern.
|
|
|
|
if (hitObjects.Length == 1 && hitObjects.First() is Slider slider)
|
|
|
|
{
|
2020-09-30 06:17:27 +00:00
|
|
|
Quad quad = getSurroundingQuad(slider.Path.ControlPoints.Select(p => p.Position.Value));
|
|
|
|
Vector2 pathRelativeDeltaScale = new Vector2(1 + scale.X / quad.Width, 1 + scale.Y / quad.Height);
|
2020-09-29 10:43:50 +00:00
|
|
|
|
2020-09-30 05:41:32 +00:00
|
|
|
foreach (var point in slider.Path.ControlPoints)
|
2020-09-30 06:17:27 +00:00
|
|
|
point.Position.Value *= pathRelativeDeltaScale;
|
2020-09-30 05:41:32 +00:00
|
|
|
}
|
|
|
|
else
|
2020-09-29 10:43:50 +00:00
|
|
|
{
|
2020-09-30 05:41:32 +00:00
|
|
|
// move the selection before scaling if dragging from top or left anchors.
|
|
|
|
if ((reference & Anchor.x0) > 0 && !moveSelection(new Vector2(-scale.X, 0))) return false;
|
|
|
|
if ((reference & Anchor.y0) > 0 && !moveSelection(new Vector2(0, -scale.Y))) return false;
|
|
|
|
|
|
|
|
Quad quad = getSurroundingQuad(hitObjects);
|
|
|
|
|
|
|
|
foreach (var h in hitObjects)
|
2020-09-29 10:43:50 +00:00
|
|
|
{
|
2020-09-30 06:17:27 +00:00
|
|
|
h.Position = new Vector2(
|
|
|
|
quad.TopLeft.X + (h.X - quad.TopLeft.X) / quad.Width * (quad.Width + scale.X),
|
|
|
|
quad.TopLeft.Y + (h.Y - quad.TopLeft.Y) / quad.Height * (quad.Height + scale.Y)
|
|
|
|
);
|
2020-09-29 10:43:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-09-30 06:17:27 +00:00
|
|
|
private static void adjustScaleFromAnchor(ref Vector2 scale, Anchor reference)
|
|
|
|
{
|
|
|
|
// cancel out scale in axes we don't care about (based on which drag handle was used).
|
|
|
|
if ((reference & Anchor.x1) > 0) scale.X = 0;
|
|
|
|
if ((reference & Anchor.y1) > 0) scale.Y = 0;
|
|
|
|
|
|
|
|
// reverse the scale direction if dragging from top or left.
|
|
|
|
if ((reference & Anchor.x0) > 0) scale.X = -scale.X;
|
|
|
|
if ((reference & Anchor.y0) > 0) scale.Y = -scale.Y;
|
|
|
|
}
|
|
|
|
|
2020-09-30 06:08:56 +00:00
|
|
|
public override bool HandleRotation(float delta)
|
|
|
|
{
|
|
|
|
var hitObjects = selectedMovableObjects;
|
|
|
|
|
|
|
|
Quad quad = getSurroundingQuad(hitObjects);
|
|
|
|
|
|
|
|
referenceOrigin ??= quad.Centre;
|
|
|
|
|
|
|
|
foreach (var h in hitObjects)
|
|
|
|
{
|
|
|
|
h.Position = rotatePointAroundOrigin(h.Position, referenceOrigin.Value, delta);
|
|
|
|
|
|
|
|
if (h is IHasPath path)
|
|
|
|
{
|
|
|
|
foreach (var point in path.Path.ControlPoints)
|
|
|
|
point.Position.Value = rotatePointAroundOrigin(point.Position.Value, Vector2.Zero, delta);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// this isn't always the case but let's be lenient for now.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2020-09-29 10:43:50 +00:00
|
|
|
private bool moveSelection(Vector2 delta)
|
2018-11-16 08:12:24 +00:00
|
|
|
{
|
2020-09-30 05:41:32 +00:00
|
|
|
var hitObjects = selectedMovableObjects;
|
2019-11-06 08:27:41 +00:00
|
|
|
|
2020-09-30 05:41:32 +00:00
|
|
|
Quad quad = getSurroundingQuad(hitObjects);
|
2019-11-06 08:27:41 +00:00
|
|
|
|
2020-09-30 05:41:32 +00:00
|
|
|
if (quad.TopLeft.X + delta.X < 0 ||
|
|
|
|
quad.TopLeft.Y + delta.Y < 0 ||
|
|
|
|
quad.BottomRight.X + delta.X > DrawWidth ||
|
|
|
|
quad.BottomRight.Y + delta.Y > DrawHeight)
|
2019-11-06 08:27:41 +00:00
|
|
|
return false;
|
|
|
|
|
2020-09-30 05:41:32 +00:00
|
|
|
foreach (var h in hitObjects)
|
2020-09-29 10:43:50 +00:00
|
|
|
h.Position += delta;
|
2018-11-26 07:08:56 +00:00
|
|
|
|
2019-11-06 08:27:41 +00:00
|
|
|
return true;
|
2018-11-16 08:12:24 +00:00
|
|
|
}
|
2020-09-29 10:50:03 +00:00
|
|
|
|
2020-09-30 04:52:57 +00:00
|
|
|
/// <summary>
|
2020-09-30 05:41:32 +00:00
|
|
|
/// Returns a gamefield-space quad surrounding the provided hit objects.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="hitObjects">The hit objects to calculate a quad for.</param>
|
|
|
|
private Quad getSurroundingQuad(OsuHitObject[] hitObjects) =>
|
|
|
|
getSurroundingQuad(hitObjects.SelectMany(h => new[] { h.Position, h.EndPosition }));
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// Returns a gamefield-space quad surrounding the provided points.
|
2020-09-30 04:52:57 +00:00
|
|
|
/// </summary>
|
2020-09-30 05:41:32 +00:00
|
|
|
/// <param name="points">The points to calculate a quad for.</param>
|
|
|
|
private Quad getSurroundingQuad(IEnumerable<Vector2> points)
|
2020-09-29 10:50:03 +00:00
|
|
|
{
|
2020-09-30 04:52:57 +00:00
|
|
|
if (!SelectedHitObjects.Any())
|
|
|
|
return new Quad();
|
|
|
|
|
2020-09-29 10:50:03 +00:00
|
|
|
Vector2 minPosition = new Vector2(float.MaxValue, float.MaxValue);
|
|
|
|
Vector2 maxPosition = new Vector2(float.MinValue, float.MinValue);
|
|
|
|
|
|
|
|
// Go through all hitobjects to make sure they would remain in the bounds of the editor after movement, before any movement is attempted
|
2020-09-30 05:41:32 +00:00
|
|
|
foreach (var p in points)
|
2020-09-29 10:50:03 +00:00
|
|
|
{
|
2020-09-30 05:41:32 +00:00
|
|
|
minPosition = Vector2.ComponentMin(minPosition, p);
|
|
|
|
maxPosition = Vector2.ComponentMax(maxPosition, p);
|
2020-09-29 10:50:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Vector2 size = maxPosition - minPosition;
|
|
|
|
|
|
|
|
return new Quad(minPosition.X, minPosition.Y, size.X, size.Y);
|
|
|
|
}
|
|
|
|
|
2020-09-30 05:41:32 +00:00
|
|
|
/// <summary>
|
|
|
|
/// All osu! hitobjects which can be moved/rotated/scaled.
|
|
|
|
/// </summary>
|
|
|
|
private OsuHitObject[] selectedMovableObjects => SelectedHitObjects
|
|
|
|
.OfType<OsuHitObject>()
|
|
|
|
.Where(h => !(h is Spinner))
|
|
|
|
.ToArray();
|
|
|
|
|
2020-09-29 10:50:03 +00:00
|
|
|
/// <summary>
|
2020-09-30 04:02:05 +00:00
|
|
|
/// Rotate a point around an arbitrary origin.
|
2020-09-29 10:50:03 +00:00
|
|
|
/// </summary>
|
2020-09-30 04:02:05 +00:00
|
|
|
/// <param name="point">The point.</param>
|
|
|
|
/// <param name="origin">The centre origin to rotate around.</param>
|
2020-09-29 10:50:03 +00:00
|
|
|
/// <param name="angle">The angle to rotate (in degrees).</param>
|
2020-09-30 04:02:05 +00:00
|
|
|
private static Vector2 rotatePointAroundOrigin(Vector2 point, Vector2 origin, float angle)
|
2020-09-29 10:50:03 +00:00
|
|
|
{
|
|
|
|
angle = -angle;
|
|
|
|
|
2020-09-30 04:02:05 +00:00
|
|
|
point.X -= origin.X;
|
|
|
|
point.Y -= origin.Y;
|
2020-09-29 10:50:03 +00:00
|
|
|
|
|
|
|
Vector2 ret;
|
2020-10-01 09:10:05 +00:00
|
|
|
ret.X = point.X * MathF.Cos(MathUtils.DegreesToRadians(angle)) + point.Y * MathF.Sin(MathUtils.DegreesToRadians(angle));
|
|
|
|
ret.Y = point.X * -MathF.Sin(MathUtils.DegreesToRadians(angle)) + point.Y * MathF.Cos(MathUtils.DegreesToRadians(angle));
|
2020-09-29 10:50:03 +00:00
|
|
|
|
2020-09-30 04:02:05 +00:00
|
|
|
ret.X += origin.X;
|
|
|
|
ret.Y += origin.Y;
|
2020-09-29 10:50:03 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2018-11-16 08:12:24 +00:00
|
|
|
}
|
|
|
|
}
|