h1or4dme8/osu-lazer
1
0
Fork 0
mirror of https://github.com/ppy/osu.git synced 2025-02-13 11:12:54 +08:00
Code Issues Releases Wiki Activity

Add bounding box limit

Browse Source
This commit is contained in:
Naxess 2021-03-24 17:25:28 +01:00
parent 0f4314c1d8
commit 9df059b01d
1 changed files with 90 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
osu.Game.Rulesets.Osu/Edit/Blueprints/Sliders/Components/PathControlPointVisualiser.cs
View File

@ -11,6 +11,7 @@ using osu.Framework.Bindables;
using osu.Framework.Graphics;
using osu.Framework.Graphics.Containers;
using osu.Framework.Graphics.Cursor;
using osu.Framework.Graphics.Primitives;
using osu.Framework.Graphics.UserInterface;
using osu.Framework.Input;
using osu.Framework.Input.Bindings;
@ -165,11 +166,26 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
/// <summary>
/// Returns whether the given points are arranged in a valid way. Invalid if points
/// are almost entirely linear - as this causes the radius to approach infinity,
/// which would exhaust memory when drawing / approximating.
/// or if the bounding box of the arc is too large.
/// </summary>
/// <param name="points">The three points that make up this circular arc segment.</param>
/// <returns></returns>
private bool validCircularArcSegment(IReadOnlyList<Vector2> points)
{
float det = circularArcDeterminant(points);
RectangleF boundingBox = circularArcBoundingBox(points);
// Determinant limit prevents memory exhaustion as a result of approximating the subpath.
// Bounding box area limit prevents memory exhaustion as a result of drawing the texture.
return Math.Abs(det) > 0.001f && boundingBox.Area < 640 * 480;
}
/// <summary>
/// Computes the determinant of the circular arc segment defined by the given points.
/// </summary>
/// <param name="points">The three points defining the circular arc.</param>
/// <returns></returns>
private float circularArcDeterminant(IReadOnlyList<Vector2> points)
{
Vector2 a = points[0];
Vector2 b = points[1];
@ -181,19 +197,82 @@ namespace osu.Game.Rulesets.Osu.Edit.Blueprints.Sliders.Components
Vector2 normB = new Vector2(b.X / maxLength, b.Y / maxLength);
Vector2 normC = new Vector2(c.X / maxLength, c.Y / maxLength);
float det = (normA.X - normB.X) * (normB.Y - normC.Y) - (normB.X - normC.X) * (normA.Y - normB.Y);
return (normA.X - normB.X) * (normB.Y - normC.Y) - (normB.X - normC.X) * (normA.Y - normB.Y);
}
float acSq = (a - c).LengthSquared;
float abSq = (a - b).LengthSquared;
float bcSq = (b - c).LengthSquared;
/// <summary>
/// Computes the bounding box of the circular arc segment defined by the given points.
/// </summary>
/// <param name="points">The three points defining the circular arc.</param>
/// <returns></returns>
private RectangleF circularArcBoundingBox(IReadOnlyList<Vector2> points)
{
Vector2 a = points[0];
Vector2 b = points[1];
Vector2 c = points[2];
// Exterior = curve wraps around the long way between end-points
// Exterior bottleneck is drawing-related, interior bottleneck is approximation-related,
// where the latter is much faster, hence differing thresholds
bool exterior = abSq > acSq || bcSq > acSq;
float threshold = exterior ? 0.35f : 0.001f;
// See: https://en.wikipedia.org/wiki/Circumscribed_circle#Cartesian_coordinates_2
float d = 2 * (a.X * (b - c).Y + b.X * (c - a).Y + c.X * (a - b).Y);
float aSq = a.LengthSquared;
float bSq = b.LengthSquared;
float cSq = c.LengthSquared;
return Math.Abs(det) >= threshold;
Vector2 center = new Vector2(
aSq * (b - c).Y + bSq * (c - a).Y + cSq * (a - b).Y,
aSq * (c - b).X + bSq * (a - c).X + cSq * (b - a).X) / d;
Vector2 dA = a - center;
Vector2 dC = c - center;
float r = dA.Length;
double thetaStart = Math.Atan2(dA.Y, dA.X);
double thetaEnd = Math.Atan2(dC.Y, dC.X);
while (thetaEnd < thetaStart)
thetaEnd += 2 * Math.PI;
// Decide in which direction to draw the circle, depending on which side of
// AC B lies.
Vector2 orthoAtoC = c - a;
orthoAtoC = new Vector2(orthoAtoC.Y, -orthoAtoC.X);
bool clockwise = Vector2.Dot(orthoAtoC, b - a) >= 0;
if (clockwise)
{
if (thetaEnd < thetaStart)
thetaEnd += Math.PI * 2;
}
else
{
if (thetaStart < thetaEnd)
thetaStart += Math.PI * 2;
}
List<Vector2> boundingBoxPoints = new List<Vector2>(points);
bool includes0Degrees = 0 > thetaStart && 0 < thetaEnd;
bool includes90Degrees = Math.PI / 2 > thetaStart && Math.PI / 2 < thetaEnd;
bool includes180Degrees = Math.PI > thetaStart && Math.PI < thetaEnd;
bool includes270Degrees = Math.PI * 1.5f > thetaStart && Math.PI * 1.5f < thetaEnd;
if (!clockwise)
{
includes0Degrees = 0 < thetaStart && 0 > thetaEnd;
includes90Degrees = Math.PI / 2 < thetaStart && Math.PI / 2 > thetaEnd;
includes180Degrees = Math.PI < thetaStart && Math.PI > thetaEnd;
includes270Degrees = Math.PI * 1.5f < thetaStart && Math.PI * 1.5f > thetaEnd;
}
if (includes0Degrees) boundingBoxPoints.Add(center + new Vector2(1, 0) * r);
if (includes90Degrees) boundingBoxPoints.Add(center + new Vector2(0, 1) * r);
if (includes180Degrees) boundingBoxPoints.Add(center + new Vector2(-1, 0) * r);
if (includes270Degrees) boundingBoxPoints.Add(center + new Vector2(0, -1) * r);
float width = Math.Abs(boundingBoxPoints.Max(p => p.X) - boundingBoxPoints.Min(p => p.X));
float height = Math.Abs(boundingBoxPoints.Max(p => p.Y) - boundingBoxPoints.Min(p => p.Y));
return new RectangleF(slider.Position, new Vector2(width, height));
}
private void selectPiece(PathControlPointPiece piece, MouseButtonEvent e)