1000 lines
44 KiB
C#
1000 lines
44 KiB
C#
using System;
|
|
using UnityEngine;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Unity.Mathematics;
|
|
using UnityEditor.EditorTools;
|
|
using UnityEditor.SettingsManagement;
|
|
using UnityEngine.Splines;
|
|
using Object = UnityEngine.Object;
|
|
|
|
namespace UnityEditor.Splines
|
|
{
|
|
struct SplineCurveHit
|
|
{
|
|
public float T;
|
|
public float3 Normal;
|
|
public float3 Position;
|
|
public SelectableKnot PreviousKnot;
|
|
public SelectableKnot NextKnot;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Editor utility functions for working with <see cref="Spline"/> and <see cref="SplineData{T}"/>.
|
|
/// </summary>
|
|
public static class EditorSplineUtility
|
|
{
|
|
/// <summary>
|
|
/// Invoked once per-frame if a spline property has been modified.
|
|
/// </summary>
|
|
[Obsolete("Use AfterSplineWasModified instead.", false)]
|
|
public static event Action<Spline> afterSplineWasModified;
|
|
|
|
/// <summary>
|
|
/// Invoked once per-frame if a spline property has been modified.
|
|
/// </summary>
|
|
public static event Action<Spline> AfterSplineWasModified;
|
|
|
|
static readonly List<SplineInfo> s_SplinePtrBuffer = new List<SplineInfo>(16);
|
|
|
|
internal static event Action<SelectableKnot> knotInserted;
|
|
internal static event Action<SelectableKnot> knotRemoved;
|
|
|
|
static readonly List<ISelectableElement> s_ElementBuffer = new List<ISelectableElement>();
|
|
|
|
[UserSetting]
|
|
internal static Pref<TangentMode> s_DefaultTangentMode = new("Splines.DefaultTangentMode", TangentMode.AutoSmooth);
|
|
|
|
/// <summary>
|
|
/// Represents the default TangentMode used to place or insert knots. If the user does not define tangent
|
|
/// handles, then the tangent takes the default TangentMode.
|
|
/// </summary>
|
|
public static TangentMode DefaultTangentMode => s_DefaultTangentMode;
|
|
|
|
static EditorSplineUtility()
|
|
{
|
|
Spline.afterSplineWasModified += (spline) =>
|
|
{
|
|
afterSplineWasModified?.Invoke(spline);
|
|
AfterSplineWasModified?.Invoke(spline);
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// Use this function to register a callback that gets invoked
|
|
/// once per-frame if any <see cref="SplineData{T}"/> changes occur.
|
|
/// </summary>
|
|
/// <param name="action">The callback to register.</param>
|
|
/// <typeparam name="T">
|
|
/// The type parameter of <see cref="SplineData{T}"/>.
|
|
/// </typeparam>
|
|
public static void RegisterSplineDataChanged<T>(Action<SplineData<T>> action)
|
|
{
|
|
SplineData<T>.afterSplineDataWasModified += action;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Use this function to unregister <see cref="SplineData{T}"/> change callback.
|
|
/// </summary>
|
|
/// <param name="action">The callback to unregister.</param>
|
|
/// <typeparam name="T">
|
|
/// The type parameter of <see cref="SplineData{T}"/>.
|
|
/// </typeparam>
|
|
public static void UnregisterSplineDataChanged<T>(Action<SplineData<T>> action)
|
|
{
|
|
SplineData<T>.afterSplineDataWasModified -= action;
|
|
}
|
|
|
|
internal static IReadOnlyList<SplineInfo> GetSplinesFromTargetsInternal(IEnumerable<Object> targets)
|
|
{
|
|
GetSplinesFromTargets(targets, s_SplinePtrBuffer);
|
|
return s_SplinePtrBuffer;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a <see cref="SplineInfo"/> representation of the splines in a list of targets.
|
|
/// </summary>
|
|
/// <param name="targets">A list of Objects inheriting from <see cref="ISplineContainer"/>.</param>
|
|
/// <returns>An array to store the <see cref="SplineInfo"/> of splines found in the targets.</returns>
|
|
internal static SplineInfo[] GetSplinesFromTargets(IEnumerable<Object> targets)
|
|
{
|
|
return GetSplinesFromTargetsInternal(targets).ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a <see cref="SplineInfo"/> representation of the splines in a list of targets.
|
|
/// </summary>
|
|
/// <param name="targets">A list of Objects inheriting from <see cref="ISplineContainer"/>.</param>
|
|
/// <param name="results">A list to store the <see cref="SplineInfo"/> of splines found in the targets.</param>
|
|
internal static void GetSplinesFromTargets(IEnumerable<Object> targets, List<SplineInfo> results)
|
|
{
|
|
results.Clear();
|
|
foreach (var target in targets)
|
|
GetSplineInfosFromContainer(target, results);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a <see cref="SplineInfo"/> representation of the splines in a target.
|
|
/// </summary>
|
|
/// <param name="target">An Object inheriting from <see cref="ISplineContainer"/>.</param>
|
|
/// <param name="results">A list to store the <see cref="SplineInfo"/> of splines found in the targets.</param>
|
|
internal static void GetSplinesFromTarget(Object target, List<SplineInfo> results)
|
|
{
|
|
results.Clear();
|
|
GetSplineInfosFromContainer(target, results);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a <see cref="SplineInfo"/> representation of the splines in a target.
|
|
/// </summary>
|
|
/// <param name="target">An Object inheriting from <see cref="ISplineContainer"/>.</param>
|
|
/// <param name="results">A list to store the <see cref="SplineInfo"/> of splines found in the targets.</param>
|
|
/// <returns>True if a at least a spline was found in the target.</returns>
|
|
internal static bool TryGetSplinesFromTarget(Object target, List<SplineInfo> results)
|
|
{
|
|
results.Clear();
|
|
GetSplineInfosFromContainer(target, results);
|
|
return results.Count > 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a <see cref="SplineInfo"/> representation of the splines in a target.
|
|
/// </summary>
|
|
/// <param name="target">An Object inheriting from <see cref="ISplineContainer"/>.</param>
|
|
/// <returns>An array to store the <see cref="SplineInfo"/> of splines found in the target.</returns>
|
|
internal static SplineInfo[] GetSplinesFromTarget(Object target)
|
|
{
|
|
GetSplinesFromTarget(target, s_SplinePtrBuffer);
|
|
return s_SplinePtrBuffer.ToArray();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a <see cref="SplineInfo"/> representation of the first spline found in the target.
|
|
/// </summary>
|
|
/// <param name="target">An Object inheriting from <see cref="ISplineContainer"/>.</param>
|
|
/// <param name="splineInfo">The <see cref="SplineInfo"/> of the first spline found in the target.</param>
|
|
/// <returns>True if a spline was found in the target.</returns>
|
|
internal static bool TryGetSplineFromTarget(Object target, out SplineInfo splineInfo)
|
|
{
|
|
GetSplinesFromTarget(target, s_SplinePtrBuffer);
|
|
if (s_SplinePtrBuffer.Count > 0)
|
|
{
|
|
splineInfo = s_SplinePtrBuffer[0];
|
|
return true;
|
|
}
|
|
|
|
splineInfo = default;
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the current active context to the <see cref="SplineToolContext"/> and the current active tool to the
|
|
/// Draw Splines Tool (<see cref="KnotPlacementTool"/>)
|
|
/// </summary>
|
|
public static void SetKnotPlacementTool()
|
|
{
|
|
if(ToolManager.activeContextType != typeof(SplineToolContext))
|
|
{
|
|
ToolManager.SetActiveContext<SplineToolContext>();
|
|
ToolManager.SetActiveTool<KnotPlacementTool>();
|
|
}
|
|
else if(ToolManager.activeToolType != typeof(KnotPlacementTool))
|
|
{
|
|
ToolManager.SetActiveTool<KnotPlacementTool>();
|
|
}
|
|
}
|
|
|
|
static void GetSplineInfosFromContainer(Object target, List<SplineInfo> results)
|
|
{
|
|
if (target != null && target is ISplineContainer container)
|
|
{
|
|
var splines = container.Splines;
|
|
for (int i = 0; i < splines.Count; ++i)
|
|
results.Add(new SplineInfo(container, i));
|
|
}
|
|
}
|
|
|
|
internal static Bounds GetBounds(IReadOnlyList<SplineInfo> splines)
|
|
{
|
|
Bounds bounds = default;
|
|
bool initialized = false;
|
|
|
|
for (int i = 0; i < splines.Count; ++i)
|
|
{
|
|
var spline = splines[i].Spline;
|
|
|
|
if (spline.Count > 0 && !initialized)
|
|
bounds = spline.GetBounds(splines[i].LocalToWorld);
|
|
else
|
|
bounds.Encapsulate(spline.GetBounds(splines[i].LocalToWorld));
|
|
}
|
|
|
|
return bounds;
|
|
}
|
|
|
|
internal static Bounds GetElementBounds<T>(IReadOnlyList<T> elements, bool useKnotPositionForTangents)
|
|
where T : ISelectableElement
|
|
{
|
|
if (elements == null)
|
|
throw new ArgumentNullException(nameof(elements));
|
|
|
|
if (elements.Count == 0)
|
|
return new Bounds(Vector3.positiveInfinity, Vector3.zero);
|
|
|
|
var element = elements[0];
|
|
|
|
var position = (useKnotPositionForTangents && element is SelectableTangent tangent)
|
|
? tangent.Owner.Position
|
|
: element.Position;
|
|
|
|
Bounds bounds = new Bounds(position, Vector3.zero);
|
|
for (int i = 1; i < elements.Count; ++i)
|
|
{
|
|
element = elements[i];
|
|
if (useKnotPositionForTangents && element is SelectableTangent t)
|
|
bounds.Encapsulate(t.Owner.Position);
|
|
else
|
|
bounds.Encapsulate(element.Position);
|
|
}
|
|
|
|
return bounds;
|
|
}
|
|
|
|
internal static SelectableKnot GetKnot<T>(T element)
|
|
where T : ISelectableElement
|
|
{
|
|
return new SelectableKnot(element.SplineInfo, element.KnotIndex);
|
|
}
|
|
|
|
internal static void RecordSelection(string name)
|
|
{
|
|
Undo.RecordObjects(SplineSelection.GetAllSelectedTargets(), name);
|
|
}
|
|
|
|
internal static void RecordObjects<T>(IReadOnlyList<T> elements, string name)
|
|
where T : ISelectableElement
|
|
{
|
|
foreach (var spline in GetSplines(elements))
|
|
RecordObject(spline, name);
|
|
}
|
|
|
|
internal static void RecordObject(SplineInfo splineInfo, string name)
|
|
{
|
|
if (splineInfo.Container is Object target && target != null)
|
|
Undo.RecordObject(target, name);
|
|
}
|
|
|
|
internal static SplineInfo CreateSpline(ISplineContainer container)
|
|
{
|
|
container.AddSpline();
|
|
return new SplineInfo(container, container.Splines.Count - 1);
|
|
}
|
|
|
|
internal static SelectableKnot CreateSpline(SelectableKnot from, float3 tangentOut)
|
|
{
|
|
var splineInfo = CreateSpline(from.SplineInfo.Container);
|
|
var knot = AddKnotToTheEnd(splineInfo, from.Position, math.mul(from.Rotation, math.up()), tangentOut, false);
|
|
LinkKnots(knot, from);
|
|
return knot;
|
|
}
|
|
|
|
internal static TangentMode GetModeFromPlacementTangent(float3 tangent)
|
|
{
|
|
return math.lengthsq(tangent) < float.Epsilon ? DefaultTangentMode : TangentMode.Mirrored;
|
|
}
|
|
|
|
static SelectableKnot AddKnotInternal(SplineInfo splineInfo, float3 worldPosition, float3 normal, float3 tangentOut, int index, int previousIndex, bool updateSelection)
|
|
{
|
|
var spline = splineInfo.Spline;
|
|
|
|
if (spline.Closed && spline.Count >= 2)
|
|
Debug.LogWarning("Cannot add a point to the extremity of a closed spline.");
|
|
|
|
|
|
var localToWorld = splineInfo.LocalToWorld;
|
|
var mode = GetModeFromPlacementTangent(tangentOut);
|
|
|
|
var localPosition = math.transform(math.inverse(splineInfo.LocalToWorld), worldPosition);
|
|
quaternion localRotation;
|
|
BezierKnot newKnot;
|
|
|
|
// If we're in AutoSmooth mode
|
|
if (!SplineUtility.AreTangentsModifiable(mode))
|
|
newKnot = SplineUtility.GetAutoSmoothKnot(localPosition, previousIndex != -1 ? spline[previousIndex].Position : localPosition, localPosition, normal);
|
|
else
|
|
{
|
|
localRotation = math.mul(math.inverse(math.quaternion(localToWorld)), quaternion.LookRotationSafe(tangentOut, normal));
|
|
var tangentMagnitude = math.length(tangentOut);
|
|
// Tangents are always assumed to be +/- forward when TangentMode is not Broken.
|
|
var localTangentIn = new float3(0f, 0f, -tangentMagnitude);
|
|
var localTangentOut = new float3(0f, 0f, tangentMagnitude);
|
|
newKnot = new BezierKnot(localPosition, localTangentIn, localTangentOut, localRotation);
|
|
}
|
|
|
|
spline.Insert(index, newKnot, mode);
|
|
|
|
// When appending a knot, update the previous knot with an average rotation accounting for the new point.
|
|
// This is assuming that if the previous knot is Continuous the rotation was explicitly set, and thus will
|
|
// not update the rotation.
|
|
if (spline.Count > 1 && !SplineUtility.AreTangentsModifiable(spline.GetTangentMode(previousIndex)))
|
|
{
|
|
// calculate rotation from the average direction from points p0 -> p1 -> p2
|
|
BezierKnot current = spline[previousIndex];
|
|
BezierKnot previous = spline.Previous(previousIndex);
|
|
BezierKnot next = spline.Next(previousIndex);
|
|
|
|
current.Rotation = CalculateKnotRotation(previous.Position, current.Position, next.Position, normal);
|
|
spline[previousIndex] = current;
|
|
}
|
|
|
|
// If the element is part of a prefab, the changes have to be recorded AFTER being done on the prefab instance
|
|
// otherwise they would not be saved in the scene.
|
|
PrefabUtility.RecordPrefabInstancePropertyModifications(splineInfo.Object);
|
|
|
|
var knot = new SelectableKnot(splineInfo, index);
|
|
if(updateSelection)
|
|
SplineSelection.Set(knot);
|
|
|
|
return knot;
|
|
}
|
|
|
|
internal static SelectableKnot AddKnotToTheEnd(SplineInfo splineInfo, float3 worldPosition, float3 normal, float3 tangentOut, bool updateSelection = true)
|
|
{
|
|
return AddKnotInternal(splineInfo, worldPosition, normal, tangentOut, splineInfo.Spline.Count, splineInfo.Spline.Count - 1, updateSelection);
|
|
}
|
|
|
|
internal static SelectableKnot AddKnotToTheStart(SplineInfo splineInfo, float3 worldPosition, float3 normal, float3 tangentIn, bool updateSelection = true)
|
|
{
|
|
return AddKnotInternal(splineInfo, worldPosition, normal, -tangentIn, 0, 1, updateSelection);
|
|
}
|
|
|
|
internal static void RemoveKnot(SelectableKnot knot)
|
|
{
|
|
knot.SplineInfo.Spline.RemoveAt(knot.KnotIndex);
|
|
|
|
//Force to record changes if part of a prefab instance
|
|
PrefabUtility.RecordPrefabInstancePropertyModifications(knot.SplineInfo.Object);
|
|
knotRemoved?.Invoke(knot);
|
|
}
|
|
|
|
internal static bool ShouldRemoveSpline(SplineInfo splineInfo)
|
|
{
|
|
// Spline is Empty
|
|
if (splineInfo.Spline.Count == 0)
|
|
return true;
|
|
|
|
// Spline has one knot that is linked to another. This makes it "hidden" to the user because it's on top of another knot without having a curve associated with it.
|
|
if (splineInfo.Spline.Count == 1 && splineInfo.Container.KnotLinkCollection.TryGetKnotLinks(new SplineKnotIndex(splineInfo.Index, 0), out _))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
// Zero out the given tangent and switch knot's tangent mode to Continous if it's Mirrored.
|
|
internal static void ClearTangent(SelectableTangent tangent)
|
|
{
|
|
var spline = tangent.SplineInfo.Spline;
|
|
var knotIndex = tangent.Owner.KnotIndex;
|
|
var selectableKnot = tangent.Owner;
|
|
var bezierKnot = spline[knotIndex];
|
|
|
|
if (selectableKnot.Mode == TangentMode.Mirrored)
|
|
selectableKnot.Mode = TangentMode.Continuous;
|
|
|
|
switch (tangent.TangentIndex)
|
|
{
|
|
case (int)BezierTangent.In:
|
|
bezierKnot.TangentIn = float3.zero;
|
|
break;
|
|
|
|
case (int)BezierTangent.Out:
|
|
bezierKnot.TangentOut = float3.zero;
|
|
break;
|
|
}
|
|
|
|
spline[knotIndex] = bezierKnot;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the interpolation value that corresponds to the middle (distance wise) of the curve.
|
|
/// If spline and curveIndex are provided, the function leverages the spline's LUTs, otherwise the LUT is built on the fly.
|
|
/// </summary>
|
|
/// <param name="curve">The curve to evaluate.</param>
|
|
/// <param name="spline">The ISpline that curve belongs to. Not used if curve is not part of any spline.</param>
|
|
/// <param name="curveIndex">The index of the curve if it's part of the spine.</param>
|
|
/// <typeparam name="T">A type implementing ISpline.</typeparam>
|
|
internal static float GetCurveMiddleInterpolation<T>(BezierCurve curve, T spline, int curveIndex) where T: ISpline
|
|
{
|
|
var curveMidT = 0f;
|
|
if (curveIndex >= 0)
|
|
curveMidT = spline.GetCurveInterpolation(curveIndex, spline.GetCurveLength(curveIndex) * 0.5f);
|
|
else
|
|
curveMidT = CurveUtility.GetDistanceToInterpolation(curve, CurveUtility.ApproximateLength(curve) * 0.5f);
|
|
|
|
return curveMidT;
|
|
}
|
|
|
|
static BezierCurve GetPreviewCurveInternal(SplineInfo info, int from, float3 fromWorldTangent, float3 toWorldPoint, float3 toWorldTangent, TangentMode toMode, int previousIndex)
|
|
{
|
|
var spline = info.Spline;
|
|
var trs = info.Transform.localToWorldMatrix;
|
|
|
|
var aMode = spline.GetTangentMode(from);
|
|
var bMode = toMode;
|
|
|
|
var p0 = math.transform(trs, spline[from].Position);
|
|
var p1 = math.transform(trs, spline[from].Position + math.mul(spline[from].Rotation, fromWorldTangent));
|
|
var p3 = toWorldPoint;
|
|
var p2 = p3 - toWorldTangent;
|
|
|
|
if (!SplineUtility.AreTangentsModifiable(aMode))
|
|
p1 = aMode == TangentMode.Linear ? p0 : p0 + SplineUtility.GetAutoSmoothTangent(math.transform(trs, spline[previousIndex].Position), p0, p3, SplineUtility.CatmullRomTension);
|
|
|
|
if (!SplineUtility.AreTangentsModifiable(bMode))
|
|
p2 = bMode == TangentMode.Linear ? p3 : p3 + SplineUtility.GetAutoSmoothTangent(p3, p3, p0, SplineUtility.CatmullRomTension);
|
|
|
|
return new BezierCurve(p0, p1, p2, p3);
|
|
}
|
|
|
|
// Calculate the curve control points in world space given a new end knot.
|
|
internal static BezierCurve GetPreviewCurveFromEnd(SplineInfo info, int from, float3 toWorldPoint, float3 toWorldTangent, TangentMode toMode)
|
|
{
|
|
var tangentOut = info.Spline[from].TangentOut;
|
|
if(info.Spline.Closed && (from == 0 || AreKnotLinked( new SelectableKnot(info, from), new SelectableKnot(info, 0))))
|
|
{
|
|
var fromKnot = info.Spline[from];
|
|
tangentOut = -fromKnot.TangentIn;
|
|
}
|
|
|
|
return GetPreviewCurveInternal(info, from, tangentOut, toWorldPoint, toWorldTangent, toMode, info.Spline.PreviousIndex(from));
|
|
}
|
|
|
|
// Calculate the curve control points in world space given a new start knot.
|
|
internal static BezierCurve GetPreviewCurveFromStart(SplineInfo info, int from, float3 toWorldPoint, float3 toWorldTangent, TangentMode toMode)
|
|
{
|
|
var tangentIn = info.Spline[from].TangentIn;
|
|
if(info.Spline.Closed && (from == info.Spline.Count - 1 || AreKnotLinked( new SelectableKnot(info, from), new SelectableKnot(info, info.Spline.Count - 1))))
|
|
{
|
|
var fromKnot = info.Spline[from];
|
|
tangentIn = -fromKnot.TangentOut;
|
|
}
|
|
|
|
return GetPreviewCurveInternal(info, from, tangentIn, toWorldPoint, toWorldTangent, toMode, info.Spline.NextIndex(from));
|
|
}
|
|
|
|
internal static quaternion CalculateKnotRotation(float3 previous, float3 position, float3 next, float3 normal)
|
|
{
|
|
float3 tangent = new float3(0f, 0f, 1f);
|
|
bool hasPrevious = math.distancesq(position, previous) > float.Epsilon;
|
|
bool hasNext = math.distancesq(position, next) > float.Epsilon;
|
|
|
|
if (hasPrevious && hasNext)
|
|
tangent = ((position - previous) + (next - position)) * 5f;
|
|
else if (hasPrevious)
|
|
tangent = position - previous;
|
|
else if (hasNext)
|
|
tangent = next - position;
|
|
|
|
return SplineUtility.GetKnotRotation(tangent, normal);
|
|
}
|
|
|
|
//Get the affected curves when trying to add a knot on an existing segment
|
|
//internal static void GetAffectedCurves(SplineCurveHit hit, Dictionary<Spline, Dictionary<int, List<BezierKnot>>> affectedCurves)
|
|
internal static void GetAffectedCurves(SplineCurveHit hit, List<(Spline s, int index, List<BezierKnot> knots)> affectedCurves)
|
|
{
|
|
var spline = hit.PreviousKnot.SplineInfo.Spline;
|
|
var curveIndex = hit.PreviousKnot.KnotIndex;
|
|
var hitLocalPosition = hit.PreviousKnot.SplineInfo.Transform.InverseTransformPoint(hit.Position);
|
|
|
|
var previewKnots = new List<BezierKnot>();
|
|
|
|
var sKnot = hit.PreviousKnot;
|
|
var bKnot = new BezierKnot(sKnot.LocalPosition, sKnot.TangentIn.LocalPosition, sKnot.TangentOut.LocalPosition, sKnot.LocalRotation);
|
|
|
|
var insertedKnot = GetInsertedKnotPreview(hit.PreviousKnot.SplineInfo, hit.NextKnot.KnotIndex, hit.T, out var leftTangent, out var rightTangent);
|
|
|
|
if(spline.GetTangentMode(sKnot.KnotIndex) == TangentMode.AutoSmooth)
|
|
{
|
|
var previousKnot = spline.Previous(sKnot.KnotIndex);
|
|
var previousKnotIndex = spline.PreviousIndex(sKnot.KnotIndex);
|
|
bKnot = SplineUtility.GetAutoSmoothKnot(sKnot.LocalPosition, previousKnot.Position, hitLocalPosition);
|
|
|
|
affectedCurves.Add((spline, previousKnotIndex, new List<BezierKnot>() { previousKnot, bKnot }));
|
|
}
|
|
else
|
|
bKnot.TangentOut = math.mul(math.inverse(sKnot.LocalRotation), leftTangent);
|
|
|
|
previewKnots.Add(bKnot);
|
|
|
|
previewKnots.Add(insertedKnot);
|
|
var affectedCurveIndex = affectedCurves.FindIndex(x => x.s == spline && x.index == curveIndex);
|
|
if(affectedCurveIndex >= 0)
|
|
affectedCurves.RemoveAt(affectedCurveIndex);
|
|
affectedCurves.Add((spline, curveIndex, previewKnots));
|
|
|
|
sKnot = hit.NextKnot;
|
|
bKnot = new BezierKnot(sKnot.LocalPosition, sKnot.TangentIn.LocalPosition, sKnot.TangentOut.LocalPosition, sKnot.LocalRotation);
|
|
|
|
if(spline.GetTangentMode(sKnot.KnotIndex) == TangentMode.AutoSmooth)
|
|
{
|
|
var nextKnot = spline.Next(sKnot.KnotIndex);
|
|
bKnot = SplineUtility.GetAutoSmoothKnot(sKnot.LocalPosition, hitLocalPosition, nextKnot.Position);
|
|
|
|
affectedCurves.Add((spline, sKnot.KnotIndex, new List<BezierKnot>() { bKnot, nextKnot }));
|
|
}
|
|
else
|
|
bKnot.TangentIn = math.mul(math.inverse(sKnot.LocalRotation), rightTangent);
|
|
|
|
|
|
previewKnots.Add(bKnot);
|
|
}
|
|
|
|
internal static void GetAffectedCurves(SplineInfo splineInfo, Vector3 knotPosition, bool addingToStart, SelectableKnot lastKnot, int previousKnotIndex, List<(Spline s, int index, List<BezierKnot> knots)> affectedCurves)
|
|
{
|
|
var spline = splineInfo.Spline;
|
|
if (spline != null)
|
|
{
|
|
var lastKnotIndex = lastKnot.KnotIndex;
|
|
|
|
var affectedCurveIndex = affectedCurves.FindIndex(x => x.s == spline && x.index == (addingToStart ? lastKnotIndex : previousKnotIndex));
|
|
|
|
var lastTangentMode = spline.GetTangentMode(lastKnotIndex);
|
|
if(lastTangentMode == TangentMode.AutoSmooth)
|
|
{
|
|
var previousKnot = spline[previousKnotIndex];
|
|
var autoSmoothKnot = addingToStart ?
|
|
SplineUtility.GetAutoSmoothKnot(lastKnot.LocalPosition, knotPosition, previousKnot.Position) :
|
|
SplineUtility.GetAutoSmoothKnot(lastKnot.LocalPosition, previousKnot.Position, knotPosition);
|
|
|
|
if (affectedCurveIndex < 0)
|
|
{
|
|
if (addingToStart)
|
|
affectedCurves.Insert(0, (spline, lastKnot.KnotIndex, new List<BezierKnot>() { autoSmoothKnot, previousKnot }));
|
|
else
|
|
affectedCurves.Add((spline, previousKnotIndex, new List<BezierKnot>() { previousKnot, autoSmoothKnot }));
|
|
}
|
|
else
|
|
{
|
|
//The segment as already some changes due to some modifications on the previous knots in the previews
|
|
//So we only want to adapt the last knot in that case
|
|
var knots = affectedCurves[affectedCurveIndex].knots;
|
|
knots[addingToStart ? 0 : 1] = autoSmoothKnot;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
internal static BezierKnot GetInsertedKnotPreview(SplineInfo splineInfo, int index, float t, out Vector3 leftOutTangent, out Vector3 rightInTangent)
|
|
{
|
|
var spline = splineInfo.Spline;
|
|
|
|
var previousIndex = SplineUtility.PreviousIndex(index, spline.Count, spline.Closed);
|
|
var previous = spline[previousIndex];
|
|
|
|
var curveToSplit = new BezierCurve(previous, spline[index]);
|
|
CurveUtility.Split(curveToSplit, t, out var leftCurve, out var rightCurve);
|
|
|
|
var nextIndex = SplineUtility.NextIndex(index, spline.Count, spline.Closed);
|
|
var next = spline[nextIndex];
|
|
|
|
var up = CurveUtility.EvaluateUpVector(curveToSplit, t, math.rotate(previous.Rotation, math.up()), math.rotate(next.Rotation, math.up()));
|
|
var rotation = quaternion.LookRotationSafe(math.normalizesafe(rightCurve.Tangent0), up);
|
|
var inverseRotation = math.inverse(rotation);
|
|
|
|
leftOutTangent = leftCurve.Tangent0;
|
|
rightInTangent = rightCurve.Tangent1;
|
|
|
|
return new BezierKnot(leftCurve.P3, math.mul(inverseRotation, leftCurve.Tangent1), math.mul(inverseRotation, rightCurve.Tangent0), rotation);
|
|
}
|
|
|
|
internal static SelectableKnot InsertKnot(SplineInfo splineInfo, int index, float t)
|
|
{
|
|
var spline = splineInfo.Spline;
|
|
if (spline == null)
|
|
return default;
|
|
|
|
spline.InsertOnCurve(index, t);
|
|
|
|
var knot = new SelectableKnot(splineInfo, index);
|
|
knotInserted?.Invoke(knot);
|
|
return knot;
|
|
}
|
|
|
|
internal static SplineKnotIndex GetIndex(SelectableKnot knot)
|
|
{
|
|
return new SplineKnotIndex(knot.SplineInfo.Index, knot.KnotIndex);
|
|
}
|
|
|
|
internal static void GetKnotLinks(SelectableKnot knot, List<SelectableKnot> knots)
|
|
{
|
|
var container = knot.SplineInfo.Container;
|
|
if (container == null)
|
|
return;
|
|
|
|
knots.Clear();
|
|
if (container.KnotLinkCollection == null)
|
|
{
|
|
knots.Add(knot);
|
|
return;
|
|
}
|
|
|
|
var linkedKnots = container.KnotLinkCollection.GetKnotLinks(new SplineKnotIndex(knot.SplineInfo.Index, knot.KnotIndex));
|
|
foreach (var index in linkedKnots)
|
|
knots.Add(new SelectableKnot(new SplineInfo(container, index.Spline), index.Knot));
|
|
}
|
|
|
|
internal static void LinkKnots(IReadOnlyList<SelectableKnot> knots)
|
|
{
|
|
for (int i = 0; i < knots.Count; ++i)
|
|
{
|
|
var knot = knots[i];
|
|
var container = knot.SplineInfo.Container;
|
|
var spline = knot.SplineInfo.Spline;
|
|
var splineKnotIndex = new SplineKnotIndex() { Spline = knot.SplineInfo.Index, Knot = knot.KnotIndex };
|
|
|
|
for (int j = i + 1; j < knots.Count; ++j)
|
|
{
|
|
var otherKnot = knots[j];
|
|
// Do not link knots from different containers
|
|
if (otherKnot.SplineInfo.Container != container)
|
|
continue;
|
|
|
|
var otherSplineInfo = otherKnot.SplineInfo;
|
|
// Do not link same knots
|
|
if (otherSplineInfo.Spline == spline && otherKnot.KnotIndex == knot.KnotIndex)
|
|
continue;
|
|
|
|
var otherSplineKnotIndex = new SplineKnotIndex() { Spline = otherKnot.SplineInfo.Index, Knot = otherKnot.KnotIndex };
|
|
|
|
RecordObject(knot.SplineInfo, "Link Knots");
|
|
|
|
container.KnotLinkCollection.Link(splineKnotIndex, otherSplineKnotIndex);
|
|
container.SetLinkedKnotPosition(splineKnotIndex);
|
|
}
|
|
}
|
|
|
|
//Force to record changes if part of a prefab instance
|
|
if(knots.Count > 0 && knots[0].IsValid())
|
|
PrefabUtility.RecordPrefabInstancePropertyModifications(knots[0].SplineInfo.Object);
|
|
}
|
|
|
|
internal static void UnlinkKnots(IReadOnlyList<SelectableKnot> knots)
|
|
{
|
|
foreach (var knot in knots)
|
|
{
|
|
var container = knot.SplineInfo.Container;
|
|
var splineKnotIndex = new SplineKnotIndex() { Spline = knot.SplineInfo.Index, Knot = knot.KnotIndex };
|
|
|
|
RecordObject(knot.SplineInfo, "Unlink Knots");
|
|
container.KnotLinkCollection.Unlink(splineKnotIndex);
|
|
}
|
|
|
|
//Force to record changes if part of a prefab instance
|
|
if(knots.Count > 0 && knots[0].IsValid())
|
|
PrefabUtility.RecordPrefabInstancePropertyModifications(knots[0].SplineInfo.Object);
|
|
}
|
|
|
|
internal static void LinkKnots(SelectableKnot a, SelectableKnot b)
|
|
{
|
|
var containerA = a.SplineInfo.Container;
|
|
var containerB = b.SplineInfo.Container;
|
|
|
|
if (containerA != containerB)
|
|
return;
|
|
|
|
containerA.KnotLinkCollection.Link(GetIndex(a), GetIndex(b));
|
|
|
|
//Force to record changes if part of a prefab instance
|
|
if(a.IsValid())
|
|
PrefabUtility.RecordPrefabInstancePropertyModifications(a.SplineInfo.Object);
|
|
}
|
|
|
|
internal static bool AreKnotLinked(SelectableKnot a, SelectableKnot b)
|
|
{
|
|
var containerA = a.SplineInfo.Container;
|
|
var containerB = b.SplineInfo.Container;
|
|
|
|
if (containerA != containerB)
|
|
return false;
|
|
|
|
return containerA.AreKnotLinked(
|
|
new SplineKnotIndex(a.SplineInfo.Index, a.KnotIndex),
|
|
new SplineKnotIndex(b.SplineInfo.Index, b.KnotIndex));
|
|
|
|
}
|
|
|
|
internal static bool TryGetNearestKnot(IReadOnlyList<SplineInfo> splines, out SelectableKnot knot, float maxDistance = SplineHandleUtility.pickingDistance)
|
|
{
|
|
float nearestDist = float.MaxValue;
|
|
SelectableKnot nearest = knot = default;
|
|
|
|
for (int i = 0; i < splines.Count; ++i)
|
|
{
|
|
var spline = splines[i].Spline;
|
|
var localToWorld = splines[i].LocalToWorld;
|
|
for (int j = 0; j < spline.Count; ++j)
|
|
{
|
|
var dist = SplineHandleUtility.DistanceToCircle(spline[j].Transform(localToWorld).Position, SplineHandleUtility.pickingDistance);
|
|
if (dist <= nearestDist)
|
|
{
|
|
nearestDist = dist;
|
|
nearest = new SelectableKnot(splines[i], j);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nearestDist > maxDistance)
|
|
return false;
|
|
|
|
knot = nearest;
|
|
return true;
|
|
}
|
|
|
|
internal static bool TryGetNearestPositionOnCurve(IReadOnlyList<SplineInfo> splines, out SplineCurveHit hit, float maxDistance = SplineHandleUtility.pickingDistance)
|
|
{
|
|
SplineCurveHit nearestHit = hit = default;
|
|
BezierCurve nearestCurve = default;
|
|
float nearestDist = float.MaxValue;
|
|
|
|
for (int i = 0; i < splines.Count; ++i)
|
|
{
|
|
var spline = splines[i].Spline;
|
|
var localToWorld = splines[i].LocalToWorld;
|
|
for (int j = 0; j < spline.GetCurveCount(); ++j)
|
|
{
|
|
var curve = spline.GetCurve(j).Transform(localToWorld);
|
|
SplineHandleUtility.GetNearestPointOnCurve(curve, out Vector3 position, out float t, out float dist);
|
|
if (dist < nearestDist && t > 0f && t < 1f)
|
|
{
|
|
nearestCurve = curve;
|
|
nearestDist = dist;
|
|
nearestHit = new SplineCurveHit
|
|
{
|
|
Position = position,
|
|
T = t,
|
|
PreviousKnot = new SelectableKnot(splines[i], j),
|
|
NextKnot = new SelectableKnot(splines[i], spline.NextIndex(j))
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nearestDist > maxDistance)
|
|
return false;
|
|
|
|
var up = CurveUtility.EvaluateUpVector(nearestCurve, nearestHit.T, math.rotate(nearestHit.PreviousKnot.Rotation, math.up()), math.rotate(nearestHit.NextKnot.Rotation, math.up()));
|
|
nearestHit.Normal = up;
|
|
|
|
hit = nearestHit;
|
|
return true;
|
|
}
|
|
|
|
internal static bool IsEndKnot(SelectableKnot knot)
|
|
{
|
|
return knot.IsValid() && knot.KnotIndex == knot.SplineInfo.Spline.Count - 1;
|
|
}
|
|
|
|
internal static SelectableKnot SplitKnot(SelectableKnot knot)
|
|
{
|
|
if (!knot.IsValid())
|
|
throw new ArgumentException("Knot is invalid", nameof(knot));
|
|
|
|
var newKnot = knot.SplineInfo.Container.SplitSplineOnKnot(new SplineKnotIndex(knot.SplineInfo.Index, knot.KnotIndex));
|
|
|
|
if (newKnot.IsValid())
|
|
{
|
|
PrefabUtility.RecordPrefabInstancePropertyModifications(knot.SplineInfo.Object);
|
|
return new SelectableKnot(new SplineInfo(knot.SplineInfo.Container, newKnot.Spline), newKnot.Knot);
|
|
}
|
|
return new SelectableKnot();
|
|
}
|
|
|
|
internal static SelectableKnot JoinKnots(SelectableKnot knotA, SelectableKnot knotB)
|
|
{
|
|
if (!knotA.IsValid())
|
|
throw new ArgumentException("Knot is invalid", nameof(knotA));
|
|
|
|
if (!knotB.IsValid())
|
|
throw new ArgumentException("Knot is invalid", nameof(knotB));
|
|
|
|
//Check knots properties
|
|
var isKnotAActive = !SplineSelection.IsActive(knotB);
|
|
var knotIndexA = new SplineKnotIndex(knotA.SplineInfo.Index, knotA.KnotIndex);
|
|
var knotIndexB = new SplineKnotIndex(knotB.SplineInfo.Index, knotB.KnotIndex);
|
|
var activeKnot = isKnotAActive ? knotIndexA : knotIndexB;
|
|
var otherKnot = isKnotAActive ? knotIndexB : knotIndexA;
|
|
|
|
var res = knotA.SplineInfo.Container.JoinSplinesOnKnots(activeKnot, otherKnot);
|
|
|
|
//Force to record changes if part of a prefab instance
|
|
var activeSplineInfo = isKnotAActive ? knotA.SplineInfo : knotB.SplineInfo;
|
|
PrefabUtility.RecordPrefabInstancePropertyModifications(activeSplineInfo.Object);
|
|
|
|
return new SelectableKnot(new SplineInfo(knotA.SplineInfo.Container, res.Spline), res.Knot);
|
|
}
|
|
|
|
internal static void ReverseSplinesFlow(IReadOnlyList<SplineInfo> selectedSplines)
|
|
{
|
|
List<ISelectableElement> selectedElements = new List<ISelectableElement>();
|
|
|
|
var formerActiveElement = SplineSelection.GetActiveElement(selectedSplines);
|
|
SplineSelection.GetElements(selectedSplines, selectedElements);
|
|
var splines = GetSplines(selectedElements);
|
|
foreach (var splineInfo in splines)
|
|
SplineUtility.ReverseFlow(splineInfo);
|
|
|
|
int newActiveElementIndex = -1;
|
|
for (int i = 0; i < selectedElements.Count; ++i)
|
|
{
|
|
var element = selectedElements[i];
|
|
if (element.Equals(formerActiveElement))
|
|
newActiveElementIndex = i;
|
|
|
|
if (element is SelectableKnot knot)
|
|
selectedElements[i] = new SelectableKnot(knot.SplineInfo, knot.SplineInfo.Spline.Count - knot.KnotIndex - 1);
|
|
else if (element is SelectableTangent tangent)
|
|
selectedElements[i] = new SelectableTangent(tangent.SplineInfo, tangent.SplineInfo.Spline.Count - tangent.KnotIndex - 1, (tangent.TangentIndex + 1) % 2);
|
|
}
|
|
|
|
SplineSelection.Clear();
|
|
SplineSelection.AddRange(selectedElements);
|
|
|
|
if(newActiveElementIndex >= 0)
|
|
SplineSelection.SetActive(selectedElements[newActiveElementIndex]);
|
|
else
|
|
SplineSelection.SetActive(selectedElements[^1]);
|
|
}
|
|
|
|
internal static HashSet<SplineInfo> GetSplines<T>(IReadOnlyList<T> elements)
|
|
where T : ISelectableElement
|
|
{
|
|
HashSet<SplineInfo> splines = new HashSet<SplineInfo>();
|
|
for (int i = 0; i < elements.Count; ++i)
|
|
splines.Add(elements[i].SplineInfo);
|
|
return splines;
|
|
}
|
|
|
|
internal static void GetAdjacentTangents<T>(
|
|
T element,
|
|
out SelectableTangent previousOut,
|
|
out SelectableTangent currentIn,
|
|
out SelectableTangent currentOut,
|
|
out SelectableTangent nextIn)
|
|
where T : ISelectableElement
|
|
{
|
|
var knot = GetKnot(element);
|
|
var spline = knot.SplineInfo.Spline;
|
|
bool isFirstKnot = knot.KnotIndex == 0 && !spline.Closed;
|
|
bool isLastKnot = knot.KnotIndex == spline.Count - 1 && !spline.Closed;
|
|
|
|
previousOut = isFirstKnot ? default : new SelectableTangent(knot.SplineInfo, spline.PreviousIndex(knot.KnotIndex), BezierTangent.Out);
|
|
currentIn = isFirstKnot ? default : knot.TangentIn;
|
|
currentOut = isLastKnot ? default : knot.TangentOut;
|
|
nextIn = isLastKnot ? default : new SelectableTangent(knot.SplineInfo, spline.NextIndex(knot.KnotIndex), BezierTangent.In);
|
|
}
|
|
|
|
internal static quaternion GetElementRotation<T>(T element)
|
|
where T : ISelectableElement
|
|
{
|
|
if (element is SelectableTangent editableTangent)
|
|
{
|
|
float3 forward;
|
|
var knotUp = math.rotate(editableTangent.Owner.Rotation, math.up());
|
|
|
|
if (math.length(editableTangent.Direction) > 0)
|
|
forward = math.normalize(editableTangent.Direction);
|
|
else // Treat zero length tangent same way as when it's parallel to knot's up vector
|
|
forward = knotUp;
|
|
|
|
float3 right;
|
|
var dotForwardKnotUp = math.dot(forward, knotUp);
|
|
if (Mathf.Approximately(math.abs(dotForwardKnotUp), 1f))
|
|
right = math.rotate(editableTangent.Owner.Rotation, math.right()) * math.sign(dotForwardKnotUp);
|
|
else
|
|
right = math.cross(forward, knotUp);
|
|
|
|
return quaternion.LookRotationSafe(forward, math.cross(right, forward));
|
|
}
|
|
|
|
if (element is SelectableKnot editableKnot)
|
|
return editableKnot.Rotation;
|
|
|
|
return quaternion.identity;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the position of a tangent. This could actually result in the knot being rotated depending on the tangent mode
|
|
/// </summary>
|
|
/// <param name="tangent">The tangent to place</param>
|
|
/// <param name="position">The position that should be used to place the tangent</param>
|
|
internal static void ApplyPositionToTangent(SelectableTangent tangent, float3 position)
|
|
{
|
|
var knot = tangent.Owner;
|
|
|
|
switch (knot.Mode)
|
|
{
|
|
case TangentMode.Broken:
|
|
tangent.Position = position;
|
|
break;
|
|
|
|
case TangentMode.Continuous:
|
|
case TangentMode.Mirrored:
|
|
var deltas = TransformOperation.CalculateMirroredTangentTranslationDeltas(tangent, position);
|
|
|
|
knot.Rotation = math.mul(deltas.knotRotationDelta, knot.Rotation);
|
|
tangent.LocalDirection += math.normalize(tangent.LocalDirection) * deltas.tangentLocalMagnitudeDelta;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
internal static bool Exists(ISplineContainer container, int index)
|
|
{
|
|
if (container == null)
|
|
return false;
|
|
|
|
return index < container.Splines.Count;
|
|
}
|
|
|
|
internal static bool Exists(SplineInfo spline)
|
|
{
|
|
return Exists(spline.Container, spline.Index);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Copy an embedded <see cref="SplineData{T}"/> collection to a new <see cref="Spline"/> if the destination
|
|
/// does not already contain an entry matching the <paramref name="type"/> and <paramref name="key"/>.
|
|
/// </summary>
|
|
/// <param name="type">The <see cref="EmbeddedSplineDataType"/>.</param>
|
|
/// <param name="key">A string value used to identify and access a <see cref="SplineData{T}"/>.</param>
|
|
/// <param name="container">The <see cref="ISplineContainer"/> that contains the spline.</param>
|
|
/// <param name="source">The index of the <see cref="Spline"/> in the <paramref name="container"/> to copy data from.</param>
|
|
/// <param name="destination">The index of the <see cref="Spline"/> in the <paramref name="container"/> to copy data to.</param>
|
|
/// <returns>True if data was copied, otherwise false.</returns>
|
|
public static bool CopySplineDataIfEmpty(ISplineContainer container, int source, int destination, EmbeddedSplineDataType type, string key)
|
|
{
|
|
if (container == null)
|
|
return false;
|
|
|
|
var splines = container.Splines;
|
|
|
|
if (source < 0 || source >= splines.Count || destination < 0 || destination >= splines.Count)
|
|
return false;
|
|
|
|
var src = splines[source];
|
|
var dst = splines[destination];
|
|
|
|
// copy SplineData if the target spline is empty
|
|
switch (type)
|
|
{
|
|
case EmbeddedSplineDataType.Int:
|
|
if((dst.TryGetIntData(key, out var existingIntData) && existingIntData.Count > 0)
|
|
|| !src.TryGetIntData(key, out var srcIntData))
|
|
return false;
|
|
dst.SetIntData(key, srcIntData);
|
|
return true;
|
|
case EmbeddedSplineDataType.Float:
|
|
if((dst.TryGetFloatData(key, out var existingFloatData) && existingFloatData.Count > 0)
|
|
|| !src.TryGetFloatData(key, out var srcFloatData))
|
|
return false;
|
|
dst.SetFloatData(key, srcFloatData);
|
|
return true;
|
|
case EmbeddedSplineDataType.Float4:
|
|
if((dst.TryGetFloat4Data(key, out var existingFloat4Data) && existingFloat4Data.Count > 0)
|
|
|| !src.TryGetFloat4Data(key, out var srcFloat4Data))
|
|
return false;
|
|
dst.SetFloat4Data(key, srcFloat4Data);
|
|
return true;
|
|
case EmbeddedSplineDataType.Object:
|
|
if((dst.TryGetObjectData(key, out var existingObjectData) && existingObjectData.Count > 0)
|
|
|| !src.TryGetObjectData(key, out var srcObjectData))
|
|
return false;
|
|
dst.SetObjectData(key, srcObjectData);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
}
|
|
}
|