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); }