public void DeferredUpdate()
{
lock (this)
{
if (!_dirty)
{
return;
}
_dirty = false;
}
FromMatrix = MatrixD.CreateWorld(From.Position, CorrectTangent(From.Tangent), From.Up);
ToMatrix = MatrixD.CreateWorld(To.Position, CorrectTangent(To.Tangent), To.Up);
var ext = Math.Max((FromMatrix.Translation - ToMatrix.Translation).Length() / 3, 1f);
var d1 = default(Vector3D);
var d2 = default(Vector3D);
if (Mode != CurveMode.Linear)
{
if (_ctl0.HasValue)
{
d1 = Vector3D.Transform(_ctl0.Value, FromMatrix);
}
else
{
d1 = FromMatrix.Translation + (FromMatrix.Forward * ext);
}
if (_ctl1.HasValue)
{
d2 = Vector3D.Transform(_ctl1.Value, ToMatrix);
}
else
{
d2 = ToMatrix.Translation - (ToMatrix.Forward * ext);
}
}
switch (Mode)
{
case CurveMode.Linear:
Curve = new LinearCurve(From.Position, To.Position);
break;
case CurveMode.QuadraticBez:
Curve = new QuadraticCurve(FromMatrix.Translation, (d1 + d2) / 2, ToMatrix.Translation);
break;
case CurveMode.CubicBez:
Curve = new CubicCurve(FromMatrix.Translation, d1, d2, ToMatrix.Translation);
break;
default:
throw new Exception($"Unsupported curve mode {Mode}");
}
CurveUpdated?.Invoke(this);
}
public Vector3 Evaluate(float t)
{
t = Mathf.Clamp01(t);
Vector3 quadratic1 = QuadraticCurve.Evaluate(p1, pivot1, p2, t);
Vector3 quadratic2 = QuadraticCurve.Evaluate(pivot1, p2, pivot2, t);
return(Vector3.Lerp(quadratic1, quadratic2, t));
}
void Update()
{
if (p1 != null && p2 != null && pivot != null)
{
if (curve == null)
{
curve = new QuadraticCurve(p1.position, p2.position, pivot.position, splinePointCount);
}
UpdateCurve();
curve.Draw();
}
}
public void Initialize(NotesUI owner, RectTransform rectParent, QuadraticCurve curve, int input)
{
if (indicatorUI == null)
{
indicatorUI = Instantiate(owner.noteIndicatorPrefab, rectParent);
}
// Colocamos el indicador segun nos indique la curva
float scale = rectParent.rect.height * 2;
indicatorUI.Initialize(curve.FromPoint * scale, this.color, input);
// Hacemos que la curva empiece desde el punto 0 para que sea relativo al indicador
// y tratamos de conseguir un camino para las notas
curve.FromPoint = Vector2.zero;
curvePath.UpdateCurve(curve, curveSpacing, curveResolution, scale);
}
/// <summary>
/// Approximate a cubic Bezier with a single quadratic within a given tolerance.
/// </summary>
/// <param name="controlPoints">Four complex numbers representing control points of the cubic Bezier curve.</param>
/// <param name="maxError">Permitted deviation from the original curve.</param>
/// <param name="quadraticCurve">Three complex numbers representing control points of the quadratic
/// curve if it fits within the given tolerance, or null if no suitable
/// curve could be calculated.</param>
/// <returns>True if the curve could be converted, else false</returns>
private static bool CubicApproximateQuadratic(CubicCurve controlPoints, float maxError, out QuadraticCurve quadraticCurve)
{
if (!TryCalculateIntersection(controlPoints.Point0, controlPoints.Point1, controlPoints.Point2, controlPoints.Point3, out var q1))
{
return(false);
}
var c0 = controlPoints.Point0;
var c3 = controlPoints.Point3;
var c1 = c0 + (q1 - c0) * TwoOverThree;
var c2 = c3 + (q1 - c3) * TwoOverThree;
if (CubicFarthestFitsInside(0, c1 - controlPoints.Point1, c2 - controlPoints.Point2, 0, maxError))
{
return(false);
}
quadraticCurve = new QuadraticCurve(c0, q1, c3);
return(true);
}
public static List <Base> ToPathList(this string pathDataText)
{
pathDataText = pathDataText.Trim();
var strings = new List <string>();
int start = 0;
for (int i = 1; i <= pathDataText.Length; i++)
{
if (i == pathDataText.Length || (char.ToLower(pathDataText[i]) != 'e' && char.IsLetter(pathDataText[i])))
{
strings.Add(pathDataText.Substring(start, i - start));
start = i;
}
}
var result = new List <PathElement.Base>();
foreach (var str in strings)
{
if (string.IsNullOrWhiteSpace(str))
{
continue;
}
var cmd = char.ToUpper(str[0]);
switch (cmd)
{
case Arc.Symbol:
if (Arc.FromString(str) is List <Arc> arcList)
{
result.AddRange(arcList);
}
break;
case BezierCurve.Symbol:
if (BezierCurve.FromString(str) is List <BezierCurve> bezierCurveList)
{
result.AddRange(bezierCurveList);
}
break;
case ClosePath.Symbol:
result.Add(new ClosePath());
break;
case HorzLineTo.Symbol:
if (HorzLineTo.FromString(str) is HorzLineTo horzLineTo)
{
result.Add(horzLineTo);
}
break;
case LineTo.Symbol:
if (LineTo.FromString(str) is List <LineTo> lineList)
{
result.AddRange(lineList);
}
break;
case MoveTo.Symbol:
if (MoveTo.FromString(str) is List <Base> moveAndLineList)
{
result.AddRange(moveAndLineList);
}
break;
case QuadraticCurve.Symbol:
if (QuadraticCurve.FromString(str) is List <QuadraticCurve> quadraticCurveList)
{
result.AddRange(quadraticCurveList);
}
break;
case ShortcutBezierCurve.Symbol:
if (ShortcutBezierCurve.FromString(str) is List <ShortcutBezierCurve> shortcutBezierCurveList)
{
result.AddRange(shortcutBezierCurveList);
}
break;
case ShortcutQuadraticCurve.Symbol:
if (ShortcutQuadraticCurve.FromString(str) is List <ShortcutQuadraticCurve> shortcutQuadraticCurveList)
{
result.AddRange(shortcutQuadraticCurveList);
}
break;
case VertLineTo.Symbol:
if (VertLineTo.FromString(str) is VertLineTo vertLineTo)
{
result.Add(vertLineTo);
}
break;
default:
throw new Exception("Unrecognized Path Command : " + str);
}
}
return(result);
}
