mirror of
https://github.com/ppy/osu.git
synced 2024-11-15 22:37:26 +08:00
536 lines
19 KiB
C#
536 lines
19 KiB
C#
// 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.Graphics;
|
|
using osu.Framework.Input;
|
|
using osu.Framework.Input.Events;
|
|
using osu.Framework.Utils;
|
|
using osu.Game.Rulesets.Edit;
|
|
using osu.Game.Rulesets.Objects;
|
|
using osu.Game.Rulesets.Objects.Types;
|
|
using osu.Game.Rulesets.Osu.Edit.Blueprints.HitCircles.Components;
|
|
using osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components;
|
|
using osu.Game.Rulesets.Osu.Objects;
|
|
using osu.Game.Screens.Edit;
|
|
using osuTK;
|
|
using osuTK.Input;
|
|
|
|
namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders
|
|
{
|
|
public partial class SliderPlacementBlueprint : HitObjectPlacementBlueprint
|
|
{
|
|
public new Slider HitObject => (Slider)base.HitObject;
|
|
|
|
private SliderBodyPiece bodyPiece = null!;
|
|
private HitCirclePiece headCirclePiece = null!;
|
|
private HitCirclePiece tailCirclePiece = null!;
|
|
private PathControlPointVisualiser<Slider> controlPointVisualiser = null!;
|
|
|
|
private InputManager inputManager = null!;
|
|
|
|
private PathControlPoint? cursor;
|
|
|
|
private SliderPlacementState state;
|
|
private PathControlPoint segmentStart;
|
|
|
|
private int currentSegmentLength;
|
|
private bool usingCustomSegmentType;
|
|
|
|
[Resolved]
|
|
private IPositionSnapProvider? positionSnapProvider { get; set; }
|
|
|
|
[Resolved]
|
|
private IDistanceSnapProvider? distanceSnapProvider { get; set; }
|
|
|
|
[Resolved]
|
|
private FreehandSliderToolboxGroup? freehandToolboxGroup { get; set; }
|
|
|
|
private readonly IncrementalBSplineBuilder bSplineBuilder = new IncrementalBSplineBuilder { Degree = 4 };
|
|
|
|
protected override bool IsValidForPlacement => HitObject.Path.HasValidLength;
|
|
|
|
public SliderPlacementBlueprint()
|
|
: base(new Slider())
|
|
{
|
|
RelativeSizeAxes = Axes.Both;
|
|
|
|
HitObject.Path.ControlPoints.Add(segmentStart = new PathControlPoint(Vector2.Zero, PathType.LINEAR));
|
|
currentSegmentLength = 1;
|
|
}
|
|
|
|
[BackgroundDependencyLoader]
|
|
private void load()
|
|
{
|
|
InternalChildren = new Drawable[]
|
|
{
|
|
bodyPiece = new SliderBodyPiece(),
|
|
headCirclePiece = new HitCirclePiece(),
|
|
tailCirclePiece = new HitCirclePiece(),
|
|
controlPointVisualiser = new PathControlPointVisualiser<Slider>(HitObject, false)
|
|
};
|
|
|
|
state = SliderPlacementState.Initial;
|
|
}
|
|
|
|
protected override void LoadComplete()
|
|
{
|
|
base.LoadComplete();
|
|
|
|
inputManager = GetContainingInputManager()!;
|
|
|
|
if (freehandToolboxGroup != null)
|
|
{
|
|
freehandToolboxGroup.Tolerance.BindValueChanged(e =>
|
|
{
|
|
bSplineBuilder.Tolerance = e.NewValue;
|
|
Scheduler.AddOnce(updateSliderPathFromBSplineBuilder);
|
|
}, true);
|
|
|
|
freehandToolboxGroup.CornerThreshold.BindValueChanged(e =>
|
|
{
|
|
bSplineBuilder.CornerThreshold = e.NewValue;
|
|
Scheduler.AddOnce(updateSliderPathFromBSplineBuilder);
|
|
}, true);
|
|
|
|
freehandToolboxGroup.CircleThreshold.BindValueChanged(e =>
|
|
{
|
|
Scheduler.AddOnce(updateSliderPathFromBSplineBuilder);
|
|
}, true);
|
|
}
|
|
}
|
|
|
|
[Resolved]
|
|
private EditorBeatmap editorBeatmap { get; set; } = null!;
|
|
|
|
public override void UpdateTimeAndPosition(SnapResult result)
|
|
{
|
|
base.UpdateTimeAndPosition(result);
|
|
|
|
switch (state)
|
|
{
|
|
case SliderPlacementState.Initial:
|
|
BeginPlacement();
|
|
|
|
double? nearestSliderVelocity = (editorBeatmap
|
|
.HitObjects
|
|
.LastOrDefault(h => h is Slider && h.GetEndTime() < HitObject.StartTime) as Slider)?.SliderVelocityMultiplier;
|
|
|
|
HitObject.SliderVelocityMultiplier = nearestSliderVelocity ?? 1;
|
|
HitObject.Position = ToLocalSpace(result.ScreenSpacePosition);
|
|
|
|
// Replacing the DifficultyControlPoint above doesn't trigger any kind of invalidation.
|
|
// Without re-applying defaults, velocity won't be updated.
|
|
ApplyDefaultsToHitObject();
|
|
break;
|
|
|
|
case SliderPlacementState.ControlPoints:
|
|
updateCursor();
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected override bool OnMouseDown(MouseDownEvent e)
|
|
{
|
|
if (e.Button != MouseButton.Left)
|
|
return base.OnMouseDown(e);
|
|
|
|
switch (state)
|
|
{
|
|
case SliderPlacementState.Initial:
|
|
beginCurve();
|
|
break;
|
|
|
|
case SliderPlacementState.ControlPoints:
|
|
if (canPlaceNewControlPoint(out var lastPoint))
|
|
placeNewControlPoint();
|
|
else if (lastPoint != null)
|
|
beginNewSegment(lastPoint);
|
|
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private void beginNewSegment(PathControlPoint lastPoint)
|
|
{
|
|
segmentStart = lastPoint;
|
|
segmentStart.Type = PathType.LINEAR;
|
|
|
|
currentSegmentLength = 1;
|
|
usingCustomSegmentType = false;
|
|
}
|
|
|
|
protected override bool OnDragStart(DragStartEvent e)
|
|
{
|
|
if (e.Button != MouseButton.Left)
|
|
return base.OnDragStart(e);
|
|
|
|
if (state != SliderPlacementState.ControlPoints)
|
|
return base.OnDragStart(e);
|
|
|
|
// Only enter drawing mode if no additional control points have been placed.
|
|
int controlPointCount = HitObject.Path.ControlPoints.Count;
|
|
if (controlPointCount > 2 || (controlPointCount == 2 && HitObject.Path.ControlPoints.Last() != cursor))
|
|
return base.OnDragStart(e);
|
|
|
|
bSplineBuilder.AddLinearPoint(Vector2.Zero);
|
|
bSplineBuilder.AddLinearPoint(ToLocalSpace(e.ScreenSpaceMouseDownPosition) - HitObject.Position);
|
|
state = SliderPlacementState.Drawing;
|
|
return true;
|
|
}
|
|
|
|
protected override void OnDrag(DragEvent e)
|
|
{
|
|
base.OnDrag(e);
|
|
|
|
if (state == SliderPlacementState.Drawing)
|
|
{
|
|
bSplineBuilder.AddLinearPoint(ToLocalSpace(e.ScreenSpaceMousePosition) - HitObject.Position);
|
|
Scheduler.AddOnce(updateSliderPathFromBSplineBuilder);
|
|
}
|
|
}
|
|
|
|
protected override void OnDragEnd(DragEndEvent e)
|
|
{
|
|
base.OnDragEnd(e);
|
|
|
|
if (state == SliderPlacementState.Drawing)
|
|
{
|
|
bSplineBuilder.Finish();
|
|
updateSliderPathFromBSplineBuilder();
|
|
|
|
// Change the state so it will snap the expected distance in endCurve.
|
|
state = SliderPlacementState.Finishing;
|
|
endCurve();
|
|
}
|
|
}
|
|
|
|
protected override void OnMouseUp(MouseUpEvent e)
|
|
{
|
|
if (state == SliderPlacementState.ControlPoints && e.Button == MouseButton.Right)
|
|
endCurve();
|
|
base.OnMouseUp(e);
|
|
}
|
|
|
|
private static readonly PathType[] path_types =
|
|
[
|
|
PathType.LINEAR,
|
|
PathType.BEZIER,
|
|
PathType.PERFECT_CURVE,
|
|
PathType.BSpline(4),
|
|
];
|
|
|
|
protected override bool OnKeyDown(KeyDownEvent e)
|
|
{
|
|
if (e.Repeat)
|
|
return false;
|
|
|
|
if (state != SliderPlacementState.ControlPoints)
|
|
return false;
|
|
|
|
switch (e.Key)
|
|
{
|
|
case Key.S:
|
|
{
|
|
if (!canPlaceNewControlPoint(out _))
|
|
return false;
|
|
|
|
placeNewControlPoint();
|
|
var last = HitObject.Path.ControlPoints.Last(p => p != cursor);
|
|
beginNewSegment(last);
|
|
return true;
|
|
}
|
|
|
|
case Key.Number1:
|
|
case Key.Number2:
|
|
case Key.Number3:
|
|
case Key.Number4:
|
|
{
|
|
if (!e.AltPressed)
|
|
return false;
|
|
|
|
usingCustomSegmentType = true;
|
|
segmentStart.Type = path_types[e.Key - Key.Number1];
|
|
controlPointVisualiser.EnsureValidPathTypes();
|
|
return true;
|
|
}
|
|
|
|
case Key.Tab:
|
|
{
|
|
usingCustomSegmentType = true;
|
|
|
|
int currentTypeIndex = segmentStart.Type.HasValue ? Array.IndexOf(path_types, segmentStart.Type.Value) : -1;
|
|
|
|
if (currentTypeIndex < 0 && e.ShiftPressed)
|
|
currentTypeIndex = 0;
|
|
|
|
do
|
|
{
|
|
currentTypeIndex = (path_types.Length + currentTypeIndex + (e.ShiftPressed ? -1 : 1)) % path_types.Length;
|
|
segmentStart.Type = path_types[currentTypeIndex];
|
|
controlPointVisualiser.EnsureValidPathTypes();
|
|
} while (segmentStart.Type != path_types[currentTypeIndex]);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
protected override void Update()
|
|
{
|
|
base.Update();
|
|
updateSlider();
|
|
|
|
// Maintain the path type in case it got defaulted to bezier at some point during the drag.
|
|
updatePathType();
|
|
}
|
|
|
|
private void beginCurve()
|
|
{
|
|
BeginPlacement(commitStart: true);
|
|
state = SliderPlacementState.ControlPoints;
|
|
}
|
|
|
|
private void endCurve()
|
|
{
|
|
updateSlider();
|
|
EndPlacement(true);
|
|
}
|
|
|
|
private void updatePathType()
|
|
{
|
|
if (usingCustomSegmentType)
|
|
{
|
|
controlPointVisualiser.EnsureValidPathTypes();
|
|
return;
|
|
}
|
|
|
|
if (state == SliderPlacementState.Drawing)
|
|
{
|
|
segmentStart.Type = PathType.BSpline(4);
|
|
return;
|
|
}
|
|
|
|
switch (currentSegmentLength)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
segmentStart.Type = PathType.LINEAR;
|
|
break;
|
|
|
|
case 3:
|
|
segmentStart.Type = PathType.PERFECT_CURVE;
|
|
break;
|
|
|
|
default:
|
|
segmentStart.Type = PathType.BEZIER;
|
|
break;
|
|
}
|
|
|
|
controlPointVisualiser.EnsureValidPathTypes();
|
|
}
|
|
|
|
private void updateCursor()
|
|
{
|
|
if (canPlaceNewControlPoint(out _))
|
|
{
|
|
// The cursor does not overlap a previous control point, so it can be added if not already existing.
|
|
if (cursor == null)
|
|
{
|
|
HitObject.Path.ControlPoints.Add(cursor = new PathControlPoint { Position = Vector2.Zero });
|
|
|
|
// The path type should be adjusted in the progression of updatePathType() (LINEAR -> PC -> BEZIER).
|
|
currentSegmentLength++;
|
|
updatePathType();
|
|
}
|
|
|
|
// Update the cursor position.
|
|
cursor.Position = getCursorPosition();
|
|
}
|
|
else if (cursor != null)
|
|
{
|
|
// The cursor overlaps a previous control point, so it's removed.
|
|
HitObject.Path.ControlPoints.Remove(cursor);
|
|
cursor = null;
|
|
|
|
// The path type should be adjusted in the reverse progression of updatePathType() (BEZIER -> PC -> LINEAR).
|
|
currentSegmentLength--;
|
|
updatePathType();
|
|
}
|
|
}
|
|
|
|
private Vector2 getCursorPosition()
|
|
{
|
|
var result = positionSnapProvider?.FindSnappedPositionAndTime(inputManager.CurrentState.Mouse.Position, state == SliderPlacementState.ControlPoints ? SnapType.GlobalGrids : SnapType.All);
|
|
return ToLocalSpace(result?.ScreenSpacePosition ?? inputManager.CurrentState.Mouse.Position) - HitObject.Position;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Whether a new control point can be placed at the current mouse position.
|
|
/// </summary>
|
|
/// <param name="lastPoint">The last-placed control point. May be null, but is not null if <c>false</c> is returned.</param>
|
|
/// <returns>Whether a new control point can be placed at the current position.</returns>
|
|
private bool canPlaceNewControlPoint(out PathControlPoint? lastPoint)
|
|
{
|
|
// We cannot rely on the ordering of drawable pieces, so find the respective drawable piece by searching for the last non-cursor control point.
|
|
var last = HitObject.Path.ControlPoints.LastOrDefault(p => p != cursor);
|
|
var lastPiece = controlPointVisualiser.Pieces.Single(p => p.ControlPoint == last);
|
|
|
|
lastPoint = last;
|
|
// We may only place a new control point if the cursor is not overlapping with the last control point.
|
|
// If snapping is enabled, the cursor may not hover the last piece while still placing the control point at the same position.
|
|
return !lastPiece.IsHovered && (last is null || Vector2.DistanceSquared(last.Position, getCursorPosition()) > 1f);
|
|
}
|
|
|
|
private void placeNewControlPoint()
|
|
{
|
|
// Place a new point by detatching the current cursor.
|
|
updateCursor();
|
|
cursor = null;
|
|
}
|
|
|
|
private void updateSlider()
|
|
{
|
|
if (state == SliderPlacementState.Drawing)
|
|
HitObject.Path.ExpectedDistance.Value = (float)HitObject.Path.CalculatedDistance;
|
|
else
|
|
HitObject.Path.ExpectedDistance.Value = distanceSnapProvider?.FindSnappedDistance(HitObject, (float)HitObject.Path.CalculatedDistance, DistanceSnapTarget.Start) ?? (float)HitObject.Path.CalculatedDistance;
|
|
|
|
bodyPiece.UpdateFrom(HitObject);
|
|
headCirclePiece.UpdateFrom(HitObject.HeadCircle);
|
|
tailCirclePiece.UpdateFrom(HitObject.TailCircle);
|
|
}
|
|
|
|
private void updateSliderPathFromBSplineBuilder()
|
|
{
|
|
IReadOnlyList<List<Vector2>> builderPoints = bSplineBuilder.ControlPoints;
|
|
|
|
if (builderPoints.Count == 0 || builderPoints[0].Count == 0)
|
|
return;
|
|
|
|
HitObject.Path.ControlPoints.Clear();
|
|
|
|
// Iterate through generated segments and adding non-inheriting path types where appropriate.
|
|
for (int i = 0; i < builderPoints.Count; i++)
|
|
{
|
|
bool isLastSegment = i == builderPoints.Count - 1;
|
|
var segment = builderPoints[i];
|
|
|
|
if (segment.Count == 0)
|
|
continue;
|
|
|
|
// Replace this segment with a circular arc if it is a reasonable substitute.
|
|
var circleArcSegment = tryCircleArc(segment);
|
|
|
|
if (circleArcSegment != null)
|
|
{
|
|
HitObject.Path.ControlPoints.Add(new PathControlPoint(circleArcSegment[0], PathType.PERFECT_CURVE));
|
|
HitObject.Path.ControlPoints.Add(new PathControlPoint(circleArcSegment[1]));
|
|
}
|
|
else
|
|
{
|
|
HitObject.Path.ControlPoints.Add(new PathControlPoint(segment[0], PathType.BSpline(4)));
|
|
for (int j = 1; j < segment.Count - 1; j++)
|
|
HitObject.Path.ControlPoints.Add(new PathControlPoint(segment[j]));
|
|
}
|
|
|
|
if (isLastSegment)
|
|
HitObject.Path.ControlPoints.Add(new PathControlPoint(segment[^1]));
|
|
}
|
|
}
|
|
|
|
private Vector2[]? tryCircleArc(List<Vector2> segment)
|
|
{
|
|
if (segment.Count < 3 || freehandToolboxGroup?.CircleThreshold.Value == 0) return null;
|
|
|
|
// Assume the segment creates a reasonable circular arc and then check if it reasonable
|
|
var points = PathApproximator.BSplineToPiecewiseLinear(segment.ToArray(), bSplineBuilder.Degree);
|
|
var circleArcControlPoints = new[] { points[0], points[points.Count / 2], points[^1] };
|
|
var circleArc = new CircularArcProperties(circleArcControlPoints);
|
|
|
|
if (!circleArc.IsValid) return null;
|
|
|
|
double length = circleArc.ThetaRange * circleArc.Radius;
|
|
|
|
if (length > 1000) return null;
|
|
|
|
double loss = 0;
|
|
Vector2? lastPoint = null;
|
|
Vector2? lastVec = null;
|
|
Vector2? lastVec2 = null;
|
|
int? lastDir = null;
|
|
int? lastDir2 = null;
|
|
double totalWinding = 0;
|
|
|
|
// Loop through the points and check if they are not too far away from the circular arc.
|
|
// Also make sure it curves monotonically in one direction and at most one loop is done.
|
|
foreach (var point in points)
|
|
{
|
|
var vec = point - circleArc.Centre;
|
|
loss += Math.Pow((vec.Length - circleArc.Radius) / length, 2);
|
|
|
|
if (lastVec.HasValue)
|
|
{
|
|
double det = lastVec.Value.X * vec.Y - lastVec.Value.Y * vec.X;
|
|
int dir = Math.Sign(det);
|
|
|
|
if (dir == 0)
|
|
continue;
|
|
|
|
if (lastDir.HasValue && dir != lastDir)
|
|
return null; // Circle center is not inside the polygon
|
|
|
|
lastDir = dir;
|
|
}
|
|
|
|
lastVec = vec;
|
|
|
|
if (lastPoint.HasValue)
|
|
{
|
|
var vec2 = point - lastPoint.Value;
|
|
|
|
if (lastVec2.HasValue)
|
|
{
|
|
double dot = Vector2.Dot(vec2, lastVec2.Value);
|
|
double det = lastVec2.Value.X * vec2.Y - lastVec2.Value.Y * vec2.X;
|
|
double angle = Math.Atan2(det, dot);
|
|
int dir2 = Math.Sign(angle);
|
|
|
|
if (dir2 == 0)
|
|
continue;
|
|
|
|
if (lastDir2.HasValue && dir2 != lastDir2)
|
|
return null; // Curvature changed, like in an S-shape
|
|
|
|
totalWinding += Math.Abs(angle);
|
|
lastDir2 = dir2;
|
|
}
|
|
|
|
lastVec2 = vec2;
|
|
}
|
|
|
|
lastPoint = point;
|
|
}
|
|
|
|
loss /= points.Count;
|
|
|
|
return loss > freehandToolboxGroup?.CircleThreshold.Value || totalWinding > MathHelper.TwoPi ? null : circleArcControlPoints;
|
|
}
|
|
|
|
private enum SliderPlacementState
|
|
{
|
|
Initial,
|
|
ControlPoints,
|
|
Drawing,
|
|
Finishing
|
|
}
|
|
}
|
|
}
|