use rust_rocket;
#[cfg(feature = "editor")]
-type Rocket = rust_rocket::Rocket;
+type Rocket = rust_rocket::client::RocketClient;
#[cfg(not(feature = "editor"))]
type Rocket = ();
#[derive(Debug)]
pub struct Timer {
- pub t: f32,
-
- frame: u32,
+ pub t: f32, /// Simulation time (starts from 0 and does not advance while on pause).
+ pub now: Instant, /// Wall time, use instead of Instant::now() for frame-consistent time.
+ prev_time: Instant, /// Time of previous frame.
+ frame: u32, /// Frame count, starts from 0 and does not increment while on pause.
last_report_time: Instant,
last_report_frame: u32,
let now = Instant::now();
Timer {
t: 0.0,
+ now,
+ prev_time: now,
frame: 0,
last_report_time: now,
last_report_frame: 0,
}
}
+ // To be called once per frame, just before rendering
pub fn update(&mut self) {
- let now = Instant::now();
- self.poll_rocket();
+ self.prev_time = self.now;
+ self.now = Instant::now();
if !self.pause {
- // Increment time
- self.t += 0.01;
+ // Increment simulation time
+ let frame_time = self.now - self.prev_time;
+ self.t += frame_time.as_secs_f32();
self.frame += 1;
}
- self.maybe_report(now);
+ self.poll_rocket();
+ self.maybe_report();
}
#[cfg(not(feature = "logging"))]
- fn maybe_report(&mut self, _: Instant) {}
+ fn maybe_report(&mut self) {}
#[cfg(feature = "logging")]
- fn maybe_report(&mut self, now: Instant) {
- if now - self.last_report_time > Duration::from_secs(5) {
- self.report(now);
- self.last_report_time = now;
+ fn maybe_report(&mut self) {
+ if self.now - self.last_report_time > Duration::from_secs(5) {
+ self.report(self.now);
+ self.last_report_time = self.now;
self.last_report_frame = self.frame;
self.accum_draw_time = Duration::new(0, 0);
self.accum_idle_time = Duration::new(0, 0);
#[cfg(feature = "editor")]
fn poll_rocket(&mut self) {
+ use rust_rocket::client::Event;
+
match self.rocket {
Some(ref mut rocket) => {
let current_row = (self.t * BPS) as u32;
- if let Some(event) = rocket.poll_events() {
+ if let Some(event) = rocket.poll_events().unwrap() {
match event {
- rust_rocket::Event::SetRow(row) => {
+ Event::SetRow(row) => {
println!("SetRow (row: {:?})", row);
self.t = row as f32 / BPS;
}
- rust_rocket::Event::Pause(_) => {
- let track1 = rocket.get_track_mut("test");
+ Event::Pause(_) => {
+ let track1 = rocket.get_track_mut("test").unwrap();
println!("Pause (value: {:?}) (row: {:?})", track1.get_value(current_row as f32), current_row);
}
_ => (),