144 lines
3.6 KiB
Rust
144 lines
3.6 KiB
Rust
//! Keep track of the time we spent in each part of the game loop.
|
|
use std::time::{Duration, Instant};
|
|
|
|
/// Utility struct.
|
|
/// Keeps track of the time we spent in each part of the game loop.
|
|
#[derive(Debug, Clone)]
|
|
pub struct Timing {
|
|
/// The time we spent on all frame computations
|
|
pub frame: Duration,
|
|
frame_timer: Instant,
|
|
|
|
/// The total time we spent simulating physics
|
|
pub physics_sim: Duration,
|
|
physics_sim_timer: Instant,
|
|
|
|
/// The time we spent updating physics state
|
|
pub physics_step: Duration,
|
|
physics_step_timer: Instant,
|
|
|
|
/// The time we spent updating physics ships
|
|
pub physics_ship: Duration,
|
|
physics_ship_timer: Instant,
|
|
|
|
/// The time we spent updating physics projectiles
|
|
pub physics_proj: Duration,
|
|
physics_proj_timer: Instant,
|
|
|
|
/// The time we spent updating effects
|
|
pub physics_effect: Duration,
|
|
physics_effect_timer: Instant,
|
|
}
|
|
|
|
// TODO: document each duration
|
|
|
|
impl Timing {
|
|
/// Create a new timing struct
|
|
pub fn new() -> Self {
|
|
Self {
|
|
frame: Duration::ZERO,
|
|
physics_sim: Duration::ZERO,
|
|
physics_ship: Duration::ZERO,
|
|
physics_effect: Duration::ZERO,
|
|
physics_proj: Duration::ZERO,
|
|
physics_step: Duration::ZERO,
|
|
physics_effect_timer: Instant::now(),
|
|
physics_proj_timer: Instant::now(),
|
|
physics_step_timer: Instant::now(),
|
|
physics_sim_timer: Instant::now(),
|
|
physics_ship_timer: Instant::now(),
|
|
frame_timer: Instant::now(),
|
|
}
|
|
}
|
|
|
|
/// Start frame timer
|
|
pub fn start_frame(&mut self) {
|
|
self.frame_timer = Instant::now();
|
|
}
|
|
|
|
/// Record total frame compute time
|
|
pub fn mark_frame(&mut self) {
|
|
self.frame = self.frame_timer.elapsed();
|
|
}
|
|
|
|
/// Start physics sim timer
|
|
pub fn start_physics_sim(&mut self) {
|
|
self.physics_sim_timer = Instant::now();
|
|
}
|
|
|
|
/// Record physics simulation time
|
|
pub fn mark_physics_sim(&mut self) {
|
|
self.physics_sim = self.physics_sim_timer.elapsed();
|
|
}
|
|
|
|
/// Start physics ship timer
|
|
pub fn start_physics_ships(&mut self) {
|
|
self.physics_ship_timer = Instant::now();
|
|
}
|
|
|
|
/// Record physics ship update time
|
|
pub fn mark_physics_ships(&mut self) {
|
|
self.physics_ship = self.physics_ship_timer.elapsed();
|
|
}
|
|
|
|
/// Start physics step timer
|
|
pub fn start_physics_step(&mut self) {
|
|
self.physics_step_timer = Instant::now();
|
|
}
|
|
|
|
/// Record physics ship update time
|
|
pub fn mark_physics_step(&mut self) {
|
|
self.physics_step = self.physics_step_timer.elapsed();
|
|
}
|
|
|
|
/// Start physics ship timer
|
|
pub fn start_physics_proj(&mut self) {
|
|
self.physics_proj_timer = Instant::now();
|
|
}
|
|
|
|
/// Record physics ship update time
|
|
pub fn mark_physics_proj(&mut self) {
|
|
self.physics_proj = self.physics_proj_timer.elapsed();
|
|
}
|
|
|
|
/// Start physics ship timer
|
|
pub fn start_physics_effects(&mut self) {
|
|
self.physics_effect_timer = Instant::now();
|
|
}
|
|
|
|
/// Record physics ship update time
|
|
pub fn mark_physics_effects(&mut self) {
|
|
self.physics_effect = self.physics_effect_timer.elapsed();
|
|
}
|
|
|
|
/// Get current timing values as a pretty string
|
|
pub fn get_string(&self) -> String {
|
|
let mut s = String::new();
|
|
//s.push_str(&format!(
|
|
// "Overall {:6.00} fps\n\n",
|
|
// 1.0 / self.frame.as_secs_f32()
|
|
//));
|
|
|
|
let f = self.physics_sim.as_secs_f32();
|
|
s.push_str(&format!("Phys {:6.00} fps\n", 1.0 / f));
|
|
s.push_str(&format!(
|
|
"Step {:5.02}%\n",
|
|
100.0 * self.physics_step.as_secs_f32() / f
|
|
));
|
|
s.push_str(&format!(
|
|
"Proj {:05.02}%\n",
|
|
100.0 * self.physics_proj.as_secs_f32() / f
|
|
));
|
|
s.push_str(&format!(
|
|
"Ships {:05.02}%\n",
|
|
100.0 * self.physics_ship.as_secs_f32() / f
|
|
));
|
|
s.push_str(&format!(
|
|
"Efcts {:05.02}%",
|
|
100.0 * self.physics_effect.as_secs_f32() / f
|
|
));
|
|
|
|
return s;
|
|
}
|
|
}
|