From c25ca37bae08f7adafb27995af7337b458c62956 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Sat, 20 Aug 2022 12:45:24 -0700
Subject: [PATCH] add global time scaling and global time pausing

Co-Authored-By: ira <JustTheCoolDude@gmail.com>
---
 .../src/frame_time_diagnostics_plugin.rs      |   7 +-
 .../src/log_diagnostics_plugin.rs             |   4 +-
 crates/bevy_time/src/time.rs                  | 636 ++++++++++++++++--
 examples/2d/text2d.rs                         |   8 +-
 examples/3d/load_gltf.rs                      |   2 +-
 examples/3d/skybox.rs                         |   6 +-
 examples/3d/spotlight.rs                      |   9 +-
 examples/3d/transparency_3d.rs                |   2 +-
 examples/3d/update_gltf_scene.rs              |   4 +-
 examples/animation/custom_skinned_mesh.rs     |   6 +-
 examples/animation/gltf_skinned_mesh.rs       |   6 +-
 examples/audio/audio_control.rs               |   2 +-
 examples/ecs/component_change_detection.rs    |   4 +-
 examples/ecs/fixed_timestep.rs                |  30 +-
 examples/ecs/hierarchy.rs                     |   4 +-
 examples/ecs/removal_detection.rs             |   2 +-
 examples/ecs/state.rs                         |   2 +-
 examples/ecs/system_sets.rs                   |   2 +-
 examples/games/alien_cake_addict.rs           |   5 +-
 examples/scene/scene.rs                       |   2 +-
 examples/shader/animate_shader.rs             |   6 +-
 examples/tools/scene_viewer.rs                |   2 +-
 examples/ui/text.rs                           |   2 +-
 examples/window/window_settings.rs            |   2 +-
 24 files changed, 625 insertions(+), 130 deletions(-)

diff --git a/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
index 9075cd4284d034..b07a69fc27e55d 100644
--- a/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
@@ -43,13 +43,14 @@ impl FrameTimeDiagnosticsPlugin {
             state.frame_count as f64
         });
 
-        if time.delta_seconds_f64() == 0.0 {
+        let delta_seconds = time.raw_delta_seconds_f64();
+        if delta_seconds == 0.0 {
             return;
         }
 
-        diagnostics.add_measurement(Self::FRAME_TIME, || time.delta_seconds_f64() * 1000.);
+        diagnostics.add_measurement(Self::FRAME_TIME, || delta_seconds * 1000.0);
 
-        diagnostics.add_measurement(Self::FPS, || 1.0 / time.delta_seconds_f64());
+        diagnostics.add_measurement(Self::FPS, || 1.0 / delta_seconds);
     }
 }
 
