public float InvTransformPercent(float inPercent, SplineLerp inLerpMethod)
{
if (m_Dirty)
{
Process();
}
if (m_Looped)
{
inPercent = (inPercent + 1) % 1;
}
switch (inLerpMethod)
{
case SplineLerp.Vertex:
default:
{
return(inPercent);
}
case SplineLerp.Direct:
case SplineLerp.Precise:
{
SplineSegment seg;
GetSegment(inPercent, out seg);
return(m_VertexData[seg.VertexA].Marker + m_VertexData[seg.VertexA].Length * seg.Interpolation);
}
}
}
/// <summary>
/// Generates info about an interpolation along the given spline.
/// </summary>
static public void GetUpdateInfo(this ISpline inSpline, float inPercent, SplineLerp inLerpMethod, Curve inSegmentEase, out SplineUpdateInfo outInfo)
{
outInfo.Spline = inSpline;
outInfo.Percent = inSpline.TransformPercent(inPercent, inLerpMethod);
outInfo.Point = inSpline.GetPoint(outInfo.Percent, inSegmentEase);
outInfo.Direction = inSpline.GetDirection(outInfo.Percent, inSegmentEase);
}
public float InvTransformPercent(float inPercent, SplineLerp inLerpMethod)
{
if (m_Dirty)
{
Process();
}
if (m_Looped)
{
inPercent = (inPercent + 1) % 1;
}
if (inPercent == 0 || inPercent == 1)
{
return(inPercent);
}
switch (inLerpMethod)
{
case SplineLerp.Vertex:
default:
{
return(inPercent);
}
case SplineLerp.Direct:
{
SplineSegment seg;
GetSegment(inPercent, out seg);
return(m_VertexData[seg.VertexA].Marker + m_VertexData[seg.VertexA].Length * seg.Interpolation);
}
case SplineLerp.Precise:
{
int segCount = m_PreciseSegmentCount;
if (m_Looped)
{
inPercent = (inPercent + 1) % 1;
}
float vertAF = inPercent * segCount;
int vertA = (int)vertAF;
if (!m_Looped)
{
if (vertA < 0)
{
vertA = 0;
}
else if (vertA >= segCount)
{
vertA = segCount - 1;
}
}
float interpolation = vertAF - vertA;
return(m_PreciseSegmentData[vertA].Marker + interpolation * m_PreciseSegmentData[vertA].Length);
}
}
}
public SplineTweenSettings(SplineTweenSettings inSource)
{
LerpMethod = inSource.LerpMethod;
SegmentEase = inSource.SegmentEase;
UpdateCallback = inSource.UpdateCallback;
Offset = inSource.Offset;
Orient = new SplineOrientationSettings(inSource.Orient);
}
public float TransformPercent(float inPercent, SplineLerp inLerpMethod)
{
if (m_Dirty)
{
Process();
}
if (m_Looped)
{
inPercent = (inPercent + 1) % 1;
}
if (inPercent == 0 || inPercent == 1)
{
return(inPercent);
}
switch (inLerpMethod)
{
case SplineLerp.Vertex:
default:
{
return(inPercent);
}
case SplineLerp.Direct:
case SplineLerp.Precise:
{
int segCount = m_SegmentCount;
for (int i = segCount - 1; i > 0; --i)
{
if (m_VertexData[i].Marker <= inPercent)
{
float lerp = (inPercent - m_VertexData[i].Marker) / m_VertexData[i].Length;
return((i + lerp) / segCount);
}
}
// If these fail, use the starting node
{
float lerp = (inPercent) / m_VertexData[0].Length;
return(lerp / segCount);
}
}
}
}
public float InvTransformPercent(float inPercent, SplineLerp inLerpMethod)
{
if (m_Dirty)
{
Process();
}
if (inPercent == 0 || inPercent == 1)
{
return(inPercent);
}
switch (inLerpMethod)
{
case SplineLerp.Vertex:
case SplineLerp.Direct:
default:
{
return(inPercent);
}
case SplineLerp.Precise:
{
float vertAF = inPercent * m_PreciseSegmentCount;
int vertA = (int)vertAF;
if (vertA < 0)
{
vertA = 0;
}
else if (vertA >= m_PreciseSegmentData.Length)
{
vertA = m_PreciseSegmentData.Length - 1;
}
float interpolation = vertAF - vertA;
return(m_PreciseSegmentData[vertA].Marker + interpolation * m_PreciseSegmentData[vertA].Length);
}
}
}
public float InvTransformPercent(float inPercent, SplineLerp inLerpMethod)
{
return(RefreshSpline().InvTransformPercent(inPercent, inLerpMethod));
}
/// <summary>
/// Aligns a RectTransform to a point along the spline, using anchoredPosition.
/// </summary>
static public void AlignAnchorPos(ISpline inSpline, RectTransform inTransform, float inPercent, Axis inAxis, SplineLerp inLerpMethod, Curve inSegmentEase, SplineOrientationSettings inOrientation)
{
SplineUpdateInfo info;
GetUpdateInfo(inSpline, inPercent, inLerpMethod, inSegmentEase, out info);
inTransform.SetAnchorPos(info.Point, inAxis);
if (inOrientation != null)
{
inOrientation.Apply(ref info, inTransform, Space.Self);
}
}
/// <summary>
/// Generates info about an interpolation along the given spline.
/// </summary>
static public void GetUpdateInfo(this ISpline inSpline, float inPercent, SplineLerp inLerp, out SplineUpdateInfo outInfo)
{
GetUpdateInfo(inSpline, inPercent, inLerp, Curve.Linear, out outInfo);
}
/// <summary>
/// Samples the spline for the given range and outputs to an array.
/// </summary>
static public int Sample(this ISpline inSpline, Vector2[] outPoints, float inStart, float inEnd, SplineLerp inLerp = SplineLerp.Vertex)
{
return(Sample(inSpline, outPoints, inStart, inEnd, 0, outPoints.Length, inLerp));
}
/// <summary>
/// Samples the spline for the given range and outputs to a list.
/// </summary>
static public void Sample(this ISpline inSpline, List <Vector2> outPoints, float inStart, float inEnd, int inNumSamples, SplineLerp inLerp = SplineLerp.Vertex)
{
float delta = inEnd - inStart;
for (int i = 0; i < inNumSamples; ++i)
{
float t = (float)i / (inNumSamples - 1);
outPoints.Add(inSpline.GetPoint(inSpline.TransformPercent(inStart + t * delta, inLerp)));
}
}
/// <summary>
/// Samples the spline for the given range and outputs to an array.
/// </summary>
static public int Sample(this ISpline inSpline, Vector2[] outPoints, float inStart, float inEnd, int inStartIdx, int inNumSamples, SplineLerp inLerp = SplineLerp.Vertex)
{
inNumSamples = Mathf.Min(outPoints.Length - inStartIdx, inNumSamples);
float delta = inEnd - inStart;
for (int i = 0; i < inNumSamples; ++i)
{
float t = (float)i / (inNumSamples - 1);
outPoints[inStartIdx + i] = inSpline.GetPoint(inSpline.TransformPercent(inStart + t * delta, inLerp));
}
return(inNumSamples);
}
public float TransformPercent(float inPercent, SplineLerp inLerpMethod)
{
return(Spline.TransformPercent(inPercent, inLerpMethod));
}
