1 files changed, 25 insertions, 31 deletions

diff --git a/gate/src/core/sdl/app_clock.rs b/gate/src/core/sdl/app_clock.rs
index b45cb88..49fc67b 100644
--- a/gate/src/core/sdl/app_clock.rs
+++ b/gate/src/core/sdl/app_clock.rs
@@ -12,59 +12,53 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use sdl2::TimerSubsystem;
-
 use app_info::AppInfo;
-use std::u32;
+use std::u64;
+use std::thread;
+
+use std::time::Duration;
+use time;
 
 pub struct AppClock {
-    timer: TimerSubsystem,
-    last_ticks: u32,
-    frame_dur_millis: u32,
+    last_ticks: u64,
+    frame_dur_nanos: u32,
     work_load_sum: f64,
     work_load_max: f64,
     work_load_frames: u64,
-    last_print_workload_ticks: u32,
+    last_print_workload_ticks: u64,
 }
 
 impl AppClock {
-    pub fn new(mut timer: TimerSubsystem, info: &AppInfo) -> AppClock {
+    pub fn new(info: &AppInfo) -> AppClock {
         AppClock {
-            last_ticks: timer.ticks(),
-            timer,
-            frame_dur_millis: (1000. / info.target_fps).round() as u32,
+            last_ticks: time::precise_time_ns(),
+            frame_dur_nanos: (1_000_000_000. / info.target_fps).round() as u32,
             work_load_sum: 0.0,
             work_load_max: 0.0,
             work_load_frames: 0,
-            last_print_workload_ticks: if info.print_workload_info { 1 } else { u32::MAX - 100_000 },
+            last_print_workload_ticks: if info.print_workload_info { 1 } else { u64::MAX - 100_000 },
         }
     }
 
     pub fn step(&mut self) -> f64 {
-        let mut elapsed;
-        let mut first_iter = true;
-        loop {
-            let now = self.timer.ticks();
-            let dt = now - self.last_ticks;
-            elapsed = dt as f64 / 1_000.0;
+        let now_before_delay = time::precise_time_ns();
 
-            if first_iter {
-                first_iter = false;
-                self.append_workload(now, dt);
-            }
+        let dt_before_delay = (now_before_delay - self.last_ticks) as u32;
 
-            if dt < self.frame_dur_millis {
-                self.timer.delay(self.frame_dur_millis - dt);
-            } else {
-                break;
-            }
+        if dt_before_delay < self.frame_dur_nanos {
+            thread::sleep(Duration::new(0, self.frame_dur_nanos - dt_before_delay));
         }
-        self.last_ticks = self.timer.ticks();
-        elapsed
+
+        let now_after_delay = time::precise_time_ns();
+        let dt_after_delay = (now_after_delay - self.last_ticks) as u32;
+        
+        self.last_ticks = now_after_delay;
+
+        dt_after_delay as f64 / 1_000_000_000.0
     }
 
-    fn append_workload(&mut self, now: u32, dt: u32) {
-        let work_load = dt as f64 / self.frame_dur_millis as f64;
+    fn append_workload(&mut self, now: u64, dt: u32) {
+        let work_load = dt as f64 / self.frame_dur_nanos as f64;
         self.work_load_sum += work_load;
         self.work_load_max = self.work_load_max.max(work_load);
         self.work_load_frames += 1;