public ITween <T> Create <T>(Easing.Ease <T> e, T a, T b, float d, float dlay = 0f, float ts = 1f)
{
Tween <T> newTween = new Tween <T>(e, a, b, d, dlay, ts);
m_tweens.Add(newTween);
return(newTween);
}
//--------------------------------------------------------------------------------------------------------------
public static Vector3 EaseTypeVector(Easing.Ease _ease, Vector3 _start, Vector3 _end, float _process)
{
return(new Vector3
(
EaseingFloat
(
_ease,
_start.x,
_end.x,
_process
),
EaseingFloat
(
_ease,
_start.y,
_end.y,
_process
),
EaseingFloat
(
_ease,
_start.z,
_end.z,
_process
)
));
}
public ITweenCurve Create(AnimationCurve c, Easing.Ease <float> e, float d, float dlay = 0f, float ts = 1f)
{
TweenCurve newTween = new TweenCurve(c, e, d, dlay, ts);
m_tweens.Add(newTween);
return(newTween);
}
private static Color LerpColorWithEase(Color colFrom, Color colTo, float t, Easing.Ease easing)
{
return(new(
Mathf.Lerp(colFrom.r, colTo.r, Easing.EaseResult(easing, 0f, 1f, t)),
Mathf.Lerp(colFrom.g, colTo.g, Easing.EaseResult(easing, 0f, 1f, t)),
Mathf.Lerp(colFrom.b, colTo.b, Easing.EaseResult(easing, 0f, 1f, t)),
Mathf.Lerp(colFrom.a, colTo.a, Easing.EaseResult(easing, 0f, 1f, t))
));
}
/// <summary>
/// Init the base properties of the
/// </summary>
/// <param name="e">Easing equation</param>
/// <param name="a">Starting value</param>
/// <param name="b">Final value</param>
/// <param name="d">Duration</param>
/// <param name="dlay">Delay</param>
/// <param name="ts">Timescale</param>
public void Init(Easing.Ease <T> e, T a, T b, float d, float dlay = 0f, float ts = 1f)
{
m_ease = e;
m_delay = dlay;
m_duration = d;
m_timescale = ts;
Init(a, b);
}
private static Task AddTask(float time, Easing.Ease easing)
{
return(new()
{
normalizedProcess = 0f,
time = 0f,
goalTime = time,
easing = easing,
Data = new Hashtable()
});
}
//--------------------------------------------------------------------------------------------------------------
public static float EaseingFloat(Easing.Ease _ease, float _start, float _end, float _progress)
{
return(Easing
.GetEasingFunction(_ease)
.Invoke
(
_start,
_end,
_progress
));
}
Task AddTask(float time, Easing.Ease easing)
{
return(new Task()
{
t = 0f,
time = 0f,
goalTime = time,
easing = easing,
data = new Hashtable()
});
}
public static Task RotateTo(Transform obj, Quaternion rotTo, float time, Easing.Ease easing, System.Action callback = null)
{
Task task = a.AddTask(time, easing);
task.type = TaskType.rotate;
task.data["transform"] = obj;
task.data["from"] = obj.rotation;
task.data["to"] = rotTo;
task.callback = callback;
a.tasks.Add(task);
return(task);
}
public static Task ImageTintColor(Image image, Color colorTo, float time, Easing.Ease easing, Action callback = null)
{
var task = AddTask(time, easing);
task.type = TaskType.ImageTintColor;
task.Data["image"] = image;
task.Data["from"] = image.tintColor;
task.Data["to"] = colorTo;
task.Callback = callback;
Instance.tasks.Add(task);
return(task);
}
public static Task MaterialColor(Material mat, Color colorTo, float time, Easing.Ease easing, Action callback = null)
{
var task = AddTask(time, easing);
task.type = TaskType.MaterialColor;
task.Data["material"] = mat;
task.Data["from"] = mat.color;
task.Data["to"] = colorTo;
task.Callback = callback;
Instance.tasks.Add(task);
return(task);
}
public static Task ScaleLocal(Transform obj, Vector3 rotTo, float time, Easing.Ease easing, Action callback = null)
{
var task = AddTask(time, easing);
task.type = TaskType.ScaleLocal;
task.Data["transform"] = obj;
task.Data["from"] = obj.localScale;
task.Data["to"] = rotTo;
task.Callback = callback;
Instance.tasks.Add(task);
return(task);
}
public static Task MoveTo(Transform obj, Vector3 posTo, float time, Easing.Ease easing, Action callback = null)
{
var task = AddTask(time, easing);
task.type = TaskType.Move;
task.Data["transform"] = obj;
task.Data["from"] = obj.position;
task.Data["to"] = posTo;
task.Callback = callback;
Instance.tasks.Add(task);
return(task);
}
public static Task ScaleTo(Transform obj, Vector3 scaleTo, float time, Easing.Ease easing, System.Action callback = null)
{
Task task = a.AddTask(time, easing);
task.type = TaskType.scale;
task.data["transform"] = obj;
task.data["from"] = obj.localScale;
task.data["to"] = scaleTo;
task.callback = callback;
a.tasks.Add(task);
return(task);
}
public static Task MoveToLocal(Transform obj, Vector3 posTo, float time, Easing.Ease easing, System.Action callback = null)
{
Task task = a.AddTask(time, easing);
task.type = TaskType.moveLocal;
task.data["transform"] = obj;
task.data["from"] = obj.localPosition;
task.data["to"] = posTo;
task.callback = callback;
a.tasks.Add(task);
return(task);
}
public static IDisposable LerpAlpha(this CanvasGroup _source, Easing.Ease _easing, int _milliseconds, float _target, bool _adjustInteractAble = true, Action _onComplete = null)
{
var progress = 0f;
var current = _source.alpha;
var different = _target - current;
return(LerpThread
.Execute
(
_milliseconds,
_count =>
{
progress += Time.deltaTime / (_milliseconds * GlobalConstant.MILLISECONDS_TO_SECONDS);
var easingProgress = EasingVector.EaseingFloat(_easing, current, _target, progress);
_source.SetAlpha(easingProgress, _adjustInteractAble);
},
() =>
{
_source.SetAlpha(Mathf.Clamp01(_target), _adjustInteractAble);
_onComplete?.Invoke();
}
));
}
Quaternion UpdateRotate(Quaternion rotFrom, Quaternion rotTo, float t, Easing.Ease easing)
{
return(Quaternion.Lerp(rotFrom, rotTo, Easing.EaseResult(easing, 0f, 1f, t)));
}
Vector3 UpdateMoveUI(Vector2 posFrom, Vector2 posTo, float t, Easing.Ease easing)
{
return(Vector2.Lerp(posFrom, posTo, Easing.EaseResult(easing, 0f, 1f, t)));
}
Vector3 UpdateScale(Vector3 scaleFrom, Vector3 scaleTo, float t, Easing.Ease easing)
{
return(Vector3.Lerp(scaleFrom, scaleTo, Easing.EaseResult(easing, 0f, 1f, t)));
}
public static Task TweenMesh(MeshTween mesh, int stateFrom, int stateTo, float from, float to, float time, Easing.Ease easing, System.Action callback = null)
{
Task task = a.AddTask(time, Easing.Ease.Linear);
task.type = TaskType.tweenMesh;
task.data["between"] = null;
task.data["mesh"] = mesh;
task.data["statefrom"] = stateFrom;
task.data["stateto"] = stateTo;
task.data["from"] = from;
task.data["to"] = to;
task.callback = callback;
a.tasks.Add(task);
return(task);
}
Vector3 UpdateMoveArc(Vector3 posFrom, Vector3 posTo, float arcHeight, float t, Easing.Ease easing)
{
Vector3 pos = Vector3.Lerp(posFrom, posTo, Easing.EaseResult(easing, 0f, 1f, t));
pos.y += arcHeight * Mathf.Sin(Mathf.Clamp01(Easing.EaseResult(easing, 0f, 1f, t)) * Mathf.PI);
return(pos);
}
public static Task ActionFloat(System.Action <float> action, float from, float to, float time, Easing.Ease easing, System.Action callback = null)
{
Task task = a.AddTask(time, easing);
task.type = TaskType.actionFloat;
task.data["action"] = action;
task.data["from"] = from;
task.data["to"] = to;
task.callback = callback;
a.tasks.Add(task);
return(task);
}
public static Task ColorToSprite(SpriteRenderer sprite, Color colTo, float time, Easing.Ease easing, System.Action callback = null)
{
Task task = a.AddTask(time, easing);
task.type = TaskType.colorSprite;
task.data["sprite"] = sprite;
task.data["from"] = sprite.color;
task.data["to"] = colTo;
task.callback = callback;
a.tasks.Add(task);
return(task);
}
public static IDisposable AnimationTranslate(this RectTransform _rectTransform, Vector2 _target, float _duration, Easing.Ease _ease = Easing.Ease.EaseInOutQuad, Action _completed = null)
{
var progress = 0f;
var current = _rectTransform.anchoredPosition;
int milliseconds = Mathf.RoundToInt(_duration * 1000f);
Vector2 valueTarget;
return(LerpThread
.Execute
(
milliseconds,
_count =>
{
progress += Time.deltaTime / _duration;
valueTarget.x = EasingFormula.EasingFloat(_ease, current.x, _target.x, progress);
valueTarget.y = EasingFormula.EasingFloat(_ease, current.y, _target.y, progress);
_rectTransform.anchoredPosition = valueTarget;
},
() =>
{
valueTarget = _target;
_rectTransform.anchoredPosition = valueTarget;
_completed?.Invoke();
}
));
}
Color UpdateColor(Color colFrom, Color colTo, float t, Easing.Ease easing)
{
return(Color.Lerp(colFrom, colTo, Easing.EaseResult(easing, 0f, 1f, t)));
}
public static IDisposable AnimationHeight(this RectTransform _rectTransform, float _target, float _duration, Easing.Ease _ease = Easing.Ease.EaseInOutQuad, Action _completed = null)
{
var progress = 0f;
var currentHeight = _rectTransform.rect.height;
int milliseconds = Mathf.RoundToInt(_duration * 1000f);
float valueTarget;
return(LerpThread
.Execute
(
milliseconds,
_count =>
{
progress += Time.deltaTime / _duration;
valueTarget = EasingFormula.EasingFloat(_ease, currentHeight, _target, progress);
_rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, valueTarget);
},
() =>
{
valueTarget = _target;
_rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, valueTarget);
_completed?.Invoke();
}
));
}
public TweenCurve(AnimationCurve c, Easing.Ease <float> e, float d, float dlay = 0f, float ts = 1f)
: base(e, 0f, 1f, d, dlay, ts)
{
m_curve = c;
m_val = InternalComputeValue(0f);
}
private static Vector3 LerpVector3WithEase(Vector3 posFrom, Vector3 posTo, float t, Easing.Ease easing)
{
return(Vector3.Lerp(posFrom, posTo, Easing.EaseResult(easing, 0f, 1f, t)));
}
public static Task ColorToMaterial(Material material, Color colTo, float time, Easing.Ease easing, System.Action callback = null)
{
Task task = a.AddTask(time, easing);
task.type = TaskType.colorMaterial;
task.data["material"] = material;
task.data["from"] = material.color;
task.data["to"] = colTo;
task.callback = callback;
a.tasks.Add(task);
return(task);
}
public static IDisposable AnimationSize(this RectTransform _rectTransform, Vector2 _target, float _duration, Easing.Ease _ease = Easing.Ease.EaseInOutQuad, Action _completed = null)
{
var progress = 0f;
var rect = _rectTransform.rect;
var currentSize = new Vector2(rect.width, rect.height);
int milliseconds = Mathf.RoundToInt(_duration * 1000f);
Vector2 valueTarget;
return(LerpThread
.Execute
(
milliseconds,
_count =>
{
progress += Time.deltaTime / _duration;
valueTarget.x = EasingFormula.EasingFloat(_ease, currentSize.x, _target.x, progress);
valueTarget.y = EasingFormula.EasingFloat(_ease, currentSize.y, _target.y, progress);
_rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, valueTarget.y);
_rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, valueTarget.x);
},
() =>
{
valueTarget = _target;
_rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, valueTarget.y);
_rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, valueTarget.x);
_completed?.Invoke();
}
));
}