Inital commit

1 files changed, 226 insertions, 0 deletions

diff --git a/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/DiscreteTime.cs b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/DiscreteTime.cs
new file mode 100644
index 0000000..af68af8
--- /dev/null
+++ b/Library/PackageCache/com.unity.timeline@1.2.13/Runtime/DiscreteTime.cs
@@ -0,0 +1,226 @@
+using System;
+
+namespace UnityEngine.Timeline
+{
+    struct DiscreteTime : IComparable
+    {
+        const double k_Tick = 1e-12;
+        public static readonly DiscreteTime kMaxTime = new DiscreteTime(Int64.MaxValue);
+
+        readonly Int64 m_DiscreteTime;
+
+        public static double tickValue { get { return k_Tick; } }
+
+        public DiscreteTime(DiscreteTime time)
+        {
+            m_DiscreteTime = time.m_DiscreteTime;
+        }
+
+        DiscreteTime(Int64 time)
+        {
+            m_DiscreteTime = time;
+        }
+
+        public DiscreteTime(double time)
+        {
+            m_DiscreteTime = DoubleToDiscreteTime(time);
+        }
+
+        public DiscreteTime(float time)
+        {
+            m_DiscreteTime = FloatToDiscreteTime(time);
+        }
+
+        public DiscreteTime(int time)
+        {
+            m_DiscreteTime = IntToDiscreteTime(time);
+        }
+
+        public DiscreteTime(int frame, double fps)
+        {
+            m_DiscreteTime = DoubleToDiscreteTime(frame * fps);
+        }
+
+        public DiscreteTime OneTickBefore()
+        {
+            return new DiscreteTime(m_DiscreteTime - 1);
+        }
+
+        public DiscreteTime OneTickAfter()
+        {
+            return new DiscreteTime(m_DiscreteTime + 1);
+        }
+
+        public Int64 GetTick()
+        {
+            return m_DiscreteTime;
+        }
+
+        public static DiscreteTime FromTicks(Int64 ticks)
+        {
+            return new DiscreteTime(ticks);
+        }
+
+        public int CompareTo(object obj)
+        {
+            if (obj is DiscreteTime)
+                return m_DiscreteTime.CompareTo(((DiscreteTime)obj).m_DiscreteTime);
+            return 1;
+        }
+
+        public bool Equals(DiscreteTime other)
+        {
+            return m_DiscreteTime == other.m_DiscreteTime;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is DiscreteTime)
+                return Equals((DiscreteTime)obj);
+            return false;
+        }
+
+        static Int64 DoubleToDiscreteTime(double time)
+        {
+            double number = (time / k_Tick) + 0.5;
+            if (number < Int64.MaxValue && number > Int64.MinValue)
+                return (Int64)number;
+            throw new ArgumentOutOfRangeException("Time is over the discrete range.");
+        }
+
+        static Int64 FloatToDiscreteTime(float time)
+        {
+            float number = (time / (float)k_Tick) + 0.5f;
+            if (number < Int64.MaxValue && number > Int64.MinValue)
+                return (Int64)number;
+            throw new ArgumentOutOfRangeException("Time is over the discrete range.");
+        }
+
+        static Int64 IntToDiscreteTime(int time)
+        {
+            return DoubleToDiscreteTime(time);
+        }
+
+        static double ToDouble(Int64 time)
+        {
+            return time * k_Tick;
+        }
+
+        static float ToFloat(Int64 time)
+        {
+            return (float)ToDouble(time);
+        }
+
+        public static explicit operator double(DiscreteTime b)
+        {
+            return ToDouble(b.m_DiscreteTime);
+        }
+
+        public static explicit operator float(DiscreteTime b)
+        {
+            return ToFloat(b.m_DiscreteTime);
+        }
+
+        public static explicit operator Int64(DiscreteTime b)
+        {
+            return b.m_DiscreteTime;
+        }
+
+        public static explicit operator DiscreteTime(double time)
+        {
+            return new DiscreteTime(time);
+        }
+
+        public static explicit operator DiscreteTime(float time)
+        {
+            return new DiscreteTime(time);
+        }
+
+        public static implicit operator DiscreteTime(Int32 time)
+        {
+            return new DiscreteTime(time);
+        }
+
+        public static explicit operator DiscreteTime(Int64 time)
+        {
+            return new DiscreteTime(time);
+        }
+
+        public static bool operator==(DiscreteTime lhs, DiscreteTime rhs)
+        {
+            return lhs.m_DiscreteTime == rhs.m_DiscreteTime;
+        }
+
+        public static bool operator!=(DiscreteTime lhs, DiscreteTime rhs)
+        {
+            return !(lhs == rhs);
+        }
+
+        public static bool operator>(DiscreteTime lhs, DiscreteTime rhs)
+        {
+            return lhs.m_DiscreteTime > rhs.m_DiscreteTime;
+        }
+
+        public static bool operator<(DiscreteTime lhs, DiscreteTime rhs)
+        {
+            return lhs.m_DiscreteTime < rhs.m_DiscreteTime;
+        }
+
+        public static bool operator<=(DiscreteTime lhs, DiscreteTime rhs)
+        {
+            return lhs.m_DiscreteTime <= rhs.m_DiscreteTime;
+        }
+
+        public static bool operator>=(DiscreteTime lhs, DiscreteTime rhs)
+        {
+            return lhs.m_DiscreteTime >= rhs.m_DiscreteTime;
+        }
+
+        public static DiscreteTime operator+(DiscreteTime lhs, DiscreteTime rhs)
+        {
+            return new DiscreteTime(lhs.m_DiscreteTime + rhs.m_DiscreteTime);
+        }
+
+        public static DiscreteTime operator-(DiscreteTime lhs, DiscreteTime rhs)
+        {
+            return new DiscreteTime(lhs.m_DiscreteTime - rhs.m_DiscreteTime);
+        }
+
+        public override string ToString()
+        {
+            return m_DiscreteTime.ToString();
+        }
+
+        public override int GetHashCode()
+        {
+            return m_DiscreteTime.GetHashCode();
+        }
+
+        public static DiscreteTime Min(DiscreteTime lhs, DiscreteTime rhs)
+        {
+            return new DiscreteTime(Math.Min(lhs.m_DiscreteTime, rhs.m_DiscreteTime));
+        }
+
+        public static DiscreteTime Max(DiscreteTime lhs, DiscreteTime rhs)
+        {
+            return new DiscreteTime(Math.Max(lhs.m_DiscreteTime, rhs.m_DiscreteTime));
+        }
+
+        public static double SnapToNearestTick(double time)
+        {
+            Int64 discreteTime = DoubleToDiscreteTime(time);
+            return ToDouble(discreteTime);
+        }
+
+        public static float SnapToNearestTick(float time)
+        {
+            Int64 discreteTime = FloatToDiscreteTime(time);
+            return ToFloat(discreteTime);
+        }
+
+        public static Int64 GetNearestTick(double time)
+        {
+            return DoubleToDiscreteTime(time);
+        }
+    }
+}