public ScaleActivity(float scaleFrom, float scaleTo, TimeSpan duration, EaseMode easeMode, Action<object[]> onCompletion = null)
: base(duration, onCompletion)
{
_from = scaleFrom;
_to = scaleTo;
_easeMode = easeMode;
}
public void DrawLineAnimation(float duration = 1.5f, EaseMode ease = EaseMode.Cubic)
{
if (animationDone)
{
StartCoroutine(AnimateThroughPoints(duration, ease));
}
}
static float Ease(float t, EaseMode mode)
{
const float a = 3;
switch (mode)
{
case EaseMode.Linear:
return(t);
case EaseMode.EaseIn:
return(Mathf.Pow(t, a));
case EaseMode.EaseOut:
return(1 - Mathf.Pow(1 - t, a));
case EaseMode.EaseInOut:
return(Mathf.Pow(t, a) / (Mathf.Pow(t, a) + Mathf.Pow(1 - t, a)));
case EaseMode.Step4:
return(Mathf.Round(t * 4) / 4);
default:
return(-1);
}
}
public void WipeCurveAnimation(float duration = 0.5f, EaseMode ease = EaseMode.Cubic)
{
if (animationDone)
{
StartCoroutine(AnimatePointsAway(duration, ease));
}
}
public MoveActivity(Vector2 fromPosition, Vector2 toPosition, TimeSpan duration, EaseMode easeMode, Action<object[]> onCompletion = null)
: base(duration, onCompletion)
{
_fromPosition = fromPosition;
_toPosition = toPosition;
_easeMode = easeMode;
}
protected override IEnumerator scaleTo(Vector3 newScale, float duration, EaseMode ease)
{
Vector3 initialScale = transform.localScale;
//Assume scale uniform, which should always be the case for graphs
float scaleFactor = (float)newScale.x / initialScale.x;
Dictionary <string, float> initialWidths = new Dictionary <string, float>();
foreach (KeyValuePair <string, CurveData> entry in curves)
{
//Assumes all linerenderers in a curve are the same width
initialWidths.Add(entry.Key, entry.Value.lineRenderers[0].widthMultiplier);
}
float startTime = Time.time;
while (Time.time < startTime + duration)
{
float t = (Time.time - startTime) / duration;
t = Helpers.ApplyNormalizedEasing(t, ease);
transform.localScale = Vector3.Lerp(initialScale, newScale, t);
foreach (KeyValuePair <string, CurveData> entry in curves)
{
foreach (LineRenderer lr in entry.Value.lineRenderers)
{
lr.widthMultiplier = Mathf.Lerp(initialWidths[entry.Key], initialWidths[entry.Key] * scaleFactor, t);
}
}
yield return(null);
}
transform.localScale = newScale; //Ensure we actually get exactly to newScale
}
public MoveActivity(Vector2 fromPosition, Vector2 toPosition, TimeSpan duration, EaseMode easeMode, Action <object[]> onCompletion = null)
: base(duration, onCompletion)
{
_fromPosition = fromPosition;
_toPosition = toPosition;
_easeMode = easeMode;
}
/// <summary>
/// Same as previus funtion but with easing in/out equations.
/// </summary>
public void DoTransition(CameraTransitionEffects transition, Camera from, Camera to, float time, EaseType easeType, EaseMode easeMode, params object[] parameters)
{
this.easeType = easeType;
this.easeMode = easeMode;
DoTransition(transition, from, to, time, parameters);
}
public ScaleActivity(float scaleFrom, float scaleTo, TimeSpan duration, EaseMode easeMode, Action <object[]> onCompletion = null)
: base(duration, onCompletion)
{
_from = scaleFrom;
_to = scaleTo;
_easeMode = easeMode;
}
public void RevertColor(float duration = 0.5f, EaseMode ease = EaseMode.None)
{
MeshRenderer[] mrs = GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer mr in mrs)
{
foreach (Material mat in mr.materials)
{
StartCoroutine(changeColor(mat, originalColors[mat], duration, ease));
}
}
}
public virtual void ChangeColor(Color newColor, float duration = 0.5f, EaseMode ease = EaseMode.None)
{
MeshRenderer[] mrs = GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer mr in mrs)
{
foreach (Material mat in mr.materials)
{
StartCoroutine(changeColor(mat, newColor, duration, ease));
}
}
}
public void FadeOut(float duration = 0.5f, EaseMode ease = EaseMode.None)
{
MeshRenderer[] mrs = GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer mr in mrs)
{
foreach (Material mat in mr.materials)
{
StandardShaderUtils.ChangeRenderMode(mat, StandardShaderUtils.BlendMode.Transparent);
}
}
ChangeAlpha(0, duration: duration, ease);
}
public EaseFunction(EaseFunctionType type, EaseMode mode, double lengthMs, double fromValue, double toValue)
{
m_type = type;
m_dLength = lengthMs;
m_dFrom = fromValue;
m_dTo = toValue;
m_function = GetEasingFunction(m_type);
if (mode != EaseMode.InOut)
{
m_function = TransformEase(m_function, (mode == EaseMode.In));
}
}
public void ChangeAlpha(float newAlpha, float duration = 0.5f, EaseMode ease = EaseMode.None)
{
MeshRenderer[] mrs = GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer mr in mrs)
{
foreach (Material mat in mr.materials)
{
Color newColor = mat.color;
newColor.a = newAlpha;
StartCoroutine(changeColor(mat, newColor, duration, ease));
}
}
}
public EaseFunction(EaseFunctionType type, EaseMode mode, double lengthMs, double fromValue, double toValue)
{
m_type = type;
m_dLength = lengthMs;
m_dFrom = fromValue;
m_dTo = toValue;
m_function = GetEasingFunction(m_type);
if (mode != EaseMode.InOut)
{
m_function = TransformEase(m_function, (mode == EaseMode.In));
}
}
private IEnumerator fadeIn(float duration = 0.5f, EaseMode ease = EaseMode.None)
{
ChangeAlpha(1, duration: duration, ease);
yield return(new WaitForSeconds(duration));
MeshRenderer[] mrs = GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer mr in mrs)
{
foreach (Material mat in mr.materials)
{
StandardShaderUtils.ChangeRenderMode(mat, StandardShaderUtils.BlendMode.Opaque);
}
}
}
private IEnumerator rotateTo(Quaternion newQuaternion, float duration, EaseMode ease)
{
Quaternion initialRot = transform.localRotation;
float startTime = Time.time;
while (Time.time < startTime + duration)
{
float t = (Time.time - startTime) / duration;
t = Helpers.ApplyNormalizedEasing(t, ease);
transform.localRotation = Quaternion.Slerp(initialRot, newQuaternion, t);
yield return(null);
}
transform.localRotation = newQuaternion; //Ensure we actually get exactly to newQuaternion
}
public static float Perform(EaseMode mode, float elapsed, float duration)
{
switch (mode)
{
case EaseMode.Out:
return Out(elapsed, duration);
case EaseMode.In:
return In(elapsed, duration);
case EaseMode.InOut:
return InOut(elapsed, duration);
default:
return elapsed;
}
}
private IEnumerator animateLightIntensityTo(float intensity, float duration, EaseMode ease)
{
Light l = GetComponent <Light>();
float initialIntensity = l.intensity;
float startTime = Time.time;
while (Time.time < startTime + duration)
{
float t = (Time.time - startTime) / duration;
t = Helpers.ApplyNormalizedEasing(t, ease);
l.intensity = Mathf.Lerp(initialIntensity, intensity, t);
yield return(null);
}
l.intensity = intensity;
}
protected virtual IEnumerator scaleTo(Vector3 newScale, float duration, EaseMode ease)
{
Vector3 initialScale = transform.localScale;
float startTime = Time.time;
while (Time.time < startTime + duration)
{
float t = (Time.time - startTime) / duration;
t = Helpers.ApplyNormalizedEasing(t, ease);
transform.localScale = Vector3.Lerp(initialScale, newScale, t);
yield return(null);
}
transform.localScale = newScale; //Ensure we actually get exactly to newScale
}
private IEnumerator moveTo(Vector3 newPos, float duration, EaseMode ease)
{
Vector3 initialPos = transform.localPosition;
float startTime = Time.time;
//Debug.Log(Time.frameCount);
while (Time.time < startTime + duration)
{
float t = (Time.time - startTime) / duration;
t = Helpers.ApplyNormalizedEasing(t, ease);
transform.localPosition = Vector3.Lerp(initialPos, newPos, t);
yield return(null);
}
//Debug.Log(Time.frameCount);
transform.localPosition = newPos; //Ensure we actually get exactly to newPos
}
//TODO: Get rid of _ClippingNumber. We already have the stap size and clipping number, so we could just
//_VisibleRange.
private IEnumerator animateClippingNumber(int newClippingNumber, float duration, EaseMode ease)
{
animationDone = false;
float startTime = Time.time;
while (Time.time < startTime + duration)
{
float t = (Time.time - startTime) / duration;
t = Helpers.ApplyNormalizedEasing(t, ease);
planeRenderer.material.SetFloat("_ClippingNumber", Mathf.Lerp(clippingNumber, newClippingNumber, t));
yield return(new WaitForEndOfFrame());
}
planeRenderer.material.SetFloat("_ClippingNumber", newClippingNumber);
clippingNumber = newClippingNumber;
animationDone = true;
}
public FadeActivity(Fade fade, TimeSpan duration, EaseMode easeMode, Action<object[]> onCompletion = null)
: base(duration, onCompletion)
{
switch (fade)
{
case Fade.In:
_from = 0.0F;
_to = 1.0F;
break;
case Fade.Out:
_from = 1.0F;
_to = 0.0F;
break;
}
_easeMode = easeMode;
}
public static float Perform(EaseMode mode, float elapsed, float duration)
{
switch (mode)
{
case EaseMode.Out:
return(Out(elapsed, duration));
case EaseMode.In:
return(In(elapsed, duration));
case EaseMode.InOut:
return(InOut(elapsed, duration));
default:
return(elapsed);
}
}
private IEnumerator walkTo(Vector3 newPos, float duration, EaseMode ease, bool faceOriginal)
{
Quaternion originalAngle = transform.localRotation;
//Turning should in general happen faster than displacing
//One unit in the blob's scale, assuming it's uniform.
float distance = (newPos - transform.position).magnitude;
float turnDuration = duration * Mathf.Min(1, transform.localScale.x / distance);
MoveTo(newPos, duration, ease);
LookToward(newPos, turnDuration, ease);
if (faceOriginal)
{
yield return(new WaitForSeconds(duration));
RotateTo(originalAngle.eulerAngles);
}
yield return(null);
}
public FadeActivity(Fade fade, TimeSpan duration, EaseMode easeMode, Action <object[]> onCompletion = null)
: base(duration, onCompletion)
{
switch (fade)
{
case Fade.In:
_from = 0.0F;
_to = 1.0F;
break;
case Fade.Out:
_from = 1.0F;
_to = 0.0F;
break;
}
_easeMode = easeMode;
}
/// <summary>
/// Animates the curve to a new curve, morphing along the y-axis
/// </summary>
/// <param name="values">The new curve to animate to. Must have the same number of values as the existing curve</param>
public void AnimateToNewCurve(Vector3[] values, float duration = 1.5f, EaseMode ease = EaseMode.Cubic)
{
if (Application.isPlaying)
{
if (animationDone)
{
StartCoroutine(animateCurveTransition(dataPoints, values, duration, ease));
}
else
{
ForceStopAnimation();
}
}
else
{
Refresh(values);
}
}
/// <summary>
/// Sweeps in the curve along the Y axis
/// </summary>
/// <param name="duration">The duration of the sweep in seconds</param>
public void AnimateY(float duration = 1.5f, EaseMode ease = EaseMode.Cubic)
{
if (Application.isPlaying)
{
if (animationDone)
{
StartCoroutine(animateVisibleRange(new Vector3(maxs.x, mins.y, maxs.z), maxs, duration, ease));
}
else
{
ForceStopAnimation();
}
}
else
{
UpdateVisibleRange(mins, maxs);
}
}
private IEnumerator changeRangeY(float newMin, float newMax, float duration, EaseMode ease)
{
float oldMin = this.yMin;
float oldMax = this.yMax;
//TODO: Make this work for non-zero mins by changing axis offset and rodcontainer
float startTime = Time.time;
while (Time.time <= startTime + duration)
{
float t = (Time.time - startTime) / duration;
t = Helpers.ApplyNormalizedEasing(t, ease);
this.yMin = Mathf.Lerp(oldMin, newMin, t);
this.yMax = Mathf.Lerp(oldMax, newMax, t);
yield return(null);
}
this.yMin = newMin;
this.yMax = newMax;
updateXRangeProperties();
}
/// <summary>
/// Sweeps in the curve along the X axis
/// </summary>
/// <param name="duration">The duration of the sweep in seconds</param>
public void AnimateX(float duration = 1.5f, EaseMode ease = EaseMode.Cubic)
{
if (Application.isPlaying)
{
if (animationDone)
{
planeRenderer.material.SetFloat("_ClippingNumber", numValuesInShaderFloatArray);
StartCoroutine(animateVisibleRange(new Vector3(mins.x, maxs.y, maxs.z), maxs, duration, ease));
}
else
{
ForceStopAnimation();
}
}
else
{
UpdateVisibleRange(mins, maxs);
}
}
public static float ApplyNormalizedEasing(float t, EaseMode ease)
{
switch (ease)
{
case EaseMode.Cubic:
return(easeInAndOutCubic(0, 1, t));
case EaseMode.Quadratic:
return(easeInAndOutQuadratic(0, 1, t));
case EaseMode.SmoothStep:
return(Mathf.SmoothStep(0, 1, t));
case EaseMode.None:
return(t);
default:
return(t);
}
}
public IEnumerator changeColor(Material mat, Color newColor, float duration, EaseMode ease)
{
//Assumes simple structure where the first meshrenderer in the hierarchy is what you want.
Color initialColor = mat.color;
if (!originalColors.ContainsKey(mat))
{
originalColors.Add(mat, initialColor);
}
float startTime = Time.time;
while (Time.time < startTime + duration)
{
float t = (Time.time - startTime) / duration;
t = Helpers.ApplyNormalizedEasing(t, ease);
mat.color = Color.Lerp(initialColor, newColor, t);
yield return(null);
}
mat.color = newColor;
}
/// <summary>
/// Do easing.
/// </summary>
public static float Ease(EaseType type, EaseMode mode, float from, float to, float t)
{
Func <float, float, float> easeFunc = null;
switch (type)
{
case EaseType.Linear: easeFunc = Linear; break;
case EaseType.Quad: easeFunc = Quad; break;
case EaseType.Cubic: easeFunc = Cubic; break;
case EaseType.Quart: easeFunc = Quart; break;
case EaseType.Quint: easeFunc = Quint; break;
case EaseType.Sine: easeFunc = Sine; break;
case EaseType.Expo: easeFunc = Expo; break;
case EaseType.Circ: easeFunc = Circ; break;
case EaseType.Elastic: easeFunc = Elastic; break;
case EaseType.Back: easeFunc = Back; break;
case EaseType.Bounce: easeFunc = Bounce; break;
}
switch (mode)
{
case EaseMode.In: return(In(easeFunc, t, from, to - from));
case EaseMode.Out: return(Out(easeFunc, t, from, to - from));
case EaseMode.InOut: return(InOut(easeFunc, t, from, to - from));
}
return(0.0f);
}
private IEnumerator rotateByEuler(Vector3 eulerRotation, float duration, EaseMode ease)
{
//Final rot for setting at the end. Applied rotation goes first so it appears in
//parent/world space
Quaternion finalRot = Quaternion.Euler(eulerRotation) * transform.localRotation;
// Plan is to interpolate euler angle into pieces to get small rotations,
// then apply those rotations as quaternions one at a time
Vector3 rotSoFar = Vector3.zero;
float startTime = Time.time;
while (Time.time < startTime + duration)
{
float t = (Time.time - startTime) / duration;
t = Helpers.ApplyNormalizedEasing(t, ease);
Vector3 nextRotSoFar = Vector3.Lerp(Vector3.zero, eulerRotation, t);
transform.Rotate(nextRotSoFar - rotSoFar, Space.World);
rotSoFar = nextRotSoFar;
yield return(null);
}
transform.localRotation = finalRot;
}
IEnumerator AnimateThroughPoints(float duration, EaseMode ease)
{
animationDone = false;
List <Vector3[]> finalPointsSets = new List <Vector3[]>();
foreach (LineRenderer lr in lineRenderers)
{
Vector3[] finalPoints = new Vector3[lr.positionCount];
lr.GetPositions(finalPoints); //This is, apparently, how this method works.
finalPointsSets.Add(finalPoints);
lr.positionCount = 0;
}
var init = Time.time;
float segDur = duration / lineRenderers.Count;
float timeSoFar = 0;
for (int i = 0; i < lineRenderers.Count; i++)
{
LineRenderer lr = lineRenderers[i];
while (Time.time - init < timeSoFar + segDur)
{
float t = (Time.time - init - timeSoFar) / segDur;
t = Helpers.ApplyNormalizedEasing(t, ease);
float nextPointIndex = t * finalPointsSets[i].Length;
while (lr.positionCount < nextPointIndex)
{
lr.positionCount += 1;
lr.SetPosition(lr.positionCount - 1, finalPointsSets[i][lr.positionCount - 1]);
}
yield return(new WaitForEndOfFrame());
}
timeSoFar += segDur;
lineRenderers[i].positionCount = finalPointsSets[i].Length;
lineRenderers[i].SetPositions(finalPointsSets[i]);
}
animationDone = true;
}
static public BaseTween.EasingFunction GetEaseFunction(EaseShape shape, EaseMode mode) { return GetEaseFunction(MakeEaseFunction(shape, mode)); }
static public EaseFunction MakeEaseFunction(EaseShape shape, EaseMode mode = EaseMode.InOut)
{
if (mode == EaseMode.None) { return EaseFunction.None; }
string[] shapes = Enum.GetNames(typeof (EaseShape));
return (EaseFunction) ((int) shape + shapes.Length * (int)mode);
}
public MoveActivity(Vector2 toPosition, TimeSpan duration, EaseMode easeMode, Action<object[]> onCompletion = null)
: this(-Vector2.One, toPosition, duration, easeMode, onCompletion)
{
}
public BaseTween Easing(EaseShape s, EaseMode t) { easing = Mathfl.GetEaseFunction(s,t); return (this); }
