/// <summary>
/// Color Enumerator Function
/// </summary>
/// <param name="forward">True if it's an open animation, False if its a Close Animation</param>
/// <returns>The IEnumerator</returns>
public IEnumerator ColorFunc(bool forward)
{
if (!ColorData.Enable)
{
yield break;
}
_ColorState = VCAnimationState.AnimStarted;
VCColorComponentType ComponentType = VCColorComponentType.None;
if (GetComponent<SpriteRenderer>())
{
ComponentType = VCColorComponentType.SpriteRenderer;
}
else if (GetComponent<Renderer>())
{
ComponentType = VCColorComponentType.Renderer;
}
else if (GetComponent<Image>())
{
ComponentType = VCColorComponentType.Image;
}
else if (GetComponent<Text>())
{
ComponentType = VCColorComponentType.Text;
}
else
{
yield break;
}
while (true)
{
if (forward)
{
onColorOpenStart.Invoke();
}
else
{
onColorCloseStart.Invoke();
}
float time = 0;
bool bDelayed = false;
float Duration = forward ? ColorData.OpenAnimation.Duration : ColorData.CloseAnimation.Duration;
float Delay = forward ? ColorData.OpenAnimation.Delay : ColorData.CloseAnimation.Delay;
Color Start = forward ? ColorData.OpenAnimation.Start : ColorData.CloseAnimation.Start;
Color End = forward ? ColorData.OpenAnimation.End : ColorData.CloseAnimation.End;
if (!bDelayed && Delay > 0)
{
bDelayed = true;
yield return StartCoroutine(WaitForRealSeconds(Delay));
}
while (true)
{
time += GetDeltaTime();
Color CurrentColor = GetAnimationValueColor(ColorData, time, forward);
switch (ComponentType)
{
case VCColorComponentType.SpriteRenderer:
GetComponent<SpriteRenderer>().color = CurrentColor;
break;
case VCColorComponentType.Renderer:
GetComponent<Renderer>().material.color = CurrentColor;
break;
case VCColorComponentType.Image:
GetComponent<Image>().color = CurrentColor;
break;
case VCColorComponentType.Text:
GetComponent<Text>().color = CurrentColor;
break;
default:
break;
}
if (time < Duration)
{
yield return StartCoroutine(WaitForRealSeconds(.016f));
}
else
{
CurrentColor = Color.Lerp(Start, End, 1); ;
switch (ComponentType)
{
case VCColorComponentType.SpriteRenderer:
GetComponent<SpriteRenderer>().color = CurrentColor;
break;
case VCColorComponentType.Renderer:
GetComponent<Renderer>().material.color = CurrentColor;
break;
case VCColorComponentType.Image:
GetComponent<Image>().color = CurrentColor;
break;
case VCColorComponentType.Text:
GetComponent<Text>().color = CurrentColor;
break;
default:
break;
}
break;
}
}
if (forward)
{
onColorOpenEnd.Invoke();
}
else
{
onColorCloseEnd.Invoke();
}
if (forward)
{
if (ColorData.Autoclose)
{
forward = false;
yield return StartCoroutine(WaitForRealSeconds(ColorData.AutocloseDelay));
}
else
{
if (!ColorData.Loop)
{
break;
}
}
}
else
{
if (!ColorData.Loop)
{
break;
}
forward = true;
}
}
_ColorState = VCAnimationState.AnimFinished;
OnAnimationFinished();
}
/// <summary>
/// Alpha Enumerator Function
/// </summary>
/// <param name="forward">True if it's an open animation, False if its a Close Animation</param>
/// <returns>The IEnumerator</returns>
public IEnumerator AlphaFunc(bool forward)
{
if (!Alpha.Enable || !canvasGroup)
{
yield break;
}
_AlphaState = VCAnimationState.AnimStarted;
while (true)
{
if (forward)
{
onAlphaOpenStart.Invoke();
}
else
{
onAlphaCloseStart.Invoke();
}
float time = 0;
bool bDelayed = false;
float Duration = forward ? Alpha.OpenAnimation.Duration : Alpha.CloseAnimation.Duration;
float Delay = forward ? Alpha.OpenAnimation.Delay : Alpha.CloseAnimation.Delay;
float Start = forward ? Alpha.OpenAnimation.Start : Alpha.CloseAnimation.Start;
float End = forward ? Alpha.OpenAnimation.End : Alpha.CloseAnimation.End;
if (!bDelayed && Delay > 0)
{
bDelayed = true;
yield return StartCoroutine(WaitForRealSeconds(Delay));
}
while (true)
{
time += GetDeltaTime();
canvasGroup.alpha = Lerp(Start, End, (float)time / Duration);
if (time < Duration)
{
yield return StartCoroutine(WaitForRealSeconds(.016f));
}
else
{
canvasGroup.alpha = Lerp(Start, End, 1);
break;
}
}
if (forward)
{
onAlphaOpenEnd.Invoke();
}
else
{
onAlphaCloseEnd.Invoke();
}
if (forward)
{
if (Alpha.Autoclose)
{
forward = false;
yield return StartCoroutine(WaitForRealSeconds(Alpha.AutocloseDelay));
}
else
{
if (!Alpha.Loop)
{
break;
}
}
}
else
{
if (!Alpha.Loop)
{
break;
}
forward = true;
}
}
_AlphaState = VCAnimationState.AnimFinished;
OnAnimationFinished();
}
/// <summary>
/// Stops All the Open Animations
/// </summary>
public void StopAnimation()
{
StopMovementAnimation();
StopScaleAnimation();
StopRotationAnimation();
StopAlphaAnimation();
StopColorAnimation();
_MovementState = VCAnimationState.AnimFinished;
_ScaleState = VCAnimationState.AnimFinished;
_RotationState = VCAnimationState.AnimFinished;
_AlphaState = VCAnimationState.AnimFinished;
_ColorState = VCAnimationState.AnimFinished;
if (CurrentAnimDirection == VCAnimationDirection.Forward)
{
onOpenEnd.Invoke();
}
else
{
onCloseEnd.Invoke();
}
}
/// <summary>
/// Scale Enumerator Function
/// </summary>
/// <param name="forward">True if it's an open animation, False if its a Close Animation</param>
/// <returns>The IEnumerator</returns>
public IEnumerator ScaleFunc(bool forward)
{
if (!Scale.Enable)
{
yield break;
}
_ScaleState = VCAnimationState.AnimStarted;
while (true)
{
if (forward)
{
onScaleOpenStart.Invoke();
}
else
{
onScaleCloseStart.Invoke();
}
float time = 0;
bool bDelayed = false;
float Duration = forward ? Scale.OpenAnimation.Duration : Scale.CloseAnimation.Duration;
float Delay = forward ? Scale.OpenAnimation.Delay : Scale.CloseAnimation.Delay;
if (!bDelayed && Delay > 0)
{
bDelayed = true;
yield return StartCoroutine(WaitForRealSeconds(Delay));
}
Vector3 Start = forward ? Scale.OpenAnimation.Start : Scale.CloseAnimation.Start;
Vector3 End = forward ? Scale.OpenAnimation.End : Scale.CloseAnimation.End;
while (true)
{
time += GetDeltaTime();
if (Start != Vector3.zero && End != Vector3.zero)
{
transform.localScale = GetAnimationValue(ScaleFunctions, Scale, time, forward);
if (time < Duration)
{
yield return StartCoroutine(WaitForRealSeconds(.016f));
}
else
{
transform.localScale = GetAnimationValue(ScaleFunctions, Scale, Duration, forward);
break;
}
}
else
{
break;
}
}
if (forward)
{
onScaleOpenEnd.Invoke();
}
else
{
onScaleCloseEnd.Invoke();
}
if (forward)
{
if (Scale.Autoclose)
{
forward = false;
yield return StartCoroutine(WaitForRealSeconds(Scale.AutocloseDelay));
}
else
{
if (!Scale.Loop)
{
break;
}
}
}
else
{
if (!Scale.Loop)
{
break;
}
forward = true;
}
}
_ScaleState = VCAnimationState.AnimFinished;
OnAnimationFinished();
}
/// <summary>
/// Rotation Enumerator Function
/// </summary>
/// <param name="forward">True if it's an open animation, False if its a Close Animation</param>
/// <returns>The IEnumerator</returns>
public IEnumerator RotationFunc(bool forward)
{
if (!Rotation.Enable)
{
yield break;
}
_RotationState = VCAnimationState.AnimStarted;
while (true)
{
if (forward)
{
onRotationOpenStart.Invoke();
}
else
{
onRotationCloseStart.Invoke();
}
float time = 0;
bool bDelayed = false;
float Duration = forward ? Rotation.OpenAnimation.Duration : Rotation.CloseAnimation.Duration;
float Delay = forward ? Rotation.OpenAnimation.Delay : Rotation.CloseAnimation.Delay;
if (!bDelayed && Delay > 0)
{
bDelayed = true;
yield return StartCoroutine(WaitForRealSeconds(Delay));
}
while (true)
{
time += GetDeltaTime();
transform.eulerAngles = GetAnimationValue(RotationFunctions, Rotation, time, forward);
if (time < Duration)
{
yield return StartCoroutine(WaitForRealSeconds(.016f));
}
else
{
transform.eulerAngles = GetAnimationValue(RotationFunctions, Rotation, Duration, forward);
break;
}
}
if (forward)
{
onRotationOpenEnd.Invoke();
}
else
{
onRotationCloseEnd.Invoke();
}
if (forward)
{
if (Rotation.Autoclose)
{
forward = false;
yield return StartCoroutine(WaitForRealSeconds(Rotation.AutocloseDelay));
}
else
{
if (!Rotation.Loop)
{
break;
}
}
}
else
{
if (!Rotation.Loop)
{
break;
}
forward = true;
}
}
_RotationState = VCAnimationState.AnimFinished;
OnAnimationFinished();
}
////////////////////////////////////////////////////
/// <summary>
/// Movement Enumerator Function
/// </summary>
/// <param name="forward">True if it's an open animation, False if its a Close Animation</param>
/// <returns>The IEnumerator</returns>
public IEnumerator MoveFunc(bool forward)
{
if (!Movement.Enable)
{
yield break;
}
_MovementState = VCAnimationState.AnimStarted;
while (true)
{
if (forward)
{
onMovementOpenStart.Invoke();
}
else
{
onMovementCloseStart.Invoke();
}
float time = 0;
bool bDelayed = false;
float Duration = forward ? Movement.OpenAnimation.Duration : Movement.CloseAnimation.Duration;
float Delay = forward ? Movement.OpenAnimation.Delay : Movement.CloseAnimation.Delay;
if (!bDelayed && Delay > 0)
{
bDelayed = true;
yield return StartCoroutine(WaitForRealSeconds(Delay));
}
RectTransform rectTransform = transform as RectTransform;
while (true)
{
time += GetDeltaTime();
if (rectTransform)
{
rectTransform.anchoredPosition = GetAnimationValue(MovementFunctions, Movement, time, forward);
}
else
{
transform.position = GetAnimationValue(MovementFunctions, Movement, time, forward);
}
if (time < Duration)
{
yield return StartCoroutine(WaitForRealSeconds(.016f));
}
else
{
if (rectTransform)
{
rectTransform.anchoredPosition = GetAnimationValue(MovementFunctions, Movement, Duration, forward);
}
else
{
transform.position = GetAnimationValue(MovementFunctions, Movement, Duration, forward);
}
break;
}
}
if (forward)
{
onMovementOpenEnd.Invoke();
}
else
{
onMovementCloseEnd.Invoke();
}
if (forward)
{
if (Movement.Autoclose)
{
forward = false;
yield return StartCoroutine(WaitForRealSeconds(Movement.AutocloseDelay));
}
else
{
if (!Movement.Loop)
{
break;
}
}
}
else
{
if (!Movement.Loop)
{
break;
}
forward = true;
}
}
_MovementState = VCAnimationState.AnimFinished;
OnAnimationFinished();
}