public FadeAction(float end, bool isRelative, bool isRecursive, float duration, Easer easer, LerpDirection direction)
{
_helper.Construct(end, duration, easer, direction);
_isRelative = isRelative;
_isRecursive = isRecursive;
}
public TypeAction(string text, float duration, Easer easer, LerpDirection direction)
{
// Set text
_text = text;
_helper.Construct(_text.Length, duration, easer, direction);
}
public TypeAction(string text, float duration, Easer easer, LerpDirection direction)
{
// Set text
_text = text;
_helper.Construct(_text.Length, duration, easer, direction);
}
// Use this for initialization
void Start()
{
//easer = new PowerEase(transform.position.x, transform.position.x + 15, 3, 5, Easer.EaseType.OUT);
easer = new PowerEase(transform.localScale.x, transform.localScale.x + 15, 3, 1, Easer.EaseType.IN);
easer.RunEase(this, 2);
}
public static IEnumerator CameraTo(
this Camera cam,
float target,
float duration,
Easer ease,
Action onComplete, float delay)
{
float elapsed = 0;
var start = cam.orthographicSize;
var range = target - start;
yield return(new WaitForSeconds(delay));
while (elapsed < duration)
{
elapsed = Mathf.MoveTowards(elapsed, duration, Time.deltaTime);
cam.orthographicSize = (start + range * ease(elapsed / duration));
yield return(0);
}
cam.orthographicSize = (target);
if (onComplete != null)
{
onComplete();
}
}
public static IEnumerator ScaleTo(
this Transform transform,
Vector3 target,
float duration,
float delay,
Easer ease,
Action onComplete)
{
float elapsed = 0;
var start = transform.localScale;
var range = target - start;
yield return(new WaitForSeconds(delay));
while (elapsed < duration)
{
elapsed = Mathf.MoveTowards(elapsed, duration, Time.deltaTime);
transform.localScale = start + range * ease(elapsed / duration);
yield return(0);
}
transform.localScale = target;
if (onComplete != null)
{
onComplete();
}
}
public void Construct(Vector2 start, Vector2 control, Vector2 end, float duration, float delay = 0.0f, Easer easer = null)
{
// Set start point
_start = start;
// Set control point
_control = control;
// Set end point
_end = end;
// Set duration
_duration = duration;
// Set delay time
_delay = delay;
// Set easer
_easer = easer ?? Ease.Linear;
// Set current value
_value = start;
// Set time
_time = 0;
// Not finished
_isFinished = false;
}
public static IEnumerator CurveTo(
this Transform transform,
Vector3 control,
Vector3 target,
float duration,
Easer ease,
Action onComplete)
{
float elapsed = 0;
var start = transform.localPosition;
Vector3 position;
float t;
while (elapsed < duration)
{
elapsed = Mathf.MoveTowards(elapsed, duration, Time.deltaTime);
t = ease(elapsed / duration);
position.x = start.x * (1 - t) * (1 - t) + control.x * 2 * (1 - t) * t + target.x * t * t;
position.y = start.y * (1 - t) * (1 - t) + control.y * 2 * (1 - t) * t + target.y * t * t;
position.z = start.z * (1 - t) * (1 - t) + control.z * 2 * (1 - t) * t + target.z * t * t;
transform.localPosition = position;
yield return(0);
}
transform.localPosition = target;
if (onComplete != null)
{
onComplete();
}
}
public IEnumerator PropelBullet( Vector3 target, float duration, Easer ease)
{
yield return StartCoroutine(transform.MoveTo (target, duration,ease));
gameObject.SetChildrenActive (false);
Messenger.Broadcast<GameObject>("ReturnMeToPool", gameObject);
StopAllCoroutines();
}
public HMoveAction(float end, bool isRelative, bool isLocal, float duration, Easer easer, LerpDirection direction)
{
_helper.Construct(end, duration, easer, direction);
_isRelative = isRelative;
_isLocal = isLocal;
}
// public LerpHelper()
// {
//
// }
//
// public LerpHelper(T value)
// {
// _value = value;
// }
//
// public LerpHelper(T start, T end, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
// {
// Construct(start, end, duration, easer, direction);
// }
public void Construct(T start, T end, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
// Set start value
_start = start;
// Set end value
_end = end;
// Set delta value
_delta = Subtract(end, start);
// Set current value
_value = (direction == LerpDirection.Backward) ? end : start;
// Set duration
_duration = duration;
// Set easer
_easer = easer ?? Ease.Linear;
// Set direction
_direction = direction;
// Clear time
_time = 0;
// Not finished
_isFinished = false;
}
public FadeAction(float end, bool isRelative, bool isRecursive, float duration, Easer easer, LerpDirection direction)
{
_helper.Construct(end, duration, easer, direction);
_isRelative = isRelative;
_isRecursive = isRecursive;
}
/// <summary>
/// Constructor. Specify basic information about the Tween.
/// </summary>
/// <param name="duration">Duration of the tween (in seconds or frames).</param>
/// <param name="type">Tween type, one of Tween.PERSIST (default), Tween.LOOPING, or Tween.ONESHOT.</param>
/// <param name="complete">Optional callback for when the Tween completes.</param>
/// <param name="ease">Optional easer function to apply to the Tweened value.`</param>
public Tween(float duration = 0, uint type = 0, OnComplete complete = null, Easer ease = null)
{
_target = duration;
_type = type;
Complete = complete;
_ease = ease;
}
public virtual void Transition()
{
#if (ownsEaser)
float transitionPercentage = Easer.Ease(easeType, 0, 1, timer / transitionTime);
#else
float transitionPercentage;
if (state < TransitionState.Waiting)//if transitioning in
{
if (transitionInTime == 0)
{
transitionPercentage = 1;//instantly skip transitions with no run time
}
else
{
transitionPercentage = transitionInCurve.Evaluate(currentTime / transitionInTime);
}
}
else//fade outs
{
if (fadeOutTime == 0)
{
transitionPercentage = 0;
}
else
{
transitionPercentage = fadeOutCurve.Evaluate(currentTime / fadeOutTime);
}
}
#endif
Transition(transitionPercentage);
}
public HMoveAction(float end, bool isRelative, bool isLocal, float duration, Easer easer, LerpDirection direction)
{
_helper.Construct(end, duration, easer, direction);
_isRelative = isRelative;
_isLocal = isLocal;
}
/**
* Starts moving along the path.
* @param duration Duration of the movement.
* @param ease Optional easer function.
*/
public void SetMotion(float duration, Easer ease = null)
{
UpdatePath();
_target = duration;
_speed = _distance / duration;
_ease = ease;
Start();
}
/**
* Starts moving along the path at the speed.
* @param speed Speed of the movement.
* @param ease Optional easer function.
*/
public void SetMotionSpeed(float speed, Easer ease = null)
{
UpdatePath();
_target = _distance / speed;
_speed = speed;
_ease = ease;
Start();
}
/// <summary>
/// Tweens the value from one value to another.
/// </summary>
/// <param name="fromValue">Start value.</param>
/// <param name="toValue">End value.</param>
/// <param name="duration">Duration of the tween.</param>
/// <param name="ease">Optional easer function.</param>
public void Tween(float fromValue, float toValue, float duration, Easer ease = null)
{
_start = Value = fromValue;
_range = toValue - Value;
_target = duration;
_ease = ease;
Start();
}
public static string ToString(Easer ease)
{
if (ease == Linear)
{
return("Linear");
}
else if (ease == QuadIn)
{
return("QuadIn");
}
else if (ease == QuadOut)
{
return("QuadOut");
}
else if (ease == QuadInOut)
{
return("QuadInOut");
}
else if (ease == CubeIn)
{
return("CubeIn");
}
else if (ease == CubeOut)
{
return("CubeOut");
}
else if (ease == CubeInOut)
{
return("CubeInOut");
}
else if (ease == BackIn)
{
return("BackIn");
}
else if (ease == BackOut)
{
return("BackOut");
}
else if (ease == BackInOut)
{
return("BackInOut");
}
else if (ease == ElasticIn)
{
return("ElasticIn");
}
else if (ease == ElasticOut)
{
return("ElasticOut");
}
else if (ease == ElasticInOut)
{
return("ElasticInOut");
}
return(null);
}
void Awake()
{
HalfDuration = Duration / 2f;
MaxScaleVector = VectorExtensions.FromValue(MaxScale);
DefaultScale = transform.localScale;
UpEaser = Ease.FromType(UpEase);
DownEaser = Ease.FromType(DownEase);
}
public LerpIntAction(int start, int end, float duration, Easer easer, LerpDirection direction, Action <int> callback)
{
// Construct helper
_helper.Construct(end, duration, easer, direction);
// Set start
_helper.Start = start;
// Set callback
_callback = callback;
}
/// <summary>
/// Tweens a numeric property. If this method has already been called, the values will be overwritten.
/// </summary>
/// <param name="obj">The object containing the property.</param>
/// <param name="property">The name of the property.</param>
/// <param name="to">Value to tween to.</param>
/// <param name="duration">Duration of the tween.</param>
/// <param name="ease">Optional easer function.</param>
public void Tween(object obj, string property, float to, float duration, Easer ease = null)
{
_info = new VarTweenInfo(obj, property);
_start = _info.Value;
_range = to - _start;
_target = duration;
_ease = ease;
Start();
}
public static IEnumerator MoveFrom(
this Transform transform,
Vector3 target,
float duration,
Easer ease,
Action onComplete)
{
var start = transform.localPosition;
transform.localPosition = target;
return(MoveTo(transform, start, duration, ease, onComplete));
}
public static IEnumerator RotateFrom(
this Transform transform,
Quaternion target,
float duration,
Easer ease,
Action onComplete)
{
var start = transform.localRotation;
transform.localRotation = target;
return(RotateTo(transform, start, duration, ease, onComplete));
}
public static IEnumerator RotateTo(this Transform transform, Quaternion target, float duration, Easer ease)
{
float elapsed = 0;
var start = transform.localRotation;
while (elapsed < duration)
{
elapsed = Mathf.MoveTowards(elapsed, duration, Time.deltaTime);
transform.localRotation = Quaternion.Lerp(start, target, ease(elapsed / duration));
yield return 0;
}
transform.localRotation = target;
}
public static IEnumerator CurveTo(this Transform transform, Vector3 control, Vector3 target, float duration, Easer ease)
{
float elapsed = 0;
var start = transform.localPosition;
while (elapsed < duration)
{
elapsed = Mathf.MoveTowards(elapsed, duration, Time.deltaTime);
transform.localPosition = Calc.Bezier(start, control, target, ease(elapsed / duration));
yield return 0;
}
transform.localPosition = target;
}
// public static IEnumerator HardBlink(this GameObject m_gameObj, float duration, float freq, IEnumerator coroutine)
// {
// Debug.Log ("blink");
// yield return callOverFreq( , 2.0f, 0.2f);
// //yield return 0;
// }
#endregion
#region Transform coroutines
public static IEnumerator MoveTo(this Transform transform, Vector3 target, float duration, Easer ease)
{
float elapsed = 0;
var start = transform.localPosition;
var range = target - start;
while (elapsed < duration)
{
elapsed = Mathf.MoveTowards(elapsed, duration, Time.deltaTime);
transform.localPosition = start + range * ease(elapsed / duration);
yield return 0;
}
transform.localPosition = target;
}
public static IEnumerator CurveFrom(
this Transform transform,
Vector3 control,
Vector3 start,
float duration,
Easer ease,
Action onComplete)
{
var target = transform.localPosition;
transform.localPosition = start;
return(CurveTo(transform, control, target, duration, ease, onComplete));
}
public static IEnumerator ScaleFrom(
this Transform transform,
Vector3 target,
float duration,
float delay,
Easer ease,
Action onComplete)
{
var start = transform.localScale;
transform.localScale = target;
return(ScaleTo(transform, start, duration, delay, ease, onComplete));
}
public void Construct(T end, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
// Set end value
_end = end;
// Set duration
_duration = duration;
// Set easer
_easer = easer ?? Ease.Linear;
// Set direction
_direction = direction;
}
/// <summary>
/// Interpolates a Vector3 between from and to, using the ease function.
/// </summary>
/// <param name="from">The value to interpolate from.</param>
/// <param name="to">The value to interpolate to.</param>
/// <param name="duration">The interpolation duration, in seconds.</param>
/// <param name="ease">The ease function.</param>
/// <param name="action">The action to perform with the interpolated value.</param>
/// <returns>The IEnumerator for the coroutine.</returns>
public static IEnumerator Interpolate(Vector3 from, Vector3 to, float duration, Easer ease, Action<Vector3> action)
{
float elapsed = 0;
Vector3 range = to - from;
while (elapsed < duration)
{
elapsed = Mathf.MoveTowards(elapsed, duration, Time.deltaTime);
action(from + range * ease(elapsed / duration));
yield return 0;
}
action(from + range * ease(1));
}
public static IEnumerator TranslateTo(this Transform transform, Vector3 target, float duration, Easer ease)
{
float elapsed = 0;
var start = transform.localPosition;
// var range = target;
while (elapsed < duration)
{
elapsed = Mathf.MoveTowards(elapsed, duration, Time.deltaTime);
transform.Translate(target * ease(elapsed / duration));
yield return 0;
}
//Debug.Log ("translate");
//transform.Translate(target);
//p_del();
}
public static IEnumerator MoveAlphaTo(this GameObject m_gameObj, float target, float duration, Easer ease)
{
float elapsed = 0;
Color c = m_gameObj.GetComponent<Renderer>().material.color;
var start = c.a;
var range = target - start;
while (elapsed < duration)
{
elapsed = Mathf.MoveTowards(elapsed, duration, Time.deltaTime);
c.a = start + range * ease(elapsed / duration);
m_gameObj.GetComponent<Renderer>().material.color = c;
yield return 0;
}
c.a = target;
m_gameObj.GetComponent<Renderer>().material.color = c;
}
/// <summary>
/// Tweens the color to a new color.
/// </summary>
/// <param name="duration">Duration of the tween.</param>
/// <param name="fromColor"></param>
/// <param name="toColor">Start color.</param>
/// <param name="ease">Optional easer function.</param>
public void tween(float duration, Color fromColor, Color toColor, Easer ease = null)
{
Color = fromColor;
uint from = FP.HexColor(fromColor);
uint to = FP.HexColor(toColor);
_startR = FP.GetRed(from);
_startG = FP.GetGreen(from);
_startB = FP.GetBlue(from);
_rangeR = FP.GetRed(to) - _startR;
_rangeG = FP.GetGreen(to) - _startG;
_rangeB = FP.GetBlue(to) - _startB;
_target = duration;
_ease = ease;
Start();
}
/// <summary>
/// Self implemented tweening method is needed to make it able to stop via StopAllCoroutines();
/// </summary>
/// <param name="transform">The actual game object as Transform.</param>
/// <param name="target">Target scale.</param>
/// <param name="duration">Duration of the tweening.</param>
/// <param name="ease">Ease parameter.</param>
/// <returns></returns>
public IEnumerator Tween(Transform transform, Vector3 target, float duration, Easer ease)
{
float elapsed = 0;
var start = transform.localScale;
var range = target - start;
while (elapsed < duration)
{
elapsed = Mathf.MoveTowards(elapsed, duration, Time.deltaTime);
if (transform != null)
{
transform.localScale = start + range * ease(elapsed / duration);
yield return(0);
}
}
if (transform != null)
{
transform.localScale = target;
}
}
public static IEnumerator RotateTo(
this Transform transform,
Quaternion target,
float duration,
Easer ease,
Action onComplete)
{
float elapsed = 0;
var start = transform.localRotation;
while (elapsed < duration)
{
elapsed = Mathf.MoveTowards(elapsed, duration, Time.deltaTime);
transform.localRotation = Quaternion.Lerp(start, target, ease(elapsed / duration));
yield return(0);
}
transform.localRotation = target;
if (onComplete != null)
{
onComplete();
}
}
IEnumerator Rotate()
{
Easer ease = delayBetweenMoves > 0.0f ? Ease.SineInOut : Ease.Linear;
while (active)
{
StartCoroutine(transform.RotateTo(Quaternion.Euler(0, 0, angles[i]), rotationDuration, ease));
if (angles.Count > 1)
{
i += iterationIncrement;
if (backAndForth)
{
if (i >= angles.Count - 1)
{
iterationIncrement = -1;
}
else if (i <= 0)
{
iterationIncrement = 1;
}
}
else
{
if (i >= angles.Count)
{
i = 0;
}
}
}
else
{
i = 0;
}
yield return(new WaitForSeconds(rotationDuration + delayBetweenMoves));
}
}
/// <summary>
/// Tweens multiple numeric properties
/// </summary>
/// <param name="obj">The object containing the properties. </param>
/// <param name="values">
/// An anonymous type object containing key/value pairs of properties and target values.
/// Example: new { X = 100, Y = 50 }
/// </param>
/// <param name="duration">Duration of the tween. </param>
/// <param name="ease">Optional Easer function.</param>
/// <param name="delay"></param>
public void Tween(object obj, object values, float duration, Easer ease = null, float delay = 0)
{
_object = obj;
foreach (PropertyInfo property in values.GetType().GetProperties())
{
var info = new VarTweenInfo(_object, property.Name);
var to = new VarTweenInfo(values, property.Name, VarTweenInfo.Options.Read);
float start = info.Value;
float range = to.Value - start;
_vars.Add(info);
_start.Add(start);
_range.Add(range);
}
// FIXME: delay does nothing!
_target = duration;
_ease = ease;
Start();
}
public static IEnumerator MoveTo(
this Transform transform,
Vector3 target,
float duration,
Easer ease,
Action onComplete)
{
float elapsed = 0;
var start = transform.localPosition;
var range = target - start;
while (elapsed < duration)
{
elapsed = Mathf.MoveTowards(elapsed, duration, Time.deltaTime);
transform.position = (start + range * ease(elapsed / duration));
yield return(0);
}
transform.position = (target);
if (onComplete != null)
{
onComplete();
}
}
public ResizeAction(Vector2 end, bool isRelative, float duration, Easer easer, LerpDirection direction)
{
_helper.Construct(end, duration, easer, direction);
_isRelative = isRelative;
}
public static FillAction Create(float end, bool isRelative, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
return new FillAction(end, isRelative, duration, easer, direction);
}
public static FillAction FillBy(float delta, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
return Create(delta, true, duration, easer, direction);
}
public static FadeAction FadeOut(float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
return Create(0.0f, false, false, duration, easer, direction);
}
public static IEnumerator CurveTo(this Transform transform, Vector3 control, Vector3 target, float duration, Easer ease)
{
float elapsed = 0;
var start = transform.localPosition;
Vector3 position;
float t;
while (elapsed < duration)
{
elapsed = Mathf.MoveTowards(elapsed, duration, Time.deltaTime);
t = ease(elapsed / duration);
position.x = start.x * (1 - t) * (1 - t) + control.x * 2 * (1 - t) * t + target.x * t * t;
position.y = start.y * (1 - t) * (1 - t) + control.y * 2 * (1 - t) * t + target.y * t * t;
position.z = start.z * (1 - t) * (1 - t) + control.z * 2 * (1 - t) * t + target.z * t * t;
transform.localPosition = position;
yield return 0;
}
transform.localPosition = target;
}
public static IEnumerator MoveFrom(this Transform transform, Vector3 target, float duration, Easer ease)
{
var start = transform.localPosition;
transform.localPosition = target;
return MoveTo(transform, start, duration, ease);
}
public static FadeAction RecursiveFadeTo(float end, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
return Create(end, false, true, duration, easer, direction);
}
public static HMoveAction MoveTo(float end, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
return Create(end, false, false, duration, easer, direction);
}
public static HMoveAction Create(float end, bool isRelative, bool isLocal, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
return new HMoveAction(end, isRelative, isLocal, duration, easer, direction);
}
public static RotateAction RotateBy(float end, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
return Create(end, true, duration, easer, direction);
}
public static ScaleAction ScaleBy(Vector3 end, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
return Create(end, true, duration, easer, direction);
}
public static FadeAction RecursiveFadeBy(float delta, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
return Create(delta, true, true, duration, easer, direction);
}
public static ResizeAction Create(Vector2 end, bool isRelative, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
return new ResizeAction(end, isRelative, duration, easer, direction);
}
public static IEnumerator ScaleFrom(this Transform transform, Vector3 target, float duration, Easer ease)
{
var start = transform.localScale;
transform.localScale = target;
return ScaleTo(transform, start, duration, ease);
}
public static ResizeAction ResizeTo(Vector2 end, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
return Create(end, false, duration, easer, direction);
}
public static IEnumerator RotateFrom(this Transform transform, Quaternion target, float duration, Easer ease)
{
var start = transform.localRotation;
transform.localRotation = target;
return RotateTo(transform, start, duration, ease);
}
public static MoveAction MoveLocalTo(Vector3 end, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
return Create(end, false, true, duration, easer, direction);
}
public static IEnumerator CurveFrom(this Transform transform, Vector3 control, Vector3 start, float duration, Easer ease)
{
var target = transform.localPosition;
transform.localPosition = start;
return CurveTo(transform, control, target, duration, ease);
}
public static float Combined(Easer start, Easer end, float t)
{
return (t <= 0.5 ? 0.5f * start(t * 2.0f) : 0.5f * end(t * 2.0f - 1) + 0.5f);
}
public static AnchoredMoveAction MoveBy(Vector2 end, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
return Create(end, true, duration, easer, direction);
}
public static TypeAction Create(string text, float duration, Easer easer = null, LerpDirection direction = LerpDirection.Forward)
{
return new TypeAction(text, duration, easer, direction);
}
