public Animation Linear <T>(
FieldGetFn <T> getter,
FieldSetFn <T> setter,
LerpFn <T> lerp,
T dest,
float velocity,
Animation.Callback callback = null)
{
T origin = getter.Invoke();
float t = 0;
return(new Animation(
() =>
{
origin = getter.Invoke();
t = 0f;
return null;
},
(object state, float dt) =>
{
t += dt * velocity;
setter.Invoke(lerp.Invoke(origin, dest, t));
return state;
},
(object state) => t >= 1,
(object state) =>
{
if (callback != null)
{
callback.Invoke(null);
}
}));
}
public Animation Lerp <T>(
FieldGetFn <T> getter,
FieldSetFn <T> setter,
LerpFn <T> lerp,
Comparator <T> magnitude,
T dest,
float velocity,
Animation.Callback callback = null)
{
return(new Animation(
() => null,
(object state, float t) =>
{
setter.Invoke(lerp.Invoke(getter.Invoke(), dest, velocity * t));
return state;
},
(object state) => (magnitude.Invoke(getter.Invoke(), dest) < epsilon),
(object state) =>
{
setter.Invoke(dest);
if (callback != null)
{
callback.Invoke(state);
}
}
));
}
public static T GetValueAtDistance <T>(float distance, ValueAtDistance <T>[] values, LerpFn <T> lerp)
where T : struct
=> GetValueAtDistance(distance, values, lerp, values[0].Value, values[values.Length - 1].Value);
public static T GetValueAtDistance <T>(float distance, ValueAtDistance <T>[] values, LerpFn <T> lerp, T defMin, T defMax)
where T : struct
{
if (distance <= values[0].Distance)
{
return(defMin);
}
else if (distance >= values[values.Length - 1].Distance)
{
return(defMax);
}
else
{
for (int i = 1; i < values.Length; ++i)
{
if (values[i].Distance > distance)
{
return(LerpValueAtDistance(distance, values[i - 1], values[i], lerp));
}
}
}
return(defMax);
}
public static T LerpValueAtDistance <T>(float distance, ValueAtDistance <T> a, ValueAtDistance <T> b, LerpFn <T> lerp)
where T : struct
{
float max = b.Distance - a.Distance;
if (max > 0)
{
float t = (distance - a.Distance) / max;
if (t > 0 && t < 1)
{
return(lerp(a.Value, b.Value, t));
}
else
{
return(t <= 0 ? a.Value : b.Value);
}
}
return(a.Value);
}
