public static IEnumerator Animate(
float startValue,
float endValue,
float duration,
System.Action <float> setter,
EasingFunction.Ease ease = EasingFunction.Ease.Linear,
bool useUnscaledTime = false
)
{
if (setter != null)
{
var easingFunction = EasingFunction.GetEasingFunction(ease);
setter(startValue);
var t = 0f;
while (t < duration)
{
yield return(null);
t += useUnscaledTime? Time.unscaledDeltaTime : Time.deltaTime;
setter(easingFunction(startValue, endValue, t / duration));
}
setter(endValue);
}
}
public void SetupToaster(string newText, float newDuration, float newBeginFade, EasingFunction.Ease newEaseOut, float newFloatDistance)
{
text = newText;
duration = newDuration;
beginFade = newBeginFade;
outEasing = newEaseOut;
floatDistance = newFloatDistance;
UpdateAttributes();
}
public ColorGradient(
Color startColor,
Color endColor,
float duration,
EasingFunction.Ease easing
)
{
this.startColor = startColor;
this.endColor = endColor;
this.duration = duration;
this.easing = easing;
}
public void InitForUse(UpdateDelegate updateCallback, float delay, BeginDelegate beginCallback)
{
IsActive = true;
m_Progress = 0.0f;
m_Delay = delay;
m_EaseType = EasingFunction.Ease.Linear;
m_Speed = 1;
m_UpdateCallback = updateCallback;
m_BeginCallback = beginCallback;
m_EndCallback = null;
}
public void InitForUse(UpdateDelegate updateCallback)
{
IsActive = true;
m_Progress = 0.0f;
m_Delay = -0.1f;
m_EaseType = EasingFunction.Ease.Linear;
m_Speed = 1;
m_UpdateCallback = updateCallback;
m_BeginCallback = null;
m_EndCallback = null;
OnTerminateCallback = delegate { };
OnAbort = delegate { };
}
public static IEnumerator AnimateAlpha(
Image image,
float startValue,
float endValue,
float duration,
EasingFunction.Ease ease = EasingFunction.Ease.Linear,
bool useUnscaledTime = false
)
{
if (image == null)
{
return(null);
}
return(Animate(startValue, endValue, duration, (v) => image.color = image.color.WithAlpha(v), ease, useUnscaledTime));
}
public static IEnumerator AnimateAlpha(
CanvasGroup canvsGroup,
float startValue,
float endValue,
float duration,
EasingFunction.Ease ease = EasingFunction.Ease.Linear,
bool useUnscaledTime = false
)
{
if (canvsGroup == null)
{
return(null);
}
return(Animate(startValue, endValue, duration, (v) => canvsGroup.alpha = v, ease, useUnscaledTime));
}
/************************************************************************/
/* Task Builder */
/************************************************************************/
/// <summary>
/// Tweens actor position from one position to another.
/// </summary>
/// <param name="actor"></param>
/// <param name="newPos"></param>
/// <param name="easeFunc"></param>
/// <param name="duration"></param>
/// <param name="notOverrideExistingTask"></param>
public void TweenPosition(Transform newActor, Vector3 newPos, EasingFunction.Ease easeFunc, float newDuration, bool notOverrideExistingTask = default(bool))
{
// Merging parameters into TweenData set
TweenData newTweenData = new TweenData
{
actor = newActor,
modifyPosition = true,
func = easeFunc,
duration = newDuration
};
newTweenData.startPosition = newActor.position;
newTweenData.endPosition = newPos;
// Passing TweenData into main AddTask function
AddTask(newTweenData, notOverrideExistingTask);
}
public static IEnumerator Upper(float value, float goal, float seconds = 1, EasingFunction.Ease easing = EasingFunction.Ease.Linear)
{
float orig = value;
float i = 0.0f;
float sT = Time.time;
while (i < 1.0f)
{
i = (Time.time - sT) / (seconds);
EasingFunction.Ease ease = easing;
EasingFunction.Function func = EasingFunction.GetEasingFunction(ease);
value = func(orig, goal, i);
yield return(null);
}
}
IEnumerator MoveObject(Transform objectToMove, Vector3 position, float time, EasingFunction.Ease easeType = EasingFunction.Ease.Linear, Func <float, float, float> easingFunction = null)
{
//easingFunction = easingFunction ?? EasingFunction.GetEasingFunction(easeType);
//EasingFunction.Function =
var t = 0f;
var originalPosition = objectToMove.position;
var lastTime = Time.realtimeSinceStartup;
while (t < 1)
{
objectToMove.position = Vector3.Lerp(originalPosition, position, t);
//t += Time.deltaTime / time;
t += (Time.realtimeSinceStartup - lastTime) / time;
lastTime = Time.realtimeSinceStartup;
yield return(null);
}
}
// ///////
// Threads
// ///////
private IEnumerator PositionThread(Transform transform, Vector3 endPos, EasingFunction.Ease easeStyle, float duration)
{
// Local Info
Transform currentTransform = transform;
Vector3 currentEndPos = endPos;
EasingFunction.Ease currentEaseStyle = easeStyle;
float currentDuration = duration;
Vector3 currentStartPos = transform.position;
for (float t = 0; t < currentDuration; t += Time.deltaTime)
{
Position(currentTransform, currentStartPos, currentEndPos, currentEaseStyle, currentDuration, t);
yield return(new WaitForEndOfFrame());
}
Position(currentTransform, currentStartPos, currentEndPos, currentEaseStyle, currentDuration, currentDuration);
}
private IEnumerator RotationThread(Transform transform, Vector3 endRot, EasingFunction.Ease easeStyle, float duration)
{
// Local Info
Transform currentTransform = transform;
Vector3 currentEndRot = endRot;
EasingFunction.Ease currentEaseStyle = easeStyle;
float currentDuration = duration;
Vector3 currentStartRot = transform.eulerAngles;
for (float t = 0; t < currentDuration; t += Time.deltaTime)
{
Rotation(currentTransform, currentStartRot, currentEndRot, currentEaseStyle, currentDuration, t);
yield return(new WaitForEndOfFrame());
}
Rotation(currentTransform, currentStartRot, currentEndRot, currentEaseStyle, currentDuration, currentDuration);
}
public static IEnumerator Mover(Transform transform, Vector3 newpos, float time, EasingFunction.Ease easing)
{
float i = 0.0f;
float sT = Time.time;
while (i < 1.0f)
{
i = (Time.time - sT) / (time);
EasingFunction.Ease ease = easing;
EasingFunction.Function func = EasingFunction.GetEasingFunction(ease);
float x = func(transform.position.x, newpos.x, i);
float y = func(transform.position.y, newpos.y, i);
float z = func(transform.position.z, newpos.z, i);
transform.position = new Vector3(x, y, z);
yield return(null);
}
}
/// <summary>
/// Tweens actor scale from one size to another.
/// </summary>
/// <param name="actor"></param>
/// <param name="newScale"></param>
/// <param name="easeFunc"></param>
/// <param name="duration"></param>
/// <param name="notOverrideExistingTask"></param>
public void TweenScale(Transform newActor, Vector3 newScale, EasingFunction.Ease easeFunc, float newDuration, bool notOverrideExistingTask = default(bool))
{
// Merging parameters into TweenData set
TweenData newTweenData = new TweenData
{
actor = newActor,
modifyScale = true,
func = easeFunc,
duration = newDuration
};
Transform startT = newActor;
Transform endT = startT;
endT.localScale = newScale;
newTweenData.startScale = newActor.localScale;
newTweenData.endScale = newScale;
// Passing TweenData into main AddTask function
AddTask(newTweenData, notOverrideExistingTask);
}
IEnumerator DriveTimer(float delayTime, float time, EasingFunction.Ease easingType, Action <float> callBack)
{
if (delayTime > 0.0f)
{
yield return(new WaitForSeconds(delayTime));
}
float elapsedTime = 0.0f;
while (elapsedTime < time)
{
elapsedTime += Time.deltaTime;
float factor = EasingFunction.GetEasingFunction(easingType).Invoke(0.0f, 1.0f, Mathf.Clamp01(elapsedTime / time));
if (callBack != null)
{
callBack.Invoke(factor);
}
yield return(new WaitForEndOfFrame());
}
}
private void Rotation(Transform t, Vector3 startRot, Vector3 endRot, EasingFunction.Ease easeStyle, float duration, float time)
{
float p = EasingFunction.GetEasingFunction(easeStyle)(0.0f, duration, time / duration) / duration;
t.eulerAngles = Vector3.LerpUnclamped(startRot, endRot, p);
}
void IInstruction <T> .SetEase(EasingFunction.Ease type)
{
EaseFunction = EasingFunction.GetEasingFunction(type);
}
ITaskTweener ITaskTweener.SetEaseType(EasingFunction.Ease type)
{
Instruction.SetEase(type);
return(this);
}
public Tweener SetEase(EasingFunction.Ease easetype)
{
m_EaseType = easetype;
return(this);
}
/// <summary>
/// Tween position and rotation of selected transform from current transform to end transform.
/// </summary>
/// <param name="transform">Active transform</param>
/// <param name="endPos">End position</param>
/// <param name="endRot">End rotation</param>
/// <param name="easeStyle">Easing style</param>
/// <param name="duration">Duration length</param>
public void TweenPositionAndRotation(Transform transform, Vector3 endPos, Vector3 endRot, EasingFunction.Ease easeStyle, float duration)
{
StartCoroutine(PositionRotationThread(transform, endPos, endRot, easeStyle, duration));
}
public Easing(AnimationCurve curve)
{
Type = EasingType.Curve;
Curve = curve;
Function = EasingFunction.Ease.Linear;
}
public static void Move(this Transform transform, Vector3 newpos, float time = 1, EasingFunction.Ease easing = EasingFunction.Ease.Linear)
{
LootSaberController.Instance.StartCoroutine(Mover(transform, newpos, time, easing));
}
// //////
// Helper
// //////
private void Position(Transform t, Vector3 startPos, Vector3 endPos, EasingFunction.Ease easeStyle, float duration, float time)
{
float p = EasingFunction.GetEasingFunction(easeStyle)(0.0f, duration, time / duration) / duration;
t.position = Vector3.LerpUnclamped(startPos, endPos, p);
}
public Easing(EasingFunction.Ease function)
{
Type = EasingType.Function;
Function = function;
Curve = AnimationCurve.Linear(0, 0, 1, 1);
}
public static void Move(this Transform transform, float newX, float newY, float newZ, float time = 1, EasingFunction.Ease easing = EasingFunction.Ease.Linear)
{
Vector3 tv3 = new Vector3(newX, newY, newZ);
LootSaberController.Instance.StartCoroutine(Mover(transform, tv3, time, easing));
}
private void Rotation(Transform t, Quaternion startRot, Quaternion endRot, EasingFunction.Ease easeStyle, float duration, float time)
{
float p = EasingFunction.GetEasingFunction(easeStyle)(0.0f, duration, time / duration) / duration;
t.rotation = Quaternion.LerpUnclamped(startRot, endRot, p);
}
public static void GoUp(this int value, int goal, float seconds = 1, EasingFunction.Ease easing = EasingFunction.Ease.Linear)
{
LootSaberController.Instance.StartCoroutine(Upper(value, goal, seconds, easing));
}
private void Scale(Transform t, Vector3 startScale, Vector3 endScale, EasingFunction.Ease easeStyle, float duration, float time)
{
float p = EasingFunction.GetEasingFunction(easeStyle)(0.0f, duration, time / duration) / duration;
t.localScale = Vector3.LerpUnclamped(startScale, endScale, p);
}
/* WIP edit time scrub bar and play button
* Maybe move to own class so can re-use (e.g. ActionHelpers)
* private static readonly GUIContent scrubLabel = new GUIContent("Preview", "Preview tween in the Scene View.");
*
* private static Texture _playIcon;
*
* private static Texture playIcon
* {
* get
* {
* if (_playIcon == null)
* {
* _playIcon = EditorGUIUtility.IconContent("IN foldout act").image;
* }
*
* return _playIcon;
* }
* }
*
* private static GUIStyle _buttonStyle;
*
* private static GUIStyle buttonStyle
* {
* get
* {
* if (_buttonStyle == null)
* {
* _buttonStyle = new GUIStyle("Button");
* _buttonStyle.padding = new RectOffset(2,2,0,0);
* }
*
* return _buttonStyle;
* }
* }
*/
/// <summary>
/// Draws scrubbing controls and a preview curve for EasingFunctions
/// </summary>
/// <param name="ease">The Ease function to preview</param>
/// <param name="playPreview">Did the user hit Play in the scrubbing slider</param>
/// <param name="currentTime">Used to draw the current time on the preview</param>
/// <param name="currentTimeColor">Color used to draw current time</param>
public static void DrawPreviewCurve(EasingFunction.Ease ease, ref bool playPreview, ref float currentTime, Color currentTimeColor)
{
/* WIP edit time preview
* if (!EditorApplication.isPlaying)
* {
* GUILayout.BeginHorizontal();
*
* EditorGUILayout.PrefixLabel(scrubLabel);
*
* playPreview = GUILayout.Toggle(playPreview, playIcon, buttonStyle, GUILayout.Height(15f), GUILayout.Width(17f));
*
* EditorGUI.BeginChangeCheck();
* currentTime = EditorGUILayout.Slider(currentTime, 0, 1);
* if (EditorGUI.EndChangeCheck())
* playPreview = false;
*
* GUILayout.EndHorizontal();
* }*/
if (ease == EasingFunction.Ease.CustomCurve)
{
return;
}
var func = EasingFunction.GetEasingFunction(ease);
var derivFunc = EasingFunction.GetEasingFunctionDerivative(ease);
if (func == null || derivFunc == null)
{
return;
}
var area = ActionHelpers.GetControlPreviewRect(45f);
// some ease functions overshoot 0 and 1
// so leave some margins at top/bottom
const float overflow = .3f;
var yRange = area.height * (1 - 2 * overflow);
// setup the range
var origin = new Vector2(area.x, area.yMax - area.height * overflow);
var yMax = new Vector2(area.x, area.y + area.height * overflow);
// draw axis (horizontal lines at 0 and 1)
var axisColor = EditorStyles.label.normal.textColor;
axisColor.a = 0.2f;
Handles.color = axisColor;
Handles.DrawLine(origin, new Vector3(area.xMax, origin.y));
Handles.DrawLine(yMax, new Vector3(area.xMax, yMax.y));
// draw curve
Handles.color = EditorStyles.label.normal.textColor;
var numSampleSteps = (int)area.width / 2;
// add start point: (0,0)
pointBuffer[0] = new Vector3(origin.x, origin.y);
// only add points to the curve when curve threshold is exceeded
// e.g. so a linear ease will only have 2 points
const float curveThreshold = 0.05f;
var prevSlope = 0f;
var pointIndex = 1;
for (var i = 1; i < numSampleSteps && pointIndex < maxCurvePoints - 1; i++)
{
var step = i / (float)numSampleSteps;
var y = func(0, 1, step);
var slope = derivFunc(0, 1, step);
if (Mathf.Abs(slope - prevSlope) > curveThreshold ||
Mathf.Sign(slope) != Mathf.Sign(prevSlope))
{
prevSlope = slope;
pointBuffer[pointIndex++] = new Vector3(origin.x + step * area.width, origin.y - y * yRange);
}
}
// add last point, to guarantee at least 2 points (e.g., linear)
pointBuffer[pointIndex] = new Vector3(area.xMax, origin.y - func(0, 1, 1) * yRange);
// draw the curve
Handles.DrawAAPolyLine(2, pointIndex + 1, pointBuffer);
// draw current time
if (Application.isPlaying && currentTime > 0)
{
var x = area.x + area.width * currentTime;
var y = origin.y - func(0, 1, currentTime) * yRange;
var guiColor = GUI.color;
GUI.color = currentTimeColor;
GUI.DrawTexture(new Rect(x - 1, y - 1, 2, 2), EditorGUIUtility.whiteTexture);
GUI.color = new Color(GUI.color.r, GUI.color.g, GUI.color.b, 0.2f);
GUI.DrawTexture(new Rect(x - 1, area.y, 2, area.height), EditorGUIUtility.whiteTexture);
GUI.color = guiColor;
//Handles.DrawLine(new Vector3(x, area.y), new Vector3(x, area.yMax));
}
// need to do this?
Handles.color = Color.white;
#if DEBUG_EASE_EDITOR
// debug the number of points generated when sampling this curve
if (debugged != ease && pointIndex > 1)
{
Debug.Log(pointIndex);
debugged = ease;
}
#endif
}
private void Scale(Transform t, float startScale, float endScale, EasingFunction.Ease easeStyle, float duration, float time)
{
//TODO: Make scalable tween using one float value
}
