SimpleAnimation.cs

Go to the documentation of this file.

using System;
using UnityEngine.Events;
 
namespace UnityEngine
{
    [Serializable] 
    public abstract class SimpleAnimation : ISimpleAnimation
    {
        [Tooltip("The name of the animation")]
        [SerializeField] public string name;
        public float timeStamp { get => _timeStamp; protected set => _timeStamp = value; }
        [HideInInspector] private float _timeStamp;
        public float progress
        {
            get {
                if (!mirror)
                    return timeStamp/ duration;
                return 1 - (timeStamp/ duration);
            }
            set => SetProgress(value);
        }
        [Tooltip("Determines how the animation behaves once finished. Should be executed only once? Start over? Go back?")]
        [SerializeField] public WrapMode wrapMode;
        [Tooltip("Should the animation be played from end to start instead of from start to end?")]
        [SerializeField] public bool mirror;
        [Tooltip("How much should the animation last?")]
        [SerializeField] public float duration;
        [Tooltip("The curve of the animation over time. The bottom is the start state and the top is end state.")]
        [SerializeField] public AnimationCurve curve;
        public float currentAnimationCurveValue => curve.Evaluate(timeStamp / duration);
        [Tooltip("Events executed every time the animation advances")]
        [SerializeField] public UnityEvent onStep;
        [Tooltip("Events executed when the animation finishes")]
        [SerializeField] public UnityEvent onFinish;
 
        
        public enum WrapMode
        {
            Once,
            Loop,
            PingPong
        }
        
        public virtual bool Step(float deltaTime, bool inverseIfMirror = true)
        {
            if (!mirror || !inverseIfMirror)
                timeStamp += deltaTime;
            else if (mirror)
                timeStamp -= deltaTime;
            else
                Debug.LogError("Unexpected Step call for a SimpleAnimation.");
 
            onStep?.Invoke();
            
            if ( ((timeStamp >= duration) && !mirror) || ((timeStamp <= 0) && mirror) )
            {
                if (!mirror)
                    timeStamp = duration;
                else
                    timeStamp = 0;
                
                onFinish?.Invoke();
 
                switch (wrapMode)
                {
 
                    case WrapMode.Once:
                        break;
                    case WrapMode.Loop:
                        SetProgress(0f);
                        break;
                    case WrapMode.PingPong:
                        mirror = !mirror;
                        break;
                    default:
                        throw new ArgumentOutOfRangeException();
                }
                
                return ((timeStamp >= duration) && !mirror) || ((timeStamp <= 0) && mirror); // Double evaluation to avoid bugs with modifications on the event invoked.
            }
 
            return false;
        }
 
        public void Reset()
        {
            timeStamp = !mirror? 0f : duration;
        }
 
 
        public override string ToString()
        {
            return "Current time: " + timeStamp + "/" + duration + ". Mirror: " + mirror;
        }
 
 
        public static AnimationCurve GetCurve(Curve curve)
        {
            switch (curve)
            {
                case Curve.Linear:
                    return AnimationCurve.Linear(0, 0, 1, 1);
                case Curve.EaseInOut:
                    return AnimationCurve.EaseInOut(0, 0, 1, 1);
                default:
                    throw new ArgumentOutOfRangeException(nameof(curve), curve, null);
            }
        }
 
        public virtual void SetProgress(float progress)
        {
            if (mirror) progress = 1 - progress;
            float desiredTime = progress * duration;
            Step(desiredTime - timeStamp, !mirror);
        }
 
        public abstract UnityEngine.Object GetAnimatedObject(bool displayWarningIfNotApplicable = true);
 
    }
    
    public enum Curve
    {
        Linear,
        EaseInOut
    }
    
}