public static TweenRectMove moveRectFromTo(RectTransform rectTransform,
Func <Vector2> from,
Func <Vector2> to,
float duration = 1f,
TweenEase easing = null,
TweenStart onStart = null,
TweenComplete onComplete = null,
TweenCancel onCancel = null)
{
if (from == null)
{
throw new ArgumentNullException("from");
}
if (to == null)
{
throw new ArgumentNullException("to");
}
return(new TweenRectMove(rectTransform)
{
fromGetter = from,
toGetter = to,
easing = easing,
duration = duration,
externStart = onStart,
externComplete = onComplete,
externCancel = onCancel,
});
}
public static TweenMove moveFromTo(Transform transform,
Func <Vector3> from,
Func <Vector3> to,
float duration = 1f,
Space space = Space.Self,
TweenEase easing = null,
TweenStart onStart = null,
TweenComplete onComplete = null,
TweenCancel onCancel = null)
{
if (from == null)
{
throw new ArgumentNullException("from");
}
if (to == null)
{
throw new ArgumentNullException("to");
}
return(new TweenMove(transform)
{
fromGetter = from,
toGetter = to,
easing = easing,
space = space,
duration = duration,
externStart = onStart,
externComplete = onComplete,
externCancel = onCancel,
});
}
private IEnumerator Tween(MoveTweenData data, Action onComplete)
{
float timer = 0;
float duration = data.Duration;
TweenType tweenType = data.TweenType;
Vector3 startPosition = transform.position;
Vector3 endPosition = startPosition + data.EndPosition;
Vector3 difference = endPosition - startPosition;
Vector3 newPosition = startPosition;
while (timer < duration)
{
// @TODO: Limit it only to necessary axis for performance.
// For development purposes, all axis are available.
newPosition.x = TweenEase.GetNewValue(tweenType, timer, startPosition.x, difference.x, duration);
newPosition.y = TweenEase.GetNewValue(tweenType, timer, startPosition.y, difference.y, duration);
newPosition.z = TweenEase.GetNewValue(tweenType, timer, startPosition.z, difference.z, duration);
transform.position = newPosition;
timer = Mathf.Clamp(timer + Time.deltaTime, 0, duration);
yield return(new WaitForEndOfFrame());
}
transform.position = endPosition;
onComplete?.Invoke();
}
public static TweenEasing fromTo(Func <float> from,
Func <float> to,
float duration,
TweenEase easing = null,
TweenUpdate onUpdate = null,
TweenStart onStart = null,
TweenComplete onComplete = null,
TweenCancel onCancel = null)
{
if (from == null)
{
throw new ArgumentNullException("from");
}
if (to == null)
{
throw new ArgumentNullException("to");
}
easing = easing ?? Easings.Linear;
return(new TweenEasing
{
fromGetter = from,
toGetter = to,
easing = easing,
duration = duration,
externUpdate = onUpdate,
externStart = onStart,
externComplete = onComplete,
externCancel = onCancel,
});
}
private void Update()
{
if (_timer < _duration)
{
_currentValue = TweenEase.GetNewValue(_tweenType, _timer, _value, _value, _duration);
}
_timer = Mathf.Clamp(_timer + Time.deltaTime, 0, _duration);
}
public static TweenScale scaleFromTo(Transform transform,
Vector3 from,
Vector3 to,
float duration = 1f,
TweenEase easing = null,
TweenStart onStart = null,
TweenComplete onComplete = null,
TweenCancel onCancel = null)
{
return(new TweenScale(transform)
{
from = from,
to = to,
easing = easing,
duration = duration,
externStart = onStart,
externComplete = onComplete,
externCancel = onCancel,
});
}
public static TweenRectMove moveRectFromTo(RectTransform rectTransform,
Vector2 from,
Vector2 to,
float duration = 1f,
TweenEase easing = null,
TweenStart onStart = null,
TweenComplete onComplete = null,
TweenCancel onCancel = null)
{
return(new TweenRectMove(rectTransform)
{
from = from,
to = to,
easing = easing,
duration = duration,
externStart = onStart,
externComplete = onComplete,
externCancel = onCancel,
});
}
public static TweenScale scaleTo(Transform transform,
Vector3 to,
float duration = 1f,
TweenEase easing = null,
TweenStart onStart = null,
TweenComplete onComplete = null,
TweenCancel onCancel = null)
{
var tween = new TweenScale(transform)
{
to = to,
easing = easing,
duration = duration,
externStart = onStart,
externComplete = onComplete,
externCancel = onCancel,
};
tween.fromGetter = () => tween.transform.localScale;
return(tween);
}
public static TweenRectMove moveRectTo(RectTransform rectTransform,
Vector2 to,
float duration = 1f,
TweenEase easing = null,
TweenStart onStart = null,
TweenComplete onComplete = null,
TweenCancel onCancel = null)
{
var tween = new TweenRectMove(rectTransform)
{
to = to,
easing = easing,
duration = duration,
externStart = onStart,
externComplete = onComplete,
externCancel = onCancel,
};
tween.fromGetter = () => tween.rectTransform.anchoredPosition;
return(tween);
}
public static TweenRotate rotateFromTo(Transform transform,
Quaternion from,
Quaternion to,
float duration = 1f,
Space space = Space.Self,
TweenEase easing = null,
TweenStart onStart = null,
TweenComplete onComplete = null,
TweenCancel onCancel = null)
{
return(new TweenRotate(transform)
{
from = from,
to = to,
easing = easing,
space = space,
duration = duration,
externStart = onStart,
externComplete = onComplete,
externCancel = onCancel,
});
}
public static TweenRotate rotateTo(Transform transform,
Quaternion to,
float duration = 1f,
Space space = Space.Self,
TweenEase easing = null,
TweenStart onStart = null,
TweenComplete onComplete = null,
TweenCancel onCancel = null)
{
var tween = new TweenRotate(transform)
{
to = to,
easing = easing,
space = space,
duration = duration,
externStart = onStart,
externComplete = onComplete,
externCancel = onCancel,
};
tween.fromGetter = () => transform.localRotation;
return(tween);
}
public static TweenColorEasing fromTo(Color from,
Color to,
float duration,
TweenEase easing = null,
ColorTweenUpdate onUpdate = null,
TweenStart onStart = null,
TweenComplete onComplete = null,
TweenCancel onCancel = null)
{
easing = easing ?? Easings.Linear;
return(new TweenColorEasing
{
from = from,
to = to,
easing = easing,
duration = duration,
externUpdate = onUpdate,
externStart = onStart,
externComplete = onComplete,
externCancel = onCancel,
});
}
public static TweenMove moveTo(Transform transform,
Vector3 to,
float duration = 1f,
Space space = Space.Self,
TweenEase easing = null,
TweenStart onStart = null,
TweenComplete onComplete = null,
TweenCancel onCancel = null)
{
var tween = new TweenMove(transform)
{
to = to,
easing = easing,
duration = duration,
space = space,
externStart = onStart,
externComplete = onComplete,
externCancel = onCancel,
};
tween.fromGetter = () => tween.space == Space.Self ? tween.transform.localPosition : tween.transform.position;
return(tween);
}
public static TweenNodule FloatTo(float p_startValue, float p_finalValue, float p_duration, TweenEase p_easeType, Action <float> p_callbackUpdate)
{
return(FloatTo(p_startValue, p_finalValue, p_duration, p_easeType, 0, p_callbackUpdate));
}
public static TweenNodule Vector4To(Vector4 p_startValue, Vector4 p_finalValue, float p_duration, TweenEase p_easeType, float p_delay, bool p_useUnityTime, Action <Vector4> p_callbackUpdate)
{
TweenNodule __temp = ATween.FloatTo(0, 1, p_duration, p_easeType, p_delay, p_useUnityTime, delegate(float newFloat)
{
p_callbackUpdate(Vector4.Lerp(p_startValue, p_finalValue, newFloat));
});
return(__temp);
}
public static TweenNodule Vector4To(Vector4 p_startValue, Vector4 p_finalValue, float p_duration, TweenEase p_easeType, float p_delay, Action <Vector4> p_callbackUpdate)
{
return(Vector4To(p_startValue, p_finalValue, p_duration, p_easeType, p_delay, true, p_callbackUpdate));
}
public static TweenNodule RectTo(Rect p_startValue, Rect p_finalValue, float p_duration, TweenEase p_easeType, float p_delay, bool p_useUnityTime, Action <Rect> p_callbackUpdate)
{
TweenNodule __temp = ATween.FloatTo(0, 1, p_duration, p_easeType, p_delay, p_useUnityTime, delegate(float newFloat)
{
p_callbackUpdate(new Rect(
Mathf.Lerp(p_startValue.x, p_finalValue.x, newFloat),
Mathf.Lerp(p_startValue.y, p_finalValue.y, newFloat),
Mathf.Lerp(p_startValue.width, p_finalValue.width, newFloat),
Mathf.Lerp(p_startValue.height, p_finalValue.height, newFloat)
));
});
return(__temp);
}
public static TweenNodule RectTo(Rect p_startValue, Rect p_finalValue, float p_duration, TweenEase p_easeType, float p_delay, Action <Rect> p_callbackUpdate)
{
return(RectTo(p_startValue, p_finalValue, p_duration, p_easeType, p_delay, true, p_callbackUpdate));
}
public static TweenNodule ColorTo(Color p_startColor, Color p_finalColor, float p_duration, TweenEase p_easeType, float p_delay, bool p_useUnityTime, Action <Color> p_callbackUpdate)
{
TweenNodule __temp = ATween.FloatTo(0, 1, p_duration, p_easeType, p_delay, p_useUnityTime, delegate(float newFloat)
{
p_callbackUpdate(Color.Lerp(p_startColor, p_finalColor, newFloat));
});
return(__temp);
}
public static TweenNodule ColorTo(Color p_startColor, Color p_finalColor, float p_duration, TweenEase p_easeType, float p_delay, Action <Color> p_callbackUpdate)
{
return(ColorTo(p_startColor, p_finalColor, p_duration, p_easeType, p_delay, true, p_callbackUpdate));
}
public static TweenNodule QuaternionTo(Quaternion p_startValue, Quaternion p_finalValue, float p_duration, TweenEase p_easeType, float p_delay, bool p_useUnityTime, Action <Quaternion> p_callbackUpdate)
{
TweenNodule nodule = ATween.FloatTo(0, 1, p_duration, p_easeType, p_delay, p_useUnityTime, delegate(float newFloat)
{
p_callbackUpdate(Quaternion.Lerp(p_startValue, p_finalValue, newFloat));
});
return(nodule);
}
public static TweenNodule QuaternionTo(Quaternion p_startValue, Quaternion p_finalValue, float p_duration, TweenEase p_easeType, float p_delay, Action <Quaternion> p_callbackUpdate)
{
return(QuaternionTo(p_startValue, p_finalValue, p_duration, p_easeType, p_delay, true, p_callbackUpdate));
}
public static float Lerp(float from, float to, float t, TweenEase easing)
{
return(easing(t, from, to - from, 1f));
}
public static TweenNodule FloatTo(float p_startValue, float p_finalValue, float p_duration, TweenEase p_easeType, float p_delay, bool p_useUnityTime, Action <float> p_callbackUpdate)
{
return(FloatTo(p_startValue, p_finalValue, p_duration, p_easeType, p_delay, p_useUnityTime, false, p_callbackUpdate));
}
private static TweenNodule FloatTo(float p_startValue, float p_finalValue, float p_duration, TweenEase p_easeType, float p_delay, bool p_useUnityTime, bool p_isLoop, Action <float> p_callbackUpdate)
{
TweenNodule __nodule = new TweenNodule();
float __startValue = p_startValue;
float __counter = 0f;
float __timeNow = Time.time;
float __ableToStartIn = __timeNow + p_delay;
__nodule.args = new float[] { __counter };
__nodule.onLoop = p_isLoop;
if (p_useUnityTime)
{
__nodule.onResume += delegate()
{
__nodule.args[1] = Time.realtimeSinceStartup;
}
}
;
//Delegates the function that must be executed at each update
__nodule.toDo += delegate()
{
if (__ableToStartIn <= Time.time)
{
if (!__nodule.paused)
{
//Rescue variables from class
float ___counter = __nodule.args[0];
float __currentValue;
if (___counter < p_duration)
{
//Increment counter
if (!p_useUnityTime)
{
___counter += Timer.realDeltaTime;
}
else
{
___counter += Time.deltaTime;
}
float __normalizedTime = Mathf.Min(___counter / p_duration, 1f);
//Increment the returned value on callback depending on ease style
__currentValue = EaseMathsTween.GetTransaction(__startValue, p_finalValue, __normalizedTime, p_easeType);
//Call the callback
p_callbackUpdate(__currentValue);
//Save necessary vars into the class for further calculations
__nodule.args[0] = ___counter;
}
else
{
if (__nodule.onLoop)
{
__nodule.args[0] = 0;
__ableToStartIn = Time.realtimeSinceStartup + p_delay;
}
else
{
__nodule.finished = true;
}
}
}
}
};
CoreTween.aTweenInstance.AddNodule(__nodule);
return(__nodule);
}
private void UpdateScaler(float timeLeft)
{
DifficultyScale = (int)TweenEase.GetNewValue(_tweenType, _gameTimer.Duration - timeLeft, _difficultyRange.x, _difficultyRange.y, _gameTimer.Duration);
}
public static float Lerp(float from, float to, float t, float duration, TweenEase easing)
{
return(easing(t, from, to - from, duration));
}
public static float GetTransaction(float start, float end, float normalizedTime, TweenEase ease)
{
switch (ease)
{
default:
case TweenEase.LINEAR:
return(Linear(start, end, normalizedTime));
case TweenEase.SPRING:
return(SpringEase(start, end, normalizedTime));
case TweenEase.QUAD_IN:
return(EaseInQuad(start, end, normalizedTime));
case TweenEase.QUAD_OUT:
return(EaseOutQuad(start, end, normalizedTime));
case TweenEase.QUAD_IN_OUT:
return(EaseInOutQuad(start, end, normalizedTime));
case TweenEase.CUBIC_IN:
return(EaseInCubic(start, end, normalizedTime));
case TweenEase.CUBIC_OUT:
return(EaseOutCubic(start, end, normalizedTime));
case TweenEase.CUBIC_IN_OUT:
return(EaseInOutCubic(start, end, normalizedTime));
case TweenEase.BOUNCE_IN:
return(EaseInBounce(start, end, normalizedTime));
case TweenEase.BOUNCE_OUT:
return(EaseOutBounce(start, end, normalizedTime));
case TweenEase.ELASTIC_IN:
return(EaseInElastic(start, end, normalizedTime));
case TweenEase.ELASTIC_OUT:
return(EaseOutElastic(start, end, normalizedTime));
case TweenEase.ELASTIC_IN_OUT:
return(EaseInOutElastic(start, end, normalizedTime));
case TweenEase.QUART_IN:
return(EaseInQuart(start, end, normalizedTime));
case TweenEase.QUART_OUT:
return(EaseOutQuart(start, end, normalizedTime));
case TweenEase.QUART_IN_OUT:
return(EaseInOutQuart(start, end, normalizedTime));
case TweenEase.QUINT_IN:
return(EaseInQuint(start, end, normalizedTime));
case TweenEase.QUINT_OUT:
return(EaseOutQuint(start, end, normalizedTime));
case TweenEase.QUINT_IN_OUT:
return(EaseInOutQuint(start, end, normalizedTime));
case TweenEase.SINE_IN:
return(EaseInSine(start, end, normalizedTime));
case TweenEase.SINE_OUT:
return(EaseOutSine(start, end, normalizedTime));
case TweenEase.SINE_IN_OUT:
return(EaseInOutSine(start, end, normalizedTime));
case TweenEase.EXPO_IN:
return(EaseInExpo(start, end, normalizedTime));
case TweenEase.EXPO_OUT:
return(EaseOutExpo(start, end, normalizedTime));
case TweenEase.EXPO_IN_OUT:
return(EaseInOutExpo(start, end, normalizedTime));
case TweenEase.CIRC_IN:
return(EaseInCirc(start, end, normalizedTime));
case TweenEase.CIRC_OUT:
return(EaseOutCirc(start, end, normalizedTime));
case TweenEase.CIRC_IN_OUT:
return(EaseInOutCirc(start, end, normalizedTime));
case TweenEase.BACK_IN:
return(EaseInBack(start, end, normalizedTime));
case TweenEase.BACK_OUT:
return(EaseOutBack(start, end, normalizedTime));
case TweenEase.BACK_IN_OUT:
return(EaseInOutBack(start, end, normalizedTime));
}
}
