379 lines
20 KiB
C#
379 lines
20 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Unity.Collections;
|
|
using Unity.Mathematics;
|
|
|
|
namespace UnityEngine.Splines
|
|
{
|
|
/// <summary>
|
|
/// A read-only representation of <see cref="Spline"/> that is optimized for efficient access and queries.
|
|
/// NativeSpline can be constructed with a spline and Transform. If a transform is applied, all values will be
|
|
/// relative to the transformed knot positions.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// NativeSpline is compatible with the job system.
|
|
/// </remarks>
|
|
public struct NativeSpline : ISpline, IDisposable
|
|
{
|
|
[ReadOnly]
|
|
NativeArray<BezierKnot> m_Knots;
|
|
|
|
[ReadOnly]
|
|
NativeArray<BezierCurve> m_Curves;
|
|
|
|
// As we cannot make a NativeArray of NativeArray all segments lookup tables are stored in a single array
|
|
// each lookup table as a length of k_SegmentResolution and starts at index i = curveIndex * k_SegmentResolution
|
|
[ReadOnly]
|
|
NativeArray<DistanceToInterpolation> m_SegmentLengthsLookupTable;
|
|
|
|
// As we cannot make a NativeArray of NativeArray all segments lookup tables are stored in a single array
|
|
// each lookup table as a length of k_SegmentResolution and starts at index i = curveIndex * k_SegmentResolution
|
|
[ReadOnly]
|
|
NativeArray<float3> m_UpVectorsLookupTable;
|
|
|
|
bool m_Closed;
|
|
float m_Length;
|
|
const int k_SegmentResolution = 30;
|
|
|
|
/// <summary>
|
|
/// A NativeArray of <see cref="BezierKnot"/> that form this Spline.
|
|
/// </summary>
|
|
/// <value>
|
|
/// Returns a reference to the knots array.
|
|
/// </value>
|
|
public NativeArray<BezierKnot> Knots => m_Knots;
|
|
|
|
/// <summary>
|
|
/// A NativeArray of <see cref="BezierCurve"/> that form this Spline.
|
|
/// </summary>
|
|
/// <value>
|
|
/// Returns a reference to the curves array.
|
|
/// </value>
|
|
public NativeArray<BezierCurve> Curves => m_Curves;
|
|
|
|
/// <summary>
|
|
/// Whether the spline is open (has a start and end point) or closed (forms an unbroken loop).
|
|
/// </summary>
|
|
public bool Closed => m_Closed;
|
|
|
|
/// <summary>
|
|
/// Return the number of knots.
|
|
/// </summary>
|
|
public int Count => m_Knots.Length;
|
|
|
|
/// <summary>
|
|
/// Return the sum of all curve lengths, accounting for <see cref="Closed"/> state.
|
|
/// Note that this value is affected by the transform used to create this NativeSpline.
|
|
/// </summary>
|
|
/// <returns>
|
|
/// Returns the sum length of all curves composing this spline, accounting for closed state.
|
|
/// </returns>
|
|
public float GetLength() => m_Length;
|
|
|
|
/// <summary>
|
|
/// Get the knot at <paramref name="index"/>.
|
|
/// </summary>
|
|
/// <param name="index">The zero-based index of the knot.</param>
|
|
public BezierKnot this[int index] => m_Knots[index];
|
|
|
|
/// <summary>
|
|
/// Get an enumerator that iterates through the <see cref="BezierKnot"/> collection.
|
|
/// </summary>
|
|
/// <returns>An IEnumerator that is used to iterate the <see cref="BezierKnot"/> collection.</returns>
|
|
public IEnumerator<BezierKnot> GetEnumerator() => m_Knots.GetEnumerator();
|
|
|
|
/// <summary>
|
|
/// Gets an enumerator that iterates through the <see cref="BezierKnot"/> collection.
|
|
/// </summary>
|
|
/// <returns>An IEnumerator that is used to iterate the <see cref="BezierKnot"/> collection.</returns>
|
|
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
|
|
|
|
/// <summary>
|
|
/// Create a new NativeSpline from a set of <see cref="BezierKnot"/>.
|
|
/// </summary>
|
|
/// <param name="spline">The <see cref="ISpline"/> object to convert to a <see cref="NativeSpline"/>.</param>
|
|
/// <param name="allocator">The memory allocation method to use when reserving space for native arrays.</param>
|
|
public NativeSpline(ISpline spline, Allocator allocator = Allocator.Temp)
|
|
: this(spline, float4x4.identity, false, allocator)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a new NativeSpline from a set of <see cref="BezierKnot"/>.
|
|
/// </summary>
|
|
/// <param name="spline">The <see cref="ISpline"/> object to convert to a <see cref="NativeSpline"/>.</param>
|
|
/// <param name="cacheUpVectors"> Whether to cache the values of the Up vectors along the entire spline to reduce
|
|
/// the time it takes to access those Up vectors. If you set this to true, the creation of native splines might
|
|
/// be less performant because all the Up vectors along the spline are computed. Consider how often you need to
|
|
/// access the values of Up vectors along the spline before you cache them. </param>
|
|
/// <param name="allocator">The memory allocation method to use when reserving space for native arrays.</param>
|
|
public NativeSpline(ISpline spline, bool cacheUpVectors, Allocator allocator = Allocator.Temp)
|
|
: this(spline, float4x4.identity, cacheUpVectors, allocator)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Create a new NativeSpline from a set of <see cref="BezierKnot"/>.
|
|
/// </summary>
|
|
/// <param name="spline">The <see cref="ISpline"/> object to convert to a <see cref="NativeSpline"/>.</param>
|
|
/// <param name="transform">A transform matrix to be applied to the spline knots and tangents.</param>
|
|
/// <param name="allocator">The memory allocation method to use when reserving space for native arrays.</param>
|
|
public NativeSpline(ISpline spline, float4x4 transform, Allocator allocator = Allocator.Temp)
|
|
: this(spline,
|
|
spline is IHasEmptyCurves disconnect ? disconnect.EmptyCurves : null,
|
|
spline.Closed,
|
|
transform,
|
|
false,
|
|
allocator)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a new NativeSpline from a set of <see cref="BezierKnot"/>.
|
|
/// </summary>
|
|
/// <param name="spline">The <see cref="ISpline"/> object to convert to a <see cref="NativeSpline"/>.</param>
|
|
/// <param name="transform">A transform matrix to be applied to the spline knots and tangents.</param>
|
|
/// <param name="cacheUpVectors"> Whether to cache the values of the Up vectors along the entire spline to reduce
|
|
/// the time it takes to access those Up vectors. If you set this to true, the creation of native splines might
|
|
/// be less performant because all the Up vectors along the spline are computed. Consider how often you need to
|
|
/// access the values of Up vectors along the spline before you cache them. </param>
|
|
/// <param name="allocator">The memory allocation method to use when reserving space for native arrays.</param>
|
|
public NativeSpline(ISpline spline, float4x4 transform, bool cacheUpVectors, Allocator allocator = Allocator.Temp)
|
|
: this(spline,
|
|
spline is IHasEmptyCurves disconnect ? disconnect.EmptyCurves : null,
|
|
spline.Closed,
|
|
transform,
|
|
cacheUpVectors,
|
|
allocator)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a new NativeSpline from a set of <see cref="BezierKnot"/>.
|
|
/// </summary>
|
|
/// <param name="knots">A collection of sequential <see cref="BezierKnot"/> forming the spline path.</param>
|
|
/// <param name="closed">Whether the spline is open (has a start and end point) or closed (forms an unbroken loop).</param>
|
|
/// <param name="transform">Apply a transformation matrix to the control <see cref="Knots"/>.</param>
|
|
/// <param name="allocator">The memory allocation method to use when reserving space for native arrays.</param>
|
|
public NativeSpline(
|
|
IReadOnlyList<BezierKnot> knots,
|
|
bool closed,
|
|
float4x4 transform,
|
|
Allocator allocator = Allocator.Temp) : this(knots, null, closed, transform, false, allocator)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a new NativeSpline from a set of <see cref="BezierKnot"/>.
|
|
/// </summary>
|
|
/// <param name="knots">A collection of sequential <see cref="BezierKnot"/> forming the spline path.</param>
|
|
/// <param name="closed">Whether the spline is open (has a start and end point) or closed (forms an unbroken loop).</param>
|
|
/// <param name="transform">Apply a transformation matrix to the control <see cref="Knots"/>.</param>
|
|
/// <param name="cacheUpVectors"> Whether to cache the values of the Up vectors along the entire spline to reduce
|
|
/// the time it takes to access those Up vectors. If you set this to true, the creation of native splines might
|
|
/// be less performant because all the Up vectors along the spline are computed. Consider how often you need to
|
|
/// access the values of Up vectors along the spline before you cache them. </param>
|
|
/// <param name="allocator">The memory allocation method to use when reserving space for native arrays.</param>
|
|
public NativeSpline(
|
|
IReadOnlyList<BezierKnot> knots,
|
|
bool closed,
|
|
float4x4 transform,
|
|
bool cacheUpVectors,
|
|
Allocator allocator = Allocator.Temp) : this(knots, null, closed, transform, cacheUpVectors, allocator)
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Create a new NativeSpline from a set of <see cref="BezierKnot"/>.
|
|
/// </summary>
|
|
/// <param name="knots">A collection of sequential <see cref="BezierKnot"/> forming the spline path.</param>
|
|
/// <param name="splits">A collection of knot indices that should be considered degenerate curves for the
|
|
/// purpose of creating a non-interpolated gap between curves.</param>
|
|
/// <param name="closed">Whether the spline is open (has a start and end point) or closed (forms an unbroken loop).</param>
|
|
/// <param name="transform">Apply a transformation matrix to the control <see cref="Knots"/>.</param>
|
|
/// <param name="allocator">The memory allocation method to use when reserving space for native arrays.</param>
|
|
public NativeSpline(IReadOnlyList<BezierKnot> knots, IReadOnlyList<int> splits, bool closed, float4x4 transform, Allocator allocator = Allocator.Temp)
|
|
: this(knots, splits, closed, transform, false, allocator)
|
|
{ }
|
|
|
|
/// <summary>
|
|
/// Create a new NativeSpline from a set of <see cref="BezierKnot"/>.
|
|
/// </summary>
|
|
/// <param name="knots">A collection of sequential <see cref="BezierKnot"/> forming the spline path.</param>
|
|
/// <param name="splits">A collection of knot indices that should be considered degenerate curves for the
|
|
/// purpose of creating a non-interpolated gap between curves.</param>
|
|
/// <param name="closed">Whether the spline is open (has a start and end point) or closed (forms an unbroken loop).</param>
|
|
/// <param name="transform">Apply a transformation matrix to the control <see cref="Knots"/>.</param>
|
|
/// <param name="cacheUpVectors"> Whether to cache the values of the Up vectors along the entire spline to reduce
|
|
/// the time it takes to access those Up vectors. If you set this to true, the creation of native splines might
|
|
/// be less performant because all the Up vectors along the spline are computed. Consider how often you need to
|
|
/// access the values of Up vectors along the spline before you cache them. </param>
|
|
/// <param name="allocator">The memory allocation method to use when reserving space for native arrays.</param>
|
|
public NativeSpline(IReadOnlyList<BezierKnot> knots, IReadOnlyList<int> splits, bool closed, float4x4 transform, bool cacheUpVectors, Allocator allocator = Allocator.Temp)
|
|
{
|
|
int knotCount = knots.Count;
|
|
m_Knots = new NativeArray<BezierKnot>(knotCount, allocator);
|
|
m_Curves = new NativeArray<BezierCurve>(knotCount, allocator);
|
|
m_SegmentLengthsLookupTable = new NativeArray<DistanceToInterpolation>(knotCount * k_SegmentResolution, allocator);
|
|
m_Closed = closed;
|
|
m_Length = 0f;
|
|
|
|
//Costly to do this for temporary NativeSpline that does not require to access/compute up vectors
|
|
m_UpVectorsLookupTable = new NativeArray<float3>(cacheUpVectors ? knotCount * k_SegmentResolution : 0, allocator);
|
|
|
|
// As we cannot make a NativeArray of NativeArray all segments lookup tables are stored in a single array
|
|
// each lookup table as a length of k_SegmentResolution and starts at index i = curveIndex * k_SegmentResolution
|
|
|
|
var distanceToTimes = new NativeArray<DistanceToInterpolation>(k_SegmentResolution, Allocator.Temp);
|
|
var upVectors = cacheUpVectors ? new NativeArray<float3>(k_SegmentResolution, Allocator.Temp) : default;
|
|
|
|
if (knotCount > 0)
|
|
{
|
|
BezierKnot cur = knots[0].Transform(transform);
|
|
for (int i = 0; i < knotCount; ++i)
|
|
{
|
|
BezierKnot next = knots[(i + 1) % knotCount].Transform(transform);
|
|
m_Knots[i] = cur;
|
|
|
|
if (splits != null && splits.Contains(i))
|
|
{
|
|
m_Curves[i] = new BezierCurve(new BezierKnot(cur.Position), new BezierKnot(cur.Position));
|
|
var up = cacheUpVectors ? math.rotate(cur.Rotation, math.up()) : float3.zero;
|
|
for (int n = 0; n < k_SegmentResolution; ++n)
|
|
{
|
|
//Cache Distance in case of a split is empty
|
|
distanceToTimes[n] = new DistanceToInterpolation();
|
|
//up Vectors in case of a split is the knot up vector
|
|
if(cacheUpVectors)
|
|
upVectors[n] = up;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_Curves[i] = new BezierCurve(cur, next);
|
|
CurveUtility.CalculateCurveLengths(m_Curves[i], distanceToTimes);
|
|
|
|
if (cacheUpVectors)
|
|
{
|
|
var curveStartUp = math.rotate(cur.Rotation, math.up());
|
|
var curveEndUp = math.rotate(next.Rotation, math.up());
|
|
CurveUtility.EvaluateUpVectors(m_Curves[i], curveStartUp, curveEndUp, upVectors);
|
|
}
|
|
}
|
|
|
|
if (m_Closed || i < knotCount - 1)
|
|
m_Length += distanceToTimes[k_SegmentResolution - 1].Distance;
|
|
|
|
for (int index = 0; index < k_SegmentResolution; index++)
|
|
{
|
|
m_SegmentLengthsLookupTable[i * k_SegmentResolution + index] = distanceToTimes[index];
|
|
|
|
if(cacheUpVectors)
|
|
m_UpVectorsLookupTable[i * k_SegmentResolution + index] = upVectors[index];
|
|
}
|
|
|
|
cur = next;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get a <see cref="BezierCurve"/> from a knot index.
|
|
/// </summary>
|
|
/// <param name="index">The knot index that serves as the first control point for this curve.</param>
|
|
/// <returns>
|
|
/// A <see cref="BezierCurve"/> formed by the knot at index and the next knot.
|
|
/// </returns>
|
|
public BezierCurve GetCurve(int index) => m_Curves[index];
|
|
|
|
|
|
/// <summary>
|
|
/// Get the length of a <see cref="BezierCurve"/>.
|
|
/// </summary>
|
|
/// <param name="curveIndex">The 0 based index of the curve to find length for.</param>
|
|
/// <returns>The length of the bezier curve at index.</returns>
|
|
public float GetCurveLength(int curveIndex)
|
|
{
|
|
return m_SegmentLengthsLookupTable[curveIndex * k_SegmentResolution + k_SegmentResolution - 1].Distance;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the up vector for a t ratio on the curve.
|
|
/// </summary>
|
|
/// <param name="index">The index of the curve for which the length needs to be retrieved.</param>
|
|
/// <param name="t">A value between 0 and 1 representing the ratio along the spline.</param>
|
|
/// <returns>
|
|
/// Returns the up vector at the t ratio of the curve of index 'index'.
|
|
/// </returns>
|
|
public float3 GetCurveUpVector(int index, float t)
|
|
{
|
|
// Value is not cached, compute the value directly on demand
|
|
if (m_UpVectorsLookupTable.Length == 0)
|
|
return this.CalculateUpVector(index, t);
|
|
|
|
var curveIndex = index * k_SegmentResolution;
|
|
var offset = 1f / (float)(k_SegmentResolution - 1);
|
|
var curveT = 0f;
|
|
for (int i = 0; i < k_SegmentResolution; i++)
|
|
{
|
|
if (t <= curveT + offset)
|
|
{
|
|
var value = math.lerp(m_UpVectorsLookupTable[curveIndex + i],
|
|
m_UpVectorsLookupTable[curveIndex + i + 1],
|
|
(t - curveT) / offset);
|
|
|
|
return value;
|
|
}
|
|
curveT += offset;
|
|
}
|
|
|
|
//Otherwise, no value has been found, return the one at the end of the segment
|
|
return m_UpVectorsLookupTable[curveIndex + k_SegmentResolution - 1];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Release allocated resources.
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
m_Knots.Dispose();
|
|
m_Curves.Dispose();
|
|
m_SegmentLengthsLookupTable.Dispose();
|
|
m_UpVectorsLookupTable.Dispose();
|
|
}
|
|
|
|
// Wrapper around NativeSlice<T> because the native type does not implement IReadOnlyList<T>.
|
|
struct Slice<T> : IReadOnlyList<T> where T : struct
|
|
{
|
|
NativeSlice<T> m_Slice;
|
|
public Slice(NativeArray<T> array, int start, int count) { m_Slice = new NativeSlice<T>(array, start, count); }
|
|
public IEnumerator<T> GetEnumerator() => m_Slice.GetEnumerator();
|
|
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
|
|
public int Count => m_Slice.Length;
|
|
public T this[int index] => m_Slice[index];
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the normalized interpolation (t) corresponding to a distance on a <see cref="BezierCurve"/>.
|
|
/// </summary>
|
|
/// <param name="curveIndex"> The zero-based index of the curve.</param>
|
|
/// <param name="curveDistance">The curve-relative distance to convert to an interpolation ratio (also referred to as 't').</param>
|
|
/// <returns> The normalized interpolation ratio associated to distance on the designated curve.</returns>
|
|
public float GetCurveInterpolation(int curveIndex, float curveDistance)
|
|
{
|
|
if(curveIndex <0 || curveIndex >= m_SegmentLengthsLookupTable.Length || curveDistance <= 0)
|
|
return 0f;
|
|
var curveLength = GetCurveLength(curveIndex);
|
|
if(curveDistance >= curveLength)
|
|
return 1f;
|
|
var startIndex = curveIndex * k_SegmentResolution;
|
|
var slice = new Slice<DistanceToInterpolation>(m_SegmentLengthsLookupTable, startIndex, k_SegmentResolution);
|
|
return CurveUtility.GetDistanceToInterpolation(slice, curveDistance);
|
|
}
|
|
}
|
|
}
|