use bevy_ecs::{reflect::ReflectResource, system::Resource};
use bevy_reflect::{FromReflect, Reflect};
use bevy_utils::{Duration, Instant};
#[derive(Resource, Reflect, FromReflect, Debug, Clone)]
#[reflect(Resource)]
pub struct Time {
startup: Instant,
first_update: Option<Instant>,
last_update: Option<Instant>,
paused: bool,
relative_speed: f64, delta: Duration,
delta_seconds: f32,
delta_seconds_f64: f64,
elapsed: Duration,
elapsed_seconds: f32,
elapsed_seconds_f64: f64,
raw_delta: Duration,
raw_delta_seconds: f32,
raw_delta_seconds_f64: f64,
raw_elapsed: Duration,
raw_elapsed_seconds: f32,
raw_elapsed_seconds_f64: f64,
wrap_period: Duration,
elapsed_wrapped: Duration,
elapsed_seconds_wrapped: f32,
elapsed_seconds_wrapped_f64: f64,
raw_elapsed_wrapped: Duration,
raw_elapsed_seconds_wrapped: f32,
raw_elapsed_seconds_wrapped_f64: f64,
}
impl Default for Time {
fn default() -> Self {
Self {
startup: Instant::now(),
first_update: None,
last_update: None,
paused: false,
relative_speed: 1.0,
delta: Duration::ZERO,
delta_seconds: 0.0,
delta_seconds_f64: 0.0,
elapsed: Duration::ZERO,
elapsed_seconds: 0.0,
elapsed_seconds_f64: 0.0,
raw_delta: Duration::ZERO,
raw_delta_seconds: 0.0,
raw_delta_seconds_f64: 0.0,
raw_elapsed: Duration::ZERO,
raw_elapsed_seconds: 0.0,
raw_elapsed_seconds_f64: 0.0,
wrap_period: Duration::from_secs(3600), elapsed_wrapped: Duration::ZERO,
elapsed_seconds_wrapped: 0.0,
elapsed_seconds_wrapped_f64: 0.0,
raw_elapsed_wrapped: Duration::ZERO,
raw_elapsed_seconds_wrapped: 0.0,
raw_elapsed_seconds_wrapped_f64: 0.0,
}
}
}
impl Time {
pub fn new(startup: Instant) -> Self {
Self {
startup,
..Default::default()
}
}
pub fn update(&mut self) {
let now = Instant::now();
self.update_with_instant(now);
}
pub fn update_with_instant(&mut self, instant: Instant) {
let raw_delta = instant - self.last_update.unwrap_or(self.startup);
let delta = if self.paused {
Duration::ZERO
} else if self.relative_speed != 1.0 {
raw_delta.mul_f64(self.relative_speed)
} else {
raw_delta
};
if self.last_update.is_some() {
self.delta = delta;
self.delta_seconds = self.delta.as_secs_f32();
self.delta_seconds_f64 = self.delta.as_secs_f64();
self.raw_delta = raw_delta;
self.raw_delta_seconds = self.raw_delta.as_secs_f32();
self.raw_delta_seconds_f64 = self.raw_delta.as_secs_f64();
} else {
self.first_update = Some(instant);
}
self.elapsed += delta;
self.elapsed_seconds = self.elapsed.as_secs_f32();
self.elapsed_seconds_f64 = self.elapsed.as_secs_f64();
self.raw_elapsed += raw_delta;
self.raw_elapsed_seconds = self.raw_elapsed.as_secs_f32();
self.raw_elapsed_seconds_f64 = self.raw_elapsed.as_secs_f64();
self.elapsed_wrapped = duration_div_rem(self.elapsed, self.wrap_period).1;
self.elapsed_seconds_wrapped = self.elapsed_wrapped.as_secs_f32();
self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();
self.raw_elapsed_wrapped = duration_div_rem(self.raw_elapsed, self.wrap_period).1;
self.raw_elapsed_seconds_wrapped = self.raw_elapsed_wrapped.as_secs_f32();
self.raw_elapsed_seconds_wrapped_f64 = self.raw_elapsed_wrapped.as_secs_f64();
self.last_update = Some(instant);
}
#[inline]
pub fn startup(&self) -> Instant {
self.startup
}
#[inline]
pub fn first_update(&self) -> Option<Instant> {
self.first_update
}
#[inline]
pub fn last_update(&self) -> Option<Instant> {
self.last_update
}
#[inline]
pub fn delta(&self) -> Duration {
self.delta
}
#[inline]
pub fn delta_seconds(&self) -> f32 {
self.delta_seconds
}
#[inline]
pub fn delta_seconds_f64(&self) -> f64 {
self.delta_seconds_f64
}
#[inline]
pub fn elapsed(&self) -> Duration {
self.elapsed
}
#[inline]
pub fn elapsed_seconds(&self) -> f32 {
self.elapsed_seconds
}
#[inline]
pub fn elapsed_seconds_f64(&self) -> f64 {
self.elapsed_seconds_f64
}
#[inline]
pub fn elapsed_wrapped(&self) -> Duration {
self.elapsed_wrapped
}
#[inline]
pub fn elapsed_seconds_wrapped(&self) -> f32 {
self.elapsed_seconds_wrapped
}
#[inline]
pub fn elapsed_seconds_wrapped_f64(&self) -> f64 {
self.elapsed_seconds_wrapped_f64
}
#[inline]
pub fn raw_delta(&self) -> Duration {
self.raw_delta
}
#[inline]
pub fn raw_delta_seconds(&self) -> f32 {
self.raw_delta_seconds
}
#[inline]
pub fn raw_delta_seconds_f64(&self) -> f64 {
self.raw_delta_seconds_f64
}
#[inline]
pub fn raw_elapsed(&self) -> Duration {
self.raw_elapsed
}
#[inline]
pub fn raw_elapsed_seconds(&self) -> f32 {
self.raw_elapsed_seconds
}
#[inline]
pub fn raw_elapsed_seconds_f64(&self) -> f64 {
self.raw_elapsed_seconds_f64
}
#[inline]
pub fn raw_elapsed_wrapped(&self) -> Duration {
self.raw_elapsed_wrapped
}
#[inline]
pub fn raw_elapsed_seconds_wrapped(&self) -> f32 {
self.raw_elapsed_seconds_wrapped
}
#[inline]
pub fn raw_elapsed_seconds_wrapped_f64(&self) -> f64 {
self.raw_elapsed_seconds_wrapped_f64
}
#[inline]
pub fn wrap_period(&self) -> Duration {
self.wrap_period
}
#[inline]
pub fn set_wrap_period(&mut self, wrap_period: Duration) {
assert!(!wrap_period.is_zero(), "division by zero");
self.wrap_period = wrap_period;
}
#[inline]
pub fn relative_speed(&self) -> f32 {
self.relative_speed_f64() as f32
}
#[inline]
pub fn relative_speed_f64(&self) -> f64 {
if self.paused {
0.0
} else {
self.relative_speed
}
}
#[inline]
pub fn set_relative_speed(&mut self, ratio: f32) {
self.set_relative_speed_f64(ratio as f64);
}
#[inline]
pub fn set_relative_speed_f64(&mut self, ratio: f64) {
assert!(ratio.is_finite(), "tried to go infinitely fast");
assert!(ratio.is_sign_positive(), "tried to go back in time");
self.relative_speed = ratio;
}
#[inline]
pub fn pause(&mut self) {
self.paused = true;
}
#[inline]
pub fn unpause(&mut self) {
self.paused = false;
}
#[inline]
pub fn is_paused(&self) -> bool {
self.paused
}
}
fn duration_div_rem(dividend: Duration, divisor: Duration) -> (u32, Duration) {
let quotient = (dividend.as_nanos() / divisor.as_nanos()) as u32;
let remainder = dividend - (quotient * divisor);
(quotient, remainder)
}
#[cfg(test)]
#[allow(clippy::float_cmp)]
mod tests {
use super::Time;
use bevy_utils::{Duration, Instant};
fn assert_float_eq(a: f32, b: f32) {
assert!((a - b).abs() <= f32::EPSILON, "{a} != {b}");
}
#[test]
#[cfg(not(all(target_arch = "aarch64", target_vendor = "apple")))]
fn update_test() {
let start_instant = Instant::now();
let mut time = Time::new(start_instant);
assert_eq!(time.startup(), start_instant);
assert_eq!(time.first_update(), None);
assert_eq!(time.last_update(), None);
assert_eq!(time.relative_speed(), 1.0);
assert_eq!(time.delta(), Duration::ZERO);
assert_eq!(time.delta_seconds(), 0.0);
assert_eq!(time.delta_seconds_f64(), 0.0);
assert_eq!(time.raw_delta(), Duration::ZERO);
assert_eq!(time.raw_delta_seconds(), 0.0);
assert_eq!(time.raw_delta_seconds_f64(), 0.0);
assert_eq!(time.elapsed(), Duration::ZERO);
assert_eq!(time.elapsed_seconds(), 0.0);
assert_eq!(time.elapsed_seconds_f64(), 0.0);
assert_eq!(time.raw_elapsed(), Duration::ZERO);
assert_eq!(time.raw_elapsed_seconds(), 0.0);
assert_eq!(time.raw_elapsed_seconds_f64(), 0.0);
let first_update_instant = Instant::now();
time.update_with_instant(first_update_instant);
assert_eq!(time.startup(), start_instant);
assert_eq!(time.first_update(), Some(first_update_instant));
assert_eq!(time.last_update(), Some(first_update_instant));
assert_eq!(time.relative_speed(), 1.0);
assert_eq!(time.delta(), Duration::ZERO);
assert_eq!(time.delta_seconds(), 0.0);
assert_eq!(time.delta_seconds_f64(), 0.0);
assert_eq!(time.raw_delta(), Duration::ZERO);
assert_eq!(time.raw_delta_seconds(), 0.0);
assert_eq!(time.raw_delta_seconds_f64(), 0.0);
assert_eq!(time.elapsed(), first_update_instant - start_instant,);
assert_eq!(
time.elapsed_seconds(),
(first_update_instant - start_instant).as_secs_f32(),
);
assert_eq!(
time.elapsed_seconds_f64(),
(first_update_instant - start_instant).as_secs_f64(),
);
assert_eq!(time.raw_elapsed(), first_update_instant - start_instant,);
assert_eq!(
time.raw_elapsed_seconds(),
(first_update_instant - start_instant).as_secs_f32(),
);
assert_eq!(
time.raw_elapsed_seconds_f64(),
(first_update_instant - start_instant).as_secs_f64(),
);
let second_update_instant = Instant::now();
time.update_with_instant(second_update_instant);
assert_eq!(time.startup(), start_instant);
assert_eq!(time.first_update(), Some(first_update_instant));
assert_eq!(time.last_update(), Some(second_update_instant));
assert_eq!(time.relative_speed(), 1.0);
assert_eq!(time.delta(), second_update_instant - first_update_instant);
assert_eq!(
time.delta_seconds(),
(second_update_instant - first_update_instant).as_secs_f32(),
);
assert_eq!(
time.delta_seconds_f64(),
(second_update_instant - first_update_instant).as_secs_f64(),
);
assert_eq!(
time.raw_delta(),
second_update_instant - first_update_instant,
);
assert_eq!(
time.raw_delta_seconds(),
(second_update_instant - first_update_instant).as_secs_f32(),
);
assert_eq!(
time.raw_delta_seconds_f64(),
(second_update_instant - first_update_instant).as_secs_f64(),
);
assert_eq!(time.elapsed(), second_update_instant - start_instant,);
assert_eq!(
time.elapsed_seconds(),
(second_update_instant - start_instant).as_secs_f32(),
);
assert_eq!(
time.elapsed_seconds_f64(),
(second_update_instant - start_instant).as_secs_f64(),
);
assert_eq!(time.raw_elapsed(), second_update_instant - start_instant,);
assert_eq!(
time.raw_elapsed_seconds(),
(second_update_instant - start_instant).as_secs_f32(),
);
assert_eq!(
time.raw_elapsed_seconds_f64(),
(second_update_instant - start_instant).as_secs_f64(),
);
}
#[test]
fn wrapping_test() {
let start_instant = Instant::now();
let mut time = Time {
startup: start_instant,
wrap_period: Duration::from_secs(3),
..Default::default()
};
assert_eq!(time.elapsed_seconds_wrapped(), 0.0);
time.update_with_instant(start_instant + Duration::from_secs(1));
assert_float_eq(time.elapsed_seconds_wrapped(), 1.0);
time.update_with_instant(start_instant + Duration::from_secs(2));
assert_float_eq(time.elapsed_seconds_wrapped(), 2.0);
time.update_with_instant(start_instant + Duration::from_secs(3));
assert_float_eq(time.elapsed_seconds_wrapped(), 0.0);
time.update_with_instant(start_instant + Duration::from_secs(4));
assert_float_eq(time.elapsed_seconds_wrapped(), 1.0);
}
#[test]
#[cfg(not(all(target_arch = "aarch64", target_vendor = "apple")))]
fn relative_speed_test() {
let start_instant = Instant::now();
let mut time = Time::new(start_instant);
let first_update_instant = Instant::now();
time.update_with_instant(first_update_instant);
let second_update_instant = Instant::now();
time.update_with_instant(second_update_instant);
assert_eq!(time.startup(), start_instant);
assert_eq!(time.first_update(), Some(first_update_instant));
assert_eq!(time.last_update(), Some(second_update_instant));
assert_eq!(time.relative_speed(), 1.0);
assert_eq!(time.delta(), second_update_instant - first_update_instant);
assert_eq!(
time.delta_seconds(),
(second_update_instant - first_update_instant).as_secs_f32(),
);
assert_eq!(
time.delta_seconds_f64(),
(second_update_instant - first_update_instant).as_secs_f64(),
);
assert_eq!(
time.raw_delta(),
second_update_instant - first_update_instant,
);
assert_eq!(
time.raw_delta_seconds(),
(second_update_instant - first_update_instant).as_secs_f32(),
);
assert_eq!(
time.raw_delta_seconds_f64(),
(second_update_instant - first_update_instant).as_secs_f64(),
);
assert_eq!(time.elapsed(), second_update_instant - start_instant,);
assert_eq!(
time.elapsed_seconds(),
(second_update_instant - start_instant).as_secs_f32(),
);
assert_eq!(
time.elapsed_seconds_f64(),
(second_update_instant - start_instant).as_secs_f64(),
);
assert_eq!(time.raw_elapsed(), second_update_instant - start_instant,);
assert_eq!(
time.raw_elapsed_seconds(),
(second_update_instant - start_instant).as_secs_f32(),
);
assert_eq!(
time.raw_elapsed_seconds_f64(),
(second_update_instant - start_instant).as_secs_f64(),
);
time.set_relative_speed(2.0);
let elapsed = Duration::from_secs(1);
let third_update_instant = second_update_instant + elapsed;
time.update_with_instant(third_update_instant);
assert_eq!(time.startup(), start_instant);
assert_eq!(time.first_update(), Some(first_update_instant));
assert_eq!(time.last_update(), Some(third_update_instant));
assert_eq!(time.relative_speed(), 2.0);
assert_eq!(time.delta(), elapsed.mul_f32(2.0));
assert_eq!(time.delta_seconds(), elapsed.mul_f32(2.0).as_secs_f32());
assert_eq!(time.delta_seconds_f64(), elapsed.mul_f32(2.0).as_secs_f64());
assert_eq!(time.raw_delta(), elapsed);
assert_eq!(time.raw_delta_seconds(), elapsed.as_secs_f32());
assert_eq!(time.raw_delta_seconds_f64(), elapsed.as_secs_f64());
assert_eq!(
time.elapsed(),
second_update_instant - start_instant + elapsed.mul_f32(2.0),
);
assert_eq!(
time.elapsed_seconds(),
(second_update_instant - start_instant + elapsed.mul_f32(2.0)).as_secs_f32(),
);
assert_eq!(
time.elapsed_seconds_f64(),
(second_update_instant - start_instant + elapsed.mul_f32(2.0)).as_secs_f64(),
);
assert_eq!(
time.raw_elapsed(),
second_update_instant - start_instant + elapsed,
);
assert_eq!(
time.raw_elapsed_seconds(),
(second_update_instant - start_instant + elapsed).as_secs_f32(),
);
assert_eq!(
time.raw_elapsed_seconds_f64(),
(second_update_instant - start_instant + elapsed).as_secs_f64(),
);
}
#[test]
#[cfg(not(all(target_arch = "aarch64", target_vendor = "apple")))]
fn pause_test() {
let start_instant = Instant::now();
let mut time = Time::new(start_instant);
let first_update_instant = Instant::now();
time.update_with_instant(first_update_instant);
assert!(!time.is_paused());
assert_eq!(time.relative_speed(), 1.0);
time.pause();
assert!(time.is_paused());
assert_eq!(time.relative_speed(), 0.0);
let second_update_instant = Instant::now();
time.update_with_instant(second_update_instant);
assert_eq!(time.startup(), start_instant);
assert_eq!(time.first_update(), Some(first_update_instant));
assert_eq!(time.last_update(), Some(second_update_instant));
assert_eq!(time.delta(), Duration::ZERO);
assert_eq!(
time.raw_delta(),
second_update_instant - first_update_instant,
);
assert_eq!(time.elapsed(), first_update_instant - start_instant);
assert_eq!(time.raw_elapsed(), second_update_instant - start_instant);
time.unpause();
assert!(!time.is_paused());
assert_eq!(time.relative_speed(), 1.0);
let third_update_instant = Instant::now();
time.update_with_instant(third_update_instant);
assert_eq!(time.startup(), start_instant);
assert_eq!(time.first_update(), Some(first_update_instant));
assert_eq!(time.last_update(), Some(third_update_instant));
assert_eq!(time.delta(), third_update_instant - second_update_instant);
assert_eq!(
time.raw_delta(),
third_update_instant - second_update_instant,
);
assert_eq!(
time.elapsed(),
(third_update_instant - second_update_instant) + (first_update_instant - start_instant),
);
assert_eq!(time.raw_elapsed(), third_update_instant - start_instant);
}
}