diff --git a/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
index 947b780725d3f2..26226dc036bcc4 100644
--- a/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
@@ -85,7 +85,7 @@ impl LogDiagnosticsPlugin {
         time: Res<Time>,
         diagnostics: Res<Diagnostics>,
     ) {
-        if state.timer.tick(time.delta()).finished() {
+        if state.timer.tick(time.raw_delta()).finished() {
             if let Some(ref filter) = state.filter {
                 for diagnostic in filter.iter().flat_map(|id| {
                     diagnostics
@@ -110,7 +110,7 @@ impl LogDiagnosticsPlugin {
         time: Res<Time>,
         diagnostics: Res<Diagnostics>,
     ) {
-        if state.timer.tick(time.delta()).finished() {
+        if state.timer.tick(time.raw_delta()).finished() {
             if let Some(ref filter) = state.filter {
                 for diagnostic in filter.iter().flat_map(|id| {
                     diagnostics
diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index 1835f841c93a7d..a7fa93f7da8327 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -2,48 +2,92 @@ use bevy_ecs::{reflect::ReflectResource, system::Resource};
 use bevy_reflect::{FromReflect, Reflect};
 use bevy_utils::{Duration, Instant};
 
-/// Tracks elapsed time since the last update and since the App has started
+/// Tracks how much time has advanced (and also how much real time has elapsed) since
+/// the previous app update and since the app was started.
 #[derive(Resource, Reflect, FromReflect, Debug, Clone)]
 #[reflect(Resource)]
 pub struct Time {
-    delta: Duration,
+    startup: Instant,
+    first_update: Option<Instant>,
     last_update: Option<Instant>,
-    delta_seconds_f64: f64,
+    relative_speed: f64, // using `f64` instead of `f32` to minimize drift from rounding errors
+    paused: bool,
+    delta: Duration,
     delta_seconds: f32,
-    seconds_since_startup: f64,
-    time_since_startup: Duration,
-    startup: Instant,
+    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,
+    // wrapping
+    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() -> Time {
-        Time {
-            delta: Duration::from_secs(0),
-            last_update: None,
+    fn default() -> Self {
+        Self {
             startup: Instant::now(),
-            delta_seconds_f64: 0.0,
-            seconds_since_startup: 0.0,
-            time_since_startup: Duration::from_secs(0),
+            first_update: None,
+            last_update: None,
+            relative_speed: 1.0,
+            paused: false,
+            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), // 1 hour
+            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 {
+    /// Constructs a new `Time` instance with a specific startup `Instant`.
+    pub fn new(startup: Instant) -> Self {
+        Self {
+            startup,
+            ..Default::default()
+        }
+    }
+
     /// Updates the internal time measurements.
     ///
-    /// Calling this method on the [`Time`] resource as part of your app will most likely result in
-    /// inaccurate timekeeping, as the resource is ordinarily managed by the
-    /// [`TimePlugin`](crate::TimePlugin).
+    /// Calling this method as part of your app will most likely result in inaccurate timekeeping,
+    /// as the `Time` resource is ordinarily managed by the [`TimePlugin`](crate::TimePlugin).
     pub fn update(&mut self) {
-        self.update_with_instant(Instant::now());
+        let now = Instant::now();
+        self.update_with_instant(now);
     }
 
-    /// Update time with a specified [`Instant`]
+    /// Updates time with a specified [`Instant`].
     ///
-    /// This method is provided for use in tests. Calling this method on the [`Time`] resource as
-    /// part of your app will most likely result in inaccurate timekeeping, as the resource is
-    /// ordinarily managed by the [`TimePlugin`](crate::TimePlugin).
+    /// This method is provided for use in tests. Calling this method as part of your app will most
+    /// likely result in inaccurate timekeeping, as the `Time` resource is ordinarily managed by the
+    /// [`TimePlugin`](crate::TimePlugin).
     ///
     /// # Examples
     ///
@@ -92,123 +136,571 @@ impl Time {
     /// }
     /// ```
     pub fn update_with_instant(&mut self, instant: Instant) {
-        if let Some(last_update) = self.last_update {
-            self.delta = instant - last_update;
-            self.delta_seconds_f64 = self.delta.as_secs_f64();
+        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 {
+            // avoid rounding errors at normal speed
+            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.time_since_startup = instant - self.startup;
-        self.seconds_since_startup = self.time_since_startup.as_secs_f64();
+        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);
     }
 
-    /// The delta between the current tick and last tick as a [`Duration`]
+    /// Returns the [`Instant`] the app was started.
+    #[inline]
+    pub fn startup(&self) -> Instant {
+        self.startup
+    }
+
+    /// Returns the [`Instant`] when [`update`](#method.update) was first called, if it exists.
+    #[inline]
+    pub fn first_update(&self) -> Option<Instant> {
+        self.first_update
+    }
+
+    /// Returns the [`Instant`] when [`update`](#method.update) was last called, if it exists.
+    #[inline]
+    pub fn last_update(&self) -> Option<Instant> {
+        self.last_update
+    }
+
+    /// Returns how much time has advanced since the last [`update`](#method.update), as a [`Duration`].
     #[inline]
     pub fn delta(&self) -> Duration {
         self.delta
     }
 
-    /// The delta between the current and last tick as [`f32`] seconds
+    /// Returns how much time has advanced since the last [`update`](#method.update), as [`f32`] seconds.
     #[inline]
     pub fn delta_seconds(&self) -> f32 {
         self.delta_seconds
     }
 
-    /// The delta between the current and last tick as [`f64`] seconds
+    /// Returns how much time has advanced since the last [`update`](#method.update), as [`f64`] seconds.
     #[inline]
     pub fn delta_seconds_f64(&self) -> f64 {
         self.delta_seconds_f64
     }
 
-    /// The time from startup to the last update in seconds
+    /// Returns how much time has advanced since [`startup`](#method.startup), as [`Duration`].
     #[inline]
-    pub fn seconds_since_startup(&self) -> f64 {
-        self.seconds_since_startup
+    pub fn elapsed(&self) -> Duration {
+        self.elapsed
     }
 
-    /// The [`Instant`] the app was started
+    /// Returns how much time has advanced since [`startup`](#method.startup), as [`f32`] seconds.
+    ///
+    /// **Note:** This is a monotonically increasing value. It's precision will degrade over time.
+    /// If you need an `f32` but that precision loss is unacceptable,
+    /// use [`elapsed_seconds_wrapped`](#method.elapsed_seconds_wrapped).
     #[inline]
-    pub fn startup(&self) -> Instant {
-        self.startup
+    pub fn elapsed_seconds(&self) -> f32 {
+        self.elapsed_seconds
     }
 
-    /// The [`Instant`] when [`Time::update`] was last called, if it exists
+    /// Returns how much time has advanced since [`startup`](#method.startup), as [`f64`] seconds.
     #[inline]
-    pub fn last_update(&self) -> Option<Instant> {
-        self.last_update
+    pub fn elapsed_seconds_f64(&self) -> f64 {
+        self.elapsed_seconds_f64
+    }
+
+    /// Returns how much time has advanced since [`startup`](#method.startup) modulo
+    /// the [`wrap_period`](#method.wrap_period), as [`Duration`].
+    #[inline]
+    pub fn elapsed_wrapped(&self) -> Duration {
+        self.elapsed_wrapped
+    }
+
+    /// Returns how much time has advanced since [`startup`](#method.startup) modulo
+    /// the [`wrap_period`](#method.wrap_period), as [`f32`] seconds.
+    ///
+    /// This method is intended for applications (e.g. shaders) that require an [`f32`] value but
+    /// suffer from the gradual precision loss of [`elapsed_seconds`](#method.elapsed_seconds).
+    #[inline]
+    pub fn elapsed_seconds_wrapped(&self) -> f32 {
+        self.elapsed_seconds_wrapped
+    }
+
+    /// Returns how much time has advanced since [`startup`](#method.startup) modulo
+    /// the [`wrap_period`](#method.wrap_period), as [`f64`] seconds.
+    #[inline]
+    pub fn elapsed_seconds_wrapped_f64(&self) -> f64 {
+        self.elapsed_seconds_wrapped_f64
+    }
+
+    /// Returns the exact clock time elapsed since the last [`update`](#method.update), as a [`Duration`].
+    #[inline]
+    pub fn raw_delta(&self) -> Duration {
+        self.raw_delta
+    }
+
+    /// Returns the exact clock time elapsed since the last [`update`](#method.update), as [`f32`] seconds.
+    #[inline]
+    pub fn raw_delta_seconds(&self) -> f32 {
+        self.raw_delta_seconds
+    }
+
+    /// Returns the exact clock time elapsed since the last [`update`](#method.update), as [`f64`] seconds.
+    #[inline]
+    pub fn raw_delta_seconds_f64(&self) -> f64 {
+        self.raw_delta_seconds_f64
     }
 
-    /// The [`Duration`] from startup to the last update
+    /// Returns the exact clock time elapsed since [`startup`](#method.startup), as [`Duration`].
     #[inline]
-    pub fn time_since_startup(&self) -> Duration {
-        self.time_since_startup
+    pub fn raw_elapsed(&self) -> Duration {
+        self.raw_elapsed
+    }
+
+    /// Returns the exact clock time elapsed since [`startup`](#method.startup), as [`f32`] seconds.
+    #[inline]
+    pub fn raw_elapsed_seconds(&self) -> f32 {
+        self.raw_elapsed_seconds
+    }
+
+    /// Returns the exact clock time elapsed since [`startup`](#method.startup), as [`f64`] seconds.
+    #[inline]
+    pub fn raw_elapsed_seconds_f64(&self) -> f64 {
+        self.raw_elapsed_seconds_f64
+    }
+
+    /// Returns the exact clock time elapsed since [`startup`](#method.startup) modulo
+    /// the [`wrap_period`](#method.wrap_period), as [`Duration`].
+    #[inline]
+    pub fn raw_elapsed_wrapped(&self) -> Duration {
+        self.raw_elapsed_wrapped
+    }
+
+    /// Returns the exact clock time elapsed since [`startup`](#method.startup) modulo
+    /// the [`wrap_period`](#method.wrap_period), as [`f32`] seconds.
+    #[inline]
+    pub fn raw_elapsed_seconds_wrapped(&self) -> f32 {
+        self.raw_elapsed_seconds_wrapped
+    }
+
+    /// Returns the exact clock time elapsed since [`startup`](#method.startup) modulo
+    /// the [`wrap_period`](#method.wrap_period), as [`f64`] seconds.
+    #[inline]
+    pub fn raw_elapsed_seconds_wrapped_f64(&self) -> f64 {
+        self.raw_elapsed_seconds_wrapped_f64
+    }
+
+    /// Returns the modulus used to calculate [`elapsed_wrapped`](#method.elapsed_wrapped) and
+    /// [`raw_elapsed_wrapped`](#method.raw_elapsed_wrapped).
+    ///
+    /// **Note:** The default modulus is one hour.
+    #[inline]
+    pub fn wrap_period(&self) -> Duration {
+        self.wrap_period
+    }
+
+    /// Sets the modulus used to calculate [`elapsed_wrapped`](#method.elapsed_wrapped) and
+    /// [`raw_elapsed_wrapped`](#method.raw_elapsed_wrapped).
+    ///
+    /// # Panics
+    ///
+    /// Panics if `wrap_period` is zero.
+    #[inline]
+    pub fn set_wrap_period(&mut self, wrap_period: Duration) {
+        assert!(wrap_period != Duration::ZERO, "division by zero");
+        self.wrap_period = wrap_period;
+    }
+
+    /// Returns the rate that time advances relative to real time, as [`f32`].
+    /// You might recognize this as "time scaling" or "time dilation" in other engines.
+    ///
+    /// **Note:** This function will return zero when time is paused.
+    #[inline]
+    pub fn relative_speed(&self) -> f32 {
+        self.relative_speed_f64() as f32
+    }
+
+    /// Returns the rate that time advances relative to real time, as [`f64`].
+    /// You might recognize this as "time scaling" or "time dilation" in other engines.
+    ///
+    /// **Note:** This function will return zero when time is paused.
+    #[inline]
+    pub fn relative_speed_f64(&self) -> f64 {
+        if self.paused {
+            0.0
+        } else {
+            self.relative_speed
+        }
+    }
+
+    /// Sets the rate that time advances relative to real time, given as an [`f32`].
+    ///
+    /// For example, if set to `2.0`, time will advance twice as fast as your system clock.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `ratio` is negative or not finite.
+    #[inline]
+    pub fn set_relative_speed(&mut self, ratio: f32) {
+        self.set_relative_speed_f64(ratio as f64);
+    }
+
+    /// Sets the rate that time advances relative to real time, given as an [`f64`].
+    ///
+    /// For example, if set to `2.0`, time will advance twice as fast as your system clock.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `ratio` is negative or not finite.
+    #[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;
+    }
+
+    /// Stops time, preventing it from advancing until resumed. Does not affect raw measurements.
+    #[inline]
+    pub fn pause(&mut self) {
+        self.paused = true;
+    }
+
+    /// Resumes time if paused.
+    #[inline]
+    pub fn unpause(&mut self) {
+        self.paused = false;
+    }
+
+    /// Returns `true` if time has been paused.
+    #[inline]
+    pub fn paused(&self) -> bool {
+        self.paused
     }
 }
 
+fn duration_div_rem(dividend: Duration, divisor: Duration) -> (Duration, Duration) {
+    // `Duration` does not have a built-in modulo operation
+    let n = (dividend.as_nanos() / divisor.as_nanos()) as u32;
+    let quotient = n * divisor;
+    let remainder = dividend - quotient;
+    (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]
     fn update_test() {
         let start_instant = Instant::now();
+        let mut time = Time::new(start_instant);
 
-        // Create a `Time` for testing
-        let mut time = Time {
-            startup: start_instant,
-            ..Default::default()
-        };
-
-        // Ensure `time` was constructed correctly
-        assert_eq!(time.delta(), Duration::from_secs(0));
-        assert_eq!(time.last_update(), None);
+        // Ensure `time` was constructed correctly.
         assert_eq!(time.startup(), start_instant);
-        assert_eq!(time.delta_seconds_f64(), 0.0);
-        assert_eq!(time.seconds_since_startup(), 0.0);
-        assert_eq!(time.time_since_startup(), Duration::from_secs(0));
+        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);
 
-        // Update `time` and check results
+        // Update `time` and check results.
+        // The first update to `time` normally happens before other systems have run,
+        // 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.last_update(), Some(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.seconds_since_startup(),
-            (first_update_instant - start_instant).as_secs_f64()
+            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.time_since_startup(),
-            (first_update_instant - start_instant)
+            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(),
         );
-        assert_eq!(time.delta_seconds, 0.0);
 
-        // Update `time` again and check results
+        // 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.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]
+    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);
+
+        // 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.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(),
+        );
+
+        // Make app time advance at 2x the rate of your system clock.
+        time.set_relative_speed(2.0);
+
+        // Update `time` again 1 second later.
+        let elapsed = Duration::from_secs(1);
+        let third_update_instant = second_update_instant + elapsed;
+        time.update_with_instant(third_update_instant);
+
+        // Since app is advancing 2x your system clock, expect time
+        // to have advanced by twice the amount of real time elapsed.
+        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]
+    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.paused());
+        assert_eq!(time.relative_speed(), 1.0);
+
+        time.pause();
+
+        assert!(time.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.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);
-        // At this point its safe to use time.delta as a valid value
-        // because it's been previously verified to be correct
-        assert_eq!(time.delta_seconds_f64(), time.delta().as_secs_f64());
+        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.seconds_since_startup(),
-            (second_update_instant - start_instant).as_secs_f64()
+            time.raw_delta(),
+            third_update_instant - second_update_instant,
         );
         assert_eq!(
-            time.time_since_startup(),
-            (second_update_instant - start_instant)
+            time.elapsed(),
+            (third_update_instant - second_update_instant) + (first_update_instant - start_instant),
         );
-        assert_eq!(time.delta_seconds(), time.delta().as_secs_f32());
+        assert_eq!(time.raw_elapsed(), third_update_instant - start_instant);
     }
 }
diff --git a/examples/2d/text2d.rs b/examples/2d/text2d.rs
index b2edf872d26a80..f68b411692125a 100644
--- a/examples/2d/text2d.rs
+++ b/examples/2d/text2d.rs
@@ -91,8 +91,8 @@ fn animate_translation(
     mut query: Query<&mut Transform, (With<Text>, With<AnimateTranslation>)>,
 ) {
     for mut transform in &mut query {
-        transform.translation.x = 100.0 * time.seconds_since_startup().sin() as f32 - 400.0;
-        transform.translation.y = 100.0 * time.seconds_since_startup().cos() as f32;
+        transform.translation.x = 100.0 * time.elapsed_seconds().sin() - 400.0;
+        transform.translation.y = 100.0 * time.elapsed_seconds().cos();
     }
 }
 
@@ -101,7 +101,7 @@ fn animate_rotation(
     mut query: Query<&mut Transform, (With<Text>, With<AnimateRotation>)>,
 ) {
     for mut transform in &mut query {
-        transform.rotation = Quat::from_rotation_z(time.seconds_since_startup().cos() as f32);
+        transform.rotation = Quat::from_rotation_z(time.elapsed_seconds().cos());
     }
 }
 
@@ -113,6 +113,6 @@ fn animate_scale(
     // rendered quad, resulting in a pixellated look.
     for mut transform in &mut query {
         transform.translation = Vec3::new(400.0, 0.0, 0.0);
-        transform.scale = Vec3::splat((time.seconds_since_startup().sin() as f32 + 1.1) * 2.0);
+        transform.scale = Vec3::splat((time.elapsed_seconds().sin() + 1.1) * 2.0);
     }
 }
diff --git a/examples/3d/load_gltf.rs b/examples/3d/load_gltf.rs
index 1248801a5c3363..6bfe3a9e62ac2c 100644
--- a/examples/3d/load_gltf.rs
+++ b/examples/3d/load_gltf.rs
@@ -50,7 +50,7 @@ fn animate_light_direction(
         transform.rotation = Quat::from_euler(
             EulerRot::ZYX,
             0.0,
-            time.seconds_since_startup() as f32 * std::f32::consts::TAU / 10.0,
+            time.elapsed_seconds() * std::f32::consts::TAU / 10.0,
             -std::f32::consts::FRAC_PI_4,
         );
     }
diff --git a/examples/3d/skybox.rs b/examples/3d/skybox.rs
index ae6aa9a0f86c66..0dbe017834300b 100644
--- a/examples/3d/skybox.rs
+++ b/examples/3d/skybox.rs
@@ -98,16 +98,16 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     });
 }
 
-const CUBEMAP_SWAP_DELAY: f64 = 3.0;
+const CUBEMAP_SWAP_DELAY: f32 = 3.0;
 
 fn cycle_cubemap_asset(
     time: Res<Time>,
-    mut next_swap: Local<f64>,
+    mut next_swap: Local<f32>,
     mut cubemap: ResMut<Cubemap>,
     asset_server: Res<AssetServer>,
     render_device: Res<RenderDevice>,
 ) {
-    let now = time.seconds_since_startup();
+    let now = time.elapsed_seconds();
     if *next_swap == 0.0 {
         *next_swap = now + CUBEMAP_SWAP_DELAY;
         return;
diff --git a/examples/3d/spotlight.rs b/examples/3d/spotlight.rs
index d241d3d236eb0f..25e29055fe74ea 100644
--- a/examples/3d/spotlight.rs
+++ b/examples/3d/spotlight.rs
@@ -123,13 +123,12 @@ fn light_sway(time: Res<Time>, mut query: Query<(&mut Transform, &mut SpotLight)
     for (mut transform, mut angles) in query.iter_mut() {
         transform.rotation = Quat::from_euler(
             EulerRot::XYZ,
-            -std::f32::consts::FRAC_PI_2
-                + (time.seconds_since_startup() * 0.67 * 3.0).sin() as f32 * 0.5,
-            (time.seconds_since_startup() * 3.0).sin() as f32 * 0.5,
+            -std::f32::consts::FRAC_PI_2 + (time.elapsed_seconds() * 0.67 * 3.0).sin() * 0.5,
+            (time.elapsed_seconds() * 3.0).sin() * 0.5,
             0.0,
         );
-        let angle = ((time.seconds_since_startup() * 1.2).sin() as f32 + 1.0)
-            * (std::f32::consts::FRAC_PI_4 - 0.1);
+        let angle =
+            ((time.elapsed_seconds() * 1.2).sin() + 1.0) * (std::f32::consts::FRAC_PI_4 - 0.1);
         angles.inner_angle = angle * 0.8;
         angles.outer_angle = angle;
     }
diff --git a/examples/3d/transparency_3d.rs b/examples/3d/transparency_3d.rs
index 40baaffbbd7872..a4d05ca0d9a1a2 100644
--- a/examples/3d/transparency_3d.rs
+++ b/examples/3d/transparency_3d.rs
@@ -88,7 +88,7 @@ fn setup(
 ///                when the alpha value goes back below the threshold.
 /// - `Blend`: Object fades in and out smoothly.
 pub fn fade_transparency(time: Res<Time>, mut materials: ResMut<Assets<StandardMaterial>>) {
-    let alpha = (time.time_since_startup().as_secs_f32().sin() / 2.0) + 0.5;
+    let alpha = (time.elapsed_seconds().sin() / 2.0) + 0.5;
     for (_, material) in materials.iter_mut() {
         material.base_color.set_a(alpha);
     }
diff --git a/examples/3d/update_gltf_scene.rs b/examples/3d/update_gltf_scene.rs
index 6237579568d854..d9faaae70fa0c7 100644
--- a/examples/3d/update_gltf_scene.rs
+++ b/examples/3d/update_gltf_scene.rs
@@ -53,9 +53,9 @@ fn move_scene_entities(
         iter_hierarchy(moved_scene_entity, &children, &mut |entity| {
             if let Ok(mut transform) = transforms.get_mut(entity) {
                 transform.translation = Vec3::new(
-                    offset * time.seconds_since_startup().sin() as f32 / 20.,
+                    offset * time.elapsed_seconds().sin() / 20.,
                     0.,
-                    time.seconds_since_startup().cos() as f32 / 20.,
+                    time.elapsed_seconds().cos() / 20.,
                 );
                 offset += 1.0;
             }
diff --git a/examples/animation/custom_skinned_mesh.rs b/examples/animation/custom_skinned_mesh.rs
index 94a657ffe5f907..42ab172d57920a 100644
--- a/examples/animation/custom_skinned_mesh.rs
+++ b/examples/animation/custom_skinned_mesh.rs
@@ -164,9 +164,7 @@ fn setup(
 /// Animate the joint marked with [`AnimatedJoint`] component.
 fn joint_animation(time: Res<Time>, mut query: Query<&mut Transform, With<AnimatedJoint>>) {
     for mut transform in &mut query {
-        transform.rotation = Quat::from_axis_angle(
-            Vec3::Z,
-            0.5 * PI * time.time_since_startup().as_secs_f32().sin(),
-        );
+        transform.rotation =
+            Quat::from_axis_angle(Vec3::Z, 0.5 * PI * time.elapsed_seconds().sin());
     }
 }
diff --git a/examples/animation/gltf_skinned_mesh.rs b/examples/animation/gltf_skinned_mesh.rs
index 4b9ee2ba136fb9..fc3449279a7370 100644
--- a/examples/animation/gltf_skinned_mesh.rs
+++ b/examples/animation/gltf_skinned_mesh.rs
@@ -66,9 +66,7 @@ fn joint_animation(
         // Get `Transform` in the second joint.
         let mut second_joint_transform = transform_query.get_mut(second_joint_entity).unwrap();
 
-        second_joint_transform.rotation = Quat::from_axis_angle(
-            Vec3::Z,
-            0.5 * PI * time.time_since_startup().as_secs_f32().sin(),
-        );
+        second_joint_transform.rotation =
+            Quat::from_axis_angle(Vec3::Z, 0.5 * PI * time.elapsed_seconds().sin());
     }
 }
diff --git a/examples/audio/audio_control.rs b/examples/audio/audio_control.rs
index 2c5da2c919936c..d5344e68ead8bb 100644
--- a/examples/audio/audio_control.rs
+++ b/examples/audio/audio_control.rs
@@ -32,7 +32,7 @@ fn update_speed(
     time: Res<Time>,
 ) {
     if let Some(sink) = audio_sinks.get(&music_controller.0) {
-        sink.set_speed(((time.seconds_since_startup() / 5.0).sin() as f32 + 1.0).max(0.1));
+        sink.set_speed(((time.elapsed_seconds() / 5.0).sin() + 1.0).max(0.1));
     }
 }
 
diff --git a/examples/ecs/component_change_detection.rs b/examples/ecs/component_change_detection.rs
index 2d31302a3dd477..f704652fc9d6ea 100644
--- a/examples/ecs/component_change_detection.rs
+++ b/examples/ecs/component_change_detection.rs
@@ -14,7 +14,7 @@ fn main() {
 }
 
 #[derive(Component, Debug)]
-struct MyComponent(f64);
+struct MyComponent(f32);
 
 fn setup(mut commands: Commands) {
     commands.spawn().insert(MyComponent(0.));
@@ -25,7 +25,7 @@ fn change_component(time: Res<Time>, mut query: Query<(Entity, &mut MyComponent)
     for (entity, mut component) in &mut query {
         if rand::thread_rng().gen_bool(0.1) {
             info!("changing component {:?}", entity);
-            component.0 = time.seconds_since_startup();
+            component.0 = time.elapsed_seconds();
         }
     }
 }
diff --git a/examples/ecs/fixed_timestep.rs b/examples/ecs/fixed_timestep.rs
index 0f58e7d531ee89..77755dc42a58e5 100644
--- a/examples/ecs/fixed_timestep.rs
+++ b/examples/ecs/fixed_timestep.rs
@@ -31,22 +31,30 @@ fn main() {
         .run();
 }
 
-fn frame_update(mut last_time: Local<f64>, time: Res<Time>) {
-    info!("update: {}", time.seconds_since_startup() - *last_time);
-    *last_time = time.seconds_since_startup();
+fn frame_update(mut last_time: Local<f32>, time: Res<Time>) {
+    info!(
+        "time since last frame_update: {}",
+        time.raw_elapsed_seconds() - *last_time
+    );
+    *last_time = time.raw_elapsed_seconds();
 }
 
-fn fixed_update(mut last_time: Local<f64>, time: Res<Time>, fixed_timesteps: Res<FixedTimesteps>) {
+fn fixed_update(mut last_time: Local<f32>, time: Res<Time>, fixed_timesteps: Res<FixedTimesteps>) {
     info!(
-        "fixed_update: {}",
-        time.seconds_since_startup() - *last_time,
+        "time since last fixed_update: {}\n",
+        time.raw_elapsed_seconds() - *last_time
     );
 
-    let fixed_timestep = fixed_timesteps.get(LABEL).unwrap();
+    let state = fixed_timesteps.get(LABEL).unwrap();
+
+    info!("fixed timestep: {}\n", 0.5);
     info!(
-        "  overstep_percentage: {}",
-        fixed_timestep.overstep_percentage()
+        "time accrued toward next fixed_update: {}\n",
+        state.accumulator()
     );
-
-    *last_time = time.seconds_since_startup();
+    info!(
+        "time accrued toward next fixed_update (% of timestep): {}",
+        state.overstep_percentage()
+    );
+    *last_time = time.raw_elapsed_seconds();
 }
diff --git a/examples/ecs/hierarchy.rs b/examples/ecs/hierarchy.rs
index 22b6c8e6a207ce..52dd63037f9663 100644
--- a/examples/ecs/hierarchy.rs
+++ b/examples/ecs/hierarchy.rs
@@ -86,12 +86,12 @@ fn rotate(
 
         // To demonstrate removing children, we'll start to remove the children after a couple of
         // seconds
-        if time.seconds_since_startup() >= 2.0 && children.len() == 3 {
+        if time.elapsed_seconds() >= 2.0 && children.len() == 3 {
             let child = children.last().copied().unwrap();
             commands.entity(child).despawn_recursive();
         }
 
-        if time.seconds_since_startup() >= 4.0 {
+        if time.elapsed_seconds() >= 4.0 {
             // This will remove the entity from its parent's list of children, as well as despawn
             // any children the entity has.
             commands.entity(parent).despawn_recursive();
diff --git a/examples/ecs/removal_detection.rs b/examples/ecs/removal_detection.rs
index 0f3c6c7c100f7a..3a29339ea1364b 100644
--- a/examples/ecs/removal_detection.rs
+++ b/examples/ecs/removal_detection.rs
@@ -42,7 +42,7 @@ fn remove_component(
     query: Query<Entity, With<MyComponent>>,
 ) {
     // After two seconds have passed the `Component` is removed.
-    if time.seconds_since_startup() > 2.0 {
+    if time.elapsed_seconds() > 2.0 {
         if let Some(entity) = query.iter().next() {
             commands.entity(entity).remove::<MyComponent>();
         }
diff --git a/examples/ecs/state.rs b/examples/ecs/state.rs
index db34e5358d2499..b2d739b5e301e3 100644
--- a/examples/ecs/state.rs
+++ b/examples/ecs/state.rs
@@ -134,6 +134,6 @@ fn change_color(time: Res<Time>, mut query: Query<&mut Sprite>) {
     for mut sprite in &mut query {
         sprite
             .color
-            .set_b((time.seconds_since_startup() * 0.5).sin() as f32 + 2.0);
+            .set_b((time.elapsed_seconds() * 0.5).sin() as f32 + 2.0);
     }
 }
diff --git a/examples/ecs/system_sets.rs b/examples/ecs/system_sets.rs
index 035103ca2789e5..c47007bee37267 100644
--- a/examples/ecs/system_sets.rs
+++ b/examples/ecs/system_sets.rs
@@ -88,7 +88,7 @@ fn main() {
 /// Example of a run criteria.
 /// Here we only want to run for a second, then stop.
 fn run_for_a_second(time: Res<Time>, mut done: ResMut<Done>) -> ShouldRun {
-    let elapsed = time.seconds_since_startup();
+    let elapsed = time.elapsed_seconds();
     if elapsed < 1.0 {
         info!(
             "We should run again. Elapsed/remaining: {:.2}s/{:.2}s",
diff --git a/examples/games/alien_cake_addict.rs b/examples/games/alien_cake_addict.rs
index b634b5786dd656..1f7bf57692157f 100644
--- a/examples/games/alien_cake_addict.rs
+++ b/examples/games/alien_cake_addict.rs
@@ -347,9 +347,8 @@ fn rotate_bonus(game: Res<Game>, time: Res<Time>, mut transforms: Query<&mut Tra
     if let Some(entity) = game.bonus.entity {
         if let Ok(mut cake_transform) = transforms.get_mut(entity) {
             cake_transform.rotate_y(time.delta_seconds());
-            cake_transform.scale = Vec3::splat(
-                1.0 + (game.score as f32 / 10.0 * time.seconds_since_startup().sin() as f32).abs(),
-            );
+            cake_transform.scale =
+                Vec3::splat(1.0 + (game.score as f32 / 10.0 * time.elapsed_seconds().sin()).abs());
         }
     }
 }
diff --git a/examples/scene/scene.rs b/examples/scene/scene.rs
index ae13f620680852..81d1e8c2276543 100644
--- a/examples/scene/scene.rs
+++ b/examples/scene/scene.rs
@@ -43,7 +43,7 @@ impl FromWorld for ComponentB {
     fn from_world(world: &mut World) -> Self {
         let time = world.resource::<Time>();
         ComponentB {
-            _time_since_startup: time.time_since_startup(),
+            _time_since_startup: time.elapsed(),
             value: "Default Value".to_string(),
         }
     }
diff --git a/examples/shader/animate_shader.rs b/examples/shader/animate_shader.rs
index ce8c4ed06830c1..fee92b72b27990 100644
--- a/examples/shader/animate_shader.rs
+++ b/examples/shader/animate_shader.rs
@@ -136,7 +136,7 @@ fn queue_custom(
 
 #[derive(Resource, Default)]
 struct ExtractedTime {
-    seconds_since_startup: f32,
+    elapsed_seconds: f32,
 }
 
 impl ExtractResource for ExtractedTime {
@@ -144,7 +144,7 @@ impl ExtractResource for ExtractedTime {
 
     fn extract_resource(time: &Self::Source) -> Self {
         ExtractedTime {
-            seconds_since_startup: time.seconds_since_startup() as f32,
+            elapsed_seconds: time.elapsed_seconds(),
         }
     }
 }
@@ -164,7 +164,7 @@ fn prepare_time(
     render_queue.write_buffer(
         &time_meta.buffer,
         0,
-        bevy::core::cast_slice(&[time.seconds_since_startup]),
+        bevy::core::cast_slice(&[time.elapsed_seconds]),
     );
 }
 
diff --git a/examples/tools/scene_viewer.rs b/examples/tools/scene_viewer.rs
index db696547bbdfff..57ac44aa23849f 100644
--- a/examples/tools/scene_viewer.rs
+++ b/examples/tools/scene_viewer.rs
@@ -330,7 +330,7 @@ fn update_lights(
             transform.rotation = Quat::from_euler(
                 EulerRot::ZYX,
                 0.0,
-                time.seconds_since_startup() as f32 * TAU / 30.0,
+                time.elapsed_seconds() * TAU / 30.0,
                 -TAU / 8.,
             );
         }
diff --git a/examples/ui/text.rs b/examples/ui/text.rs
index 36b56750ef292c..bb306cef7db3ee 100644
--- a/examples/ui/text.rs
+++ b/examples/ui/text.rs
@@ -85,7 +85,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 
 fn text_color_system(time: Res<Time>, mut query: Query<&mut Text, With<ColorText>>) {
     for mut text in &mut query {
-        let seconds = time.seconds_since_startup() as f32;
+        let seconds = time.elapsed_seconds();
 
         // Update the color of the first and only section.
         text.sections[0].style.color = Color::Rgba {
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index 5bda8151b72da4..0b32df61a476e6 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -24,7 +24,7 @@ fn change_title(time: Res<Time>, mut windows: ResMut<Windows>) {
     let window = windows.primary_mut();
     window.set_title(format!(
         "Seconds since startup: {}",
-        time.seconds_since_startup().round()
+        time.elapsed_seconds().round()
     ));
 }