protected override Vector3 Evaluate(Vector3 a, Vector3 b, float t, EaseDelegate easeFunction)
{
return(new Vector3(
easeFunction(a.x, b.x, t),
easeFunction(a.y, b.y, t),
easeFunction(a.z, b.z, t)));
}
public Vector3 Evaluate(
Vector3 initialValue,
Vector3 finalValue,
float time,
EaseDelegate easeFunction
)
{
if (easeFunction == null)
{
throw new ArgumentNullException($"Tried to Evaluate with a " +
$"null {nameof(EaseDelegate)} on {nameof(Vector3Interpolator)}");
}
if (rotationMode == RotationMode.Fast)
{
Vector3 deltaAngle = AngleUtils.DeltaAngle(initialValue, finalValue);
finalValue = initialValue + deltaAngle;
}
return(new Vector3(
easeFunction(initialValue.x, finalValue.x, time),
easeFunction(initialValue.y, finalValue.y, time),
easeFunction(initialValue.z, finalValue.z, time)
));
}
protected override Color Evaluate(Color a, Color b, float t, EaseDelegate easeFunction)
{
return(new Color(
easeFunction(a.r, b.r, t),
easeFunction(a.g, b.g, t),
easeFunction(a.b, b.b, t),
easeFunction(a.a, b.a, t)));
}
public override void OnEaseDelegateChanges(EaseDelegate easeFunction)
{
foreach (Tween tween in tweens)
{
tween.OnEaseDelegateChanges(easeFunction);
}
EaseFunction = easeFunction;
}
public void TweenPositionTo(Vector2 targetPos, float duration, EaseDelegate ease, bool local)
{
if (positionRoutine != null)
{
StopCoroutine(positionRoutine);
}
positionRoutine = TweeningPositionTo(targetPos, duration, ease, local);
StartCoroutine(positionRoutine);
}
public void TweenEulerTo(Vector3 targetEuler, float duration, EaseDelegate ease, bool local)
{
if (rotationRoutine != null)
{
StopCoroutine(rotationRoutine);
}
rotationRoutine = TweeningEulerTo(targetEuler, duration, ease, local);
StartCoroutine(rotationRoutine);
}
public override void OnEaseDelegateChanges(EaseDelegate easeFunction)
{
foreach (ITweener tweener in tweeners)
{
tweener.SetEase(easeFunction);
}
EaseFunction = easeFunction;
}
public void TweenScaleTo(Vector3 targetScale, float duration, EaseDelegate ease)
{
if (scaleRoutine != null)
{
StopCoroutine(scaleRoutine);
}
scaleRoutine = TweeningScaleTo(targetScale, duration, ease);
StartCoroutine(scaleRoutine);
}
public FTweener SetEase(EaseDelegate ease)
{
if (setup)
{
Debug.LogWarning("Tried to modify running tween");
}
this.ease = Ease.__Custom;
customEase = ease;
return(this);
}
internal static EaseDelegate GetEaseDelegate(AnimationCurve animationCurve)
{
EaseDelegate result = (float a, float b, float t) =>
{
float newT = animationCurve.Evaluate(t);
return(a + ((b - a) * newT));
};
return(result);
}
private IEnumerator MoveToPosition(Vector3 targetPos, float duration, EaseDelegate getCurrentPosition)
{
float elapsedTime = 0;
Vector3 startingPos = transform.localPosition;
while (elapsedTime < duration)
{
transform.localPosition = getCurrentPosition(startingPos, targetPos, (elapsedTime / duration));
elapsedTime += Time.deltaTime;
yield return(null);
}
transform.localPosition = targetPos;
}
public int Evaluate(
int initialValue,
int finalValue,
float time,
EaseDelegate easeFunction
)
{
if (easeFunction == null)
{
throw new ArgumentNullException($"Tried to Evaluate with a " +
$"null {nameof(EaseDelegate)} on {nameof(IntInterpolator)}");
}
return((int)easeFunction(initialValue, finalValue, time));
}
IEnumerator TweeningScaleTo(Vector3 targetScale, float duration, EaseDelegate ease)
{
Vector2 startScale = transform.localScale;
float counter = 0;
while (counter < duration)
{
counter += Time.deltaTime;
counter = Mathf.Clamp(counter, 0, duration);
float l = ease(counter / duration);
transform.localScale = Vector3.Lerp(startScale, targetScale, l);
yield return(null);
}
}
public Quaternion Evaluate(
Quaternion initialValue,
Quaternion finalValue,
float time,
EaseDelegate easeFunction
)
{
if (easeFunction == null)
{
throw new ArgumentNullException($"Tried to Evaluate with a " +
$"null {nameof(EaseDelegate)} on {nameof(ColorInterpolator)}");
}
float curveTime = easeFunction(0f, 1f, time);
return(Quaternion.Slerp(initialValue, finalValue, curveTime));
}
public Vector2 Evaluate(
Vector2 initialValue,
Vector2 finalValue,
float time,
EaseDelegate easeFunction
)
{
if (easeFunction == null)
{
throw new ArgumentNullException($"Tried to Evaluate with a " +
$"null {nameof(EaseDelegate)} on {nameof(Vector2Interpolator)}");
}
return(new Vector2(
easeFunction(initialValue.x, finalValue.x, time),
easeFunction(initialValue.y, finalValue.y, time)
));
}
public Color Evaluate(
Color initialValue,
Color finalValue,
float time,
EaseDelegate easeFunction
)
{
if (easeFunction == null)
{
throw new ArgumentNullException($"Tried to Evaluate with a " +
$"null {nameof(EaseDelegate)} on {nameof(ColorInterpolator)}");
}
return(new Color(
easeFunction(initialValue.r, finalValue.r, time),
easeFunction(initialValue.g, finalValue.g, time),
easeFunction(initialValue.b, finalValue.b, time),
easeFunction(initialValue.a, finalValue.a, time)
));
}
public Rect Evaluate(
Rect initialValue,
Rect finalValue,
float time,
EaseDelegate easeFunction
)
{
if (easeFunction == null)
{
throw new ArgumentNullException($"Tried to Evaluate with a " +
$"null {nameof(EaseDelegate)} on {nameof(Rect)}");
}
return(new Rect(
easeFunction(initialValue.x, finalValue.x, time),
easeFunction(initialValue.y, finalValue.y, time),
easeFunction(initialValue.width, finalValue.width, time),
easeFunction(initialValue.height, finalValue.height, time)
));
}
IEnumerator TweeningEulerTo(Vector3 targetEuler, float duration, EaseDelegate ease, bool local)
{
Vector2 startEuler = local ? transform.localEulerAngles : transform.eulerAngles;
float counter = 0;
while (counter < duration)
{
counter += Time.deltaTime;
counter = Mathf.Clamp(counter, 0, duration);
float l = ease(counter / duration);
if (local)
{
transform.localEulerAngles = Vector3.Lerp(startEuler, targetEuler, l);
}
else
{
transform.eulerAngles = Vector3.Lerp(startEuler, targetEuler, l);
}
yield return(null);
}
}
IEnumerator TweeningPositionTo(Vector2 targetPos, float duration, EaseDelegate ease, bool local)
{
//Debug.Log("Called");
Vector2 startPos = local?transform.localPosition:transform.position;
float counter = 0;
while (counter < duration)
{
counter += Time.deltaTime;
counter = Mathf.Clamp(counter, 0, duration); //on clamp histoire de jamais avoir de valeur > duration qui pourrait faire foirer le Ease en dessous.
float l = ease(counter / duration); //on applique un Easing au counter pour avoir une valeur entre 0 et 1 qui suit une "courbe" spécifique.
//puis on lerp entre les deux position, en fonction de si c'est en local ou pas
if (local)
{
transform.localPosition = Vector2.Lerp(startPos, targetPos, l);
}
else
{
transform.position = Vector2.Lerp(startPos, targetPos, l);
}
yield return(null); //pour que la coroutine fasse cette opération à chaque frame, plutôt que tout d'un coup
}
}
protected override float Evaluate(float a, float b, float t, EaseDelegate easeFunction)
{
return(easeFunction(a, b, t));
}
public void SetEase(EaseDelegate easeFunction)
{
this.easeFunction = easeFunction;
}
/// <summary>
/// Easing Functions enumeration
/// </summary>
/// <summary>
/// Interpolate using the specified function.
/// </summary>
static public float Evaluate(float p, Ease function, EaseDelegate del)
{
switch (function)
{
default:
case Ease.QuadraticOut: return(QuadraticEaseOut(p));
case Ease.QuadraticIn: return(QuadraticEaseIn(p));
case Ease.QuadraticInOut: return(QuadraticEaseInOut(p));
case Ease.CubicIn: return(CubicEaseIn(p));
case Ease.CubicOut: return(CubicEaseOut(p));
case Ease.CubicInOut: return(CubicEaseInOut(p));
case Ease.QuarticIn: return(QuarticEaseIn(p));
case Ease.QuarticOut: return(QuarticEaseOut(p));
case Ease.QuarticInOut: return(QuarticEaseInOut(p));
case Ease.QuinticIn: return(QuinticEaseIn(p));
case Ease.QuinticOut: return(QuinticEaseOut(p));
case Ease.QuinticInOut: return(QuinticEaseInOut(p));
case Ease.SineIn: return(SineEaseIn(p));
case Ease.SineOut: return(SineEaseOut(p));
case Ease.SineInOut: return(SineEaseInOut(p));
case Ease.CircularIn: return(CircularEaseIn(p));
case Ease.CircularOut: return(CircularEaseOut(p));
case Ease.CircularInOut: return(CircularEaseInOut(p));
case Ease.ExponentialIn: return(ExponentialEaseIn(p));
case Ease.ExponentialOut: return(ExponentialEaseOut(p));
case Ease.ExponentialInOut: return(ExponentialEaseInOut(p));
case Ease.ElasticIn: return(ElasticEaseIn(p));
case Ease.ElasticOut: return(ElasticEaseOut(p));
case Ease.ElasticInOut: return(ElasticEaseInOut(p));
case Ease.BackIn: return(BackEaseIn(p));
case Ease.BackOut: return(BackEaseOut(p));
case Ease.BackInOut: return(BackEaseInOut(p));
case Ease.BounceIn: return(BounceEaseIn(p));
case Ease.BounceOut: return(BounceEaseOut(p));
case Ease.BounceInOut: return(BounceEaseInOut(p));
case Ease.Linear: return(Linear(p));
case Ease.__Custom: return(del(p));
}
}
public override void OnEaseDelegateChanges(EaseDelegate easeFunction)
{
}
public void SetEase(EaseDelegate easeFunction)
{
EaseFunction = easeFunction;
OnEaseDelegateChanges(EaseFunction);
}
public abstract void OnEaseDelegateChanges(EaseDelegate easeFunction);
protected abstract T Evaluate(T a, T b, float t, EaseDelegate easeFunction);
public void SetEase(Ease ease)
{
easeFunction = TweenerCore.GetEaseFunction(ease);
}
public Interpolator(Ease ease)
{
easeFunction = TweenerCore.GetEaseFunction(ease);
}
