1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-18 09:32:58 +08:00
osu-lazer/osu.Game/Overlays/SkinEditor/SkinSelectionHandler.cs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

327 lines
12 KiB
C#
Raw Normal View History

// 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 System.Collections.Generic;
using System.Linq;
using osu.Framework.Allocation;
using osu.Framework.Extensions;
using osu.Framework.Graphics;
2021-05-20 17:24:25 +08:00
using osu.Framework.Graphics.Primitives;
using osu.Framework.Graphics.UserInterface;
using osu.Game.Extensions;
using osu.Game.Graphics.UserInterface;
using osu.Game.Rulesets.Edit;
using osu.Game.Screens.Edit.Compose.Components;
2023-01-26 17:21:04 +08:00
using osu.Game.Skinning;
using osu.Game.Utils;
using osuTK;
2023-01-26 17:21:04 +08:00
namespace osu.Game.Overlays.SkinEditor
{
public partial class SkinSelectionHandler : SelectionHandler<ISerialisableDrawable>
{
private OsuMenuItem originMenu = null!;
[Resolved]
2023-01-26 16:46:19 +08:00
private SkinEditor skinEditor { get; set; } = null!;
public override SelectionRotationHandler CreateRotationHandler() => new SkinSelectionRotationHandler
{
UpdatePosition = updateDrawablePosition
};
2024-01-20 09:49:56 +08:00
public override SelectionScaleHandler CreateScaleHandler()
{
2024-01-20 09:49:56 +08:00
var scaleHandler = new SkinSelectionScaleHandler
2021-05-19 20:46:41 +08:00
{
2024-01-20 09:49:56 +08:00
UpdatePosition = updateDrawablePosition
};
2024-01-20 09:49:56 +08:00
scaleHandler.PerformFlipFromScaleHandles += a => SelectionBox.PerformFlipFromScaleHandles(a);
2024-01-20 09:49:56 +08:00
return scaleHandler;
}
2022-01-05 15:46:34 +08:00
public override bool HandleFlip(Direction direction, bool flipOverOrigin)
{
var selectionQuad = getSelectionQuad();
Vector2 scaleFactor = direction == Direction.Horizontal ? new Vector2(-1, 1) : new Vector2(1, -1);
foreach (var b in SelectedBlueprints)
{
var drawableItem = (Drawable)b.Item;
var flippedPosition = GeometryUtils.GetFlippedPosition(direction, flipOverOrigin ? drawableItem.Parent!.ScreenSpaceDrawQuad : selectionQuad, b.ScreenSpaceSelectionPoint);
updateDrawablePosition(drawableItem, flippedPosition);
drawableItem.Scale *= scaleFactor;
drawableItem.Rotation -= drawableItem.Rotation % 180 * 2;
}
return true;
}
public override bool HandleMovement(MoveSelectionEvent<ISerialisableDrawable> moveEvent)
{
foreach (var c in SelectedBlueprints)
{
var item = c.Item;
Drawable drawable = (Drawable)item;
if (!item.UsesFixedAnchor)
ApplyClosestAnchorOrigin(drawable);
drawable.Position += drawable.ScreenSpaceDeltaToParentSpace(moveEvent.ScreenSpaceDelta);
}
return true;
}
public static void ApplyClosestAnchorOrigin(Drawable drawable)
{
var closest = getClosestAnchor(drawable);
applyAnchor(drawable, closest);
applyOrigin(drawable, closest);
}
protected override void OnSelectionChanged()
{
base.OnSelectionChanged();
SelectionBox.CanFlipX = true;
SelectionBox.CanFlipY = true;
SelectionBox.CanReverse = false;
}
protected override void DeleteItems(IEnumerable<ISerialisableDrawable> items) =>
skinEditor.DeleteItems(items.ToArray());
protected override IEnumerable<MenuItem> GetContextMenuItemsForSelection(IEnumerable<SelectionBlueprint<ISerialisableDrawable>> selection)
{
var closestItem = new TernaryStateRadioMenuItem("Closest", MenuItemType.Standard, _ => applyClosestAnchors())
2021-06-07 13:08:39 +08:00
{
State = { Value = GetStateFromSelection(selection, c => !c.Item.UsesFixedAnchor) }
};
yield return new OsuMenuItem("Anchor")
{
2021-06-11 18:22:24 +08:00
Items = createAnchorItems((d, a) => d.UsesFixedAnchor && ((Drawable)d).Anchor == a, applyFixedAnchors)
.Prepend(closestItem)
.ToArray()
};
yield return originMenu = new OsuMenuItem("Origin");
closestItem.State.BindValueChanged(s =>
{
// For UX simplicity, origin should only be user-editable when "closest" anchor mode is disabled.
originMenu.Items = s.NewValue == TernaryState.True
? Array.Empty<MenuItem>()
: createAnchorItems((d, o) => ((Drawable)d).Origin == o, applyOrigins).ToArray();
}, true);
yield return new OsuMenuItemSpacer();
yield return new OsuMenuItem("Reset position", MenuItemType.Standard, () =>
{
foreach (var blueprint in SelectedBlueprints)
((Drawable)blueprint.Item).Position = Vector2.Zero;
});
yield return new OsuMenuItem("Reset rotation", MenuItemType.Standard, () =>
{
foreach (var blueprint in SelectedBlueprints)
((Drawable)blueprint.Item).Rotation = 0;
});
yield return new OsuMenuItem("Reset scale", MenuItemType.Standard, () =>
{
foreach (var blueprint in SelectedBlueprints)
{
var blueprintItem = ((Drawable)blueprint.Item);
blueprintItem.Scale = Vector2.One;
2023-11-10 13:43:51 +08:00
2024-07-02 23:19:04 +08:00
if (blueprintItem.RelativeSizeAxes.HasFlag(Axes.X))
2023-11-10 13:43:51 +08:00
blueprintItem.Width = 1;
2024-07-02 23:19:04 +08:00
if (blueprintItem.RelativeSizeAxes.HasFlag(Axes.Y))
2023-11-10 13:43:51 +08:00
blueprintItem.Height = 1;
}
});
yield return new OsuMenuItemSpacer();
yield return new OsuMenuItem("Bring to front", MenuItemType.Standard, () => skinEditor.BringSelectionToFront());
yield return new OsuMenuItem("Send to back", MenuItemType.Standard, () => skinEditor.SendSelectionToBack());
yield return new OsuMenuItemSpacer();
foreach (var item in base.GetContextMenuItemsForSelection(selection))
yield return item;
IEnumerable<TernaryStateMenuItem> createAnchorItems(Func<ISerialisableDrawable, Anchor, bool> checkFunction, Action<Anchor> applyFunction)
{
var displayableAnchors = new[]
{
Anchor.TopLeft,
Anchor.TopCentre,
Anchor.TopRight,
Anchor.CentreLeft,
Anchor.Centre,
Anchor.CentreRight,
Anchor.BottomLeft,
Anchor.BottomCentre,
Anchor.BottomRight,
};
return displayableAnchors.Select(a =>
{
return new TernaryStateRadioMenuItem(a.ToString(), MenuItemType.Standard, _ => applyFunction(a))
{
State = { Value = GetStateFromSelection(selection, c => checkFunction(c.Item, a)) }
};
});
}
}
private static void updateDrawablePosition(Drawable drawable, Vector2 screenSpacePosition)
{
drawable.Position =
drawable.Parent!.ToLocalSpace(screenSpacePosition) - drawable.AnchorPosition;
}
private void applyOrigins(Anchor origin)
{
OnOperationBegan();
foreach (var item in SelectedItems)
{
var drawable = (Drawable)item;
applyOrigin(drawable, origin);
if (!item.UsesFixedAnchor)
ApplyClosestAnchorOrigin(drawable);
}
OnOperationEnded();
}
2021-05-20 17:24:25 +08:00
/// <summary>
/// A screen-space quad surrounding all selected drawables, accounting for their full displayed size.
/// </summary>
/// <returns></returns>
private Quad getSelectionQuad() =>
GeometryUtils.GetSurroundingQuad(SelectedBlueprints.SelectMany(b => b.Item.ScreenSpaceDrawQuad.GetVertices().ToArray()));
2021-05-20 17:24:25 +08:00
private void applyFixedAnchors(Anchor anchor)
{
OnOperationBegan();
foreach (var item in SelectedItems)
{
var drawable = (Drawable)item;
item.UsesFixedAnchor = true;
applyAnchor(drawable, anchor);
}
OnOperationEnded();
}
private void applyClosestAnchors()
{
OnOperationBegan();
foreach (var item in SelectedItems)
{
item.UsesFixedAnchor = false;
ApplyClosestAnchorOrigin((Drawable)item);
}
OnOperationEnded();
}
private static Anchor getClosestAnchor(Drawable drawable)
{
var parent = drawable.Parent;
if (parent == null)
return drawable.Anchor;
var screenPosition = drawable.ToScreenSpace(drawable.OriginPosition);
2021-06-11 18:55:47 +08:00
var absolutePosition = parent.ToLocalSpace(screenPosition);
var factor = parent.RelativeToAbsoluteFactor;
var result = default(Anchor);
static Anchor getAnchorFromPosition(float xOrY, Anchor anchor0, Anchor anchor1, Anchor anchor2)
2021-06-11 18:51:12 +08:00
{
if (xOrY >= 2 / 3f)
return anchor2;
2021-06-11 18:51:12 +08:00
if (xOrY >= 1 / 3f)
return anchor1;
2021-06-11 18:51:12 +08:00
return anchor0;
2021-06-11 18:51:12 +08:00
}
result |= getAnchorFromPosition(absolutePosition.X / factor.X, Anchor.x0, Anchor.x1, Anchor.x2);
result |= getAnchorFromPosition(absolutePosition.Y / factor.Y, Anchor.y0, Anchor.y1, Anchor.y2);
return result;
}
private static void applyAnchor(Drawable drawable, Anchor anchor)
{
if (anchor == drawable.Anchor) return;
var previousAnchor = drawable.AnchorPosition;
drawable.Anchor = anchor;
drawable.Position -= drawable.AnchorPosition - previousAnchor;
}
private static void applyOrigin(Drawable drawable, Anchor screenSpaceOrigin)
{
var boundingBox = drawable.ScreenSpaceDrawQuad.AABBFloat;
var targetScreenSpacePosition = screenSpaceOrigin.PositionOnQuad(boundingBox);
Anchor localOrigin = Anchor.TopLeft;
float smallestDistanceFromTargetPosition = float.PositiveInfinity;
void checkOrigin(Anchor originToTest)
{
Vector2 positionToTest = drawable.ToScreenSpace(originToTest.PositionOnQuad(drawable.DrawRectangle));
float testedDistance = Vector2.Distance(targetScreenSpacePosition, positionToTest);
if (testedDistance < smallestDistanceFromTargetPosition)
{
localOrigin = originToTest;
smallestDistanceFromTargetPosition = testedDistance;
}
}
checkOrigin(Anchor.TopLeft);
checkOrigin(Anchor.TopCentre);
checkOrigin(Anchor.TopRight);
checkOrigin(Anchor.CentreLeft);
checkOrigin(Anchor.Centre);
checkOrigin(Anchor.CentreRight);
checkOrigin(Anchor.BottomLeft);
checkOrigin(Anchor.BottomCentre);
checkOrigin(Anchor.BottomRight);
Vector2 offset = drawable.ToParentSpace(localOrigin.PositionOnQuad(drawable.DrawRectangle)) - drawable.ToParentSpace(drawable.Origin.PositionOnQuad(drawable.DrawRectangle));
drawable.Origin = localOrigin;
drawable.Position += offset;
}
}
}