A game about forced loneliness, made by TACStudios
tacstudios.tngl.sh
1using System;
2
3namespace UnityEngine.Timeline
4{
5 struct DiscreteTime : IComparable
6 {
7 const double k_Tick = 1e-12;
8 public static readonly DiscreteTime kMaxTime = new DiscreteTime(Int64.MaxValue);
9
10 readonly Int64 m_DiscreteTime;
11
12 public static double tickValue { get { return k_Tick; } }
13
14 public DiscreteTime(DiscreteTime time)
15 {
16 m_DiscreteTime = time.m_DiscreteTime;
17 }
18
19 DiscreteTime(Int64 time)
20 {
21 m_DiscreteTime = time;
22 }
23
24 public DiscreteTime(double time)
25 {
26 m_DiscreteTime = DoubleToDiscreteTime(time);
27 }
28
29 public DiscreteTime(float time)
30 {
31 m_DiscreteTime = FloatToDiscreteTime(time);
32 }
33
34 public DiscreteTime(int time)
35 {
36 m_DiscreteTime = IntToDiscreteTime(time);
37 }
38
39 public DiscreteTime(int frame, double fps)
40 {
41 m_DiscreteTime = DoubleToDiscreteTime(frame * fps);
42 }
43
44 public DiscreteTime OneTickBefore()
45 {
46 return new DiscreteTime(m_DiscreteTime - 1);
47 }
48
49 public DiscreteTime OneTickAfter()
50 {
51 return new DiscreteTime(m_DiscreteTime + 1);
52 }
53
54 public Int64 GetTick()
55 {
56 return m_DiscreteTime;
57 }
58
59 public static DiscreteTime FromTicks(Int64 ticks)
60 {
61 return new DiscreteTime(ticks);
62 }
63
64 public int CompareTo(object obj)
65 {
66 if (obj is DiscreteTime)
67 return m_DiscreteTime.CompareTo(((DiscreteTime)obj).m_DiscreteTime);
68 return 1;
69 }
70
71 public bool Equals(DiscreteTime other)
72 {
73 return m_DiscreteTime == other.m_DiscreteTime;
74 }
75
76 public override bool Equals(object obj)
77 {
78 if (obj is DiscreteTime)
79 return Equals((DiscreteTime)obj);
80 return false;
81 }
82
83 static Int64 DoubleToDiscreteTime(double time)
84 {
85 double number = (time / k_Tick) + 0.5;
86 if (number < Int64.MaxValue && number > Int64.MinValue)
87 return (Int64)number;
88 throw new ArgumentOutOfRangeException("Time is over the discrete range.");
89 }
90
91 static Int64 FloatToDiscreteTime(float time)
92 {
93 float number = (time / (float)k_Tick) + 0.5f;
94 if (number < Int64.MaxValue && number > Int64.MinValue)
95 return (Int64)number;
96 throw new ArgumentOutOfRangeException("Time is over the discrete range.");
97 }
98
99 static Int64 IntToDiscreteTime(int time)
100 {
101 return DoubleToDiscreteTime(time);
102 }
103
104 static double ToDouble(Int64 time)
105 {
106 return time * k_Tick;
107 }
108
109 static float ToFloat(Int64 time)
110 {
111 return (float)ToDouble(time);
112 }
113
114 public static explicit operator double(DiscreteTime b)
115 {
116 return ToDouble(b.m_DiscreteTime);
117 }
118
119 public static explicit operator float(DiscreteTime b)
120 {
121 return ToFloat(b.m_DiscreteTime);
122 }
123
124 public static explicit operator Int64(DiscreteTime b)
125 {
126 return b.m_DiscreteTime;
127 }
128
129 public static explicit operator DiscreteTime(double time)
130 {
131 return new DiscreteTime(time);
132 }
133
134 public static explicit operator DiscreteTime(float time)
135 {
136 return new DiscreteTime(time);
137 }
138
139 public static implicit operator DiscreteTime(Int32 time)
140 {
141 return new DiscreteTime(time);
142 }
143
144 public static explicit operator DiscreteTime(Int64 time)
145 {
146 return new DiscreteTime(time);
147 }
148
149 public static bool operator ==(DiscreteTime lhs, DiscreteTime rhs)
150 {
151 return lhs.m_DiscreteTime == rhs.m_DiscreteTime;
152 }
153
154 public static bool operator !=(DiscreteTime lhs, DiscreteTime rhs)
155 {
156 return !(lhs == rhs);
157 }
158
159 public static bool operator >(DiscreteTime lhs, DiscreteTime rhs)
160 {
161 return lhs.m_DiscreteTime > rhs.m_DiscreteTime;
162 }
163
164 public static bool operator <(DiscreteTime lhs, DiscreteTime rhs)
165 {
166 return lhs.m_DiscreteTime < rhs.m_DiscreteTime;
167 }
168
169 public static bool operator <=(DiscreteTime lhs, DiscreteTime rhs)
170 {
171 return lhs.m_DiscreteTime <= rhs.m_DiscreteTime;
172 }
173
174 public static bool operator >=(DiscreteTime lhs, DiscreteTime rhs)
175 {
176 return lhs.m_DiscreteTime >= rhs.m_DiscreteTime;
177 }
178
179 public static DiscreteTime operator +(DiscreteTime lhs, DiscreteTime rhs)
180 {
181 return new DiscreteTime(lhs.m_DiscreteTime + rhs.m_DiscreteTime);
182 }
183
184 public static DiscreteTime operator -(DiscreteTime lhs, DiscreteTime rhs)
185 {
186 return new DiscreteTime(lhs.m_DiscreteTime - rhs.m_DiscreteTime);
187 }
188
189 public override string ToString()
190 {
191 return m_DiscreteTime.ToString();
192 }
193
194 public override int GetHashCode()
195 {
196 return m_DiscreteTime.GetHashCode();
197 }
198
199 public static DiscreteTime Min(DiscreteTime lhs, DiscreteTime rhs)
200 {
201 return new DiscreteTime(Math.Min(lhs.m_DiscreteTime, rhs.m_DiscreteTime));
202 }
203
204 public static DiscreteTime Max(DiscreteTime lhs, DiscreteTime rhs)
205 {
206 return new DiscreteTime(Math.Max(lhs.m_DiscreteTime, rhs.m_DiscreteTime));
207 }
208
209 public static double SnapToNearestTick(double time)
210 {
211 Int64 discreteTime = DoubleToDiscreteTime(time);
212 return ToDouble(discreteTime);
213 }
214
215 public static float SnapToNearestTick(float time)
216 {
217 Int64 discreteTime = FloatToDiscreteTime(time);
218 return ToFloat(discreteTime);
219 }
220
221 public static Int64 GetNearestTick(double time)
222 {
223 return DoubleToDiscreteTime(time);
224 }
225 }
226}