public static PointTransformation <T> Create <T>(T target, string property, TimeSpan duration,
EaserFunction easerFunction = null, bool useStartValue = true,
params Point[] values) where T : class
{
return(new PointTransformation <T>(target, property,
duration, easerFunction, useStartValue, values));
}
private IEnumerable <TType> Interpolate(int stepCount, EaserFunction easer, TVector from, TVector to)
{
var edge = Subtract(to, from);
//Calculate the unit vector for the edge
var normal = Normalize(edge);
//Determine the length of the edge
var edgeLength = GetLength(edge);
//Yield a value at each step along this edge
for (var stepIndex = 1; stepIndex < stepCount; stepIndex++)
{
//Calculate the progress through this edge
var progress = easer(stepIndex, stepCount);
//Multiply the edge's distance by the progress
var progressDistance = edgeLength * progress;
//Multiply the normal by the progress to get the vector from the last point
var progressVector = Multiply(normal, progressDistance);
//Add the progress vector to the last point to get the new point
var newPoint = Add(from, progressVector);
//Convert and return
yield return(FromVector(newPoint));
}
//Return the end point for this edge
yield return(FromVector(to));
}
public IEnumerable <double> Interpolate(int stepCount, EaserFunction easer, double[] points)
{
if (stepCount <= 0)
{
yield break;
}
//Get the list of edges
var edges = GetEdges(points);
//The distance to travel per step
var velocity = TotalEdgeLength(edges) / stepCount;
if (velocity <= 0)
{
for (var i = 0; i < stepCount; i++)
{
yield return(points.Last());
}
}
else
{
//Yield a point for each step
foreach (var(pointA, pointB, edge) in edges)
{
var edgeSteps = edge / velocity;
foreach (var value in Interpolate((int)edgeSteps, easer, pointA, pointB))
{
yield return(value);
}
}
}
}
public ColorTransformation(TClass target,
string property,
TimeSpan duration,
EaserFunction easerFunction = null,
bool useStartValue = false,
params Color[] values) : base(target,
property,
duration,
new ColorInterpolator(), easerFunction, useStartValue, values)
{
}
/// <summary>
/// Transform a double property on the target object to the value returned by the given Func<>at intervals
/// specified by the step duration up to the task duration
/// </summary>
/// <summary>
public DoubleTransformation(TClass target,
string property,
TimeSpan stepCount,
EaserFunction easerFunction = null,
bool useStartValue = false,
params double[] values) : base(target,
property,
stepCount,
new DoubleInterpolator(), easerFunction, useStartValue, values)
{
}
public Vec2Transformation(TClass target,
string property,
TimeSpan duration,
EaserFunction easerFunction = null,
bool useStartValue = true,
params Vector2[] values) : base(target,
property,
duration,
new Vec2LinearInterpolator(),
easerFunction, useStartValue, values)
{
}
public PointTransformation(TClass target,
string property,
TimeSpan duration,
EaserFunction easerFunction = null,
bool useStartValue = true,
params Point[] values) : base(target,
property,
duration,
new PointInterpolator(),
easerFunction, useStartValue, values)
{
}
public IEnumerable <TType> Interpolate(int stepCount, EaserFunction easer, TType from, TType to)
{
if (stepCount <= 0)
{
yield break;
}
var fromVector = ToVector(from);
var toVector = ToVector(from);
foreach (var value in Interpolate(stepCount, easer, fromVector, toVector))
{
yield return(value);
}
}
protected InterpolatedTransformation(TClass target,
string property,
TimeSpan duration,
ILinearInterpolator <TProperty> interpolator,
EaserFunction easerFunction = null,
bool useStartValue = true,
params TProperty[] values) : base(target,
property,
duration,
useStartValue,
values)
{
_interpolator = interpolator;
Easer = easerFunction ?? DefaultEasers.Linear;
}
public IEnumerable <double> Interpolate(int stepCount, EaserFunction easer, double from, double to)
{
if (stepCount <= 0)
{
yield break;
}
var edgeLength = to - from;
for (var stepIndex = 1; stepIndex < stepCount; stepIndex++)
{
yield return(from + edgeLength * easer(stepIndex, stepCount));
}
yield return(to);
}
public IEnumerable <int> Interpolate(int stepCount, EaserFunction easer, int from, int to)
{
if (stepCount <= 0)
{
yield break;
}
var edgeLength = to - from;
for (var stepIndex = 1; stepIndex < stepCount; stepIndex++)
{
yield return(from + (int)(edgeLength * easer(stepIndex, stepCount)));
}
//Return the last point for this step
yield return(to);
}
public IEnumerable <int> Interpolate(int stepCount, EaserFunction easer, int[] points)
{
if (stepCount <= 0)
{
yield break;
}
//Get the list of edges
var edges = GetEdges(points);
//The distance to travel per step
var velocity = TotalEdgeLength(edges) / stepCount;
if (velocity <= 0)
{
//If the distance to travel per step is 0 then return the last destination
//for each step
for (var i = 0; i < stepCount; i++)
{
yield return(points.Last());
}
}
else
{
//for each edge
foreach (var(pointA, pointB, edge) in edges)
{
//Calculate how many steps this edge has
var edgeSteps = edge / velocity;
//Return a value for each step along this edge
foreach (var value in Interpolate(edgeSteps, easer, pointA, pointB))
{
yield return(value);
}
}
}
}
public IEnumerable <TType> Interpolate(int stepCount, EaserFunction easer, TType[] points)
{
if (stepCount <= 0)
{
yield break;
}
//Get the list of edges
var edges = GetEdges(points.Select(ToVector).ToArray());
//Calculate the total length to travel
var velocity = TotalEdgeLength(edges) / stepCount;
if (velocity <= 0)
{
for (var i = 0; i < stepCount; i++)
{
yield return(points.Last());
}
}
else
{
foreach (var(pointA, pointB, edge) in edges)
{
//Determine the length of the edge
var edgeLength = GetLength(edge);
//Calculate the number of steps needed for this edge
var edgeSteps = edgeLength / velocity;
foreach (var value in Interpolate((int)edgeSteps, easer, pointA, pointB))
{
yield return(value);
}
}
}
}
public IEnumerable <TType> Interpolate(int stepCount, EaserFunction easer, params TType[] points)
{
if (stepCount <= 0)
{
yield break;
}
var curveSegments = new List <(Vector2, Vector2, Vector2, Vector2)>();
var vecPoints = points.Select(ToVector).ToList();
for (var i = 2; i + 1 < vecPoints.Count; i += 2)
{
var point1 = vecPoints[i - 2];
var point2 = vecPoints[i - 1];
var point3 = vecPoints[i];
var point4 = vecPoints[i + 1];
curveSegments.Add((point1, point2, point3, point4));
}
var pointsOnCurve = new List <Vector2>();
foreach (var curveSegment in curveSegments)
{
for (var i = 0; i <= 10; i++)
{
var x = X(i / 10f, curveSegment.Item1.X, curveSegment.Item2.X, curveSegment.Item3.X,
curveSegment.Item4.X);
var y = Y(i / 10f, curveSegment.Item1.Y, curveSegment.Item2.Y, curveSegment.Item3.Y,
curveSegment.Item4.Y);
pointsOnCurve.Add(new Vector2(x, y));
}
}
//Get the list of edges
var edges = GetEdges(pointsOnCurve);
//Calculate the total length to travel
var velocity = TotalEdgeLength(edges) / stepCount;
if (velocity <= 0)
{
for (var i = 0; i < stepCount; i++)
{
yield return(points.Last());
}
}
else
{
foreach (var(pointA, pointB, edge) in edges)
{
//Calculate the unit vector for the edge
var normal = Normalize(edge);
//Determine the length of the edge
var edgeLength = GetLength(edge);
//Calculate the number of steps needed for this edge
var edgeSteps = edgeLength / velocity;
//Yield a value at each step along this edge
for (var stepIndex = 1; stepIndex < edgeSteps; stepIndex++)
{
//Calculate the progress through this edge
var progress = easer(stepIndex, (int)edgeSteps);
//Multiply the edge's distance by the progress
var progressDistance = edgeLength * progress;
//Multiply the normal by the progress to get the vector from the last point
var progressVector = Multiply(normal, progressDistance);
//Add the progress vector to the last point to get the new point
var newPoint = Add(pointA, progressVector);
//Convert and return
yield return(FromVector(newPoint));
}
//Return the end point for this edge
yield return(FromVector(pointB));
}
}
}
public IEnumerable <TType> Interpolate(int stepCount, EaserFunction easer, TType from, TType to) => Interpolate(stepCount, easer, ToVector(from), ToVector(to));
