From f9da443880a61d45754f5f0370d320d96451a8e5 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Sat, 6 Nov 2021 14:48:11 -0700
Subject: [PATCH] Removed live_real_ fns, changed real_ to raw_, added
 Time.fixedTime equiv. with tests

When comparing dilated and raw delta/elapsed time measurements, be aware that `relative_speed` != 1.0 may have rounding errors, so the ratios might not be perfect.
---
 crates/bevy_core/src/time/fixed_timestep.rs |  54 +--
 crates/bevy_core/src/time/time.rs           | 369 +++++++++++++-------
 examples/scene/scene.rs                     |   4 +-
 examples/wasm/winit_wasm.rs                 |   2 +-
 4 files changed, 270 insertions(+), 159 deletions(-)

diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 09f77b684af223..b98cb392b88ac3 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -1,39 +1,48 @@
 use bevy_ecs::{schedule::ShouldRun, system::ResMut};
-
 use bevy_utils::Duration;
 
+use crate::Time;
+
 #[derive(Debug, Clone)]
 pub struct FixedTimestepState {
     time: Duration,
-    steps: usize,
+    steps: u32,
 }
 
 impl Default for FixedTimestepState {
     fn default() -> Self {
         Self {
-            time: Duration::from_secs(0),
+            time: Duration::ZERO,
             steps: 0,
         }
     }
 }
 
 impl FixedTimestepState {
-    pub fn new(time: Duration, steps: usize) -> Self {
+    pub fn new(time: Duration, steps: u32) -> Self {
         Self { time, steps }
     }
 
     /// The number of accrued steps.
     #[inline]
-    pub fn steps(&self) -> usize {
+    pub fn steps(&self) -> u32 {
         self.steps
     }
 
-    /// The amount of time accrued toward the next step as [`Duration`].
+    /// The amount of time accrued toward new steps as [`Duration`].
     #[inline]
-    pub fn overstep(&self) -> Duration {
+    pub fn time(&self) -> Duration {
         self.time
     }
 
+    pub fn set_steps(&mut self, steps: u32) {
+        self.steps = steps;
+    }
+
+    pub fn set_time(&mut self, time: Duration) {
+        self.time = time;
+    }
+
     /// The amount of time accrued toward the next step as [`f32`] % of timestep.
     pub fn overstep_percentage(&self, timestep: Duration) -> f32 {
         self.time.as_secs_f32() / timestep.as_secs_f32()
@@ -44,7 +53,7 @@ impl FixedTimestepState {
         self.time.as_secs_f64() / timestep.as_secs_f64()
     }
 
-    /// Add to the stored time, then convert into as many steps as possible.
+    /// Add to the accrued time, then convert into as many steps as possible.
     pub fn add_time(&mut self, time: Duration, timestep: Duration) {
         self.time += time;
         while self.time >= timestep {
@@ -54,22 +63,14 @@ impl FixedTimestepState {
     }
 
     /// Consume a stored step (if any).
-    pub fn sub_step(&mut self) -> Option<usize> {
+    pub fn sub_step(&mut self) -> Option<u32> {
         let remaining = self.steps.checked_sub(1);
         self.steps = self.steps.saturating_sub(1);
         remaining
     }
 
-    pub fn set_time(&mut self, time: Duration) {
-        self.time = time;
-    }
-
-    pub fn set_steps(&mut self, steps: usize) {
-        self.steps = steps;
-    }
-
     pub fn reset(&mut self) {
-        self.time = Duration::from_secs(0);
+        self.time = Duration::ZERO;
         self.steps = 0;
     }
 }
@@ -77,8 +78,9 @@ impl FixedTimestepState {
 pub struct FixedTimestep;
 
 impl FixedTimestep {
-    pub fn step(mut accumulator: ResMut<FixedTimestepState>) -> ShouldRun {
+    pub fn step(mut time: ResMut<Time>, mut accumulator: ResMut<FixedTimestepState>) -> ShouldRun {
         if accumulator.sub_step().is_some() {
+            time.advance_step();
             ShouldRun::YesAndCheckAgain
         } else {
             ShouldRun::No
@@ -96,38 +98,38 @@ mod tests {
         let mut accumulator = FixedTimestepState::default();
 
         assert_eq!(accumulator.steps(), 0);
-        assert_eq!(accumulator.overstep(), Duration::from_secs(0));
+        assert_eq!(accumulator.time(), Duration::ZERO);
 
         accumulator.add_time(Duration::from_secs(5), Duration::from_secs(1));
 
         assert_eq!(accumulator.steps(), 5);
-        assert_eq!(accumulator.overstep(), Duration::from_secs(0));
+        assert_eq!(accumulator.time(), Duration::ZERO);
 
         let steps_remaining = accumulator.sub_step();
 
         assert_eq!(steps_remaining, Some(4));
         assert_eq!(accumulator.steps(), 4);
-        assert_eq!(accumulator.overstep(), Duration::from_secs(0));
+        assert_eq!(accumulator.time(), Duration::ZERO);
 
         accumulator.set_time(Duration::from_secs(1));
 
         assert_eq!(accumulator.steps(), 4);
-        assert_eq!(accumulator.overstep(), Duration::from_secs(1));
+        assert_eq!(accumulator.time(), Duration::from_secs(1));
 
         accumulator.set_steps(12);
 
         assert_eq!(accumulator.steps(), 12);
-        assert_eq!(accumulator.overstep(), Duration::from_secs(1));
+        assert_eq!(accumulator.time(), Duration::from_secs(1));
 
         accumulator.reset();
 
         assert_eq!(accumulator.steps(), 0);
-        assert_eq!(accumulator.overstep(), Duration::from_secs(0));
+        assert_eq!(accumulator.time(), Duration::ZERO);
 
         let steps_remaining = accumulator.sub_step();
 
         assert_eq!(steps_remaining, None);
         assert_eq!(accumulator.steps(), 0);
-        assert_eq!(accumulator.overstep(), Duration::from_secs(0));
+        assert_eq!(accumulator.time(), Duration::ZERO);
     }
 }
diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index d6e133e0433bb9..a65642f584ceb4 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -9,33 +9,41 @@ pub struct Time {
     delta: Duration,
     delta_seconds: f32,
     delta_seconds_f64: f64,
-    fixed_delta: Duration,
-    fixed_delta_seconds: f32,
-    fixed_delta_seconds_f64: f64,
+    raw_delta: Duration,
+    raw_delta_seconds: f32,
+    raw_delta_seconds_f64: f64,
     relative_speed: f32,
-    time_since_startup: Duration,
+    elapsed_since_startup: Duration,
     first_update: Option<Instant>,
     last_update: Option<Instant>,
     startup: Instant,
+    fixed_delta: Duration,
+    fixed_delta_seconds: f32,
+    fixed_delta_seconds_f64: f64,
+    fixed_elapsed_since_startup: Duration,
 }
 
 impl Default for Time {
     fn default() -> Self {
         // 60Hz is a popular number, but it can't be expressed as an exact float.
-        // Power-of-two frequencies (i.e. 32Hz, 64Hz, 128Hz) have better numeric stability.
+        // Powers of two (i.e. 32Hz, 64Hz, 128Hz) are better for numerical integration.
         let fixed_delta = Duration::from_secs_f32(1.0 / 64.0);
         Self {
-            delta: Duration::from_secs(0),
+            delta: Duration::ZERO,
             delta_seconds: 0.0,
             delta_seconds_f64: 0.0,
-            fixed_delta,
-            fixed_delta_seconds: fixed_delta.as_secs_f32(),
-            fixed_delta_seconds_f64: fixed_delta.as_secs_f64(),
+            raw_delta: Duration::ZERO,
+            raw_delta_seconds: 0.0,
+            raw_delta_seconds_f64: 0.0,
             relative_speed: 1.0,
-            time_since_startup: Duration::from_secs(0),
+            elapsed_since_startup: Duration::ZERO,
             first_update: None,
             last_update: None,
             startup: Instant::now(),
+            fixed_delta,
+            fixed_delta_seconds: fixed_delta.as_secs_f32(),
+            fixed_delta_seconds_f64: fixed_delta.as_secs_f64(),
+            fixed_elapsed_since_startup: Duration::ZERO,
         }
     }
 }
@@ -48,93 +56,146 @@ impl Time {
 
     pub(crate) fn update_with_instant(&mut self, instant: Instant) {
         if let Some(last_update) = self.last_update {
-            self.delta = instant - last_update;
+            self.raw_delta = instant - last_update;
+            self.raw_delta_seconds = self.raw_delta.as_secs_f32();
+            self.raw_delta_seconds_f64 = self.raw_delta.as_secs_f64();
+
+            if self.relative_speed != 1.0 {
+                // just to be safe
+                self.delta = self.raw_delta.mul_f64(self.relative_speed_f64());
+            } else {
+                self.delta = self.raw_delta;
+            }
+
             self.delta_seconds = self.delta.as_secs_f32();
             self.delta_seconds_f64 = self.delta.as_secs_f64();
-            self.time_since_startup += self.delta.mul_f32(self.relative_speed);
+            self.elapsed_since_startup += self.delta;
         } else {
             self.first_update = Some(instant);
-            self.time_since_startup += (instant - self.startup).mul_f32(self.relative_speed);
+
+            if self.relative_speed != 1.0 {
+                // just to be safe
+                self.elapsed_since_startup +=
+                    (instant - self.startup).mul_f64(self.relative_speed as f64);
+            } else {
+                self.elapsed_since_startup += instant - self.startup;
+            }
         }
 
         self.last_update = Some(instant);
     }
 
-    /// The delta between the current and last update, as a [`Duration`].
+    pub(crate) fn advance_step(&mut self) {
+        self.fixed_elapsed_since_startup += self.fixed_delta;
+    }
+
+    /// The time since the last update, as a [`Duration`].
+    /// Affected by [`Time::relative_speed`].
     #[inline]
     pub fn delta(&self) -> Duration {
         self.delta
     }
 
-    /// The delta between the current and last update, as [`f32`] seconds
+    /// The time since the last update, as [`f32`] seconds.
+    /// Affected by [`Time::relative_speed`].
     #[inline]
     pub fn delta_seconds(&self) -> f32 {
         self.delta_seconds
     }
 
-    /// The delta between the current and last update, as [`f64`] seconds.
+    /// The time since the last update, as [`f64`] seconds.
+    /// Affected by [`Time::relative_speed`].
     #[inline]
     pub fn delta_seconds_f64(&self) -> f64 {
         self.delta_seconds_f64
     }
 
-    /// The *virtual* delta between each fixed update step, as a [`Duration`].
-    /// Note that the true delta between fixed update steps varies.
+    /// The exact CPU time since the last update, as a [`Duration`].
+    /// **Not** affected by [`Time::relative_speed`].
+    #[inline]
+    pub fn raw_delta(&self) -> Duration {
+        self.raw_delta
+    }
+
+    /// The exact CPU time since the last update, as [`f32`] seconds.
+    /// **Not** affected by [`Time::relative_speed`].
+    #[inline]
+    pub fn raw_delta_seconds(&self) -> f32 {
+        self.raw_delta_seconds
+    }
+
+    /// The exact CPU time since the last update, as [`f64`] seconds.
+    /// **Not** affected by [`Time::relative_speed`].
+    #[inline]
+    pub fn raw_delta_seconds_f64(&self) -> f64 {
+        self.raw_delta_seconds_f64
+    }
+
+    /// The reciprocal of the rate set by [`Time::set_steps_per_second`], as a [`Duration`].
+    ///
+    /// A fixed timestep only guarantees that N steps run for each second of elapsed time, not that
+    /// one step runs every [`Time::fixed_delta`] seconds. The exact CPU time between steps depends
+    /// on the frame rate, so use [`Time::fixed_delta`] in systems for consistent behavior.
     #[inline]
     pub fn fixed_delta(&self) -> Duration {
         self.fixed_delta
     }
 
-    /// The *virtual* delta between each fixed update step, as [`f32`] seconds.
-    /// Note that the true delta between fixed update steps varies.
+    /// The reciprocal of the rate set by [`Time::set_steps_per_second`], as [`f32`] seconds.
+    ///
+    /// A fixed timestep only guarantees that N steps run for each second of elapsed time, not that
+    /// one step runs every [`Time::fixed_delta`] seconds. The exact CPU time between steps depends
+    /// on the frame rate, so use [`Time::fixed_delta`] in systems for consistent behavior.
     #[inline]
     pub fn fixed_delta_seconds(&self) -> f32 {
         self.fixed_delta_seconds
     }
 
-    /// The *virtual* delta between each fixed update step, as [`f64`] seconds.
-    /// Note that the true delta between fixed update steps varies.
+    /// The reciprocal of the rate set by [`Time::set_steps_per_second`], as [`f64`] seconds.
+    ///
+    /// A fixed timestep only guarantees that N steps run for each second of elapsed time, not that
+    /// one step runs every [`Time::fixed_delta`] seconds. The exact CPU time between steps depends
+    /// on the frame rate, so use [`Time::fixed_delta`] in systems for consistent behavior.
     #[inline]
     pub fn fixed_delta_seconds_f64(&self) -> f64 {
         self.fixed_delta_seconds_f64
     }
 
-    /// Changes [`Time::fixed_delta`]. Users are strongly cautioned against modifying
-    /// the step rate this way, except during startup.
-    /// Prefer [`Time::set_relative_speed`] to ensure that consumers of
-    /// [`Time::fixed_delta`] produce consistent behavior.
-    pub fn set_steps_per_second(&mut self, steps: f32) {
-        self.fixed_delta = Duration::from_secs_f32(1.0 / steps);
+    /// Change the step Hz (changes [`Time::fixed_delta`]). Users are strongly cautioned against
+    /// changing this outside of startup. Use [`Time::set_relative_speed`] to ensure that systems
+    /// using [`fixed_delta`] behave consistently.
+    pub fn set_steps_per_second(&mut self, rate: f32) {
+        self.fixed_delta = Duration::from_secs_f32(1.0 / rate);
         self.fixed_delta_seconds = self.fixed_delta.as_secs_f32();
         self.fixed_delta_seconds_f64 = self.fixed_delta.as_secs_f64();
     }
 
-    /// The rate that time advances relative to the real world, as [`f32`].
+    /// The rate that time advances relative to CPU time, as [`f32`]. 1.0 by default.
     #[inline]
     pub fn relative_speed(&self) -> f32 {
         self.relative_speed
     }
 
-    /// The rate that time advances relative to the real world, as [`f64`].
+    /// The rate that time advances relative to CPU time, as [`f64`]. 1.0 by default.
     #[inline]
     pub fn relative_speed_f64(&self) -> f64 {
         self.relative_speed as f64
     }
 
-    /// Set rate time advances relative to the real world. Must be >= 0.0.
+    /// Set the rate that time advances relative to CPU time. Must be >= 0.0.
     #[inline]
     pub fn set_relative_speed(&mut self, relative_speed: f32) {
-        assert!(relative_speed >= 0.0);
+        assert!((relative_speed >= 0.0) && relative_speed.is_finite());
         self.relative_speed = relative_speed;
     }
 
-    /// The ['Instant'] when [`Time::update`] was first called, if it exists.
+    /// The [`Instant`] when [`Time::update`] was first called, if it exists.
     #[inline]
     pub fn first_update(&self) -> Option<Instant> {
         self.first_update
     }
 
-    /// The ['Instant'] when [`Time::update`] was last called, if it exists.
+    /// The [`Instant`] when [`Time::update`] was last called, if it exists.
     #[inline]
     pub fn last_update(&self) -> Option<Instant> {
         self.last_update
@@ -146,72 +207,75 @@ impl Time {
         self.startup
     }
 
-    /// The time since startup, as [`Duration`]. Affected by speed multiplier.
-    /// Sampled during the latest update.
+    /// The time since startup, as [`Duration`].
+    /// Advances by [`Time::delta`] each update.
     #[inline]
-    pub fn time_since_startup(&self) -> Duration {
-        self.time_since_startup
+    pub fn elapsed_since_startup(&self) -> Duration {
+        self.elapsed_since_startup
     }
 
-    /// The time since startup, as [`f32`] seconds. Affected by speed multiplier.
-    /// Sampled during the latest update.
+    /// The time since startup, as [`f32`] seconds.
+    /// Advances by [`Time::delta`] each update.
     #[inline]
     pub fn seconds_since_startup(&self) -> f32 {
-        self.time_since_startup().as_secs_f32()
+        self.elapsed_since_startup().as_secs_f32()
     }
 
-    /// The time since startup, as [`f64`] seconds. Affected by speed multiplier.
-    /// Sampled during the latest update.
+    /// The time since startup, as [`f64`] seconds.
+    /// Advances by [`Time::delta`] each update.
     #[inline]
     pub fn seconds_since_startup_f64(&self) -> f64 {
-        self.time_since_startup().as_secs_f64()
+        self.elapsed_since_startup().as_secs_f64()
     }
 
-    /// The time since startup, as [`Duration`]. Unaffected by speed multiplier.
-    /// Sampled during the latest update.
-    pub fn real_time_since_startup(&self) -> Duration {
+    /// The exact CPU time since startup, as [`Duration`].
+    /// Advances by [`Time::raw_delta`] each update.
+    pub fn raw_elapsed_since_startup(&self) -> Duration {
         self.last_update.unwrap_or(self.startup) - self.startup
     }
 
-    /// The time since startup, as [`f32`] seconds. Unaffected by speed multiplier.
-    /// Sampled during the latest update.
+    /// The exact CPU time since startup, as [`f32`] seconds.
+    /// Advances by [`Time::raw_delta`] each update.
     #[inline]
-    pub fn real_seconds_since_startup(&self) -> f32 {
-        self.real_time_since_startup().as_secs_f32()
+    pub fn raw_seconds_since_startup(&self) -> f32 {
+        self.raw_elapsed_since_startup().as_secs_f32()
     }
 
-    /// The time since startup, as [`f64`] seconds. Unaffected by speed multiplier.
-    /// Sampled during the latest update.
+    /// The exact CPU time since startup, as [`f64`] seconds.
+    /// Advances by [`Time::raw_delta`] each update.
     #[inline]
-    pub fn real_seconds_since_startup_f64(&self) -> f64 {
-        self.real_time_since_startup().as_secs_f64()
+    pub fn raw_seconds_since_startup_f64(&self) -> f64 {
+        self.raw_elapsed_since_startup().as_secs_f64()
     }
 
-    /// The time since startup, as [`Duration`]. Unaffected by speed multiplier.
-    /// Sampled at call.
-    pub fn live_real_time_since_startup(&self) -> Duration {
-        Instant::now() - self.startup
+    /// The time since startup, as [`Duration`].
+    /// Advances by [`Time::fixed_delta`] each step.
+    #[inline]
+    pub fn fixed_elapsed_since_startup(&self) -> Duration {
+        // NOTE: actually lags behind time.elapsed_since_startup()
+        // because time.first_update() - time.startup() isn't counted
+        self.fixed_elapsed_since_startup
     }
 
-    /// The time since startup, as [`f32`] seconds. Unaffected by speed multiplier.
-    /// Sampled at call.
+    /// The time since startup, as [`f32`] seconds.
+    /// Advances by [`Time::fixed_delta`] each step.
     #[inline]
-    pub fn live_real_seconds_since_startup(&self) -> f32 {
-        self.live_real_time_since_startup().as_secs_f32()
+    pub fn fixed_seconds_since_startup(&self) -> f32 {
+        self.fixed_elapsed_since_startup().as_secs_f32()
     }
 
-    /// The time since startup, as [`f64`] seconds. Unaffected by speed multiplier.
-    /// Sampled at call.
+    /// The time since startup, as [`f64`] seconds.
+    /// Advances by [`Time::fixed_delta`] each step.
     #[inline]
-    pub fn live_real_seconds_since_startup_f64(&self) -> f64 {
-        self.live_real_time_since_startup().as_secs_f64()
+    pub fn fixed_seconds_since_startup_f64(&self) -> f64 {
+        self.fixed_elapsed_since_startup().as_secs_f64()
     }
 }
 
 pub(crate) fn time_system(mut time: ResMut<Time>, mut accumulator: ResMut<FixedTimestepState>) {
     time.update();
     accumulator.add_time(
-        time.delta().mul_f32(time.relative_speed()),
+        time.delta().mul_f64(time.relative_speed_f64()),
         time.fixed_delta(),
     );
 }
@@ -220,6 +284,7 @@ pub(crate) fn time_system(mut time: ResMut<Time>, mut accumulator: ResMut<FixedT
 #[allow(clippy::float_cmp)]
 mod tests {
     use super::Time;
+    use crate::FixedTimestepState;
     use bevy_utils::{Duration, Instant};
 
     #[test]
@@ -233,125 +298,169 @@ mod tests {
         };
 
         // Ensure `time` was constructed correctly.
-        assert_eq!(time.delta(), Duration::from_secs(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.delta(), Duration::ZERO);
         assert_eq!(time.delta_seconds(), 0.0);
         assert_eq!(time.delta_seconds_f64(), 0.0);
-
-        // Fixed delta is fixed.
-        assert_eq!(time.fixed_delta(), Duration::from_secs_f32(1.0 / 64.0));
-        assert_eq!(time.fixed_delta_seconds(), time.fixed_delta().as_secs_f32());
-        assert_eq!(
-            time.fixed_delta_seconds_f64(),
-            time.fixed_delta().as_secs_f64()
-        );
-
-        // Sanity check.
         assert_eq!(time.first_update(), None);
         assert_eq!(time.last_update(), None);
         assert_eq!(time.startup(), start_instant);
         assert_eq!(time.relative_speed(), 1.0);
-        assert_eq!(time.time_since_startup(), Duration::from_secs(0));
-        assert_eq!(time.real_time_since_startup(), Duration::from_secs(0));
+        assert_eq!(time.elapsed_since_startup(), Duration::ZERO);
+        assert_eq!(time.raw_elapsed_since_startup(), Duration::ZERO);
 
         // Update `time` and check results.
         // The first update to `time` normally happens before other systems have run,
-        // so delta isn't "ready" until the second update.
+        // so the first delta doesn't appear until the second update.
         let first_update_instant = Instant::now();
-
         time.update_with_instant(first_update_instant);
 
-        assert_eq!(time.delta(), Duration::from_secs(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.delta(), Duration::ZERO);
         assert_eq!(time.delta_seconds(), 0.0);
         assert_eq!(time.delta_seconds_f64(), 0.0);
-
-        // Fixed delta is still fixed.
-        assert_eq!(time.fixed_delta(), Duration::from_secs_f32(1.0 / 64.0));
-        assert_eq!(time.fixed_delta_seconds(), time.fixed_delta().as_secs_f32());
-        assert_eq!(
-            time.fixed_delta_seconds_f64(),
-            time.fixed_delta().as_secs_f64()
-        );
-
-        // Sanity check.
         assert_eq!(time.first_update(), Some(first_update_instant));
         assert_eq!(time.last_update(), Some(first_update_instant));
         assert_eq!(time.startup(), start_instant);
         assert_eq!(time.relative_speed(), 1.0);
         assert_eq!(
-            time.time_since_startup(),
+            time.elapsed_since_startup(),
             first_update_instant - start_instant
         );
         assert_eq!(
-            time.real_time_since_startup(),
+            time.raw_elapsed_since_startup(),
             first_update_instant - start_instant
         );
 
         // Update `time` again and check results.
         // At this point its safe to use time.delta().
         let second_update_instant = Instant::now();
-
         time.update_with_instant(second_update_instant);
 
+        assert_eq!(
+            time.raw_delta(),
+            second_update_instant - first_update_instant
+        );
+        assert_eq!(time.raw_delta_seconds(), time.raw_delta().as_secs_f32());
+        assert_eq!(time.raw_delta_seconds_f64(), time.raw_delta().as_secs_f64());
         assert_eq!(time.delta(), second_update_instant - first_update_instant);
         assert_eq!(time.delta_seconds(), time.delta().as_secs_f32());
         assert_eq!(time.delta_seconds_f64(), time.delta().as_secs_f64());
-
-        // Fixed delta is STILL fixed.
-        assert_eq!(time.fixed_delta(), Duration::from_secs_f32(1.0 / 64.0));
-        assert_eq!(time.fixed_delta_seconds(), time.fixed_delta().as_secs_f32());
-        assert_eq!(
-            time.fixed_delta_seconds_f64(),
-            time.fixed_delta().as_secs_f64()
-        );
-
-        // Sanity check.
         assert_eq!(time.first_update(), Some(first_update_instant));
         assert_eq!(time.last_update(), Some(second_update_instant));
         assert_eq!(time.startup(), start_instant);
         assert_eq!(time.relative_speed(), 1.0);
         assert_eq!(
-            time.time_since_startup(),
+            time.elapsed_since_startup(),
             second_update_instant - start_instant
         );
         assert_eq!(
-            time.real_time_since_startup(),
+            time.raw_elapsed_since_startup(),
             second_update_instant - start_instant
         );
 
-        // Make app time advance at 2x the rate of real world time.
+        // Make app time advance at 2x the rate of the system clock.
         time.set_relative_speed(2.0);
-
         // Update `time` again 1 second later.
-        let third_update_instant = second_update_instant + Duration::from_secs(1);
-
+        let elapsed = Duration::from_secs(1);
+        let third_update_instant = second_update_instant + elapsed;
         time.update_with_instant(third_update_instant);
 
-        assert_eq!(time.delta(), third_update_instant - second_update_instant);
+        // Since app is advancing 2x the system clock, expect elapsed time
+        // to have advanced by twice the amount of raw CPU time.
+        assert_eq!(time.relative_speed(), 2.0);
+        assert_eq!(time.raw_delta(), elapsed);
+        assert_eq!(time.raw_delta_seconds(), time.raw_delta().as_secs_f32());
+        assert_eq!(time.raw_delta_seconds_f64(), time.raw_delta().as_secs_f64());
+        assert_eq!(time.delta(), elapsed.mul_f32(2.0));
         assert_eq!(time.delta_seconds(), time.delta().as_secs_f32());
         assert_eq!(time.delta_seconds_f64(), time.delta().as_secs_f64());
-
-        // Fixed delta is still fixed.
-        assert_eq!(time.fixed_delta(), Duration::from_secs_f32(1.0 / 64.0));
-        assert_eq!(time.fixed_delta_seconds(), time.fixed_delta().as_secs_f32());
-        assert_eq!(
-            time.fixed_delta_seconds_f64(),
-            time.fixed_delta().as_secs_f64()
-        );
-
-        // Sanity check.
         assert_eq!(time.first_update(), Some(first_update_instant));
         assert_eq!(time.last_update(), Some(third_update_instant));
         assert_eq!(time.startup(), start_instant);
+        assert_eq!(
+            time.elapsed_since_startup(),
+            second_update_instant - start_instant + elapsed.mul_f32(2.0)
+        );
+        assert_eq!(
+            time.raw_elapsed_since_startup(),
+            second_update_instant - start_instant + elapsed
+        );
+    }
 
-        // App is advancing 2x real time speed, so app time should have advanced by 2 seconds.
-        assert_eq!(time.relative_speed(), 2.0);
+    #[test]
+    fn fixed_timestep_test() {
+        let start_instant = Instant::now();
+
+        // Create a `Time` for testing.
+        let mut time = Time {
+            startup: start_instant,
+            ..Default::default()
+        };
+
+        let fixed_delta = time.fixed_delta();
+
+        // Create a `FixedTimestep for testing.
+        let mut accumulator = FixedTimestepState::new(Duration::ZERO, 0);
+
+        // Get the first update out of the way, so that
+        // time.delta() will get a nonzero value next time.
+        let first_update_instant = Instant::now();
+        time.update_with_instant(first_update_instant);
+
+        // Confirm that fixed delta didn't change on its own.
+        assert_eq!(time.fixed_delta(), fixed_delta);
+        assert_eq!(time.fixed_delta_seconds(), fixed_delta.as_secs_f32());
+        assert_eq!(time.fixed_delta_seconds_f64(), fixed_delta.as_secs_f64());
+
+        // Run for 10.5x the timestep.
+        let ten = time.fixed_delta() * 10;
+        let half = time.fixed_delta() / 2;
+        let second_update_instant = first_update_instant + ten + half;
+        time.update_with_instant(second_update_instant);
+        accumulator.add_time(
+            time.delta().mul_f64(time.relative_speed_f64()),
+            time.fixed_delta(),
+        );
+
+        // Confirm that 10.5 steps have accumulated.
+        assert_eq!(time.raw_delta(), ten + half);
+        assert_eq!(time.delta(), time.raw_delta());
+        assert_eq!(accumulator.steps(), 10);
+        assert_eq!(accumulator.time(), half);
+
+        assert_eq!(time.fixed_elapsed_since_startup(), Duration::ZERO);
         assert_eq!(
-            time.time_since_startup(),
-            second_update_instant - start_instant + Duration::from_secs(2)
+            time.fixed_seconds_since_startup(),
+            Duration::ZERO.as_secs_f32()
         );
         assert_eq!(
-            time.real_time_since_startup(),
-            second_update_instant - start_instant + Duration::from_secs(1)
+            time.fixed_seconds_since_startup_f64(),
+            Duration::ZERO.as_secs_f64()
         );
+
+        // Consume accumulated steps and advanced the fixed time clock.
+        while accumulator.sub_step().is_some() {
+            time.advance_step();
+        }
+
+        // Confirm that fixed delta didn't change on its own.
+        assert_eq!(time.fixed_delta(), fixed_delta);
+        assert_eq!(time.fixed_delta_seconds(), fixed_delta.as_secs_f32());
+        assert_eq!(time.fixed_delta_seconds_f64(), fixed_delta.as_secs_f64());
+
+        // Confirm that the fixed time clock has advanced 10 steps worth of time.
+        assert_eq!(time.fixed_elapsed_since_startup(), ten);
+        assert_eq!(time.fixed_seconds_since_startup(), ten.as_secs_f32());
+        assert_eq!(time.fixed_seconds_since_startup_f64(), ten.as_secs_f64());
+
+        // Confirm that the fixed clock lags behind the normal clock by a specific amount.
+        let diff = time.elapsed_since_startup() - time.fixed_elapsed_since_startup();
+        let expected = time.first_update().unwrap() - time.startup() + accumulator.time();
+        assert_eq!(diff, expected);
     }
 }
diff --git a/examples/scene/scene.rs b/examples/scene/scene.rs
index b8f821489451a2..36e740fddf6815 100644
--- a/examples/scene/scene.rs
+++ b/examples/scene/scene.rs
@@ -35,14 +35,14 @@ struct ComponentA {
 struct ComponentB {
     pub value: String,
     #[reflect(ignore)]
-    pub _time_since_startup: Duration,
+    pub _elapsed_since_startup: Duration,
 }
 
 impl FromWorld for ComponentB {
     fn from_world(world: &mut World) -> Self {
         let time = world.get_resource::<Time>().unwrap();
         ComponentB {
-            _time_since_startup: time.time_since_startup(),
+            _elapsed_since_startup: time.elapsed_since_startup(),
             value: "Default Value".to_string(),
         }
     }
diff --git a/examples/wasm/winit_wasm.rs b/examples/wasm/winit_wasm.rs
index f7a4353dfc3f2b..08010dafd3ed1a 100644
--- a/examples/wasm/winit_wasm.rs
+++ b/examples/wasm/winit_wasm.rs
@@ -32,7 +32,7 @@ fn counter(mut state: Local<CounterState>, time: Res<Time>) {
         info!(
             "tick {} @ {:?} [Δ{}]",
             state.count,
-            time.time_since_startup(),
+            time.elapsed_since_startup(),
             time.delta_seconds()
         );
     }