/// <summary>
/// Lerp the color of a UI element over time.
/// </summary>
/// <param name="targetGraphic">The target UI element to effect.</param>
/// <param name="color">The new color to lerp to.</param>
/// <param name="time">The amount of time to lerp over.</param>
/// <param name="tScale">The method used to evaluate T as the lerp occurs. Defaults to linear.</param>
/// <param name="callback">Function to call when this lerp has completed.</param>
/// <returns></returns>
public static IEnumerator LerpUIColor(
Graphic targetGraphic, Color color, float time, PercentageEvaluator tScale = null,
CallOnComplete callback = null)
{
if (tScale == null)
{
tScale = LINEAR_EVALUATOR;
}
float elapsedTime = 0.0f;
Color startingVal = targetGraphic.color;
while (elapsedTime < time)
{
yield return(null);
targetGraphic.color = Color.Lerp(startingVal, color, tScale(elapsedTime, time));
elapsedTime += Time.deltaTime;
}
targetGraphic.color = color;
if (callback != null)
{
callback();
}
}
/// <summary>
/// Lerps the intensity of a light over the amount of time provided.
/// </summary>
/// <param name="light">The light to lerp.</param>
/// <param name="newIntensity">The new target intensity value.</param>
/// <param name="time">The amount of time to lerp over.</param>
/// <param name="tScale">The method used to evaluate T as the lerp occurs. Defaults to linear.</param>
/// <param name="callback">Function to call when this lerp has completed.</param>
public static IEnumerator LerpLightIntensity(
Light light, float newIntensity, float time, PercentageEvaluator tScale = null, CallOnComplete callback = null)
{
if (tScale == null)
{
tScale = LINEAR_EVALUATOR;
}
float elapsedTime = 0.0f, startingVal = light.intensity;
while (elapsedTime < time)
{
light.intensity = Mathf.Lerp(startingVal, newIntensity, tScale(elapsedTime, time));
elapsedTime += Time.deltaTime;
yield return(null);
}
light.intensity = newIntensity;
if (callback != null)
{
callback();
}
}
/// <summary>
/// Private function for lerping a world position.
/// </summary>
private static IEnumerator LerpWorldPos(Transform obj, Vector3 p, float t, PercentageEvaluator tScale)
{
float currentTime = 0.0f;
Vector3 startPos = obj.position;
while (currentTime < t)
{
obj.transform.position = Vector3.Lerp(startPos, p, tScale(currentTime, t));
currentTime += Time.deltaTime;
yield return(null);
}
obj.transform.position = p;
}
/// <summary>
/// Generic coroutine to scale the rotation of an object in 3D.
/// </summary>
/// <param name="tRef">The transform to move.</param>
/// <param name="target">The new target position.</param>
/// <param name="time">Time to lerp over.</param>
/// <param name="tScale">The method used to evaluate T as the lerp occurs. Defaults to linear.</param>
/// <param name="callback">Function to call when this lerp has completed.</param>
public static IEnumerator LerpScale(
Transform tRef, Vector3 target, float time, PercentageEvaluator tScale = null, CallOnComplete callback = null)
{
if (tScale == null)
{
tScale = LINEAR_EVALUATOR;
}
yield return(LerpLocalScale(tRef, target, time, tScale));
if (callback != null)
{
callback();
}
}
/// <summary>
/// Generic coroutine to lerp the position of an object in 3D.
/// </summary>
/// <param name="tRef">The transform to move.</param>
/// <param name="target">The new target position.</param>
/// <param name="time">Time to lerp over.</param>
/// <param name="space">Whether to apply this transformation to the local or world position.</param>
/// <param name="tScale">The method used to evaluate T as the lerp occurs. Defaults to linear.</param>
/// <param name="callback">Function to call when this lerp has completed.</param>
public static IEnumerator LerpPosition(
Transform tRef, Vector3 target, float time, Space space = Space.Self, PercentageEvaluator tScale = null,
CallOnComplete callback = null)
{
if (tScale == null)
{
tScale = LINEAR_EVALUATOR;
}
if (space == Space.Self)
{
yield return(LerpLocalPos(tRef, target, time, tScale));
}
else
{
yield return(LerpWorldPos(tRef, target, time, tScale));
}
if (callback != null)
{
callback();
}
}
/// <summary>
/// Private fucntion for lerping a local rotation.
/// </summary>
private static IEnumerator LerpLocalScale(Transform obj, Vector3 scale, float t, PercentageEvaluator tScale)
{
float currentTime = 0.0f;
Vector3 startPos = obj.localScale;
while (currentTime < t)
{
obj.transform.localScale = Vector3.Lerp(startPos, scale, tScale(currentTime, t));
currentTime += Time.deltaTime;
yield return(null);
}
obj.transform.localScale = scale;
}
/// <summary>
/// Private function for lerping a world rotation.
/// </summary>
private static IEnumerator LerpWorldRot(Transform t, Quaternion rot, float time, PercentageEvaluator tScale)
{
float currentTime = 0.0f;
Quaternion startRot = t.rotation;
while (currentTime < time)
{
t.rotation = Quaternion.Slerp(startRot, rot, tScale(currentTime, time));
currentTime += Time.deltaTime;
yield return(new WaitForEndOfFrame());
}
t.rotation = rot;
}
