InterpolatedValue.cs

Go to the documentation of this file.

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

using System;
using UnityEngine;

namespace HoloToolkit.Unity
{
    [Serializable]
    public abstract class InterpolatedValue<T>
    {
        public const float SmallNumber = 0.0000001f;
        public const float SmallNumberSquared = SmallNumber * SmallNumber;

        public static implicit operator T(InterpolatedValue<T> interpolatedValue)
        {
            return interpolatedValue.Value;
        }

        public event Action<InterpolatedValue<T>> Started;

        public event Action<InterpolatedValue<T>> Completed;

        public event Action<InterpolatedValue<T>> ValueChanged;

        private T targetValue;
        private T startValue;
        private float timeInterpolationStartedAt;
        private bool firstUpdateFrameSkipped;
        private bool skipFirstUpdateFrame;
        private bool performingInterpolativeSnap;

        [SerializeField]
        [Tooltip("Time the interpolator takes to get from current value to the target value")]
        private float duration = 1.0f;

        public float Duration
        {
            get { return duration; }
            set { duration = value; }
        }

        [SerializeField]
        [Tooltip("Time the interpolator takes to get from current value to the target value")]
        private AnimationCurve curve = null;

        public AnimationCurve Curve
        {
            get { return curve; }
            set { curve = value; }
        }

        public bool IsValid { get { return Curve != null; } }

        public bool IsRunning { get; private set; }

        private T value;
        
        public T Value
        {
            get { return value; }
            private set
            {
                if (!DoValuesEqual(this.value, value))
                {
                    this.value = value;
                    ValueChanged.RaiseEvent(this);
                }
            }
        }

        public T Target
        {
            get { return targetValue; }
        }

        protected float CurrentTime
        {
            get
            {
#if UNITY_EDITOR
                return !Application.isPlaying ? (float)UnityEditor.EditorApplication.timeSinceStartup : Time.time;
#else
                return Time.time;
#endif
            }
        }

        public InterpolatedValue(T initialValue, bool skipFirstUpdateFrame)
        {
            IsRunning = false;
            Value = targetValue = initialValue;
            Duration = 1.0f;
            firstUpdateFrameSkipped = false;
            this.skipFirstUpdateFrame = skipFirstUpdateFrame;
            performingInterpolativeSnap = false;
        }

        public void UpdateTarget(T updateTargetValue)
        {
            UpdateTarget(updateTargetValue, false);
        }

        public void UpdateTarget(T updateTargetValue, bool forceUpdate)
        {
            performingInterpolativeSnap = false;

            targetValue = updateTargetValue;

            startValue = Value;
            timeInterpolationStartedAt = CurrentTime;

            if (!DoValuesEqual(updateTargetValue, Value))
            {
                EnsureEnabled();
            }
            else if (forceUpdate && !IsRunning)
            {
                ValueChanged.RaiseEvent(this);
            }
        }

        public void SnapToTarget()
        {
            SnapToTarget(targetValue);
        }

        public void SnapToTarget(T snapTargetValue)
        {
            performingInterpolativeSnap = false;
            Value = startValue = snapTargetValue;
            EnsureDisabled();
        }

        public void InterpolateThenSnapToTarget(T snapTargetValue)
        {
            if (performingInterpolativeSnap)
            {
                // If we are running, just update the target, otherwise just snap to target
                if (IsRunning)
                {
                    targetValue = snapTargetValue;
                }
                else
                {
                    Value = startValue = snapTargetValue;
                }
            }
            else
            {
                UpdateTarget(snapTargetValue);
                performingInterpolativeSnap = true;
            }
        }

        public void EnsureEnabled()
        {
            if (!IsRunning)
            {
                if (skipFirstUpdateFrame)
                {
                    firstUpdateFrameSkipped = false;
                }

                IsRunning = true;

                Started.RaiseEvent(this);
            }
        }

        public void EnsureDisabled()
        {
            if (IsRunning)
            {
                IsRunning = false;

                Completed.RaiseEvent(this);
            }
        }

        public T FrameUpdate()
        {
            if (IsRunning)
            {
                if (skipFirstUpdateFrame && !firstUpdateFrameSkipped)
                {
                    firstUpdateFrameSkipped = true;
                    timeInterpolationStartedAt = CurrentTime;
                    return Value;
                }

                float timeDelta = CurrentTime - timeInterpolationStartedAt;

                // Normalize the delta to curve duration
                timeDelta *= Curve.Duration() / Duration;

                Value = ApplyCurveValue(startValue, targetValue, Curve.Evaluate(timeDelta));
                if (timeDelta >= Curve.Duration())
                {
                    EnsureDisabled();
                }
            }

            return Value;
        }

        public abstract bool DoValuesEqual(T one, T other);

        public abstract T ApplyCurveValue(T startValue, T targetValue, float curveValue);
    }
}