861 lines
51 KiB
Plaintext
861 lines
51 KiB
Plaintext
// This file is generated. Do not modify by hand.
|
|
// XML documentation file not found. To check if public methods have XML comments,
|
|
// make sure the XML doc file is present and located next to the scraped dll
|
|
namespace UnityEngine.Splines
|
|
{
|
|
public struct BezierCurve : System.IEquatable<BezierCurve>
|
|
{
|
|
public Unity.Mathematics.float3 P0;
|
|
public Unity.Mathematics.float3 P1;
|
|
public Unity.Mathematics.float3 P2;
|
|
public Unity.Mathematics.float3 P3;
|
|
public Unity.Mathematics.float3 Tangent0 { get; set; }
|
|
public Unity.Mathematics.float3 Tangent1 { get; set; }
|
|
public BezierCurve(Unity.Mathematics.float3 p0, Unity.Mathematics.float3 p1) {}
|
|
public BezierCurve(BezierKnot a, BezierKnot b) {}
|
|
public BezierCurve(Unity.Mathematics.float3 p0, Unity.Mathematics.float3 p1, Unity.Mathematics.float3 p2) {}
|
|
public BezierCurve(Unity.Mathematics.float3 p0, Unity.Mathematics.float3 p1, Unity.Mathematics.float3 p2, Unity.Mathematics.float3 p3) {}
|
|
public override bool Equals(object obj);
|
|
public bool Equals(BezierCurve other);
|
|
public static BezierCurve FromTangent(Unity.Mathematics.float3 pointA, Unity.Mathematics.float3 tangentOutA, Unity.Mathematics.float3 pointB, Unity.Mathematics.float3 tangentInB);
|
|
public override int GetHashCode();
|
|
public BezierCurve GetInvertedCurve();
|
|
public static bool operator ==(BezierCurve left, BezierCurve right);
|
|
public static bool operator !=(BezierCurve left, BezierCurve right);
|
|
public BezierCurve Transform(Unity.Mathematics.float4x4 matrix);
|
|
}
|
|
|
|
public struct BezierKnot : ISerializationCallbackReceiver, System.IEquatable<BezierKnot>
|
|
{
|
|
public Unity.Mathematics.float3 Position;
|
|
public Unity.Mathematics.quaternion Rotation;
|
|
public Unity.Mathematics.float3 TangentIn;
|
|
public Unity.Mathematics.float3 TangentOut;
|
|
public BezierKnot(Unity.Mathematics.float3 position) {}
|
|
public BezierKnot(Unity.Mathematics.float3 position, Unity.Mathematics.float3 tangentIn, Unity.Mathematics.float3 tangentOut) {}
|
|
public BezierKnot(Unity.Mathematics.float3 position, Unity.Mathematics.float3 tangentIn, Unity.Mathematics.float3 tangentOut, Unity.Mathematics.quaternion rotation) {}
|
|
public override bool Equals(object obj);
|
|
public bool Equals(BezierKnot other);
|
|
public override int GetHashCode();
|
|
public void OnAfterDeserialize();
|
|
public void OnBeforeSerialize();
|
|
public static BezierKnot operator +(BezierKnot knot, Unity.Mathematics.float3 rhs);
|
|
public static BezierKnot operator -(BezierKnot knot, Unity.Mathematics.float3 rhs);
|
|
public override string ToString();
|
|
public BezierKnot Transform(Unity.Mathematics.float4x4 matrix);
|
|
}
|
|
|
|
public enum BezierTangent
|
|
{
|
|
In = 0,
|
|
Out = 1,
|
|
}
|
|
|
|
public static class CurveUtility
|
|
{
|
|
public static float ApproximateLength(BezierCurve curve);
|
|
public static void CalculateCurveLengths(BezierCurve curve, DistanceToInterpolation[] lookupTable);
|
|
public static float CalculateLength(BezierCurve curve, int resolution = 30);
|
|
public static Unity.Mathematics.float3 EvaluateAcceleration(BezierCurve curve, float t);
|
|
public static float EvaluateCurvature(BezierCurve curve, float t);
|
|
public static Unity.Mathematics.float3 EvaluatePosition(BezierCurve curve, float t);
|
|
public static Unity.Mathematics.float3 EvaluateTangent(BezierCurve curve, float t);
|
|
public static float GetDistanceToInterpolation<T>(T lut, float distance) where T : System.Collections.Generic.IReadOnlyList<DistanceToInterpolation>;
|
|
public static float GetDistanceToInterpolation(BezierCurve curve, float distance);
|
|
public static Unity.Mathematics.float3 GetNearestPoint(BezierCurve curve, Ray ray, int resolution = 16);
|
|
public static float GetNearestPoint(BezierCurve curve, Ray ray, out Unity.Mathematics.float3 position, out float interpolation, int resolution = 16);
|
|
public static void Split(BezierCurve curve, float t, out BezierCurve left, out BezierCurve right);
|
|
}
|
|
|
|
public struct DataPoint<TDataType> : IDataPoint, System.IComparable<float>, System.IComparable<UnityEngine.Splines.DataPoint<TDataType>>
|
|
{
|
|
public float Index { get; set; }
|
|
public TDataType Value { get; set; }
|
|
public DataPoint(float index, TDataType value) {}
|
|
public int CompareTo(float other);
|
|
public int CompareTo(UnityEngine.Splines.DataPoint<TDataType> other);
|
|
public override string ToString();
|
|
}
|
|
|
|
public struct DistanceToInterpolation
|
|
{
|
|
public float Distance;
|
|
public float T;
|
|
}
|
|
|
|
public class EmbeddedSplineData
|
|
{
|
|
public SplineContainer Container { get; set; }
|
|
public string Key { get; set; }
|
|
public int SplineIndex { get; set; }
|
|
public EmbeddedSplineDataType Type { get; set; }
|
|
public EmbeddedSplineData() {}
|
|
public EmbeddedSplineData(string key, EmbeddedSplineDataType type, SplineContainer container = default(SplineContainer), int splineIndex = 0) {}
|
|
public UnityEngine.Splines.SplineData<Unity.Mathematics.float4> GetOrCreateFloat4Data();
|
|
public UnityEngine.Splines.SplineData<float> GetOrCreateFloatData();
|
|
public UnityEngine.Splines.SplineData<int> GetOrCreateIntData();
|
|
public UnityEngine.Splines.SplineData<UnityEngine.Object> GetOrCreateObjectData();
|
|
public bool TryGetFloat4Data(out UnityEngine.Splines.SplineData<Unity.Mathematics.float4> data);
|
|
public bool TryGetFloatData(out UnityEngine.Splines.SplineData<float> data);
|
|
public bool TryGetIntData(out UnityEngine.Splines.SplineData<int> data);
|
|
public bool TryGetObjectData(out UnityEngine.Splines.SplineData<UnityEngine.Object> data);
|
|
public bool TryGetSpline(out Spline spline);
|
|
}
|
|
|
|
[System.Flags] public enum EmbeddedSplineDataField
|
|
{
|
|
All = 255,
|
|
Container = 1,
|
|
Key = 4,
|
|
SplineIndex = 2,
|
|
Type = 8,
|
|
}
|
|
|
|
public class EmbeddedSplineDataFieldsAttribute : PropertyAttribute
|
|
{
|
|
public readonly EmbeddedSplineDataField Fields;
|
|
public EmbeddedSplineDataFieldsAttribute(EmbeddedSplineDataField fields) {}
|
|
}
|
|
|
|
public enum EmbeddedSplineDataType
|
|
{
|
|
Float = 1,
|
|
Float4 = 2,
|
|
Int = 0,
|
|
Object = 3,
|
|
}
|
|
|
|
public struct GetPosition : Unity.Jobs.IJobParallelFor
|
|
{
|
|
[Unity.Collections.WriteOnly] public Unity.Collections.NativeArray<Unity.Mathematics.float3> Positions;
|
|
[Unity.Collections.ReadOnly] public NativeSpline Spline;
|
|
public void Execute(int index);
|
|
}
|
|
|
|
public struct GetPositionTangentNormal : Unity.Jobs.IJobParallelFor
|
|
{
|
|
[Unity.Collections.WriteOnly] public Unity.Collections.NativeArray<Unity.Mathematics.float3> Normals;
|
|
[Unity.Collections.WriteOnly] public Unity.Collections.NativeArray<Unity.Mathematics.float3> Positions;
|
|
[Unity.Collections.ReadOnly] public NativeSpline Spline;
|
|
[Unity.Collections.WriteOnly] public Unity.Collections.NativeArray<Unity.Mathematics.float3> Tangents;
|
|
public void Execute(int index);
|
|
}
|
|
|
|
public interface IDataPoint
|
|
{
|
|
public float Index { get; set; }
|
|
}
|
|
|
|
public interface IHasEmptyCurves
|
|
{
|
|
public System.Collections.Generic.IReadOnlyList<int> EmptyCurves { get; }
|
|
}
|
|
|
|
public interface IInterpolator<T>
|
|
{
|
|
public T Interpolate(T from, T to, float t);
|
|
}
|
|
|
|
public static class InterpolatorUtility
|
|
{
|
|
public static UnityEngine.Splines.IInterpolator<Color> LerpColor { get; }
|
|
public static UnityEngine.Splines.IInterpolator<float> LerpFloat { get; }
|
|
public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float2> LerpFloat2 { get; }
|
|
public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float3> LerpFloat3 { get; }
|
|
public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float4> LerpFloat4 { get; }
|
|
public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.quaternion> LerpQuaternion { get; }
|
|
public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float2> SlerpFloat2 { get; }
|
|
public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float3> SlerpFloat3 { get; }
|
|
public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.quaternion> SlerpQuaternion { get; }
|
|
public static UnityEngine.Splines.IInterpolator<float> SmoothStepFloat { get; }
|
|
public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float2> SmoothStepFloat2 { get; }
|
|
public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float3> SmoothStepFloat3 { get; }
|
|
public static UnityEngine.Splines.IInterpolator<Unity.Mathematics.float4> SmoothStepFloat4 { get; }
|
|
}
|
|
|
|
public interface ISpline : System.Collections.Generic.IEnumerable<BezierKnot>, System.Collections.Generic.IReadOnlyCollection<BezierKnot>, System.Collections.Generic.IReadOnlyList<BezierKnot>, System.Collections.IEnumerable
|
|
{
|
|
public bool Closed { get; }
|
|
public BezierCurve GetCurve(int index);
|
|
public float GetCurveInterpolation(int curveIndex, float curveDistance);
|
|
public float GetCurveLength(int index);
|
|
public float GetLength();
|
|
}
|
|
|
|
public interface ISplineContainer
|
|
{
|
|
public KnotLinkCollection KnotLinkCollection { get; }
|
|
public System.Collections.Generic.IReadOnlyList<Spline> Splines { get; set; }
|
|
}
|
|
|
|
[System.Obsolete(@"Use ISplineContainer instead.")] public interface ISplineProvider
|
|
{
|
|
public System.Collections.Generic.IEnumerable<Spline> Splines { get; }
|
|
}
|
|
|
|
public sealed class KnotLinkCollection
|
|
{
|
|
public int Count { get; }
|
|
public KnotLinkCollection() {}
|
|
public void Clear();
|
|
public System.Collections.Generic.IReadOnlyList<SplineKnotIndex> GetKnotLinks(SplineKnotIndex knotIndex);
|
|
public void KnotIndexChanged(SplineKnotIndex previousIndex, SplineKnotIndex newIndex);
|
|
public void KnotIndexChanged(int splineIndex, int previousKnotIndex, int newKnotIndex);
|
|
public void KnotInserted(SplineKnotIndex index);
|
|
public void KnotInserted(int splineIndex, int knotIndex);
|
|
public void KnotRemoved(SplineKnotIndex index);
|
|
public void KnotRemoved(int splineIndex, int knotIndex);
|
|
public void Link(SplineKnotIndex knotA, SplineKnotIndex knotB);
|
|
public void ShiftKnotIndices(SplineKnotIndex index, int offset);
|
|
public void SplineIndexChanged(int previousIndex, int newIndex);
|
|
public void SplineRemoved(int splineIndex);
|
|
public bool TryGetKnotLinks(SplineKnotIndex knotIndex, out System.Collections.Generic.IReadOnlyList<SplineKnotIndex> linkedKnots);
|
|
public void Unlink(SplineKnotIndex knot);
|
|
}
|
|
|
|
public struct NativeSpline : ISpline, System.Collections.Generic.IEnumerable<BezierKnot>, System.Collections.Generic.IReadOnlyCollection<BezierKnot>, System.Collections.Generic.IReadOnlyList<BezierKnot>, System.Collections.IEnumerable, System.IDisposable
|
|
{
|
|
public bool Closed { get; }
|
|
public int Count { get; }
|
|
public Unity.Collections.NativeArray<BezierCurve> Curves { get; }
|
|
public BezierKnot this[int index] { get; }
|
|
public Unity.Collections.NativeArray<BezierKnot> Knots { get; }
|
|
public NativeSpline(ISpline spline, Unity.Collections.Allocator allocator = Unity.Collections.Allocator.Temp) {}
|
|
public NativeSpline(ISpline spline, Unity.Mathematics.float4x4 transform, Unity.Collections.Allocator allocator = Unity.Collections.Allocator.Temp) {}
|
|
public NativeSpline(System.Collections.Generic.IReadOnlyList<BezierKnot> knots, bool closed, Unity.Mathematics.float4x4 transform, Unity.Collections.Allocator allocator = Unity.Collections.Allocator.Temp) {}
|
|
public NativeSpline(System.Collections.Generic.IReadOnlyList<BezierKnot> knots, System.Collections.Generic.IReadOnlyList<int> splits, bool closed, Unity.Mathematics.float4x4 transform, Unity.Collections.Allocator allocator = Unity.Collections.Allocator.Temp) {}
|
|
public void Dispose();
|
|
public BezierCurve GetCurve(int index);
|
|
public float GetCurveInterpolation(int curveIndex, float curveDistance);
|
|
public float GetCurveLength(int curveIndex);
|
|
public System.Collections.Generic.IEnumerator<BezierKnot> GetEnumerator();
|
|
public float GetLength();
|
|
}
|
|
|
|
public enum PathIndexUnit
|
|
{
|
|
Distance = 0,
|
|
Knot = 2,
|
|
Normalized = 1,
|
|
}
|
|
|
|
public enum SliceDirection
|
|
{
|
|
Backward = 1,
|
|
Forward = 0,
|
|
}
|
|
|
|
public class Spline : ISpline, System.Collections.Generic.ICollection<BezierKnot>, System.Collections.Generic.IEnumerable<BezierKnot>, System.Collections.Generic.IList<BezierKnot>, System.Collections.Generic.IReadOnlyCollection<BezierKnot>, System.Collections.Generic.IReadOnlyList<BezierKnot>, System.Collections.IEnumerable
|
|
{
|
|
[System.Obsolete(@"Deprecated, use Changed instead.")] public event System.Action changed;
|
|
public static event System.Action<Spline, int, SplineModification> Changed;
|
|
public bool Closed { get; set; }
|
|
public int Count { get; }
|
|
[System.Obsolete(@"Use GetTangentMode and SetTangentMode.")] public SplineType EditType { get; set; }
|
|
public bool IsReadOnly { get; }
|
|
public BezierKnot this[int index] { get; set; }
|
|
public System.Collections.Generic.IEnumerable<BezierKnot> Knots { get; set; }
|
|
public Spline() {}
|
|
public Spline(Spline spline) {}
|
|
public Spline(System.Collections.Generic.IEnumerable<BezierKnot> knots, bool closed = false) {}
|
|
public Spline(int knotCapacity, bool closed = false) {}
|
|
public void Add(BezierKnot item);
|
|
public void Add(BezierKnot item, TangentMode mode);
|
|
public void Add(BezierKnot item, TangentMode mode, float tension);
|
|
public void Clear();
|
|
public bool Contains(BezierKnot item);
|
|
public void Copy(Spline copyFrom);
|
|
public void CopyTo(BezierKnot[] array, int arrayIndex);
|
|
public void EnforceTangentModeNoNotify(int index);
|
|
public void EnforceTangentModeNoNotify(SplineRange range);
|
|
public float GetAutoSmoothTension(int index);
|
|
public BezierCurve GetCurve(int index);
|
|
public float GetCurveInterpolation(int curveIndex, float curveDistance);
|
|
public float GetCurveLength(int index);
|
|
public System.Collections.Generic.IEnumerator<BezierKnot> GetEnumerator();
|
|
public System.Collections.Generic.IEnumerable<string> GetFloat4DataKeys();
|
|
public System.Collections.Generic.IEnumerable<UnityEngine.Splines.SplineData<Unity.Mathematics.float4>> GetFloat4DataValues();
|
|
public System.Collections.Generic.IEnumerable<string> GetFloatDataKeys();
|
|
public System.Collections.Generic.IEnumerable<UnityEngine.Splines.SplineData<float>> GetFloatDataValues();
|
|
public System.Collections.Generic.IEnumerable<string> GetIntDataKeys();
|
|
public System.Collections.Generic.IEnumerable<UnityEngine.Splines.SplineData<int>> GetIntDataValues();
|
|
public float GetLength();
|
|
public System.Collections.Generic.IEnumerable<string> GetObjectDataKeys();
|
|
public System.Collections.Generic.IEnumerable<UnityEngine.Splines.SplineData<UnityEngine.Object>> GetObjectDataValues();
|
|
public UnityEngine.Splines.SplineData<Unity.Mathematics.float4> GetOrCreateFloat4Data(string key);
|
|
public UnityEngine.Splines.SplineData<float> GetOrCreateFloatData(string key);
|
|
public UnityEngine.Splines.SplineData<int> GetOrCreateIntData(string key);
|
|
public UnityEngine.Splines.SplineData<UnityEngine.Object> GetOrCreateObjectData(string key);
|
|
public System.Collections.Generic.IEnumerable<string> GetSplineDataKeys(EmbeddedSplineDataType type);
|
|
public TangentMode GetTangentMode(int index);
|
|
public int IndexOf(BezierKnot item);
|
|
public void Insert(int index, BezierKnot knot);
|
|
public void Insert(int index, BezierKnot knot, TangentMode mode);
|
|
public void Insert(int index, BezierKnot knot, TangentMode mode, float tension);
|
|
protected virtual void OnSplineChanged();
|
|
public bool Remove(BezierKnot item);
|
|
public void RemoveAt(int index);
|
|
public bool RemoveFloat4Data(string key);
|
|
public bool RemoveFloatData(string key);
|
|
public bool RemoveIntData(string key);
|
|
public bool RemoveObjectData(string key);
|
|
public void Resize(int newSize);
|
|
public void SetAutoSmoothTension(int index, float tension);
|
|
public void SetAutoSmoothTension(SplineRange range, float tension);
|
|
public void SetAutoSmoothTensionNoNotify(int index, float tension);
|
|
public void SetAutoSmoothTensionNoNotify(SplineRange range, float tension);
|
|
public void SetFloat4Data(string key, UnityEngine.Splines.SplineData<Unity.Mathematics.float4> value);
|
|
public void SetFloatData(string key, UnityEngine.Splines.SplineData<float> value);
|
|
public void SetIntData(string key, UnityEngine.Splines.SplineData<int> value);
|
|
public void SetKnot(int index, BezierKnot value, BezierTangent main = BezierTangent.Out);
|
|
public void SetKnotNoNotify(int index, BezierKnot value, BezierTangent main = BezierTangent.Out);
|
|
public void SetObjectData(string key, UnityEngine.Splines.SplineData<UnityEngine.Object> value);
|
|
public void SetTangentMode(TangentMode mode);
|
|
public void SetTangentMode(int index, TangentMode mode, BezierTangent main = BezierTangent.Out);
|
|
public void SetTangentMode(SplineRange range, TangentMode mode, BezierTangent main = BezierTangent.Out);
|
|
public void SetTangentModeNoNotify(int index, TangentMode mode, BezierTangent main = BezierTangent.Out);
|
|
public BezierKnot[] ToArray();
|
|
public bool TryGetFloat4Data(string key, out UnityEngine.Splines.SplineData<Unity.Mathematics.float4> data);
|
|
public bool TryGetFloatData(string key, out UnityEngine.Splines.SplineData<float> data);
|
|
public bool TryGetIntData(string key, out UnityEngine.Splines.SplineData<int> data);
|
|
public bool TryGetObjectData(string key, out UnityEngine.Splines.SplineData<UnityEngine.Object> data);
|
|
public void Warmup();
|
|
}
|
|
|
|
[AddComponentMenu(@"Splines/Spline Animate")] public class SplineAnimate : SplineComponent
|
|
{
|
|
[System.Obsolete(@"Use Updated instead.", false)] public event System.Action<Vector3, Quaternion> onUpdated;
|
|
public event System.Action<Vector3, Quaternion> Updated;
|
|
public SplineAnimate.AlignmentMode Alignment { get; set; }
|
|
[System.Obsolete(@"Use Alignment instead.", false)] public SplineAnimate.AlignmentMode alignmentMode { get; }
|
|
public SplineAnimate.Method AnimationMethod { get; set; }
|
|
public SplineContainer Container { get; set; }
|
|
[System.Obsolete(@"Use Duration instead.", false)] public float duration { get; }
|
|
public float Duration { get; set; }
|
|
public SplineAnimate.EasingMode Easing { get; set; }
|
|
[System.Obsolete(@"Use Easing instead.", false)] public SplineAnimate.EasingMode easingMode { get; }
|
|
[System.Obsolete(@"Use ElapsedTime instead.", false)] public float elapsedTime { get; }
|
|
public float ElapsedTime { get; set; }
|
|
[System.Obsolete(@"Use IsPlaying instead.", false)] public bool isPlaying { get; }
|
|
public bool IsPlaying { get; }
|
|
public SplineAnimate.LoopMode Loop { get; set; }
|
|
[System.Obsolete(@"Use Loop instead.", false)] public SplineAnimate.LoopMode loopMode { get; }
|
|
[System.Obsolete(@"Use MaxSpeed instead.", false)] public float maxSpeed { get; }
|
|
public float MaxSpeed { get; set; }
|
|
[System.Obsolete(@"Use AnimationMethod instead.", false)] public SplineAnimate.Method method { get; }
|
|
[System.Obsolete(@"Use NormalizedTime instead.", false)] public float normalizedTime { get; }
|
|
public float NormalizedTime { get; set; }
|
|
[System.Obsolete(@"Use ObjectForwardAxis instead.", false)] public SplineComponent.AlignAxis objectForwardAxis { get; }
|
|
public SplineComponent.AlignAxis ObjectForwardAxis { get; set; }
|
|
[System.Obsolete(@"Use ObjectUpAxis instead.", false)] public SplineComponent.AlignAxis objectUpAxis { get; }
|
|
public SplineComponent.AlignAxis ObjectUpAxis { get; set; }
|
|
[System.Obsolete(@"Use PlayOnAwake instead.", false)] public bool playOnAwake { get; }
|
|
public bool PlayOnAwake { get; set; }
|
|
[System.Obsolete(@"Use Container instead.", false)] public SplineContainer splineContainer { get; }
|
|
public float StartOffset { get; set; }
|
|
public SplineAnimate() {}
|
|
public void Pause();
|
|
public void Play();
|
|
public void Restart(bool autoplay);
|
|
public void Update();
|
|
public enum AlignmentMode
|
|
{
|
|
[InspectorName(@"None")] None = 0,
|
|
[InspectorName(@"Spline Element")] SplineElement = 1,
|
|
[InspectorName(@"Spline Object")] SplineObject = 2,
|
|
[InspectorName(@"World Space")] World = 3,
|
|
}
|
|
public enum EasingMode
|
|
{
|
|
[InspectorName(@"Ease In Only")] EaseIn = 1,
|
|
[InspectorName(@"Ease In-Out")] EaseInOut = 3,
|
|
[InspectorName(@"Ease Out Only")] EaseOut = 2,
|
|
[InspectorName(@"None")] None = 0,
|
|
}
|
|
public enum LoopMode
|
|
{
|
|
[InspectorName(@"Loop Continuous")] Loop = 1,
|
|
[InspectorName(@"Ease In Then Continuous")] LoopEaseInOnce = 2,
|
|
[InspectorName(@"Once")] Once = 0,
|
|
[InspectorName(@"Ping Pong")] PingPong = 3,
|
|
}
|
|
public enum Method
|
|
{
|
|
Speed = 1,
|
|
Time = 0,
|
|
}
|
|
}
|
|
|
|
public abstract class SplineComponent : MonoBehaviour
|
|
{
|
|
protected SplineComponent() {}
|
|
protected Unity.Mathematics.float3 GetAxis(SplineComponent.AlignAxis axis);
|
|
public enum AlignAxis
|
|
{
|
|
[InspectorName(@"Object X-")] NegativeXAxis = 3,
|
|
[InspectorName(@"Object Y-")] NegativeYAxis = 4,
|
|
[InspectorName(@"Object Z-")] NegativeZAxis = 5,
|
|
[InspectorName(@"Object X+")] XAxis = 0,
|
|
[InspectorName(@"Object Y+")] YAxis = 1,
|
|
[InspectorName(@"Object Z+")] ZAxis = 2,
|
|
}
|
|
}
|
|
|
|
public struct SplineComputeBufferScope<T> : System.IDisposable where T : ISpline
|
|
{
|
|
public ComputeBuffer CurveLengths { get; }
|
|
public ComputeBuffer Curves { get; }
|
|
public Vector4 Info { get; }
|
|
public SplineComputeBufferScope(T spline) {}
|
|
public void Bind(ComputeShader shader, int kernel, string info, string curves, string lengths);
|
|
public void Dispose();
|
|
public void Upload();
|
|
}
|
|
|
|
[AddComponentMenu(@"Splines/Spline")] [ExecuteInEditMode] [Icon(@"Packages/com.unity.splines/Editor/Resources/Icons/SplineComponent.png")] public sealed class SplineContainer : MonoBehaviour, ISerializationCallbackReceiver, ISplineContainer
|
|
{
|
|
public static event System.Action<SplineContainer, int> SplineAdded;
|
|
public static event System.Action<SplineContainer, int> SplineRemoved;
|
|
public static event System.Action<SplineContainer, int, int> SplineReordered;
|
|
public Spline this[int index] { get; }
|
|
public KnotLinkCollection KnotLinkCollection { get; }
|
|
public Spline Spline { get; set; }
|
|
public System.Collections.Generic.IReadOnlyList<Spline> Splines { get; set; }
|
|
public SplineContainer() {}
|
|
public float CalculateLength();
|
|
public float CalculateLength(int splineIndex);
|
|
public bool Evaluate(float t, out Unity.Mathematics.float3 position, out Unity.Mathematics.float3 tangent, out Unity.Mathematics.float3 upVector);
|
|
public bool Evaluate(int splineIndex, float t, out Unity.Mathematics.float3 position, out Unity.Mathematics.float3 tangent, out Unity.Mathematics.float3 upVector);
|
|
public bool Evaluate<T>(T spline, float t, out Unity.Mathematics.float3 position, out Unity.Mathematics.float3 tangent, out Unity.Mathematics.float3 upVector) where T : ISpline;
|
|
public Unity.Mathematics.float3 EvaluateAcceleration(float t);
|
|
public Unity.Mathematics.float3 EvaluateAcceleration(int splineIndex, float t);
|
|
public Unity.Mathematics.float3 EvaluateAcceleration<T>(T spline, float t) where T : ISpline;
|
|
public Unity.Mathematics.float3 EvaluatePosition(float t);
|
|
public Unity.Mathematics.float3 EvaluatePosition(int splineIndex, float t);
|
|
public Unity.Mathematics.float3 EvaluatePosition<T>(T spline, float t) where T : ISpline;
|
|
public Unity.Mathematics.float3 EvaluateTangent(float t);
|
|
public Unity.Mathematics.float3 EvaluateTangent(int splineIndex, float t);
|
|
public Unity.Mathematics.float3 EvaluateTangent<T>(T spline, float t) where T : ISpline;
|
|
public Unity.Mathematics.float3 EvaluateUpVector(float t);
|
|
public Unity.Mathematics.float3 EvaluateUpVector(int splineIndex, float t);
|
|
public Unity.Mathematics.float3 EvaluateUpVector<T>(T spline, float t) where T : ISpline;
|
|
public void OnAfterDeserialize();
|
|
public void OnBeforeSerialize();
|
|
}
|
|
|
|
public class SplineData<T> : System.Collections.Generic.IEnumerable<UnityEngine.Splines.DataPoint<T>>, System.Collections.IEnumerable
|
|
{
|
|
[System.Obsolete(@"Use Changed instead.", false)] public event System.Action changed;
|
|
public event System.Action Changed;
|
|
public int Count { get; }
|
|
public T DefaultValue { get; set; }
|
|
public System.Collections.Generic.IEnumerable<float> Indexes { get; }
|
|
public UnityEngine.Splines.DataPoint<T> this[int index] { get; set; }
|
|
public PathIndexUnit PathIndexUnit { get; set; }
|
|
public SplineData() {}
|
|
public SplineData(System.Collections.Generic.IEnumerable<UnityEngine.Splines.DataPoint<T>> dataPoints) {}
|
|
public SplineData(T init) {}
|
|
public int Add(UnityEngine.Splines.DataPoint<T> dataPoint);
|
|
public void Add(float t, T data);
|
|
public int AddDataPointWithDefaultValue(float t, bool useDefaultValue = false);
|
|
public void Clear();
|
|
public void ConvertPathUnit<TSplineType>(TSplineType spline, PathIndexUnit toUnit) where TSplineType : ISpline;
|
|
public T Evaluate<TSpline, TInterpolator>(TSpline spline, float t, TInterpolator interpolator) where TSpline : ISpline where TInterpolator : UnityEngine.Splines.IInterpolator<T>;
|
|
public T Evaluate<TSpline, TInterpolator>(TSpline spline, float t, PathIndexUnit indexUnit, TInterpolator interpolator) where TSpline : ISpline where TInterpolator : UnityEngine.Splines.IInterpolator<T>;
|
|
public System.Collections.Generic.IEnumerator<UnityEngine.Splines.DataPoint<T>> GetEnumerator();
|
|
public float GetNormalizedInterpolation<TSplineType>(TSplineType spline, float t) where TSplineType : ISpline;
|
|
public int MoveDataPoint(int index, float newIndex);
|
|
public void RemoveAt(int index);
|
|
public bool RemoveDataPoint(float t);
|
|
public void SetDataPoint(int index, UnityEngine.Splines.DataPoint<T> value);
|
|
public void SetDataPointNoSort(int index, UnityEngine.Splines.DataPoint<T> value);
|
|
public void SortIfNecessary();
|
|
}
|
|
|
|
[System.AttributeUsage(System.AttributeTargets.Field)] [System.Obsolete(@"Use SplineDataHandles.DataPointHandles instead and EditorTools to interact with SplineData.", false)] public abstract class SplineDataHandleAttribute : System.Attribute
|
|
{
|
|
protected SplineDataHandleAttribute() {}
|
|
}
|
|
|
|
[AddComponentMenu(@"Splines/Spline Extrude")] [RequireComponent(typeof(MeshFilter), typeof(MeshRenderer))] public class SplineExtrude : MonoBehaviour
|
|
{
|
|
[System.Obsolete(@"Use Capped instead.", false)] public bool capped { get; }
|
|
public bool Capped { get; set; }
|
|
[System.Obsolete(@"Use Container instead.", false)] public SplineContainer container { get; }
|
|
public SplineContainer Container { get; set; }
|
|
[System.Obsolete(@"Use Radius instead.", false)] public float radius { get; }
|
|
public float Radius { get; set; }
|
|
[System.Obsolete(@"Use Range instead.", false)] public Vector2 range { get; }
|
|
public Vector2 Range { get; set; }
|
|
[System.Obsolete(@"Use RebuildFrequency instead.", false)] public int rebuildFrequency { get; }
|
|
public int RebuildFrequency { get; set; }
|
|
[System.Obsolete(@"Use RebuildOnSplineChange instead.", false)] public bool rebuildOnSplineChange { get; }
|
|
public bool RebuildOnSplineChange { get; set; }
|
|
[System.Obsolete(@"Use SegmentsPerUnit instead.", false)] public float segmentsPerUnit { get; }
|
|
public float SegmentsPerUnit { get; set; }
|
|
[System.Obsolete(@"Use Sides instead.", false)] public int sides { get; }
|
|
public int Sides { get; set; }
|
|
[System.Obsolete(@"Use Spline instead.", false)] public Spline spline { get; }
|
|
public Spline Spline { get; }
|
|
public System.Collections.Generic.IReadOnlyList<Spline> Splines { get; }
|
|
public SplineExtrude() {}
|
|
public void Rebuild();
|
|
}
|
|
|
|
public static class SplineFactory
|
|
{
|
|
public static Spline CreateCatmullRom(System.Collections.Generic.IList<Unity.Mathematics.float3> positions, bool closed = false);
|
|
public static Spline CreateCircle(float radius);
|
|
public static Spline CreateHelix(float radius, float height, int revolutions);
|
|
public static Spline CreateLinear(System.Collections.Generic.IList<Unity.Mathematics.float3> positions, bool closed = false);
|
|
public static Spline CreateLinear(System.Collections.Generic.IList<Unity.Mathematics.float3> positions, System.Collections.Generic.IList<Unity.Mathematics.quaternion> rotations, bool closed = false);
|
|
public static Spline CreatePolygon(float edgeSize, int sides);
|
|
public static Spline CreateRoundedCornerSquare(float size, float cornerRadius);
|
|
public static Spline CreateRoundedSquare(float radius, float rounding);
|
|
public static Spline CreateSquare(float size);
|
|
public static Spline CreateStarPolygon(float edgeSize, int corners, float concavity);
|
|
}
|
|
|
|
public class SplineIndexAttribute : PropertyAttribute
|
|
{
|
|
public readonly string SplineContainerProperty;
|
|
public SplineIndexAttribute(string splineContainerProperty) {}
|
|
}
|
|
|
|
public struct SplineInfo : ISerializationCallbackReceiver, System.IEquatable<SplineInfo>
|
|
{
|
|
public ISplineContainer Container { get; set; }
|
|
public int Index { get; set; }
|
|
public Unity.Mathematics.float4x4 LocalToWorld { get; }
|
|
public UnityEngine.Object Object { get; }
|
|
public Spline Spline { get; }
|
|
public Transform Transform { get; }
|
|
public SplineInfo(ISplineContainer container, int index) {}
|
|
public override bool Equals(object obj);
|
|
public bool Equals(SplineInfo other);
|
|
public override int GetHashCode();
|
|
public void OnAfterDeserialize();
|
|
public void OnBeforeSerialize();
|
|
}
|
|
|
|
[AddComponentMenu(@"Splines/Spline Instantiate")] [ExecuteInEditMode] public class SplineInstantiate : SplineComponent
|
|
{
|
|
[System.Obsolete(@"Use Container instead.", false)] public SplineContainer container { get; }
|
|
public SplineContainer Container { get; set; }
|
|
public SplineInstantiate.Space CoordinateSpace { get; set; }
|
|
[System.Obsolete(@"Use ForwardAxis instead.", false)] public SplineComponent.AlignAxis forwardAxis { get; }
|
|
public SplineComponent.AlignAxis ForwardAxis { get; set; }
|
|
public SplineInstantiate.Method InstantiateMethod { get; set; }
|
|
public SplineInstantiate.InstantiableItem[] itemsToInstantiate { get; set; }
|
|
[System.Obsolete(@"Use MaxPositionOffset instead.", false)] public Vector3 maxPositionOffset { get; }
|
|
public Vector3 MaxPositionOffset { get; set; }
|
|
[System.Obsolete(@"Use MaxRotationOffset instead.", false)] public Vector3 maxRotationOffset { get; }
|
|
public Vector3 MaxRotationOffset { get; set; }
|
|
[System.Obsolete(@"Use MaxScaleOffset instead.", false)] public Vector3 maxScaleOffset { get; }
|
|
public Vector3 MaxScaleOffset { get; set; }
|
|
public float MaxSpacing { get; set; }
|
|
[System.Obsolete(@"Use InstantiateMethod instead.", false)] public SplineInstantiate.Method method { get; }
|
|
[System.Obsolete(@"Use MinPositionOffset instead.", false)] public Vector3 minPositionOffset { get; }
|
|
public Vector3 MinPositionOffset { get; set; }
|
|
[System.Obsolete(@"Use MinRotationOffset instead.", false)] public Vector3 minRotationOffset { get; }
|
|
public Vector3 MinRotationOffset { get; set; }
|
|
[System.Obsolete(@"Use MinScaleOffset instead.", false)] public Vector3 minScaleOffset { get; }
|
|
public Vector3 MinScaleOffset { get; set; }
|
|
public float MinSpacing { get; set; }
|
|
[System.Obsolete(@"Use PositionSpace instead.", false)] public SplineInstantiate.OffsetSpace positionSpace { get; }
|
|
public SplineInstantiate.OffsetSpace PositionSpace { get; set; }
|
|
[System.Obsolete(@"Use RotationSpace instead.", false)] public SplineInstantiate.OffsetSpace rotationSpace { get; }
|
|
public SplineInstantiate.OffsetSpace RotationSpace { get; set; }
|
|
[System.Obsolete(@"Use ScaleSpace instead.", false)] public SplineInstantiate.OffsetSpace scaleSpace { get; }
|
|
public SplineInstantiate.OffsetSpace ScaleSpace { get; set; }
|
|
[System.Obsolete(@"Use CoordinateSpace instead.", false)] public SplineInstantiate.Space space { get; }
|
|
[System.Obsolete(@"Use UpAxis instead.", false)] public SplineComponent.AlignAxis upAxis { get; }
|
|
public SplineComponent.AlignAxis UpAxis { get; set; }
|
|
public SplineInstantiate() {}
|
|
public void Clear();
|
|
public void Randomize();
|
|
public void SetDirty();
|
|
public void UpdateInstances();
|
|
public struct InstantiableItem
|
|
{
|
|
[HideInInspector] [System.Obsolete(@"Use Prefab instead.", false)] public GameObject prefab;
|
|
[UnityEngine.Serialization.FormerlySerializedAs(@"prefab")] public GameObject Prefab;
|
|
[HideInInspector] [System.Obsolete(@"Use Probability instead.", false)] public float probability;
|
|
[UnityEngine.Serialization.FormerlySerializedAs(@"probability")] public float Probability;
|
|
}
|
|
public enum Method
|
|
{
|
|
[InspectorName(@"Instance Count")] InstanceCount = 0,
|
|
[InspectorName(@"Linear Distance")] LinearDistance = 2,
|
|
[InspectorName(@"Spline Distance")] SpacingDistance = 1,
|
|
}
|
|
public enum OffsetSpace
|
|
{
|
|
[InspectorName(@"Spline Object")] Local = 1,
|
|
[InspectorName(@"Instantiated Object")] Object = 3,
|
|
[InspectorName(@"Spline Element")] Spline = 0,
|
|
[InspectorName(@"World Space")] World = 2,
|
|
}
|
|
public enum Space
|
|
{
|
|
[InspectorName(@"Spline Object")] Local = 1,
|
|
[InspectorName(@"Spline Element")] Spline = 0,
|
|
[InspectorName(@"World Space")] World = 2,
|
|
}
|
|
}
|
|
|
|
public static class SplineJobs
|
|
{
|
|
public static void EvaluatePosition<T>(T spline, Unity.Collections.NativeArray<Unity.Mathematics.float3> positions) where T : ISpline;
|
|
public static void EvaluatePosition(NativeSpline spline, Unity.Collections.NativeArray<Unity.Mathematics.float3> positions);
|
|
public static void EvaluatePositionTangentNormal<T>(T spline, Unity.Collections.NativeArray<Unity.Mathematics.float3> positions, Unity.Collections.NativeArray<Unity.Mathematics.float3> tangents, Unity.Collections.NativeArray<Unity.Mathematics.float3> normals) where T : ISpline;
|
|
public static void EvaluatePositionTangentNormal(NativeSpline spline, Unity.Collections.NativeArray<Unity.Mathematics.float3> positions, Unity.Collections.NativeArray<Unity.Mathematics.float3> tangents, Unity.Collections.NativeArray<Unity.Mathematics.float3> normals);
|
|
}
|
|
|
|
public struct SplineKnotIndex : System.IEquatable<SplineKnotIndex>
|
|
{
|
|
public int Knot;
|
|
public int Spline;
|
|
public SplineKnotIndex(int spline, int knot) {}
|
|
public override bool Equals(object obj);
|
|
public bool Equals(SplineKnotIndex otherIndex);
|
|
public override int GetHashCode();
|
|
public static bool operator ==(SplineKnotIndex indexA, SplineKnotIndex indexB);
|
|
public static bool operator !=(SplineKnotIndex indexA, SplineKnotIndex indexB);
|
|
public override string ToString();
|
|
}
|
|
|
|
public static class SplineMath
|
|
{
|
|
public static float DistancePointLine(Unity.Mathematics.float3 p, Unity.Mathematics.float3 a, Unity.Mathematics.float3 b);
|
|
public static Unity.Mathematics.float3 PointLineNearestPoint(Unity.Mathematics.float3 p, Unity.Mathematics.float3 a, Unity.Mathematics.float3 b, out float lineParam);
|
|
public static Unity.Mathematics.float3 RayLineDistance(Unity.Mathematics.float3 ro, Unity.Mathematics.float3 rd, Unity.Mathematics.float3 a, Unity.Mathematics.float3 b);
|
|
public static System.ValueTuple<Unity.Mathematics.float3, Unity.Mathematics.float3> RayLineNearestPoint(Unity.Mathematics.float3 ro, Unity.Mathematics.float3 rd, Unity.Mathematics.float3 a, Unity.Mathematics.float3 b);
|
|
public static System.ValueTuple<Unity.Mathematics.float3, Unity.Mathematics.float3> RayLineNearestPoint(Unity.Mathematics.float3 ro, Unity.Mathematics.float3 rd, Unity.Mathematics.float3 a, Unity.Mathematics.float3 b, out float rayParam, out float lineParam);
|
|
public static float RayLineParameter(Unity.Mathematics.float3 ro, Unity.Mathematics.float3 rd, Unity.Mathematics.float3 lineOrigin, Unity.Mathematics.float3 lineDir);
|
|
}
|
|
|
|
public static class SplineMesh
|
|
{
|
|
public static void Extrude<T>(T spline, Mesh mesh, float radius, int sides, int segments, bool capped = true) where T : ISpline;
|
|
public static void Extrude<T>(System.Collections.Generic.IReadOnlyList<T> splines, Mesh mesh, float radius, int sides, float segmentsPerUnit, bool capped, Unity.Mathematics.float2 range) where T : ISpline;
|
|
public static void Extrude<T>(T spline, Mesh mesh, float radius, int sides, int segments, bool capped, Unity.Mathematics.float2 range) where T : ISpline;
|
|
public static void Extrude<TSplineType, TVertexType, TIndexType>(TSplineType spline, Unity.Collections.NativeArray<TVertexType> vertices, Unity.Collections.NativeArray<TIndexType> indices, float radius, int sides, int segments, bool capped, Unity.Mathematics.float2 range) where TSplineType : ISpline where TVertexType : struct, SplineMesh.ISplineVertexData, new() where TIndexType : struct, new();
|
|
public static void GetVertexAndIndexCount(int sides, int segments, bool capped, bool closed, Vector2 range, out int vertexCount, out int indexCount);
|
|
public interface ISplineVertexData
|
|
{
|
|
public Vector3 normal { get; set; }
|
|
public Vector3 position { get; set; }
|
|
public Vector2 texture { get; set; }
|
|
}
|
|
}
|
|
|
|
public enum SplineModification
|
|
{
|
|
ClosedModified = 1,
|
|
Default = 0,
|
|
KnotInserted = 3,
|
|
KnotModified = 2,
|
|
KnotRemoved = 4,
|
|
KnotReordered = 5,
|
|
}
|
|
|
|
public class SplinePath : UnityEngine.Splines.SplinePath<UnityEngine.Splines.SplineSlice<Spline>>
|
|
{
|
|
public SplinePath(System.Collections.Generic.IEnumerable<UnityEngine.Splines.SplineSlice<Spline>> slices) {}
|
|
}
|
|
|
|
public class SplinePath<T> : IHasEmptyCurves, ISpline, System.Collections.Generic.IEnumerable<BezierKnot>, System.Collections.Generic.IReadOnlyCollection<BezierKnot>, System.Collections.Generic.IReadOnlyList<BezierKnot>, System.Collections.IEnumerable where T : ISpline
|
|
{
|
|
public bool Closed { get; }
|
|
public int Count { get; }
|
|
public System.Collections.Generic.IReadOnlyList<int> EmptyCurves { get; }
|
|
public BezierKnot this[int index] { get; }
|
|
public BezierKnot this[SplineKnotIndex index] { get; }
|
|
public System.Collections.Generic.IReadOnlyList<T> Slices { get; set; }
|
|
public SplinePath(System.Collections.Generic.IEnumerable<T> slices) {}
|
|
public BezierCurve GetCurve(int knot);
|
|
public float GetCurveInterpolation(int curveIndex, float curveDistance);
|
|
public float GetCurveLength(int index);
|
|
public System.Collections.Generic.IEnumerator<BezierKnot> GetEnumerator();
|
|
public float GetLength();
|
|
}
|
|
|
|
public struct SplineRange : System.Collections.Generic.IEnumerable<int>, System.Collections.IEnumerable
|
|
{
|
|
public int Count { get; set; }
|
|
public SliceDirection Direction { get; set; }
|
|
public int End { get; }
|
|
public int this[int index] { get; }
|
|
public int Start { get; set; }
|
|
public SplineRange(int start, int count) {}
|
|
public SplineRange(int start, int count, SliceDirection direction) {}
|
|
public System.Collections.Generic.IEnumerator<int> GetEnumerator();
|
|
public override string ToString();
|
|
public struct SplineRangeEnumerator : System.Collections.Generic.IEnumerator<int>, System.Collections.IEnumerator, System.IDisposable
|
|
{
|
|
public int Current { get; }
|
|
public SplineRangeEnumerator(SplineRange range) {}
|
|
public void Dispose();
|
|
public bool MoveNext();
|
|
public void Reset();
|
|
}
|
|
}
|
|
|
|
public struct SplineSlice<T> : ISpline, System.Collections.Generic.IEnumerable<BezierKnot>, System.Collections.Generic.IReadOnlyCollection<BezierKnot>, System.Collections.Generic.IReadOnlyList<BezierKnot>, System.Collections.IEnumerable where T : ISpline
|
|
{
|
|
public SplineRange Range;
|
|
public T Spline;
|
|
public Unity.Mathematics.float4x4 Transform;
|
|
public bool Closed { get; }
|
|
public int Count { get; }
|
|
public BezierKnot this[int index] { get; }
|
|
public SplineSlice(T spline, SplineRange range) {}
|
|
public SplineSlice(T spline, SplineRange range, Unity.Mathematics.float4x4 transform) {}
|
|
public BezierCurve GetCurve(int index);
|
|
public float GetCurveInterpolation(int curveIndex, float curveDistance);
|
|
public float GetCurveLength(int index);
|
|
public System.Collections.Generic.IEnumerator<BezierKnot> GetEnumerator();
|
|
public float GetLength();
|
|
}
|
|
|
|
[System.Obsolete(@"Replaced by GetTangentMode and SetTangentMode.")] public enum SplineType
|
|
{
|
|
Bezier = 1,
|
|
CatmullRom = 0,
|
|
Linear = 2,
|
|
}
|
|
|
|
public static class SplineUtility
|
|
{
|
|
public const float CatmullRomTension = 0.5f;
|
|
public const float DefaultTension = 0.5f;
|
|
public const int DrawResolutionDefault = 10;
|
|
public const int PickResolutionDefault = 4;
|
|
public const int PickResolutionMax = 64;
|
|
public const int PickResolutionMin = 2;
|
|
public static Spline AddSpline<T>(this T container) where T : ISplineContainer;
|
|
public static void AddSpline<T>(this T container, Spline spline) where T : ISplineContainer;
|
|
public static float CalculateLength<T>(this T spline, Unity.Mathematics.float4x4 transform) where T : ISpline;
|
|
public static float ConvertIndexUnit<T>(this T spline, float t, PathIndexUnit targetPathUnit) where T : ISpline;
|
|
public static float ConvertIndexUnit<T>(this T spline, float t, PathIndexUnit fromPathUnit, PathIndexUnit targetPathUnit) where T : ISpline;
|
|
public static void CopyKnotLinks<T>(this T container, int srcSplineIndex, int destSplineIndex) where T : ISplineContainer;
|
|
public static float CurveToSplineT<T>(this T spline, float curve) where T : ISpline;
|
|
public static bool Evaluate<T>(this T spline, float t, out Unity.Mathematics.float3 position, out Unity.Mathematics.float3 tangent, out Unity.Mathematics.float3 upVector) where T : ISpline;
|
|
public static Unity.Mathematics.float3 EvaluateAcceleration<T>(this T spline, float t) where T : ISpline;
|
|
public static float EvaluateCurvature<T>(this T spline, float t) where T : ISpline;
|
|
public static Unity.Mathematics.float3 EvaluateCurvatureCenter<T>(this T spline, float t) where T : ISpline;
|
|
public static bool EvaluateNurbs(float t, System.Collections.Generic.List<Unity.Mathematics.float3> controlPoints, System.Collections.Generic.List<double> knotVector, int order, out Unity.Mathematics.float3 position);
|
|
public static Unity.Mathematics.float3 EvaluatePosition<T>(this T spline, float t) where T : ISpline;
|
|
public static Unity.Mathematics.float3 EvaluateTangent<T>(this T spline, float t) where T : ISpline;
|
|
public static Unity.Mathematics.float3 EvaluateUpVector<T>(this T spline, float t) where T : ISpline;
|
|
public static bool FitSplineToPoints(System.Collections.Generic.List<Unity.Mathematics.float3> points, float errorThreshold, bool closed, out Spline spline);
|
|
public static BezierKnot GetAutoSmoothKnot(Unity.Mathematics.float3 position, Unity.Mathematics.float3 previous, Unity.Mathematics.float3 next);
|
|
public static BezierKnot GetAutoSmoothKnot(Unity.Mathematics.float3 position, Unity.Mathematics.float3 previous, Unity.Mathematics.float3 next, Unity.Mathematics.float3 normal);
|
|
public static BezierKnot GetAutoSmoothKnot(Unity.Mathematics.float3 position, Unity.Mathematics.float3 previous, Unity.Mathematics.float3 next, Unity.Mathematics.float3 normal, float tension = 0.5f);
|
|
public static Unity.Mathematics.float3 GetAutoSmoothTangent(Unity.Mathematics.float3 previous, Unity.Mathematics.float3 next, float tension = 0.5f);
|
|
public static Unity.Mathematics.float3 GetAutoSmoothTangent(Unity.Mathematics.float3 previous, Unity.Mathematics.float3 current, Unity.Mathematics.float3 next, float tension = 0.5f);
|
|
public static Bounds GetBounds<T>(this T spline) where T : ISpline;
|
|
public static Bounds GetBounds<T>(this T spline, Unity.Mathematics.float4x4 transform) where T : ISpline;
|
|
public static Unity.Mathematics.float3 GetCatmullRomTangent(Unity.Mathematics.float3 previous, Unity.Mathematics.float3 next);
|
|
public static int GetCurveCount<T>(this T spline) where T : ISpline;
|
|
public static float GetNearestPoint<T>(T spline, Unity.Mathematics.float3 point, out Unity.Mathematics.float3 nearest, out float t, int resolution = 4, int iterations = 2) where T : ISpline;
|
|
public static float GetNearestPoint<T>(T spline, Ray ray, out Unity.Mathematics.float3 nearest, out float t, int resolution = 4, int iterations = 2) where T : ISpline;
|
|
public static float GetNormalizedInterpolation<T>(T spline, float t, PathIndexUnit originalPathUnit) where T : ISpline;
|
|
public static Unity.Mathematics.float3 GetPointAtLinearDistance<T>(this T spline, float fromT, float relativeDistance, out float resultPointT) where T : ISpline;
|
|
[System.Obsolete(@"Use GetSubdivisionCount instead.", false)] public static int GetSegmentCount(float length, int resolution);
|
|
public static int GetSubdivisionCount(float length, int resolution);
|
|
public static void LinkKnots<T>(this T container, SplineKnotIndex knotA, SplineKnotIndex knotB) where T : ISplineContainer;
|
|
public static BezierKnot Next<T>(this T spline, int index) where T : ISpline;
|
|
public static int NextIndex<T>(this T spline, int index) where T : ISpline;
|
|
public static BezierKnot Previous<T>(this T spline, int index) where T : ISpline;
|
|
public static int PreviousIndex<T>(this T spline, int index) where T : ISpline;
|
|
public static System.Collections.Generic.List<Unity.Mathematics.float3> ReducePoints<T>(T line, float epsilon = 0.15f) where T : System.Collections.Generic.IList<Unity.Mathematics.float3>;
|
|
public static void ReducePoints<T>(T line, System.Collections.Generic.List<Unity.Mathematics.float3> results, float epsilon = 0.15f) where T : System.Collections.Generic.IList<Unity.Mathematics.float3>;
|
|
public static bool RemoveSpline<T>(this T container, Spline spline) where T : ISplineContainer;
|
|
public static bool RemoveSplineAt<T>(this T container, int splineIndex) where T : ISplineContainer;
|
|
public static bool ReorderSpline<T>(this T container, int previousSplineIndex, int newSplineIndex) where T : ISplineContainer;
|
|
public static void SetLinkedKnotPosition<T>(this T container, SplineKnotIndex index) where T : ISplineContainer;
|
|
public static void SetPivot(SplineContainer container, Vector3 position);
|
|
public static int SplineToCurveT<T>(this T spline, float splineT, out float curveT) where T : ISpline;
|
|
public static void UnlinkKnots<T>(this T container, System.Collections.Generic.IReadOnlyList<SplineKnotIndex> knots) where T : ISplineContainer;
|
|
}
|
|
|
|
public enum TangentMode
|
|
{
|
|
AutoSmooth = 0,
|
|
Broken = 4,
|
|
Continuous = 3,
|
|
Linear = 1,
|
|
Mirrored = 2,
|
|
}
|
|
}
|
|
|
|
namespace UnityEngine.Splines.Interpolators
|
|
{
|
|
public struct LerpColor : UnityEngine.Splines.IInterpolator<Color>
|
|
{
|
|
public Color Interpolate(Color a, Color b, float t);
|
|
}
|
|
|
|
public struct LerpFloat : UnityEngine.Splines.IInterpolator<float>
|
|
{
|
|
public float Interpolate(float a, float b, float t);
|
|
}
|
|
|
|
public struct LerpFloat2 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float2>
|
|
{
|
|
public Unity.Mathematics.float2 Interpolate(Unity.Mathematics.float2 a, Unity.Mathematics.float2 b, float t);
|
|
}
|
|
|
|
public struct LerpFloat3 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float3>
|
|
{
|
|
public Unity.Mathematics.float3 Interpolate(Unity.Mathematics.float3 a, Unity.Mathematics.float3 b, float t);
|
|
}
|
|
|
|
public struct LerpFloat4 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float4>
|
|
{
|
|
public Unity.Mathematics.float4 Interpolate(Unity.Mathematics.float4 a, Unity.Mathematics.float4 b, float t);
|
|
}
|
|
|
|
public struct LerpQuaternion : UnityEngine.Splines.IInterpolator<Unity.Mathematics.quaternion>
|
|
{
|
|
public Unity.Mathematics.quaternion Interpolate(Unity.Mathematics.quaternion a, Unity.Mathematics.quaternion b, float t);
|
|
}
|
|
|
|
public struct SlerpFloat2 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float2>
|
|
{
|
|
public Unity.Mathematics.float2 Interpolate(Unity.Mathematics.float2 a, Unity.Mathematics.float2 b, float t);
|
|
}
|
|
|
|
public struct SlerpFloat3 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float3>
|
|
{
|
|
public Unity.Mathematics.float3 Interpolate(Unity.Mathematics.float3 a, Unity.Mathematics.float3 b, float t);
|
|
}
|
|
|
|
public struct SlerpQuaternion : UnityEngine.Splines.IInterpolator<Unity.Mathematics.quaternion>
|
|
{
|
|
public Unity.Mathematics.quaternion Interpolate(Unity.Mathematics.quaternion a, Unity.Mathematics.quaternion b, float t);
|
|
}
|
|
|
|
public struct SmoothStepFloat : UnityEngine.Splines.IInterpolator<float>
|
|
{
|
|
public float Interpolate(float a, float b, float t);
|
|
}
|
|
|
|
public struct SmoothStepFloat2 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float2>
|
|
{
|
|
public Unity.Mathematics.float2 Interpolate(Unity.Mathematics.float2 a, Unity.Mathematics.float2 b, float t);
|
|
}
|
|
|
|
public struct SmoothStepFloat3 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float3>
|
|
{
|
|
public Unity.Mathematics.float3 Interpolate(Unity.Mathematics.float3 a, Unity.Mathematics.float3 b, float t);
|
|
}
|
|
|
|
public struct SmoothStepFloat4 : UnityEngine.Splines.IInterpolator<Unity.Mathematics.float4>
|
|
{
|
|
public Unity.Mathematics.float4 Interpolate(Unity.Mathematics.float4 a, Unity.Mathematics.float4 b, float t);
|
|
}
|
|
}
|