From fa5b606deb6d16515c9cfa2e7f5bb99d835656de Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 28 Jul 2022 17:28:20 -0700
Subject: [PATCH 1/3] main changes

---
 crates/bevy_time/src/fixed_timestep.rs | 583 +++++++++++++++----------
 crates/bevy_time/src/lib.rs            |  84 +++-
 crates/bevy_time/src/time.rs           | 376 +++++++++++++---
 3 files changed, 721 insertions(+), 322 deletions(-)

diff --git a/crates/bevy_time/src/fixed_timestep.rs b/crates/bevy_time/src/fixed_timestep.rs
index 78fdfca797c50..d5564d1df8fa2 100644
--- a/crates/bevy_time/src/fixed_timestep.rs
+++ b/crates/bevy_time/src/fixed_timestep.rs
@@ -1,302 +1,401 @@
 use crate::Time;
-use bevy_ecs::{
-    archetype::ArchetypeComponentId,
-    component::ComponentId,
-    query::Access,
-    schedule::ShouldRun,
-    system::{IntoSystem, Res, ResMut, System},
-    world::World,
-};
-use bevy_utils::HashMap;
-use std::borrow::Cow;
-
-/// The internal state of each [`FixedTimestep`].
-#[derive(Debug)]
-pub struct FixedTimestepState {
-    step: f64,
-    accumulator: f64,
+
+use bevy_ecs::world::{FromWorld, World};
+use bevy_utils::{Duration, Instant};
+
+/// A [`Time`] variant that is synchronized to the main `Time` resource, but only advances
+/// in increments of a constant [`delta`](FixedTime::delta).
+#[derive(Debug, Clone)]
+pub struct FixedTime {
+    startup: Instant,
+    first_update: Option<Instant>,
+    last_update: Option<Instant>,
+    delta: Duration,
+    delta_seconds: f32,
+    delta_seconds_f64: f64,
+    elapsed_since_startup: Duration,
+    seconds_since_startup: f32,
+    seconds_since_startup_f64: f64,
 }
 
-impl FixedTimestepState {
-    /// The amount of time each step takes.
-    pub fn step(&self) -> f64 {
-        self.step
+impl FromWorld for FixedTime {
+    fn from_world(world: &mut World) -> Self {
+        let time = world.resource::<Time>();
+        Self {
+            startup: time.startup(),
+            first_update: None,
+            last_update: None,
+            delta: Self::DEFAULT_STEP_SIZE,
+            delta_seconds: Self::DEFAULT_STEP_SIZE.as_secs_f32(),
+            delta_seconds_f64: Self::DEFAULT_STEP_SIZE.as_secs_f64(),
+            elapsed_since_startup: Duration::ZERO,
+            seconds_since_startup: 0.0,
+            seconds_since_startup_f64: 0.0,
+        }
     }
+}
+
+impl FixedTime {
+    /// The default step size.
+    // 60Hz is a popular tick rate, but it can't be expressed as an exact float.
+    // The nearby power of two, 64Hz, is more stable for numerical integration.
+    pub const DEFAULT_STEP_SIZE: Duration = Duration::from_micros(15625); // 64Hz
 
-    /// The number of steps made in a second.
-    pub fn steps_per_second(&self) -> f64 {
-        1.0 / self.step
+    /// Constructs a new `FixedTime` instance with a specific step size [`Duration`] and startup [`Instant`].
+    pub fn new(step_size: Duration, startup: Instant) -> Self {
+        Self {
+            startup,
+            first_update: None,
+            last_update: None,
+            delta: step_size,
+            delta_seconds: step_size.as_secs_f32(),
+            delta_seconds_f64: step_size.as_secs_f64(),
+            elapsed_since_startup: Duration::ZERO,
+            seconds_since_startup: 0.0,
+            seconds_since_startup_f64: 0.0,
+        }
     }
 
-    /// The amount of time (in seconds) left over from the last step.
-    pub fn accumulator(&self) -> f64 {
-        self.accumulator
+    /// Updates internal time measurements.
+    pub fn update(&mut self) {
+        let now = Instant::now();
+        self.update_with_instant(now);
     }
 
-    /// The percentage of "step" stored inside the accumulator. Calculated as accumulator / step.
-    pub fn overstep_percentage(&self) -> f64 {
-        self.accumulator / self.step
+    /// Updates time with a specified [`Instant`].
+    pub fn update_with_instant(&mut self, instant: Instant) {
+        if self.last_update.is_none() {
+            self.first_update = Some(instant);
+        }
+        self.last_update = Some(instant);
+        self.elapsed_since_startup += self.delta;
+        self.seconds_since_startup = self.elapsed_since_startup.as_secs_f32();
+        self.seconds_since_startup_f64 = self.elapsed_since_startup.as_secs_f64();
     }
-}
 
-/// A global resource that tracks the individual [`FixedTimestepState`]s
-/// for every labeled [`FixedTimestep`].
-#[derive(Default)]
-pub struct FixedTimesteps {
-    fixed_timesteps: HashMap<String, FixedTimestepState>,
-}
+    /// Returns the [`Instant`] the app was started.
+    #[inline]
+    pub fn startup(&self) -> Instant {
+        self.startup
+    }
 
-impl FixedTimesteps {
-    /// Gets the [`FixedTimestepState`] for a given label.
-    pub fn get(&self, name: &str) -> Option<&FixedTimestepState> {
-        self.fixed_timesteps.get(name)
+    /// Returns the [`Instant`] when [`update`](Self::update) was first called, if it exists.
+    #[inline]
+    pub fn first_update(&self) -> Option<Instant> {
+        self.first_update
     }
-}
 
-/// A system run criteria that enables systems or stages to run at a fixed timestep between executions.
-///
-/// This does not guarantee that the time elapsed between executions is exactly the provided
-/// fixed timestep, but will guarantee that the execution will run multiple times per game tick
-/// until the number of repetitions is as expected.
-///
-/// For example, a system with a fixed timestep run criteria of 120 times per second will run
-/// two times during a ~16.667ms frame, once during a ~8.333ms frame, and once every two frames
-/// with ~4.167ms frames. However, the same criteria may not result in exactly 8.333ms passing
-/// between each execution.
-///
-/// When using this run criteria, it is advised not to rely on [`Time::delta`] or any of it's
-/// variants for game simulation, but rather use the constant time delta used to initialize the
-/// [`FixedTimestep`] instead.
-///
-/// For more fine tuned information about the execution status of a given fixed timestep,
-/// use the [`FixedTimesteps`] resource.
-pub struct FixedTimestep {
-    state: LocalFixedTimestepState,
-    internal_system: Box<dyn System<In = (), Out = ShouldRun>>,
-}
+    /// Returns the [`Instant`] when [`update`](Self::update) was last called, if it exists.
+    #[inline]
+    pub fn last_update(&self) -> Option<Instant> {
+        self.last_update
+    }
 
-impl Default for FixedTimestep {
-    fn default() -> Self {
-        Self {
-            state: LocalFixedTimestepState::default(),
-            internal_system: Box::new(IntoSystem::into_system(Self::prepare_system(
-                Default::default(),
-            ))),
-        }
+    /// Returns how much time advances with each [`update`](Self::update), as a [`Duration`].
+    #[inline]
+    pub fn delta(&self) -> Duration {
+        self.delta
     }
-}
 
-impl FixedTimestep {
-    /// Creates a [`FixedTimestep`] that ticks once every `step` seconds.
-    pub fn step(step: f64) -> Self {
-        Self {
-            state: LocalFixedTimestepState {
-                step,
-                ..Default::default()
-            },
-            ..Default::default()
-        }
+    /// Returns how much time advances with each [`update`](Self::update), as [`f32`] seconds.
+    #[inline]
+    pub fn delta_seconds(&self) -> f32 {
+        self.delta_seconds
     }
 
-    /// Creates a [`FixedTimestep`] that ticks once every `rate` times per second.
-    pub fn steps_per_second(rate: f64) -> Self {
-        Self {
-            state: LocalFixedTimestepState {
-                step: 1.0 / rate,
-                ..Default::default()
-            },
-            ..Default::default()
-        }
+    /// Returns how much time advances with each [`update`](Self::update), as [`f64`] seconds.
+    #[inline]
+    pub fn delta_seconds_f64(&self) -> f64 {
+        self.delta_seconds_f64
     }
 
-    /// Sets the label for the timestep. Setting a label allows a timestep
-    /// to be observed by the global [`FixedTimesteps`] resource.
-    #[must_use]
-    pub fn with_label(mut self, label: &str) -> Self {
-        self.state.label = Some(label.to_string());
-        self
+    /// Sets [`delta`](Self::delta) to the given step size ([`Duration`]).
+    ///
+    /// **Note:** Outside of startup, users should strongly prefer using [`Time::set_relative_speed`].
+    /// Changing the step size itself will likely result in unstable numerical behavior.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `step_size` is a zero-length duration.
+    pub fn set_delta(&mut self, step_size: Duration) {
+        assert!(!step_size.is_zero(), "division by zero");
+        self.delta = step_size;
+        self.delta_seconds = self.delta.as_secs_f32();
+        self.delta_seconds_f64 = self.delta.as_secs_f64();
     }
 
-    fn prepare_system(
-        mut state: LocalFixedTimestepState,
-    ) -> impl FnMut(Res<Time>, ResMut<FixedTimesteps>) -> ShouldRun {
-        move |time, mut fixed_timesteps| {
-            let should_run = state.update(&time);
-            if let Some(ref label) = state.label {
-                let res_state = fixed_timesteps.fixed_timesteps.get_mut(label).unwrap();
-                res_state.step = state.step;
-                res_state.accumulator = state.accumulator;
-            }
-
-            should_run
-        }
+    /// Sets [`delta`](Self::delta) to the given step size ([`f32`] seconds).
+    ///
+    /// **Note:** This should only be set *once* (i.e. at startup).
+    /// Afterwards, only [`Time::set_relative_speed`] should be used to adjust simulation speed.
+    /// Changing [`delta`](Self::delta) directly will likely result in unstable numerical behavior.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `step_size` is less than or equal to zero, not finite, or overflows a `Duration`.
+    pub fn set_delta_seconds(&mut self, step_size: f32) {
+        self.set_delta(Duration::from_secs_f32(step_size));
     }
-}
 
-#[derive(Clone)]
-struct LocalFixedTimestepState {
-    label: Option<String>, // TODO: consider making this a TypedLabel
-    step: f64,
-    accumulator: f64,
-    looping: bool,
-}
+    /// Sets [`delta`](Self::delta) to the given step size ([`f64`] seconds).
+    ///
+    /// **Note:** This should only be set *once* (i.e. at startup).
+    /// Afterwards, only [`Time::set_relative_speed`] should be used to adjust simulation speed.
+    /// Changing [`delta`](Self::delta) directly will likely result in unstable numerical behavior.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `step_size` is less than or equal to zero, not finite, or overflows a `Duration`.
+    pub fn set_delta_seconds_f64(&mut self, step_size: f64) {
+        self.set_delta(Duration::from_secs_f64(step_size));
+    }
 
-impl Default for LocalFixedTimestepState {
-    fn default() -> Self {
-        Self {
-            step: 1.0 / 60.0,
-            accumulator: 0.0,
-            label: None,
-            looping: false,
-        }
+    /// Returns the nominal update rate (reciprocal of [`delta`](Self::delta)) as [`f32`].
+    #[inline]
+    pub fn steps_per_second(&self) -> f32 {
+        1.0 / self.delta_seconds
     }
-}
 
-impl LocalFixedTimestepState {
-    fn update(&mut self, time: &Time) -> ShouldRun {
-        if !self.looping {
-            self.accumulator += time.delta_seconds_f64();
-        }
+    /// Returns the nominal update rate (reciprocal of [`delta`](Self::delta)) as [`f64`].
+    #[inline]
+    pub fn steps_per_second_f64(&self) -> f64 {
+        1.0 / self.delta_seconds_f64
+    }
 
-        if self.accumulator >= self.step {
-            self.accumulator -= self.step;
-            self.looping = true;
-            ShouldRun::YesAndCheckAgain
-        } else {
-            self.looping = false;
-            ShouldRun::No
-        }
+    /// Sets [`delta`](Self::delta) to the reciprocal of `rate`, given as [`f32`].
+    ///
+    /// **Note:** This should only be set *once* (i.e. at startup).
+    /// Afterwards, only [`Time::set_relative_speed`] should be used to adjust simulation speed.
+    /// Changing [`delta`](Self::delta) directly will likely result in unstable numerical behavior.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `rate` is less than or equal to zero or not finite.
+    pub fn set_steps_per_second(&mut self, rate: f32) {
+        assert!(rate.is_finite(), "tried to go infinitely fast");
+        assert!(rate.is_sign_positive(), "tried to go back in time");
+        self.set_delta(Duration::from_secs_f32(1.0 / rate));
+    }
+
+    /// Sets [`delta`](Self::delta) to the reciprocal of `rate`, given as [`f64`].
+    ///
+    /// **Note:** This should only be set *once* (i.e. at startup).
+    /// Afterwards, only [`Time::set_relative_speed`] should be used to adjust simulation speed.
+    /// Changing [`delta`](Self::delta) directly will likely result in unstable numerical behavior.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `rate` is less than or equal to zero or not finite.
+    pub fn set_steps_per_second_f64(&mut self, rate: f64) {
+        assert!(rate.is_finite(), "tried to go infinitely fast");
+        assert!(rate.is_sign_positive(), "tried to go back in time");
+        self.set_delta(Duration::from_secs_f64(1.0 / rate));
+    }
+
+    /// Returns how much time has advanced since [`startup`](Self::startup), as [`Duration`].
+    #[inline]
+    pub fn elapsed_since_startup(&self) -> Duration {
+        self.elapsed_since_startup
+    }
+
+    /// Returns how much time has advanced since [`startup`](Self::startup), as [`f32`] seconds.
+    #[inline]
+    pub fn seconds_since_startup(&self) -> f32 {
+        self.seconds_since_startup
+    }
+
+    /// Returns how much time has advanced since [`startup`](Self::startup), as [`f64`] seconds.
+    #[inline]
+    pub fn seconds_since_startup_f64(&self) -> f64 {
+        self.seconds_since_startup_f64
     }
 }
 
-impl System for FixedTimestep {
-    type In = ();
-    type Out = ShouldRun;
+/// Accumulates time and converts it into steps: one step per `timestep`.
+///
+/// Used to advance [`FixedTime`].
+#[derive(Debug, Clone)]
+pub struct FixedTimestepState {
+    steps: u32,
+    overstep: Duration,
+}
 
-    fn name(&self) -> Cow<'static, str> {
-        Cow::Borrowed(std::any::type_name::<FixedTimestep>())
+impl Default for FixedTimestepState {
+    fn default() -> Self {
+        Self {
+            steps: 0,
+            overstep: Duration::ZERO,
+        }
     }
+}
 
-    fn archetype_component_access(&self) -> &Access<ArchetypeComponentId> {
-        self.internal_system.archetype_component_access()
+impl FixedTimestepState {
+    /// Constructs a new `FixedTimestepState`.
+    pub fn new(steps: u32, overstep: Duration) -> Self {
+        Self { steps, overstep }
     }
 
-    fn component_access(&self) -> &Access<ComponentId> {
-        self.internal_system.component_access()
+    /// Returns the number of steps accumulated.
+    #[inline]
+    pub fn steps(&self) -> u32 {
+        self.steps
     }
 
-    fn is_send(&self) -> bool {
-        self.internal_system.is_send()
+    /// Returns the amount of time accumulated toward new steps, as a [`Duration`].
+    #[inline]
+    pub fn overstep(&self) -> Duration {
+        self.overstep
     }
 
-    unsafe fn run_unsafe(&mut self, _input: (), world: &World) -> ShouldRun {
-        // SAFETY: this system inherits the internal system's component access and archetype component
-        // access, which means the caller has ensured running the internal system is safe
-        self.internal_system.run_unsafe((), world)
+    /// Returns the amount of time accumulated toward new steps, as an [`f32`] fraction of `timestep`.
+    ///
+    /// Useful for interpolating data between consecutive updates.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `timestep` is a zero-length duration.
+    pub fn overstep_percentage(&self, timestep: Duration) -> f32 {
+        assert!(!timestep.is_zero(), "division by zero");
+        self.overstep.as_secs_f32() / timestep.as_secs_f32()
     }
 
-    fn apply_buffers(&mut self, world: &mut World) {
-        self.internal_system.apply_buffers(world);
+    /// Returns the amount of time accumulated toward new steps, as an [`f64`] fraction of `timestep`.
+    ///
+    /// Useful for interpolating data between consecutive updates.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `timestep` is a zero-length duration.
+    pub fn overstep_percentage_f64(&self, timestep: Duration) -> f64 {
+        assert!(!timestep.is_zero(), "division by zero");
+        self.overstep.as_secs_f64() / timestep.as_secs_f64()
     }
 
-    fn initialize(&mut self, world: &mut World) {
-        self.internal_system = Box::new(IntoSystem::into_system(Self::prepare_system(
-            self.state.clone(),
-        )));
-        self.internal_system.initialize(world);
-        if let Some(ref label) = self.state.label {
-            let mut fixed_timesteps = world.resource_mut::<FixedTimesteps>();
-            fixed_timesteps.fixed_timesteps.insert(
-                label.clone(),
-                FixedTimestepState {
-                    accumulator: 0.0,
-                    step: self.state.step,
-                },
-            );
+    /// Adds `time` to the internal `overstep`, then converts the `overstep` accumulated into
+    /// as many `timestep`-sized steps as possible.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `timestep` is a zero-length duration.
+    pub fn add_time(&mut self, time: Duration, timestep: Duration) {
+        assert!(!timestep.is_zero(), "division by zero");
+        self.overstep += time;
+        while self.overstep >= timestep {
+            self.overstep -= timestep;
+            self.steps += 1;
         }
     }
 
-    fn update_archetype_component_access(&mut self, world: &World) {
-        self.internal_system
-            .update_archetype_component_access(world);
+    /// Consumes one step and returns the number remaining. Returns `None` if there was
+    /// no step to consume.
+    pub fn sub_step(&mut self) -> Option<u32> {
+        let remaining = self.steps.checked_sub(1);
+        self.steps = self.steps.saturating_sub(1);
+        remaining
     }
 
-    fn check_change_tick(&mut self, change_tick: u32) {
-        self.internal_system.check_change_tick(change_tick);
+    /// Clears accumulated time and steps.
+    pub fn reset(&mut self) {
+        self.steps = 0;
+        self.overstep = Duration::ZERO;
     }
 }
 
 #[cfg(test)]
-mod test {
-    use super::*;
-    use bevy_ecs::prelude::*;
-    use bevy_utils::Instant;
-    use std::ops::{Add, Mul};
-    use std::time::Duration;
-
-    type Count = usize;
-    const LABEL: &str = "test_step";
-
+mod tests {
+    use crate::{FixedTime, FixedTimestepState, Time};
+    use bevy_utils::{Duration, Instant};
     #[test]
-    fn test() {
-        let mut world = World::default();
-        let mut time = Time::default();
-        let instance = Instant::now();
-        time.update_with_instant(instance);
-        world.insert_resource(time);
-        world.insert_resource(FixedTimesteps::default());
-        world.insert_resource::<Count>(0);
-        let mut schedule = Schedule::default();
-
-        schedule.add_stage(
-            "update",
-            SystemStage::parallel()
-                .with_run_criteria(FixedTimestep::step(0.5).with_label(LABEL))
-                .with_system(fixed_update),
-        );
-
-        // if time does not progress, the step does not run
-        schedule.run(&mut world);
-        schedule.run(&mut world);
-        assert_eq!(0, *world.resource::<Count>());
-        assert_eq!(0., get_accumulator_deciseconds(&world));
-
-        // let's progress less than one step
-        advance_time(&mut world, instance, 0.4);
-        schedule.run(&mut world);
-        assert_eq!(0, *world.resource::<Count>());
-        assert_eq!(4., get_accumulator_deciseconds(&world));
-
-        // finish the first step with 0.1s above the step length
-        advance_time(&mut world, instance, 0.6);
-        schedule.run(&mut world);
-        assert_eq!(1, *world.resource::<Count>());
-        assert_eq!(1., get_accumulator_deciseconds(&world));
-
-        // runs multiple times if the delta is multiple step lengths
-        advance_time(&mut world, instance, 1.7);
-        schedule.run(&mut world);
-        assert_eq!(3, *world.resource::<Count>());
-        assert_eq!(2., get_accumulator_deciseconds(&world));
-    }
-
-    fn fixed_update(mut count: ResMut<Count>) {
-        *count += 1;
+    fn test_fixed_timestep_state_methods() {
+        let mut accumulator = FixedTimestepState::default();
+        assert_eq!(accumulator.steps(), 0);
+        assert_eq!(accumulator.overstep(), Duration::ZERO);
+
+        accumulator.add_time(Duration::from_secs(5), Duration::from_secs(1));
+        assert_eq!(accumulator.steps(), 5);
+        assert_eq!(accumulator.overstep(), Duration::ZERO);
+
+        let steps_remaining = accumulator.sub_step();
+        assert_eq!(steps_remaining, Some(4));
+        assert_eq!(accumulator.steps(), 4);
+        assert_eq!(accumulator.overstep(), Duration::ZERO);
+
+        accumulator.reset();
+        assert_eq!(accumulator.steps(), 0);
+        assert_eq!(accumulator.overstep(), Duration::ZERO);
+
+        let steps_remaining = accumulator.sub_step();
+        assert_eq!(steps_remaining, None);
+        assert_eq!(accumulator.steps(), 0);
+        assert_eq!(accumulator.overstep(), Duration::ZERO);
     }
 
-    fn advance_time(world: &mut World, instance: Instant, seconds: f32) {
-        world
-            .resource_mut::<Time>()
-            .update_with_instant(instance.add(Duration::from_secs_f32(seconds)));
-    }
+    #[test]
+    fn test_fixed_timestep() {
+        let start_instant = Instant::now();
+        let timestep = Duration::from_millis(20);
+
+        // Create a `Time`, `FixedTime`, and `FixedTimestepState` for testing.
+        let mut time = Time::new(start_instant);
+        let mut fixed_time = FixedTime::new(timestep, start_instant);
+        let mut accumulator = FixedTimestepState::default();
+
+        // Confirm that the timestep is what we set it to be.
+        assert_eq!(fixed_time.delta(), timestep);
+        assert_eq!(fixed_time.delta_seconds(), timestep.as_secs_f32());
+        assert_eq!(fixed_time.delta_seconds_f64(), timestep.as_secs_f64());
+
+        // Get the first update out of the way, so time.delta() has a nonzero value next time.
+        let first_update_instant = Instant::now();
+        time.update_with_instant(first_update_instant);
+
+        // Accumulate the time.
+        let start_delay = first_update_instant - start_instant;
+        accumulator.add_time(start_delay, fixed_time.delta());
+
+        // 10.5x the timestep elapses before the second update.
+        let ten = Duration::from_millis(200);
+        let half = Duration::from_millis(10);
+
+        let second_update_instant = first_update_instant + ten + half;
+        time.update_with_instant(second_update_instant);
+        assert_eq!(time.raw_delta(), ten + half);
+        assert_eq!(time.delta(), ten + half);
+
+        // Accumulate the time.
+        accumulator.add_time(time.delta(), fixed_time.delta());
+
+        // Confirm that 10.5 steps have accumulated.
+        assert_eq!(accumulator.steps(), 10);
+        assert_eq!(accumulator.overstep(), start_delay + half);
+
+        // Confirm that fixed time has not been updated yet.
+        assert_eq!(fixed_time.elapsed_since_startup(), Duration::ZERO);
+        assert_eq!(
+            fixed_time.seconds_since_startup(),
+            Duration::ZERO.as_secs_f32()
+        );
+        assert_eq!(
+            fixed_time.seconds_since_startup_f64(),
+            Duration::ZERO.as_secs_f64()
+        );
 
-    fn get_accumulator_deciseconds(world: &World) -> f64 {
-        world
-            .resource::<FixedTimesteps>()
-            .get(LABEL)
-            .unwrap()
-            .accumulator
-            .mul(10.)
-            .round()
+        // Consume accumulated steps and advanced the fixed time clock.
+        while accumulator.sub_step().is_some() {
+            fixed_time.update();
+        }
+        // Confirm that the timestep is still the same.
+        assert_eq!(fixed_time.delta(), timestep);
+        assert_eq!(fixed_time.delta_seconds(), timestep.as_secs_f32());
+        assert_eq!(fixed_time.delta_seconds_f64(), timestep.as_secs_f64());
+
+        // Confirm that the fixed time clock has advanced 10 steps worth of time.
+        assert_eq!(fixed_time.elapsed_since_startup(), ten);
+        assert_eq!(fixed_time.seconds_since_startup(), ten.as_secs_f32());
+        assert_eq!(fixed_time.seconds_since_startup_f64(), ten.as_secs_f64());
+
+        // Confirm that the fixed clock lags behind the normal clock by the sub-step amount.
+        let diff = time.elapsed_since_startup() - fixed_time.elapsed_since_startup();
+        assert_eq!(diff, start_delay + half);
     }
 }
diff --git a/crates/bevy_time/src/lib.rs b/crates/bevy_time/src/lib.rs
index 5982305159766..c3f863f9286b0 100644
--- a/crates/bevy_time/src/lib.rs
+++ b/crates/bevy_time/src/lib.rs
@@ -9,6 +9,7 @@ pub use stopwatch::*;
 pub use time::*;
 pub use timer::*;
 
+use bevy_ecs::schedule::ShouldRun;
 use bevy_ecs::system::{Local, Res, ResMut};
 use bevy_utils::{tracing::warn, Instant};
 use crossbeam_channel::{Receiver, Sender};
@@ -16,25 +17,29 @@ use crossbeam_channel::{Receiver, Sender};
 pub mod prelude {
     //! The Bevy Time Prelude.
     #[doc(hidden)]
-    pub use crate::{Time, Timer};
+    pub use crate::{FixedTime, FixedTimestep, FixedTimestepState, Time, Timer};
 }
 
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
 
-/// Adds time functionality to Apps.
+/// Adds timekeeping functionality.
 #[derive(Default)]
 pub struct TimePlugin;
 
 #[derive(Debug, PartialEq, Eq, Clone, Hash, SystemLabel)]
-/// Updates the elapsed time. Any system that interacts with [Time] component should run after
-/// this.
+
+/// Measures elapsed time since previous update, advances [`Time`], and accumulates elapsed time for
+/// to advance [`FixedTime`] later.
+///
+/// Systems that interact with the [`Time`] resource should be scheduled after this.
 pub struct TimeSystem;
 
 impl Plugin for TimePlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<Time>()
-            .init_resource::<FixedTimesteps>()
+            .init_resource::<FixedTime>()
+            .init_resource::<FixedTimestepState>()
             .register_type::<Timer>()
             // time system is added as an "exclusive system" to ensure it runs before other systems
             // in CoreStage::First
@@ -58,22 +63,81 @@ pub fn create_time_channels() -> (TimeSender, TimeReceiver) {
     (TimeSender(s), TimeReceiver(r))
 }
 
-/// The system used to update the [`Time`] used by app logic. If there is a render world the time is sent from
-/// there to this system through channels. Otherwise the time is updated in this system.
+/// Advances [`Time`] and accumulates the elapsed time to advance [`FixedTime`] later.
+///
+/// If the render world exists, the update [`Instant`] is received from a channel.
+/// Otherwise, the update `Instant` is measured inside this system.
 fn time_system(
     mut time: ResMut<Time>,
+    fixed_time: Option<Res<FixedTime>>,
+    accumulator: Option<ResMut<FixedTimestepState>>,
     time_recv: Option<Res<TimeReceiver>>,
     mut has_received_time: Local<bool>,
 ) {
+    let cond1 = time.first_update().is_none();
+
     if let Some(time_recv) = time_recv {
         // TODO: Figure out how to handle this when using pipelined rendering.
-        if let Ok(new_time) = time_recv.0.try_recv() {
-            time.update_with_instant(new_time);
+        if let Ok(instant) = time_recv.0.try_recv() {
+            time.update_with_instant(instant);
             *has_received_time = true;
         } else if *has_received_time {
-            warn!("time_system did not receive the time from the render world! Calculations depending on the time may be incorrect.");
+            warn!(
+                "`time_system` did not receive `Time` from the render world! \
+                Calculations depending on the time may be incorrect!"
+            );
         }
     } else {
         time.update();
     }
+
+    let cond2 = time.first_update().is_some();
+
+    if let (Some(fixed_time), Some(mut accumulator)) = (fixed_time, accumulator) {
+        // On first update, account for the exact startup delay so that `FixedTime` is synced.
+        let mut delta = if cond1 && cond2 {
+            time.first_update().unwrap() - time.startup()
+        } else {
+            time.raw_delta()
+        };
+        // Avoid rounding errors when the relative speed is 1.
+        if time.relative_speed_f64() != 1.0 {
+            delta = delta.mul_f64(time.relative_speed_f64());
+        }
+        // Accumulate the time advanced.
+        accumulator.add_time(delta, fixed_time.delta());
+    }
+}
+
+/// A run criteria that succeeds once for every [`FixedTime::delta`] seconds that [`Time`] advances.
+///
+/// That is different from the run criteria succeeding once every `FixedTime::delta` seconds.
+/// The exact CPU time between runs depends on the frame rate and [`Time::relative_speed`].
+///
+/// For example, a [`Stage`](bevy_ecs::schedule::Stage) set to run 100 times per second (10ms timestep)
+/// will run once for every 10ms that [`Time`] advances. But unless [`Time::delta`] happens to be a
+/// constant 10ms, the actual time between runs will vary, so systems subject to this run criteria
+/// should use `FixedTime` instead of `Time` to see consistent behavior.
+pub struct FixedTimestep;
+
+impl FixedTimestep {
+    /// Returns `ShouldRun::YesAndCheckAgain` while there are accumulated steps remaining, `ShouldRun::No` otherwise.
+    ///
+    /// Also returns `ShouldRun::No` if either [`FixedTime`] or [`FixedTimestepState`] does not exist.
+    pub fn step(
+        fixed_time: Option<ResMut<FixedTime>>,
+        accumulator: Option<ResMut<FixedTimestepState>>,
+    ) -> ShouldRun {
+        match (fixed_time, accumulator) {
+            (Some(mut fixed_time), Some(mut accumulator)) => {
+                if accumulator.sub_step().is_some() {
+                    fixed_time.update();
+                    ShouldRun::YesAndCheckAgain
+                } else {
+                    ShouldRun::No
+                }
+            }
+            _ => ShouldRun::No,
+        }
+    }
 }
diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index cfe34316a745a..39b6ab02c8c2c 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -2,48 +2,71 @@ use bevy_ecs::reflect::ReflectResource;
 use bevy_reflect::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 the raw CPU time elapsed) since its previous update
+/// and since the app was started.
 #[derive(Reflect, 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
+    delta: Duration,
     delta_seconds: f32,
-    seconds_since_startup: f64,
-    time_since_startup: Duration,
-    startup: Instant,
+    delta_seconds_f64: f64,
+    elapsed_since_startup: Duration,
+    seconds_since_startup: f32,
+    seconds_since_startup_f64: f64,
+    raw_delta: Duration,
+    raw_delta_seconds: f32,
+    raw_delta_seconds_f64: f64,
+    raw_elapsed_since_startup: Duration,
+    raw_seconds_since_startup: f32,
+    raw_seconds_since_startup_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(),
+            first_update: None,
+            last_update: None,
+            relative_speed: 1.0,
+            delta: Duration::ZERO,
+            delta_seconds: 0.0,
             delta_seconds_f64: 0.0,
+            elapsed_since_startup: Duration::ZERO,
             seconds_since_startup: 0.0,
-            time_since_startup: Duration::from_secs(0),
-            delta_seconds: 0.0,
+            seconds_since_startup_f64: 0.0,
+            raw_delta: Duration::ZERO,
+            raw_delta_seconds: 0.0,
+            raw_delta_seconds_f64: 0.0,
+            raw_elapsed_since_startup: Duration::ZERO,
+            raw_seconds_since_startup: 0.0,
+            raw_seconds_since_startup_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).
     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 in a normal app will result
+    /// in inaccurate timekeeping, as the resource is ordinarily managed by the [`TimePlugin`](crate::TimePlugin).
     ///
     /// # Examples
     ///
@@ -91,57 +114,165 @@ 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 = if let Some(last_update) = self.last_update {
+            instant - last_update
+        } else {
+            instant - self.startup
+        };
+
+        // Avoid rounding errors when the relative speed is 1.
+        let delta = 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.time_since_startup = instant - self.startup;
-        self.seconds_since_startup = self.time_since_startup.as_secs_f64();
+        self.elapsed_since_startup += delta;
+        self.seconds_since_startup = self.elapsed_since_startup.as_secs_f32();
+        self.seconds_since_startup_f64 = self.elapsed_since_startup.as_secs_f64();
+        self.raw_elapsed_since_startup += raw_delta;
+        self.raw_seconds_since_startup = self.raw_elapsed_since_startup.as_secs_f32();
+        self.raw_seconds_since_startup_f64 = self.raw_elapsed_since_startup.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`](Self::update) was first called, if it exists.
+    #[inline]
+    pub fn first_update(&self) -> Option<Instant> {
+        self.first_update
+    }
+
+    /// Returns the [`Instant`] when [`update`](Self::update) was last called, if it exists.
+    #[inline]
+    pub fn last_update(&self) -> Option<Instant> {
+        self.last_update
+    }
+
+    /// Returns the rate that time advances relative to raw CPU time, as [`f32`].
+    ///
+    /// `1.0` by default.
+    #[inline]
+    pub fn relative_speed(&self) -> f32 {
+        self.relative_speed as f32
+    }
+
+    /// Returns the rate that time advances relative to raw CPU time, as [`f64`].
+    ///
+    /// `1.0` by default.
+    #[inline]
+    pub fn relative_speed_f64(&self) -> f64 {
+        self.relative_speed
+    }
+
+    /// Sets the rate that time advances relative to raw CPU time, given as [`f32`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if `ratio` is negative or not finite.
+    pub fn set_relative_speed(&mut self, ratio: f32) {
+        assert!(ratio.is_finite(), "tried to go infinitely fast");
+        assert!(ratio.is_sign_positive(), "tried to go back in time");
+        self.relative_speed = ratio as f64;
+    }
+
+    /// Sets the rate that time advances relative to raw CPU time, given as [`f64`].
+    ///
+    /// # Panics
+    ///
+    /// Panics if `ratio` is negative or not finite.
+    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;
+    }
+
+    /// Returns how much time has advanced since the last [`update`](Self::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`](Self::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`](Self::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 the exact CPU time elapsed since the last [`update`](Self::update), as a [`Duration`].
+    #[inline]
+    pub fn raw_delta(&self) -> Duration {
+        self.raw_delta
+    }
+
+    /// Returns the exact CPU time elapsed since the last [`update`](Self::update), as [`f32`] seconds.
+    #[inline]
+    pub fn raw_delta_seconds(&self) -> f32 {
+        self.raw_delta_seconds
+    }
+
+    /// Returns the exact CPU time elapsed since the last [`update`](Self::update), as [`f64`] seconds.
     #[inline]
-    pub fn seconds_since_startup(&self) -> f64 {
+    pub fn raw_delta_seconds_f64(&self) -> f64 {
+        self.raw_delta_seconds_f64
+    }
+
+    /// Returns how much time has advanced since [`startup`](Self::startup), as [`Duration`].
+    #[inline]
+    pub fn elapsed_since_startup(&self) -> Duration {
+        self.elapsed_since_startup
+    }
+
+    /// Returns how much time has advanced since [`startup`](Self::startup), as [`f32`] seconds.
+    #[inline]
+    pub fn seconds_since_startup(&self) -> f32 {
         self.seconds_since_startup
     }
 
-    /// The [`Instant`] the app was started
+    /// Returns how much time has advanced since [`startup`](Self::startup), as [`f64`] seconds.
     #[inline]
-    pub fn startup(&self) -> Instant {
-        self.startup
+    pub fn seconds_since_startup_f64(&self) -> f64 {
+        self.seconds_since_startup_f64
     }
 
-    /// The [`Instant`] when [`Time::update`] was last called, if it exists
+    /// Returns the exact CPU time elapsed since [`startup`](Self::startup), as [`Duration`].
     #[inline]
-    pub fn last_update(&self) -> Option<Instant> {
-        self.last_update
+    pub fn raw_elapsed_since_startup(&self) -> Duration {
+        self.raw_elapsed_since_startup
+    }
+
+    /// Returns the exact CPU time elapsed since [`startup`](Self::startup), as [`f32`] seconds.
+    #[inline]
+    pub fn raw_seconds_since_startup(&self) -> f32 {
+        self.raw_seconds_since_startup
     }
 
-    /// The [`Duration`] from startup to the last update
+    /// Returns the exact CPU time elapsed since [`startup`](Self::startup), as [`f64`] seconds.
     #[inline]
-    pub fn time_since_startup(&self) -> Duration {
-        self.time_since_startup
+    pub fn raw_seconds_since_startup_f64(&self) -> f64 {
+        self.raw_seconds_since_startup_f64
     }
 }
 
@@ -153,61 +284,166 @@ mod tests {
 
     #[test]
     fn update_test() {
+        // Create a `Time` for testing.
         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.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_since_startup(), Duration::ZERO);
         assert_eq!(time.seconds_since_startup(), 0.0);
-        assert_eq!(time.time_since_startup(), Duration::from_secs(0));
-        assert_eq!(time.delta_seconds(), 0.0);
+        assert_eq!(time.seconds_since_startup_f64(), 0.0);
+        assert_eq!(time.raw_elapsed_since_startup(), Duration::ZERO);
+        assert_eq!(time.raw_seconds_since_startup(), 0.0);
+        assert_eq!(time.raw_seconds_since_startup_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_since_startup(),
+            first_update_instant - start_instant,
+        );
         assert_eq!(
             time.seconds_since_startup(),
-            (first_update_instant - start_instant).as_secs_f64()
+            (first_update_instant - start_instant).as_secs_f32(),
+        );
+        assert_eq!(
+            time.seconds_since_startup_f64(),
+            (first_update_instant - start_instant).as_secs_f64(),
+        );
+        assert_eq!(
+            time.raw_elapsed_since_startup(),
+            first_update_instant - start_instant,
+        );
+        assert_eq!(
+            time.raw_seconds_since_startup(),
+            (first_update_instant - start_instant).as_secs_f32(),
         );
         assert_eq!(
-            time.time_since_startup(),
-            (first_update_instant - start_instant)
+            time.raw_seconds_since_startup_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.delta(), second_update_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(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_since_startup(),
+            second_update_instant - start_instant,
+        );
+        assert_eq!(
+            time.seconds_since_startup(),
+            (second_update_instant - start_instant).as_secs_f32(),
+        );
+        assert_eq!(
+            time.seconds_since_startup_f64(),
+            (second_update_instant - start_instant).as_secs_f64(),
+        );
+        assert_eq!(
+            time.raw_elapsed_since_startup(),
+            second_update_instant - start_instant,
+        );
+        assert_eq!(
+            time.raw_seconds_since_startup(),
+            (second_update_instant - start_instant).as_secs_f32(),
+        );
+        assert_eq!(
+            time.raw_seconds_since_startup_f64(),
+            (second_update_instant - start_instant).as_secs_f64(),
+        );
+
+        // 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 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 the system clock, expect elapsed time
+        // to have advanced by twice the amount of raw CPU time.
         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.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_since_startup(),
+            second_update_instant - start_instant + elapsed.mul_f32(2.0),
+        );
         assert_eq!(
             time.seconds_since_startup(),
-            (second_update_instant - start_instant).as_secs_f64()
+            (second_update_instant - start_instant + elapsed.mul_f32(2.0)).as_secs_f32(),
+        );
+        assert_eq!(
+            time.seconds_since_startup_f64(),
+            (second_update_instant - start_instant + elapsed.mul_f32(2.0)).as_secs_f64(),
+        );
+        assert_eq!(
+            time.raw_elapsed_since_startup(),
+            second_update_instant - start_instant + elapsed,
+        );
+        assert_eq!(
+            time.raw_seconds_since_startup(),
+            (second_update_instant - start_instant + elapsed).as_secs_f32(),
         );
         assert_eq!(
-            time.time_since_startup(),
-            (second_update_instant - start_instant)
+            time.raw_seconds_since_startup_f64(),
+            (second_update_instant - start_instant + elapsed).as_secs_f64(),
         );
-        assert_eq!(time.delta_seconds(), time.delta().as_secs_f32());
     }
 }

From 0d832886b882273f8d848361a609e19785e5c561 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 28 Jul 2022 18:26:38 -0700
Subject: [PATCH 2/3] fix examples

---
 examples/2d/rotation.rs                    | 17 +++++---
 examples/3d/transparency_3d.rs             |  2 +-
 examples/animation/custom_skinned_mesh.rs  |  6 +--
 examples/animation/gltf_skinned_mesh.rs    |  6 +--
 examples/ecs/component_change_detection.rs |  2 +-
 examples/ecs/fixed_timestep.rs             | 51 ++++++++++++----------
 examples/ecs/iter_combinations.rs          | 19 +++++---
 examples/games/alien_cake_addict.rs        | 16 ++++++-
 examples/games/breakout.rs                 | 19 ++++----
 examples/scene/scene.rs                    |  2 +-
 examples/stress_tests/bevymark.rs          |  6 ++-
 11 files changed, 85 insertions(+), 61 deletions(-)

diff --git a/examples/2d/rotation.rs b/examples/2d/rotation.rs
index 7c6a5e91d5aaf..ae09bdad5755b 100644
--- a/examples/2d/rotation.rs
+++ b/examples/2d/rotation.rs
@@ -1,17 +1,19 @@
 //! Demonstrates rotating entities in 2D using quaternions.
 
-use bevy::{math::Vec3Swizzles, prelude::*, time::FixedTimestep};
+use bevy::{math::Vec3Swizzles, prelude::*};
 
-const TIME_STEP: f32 = 1.0 / 60.0;
 const BOUNDS: Vec2 = Vec2::new(1200.0, 640.0);
 
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
+        .add_startup_system(|mut fixed_time: ResMut<FixedTime>| {
+            fixed_time.set_steps_per_second(60.0);
+        })
         .add_startup_system(setup)
         .add_system_set(
             SystemSet::new()
-                .with_run_criteria(FixedTimestep::step(TIME_STEP as f64))
+                .with_run_criteria(FixedTimestep::step)
                 .with_system(player_movement_system)
                 .with_system(snap_to_player_system)
                 .with_system(rotate_to_player_system),
@@ -110,6 +112,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 
 /// Demonstrates applying rotation and movement based on keyboard input.
 fn player_movement_system(
+    fixed_time: Res<FixedTime>,
     keyboard_input: Res<Input<KeyCode>>,
     mut query: Query<(&Player, &mut Transform)>,
 ) {
@@ -131,12 +134,12 @@ fn player_movement_system(
     }
 
     // update the ship rotation around the Z axis (perpendicular to the 2D plane of the screen)
-    transform.rotate_z(rotation_factor * ship.rotation_speed * TIME_STEP);
+    transform.rotate_z(rotation_factor * ship.rotation_speed * fixed_time.delta_seconds());
 
     // get the ship's forward vector by applying the current rotation to the ships initial facing vector
     let movement_direction = transform.rotation * Vec3::Y;
     // get the distance the ship will move based on direction, the ship's movement speed and delta time
-    let movement_distance = movement_factor * ship.movement_speed * TIME_STEP;
+    let movement_distance = movement_factor * ship.movement_speed * fixed_time.delta_seconds();
     // create the change in translation using the new movement direction and distance
     let translation_delta = movement_direction * movement_distance;
     // update the ship translation with our new translation delta
@@ -191,6 +194,7 @@ fn snap_to_player_system(
 /// floating point precision loss, so it pays to clamp your dot product value before calling
 /// `acos`.
 fn rotate_to_player_system(
+    fixed_time: Res<FixedTime>,
     mut query: Query<(&RotateToPlayer, &mut Transform), Without<Player>>,
     player_query: Query<&Transform, With<Player>>,
 ) {
@@ -235,7 +239,8 @@ fn rotate_to_player_system(
         let max_angle = forward_dot_player.clamp(-1.0, 1.0).acos(); // clamp acos for safety
 
         // calculate angle of rotation with limit
-        let rotation_angle = rotation_sign * (config.rotation_speed * TIME_STEP).min(max_angle);
+        let rotation_angle =
+            rotation_sign * (config.rotation_speed * fixed_time.delta_seconds()).min(max_angle);
 
         // rotate the enemy to face the player
         enemy_transform.rotate_z(rotation_angle);
diff --git a/examples/3d/transparency_3d.rs b/examples/3d/transparency_3d.rs
index 40baaffbbd787..833bef82e1cc9 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.seconds_since_startup().sin() / 2.0) + 0.5;
     for (_, material) in materials.iter_mut() {
         material.base_color.set_a(alpha);
     }
diff --git a/examples/animation/custom_skinned_mesh.rs b/examples/animation/custom_skinned_mesh.rs
index 94a657ffe5f90..751f644d788c5 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.seconds_since_startup().sin());
     }
 }
diff --git a/examples/animation/gltf_skinned_mesh.rs b/examples/animation/gltf_skinned_mesh.rs
index 4b9ee2ba136fb..0ec926470aca9 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.seconds_since_startup().sin());
     }
 }
diff --git a/examples/ecs/component_change_detection.rs b/examples/ecs/component_change_detection.rs
index 2d31302a3dd47..8c72d3ddd2b46 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.));
diff --git a/examples/ecs/fixed_timestep.rs b/examples/ecs/fixed_timestep.rs
index 0f58e7d531ee8..e91ffea001dae 100644
--- a/examples/ecs/fixed_timestep.rs
+++ b/examples/ecs/fixed_timestep.rs
@@ -1,11 +1,6 @@
 //! Shows how to create systems that run every fixed timestep, rather than every tick.
 
-use bevy::{
-    prelude::*,
-    time::{FixedTimestep, FixedTimesteps},
-};
-
-const LABEL: &str = "my_fixed_timestep";
+use bevy::prelude::*;
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
 struct FixedUpdateStage;
@@ -13,40 +8,48 @@ struct FixedUpdateStage;
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
-        // this system will run once every update (it should match your screen's refresh rate)
+        .add_startup_system(|mut fixed_time: ResMut<FixedTime>| {
+            fixed_time.set_steps_per_second(10.0);
+        })
+        // Add a system that runs once per update (which should match your screen's refresh rate).
         .add_system(frame_update)
-        // add a new stage that runs twice a second
+        // Add a new stage that runs ten times per second.
         .add_stage_after(
             CoreStage::Update,
             FixedUpdateStage,
             SystemStage::parallel()
-                .with_run_criteria(
-                    FixedTimestep::step(0.5)
-                        // labels are optional. they provide a way to access the current
-                        // FixedTimestep state from within a system
-                        .with_label(LABEL),
-                )
+                .with_run_criteria(FixedTimestep::step)
                 .with_system(fixed_update),
         )
         .run();
 }
 
-fn frame_update(mut last_time: Local<f64>, time: Res<Time>) {
-    info!("update: {}", time.seconds_since_startup() - *last_time);
+fn frame_update(mut last_time: Local<f32>, time: Res<Time>) {
+    info!(
+        "time since last frame_update: {}",
+        time.seconds_since_startup() - *last_time
+    );
     *last_time = time.seconds_since_startup();
 }
 
-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_time: Res<FixedTime>,
+    accumulator: Res<FixedTimestepState>,
+) {
     info!(
-        "fixed_update: {}",
-        time.seconds_since_startup() - *last_time,
+        "time since last fixed_update: {}\n",
+        time.seconds_since_startup() - *last_time
     );
-
-    let fixed_timestep = fixed_timesteps.get(LABEL).unwrap();
+    info!("fixed timestep: {}\n", fixed_time.delta_seconds());
     info!(
-        "  overstep_percentage: {}",
-        fixed_timestep.overstep_percentage()
+        "time accrued toward next fixed_update: {}\n",
+        accumulator.overstep().as_secs_f32()
+    );
+    info!(
+        "time accrued toward next fixed_update (% of timestep): {}",
+        accumulator.overstep_percentage(fixed_time.delta())
     );
-
     *last_time = time.seconds_since_startup();
 }
diff --git a/examples/ecs/iter_combinations.rs b/examples/ecs/iter_combinations.rs
index b66f9148b33a1..b27caa63c2e7e 100644
--- a/examples/ecs/iter_combinations.rs
+++ b/examples/ecs/iter_combinations.rs
@@ -1,13 +1,11 @@
 //! Shows how to iterate over combinations of query results.
 
-use bevy::{pbr::AmbientLight, prelude::*, render::camera::Camera, time::FixedTimestep};
+use bevy::{pbr::AmbientLight, prelude::*, render::camera::Camera};
 use rand::{thread_rng, Rng};
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
 struct FixedUpdateStage;
 
-const DELTA_TIME: f64 = 0.01;
-
 fn main() {
     App::new()
         .add_plugins(DefaultPlugins)
@@ -15,12 +13,15 @@ fn main() {
             brightness: 0.03,
             ..default()
         })
+        .add_startup_system(|mut fixed_time: ResMut<FixedTime>| {
+            fixed_time.set_steps_per_second(10.0);
+        })
         .add_startup_system(generate_bodies)
         .add_stage_after(
             CoreStage::Update,
             FixedUpdateStage,
             SystemStage::parallel()
-                .with_run_criteria(FixedTimestep::step(DELTA_TIME))
+                .with_run_criteria(FixedTimestep::step)
                 .with_system(interact_bodies)
                 .with_system(integrate),
         )
@@ -54,6 +55,7 @@ fn generate_bodies(
     mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
+    fixed_time: Res<FixedTime>,
 ) {
     let mesh = meshes.add(Mesh::from(shape::Icosphere {
         radius: 1.0,
@@ -103,7 +105,7 @@ fn generate_bodies(
                         rng.gen_range(vel_range.clone()),
                         rng.gen_range(vel_range.clone()),
                         rng.gen_range(vel_range.clone()),
-                    ) * DELTA_TIME as f32,
+                    ) * fixed_time.delta_seconds(),
             ),
         });
     }
@@ -162,8 +164,11 @@ fn interact_bodies(mut query: Query<(&Mass, &GlobalTransform, &mut Acceleration)
     }
 }
 
-fn integrate(mut query: Query<(&mut Acceleration, &mut Transform, &mut LastPos)>) {
-    let dt_sq = (DELTA_TIME * DELTA_TIME) as f32;
+fn integrate(
+    fixed_time: Res<FixedTime>,
+    mut query: Query<(&mut Acceleration, &mut Transform, &mut LastPos)>,
+) {
+    let dt_sq = fixed_time.delta_seconds() * fixed_time.delta_seconds();
     for (mut acceleration, mut transform, mut last_pos) in &mut query {
         // verlet integration
         // x(t+dt) = 2x(t) - x(t-dt) + a(t)dt^2 + O(dt^4)
diff --git a/examples/games/alien_cake_addict.rs b/examples/games/alien_cake_addict.rs
index f0a6b4e0c05cf..1d847d16acb17 100644
--- a/examples/games/alien_cake_addict.rs
+++ b/examples/games/alien_cake_addict.rs
@@ -1,6 +1,7 @@
 //! Eat the cakes. Eat them all. An example 3D game.
 
-use bevy::{ecs::schedule::SystemSet, prelude::*, time::FixedTimestep};
+use bevy::ecs::schedule::ShouldRun;
+use bevy::prelude::*;
 use rand::Rng;
 
 #[derive(Clone, Eq, PartialEq, Debug, Hash)]
@@ -9,9 +10,12 @@ enum GameState {
     GameOver,
 }
 
+struct SpawnTimer(Timer);
+
 fn main() {
     App::new()
         .init_resource::<Game>()
+        .insert_resource(SpawnTimer(Timer::from_seconds(5.0, false)))
         .add_plugins(DefaultPlugins)
         .add_state(GameState::Playing)
         .add_startup_system(setup_cameras)
@@ -29,7 +33,15 @@ fn main() {
         .add_system_set(SystemSet::on_exit(GameState::GameOver).with_system(teardown))
         .add_system_set(
             SystemSet::new()
-                .with_run_criteria(FixedTimestep::step(5.0))
+                .with_run_criteria(|time: Res<Time>, mut timer: ResMut<SpawnTimer>| {
+                    timer.0.tick(time.delta());
+                    if timer.0.finished() {
+                        timer.0.reset();
+                        ShouldRun::Yes
+                    } else {
+                        ShouldRun::No
+                    }
+                })
                 .with_system(spawn_bonus),
         )
         .add_system(bevy::window::close_on_esc)
diff --git a/examples/games/breakout.rs b/examples/games/breakout.rs
index 2260ed91a58c8..f1a87a66071da 100644
--- a/examples/games/breakout.rs
+++ b/examples/games/breakout.rs
@@ -3,12 +3,8 @@
 use bevy::{
     prelude::*,
     sprite::collide_aabb::{collide, Collision},
-    time::FixedTimestep,
 };
 
-// Defines the amount of time that should elapse between each physics step.
-const TIME_STEP: f32 = 1.0 / 60.0;
-
 // These constants are defined in `Transform` units.
 // Using the default 2D camera they correspond 1:1 with screen pixels.
 const PADDLE_SIZE: Vec3 = Vec3::new(120.0, 20.0, 0.0);
@@ -55,11 +51,14 @@ fn main() {
         .add_plugins(DefaultPlugins)
         .insert_resource(Scoreboard { score: 0 })
         .insert_resource(ClearColor(BACKGROUND_COLOR))
+        .add_startup_system(|mut fixed_time: ResMut<FixedTime>| {
+            fixed_time.set_steps_per_second(60.0);
+        })
         .add_startup_system(setup)
         .add_event::<CollisionEvent>()
         .add_system_set(
             SystemSet::new()
-                .with_run_criteria(FixedTimestep::step(TIME_STEP as f64))
+                .with_run_criteria(FixedTimestep::step)
                 .with_system(check_for_collisions)
                 .with_system(move_paddle.before(check_for_collisions))
                 .with_system(apply_velocity.before(check_for_collisions))
@@ -310,6 +309,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 }
 
 fn move_paddle(
+    fixed_time: Res<FixedTime>,
     keyboard_input: Res<Input<KeyCode>>,
     mut query: Query<&mut Transform, With<Paddle>>,
 ) {
@@ -325,7 +325,8 @@ fn move_paddle(
     }
 
     // Calculate the new horizontal paddle position based on player input
-    let new_paddle_position = paddle_transform.translation.x + direction * PADDLE_SPEED * TIME_STEP;
+    let new_paddle_position =
+        paddle_transform.translation.x + direction * PADDLE_SPEED * fixed_time.delta_seconds();
 
     // Update the paddle position,
     // making sure it doesn't cause the paddle to leave the arena
@@ -335,10 +336,10 @@ fn move_paddle(
     paddle_transform.translation.x = new_paddle_position.clamp(left_bound, right_bound);
 }
 
-fn apply_velocity(mut query: Query<(&mut Transform, &Velocity)>) {
+fn apply_velocity(fixed_time: Res<FixedTime>, mut query: Query<(&mut Transform, &Velocity)>) {
     for (mut transform, velocity) in &mut query {
-        transform.translation.x += velocity.x * TIME_STEP;
-        transform.translation.y += velocity.y * TIME_STEP;
+        transform.translation.x += velocity.x * fixed_time.delta_seconds();
+        transform.translation.y += velocity.y * fixed_time.delta_seconds();
     }
 }
 
diff --git a/examples/scene/scene.rs b/examples/scene/scene.rs
index 66689e2a8b5f2..d45a5440515ff 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_since_startup(),
             value: "Default Value".to_string(),
         }
     }
diff --git a/examples/stress_tests/bevymark.rs b/examples/stress_tests/bevymark.rs
index 249e506ce0f15..43f6302c6ca0c 100644
--- a/examples/stress_tests/bevymark.rs
+++ b/examples/stress_tests/bevymark.rs
@@ -5,7 +5,6 @@
 use bevy::{
     diagnostic::{Diagnostics, FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
     prelude::*,
-    time::FixedTimestep,
     window::PresentMode,
 };
 use rand::{thread_rng, Rng};
@@ -43,6 +42,9 @@ fn main() {
             count: 0,
             color: Color::WHITE,
         })
+        .add_startup_system(|mut fixed_time: ResMut<FixedTime>| {
+            fixed_time.set_steps_per_second(5.0);
+        })
         .add_startup_system(setup)
         .add_system(mouse_handler)
         .add_system(movement_system)
@@ -50,7 +52,7 @@ fn main() {
         .add_system(counter_system)
         .add_system_set(
             SystemSet::new()
-                .with_run_criteria(FixedTimestep::step(0.2))
+                .with_run_criteria(FixedTimestep::step)
                 .with_system(scheduled_spawner),
         )
         .run();

From df5f198e99c4583d23e70ebf123fe9e7498f5372 Mon Sep 17 00:00:00 2001
From: Joy <51241057+maniwani@users.noreply.github.com>
Date: Thu, 28 Jul 2022 20:05:18 -0700
Subject: [PATCH 3/3] diagnostics plugins need unscaled time

---
 crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs | 6 +++---
 crates/bevy_diagnostic/src/log_diagnostics_plugin.rs        | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
index bc07eaaad6887..9265e14ba9864 100644
--- a/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
@@ -42,13 +42,13 @@ impl FrameTimeDiagnosticsPlugin {
             state.frame_count as f64
         });
 
-        if time.delta_seconds_f64() == 0.0 {
+        if time.raw_delta_seconds_f64() == 0.0 {
             return;
         }
 
-        diagnostics.add_measurement(Self::FRAME_TIME, || time.delta_seconds_f64());
+        diagnostics.add_measurement(Self::FRAME_TIME, || time.raw_delta_seconds_f64());
 
-        diagnostics.add_measurement(Self::FPS, || 1.0 / time.delta_seconds_f64());
+        diagnostics.add_measurement(Self::FPS, || 1.0 / time.raw_delta_seconds_f64());
     }
 }
 
diff --git a/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
index 2dc7c053baf1c..b3694f77ad5b1 100644
--- a/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
@@ -84,7 +84,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
@@ -109,7 +109,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