void ScaleOnCurve()
{
float curveDur = this.scalingCurve.keys[this.scalingCurve.length - 1].time;
IEnumerator scale = StratusRoutines.Scale(transform, this.scalingCurve, curveDur);
this.transform.StartCoroutine(scale, TransformationType.Scale);
}
public static IEnumerator ComposeCrossFade(this CanvasGroup canvasGroup,
float alpha,
bool interactable,
bool blocksRaycasts,
float duration,
Action onFinished = null)
{
float initialAlpha = canvasGroup.alpha;
if (duration > 0.0f)
{
yield return(StratusRoutines.Lerp((t) =>
{
canvasGroup.alpha = initialAlpha.LerpTo(alpha, t);
}, duration));
}
else
{
canvasGroup.alpha = alpha;
}
canvasGroup.blocksRaycasts = blocksRaycasts;
canvasGroup.interactable = interactable;
onFinished?.Invoke();
}
protected override void OnTrigger()
{
IEnumerator routine = null;
switch (type)
{
case Type.Color:
routine = StratusRoutines.Lerp(material.color, color, duration, (Color val) => { material.color = val; }, Color.Lerp);
break;
case Type.SetFloat:
routine = StratusRoutines.Lerp(material.GetFloat(propertyName), floatValue, duration, (float val) => { material.SetFloat(propertyName, val); }, StratusRoutines.Lerp);
break;
case Type.SetInteger:
routine = StratusRoutines.Lerp(material.GetInt(propertyName), integerValue, duration, (float val) => { material.SetInt(propertyName, Mathf.CeilToInt(val)); }, StratusRoutines.Lerp);
break;
case Type.SetTexture:
routine = StratusRoutines.Call(() => { material.SetTexture(propertyName, texture); }, duration);
break;
case Type.Lerp:
routine = StratusRoutines.Lerp((float t) => { material.Lerp(material, material2, t); }, duration);
break;
default:
break;
}
this.StartCoroutine(routine, "Interpolate");
}
/// <summary>
/// Fades out this telegraph. It will destroy it shortly after its been completely faded out.
/// </summary>
/// <param name="fadeSpeed"></param>
public void End(float fadeSpeed, float destroySpeed = 0.0f)
{
//Trace.Script("Hiding telegraph over " + duration + " seconds!", this);
StartCoroutine(StratusRoutines.Fade(this.gameObject, 0f, fadeSpeed));
if (destroySpeed > 0.0f)
{
GameObject.Destroy(this.gameObject, destroySpeed);
}
}
public void FadeColor(Color color, float duration, bool ignoreTimeScale)
{
if (debug)
{
StratusDebug.Log("Fading to " + color, this);
}
previousColor = currentColor;
currentColor = color;
//image.CrossFadeColor(color, duration, ignoreTimeScale, useAlpha);
this.StartCoroutine(StratusRoutines.Lerp(image.color, color, duration, (Color val) => { image.color = val; }, Color.Lerp), "Fade Color");
}
//--------------------------------------------------------------------------------------------/
// Methods
//--------------------------------------------------------------------------------------------/
public void Fade(float alpha, float duration, bool ignoreTimeScale)
{
if (debug)
{
StratusDebug.Log("Fading to " + alpha, this);
}
previousAlpha = currentAlpha;
currentAlpha = alpha;
//image.CrossFadeAlpha(alpha, duration, ignoreTimeScale);
this.StartCoroutine(StratusRoutines.Lerp(image.color.a, alpha, duration, (float val) => { image.color = image.color.ScaleAlpha(val); }, StratusRoutines.Lerp), "Fade");
}
public void StartScrolling()
{
scrollRect.verticalNormalizedPosition = initialValue;
var routine = StratusRoutines.Interpolate(initialValue, finalValue, scrollDuration,
(value) =>
{
scrollRect.verticalNormalizedPosition = value;
});
scrollingRoutine = StartCoroutine(routine);
this.Log($"Now scrolling over {scrollDuration} seconds...");
}
//------------------------------------------------------------------------/
// Routines
//------------------------------------------------------------------------/
/// <summary>
/// Fades in this telegraph.
/// </summary>
/// <param name="duration"></param>
public void Start(float duration)
{
//Trace.Script("Displaying telegraph over " + duration + " seconds!", this);
StartCoroutine(StratusRoutines.Fade(this.gameObject, 1f, duration));
}
void Scale()
{
IEnumerator scale = StratusRoutines.Scale(transform, this.scalar, this.duration);
this.transform.StartCoroutine(scale, TransformationType.Scale);
}
void RotateAroundWhile()
{
IEnumerator rotateAround = StratusRoutines.RotateAround(transform, target.position, axis, angleAroundTarget);
this.transform.StartCoroutine(rotateAround, TransformationType.Translate | TransformationType.Rotate);
}
void LookAt()
{
IEnumerator lookAt = StratusRoutines.LookAt(transform, target, duration);
this.transform.StartCoroutine(lookAt, TransformationType.Rotate);
}
void Follow()
{
IEnumerator follow = StratusRoutines.Follow(transform, target, moveSpeed, distance, maintainDistance);
this.transform.StartCoroutine(follow, TransformationType.Translate);
}
void MoveTo()
{
IEnumerator move = StratusRoutines.MoveTo(transform, target.position, duration);
this.transform.StartCoroutine(move, TransformationType.Translate);
}
void ScaleSequence()
{
var scaling = StratusRoutines.Scale(transform, new float[] { 0.5f, 4f, 1f }, duration, repeat);
this.StartCoroutine(scaling, "Scale");
}
void Track()
{
IEnumerator track = StratusRoutines.Track(transform, target, damping);
this.transform.StartCoroutine(track, TransformationType.Rotate);
}
//--------------------------------------------------------------------------------------------/
// Methods
//--------------------------------------------------------------------------------------------/
/// <summary>
/// Interpolates to the specified transformation.
/// </summary>
public void Apply(Vector3 value)
{
currentAction = StratusActions.Sequence(this);
if (debug)
{
StratusDebug.Log($"The {eventType} operation was applied on {target.name}", this);
}
switch (eventType)
{
case EventType.Translate:
transformationType = TransformationType.Translate;
if (valueType == ValueType.Static)
{
if (local)
{
previousValue = target.localPosition;
currentCoroutine = StratusRoutines.Interpolate(previousValue, currentValue, duration, (Vector3 val) => { target.localPosition = val; }, ease);
//Actions.Property(currentAction, () => target.localPosition, currentValue, this.duration, this.ease);
}
else
{
previousValue = target.position;
currentCoroutine = StratusRoutines.Interpolate(previousValue, currentValue, duration, (Vector3 val) => { target.position = val; }, ease);
//Actions.Property(currentAction, () => target.position, currentValue, this.duration, this.ease);
}
}
else if (valueType == ValueType.Mirror)
{
previousValue = target.position;
currentCoroutine = StratusRoutines.Interpolate(previousValue, source.position, duration, (Vector3 val) => { target.position = val; }, ease);
//Actions.Property(currentAction, () => target.position, source.position, this.duration, this.ease);
}
target.StartCoroutine(currentCoroutine, transformationType);
break;
case EventType.Rotate:
transformationType = TransformationType.Rotate;
previousValue = target.rotation.eulerAngles;
currentCoroutine = StratusRoutines.Rotate(target, isMirror ? source.rotation.eulerAngles : currentValue, duration);
target.StartCoroutine(currentCoroutine, transformationType);
//Actions.Property(currentAction, () => target.rotation.eulerAngles, isMirror ? source.localRotation.eulerAngles : currentValue, this.duration, this.ease);
break;
case EventType.RotateAround:
transformationType = TransformationType.Translate | TransformationType.Rotate;
previousValue = target.rotation.eulerAngles;
currentCoroutine = StratusRoutines.RotateAround(target, isMirror ? source.position : currentValue, axis, angleAroundTarget, duration);
target.StartCoroutine(currentCoroutine, transformationType);
break;
case EventType.Scale:
previousValue = target.localScale;
transformationType = TransformationType.Scale;
currentCoroutine = StratusRoutines.Interpolate(previousValue, isMirror ? source.localScale : currentValue, duration, (Vector3 val) => { target.localScale = val; }, ease);;
//Routines.Scale(target, isMirror ? source.localScale : currentValue, this.duration);
target.StartCoroutine(currentCoroutine, transformationType);
//Actions.Property(currentAction, () => target.localScale, isMirror ? source.localScale : currentValue, this.duration, this.ease);
break;
case EventType.Parent:
StratusActions.Delay(currentAction, duration);
StratusActions.Call(currentAction, () => { target.SetParent(source); });
break;
case EventType.Reset:
StratusActions.Delay(currentAction, duration);
StratusActions.Call(currentAction, () => { target.Reset(); });
break;
}
}
public void UpdateProgress(float value, float duration, Action onFinished)
{
IEnumerator routine = StratusRoutines.Lerp(progress, value, duration, SetProgress, StratusRoutines.Lerp, onFinished);
progressRoutine = StartCoroutine(routine);
}
