Remove instant dependency in favor of web-time (#767)

2 files changed, 48 insertions, 29 deletions

diff --git a/src/counters/mod.rs b/src/counters/mod.rs
index 188f078..43d4bd2 100644
--- a/src/counters/mod.rs
+++ b/src/counters/mod.rs
@@ -1,5 +1,6 @@
 //! Counters for benchmarking various parts of the physics engine.
 
+use core::time::Duration;
 use std::fmt::{Display, Formatter, Result};
 
 pub use self::ccd_counters::CCDCounters;
@@ -76,11 +77,16 @@ impl Counters {
         }
     }
 
-    /// Total time spent for one  of the physics engine.
-    pub fn step_time(&self) -> f64 {
+    /// Total time spent for one of the physics engine.
+    pub fn step_time(&self) -> Duration {
         self.step_time.time()
     }
 
+    /// Total time spent for one of the physics engine, in milliseconds.
+    pub fn step_time_ms(&self) -> f64 {
+        self.step_time.time_ms()
+    }
+
     /// Notify that the custom operation has started.
     pub fn custom_started(&mut self) {
         if self.enabled {
@@ -96,10 +102,15 @@ impl Counters {
     }
 
     /// Total time of a custom event.
-    pub fn custom_time(&self) -> f64 {
+    pub fn custom_time(&self) -> Duration {
         self.custom.time()
     }
 
+    /// Total time of a custom event, in milliseconds.
+    pub fn custom_time_ms(&self) -> f64 {
+        self.custom.time_ms()
+    }
+
     /// Set the number of constraints generated.
     pub fn set_nconstraints(&mut self, n: usize) {
         self.solver.nconstraints = n;
@@ -129,7 +140,7 @@ impl Counters {
 }
 
 macro_rules! measure_method {
-    ($started:ident, $stopped:ident, $time:ident, $info:ident. $timer:ident) => {
+    ($started:ident, $stopped:ident, $time_ms:ident, $info:ident. $timer:ident) => {
         impl Counters {
             /// Start this timer.
             pub fn $started(&mut self) {
@@ -145,10 +156,10 @@ macro_rules! measure_method {
                 }
             }
 
-            /// Gets the time elapsed for this timer.
-            pub fn $time(&self) -> f64 {
+            /// Gets the time elapsed for this timer, in milliseconds.
+            pub fn $time_ms(&self) -> f64 {
                 if self.enabled {
-                    self.$info.$timer.time()
+                    self.$info.$timer.time_ms()
                 } else {
                     0.0
                 }
@@ -160,63 +171,63 @@ macro_rules! measure_method {
 measure_method!(
     update_started,
     update_completed,
-    update_time,
+    update_time_ms,
     stages.update_time
 );
 measure_method!(
     collision_detection_started,
     collision_detection_completed,
-    collision_detection_time,
+    collision_detection_time_ms,
     stages.collision_detection_time
 );
 measure_method!(
     island_construction_started,
     island_construction_completed,
-    island_construction_time,
+    island_construction_time_ms,
     stages.island_construction_time
 );
 measure_method!(
     solver_started,
     solver_completed,
-    solver_time,
+    solver_time_ms,
     stages.solver_time
 );
-measure_method!(ccd_started, ccd_completed, ccd_time, stages.ccd_time);
+measure_method!(ccd_started, ccd_completed, ccd_time_ms, stages.ccd_time);
 measure_method!(
     query_pipeline_update_started,
     query_pipeline_update_completed,
-    query_pipeline_update_time,
+    query_pipeline_update_time_ms,
     stages.query_pipeline_time
 );
 
 measure_method!(
     assembly_started,
     assembly_completed,
-    assembly_time,
+    assembly_time_ms,
     solver.velocity_assembly_time
 );
 measure_method!(
     velocity_resolution_started,
     velocity_resolution_completed,
-    velocity_resolution_time,
+    velocity_resolution_time_ms,
     solver.velocity_resolution_time
 );
 measure_method!(
     velocity_update_started,
     velocity_update_completed,
-    velocity_update_time,
+    velocity_update_time_ms,
     solver.velocity_update_time
 );
 measure_method!(
     broad_phase_started,
     broad_phase_completed,
-    broad_phase_time,
+    broad_phase_time_ms,
     cd.broad_phase_time
 );
 measure_method!(
     narrow_phase_started,
     narrow_phase_completed,
-    narrow_phase_time,
+    narrow_phase_time_ms,
     cd.narrow_phase_time
 );
 
diff --git a/src/counters/timer.rs b/src/counters/timer.rs
index bc0397d..3ffef43 100644
--- a/src/counters/timer.rs
+++ b/src/counters/timer.rs
@@ -1,33 +1,36 @@
-use std::fmt::{Display, Error, Formatter};
+use std::{
+    fmt::{Display, Error, Formatter},
+    time::Duration,
+};
 
 /// A timer.
 #[derive(Copy, Clone, Debug, Default)]
 pub struct Timer {
-    time: f64,
+    time: Duration,
     #[allow(dead_code)] // The field isn’t used if the `profiler` feature isn’t enabled.
-    start: Option<f64>,
+    start: Option<std::time::Instant>,
 }
 
 impl Timer {
     /// Creates a new timer initialized to zero and not started.
     pub fn new() -> Self {
         Timer {
-            time: 0.0,
+            time: Duration::from_secs(0),
             start: None,
         }
     }
 
     /// Resets the timer to 0.
     pub fn reset(&mut self) {
-        self.time = 0.0
+        self.time = Duration::from_secs(0)
     }
 
     /// Start the timer.
     pub fn start(&mut self) {
         #[cfg(feature = "profiler")]
         {
-            self.time = 0.0;
-            self.start = Some(instant::now());
+            self.time = Duration::from_secs(0);
+            self.start = Some(web_time::Instant::now());
         }
     }
 
@@ -36,7 +39,7 @@ impl Timer {
         #[cfg(feature = "profiler")]
         {
             if let Some(start) = self.start {
-                self.time += instant::now() - start;
+                self.time += web_time::Instant::now().duration_since(start);
             }
             self.start = None;
         }
@@ -46,18 +49,23 @@ impl Timer {
     pub fn resume(&mut self) {
         #[cfg(feature = "profiler")]
         {
-            self.start = Some(instant::now());
+            self.start = Some(web_time::Instant::now());
         }
     }
 
     /// The measured time between the last `.start()` and `.pause()` calls.
-    pub fn time(&self) -> f64 {
+    pub fn time(&self) -> Duration {
         self.time
     }
+
+    /// The measured time in milliseconds between the last `.start()` and `.pause()` calls.
+    pub fn time_ms(&self) -> f64 {
+        self.time.as_secs_f64() * 1000.0
+    }
 }
 
 impl Display for Timer {
     fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
-        write!(f, "{}s", self.time)
+        write!(f, "{}ms", self.time_ms())
     }
 }