/// <summary> /// Runs the animation. /// </summary> /// <returns>The animation.</returns> /// <param name="isHorizontal">If set to <c>true</c> is horizontal.</param> /// <param name="startPosition">Start position.</param> /// <param name="endPosition">End position.</param> /// <param name="unscaledTime">If set to <c>true</c> use unscaled time.</param> protected virtual IEnumerator RunAnimation(bool isHorizontal, float startPosition, float endPosition, bool unscaledTime) { float delta; var animation_length = Movement.keys[Movement.keys.Length - 1].time; var start_time = Utilites.GetTime(unscaledTime); do { delta = Utilites.GetTime(unscaledTime) - start_time; var value = Movement.Evaluate(delta); var position = startPosition + ((endPosition - startPosition) * value); SetPosition(position, isHorizontal); yield return(null); }while (delta < animation_length); SetPosition(endPosition, isHorizontal); ScrollRectRestore(); isAnimationRunning = false; currentAnimation = null; }
/// <summary> /// Base collapse animation. /// </summary> /// <param name="notify">Notify.</param> /// <param name="isHorizontal">Is horizontal?</param> /// <param name="speed">Animation speed in points per second.</param> /// <returns>Returns animations.</returns> public static IEnumerator AnimationCollapseBase(Notify notify, bool isHorizontal, float speed) { var rect = notify.transform as RectTransform; var layout = notify.GetComponentInParent <EasyLayout>(); var axis = isHorizontal ? RectTransform.Axis.Horizontal : RectTransform.Axis.Vertical; var base_size = isHorizontal ? rect.rect.width : rect.rect.height; var time = base_size / speed; var end_time = Utilites.GetTime(notify.unscaledTime) + time; while (Utilites.GetTime(notify.unscaledTime) <= end_time) { var t = 1f - ((end_time - Utilites.GetTime(notify.unscaledTime)) / time); var size = Mathf.Lerp(base_size, 0f, t); rect.SetSizeWithCurrentAnchors(axis, size); if (layout != null) { layout.NeedUpdateLayout(); } yield return(null); } // return height back for future use rect.SetSizeWithCurrentAnchors(axis, base_size); }
/// <summary> /// Collapse animation. /// </summary> /// <param name="notify">Notify.</param> /// <returns>Returns animations.</returns> public static IEnumerator AnimationCollapse(Notify notify) { var rect = notify.transform as RectTransform; var layout = notify.GetComponentInParent <EasyLayout>(); var max_height = rect.rect.height; var speed = 200f; var time = max_height / speed; var end_time = Utilites.GetTime(notify.unscaledTime) + time; while (Utilites.GetTime(notify.unscaledTime) <= end_time) { var t = 1 - ((end_time - Utilites.GetTime(notify.unscaledTime)) / time); var height = Mathf.Lerp(max_height, 0, t); rect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, height); if (layout != null) { layout.UpdateLayout(); } yield return(null); } // return height back for future use rect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, max_height); }
IEnumerator AnimationConstantTime(int targetValue) { if (targetValue > Max) { targetValue = Max; } var start = Value; var delta = targetValue - start; if (delta != 0) { var total_time = Speed; var start_time = Utilites.GetTime(UnscaledTime); var end_time = start_time + total_time; do { var progress = Mathf.Min(1, (Utilites.GetTime(UnscaledTime) - start_time) / total_time); progressValue = start + Mathf.RoundToInt(progress * delta); UpdateProgressbar(); yield return(null); }while (end_time > Utilites.GetTime(UnscaledTime)); progressValue = targetValue; UpdateProgressbar(); } IsAnimationRunning = false; }
/// <summary> /// Scroll on click. /// </summary> /// <param name="type">Type.</param> public void ScrollOnClick(ScrollButtonType type) { if (!Interactable) { return; } AnimationStop(); if ((AnimationStartTime + AnimationLength) < Utilites.GetTime(UnscaledTime)) { return; } ScrollRect.StopMovement(); var start = ScrollRect.content.localPosition; var end = ScrollOnClick(type, start, ScrollRect.scrollSensitivity * ScrollSensitivityRateOnClick); if (Animate) { CurrentCoroutine = AnimationClick(start, end); StartCoroutine(CurrentCoroutine); } else { ScrollRect.content.localPosition = end; ForceUpdateBounds(); } }
/// <summary> /// Handle scroll changes. /// </summary> protected virtual void ScrollChanged() { if (!gameObject.activeInHierarchy) { return; } var distance = Mathf.Abs(IsHorizontal() ? DragDelta.x : DragDelta.y); var time = Utilites.GetTime(UnscaledTime) - DragStarted; var is_fast = (distance >= FastDragDistance) && (time <= FastDragTime); if (!is_fast) { var pos = IsHorizontal() ? -ScrollRect.content.anchoredPosition.x : ScrollRect.content.anchoredPosition.y; var page = Mathf.RoundToInt(pos / GetPageSize()); GoToPage(page, true); DragDelta = Vector2.zero; DragStarted = 0f; } else { var direction = IsHorizontal() ? DragDelta.x : -DragDelta.y; DragDelta = Vector2.zero; if (direction == 0f) { return; } var page = direction < 0 ? CurrentPage + 1 : CurrentPage - 1; GoToPage(page, false); } }
/// <summary> /// Base slide animation. /// </summary> /// <param name="notify">Notify.</param> /// <param name="isHorizontal">Is horizontal slide?</param> /// <param name="direction">Slide direction.</param> /// <param name="speed">Speed.</param> /// <param name="animateOthers">Animate other notifications.</param> /// <returns>Animation.</returns> public static IEnumerator AnimationSlideBase(Notify notify, bool isHorizontal, float direction, float speed, bool animateOthers = true) { var replacement = GetReplacement(notify); var layout_element = Utilites.GetOrAddComponent <LayoutElement>(notify); layout_element.ignoreLayout = true; var layout = notify.GetComponentInParent <EasyLayout>(); var rect = notify.transform as RectTransform; var base_size = isHorizontal ? rect.rect.width : rect.rect.height; var base_pos = rect.anchoredPosition; var time = base_size / speed; var end_time = Utilites.GetTime(notify.unscaledTime) + time; var axis = isHorizontal ? RectTransform.Axis.Horizontal : RectTransform.Axis.Vertical; while (Utilites.GetTime(notify.unscaledTime) <= end_time) { if (!animateOthers) { base_pos = replacement.anchoredPosition; } var t = 1 - ((end_time - Utilites.GetTime(notify.unscaledTime)) / time); var size = Mathf.Lerp(0, base_size, t); rect.anchoredPosition = isHorizontal ? new Vector2(base_pos.x + (size * direction), base_pos.y) : new Vector2(base_pos.x, base_pos.y + (size * direction)); if (animateOthers) { replacement.SetSizeWithCurrentAnchors(axis, base_size - size); if (layout != null) { layout.NeedUpdateLayout(); } } yield return(null); } layout_element.ignoreLayout = false; Replacements.Push(replacement); replacement.gameObject.SetActive(false); replacement.SetSizeWithCurrentAnchors(axis, base_size); if (layout != null) { layout.NeedUpdateLayout(); } }
/// <summary> /// Scroll on hold. /// </summary> /// <param name="type">Type.</param> public void ScrolOnHold(ScrollButtonType type) { if (!Interactable) { return; } AnimationStop(); AnimationStartTime = Utilites.GetTime(UnscaledTime); StartPosition = ScrollRect.content.localPosition; ScrollRect.StopMovement(); CurrentCoroutine = AnimationHold(type); StartCoroutine(CurrentCoroutine); }
/// <summary> /// Open animation. /// </summary> /// <returns>Animation.</returns> /// <param name="rectTransform">RectTransform.</param> /// <param name="time">Time.</param> /// <param name="isHorizontal">Is Horizontal animated width changes; otherwise height.</param> /// <param name="unscaledTime">Use unscaled time.</param> /// <param name="actionAfter">Action to run after animation.</param> public static IEnumerator OpenFlexible(RectTransform rectTransform, float time = 0.5f, bool isHorizontal = false, bool unscaledTime = false, Action actionAfter = null) { var layoutElement = Utilites.GetOrAddComponent <LayoutElement>(rectTransform); if (isHorizontal) { layoutElement.preferredWidth = -1f; } else { layoutElement.preferredHeight = -1f; } var end_time = Utilites.GetTime(unscaledTime) + time; while (Utilites.GetTime(unscaledTime) <= end_time) { var t = 1 - ((end_time - Utilites.GetTime(unscaledTime)) / time); var size = Mathf.Lerp(0f, 1f, t); if (isHorizontal) { layoutElement.flexibleWidth = size; } else { layoutElement.flexibleHeight = size; } yield return(null); } // return size back for future use if (isHorizontal) { layoutElement.flexibleWidth = 1f; } else { layoutElement.flexibleHeight = 1f; } if (actionAfter != null) { actionAfter(); } }
/// <summary> /// Animation on click. /// </summary> /// <returns>Nothing.</returns> /// <param name="start">Start scroll position.</param> /// <param name="end">End scroll position.</param> protected virtual IEnumerator AnimationClick(Vector3 start, Vector3 end) { var animation_position = 0f; do { animation_position = Utilites.GetTime(UnscaledTime) - AnimationStartTime; var pos = Vector3.Lerp(start, end, Curve.Evaluate(animation_position)); ScrollRect.content.localPosition = pos; ForceUpdateBounds(); yield return(null); }while (animation_position < AnimationLength); ScrollRect.content.localPosition = end; ForceUpdateBounds(); }
IEnumerator IndeterminateAnimation() { while (true) { var r = Bar.uvRect; if (Direction == ProgressbarDirection.Horizontal) { r.x = (Utilites.GetTime(UnscaledTime) * (-Speed)) % 1; } else { r.y = (Utilites.GetTime(UnscaledTime) * (-Speed)) % 1; } Bar.uvRect = r; yield return(null); } }
/// <summary> /// Happens when ScrollRect OnDragStart event occurs. /// </summary> /// <param name="eventData">Event data.</param> protected virtual void OnScrollRectDragStart(PointerEventData eventData) { if (!IsValidDrag(eventData)) { return; } DragDelta = Vector2.zero; isDragging = true; CursorStartPosition = Vector2.zero; RectTransformUtility.ScreenPointToLocalPointInRectangle(ScrollRect.transform as RectTransform, eventData.position, eventData.pressEventCamera, out CursorStartPosition); DragStarted = Utilites.GetTime(UnscaledTime); StopAnimation(); }
/// <summary> /// Collapse animation. /// </summary> /// <returns>Animation.</returns> /// <param name="rectTransform">RectTransform.</param> /// <param name="time">Time.</param> /// <param name="isHorizontal">Is Horizontal animated width changes; otherwise height.</param> /// <param name="unscaledTime">Use unscaled time.</param> /// <param name="actionAfter">Action to run after animation.</param> public static IEnumerator Collapse(RectTransform rectTransform, float time = 0.5f, bool isHorizontal = false, bool unscaledTime = false, Action actionAfter = null) { var layoutElement = Utilites.GetOrAddComponent <LayoutElement>(rectTransform); var size = isHorizontal ? (LayoutUtilites.IsWidthControlled(rectTransform) ? LayoutUtility.GetPreferredWidth(rectTransform) : rectTransform.rect.width) : (LayoutUtilites.IsHeightControlled(rectTransform) ? LayoutUtility.GetPreferredHeight(rectTransform) : rectTransform.rect.height); var end_time = Utilites.GetTime(unscaledTime) + time; while (Utilites.GetTime(unscaledTime) <= end_time) { var t = 1 - ((end_time - Utilites.GetTime(unscaledTime)) / time); var new_size = Mathf.Lerp(size, 0, t); if (isHorizontal) { rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, new_size); layoutElement.preferredWidth = new_size; } else { rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, new_size); layoutElement.preferredHeight = new_size; } yield return(null); } // return size back for future use if (isHorizontal) { rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, size); layoutElement.preferredWidth = size; } else { rectTransform.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, size); layoutElement.preferredHeight = size; } if (actionAfter != null) { actionAfter(); } }
/// <summary> /// Rotate animation. /// </summary> /// <param name="notify">Notify.</param> /// <returns>Returns animations.</returns> public static IEnumerator AnimationRotate(Notify notify) { var rect = notify.transform as RectTransform; var start_rotarion = rect.localRotation.eulerAngles; var length = 0.5f; var end_time = Utilites.GetTime(notify.unscaledTime) + length; while (Utilites.GetTime(notify.unscaledTime) <= end_time) { var t = 1 - ((end_time - Utilites.GetTime(notify.unscaledTime)) / length); var rotation_x = Mathf.Lerp(0, 90, t); rect.localRotation = Quaternion.Euler(rotation_x, start_rotarion.y, start_rotarion.z); yield return(null); } // return rotation back for future use rect.localRotation = Quaternion.Euler(start_rotarion); }
/// <summary> /// Animates the switch. /// </summary> /// <returns>The switch.</returns> /// <param name="state">IsOn.</param> /// <param name="time">Time.</param> protected virtual IEnumerator AnimateSwitch(bool state, float time) { SetMarkPosition(GetPosition(!IsOn)); var prev_position = GetPosition(!IsOn); var next_position = GetPosition(IsOn); var end_time = Utilites.GetTime(UnscaledTime) + time; while (Utilites.GetTime(UnscaledTime) <= end_time) { var distance = 1 - ((end_time - Utilites.GetTime(UnscaledTime)) / time); var pos = Mathf.Lerp(prev_position, next_position, distance); SetMarkPosition(pos); yield return(null); } SetMarkPosition(GetPosition(IsOn)); }
/// <summary> /// Collapse animation. /// </summary> /// <returns>Animation coroutine.</returns> protected virtual IEnumerator AnimationCollapse() { var max_height = rect.rect.height; var speed = 200f; // pixels per second var time = max_height / speed; var end_time = Utilites.GetTime(UnscaledTime) + time; while (Utilites.GetTime(UnscaledTime) <= end_time) { var t = 1 - ((end_time - Utilites.GetTime(UnscaledTime)) / time); var height = Mathf.Lerp(max_height, 0, t); rect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, height); yield return(null); } // return height back for future use rect.SetSizeWithCurrentAnchors(RectTransform.Axis.Vertical, max_height); }
/// <summary> /// Base rotate animation. /// </summary> /// <param name="notify">Notify.</param> /// <param name="isHorizontal">Is horizontal></param> /// <param name="timeLength">Animation length in seconds.</param> /// <returns>Returns animations.</returns> public static IEnumerator AnimationRotateBase(Notify notify, bool isHorizontal, float timeLength) { var rect = notify.transform as RectTransform; var base_rotation = rect.localRotation.eulerAngles; var end_time = Utilites.GetTime(notify.unscaledTime) + timeLength; while (Utilites.GetTime(notify.unscaledTime) <= end_time) { var t = 1f - ((end_time - Utilites.GetTime(notify.unscaledTime)) / timeLength); var rotation = Mathf.Lerp(0f, 90f, t); rect.localRotation = isHorizontal ? Quaternion.Euler(base_rotation.x, rotation, base_rotation.z) : Quaternion.Euler(rotation, base_rotation.y, base_rotation.z); yield return(null); } // return rotation back for future use rect.localRotation = Quaternion.Euler(base_rotation); }
/// <summary> /// Rotate animation. /// </summary> /// <returns>Animation.</returns> /// <param name="rectTransform">RectTransform.</param> /// <param name="time">Time.</param> /// <param name="startAngle">Start rotation angle.</param> /// <param name="endAngle">End rotation angle.</param> /// <param name="unscaledTime">Use unscaled time.</param> /// <param name="actionAfter">Action to run after animation.</param> public static IEnumerator RotateZ(RectTransform rectTransform, float time = 0.5f, float startAngle = 0, float endAngle = 90, bool unscaledTime = false, Action actionAfter = null) { var start_rotarion = rectTransform.localRotation.eulerAngles; var end_time = Utilites.GetTime(unscaledTime) + time; while (Utilites.GetTime(unscaledTime) <= end_time) { var t = 1 - ((end_time - Utilites.GetTime(unscaledTime)) / time); var rotation_z = Mathf.Lerp(startAngle, endAngle, t); rectTransform.localRotation = Quaternion.Euler(start_rotarion.x, start_rotarion.y, rotation_z); yield return(null); } // return rotation back for future use rectTransform.localRotation = Quaternion.Euler(start_rotarion); if (actionAfter != null) { actionAfter(); } }
/// <summary> /// Animation coroutine. /// </summary> /// <returns>Coroutine.</returns> protected IEnumerator AnimationCoroutine() { var start_pos = DragRect.localPosition; var end_pos = RestrictPosition(DragRect.localPosition); if (start_pos != end_pos) { var animation_length = Draggable.Curve.keys[Draggable.Curve.keys.Length - 1].time; var startTime = Utilites.GetTime(Draggable.UnscaledTime); var animation_position = 0f; do { animation_position = Utilites.GetTime(Draggable.UnscaledTime) - startTime; var value = Draggable.Curve.Evaluate(animation_position); DragRect.localPosition = Vector3.Lerp(start_pos, end_pos, value); yield return(null); }while (animation_position < animation_length); DragRect.localPosition = end_pos; } }
/// <summary> /// Runs the animation. /// </summary> /// <returns>The animation.</returns> /// <param name="isHorizontal">If set to <c>true</c> is horizontal.</param> /// <param name="startPosition">Start position.</param> /// <param name="endPosition">End position.</param> /// <param name="unscaledTime">If set to <c>true</c> use unscaled time.</param> protected virtual IEnumerator RunAnimation(bool isHorizontal, float startPosition, float endPosition, bool unscaledTime) { float delta; var animation_length = Movement.keys[Movement.keys.Length - 1].time; var start_time = Utilites.GetTime(unscaledTime); do { delta = Utilites.GetTime(unscaledTime) - start_time; var value = Movement.Evaluate(delta); var position = startPosition + ((endPosition - startPosition) * value); if (isHorizontal) { RectTransform.anchoredPosition = new Vector2(position, RectTransform.anchoredPosition.y); } else { RectTransform.anchoredPosition = new Vector2(RectTransform.anchoredPosition.x, position); } yield return(null); }while (delta < animation_length); if (isHorizontal) { RectTransform.anchoredPosition = new Vector2(endPosition, RectTransform.anchoredPosition.y); } else { RectTransform.anchoredPosition = new Vector2(RectTransform.anchoredPosition.x, endPosition); } IsAnimationRunning = false; }
protected float GetTime() { return(Utilites.GetTime(UnscaledTime)); }
protected float GetTime() { return(Utilites.GetTime(Draggable.UnscaledTime)); }